arch/alpha/boot/bootp.c

111

load(unsigned long dst, unsigned long src, unsigned long count)

arch/alpha/boot/bootp.c

113

memcpy((void *)dst, (void *)src, count);

arch/alpha/include/asm/checksum.h

46

__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len);

arch/alpha/include/asm/checksum.h

48

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/alpha/include/asm/io.h

622

extern void insb (unsigned long port, void *dst, unsigned long count);

arch/alpha/include/asm/io.h

623

extern void insw (unsigned long port, void *dst, unsigned long count);

arch/alpha/include/asm/io.h

624

extern void insl (unsigned long port, void *dst, unsigned long count);

arch/alpha/kernel/io.c

277

void ioread8_rep(const void __iomem *port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

279

while ((unsigned long)dst & 0x3) {

arch/alpha/kernel/io.c

283

*(unsigned char *)dst = ioread8(port);

arch/alpha/kernel/io.c

284

dst += 1;

arch/alpha/kernel/io.c

294

*(unsigned int *)dst = w;

arch/alpha/kernel/io.c

295

dst += 4;

arch/alpha/kernel/io.c

300

*(unsigned char *)dst = ioread8(port);

arch/alpha/kernel/io.c

301

dst += 1;

arch/alpha/kernel/io.c

305

void insb(unsigned long port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

307

ioread8_rep(ioport_map(port, 1), dst, count);

arch/alpha/kernel/io.c

320

void ioread16_rep(const void __iomem *port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

322

if (unlikely((unsigned long)dst & 0x3)) {

arch/alpha/kernel/io.c

325

BUG_ON((unsigned long)dst & 0x1);

arch/alpha/kernel/io.c

327

*(unsigned short *)dst = ioread16(port);

arch/alpha/kernel/io.c

328

dst += 2;

arch/alpha/kernel/io.c

336

*(unsigned int *)dst = w;

arch/alpha/kernel/io.c

337

dst += 4;

arch/alpha/kernel/io.c

341

*(unsigned short*)dst = ioread16(port);

arch/alpha/kernel/io.c

345

void insw(unsigned long port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

347

ioread16_rep(ioport_map(port, 2), dst, count);

arch/alpha/kernel/io.c

360

void ioread32_rep(const void __iomem *port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

362

if (unlikely((unsigned long)dst & 0x3)) {

arch/alpha/kernel/io.c

365

((struct S *)dst)->x = ioread32(port);

arch/alpha/kernel/io.c

366

dst += 4;

arch/alpha/kernel/io.c

371

*(unsigned int *)dst = ioread32(port);

arch/alpha/kernel/io.c

372

dst += 4;

arch/alpha/kernel/io.c

377

void insl(unsigned long port, void *dst, unsigned long count)

arch/alpha/kernel/io.c

379

ioread32_rep(ioport_map(port, 4), dst, count);

arch/alpha/lib/csum_partial_copy.c

100

dst++;

arch/alpha/lib/csum_partial_copy.c

108

tmp = *dst;

arch/alpha/lib/csum_partial_copy.c

113

*dst = word | tmp;

arch/alpha/lib/csum_partial_copy.c

125

unsigned long *dst,

arch/alpha/lib/csum_partial_copy.c

150

*dst = word;

arch/alpha/lib/csum_partial_copy.c

151

dst++;

arch/alpha/lib/csum_partial_copy.c

161

tmp = *dst;

arch/alpha/lib/csum_partial_copy.c

169

*dst = word | tmp;

arch/alpha/lib/csum_partial_copy.c

180

unsigned long *dst,

arch/alpha/lib/csum_partial_copy.c

197

stq_u(partial_dest | second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

202

dst++;

arch/alpha/lib/csum_partial_copy.c

217

stq_u(partial_dest, dst);

arch/alpha/lib/csum_partial_copy.c

219

dst++;

arch/alpha/lib/csum_partial_copy.c

224

ldq_u(second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

226

stq_u(partial_dest | second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

238

unsigned long * dst,

arch/alpha/lib/csum_partial_copy.c

266

stq_u(partial_dest | second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

269

dst++;

arch/alpha/lib/csum_partial_copy.c

287

stq_u(partial_dest | second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

289

ldq_u(second_dest, dst+1);

arch/alpha/lib/csum_partial_copy.c

292

stq_u(partial_dest | second_dest, dst+1);

arch/alpha/lib/csum_partial_copy.c

304

ldq_u(second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

310

stq_u(partial_dest | word | second_dest, dst);

arch/alpha/lib/csum_partial_copy.c

316

static __wsum __csum_and_copy(const void __user *src, void *dst, int len)

arch/alpha/lib/csum_partial_copy.c

319

unsigned long doff = 7 & (unsigned long) dst;

arch/alpha/lib/csum_partial_copy.c

326

(unsigned long *) dst, len-8);

arch/alpha/lib/csum_partial_copy.c

330

(unsigned long *) dst,

arch/alpha/lib/csum_partial_copy.c

334

ldq_u(partial_dest, dst);

arch/alpha/lib/csum_partial_copy.c

338

(unsigned long *) dst,

arch/alpha/lib/csum_partial_copy.c

343

(unsigned long *) dst,

arch/alpha/lib/csum_partial_copy.c

350

csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/alpha/lib/csum_partial_copy.c

354

return __csum_and_copy(src, dst, len);

arch/alpha/lib/csum_partial_copy.c

358

csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/alpha/lib/csum_partial_copy.c

361

dst, len);

arch/alpha/lib/csum_partial_copy.c

84

csum_partial_cfu_aligned(const unsigned long __user *src, unsigned long *dst,

arch/alpha/lib/csum_partial_copy.c

99

*dst = word;

arch/alpha/lib/srm_printk.c

15

char *src, *dst;

arch/alpha/lib/srm_printk.c

32

for (dst = src + num_lf; src >= buf; ) {

arch/alpha/lib/srm_printk.c

34

*dst-- = '\r';

arch/alpha/lib/srm_printk.c

36

*dst-- = *src--;

arch/arc/include/asm/cacheflush.h

59

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/arc/include/asm/cacheflush.h

61

memcpy(dst, src, len); \

arch/arc/include/asm/cacheflush.h

63

__sync_icache_dcache((unsigned long)(dst), vaddr, len); \

arch/arc/include/asm/cacheflush.h

66

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/arc/include/asm/cacheflush.h

67

memcpy(dst, src, len); \

arch/arc/include/asm/uaccess.h

101

#define __arc_put_user_one(src, dst, op, ret) \

arch/arc/include/asm/uaccess.h

116

: "r" (src), "r" (dst), "ir" (-EFAULT))

arch/arc/include/asm/uaccess.h

118

#define __arc_put_user_one_64(src, dst, ret) \

arch/arc/include/asm/uaccess.h

135

: "r" (src), "r" (dst), "ir" (-EFAULT))

arch/arc/include/asm/uaccess.h

46

#define __arc_get_user_one(dst, src, op, ret) \

arch/arc/include/asm/uaccess.h

63

: "+r" (ret), "=r" (dst) \

arch/arc/include/asm/uaccess.h

66

#define __arc_get_user_one_64(dst, src, ret) \

arch/arc/include/asm/uaccess.h

86

: "+r" (ret), "=r" (dst) \

arch/arc/mm/cache.c

886

struct folio *dst = page_folio(to);

arch/arc/mm/cache.c

892

clear_bit(PG_dc_clean, &dst->flags.f);

arch/arc/net/bpf_jit_core.c

1044

len += zext(BUF(buf, len), dst);

arch/arc/net/bpf_jit_core.c

740

const u8 dst = insn->dst_reg;

arch/arc/net/bpf_jit_core.c

751

len = add_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

755

len = add_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

759

len = sub_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

763

len = sub_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

767

len = neg_r32(buf, dst);

arch/arc/net/bpf_jit_core.c

771

len = mul_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

775

len = mul_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

779

len = div_r32(buf, dst, src, off == 1);

arch/arc/net/bpf_jit_core.c

783

len = div_r32_i32(buf, dst, imm, off == 1);

arch/arc/net/bpf_jit_core.c

787

len = mod_r32(buf, dst, src, off == 1);

arch/arc/net/bpf_jit_core.c

791

len = mod_r32_i32(buf, dst, imm, off == 1);

arch/arc/net/bpf_jit_core.c

795

len = and_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

799

len = and_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

803

len = or_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

807

len = or_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

811

len = xor_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

815

len = xor_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

819

len = lsh_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

823

len = lsh_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

827

len = rsh_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

831

len = rsh_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

835

len = arsh_r32(buf, dst, src);

arch/arc/net/bpf_jit_core.c

839

len = arsh_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

843

len = mov_r32(buf, dst, src, (u8)off);

arch/arc/net/bpf_jit_core.c

847

len = mov_r32_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

853

CHECK_RET(handle_swap(buf, dst, imm, BPF_SRC(code),

arch/arc/net/bpf_jit_core.c

860

len = add_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

864

len = add_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

868

len = sub_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

872

len = sub_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

876

len = neg_r64(buf, dst);

arch/arc/net/bpf_jit_core.c

880

len = mul_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

884

len = mul_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

888

len = and_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

892

len = and_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

896

len = or_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

900

len = or_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

904

len = xor_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

908

len = xor_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

912

len = lsh_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

916

len = lsh_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

920

len = rsh_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

924

len = rsh_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

928

len = arsh_r64(buf, dst, src);

arch/arc/net/bpf_jit_core.c

932

len = arsh_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

936

len = mov_r64(buf, dst, src, (u8)off);

arch/arc/net/bpf_jit_core.c

940

len = mov_r64_i32(buf, dst, imm);

arch/arc/net/bpf_jit_core.c

953

len = load_r(buf, dst, src, off, BPF_SIZE(code), false);

arch/arc/net/bpf_jit_core.c

958

len = load_r(buf, dst, src, off, BPF_SIZE(code), true);

arch/arc/net/bpf_jit_core.c

965

len = store_r(buf, src, dst, off, BPF_SIZE(code));

arch/arc/net/bpf_jit_core.c

971

len = store_i(buf, imm, dst, off, BPF_SIZE(code));

arch/arm/crypto/aes-ce-glue.c

177

ce_aes_ecb_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

197

ce_aes_ecb_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

215

ce_aes_cbc_encrypt(walk->dst.virt.addr, walk->src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

245

ce_aes_cbc_decrypt(walk->dst.virt.addr, walk->src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

25

asmlinkage void ce_aes_invert(void *dst, void *src);

arch/arm/crypto/aes-ce-glue.c

270

struct scatterlist *src = req->src, *dst = req->dst;

arch/arm/crypto/aes-ce-glue.c

287

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm/crypto/aes-ce-glue.c

299

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/arm/crypto/aes-ce-glue.c

300

if (req->dst != req->src)

arch/arm/crypto/aes-ce-glue.c

301

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/arm/crypto/aes-ce-glue.c

306

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm/crypto/aes-ce-glue.c

315

ce_aes_cbc_cts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

328

struct scatterlist *src = req->src, *dst = req->dst;

arch/arm/crypto/aes-ce-glue.c

345

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm/crypto/aes-ce-glue.c

357

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/arm/crypto/aes-ce-glue.c

358

if (req->dst != req->src)

arch/arm/crypto/aes-ce-glue.c

359

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/arm/crypto/aes-ce-glue.c

364

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm/crypto/aes-ce-glue.c

373

ce_aes_cbc_cts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

392

ce_aes_ctr_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

402

u8 *tdst = walk.dst.virt.addr;

arch/arm/crypto/aes-ce-glue.c

427

struct scatterlist *src, *dst;

arch/arm/crypto/aes-ce-glue.c

445

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm/crypto/aes-ce-glue.c

461

ce_aes_xts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

471

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/arm/crypto/aes-ce-glue.c

472

if (req->dst != req->src)

arch/arm/crypto/aes-ce-glue.c

473

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/arm/crypto/aes-ce-glue.c

475

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm/crypto/aes-ce-glue.c

483

ce_aes_xts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

499

struct scatterlist *src, *dst;

arch/arm/crypto/aes-ce-glue.c

517

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm/crypto/aes-ce-glue.c

533

ce_aes_xts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-ce-glue.c

543

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/arm/crypto/aes-ce-glue.c

544

if (req->dst != req->src)

arch/arm/crypto/aes-ce-glue.c

545

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/arm/crypto/aes-ce-glue.c

547

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm/crypto/aes-ce-glue.c

555

ce_aes_xts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-neonbs-glue.c

154

u8 *dst = walk.dst.virt.addr;

arch/arm/crypto/aes-neonbs-glue.c

158

crypto_xor_cpy(dst, src, prev, AES_BLOCK_SIZE);

arch/arm/crypto/aes-neonbs-glue.c

159

aes_encrypt(&ctx->fallback, dst, dst);

arch/arm/crypto/aes-neonbs-glue.c

160

prev = dst;

arch/arm/crypto/aes-neonbs-glue.c

162

dst += AES_BLOCK_SIZE;

arch/arm/crypto/aes-neonbs-glue.c

188

aesbs_cbc_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm/crypto/aes-neonbs-glue.c

211

u8 *dst = walk.dst.virt.addr;

arch/arm/crypto/aes-neonbs-glue.c

215

src = dst = memcpy(buf + sizeof(buf) - bytes,

arch/arm/crypto/aes-neonbs-glue.c

221

aesbs_ctr_encrypt(dst, src, ctx->rk, ctx->rounds, bytes, walk.iv);

arch/arm/crypto/aes-neonbs-glue.c

225

memcpy(walk.dst.virt.addr,

arch/arm/crypto/aes-neonbs-glue.c

276

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm/crypto/aes-neonbs-glue.c

298

fn(walk.dst.virt.addr, walk.src.virt.addr, ctx->key.rk,

arch/arm/crypto/aes-neonbs-glue.c

309

scatterwalk_map_and_copy(buf, req->dst, req->cryptlen - AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

323

scatterwalk_map_and_copy(buf, req->dst, req->cryptlen - AES_BLOCK_SIZE,

arch/arm/crypto/aes-neonbs-glue.c

98

fn(walk.dst.virt.addr, walk.src.virt.addr, ctx->rk,

arch/arm/crypto/ghash-ce-glue.c

113

unsigned int len, u8 *dst)

arch/arm/crypto/ghash-ce-glue.c

125

return ghash_export(desc, dst);

arch/arm/crypto/ghash-ce-glue.c

187

struct gcm_key const *k, char *dst,

arch/arm/crypto/ghash-ce-glue.c

195

struct gcm_key const *k, char *dst,

arch/arm/crypto/ghash-ce-glue.c

317

u8 *tag, *dst;

arch/arm/crypto/ghash-ce-glue.c

328

dst = walk.dst.virt.addr;

arch/arm/crypto/ghash-ce-glue.c

333

pmull_gcm_encrypt(nblocks, dg, src, ctx, dst, iv,

arch/arm/crypto/ghash-ce-glue.c

339

dst += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

351

dst = walk.dst.virt.addr;

arch/arm/crypto/ghash-ce-glue.c

371

if (unlikely(tail && (tail == walk.nbytes || src != dst)))

arch/arm/crypto/ghash-ce-glue.c

378

if (unlikely(tail && src != dst))

arch/arm/crypto/ghash-ce-glue.c

379

memcpy(dst, src, tail);

arch/arm/crypto/ghash-ce-glue.c

388

scatterwalk_map_and_copy(tag, req->dst, req->assoclen + req->cryptlen,

arch/arm/crypto/ghash-ce-glue.c

406

u8 *tag, *dst;

arch/arm/crypto/ghash-ce-glue.c

421

dst = walk.dst.virt.addr;

arch/arm/crypto/ghash-ce-glue.c

426

pmull_gcm_decrypt(nblocks, dg, src, ctx, dst, iv,

arch/arm/crypto/ghash-ce-glue.c

432

dst += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

444

dst = walk.dst.virt.addr;

arch/arm/crypto/ghash-ce-glue.c

455

if (unlikely(tail && (tail == walk.nbytes || src != dst)))

arch/arm/crypto/ghash-ce-glue.c

462

if (unlikely(tail && src != dst))

arch/arm/crypto/ghash-ce-glue.c

463

memcpy(dst, src, tail);

arch/arm/crypto/ghash-ce-glue.c

95

u8 *dst = out;

arch/arm/crypto/ghash-ce-glue.c

97

put_unaligned_be64(ctx->digest[1], dst);

arch/arm/crypto/ghash-ce-glue.c

98

put_unaligned_be64(ctx->digest[0], dst + 8);

arch/arm/include/asm/assembler.h

636

.macro mov_l, dst:req, imm:req, cond

arch/arm/include/asm/assembler.h

652

.macro adr_l, dst:req, sym:req, cond

arch/arm/include/asm/assembler.h

663

.macro ldr_l, dst:req, sym:req, cond

arch/arm/include/asm/assembler.h

786

.macro bl_r, dst:req, c

arch/arm/include/asm/cacheflush.h

170

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/arm/include/asm/cacheflush.h

172

memcpy(dst, src, len); \

arch/arm/include/asm/checksum.h

39

csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/arm/include/asm/checksum.h

42

csum_partial_copy_from_user(const void __user *src, void *dst, int len);

arch/arm/include/asm/checksum.h

47

__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/arm/include/asm/checksum.h

52

return csum_partial_copy_from_user(src, dst, len);

arch/arm/include/asm/io.h

301

static inline void memset_io(volatile void __iomem *dst, unsigned c,

arch/arm/include/asm/io.h

305

mmioset((void __force *)dst, c, count);

arch/arm/include/asm/io.h

307

#define memset_io(dst,c,count) memset_io(dst,c,count)

arch/arm/include/asm/string.h

65

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/arm/include/asm/string.h

66

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/arm/include/asm/uaccess.h

509

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/arm/include/asm/uaccess.h

530

put_unaligned(__val, (type *)(dst)); \

arch/arm/include/asm/uaccess.h

532

*(type *)(dst) = __val; /* aligned by caller */ \

arch/arm/include/asm/uaccess.h

537

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/arm/include/asm/uaccess.h

539

const type *__pk_ptr = (dst); \

arch/arm/include/asm/xor.h

14

#define GET_BLOCK_2(dst) \

arch/arm/include/asm/xor.h

16

: "=r" (dst), "=r" (a1), "=r" (a2) \

arch/arm/include/asm/xor.h

17

: "0" (dst))

arch/arm/include/asm/xor.h

19

#define GET_BLOCK_4(dst) \

arch/arm/include/asm/xor.h

21

: "=r" (dst), "=r" (a1), "=r" (a2), "=r" (a3), "=r" (a4) \

arch/arm/include/asm/xor.h

22

: "0" (dst))

arch/arm/include/asm/xor.h

36

#define PUT_BLOCK_2(dst) \

arch/arm/include/asm/xor.h

38

: "=r" (dst) \

arch/arm/include/asm/xor.h

39

: "0" (dst), "r" (a1), "r" (a2))

arch/arm/include/asm/xor.h

41

#define PUT_BLOCK_4(dst) \

arch/arm/include/asm/xor.h

43

: "=r" (dst) \

arch/arm/include/asm/xor.h

44

: "0" (dst), "r" (a1), "r" (a2), "r" (a3), "r" (a4))

arch/arm/kernel/io.c

77

void _memset_io(volatile void __iomem *dst, int c, size_t count)

arch/arm/kernel/io.c

81

writeb(c, dst);

arch/arm/kernel/io.c

82

dst++;

arch/arm/mach-omap1/sram-init.c

64

void *dst = NULL;

arch/arm/mach-omap1/sram-init.c

75

dst = fncpy(sram, funcp, size);

arch/arm/mach-omap1/sram-init.c

79

return dst;

arch/arm/mach-omap2/sram.c

101

return dst;

arch/arm/mach-omap2/sram.c

86

void *dst = NULL;

arch/arm/mach-omap2/sram.c

97

dst = fncpy(sram, funcp, size);

arch/arm/mm/flush.c

186

unsigned long uaddr, void *dst, const void *src,

arch/arm/mm/flush.c

192

memcpy(dst, src, len);

arch/arm/mm/flush.c

193

flush_ptrace_access(vma, page, uaddr, dst, len);

arch/arm/mm/nommu.c

185

unsigned long uaddr, void *dst, const void *src,

arch/arm/mm/nommu.c

188

memcpy(dst, src, len);

arch/arm/net/bpf_jit_32.c

1004

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1008

static inline void emit_a32_lsh_r64(const s8 dst[], const s8 src[],

arch/arm/net/bpf_jit_32.c

1017

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1032

static inline void emit_a32_arsh_r64(const s8 dst[], const s8 src[],

arch/arm/net/bpf_jit_32.c

1041

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1057

static inline void emit_a32_rsh_r64(const s8 dst[], const s8 src[],

arch/arm/net/bpf_jit_32.c

1066

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1081

static inline void emit_a32_lsh_i64(const s8 dst[],

arch/arm/net/bpf_jit_32.c

1088

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1103

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1107

static inline void emit_a32_rsh_i64(const s8 dst[],

arch/arm/net/bpf_jit_32.c

1114

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1133

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1137

static inline void emit_a32_arsh_i64(const s8 dst[],

arch/arm/net/bpf_jit_32.c

1144

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1163

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1166

static inline void emit_a32_mul_r64(const s8 dst[], const s8 src[],

arch/arm/net/bpf_jit_32.c

1173

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

1227

static inline void emit_str_r(const s8 dst, const s8 src[],

arch/arm/net/bpf_jit_32.c

1232

rd = arm_bpf_get_reg32(dst, tmp[1], ctx);

arch/arm/net/bpf_jit_32.c

1262

static inline void emit_ldx_r(const s8 dst[], const s8 src,

arch/arm/net/bpf_jit_32.c

1265

const s8 *rd = is_stacked(dst_lo) ? tmp : dst;

arch/arm/net/bpf_jit_32.c

1302

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1306

static inline void emit_ldsx_r(const s8 dst[], const s8 src,

arch/arm/net/bpf_jit_32.c

1309

const s8 *rd = is_stacked(dst_lo) ? tmp : dst;

arch/arm/net/bpf_jit_32.c

1346

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1592

const s8 *dst = bpf2a32[insn->dst_reg];

arch/arm/net/bpf_jit_32.c

1630

emit_a32_movsx_r64(is64, insn->off, dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1632

emit_a32_mov_r64(is64, dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1636

emit_a32_mov_se_i64(is64, dst, imm, ctx);

arch/arm/net/bpf_jit_32.c

1675

emit_a32_alu_r64(is64, dst, src, ctx, BPF_OP(code));

arch/arm/net/bpf_jit_32.c

1685

emit_a32_alu_r64(is64, dst, tmp2, ctx, BPF_OP(code));

arch/arm/net/bpf_jit_32.c

1717

rd = arm_bpf_get_reg64(dst, tmp2, ctx);

arch/arm/net/bpf_jit_32.c

1728

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1747

emit_a32_lsh_i64(dst, imm, ctx);

arch/arm/net/bpf_jit_32.c

1753

emit_a32_rsh_i64(dst, imm, ctx);

arch/arm/net/bpf_jit_32.c

1757

emit_a32_lsh_r64(dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1761

emit_a32_rsh_r64(dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1765

emit_a32_arsh_r64(dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1771

emit_a32_arsh_i64(dst, imm, ctx);

arch/arm/net/bpf_jit_32.c

1781

emit_a32_neg64(dst, ctx);

arch/arm/net/bpf_jit_32.c

1788

emit_a32_mul_r64(dst, src, ctx);

arch/arm/net/bpf_jit_32.c

1798

emit_a32_mul_r64(dst, tmp2, ctx);

arch/arm/net/bpf_jit_32.c

1808

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

181

#define dst_lo dst[1]

arch/arm/net/bpf_jit_32.c

182

#define dst_hi dst[0]

arch/arm/net/bpf_jit_32.c

1848

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

1855

emit_a32_mov_i64(dst, val, ctx);

arch/arm/net/bpf_jit_32.c

1870

emit_ldsx_r(dst, rn, off, ctx, BPF_SIZE(code));

arch/arm/net/bpf_jit_32.c

1872

emit_ldx_r(dst, rn, off, ctx, BPF_SIZE(code));

arch/arm/net/bpf_jit_32.c

1985

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

524

u32 dst;

arch/arm/net/bpf_jit_32.c

561

dst = (u32)jit_sdiv32;

arch/arm/net/bpf_jit_32.c

563

dst = (u32)jit_smod32;

arch/arm/net/bpf_jit_32.c

566

dst = (u32)jit_udiv32;

arch/arm/net/bpf_jit_32.c

568

dst = (u32)jit_mod32;

arch/arm/net/bpf_jit_32.c

571

emit_mov_i(ARM_IP, dst, ctx);

arch/arm/net/bpf_jit_32.c

591

u32 dst;

arch/arm/net/bpf_jit_32.c

629

dst = (u32)jit_sdiv64;

arch/arm/net/bpf_jit_32.c

631

dst = (u32)jit_smod64;

arch/arm/net/bpf_jit_32.c

634

dst = (u32)jit_udiv64;

arch/arm/net/bpf_jit_32.c

636

dst = (u32)jit_mod64;

arch/arm/net/bpf_jit_32.c

639

emit_mov_i(ARM_IP, dst, ctx);

arch/arm/net/bpf_jit_32.c

732

static inline void emit_a32_mov_i(const s8 dst, const u32 val,

arch/arm/net/bpf_jit_32.c

737

if (is_stacked(dst)) {

arch/arm/net/bpf_jit_32.c

739

arm_bpf_put_reg32(dst, tmp[1], ctx);

arch/arm/net/bpf_jit_32.c

741

emit_mov_i(dst, val, ctx);

arch/arm/net/bpf_jit_32.c

745

static void emit_a32_mov_i64(const s8 dst[], u64 val, struct jit_ctx *ctx)

arch/arm/net/bpf_jit_32.c

748

const s8 *rd = is_stacked(dst_lo) ? tmp : dst;

arch/arm/net/bpf_jit_32.c

753

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

757

static inline void emit_a32_mov_se_i64(const bool is64, const s8 dst[],

arch/arm/net/bpf_jit_32.c

763

emit_a32_mov_i64(dst, val64, ctx);

arch/arm/net/bpf_jit_32.c

766

static inline void emit_a32_add_r(const u8 dst, const u8 src,

arch/arm/net/bpf_jit_32.c

776

emit(ARM_ADDS_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

778

emit(ARM_ADC_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

780

emit(ARM_ADD_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

783

static inline void emit_a32_sub_r(const u8 dst, const u8 src,

arch/arm/net/bpf_jit_32.c

793

emit(ARM_SUBS_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

795

emit(ARM_SBC_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

797

emit(ARM_SUB_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

800

static inline void emit_alu_r(const u8 dst, const u8 src, const bool is64,

arch/arm/net/bpf_jit_32.c

805

emit_a32_add_r(dst, src, is64, hi, ctx);

arch/arm/net/bpf_jit_32.c

809

emit_a32_sub_r(dst, src, is64, hi, ctx);

arch/arm/net/bpf_jit_32.c

813

emit(ARM_ORR_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

817

emit(ARM_AND_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

821

emit(ARM_EOR_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

825

emit(ARM_MUL(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

829

emit(ARM_LSL_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

833

emit(ARM_LSR_R(dst, dst, src), ctx);

arch/arm/net/bpf_jit_32.c

837

emit(ARM_MOV_SR(dst, dst, SRTYPE_ASR, src), ctx);

arch/arm/net/bpf_jit_32.c

843

static inline void emit_a32_alu_r64(const bool is64, const s8 dst[],

arch/arm/net/bpf_jit_32.c

850

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/net/bpf_jit_32.c

870

arm_bpf_put_reg64(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

874

static inline void emit_a32_mov_r(const s8 dst, const s8 src, struct jit_ctx *ctx) {

arch/arm/net/bpf_jit_32.c

879

arm_bpf_put_reg32(dst, rt, ctx);

arch/arm/net/bpf_jit_32.c

883

static inline void emit_a32_mov_r64(const bool is64, const s8 dst[],

arch/arm/net/bpf_jit_32.c

902

emit(ARM_LDRD_I(dst[1], ARM_FP, EBPF_SCRATCH_TO_ARM_FP(src_lo)), ctx);

arch/arm/net/bpf_jit_32.c

906

emit(ARM_MOV_R(dst[0], src[0]), ctx);

arch/arm/net/bpf_jit_32.c

907

emit(ARM_MOV_R(dst[1], src[1]), ctx);

arch/arm/net/bpf_jit_32.c

912

static inline void emit_a32_movsx_r64(const bool is64, const u8 off, const s8 dst[], const s8 src[],

arch/arm/net/bpf_jit_32.c

965

static inline void emit_a32_alu_i(const s8 dst, const u32 val,

arch/arm/net/bpf_jit_32.c

970

rd = arm_bpf_get_reg32(dst, tmp[0], ctx);

arch/arm/net/bpf_jit_32.c

988

arm_bpf_put_reg32(dst, rd, ctx);

arch/arm/net/bpf_jit_32.c

992

static inline void emit_a32_neg64(const s8 dst[],

arch/arm/net/bpf_jit_32.c

998

rd = arm_bpf_get_reg64(dst, tmp, ctx);

arch/arm/probes/uprobes/core.c

117

void *dst = xol_page_kaddr + (vaddr & ~PAGE_MASK);

arch/arm/probes/uprobes/core.c

122

memcpy(dst, src, len);

arch/arm/probes/uprobes/core.c

125

flush_uprobe_xol_access(page, vaddr, dst, len);

arch/arm/vdso/vdsomunge.c

111

static void write_elf_word(Elf32_Word val, Elf32_Word *dst, bool swap)

arch/arm/vdso/vdsomunge.c

113

*dst = swap ? swab32(val) : val;

arch/arm64/crypto/aes-ce-ccm-glue.c

193

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/aes-ce-ccm-glue.c

203

src = dst = memcpy(&buf[sizeof(buf) - walk.nbytes],

arch/arm64/crypto/aes-ce-ccm-glue.c

206

ce_aes_ccm_encrypt(dst, src, walk.nbytes - tail,

arch/arm64/crypto/aes-ce-ccm-glue.c

211

memcpy(walk.dst.virt.addr, dst, walk.nbytes);

arch/arm64/crypto/aes-ce-ccm-glue.c

223

scatterwalk_map_and_copy(mac, req->dst, req->assoclen + req->cryptlen,

arch/arm64/crypto/aes-ce-ccm-glue.c

258

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/aes-ce-ccm-glue.c

268

src = dst = memcpy(&buf[sizeof(buf) - walk.nbytes],

arch/arm64/crypto/aes-ce-ccm-glue.c

271

ce_aes_ccm_decrypt(dst, src, walk.nbytes - tail,

arch/arm64/crypto/aes-ce-ccm-glue.c

276

memcpy(walk.dst.virt.addr, dst, walk.nbytes);

arch/arm64/crypto/aes-glue.c

189

aes_ecb_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

208

aes_ecb_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

225

aes_cbc_encrypt(walk->dst.virt.addr, walk->src.virt.addr,

arch/arm64/crypto/aes-glue.c

253

aes_cbc_decrypt(walk->dst.virt.addr, walk->src.virt.addr,

arch/arm64/crypto/aes-glue.c

277

struct scatterlist *src = req->src, *dst = req->dst;

arch/arm64/crypto/aes-glue.c

293

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/aes-glue.c

305

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/arm64/crypto/aes-glue.c

306

if (req->dst != req->src)

arch/arm64/crypto/aes-glue.c

307

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/arm64/crypto/aes-glue.c

312

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm64/crypto/aes-glue.c

321

aes_cbc_cts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

333

struct scatterlist *src = req->src, *dst = req->dst;

arch/arm64/crypto/aes-glue.c

349

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/aes-glue.c

361

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/arm64/crypto/aes-glue.c

362

if (req->dst != req->src)

arch/arm64/crypto/aes-glue.c

363

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/arm64/crypto/aes-glue.c

368

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm64/crypto/aes-glue.c

377

aes_cbc_cts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

396

aes_essiv_cbc_encrypt(walk.dst.virt.addr,

arch/arm64/crypto/aes-glue.c

418

aes_essiv_cbc_decrypt(walk.dst.virt.addr,

arch/arm64/crypto/aes-glue.c

440

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/aes-glue.c

452

src = dst = memcpy(buf + sizeof(buf) - nbytes,

arch/arm64/crypto/aes-glue.c

458

aes_xctr_encrypt(dst, src, ctx->key_enc, rounds, nbytes,

arch/arm64/crypto/aes-glue.c

462

memcpy(walk.dst.virt.addr,

arch/arm64/crypto/aes-glue.c

484

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/aes-glue.c

496

src = dst = memcpy(buf + sizeof(buf) - nbytes,

arch/arm64/crypto/aes-glue.c

502

aes_ctr_encrypt(dst, src, ctx->key_enc, rounds, nbytes,

arch/arm64/crypto/aes-glue.c

506

memcpy(walk.dst.virt.addr,

arch/arm64/crypto/aes-glue.c

523

struct scatterlist *src, *dst;

arch/arm64/crypto/aes-glue.c

541

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/aes-glue.c

557

aes_xts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

566

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/arm64/crypto/aes-glue.c

567

if (req->dst != req->src)

arch/arm64/crypto/aes-glue.c

568

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/arm64/crypto/aes-glue.c

570

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-glue.c

577

aes_xts_encrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

592

struct scatterlist *src, *dst;

arch/arm64/crypto/aes-glue.c

610

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/aes-glue.c

626

aes_xts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-glue.c

635

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/arm64/crypto/aes-glue.c

636

if (req->dst != req->src)

arch/arm64/crypto/aes-glue.c

637

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/arm64/crypto/aes-glue.c

639

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-glue.c

646

aes_xts_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-neonbs-glue.c

118

fn(walk.dst.virt.addr, walk.src.virt.addr, ctx->rk,

arch/arm64/crypto/aes-neonbs-glue.c

177

neon_aes_cbc_encrypt(walk.dst.virt.addr,

arch/arm64/crypto/aes-neonbs-glue.c

203

aesbs_cbc_decrypt(walk.dst.virt.addr, walk.src.virt.addr,

arch/arm64/crypto/aes-neonbs-glue.c

226

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/aes-neonbs-glue.c

230

aesbs_ctr_encrypt(dst, src, ctx->key.rk,

arch/arm64/crypto/aes-neonbs-glue.c

233

dst += blocks * AES_BLOCK_SIZE;

arch/arm64/crypto/aes-neonbs-glue.c

238

u8 *d = dst;

arch/arm64/crypto/aes-neonbs-glue.c

241

src = dst = memcpy(buf + sizeof(buf) -

arch/arm64/crypto/aes-neonbs-glue.c

244

neon_aes_ctr_encrypt(dst, src, ctx->enc,

arch/arm64/crypto/aes-neonbs-glue.c

249

memcpy(d, dst, nbytes);

arch/arm64/crypto/aes-neonbs-glue.c

293

struct scatterlist *src, *dst;

arch/arm64/crypto/aes-neonbs-glue.c

312

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/aes-neonbs-glue.c

327

out = walk.dst.virt.addr;

arch/arm64/crypto/aes-neonbs-glue.c

363

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/arm64/crypto/aes-neonbs-glue.c

364

if (req->dst != req->src)

arch/arm64/crypto/aes-neonbs-glue.c

365

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/arm64/crypto/aes-neonbs-glue.c

367

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/arm64/crypto/aes-neonbs-glue.c

374

out = walk.dst.virt.addr;

arch/arm64/crypto/ghash-ce-glue.c

109

u8 *dst = out;

arch/arm64/crypto/ghash-ce-glue.c

111

put_unaligned_be64(ctx->digest[1], dst);

arch/arm64/crypto/ghash-ce-glue.c

112

put_unaligned_be64(ctx->digest[0], dst + 8);

arch/arm64/crypto/ghash-ce-glue.c

127

unsigned int len, u8 *dst)

arch/arm64/crypto/ghash-ce-glue.c

140

return ghash_export(desc, dst);

arch/arm64/crypto/ghash-ce-glue.c

306

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/ghash-ce-glue.c

312

src = dst = memcpy(buf + sizeof(buf) - nbytes,

arch/arm64/crypto/ghash-ce-glue.c

320

pmull_gcm_encrypt(nbytes, dst, src, ctx->ghash_key.h,

arch/arm64/crypto/ghash-ce-glue.c

328

memcpy(walk.dst.virt.addr,

arch/arm64/crypto/ghash-ce-glue.c

338

scatterwalk_map_and_copy(tag, req->dst, req->assoclen + req->cryptlen,

arch/arm64/crypto/ghash-ce-glue.c

374

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/ghash-ce-glue.c

380

src = dst = memcpy(buf + sizeof(buf) - nbytes,

arch/arm64/crypto/ghash-ce-glue.c

388

ret = pmull_gcm_decrypt(nbytes, dst, src,

arch/arm64/crypto/ghash-ce-glue.c

398

memcpy(walk.dst.virt.addr,

arch/arm64/crypto/ghash-ce-glue.c

54

asmlinkage void pmull_gcm_encrypt(int bytes, u8 dst[], const u8 src[],

arch/arm64/crypto/ghash-ce-glue.c

57

asmlinkage int pmull_gcm_decrypt(int bytes, u8 dst[], const u8 src[],

arch/arm64/crypto/sm4-ce-ccm-glue.c

158

void (*sm4_ce_ccm_crypt)(const u32 *rkey_enc, u8 *dst,

arch/arm64/crypto/sm4-ce-ccm-glue.c

179

sm4_ce_ccm_crypt(rkey_enc, walk->dst.virt.addr,

arch/arm64/crypto/sm4-ce-ccm-glue.c

212

scatterwalk_map_and_copy(mac, req->dst, req->assoclen + req->cryptlen,

arch/arm64/crypto/sm4-ce-ccm-glue.c

23

asmlinkage void sm4_ce_ccm_enc(const u32 *rkey_enc, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-ccm-glue.c

25

asmlinkage void sm4_ce_ccm_dec(const u32 *rkey_enc, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-gcm-glue.c

133

u8 *dst, const u8 *src, u8 *iv,

arch/arm64/crypto/sm4-ce-gcm-glue.c

157

u8 *dst = walk->dst.virt.addr;

arch/arm64/crypto/sm4-ce-gcm-glue.c

165

sm4_ce_pmull_gcm_crypt(ctx->key.rkey_enc, dst, src, iv,

arch/arm64/crypto/sm4-ce-gcm-glue.c

188

scatterwalk_map_and_copy(ghash, req->dst, req->assoclen + req->cryptlen,

arch/arm64/crypto/sm4-ce-gcm-glue.c

25

asmlinkage void sm4_ce_pmull_gcm_enc(const u32 *rkey_enc, u8 *dst,

arch/arm64/crypto/sm4-ce-gcm-glue.c

29

asmlinkage void sm4_ce_pmull_gcm_dec(const u32 *rkey_enc, u8 *dst,

arch/arm64/crypto/sm4-ce-glue.c

116

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-ce-glue.c

122

sm4_ce_crypt(rkey, dst, src, nblks);

arch/arm64/crypto/sm4-ce-glue.c

162

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-ce-glue.c

169

sm4_ce_cbc_enc(ctx->rkey_enc, dst, src,

arch/arm64/crypto/sm4-ce-glue.c

172

sm4_ce_cbc_dec(ctx->rkey_dec, dst, src,

arch/arm64/crypto/sm4-ce-glue.c

204

struct scatterlist *dst = req->dst;

arch/arm64/crypto/sm4-ce-glue.c

224

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm64/crypto/sm4-ce-glue.c

232

dst = src = scatterwalk_ffwd(sg_src, src, subreq.cryptlen);

arch/arm64/crypto/sm4-ce-glue.c

233

if (req->dst != req->src)

arch/arm64/crypto/sm4-ce-glue.c

234

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/arm64/crypto/sm4-ce-glue.c

239

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm64/crypto/sm4-ce-glue.c

249

sm4_ce_cbc_cts_enc(ctx->rkey_enc, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

252

sm4_ce_cbc_cts_dec(ctx->rkey_dec, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

28

asmlinkage void sm4_ce_crypt_block(const u32 *rkey, u8 *dst, const u8 *src);

arch/arm64/crypto/sm4-ce-glue.c

281

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-ce-glue.c

287

sm4_ce_ctr_enc(ctx->rkey_enc, dst, src, walk.iv, nblks);

arch/arm64/crypto/sm4-ce-glue.c

288

dst += nblks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-glue.c

29

asmlinkage void sm4_ce_crypt(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

299

crypto_xor_cpy(dst, src, keystream, nbytes);

arch/arm64/crypto/sm4-ce-glue.c

31

asmlinkage void sm4_ce_cbc_enc(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

318

struct scatterlist *src, *dst;

arch/arm64/crypto/sm4-ce-glue.c

33

asmlinkage void sm4_ce_cbc_dec(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

339

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/arm64/crypto/sm4-ce-glue.c

35

asmlinkage void sm4_ce_cbc_cts_enc(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

355

sm4_ce_xts_enc(ctx->key1.rkey_enc, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

359

sm4_ce_xts_dec(ctx->key1.rkey_dec, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

37

asmlinkage void sm4_ce_cbc_cts_dec(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

375

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/arm64/crypto/sm4-ce-glue.c

376

if (req->dst != req->src)

arch/arm64/crypto/sm4-ce-glue.c

377

dst = scatterwalk_ffwd(sg_dst, req->dst, subreq.cryptlen);

arch/arm64/crypto/sm4-ce-glue.c

379

skcipher_request_set_crypt(&subreq, src, dst,

arch/arm64/crypto/sm4-ce-glue.c

387

sm4_ce_xts_enc(ctx->key1.rkey_enc, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

39

asmlinkage void sm4_ce_ctr_enc(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

391

sm4_ce_xts_dec(ctx->key1.rkey_dec, walk.dst.virt.addr,

arch/arm64/crypto/sm4-ce-glue.c

41

asmlinkage void sm4_ce_xts_enc(const u32 *rkey1, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce-glue.c

44

asmlinkage void sm4_ce_xts_dec(const u32 *rkey1, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-ce.h

10

void sm4_ce_crypt_block(const u32 *rkey, u8 *dst, const u8 *src);

arch/arm64/crypto/sm4-ce.h

12

void sm4_ce_cbc_enc(const u32 *rkey_enc, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-neon-glue.c

121

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-neon-glue.c

127

sm4_neon_cbc_dec(ctx->rkey_dec, dst, src,

arch/arm64/crypto/sm4-neon-glue.c

149

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-neon-glue.c

155

sm4_neon_ctr_crypt(ctx->rkey_enc, dst, src,

arch/arm64/crypto/sm4-neon-glue.c

158

dst += nblocks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

169

crypto_xor_cpy(dst, src, keystream, nbytes);

arch/arm64/crypto/sm4-neon-glue.c

21

asmlinkage void sm4_neon_crypt(const u32 *rkey, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-neon-glue.c

23

asmlinkage void sm4_neon_cbc_dec(const u32 *rkey_dec, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-neon-glue.c

25

asmlinkage void sm4_neon_ctr_crypt(const u32 *rkey_enc, u8 *dst, const u8 *src,

arch/arm64/crypto/sm4-neon-glue.c

46

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-neon-glue.c

52

sm4_neon_crypt(rkey, dst, src, nblocks);

arch/arm64/crypto/sm4-neon-glue.c

90

u8 *dst = walk.dst.virt.addr;

arch/arm64/crypto/sm4-neon-glue.c

93

crypto_xor_cpy(dst, src, iv, SM4_BLOCK_SIZE);

arch/arm64/crypto/sm4-neon-glue.c

94

sm4_crypt_block(ctx->rkey_enc, dst, dst);

arch/arm64/crypto/sm4-neon-glue.c

95

iv = dst;

arch/arm64/crypto/sm4-neon-glue.c

97

dst += SM4_BLOCK_SIZE;

arch/arm64/include/asm/assembler.h

175

.macro adr_l, dst, sym

arch/arm64/include/asm/assembler.h

187

.macro ldr_l, dst, sym, tmp=

arch/arm64/include/asm/assembler.h

212

.macro get_this_cpu_offset, dst

arch/arm64/include/asm/assembler.h

216

.macro get_this_cpu_offset, dst

arch/arm64/include/asm/assembler.h

238

.macro adr_this_cpu, dst, sym, tmp

arch/arm64/include/asm/assembler.h

250

.macro ldr_this_cpu dst, sym, tmp

arch/arm64/include/asm/insn.h

618

u32 aarch64_insn_gen_add_sub_imm(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

625

u32 aarch64_insn_gen_bitfield(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

630

u32 aarch64_insn_gen_movewide(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

634

u32 aarch64_insn_gen_add_sub_shifted_reg(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

640

u32 aarch64_insn_gen_data1(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

644

u32 aarch64_insn_gen_data2(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

649

u32 aarch64_insn_gen_data3(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

655

u32 aarch64_insn_gen_logical_shifted_reg(enum aarch64_insn_register dst,

arch/arm64/include/asm/insn.h

661

u32 aarch64_insn_gen_move_reg(enum aarch64_insn_register dst,

arch/arm64/include/asm/module.h

52

struct plt_entry get_plt_entry(u64 dst, void *pc);

arch/arm64/include/asm/string.h

48

void memcpy_flushcache(void *dst, const void *src, size_t cnt);

arch/arm64/include/asm/string.h

59

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/arm64/include/asm/string.h

60

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/arm64/include/asm/text-patching.h

11

void *aarch64_insn_set(void *dst, u32 insn, size_t len);

arch/arm64/include/asm/text-patching.h

12

void *aarch64_insn_copy(void *dst, void *src, size_t len);

arch/arm64/include/asm/traps.h

119

unsigned long dst, size;

arch/arm64/include/asm/traps.h

121

dst = regs->regs[dstreg];

arch/arm64/include/asm/traps.h

133

regs->regs[dstreg] = dst + size;

arch/arm64/include/asm/traps.h

143

regs->regs[dstreg] = dst - size;

arch/arm64/include/asm/traps.h

150

regs->regs[dstreg] = dst + size;

arch/arm64/include/asm/uaccess.h

277

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/arm64/include/asm/uaccess.h

279

__typeof__(dst) __gkn_dst = (dst); \

arch/arm64/include/asm/uaccess.h

374

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/arm64/include/asm/uaccess.h

376

__typeof__(dst) __pkn_dst = (dst); \

arch/arm64/include/asm/uaccess.h

440

#define unsafe_copy_loop(dst, src, len, type, label) \

arch/arm64/include/asm/uaccess.h

442

unsafe_put_user(*(type *)(src),(type __user *)(dst),label); \

arch/arm64/include/asm/uaccess.h

443

dst += sizeof(type); \

arch/arm64/include/asm/uaccess.h

481

static inline int __copy_from_user_flushcache(void *dst, const void __user *src, unsigned size)

arch/arm64/include/asm/uaccess.h

483

kasan_check_write(dst, size);

arch/arm64/include/asm/uaccess.h

484

return __copy_user_flushcache(dst, __uaccess_mask_ptr(src), size);

arch/arm64/kernel/module-plts.c

13

static struct plt_entry __get_adrp_add_pair(u64 dst, u64 pc,

arch/arm64/kernel/module-plts.c

18

adrp = aarch64_insn_gen_adr(pc, dst, reg, AARCH64_INSN_ADR_TYPE_ADRP);

arch/arm64/kernel/module-plts.c

19

add = aarch64_insn_gen_add_sub_imm(reg, reg, dst % SZ_4K,

arch/arm64/kernel/module-plts.c

26

struct plt_entry get_plt_entry(u64 dst, void *pc)

arch/arm64/kernel/module-plts.c

35

plt = __get_adrp_add_pair(dst, (u64)pc, AARCH64_INSN_REG_16);

arch/arm64/kernel/patching.c

105

typedef void text_poke_f(void *dst, void *src, size_t patched, size_t len);

arch/arm64/kernel/patching.c

135

static void text_poke_memcpy(void *dst, void *src, size_t patched, size_t len)

arch/arm64/kernel/patching.c

137

copy_to_kernel_nofault(dst, src + patched, len);

arch/arm64/kernel/patching.c

140

static void text_poke_memset(void *dst, void *src, size_t patched, size_t len)

arch/arm64/kernel/patching.c

144

memset32(dst, c, len / 4);

arch/arm64/kernel/patching.c

155

noinstr void *aarch64_insn_copy(void *dst, void *src, size_t len)

arch/arm64/kernel/patching.c

158

if ((uintptr_t)dst & 0x3)

arch/arm64/kernel/patching.c

161

return __text_poke(text_poke_memcpy, dst, src, len);

arch/arm64/kernel/patching.c

172

noinstr void *aarch64_insn_set(void *dst, u32 insn, size_t len)

arch/arm64/kernel/patching.c

174

if ((uintptr_t)dst & 0x3)

arch/arm64/kernel/patching.c

177

return __text_poke(text_poke_memset, dst, &insn, len);

arch/arm64/kernel/probes/uprobes.c

19

void *dst = xol_page_kaddr + (vaddr & ~PAGE_MASK);

arch/arm64/kernel/probes/uprobes.c

25

if (!memcmp(dst, src, len))

arch/arm64/kernel/probes/uprobes.c

29

memcpy(dst, src, len);

arch/arm64/kernel/probes/uprobes.c

32

sync_icache_aliases((unsigned long)dst, (unsigned long)dst + len);

arch/arm64/kernel/process.c

347

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/arm64/kernel/process.c

357

*dst = *src;

arch/arm64/kernel/process.c

363

dst->thread.fp_type = FP_STATE_FPSIMD;

arch/arm64/kernel/process.c

364

dst->thread.sve_state = NULL;

arch/arm64/kernel/process.c

365

clear_tsk_thread_flag(dst, TIF_SVE);

arch/arm64/kernel/process.c

366

task_smstop_sm(dst);

arch/arm64/kernel/process.c

374

dst->thread.sme_state = NULL;

arch/arm64/kernel/process.c

375

clear_tsk_thread_flag(dst, TIF_SME);

arch/arm64/kernel/process.c

376

dst->thread.svcr &= ~SVCR_ZA_MASK;

arch/arm64/kernel/process.c

379

clear_tsk_thread_flag(dst, TIF_MTE_ASYNC_FAULT);

arch/arm64/kernel/process.c

384

static int copy_thread_za(struct task_struct *dst, struct task_struct *src)

arch/arm64/kernel/process.c

389

dst->thread.sve_state = kzalloc(sve_state_size(src),

arch/arm64/kernel/process.c

391

if (!dst->thread.sve_state)

arch/arm64/kernel/process.c

394

dst->thread.sme_state = kmemdup(src->thread.sme_state,

arch/arm64/kernel/process.c

397

if (!dst->thread.sme_state) {

arch/arm64/kernel/process.c

398

kfree(dst->thread.sve_state);

arch/arm64/kernel/process.c

399

dst->thread.sve_state = NULL;

arch/arm64/kernel/process.c

403

set_tsk_thread_flag(dst, TIF_SME);

arch/arm64/kernel/process.c

404

dst->thread.svcr |= SVCR_ZA_MASK;

arch/arm64/lib/csum.c

136

__uint128_t src, dst;

arch/arm64/lib/csum.c

140

dst = *(const __uint128_t *)daddr->s6_addr;

arch/arm64/lib/csum.c

149

dst += (dst >> 64) | (dst << 64);

arch/arm64/lib/csum.c

152

sum = accumulate(sum, dst >> 64);

arch/arm64/lib/insn.c

1025

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

1030

u32 aarch64_insn_gen_data2(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

1073

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

1080

u32 aarch64_insn_gen_data3(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

1112

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

1123

u32 aarch64_insn_gen_logical_shifted_reg(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

1184

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

1197

u32 aarch64_insn_gen_move_reg(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

1201

return aarch64_insn_gen_logical_shifted_reg(dst, AARCH64_INSN_REG_ZR,

arch/arm64/lib/insn.c

758

u32 aarch64_insn_gen_add_sub_imm(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

808

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

819

u32 aarch64_insn_gen_bitfield(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

865

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

874

u32 aarch64_insn_gen_movewide(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

924

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

929

u32 aarch64_insn_gen_add_sub_shifted_reg(enum aarch64_insn_register dst,

arch/arm64/lib/insn.c

978

insn = aarch64_insn_encode_register(AARCH64_INSN_REGTYPE_RD, insn, dst);

arch/arm64/lib/insn.c

987

u32 aarch64_insn_gen_data1(enum aarch64_insn_register dst,

arch/arm64/lib/uaccess_flushcache.c

10

void memcpy_flushcache(void *dst, const void *src, size_t cnt)

arch/arm64/lib/uaccess_flushcache.c

17

memcpy(dst, src, cnt);

arch/arm64/lib/uaccess_flushcache.c

18

dcache_clean_pop((unsigned long)dst, (unsigned long)dst + cnt);

arch/arm64/mm/copypage.c

22

struct folio *dst = page_folio(to);

arch/arm64/mm/copypage.c

38

folio_try_hugetlb_mte_tagging(dst);

arch/arm64/mm/copypage.c

49

kto = page_address(folio_page(dst, i));

arch/arm64/mm/copypage.c

52

folio_set_hugetlb_mte_tagged(dst);

arch/arm64/mm/flush.c

45

unsigned long uaddr, void *dst, const void *src,

arch/arm64/mm/flush.c

48

memcpy(dst, src, len);

arch/arm64/mm/flush.c

49

flush_ptrace_access(vma, (unsigned long)dst, (unsigned long)dst + len);

arch/arm64/net/bpf_jit_comp.c

1205

u8 dst = bpf2a64[insn->dst_reg];

arch/arm64/net/bpf_jit_comp.c

1233

emit_a64_mov_i(0, dst, ctx->user_vm_start >> 32, ctx);

arch/arm64/net/bpf_jit_comp.c

1234

emit(A64_LSL(1, dst, dst, 32), ctx);

arch/arm64/net/bpf_jit_comp.c

1236

emit(A64_ORR(1, tmp, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1237

emit(A64_MOV(1, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1240

if (dst != src)

arch/arm64/net/bpf_jit_comp.c

1241

emit(A64_MOV(1, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1246

emit(A64_ADD(1, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1251

emit(A64_MOV(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1254

emit(A64_SXTB(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1257

emit(A64_SXTH(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1260

emit(A64_SXTW(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1267

emit(A64_ADD(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1271

emit(A64_SUB(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1275

emit(A64_AND(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1279

emit(A64_ORR(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1283

emit(A64_EOR(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1287

emit(A64_MUL(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1292

emit(A64_UDIV(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1294

emit(A64_SDIV(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1299

emit(A64_UDIV(is64, tmp, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1301

emit(A64_SDIV(is64, tmp, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1302

emit(A64_MSUB(is64, dst, dst, tmp, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1306

emit(A64_LSLV(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1310

emit(A64_LSRV(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1314

emit(A64_ASRV(is64, dst, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1319

emit(A64_NEG(is64, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1334

emit(A64_REV16(is64, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1336

emit(A64_UXTH(is64, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1339

emit(A64_REV32(0, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1343

emit(A64_REV64(dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1351

emit(A64_UXTH(is64, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1355

emit(A64_UXTW(is64, dst, dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1365

emit_a64_mov_i(is64, dst, imm, ctx);

arch/arm64/net/bpf_jit_comp.c

1370

emit_a64_add_i(is64, dst, dst, tmp, imm, ctx);

arch/arm64/net/bpf_jit_comp.c

1375

emit(A64_SUB_I(is64, dst, dst, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1377

emit(A64_ADD_I(is64, dst, dst, -imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1380

emit(A64_SUB(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1385

a64_insn = A64_AND_I(is64, dst, dst, imm);

arch/arm64/net/bpf_jit_comp.c

1390

emit(A64_AND(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1395

a64_insn = A64_ORR_I(is64, dst, dst, imm);

arch/arm64/net/bpf_jit_comp.c

1400

emit(A64_ORR(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1405

a64_insn = A64_EOR_I(is64, dst, dst, imm);

arch/arm64/net/bpf_jit_comp.c

1410

emit(A64_EOR(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1416

emit(A64_MUL(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1422

emit(A64_UDIV(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1424

emit(A64_SDIV(is64, dst, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1430

emit(A64_UDIV(is64, tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1432

emit(A64_SDIV(is64, tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1433

emit(A64_MSUB(is64, dst, dst, tmp, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1437

emit(A64_LSL(is64, dst, dst, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1441

emit(A64_LSR(is64, dst, dst, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1445

emit(A64_ASR(is64, dst, dst, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1450

emit(A64_BR(dst), ctx);

arch/arm64/net/bpf_jit_comp.c

1483

emit(A64_CMP(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1526

emit(A64_TST(is64, dst, src), ctx);

arch/arm64/net/bpf_jit_comp.c

1550

emit(A64_CMP_I(is64, dst, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1552

emit(A64_CMN_I(is64, dst, -imm), ctx);

arch/arm64/net/bpf_jit_comp.c

1555

emit(A64_CMP(is64, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1560

a64_insn = A64_TST_I(is64, dst, imm);

arch/arm64/net/bpf_jit_comp.c

1565

emit(A64_TST(is64, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1635

emit_addr_mov_i64(dst, imm64, ctx);

arch/arm64/net/bpf_jit_comp.c

1637

emit_a64_mov_i64(dst, imm64, ctx);

arch/arm64/net/bpf_jit_comp.c

1684

emit(A64_LDRSWI(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1686

emit(A64_LDR32I(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1690

emit(A64_LDRSW(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1692

emit(A64_LDR32(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1698

emit(A64_LDRSHI(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1700

emit(A64_LDRHI(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1704

emit(A64_LDRSH(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1706

emit(A64_LDRH(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1712

emit(A64_LDRSBI(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1714

emit(A64_LDRBI(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1718

emit(A64_LDRSB(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1720

emit(A64_LDRB(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1725

emit(A64_LDR64I(dst, src_adj, off_adj), ctx);

arch/arm64/net/bpf_jit_comp.c

1728

emit(A64_LDR64(dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1733

ret = add_exception_handler(insn, ctx, dst);

arch/arm64/net/bpf_jit_comp.c

1758

emit(A64_ADD(1, tmp3, dst, arena_vm_base), ctx);

arch/arm64/net/bpf_jit_comp.c

1759

dst = tmp3;

arch/arm64/net/bpf_jit_comp.c

1761

if (dst == fp) {

arch/arm64/net/bpf_jit_comp.c

1765

dst_adj = dst;

arch/arm64/net/bpf_jit_comp.c

1776

emit(A64_STR32(tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1784

emit(A64_STRH(tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1792

emit(A64_STRB(tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1800

emit(A64_STR64(tmp, dst, tmp2), ctx);

arch/arm64/net/bpf_jit_comp.c

1805

ret = add_exception_handler(insn, ctx, dst);

arch/arm64/net/bpf_jit_comp.c

1820

emit(A64_ADD(1, tmp2, dst, arena_vm_base), ctx);

arch/arm64/net/bpf_jit_comp.c

1821

dst = tmp2;

arch/arm64/net/bpf_jit_comp.c

1823

if (dst == fp) {

arch/arm64/net/bpf_jit_comp.c

1827

dst_adj = dst;

arch/arm64/net/bpf_jit_comp.c

1836

emit(A64_STR32(src, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1844

emit(A64_STRH(src, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1852

emit(A64_STRB(src, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1860

emit(A64_STR64(src, dst, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

1865

ret = add_exception_handler(insn, ctx, dst);

arch/arm64/net/bpf_jit_comp.c

1888

ret = add_exception_handler(insn, ctx, dst);

arch/arm64/net/bpf_jit_comp.c

2273

void *bpf_arch_text_copy(void *dst, void *src, size_t len)

arch/arm64/net/bpf_jit_comp.c

2275

if (!aarch64_insn_copy(dst, src, len))

arch/arm64/net/bpf_jit_comp.c

2277

return dst;

arch/arm64/net/bpf_jit_comp.c

273

int bpf_arch_text_invalidate(void *dst, size_t len)

arch/arm64/net/bpf_jit_comp.c

275

if (!aarch64_insn_set(dst, AARCH64_BREAK_FAULT, len))

arch/arm64/net/bpf_jit_comp.c

295

static inline void emit_a64_add_i(const bool is64, const int dst, const int src,

arch/arm64/net/bpf_jit_comp.c

299

emit(A64_ADD_I(is64, dst, src, imm), ctx);

arch/arm64/net/bpf_jit_comp.c

301

emit(A64_SUB_I(is64, dst, src, -imm), ctx);

arch/arm64/net/bpf_jit_comp.c

304

emit(A64_ADD(is64, dst, src, tmp), ctx);

arch/arm64/net/bpf_jit_comp.c

711

const u8 dst = bpf2a64[insn->dst_reg];

arch/arm64/net/bpf_jit_comp.c

721

reg = dst;

arch/arm64/net/bpf_jit_comp.c

741

emit(A64_LDARB(dst, reg), ctx);

arch/arm64/net/bpf_jit_comp.c

744

emit(A64_LDARH(dst, reg), ctx);

arch/arm64/net/bpf_jit_comp.c

747

emit(A64_LDAR32(dst, reg), ctx);

arch/arm64/net/bpf_jit_comp.c

750

emit(A64_LDAR64(dst, reg), ctx);

arch/arm64/net/bpf_jit_comp.c

783

const u8 dst = bpf2a64[insn->dst_reg];

arch/arm64/net/bpf_jit_comp.c

790

u8 reg = dst;

arch/arm64/net/bpf_jit_comp.c

849

const u8 dst = bpf2a64[insn->dst_reg];

arch/arm64/net/bpf_jit_comp.c

858

u8 reg = dst;

arch/csky/abiv1/inc/abi/cacheflush.h

53

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/csky/abiv1/inc/abi/cacheflush.h

55

memcpy(dst, src, len); \

arch/csky/abiv1/inc/abi/cacheflush.h

58

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/csky/abiv1/inc/abi/cacheflush.h

60

memcpy(dst, src, len); \

arch/csky/abiv2/inc/abi/cacheflush.h

47

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/csky/abiv2/inc/abi/cacheflush.h

49

memcpy(dst, src, len); \

arch/csky/abiv2/inc/abi/cacheflush.h

51

dcache_wb_range((unsigned long)dst, \

arch/csky/abiv2/inc/abi/cacheflush.h

52

(unsigned long)dst + len); \

arch/csky/abiv2/inc/abi/cacheflush.h

54

(unsigned long)dst, \

arch/csky/abiv2/inc/abi/cacheflush.h

55

(unsigned long)dst + len); \

arch/csky/abiv2/inc/abi/cacheflush.h

58

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/csky/abiv2/inc/abi/cacheflush.h

59

memcpy(dst, src, len)

arch/hexagon/include/asm/cacheflush.h

72

unsigned long vaddr, void *dst, void *src, int len);

arch/hexagon/include/asm/cacheflush.h

75

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/hexagon/include/asm/cacheflush.h

76

memcpy(dst, src, len)

arch/hexagon/mm/cache.c

119

unsigned long vaddr, void *dst, void *src, int len)

arch/hexagon/mm/cache.c

121

memcpy(dst, src, len);

arch/hexagon/mm/cache.c

123

flush_icache_range((unsigned long) dst,

arch/hexagon/mm/cache.c

124

(unsigned long) dst + len);

arch/loongarch/include/asm/asmmacro.h

658

.macro not dst src

arch/loongarch/include/asm/inst.h

509

int larch_insn_text_copy(void *dst, void *src, size_t len);

arch/loongarch/include/asm/string.h

30

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/loongarch/include/asm/string.h

31

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/loongarch/include/asm/uaccess.h

250

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/loongarch/include/asm/uaccess.h

254

__get_kernel_common(*((type *)(dst)), sizeof(type), \

arch/loongarch/include/asm/uaccess.h

265

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/loongarch/include/asm/uaccess.h

271

__put_kernel_common(((type *)(dst)), sizeof(type)); \

arch/loongarch/kernel/inst.c

236

void *dst;

arch/loongarch/kernel/inst.c

248

ret = copy_to_kernel_nofault(copy->dst, copy->src, copy->len);

arch/loongarch/kernel/inst.c

255

flush_icache_range((unsigned long)copy->dst, (unsigned long)copy->dst + copy->len);

arch/loongarch/kernel/inst.c

260

int larch_insn_text_copy(void *dst, void *src, size_t len)

arch/loongarch/kernel/inst.c

266

.dst = dst,

arch/loongarch/kernel/inst.c

278

start = round_down((size_t)dst, PAGE_SIZE);

arch/loongarch/kernel/inst.c

279

end = round_up((size_t)dst + len, PAGE_SIZE);

arch/loongarch/kernel/process.c

111

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/loongarch/kernel/process.c

134

memcpy(dst, src, sizeof(struct task_struct));

arch/loongarch/kernel/process.c

139

memcpy(dst, src, offsetof(struct task_struct, thread.fpu.fpr));

arch/loongarch/kernel/process.c

141

memcpy(dst, src, offsetof(struct task_struct, thread.lbt.scr0));

arch/loongarch/kernel/process.c

144

memcpy(&dst->thread.lbt, &src->thread.lbt, sizeof(struct loongarch_lbt));

arch/loongarch/kernel/uprobes.c

139

void *dst = kaddr + (vaddr & ~PAGE_MASK);

arch/loongarch/kernel/uprobes.c

141

memcpy(dst, src, len);

arch/loongarch/kernel/uprobes.c

142

flush_icache_range((unsigned long)dst, (unsigned long)dst + len);

arch/loongarch/lib/csum.c

125

__uint128_t src, dst;

arch/loongarch/lib/csum.c

129

dst = *(const __uint128_t *)daddr->s6_addr;

arch/loongarch/lib/csum.c

134

dst += (dst >> 64) | (dst << 64);

arch/loongarch/lib/csum.c

137

sum = accumulate(sum, dst >> 64);

arch/loongarch/net/bpf_jit.c

1046

move_addr(ctx, dst, imm64);

arch/loongarch/net/bpf_jit.c

1048

move_imm(ctx, dst, imm64, is32);

arch/loongarch/net/bpf_jit.c

1085

emit_insn(ctx, ldb, dst, src, off);

arch/loongarch/net/bpf_jit.c

1087

emit_insn(ctx, ldbu, dst, src, off);

arch/loongarch/net/bpf_jit.c

1091

emit_insn(ctx, ldxb, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1093

emit_insn(ctx, ldxbu, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1099

emit_insn(ctx, ldh, dst, src, off);

arch/loongarch/net/bpf_jit.c

1101

emit_insn(ctx, ldhu, dst, src, off);

arch/loongarch/net/bpf_jit.c

1105

emit_insn(ctx, ldxh, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1107

emit_insn(ctx, ldxhu, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1113

emit_insn(ctx, ldw, dst, src, off);

arch/loongarch/net/bpf_jit.c

1115

emit_insn(ctx, ldwu, dst, src, off);

arch/loongarch/net/bpf_jit.c

1119

emit_insn(ctx, ldxw, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1121

emit_insn(ctx, ldxwu, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1126

emit_insn(ctx, ldxd, dst, src, t1);

arch/loongarch/net/bpf_jit.c

1130

ret = add_exception_handler(insn, ctx, dst);

arch/loongarch/net/bpf_jit.c

1146

emit_insn(ctx, addd, t3, dst, REG_ARENA);

arch/loongarch/net/bpf_jit.c

1147

dst = t3;

arch/loongarch/net/bpf_jit.c

1154

emit_insn(ctx, stb, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1157

emit_insn(ctx, stxb, t1, dst, t2);

arch/loongarch/net/bpf_jit.c

1163

emit_insn(ctx, sth, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1166

emit_insn(ctx, stxh, t1, dst, t2);

arch/loongarch/net/bpf_jit.c

1172

emit_insn(ctx, stw, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1174

emit_insn(ctx, stptrw, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1177

emit_insn(ctx, stxw, t1, dst, t2);

arch/loongarch/net/bpf_jit.c

1183

emit_insn(ctx, std, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1185

emit_insn(ctx, stptrd, t1, dst, off);

arch/loongarch/net/bpf_jit.c

1188

emit_insn(ctx, stxd, t1, dst, t2);

arch/loongarch/net/bpf_jit.c

1209

emit_insn(ctx, addd, t2, dst, REG_ARENA);

arch/loongarch/net/bpf_jit.c

1210

dst = t2;

arch/loongarch/net/bpf_jit.c

1216

emit_insn(ctx, stb, src, dst, off);

arch/loongarch/net/bpf_jit.c

1219

emit_insn(ctx, stxb, src, dst, t1);

arch/loongarch/net/bpf_jit.c

1224

emit_insn(ctx, sth, src, dst, off);

arch/loongarch/net/bpf_jit.c

1227

emit_insn(ctx, stxh, src, dst, t1);

arch/loongarch/net/bpf_jit.c

1232

emit_insn(ctx, stw, src, dst, off);

arch/loongarch/net/bpf_jit.c

1234

emit_insn(ctx, stptrw, src, dst, off);

arch/loongarch/net/bpf_jit.c

1237

emit_insn(ctx, stxw, src, dst, t1);

arch/loongarch/net/bpf_jit.c

1242

emit_insn(ctx, std, src, dst, off);

arch/loongarch/net/bpf_jit.c

1244

emit_insn(ctx, stptrd, src, dst, off);

arch/loongarch/net/bpf_jit.c

1247

emit_insn(ctx, stxd, src, dst, t1);

arch/loongarch/net/bpf_jit.c

1378

void *bpf_arch_text_copy(void *dst, void *src, size_t len)

arch/loongarch/net/bpf_jit.c

1384

ret = larch_insn_text_copy(dst, src, len);

arch/loongarch/net/bpf_jit.c

1388

return ret ? ERR_PTR(-EINVAL) : dst;

arch/loongarch/net/bpf_jit.c

1444

int bpf_arch_text_invalidate(void *dst, size_t len)

arch/loongarch/net/bpf_jit.c

1459

if (larch_insn_text_copy(dst, inst, len))

arch/loongarch/net/bpf_jit.c

354

const u8 dst = regmap[insn->dst_reg];

arch/loongarch/net/bpf_jit.c

360

emit_insn(ctx, addd, t1, dst, t1);

arch/loongarch/net/bpf_jit.c

553

u8 dst = regmap[insn->dst_reg];

arch/loongarch/net/bpf_jit.c

565

move_imm(ctx, dst, (ctx->user_vm_start >> 32) << 32, false);

arch/loongarch/net/bpf_jit.c

567

emit_insn(ctx, or, t1, dst, t1);

arch/loongarch/net/bpf_jit.c

568

move_reg(ctx, dst, t1);

arch/loongarch/net/bpf_jit.c

573

move_reg(ctx, dst, src);

arch/loongarch/net/bpf_jit.c

574

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

577

emit_insn(ctx, extwb, dst, src);

arch/loongarch/net/bpf_jit.c

578

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

581

emit_insn(ctx, extwh, dst, src);

arch/loongarch/net/bpf_jit.c

582

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

585

emit_insn(ctx, addw, dst, src, LOONGARCH_GPR_ZERO);

arch/loongarch/net/bpf_jit.c

593

move_imm(ctx, dst, imm, is32);

arch/loongarch/net/bpf_jit.c

599

emit_insn(ctx, addd, dst, dst, src);

arch/loongarch/net/bpf_jit.c

600

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

607

emit_insn(ctx, addid, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

610

emit_insn(ctx, addd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

612

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

618

emit_insn(ctx, subd, dst, dst, src);

arch/loongarch/net/bpf_jit.c

619

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

626

emit_insn(ctx, addid, dst, dst, -imm);

arch/loongarch/net/bpf_jit.c

629

emit_insn(ctx, subd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

631

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

637

emit_insn(ctx, muld, dst, dst, src);

arch/loongarch/net/bpf_jit.c

638

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

645

emit_insn(ctx, muld, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

646

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

653

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

656

emit_insn(ctx, divdu, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

657

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

659

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

662

emit_insn(ctx, divd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

663

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

672

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

673

emit_insn(ctx, divdu, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

674

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

678

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

679

emit_insn(ctx, divd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

680

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

688

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

691

emit_insn(ctx, moddu, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

692

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

694

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

697

emit_insn(ctx, modd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

698

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

707

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

708

emit_insn(ctx, moddu, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

709

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

713

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

714

emit_insn(ctx, modd, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

715

emit_sext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

723

emit_insn(ctx, subd, dst, LOONGARCH_GPR_ZERO, dst);

arch/loongarch/net/bpf_jit.c

724

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

730

emit_insn(ctx, and, dst, dst, src);

arch/loongarch/net/bpf_jit.c

731

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

738

emit_insn(ctx, andi, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

741

emit_insn(ctx, and, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

743

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

749

emit_insn(ctx, or, dst, dst, src);

arch/loongarch/net/bpf_jit.c

750

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

757

emit_insn(ctx, ori, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

760

emit_insn(ctx, or, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

762

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

768

emit_insn(ctx, xor, dst, dst, src);

arch/loongarch/net/bpf_jit.c

769

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

776

emit_insn(ctx, xori, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

779

emit_insn(ctx, xor, dst, dst, t1);

arch/loongarch/net/bpf_jit.c

781

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

786

emit_insn(ctx, sllw, dst, dst, src);

arch/loongarch/net/bpf_jit.c

787

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

791

emit_insn(ctx, slld, dst, dst, src);

arch/loongarch/net/bpf_jit.c

796

emit_insn(ctx, slliw, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

797

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

801

emit_insn(ctx, sllid, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

806

emit_insn(ctx, srlw, dst, dst, src);

arch/loongarch/net/bpf_jit.c

807

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

811

emit_insn(ctx, srld, dst, dst, src);

arch/loongarch/net/bpf_jit.c

816

emit_insn(ctx, srliw, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

817

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

821

emit_insn(ctx, srlid, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

826

emit_insn(ctx, sraw, dst, dst, src);

arch/loongarch/net/bpf_jit.c

827

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

831

emit_insn(ctx, srad, dst, dst, src);

arch/loongarch/net/bpf_jit.c

836

emit_insn(ctx, sraiw, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

837

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

841

emit_insn(ctx, sraid, dst, dst, imm);

arch/loongarch/net/bpf_jit.c

849

emit_insn(ctx, bstrpickd, dst, dst, 15, 0);

arch/loongarch/net/bpf_jit.c

853

emit_zext_32(ctx, dst, is32);

arch/loongarch/net/bpf_jit.c

865

emit_insn(ctx, revb2h, dst, dst);

arch/loongarch/net/bpf_jit.c

867

emit_insn(ctx, bstrpickd, dst, dst, 15, 0);

arch/loongarch/net/bpf_jit.c

870

emit_insn(ctx, revb2w, dst, dst);

arch/loongarch/net/bpf_jit.c

872

emit_zext_32(ctx, dst, true);

arch/loongarch/net/bpf_jit.c

875

emit_insn(ctx, revbd, dst, dst);

arch/loongarch/net/bpf_jit.c

902

move_reg(ctx, t1, dst);

arch/loongarch/net/bpf_jit.c

944

move_reg(ctx, t2, dst);

arch/loongarch/net/bpf_jit.c

960

emit_insn(ctx, and, t1, dst, src);

arch/loongarch/net/bpf_jit.c

971

emit_insn(ctx, and, t1, dst, t1);

arch/m68k/include/asm/cacheflush_mm.h

274

void *dst, void *src, int len)

arch/m68k/include/asm/cacheflush_mm.h

277

memcpy(dst, src, len);

arch/m68k/include/asm/cacheflush_mm.h

282

void *dst, void *src, int len)

arch/m68k/include/asm/cacheflush_mm.h

285

memcpy(dst, src, len);

arch/m68k/include/asm/checksum.h

36

void *dst,

arch/m68k/include/asm/checksum.h

40

void *dst, int len);

arch/m68k/include/asm/kmap.h

43

static inline void memcpy_fromio(void *dst, const volatile void __iomem *src,

arch/m68k/include/asm/kmap.h

46

__builtin_memcpy(dst, (void __force *) src, count);

arch/m68k/include/asm/kmap.h

50

static inline void memcpy_toio(volatile void __iomem *dst, const void *src,

arch/m68k/include/asm/kmap.h

53

__builtin_memcpy((void __force *) dst, src, count);

arch/m68k/include/asm/uaccess.h

383

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/m68k/include/asm/uaccess.h

385

type *__gk_dst = (type *)(dst); \

arch/m68k/include/asm/uaccess.h

412

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/m68k/include/asm/uaccess.h

415

type *__pk_dst = (type *)(dst); \

arch/m68k/include/asm/uaccess.h

441

extern long strncpy_from_user(char *dst, const char __user *src, long count);

arch/m68k/lib/checksum.c

132

csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/m68k/lib/checksum.c

260

: "=d" (sum), "=d" (len), "=a" (src), "=a" (dst),

arch/m68k/lib/checksum.c

262

: "0" (sum), "1" (len), "2" (src), "3" (dst)

arch/m68k/lib/checksum.c

274

csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/m68k/lib/checksum.c

363

: "=d" (sum), "=d" (len), "=a" (src), "=a" (dst),

arch/m68k/lib/checksum.c

365

: "0" (sum), "1" (len), "2" (src), "3" (dst)

arch/microblaze/include/asm/cacheflush.h

90

void *dst, void *src, int len)

arch/microblaze/include/asm/cacheflush.h

92

u32 addr = virt_to_phys(dst);

arch/microblaze/include/asm/cacheflush.h

93

memcpy(dst, src, len);

arch/microblaze/include/asm/uaccess.h

259

__must_check long strncpy_from_user(char *dst, const char __user *src,

arch/microblaze/kernel/setup.c

167

dst = (unsigned long *) (offset * sizeof(u32));

arch/microblaze/kernel/setup.c

168

for (src = __ivt_start + offset; src < __ivt_end; src++, dst++)

arch/microblaze/kernel/setup.c

169

*dst = *src;

arch/microblaze/kernel/setup.c

92

unsigned long *src, *dst;

arch/microblaze/lib/memcpy.c

160

dst = (void *)i_dst;

arch/microblaze/lib/memcpy.c

167

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

170

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

173

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

38

char *dst = v_dst;

arch/microblaze/lib/memcpy.c

54

switch ((unsigned long)dst & 3) {

arch/microblaze/lib/memcpy.c

56

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

60

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

64

*dst++ = *src++;

arch/microblaze/lib/memcpy.c

68

i_dst = (void *)dst;

arch/microblaze/lib/memmove.c

174

dst = (void *)i_dst;

arch/microblaze/lib/memmove.c

181

*--dst = *--src;

arch/microblaze/lib/memmove.c

184

*--dst = *--src;

arch/microblaze/lib/memmove.c

187

*--dst = *--src;

arch/microblaze/lib/memmove.c

190

*--dst = *--src;

arch/microblaze/lib/memmove.c

37

char *dst = v_dst;

arch/microblaze/lib/memmove.c

56

dst += c;

arch/microblaze/lib/memmove.c

65

switch ((unsigned long)dst & 3) {

arch/microblaze/lib/memmove.c

67

*--dst = *--src;

arch/microblaze/lib/memmove.c

71

*--dst = *--src;

arch/microblaze/lib/memmove.c

75

*--dst = *--src;

arch/microblaze/lib/memmove.c

79

i_dst = (void *)dst;

arch/mips/include/asm/cacheflush.h

114

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/mips/include/asm/cacheflush.h

118

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/mips/include/asm/checksum.h

37

__wsum __csum_partial_copy_from_user(const void __user *src, void *dst, int len);

arch/mips/include/asm/checksum.h

38

__wsum __csum_partial_copy_to_user(const void *src, void __user *dst, int len);

arch/mips/include/asm/checksum.h

42

__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/mips/include/asm/checksum.h

47

return __csum_partial_copy_from_user(src, dst, len);

arch/mips/include/asm/checksum.h

55

__wsum csum_and_copy_to_user(const void *src, void __user *dst, int len)

arch/mips/include/asm/checksum.h

58

if (!access_ok(dst, len))

arch/mips/include/asm/checksum.h

60

return __csum_partial_copy_to_user(src, dst, len);

arch/mips/include/asm/checksum.h

68

__wsum __csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/mips/include/asm/checksum.h

69

static inline __wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/mips/include/asm/checksum.h

71

return __csum_partial_copy_nocheck(src, dst, len);

arch/mips/include/asm/ftrace.h

22

#define safe_load(load, src, dst, error) \

arch/mips/include/asm/ftrace.h

38

: [tmp_dst] "=&r" (dst), [tmp_err] "=r" (error)\

arch/mips/include/asm/ftrace.h

44

#define safe_store(store, src, dst, error) \

arch/mips/include/asm/ftrace.h

61

: [tmp_dst] "r" (dst), [tmp_src] "r" (src)\

arch/mips/include/asm/ftrace.h

66

#define safe_load_code(dst, src, error) \

arch/mips/include/asm/ftrace.h

67

safe_load(STR(lw), src, dst, error)

arch/mips/include/asm/ftrace.h

68

#define safe_store_code(src, dst, error) \

arch/mips/include/asm/ftrace.h

69

safe_store(STR(sw), src, dst, error)

arch/mips/include/asm/ftrace.h

71

#define safe_load_stack(dst, src, error) \

arch/mips/include/asm/ftrace.h

72

safe_load(STR(PTR_L), src, dst, error)

arch/mips/include/asm/ftrace.h

74

#define safe_store_stack(src, dst, error) \

arch/mips/include/asm/ftrace.h

75

safe_store(STR(PTR_S), src, dst, error)

arch/mips/include/asm/mach-loongson2ef/loongson.h

312

#define LOONGSON_ADDRWIN_CFG(s, d, w, src, dst, size) do {\

arch/mips/include/asm/mach-loongson2ef/loongson.h

314

s##_WIN##w##_MMAP = (dst) | ADDRWIN_MAP_DST_##d; \

arch/mips/include/asm/mach-loongson2ef/loongson.h

318

#define LOONGSON_ADDRWIN_CPUTOPCI(win, src, dst, size) \

arch/mips/include/asm/mach-loongson2ef/loongson.h

319

LOONGSON_ADDRWIN_CFG(CPU, PCI, win, src, dst, size)

arch/mips/include/asm/mach-loongson2ef/loongson.h

320

#define LOONGSON_ADDRWIN_CPUTODDR(win, src, dst, size) \

arch/mips/include/asm/mach-loongson2ef/loongson.h

321

LOONGSON_ADDRWIN_CFG(CPU, DDR, win, src, dst, size)

arch/mips/include/asm/mach-loongson2ef/loongson.h

322

#define LOONGSON_ADDRWIN_PCITODDR(win, src, dst, size) \

arch/mips/include/asm/mach-loongson2ef/loongson.h

323

LOONGSON_ADDRWIN_CFG(PCIDMA, DDR, win, src, dst, size)

arch/mips/include/asm/octeon/cvmx-iob-defs.h

402

uint64_t dst:9;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

406

uint64_t dst:9;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

421

uint64_t dst:9;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

425

uint64_t dst:9;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

597

uint64_t dst:8;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

601

uint64_t dst:8;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

616

uint64_t dst:8;

arch/mips/include/asm/octeon/cvmx-iob-defs.h

620

uint64_t dst:8;

arch/mips/include/asm/octeon/cvmx-pip-defs.h

2536

uint64_t dst:16;

arch/mips/include/asm/octeon/cvmx-pip-defs.h

2540

uint64_t dst:16;

arch/mips/include/asm/processor.h

32

extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);

arch/mips/include/asm/uaccess.h

258

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/mips/include/asm/uaccess.h

264

__get_data_asm(*(type *)(dst), kernel_lb, \

arch/mips/include/asm/uaccess.h

268

__get_data_asm(*(type *)(dst), kernel_lh, \

arch/mips/include/asm/uaccess.h

272

__get_data_asm(*(type *)(dst), kernel_lw, \

arch/mips/include/asm/uaccess.h

276

__GET_DW(*(type *)(dst), kernel_ld, \

arch/mips/include/asm/uaccess.h

336

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/mips/include/asm/uaccess.h

344

__put_data_asm(kernel_sb, (type *)(dst)); \

arch/mips/include/asm/uaccess.h

347

__put_data_asm(kernel_sh, (type *)(dst)); \

arch/mips/include/asm/uaccess.h

350

__put_data_asm(kernel_sw, (type *)(dst)) \

arch/mips/include/asm/uaccess.h

353

__PUT_DW(kernel_sd, (type *)(dst)); \

arch/mips/kernel/process.c

101

*dst = *src;

arch/mips/kernel/process.c

81

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/mips/kernel/smp-bmips.c

467

static void bmips_wr_vec(unsigned long dst, char *start, char *end)

arch/mips/kernel/smp-bmips.c

469

memcpy((void *)dst, start, end - start);

arch/mips/kernel/smp-bmips.c

470

dma_cache_wback(dst, end - start);

arch/mips/kernel/smp-bmips.c

471

local_flush_icache_range(dst, dst + (end - start));

arch/mips/lib/iomap_copy.c

19

u64 *dst = to;

arch/mips/lib/iomap_copy.c

24

*dst++ = __raw_readq(src++);

arch/mips/mm/init.c

189

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/mips/mm/init.c

200

memcpy(dst, src, len);

arch/mips/mm/init.c

209

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/mips/mm/init.c

217

memcpy(dst, vfrom, len);

arch/mips/mm/init.c

220

memcpy(dst, src, len);

arch/mips/net/bpf_jit_comp.c

192

void emit_mov_i(struct jit_context *ctx, u8 dst, s32 imm)

arch/mips/net/bpf_jit_comp.c

195

emit(ctx, addiu, dst, MIPS_R_ZERO, imm);

arch/mips/net/bpf_jit_comp.c

197

emit(ctx, lui, dst, (s16)((u32)imm >> 16));

arch/mips/net/bpf_jit_comp.c

198

emit(ctx, ori, dst, dst, (u16)(imm & 0xffff));

arch/mips/net/bpf_jit_comp.c

200

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp.c

204

void emit_mov_r(struct jit_context *ctx, u8 dst, u8 src)

arch/mips/net/bpf_jit_comp.c

206

emit(ctx, ori, dst, src, 0);

arch/mips/net/bpf_jit_comp.c

207

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp.c

298

void emit_alu_i(struct jit_context *ctx, u8 dst, s32 imm, u8 op)

arch/mips/net/bpf_jit_comp.c

303

emit(ctx, subu, dst, MIPS_R_ZERO, dst);

arch/mips/net/bpf_jit_comp.c

307

emit(ctx, andi, dst, dst, (u16)imm);

arch/mips/net/bpf_jit_comp.c

311

emit(ctx, ori, dst, dst, (u16)imm);

arch/mips/net/bpf_jit_comp.c

315

emit(ctx, xori, dst, dst, (u16)imm);

arch/mips/net/bpf_jit_comp.c

319

emit(ctx, sll, dst, dst, imm);

arch/mips/net/bpf_jit_comp.c

323

emit(ctx, srl, dst, dst, imm);

arch/mips/net/bpf_jit_comp.c

327

emit(ctx, sra, dst, dst, imm);

arch/mips/net/bpf_jit_comp.c

331

emit(ctx, addiu, dst, dst, imm);

arch/mips/net/bpf_jit_comp.c

335

emit(ctx, addiu, dst, dst, -imm);

arch/mips/net/bpf_jit_comp.c

338

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp.c

342

void emit_alu_r(struct jit_context *ctx, u8 dst, u8 src, u8 op)

arch/mips/net/bpf_jit_comp.c

347

emit(ctx, and, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

351

emit(ctx, or, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

355

emit(ctx, xor, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

359

emit(ctx, sllv, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

363

emit(ctx, srlv, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

367

emit(ctx, srav, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

371

emit(ctx, addu, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

375

emit(ctx, subu, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

380

emit(ctx, mul, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

382

emit(ctx, multu, dst, src);

arch/mips/net/bpf_jit_comp.c

383

emit(ctx, mflo, dst);

arch/mips/net/bpf_jit_comp.c

389

emit(ctx, divu_r6, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

391

emit(ctx, divu, dst, src);

arch/mips/net/bpf_jit_comp.c

392

emit(ctx, mflo, dst);

arch/mips/net/bpf_jit_comp.c

398

emit(ctx, modu, dst, dst, src);

arch/mips/net/bpf_jit_comp.c

400

emit(ctx, divu, dst, src);

arch/mips/net/bpf_jit_comp.c

401

emit(ctx, mfhi, dst);

arch/mips/net/bpf_jit_comp.c

405

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp.c

409

void emit_atomic_r(struct jit_context *ctx, u8 dst, u8 src, s16 off, u8 code)

arch/mips/net/bpf_jit_comp.c

412

emit(ctx, ll, MIPS_R_T9, off, dst);

arch/mips/net/bpf_jit_comp.c

434

emit(ctx, sc, MIPS_R_T8, off, dst);

arch/mips/net/bpf_jit_comp.c

445

void emit_cmpxchg_r(struct jit_context *ctx, u8 dst, u8 src, u8 res, s16 off)

arch/mips/net/bpf_jit_comp.c

448

emit(ctx, ll, MIPS_R_T9, off, dst);

arch/mips/net/bpf_jit_comp.c

451

emit(ctx, sc, MIPS_R_T8, off, dst);

arch/mips/net/bpf_jit_comp.c

458

void emit_bswap_r(struct jit_context *ctx, u8 dst, u32 width)

arch/mips/net/bpf_jit_comp.c

467

emit(ctx, wsbh, dst, dst);

arch/mips/net/bpf_jit_comp.c

468

emit(ctx, rotr, dst, dst, 16);

arch/mips/net/bpf_jit_comp.c

470

emit(ctx, sll, tmp, dst, 16); /* tmp = dst << 16 */

arch/mips/net/bpf_jit_comp.c

471

emit(ctx, srl, dst, dst, 16); /* dst = dst >> 16 */

arch/mips/net/bpf_jit_comp.c

472

emit(ctx, or, dst, dst, tmp); /* dst = dst | tmp */

arch/mips/net/bpf_jit_comp.c

477

emit(ctx, and, tmp, dst, msk); /* tmp = dst & msk */

arch/mips/net/bpf_jit_comp.c

479

emit(ctx, srl, dst, dst, 8); /* dst = dst >> 8 */

arch/mips/net/bpf_jit_comp.c

480

emit(ctx, and, dst, dst, msk); /* dst = dst & msk */

arch/mips/net/bpf_jit_comp.c

481

emit(ctx, or, dst, dst, tmp); /* reg = dst | tmp */

arch/mips/net/bpf_jit_comp.c

487

emit(ctx, wsbh, dst, dst);

arch/mips/net/bpf_jit_comp.c

488

emit(ctx, andi, dst, dst, 0xffff);

arch/mips/net/bpf_jit_comp.c

490

emit(ctx, andi, tmp, dst, 0xff00); /* t = d & 0xff00 */

arch/mips/net/bpf_jit_comp.c

492

emit(ctx, andi, dst, dst, 0x00ff); /* d = d & 0x00ff */

arch/mips/net/bpf_jit_comp.c

493

emit(ctx, sll, dst, dst, 8); /* d = d << 8 */

arch/mips/net/bpf_jit_comp.c

494

emit(ctx, or, dst, dst, tmp); /* d = d | t */

arch/mips/net/bpf_jit_comp.c

498

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp.c

698

void emit_jmp_i(struct jit_context *ctx, u8 dst, s32 imm, s32 off, u8 op)

arch/mips/net/bpf_jit_comp.c

706

emit(ctx, andi, MIPS_R_T9, dst, (u16)imm);

arch/mips/net/bpf_jit_comp.c

711

emit(ctx, andi, MIPS_R_T9, dst, (u16)imm);

arch/mips/net/bpf_jit_comp.c

716

emit(ctx, sltiu, MIPS_R_T9, dst, imm + 1);

arch/mips/net/bpf_jit_comp.c

721

emit(ctx, sltiu, MIPS_R_T9, dst, imm);

arch/mips/net/bpf_jit_comp.c

726

emit(ctx, sltiu, MIPS_R_T9, dst, imm);

arch/mips/net/bpf_jit_comp.c

731

emit(ctx, sltiu, MIPS_R_T9, dst, imm + 1);

arch/mips/net/bpf_jit_comp.c

736

emit(ctx, slti, MIPS_R_T9, dst, imm + 1);

arch/mips/net/bpf_jit_comp.c

741

emit(ctx, slti, MIPS_R_T9, dst, imm);

arch/mips/net/bpf_jit_comp.c

746

emit(ctx, slti, MIPS_R_T9, dst, imm);

arch/mips/net/bpf_jit_comp.c

751

emit(ctx, slti, MIPS_R_T9, dst, imm + 1);

arch/mips/net/bpf_jit_comp.c

758

void emit_jmp_r(struct jit_context *ctx, u8 dst, u8 src, s32 off, u8 op)

arch/mips/net/bpf_jit_comp.c

766

emit(ctx, beq, dst, src, off);

arch/mips/net/bpf_jit_comp.c

770

emit(ctx, bne, dst, src, off);

arch/mips/net/bpf_jit_comp.c

774

emit(ctx, and, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

779

emit(ctx, and, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

784

emit(ctx, sltu, MIPS_R_T9, src, dst);

arch/mips/net/bpf_jit_comp.c

789

emit(ctx, sltu, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

794

emit(ctx, sltu, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

799

emit(ctx, sltu, MIPS_R_T9, src, dst);

arch/mips/net/bpf_jit_comp.c

804

emit(ctx, slt, MIPS_R_T9, src, dst);

arch/mips/net/bpf_jit_comp.c

809

emit(ctx, slt, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

814

emit(ctx, slt, MIPS_R_T9, dst, src);

arch/mips/net/bpf_jit_comp.c

819

emit(ctx, slt, MIPS_R_T9, src, dst);

arch/mips/net/bpf_jit_comp.h

160

void emit_mov_i(struct jit_context *ctx, u8 dst, s32 imm);

arch/mips/net/bpf_jit_comp.h

163

void emit_mov_r(struct jit_context *ctx, u8 dst, u8 src);

arch/mips/net/bpf_jit_comp.h

172

void emit_alu_i(struct jit_context *ctx, u8 dst, s32 imm, u8 op);

arch/mips/net/bpf_jit_comp.h

175

void emit_alu_r(struct jit_context *ctx, u8 dst, u8 src, u8 op);

arch/mips/net/bpf_jit_comp.h

178

void emit_atomic_r(struct jit_context *ctx, u8 dst, u8 src, s16 off, u8 code);

arch/mips/net/bpf_jit_comp.h

181

void emit_cmpxchg_r(struct jit_context *ctx, u8 dst, u8 src, u8 res, s16 off);

arch/mips/net/bpf_jit_comp.h

184

void emit_bswap_r(struct jit_context *ctx, u8 dst, u32 width);

arch/mips/net/bpf_jit_comp.h

201

void emit_jmp_i(struct jit_context *ctx, u8 dst, s32 imm, s32 off, u8 op);

arch/mips/net/bpf_jit_comp.h

204

void emit_jmp_r(struct jit_context *ctx, u8 dst, u8 src, s32 off, u8 op);

arch/mips/net/bpf_jit_comp32.c

1093

const u8 dst[], s32 imm, s32 off, u8 op)

arch/mips/net/bpf_jit_comp32.c

1106

emit(ctx, addiu, tmp, lo(dst), -imm);

arch/mips/net/bpf_jit_comp32.c

1108

emit(ctx, xori, tmp, lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

1111

emit(ctx, xor, tmp, lo(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

1114

emit(ctx, addu, MIPS_R_T9, hi(dst), 1);

arch/mips/net/bpf_jit_comp32.c

1117

emit(ctx, or, tmp, tmp, hi(dst));

arch/mips/net/bpf_jit_comp32.c

1129

emit(ctx, andi, tmp, lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

1132

emit(ctx, and, tmp, lo(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

1135

emit(ctx, or, tmp, tmp, hi(dst));

arch/mips/net/bpf_jit_comp32.c

1143

emit_sltiu_r64(ctx, tmp, dst, (s64)imm + 1);

arch/mips/net/bpf_jit_comp32.c

1148

emit_sltiu_r64(ctx, tmp, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1153

emit_sltiu_r64(ctx, tmp, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1158

emit_sltiu_r64(ctx, tmp, dst, (s64)imm + 1);

arch/mips/net/bpf_jit_comp32.c

1163

emit_slti_r64(ctx, tmp, dst, (s64)imm + 1);

arch/mips/net/bpf_jit_comp32.c

1168

emit_slti_r64(ctx, tmp, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1173

emit_slti_r64(ctx, tmp, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1178

emit_slti_r64(ctx, tmp, dst, (s64)imm + 1);

arch/mips/net/bpf_jit_comp32.c

1186

const u8 dst[], const u8 src[], s32 off, u8 op)

arch/mips/net/bpf_jit_comp32.c

1199

emit(ctx, subu, t1, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

1200

emit(ctx, subu, t2, hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

1211

emit(ctx, and, t1, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

1212

emit(ctx, and, t2, hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

1221

emit_sltu_r64(ctx, t1, src, dst);

arch/mips/net/bpf_jit_comp32.c

1226

emit_sltu_r64(ctx, t1, dst, src);

arch/mips/net/bpf_jit_comp32.c

1231

emit_sltu_r64(ctx, t1, dst, src);

arch/mips/net/bpf_jit_comp32.c

1236

emit_sltu_r64(ctx, t1, src, dst);

arch/mips/net/bpf_jit_comp32.c

1241

emit_slt_r64(ctx, t1, src, dst);

arch/mips/net/bpf_jit_comp32.c

1246

emit_slt_r64(ctx, t1, dst, src);

arch/mips/net/bpf_jit_comp32.c

1251

emit_slt_r64(ctx, t1, dst, src);

arch/mips/net/bpf_jit_comp32.c

1256

emit_slt_r64(ctx, t1, src, dst);

arch/mips/net/bpf_jit_comp32.c

1465

const u8 *dst = bpf2mips32[insn->dst_reg];

arch/mips/net/bpf_jit_comp32.c

1479

emit_mov_i(ctx, lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

1480

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1486

emit_mov_i(ctx, hi(dst), 0);

arch/mips/net/bpf_jit_comp32.c

1488

emit_mov_r(ctx, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

1489

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1494

emit_alu_i(ctx, lo(dst), 0, BPF_NEG);

arch/mips/net/bpf_jit_comp32.c

1495

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1521

emit_alu_r(ctx, lo(dst), MIPS_R_T6, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1523

emit_alu_i(ctx, lo(dst), val, alu);

arch/mips/net/bpf_jit_comp32.c

1525

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1549

emit_alu_r(ctx, lo(dst), lo(src), BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1550

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1554

emit_mov_se_i64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1558

emit_mov_r(ctx, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

1559

emit_mov_r(ctx, hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

1563

emit_neg_i64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1567

emit_alu_i64(ctx, dst, imm, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1578

emit_alu_i64(ctx, dst, imm, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1587

emit_shift_i64(ctx, dst, imm, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1591

emit_mul_i64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1602

emit_divmod_r64(ctx, dst, tmp, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1614

emit_alu_r64(ctx, dst, src, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1622

emit_shift_r64(ctx, dst, lo(src), BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1626

emit_mul_r64(ctx, dst, src);

arch/mips/net/bpf_jit_comp32.c

1632

emit_divmod_r64(ctx, dst, src, BPF_OP(code));

arch/mips/net/bpf_jit_comp32.c

1645

emit_bswap_r64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1647

emit_trunc_r64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp32.c

1651

emit_mov_i(ctx, lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

1652

emit_mov_i(ctx, hi(dst), insn[1].imm);

arch/mips/net/bpf_jit_comp32.c

1659

emit_ldx(ctx, dst, lo(src), off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp32.c

1677

emit_stx(ctx, lo(dst), tmp, off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp32.c

1684

emit_stx(ctx, lo(dst), src, off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp32.c

1702

emit_atomic_r(ctx, lo(dst), lo(src), off, imm);

arch/mips/net/bpf_jit_comp32.c

1704

emit_atomic_r32(ctx, lo(dst), lo(src),

arch/mips/net/bpf_jit_comp32.c

1711

emit_cmpxchg_r(ctx, lo(dst), lo(src),

arch/mips/net/bpf_jit_comp32.c

1714

emit_cmpxchg_r32(ctx, lo(dst), lo(src), off);

arch/mips/net/bpf_jit_comp32.c

1733

emit_atomic_r64(ctx, lo(dst), src, off, imm);

arch/mips/net/bpf_jit_comp32.c

1736

emit_cmpxchg_r64(ctx, lo(dst), src, off);

arch/mips/net/bpf_jit_comp32.c

174

static void emit_mov_se_i64(struct jit_context *ctx, const u8 dst[], s32 imm)

arch/mips/net/bpf_jit_comp32.c

176

emit_mov_i(ctx, lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

1766

setup_jmp_r(ctx, dst == src, BPF_OP(code), off, &jmp, &rel);

arch/mips/net/bpf_jit_comp32.c

1767

emit_jmp_r(ctx, lo(dst), lo(src), rel, jmp);

arch/mips/net/bpf_jit_comp32.c

178

emit(ctx, addiu, hi(dst), MIPS_R_ZERO, -1);

arch/mips/net/bpf_jit_comp32.c

1797

emit_jmp_i(ctx, lo(dst), imm, rel, jmp);

arch/mips/net/bpf_jit_comp32.c

180

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

1801

emit_jmp_r(ctx, lo(dst), MIPS_R_T6, rel, jmp);

arch/mips/net/bpf_jit_comp32.c

181

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

1830

setup_jmp_r(ctx, dst == src, BPF_OP(code), off, &jmp, &rel);

arch/mips/net/bpf_jit_comp32.c

1831

emit_jmp_r64(ctx, dst, src, rel, jmp);

arch/mips/net/bpf_jit_comp32.c

185

static void emit_zext_ver(struct jit_context *ctx, const u8 dst[])

arch/mips/net/bpf_jit_comp32.c

1860

emit_jmp_i64(ctx, dst, imm, rel, jmp);

arch/mips/net/bpf_jit_comp32.c

188

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

189

clobber_reg(ctx, hi(dst));

arch/mips/net/bpf_jit_comp32.c

202

const u8 dst[], s32 imm, u8 op)

arch/mips/net/bpf_jit_comp32.c

228

emit(ctx, addu, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

229

emit(ctx, sltu, MIPS_R_T9, lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

230

emit(ctx, addu, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

232

emit(ctx, addiu, hi(dst), hi(dst), -1);

arch/mips/net/bpf_jit_comp32.c

236

emit(ctx, sltu, MIPS_R_T9, lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

237

emit(ctx, subu, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

238

emit(ctx, subu, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

240

emit(ctx, addiu, hi(dst), hi(dst), 1);

arch/mips/net/bpf_jit_comp32.c

244

emit(ctx, or, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

246

emit(ctx, addiu, hi(dst), MIPS_R_ZERO, -1);

arch/mips/net/bpf_jit_comp32.c

250

emit(ctx, and, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

252

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

256

emit(ctx, xor, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

258

emit(ctx, subu, hi(dst), MIPS_R_ZERO, hi(dst));

arch/mips/net/bpf_jit_comp32.c

259

emit(ctx, addiu, hi(dst), hi(dst), -1);

arch/mips/net/bpf_jit_comp32.c

263

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

268

const u8 dst[], const u8 src[], u8 op)

arch/mips/net/bpf_jit_comp32.c

273

if (src == dst) {

arch/mips/net/bpf_jit_comp32.c

274

emit(ctx, srl, MIPS_R_T9, lo(dst), 31);

arch/mips/net/bpf_jit_comp32.c

275

emit(ctx, addu, lo(dst), lo(dst), lo(dst));

arch/mips/net/bpf_jit_comp32.c

277

emit(ctx, addu, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

278

emit(ctx, sltu, MIPS_R_T9, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

280

emit(ctx, addu, hi(dst), hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

281

emit(ctx, addu, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

285

emit(ctx, sltu, MIPS_R_T9, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

286

emit(ctx, subu, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

287

emit(ctx, subu, hi(dst), hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

288

emit(ctx, subu, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

292

emit(ctx, or, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

293

emit(ctx, or, hi(dst), hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

297

emit(ctx, and, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

298

emit(ctx, and, hi(dst), hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

302

emit(ctx, xor, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

303

emit(ctx, xor, hi(dst), hi(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

306

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

310

static void emit_neg_i64(struct jit_context *ctx, const u8 dst[])

arch/mips/net/bpf_jit_comp32.c

312

emit(ctx, sltu, MIPS_R_T9, MIPS_R_ZERO, lo(dst));

arch/mips/net/bpf_jit_comp32.c

313

emit(ctx, subu, lo(dst), MIPS_R_ZERO, lo(dst));

arch/mips/net/bpf_jit_comp32.c

314

emit(ctx, subu, hi(dst), MIPS_R_ZERO, hi(dst));

arch/mips/net/bpf_jit_comp32.c

315

emit(ctx, subu, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

317

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

322

const u8 dst[], u32 imm, u8 op)

arch/mips/net/bpf_jit_comp32.c

328

emit(ctx, srl, MIPS_R_T9, lo(dst), 32 - imm);

arch/mips/net/bpf_jit_comp32.c

329

emit(ctx, sll, lo(dst), lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

330

emit(ctx, sll, hi(dst), hi(dst), imm);

arch/mips/net/bpf_jit_comp32.c

331

emit(ctx, or, hi(dst), hi(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

333

emit(ctx, sll, hi(dst), lo(dst), imm - 32);

arch/mips/net/bpf_jit_comp32.c

334

emit(ctx, move, lo(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

340

emit(ctx, sll, MIPS_R_T9, hi(dst), 32 - imm);

arch/mips/net/bpf_jit_comp32.c

341

emit(ctx, srl, lo(dst), lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

342

emit(ctx, srl, hi(dst), hi(dst), imm);

arch/mips/net/bpf_jit_comp32.c

343

emit(ctx, or, lo(dst), lo(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

345

emit(ctx, srl, lo(dst), hi(dst), imm - 32);

arch/mips/net/bpf_jit_comp32.c

346

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

352

emit(ctx, sll, MIPS_R_T9, hi(dst), 32 - imm);

arch/mips/net/bpf_jit_comp32.c

353

emit(ctx, srl, lo(dst), lo(dst), imm);

arch/mips/net/bpf_jit_comp32.c

354

emit(ctx, sra, hi(dst), hi(dst), imm);

arch/mips/net/bpf_jit_comp32.c

355

emit(ctx, or, lo(dst), lo(dst), MIPS_R_T9);

arch/mips/net/bpf_jit_comp32.c

357

emit(ctx, sra, lo(dst), hi(dst), imm - 32);

arch/mips/net/bpf_jit_comp32.c

358

emit(ctx, sra, hi(dst), hi(dst), 31);

arch/mips/net/bpf_jit_comp32.c

362

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

367

const u8 dst[], u8 src, u8 op)

arch/mips/net/bpf_jit_comp32.c

380

emit(ctx, sllv, hi(dst), lo(dst), src); /* dh = dl << src */

arch/mips/net/bpf_jit_comp32.c

381

emit(ctx, move, lo(dst), MIPS_R_ZERO); /* dl = 0 */

arch/mips/net/bpf_jit_comp32.c

384

emit(ctx, srl, t1, lo(dst), 1); /* t1 = dl >> 1 */

arch/mips/net/bpf_jit_comp32.c

386

emit(ctx, sllv, lo(dst), lo(dst), src); /* dl = dl << src */

arch/mips/net/bpf_jit_comp32.c

387

emit(ctx, sllv, hi(dst), hi(dst), src); /* dh = dh << src */

arch/mips/net/bpf_jit_comp32.c

388

emit(ctx, or, hi(dst), hi(dst), t1); /* dh = dh | t1 */

arch/mips/net/bpf_jit_comp32.c

393

emit(ctx, srlv, lo(dst), hi(dst), src); /* dl = dh >> src */

arch/mips/net/bpf_jit_comp32.c

394

emit(ctx, move, hi(dst), MIPS_R_ZERO); /* dh = 0 */

arch/mips/net/bpf_jit_comp32.c

397

emit(ctx, sll, t1, hi(dst), 1); /* t1 = dl << 1 */

arch/mips/net/bpf_jit_comp32.c

399

emit(ctx, srlv, lo(dst), lo(dst), src); /* dl = dl >> src */

arch/mips/net/bpf_jit_comp32.c

400

emit(ctx, srlv, hi(dst), hi(dst), src); /* dh = dh >> src */

arch/mips/net/bpf_jit_comp32.c

401

emit(ctx, or, lo(dst), lo(dst), t1); /* dl = dl | t1 */

arch/mips/net/bpf_jit_comp32.c

406

emit(ctx, srav, lo(dst), hi(dst), src); /* dl = dh >>a src */

arch/mips/net/bpf_jit_comp32.c

407

emit(ctx, sra, hi(dst), hi(dst), 31); /* dh = dh >>a 31 */

arch/mips/net/bpf_jit_comp32.c

410

emit(ctx, sll, t1, hi(dst), 1); /* t1 = dl << 1 */

arch/mips/net/bpf_jit_comp32.c

412

emit(ctx, srlv, lo(dst), lo(dst), src); /* dl = dl >>a src */

arch/mips/net/bpf_jit_comp32.c

413

emit(ctx, srav, hi(dst), hi(dst), src); /* dh = dh >> src */

arch/mips/net/bpf_jit_comp32.c

414

emit(ctx, or, lo(dst), lo(dst), t1); /* dl = dl | t1 */

arch/mips/net/bpf_jit_comp32.c

419

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

423

static void emit_mul_i64(struct jit_context *ctx, const u8 dst[], s32 imm)

arch/mips/net/bpf_jit_comp32.c

434

emit_neg_i64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

437

emit_mov_r(ctx, lo(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

438

emit_mov_r(ctx, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

445

emit(ctx, mul, hi(dst), hi(dst), src);

arch/mips/net/bpf_jit_comp32.c

447

emit(ctx, multu, hi(dst), src);

arch/mips/net/bpf_jit_comp32.c

448

emit(ctx, mflo, hi(dst));

arch/mips/net/bpf_jit_comp32.c

453

emit(ctx, subu, hi(dst), hi(dst), lo(dst));

arch/mips/net/bpf_jit_comp32.c

458

emit(ctx, muhu, tmp, lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

459

emit(ctx, mulu, lo(dst), lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

461

emit(ctx, multu, lo(dst), src);

arch/mips/net/bpf_jit_comp32.c

462

emit(ctx, mflo, lo(dst));

arch/mips/net/bpf_jit_comp32.c

467

emit(ctx, addu, hi(dst), hi(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

468

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

475

const u8 dst[], const u8 src[])

arch/mips/net/bpf_jit_comp32.c

482

emit(ctx, mul, acc, hi(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

484

emit(ctx, multu, hi(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

490

emit(ctx, mul, tmp, lo(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

492

emit(ctx, multu, lo(dst), hi(src));

arch/mips/net/bpf_jit_comp32.c

502

emit(ctx, muhu, tmp, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

503

emit(ctx, mulu, lo(dst), lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

505

emit(ctx, multu, lo(dst), lo(src));

arch/mips/net/bpf_jit_comp32.c

506

emit(ctx, mflo, lo(dst));

arch/mips/net/bpf_jit_comp32.c

511

emit(ctx, addu, hi(dst), acc, tmp);

arch/mips/net/bpf_jit_comp32.c

512

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

526

const u8 dst[], const u8 src[], u8 op)

arch/mips/net/bpf_jit_comp32.c

541

emit(ctx, move, r1[k], dst[k]);

arch/mips/net/bpf_jit_comp32.c

561

emit(ctx, move, dst[0], r0[0]);

arch/mips/net/bpf_jit_comp32.c

562

emit(ctx, move, dst[1], r0[1]);

arch/mips/net/bpf_jit_comp32.c

565

exclude = BIT(lo(dst)) | BIT(hi(dst));

arch/mips/net/bpf_jit_comp32.c

570

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

577

static void emit_swap8_r(struct jit_context *ctx, u8 dst, u8 src, u8 mask)

arch/mips/net/bpf_jit_comp32.c

583

emit(ctx, srl, dst, src, 8); /* dst = src >> 8 */

arch/mips/net/bpf_jit_comp32.c

584

emit(ctx, and, dst, dst, mask); /* dst = dst & 0x00ff00ff */

arch/mips/net/bpf_jit_comp32.c

585

emit(ctx, or, dst, dst, tmp); /* dst = dst | tmp */

arch/mips/net/bpf_jit_comp32.c

589

static void emit_swap16_r(struct jit_context *ctx, u8 dst, u8 src)

arch/mips/net/bpf_jit_comp32.c

594

emit(ctx, srl, dst, src, 16); /* dst = src >> 16 */

arch/mips/net/bpf_jit_comp32.c

595

emit(ctx, or, dst, dst, tmp); /* dst = dst | tmp */

arch/mips/net/bpf_jit_comp32.c

599

static void emit_bswap_r64(struct jit_context *ctx, const u8 dst[], u32 width)

arch/mips/net/bpf_jit_comp32.c

607

emit(ctx, rotr, tmp, hi(dst), 16);

arch/mips/net/bpf_jit_comp32.c

608

emit(ctx, rotr, hi(dst), lo(dst), 16);

arch/mips/net/bpf_jit_comp32.c

609

emit(ctx, wsbh, lo(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

610

emit(ctx, wsbh, hi(dst), hi(dst));

arch/mips/net/bpf_jit_comp32.c

612

emit_swap16_r(ctx, tmp, lo(dst));

arch/mips/net/bpf_jit_comp32.c

613

emit_swap16_r(ctx, lo(dst), hi(dst));

arch/mips/net/bpf_jit_comp32.c

614

emit(ctx, move, hi(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

618

emit_swap8_r(ctx, lo(dst), lo(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

619

emit_swap8_r(ctx, hi(dst), hi(dst), tmp);

arch/mips/net/bpf_jit_comp32.c

626

emit_bswap_r(ctx, lo(dst), width);

arch/mips/net/bpf_jit_comp32.c

627

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

630

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

634

static void emit_trunc_r64(struct jit_context *ctx, const u8 dst[], u32 width)

arch/mips/net/bpf_jit_comp32.c

641

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

642

clobber_reg(ctx, hi(dst));

arch/mips/net/bpf_jit_comp32.c

646

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

647

emit(ctx, andi, lo(dst), lo(dst), 0xffff);

arch/mips/net/bpf_jit_comp32.c

648

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

655

const u8 dst[], u8 src, s16 off, u8 size)

arch/mips/net/bpf_jit_comp32.c

660

emit(ctx, lbu, lo(dst), off, src);

arch/mips/net/bpf_jit_comp32.c

661

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

665

emit(ctx, lhu, lo(dst), off, src);

arch/mips/net/bpf_jit_comp32.c

666

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

670

emit(ctx, lw, lo(dst), off, src);

arch/mips/net/bpf_jit_comp32.c

671

emit(ctx, move, hi(dst), MIPS_R_ZERO);

arch/mips/net/bpf_jit_comp32.c

675

if (dst[1] == src) {

arch/mips/net/bpf_jit_comp32.c

676

emit(ctx, lw, dst[0], off + 4, src);

arch/mips/net/bpf_jit_comp32.c

677

emit(ctx, lw, dst[1], off, src);

arch/mips/net/bpf_jit_comp32.c

679

emit(ctx, lw, dst[1], off, src);

arch/mips/net/bpf_jit_comp32.c

680

emit(ctx, lw, dst[0], off + 4, src);

arch/mips/net/bpf_jit_comp32.c

685

clobber_reg64(ctx, dst);

arch/mips/net/bpf_jit_comp32.c

690

const u8 dst, const u8 src[], s16 off, u8 size)

arch/mips/net/bpf_jit_comp32.c

695

emit(ctx, sb, lo(src), off, dst);

arch/mips/net/bpf_jit_comp32.c

699

emit(ctx, sh, lo(src), off, dst);

arch/mips/net/bpf_jit_comp32.c

703

emit(ctx, sw, lo(src), off, dst);

arch/mips/net/bpf_jit_comp32.c

707

emit(ctx, sw, src[1], off, dst);

arch/mips/net/bpf_jit_comp32.c

708

emit(ctx, sw, src[0], off + 4, dst);

arch/mips/net/bpf_jit_comp32.c

715

u8 dst, u8 src, s16 off, u8 code)

arch/mips/net/bpf_jit_comp32.c

727

emit(ctx, move, MIPS_R_T9, dst);

arch/mips/net/bpf_jit_comp32.c

798

u8 dst, const u8 src[], s16 off, u8 code)

arch/mips/net/bpf_jit_comp32.c

812

emit(ctx, move, MIPS_R_T9, dst);

arch/mips/net/bpf_jit_comp32.c

873

static void emit_cmpxchg_r32(struct jit_context *ctx, u8 dst, u8 src, s16 off)

arch/mips/net/bpf_jit_comp32.c

885

emit(ctx, addiu, MIPS_R_T9, dst, off);

arch/mips/net/bpf_jit_comp32.c

910

u8 dst, const u8 src[], s16 off)

arch/mips/net/bpf_jit_comp32.c

924

emit(ctx, addiu, MIPS_R_T9, dst, off);

arch/mips/net/bpf_jit_comp64.c

100

emit(ctx, sll, dst, src, 0);

arch/mips/net/bpf_jit_comp64.c

101

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

1020

emit_jmp_i(ctx, dst, imm, rel, jmp);

arch/mips/net/bpf_jit_comp64.c

1024

emit_jmp_r(ctx, dst, MIPS_R_T4, rel, jmp);

arch/mips/net/bpf_jit_comp64.c

105

static void emit_zext(struct jit_context *ctx, u8 dst)

arch/mips/net/bpf_jit_comp64.c

108

emit(ctx, dinsu, dst, MIPS_R_ZERO, 32, 32);

arch/mips/net/bpf_jit_comp64.c

110

emit(ctx, and, dst, dst, bpf2mips64[JIT_REG_ZX]);

arch/mips/net/bpf_jit_comp64.c

113

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

117

static void emit_zext_ver(struct jit_context *ctx, u8 dst)

arch/mips/net/bpf_jit_comp64.c

120

emit_zext(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

124

static void emit_mov_i64(struct jit_context *ctx, u8 dst, u64 imm64)

arch/mips/net/bpf_jit_comp64.c

127

emit(ctx, daddiu, dst, MIPS_R_ZERO, (s16)imm64);

arch/mips/net/bpf_jit_comp64.c

130

emit(ctx, lui, dst, (s16)(imm64 >> 16));

arch/mips/net/bpf_jit_comp64.c

131

emit(ctx, ori, dst, dst, (u16)imm64 & 0xffff);

arch/mips/net/bpf_jit_comp64.c

140

if (acc == dst)

arch/mips/net/bpf_jit_comp64.c

145

emit(ctx, dsll_safe, dst, dst, shift);

arch/mips/net/bpf_jit_comp64.c

146

emit(ctx, ori, dst, acc, half);

arch/mips/net/bpf_jit_comp64.c

147

acc = dst;

arch/mips/net/bpf_jit_comp64.c

152

emit(ctx, dsll_safe, dst, dst, shift);

arch/mips/net/bpf_jit_comp64.c

154

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

158

static void emit_alu_i64(struct jit_context *ctx, u8 dst, s32 imm, u8 op)

arch/mips/net/bpf_jit_comp64.c

163

emit(ctx, ori, dst, dst, (u16)imm);

arch/mips/net/bpf_jit_comp64.c

167

emit(ctx, xori, dst, dst, (u16)imm);

arch/mips/net/bpf_jit_comp64.c

171

emit(ctx, dsubu, dst, MIPS_R_ZERO, dst);

arch/mips/net/bpf_jit_comp64.c

175

emit(ctx, dsll_safe, dst, dst, imm);

arch/mips/net/bpf_jit_comp64.c

179

emit(ctx, dsrl_safe, dst, dst, imm);

arch/mips/net/bpf_jit_comp64.c

183

emit(ctx, dsra_safe, dst, dst, imm);

arch/mips/net/bpf_jit_comp64.c

187

emit(ctx, daddiu, dst, dst, imm);

arch/mips/net/bpf_jit_comp64.c

191

emit(ctx, daddiu, dst, dst, -imm);

arch/mips/net/bpf_jit_comp64.c

195

emit_alu_i(ctx, dst, imm, op);

arch/mips/net/bpf_jit_comp64.c

197

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

201

static void emit_alu_r64(struct jit_context *ctx, u8 dst, u8 src, u8 op)

arch/mips/net/bpf_jit_comp64.c

206

emit(ctx, dsllv, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

210

emit(ctx, dsrlv, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

214

emit(ctx, dsrav, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

218

emit(ctx, daddu, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

222

emit(ctx, dsubu, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

227

emit(ctx, dmulu, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

229

emit(ctx, dmultu, dst, src);

arch/mips/net/bpf_jit_comp64.c

230

emit(ctx, mflo, dst);

arch/mips/net/bpf_jit_comp64.c

239

emit(ctx, ddivu_r6, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

241

emit(ctx, ddivu, dst, src);

arch/mips/net/bpf_jit_comp64.c

242

emit(ctx, mflo, dst);

arch/mips/net/bpf_jit_comp64.c

248

emit(ctx, dmodu, dst, dst, src);

arch/mips/net/bpf_jit_comp64.c

250

emit(ctx, ddivu, dst, src);

arch/mips/net/bpf_jit_comp64.c

251

emit(ctx, mfhi, dst);

arch/mips/net/bpf_jit_comp64.c

256

emit_alu_r(ctx, dst, src, op);

arch/mips/net/bpf_jit_comp64.c

258

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

262

static void emit_swap_r64(struct jit_context *ctx, u8 dst, u8 mask, u32 bits)

arch/mips/net/bpf_jit_comp64.c

266

emit(ctx, and, tmp, dst, mask); /* tmp = dst & mask */

arch/mips/net/bpf_jit_comp64.c

268

emit(ctx, dsrl, dst, dst, bits); /* dst = dst >> bits */

arch/mips/net/bpf_jit_comp64.c

269

emit(ctx, and, dst, dst, mask); /* dst = dst & mask */

arch/mips/net/bpf_jit_comp64.c

270

emit(ctx, or, dst, dst, tmp); /* dst = dst | tmp */

arch/mips/net/bpf_jit_comp64.c

274

static void emit_bswap_r64(struct jit_context *ctx, u8 dst, u32 width)

arch/mips/net/bpf_jit_comp64.c

280

emit(ctx, dsbh, dst, dst);

arch/mips/net/bpf_jit_comp64.c

281

emit(ctx, dshd, dst, dst);

arch/mips/net/bpf_jit_comp64.c

286

emit(ctx, dsll32, t2, dst, 0); /* t2 = dst << 32 */

arch/mips/net/bpf_jit_comp64.c

287

emit(ctx, dsrl32, dst, dst, 0); /* dst = dst >> 32 */

arch/mips/net/bpf_jit_comp64.c

288

emit(ctx, or, dst, dst, t2); /* dst = dst | t2 */

arch/mips/net/bpf_jit_comp64.c

293

emit_swap_r64(ctx, dst, t1, 16);/* dst = swap16(dst) */

arch/mips/net/bpf_jit_comp64.c

299

emit_swap_r64(ctx, dst, t1, 8); /* dst = swap8(dst) */

arch/mips/net/bpf_jit_comp64.c

306

emit_sext(ctx, dst, dst);

arch/mips/net/bpf_jit_comp64.c

307

emit_bswap_r(ctx, dst, width);

arch/mips/net/bpf_jit_comp64.c

309

emit_zext(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

312

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

316

static void emit_trunc_r64(struct jit_context *ctx, u8 dst, u32 width)

arch/mips/net/bpf_jit_comp64.c

323

emit_zext(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

327

emit(ctx, andi, dst, dst, 0xffff);

arch/mips/net/bpf_jit_comp64.c

330

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

334

static void emit_ldx(struct jit_context *ctx, u8 dst, u8 src, s16 off, u8 size)

arch/mips/net/bpf_jit_comp64.c

339

emit(ctx, lbu, dst, off, src);

arch/mips/net/bpf_jit_comp64.c

343

emit(ctx, lhu, dst, off, src);

arch/mips/net/bpf_jit_comp64.c

347

emit(ctx, lwu, dst, off, src);

arch/mips/net/bpf_jit_comp64.c

351

emit(ctx, ld, dst, off, src);

arch/mips/net/bpf_jit_comp64.c

354

clobber_reg(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

358

static void emit_stx(struct jit_context *ctx, u8 dst, u8 src, s16 off, u8 size)

arch/mips/net/bpf_jit_comp64.c

363

emit(ctx, sb, src, off, dst);

arch/mips/net/bpf_jit_comp64.c

367

emit(ctx, sh, src, off, dst);

arch/mips/net/bpf_jit_comp64.c

371

emit(ctx, sw, src, off, dst);

arch/mips/net/bpf_jit_comp64.c

375

emit(ctx, sd, src, off, dst);

arch/mips/net/bpf_jit_comp64.c

382

u8 dst, u8 src, s16 off, u8 code)

arch/mips/net/bpf_jit_comp64.c

388

emit(ctx, lld, t1, off, dst);

arch/mips/net/bpf_jit_comp64.c

410

emit(ctx, scd, t2, off, dst);

arch/mips/net/bpf_jit_comp64.c

421

static void emit_cmpxchg_r64(struct jit_context *ctx, u8 dst, u8 src, s16 off)

arch/mips/net/bpf_jit_comp64.c

428

emit(ctx, lld, t1, off, dst);

arch/mips/net/bpf_jit_comp64.c

431

emit(ctx, scd, t2, off, dst);

arch/mips/net/bpf_jit_comp64.c

637

u8 dst = bpf2mips64[insn->dst_reg];

arch/mips/net/bpf_jit_comp64.c

650

emit_mov_i(ctx, dst, imm);

arch/mips/net/bpf_jit_comp64.c

651

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

657

emit_zext(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

659

emit_mov_r(ctx, dst, src);

arch/mips/net/bpf_jit_comp64.c

660

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

665

emit_sext(ctx, dst, dst);

arch/mips/net/bpf_jit_comp64.c

666

emit_alu_i(ctx, dst, 0, BPF_NEG);

arch/mips/net/bpf_jit_comp64.c

667

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

679

emit_alu_r(ctx, dst, MIPS_R_T4, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

681

emit_alu_i(ctx, dst, val, alu);

arch/mips/net/bpf_jit_comp64.c

683

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

700

emit_sext(ctx, dst, dst);

arch/mips/net/bpf_jit_comp64.c

702

emit_alu_r(ctx, dst, MIPS_R_T4, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

704

emit_sext(ctx, dst, dst);

arch/mips/net/bpf_jit_comp64.c

705

emit_alu_i(ctx, dst, val, alu);

arch/mips/net/bpf_jit_comp64.c

707

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

717

emit_alu_r(ctx, dst, src, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

718

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

734

emit_sext(ctx, dst, dst);

arch/mips/net/bpf_jit_comp64.c

736

emit_alu_r(ctx, dst, MIPS_R_T4, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

737

emit_zext_ver(ctx, dst);

arch/mips/net/bpf_jit_comp64.c

741

emit_mov_i(ctx, dst, imm);

arch/mips/net/bpf_jit_comp64.c

745

emit_mov_r(ctx, dst, src);

arch/mips/net/bpf_jit_comp64.c

749

emit_alu_i64(ctx, dst, 0, BPF_NEG);

arch/mips/net/bpf_jit_comp64.c

775

emit_alu_r64(ctx, dst, MIPS_R_T4, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

777

emit_alu_i64(ctx, dst, val, alu);

arch/mips/net/bpf_jit_comp64.c

802

emit_alu_r64(ctx, dst, src, BPF_OP(code));

arch/mips/net/bpf_jit_comp64.c

815

emit_bswap_r64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp64.c

817

emit_trunc_r64(ctx, dst, imm);

arch/mips/net/bpf_jit_comp64.c

821

emit_mov_i64(ctx, dst, (u32)imm | ((u64)insn[1].imm << 32));

arch/mips/net/bpf_jit_comp64.c

828

emit_ldx(ctx, dst, src, off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp64.c

836

emit_stx(ctx, dst, MIPS_R_T4, off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp64.c

843

emit_stx(ctx, dst, src, off, BPF_SIZE(code));

arch/mips/net/bpf_jit_comp64.c

862

emit_atomic_r64(ctx, dst, src, off, imm);

arch/mips/net/bpf_jit_comp64.c

864

u8 tmp = dst;

arch/mips/net/bpf_jit_comp64.c

866

if (src == dst) { /* Don't overwrite dst */

arch/mips/net/bpf_jit_comp64.c

867

emit_mov_r(ctx, MIPS_R_T4, dst);

arch/mips/net/bpf_jit_comp64.c

875

emit_atomic_r(ctx, dst, MIPS_R_T4, off, imm);

arch/mips/net/bpf_jit_comp64.c

880

emit_cmpxchg_r64(ctx, dst, src, off);

arch/mips/net/bpf_jit_comp64.c

884

if (res == dst) /* Don't overwrite dst */

arch/mips/net/bpf_jit_comp64.c

888

emit_cmpxchg_r(ctx, dst, MIPS_R_T5, tmp, off);

arch/mips/net/bpf_jit_comp64.c

889

if (res == dst) /* Restore result */

arch/mips/net/bpf_jit_comp64.c

922

setup_jmp_r(ctx, dst == src, BPF_OP(code), off, &jmp, &rel);

arch/mips/net/bpf_jit_comp64.c

923

emit_sext(ctx, MIPS_R_T4, dst); /* Sign-extended dst */

arch/mips/net/bpf_jit_comp64.c

954

emit_sext(ctx, MIPS_R_T4, dst); /* Sign-extended dst */

arch/mips/net/bpf_jit_comp64.c

98

static void emit_sext(struct jit_context *ctx, u8 dst, u8 src)

arch/mips/net/bpf_jit_comp64.c

989

setup_jmp_r(ctx, dst == src, BPF_OP(code), off, &jmp, &rel);

arch/mips/net/bpf_jit_comp64.c

990

emit_jmp_r(ctx, dst, src, rel, jmp);

arch/mips/pic32/pic32mzda/init.c

59

char *dst = &(arcs_cmdline[0]);

arch/mips/pic32/pic32mzda/init.c

65

*dst++ = *src++;

arch/mips/pic32/pic32mzda/init.c

68

*dst++ = ' ';

arch/mips/pic32/pic32mzda/init.c

71

--dst;

arch/mips/pic32/pic32mzda/init.c

73

*dst = 0;

arch/nios2/include/asm/cacheflush.h

46

void *dst, void *src, int len);

arch/nios2/include/asm/cacheflush.h

49

void *dst, void *src, int len);

arch/nios2/lib/memmove.c

15

unsigned long dst, src;

arch/nios2/lib/memmove.c

21

dst = (unsigned long) d;

arch/nios2/lib/memmove.c

24

if ((count < 8) || ((dst ^ src) & 3))

arch/nios2/lib/memmove.c

27

if (dst & 1) {

arch/nios2/lib/memmove.c

28

*(char *)dst++ = *(char *)src++;

arch/nios2/lib/memmove.c

31

if (dst & 2) {

arch/nios2/lib/memmove.c

32

*(short *)dst = *(short *)src;

arch/nios2/lib/memmove.c

34

dst += 2;

arch/nios2/lib/memmove.c

38

*(long *)dst = *(long *)src;

arch/nios2/lib/memmove.c

40

dst += 4;

arch/nios2/lib/memmove.c

45

*(char *)dst++ = *(char *)src++;

arch/nios2/lib/memmove.c

47

dst = (unsigned long) d + count;

arch/nios2/lib/memmove.c

50

if ((count < 8) || ((dst ^ src) & 3))

arch/nios2/lib/memmove.c

53

if (dst & 1) {

arch/nios2/lib/memmove.c

55

dst--;

arch/nios2/lib/memmove.c

57

*(char *)dst = *(char *)src;

arch/nios2/lib/memmove.c

59

if (dst & 2) {

arch/nios2/lib/memmove.c

61

dst -= 2;

arch/nios2/lib/memmove.c

63

*(short *)dst = *(short *)src;

arch/nios2/lib/memmove.c

67

dst -= 4;

arch/nios2/lib/memmove.c

69

*(long *)dst = *(long *)src;

arch/nios2/lib/memmove.c

74

dst--;

arch/nios2/lib/memmove.c

75

*(char *)dst = *(char *)src;

arch/nios2/mm/cacheflush.c

263

void *dst, void *src, int len)

arch/nios2/mm/cacheflush.c

266

memcpy(dst, src, len);

arch/nios2/mm/cacheflush.c

274

void *dst, void *src, int len)

arch/nios2/mm/cacheflush.c

277

memcpy(dst, src, len);

arch/nios2/mm/cacheflush.c

278

__flush_dcache((unsigned long)dst, (unsigned long)dst + len);

arch/nios2/mm/cacheflush.c

280

__flush_icache((unsigned long)dst, (unsigned long)dst + len);

arch/parisc/include/asm/cacheflush.h

71

unsigned long user_vaddr, void *dst, void *src, int len);

arch/parisc/include/asm/cacheflush.h

73

unsigned long user_vaddr, void *dst, void *src, int len);

arch/parisc/include/asm/elf.h

276

#define ELF_CORE_COPY_REGS(dst, pt) \

arch/parisc/include/asm/elf.h

277

memset(dst, 0, sizeof(dst)); /* don't leak any "random" bits */ \

arch/parisc/include/asm/elf.h

279

for (i = 0; i < 32; i++) dst[i] = pt->gr[i]; \

arch/parisc/include/asm/elf.h

280

for (i = 0; i < 8; i++) dst[32 + i] = pt->sr[i]; \

arch/parisc/include/asm/elf.h

282

dst[40] = pt->iaoq[0]; dst[41] = pt->iaoq[1]; \

arch/parisc/include/asm/elf.h

283

dst[42] = pt->iasq[0]; dst[43] = pt->iasq[1]; \

arch/parisc/include/asm/elf.h

284

dst[44] = pt->sar; dst[45] = pt->iir; \

arch/parisc/include/asm/elf.h

285

dst[46] = pt->isr; dst[47] = pt->ior; \

arch/parisc/include/asm/elf.h

286

dst[48] = mfctl(22); dst[49] = mfctl(0); \

arch/parisc/include/asm/elf.h

287

dst[50] = mfctl(24); dst[51] = mfctl(25); \

arch/parisc/include/asm/elf.h

288

dst[52] = mfctl(26); dst[53] = mfctl(27); \

arch/parisc/include/asm/elf.h

289

dst[54] = mfctl(28); dst[55] = mfctl(29); \

arch/parisc/include/asm/elf.h

290

dst[56] = mfctl(30); dst[57] = mfctl(31); \

arch/parisc/include/asm/elf.h

291

dst[58] = mfctl( 8); dst[59] = mfctl( 9); \

arch/parisc/include/asm/elf.h

292

dst[60] = mfctl(12); dst[61] = mfctl(13); \

arch/parisc/include/asm/elf.h

293

dst[62] = mfctl(10); dst[63] = mfctl(15);

arch/parisc/include/asm/hash.h

106

#define _ASSIGN(dst, src, ...) asm("" : "=r" (dst) : "0" (src), ##__VA_ARGS__)

arch/parisc/include/asm/io.h

203

extern void insb (unsigned long port, void *dst, unsigned long count);

arch/parisc/include/asm/io.h

204

extern void insw (unsigned long port, void *dst, unsigned long count);

arch/parisc/include/asm/io.h

205

extern void insl (unsigned long port, void *dst, unsigned long count);

arch/parisc/include/asm/uaccess.h

136

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/parisc/include/asm/uaccess.h

140

__err = __put_user_internal(SR_KERNEL, __z, (type *)(dst)); \

arch/parisc/include/asm/uaccess.h

196

unsigned long __must_check raw_copy_to_user(void __user *dst, const void *src,

arch/parisc/include/asm/uaccess.h

198

unsigned long __must_check raw_copy_from_user(void *dst, const void __user *src,

arch/parisc/include/asm/uaccess.h

78

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/parisc/include/asm/uaccess.h

86

*(type *)(dst) = __z; \

arch/parisc/kernel/cache.c

661

unsigned long user_vaddr, void *dst, void *src, int len)

arch/parisc/kernel/cache.c

664

memcpy(dst, src, len);

arch/parisc/kernel/cache.c

665

flush_kernel_dcache_page_addr(PTR_PAGE_ALIGN_DOWN(dst));

arch/parisc/kernel/cache.c

669

unsigned long user_vaddr, void *dst, void *src, int len)

arch/parisc/kernel/cache.c

672

memcpy(dst, src, len);

arch/parisc/lib/io.c

131

void insl (unsigned long port, void *dst, unsigned long count)

arch/parisc/lib/io.c

136

p = (unsigned char *)dst;

arch/parisc/lib/io.c

141

switch (((unsigned long) dst) & 0x3)

arch/parisc/lib/io.c

19

void insb (unsigned long port, void *dst, unsigned long count)

arch/parisc/lib/io.c

23

p = (unsigned char *)dst;

arch/parisc/lib/io.c

59

void insw (unsigned long port, void *dst, unsigned long count)

arch/parisc/lib/io.c

64

p = (unsigned char *)dst;

arch/parisc/lib/iomap.c

106

static void ioport_read8r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

108

insb(ADDR2PORT(addr), dst, count);

arch/parisc/lib/iomap.c

111

static void ioport_read16r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

113

insw(ADDR2PORT(addr), dst, count);

arch/parisc/lib/iomap.c

116

static void ioport_read32r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

118

insl(ADDR2PORT(addr), dst, count);

arch/parisc/lib/iomap.c

231

static void iomem_read8r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

234

*(u8 *)dst = __raw_readb(addr);

arch/parisc/lib/iomap.c

235

dst++;

arch/parisc/lib/iomap.c

239

static void iomem_read16r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

242

*(u16 *)dst = __raw_readw(addr);

arch/parisc/lib/iomap.c

243

dst += 2;

arch/parisc/lib/iomap.c

247

static void iomem_read32r(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

250

*(u32 *)dst = __raw_readl(addr);

arch/parisc/lib/iomap.c

251

dst += 4;

arch/parisc/lib/iomap.c

430

void ioread8_rep(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

433

iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);

arch/parisc/lib/iomap.c

436

*(u8 *)dst = *(u8 *)addr;

arch/parisc/lib/iomap.c

437

dst++;

arch/parisc/lib/iomap.c

442

void ioread16_rep(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

445

iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);

arch/parisc/lib/iomap.c

448

*(u16 *)dst = *(u16 *)addr;

arch/parisc/lib/iomap.c

449

dst += 2;

arch/parisc/lib/iomap.c

454

void ioread32_rep(const void __iomem *addr, void *dst, unsigned long count)

arch/parisc/lib/iomap.c

457

iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);

arch/parisc/lib/iomap.c

460

*(u32 *)dst = *(u32 *)addr;

arch/parisc/lib/iomap.c

461

dst += 4;

arch/parisc/lib/memcpy.c

21

extern unsigned long pa_memcpy(void *dst, const void *src,

arch/parisc/lib/memcpy.c

24

unsigned long raw_copy_to_user(void __user *dst, const void *src,

arch/parisc/lib/memcpy.c

29

return pa_memcpy((void __force *)dst, src, len);

arch/parisc/lib/memcpy.c

33

unsigned long raw_copy_from_user(void *dst, const void __user *src,

arch/parisc/lib/memcpy.c

53

return len - newlen + pa_memcpy(dst, (void __force *)src, newlen);

arch/parisc/lib/memcpy.c

57

void * memcpy(void * dst,const void *src, size_t count)

arch/parisc/lib/memcpy.c

61

pa_memcpy(dst, src, count);

arch/parisc/lib/memcpy.c

62

return dst;

arch/parisc/math-emu/dbl_float.h

90

#define Dbl_rightshiftby1_withextent(leftb,right,dst) \

arch/parisc/math-emu/dbl_float.h

91

Extall(dst) = (Dallp2(leftb) << 31) | ((unsigned int)Extall(right) >> 1) | \

arch/parisc/math-emu/sgl_float.h

53

#define Sgl_rightshiftby1_withextent(left,right,dst) \

arch/parisc/net/bpf_jit_comp32.c

1006

static int emit_load_r64(const s8 *dst, const s8 *src, s16 off,

arch/parisc/net/bpf_jit_comp32.c

1011

const s8 *rd = bpf_get_reg64_ref(dst, tmp1, ctx->prog->aux->verifier_zext, ctx);

arch/parisc/net/bpf_jit_comp32.c

1048

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

1052

static int emit_store_r64(const s8 *dst, const s8 *src, s16 off,

arch/parisc/net/bpf_jit_comp32.c

1058

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

1106

static void emit_zext64(const s8 *dst, struct hppa_jit_context *ctx)

arch/parisc/net/bpf_jit_comp32.c

1111

rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

1113

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

1126

const s8 *dst = regmap[insn->dst_reg];

arch/parisc/net/bpf_jit_comp32.c

1166

emit_alu_r64(dst, src, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1171

emit_alu_r64(dst, tmp2, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1181

emit_alu_i64(dst, imm, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1187

emit_zext64(dst, ctx);

arch/parisc/net/bpf_jit_comp32.c

1214

emit_alu_r32(dst, src, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1230

emit_alu_i32(dst, imm, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1239

emit_alu_r32(dst, tmp2, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1245

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

1265

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

1271

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

1295

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

1387

emit_branch_r64(dst, src, paoff, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1389

emit_branch_r32(dst, src, paoff, ctx, BPF_OP(code));

arch/parisc/net/bpf_jit_comp32.c

1406

const s8 *rd = bpf_get_reg64_ref(dst, tmp1, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1415

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

1424

if (emit_load_r64(dst, src, off, ctx, BPF_SIZE(code)))

arch/parisc/net/bpf_jit_comp32.c

1447

if (emit_store_r64(dst, src, off, ctx, BPF_SIZE(code),

arch/parisc/net/bpf_jit_comp32.c

1470

const s8 *dst, *reg;

arch/parisc/net/bpf_jit_comp32.c

1547

dst = regmap[BPF_REG_5];

arch/parisc/net/bpf_jit_comp32.c

1548

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1554

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

1557

dst = regmap[BPF_REG_4];

arch/parisc/net/bpf_jit_comp32.c

1558

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1564

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

1567

dst = regmap[BPF_REG_3];

arch/parisc/net/bpf_jit_comp32.c

1568

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1574

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

1577

dst = regmap[BPF_REG_2];

arch/parisc/net/bpf_jit_comp32.c

1578

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1584

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

1587

dst = regmap[BPF_REG_1];

arch/parisc/net/bpf_jit_comp32.c

1588

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1594

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

1598

dst = regmap[BPF_REG_FP];

arch/parisc/net/bpf_jit_comp32.c

1599

reg = bpf_get_reg64_ref(dst, tmp, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

1606

bpf_put_reg64(dst, tmp, ctx);

arch/parisc/net/bpf_jit_comp32.c

421

static void emit_alu_i64(const s8 *dst, s32 imm,

arch/parisc/net/bpf_jit_comp32.c

428

rd = bpf_get_reg64_ref(dst, tmp1, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

430

rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

506

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

509

static void emit_alu_i32(const s8 *dst, s32 imm,

arch/parisc/net/bpf_jit_comp32.c

513

const s8 *rd = bpf_get_reg32(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

516

rd = bpf_get_reg32_ref(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

518

rd = bpf_get_reg32(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

561

bpf_put_reg32(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

564

static void emit_alu_r64(const s8 *dst, const s8 *src,

arch/parisc/net/bpf_jit_comp32.c

573

rd = bpf_get_reg64_ref(dst, tmp1, false, ctx);

arch/parisc/net/bpf_jit_comp32.c

575

rd = bpf_get_reg64(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

629

bpf_put_reg64(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp32.c

632

static void emit_alu_r32(const s8 *dst, const s8 *src,

arch/parisc/net/bpf_jit_comp32.c

641

rd = bpf_get_reg32_ref(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

643

rd = bpf_get_reg32(dst, tmp1, ctx);

arch/parisc/net/bpf_jit_comp32.c

696

bpf_put_reg32(dst, rd, ctx);

arch/parisc/net/bpf_jit_comp64.c

1163

#define LOAD_PARAM(arg, dst) \

arch/parisc/net/bpf_jit_comp64.c

1164

if (REG_WAS_SEEN(ctx, regmap[dst]) || \

arch/parisc/net/bpf_jit_comp64.c

1166

emit_hppa_copy(arg, regmap[dst], ctx)

arch/powerpc/crypto/aes-gcm-p10-glue.c

265

u8 *dst = walk.dst.virt.addr;

arch/powerpc/crypto/aes-gcm-p10-glue.c

269

src = dst = memcpy(buf, src, nbytes);

arch/powerpc/crypto/aes-gcm-p10-glue.c

273

aes_p10_gcm_encrypt(src, dst, nbytes,

arch/powerpc/crypto/aes-gcm-p10-glue.c

276

aes_p10_gcm_decrypt(src, dst, nbytes,

arch/powerpc/crypto/aes-gcm-p10-glue.c

280

memcpy(walk.dst.virt.addr, buf, nbytes);

arch/powerpc/crypto/aes-gcm-p10-glue.c

299

scatterwalk_map_and_copy(hash->Htable, req->dst, req->assoclen + cryptlen,

arch/powerpc/crypto/aes-spe-glue.c

148

ppc_encrypt_ecb(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

151

ppc_decrypt_ecb(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

187

ppc_encrypt_cbc(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

191

ppc_decrypt_cbc(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

228

ppc_crypt_ctr(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

256

ppc_encrypt_xts(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

260

ppc_decrypt_xts(walk.dst.virt.addr, walk.src.virt.addr,

arch/powerpc/crypto/aes-spe-glue.c

287

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/powerpc/crypto/aes-spe-glue.c

296

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE, 0);

arch/powerpc/crypto/aes-spe-glue.c

305

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE + tail, 1);

arch/powerpc/crypto/aes-spe-glue.c

326

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/powerpc/crypto/aes-spe-glue.c

352

scatterwalk_map_and_copy(b[0], req->dst, offset, AES_BLOCK_SIZE + tail, 1);

arch/powerpc/crypto/aes_cbc.c

98

walk.dst.virt.addr,

arch/powerpc/crypto/aes_ctr.c

116

walk.dst.virt.addr,

arch/powerpc/crypto/aes_ctr.c

79

u8 *dst = walk->dst.virt.addr;

arch/powerpc/crypto/aes_ctr.c

90

crypto_xor_cpy(dst, keystream, src, nbytes);

arch/powerpc/crypto/aes_xts.c

123

walk.dst.virt.addr,

arch/powerpc/crypto/aes_xts.c

128

walk.dst.virt.addr,

arch/powerpc/include/asm/async_tx.h

22

#define async_tx_find_channel(dep, type, dst, dst_count, src, src_count, len) \

arch/powerpc/include/asm/checksum.h

21

extern __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/powerpc/include/asm/checksum.h

24

extern __wsum csum_and_copy_from_user(const void __user *src, void *dst,

arch/powerpc/include/asm/checksum.h

27

extern __wsum csum_and_copy_to_user(const void *src, void __user *dst,

arch/powerpc/include/asm/checksum.h

31

#define csum_partial_copy_nocheck(src, dst, len) \

arch/powerpc/include/asm/checksum.h

32

csum_partial_copy_generic((src), (dst), (len))

arch/powerpc/include/asm/cpm2.h

696

uint dst; /* destination data buffer pointer */

arch/powerpc/include/asm/io.h

492

#define __do_memcpy_fromio(dst, src, n) \

arch/powerpc/include/asm/io.h

493

eeh_memcpy_fromio(dst, src, n)

arch/powerpc/include/asm/io.h

495

#define __do_memcpy_fromio(dst, src, n) \

arch/powerpc/include/asm/io.h

496

_memcpy_fromio(dst, src, n)

arch/powerpc/include/asm/io.h

858

#define mmio_insb(addr, dst, count) readsb(addr, dst, count)

arch/powerpc/include/asm/io.h

859

#define mmio_insw(addr, dst, count) readsw(addr, dst, count)

arch/powerpc/include/asm/io.h

860

#define mmio_insl(addr, dst, count) readsl(addr, dst, count)

arch/powerpc/include/asm/kvm_fpu.h

14

extern void fps_fres(u64 *fpscr, u32 *dst, u32 *src1);

arch/powerpc/include/asm/kvm_fpu.h

15

extern void fps_frsqrte(u64 *fpscr, u32 *dst, u32 *src1);

arch/powerpc/include/asm/kvm_fpu.h

16

extern void fps_fsqrts(u64 *fpscr, u32 *dst, u32 *src1);

arch/powerpc/include/asm/kvm_fpu.h

18

extern void fps_fadds(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2);

arch/powerpc/include/asm/kvm_fpu.h

19

extern void fps_fdivs(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2);

arch/powerpc/include/asm/kvm_fpu.h

20

extern void fps_fmuls(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2);

arch/powerpc/include/asm/kvm_fpu.h

21

extern void fps_fsubs(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2);

arch/powerpc/include/asm/kvm_fpu.h

23

extern void fps_fmadds(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2,

arch/powerpc/include/asm/kvm_fpu.h

25

extern void fps_fmsubs(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2,

arch/powerpc/include/asm/kvm_fpu.h

27

extern void fps_fnmadds(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2,

arch/powerpc/include/asm/kvm_fpu.h

29

extern void fps_fnmsubs(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2,

arch/powerpc/include/asm/kvm_fpu.h

31

extern void fps_fsel(u64 *fpscr, u32 *dst, u32 *src1, u32 *src2,

arch/powerpc/include/asm/kvm_fpu.h

35

u64 *dst, u64 *src1);

arch/powerpc/include/asm/kvm_fpu.h

37

u64 *dst, u64 *src1, u64 *src2);

arch/powerpc/include/asm/kvm_fpu.h

39

u64 *dst, u64 *src1, u64 *src2, u64 *src3);

arch/powerpc/include/asm/string.h

48

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/powerpc/include/asm/string.h

49

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/powerpc/include/asm/thread_info.h

87

extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);

arch/powerpc/include/asm/uaccess.h

408

extern long strncpy_from_user(char *dst, const char __user *src, long count);

arch/powerpc/include/asm/uaccess.h

437

extern long __copy_from_user_flushcache(void *dst, const void __user *src,

arch/powerpc/include/asm/uaccess.h

592

#define arch_get_kernel_nofault(dst, src, type, err_label) \

arch/powerpc/include/asm/uaccess.h

593

__get_user_size_goto(*((type *)(dst)), \

arch/powerpc/include/asm/uaccess.h

596

#define arch_put_kernel_nofault(dst, src, type, err_label) \

arch/powerpc/include/asm/uaccess.h

598

(__force type __user *)(dst), sizeof(type), err_label)

arch/powerpc/kernel/btext.c

354

unsigned int *dst = (unsigned int *)calc_base(0,0);

arch/powerpc/kernel/btext.c

364

unsigned int *dst_ptr = dst;

arch/powerpc/kernel/btext.c

368

dst += (dispDeviceRowBytes >> 2);

arch/powerpc/kernel/btext.c

372

unsigned int *dst_ptr = dst;

arch/powerpc/kernel/btext.c

375

dst += (dispDeviceRowBytes >> 2);

arch/powerpc/kernel/process.c

1684

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/powerpc/kernel/process.c

1699

*dst = *src;

arch/powerpc/kernel/process.c

1701

clear_task_ebb(dst);

arch/powerpc/kernel/signal.h

19

static inline int __get_user_sigset(sigset_t *dst, const sigset_t __user *src)

arch/powerpc/kernel/signal.h

23

return __get_user(dst->sig[0], (u64 __user *)&src->sig[0]);

arch/powerpc/kernel/signal.h

25

#define unsafe_get_user_sigset(dst, src, label) do { \

arch/powerpc/kernel/signal.h

26

sigset_t *__dst = dst; \

arch/powerpc/kernel/vecemu.c

16

extern void vaddfp(vector128 *dst, vector128 *a, vector128 *b);

arch/powerpc/kernel/vecemu.c

17

extern void vsubfp(vector128 *dst, vector128 *a, vector128 *b);

arch/powerpc/kernel/vecemu.c

18

extern void vmaddfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);

arch/powerpc/kernel/vecemu.c

19

extern void vnmsubfp(vector128 *dst, vector128 *a, vector128 *b, vector128 *c);

arch/powerpc/kernel/vecemu.c

20

extern void vrefp(vector128 *dst, vector128 *src);

arch/powerpc/kernel/vecemu.c

21

extern void vrsqrtefp(vector128 *dst, vector128 *src);

arch/powerpc/kernel/vecemu.c

22

extern void vexptep(vector128 *dst, vector128 *src);

arch/powerpc/kvm/book3s_hv_uvmem.c

530

mig.dst = &dst_pfn;

arch/powerpc/kvm/book3s_hv_uvmem.c

572

*mig.dst = migrate_pfn(pfn);

arch/powerpc/kvm/book3s_hv_uvmem.c

758

mig.dst = &dst_pfn;

arch/powerpc/kvm/book3s_hv_uvmem.c

787

*mig.dst = migrate_pfn(page_to_pfn(dpage));

arch/powerpc/kvm/book3s_paired_singles.c

494

u32 *dst, u32 *src1,

arch/powerpc/kvm/book3s_paired_singles.c

542

u32 *dst, u32 *src1,

arch/powerpc/kvm/book3s_paired_singles.c

593

u32 *dst, u32 *src1))

arch/powerpc/kvm/mpic.c

1028

struct irq_dest *dst;

arch/powerpc/kvm/mpic.c

1040

dst = &opp->dst[idx];

arch/powerpc/kvm/mpic.c

1054

dst->ctpr = val & 0x0000000F;

arch/powerpc/kvm/mpic.c

1057

__func__, idx, dst->ctpr, dst->raised.priority,

arch/powerpc/kvm/mpic.c

1058

dst->servicing.priority);

arch/powerpc/kvm/mpic.c

1060

if (dst->raised.priority <= dst->ctpr) {

arch/powerpc/kvm/mpic.c

1063

mpic_irq_lower(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

1064

} else if (dst->raised.priority > dst->servicing.priority) {

arch/powerpc/kvm/mpic.c

1066

__func__, idx, dst->raised.next);

arch/powerpc/kvm/mpic.c

1067

mpic_irq_raise(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

1081

s_IRQ = IRQ_get_next(opp, &dst->servicing);

arch/powerpc/kvm/mpic.c

1089

IRQ_resetbit(&dst->servicing, s_IRQ);

arch/powerpc/kvm/mpic.c

1093

s_IRQ = IRQ_get_next(opp, &dst->servicing);

arch/powerpc/kvm/mpic.c

1095

n_IRQ = IRQ_get_next(opp, &dst->raised);

arch/powerpc/kvm/mpic.c

1099

IVPR_PRIORITY(src->ivpr) > dst->servicing.priority)) {

arch/powerpc/kvm/mpic.c

1102

mpic_irq_raise(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

1126

static uint32_t openpic_iack(struct openpic *opp, struct irq_dest *dst,

arch/powerpc/kvm/mpic.c

1133

mpic_irq_lower(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

1135

irq = IRQ_get_next(opp, &dst->raised);

arch/powerpc/kvm/mpic.c

1144

!(IVPR_PRIORITY(src->ivpr) > dst->ctpr)) {

arch/powerpc/kvm/mpic.c

1146

__func__, irq, dst->ctpr, src->ivpr);

arch/powerpc/kvm/mpic.c

1151

IRQ_setbit(&dst->servicing, irq);

arch/powerpc/kvm/mpic.c

1159

IRQ_resetbit(&dst->raised, irq);

arch/powerpc/kvm/mpic.c

1185

kvmppc_set_epr(vcpu, openpic_iack(opp, &opp->dst[cpu], cpu));

arch/powerpc/kvm/mpic.c

1194

struct irq_dest *dst;

arch/powerpc/kvm/mpic.c

1206

dst = &opp->dst[idx];

arch/powerpc/kvm/mpic.c

1210

retval = dst->ctpr;

arch/powerpc/kvm/mpic.c

1216

retval = openpic_iack(opp, dst, idx);

arch/powerpc/kvm/mpic.c

1747

if (opp->dst[cpu].vcpu) {

arch/powerpc/kvm/mpic.c

1756

opp->dst[cpu].vcpu = vcpu;

arch/powerpc/kvm/mpic.c

1779

BUG_ON(!opp->dst[vcpu->arch.irq_cpu_id].vcpu);

arch/powerpc/kvm/mpic.c

1781

opp->dst[vcpu->arch.irq_cpu_id].vcpu = NULL;

arch/powerpc/kvm/mpic.c

223

struct irq_dest dst[MAX_CPU];

arch/powerpc/kvm/mpic.c

241

static void mpic_irq_raise(struct openpic *opp, struct irq_dest *dst,

arch/powerpc/kvm/mpic.c

248

if (!dst->vcpu) {

arch/powerpc/kvm/mpic.c

250

__func__, (int)(dst - &opp->dst[0]));

arch/powerpc/kvm/mpic.c

254

pr_debug("%s: cpu %d output %d\n", __func__, dst->vcpu->arch.irq_cpu_id,

arch/powerpc/kvm/mpic.c

260

kvm_vcpu_ioctl_interrupt(dst->vcpu, &irq);

arch/powerpc/kvm/mpic.c

263

static void mpic_irq_lower(struct openpic *opp, struct irq_dest *dst,

arch/powerpc/kvm/mpic.c

266

if (!dst->vcpu) {

arch/powerpc/kvm/mpic.c

268

__func__, (int)(dst - &opp->dst[0]));

arch/powerpc/kvm/mpic.c

272

pr_debug("%s: cpu %d output %d\n", __func__, dst->vcpu->arch.irq_cpu_id,

arch/powerpc/kvm/mpic.c

278

kvmppc_core_dequeue_external(dst->vcpu);

arch/powerpc/kvm/mpic.c

326

struct irq_dest *dst;

arch/powerpc/kvm/mpic.c

330

dst = &opp->dst[n_CPU];

arch/powerpc/kvm/mpic.c

339

dst->outputs_active[src->output]);

arch/powerpc/kvm/mpic.c

347

dst->outputs_active[src->output]++ == 0) {

arch/powerpc/kvm/mpic.c

350

mpic_irq_raise(opp, dst, src->output);

arch/powerpc/kvm/mpic.c

354

--dst->outputs_active[src->output] == 0) {

arch/powerpc/kvm/mpic.c

357

mpic_irq_lower(opp, dst, src->output);

arch/powerpc/kvm/mpic.c

370

IRQ_setbit(&dst->raised, n_IRQ);

arch/powerpc/kvm/mpic.c

372

IRQ_resetbit(&dst->raised, n_IRQ);

arch/powerpc/kvm/mpic.c

374

IRQ_check(opp, &dst->raised);

arch/powerpc/kvm/mpic.c

376

if (active && priority <= dst->ctpr) {

arch/powerpc/kvm/mpic.c

378

__func__, n_IRQ, priority, dst->ctpr, n_CPU);

arch/powerpc/kvm/mpic.c

383

if (IRQ_get_next(opp, &dst->servicing) >= 0 &&

arch/powerpc/kvm/mpic.c

384

priority <= dst->servicing.priority) {

arch/powerpc/kvm/mpic.c

386

__func__, n_IRQ, dst->servicing.next, n_CPU);

arch/powerpc/kvm/mpic.c

389

__func__, n_CPU, n_IRQ, dst->raised.next);

arch/powerpc/kvm/mpic.c

390

mpic_irq_raise(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

393

IRQ_get_next(opp, &dst->servicing);

arch/powerpc/kvm/mpic.c

394

if (dst->raised.priority > dst->ctpr &&

arch/powerpc/kvm/mpic.c

395

dst->raised.priority > dst->servicing.priority) {

arch/powerpc/kvm/mpic.c

397

__func__, n_IRQ, dst->raised.next,

arch/powerpc/kvm/mpic.c

398

dst->raised.priority, dst->ctpr,

arch/powerpc/kvm/mpic.c

399

dst->servicing.priority, n_CPU);

arch/powerpc/kvm/mpic.c

403

__func__, n_IRQ, dst->ctpr,

arch/powerpc/kvm/mpic.c

404

dst->servicing.priority, n_CPU);

arch/powerpc/kvm/mpic.c

405

mpic_irq_lower(opp, dst, ILR_INTTGT_INT);

arch/powerpc/kvm/mpic.c

546

opp->dst[i].ctpr = 15;

arch/powerpc/kvm/mpic.c

547

memset(&opp->dst[i].raised, 0, sizeof(struct irq_queue));

arch/powerpc/kvm/mpic.c

548

opp->dst[i].raised.next = -1;

arch/powerpc/kvm/mpic.c

549

memset(&opp->dst[i].servicing, 0, sizeof(struct irq_queue));

arch/powerpc/kvm/mpic.c

550

opp->dst[i].servicing.next = -1;

arch/powerpc/lib/checksum_wrappers.c

14

__wsum csum_and_copy_from_user(const void __user *src, void *dst,

arch/powerpc/lib/checksum_wrappers.c

22

csum = csum_partial_copy_generic((void __force *)src, dst, len);

arch/powerpc/lib/checksum_wrappers.c

28

__wsum csum_and_copy_to_user(const void *src, void __user *dst, int len)

arch/powerpc/lib/checksum_wrappers.c

32

if (unlikely(!user_write_access_begin(dst, len)))

arch/powerpc/lib/checksum_wrappers.c

35

csum = csum_partial_copy_generic(src, (void __force *)dst, len);

arch/powerpc/mm/book3s64/slice.c

390

static inline void slice_copy_mask(struct slice_mask *dst,

arch/powerpc/mm/book3s64/slice.c

393

dst->low_slices = src->low_slices;

arch/powerpc/mm/book3s64/slice.c

396

bitmap_copy(dst->high_slices, src->high_slices, SLICE_NUM_HIGH);

arch/powerpc/mm/book3s64/slice.c

399

static inline void slice_or_mask(struct slice_mask *dst,

arch/powerpc/mm/book3s64/slice.c

403

dst->low_slices = src1->low_slices | src2->low_slices;

arch/powerpc/mm/book3s64/slice.c

406

bitmap_or(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);

arch/powerpc/mm/book3s64/slice.c

409

static inline void slice_andnot_mask(struct slice_mask *dst,

arch/powerpc/mm/book3s64/slice.c

413

dst->low_slices = src1->low_slices & ~src2->low_slices;

arch/powerpc/mm/book3s64/slice.c

416

bitmap_andnot(dst->high_slices, src1->high_slices, src2->high_slices, SLICE_NUM_HIGH);

arch/powerpc/net/bpf_jit_comp.c

388

void *bpf_arch_text_copy(void *dst, void *src, size_t len)

arch/powerpc/net/bpf_jit_comp.c

392

if (WARN_ON_ONCE(core_kernel_text((unsigned long)dst)))

arch/powerpc/net/bpf_jit_comp.c

396

err = patch_instructions(dst, src, len, false);

arch/powerpc/net/bpf_jit_comp.c

399

return err ? ERR_PTR(err) : dst;

arch/powerpc/net/bpf_jit_comp.c

402

int bpf_arch_text_invalidate(void *dst, size_t len)

arch/powerpc/net/bpf_jit_comp.c

407

if (WARN_ON_ONCE(core_kernel_text((unsigned long)dst)))

arch/powerpc/net/bpf_jit_comp.c

411

ret = patch_instructions(dst, &insn, len, true);

arch/powerpc/platforms/512x/mpc512x_shared.c

210

unsigned long dst;

arch/powerpc/platforms/512x/mpc512x_shared.c

239

dst = (unsigned long)&diu_shared_fb.ad0;

arch/powerpc/platforms/512x/mpc512x_shared.c

240

flush_dcache_range(dst, dst + sizeof(struct diu_ad) - 1);

arch/powerpc/platforms/512x/mpc512x_shared.c

259

dst = (unsigned long)&diu_shared_fb.gamma;

arch/powerpc/platforms/512x/mpc512x_shared.c

260

flush_dcache_range(dst, dst + sizeof(diu_shared_fb.gamma) - 1);

arch/powerpc/platforms/8xx/micropatch.c

368

u32 __iomem *dst = (u32 __iomem *)&cp->cp_dparam[PROFF_DSP1 + i];

arch/powerpc/platforms/8xx/micropatch.c

370

out_be32(dst, in_be32(src));

arch/powerpc/platforms/powermac/time.c

72

int dst;

arch/powerpc/platforms/powermac/time.c

79

dst = ((pmac_xpram_read(PMAC_XPRAM_MACHINE_LOC + 0x8) & 0x80) != 0);

arch/powerpc/platforms/powermac/time.c

81

str_on_off(dst));

arch/powerpc/platforms/pseries/iommu.c

1003

dst = kzalloc_obj(*dst);

arch/powerpc/platforms/pseries/iommu.c

1004

if (!dst)

arch/powerpc/platforms/pseries/iommu.c

1007

dst->name = kstrdup(to, GFP_KERNEL);

arch/powerpc/platforms/pseries/iommu.c

1008

dst->value = kmemdup(src->value, src->length, GFP_KERNEL);

arch/powerpc/platforms/pseries/iommu.c

1009

dst->length = src->length;

arch/powerpc/platforms/pseries/iommu.c

1010

if (!dst->name || !dst->value)

arch/powerpc/platforms/pseries/iommu.c

1013

if (of_add_property(pdn, dst)) {

arch/powerpc/platforms/pseries/iommu.c

1021

kfree(dst->name);

arch/powerpc/platforms/pseries/iommu.c

1022

kfree(dst->value);

arch/powerpc/platforms/pseries/iommu.c

1023

kfree(dst);

arch/powerpc/platforms/pseries/iommu.c

997

struct property *src, *dst;

arch/riscv/crypto/aes-riscv64-glue.c

103

walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

107

walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

141

walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

146

walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

174

struct scatterlist *src, *dst;

arch/riscv/crypto/aes-riscv64-glue.c

199

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/riscv/crypto/aes-riscv64-glue.c

204

dst = src = scatterwalk_ffwd(sg_src, req->src, cbc_len);

arch/riscv/crypto/aes-riscv64-glue.c

205

if (req->dst != req->src)

arch/riscv/crypto/aes-riscv64-glue.c

206

dst = scatterwalk_ffwd(sg_dst, req->dst, cbc_len);

arch/riscv/crypto/aes-riscv64-glue.c

207

skcipher_request_set_crypt(&subreq, src, dst,

arch/riscv/crypto/aes-riscv64-glue.c

214

aes_cbc_cts_crypt_zvkned(ctx, walk.src.virt.addr, walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

260

walk.dst.virt.addr, nbytes,

arch/riscv/crypto/aes-riscv64-glue.c

272

walk.dst.virt.addr,

arch/riscv/crypto/aes-riscv64-glue.c

280

walk.dst.virt.addr + p1_nbytes,

arch/riscv/crypto/aes-riscv64-glue.c

316

struct scatterlist *src, *dst;

arch/riscv/crypto/aes-riscv64-glue.c

342

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/riscv/crypto/aes-riscv64-glue.c

361

walk.dst.virt.addr, nbytes, req->iv);

arch/riscv/crypto/aes-riscv64-glue.c

365

walk.dst.virt.addr, nbytes, req->iv);

arch/riscv/crypto/aes-riscv64-glue.c

375

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/riscv/crypto/aes-riscv64-glue.c

376

if (req->dst != req->src)

arch/riscv/crypto/aes-riscv64-glue.c

377

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/riscv/crypto/aes-riscv64-glue.c

379

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/riscv/crypto/aes-riscv64-glue.c

390

walk.dst.virt.addr, walk.nbytes, req->iv);

arch/riscv/crypto/aes-riscv64-glue.c

394

walk.dst.virt.addr, walk.nbytes, req->iv);

arch/riscv/crypto/sm4-riscv64-glue.c

43

static void riscv64_sm4_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/riscv/crypto/sm4-riscv64-glue.c

49

sm4_crypt_zvksed_zvkb(ctx->rkey_enc, src, dst);

arch/riscv/crypto/sm4-riscv64-glue.c

52

sm4_crypt_block(ctx->rkey_enc, dst, src);

arch/riscv/crypto/sm4-riscv64-glue.c

56

static void riscv64_sm4_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/riscv/crypto/sm4-riscv64-glue.c

62

sm4_crypt_zvksed_zvkb(ctx->rkey_dec, src, dst);

arch/riscv/crypto/sm4-riscv64-glue.c

65

sm4_crypt_block(ctx->rkey_dec, dst, src);

arch/riscv/include/asm/asm-prototypes.h

15

asmlinkage int enter_vector_usercopy(void *dst, void *src, size_t n, bool enable_sum);

arch/riscv/include/asm/asm.h

103

.macro asm_per_cpu dst sym tmp

arch/riscv/include/asm/asm.h

108

.macro load_per_cpu dst ptr tmp

arch/riscv/include/asm/asm.h

93

.macro asm_per_cpu dst sym tmp

arch/riscv/include/asm/processor.h

190

extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);

arch/riscv/include/asm/string.h

35

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/riscv/include/asm/string.h

37

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/riscv/include/asm/thread_info.h

102

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);

arch/riscv/include/asm/uaccess.h

450

#define arch_get_kernel_nofault(dst, src, type, err_label) \

arch/riscv/include/asm/uaccess.h

451

__get_user_nocheck(*((type *)(dst)), (__force __user type *)(src), err_label)

arch/riscv/include/asm/uaccess.h

453

#define arch_put_kernel_nofault(dst, src, type, err_label) \

arch/riscv/include/asm/uaccess.h

454

__put_user_nocheck(*((type *)(src)), (__force __user type *)(dst), err_label)

arch/riscv/kernel/copy-unaligned.h

10

void __riscv_copy_words_unaligned(void *dst, const void *src, size_t size);

arch/riscv/kernel/copy-unaligned.h

11

void __riscv_copy_bytes_unaligned(void *dst, const void *src, size_t size);

arch/riscv/kernel/copy-unaligned.h

14

void __riscv_copy_vec_words_unaligned(void *dst, const void *src, size_t size);

arch/riscv/kernel/copy-unaligned.h

15

void __riscv_copy_vec_bytes_unaligned(void *dst, const void *src, size_t size);

arch/riscv/kernel/probes/uprobes.c

169

void *dst = kaddr + (vaddr & ~PAGE_MASK);

arch/riscv/kernel/probes/uprobes.c

170

unsigned long start = (unsigned long)dst;

arch/riscv/kernel/probes/uprobes.c

172

memcpy(dst, src, len);

arch/riscv/kernel/probes/uprobes.c

176

dst += GET_INSN_LENGTH(*(probe_opcode_t *)src);

arch/riscv/kernel/probes/uprobes.c

177

*(uprobe_opcode_t *)dst = __BUG_INSN_32;

arch/riscv/kernel/process.c

214

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/riscv/kernel/process.c

217

*dst = *src;

arch/riscv/kernel/process.c

219

memset(&dst->thread.vstate, 0, sizeof(struct __riscv_v_ext_state));

arch/riscv/kernel/process.c

220

memset(&dst->thread.kernel_vstate, 0, sizeof(struct __riscv_v_ext_state));

arch/riscv/kernel/process.c

221

clear_tsk_thread_flag(dst, TIF_RISCV_V_DEFER_RESTORE);

arch/riscv/kernel/unaligned_access_speed.c

290

void *dst;

arch/riscv/kernel/unaligned_access_speed.c

304

dst = (void *)((unsigned long)page_address(page) | 0x1);

arch/riscv/kernel/unaligned_access_speed.c

306

src = dst + (MISALIGNED_BUFFER_SIZE / 2);

arch/riscv/kernel/unaligned_access_speed.c

312

__riscv_copy_vec_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

326

__riscv_copy_vec_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

335

__riscv_copy_vec_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

344

__riscv_copy_vec_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

42

void *dst;

arch/riscv/kernel/unaligned_access_speed.c

50

dst = (void *)((unsigned long)page_address(page) | 0x1);

arch/riscv/kernel/unaligned_access_speed.c

52

src = dst + (MISALIGNED_BUFFER_SIZE / 2);

arch/riscv/kernel/unaligned_access_speed.c

56

__riscv_copy_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

70

__riscv_copy_words_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

79

__riscv_copy_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/kernel/unaligned_access_speed.c

87

__riscv_copy_bytes_unaligned(dst, src, MISALIGNED_COPY_SIZE);

arch/riscv/lib/riscv_v_helpers.c

18

int __asm_vector_usercopy(void *dst, void *src, size_t n);

arch/riscv/lib/riscv_v_helpers.c

19

int __asm_vector_usercopy_sum_enabled(void *dst, void *src, size_t n);

arch/riscv/lib/riscv_v_helpers.c

20

int fallback_scalar_usercopy(void *dst, void *src, size_t n);

arch/riscv/lib/riscv_v_helpers.c

21

int fallback_scalar_usercopy_sum_enabled(void *dst, void *src, size_t n);

arch/riscv/lib/riscv_v_helpers.c

22

asmlinkage int enter_vector_usercopy(void *dst, void *src, size_t n,

arch/riscv/lib/riscv_v_helpers.c

32

remain = enable_sum ? __asm_vector_usercopy(dst, src, n) :

arch/riscv/lib/riscv_v_helpers.c

33

__asm_vector_usercopy_sum_enabled(dst, src, n);

arch/riscv/lib/riscv_v_helpers.c

38

dst += copied;

arch/riscv/lib/riscv_v_helpers.c

47

return enable_sum ? fallback_scalar_usercopy(dst, src, n) :

arch/riscv/lib/riscv_v_helpers.c

48

fallback_scalar_usercopy_sum_enabled(dst, src, n);

arch/riscv/net/bpf_jit_comp32.c

1011

emit_alu_i64(dst, imm, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1017

emit_zext64(dst, ctx);

arch/riscv/net/bpf_jit_comp32.c

1044

emit_alu_r32(dst, src, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1060

emit_alu_i32(dst, imm, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1068

emit_alu_r32(dst, tmp2, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1073

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

1092

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

1098

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

1126

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

1218

emit_branch_r64(dst, src, rvoff, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1220

emit_branch_r32(dst, src, rvoff, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

1236

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

1239

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

1247

if (emit_load_r64(dst, src, off, ctx, BPF_SIZE(code)))

arch/riscv/net/bpf_jit_comp32.c

1269

if (emit_store_r64(dst, src, off, ctx, BPF_SIZE(code),

arch/riscv/net/bpf_jit_comp32.c

1282

if (emit_store_r64(dst, src, off, ctx, BPF_SIZE(code),

arch/riscv/net/bpf_jit_comp32.c

243

static void emit_alu_i64(const s8 *dst, s32 imm,

arch/riscv/net/bpf_jit_comp32.c

247

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

324

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

327

static void emit_alu_i32(const s8 *dst, s32 imm,

arch/riscv/net/bpf_jit_comp32.c

331

const s8 *rd = bpf_get_reg32(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

403

bpf_put_reg32(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

406

static void emit_alu_r64(const s8 *dst, const s8 *src,

arch/riscv/net/bpf_jit_comp32.c

411

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

508

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

511

static void emit_alu_r32(const s8 *dst, const s8 *src,

arch/riscv/net/bpf_jit_comp32.c

516

const s8 *rd = bpf_get_reg32(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

561

bpf_put_reg32(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

835

static int emit_load_r64(const s8 *dst, const s8 *src, s16 off,

arch/riscv/net/bpf_jit_comp32.c

840

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

868

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

872

static int emit_store_r64(const s8 *dst, const s8 *src, s16 off,

arch/riscv/net/bpf_jit_comp32.c

878

const s8 *rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

943

static void emit_zext64(const s8 *dst, struct rv_jit_context *ctx)

arch/riscv/net/bpf_jit_comp32.c

948

rd = bpf_get_reg64(dst, tmp1, ctx);

arch/riscv/net/bpf_jit_comp32.c

950

bpf_put_reg64(dst, rd, ctx);

arch/riscv/net/bpf_jit_comp32.c

963

const s8 *dst = bpf2rv32[insn->dst_reg];

arch/riscv/net/bpf_jit_comp32.c

991

emit_alu_r64(dst, src, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_comp32.c

995

emit_alu_r64(dst, tmp2, ctx, BPF_OP(code));

arch/riscv/net/bpf_jit_core.c

222

void *bpf_arch_text_copy(void *dst, void *src, size_t len)

arch/riscv/net/bpf_jit_core.c

227

ret = patch_text_nosync(dst, src, len);

arch/riscv/net/bpf_jit_core.c

233

return dst;

arch/riscv/net/bpf_jit_core.c

236

int bpf_arch_text_invalidate(void *dst, size_t len)

arch/riscv/net/bpf_jit_core.c

241

ret = patch_text_set_nosync(dst, 0, len);

arch/s390/boot/printk.c

114

return p - dst;

arch/s390/boot/printk.c

57

static char *as_hex(char *dst, unsigned long val, int pad)

arch/s390/boot/printk.c

59

char *p = dst + max(pad, (int)__fls(val | 1) / 4 + 1);

arch/s390/boot/printk.c

61

for (*p-- = '\0'; p >= dst; val >>= 4)

arch/s390/boot/printk.c

63

return dst;

arch/s390/boot/printk.c

88

static ssize_t strpad(char *dst, size_t dst_size, const char *src,

arch/s390/boot/printk.c

92

char *p = dst;

arch/s390/boot/string.c

32

ssize_t sized_strscpy(char *dst, const char *src, size_t count)

arch/s390/boot/string.c

39

memcpy(dst, src, len);

arch/s390/boot/string.c

40

dst[len] = '\0';

arch/s390/crypto/aes_s390.c

136

walk.dst.virt.addr, walk.src.virt.addr, n);

arch/s390/crypto/aes_s390.c

240

walk.dst.virt.addr, walk.src.virt.addr, n);

arch/s390/crypto/aes_s390.c

366

walk.dst.virt.addr, walk.src.virt.addr, n);

arch/s390/crypto/aes_s390.c

494

walk.dst.virt.addr, walk.src.virt.addr, n);

arch/s390/crypto/aes_s390.c

586

cpacf_kmctr(sctx->fc, sctx->key, walk.dst.virt.addr,

arch/s390/crypto/aes_s390.c

604

memcpy(walk.dst.virt.addr, buf, nbytes);

arch/s390/crypto/aes_s390.c

864

gcm_walk_start(&gw_out, req->dst, len);

arch/s390/crypto/aes_s390.c

911

scatterwalk_map_and_copy(param.t, req->dst, len, taglen, 1);

arch/s390/crypto/des_s390.c

101

cpacf_km(fc, ctx->key, walk.dst.virt.addr,

arch/s390/crypto/des_s390.c

128

cpacf_kmc(fc, &param, walk.dst.virt.addr,

arch/s390/crypto/des_s390.c

220

static void des3_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/s390/crypto/des_s390.c

224

cpacf_km(CPACF_KM_TDEA_192, ctx->key, dst, src, DES_BLOCK_SIZE);

arch/s390/crypto/des_s390.c

227

static void des3_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/s390/crypto/des_s390.c

232

ctx->key, dst, src, DES_BLOCK_SIZE);

arch/s390/crypto/des_s390.c

335

cpacf_kmctr(fc, ctx->key, walk.dst.virt.addr,

arch/s390/crypto/des_s390.c

349

memcpy(walk.dst.virt.addr, buf, nbytes);

arch/s390/crypto/ghash_s390.c

77

unsigned int len, u8 *dst)

arch/s390/crypto/ghash_s390.c

82

memcpy(dst, dctx->icv, GHASH_BLOCK_SIZE);

arch/s390/crypto/paes_s390.c

1031

memcpy(walk->dst.virt.addr, buf, nbytes);

arch/s390/crypto/paes_s390.c

1312

walk->dst.virt.addr, walk->src.virt.addr, n);

arch/s390/crypto/paes_s390.c

1406

walk->dst.virt.addr, walk->src.virt.addr, n);

arch/s390/crypto/paes_s390.c

434

walk->dst.virt.addr, walk->src.virt.addr, n);

arch/s390/crypto/paes_s390.c

698

walk->dst.virt.addr, walk->src.virt.addr, n);

arch/s390/crypto/paes_s390.c

981

k = cpacf_kmctr(ctx->fc, param, walk->dst.virt.addr,

arch/s390/include/asm/checksum.h

38

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/s390/include/asm/cpacf.h

420

: [src] "+&d" (s.pair), [dst] "+&d" (d.pair)

arch/s390/include/asm/cpacf.h

452

: [src] "+&d" (s.pair), [dst] "+&d" (d.pair)

arch/s390/include/asm/cpacf.h

584

: [src] "+&d" (s.pair), [dst] "+&d" (d.pair),

arch/s390/include/asm/cpacf.h

618

: [dst] "+&d" (d.pair)

arch/s390/include/asm/cpacf.h

729

: [dst] "+&d" (d.pair), [src] "+&d" (s.pair),

arch/s390/include/asm/io.h

61

#define memcpy_fromio(dst, src, count) zpci_memcpy_fromio(dst, src, count)

arch/s390/include/asm/io.h

62

#define memcpy_toio(dst, src, count) zpci_memcpy_toio(dst, src, count)

arch/s390/include/asm/io.h

63

#define memset_io(dst, val, count) zpci_memset_io(dst, val, count)

arch/s390/include/asm/maccess.h

17

int copy_oldmem_kernel(void *dst, unsigned long src, size_t count);

arch/s390/include/asm/page.h

55

union register_pair dst, src;

arch/s390/include/asm/page.h

57

dst.even = (unsigned long) to;

arch/s390/include/asm/page.h

58

dst.odd = 0x1000;

arch/s390/include/asm/page.h

64

: [dst] "+&d" (dst.pair), [src] "+&d" (src.pair)

arch/s390/include/asm/pci_io.h

100

static inline int zpci_read_single(void *dst, const volatile void __iomem *src,

arch/s390/include/asm/pci_io.h

112

*((u8 *) dst) = (u8) data;

arch/s390/include/asm/pci_io.h

115

*((u16 *) dst) = (u16) data;

arch/s390/include/asm/pci_io.h

118

*((u32 *) dst) = (u32) data;

arch/s390/include/asm/pci_io.h

121

*((u64 *) dst) = (u64) data;

arch/s390/include/asm/pci_io.h

128

int zpci_write_block(volatile void __iomem *dst, const void *src,

arch/s390/include/asm/pci_io.h

131

static inline int zpci_get_max_io_size(u64 src, u64 dst, int len, int max)

arch/s390/include/asm/pci_io.h

133

int offset = dst & ZPCI_BOUNDARY_MASK;

arch/s390/include/asm/pci_io.h

137

if (IS_ALIGNED(src, 8) && IS_ALIGNED(dst, 8) && IS_ALIGNED(size, 8))

arch/s390/include/asm/pci_io.h

145

static inline int zpci_memcpy_fromio(void *dst,

arch/s390/include/asm/pci_io.h

153

(u64) dst, n,

arch/s390/include/asm/pci_io.h

155

rc = zpci_read_single(dst, src, size);

arch/s390/include/asm/pci_io.h

159

dst += size;

arch/s390/include/asm/pci_io.h

165

static inline int zpci_memcpy_toio(volatile void __iomem *dst,

arch/s390/include/asm/pci_io.h

174

size = zpci_get_max_io_size((u64 __force) dst,

arch/s390/include/asm/pci_io.h

178

rc = zpci_write_block(dst, src, size);

arch/s390/include/asm/pci_io.h

180

rc = zpci_write_single(dst, src, size);

arch/s390/include/asm/pci_io.h

184

dst += size;

arch/s390/include/asm/pci_io.h

190

static inline int zpci_memset_io(volatile void __iomem *dst,

arch/s390/include/asm/pci_io.h

200

rc = zpci_memcpy_toio(dst, src, count);

arch/s390/include/asm/pci_io.h

75

static inline int zpci_write_single(volatile void __iomem *dst, const void *src,

arch/s390/include/asm/pci_io.h

97

return zpci_store(dst, val, len);

arch/s390/include/asm/sclp.h

193

void sclp_ocf_cpc_name_copy(char *dst);

arch/s390/include/asm/string.h

137

static inline char *strcat(char *dst, const char *src)

arch/s390/include/asm/string.h

140

char *ret = dst;

arch/s390/include/asm/string.h

148

: [dummy] "+&a" (dummy), [dst] "+&a" (dst), [src] "+&a" (src)

arch/s390/include/asm/string.h

191

char *strcat(char *dst, const char *src);

arch/s390/include/asm/sysinfo.h

230

int sthyi_fill(void *dst, u64 *rc);

arch/s390/include/asm/uaccess.h

363

long __must_check strncpy_from_user(char *dst, const char __user *src, long count);

arch/s390/include/asm/uaccess.h

400

void *__s390_kernel_write(void *dst, const void *src, size_t size);

arch/s390/include/asm/uaccess.h

402

static inline void *s390_kernel_write(void *dst, const void *src, size_t size)

arch/s390/include/asm/uaccess.h

405

return memcpy(dst, src, size);

arch/s390/include/asm/uaccess.h

406

return __s390_kernel_write(dst, src, size);

arch/s390/include/asm/uaccess.h

413

#define __mvc_kernel_nofault(dst, src, type, err_label) \

arch/s390/include/asm/uaccess.h

425

: [_dst] "=Q" (*(type *)dst) \

arch/s390/include/asm/uaccess.h

439

#define __mvc_kernel_nofault(dst, src, type, err_label) \

arch/s390/include/asm/uaccess.h

441

type *(__dst) = (type *)(dst); \

arch/s390/kernel/crash_dump.c

149

int copy_oldmem_kernel(void *dst, unsigned long src, size_t count)

arch/s390/kernel/crash_dump.c

154

kvec.iov_base = dst;

arch/s390/kernel/dis.c

491

static int copy_from_regs(struct pt_regs *regs, void *dst, void *src, int len)

arch/s390/kernel/dis.c

494

if (copy_from_user(dst, (char __user *)src, len))

arch/s390/kernel/dis.c

497

if (copy_from_kernel_nofault(dst, src, len))

arch/s390/kernel/ipl.c

1097

static void reipl_get_ascii_nss_name(char *dst,

arch/s390/kernel/ipl.c

1100

memcpy(dst, ipb->ccw.nss_name, NSS_NAME_SIZE);

arch/s390/kernel/ipl.c

1101

EBCASC(dst, NSS_NAME_SIZE);

arch/s390/kernel/ipl.c

1102

dst[NSS_NAME_SIZE] = 0;

arch/s390/kernel/ipl.c

2276

static void __init strscpy_skip_quote(char *dst, char *src, int n)

arch/s390/kernel/ipl.c

2285

dst[dx] = src[sx];

arch/s390/kernel/ipl.c

2290

dst[dx] = '\0';

arch/s390/kernel/lgr.c

58

static void cpascii(char *dst, char *src, int size)

arch/s390/kernel/lgr.c

60

memcpy(dst, src, size);

arch/s390/kernel/lgr.c

61

EBCASC(dst, size);

arch/s390/kernel/process.c

100

dst->thread.gs_cb = NULL;

arch/s390/kernel/process.c

101

dst->thread.gs_bc_cb = NULL;

arch/s390/kernel/process.c

85

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/s390/kernel/process.c

89

*dst = *src;

arch/s390/kernel/process.c

90

dst->thread.kfpu_flags = 0;

arch/s390/kernel/process.c

99

dst->thread.ri_cb = NULL;

arch/s390/kernel/sthyi.c

439

static int fill_dst(void *dst, u64 *rc)

arch/s390/kernel/sthyi.c

443

struct sthyi_sctns *sctns = (struct sthyi_sctns *)dst;

arch/s390/kernel/sthyi.c

450

memset(dst, 0, PAGE_SIZE);

arch/s390/kernel/sthyi.c

451

return sthyi((u64)dst, rc);

arch/s390/kernel/sthyi.c

461

memset(dst, 0, PAGE_SIZE);

arch/s390/kernel/sthyi.c

507

int sthyi_fill(void *dst, u64 *rc)

arch/s390/kernel/sthyi.c

523

memcpy(dst, sthyi_cache.info, PAGE_SIZE);

arch/s390/kernel/topology.c

116

cpumask_copy(dst, &mask);

arch/s390/kernel/topology.c

67

static void cpu_group_map(cpumask_t *dst, struct mask_info *info, unsigned int cpu)

arch/s390/kernel/topology.c

95

cpumask_copy(dst, &mask);

arch/s390/kernel/topology.c

98

static void cpu_thread_map(cpumask_t *dst, unsigned int cpu)

arch/s390/kvm/kvm-s390.c

1851

struct kvm_s390_vm_cpu_uv_feat __user *dst = (void __user *)attr->addr;

arch/s390/kvm/kvm-s390.c

1854

if (put_user(feat, &dst->feat))

arch/s390/kvm/kvm-s390.c

1863

struct kvm_s390_vm_cpu_uv_feat __user *dst = (void __user *)attr->addr;

arch/s390/kvm/kvm-s390.c

1866

BUILD_BUG_ON(sizeof(*dst) != sizeof(uv_info.uv_feature_indications));

arch/s390/kvm/kvm-s390.c

1869

if (put_user(feat, &dst->feat))

arch/s390/lib/csum-partial.c

19

static __always_inline __wsum csum_copy(void *dst, const void *src, int len, __wsum sum, bool copy)

arch/s390/lib/csum-partial.c

25

memcpy(dst, src, len);

arch/s390/lib/csum-partial.c

26

return cksm(dst, len, sum);

arch/s390/lib/csum-partial.c

36

fpu_vstm(20, 23, dst);

arch/s390/lib/csum-partial.c

37

dst += 64;

arch/s390/lib/csum-partial.c

49

fpu_vstm(20, 21, dst);

arch/s390/lib/csum-partial.c

50

dst += 32;

arch/s390/lib/csum-partial.c

60

fpu_vst(20, dst);

arch/s390/lib/csum-partial.c

61

dst += 16;

arch/s390/lib/csum-partial.c

70

fpu_vstl(20, len - 1, dst);

arch/s390/lib/csum-partial.c

87

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/s390/lib/csum-partial.c

89

return csum_copy(dst, src, len, 0, true);

arch/s390/mm/maccess.c

28

static notrace long s390_kernel_write_odd(void *dst, const void *src, size_t size)

arch/s390/mm/maccess.c

33

aligned = (unsigned long) dst & ~7UL;

arch/s390/mm/maccess.c

34

offset = (unsigned long) dst & 7UL;

arch/s390/mm/maccess.c

65

notrace void *__s390_kernel_write(void *dst, const void *src, size_t size)

arch/s390/mm/maccess.c

67

void *tmp = dst;

arch/s390/mm/maccess.c

80

return dst;

arch/s390/pci/pci_insn.c

398

static inline int zpci_write_block_fh(volatile void __iomem *dst,

arch/s390/pci/pci_insn.c

401

struct zpci_iomap_entry *entry = &zpci_iomap_start[ZPCI_IDX(dst)];

arch/s390/pci/pci_insn.c

403

u64 offset = ZPCI_OFFSET(dst);

arch/s390/pci/pci_insn.c

426

int zpci_write_block(volatile void __iomem *dst,

arch/s390/pci/pci_insn.c

433

return zpci_write_block_fh(dst, src, len);

arch/s390/pci/pci_insn.c

435

cc = __pcistb_mio(src, (__force u64) dst, len, &status);

arch/s390/pci/pci_insn.c

437

zpci_err_insn_addr(0, 'B', cc, status, (__force u64) dst, len);

arch/s390/pci/pci_mmio.c

100

static inline int __memcpy_toio_inuser(void __iomem *dst,

arch/s390/pci/pci_mmio.c

110

size = zpci_get_max_io_size((u64 __force) dst,

arch/s390/pci/pci_mmio.c

114

rc = __pcistb_mio_inuser(dst, src, size, &status);

arch/s390/pci/pci_mmio.c

116

rc = __pcistg_mio_inuser(dst, src, size, &status);

arch/s390/pci/pci_mmio.c

120

dst += size;

arch/s390/pci/pci_mmio.c

124

zpci_err_mmio(rc, status, (__force u64) dst);

arch/s390/pci/pci_mmio.c

209

void __user *dst, const void __iomem *ioaddr,

arch/s390/pci/pci_mmio.c

246

[dst] "+a" (dst), [cnt] "+d" (cnt), [tmp] "=d" (tmp),

arch/s390/pci/pci_mmio.c

260

static inline int __memcpy_fromio_inuser(void __user *dst,

arch/s390/pci/pci_mmio.c

269

(u64 __force) dst, n,

arch/s390/pci/pci_mmio.c

271

rc = __pcilg_mio_inuser(dst, src, size, &status);

arch/s390/pci/pci_mmio.c

275

dst += size;

arch/s390/pci/pci_mmio.c

279

zpci_err_mmio(rc, status, (__force u64) dst);

arch/sh/include/asm/cacheflush.h

85

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/sh/include/asm/cacheflush.h

89

struct page *page, unsigned long vaddr, void *dst, const void *src,

arch/sh/include/asm/checksum_32.h

197

void __user *dst,

arch/sh/include/asm/checksum_32.h

200

if (!access_ok(dst, len))

arch/sh/include/asm/checksum_32.h

202

return csum_partial_copy_generic(src, (__force void *)dst, len);

arch/sh/include/asm/checksum_32.h

34

asmlinkage __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/sh/include/asm/checksum_32.h

45

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/sh/include/asm/checksum_32.h

47

return csum_partial_copy_generic(src, dst, len);

arch/sh/include/asm/checksum_32.h

52

__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/sh/include/asm/checksum_32.h

56

return csum_partial_copy_generic((__force const void *)src, dst, len);

arch/sh/include/asm/io_noioport.h

49

static inline void insb(unsigned long port, void *dst, unsigned long count)

arch/sh/include/asm/io_noioport.h

54

static inline void insw(unsigned long port, void *dst, unsigned long count)

arch/sh/include/asm/io_noioport.h

59

static inline void insl(unsigned long port, void *dst, unsigned long count)

arch/sh/include/asm/uaccess.h

126

unsigned long (*from)(void *dst, const void __user *src, unsigned long cnt);

arch/sh/include/asm/uaccess.h

127

unsigned long (*to)(void __user *dst, const void *src, unsigned long cnt);

arch/sh/kernel/dwarf.c

128

static inline int dwarf_read_addr(unsigned long *src, unsigned long *dst)

arch/sh/kernel/dwarf.c

131

put_unaligned(val, dst);

arch/sh/kernel/io.c

103

void memset_io(volatile void __iomem *dst, int c, unsigned long count)

arch/sh/kernel/io.c

107

writeb(c, dst);

arch/sh/kernel/io.c

108

dst++;

arch/sh/kernel/io_trapped.c

221

static unsigned long from_device(void *dst, const void *src, unsigned long cnt)

arch/sh/kernel/io_trapped.c

238

(unsigned long)dst, cnt);

arch/sh/kernel/io_trapped.c

244

static unsigned long to_device(void *dst, const void *src, unsigned long cnt)

arch/sh/kernel/io_trapped.c

247

unsigned long dst_addr = (unsigned long)dst;

arch/sh/kernel/process.c

24

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/sh/kernel/process.c

27

*dst = *src;

arch/sh/kernel/process.c

30

dst->thread.xstate = kmem_cache_alloc(task_xstate_cachep,

arch/sh/kernel/process.c

32

if (!dst->thread.xstate)

arch/sh/kernel/process.c

34

memcpy(dst->thread.xstate, src->thread.xstate, xstate_size);

arch/sh/kernel/traps_32.c

108

unsigned char *src, *dst;

arch/sh/kernel/traps_32.c

133

dst = (unsigned char *)rn;

arch/sh/kernel/traps_32.c

134

*(unsigned long *)dst = 0;

arch/sh/kernel/traps_32.c

137

dst += 4-count;

arch/sh/kernel/traps_32.c

139

if (ma->from(dst, srcu, count))

arch/sh/kernel/traps_32.c

142

sign_extend(count, dst);

arch/sh/kernel/traps_32.c

184

dst = (unsigned char *)rn;

arch/sh/kernel/traps_32.c

185

*(unsigned long *)dst = 0;

arch/sh/kernel/traps_32.c

187

if (ma->from(dst, srcu, 4))

arch/sh/kernel/traps_32.c

196

dst = (unsigned char*) rn;

arch/sh/kernel/traps_32.c

197

*(unsigned long*)dst = 0;

arch/sh/kernel/traps_32.c

200

dst += 4-count;

arch/sh/kernel/traps_32.c

202

if (ma->from(dst, srcu, count))

arch/sh/kernel/traps_32.c

204

sign_extend(count, dst);

arch/sh/kernel/traps_32.c

226

dst = (unsigned char *) &regs->regs[0];

arch/sh/kernel/traps_32.c

227

*(unsigned long *)dst = 0;

arch/sh/kernel/traps_32.c

230

dst += 2;

arch/sh/kernel/traps_32.c

232

if (ma->from(dst, srcu, 2))

arch/sh/kernel/traps_32.c

234

sign_extend(2, dst);

arch/sh/kernel/traps_32.c

244

dst = (unsigned char *)rn;

arch/sh/kernel/traps_32.c

245

*(unsigned long *)dst = 0;

arch/sh/kernel/traps_32.c

248

dst += 2;

arch/sh/kernel/traps_32.c

251

if (ma->from(dst, srcu, 2))

arch/sh/kernel/traps_32.c

253

sign_extend(2, dst);

arch/sh/kernel/traps_32.c

261

dst = (unsigned char *)rn;

arch/sh/kernel/traps_32.c

262

*(unsigned long *)dst = 0;

arch/sh/kernel/traps_32.c

264

if (ma->from(dst, srcu, 4))

arch/sh/kernel/traps_32.c

49

static inline void sign_extend(unsigned int count, unsigned char *dst)

arch/sh/kernel/traps_32.c

52

if ((count == 1) && dst[0] & 0x80) {

arch/sh/kernel/traps_32.c

53

dst[1] = 0xff;

arch/sh/kernel/traps_32.c

54

dst[2] = 0xff;

arch/sh/kernel/traps_32.c

55

dst[3] = 0xff;

arch/sh/kernel/traps_32.c

57

if ((count == 2) && dst[1] & 0x80) {

arch/sh/kernel/traps_32.c

58

dst[2] = 0xff;

arch/sh/kernel/traps_32.c

59

dst[3] = 0xff;

arch/sh/kernel/traps_32.c

62

if ((count == 1) && dst[3] & 0x80) {

arch/sh/kernel/traps_32.c

63

dst[2] = 0xff;

arch/sh/kernel/traps_32.c

64

dst[1] = 0xff;

arch/sh/kernel/traps_32.c

65

dst[0] = 0xff;

arch/sh/kernel/traps_32.c

67

if ((count == 2) && dst[2] & 0x80) {

arch/sh/kernel/traps_32.c

68

dst[1] = 0xff;

arch/sh/kernel/traps_32.c

69

dst[0] = 0xff;

arch/sh/kernel/traps_32.c

79

static unsigned long copy_from_kernel_wrapper(void *dst, const void __user *src,

arch/sh/kernel/traps_32.c

82

return copy_from_kernel_nofault(dst, (const void __force *)src, cnt);

arch/sh/kernel/traps_32.c

85

static unsigned long copy_to_kernel_wrapper(void __user *dst, const void *src,

arch/sh/kernel/traps_32.c

88

return copy_to_kernel_nofault((void __force *)dst, src, cnt);

arch/sh/mm/cache.c

61

unsigned long vaddr, void *dst, const void *src,

arch/sh/mm/cache.c

72

memcpy(dst, src, len);

arch/sh/mm/cache.c

82

unsigned long vaddr, void *dst, const void *src,

arch/sh/mm/cache.c

90

memcpy(dst, vfrom, len);

arch/sh/mm/cache.c

93

memcpy(dst, src, len);

arch/sparc/crypto/aes_glue.c

132

walk.dst.virt.addr,

arch/sparc/crypto/aes_glue.c

157

walk.dst.virt.addr,

arch/sparc/crypto/aes_glue.c

181

walk.dst.virt.addr,

arch/sparc/crypto/aes_glue.c

207

walk.dst.virt.addr,

arch/sparc/crypto/aes_glue.c

223

u8 *dst = walk->dst.virt.addr;

arch/sparc/crypto/aes_glue.c

228

crypto_xor_cpy(dst, (u8 *) keystream, src, nbytes);

arch/sparc/crypto/aes_glue.c

247

walk.dst.virt.addr,

arch/sparc/crypto/camellia_glue.c

111

op(walk.src.virt.addr, walk.dst.virt.addr,

arch/sparc/crypto/camellia_glue.c

158

op(walk.src.virt.addr, walk.dst.virt.addr,

arch/sparc/crypto/camellia_glue.c

187

op(walk.src.virt.addr, walk.dst.virt.addr,

arch/sparc/crypto/camellia_glue.c

61

static void camellia_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/camellia_glue.c

67

(u32 *) dst, ctx->key_len);

arch/sparc/crypto/camellia_glue.c

70

static void camellia_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/camellia_glue.c

76

(u32 *) dst, ctx->key_len);

arch/sparc/crypto/des_glue.c

111

des_sparc64_ecb_crypt(walk.src.virt.addr, walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

154

walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

160

walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

222

static void sparc_des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/des_glue.c

227

des3_ede_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);

arch/sparc/crypto/des_glue.c

230

static void sparc_des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/des_glue.c

235

des3_ede_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);

arch/sparc/crypto/des_glue.c

263

walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

310

walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

316

walk.dst.virt.addr,

arch/sparc/crypto/des_glue.c

73

static void sparc_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/des_glue.c

78

des_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);

arch/sparc/crypto/des_glue.c

81

static void sparc_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/sparc/crypto/des_glue.c

86

des_sparc64_crypt(K, (const u64 *) src, (u64 *) dst);

arch/sparc/include/asm/cacheflush_32.h

20

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/sparc/include/asm/cacheflush_32.h

23

memcpy(dst, src, len); \

arch/sparc/include/asm/cacheflush_32.h

25

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/sparc/include/asm/cacheflush_32.h

28

memcpy(dst, src, len); \

arch/sparc/include/asm/cacheflush_64.h

60

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/sparc/include/asm/cacheflush_64.h

63

memcpy(dst, src, len); \

arch/sparc/include/asm/cacheflush_64.h

67

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/sparc/include/asm/cacheflush_64.h

70

memcpy(dst, src, len); \

arch/sparc/include/asm/cacheflush_64.h

71

flush_ptrace_access(vma, page, vaddr, dst, len, 1); \

arch/sparc/include/asm/checksum_32.h

45

csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/sparc/include/asm/checksum_32.h

48

register char *d asm("o1") = dst;

arch/sparc/include/asm/checksum_32.h

63

csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/sparc/include/asm/checksum_32.h

67

return csum_partial_copy_nocheck((__force void *)src, dst, len);

arch/sparc/include/asm/checksum_32.h

71

csum_and_copy_to_user(const void *src, void __user *dst, int len)

arch/sparc/include/asm/checksum_32.h

73

if (!access_ok(dst, len))

arch/sparc/include/asm/checksum_32.h

75

return csum_partial_copy_nocheck(src, (__force void *)dst, len);

arch/sparc/include/asm/checksum_64.h

41

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/sparc/include/asm/checksum_64.h

42

__wsum csum_and_copy_from_user(const void __user *src, void *dst, int len);

arch/sparc/include/asm/checksum_64.h

43

__wsum csum_and_copy_to_user(const void *src, void __user *dst, int len);

arch/sparc/include/asm/io_32.h

104

static inline void sbus_memcpy_fromio(void *dst,

arch/sparc/include/asm/io_32.h

108

char *d = dst;

arch/sparc/include/asm/io_32.h

117

static inline void sbus_memcpy_toio(volatile void __iomem *dst,

arch/sparc/include/asm/io_32.h

122

volatile void __iomem *d = dst;

arch/sparc/include/asm/io_32.h

23

static inline void _memset_io(volatile void __iomem *dst,

arch/sparc/include/asm/io_32.h

26

volatile void __iomem *d = dst;

arch/sparc/include/asm/io_32.h

34

static inline void _memcpy_fromio(void *dst, const volatile void __iomem *src,

arch/sparc/include/asm/io_32.h

37

char *d = dst;

arch/sparc/include/asm/io_32.h

46

static inline void _memcpy_toio(volatile void __iomem *dst, const void *src,

arch/sparc/include/asm/io_32.h

50

volatile void __iomem *d = dst;

arch/sparc/include/asm/io_64.h

344

static inline void sbus_memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)

arch/sparc/include/asm/io_64.h

347

sbus_writeb(c, dst);

arch/sparc/include/asm/io_64.h

348

dst++;

arch/sparc/include/asm/io_64.h

352

static inline void memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)

arch/sparc/include/asm/io_64.h

354

volatile void __iomem *d = dst;

arch/sparc/include/asm/io_64.h

363

static inline void sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,

arch/sparc/include/asm/io_64.h

366

char *d = dst;

arch/sparc/include/asm/io_64.h

376

static inline void memcpy_fromio(void *dst, const volatile void __iomem *src,

arch/sparc/include/asm/io_64.h

379

char *d = dst;

arch/sparc/include/asm/io_64.h

389

static inline void sbus_memcpy_toio(volatile void __iomem *dst, const void *src,

arch/sparc/include/asm/io_64.h

393

volatile void __iomem *d = dst;

arch/sparc/include/asm/io_64.h

402

static inline void memcpy_toio(volatile void __iomem *dst, const void *src,

arch/sparc/include/asm/io_64.h

406

volatile void __iomem *d = dst;

arch/sparc/include/asm/uaccess_64.h

147

#define __get_kernel_nofault(dst, src, type, label) \

arch/sparc/include/asm/uaccess_64.h

164

*(type *)dst = (__force type) __gu_val; \

arch/sparc/include/asm/uaccess_64.h

77

#define __put_kernel_nofault(dst, src, type, label) \

arch/sparc/include/asm/uaccess_64.h

79

type *addr = (type __force *)(dst); \

arch/sparc/kernel/btext.c

114

unsigned int *dst = (unsigned int *)calc_base(0,0);

arch/sparc/kernel/btext.c

122

unsigned int *dst_ptr = dst;

arch/sparc/kernel/btext.c

126

dst += (dispDeviceRowBytes >> 2);

arch/sparc/kernel/btext.c

130

unsigned int *dst_ptr = dst;

arch/sparc/kernel/btext.c

133

dst += (dispDeviceRowBytes >> 2);

arch/sparc/kernel/process_32.c

218

clone_stackframe(struct sparc_stackf __user *dst,

arch/sparc/kernel/process_32.c

230

fp = (unsigned long) dst;

arch/sparc/kernel/process_64.c

651

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/sparc/kernel/process_64.c

668

*dst = *src;

arch/sparc/lib/PeeCeeI.c

116

void insw(unsigned long __addr, void *dst, unsigned long count)

arch/sparc/lib/PeeCeeI.c

121

u16 *ps = dst;

arch/sparc/lib/PeeCeeI.c

144

void insl(unsigned long __addr, void *dst, unsigned long count)

arch/sparc/lib/PeeCeeI.c

149

if ((((unsigned long)dst) & 0x3) == 0) {

arch/sparc/lib/PeeCeeI.c

150

u32 *pi = dst;

arch/sparc/lib/PeeCeeI.c

158

switch (((unsigned long)dst) & 3) {

arch/sparc/lib/PeeCeeI.c

160

ps = dst;

arch/sparc/lib/PeeCeeI.c

175

pb = dst;

arch/sparc/lib/PeeCeeI.c

192

pb = (u8 *)dst;

arch/sparc/lib/PeeCeeI.c

88

void insb(unsigned long __addr, void *dst, unsigned long count)

arch/sparc/lib/PeeCeeI.c

94

u8 *pb = dst;

arch/sparc/net/bpf_jit_comp_64.c

1004

emit_alu_K(SLL, dst, 16, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1005

emit_alu_K(SRL, dst, 16, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1011

emit_alu_K(SRL, dst, 0, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1028

emit_alu3_K(AND, dst, 0xff, tmp, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1029

emit_alu3_K(SRL, dst, 8, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1030

emit_alu3_K(AND, dst, 0xff, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1032

emit_alu(OR, tmp, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1039

emit_alu3_K(SRL, dst, 24, tmp, ctx); /* tmp = dst >> 24 */

arch/sparc/net/bpf_jit_comp_64.c

1040

emit_alu3_K(SRL, dst, 16, tmp2, ctx); /* tmp2 = dst >> 16 */

arch/sparc/net/bpf_jit_comp_64.c

1044

emit_alu3_K(SRL, dst, 8, tmp2, ctx); /* tmp2 = dst >> 8 */

arch/sparc/net/bpf_jit_comp_64.c

1048

emit_alu3_K(AND, dst, 0xff, dst, ctx); /* dst = dst & 0xff */

arch/sparc/net/bpf_jit_comp_64.c

1049

emit_alu3_K(SLL, dst, 24, dst, ctx); /* dst = dst << 24 */

arch/sparc/net/bpf_jit_comp_64.c

1050

emit_alu(OR, tmp, dst, ctx); /* dst = dst | tmp */

arch/sparc/net/bpf_jit_comp_64.c

1057

emit(ST64 | RS1(tmp) | RS2(G0) | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1058

emit(LD64A | ASI(ASI_PL) | RS1(tmp) | RS2(G0) | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1065

emit_loadimm32(imm, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1070

emit_loadimm_sext(imm, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1075

emit_alu_K(ADD, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1079

emit_alu_K(SUB, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1083

emit_alu_K(AND, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1087

emit_alu_K(OR, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1091

emit_alu_K(XOR, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1094

emit_alu_K(MUL, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1097

emit_alu_K(MULX, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1104

emit_alu_K(DIV, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1110

emit_alu_K(UDIVX, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1127

emit(div | IMMED | RS1(dst) | S13(imm) | RD(tmp), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1129

emit(SUB | RS1(dst) | RS2(tmp) | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1136

emit(div | RS1(dst) | RS2(tmp1) | RD(tmp), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1138

emit(SUB | RS1(dst) | RS2(tmp) | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1143

emit_alu_K(SLL, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1146

emit_alu_K(SLLX, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1149

emit_alu_K(SRL, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1154

emit_alu_K(SRLX, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1157

emit_alu_K(SRA, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1160

emit_alu_K(SRAX, dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1166

emit_alu_K(SRL, dst, 0, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1188

err = emit_compare_and_branch(code, dst, src, 0, false, i + off, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1207

err = emit_compare_and_branch(code, dst, 0, imm, true, i + off, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1249

emit_loadimm64(imm64, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1285

emit(opcode | RS1(src) | rs2 | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1331

emit(opcode | RS1(dst) | rs2 | RD(tmp2), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1368

emit(opcode | RS1(dst) | rs2 | RD(src), ctx);

arch/sparc/net/bpf_jit_comp_64.c

1391

emit_alu3(ADD, dst, tmp, tmp, ctx);

arch/sparc/net/bpf_jit_comp_64.c

1419

emit_alu3(ADD, dst, tmp, tmp, ctx);

arch/sparc/net/bpf_jit_comp_64.c

288

static void emit_alu(u32 opcode, u32 src, u32 dst, struct jit_ctx *ctx)

arch/sparc/net/bpf_jit_comp_64.c

290

emit(opcode | RS1(dst) | RS2(src) | RD(dst), ctx);

arch/sparc/net/bpf_jit_comp_64.c

298

static void emit_alu_K(unsigned int opcode, unsigned int dst, unsigned int imm,

arch/sparc/net/bpf_jit_comp_64.c

304

insn |= RS1(dst) | RD(dst);

arch/sparc/net/bpf_jit_comp_64.c

318

unsigned int dst, struct jit_ctx *ctx)

arch/sparc/net/bpf_jit_comp_64.c

323

insn |= RS1(src) | RD(dst);

arch/sparc/net/bpf_jit_comp_64.c

628

const u8 dst, const u8 src, struct jit_ctx *ctx)

arch/sparc/net/bpf_jit_comp_64.c

632

emit(cb_opc | WDISP10(off << 2) | RS1(dst) | RS2(src), ctx);

arch/sparc/net/bpf_jit_comp_64.c

636

const u8 dst, s32 imm, struct jit_ctx *ctx)

arch/sparc/net/bpf_jit_comp_64.c

640

emit(cb_opc | IMMED | WDISP10(off << 2) | RS1(dst) | S5(imm), ctx);

arch/sparc/net/bpf_jit_comp_64.c

658

static int emit_compare_and_branch(const u8 code, const u8 dst, u8 src,

arch/sparc/net/bpf_jit_comp_64.c

693

emit_btsti(dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

695

emit_btst(dst, src, ctx);

arch/sparc/net/bpf_jit_comp_64.c

698

emit_cmpi(dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

700

emit_cmp(dst, src, ctx);

arch/sparc/net/bpf_jit_comp_64.c

785

dst, imm, ctx);

arch/sparc/net/bpf_jit_comp_64.c

788

dst, src, ctx);

arch/sparc/net/bpf_jit_comp_64.c

898

const u8 dst = bpf2sparc[insn->dst_reg];

arch/sparc/net/bpf_jit_comp_64.c

910

emit_alu3_K(SRL, src, 0, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

915

emit_reg_move(src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

920

emit_alu(ADD, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

924

emit_alu(SUB, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

928

emit_alu(AND, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

932

emit_alu(OR, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

936

emit_alu(XOR, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

939

emit_alu(MUL, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

942

emit_alu(MULX, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

946

emit_alu(DIV, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

951

emit_alu(UDIVX, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

959

emit_alu3(DIV, dst, src, tmp, ctx);

arch/sparc/net/bpf_jit_comp_64.c

961

emit_alu3(SUB, dst, tmp, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

969

emit_alu3(UDIVX, dst, src, tmp, ctx);

arch/sparc/net/bpf_jit_comp_64.c

971

emit_alu3(SUB, dst, tmp, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

975

emit_alu(SLL, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

978

emit_alu(SLLX, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

981

emit_alu(SRL, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

986

emit_alu(SRLX, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

989

emit_alu(SRA, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

992

emit_alu(SRAX, src, dst, ctx);

arch/sparc/net/bpf_jit_comp_64.c

998

emit(SUB | RS1(0) | RS2(dst) | RD(dst), ctx);

arch/um/drivers/vector_user.c

314

char *src, *dst;

arch/um/drivers/vector_user.c

319

dst = uml_vector_fetch_arg(ifspec, "dst");

arch/um/drivers/vector_user.c

343

if ((dst == NULL) || (strlen(dst) > MAX_UN_LEN))

arch/um/drivers/vector_user.c

346

memcpy(remote_addr->sun_path, dst, strlen(dst) + 1);

arch/um/drivers/vector_user.c

609

char *src, *dst, *srcport, *dstport;

arch/um/drivers/vector_user.c

628

dst = uml_vector_fetch_arg(ifspec, "dst");

arch/um/drivers/vector_user.c

688

gairet = getaddrinfo(dst, dstport, &dsthints, &gairesult);

arch/um/include/asm/uaccess.h

41

#define __get_kernel_nofault(dst, src, type, err_label) \

arch/um/include/asm/uaccess.h

47

*((type *)dst) = (type) 0; \

arch/um/include/asm/uaccess.h

50

*((type *)dst) = get_unaligned((type *)(src)); \

arch/um/include/asm/uaccess.h

55

#define __put_kernel_nofault(dst, src, type, err_label) \

arch/um/include/asm/uaccess.h

62

put_unaligned(*((type *)src), (type *)(dst)); \

arch/um/include/shared/user.h

63

#define strscpy(dst, src) sized_strscpy(dst, src, sizeof(dst))

arch/um/kernel/process.c

193

int arch_dup_task_struct(struct task_struct *dst,

arch/um/kernel/process.c

198

memcpy(dst, src, sizeof(init_task));

arch/um/kernel/process.c

199

memset((void *)dst + sizeof(init_task), 0,

arch/um/kernel/process.c

202

memcpy(dst, src, arch_task_struct_size);

arch/um/kernel/skas/uaccess.c

182

long strncpy_from_user(char *dst, const char __user *src, long count)

arch/um/kernel/skas/uaccess.c

185

char *ptr = dst;

arch/um/kernel/skas/uaccess.c

193

return strnlen(dst, count);

arch/um/os-Linux/file.c

26

static void copy_stat(struct uml_stat *dst, const struct stat64 *src)

arch/um/os-Linux/file.c

28

*dst = ((struct uml_stat) {

arch/x86/boot/boot.h

194

void copy_to_fs(addr_t dst, void *src, size_t len);

arch/x86/boot/boot.h

195

void *copy_from_fs(void *dst, addr_t src, size_t len);

arch/x86/boot/compressed/sev-handle-vc.c

69

void *dst, char *buf, size_t size)

arch/x86/boot/compressed/sev-handle-vc.c

71

memcpy(dst, buf, size);

arch/x86/boot/string.h

10

void *memcpy(void *dst, const void *src, size_t len);

arch/x86/boot/string.h

11

void *memmove(void *dst, const void *src, size_t len);

arch/x86/boot/string.h

12

void *memset(void *dst, int c, size_t len);

arch/x86/boot/video.c

262

addr_t dst = 0;

arch/x86/boot/video.c

280

copy_to_fs(dst, src, copy*sizeof(u16));

arch/x86/boot/video.c

281

dst += copy*sizeof(u16);

arch/x86/boot/video.c

297

: "+D" (dst), "+c" (npad)

arch/x86/coco/sev/vc-handle.c

198

char *dst, char *buf, size_t size)

arch/x86/coco/sev/vc-handle.c

224

u8 __user *target = (u8 __user *)dst;

arch/x86/coco/sev/vc-handle.c

233

u16 __user *target = (u16 __user *)dst;

arch/x86/coco/sev/vc-handle.c

242

u32 __user *target = (u32 __user *)dst;

arch/x86/coco/sev/vc-handle.c

251

u64 __user *target = (u64 __user *)dst;

arch/x86/coco/sev/vc-handle.c

271

ctxt->fi.cr2 = (unsigned long)dst;

arch/x86/coco/sev/vc-handle.c

535

unsigned char *src, *dst;

arch/x86/coco/sev/vc-handle.c

551

dst = es_base + (unsigned char *)ctxt->regs->di;

arch/x86/coco/sev/vc-handle.c

557

ret = vc_write_mem(ctxt, dst, buffer, bytes);

arch/x86/coco/sev/vc-shared.c

169

void *dst, char *buf,

arch/x86/coco/sev/vc-shared.c

175

unsigned long address = (unsigned long)dst;

arch/x86/coco/sev/vc-shared.c

183

void *d = dst + (i * data_size * s);

arch/x86/crypto/aegis128-aesni-glue.c

116

walk->dst.virt.addr,

arch/x86/crypto/aegis128-aesni-glue.c

121

walk->dst.virt.addr,

arch/x86/crypto/aegis128-aesni-glue.c

133

walk->dst.virt.addr,

arch/x86/crypto/aegis128-aesni-glue.c

137

walk->dst.virt.addr,

arch/x86/crypto/aegis128-aesni-glue.c

217

scatterwalk_map_and_copy(tag.bytes, req->dst,

arch/x86/crypto/aegis128-aesni-glue.c

45

u8 *dst, unsigned int len);

arch/x86/crypto/aegis128-aesni-glue.c

48

u8 *dst, unsigned int len);

arch/x86/crypto/aegis128-aesni-glue.c

51

const u8 *src, u8 *dst,

arch/x86/crypto/aegis128-aesni-glue.c

55

const u8 *src, u8 *dst,

arch/x86/crypto/aesni-intel_glue.c

1003

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

1006

ghash_acc, src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

1011

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

1015

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

1019

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

1023

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

133

aesni_ecb_enc(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

1390

walk.dst.virt.addr, nbytes, flags);

arch/x86/crypto/aesni-intel_glue.c

1400

walk.dst.virt.addr, nbytes, flags);

arch/x86/crypto/aesni-intel_glue.c

1414

scatterwalk_map_and_copy(ghash_acc, req->dst, req->assoclen +

arch/x86/crypto/aesni-intel_glue.c

155

aesni_ecb_dec(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

177

aesni_cbc_enc(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

199

aesni_cbc_dec(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

214

struct scatterlist *src = req->src, *dst = req->dst;

arch/x86/crypto/aesni-intel_glue.c

231

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/x86/crypto/aesni-intel_glue.c

242

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/x86/crypto/aesni-intel_glue.c

243

if (req->dst != req->src)

arch/x86/crypto/aesni-intel_glue.c

244

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/x86/crypto/aesni-intel_glue.c

249

skcipher_request_set_crypt(&subreq, src, dst,

arch/x86/crypto/aesni-intel_glue.c

258

aesni_cts_cbc_enc(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

270

struct scatterlist *src = req->src, *dst = req->dst;

arch/x86/crypto/aesni-intel_glue.c

287

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/x86/crypto/aesni-intel_glue.c

298

dst = src = scatterwalk_ffwd(sg_src, req->src, subreq.cryptlen);

arch/x86/crypto/aesni-intel_glue.c

299

if (req->dst != req->src)

arch/x86/crypto/aesni-intel_glue.c

300

dst = scatterwalk_ffwd(sg_dst, req->dst,

arch/x86/crypto/aesni-intel_glue.c

305

skcipher_request_set_crypt(&subreq, src, dst,

arch/x86/crypto/aesni-intel_glue.c

314

aesni_cts_cbc_dec(ctx, walk.dst.virt.addr, walk.src.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

337

aesni_ctr_enc(ctx, walk.dst.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

344

crypto_xor_cpy(walk.dst.virt.addr + walk.nbytes - nbytes,

arch/x86/crypto/aesni-intel_glue.c

381

const u8 *src, u8 *dst, int len,

arch/x86/crypto/aesni-intel_glue.c

394

struct scatterlist *src, *dst;

arch/x86/crypto/aesni-intel_glue.c

408

skcipher_request_set_crypt(&subreq, req->src, req->dst,

arch/x86/crypto/aesni-intel_glue.c

419

walk.src.virt.addr, walk.dst.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

431

dst = src = scatterwalk_ffwd(sg_src, req->src, req->cryptlen);

arch/x86/crypto/aesni-intel_glue.c

432

if (req->dst != req->src)

arch/x86/crypto/aesni-intel_glue.c

433

dst = scatterwalk_ffwd(sg_dst, req->dst, req->cryptlen);

arch/x86/crypto/aesni-intel_glue.c

435

skcipher_request_set_crypt(req, src, dst, AES_BLOCK_SIZE + tail,

arch/x86/crypto/aesni-intel_glue.c

443

(*crypt_func)(&ctx->crypt_ctx, walk.src.virt.addr, walk.dst.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

473

req->dst->length >= req->cryptlen)) {

arch/x86/crypto/aesni-intel_glue.c

475

sg_virt(req->dst), req->cryptlen, req->iv);

arch/x86/crypto/aesni-intel_glue.c

490

const u8 *src, u8 *dst, int len,

arch/x86/crypto/aesni-intel_glue.c

493

aesni_xts_enc(key, dst, src, len, tweak);

arch/x86/crypto/aesni-intel_glue.c

497

const u8 *src, u8 *dst, int len,

arch/x86/crypto/aesni-intel_glue.c

500

aesni_xts_dec(key, dst, src, len, tweak);

arch/x86/crypto/aesni-intel_glue.c

604

const u8 *src, u8 *dst, int len,

arch/x86/crypto/aesni-intel_glue.c

635

walk.dst.virt.addr, nbytes, le_ctr);

arch/x86/crypto/aesni-intel_glue.c

645

walk.dst.virt.addr, p1_nbytes, le_ctr);

arch/x86/crypto/aesni-intel_glue.c

649

walk.dst.virt.addr + p1_nbytes,

arch/x86/crypto/aesni-intel_glue.c

668

const u8 *src, u8 *dst, int len,

arch/x86/crypto/aesni-intel_glue.c

684

(*xctr_func)(key, walk.src.virt.addr, walk.dst.virt.addr,

arch/x86/crypto/aesni-intel_glue.c

698

u8 *dst, int len, u8 tweak[AES_BLOCK_SIZE]); \

arch/x86/crypto/aesni-intel_glue.c

701

u8 *dst, int len, u8 tweak[AES_BLOCK_SIZE]); \

arch/x86/crypto/aesni-intel_glue.c

715

const u8 *src, u8 *dst, int len, const u64 le_ctr[2]);\

arch/x86/crypto/aesni-intel_glue.c

724

const u8 *src, u8 *dst, int len, \

arch/x86/crypto/aesni-intel_glue.c

954

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

958

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

962

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

966

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

971

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

975

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

979

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

983

const u8 *src, u8 *dst, int datalen);

arch/x86/crypto/aesni-intel_glue.c

989

const u8 *src, u8 *dst, int datalen, int flags)

arch/x86/crypto/aesni-intel_glue.c

995

src, dst, datalen);

arch/x86/crypto/aesni-intel_glue.c

999

src, dst, datalen);

arch/x86/crypto/aria-avx.h

16

asmlinkage void aria_aesni_avx_encrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

18

asmlinkage void aria_aesni_avx_decrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

20

asmlinkage void aria_aesni_avx_ctr_crypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

23

asmlinkage void aria_aesni_avx_gfni_encrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

25

asmlinkage void aria_aesni_avx_gfni_decrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

27

asmlinkage void aria_aesni_avx_gfni_ctr_crypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

31

asmlinkage void aria_aesni_avx2_encrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

33

asmlinkage void aria_aesni_avx2_decrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

35

asmlinkage void aria_aesni_avx2_ctr_crypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

38

asmlinkage void aria_aesni_avx2_gfni_encrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

40

asmlinkage void aria_aesni_avx2_gfni_decrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

42

asmlinkage void aria_aesni_avx2_gfni_ctr_crypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria-avx.h

47

void (*aria_encrypt_16way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

48

void (*aria_decrypt_16way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

49

void (*aria_ctr_crypt_16way)(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/aria-avx.h

51

void (*aria_encrypt_32way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

52

void (*aria_decrypt_32way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

53

void (*aria_ctr_crypt_32way)(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/aria-avx.h

55

void (*aria_encrypt_64way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

56

void (*aria_decrypt_64way)(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/aria-avx.h

57

void (*aria_ctr_crypt_64way)(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/aria_aesni_avx2_glue.c

103

aria_ops.aria_ctr_crypt_32way(ctx, dst, src,

arch/x86/crypto/aria_aesni_avx2_glue.c

107

dst += ARIA_AESNI_AVX2_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/aria_aesni_avx2_glue.c

114

aria_ops.aria_ctr_crypt_16way(ctx, dst, src,

arch/x86/crypto/aria_aesni_avx2_glue.c

118

dst += ARIA_AESNI_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/aria_aesni_avx2_glue.c

130

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_aesni_avx2_glue.c

132

dst += ARIA_BLOCK_SIZE;

arch/x86/crypto/aria_aesni_avx2_glue.c

145

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_aesni_avx2_glue.c

147

dst += nbytes;

arch/x86/crypto/aria_aesni_avx2_glue.c

19

asmlinkage void aria_aesni_avx2_encrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

22

asmlinkage void aria_aesni_avx2_decrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

25

asmlinkage void aria_aesni_avx2_ctr_crypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

29

asmlinkage void aria_aesni_avx2_gfni_encrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

32

asmlinkage void aria_aesni_avx2_gfni_decrypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

35

asmlinkage void aria_aesni_avx2_gfni_ctr_crypt_32way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx2_glue.c

99

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/aria_aesni_avx_glue.c

101

aria_ops.aria_ctr_crypt_16way(ctx, dst, src,

arch/x86/crypto/aria_aesni_avx_glue.c

105

dst += ARIA_AESNI_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/aria_aesni_avx_glue.c

117

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_aesni_avx_glue.c

119

dst += ARIA_BLOCK_SIZE;

arch/x86/crypto/aria_aesni_avx_glue.c

132

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_aesni_avx_glue.c

134

dst += nbytes;

arch/x86/crypto/aria_aesni_avx_glue.c

19

asmlinkage void aria_aesni_avx_encrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

22

asmlinkage void aria_aesni_avx_decrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

25

asmlinkage void aria_aesni_avx_ctr_crypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

29

asmlinkage void aria_aesni_avx_gfni_encrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

32

asmlinkage void aria_aesni_avx_gfni_decrypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

35

asmlinkage void aria_aesni_avx_gfni_ctr_crypt_16way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_aesni_avx_glue.c

97

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/aria_gfni_avx512_glue.c

102

aria_ops.aria_ctr_crypt_32way(ctx, dst, src,

arch/x86/crypto/aria_gfni_avx512_glue.c

106

dst += ARIA_AESNI_AVX2_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/aria_gfni_avx512_glue.c

113

aria_ops.aria_ctr_crypt_16way(ctx, dst, src,

arch/x86/crypto/aria_gfni_avx512_glue.c

117

dst += ARIA_AESNI_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/aria_gfni_avx512_glue.c

130

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_gfni_avx512_glue.c

132

dst += ARIA_BLOCK_SIZE;

arch/x86/crypto/aria_gfni_avx512_glue.c

145

crypto_xor_cpy(dst, src, &req_ctx->keystream[0],

arch/x86/crypto/aria_gfni_avx512_glue.c

147

dst += nbytes;

arch/x86/crypto/aria_gfni_avx512_glue.c

18

asmlinkage void aria_gfni_avx512_encrypt_64way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_gfni_avx512_glue.c

20

asmlinkage void aria_gfni_avx512_decrypt_64way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_gfni_avx512_glue.c

22

asmlinkage void aria_gfni_avx512_ctr_crypt_64way(const void *ctx, u8 *dst,

arch/x86/crypto/aria_gfni_avx512_glue.c

87

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/aria_gfni_avx512_glue.c

91

aria_ops.aria_ctr_crypt_64way(ctx, dst, src,

arch/x86/crypto/aria_gfni_avx512_glue.c

95

dst += ARIA_GFNI_AVX512_PARALLEL_BLOCK_SIZE;

arch/x86/crypto/blowfish_glue.c

22

asmlinkage void blowfish_enc_blk(struct bf_ctx *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/blowfish_glue.c

23

asmlinkage void blowfish_dec_blk(struct bf_ctx *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/blowfish_glue.c

26

asmlinkage void blowfish_enc_blk_4way(struct bf_ctx *ctx, u8 *dst,

arch/x86/crypto/blowfish_glue.c

28

asmlinkage void __blowfish_dec_blk_4way(struct bf_ctx *ctx, u8 *dst,

arch/x86/crypto/blowfish_glue.c

31

static inline void blowfish_dec_ecb_4way(struct bf_ctx *ctx, u8 *dst,

arch/x86/crypto/blowfish_glue.c

34

return __blowfish_dec_blk_4way(ctx, dst, src, false);

arch/x86/crypto/blowfish_glue.c

37

static inline void blowfish_dec_cbc_4way(struct bf_ctx *ctx, u8 *dst,

arch/x86/crypto/blowfish_glue.c

40

return __blowfish_dec_blk_4way(ctx, dst, src, true);

arch/x86/crypto/blowfish_glue.c

43

static void blowfish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/blowfish_glue.c

45

blowfish_enc_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/blowfish_glue.c

48

static void blowfish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/blowfish_glue.c

50

blowfish_dec_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/camellia.h

27

asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/camellia.h

29

asmlinkage void camellia_dec_blk(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia.h

32

asmlinkage void __camellia_enc_blk_2way(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/camellia.h

34

asmlinkage void camellia_dec_blk_2way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia.h

37

asmlinkage void camellia_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia.h

38

asmlinkage void camellia_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia.h

40

asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia.h

42

static inline void camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/camellia.h

44

__camellia_enc_blk(ctx, dst, src, false);

arch/x86/crypto/camellia.h

47

static inline void camellia_enc_blk_xor(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/camellia.h

49

__camellia_enc_blk(ctx, dst, src, true);

arch/x86/crypto/camellia.h

52

static inline void camellia_enc_blk_2way(const void *ctx, u8 *dst,

arch/x86/crypto/camellia.h

55

__camellia_enc_blk_2way(ctx, dst, src, false);

arch/x86/crypto/camellia.h

58

static inline void camellia_enc_blk_xor_2way(const void *ctx, u8 *dst,

arch/x86/crypto/camellia.h

61

__camellia_enc_blk_2way(ctx, dst, src, true);

arch/x86/crypto/camellia.h

65

extern void camellia_decrypt_cbc_2way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx2_glue.c

21

asmlinkage void camellia_ecb_enc_32way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx2_glue.c

22

asmlinkage void camellia_ecb_dec_32way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx2_glue.c

24

asmlinkage void camellia_cbc_dec_32way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx_glue.c

21

asmlinkage void camellia_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx_glue.c

24

asmlinkage void camellia_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_aesni_avx_glue.c

27

asmlinkage void camellia_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_glue.c

1267

void camellia_decrypt_cbc_2way(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/camellia_glue.c

1272

if (dst == src)

arch/x86/crypto/camellia_glue.c

1274

camellia_dec_blk_2way(ctx, dst, src);

arch/x86/crypto/camellia_glue.c

1275

crypto_xor(dst + CAMELLIA_BLOCK_SIZE, iv, CAMELLIA_BLOCK_SIZE);

arch/x86/crypto/camellia_glue.c

23

asmlinkage void __camellia_enc_blk(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/camellia_glue.c

26

asmlinkage void camellia_dec_blk(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_glue.c

30

asmlinkage void __camellia_enc_blk_2way(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/camellia_glue.c

33

asmlinkage void camellia_dec_blk_2way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/camellia_glue.c

36

static void camellia_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/camellia_glue.c

38

camellia_enc_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/camellia_glue.c

41

static void camellia_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/camellia_glue.c

43

camellia_dec_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/cast5_avx_glue.c

20

asmlinkage void cast5_ecb_enc_16way(struct cast5_ctx *ctx, u8 *dst,

arch/x86/crypto/cast5_avx_glue.c

22

asmlinkage void cast5_ecb_dec_16way(struct cast5_ctx *ctx, u8 *dst,

arch/x86/crypto/cast5_avx_glue.c

24

asmlinkage void cast5_cbc_dec_16way(struct cast5_ctx *ctx, u8 *dst,

arch/x86/crypto/cast6_avx_glue.c

22

asmlinkage void cast6_ecb_enc_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/cast6_avx_glue.c

23

asmlinkage void cast6_ecb_dec_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/cast6_avx_glue.c

25

asmlinkage void cast6_cbc_dec_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/des3_ede_glue.c

132

u64 *dst = (u64 *)walk->dst.virt.addr;

arch/x86/crypto/des3_ede_glue.c

136

*dst = *src ^ *iv;

arch/x86/crypto/des3_ede_glue.c

137

des3_ede_enc_blk(ctx, (u8 *)dst, (u8 *)dst);

arch/x86/crypto/des3_ede_glue.c

138

iv = dst;

arch/x86/crypto/des3_ede_glue.c

141

dst += 1;

arch/x86/crypto/des3_ede_glue.c

173

u64 *dst = (u64 *)walk->dst.virt.addr;

arch/x86/crypto/des3_ede_glue.c

179

dst += nbytes / bsize - 1;

arch/x86/crypto/des3_ede_glue.c

188

dst -= 3 - 1;

arch/x86/crypto/des3_ede_glue.c

193

des3_ede_dec_blk_3way(ctx, (u8 *)dst, (u8 *)src);

arch/x86/crypto/des3_ede_glue.c

195

dst[1] ^= ivs[0];

arch/x86/crypto/des3_ede_glue.c

196

dst[2] ^= ivs[1];

arch/x86/crypto/des3_ede_glue.c

202

*dst ^= *(src - 1);

arch/x86/crypto/des3_ede_glue.c

204

dst -= 1;

arch/x86/crypto/des3_ede_glue.c

210

des3_ede_dec_blk(ctx, (u8 *)dst, (u8 *)src);

arch/x86/crypto/des3_ede_glue.c

216

*dst ^= *(src - 1);

arch/x86/crypto/des3_ede_glue.c

218

dst -= 1;

arch/x86/crypto/des3_ede_glue.c

222

*dst ^= *(u64 *)walk->iv;

arch/x86/crypto/des3_ede_glue.c

25

asmlinkage void des3_ede_x86_64_crypt_blk(const u32 *expkey, u8 *dst,

arch/x86/crypto/des3_ede_glue.c

29

asmlinkage void des3_ede_x86_64_crypt_blk_3way(const u32 *expkey, u8 *dst,

arch/x86/crypto/des3_ede_glue.c

32

static inline void des3_ede_enc_blk(struct des3_ede_x86_ctx *ctx, u8 *dst,

arch/x86/crypto/des3_ede_glue.c

37

des3_ede_x86_64_crypt_blk(enc_ctx, dst, src);

arch/x86/crypto/des3_ede_glue.c

40

static inline void des3_ede_dec_blk(struct des3_ede_x86_ctx *ctx, u8 *dst,

arch/x86/crypto/des3_ede_glue.c

45

des3_ede_x86_64_crypt_blk(dec_ctx, dst, src);

arch/x86/crypto/des3_ede_glue.c

48

static inline void des3_ede_dec_blk_3way(struct des3_ede_x86_ctx *ctx, u8 *dst,

arch/x86/crypto/des3_ede_glue.c

53

des3_ede_x86_64_crypt_blk_3way(dec_ctx, dst, src);

arch/x86/crypto/des3_ede_glue.c

56

static void des3_ede_x86_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/des3_ede_glue.c

58

des3_ede_enc_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/des3_ede_glue.c

61

static void des3_ede_x86_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/des3_ede_glue.c

63

des3_ede_dec_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/des3_ede_glue.c

77

u8 *wdst = walk.dst.virt.addr;

arch/x86/crypto/ecb_cbc_helpers.h

25

u8 *dst = walk.dst.virt.addr; \

arch/x86/crypto/ecb_cbc_helpers.h

33

dst += (blocks) * __bsize; \

arch/x86/crypto/ecb_cbc_helpers.h

45

(func)(ctx, dst, src); \

arch/x86/crypto/ecb_cbc_helpers.h

53

crypto_xor_cpy(dst, src, __iv, __bsize); \

arch/x86/crypto/ecb_cbc_helpers.h

54

(func)(ctx, dst, dst); \

arch/x86/crypto/ecb_cbc_helpers.h

55

__iv = dst; \

arch/x86/crypto/ecb_cbc_helpers.h

69

if (dst == src) \

arch/x86/crypto/ecb_cbc_helpers.h

71

(func)(ctx, dst, src); \

arch/x86/crypto/ecb_cbc_helpers.h

72

crypto_xor(dst, walk.iv, __bsize); \

arch/x86/crypto/ghash-clmulni-intel_glue.c

102

crypto_xor(dst, src, len);

arch/x86/crypto/ghash-clmulni-intel_glue.c

103

clmul_ghash_mul(dst, &ctx->shash);

arch/x86/crypto/ghash-clmulni-intel_glue.c

109

unsigned int len, u8 *dst)

arch/x86/crypto/ghash-clmulni-intel_glue.c

116

memcpy(dst, buf, GHASH_BLOCK_SIZE);

arch/x86/crypto/ghash-clmulni-intel_glue.c

22

asmlinkage void clmul_ghash_mul(char *dst, const le128 *shash);

arch/x86/crypto/ghash-clmulni-intel_glue.c

24

asmlinkage int clmul_ghash_update(char *dst, const char *src,

arch/x86/crypto/ghash-clmulni-intel_glue.c

86

u8 *dst = dctx->buffer;

arch/x86/crypto/ghash-clmulni-intel_glue.c

90

remain = clmul_ghash_update(dst, src, srclen, &ctx->shash);

arch/x86/crypto/ghash-clmulni-intel_glue.c

98

u8 *dst = dctx->buffer;

arch/x86/crypto/serpent-avx.h

13

asmlinkage void serpent_ecb_enc_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent-avx.h

15

asmlinkage void serpent_ecb_dec_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent-avx.h

18

asmlinkage void serpent_cbc_dec_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent-sse2.h

12

asmlinkage void __serpent_enc_blk_4way(const struct serpent_ctx *ctx, u8 *dst,

arch/x86/crypto/serpent-sse2.h

14

asmlinkage void serpent_dec_blk_4way(const struct serpent_ctx *ctx, u8 *dst,

arch/x86/crypto/serpent-sse2.h

17

static inline void serpent_enc_blk_xway(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

19

__serpent_enc_blk_4way(ctx, dst, src, false);

arch/x86/crypto/serpent-sse2.h

23

u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

25

__serpent_enc_blk_4way(ctx, dst, src, true);

arch/x86/crypto/serpent-sse2.h

28

static inline void serpent_dec_blk_xway(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

30

serpent_dec_blk_4way(ctx, dst, src);

arch/x86/crypto/serpent-sse2.h

37

asmlinkage void __serpent_enc_blk_8way(const struct serpent_ctx *ctx, u8 *dst,

arch/x86/crypto/serpent-sse2.h

39

asmlinkage void serpent_dec_blk_8way(const struct serpent_ctx *ctx, u8 *dst,

arch/x86/crypto/serpent-sse2.h

42

static inline void serpent_enc_blk_xway(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

44

__serpent_enc_blk_8way(ctx, dst, src, false);

arch/x86/crypto/serpent-sse2.h

48

u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

50

__serpent_enc_blk_8way(ctx, dst, src, true);

arch/x86/crypto/serpent-sse2.h

53

static inline void serpent_dec_blk_xway(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/serpent-sse2.h

55

serpent_dec_blk_8way(ctx, dst, src);

arch/x86/crypto/serpent_avx2_glue.c

21

asmlinkage void serpent_ecb_enc_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/serpent_avx2_glue.c

22

asmlinkage void serpent_ecb_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/serpent_avx2_glue.c

23

asmlinkage void serpent_cbc_dec_16way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/serpent_avx_glue.c

23

asmlinkage void serpent_ecb_enc_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent_avx_glue.c

27

asmlinkage void serpent_ecb_dec_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent_avx_glue.c

31

asmlinkage void serpent_cbc_dec_8way_avx(const void *ctx, u8 *dst,

arch/x86/crypto/serpent_sse2_glue.c

32

static void serpent_decrypt_cbc_xway(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/serpent_sse2_glue.c

37

if (dst == src)

arch/x86/crypto/serpent_sse2_glue.c

39

serpent_dec_blk_xway(ctx, dst, src);

arch/x86/crypto/serpent_sse2_glue.c

40

crypto_xor(dst + SERPENT_BLOCK_SIZE, s, sizeof(buf));

arch/x86/crypto/sm4-avx.h

8

typedef void (*sm4_crypt_func)(const u32 *rk, u8 *dst, const u8 *src, u8 *iv);

arch/x86/crypto/sm4_aesni_avx2_glue.c

21

asmlinkage void sm4_aesni_avx2_ctr_enc_blk16(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx2_glue.c

23

asmlinkage void sm4_aesni_avx2_cbc_dec_blk16(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx_glue.c

104

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/sm4_aesni_avx_glue.c

107

crypto_xor_cpy(dst, src, iv, SM4_BLOCK_SIZE);

arch/x86/crypto/sm4_aesni_avx_glue.c

108

sm4_crypt_block(ctx->rkey_enc, dst, dst);

arch/x86/crypto/sm4_aesni_avx_glue.c

109

iv = dst;

arch/x86/crypto/sm4_aesni_avx_glue.c

111

dst += SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

137

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/sm4_aesni_avx_glue.c

142

func(ctx->rkey_dec, dst, src, walk.iv);

arch/x86/crypto/sm4_aesni_avx_glue.c

143

dst += bsize;

arch/x86/crypto/sm4_aesni_avx_glue.c

158

dst += (nblocks - 1) * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

162

crypto_xor_cpy(dst, src,

arch/x86/crypto/sm4_aesni_avx_glue.c

166

dst -= SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

168

crypto_xor_cpy(dst, walk.iv, keystream, SM4_BLOCK_SIZE);

arch/x86/crypto/sm4_aesni_avx_glue.c

170

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

202

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/sm4_aesni_avx_glue.c

207

func(ctx->rkey_enc, dst, src, walk.iv);

arch/x86/crypto/sm4_aesni_avx_glue.c

208

dst += bsize;

arch/x86/crypto/sm4_aesni_avx_glue.c

22

asmlinkage void sm4_aesni_avx_crypt4(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx_glue.c

226

crypto_xor_cpy(dst, src, keystream,

arch/x86/crypto/sm4_aesni_avx_glue.c

228

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

24

asmlinkage void sm4_aesni_avx_crypt8(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx_glue.c

244

crypto_xor_cpy(dst, src, keystream, nbytes);

arch/x86/crypto/sm4_aesni_avx_glue.c

245

dst += nbytes;

arch/x86/crypto/sm4_aesni_avx_glue.c

26

asmlinkage void sm4_aesni_avx_ctr_enc_blk8(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx_glue.c

28

asmlinkage void sm4_aesni_avx_cbc_dec_blk8(const u32 *rk, u8 *dst,

arch/x86/crypto/sm4_aesni_avx_glue.c

49

u8 *dst = walk.dst.virt.addr;

arch/x86/crypto/sm4_aesni_avx_glue.c

53

sm4_aesni_avx_crypt8(rkey, dst, src, 8);

arch/x86/crypto/sm4_aesni_avx_glue.c

54

dst += SM4_CRYPT8_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

60

sm4_aesni_avx_crypt4(rkey, dst, src, nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

61

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/twofish.h

10

asmlinkage void twofish_enc_blk(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish.h

11

asmlinkage void twofish_dec_blk(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish.h

14

asmlinkage void __twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src,

arch/x86/crypto/twofish.h

16

asmlinkage void twofish_dec_blk_3way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish.h

19

extern void twofish_dec_blk_cbc_3way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish_avx_glue.c

24

asmlinkage void twofish_ecb_enc_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish_avx_glue.c

25

asmlinkage void twofish_ecb_dec_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish_avx_glue.c

27

asmlinkage void twofish_cbc_dec_8way(const void *ctx, u8 *dst, const u8 *src);

arch/x86/crypto/twofish_avx_glue.c

35

static inline void twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/twofish_avx_glue.c

37

__twofish_enc_blk_3way(ctx, dst, src, false);

arch/x86/crypto/twofish_glue.c

48

asmlinkage void twofish_enc_blk(struct twofish_ctx *ctx, u8 *dst,

arch/x86/crypto/twofish_glue.c

51

asmlinkage void twofish_dec_blk(struct twofish_ctx *ctx, u8 *dst,

arch/x86/crypto/twofish_glue.c

55

static void twofish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/twofish_glue.c

57

twofish_enc_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/twofish_glue.c

60

static void twofish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

arch/x86/crypto/twofish_glue.c

62

twofish_dec_blk(crypto_tfm_ctx(tfm), dst, src);

arch/x86/crypto/twofish_glue_3way.c

29

static inline void twofish_enc_blk_3way(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/twofish_glue_3way.c

31

__twofish_enc_blk_3way(ctx, dst, src, false);

arch/x86/crypto/twofish_glue_3way.c

34

void twofish_dec_blk_cbc_3way(const void *ctx, u8 *dst, const u8 *src)

arch/x86/crypto/twofish_glue_3way.c

39

if (dst == src)

arch/x86/crypto/twofish_glue_3way.c

41

twofish_dec_blk_3way(ctx, dst, src);

arch/x86/crypto/twofish_glue_3way.c

42

crypto_xor(dst + TF_BLOCK_SIZE, s, sizeof(buf));

arch/x86/events/intel/lbr.c

955

u64 src, dst, cnt;

arch/x86/events/intel/lbr.c

971

dst = 0;

arch/x86/events/intel/lbr.c

974

dst |= cnt << j * LBR_INFO_BR_CNTR_BITS;

arch/x86/events/intel/lbr.c

976

cpuc->lbr_counters[i] = dst;

arch/x86/include/asm/checksum_32.h

172

void __user *dst,

arch/x86/include/asm/checksum_32.h

178

if (!user_access_begin(dst, len))

arch/x86/include/asm/checksum_32.h

181

ret = csum_partial_copy_generic(src, (__force void *)dst, len);

arch/x86/include/asm/checksum_32.h

30

asmlinkage __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/x86/include/asm/checksum_32.h

39

static inline __wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/x86/include/asm/checksum_32.h

41

return csum_partial_copy_generic(src, dst, len);

arch/x86/include/asm/checksum_32.h

45

void *dst, int len)

arch/x86/include/asm/checksum_32.h

52

ret = csum_partial_copy_generic((__force void *)src, dst, len);

arch/x86/include/asm/checksum_64.h

133

extern __visible __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/x86/include/asm/checksum_64.h

135

extern __wsum csum_and_copy_from_user(const void __user *src, void *dst, int len);

arch/x86/include/asm/checksum_64.h

136

extern __wsum csum_and_copy_to_user(const void *src, void __user *dst, int len);

arch/x86/include/asm/checksum_64.h

137

extern __wsum csum_partial_copy_nocheck(const void *src, void *dst, int len);

arch/x86/include/asm/fpu/sched.h

14

extern int fpu_clone(struct task_struct *dst, u64 clone_flags, bool minimal,

arch/x86/include/asm/io.h

391

static inline void iosubmit_cmds512(void __iomem *dst, const void *src,

arch/x86/include/asm/io.h

398

movdir64b_io(dst, from);

arch/x86/include/asm/irqdomain.h

20

extern void copy_irq_alloc_info(struct irq_alloc_info *dst,

arch/x86/include/asm/mce.h

241

unsigned long __must_check copy_mc_fragile(void *dst, const void *src, unsigned cnt);

arch/x86/include/asm/mpspec.h

72

static inline void copy_phys_cpu_present_map(unsigned long *dst)

arch/x86/include/asm/mpspec.h

74

bitmap_copy(dst, phys_cpu_present_map, MAX_LOCAL_APIC);

arch/x86/include/asm/pgtable.h

1466

static inline void clone_pgd_range(pgd_t *dst, pgd_t *src, int count)

arch/x86/include/asm/pgtable.h

1468

memcpy(dst, src, count * sizeof(pgd_t));

arch/x86/include/asm/pgtable.h

1473

memcpy(kernel_to_user_pgdp(dst), kernel_to_user_pgdp(src),

arch/x86/include/asm/ptrace.h

386

extern long copy_from_kernel_nofault(void *dst, const void *src, size_t size);

arch/x86/include/asm/special_insns.h

230

static inline void movdir64b(void *dst, const void *src)

arch/x86/include/asm/special_insns.h

233

struct { char _[64]; } *__dst = dst;

arch/x86/include/asm/special_insns.h

251

static inline void movdir64b_io(void __iomem *dst, const void *src)

arch/x86/include/asm/special_insns.h

253

movdir64b((void __force *)dst, src);

arch/x86/include/asm/special_insns.h

275

static inline int enqcmds(void __iomem *dst, const void *src)

arch/x86/include/asm/special_insns.h

278

struct { char _[64]; } __iomem *__dst = dst;

arch/x86/include/asm/string_64.h

101

__memcpy_flushcache(dst, src, cnt);

arch/x86/include/asm/string_64.h

84

void __memcpy_flushcache(void *dst, const void *src, size_t cnt);

arch/x86/include/asm/string_64.h

85

static __always_inline void memcpy_flushcache(void *dst, const void *src, size_t cnt)

arch/x86/include/asm/string_64.h

90

asm ("movntil %1, %0" : "=m"(*(u32 *)dst) : "r"(*(u32 *)src));

arch/x86/include/asm/string_64.h

93

asm ("movntiq %1, %0" : "=m"(*(u64 *)dst) : "r"(*(u64 *)src));

arch/x86/include/asm/string_64.h

96

asm ("movntiq %1, %0" : "=m"(*(u64 *)dst) : "r"(*(u64 *)src));

arch/x86/include/asm/string_64.h

97

asm ("movntiq %1, %0" : "=m"(*(u64 *)(dst + 8)) : "r"(*(u64 *)(src + 8)));

arch/x86/include/asm/uaccess.h

488

strncpy_from_user(char *dst, const char __user *src, long count);

arch/x86/include/asm/uaccess.h

601

#define unsafe_copy_loop(dst, src, len, type, label) \

arch/x86/include/asm/uaccess.h

603

unsafe_put_user(*(type *)(src),(type __user *)(dst),label); \

arch/x86/include/asm/uaccess.h

604

dst += sizeof(type); \

arch/x86/include/asm/uaccess.h

621

#define arch_get_kernel_nofault(dst, src, type, err_label) \

arch/x86/include/asm/uaccess.h

622

__get_user_size(*((type *)(dst)), (__force type __user *)(src), \

arch/x86/include/asm/uaccess.h

625

#define arch_get_kernel_nofault(dst, src, type, err_label) \

arch/x86/include/asm/uaccess.h

629

__get_user_size(*((type *)(dst)), (__force type __user *)(src), \

arch/x86/include/asm/uaccess.h

636

#define arch_put_kernel_nofault(dst, src, type, err_label) \

arch/x86/include/asm/uaccess.h

637

__put_user_size(*((type *)(src)), (__force type __user *)(dst), \

arch/x86/include/asm/uaccess_64.h

139

raw_copy_from_user(void *dst, const void __user *src, unsigned long size)

arch/x86/include/asm/uaccess_64.h

141

return copy_user_generic(dst, (__force void *)src, size);

arch/x86/include/asm/uaccess_64.h

145

raw_copy_to_user(void __user *dst, const void *src, unsigned long size)

arch/x86/include/asm/uaccess_64.h

147

return copy_user_generic((__force void *)dst, src, size);

arch/x86/include/asm/uaccess_64.h

150

extern long __copy_user_nocache(void *dst, const void __user *src, unsigned size);

arch/x86/include/asm/uaccess_64.h

151

extern long __copy_user_flushcache(void *dst, const void __user *src, unsigned size);

arch/x86/include/asm/uaccess_64.h

154

__copy_from_user_inatomic_nocache(void *dst, const void __user *src,

arch/x86/include/asm/uaccess_64.h

158

kasan_check_write(dst, size);

arch/x86/include/asm/uaccess_64.h

160

ret = __copy_user_nocache(dst, src, size);

arch/x86/include/asm/uaccess_64.h

166

__copy_from_user_flushcache(void *dst, const void __user *src, unsigned size)

arch/x86/include/asm/uaccess_64.h

168

kasan_check_write(dst, size);

arch/x86/include/asm/uaccess_64.h

169

return __copy_user_flushcache(dst, src, size);

arch/x86/kernel/alternative.c

2516

static void text_poke_memcpy(void *dst, const void *src, size_t len)

arch/x86/kernel/alternative.c

2519

__inline_memcpy(dst, src, len);

arch/x86/kernel/alternative.c

2523

static void text_poke_memset(void *dst, const void *src, size_t len)

arch/x86/kernel/alternative.c

2528

__inline_memset(dst, c, len);

arch/x86/kernel/alternative.c

2532

typedef void text_poke_f(void *dst, const void *src, size_t len);

arch/x86/kernel/apic/io_apic.c

809

static void ioapic_copy_alloc_attr(struct irq_alloc_info *dst,

arch/x86/kernel/apic/io_apic.c

815

copy_irq_alloc_info(dst, src);

arch/x86/kernel/apic/io_apic.c

816

dst->type = X86_IRQ_ALLOC_TYPE_IOAPIC;

arch/x86/kernel/apic/io_apic.c

817

dst->devid = mpc_ioapic_id(ioapic_idx);

arch/x86/kernel/apic/io_apic.c

818

dst->ioapic.pin = pin;

arch/x86/kernel/apic/io_apic.c

819

dst->ioapic.valid = 1;

arch/x86/kernel/apic/io_apic.c

821

dst->ioapic.node = src->ioapic.node;

arch/x86/kernel/apic/io_apic.c

822

dst->ioapic.is_level = src->ioapic.is_level;

arch/x86/kernel/apic/io_apic.c

823

dst->ioapic.active_low = src->ioapic.active_low;

arch/x86/kernel/apic/io_apic.c

825

dst->ioapic.node = NUMA_NO_NODE;

arch/x86/kernel/apic/io_apic.c

827

dst->ioapic.is_level = level;

arch/x86/kernel/apic/io_apic.c

828

dst->ioapic.active_low = pol_low;

arch/x86/kernel/apic/io_apic.c

834

dst->ioapic.is_level = true;

arch/x86/kernel/apic/io_apic.c

835

dst->ioapic.active_low = true;

arch/x86/kernel/apic/vector.c

81

void copy_irq_alloc_info(struct irq_alloc_info *dst, struct irq_alloc_info *src)

arch/x86/kernel/apic/vector.c

84

*dst = *src;

arch/x86/kernel/apic/vector.c

86

memset(dst, 0, sizeof(*dst));

arch/x86/kernel/fpu/core.c

634

static int update_fpu_shstk(struct task_struct *dst, unsigned long ssp)

arch/x86/kernel/fpu/core.c

643

xstate = get_xsave_addr(&x86_task_fpu(dst)->fpstate->regs.xsave,

arch/x86/kernel/fpu/core.c

661

int fpu_clone(struct task_struct *dst, u64 clone_flags, bool minimal,

arch/x86/kernel/fpu/core.c

671

struct fpu *dst_fpu = (void *)dst + sizeof(*dst);

arch/x86/kernel/fpu/core.c

673

BUILD_BUG_ON(sizeof(*dst) % SMP_CACHE_BYTES != 0);

arch/x86/kernel/fpu/core.c

687

set_tsk_thread_flag(dst, TIF_NEED_FPU_LOAD);

arch/x86/kernel/fpu/core.c

733

if (update_fpu_shstk(dst, ssp))

arch/x86/kernel/fpu/xstate.c

1277

static int copy_from_buffer(void *dst, unsigned int offset, unsigned int size,

arch/x86/kernel/fpu/xstate.c

1281

memcpy(dst, kbuf + offset, size);

arch/x86/kernel/fpu/xstate.c

1283

if (copy_from_user(dst, ubuf + offset, size))

arch/x86/kernel/fpu/xstate.c

1358

void *dst = __raw_xsave_addr(xsave, i);

arch/x86/kernel/fpu/xstate.c

1363

if (copy_from_buffer(dst, offset, size, kbuf, ubuf))

arch/x86/kernel/process.c

105

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/x86/kernel/process.c

108

memcpy_and_pad(dst, arch_task_struct_size, src, sizeof(*dst), 0);

arch/x86/kernel/process.c

111

dst->thread.vm86 = NULL;

arch/x86/kernel/uprobes.c

1033

static int copy_from_vaddr(struct mm_struct *mm, unsigned long vaddr, void *dst, int len)

arch/x86/kernel/uprobes.c

1042

uprobe_copy_from_page(page, vaddr, dst, len);

arch/x86/kvm/emulate.c

1002

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

1010

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

1060

ctxt->dst.val = fcw;

arch/x86/kvm/emulate.c

1076

ctxt->dst.val = fsw;

arch/x86/kvm/emulate.c

1276

if (ctxt->dst.type == OP_MEM && ctxt->src.type == OP_REG) {

arch/x86/kvm/emulate.c

1277

mask = ~((long)ctxt->dst.bytes * 8 - 1);

arch/x86/kvm/emulate.c

1286

ctxt->dst.addr.mem.ea = address_mask(ctxt,

arch/x86/kvm/emulate.c

1287

ctxt->dst.addr.mem.ea + (sv >> 3));

arch/x86/kvm/emulate.c

1291

ctxt->src.val &= (ctxt->dst.bytes << 3) - 1;

arch/x86/kvm/emulate.c

1387

ctxt->dst.data = rc->data + rc->pos;

arch/x86/kvm/emulate.c

1388

ctxt->dst.type = OP_MEM_STR;

arch/x86/kvm/emulate.c

1389

ctxt->dst.count = (rc->end - rc->pos) / size;

arch/x86/kvm/emulate.c

1819

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

1841

return emulate_pop(ctxt, &ctxt->dst.val, ctxt->op_bytes);

arch/x86/kvm/emulate.c

1889

ctxt->dst.type = OP_REG;

arch/x86/kvm/emulate.c

1890

ctxt->dst.addr.reg = &ctxt->eflags;

arch/x86/kvm/emulate.c

1891

ctxt->dst.bytes = ctxt->op_bytes;

arch/x86/kvm/emulate.c

1892

return emulate_popf(ctxt, &ctxt->dst.val, ctxt->op_bytes);

arch/x86/kvm/emulate.c

2193

u64 old = ctxt->dst.orig_val64;

arch/x86/kvm/emulate.c

2195

if (ctxt->dst.bytes == 16)

arch/x86/kvm/emulate.c

2204

ctxt->dst.val64 = ((u64)reg_read(ctxt, VCPU_REGS_RCX) << 32) |

arch/x86/kvm/emulate.c

2265

ctxt->dst.orig_val = ctxt->dst.val;

arch/x86/kvm/emulate.c

2266

ctxt->dst.val = reg_read(ctxt, VCPU_REGS_RAX);

arch/x86/kvm/emulate.c

2268

ctxt->src.val = ctxt->dst.orig_val;

arch/x86/kvm/emulate.c

2274

ctxt->dst.val = ctxt->src.orig_val;

arch/x86/kvm/emulate.c

2279

ctxt->src.val = ctxt->dst.orig_val;

arch/x86/kvm/emulate.c

2281

ctxt->dst.val = ctxt->dst.orig_val;

arch/x86/kvm/emulate.c

2298

ctxt->dst.val = ctxt->src.val;

arch/x86/kvm/emulate.c

283

bytes = ctxt->dst.bytes; \

arch/x86/kvm/emulate.c

291

: "+a" (ctxt->dst.val), \

arch/x86/kvm/emulate.c

297

#define __EM_ASM_1(op, dst) \

arch/x86/kvm/emulate.c

298

__EM_ASM(#op " %%" #dst " \n\t")

arch/x86/kvm/emulate.c

2983

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

300

#define __EM_ASM_1_EX(op, dst) \

arch/x86/kvm/emulate.c

301

__EM_ASM(#op " %%" #dst " \n\t" \

arch/x86/kvm/emulate.c

3011

al = ctxt->dst.val;

arch/x86/kvm/emulate.c

3029

ctxt->dst.val = al;

arch/x86/kvm/emulate.c

304

#define __EM_ASM_2(op, dst, src) \

arch/x86/kvm/emulate.c

305

__EM_ASM(#op " %%" #src ", %%" #dst " \n\t")

arch/x86/kvm/emulate.c

3050

al = ctxt->dst.val & 0xff;

arch/x86/kvm/emulate.c

3054

ctxt->dst.val = (ctxt->dst.val & 0xffff0000) | al | (ah << 8);

arch/x86/kvm/emulate.c

3067

u8 al = ctxt->dst.val & 0xff;

arch/x86/kvm/emulate.c

3068

u8 ah = (ctxt->dst.val >> 8) & 0xff;

arch/x86/kvm/emulate.c

307

#define __EM_ASM_3(op, dst, src, src2) \

arch/x86/kvm/emulate.c

3072

ctxt->dst.val = (ctxt->dst.val & 0xffff0000) | al;

arch/x86/kvm/emulate.c

308

__EM_ASM(#op " %%" #src2 ", %%" #src ", %%" #dst " \n\t")

arch/x86/kvm/emulate.c

3157

ctxt->src.val = ctxt->dst.val;

arch/x86/kvm/emulate.c

3161

ctxt->dst.val = ctxt->src.orig_val;

arch/x86/kvm/emulate.c

3168

ctxt->dst.val = ctxt->src2.val;

arch/x86/kvm/emulate.c

3174

ctxt->dst.type = OP_REG;

arch/x86/kvm/emulate.c

3175

ctxt->dst.bytes = ctxt->src.bytes;

arch/x86/kvm/emulate.c

3176

ctxt->dst.addr.reg = reg_rmw(ctxt, VCPU_REGS_RDX);

arch/x86/kvm/emulate.c

3177

ctxt->dst.val = ~((ctxt->src.val >> (ctxt->src.bytes * 8 - 1)) - 1);

arch/x86/kvm/emulate.c

3190

ctxt->dst.val = tsc_aux;

arch/x86/kvm/emulate.c

3217

memcpy(ctxt->dst.valptr, ctxt->src.valptr, sizeof(ctxt->src.valptr));

arch/x86/kvm/emulate.c

3239

ctxt->dst.val &= ~0xffffUL;

arch/x86/kvm/emulate.c

3240

ctxt->dst.val |= (unsigned long)swab16(tmp);

arch/x86/kvm/emulate.c

3243

ctxt->dst.val = swab32((u32)ctxt->src.val);

arch/x86/kvm/emulate.c

3246

ctxt->dst.val = swab64(ctxt->src.val);

arch/x86/kvm/emulate.c

3263

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3292

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3337

ctxt->dst.val = get_segment_selector(ctxt, segment);

arch/x86/kvm/emulate.c

3338

if (ctxt->dst.bytes == 4 && ctxt->dst.type == OP_MEM)

arch/x86/kvm/emulate.c

3339

ctxt->dst.bytes = 2;

arch/x86/kvm/emulate.c

3362

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3376

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3390

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3405

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3429

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3451

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3452

return segmented_write_std(ctxt, ctxt->dst.addr.mem,

arch/x86/kvm/emulate.c

3487

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3507

if (ctxt->dst.type == OP_MEM)

arch/x86/kvm/emulate.c

3508

ctxt->dst.bytes = 2;

arch/x86/kvm/emulate.c

3509

ctxt->dst.val = ctxt->ops->get_cr(ctxt, 0);

arch/x86/kvm/emulate.c

3517

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3545

if (!pio_in_emulated(ctxt, ctxt->dst.bytes, ctxt->src.val,

arch/x86/kvm/emulate.c

3546

&ctxt->dst.val))

arch/x86/kvm/emulate.c

3554

ctxt->ops->pio_out_emulated(ctxt, ctxt->src.bytes, ctxt->dst.val,

arch/x86/kvm/emulate.c

3557

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

3626

asm("bswap %0" : "+r"(ctxt->dst.val));

arch/x86/kvm/emulate.c

3630

asm("bswap %0" : "+r"(*(u32 *)&ctxt->dst.val));

arch/x86/kvm/emulate.c

3650

ctxt->dst.val = (s32) ctxt->src.val;

arch/x86/kvm/emulate.c

3920

ctxt->dst.bytes = min(ctxt->dst.bytes, 4u);

arch/x86/kvm/emulate.c

3921

if (!emulator_io_permitted(ctxt, ctxt->src.val, ctxt->dst.bytes))

arch/x86/kvm/emulate.c

393

ctxt->dst.val = 0xFF * !!(ctxt->eflags & X86_EFLAGS_CF);

arch/x86/kvm/emulate.c

3930

if (!emulator_io_permitted(ctxt, ctxt->dst.val, ctxt->src.bytes))

arch/x86/kvm/emulate.c

424

.dst_val = ctxt->dst.val64,

arch/x86/kvm/emulate.c

426

.dst_bytes = ctxt->dst.bytes,

arch/x86/kvm/emulate.c

428

.dst_type = ctxt->dst.type,

arch/x86/kvm/emulate.c

5190

rc = decode_operand(ctxt, &ctxt->dst, (ctxt->d >> DstShift) & OpMask);

arch/x86/kvm/emulate.c

5268

int saved_dst_type = ctxt->dst.type;

arch/x86/kvm/emulate.c

5273

if (ctxt->lock_prefix && (!(ctxt->d & Lock) || ctxt->dst.type != OP_MEM)) {

arch/x86/kvm/emulate.c

5327

fetch_possible_mmx_operand(&ctxt->dst);

arch/x86/kvm/emulate.c

5396

if ((ctxt->dst.type == OP_MEM) && !(ctxt->d & Mov)) {

arch/x86/kvm/emulate.c

5398

rc = segmented_read(ctxt, ctxt->dst.addr.mem,

arch/x86/kvm/emulate.c

5399

&ctxt->dst.val, ctxt->dst.bytes);

arch/x86/kvm/emulate.c

5409

ctxt->dst.orig_val64 = ctxt->dst.val64;

arch/x86/kvm/emulate.c

5443

ctxt->dst.val = ctxt->src.addr.mem.ea;

arch/x86/kvm/emulate.c

5446

if (ctxt->dst.addr.reg == reg_rmw(ctxt, VCPU_REGS_RAX))

arch/x86/kvm/emulate.c

5447

ctxt->dst.type = OP_NONE;

arch/x86/kvm/emulate.c

5453

case 2: ctxt->dst.val = (s8)ctxt->dst.val; break;

arch/x86/kvm/emulate.c

5454

case 4: ctxt->dst.val = (s16)ctxt->dst.val; break;

arch/x86/kvm/emulate.c

5455

case 8: ctxt->dst.val = (s32)ctxt->dst.val; break;

arch/x86/kvm/emulate.c

5471

ctxt->dst.type = OP_NONE; /* Disable writeback. */

arch/x86/kvm/emulate.c

5507

rc = writeback(ctxt, &ctxt->dst);

arch/x86/kvm/emulate.c

5516

ctxt->dst.type = saved_dst_type;

arch/x86/kvm/emulate.c

5522

string_addr_inc(ctxt, VCPU_REGS_RDI, &ctxt->dst);

arch/x86/kvm/emulate.c

5530

count = ctxt->dst.count;

arch/x86/kvm/emulate.c

5583

ctxt->dst.val = ops->get_cr(ctxt, ctxt->modrm_reg);

arch/x86/kvm/emulate.c

5586

ctxt->dst.val = ops->get_dr(ctxt, ctxt->modrm_reg);

arch/x86/kvm/emulate.c

5590

ctxt->dst.val = ctxt->src.val;

arch/x86/kvm/emulate.c

5592

ctxt->dst.type = OP_NONE; /* no writeback */

arch/x86/kvm/emulate.c

5599

ctxt->dst.val = test_cc(ctxt->b, ctxt->eflags);

arch/x86/kvm/emulate.c

5602

ctxt->dst.bytes = ctxt->op_bytes;

arch/x86/kvm/emulate.c

5603

ctxt->dst.val = (ctxt->src.bytes == 1) ? (u8) ctxt->src.val

arch/x86/kvm/emulate.c

5607

ctxt->dst.bytes = ctxt->op_bytes;

arch/x86/kvm/emulate.c

5608

ctxt->dst.val = (ctxt->src.bytes == 1) ? (s8) ctxt->src.val :

arch/x86/kvm/emulate.c

714

static inline int assign_eip(struct x86_emulate_ctxt *ctxt, ulong dst)

arch/x86/kvm/emulate.c

720

.ea = dst };

arch/x86/kvm/emulate.c

723

addr.ea = dst & ((1UL << (ctxt->op_bytes << 3)) - 1);

arch/x86/kvm/emulate.c

777

static inline int assign_eip_near(struct x86_emulate_ctxt *ctxt, ulong dst)

arch/x86/kvm/emulate.c

779

return assign_eip(ctxt, dst);

arch/x86/kvm/emulate.c

782

static int assign_eip_far(struct x86_emulate_ctxt *ctxt, ulong dst)

arch/x86/kvm/emulate.c

789

return assign_eip(ctxt, dst);

arch/x86/kvm/kvm_emulate.h

392

struct operand dst;

arch/x86/kvm/lapic.c

1154

struct kvm_apic_map *map, struct kvm_lapic ***dst,

arch/x86/kvm/lapic.c

1160

*dst = src;

arch/x86/kvm/lapic.c

1174

*dst = &map->phys_map[dest_id];

arch/x86/kvm/lapic.c

1181

if (!kvm_apic_map_get_logical_dest(map, irq->dest_id, dst,

arch/x86/kvm/lapic.c

1191

if (!(*dst)[i])

arch/x86/kvm/lapic.c

1195

else if (kvm_apic_compare_prio((*dst)[i]->vcpu,

arch/x86/kvm/lapic.c

1196

(*dst)[lowest]->vcpu) < 0)

arch/x86/kvm/lapic.c

1206

if (!(*dst)[lowest]) {

arch/x86/kvm/lapic.c

1224

struct kvm_lapic **dst = NULL;

arch/x86/kvm/lapic.c

1242

ret = kvm_apic_map_get_dest_lapic(kvm, &src, irq, map, &dst, &bitmap);

arch/x86/kvm/lapic.c

1246

if (!dst[i])

arch/x86/kvm/lapic.c

1248

*r += kvm_apic_set_irq(dst[i]->vcpu, irq, rtc_status);

arch/x86/kvm/lapic.c

1283

struct kvm_lapic **dst = NULL;

arch/x86/kvm/lapic.c

1292

if (kvm_apic_map_get_dest_lapic(kvm, NULL, irq, map, &dst, &bitmap) &&

arch/x86/kvm/lapic.c

1296

if (dst[i]) {

arch/x86/kvm/lapic.c

1297

*dest_vcpu = dst[i]->vcpu;

arch/x86/kvm/svm/nested.c

1708

static void nested_copy_vmcb_cache_to_control(struct vmcb_control_area *dst,

arch/x86/kvm/svm/nested.c

1713

memset(dst, 0, sizeof(struct vmcb_control_area));

arch/x86/kvm/svm/nested.c

1716

dst->intercepts[i] = from->intercepts[i];

arch/x86/kvm/svm/nested.c

1718

dst->iopm_base_pa = from->iopm_base_pa;

arch/x86/kvm/svm/nested.c

1719

dst->msrpm_base_pa = from->msrpm_base_pa;

arch/x86/kvm/svm/nested.c

1720

dst->tsc_offset = from->tsc_offset;

arch/x86/kvm/svm/nested.c

1721

dst->asid = from->asid;

arch/x86/kvm/svm/nested.c

1722

dst->tlb_ctl = from->tlb_ctl;

arch/x86/kvm/svm/nested.c

1723

dst->erap_ctl = from->erap_ctl;

arch/x86/kvm/svm/nested.c

1724

dst->int_ctl = from->int_ctl;

arch/x86/kvm/svm/nested.c

1725

dst->int_vector = from->int_vector;

arch/x86/kvm/svm/nested.c

1726

dst->int_state = from->int_state;

arch/x86/kvm/svm/nested.c

1727

dst->exit_code = from->exit_code;

arch/x86/kvm/svm/nested.c

1728

dst->exit_info_1 = from->exit_info_1;

arch/x86/kvm/svm/nested.c

1729

dst->exit_info_2 = from->exit_info_2;

arch/x86/kvm/svm/nested.c

1730

dst->exit_int_info = from->exit_int_info;

arch/x86/kvm/svm/nested.c

1731

dst->exit_int_info_err = from->exit_int_info_err;

arch/x86/kvm/svm/nested.c

1732

dst->nested_ctl = from->nested_ctl;

arch/x86/kvm/svm/nested.c

1733

dst->event_inj = from->event_inj;

arch/x86/kvm/svm/nested.c

1734

dst->event_inj_err = from->event_inj_err;

arch/x86/kvm/svm/nested.c

1735

dst->next_rip = from->next_rip;

arch/x86/kvm/svm/nested.c

1736

dst->nested_cr3 = from->nested_cr3;

arch/x86/kvm/svm/nested.c

1737

dst->virt_ext = from->virt_ext;

arch/x86/kvm/svm/nested.c

1738

dst->pause_filter_count = from->pause_filter_count;

arch/x86/kvm/svm/nested.c

1739

dst->pause_filter_thresh = from->pause_filter_thresh;

arch/x86/kvm/svm/sev.c

1144

unsigned long dst, int size,

arch/x86/kvm/svm/sev.c

1151

data.dst_addr = dst;

arch/x86/kvm/svm/sev.c

1966

struct kvm_sev_info *dst = to_kvm_sev_info(dst_kvm);

arch/x86/kvm/svm/sev.c

1973

dst->active = true;

arch/x86/kvm/svm/sev.c

1974

dst->asid = src->asid;

arch/x86/kvm/svm/sev.c

1975

dst->handle = src->handle;

arch/x86/kvm/svm/sev.c

1976

dst->pages_locked = src->pages_locked;

arch/x86/kvm/svm/sev.c

1977

dst->enc_context_owner = src->enc_context_owner;

arch/x86/kvm/svm/sev.c

1978

dst->es_active = src->es_active;

arch/x86/kvm/svm/sev.c

1979

dst->vmsa_features = src->vmsa_features;

arch/x86/kvm/svm/sev.c

1988

list_cut_before(&dst->regions_list, &src->regions_list, &src->regions_list);

arch/x86/kvm/svm/sev.c

1995

list_cut_before(&dst->mirror_vms, &src->mirror_vms, &src->mirror_vms);

arch/x86/kvm/svm/sev.c

1996

list_for_each_entry(mirror, &dst->mirror_vms, mirror_entry) {

arch/x86/kvm/svm/sev.c

2007

struct kvm_sev_info *owner_sev_info = to_kvm_sev_info(dst->enc_context_owner);

arch/x86/kvm/svm/sev.c

2010

list_add_tail(&dst->mirror_entry, &owner_sev_info->mirror_vms);

arch/x86/kvm/svm/sev.c

2018

if (!dst->es_active)

arch/x86/kvm/svm/sev.c

2045

static int sev_check_source_vcpus(struct kvm *dst, struct kvm *src)

arch/x86/kvm/svm/sev.c

2051

dst->created_vcpus != atomic_read(&dst->online_vcpus))

arch/x86/kvm/svm/sev.c

2057

if (atomic_read(&src->online_vcpus) != atomic_read(&dst->online_vcpus))

arch/x86/kvm/vmx/nested.c

3538

gpa_t dst;

arch/x86/kvm/vmx/nested.c

3560

dst = vmcs12->pml_address + sizeof(u64) * vmcs12->guest_pml_index;

arch/x86/kvm/vmx/nested.c

3562

if (kvm_write_guest_page(vcpu->kvm, gpa_to_gfn(dst), &gpa,

arch/x86/kvm/vmx/nested.c

3563

offset_in_page(dst), sizeof(gpa)))

arch/x86/kvm/vmx/tdx.c

2365

#define MEMCPY_SAME_SIZE(dst, src) \

arch/x86/kvm/vmx/tdx.c

2367

BUILD_BUG_ON(sizeof(dst) != sizeof(src)); \

arch/x86/kvm/vmx/tdx.c

2368

memcpy((dst), (src), sizeof(dst)); \

arch/x86/kvm/x86.h

716

void *dst);

arch/x86/kvm/x86.h

718

void *dst);

arch/x86/lib/copy_mc.c

104

return copy_user_generic((__force void *)dst, src, len);

arch/x86/lib/copy_mc.c

45

unsigned long copy_mc_enhanced_fast_string(void *dst, const void *src, unsigned len);

arch/x86/lib/copy_mc.c

63

unsigned long __must_check copy_mc_to_kernel(void *dst, const void *src, unsigned len)

arch/x86/lib/copy_mc.c

68

instrument_memcpy_before(dst, src, len);

arch/x86/lib/copy_mc.c

69

ret = copy_mc_fragile(dst, src, len);

arch/x86/lib/copy_mc.c

70

instrument_memcpy_after(dst, src, len, ret);

arch/x86/lib/copy_mc.c

74

instrument_memcpy_before(dst, src, len);

arch/x86/lib/copy_mc.c

75

ret = copy_mc_enhanced_fast_string(dst, src, len);

arch/x86/lib/copy_mc.c

76

instrument_memcpy_after(dst, src, len, ret);

arch/x86/lib/copy_mc.c

79

memcpy(dst, src, len);

arch/x86/lib/copy_mc.c

84

unsigned long __must_check copy_mc_to_user(void __user *dst, const void *src, unsigned len)

arch/x86/lib/copy_mc.c

89

instrument_copy_to_user(dst, src, len);

arch/x86/lib/copy_mc.c

91

ret = copy_mc_fragile((__force void *)dst, src, len);

arch/x86/lib/copy_mc.c

97

instrument_copy_to_user(dst, src, len);

arch/x86/lib/copy_mc.c

99

ret = copy_mc_enhanced_fast_string((__force void *)dst, src, len);

arch/x86/lib/csum-wrappers_64.c

22

csum_and_copy_from_user(const void __user *src, void *dst, int len)

arch/x86/lib/csum-wrappers_64.c

29

sum = csum_partial_copy_generic((__force const void *)src, dst, len);

arch/x86/lib/csum-wrappers_64.c

44

csum_and_copy_to_user(const void *src, void __user *dst, int len)

arch/x86/lib/csum-wrappers_64.c

49

if (!user_access_begin(dst, len))

arch/x86/lib/csum-wrappers_64.c

51

sum = csum_partial_copy_generic(src, (void __force *)dst, len);

arch/x86/lib/csum-wrappers_64.c

65

csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/x86/lib/csum-wrappers_64.c

67

return csum_partial_copy_generic(src, dst, len);

arch/x86/lib/usercopy_64.c

46

long __copy_user_flushcache(void *dst, const void __user *src, unsigned size)

arch/x86/lib/usercopy_64.c

48

unsigned long flushed, dest = (unsigned long) dst;

arch/x86/lib/usercopy_64.c

52

rc = __copy_user_nocache(dst, src, size);

arch/x86/lib/usercopy_64.c

65

clean_cache_range(dst, size);

arch/x86/lib/usercopy_64.c

69

clean_cache_range(dst, 1);

arch/x86/lib/usercopy_64.c

72

flushed = dest - (unsigned long) dst;

arch/x86/lib/usercopy_64.c

74

clean_cache_range(dst + size - 1, 1);

arch/x86/mm/mem_encrypt_amd.c

116

dst = enc ? early_memremap_encrypted(paddr, len) :

arch/x86/mm/mem_encrypt_amd.c

124

BUG_ON(!src || !dst);

arch/x86/mm/mem_encrypt_amd.c

132

snp_memcpy(dst, sme_early_buffer, len, paddr, !enc);

arch/x86/mm/mem_encrypt_amd.c

135

memcpy(dst, sme_early_buffer, len);

arch/x86/mm/mem_encrypt_amd.c

138

early_memunmap(dst, len);

arch/x86/mm/mem_encrypt_amd.c

57

static inline void __init snp_memcpy(void *dst, void *src, size_t sz,

arch/x86/mm/mem_encrypt_amd.c

69

memcpy(dst, src, sz);

arch/x86/mm/mem_encrypt_amd.c

78

memcpy(dst, src, sz);

arch/x86/mm/mem_encrypt_amd.c

94

void *src, *dst;

arch/x86/net/bpf_jit_comp.c

305

int bpf_arch_text_invalidate(void *dst, size_t len)

arch/x86/net/bpf_jit_comp.c

307

return IS_ERR_OR_NULL(text_poke_set(dst, 0xcc, len));

arch/x86/net/bpf_jit_comp.c

3940

void *bpf_arch_text_copy(void *dst, void *src, size_t len)

arch/x86/net/bpf_jit_comp.c

3942

if (text_poke_copy(dst, src, len) == NULL)

arch/x86/net/bpf_jit_comp.c

3944

return dst;

arch/x86/net/bpf_jit_comp32.c

1035

static inline void emit_ia32_mul_r64(const u8 dst[], const u8 src[], bool dstk,

arch/x86/net/bpf_jit_comp32.c

1112

static inline void emit_ia32_mul_i64(const u8 dst[], const u32 val,

arch/x86/net/bpf_jit_comp32.c

167

#define dst_lo dst[0]

arch/x86/net/bpf_jit_comp32.c

1678

const u8 *dst = bpf2ia32[insn->dst_reg];

arch/x86/net/bpf_jit_comp32.c

168

#define dst_hi dst[1]

arch/x86/net/bpf_jit_comp32.c

1700

emit_ia32_mov_r64(is64, dst, src, dstk, sstk,

arch/x86/net/bpf_jit_comp32.c

1705

emit_ia32_mov_i64(is64, dst, imm32,

arch/x86/net/bpf_jit_comp32.c

1740

emit_ia32_alu_r64(is64, BPF_OP(code), dst,

arch/x86/net/bpf_jit_comp32.c

1745

emit_ia32_alu_i64(is64, BPF_OP(code), dst,

arch/x86/net/bpf_jit_comp32.c

1835

emit_ia32_lsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1841

emit_ia32_rsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1845

emit_ia32_lsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1849

emit_ia32_rsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1853

emit_ia32_arsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1859

emit_ia32_arsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1870

emit_ia32_neg64(dst, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1877

emit_ia32_mul_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1880

emit_ia32_mul_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1886

emit_ia32_to_le_r64(dst, imm32, dstk, &prog,

arch/x86/net/bpf_jit_comp32.c

1891

emit_ia32_to_be_r64(dst, imm32, dstk, &prog,

arch/x86/net/bpf_jit_comp32.c

206

static inline void emit_ia32_mov_i(const u8 dst, const u32 val, bool dstk,

arch/x86/net/bpf_jit_comp32.c

218

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

221

STACK_VAR(dst), val);

arch/x86/net/bpf_jit_comp32.c

225

EMIT2(0x33, add_2reg(0xC0, dst, dst));

arch/x86/net/bpf_jit_comp32.c

227

EMIT2_off32(0xC7, add_1reg(0xC0, dst),

arch/x86/net/bpf_jit_comp32.c

234

static inline void emit_ia32_mov_r(const u8 dst, const u8 src, bool dstk,

arch/x86/net/bpf_jit_comp32.c

246

EMIT3(0x89, add_2reg(0x40, IA32_EBP, sreg), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

249

EMIT2(0x89, add_2reg(0xC0, dst, sreg));

arch/x86/net/bpf_jit_comp32.c

255

static inline void emit_ia32_mov_r64(const bool is64, const u8 dst[],

arch/x86/net/bpf_jit_comp32.c

270

static inline void emit_ia32_mov_i64(const bool is64, const u8 dst[],

arch/x86/net/bpf_jit_comp32.c

285

static inline void emit_ia32_mul_r(const u8 dst, const u8 src, bool dstk,

arch/x86/net/bpf_jit_comp32.c

298

EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EAX), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

301

EMIT2(0x8B, add_2reg(0xC0, dst, IA32_EAX));

arch/x86/net/bpf_jit_comp32.c

309

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

312

EMIT2(0x89, add_2reg(0xC0, dst, IA32_EAX));

arch/x86/net/bpf_jit_comp32.c

317

static inline void emit_ia32_to_le_r64(const u8 dst[], s32 val,

arch/x86/net/bpf_jit_comp32.c

365

static inline void emit_ia32_to_be_r64(const u8 dst[], s32 val,

arch/x86/net/bpf_jit_comp32.c

435

static inline void emit_ia32_div_mod_r(const u8 op, const u8 dst, const u8 src,

arch/x86/net/bpf_jit_comp32.c

452

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

455

EMIT2(0x8B, add_2reg(0xC0, dst, IA32_EAX));

arch/x86/net/bpf_jit_comp32.c

465

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

467

EMIT2(0x89, add_2reg(0xC0, dst, IA32_EDX));

arch/x86/net/bpf_jit_comp32.c

471

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

473

EMIT2(0x89, add_2reg(0xC0, dst, IA32_EAX));

arch/x86/net/bpf_jit_comp32.c

482

static inline void emit_ia32_shift_r(const u8 op, const u8 dst, const u8 src,

arch/x86/net/bpf_jit_comp32.c

487

u8 dreg = dstk ? IA32_EAX : dst;

arch/x86/net/bpf_jit_comp32.c

492

EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EAX), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

515

EMIT3(0x89, add_2reg(0x40, IA32_EBP, dreg), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

524

const u8 dst, const u8 src, bool dstk,

arch/x86/net/bpf_jit_comp32.c

530

u8 dreg = dstk ? IA32_EDX : dst;

arch/x86/net/bpf_jit_comp32.c

538

EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EDX), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

572

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

578

const u8 dst[], const u8 src[],

arch/x86/net/bpf_jit_comp32.c

598

const u8 dst, const s32 val, bool dstk,

arch/x86/net/bpf_jit_comp32.c

603

u8 dreg = dstk ? IA32_EAX : dst;

arch/x86/net/bpf_jit_comp32.c

608

EMIT3(0x8B, add_2reg(0x40, IA32_EBP, IA32_EAX), STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

672

STACK_VAR(dst));

arch/x86/net/bpf_jit_comp32.c

678

const u8 dst[], const u32 val,

arch/x86/net/bpf_jit_comp32.c

698

static inline void emit_ia32_neg64(const u8 dst[], bool dstk, u8 **pprog)

arch/x86/net/bpf_jit_comp32.c

731

static inline void emit_ia32_lsh_r64(const u8 dst[], const u8 src[],

arch/x86/net/bpf_jit_comp32.c

784

static inline void emit_ia32_arsh_r64(const u8 dst[], const u8 src[],

arch/x86/net/bpf_jit_comp32.c

837

static inline void emit_ia32_rsh_r64(const u8 dst[], const u8 src[], bool dstk,

arch/x86/net/bpf_jit_comp32.c

890

static inline void emit_ia32_lsh_i64(const u8 dst[], const u32 val,

arch/x86/net/bpf_jit_comp32.c

938

static inline void emit_ia32_rsh_i64(const u8 dst[], const u32 val,

arch/x86/net/bpf_jit_comp32.c

987

static inline void emit_ia32_arsh_i64(const u8 dst[], const u32 val,

arch/x86/um/asm/checksum.h

24

extern __visible __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/xtensa/boot/lib/zmem.c

36

void gunzip (void *dst, int dstlen, unsigned char *src, int *lenp)

arch/xtensa/boot/lib/zmem.c

7

void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp);

arch/xtensa/boot/lib/zmem.c

71

s.next_out = dst;

arch/xtensa/boot/lib/zmem.c

78

*lenp = s.next_out - (unsigned char *) dst;

arch/xtensa/include/asm/asmmacro.h

219

.macro do_abs dst, src, tmp

arch/xtensa/include/asm/cacheflush.h

167

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

arch/xtensa/include/asm/cacheflush.h

169

memcpy(dst, src, len); \

arch/xtensa/include/asm/cacheflush.h

170

__flush_dcache_range((unsigned long) dst, len); \

arch/xtensa/include/asm/cacheflush.h

171

__invalidate_icache_range((unsigned long) dst, len); \

arch/xtensa/include/asm/cacheflush.h

174

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

arch/xtensa/include/asm/cacheflush.h

175

memcpy(dst, src, len)

arch/xtensa/include/asm/checksum.h

241

void __user *dst, int len)

arch/xtensa/include/asm/checksum.h

243

if (!access_ok(dst, len))

arch/xtensa/include/asm/checksum.h

245

return csum_partial_copy_generic(src, (__force void *)dst, len);

arch/xtensa/include/asm/checksum.h

40

asmlinkage __wsum csum_partial_copy_generic(const void *src, void *dst, int len);

arch/xtensa/include/asm/checksum.h

48

__wsum csum_partial_copy_nocheck(const void *src, void *dst, int len)

arch/xtensa/include/asm/checksum.h

50

return csum_partial_copy_generic(src, dst, len);

arch/xtensa/include/asm/checksum.h

55

__wsum csum_and_copy_from_user(const void __user *src, void *dst,

arch/xtensa/include/asm/checksum.h

60

return csum_partial_copy_generic((__force const void *)src, dst, len);

arch/xtensa/include/asm/string.h

128

#define memcpy(dst, src, len) __memcpy(dst, src, len)

arch/xtensa/include/asm/string.h

129

#define memmove(dst, src, len) __memmove(dst, src, len)

arch/xtensa/include/asm/uaccess.h

270

extern long __strncpy_user(char *dst, const char __user *src, long count);

arch/xtensa/include/asm/uaccess.h

273

strncpy_from_user(char *dst, const char __user *src, long count)

arch/xtensa/include/asm/uaccess.h

276

return __strncpy_user(dst, src, count);

arch/xtensa/include/asm/uaccess.h

280

long strncpy_from_user(char *dst, const char __user *src, long count);

arch/xtensa/kernel/process.c

217

int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)

arch/xtensa/kernel/process.c

222

*dst = *src;

arch/xtensa/mm/cache.c

102

void copy_user_highpage(struct page *dst, struct page *src,

arch/xtensa/mm/cache.c

105

struct folio *folio = page_folio(dst);

arch/xtensa/mm/cache.c

107

void *dst_vaddr = coherent_kvaddr(dst, TLBTEMP_BASE_1, vaddr,

arch/xtensa/mm/cache.c

113

kmap_invalidate_coherent(dst, vaddr);

arch/xtensa/mm/cache.c

274

unsigned long vaddr, void *dst, const void *src,

arch/xtensa/mm/cache.c

291

memcpy(dst, src, len);

arch/xtensa/mm/cache.c

302

__flush_invalidate_dcache_range((unsigned long) dst, len);

arch/xtensa/mm/cache.c

308

__flush_dcache_range((unsigned long)dst,len);

arch/xtensa/mm/cache.c

309

__invalidate_icache_range((unsigned long) dst, len);

arch/xtensa/mm/cache.c

314

unsigned long vaddr, void *dst, const void *src,

arch/xtensa/mm/cache.c

332

memcpy(dst, src, len);

block/bio.c

1575

void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,

block/bio.c

1580

struct bio_vec dst_bv = bio_iter_iovec(dst, *dst_iter);

block/bio.c

1591

bio_advance_iter_single(dst, dst_iter, bytes);

block/bio.c

1604

void bio_copy_data(struct bio *dst, struct bio *src)

block/bio.c

1607

struct bvec_iter dst_iter = dst->bi_iter;

block/bio.c

1609

bio_copy_data_iter(dst, &dst_iter, src, &src_iter);

block/blk-cgroup.c

1008

static void blkg_iostat_add(struct blkg_iostat *dst, struct blkg_iostat *src)

block/blk-cgroup.c

1013

dst->bytes[i] += src->bytes[i];

block/blk-cgroup.c

1014

dst->ios[i] += src->ios[i];

block/blk-cgroup.c

1018

static void blkg_iostat_sub(struct blkg_iostat *dst, struct blkg_iostat *src)

block/blk-cgroup.c

1023

dst->bytes[i] -= src->bytes[i];

block/blk-cgroup.c

1024

dst->ios[i] -= src->ios[i];

block/blk-cgroup.c

2172

void bio_clone_blkg_association(struct bio *dst, struct bio *src)

block/blk-cgroup.c

2175

bio_associate_blkg_from_css(dst, bio_blkcg_css(src));

block/blk-cgroup.c

616

static void blkg_iostat_set(struct blkg_iostat *dst, struct blkg_iostat *src)

block/blk-cgroup.c

621

dst->bytes[i] = src->bytes[i];

block/blk-cgroup.c

622

dst->ios[i] = src->ios[i];

block/blk-crypto-fallback.c

248

struct scatterlist src, dst;

block/blk-crypto-fallback.c

261

sg_init_table(&dst, 1);

block/blk-crypto-fallback.c

263

skcipher_request_set_crypt(ciph_req, &src, &dst, data_unit_size,

block/blk-crypto-fallback.c

292

sg_set_page(&dst, enc_page, data_unit_size, src_bv.bv_offset);

block/blk-crypto-fallback.c

311

dst.offset += data_unit_size;

block/blk-crypto-profile.c

653

void blk_crypto_update_capabilities(struct blk_crypto_profile *dst,

block/blk-crypto-profile.c

656

memcpy(dst->modes_supported, src->modes_supported,

block/blk-crypto-profile.c

657

sizeof(dst->modes_supported));

block/blk-crypto-profile.c

659

dst->max_dun_bytes_supported = src->max_dun_bytes_supported;

block/blk-crypto-profile.c

660

dst->key_types_supported = src->key_types_supported;

block/blk-crypto.c

126

int __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask)

block/blk-crypto.c

128

dst->bi_crypt_context = mempool_alloc(bio_crypt_ctx_pool, gfp_mask);

block/blk-crypto.c

129

if (!dst->bi_crypt_context)

block/blk-crypto.c

131

*dst->bi_crypt_context = *src->bi_crypt_context;

block/blk-stat.c

28

void blk_rq_stat_sum(struct blk_rq_stat *dst, struct blk_rq_stat *src)

block/blk-stat.c

30

if (dst->nr_samples + src->nr_samples <= dst->nr_samples)

block/blk-stat.c

33

dst->min = min(dst->min, src->min);

block/blk-stat.c

34

dst->max = max(dst->max, src->max);

block/blk-stat.c

36

dst->mean = div_u64(src->batch + dst->mean * dst->nr_samples,

block/blk-stat.c

37

dst->nr_samples + src->nr_samples);

block/blk-stat.c

39

dst->nr_samples += src->nr_samples;

block/sed-opal.c

1401

u8 *dst;

block/sed-opal.c

1441

dst = add_bytestring_header(&err, dev, len);

block/sed-opal.c

1442

if (!dst)

block/sed-opal.c

1445

if (copy_from_user(dst, src + off, len)) {

block/sed-opal.c

2378

u8 __user *dst;

block/sed-opal.c

2428

dst = (u8 __user *)(uintptr_t)read_tbl->data;

block/sed-opal.c

2429

if (copy_to_user(dst + off, dev->prev_data, dev->prev_d_len)) {

crypto/842.c

44

u8 *dst, unsigned int *dlen, void *ctx)

crypto/842.c

46

return sw842_compress(src, slen, dst, dlen, ctx);

crypto/842.c

51

u8 *dst, unsigned int *dlen, void *ctx)

crypto/842.c

53

return sw842_decompress(src, slen, dst, dlen);

crypto/acompress.c

192

acomp_request_set_dst_dma(req, state->dst, dlen);

crypto/acompress.c

215

state->dst = dvirt;

crypto/acompress.c

532

struct scatterlist *dst = req->dst;

crypto/acompress.c

557

scatterwalk_start(&walk->out, dst);

crypto/acompress.c

575

if (req->dst == &req->chain.dsg)

crypto/acompress.c

576

nreq->dst = &nreq->chain.dsg;

crypto/adiantum.c

374

struct scatterlist *src = req->src, *dst = req->dst;

crypto/adiantum.c

447

req->dst, stream_len, &rbuf);

crypto/adiantum.c

465

if (dst->length >= req->cryptlen &&

crypto/adiantum.c

466

dst->offset + req->cryptlen <= PAGE_SIZE) {

crypto/adiantum.c

468

struct page *page = sg_page(dst);

crypto/adiantum.c

469

void *virt = kmap_local_page(page) + dst->offset;

crypto/adiantum.c

480

adiantum_hash_message(req, dst, &msg_hash);

crypto/adiantum.c

482

memcpy_to_sglist(dst, bulk_len, &rbuf.bignum, sizeof(le128));

crypto/aegis-neon.h

10

void crypto_aegis128_decrypt_chunk_neon(void *state, void *dst, const void *src,

crypto/aegis-neon.h

8

void crypto_aegis128_encrypt_chunk_neon(void *state, void *dst, const void *src,

crypto/aegis.h

36

void crypto_aegis128_encrypt_chunk_simd(struct aegis_state *state, u8 *dst,

crypto/aegis.h

38

void crypto_aegis128_decrypt_chunk_simd(struct aegis_state *state, u8 *dst,

crypto/aegis.h

46

static __always_inline void crypto_aegis_block_xor(union aegis_block *dst,

crypto/aegis.h

49

dst->words64[0] ^= src->words64[0];

crypto/aegis.h

50

dst->words64[1] ^= src->words64[1];

crypto/aegis.h

53

static __always_inline void crypto_aegis_block_and(union aegis_block *dst,

crypto/aegis.h

56

dst->words64[0] &= src->words64[0];

crypto/aegis.h

57

dst->words64[1] &= src->words64[1];

crypto/aegis.h

60

static __always_inline void crypto_aegis_aesenc(union aegis_block *dst,

crypto/aegis.h

73

dst->words32[0] = cpu_to_le32(d0) ^ key->words32[0];

crypto/aegis.h

74

dst->words32[1] = cpu_to_le32(d1) ^ key->words32[1];

crypto/aegis.h

75

dst->words32[2] = cpu_to_le32(d2) ^ key->words32[2];

crypto/aegis.h

76

dst->words32[3] = cpu_to_le32(d3) ^ key->words32[3];

crypto/aegis128-core.c

147

static void crypto_aegis128_wipe_chunk(struct aegis_state *state, u8 *dst,

crypto/aegis128-core.c

150

memzero_explicit(dst, size);

crypto/aegis128-core.c

153

static void crypto_aegis128_encrypt_chunk(struct aegis_state *state, u8 *dst,

crypto/aegis128-core.c

158

if (AEGIS_ALIGNED(src) && AEGIS_ALIGNED(dst)) {

crypto/aegis128-core.c

161

(union aegis_block *)dst;

crypto/aegis128-core.c

177

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-core.c

189

memcpy(dst, tmp.bytes, AEGIS_BLOCK_SIZE);

crypto/aegis128-core.c

193

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-core.c

210

memcpy(dst, msg.bytes, size);

crypto/aegis128-core.c

214

static void crypto_aegis128_decrypt_chunk(struct aegis_state *state, u8 *dst,

crypto/aegis128-core.c

219

if (AEGIS_ALIGNED(src) && AEGIS_ALIGNED(dst)) {

crypto/aegis128-core.c

222

(union aegis_block *)dst;

crypto/aegis128-core.c

238

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-core.c

250

memcpy(dst, tmp.bytes, AEGIS_BLOCK_SIZE);

crypto/aegis128-core.c

254

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-core.c

272

memcpy(dst, msg.bytes, size);

crypto/aegis128-core.c

323

u8 *dst,

crypto/aegis128-core.c

335

crypt(state, walk->dst.virt.addr, walk->src.virt.addr, nbytes);

crypto/aegis128-core.c

403

scatterwalk_map_and_copy(tag.bytes, req->dst, req->assoclen + cryptlen,

crypto/aegis128-core.c

467

scatterwalk_map_and_copy(tag.bytes, req->dst, req->assoclen + cryptlen,

crypto/aegis128-neon-inner.c

222

void crypto_aegis128_encrypt_chunk_neon(void *state, void *dst, const void *src,

crypto/aegis128-neon-inner.c

237

vst1q_u8(dst, msg);

crypto/aegis128-neon-inner.c

241

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-neon-inner.c

248

void *out = dst;

crypto/aegis128-neon-inner.c

263

memcpy(dst, out, size);

crypto/aegis128-neon-inner.c

271

void crypto_aegis128_decrypt_chunk_neon(void *state, void *dst, const void *src,

crypto/aegis128-neon-inner.c

283

vst1q_u8(dst, msg);

crypto/aegis128-neon-inner.c

287

dst += AEGIS_BLOCK_SIZE;

crypto/aegis128-neon-inner.c

294

void *out = dst;

crypto/aegis128-neon-inner.c

309

memcpy(dst, out, size);

crypto/aegis128-neon.c

37

void crypto_aegis128_encrypt_chunk_simd(struct aegis_state *state, u8 *dst,

crypto/aegis128-neon.c

41

crypto_aegis128_encrypt_chunk_neon(state, dst, src, size);

crypto/aegis128-neon.c

44

void crypto_aegis128_decrypt_chunk_simd(struct aegis_state *state, u8 *dst,

crypto/aegis128-neon.c

48

crypto_aegis128_decrypt_chunk_neon(state, dst, src, size);

crypto/af_alg.c

684

void af_alg_pull_tsgl(struct sock *sk, size_t used, struct scatterlist *dst)

crypto/af_alg.c

708

if (dst) {

crypto/af_alg.c

711

sg_set_page(dst + j, page, plen, sg[i].offset);

crypto/akcipher.c

210

memcpy(data->dst, data->buf, data->dlen);

crypto/akcipher.c

218

void *dst, unsigned int dlen)

crypto/akcipher.c

223

.dst = dst,

crypto/akcipher.c

236

void *dst, unsigned int dlen)

crypto/akcipher.c

241

.dst = dst,

crypto/akcipher.c

26

void *dst;

crypto/anubis.c

572

u8 *dst, const u8 *src, const int R)

crypto/anubis.c

654

put_unaligned_be32(inter[i], &dst[4 * i]);

crypto/anubis.c

657

static void anubis_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/anubis.c

660

anubis_crypt(ctx->E, dst, src, ctx->R);

crypto/anubis.c

663

static void anubis_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/anubis.c

666

anubis_crypt(ctx->D, dst, src, ctx->R);

crypto/arc4.c

28

u8 *dst, unsigned nbytes, u8 *siv, u32 flags)

crypto/arc4.c

37

arc4_crypt(ctx, dst, src, nbytes);

crypto/asymmetric_keys/public_key.c

164

static u8 *pkey_pack_u32(u8 *dst, u32 val)

crypto/asymmetric_keys/public_key.c

166

memcpy(dst, &val, sizeof(val));

crypto/asymmetric_keys/public_key.c

167

return dst + sizeof(val);

crypto/authenc.c

118

scatterwalk_map_and_copy(ahreq->result, req->dst,

crypto/authenc.c

159

ahash_request_set_crypt(ahreq, req->dst, hash,

crypto/authenc.c

169

scatterwalk_map_and_copy(hash, req->dst, req->assoclen + req->cryptlen,

crypto/authenc.c

198

struct scatterlist *src, *dst;

crypto/authenc.c

202

dst = src;

crypto/authenc.c

204

if (req->src != req->dst) {

crypto/authenc.c

205

memcpy_sglist(req->dst, req->src, req->assoclen);

crypto/authenc.c

206

dst = scatterwalk_ffwd(areq_ctx->dst, req->dst, req->assoclen);

crypto/authenc.c

212

skcipher_request_set_crypt(skreq, src, dst, cryptlen, req->iv);

crypto/authenc.c

242

struct scatterlist *src, *dst;

crypto/authenc.c

250

dst = src;

crypto/authenc.c

252

if (req->src != req->dst)

crypto/authenc.c

253

dst = scatterwalk_ffwd(areq_ctx->dst, req->dst, req->assoclen);

crypto/authenc.c

260

skcipher_request_set_crypt(skreq, src, dst,

crypto/authenc.c

34

struct scatterlist dst[2];

crypto/authencesn.c

101

scatterwalk_map_and_copy(hash, dst, assoclen + cryptlen, authsize, 1);

crypto/authencesn.c

125

struct scatterlist *dst = req->dst;

crypto/authencesn.c

132

scatterwalk_map_and_copy(tmp, dst, 0, 8, 0);

crypto/authencesn.c

133

scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);

crypto/authencesn.c

134

scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1);

crypto/authencesn.c

136

sg_init_table(areq_ctx->dst, 2);

crypto/authencesn.c

137

dst = scatterwalk_ffwd(areq_ctx->dst, dst, 4);

crypto/authencesn.c

140

ahash_request_set_crypt(ahreq, dst, hash, assoclen + cryptlen);

crypto/authencesn.c

169

struct scatterlist *src, *dst;

crypto/authencesn.c

177

dst = src;

crypto/authencesn.c

179

if (req->src != req->dst) {

crypto/authencesn.c

180

memcpy_sglist(req->dst, req->src, assoclen);

crypto/authencesn.c

181

sg_init_table(areq_ctx->dst, 2);

crypto/authencesn.c

182

dst = scatterwalk_ffwd(areq_ctx->dst, req->dst, assoclen);

crypto/authencesn.c

188

skcipher_request_set_crypt(skreq, src, dst, cryptlen, req->iv);

crypto/authencesn.c

211

struct scatterlist *dst = req->dst;

crypto/authencesn.c

218

if (src == dst) {

crypto/authencesn.c

220

scatterwalk_map_and_copy(tmp, dst, 4, 4, 0);

crypto/authencesn.c

221

scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 0);

crypto/authencesn.c

222

scatterwalk_map_and_copy(tmp, dst, 0, 8, 1);

crypto/authencesn.c

224

memcpy_sglist(dst, src, assoclen);

crypto/authencesn.c

231

if (src != dst)

crypto/authencesn.c

233

dst = scatterwalk_ffwd(areq_ctx->dst, dst, assoclen);

crypto/authencesn.c

238

skcipher_request_set_crypt(skreq, src, dst, cryptlen, req->iv);

crypto/authencesn.c

264

struct scatterlist *dst = req->dst;

crypto/authencesn.c

280

if (src == dst) {

crypto/authencesn.c

281

scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);

crypto/authencesn.c

282

scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1);

crypto/authencesn.c

283

dst = scatterwalk_ffwd(areq_ctx->dst, dst, 4);

crypto/authencesn.c

285

scatterwalk_map_and_copy(tmp, dst, 0, 4, 1);

crypto/authencesn.c

286

scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen - 4, 4, 1);

crypto/authencesn.c

289

dst = scatterwalk_ffwd(areq_ctx->dst, dst, 4);

crypto/authencesn.c

290

memcpy_sglist(dst, src, assoclen + cryptlen - 8);

crypto/authencesn.c

291

dst = req->dst;

crypto/authencesn.c

295

ahash_request_set_crypt(ahreq, dst, ohash, assoclen + cryptlen);

crypto/authencesn.c

37

struct scatterlist dst[2];

crypto/authencesn.c

93

struct scatterlist *dst = req->dst;

crypto/authencesn.c

97

scatterwalk_map_and_copy(tmp, dst, 4, 4, 0);

crypto/authencesn.c

98

scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 0);

crypto/authencesn.c

99

scatterwalk_map_and_copy(tmp, dst, 0, 8, 1);

crypto/blowfish_common.c

311

static void encrypt_block(struct bf_ctx *bctx, u32 *dst, u32 *src)

crypto/blowfish_common.c

338

dst[0] = yr;

crypto/blowfish_common.c

339

dst[1] = yl;

crypto/blowfish_generic.c

37

static void bf_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/blowfish_generic.c

65

put_unaligned_be32(yr, dst);

crypto/blowfish_generic.c

66

put_unaligned_be32(yl, dst + 4);

crypto/blowfish_generic.c

69

static void bf_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/blowfish_generic.c

97

put_unaligned_be32(yr, dst);

crypto/blowfish_generic.c

98

put_unaligned_be32(yl, dst + 4);

crypto/bpf_crypto_skcipher.c

43

static int bpf_crypto_lskcipher_encrypt(void *tfm, const u8 *src, u8 *dst,

crypto/bpf_crypto_skcipher.c

46

return crypto_lskcipher_encrypt(tfm, src, dst, len, siv);

crypto/bpf_crypto_skcipher.c

49

static int bpf_crypto_lskcipher_decrypt(void *tfm, const u8 *src, u8 *dst,

crypto/bpf_crypto_skcipher.c

52

return crypto_lskcipher_decrypt(tfm, src, dst, len, siv);

crypto/cbc.c

123

u8 *dst, unsigned len, u8 *iv, u32 flags)

crypto/cbc.c

130

if (src == dst)

crypto/cbc.c

131

rem = crypto_cbc_decrypt_inplace(cipher, dst, len, iv);

crypto/cbc.c

133

rem = crypto_cbc_decrypt_segment(cipher, src, dst, len, iv);

crypto/cbc.c

16

const u8 *src, u8 *dst, unsigned nbytes,

crypto/cbc.c

21

for (; nbytes >= bsize; src += bsize, dst += bsize, nbytes -= bsize) {

crypto/cbc.c

23

crypto_lskcipher_encrypt(tfm, iv, dst, bsize, NULL);

crypto/cbc.c

24

memcpy(iv, dst, bsize);

crypto/cbc.c

54

u8 *dst, unsigned len, u8 *iv, u32 flags)

crypto/cbc.c

61

if (src == dst)

crypto/cbc.c

62

rem = crypto_cbc_encrypt_inplace(cipher, dst, len, iv);

crypto/cbc.c

64

rem = crypto_cbc_encrypt_segment(cipher, src, dst, len, iv);

crypto/cbc.c

70

const u8 *src, u8 *dst, unsigned nbytes,

crypto/cbc.c

80

crypto_lskcipher_decrypt(tfm, src, dst, bsize, NULL);

crypto/cbc.c

81

crypto_xor(dst, iv, bsize);

crypto/cbc.c

85

dst += bsize;

crypto/ccm.c

232

scatterwalk_map_and_copy(odata, req->dst,

crypto/ccm.c

271

if (req->src != req->dst) {

crypto/ccm.c

272

sg_init_table(pctx->dst, 3);

crypto/ccm.c

273

sg_set_buf(pctx->dst, tag, 16);

crypto/ccm.c

274

sg = scatterwalk_ffwd(pctx->dst + 1, req->dst, req->assoclen);

crypto/ccm.c

275

if (sg != pctx->dst + 1)

crypto/ccm.c

276

sg_chain(pctx->dst, 2, sg);

crypto/ccm.c

288

struct scatterlist *dst;

crypto/ccm.c

302

dst = pctx->src;

crypto/ccm.c

303

if (req->src != req->dst)

crypto/ccm.c

304

dst = pctx->dst;

crypto/ccm.c

309

skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);

crypto/ccm.c

315

scatterwalk_map_and_copy(odata, sg_next(dst), cryptlen,

crypto/ccm.c

327

struct scatterlist *dst;

crypto/ccm.c

331

dst = sg_next(req->src == req->dst ? pctx->src : pctx->dst);

crypto/ccm.c

334

err = crypto_ccm_auth(req, dst, cryptlen);

crypto/ccm.c

347

struct scatterlist *dst;

crypto/ccm.c

364

dst = pctx->src;

crypto/ccm.c

365

if (req->src != req->dst)

crypto/ccm.c

366

dst = pctx->dst;

crypto/ccm.c

37

struct scatterlist dst[3];

crypto/ccm.c

373

skcipher_request_set_crypt(skreq, pctx->src, dst, cryptlen + 16, iv);

crypto/ccm.c

378

err = crypto_ccm_auth(req, sg_next(dst), cryptlen);

crypto/ccm.c

47

struct scatterlist dst[3];

crypto/ccm.c

623

if (req->src != req->dst) {

crypto/ccm.c

624

sg_init_table(rctx->dst, 3);

crypto/ccm.c

625

sg_set_buf(rctx->dst, iv + 16, req->assoclen - 8);

crypto/ccm.c

626

sg = scatterwalk_ffwd(rctx->dst + 1, req->dst, req->assoclen);

crypto/ccm.c

627

if (sg != rctx->dst + 1)

crypto/ccm.c

628

sg_chain(rctx->dst, 2, sg);

crypto/ccm.c

635

req->src == req->dst ? rctx->src : rctx->dst,

crypto/chacha.c

66

chacha_crypt(&state, walk.dst.virt.addr, walk.src.virt.addr,

crypto/chacha20poly1305.c

104

struct scatterlist *src, *dst;

crypto/chacha20poly1305.c

113

dst = src;

crypto/chacha20poly1305.c

114

if (req->src != req->dst)

crypto/chacha20poly1305.c

115

dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);

crypto/chacha20poly1305.c

120

skcipher_request_set_crypt(&creq->req, src, dst,

crypto/chacha20poly1305.c

149

if (sg != req->dst)

crypto/chacha20poly1305.c

150

memcpy_sglist(req->dst, sg, req->assoclen);

crypto/chacha20poly1305.c

153

sg = req->dst;

crypto/chacha20poly1305.c

246

struct scatterlist *src, *dst;

crypto/chacha20poly1305.c

255

dst = src;

crypto/chacha20poly1305.c

256

if (req->src != req->dst)

crypto/chacha20poly1305.c

257

dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);

crypto/chacha20poly1305.c

262

skcipher_request_set_crypt(&creq->req, src, dst,

crypto/chacha20poly1305.c

40

struct scatterlist dst[2];

crypto/cipher.c

59

u8 *dst, const u8 *src, bool enc)

crypto/cipher.c

66

if (unlikely(((unsigned long)dst | (unsigned long)src) & alignmask)) {

crypto/cipher.c

73

memcpy(dst, tmp, bs);

crypto/cipher.c

75

fn(crypto_cipher_tfm(tfm), dst, src);

crypto/cipher.c

80

u8 *dst, const u8 *src)

crypto/cipher.c

82

cipher_crypt_one(tfm, dst, src, true);

crypto/cipher.c

87

u8 *dst, const u8 *src)

crypto/cipher.c

89

cipher_crypt_one(tfm, dst, src, false);

crypto/cryptd.c

266

skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

crypto/cryptd.c

767

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

crypto/crypto_null.c

57

static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/crypto_null.c

59

memcpy(dst, src, NULL_BLOCK_SIZE);

crypto/crypto_null.c

64

if (req->src != req->dst)

crypto/crypto_null.c

65

memcpy_sglist(req->dst, req->src, req->cryptlen);

crypto/ctr.c

111

if (walk.src.virt.addr == walk.dst.virt.addr)

crypto/ctr.c

212

skcipher_request_set_crypt(subreq, req->src, req->dst,

crypto/ctr.c

37

u8 *dst = walk->dst.virt.addr;

crypto/ctr.c

41

crypto_xor_cpy(dst, keystream, src, nbytes);

crypto/ctr.c

54

u8 *dst = walk->dst.virt.addr;

crypto/ctr.c

59

fn(crypto_cipher_tfm(tfm), dst, ctrblk);

crypto/ctr.c

60

crypto_xor(dst, src, bsize);

crypto/ctr.c

66

dst += bsize;

crypto/ctr.c

80

u8 *dst = walk->dst.virt.addr;

crypto/ctr.c

88

crypto_xor(dst, keystream, bsize);

crypto/ctr.c

93

dst += bsize;

crypto/cts.c

112

sg = scatterwalk_ffwd(rctx->sg, req->dst, offset - bsize);

crypto/cts.c

162

skcipher_request_set_crypt(subreq, req->src, req->dst, nbytes,

crypto/cts.c

172

skcipher_request_set_crypt(subreq, req->src, req->dst,

crypto/cts.c

194

sg = scatterwalk_ffwd(rctx->sg, req->dst, offset - bsize);

crypto/cts.c

257

skcipher_request_set_crypt(subreq, req->src, req->dst, nbytes,

crypto/cts.c

276

skcipher_request_set_crypt(subreq, req->src, req->dst,

crypto/deflate.c

172

stream->next_out = walk.dst.virt.addr;

crypto/deflate.c

81

stream->next_out = walk.dst.virt.addr;

crypto/des_generic.c

37

static void crypto_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/des_generic.c

41

des_encrypt(dctx, dst, src);

crypto/des_generic.c

44

static void crypto_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/des_generic.c

48

des_decrypt(dctx, dst, src);

crypto/des_generic.c

69

static void crypto_des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst,

crypto/des_generic.c

74

des3_ede_encrypt(dctx, dst, src);

crypto/des_generic.c

77

static void crypto_des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst,

crypto/des_generic.c

82

des3_ede_decrypt(dctx, dst, src);

crypto/dh.c

237

ret = mpi_write_to_sgl(val, req->dst, req->dst_len, &sign);

crypto/dh.c

335

static u64 __add_u64_to_be(__be64 *dst, unsigned int n, u64 val)

crypto/dh.c

340

u64 tmp = be64_to_cpu(dst[i - 1]);

crypto/dh.c

344

dst[i - 1] = cpu_to_be64(tmp);

crypto/dh.c

525

kpp_request_set_output(dh_req, req->dst, req->dst_len);

crypto/dh_helper.c

15

static inline u8 *dh_pack_data(u8 *dst, u8 *end, const void *src, size_t size)

crypto/dh_helper.c

17

if (!dst || size > end - dst)

crypto/dh_helper.c

19

memcpy(dst, src, size);

crypto/dh_helper.c

20

return dst + size;

crypto/dh_helper.c

23

static inline const u8 *dh_unpack_data(void *dst, const void *src, size_t size)

crypto/dh_helper.c

25

memcpy(dst, src, size);

crypto/drbg.c

1685

u8 *dst, unsigned int dlen)

crypto/drbg.c

1697

return drbg_generate_long(drbg, dst, dlen, addtl);

crypto/drbg.c

550

static inline void drbg_add_buf(unsigned char *dst, size_t dstlen,

crypto/drbg.c

559

dstptr = dst + (dstlen-1);

crypto/drbg.c

713

unsigned char *dst = drbg->scratchpad + drbg_statelen(drbg);

crypto/drbg.c

725

ret = drbg_kcapi_hash(drbg, dst, &datalist);

crypto/drbg.c

733

memcpy(buf + len, dst, outlen);

crypto/ecb.c

17

u8 *dst, unsigned nbytes, bool final,

crypto/ecb.c

23

fn(crypto_cipher_tfm(cipher), dst, src);

crypto/ecb.c

26

dst += bsize;

crypto/ecb.c

35

u8 *dst, unsigned len, u8 *iv, u32 flags)

crypto/ecb.c

40

return crypto_ecb_crypt(cipher, src, dst, len,

crypto/ecb.c

46

u8 *dst, unsigned len, u8 *iv, u32 flags)

crypto/ecb.c

51

return crypto_ecb_crypt(cipher, src, dst, len,

crypto/ecdh.c

109

copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst,

crypto/ecdh_helper.c

15

static inline u8 *ecdh_pack_data(void *dst, const void *src, size_t sz)

crypto/ecdh_helper.c

17

memcpy(dst, src, sz);

crypto/ecdh_helper.c

18

return dst + sz;

crypto/ecdh_helper.c

21

static inline const u8 *ecdh_unpack_data(void *dst, const void *src, size_t sz)

crypto/ecdh_helper.c

23

memcpy(dst, src, sz);

crypto/echainiv.c

43

if (req->src != req->dst)

crypto/echainiv.c

44

memcpy_sglist(req->dst, req->src,

crypto/echainiv.c

49

aead_request_set_crypt(subreq, req->dst, req->dst,

crypto/echainiv.c

57

scatterwalk_map_and_copy(info, req->dst, req->assoclen, ivsize, 1);

crypto/echainiv.c

91

aead_request_set_crypt(subreq, req->src, req->dst,

crypto/ecrdsa.c

176

static u8 *ecrdsa_unpack_u32(u32 *dst, void *src)

crypto/ecrdsa.c

178

memcpy(dst, src, sizeof(u32));

crypto/essiv.c

150

skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

crypto/essiv.c

205

if (req->src == req->dst || !enc) {

crypto/essiv.c

206

scatterwalk_map_and_copy(req->iv, req->dst, ssize, ivsize, 1);

crypto/essiv.c

248

aead_request_set_crypt(subreq, src, req->dst, req->cryptlen, req->iv);

crypto/fcrypt.c

233

static void fcrypt_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/fcrypt.c

259

memcpy(dst, &X, sizeof(X));

crypto/fcrypt.c

265

static void fcrypt_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/fcrypt.c

291

memcpy(dst, &X, sizeof(X));

crypto/gcm.c

164

if (req->src != req->dst) {

crypto/gcm.c

165

sg_init_table(pctx->dst, 3);

crypto/gcm.c

166

sg_set_buf(pctx->dst, pctx->auth_tag, sizeof(pctx->auth_tag));

crypto/gcm.c

167

sg = scatterwalk_ffwd(pctx->dst + 1, req->dst, req->assoclen);

crypto/gcm.c

168

if (sg != pctx->dst + 1)

crypto/gcm.c

169

sg_chain(pctx->dst, 2, sg);

crypto/gcm.c

180

struct scatterlist *dst;

crypto/gcm.c

182

dst = req->src == req->dst ? pctx->src : pctx->dst;

crypto/gcm.c

185

skcipher_request_set_crypt(skreq, pctx->src, dst,

crypto/gcm.c

38

struct scatterlist dst[3];

crypto/gcm.c

412

scatterwalk_map_and_copy(auth_tag, req->dst,

crypto/gcm.c

423

gctx->src = sg_next(req->src == req->dst ? pctx->src : pctx->dst);

crypto/gcm.c

66

struct scatterlist dst[3];

crypto/gcm.c

736

if (req->src != req->dst) {

crypto/gcm.c

737

sg_init_table(rctx->dst, 3);

crypto/gcm.c

738

sg_set_buf(rctx->dst, iv + GCM_AES_IV_SIZE, req->assoclen - 8);

crypto/gcm.c

739

sg = scatterwalk_ffwd(rctx->dst + 1, req->dst, req->assoclen);

crypto/gcm.c

740

if (sg != rctx->dst + 1)

crypto/gcm.c

741

sg_chain(rctx->dst, 2, sg);

crypto/gcm.c

748

req->src == req->dst ? rctx->src : rctx->dst,

crypto/gcm.c

930

if (req->src != req->dst) {

crypto/gcm.c

934

memcpy_sglist(req->dst, req->src, nbytes);

crypto/gcm.c

943

aead_request_set_crypt(subreq, req->src, req->dst,

crypto/ghash-generic.c

100

u8 *dst = dctx->buffer;

crypto/ghash-generic.c

103

crypto_xor(dst, src, len);

crypto/ghash-generic.c

104

gf128mul_4k_lle((be128 *)dst, ctx->gf128);

crypto/ghash-generic.c

109

unsigned int len, u8 *dst)

crypto/ghash-generic.c

115

memcpy(dst, buf, GHASH_BLOCK_SIZE);

crypto/ghash-generic.c

83

u8 *dst = dctx->buffer;

crypto/ghash-generic.c

86

crypto_xor(dst, src, GHASH_BLOCK_SIZE);

crypto/ghash-generic.c

87

gf128mul_4k_lle((be128 *)dst, ctx->gf128);

crypto/hctr2.c

194

scatterwalk_map_and_copy(rctx->first_block, req->dst,

crypto/hctr2.c

228

rctx->bulk_part_dst = scatterwalk_ffwd(rctx->sg_dst, req->dst,

crypto/hmac.c

161

static int hmac_clone_tfm(struct crypto_shash *dst, struct crypto_shash *src)

crypto/hmac.c

164

struct hmac_ctx *dctx = crypto_shash_ctx(dst);

crypto/hmac.c

426

static int hmac_clone_ahash_tfm(struct crypto_ahash *dst,

crypto/hmac.c

430

struct ahash_hmac_ctx *dctx = crypto_ahash_ctx(dst);

crypto/jitterentropy-kcapi.c

174

int jent_read_random_block(void *hash_state, char *dst, unsigned int dst_len)

crypto/jitterentropy-kcapi.c

185

memcpy(dst, jent_block, dst_len);

crypto/jitterentropy.h

11

int jent_read_random_block(void *hash_state, char *dst, unsigned int dst_len);

crypto/kdf_sp800108.c

19

u8 *dst, unsigned int dlen)

crypto/kdf_sp800108.c

26

u8 *dst_orig = dst;

crypto/kdf_sp800108.c

52

memcpy(dst, tmpbuffer, dlen);

crypto/kdf_sp800108.c

57

err = crypto_shash_final(desc, dst);

crypto/kdf_sp800108.c

62

dst += h;

crypto/khazad.c

801

u8 *dst, const u8 *src)

crypto/khazad.c

830

put_unaligned_be64(state, dst);

crypto/khazad.c

833

static void khazad_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/khazad.c

836

khazad_crypt(ctx->E, dst, src);

crypto/khazad.c

839

static void khazad_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/khazad.c

842

khazad_crypt(ctx->D, dst, src);

crypto/krb5enc.c

148

struct scatterlist *src, *dst;

crypto/krb5enc.c

151

if (req->src == req->dst)

crypto/krb5enc.c

152

dst = src;

crypto/krb5enc.c

154

dst = scatterwalk_ffwd(areq_ctx->dst, req->dst, req->assoclen);

crypto/krb5enc.c

159

skcipher_request_set_crypt(skreq, src, dst, req->cryptlen, req->iv);

crypto/krb5enc.c

172

scatterwalk_map_and_copy(hash, req->dst,

crypto/krb5enc.c

291

ahash_request_set_crypt(ahreq, req->dst, hash,

crypto/krb5enc.c

316

struct scatterlist *src, *dst;

crypto/krb5enc.c

319

dst = src;

crypto/krb5enc.c

321

if (req->src != req->dst)

crypto/krb5enc.c

322

dst = scatterwalk_ffwd(areq_ctx->dst, req->dst, req->assoclen);

crypto/krb5enc.c

327

skcipher_request_set_crypt(skreq, src, dst,

crypto/krb5enc.c

38

struct scatterlist dst[2];

crypto/lrw.c

174

wdst = w.dst.virt.addr;

crypto/lrw.c

233

skcipher_request_set_crypt(subreq, req->dst, req->dst,

crypto/lskcipher.c

108

memcpy(dst, p, chunk);

crypto/lskcipher.c

110

dst += chunk;

crypto/lskcipher.c

124

u8 *dst, unsigned len, u8 *iv,

crypto/lskcipher.c

126

const u8 *src, u8 *dst,

crypto/lskcipher.c

132

if (((unsigned long)src | (unsigned long)dst | (unsigned long)iv) &

crypto/lskcipher.c

134

return crypto_lskcipher_crypt_unaligned(tfm, src, dst, len, iv,

crypto/lskcipher.c

137

return crypt(tfm, src, dst, len, iv, CRYPTO_LSKCIPHER_FLAG_FINAL);

crypto/lskcipher.c

141

u8 *dst, unsigned len, u8 *iv)

crypto/lskcipher.c

145

return crypto_lskcipher_crypt(tfm, src, dst, len, iv, alg->encrypt);

crypto/lskcipher.c

150

u8 *dst, unsigned len, u8 *iv)

crypto/lskcipher.c

154

return crypto_lskcipher_crypt(tfm, src, dst, len, iv, alg->decrypt);

crypto/lskcipher.c

160

const u8 *src, u8 *dst,

crypto/lskcipher.c

188

err = crypt(tfm, walk.src.virt.addr, walk.dst.virt.addr,

crypto/lskcipher.c

70

struct crypto_lskcipher *tfm, const u8 *src, u8 *dst, unsigned len,

crypto/lskcipher.c

72

u8 *dst, unsigned len, u8 *iv, u32 flags))

crypto/lz4.c

32

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lz4.c

34

int out_len = LZ4_compress_default(src, dst,

crypto/lz4.c

45

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lz4.c

48

return __lz4_compress_crypto(src, slen, dst, dlen, ctx);

crypto/lz4.c

52

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lz4.c

54

int out_len = LZ4_decompress_safe(src, dst, slen, *dlen);

crypto/lz4.c

64

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lz4.c

67

return __lz4_decompress_crypto(src, slen, dst, dlen, NULL);

crypto/lz4hc.c

30

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lz4hc.c

32

int out_len = LZ4_compress_HC(src, dst, slen,

crypto/lz4hc.c

43

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lz4hc.c

46

return __lz4hc_compress_crypto(src, slen, dst, dlen, ctx);

crypto/lz4hc.c

50

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lz4hc.c

52

int out_len = LZ4_decompress_safe(src, dst, slen, *dlen);

crypto/lz4hc.c

62

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lz4hc.c

65

return __lz4hc_decompress_crypto(src, slen, dst, dlen, NULL);

crypto/lzo-rle.c

29

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lzo-rle.c

34

err = lzorle1x_1_compress_safe(src, slen, dst, &tmp_len, ctx);

crypto/lzo-rle.c

44

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lzo-rle.c

47

return __lzorle_compress(src, slen, dst, dlen, ctx);

crypto/lzo-rle.c

51

u8 *dst, unsigned int *dlen)

crypto/lzo-rle.c

56

err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);

crypto/lzo-rle.c

66

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lzo-rle.c

69

return __lzorle_decompress(src, slen, dst, dlen);

crypto/lzo.c

29

u8 *dst, unsigned int *dlen, void *ctx)

crypto/lzo.c

34

err = lzo1x_1_compress_safe(src, slen, dst, &tmp_len, ctx);

crypto/lzo.c

44

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lzo.c

47

return __lzo_compress(src, slen, dst, dlen, ctx);

crypto/lzo.c

51

u8 *dst, unsigned int *dlen)

crypto/lzo.c

56

err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);

crypto/lzo.c

66

unsigned int slen, u8 *dst, unsigned int *dlen,

crypto/lzo.c

69

return __lzo_decompress(src, slen, dst, dlen);

crypto/pcbc.c

100

crypto_xor_cpy(iv, dst, src, bsize);

crypto/pcbc.c

103

dst += bsize;

crypto/pcbc.c

115

u8 *dst = walk->dst.virt.addr;

crypto/pcbc.c

120

memcpy(tmpbuf, dst, bsize);

crypto/pcbc.c

121

crypto_cipher_decrypt_one(tfm, dst, dst);

crypto/pcbc.c

122

crypto_xor(dst, iv, bsize);

crypto/pcbc.c

123

crypto_xor_cpy(iv, dst, tmpbuf, bsize);

crypto/pcbc.c

125

dst += bsize;

crypto/pcbc.c

142

if (walk.src.virt.addr == walk.dst.virt.addr)

crypto/pcbc.c

27

u8 *dst = walk->dst.virt.addr;

crypto/pcbc.c

32

crypto_cipher_encrypt_one(tfm, dst, iv);

crypto/pcbc.c

33

crypto_xor_cpy(iv, dst, src, bsize);

crypto/pcbc.c

36

dst += bsize;

crypto/pcbc.c

48

u8 *dst = walk->dst.virt.addr;

crypto/pcbc.c

53

memcpy(tmpbuf, dst, bsize);

crypto/pcbc.c

54

crypto_xor(iv, dst, bsize);

crypto/pcbc.c

55

crypto_cipher_encrypt_one(tfm, dst, iv);

crypto/pcbc.c

56

crypto_xor_cpy(iv, tmpbuf, dst, bsize);

crypto/pcbc.c

58

dst += bsize;

crypto/pcbc.c

75

if (walk.src.virt.addr == walk.dst.virt.addr)

crypto/pcbc.c

94

u8 *dst = walk->dst.virt.addr;

crypto/pcbc.c

98

crypto_cipher_decrypt_one(tfm, dst, src);

crypto/pcbc.c

99

crypto_xor(dst, iv, bsize);

crypto/pcrypt.c

113

aead_request_set_crypt(creq, req->src, req->dst,

crypto/pcrypt.c

164

aead_request_set_crypt(creq, req->src, req->dst,

crypto/rmd160.c

298

__le32 *dst = (__le32 *)out;

crypto/rmd160.c

316

dst[i] = cpu_to_le32p(&rctx->state[i]);

crypto/rsa-pkcs1pad.c

101

sg_copy_from_buffer(req->dst,

crypto/rsa-pkcs1pad.c

102

sg_nents_for_len(req->dst, ctx->key_size),

crypto/rsa-pkcs1pad.c

166

req->dst, ctx->key_size - 1, req->dst_len);

crypto/rsa-pkcs1pad.c

219

sg_copy_from_buffer(req->dst,

crypto/rsa-pkcs1pad.c

220

sg_nents_for_len(req->dst, req->dst_len),

crypto/rsa-pkcs1pad.c

99

sg_copy_to_buffer(req->dst, sg_nents_for_len(req->dst, len),

crypto/rsa.c

145

ret = mpi_write_to_sgl(c, req->dst, req->dst_len, &sign);

crypto/rsa.c

184

ret = mpi_write_to_sgl(m, req->dst, req->dst_len, &sign);

crypto/rsassa-pkcs1.c

160

void *dst, unsigned int dlen)

crypto/rsassa-pkcs1.c

187

in_buf = dst;

crypto/rsassa-pkcs1.c

209

memmove(dst + pad_len, dst, len);

crypto/rsassa-pkcs1.c

210

memset(dst, 0, pad_len);

crypto/scatterwalk.c

100

void memcpy_sglist(struct scatterlist *dst, struct scatterlist *src,

crypto/scatterwalk.c

109

dst_offset = dst->offset;

crypto/scatterwalk.c

113

dst->offset + dst->length - dst_offset,

crypto/scatterwalk.c

116

struct page *dst_page = sg_page(dst);

crypto/scatterwalk.c

175

if (dst_offset >= dst->offset + dst->length) {

crypto/scatterwalk.c

176

dst = sg_next(dst);

crypto/scatterwalk.c

177

dst_offset = dst->offset;

crypto/scatterwalk.c

183

struct scatterlist *scatterwalk_ffwd(struct scatterlist dst[2],

crypto/scatterwalk.c

198

sg_init_table(dst, 2);

crypto/scatterwalk.c

199

sg_set_page(dst, sg_page(src), src->length - len, src->offset + len);

crypto/scatterwalk.c

200

scatterwalk_crypto_chain(dst, sg_next(src), 2);

crypto/scatterwalk.c

202

return dst;

crypto/scompress.c

182

u8 *dst;

crypto/scompress.c

188

if (!req->dst || !dlen)

crypto/scompress.c

192

dst = req->dvirt;

crypto/scompress.c

194

if (dlen <= req->dst->length) {

crypto/scompress.c

195

dpage = sg_page(req->dst);

crypto/scompress.c

196

doff = req->dst->offset;

crypto/scompress.c

208

dst = kmap_local_page(dpage) + doff;

crypto/scompress.c

244

dst, &dlen, stream->ctx);

crypto/scompress.c

247

dst, &dlen, stream->ctx);

crypto/scompress.c

252

dst, &dlen, stream->ctx);

crypto/scompress.c

255

dst, &dlen, stream->ctx);

crypto/scompress.c

264

kunmap_local(dst);

crypto/seqiv.c

117

aead_request_set_crypt(subreq, req->src, req->dst,

crypto/seqiv.c

68

if (req->src != req->dst)

crypto/seqiv.c

69

memcpy_sglist(req->dst, req->src,

crypto/seqiv.c

86

aead_request_set_crypt(subreq, req->dst, req->dst,

crypto/seqiv.c

91

scatterwalk_map_and_copy(info, req->dst, req->assoclen, ivsize, 1);

crypto/serpent_generic.c

458

void __serpent_encrypt(const void *c, u8 *dst, const u8 *src)

crypto/serpent_generic.c

503

put_unaligned_le32(r0, dst);

crypto/serpent_generic.c

504

put_unaligned_le32(r1, dst + 4);

crypto/serpent_generic.c

505

put_unaligned_le32(r2, dst + 8);

crypto/serpent_generic.c

506

put_unaligned_le32(r3, dst + 12);

crypto/serpent_generic.c

510

static void serpent_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/serpent_generic.c

514

__serpent_encrypt(ctx, dst, src);

crypto/serpent_generic.c

517

void __serpent_decrypt(const void *c, u8 *dst, const u8 *src)

crypto/serpent_generic.c

562

put_unaligned_le32(r2, dst);

crypto/serpent_generic.c

563

put_unaligned_le32(r3, dst + 4);

crypto/serpent_generic.c

564

put_unaligned_le32(r1, dst + 8);

crypto/serpent_generic.c

565

put_unaligned_le32(r4, dst + 12);

crypto/serpent_generic.c

569

static void serpent_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/serpent_generic.c

573

__serpent_decrypt(ctx, dst, src);

crypto/sig.c

88

void *dst, unsigned int dlen)

crypto/sig.c

95

const void *dst, unsigned int dlen)

crypto/skcipher.c

306

scatterwalk_start(&walk->out, req->dst);

crypto/skcipher.c

339

scatterwalk_start_at_pos(&walk->out, req->dst, req->assoclen);

crypto/tea.c

106

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

107

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

124

static void xtea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/tea.c

139

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

140

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

143

static void xtea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/tea.c

159

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

160

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

164

static void xeta_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/tea.c

179

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

180

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

183

static void xeta_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/tea.c

199

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

200

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

56

static void tea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/tea.c

78

put_unaligned_le32(y, &dst[0]);

crypto/tea.c

79

put_unaligned_le32(z, &dst[4]);

crypto/tea.c

82

static void tea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)

crypto/testmgr.c

2117

aead_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr,

crypto/testmgr.c

2132

req->dst != tsgls->dst.sgl_ptr ||

crypto/testmgr.c

2147

if (req->dst != tsgls->dst.sgl_ptr)

crypto/testmgr.c

2164

if (tsgls->dst.sgl_ptr != tsgls->src.sgl &&

crypto/testmgr.c

2165

is_test_sglist_corrupted(&tsgls->dst)) {

crypto/testmgr.c

2198

err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,

crypto/testmgr.c

2331

struct scatterlist src[2], dst;

crypto/testmgr.c

2343

sg_init_one(&dst, vec->ctext, vec->alen + vec->clen);

crypto/testmgr.c

2346

aead_request_set_crypt(req, src, &dst, vec->plen, iv);

crypto/testmgr.c

2868

skcipher_request_set_crypt(req, tsgls->src.sgl_ptr, tsgls->dst.sgl_ptr,

crypto/testmgr.c

2881

req->dst != tsgls->dst.sgl_ptr ||

crypto/testmgr.c

2894

if (req->dst != tsgls->dst.sgl_ptr)

crypto/testmgr.c

2911

if (tsgls->dst.sgl_ptr != tsgls->src.sgl &&

crypto/testmgr.c

2912

is_test_sglist_corrupted(&tsgls->dst)) {

crypto/testmgr.c

2933

err = verify_correct_output(&tsgls->dst, enc ? vec->ctext : vec->ptext,

crypto/testmgr.c

3012

struct scatterlist src, dst;

crypto/testmgr.c

3036

sg_init_one(&dst, vec->ctext, vec->len);

crypto/testmgr.c

3039

skcipher_request_set_crypt(req, &src, &dst, vec->len, iv);

crypto/testmgr.c

3279

struct scatterlist src, dst;

crypto/testmgr.c

3307

sg_init_one(&dst, output, dlen);

crypto/testmgr.c

3318

acomp_request_set_params(req, &src, &dst, ilen, dlen);

crypto/testmgr.c

3334

sg_init_one(&dst, decomp_out, dlen);

crypto/testmgr.c

3336

acomp_request_set_params(req, &src, &dst, ilen, dlen);

crypto/testmgr.c

3384

sg_init_one(&dst, output, dlen);

crypto/testmgr.c

3395

acomp_request_set_params(req, &src, &dst, ilen, dlen);

crypto/testmgr.c

3592

struct scatterlist src, dst;

crypto/testmgr.c

3613

sg_init_one(&dst, output_buf, out_len_max);

crypto/testmgr.c

3614

kpp_request_set_output(req, &dst, out_len_max);

crypto/testmgr.c

3628

a_public = kmemdup(sg_virt(req->dst), out_len_max, GFP_KERNEL);

crypto/testmgr.c

3635

if (memcmp(vec->expected_a_public, sg_virt(req->dst),

crypto/testmgr.c

3652

sg_init_one(&dst, output_buf, out_len_max);

crypto/testmgr.c

3654

kpp_request_set_output(req, &dst, out_len_max);

crypto/testmgr.c

3666

a_ss = kmemdup(sg_virt(req->dst), vec->expected_ss_size, GFP_KERNEL);

crypto/testmgr.c

3682

sg_init_one(&dst, output_buf, out_len_max);

crypto/testmgr.c

3684

kpp_request_set_output(req, &dst, out_len_max);

crypto/testmgr.c

3704

if (memcmp(shared_secret, sg_virt(req->dst),

crypto/testmgr.c

3760

static u8 *test_pack_u32(u8 *dst, u32 val)

crypto/testmgr.c

3762

memcpy(dst, &val, sizeof(val));

crypto/testmgr.c

3763

return dst + sizeof(val);

crypto/testmgr.c

3776

struct scatterlist src, dst, src_tab[2];

crypto/testmgr.c

3816

sg_init_one(&dst, outbuf_enc, out_len_max);

crypto/testmgr.c

3817

akcipher_request_set_crypt(req, src_tab, &dst, vecs->m_size,

crypto/testmgr.c

3867

sg_init_one(&dst, outbuf_dec, out_len_max);

crypto/testmgr.c

3869

akcipher_request_set_crypt(req, &src, &dst, c_size, out_len_max);

crypto/testmgr.c

735

struct test_sglist dst;

crypto/testmgr.c

748

if (init_test_sglist(&tsgls->dst) != 0)

crypto/testmgr.c

764

destroy_test_sglist(&tsgls->dst);

crypto/testmgr.c

797

tsgls->dst.sgl_ptr = tsgls->src.sgl;

crypto/testmgr.c

798

tsgls->dst.nents = tsgls->src.nents;

crypto/testmgr.c

807

memcpy(tsgls->dst.sgl, tsgls->src.sgl,

crypto/testmgr.c

809

memcpy(tsgls->dst.sgl_saved, tsgls->src.sgl,

crypto/testmgr.c

811

tsgls->dst.sgl_ptr = tsgls->dst.sgl;

crypto/testmgr.c

812

tsgls->dst.nents = tsgls->src.nents;

crypto/testmgr.c

816

return build_test_sglist(&tsgls->dst,

crypto/xctr.c

112

if (walk.src.virt.addr == walk.dst.virt.addr)

crypto/xctr.c

39

u8 *dst = walk->dst.virt.addr;

crypto/xctr.c

45

crypto_xor_cpy(dst, keystream, src, nbytes);

crypto/xctr.c

55

u8 *dst = walk->dst.virt.addr;

crypto/xctr.c

61

fn(crypto_cipher_tfm(tfm), dst, walk->iv);

crypto/xctr.c

62

crypto_xor(dst, src, XCTR_BLOCKSIZE);

crypto/xctr.c

68

dst += XCTR_BLOCKSIZE;

crypto/xctr.c

81

u8 *data = walk->dst.virt.addr;

crypto/xts.c

106

wdst = w.dst.virt.addr;

crypto/xts.c

171

rctx->tail = scatterwalk_ffwd(rctx->sg, req->dst,

crypto/xts.c

252

skcipher_request_set_crypt(subreq, req->dst, req->dst,

crypto/zstd.c

132

outbuf.dst = (u8 *)walk.dst.virt.addr;

crypto/zstd.c

139

walk.dst.virt.addr, &total_out);

crypto/zstd.c

191

const void *src, void *dst, unsigned int *dlen)

crypto/zstd.c

199

out_len = zstd_decompress_dctx(ctx->dctx, dst, req->dlen, src, req->slen);

crypto/zstd.c

247

walk.dst.virt.addr, &total_out);

crypto/zstd.c

259

outbuf.dst = (u8 *)walk.dst.virt.addr;

crypto/zstd.c

79

const void *src, void *dst, unsigned int *dlen)

crypto/zstd.c

87

out_len = zstd_compress_cctx(ctx->cctx, dst, req->dlen, src, req->slen,

drivers/accel/ethosu/ethosu_gem.c

112

struct dma dst;

drivers/accel/ethosu/ethosu_gem.c

397

dstlen = dma_length(info, &st.dma, &st.dma.dst);

drivers/accel/ethosu/ethosu_gem.c

399

if (st.dma.dst.region >= 0)

drivers/accel/ethosu/ethosu_gem.c

400

info->output_region[st.dma.dst.region] = true;

drivers/accel/ethosu/ethosu_gem.c

403

st.dma.dst.region, st.dma.dst.offset, dstlen);

drivers/accel/ethosu/ethosu_gem.c

620

st.dma.dst.region = -1;

drivers/accel/ethosu/ethosu_gem.c

622

st.dma.dst.region = param & 0x7;

drivers/accel/ethosu/ethosu_gem.c

637

st.dma.dst.stride[0] = ((s64)addr << 24) >> 24;

drivers/accel/ethosu/ethosu_gem.c

640

st.dma.dst.stride[1] = ((s64)addr << 24) >> 24;

drivers/accel/ethosu/ethosu_gem.c

646

st.dma.dst.offset = addr;

drivers/accel/ethosu/ethosu_gem.c

649

st.dma.src.len = st.dma.dst.len = addr;

drivers/accel/habanalabs/common/firmware_if.c

285

const struct firmware *fw, void __iomem *dst,

drivers/accel/habanalabs/common/firmware_if.c

303

memcpy_toio(dst, fw_data + src_offset, size);

drivers/accel/habanalabs/common/firmware_if.c

319

struct lkd_msg_comms *msg, void __iomem *dst,

drivers/accel/habanalabs/common/firmware_if.c

337

memcpy_toio(dst, msg_data + src_offset, size);

drivers/accel/habanalabs/common/firmware_if.c

356

void __iomem *dst, u32 src_offset, u32 size)

drivers/accel/habanalabs/common/firmware_if.c

365

rc = hl_fw_copy_fw_to_device(hdev, fw, dst, src_offset, size);

drivers/accel/habanalabs/common/habanalabs.h

3995

void __iomem *dst, u32 src_offset, u32 size);

drivers/accel/habanalabs/gaudi/gaudi.c

3690

void __iomem *dst;

drivers/accel/habanalabs/gaudi/gaudi.c

3692

dst = hdev->pcie_bar[HBM_BAR_ID] + LINUX_FW_OFFSET;

drivers/accel/habanalabs/gaudi/gaudi.c

3694

return hl_fw_load_fw_to_device(hdev, GAUDI_LINUX_FW_FILE, dst, 0, 0);

drivers/accel/habanalabs/gaudi/gaudi.c

3699

void __iomem *dst;

drivers/accel/habanalabs/gaudi/gaudi.c

3701

dst = hdev->pcie_bar[SRAM_BAR_ID] + BOOT_FIT_SRAM_OFFSET;

drivers/accel/habanalabs/gaudi/gaudi.c

3703

return hl_fw_load_fw_to_device(hdev, GAUDI_BOOT_FIT_FILE, dst, 0, 0);

drivers/accel/habanalabs/goya/goya.c

2498

void __iomem *dst;

drivers/accel/habanalabs/goya/goya.c

2500

dst = hdev->pcie_bar[DDR_BAR_ID] + LINUX_FW_OFFSET;

drivers/accel/habanalabs/goya/goya.c

2502

return hl_fw_load_fw_to_device(hdev, GOYA_LINUX_FW_FILE, dst, 0, 0);

drivers/accel/habanalabs/goya/goya.c

2515

void __iomem *dst;

drivers/accel/habanalabs/goya/goya.c

2517

dst = hdev->pcie_bar[SRAM_CFG_BAR_ID] + BOOT_FIT_SRAM_OFFSET;

drivers/accel/habanalabs/goya/goya.c

2519

return hl_fw_load_fw_to_device(hdev, GOYA_BOOT_FIT_FILE, dst, 0, 0);

drivers/accel/ivpu/vpu_boot_api.h

180

u32 dst;

drivers/acpi/apei/erst.c

280

void *src, *dst;

drivers/acpi/apei/erst.c

295

dst = ioremap(ctx->dst_base + offset, ctx->var2);

drivers/acpi/apei/erst.c

296

if (!dst) {

drivers/acpi/apei/erst.c

301

memmove(dst, src, ctx->var2);

drivers/acpi/apei/erst.c

304

iounmap(dst);

drivers/acpi/nfit/core.c

244

void *dst;

drivers/acpi/nfit/core.c

272

dst = buf + 1;

drivers/acpi/nfit/core.c

275

buf->buffer.pointer = dst;

drivers/acpi/nfit/core.c

280

memcpy(dst, &obj->integer.value, 4);

drivers/acpi/nfit/core.c

281

dst += 4;

drivers/acpi/nfit/core.c

283

memcpy(dst, obj->buffer.pointer, obj->buffer.length);

drivers/acpi/nfit/core.c

284

dst += obj->buffer.length;

drivers/acpi/nfit/core.c

295

void *dst = NULL;

drivers/acpi/nfit/core.c

307

dst = buf + 1;

drivers/acpi/nfit/core.c

310

buf->buffer.pointer = dst;

drivers/acpi/nfit/core.c

311

memcpy(dst, &integer->integer.value, 4);

drivers/acpi/utils.c

433

void acpi_handle_list_replace(struct acpi_handle_list *dst,

drivers/acpi/utils.c

436

if (dst->count)

drivers/acpi/utils.c

437

kfree(dst->handles);

drivers/acpi/utils.c

439

dst->count = src->count;

drivers/acpi/utils.c

440

dst->handles = src->handles;

drivers/ata/ahci_xgene.c

42

#define PORTADDR_SET(dst, src) \

drivers/ata/ahci_xgene.c

43

(((dst) & ~0x0000003f) | (((u32)(src)) & 0x0000003f))

drivers/ata/ahci_xgene.c

45

#define PORTPHY1CFG_FRCPHYRDY_SET(dst, src) \

drivers/ata/ahci_xgene.c

46

(((dst) & ~0x00100000) | (((u32)(src) << 0x14) & 0x00100000))

drivers/ata/ahci_xgene.c

52

#define PORTPHY5CFG_RTCHG_SET(dst, src) \

drivers/ata/ahci_xgene.c

53

(((dst) & ~0xfff00000) | (((u32)(src) << 0x14) & 0xfff00000))

drivers/ata/ahci_xgene.c

54

#define PORTAXICFG_EN_CONTEXT_SET(dst, src) \

drivers/ata/ahci_xgene.c

55

(((dst) & ~0x01000000) | (((u32)(src) << 0x18) & 0x01000000))

drivers/ata/ahci_xgene.c

57

#define PORTAXICFG_OUTTRANS_SET(dst, src) \

drivers/ata/ahci_xgene.c

58

(((dst) & ~0x00f00000) | (((u32)(src) << 0x14) & 0x00f00000))

drivers/ata/ahci_xgene.c

60

#define PORTRANSCFG_RXWM_SET(dst, src) \

drivers/ata/ahci_xgene.c

61

(((dst) & ~0x0000007f) | (((u32)(src)) & 0x0000007f))

drivers/ata/libata-scsi.c

427

u16 __user *dst = arg;

drivers/ata/libata-scsi.c

433

if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))

drivers/ata/libata-scsi.c

437

if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))

drivers/ata/libata-scsi.c

441

if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))

drivers/ata/libata-scsi.c

445

if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))

drivers/base/swnode.c

262

static int property_entry_copy_data(struct property_entry *dst,

drivers/base/swnode.c

283

if (src->length <= sizeof(dst->value)) {

drivers/base/swnode.c

284

dst_ptr = &dst->value;

drivers/base/swnode.c

285

dst->is_inline = true;

drivers/base/swnode.c

290

dst->pointer = dst_ptr;

drivers/base/swnode.c

296

if (!dst->is_inline)

drivers/base/swnode.c

297

kfree(dst->pointer);

drivers/base/swnode.c

304

dst->length = src->length;

drivers/base/swnode.c

305

dst->type = src->type;

drivers/base/swnode.c

306

dst->name = kstrdup(src->name, GFP_KERNEL);

drivers/base/swnode.c

307

if (!dst->name) {

drivers/base/swnode.c

308

property_entry_free_data(dst);

drivers/block/aoe/aoe.h

40

unsigned char dst[6];

drivers/block/aoe/aoecmd.c

133

memcpy(h->dst, t->addr, sizeof h->dst);

drivers/block/aoe/aoecmd.c

1350

h->dst);

drivers/block/aoe/aoecmd.c

442

memset(h->dst, 0xff, sizeof h->dst);

drivers/block/aoe/aoecmd.c

479

h->src, h->dst, t->nout);

drivers/block/aoe/aoecmd.c

486

memcpy(h->dst, t->addr, sizeof h->dst);

drivers/block/null_blk/main.c

1046

void *dst, *src;

drivers/block/null_blk/main.c

1067

dst = kmap_local_page(t_page->page);

drivers/block/null_blk/main.c

1073

memcpy(dst + offset, src + offset,

drivers/block/null_blk/main.c

1079

kunmap_local(dst);

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

600

paths[path_cnt].dst = &addrs[path_cnt * 2 + 1];

drivers/block/xen-blkback/blkback.c

1074

static void blkif_get_x86_32_req(struct blkif_request *dst,

drivers/block/xen-blkback/blkback.c

1079

dst->operation = READ_ONCE(src->operation);

drivers/block/xen-blkback/blkback.c

1081

switch (dst->operation) {

drivers/block/xen-blkback/blkback.c

1086

dst->u.rw.nr_segments = READ_ONCE(src->u.rw.nr_segments);

drivers/block/xen-blkback/blkback.c

1087

dst->u.rw.handle = src->u.rw.handle;

drivers/block/xen-blkback/blkback.c

1088

dst->u.rw.id = src->u.rw.id;

drivers/block/xen-blkback/blkback.c

1089

dst->u.rw.sector_number = src->u.rw.sector_number;

drivers/block/xen-blkback/blkback.c

1091

dst->u.rw.nr_segments);

drivers/block/xen-blkback/blkback.c

1093

dst->u.rw.seg[i] = src->u.rw.seg[i];

drivers/block/xen-blkback/blkback.c

1097

dst->u.discard.flag = src->u.discard.flag;

drivers/block/xen-blkback/blkback.c

1098

dst->u.discard.id = src->u.discard.id;

drivers/block/xen-blkback/blkback.c

1099

dst->u.discard.sector_number = src->u.discard.sector_number;

drivers/block/xen-blkback/blkback.c

1100

dst->u.discard.nr_sectors = src->u.discard.nr_sectors;

drivers/block/xen-blkback/blkback.c

1104

dst->u.indirect.indirect_op = src->u.indirect.indirect_op;

drivers/block/xen-blkback/blkback.c

1105

dst->u.indirect.nr_segments =

drivers/block/xen-blkback/blkback.c

1107

dst->u.indirect.handle = src->u.indirect.handle;

drivers/block/xen-blkback/blkback.c

1108

dst->u.indirect.id = src->u.indirect.id;

drivers/block/xen-blkback/blkback.c

1109

dst->u.indirect.sector_number = src->u.indirect.sector_number;

drivers/block/xen-blkback/blkback.c

1111

INDIRECT_PAGES(dst->u.indirect.nr_segments));

drivers/block/xen-blkback/blkback.c

1113

dst->u.indirect.indirect_grefs[i] =

drivers/block/xen-blkback/blkback.c

1122

dst->u.other.id = src->u.other.id;

drivers/block/xen-blkback/blkback.c

1127

static void blkif_get_x86_64_req(struct blkif_request *dst,

drivers/block/xen-blkback/blkback.c

1132

dst->operation = READ_ONCE(src->operation);

drivers/block/xen-blkback/blkback.c

1134

switch (dst->operation) {

drivers/block/xen-blkback/blkback.c

1139

dst->u.rw.nr_segments = READ_ONCE(src->u.rw.nr_segments);

drivers/block/xen-blkback/blkback.c

1140

dst->u.rw.handle = src->u.rw.handle;

drivers/block/xen-blkback/blkback.c

1141

dst->u.rw.id = src->u.rw.id;

drivers/block/xen-blkback/blkback.c

1142

dst->u.rw.sector_number = src->u.rw.sector_number;

drivers/block/xen-blkback/blkback.c

1144

dst->u.rw.nr_segments);

drivers/block/xen-blkback/blkback.c

1146

dst->u.rw.seg[i] = src->u.rw.seg[i];

drivers/block/xen-blkback/blkback.c

1150

dst->u.discard.flag = src->u.discard.flag;

drivers/block/xen-blkback/blkback.c

1151

dst->u.discard.id = src->u.discard.id;

drivers/block/xen-blkback/blkback.c

1152

dst->u.discard.sector_number = src->u.discard.sector_number;

drivers/block/xen-blkback/blkback.c

1153

dst->u.discard.nr_sectors = src->u.discard.nr_sectors;

drivers/block/xen-blkback/blkback.c

1157

dst->u.indirect.indirect_op = src->u.indirect.indirect_op;

drivers/block/xen-blkback/blkback.c

1158

dst->u.indirect.nr_segments =

drivers/block/xen-blkback/blkback.c

1160

dst->u.indirect.handle = src->u.indirect.handle;

drivers/block/xen-blkback/blkback.c

1161

dst->u.indirect.id = src->u.indirect.id;

drivers/block/xen-blkback/blkback.c

1162

dst->u.indirect.sector_number = src->u.indirect.sector_number;

drivers/block/xen-blkback/blkback.c

1164

INDIRECT_PAGES(dst->u.indirect.nr_segments));

drivers/block/xen-blkback/blkback.c

1166

dst->u.indirect.indirect_grefs[i] =

drivers/block/xen-blkback/blkback.c

1175

dst->u.other.id = src->u.other.id;

drivers/block/zram/backend_842.c

38

ret = sw842_compress(req->src, req->src_len, req->dst, &dlen,

drivers/block/zram/backend_842.c

50

return sw842_decompress(req->src, req->src_len, req->dst, &dlen);

drivers/block/zram/backend_deflate.c

103

deflate->next_out = (u8 *)req->dst;

drivers/block/zram/backend_deflate.c

130

inflate->next_out = (u8 *)req->dst;

drivers/block/zram/backend_lz4.c

102

ret = LZ4_decompress_safe(req->src, req->dst, req->src_len,

drivers/block/zram/backend_lz4.c

111

req->dst, req->src_len,

drivers/block/zram/backend_lz4.c

77

ret = LZ4_compress_fast(req->src, req->dst, req->src_len,

drivers/block/zram/backend_lz4.c

86

req->dst, req->src_len,

drivers/block/zram/backend_lz4hc.c

103

ret = LZ4_decompress_safe(req->src, req->dst, req->src_len,

drivers/block/zram/backend_lz4hc.c

112

req->dst, req->src_len,

drivers/block/zram/backend_lz4hc.c

77

ret = LZ4_compress_HC(req->src, req->dst, req->src_len,

drivers/block/zram/backend_lz4hc.c

87

ret = LZ4_compress_HC_continue(zctx->cstrm, req->src, req->dst,

drivers/block/zram/backend_lzo.c

36

ret = lzo1x_1_compress(req->src, req->src_len, req->dst,

drivers/block/zram/backend_lzo.c

47

req->dst, &req->dst_len);

drivers/block/zram/backend_lzorle.c

36

ret = lzorle1x_1_compress(req->src, req->src_len, req->dst,

drivers/block/zram/backend_lzorle.c

47

req->dst, &req->dst_len);

drivers/block/zram/backend_zstd.c

177

ret = zstd_compress_cctx(zctx->cctx, req->dst, req->dst_len,

drivers/block/zram/backend_zstd.c

180

ret = zstd_compress_using_cdict(zctx->cctx, req->dst,

drivers/block/zram/backend_zstd.c

198

ret = zstd_decompress_dctx(zctx->dctx, req->dst, req->dst_len,

drivers/block/zram/backend_zstd.c

201

ret = zstd_decompress_using_ddict(zctx->dctx, req->dst,

drivers/block/zram/zcomp.c

142

.dst = zstrm->buffer,

drivers/block/zram/zcomp.c

156

const void *src, unsigned int src_len, void *dst)

drivers/block/zram/zcomp.c

160

.dst = dst,

drivers/block/zram/zcomp.h

53

unsigned char *dst;

drivers/block/zram/zcomp.h

94

const void *src, unsigned int src_len, void *dst);

drivers/block/zram/zram_drv.c

2051

void *src, *dst;

drivers/block/zram/zram_drv.c

2055

dst = kmap_local_page(page);

drivers/block/zram/zram_drv.c

2056

copy_page(dst, src);

drivers/block/zram/zram_drv.c

2057

kunmap_local(dst);

drivers/block/zram/zram_drv.c

2068

void *src, *dst;

drivers/block/zram/zram_drv.c

2078

dst = kmap_local_page(page);

drivers/block/zram/zram_drv.c

2079

ret = zcomp_decompress(zram->comps[prio], zstrm, src, size, dst);

drivers/block/zram/zram_drv.c

2080

kunmap_local(dst);

drivers/cdx/controller/cdx_rpmsg.c

131

chinfo.dst = rpdev->dst;

drivers/char/hw_random/xgene-rng.c

53

#define MAX_REFILL_CYCLES_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

54

((dst & ~0xffff0000) | (((u32)src << 16) & 0xffff0000))

drivers/char/hw_random/xgene-rng.c

55

#define MIN_REFILL_CYCLES_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

56

((dst & ~0x000000ff) | (((u32)src) & 0x000000ff))

drivers/char/hw_random/xgene-rng.c

57

#define ALARM_THRESHOLD_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

58

((dst & ~0x000000ff) | (((u32)src) & 0x000000ff))

drivers/char/hw_random/xgene-rng.c

59

#define ENABLE_RNG_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

60

((dst & ~BIT(10)) | (((u32)src << 10) & BIT(10)))

drivers/char/hw_random/xgene-rng.c

61

#define REGSPEC_TEST_MODE_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

62

((dst & ~BIT(8)) | (((u32)src << 8) & BIT(8)))

drivers/char/hw_random/xgene-rng.c

63

#define MONOBIT_FAIL_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

64

((dst & ~BIT(7)) | (((u32)src << 7) & BIT(7)))

drivers/char/hw_random/xgene-rng.c

65

#define POKER_FAIL_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

66

((dst & ~BIT(6)) | (((u32)src << 6) & BIT(6)))

drivers/char/hw_random/xgene-rng.c

67

#define LONG_RUN_FAIL_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

68

((dst & ~BIT(5)) | (((u32)src << 5) & BIT(5)))

drivers/char/hw_random/xgene-rng.c

69

#define RUN_FAIL_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

70

((dst & ~BIT(4)) | (((u32)src << 4) & BIT(4)))

drivers/char/hw_random/xgene-rng.c

71

#define NOISE_FAIL_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

72

((dst & ~BIT(3)) | (((u32)src << 3) & BIT(3)))

drivers/char/hw_random/xgene-rng.c

73

#define STUCK_OUT_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

74

((dst & ~BIT(2)) | (((u32)src << 2) & BIT(2)))

drivers/char/hw_random/xgene-rng.c

75

#define SHUTDOWN_OFLO_MASK_SET(dst, src) \

drivers/char/hw_random/xgene-rng.c

76

((dst & ~BIT(1)) | (((u32)src << 1) & BIT(1)))

drivers/char/ps3flash.c

170

void *dst;

drivers/char/ps3flash.c

193

dst = dev->bounce_buf + offset;

drivers/char/ps3flash.c

206

__func__, __LINE__, n, userbuf, kernelbuf, dst);

drivers/char/ps3flash.c

208

if (copy_from_user(dst, userbuf, n)) {

drivers/char/ps3flash.c

215

memcpy(dst, kernelbuf, n);

drivers/char/xillybus/xillyusb.c

346

static int xilly_copy_from_user(void *dst, const void *src, int n)

drivers/char/xillybus/xillyusb.c

348

if (copy_from_user(dst, (const void __user *)src, n))

drivers/char/xillybus/xillyusb.c

354

static int xilly_copy_to_user(void *dst, const void *src, int n)

drivers/char/xillybus/xillyusb.c

356

if (copy_to_user((void __user *)dst, src, n))

drivers/char/xillybus/xillyusb.c

362

static int xilly_memcpy(void *dst, const void *src, int n)

drivers/char/xillybus/xillyusb.c

364

memcpy(dst, src, n);

drivers/clk/clk.c

4209

const char *dst;

drivers/clk/clk.c

4217

*dst_p = dst = kstrdup_const(src, GFP_KERNEL);

drivers/clk/clk.c

4218

if (!dst)

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

108

sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

137

scatterwalk_map_and_copy(areq->iv, areq->dst, areq->cryptlen - ivsize,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

165

skcipher_request_set_crypt(&ctx->fallback_req, areq->src, areq->dst,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

183

struct scatterlist *out_sg = areq->dst;

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

212

if (!areq->src || !areq->dst) {

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

326

sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

384

scatterwalk_map_and_copy(areq->iv, areq->dst, areq->cryptlen - ivsize,

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c

44

if (!areq->src || !areq->dst) {

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-prng.c

17

unsigned int slen, u8 *dst, unsigned int dlen)

drivers/crypto/allwinner/sun4i-ss/sun4i-ss-prng.c

23

u32 *data = (u32 *)dst;

drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h

235

unsigned int slen, u8 *dst, unsigned int dlen);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

125

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

151

int nd = sg_nents_for_len(areq->dst, areq->cryptlen);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

219

if (areq->src == areq->dst) {

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

234

nr_sgd = dma_map_sg(ce->dev, areq->dst, nd, DMA_FROM_DEVICE);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

258

for_each_sg(areq->dst, sg, nr_sgd, i) {

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

277

if (areq->src == areq->dst) {

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

284

dma_unmap_sg(ce->dev, areq->dst, nd, DMA_FROM_DEVICE);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

298

scatterwalk_map_and_copy(areq->iv, areq->dst, offset,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

323

if (areq->src == areq->dst) {

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

328

dma_unmap_sg(ce->dev, areq->dst, nr_sgd, DMA_FROM_DEVICE);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

340

scatterwalk_map_and_copy(areq->iv, areq->dst, offset,

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

35

sg_nents_for_len(areq->dst, areq->cryptlen) > MAX_SG) {

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-cipher.c

84

sg = areq->dst;

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-prng.c

152

memcpy(dst, d, dlen);

drivers/crypto/allwinner/sun8i-ce/sun8i-ce-prng.c

56

unsigned int slen, u8 *dst, unsigned int dlen)

drivers/crypto/allwinner/sun8i-ce/sun8i-ce.h

402

unsigned int slen, u8 *dst, unsigned int dlen);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

111

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

198

int nsgd = sg_nents_for_len(areq->dst, areq->cryptlen);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

230

if (areq->src == areq->dst) {

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

245

nr_sgd = dma_map_sg(ss->dev, areq->dst, nsgd, DMA_FROM_DEVICE);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

277

sg = areq->dst;

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

29

struct scatterlist *out_sg = areq->dst;

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

300

if (areq->src == areq->dst) {

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

304

dma_unmap_sg(ss->dev, areq->dst, nsgd, DMA_FROM_DEVICE);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

319

scatterwalk_map_and_copy(areq->iv, areq->dst, offset,

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

39

sg_nents_for_len(areq->dst, areq->cryptlen) > 8) {

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

60

sg = areq->dst;

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-cipher.c

77

out_sg = areq->dst;

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-prng.c

169

memcpy(dst, d, dlen);

drivers/crypto/allwinner/sun8i-ss/sun8i-ss-prng.c

58

unsigned int slen, u8 *dst, unsigned int dlen)

drivers/crypto/allwinner/sun8i-ss/sun8i-ss.h

304

unsigned int slen, u8 *dst, unsigned int dlen);

drivers/crypto/amcc/crypto4xx_alg.c

215

return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_alg.c

230

return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_alg.c

258

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_alg.c

342

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

drivers/crypto/amcc/crypto4xx_alg.c

451

return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_alg.c

453

sa, ctx->sa_len, req->assoclen, rctx->dst);

drivers/crypto/amcc/crypto4xx_alg.c

587

return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_alg.c

590

ctx->sa_len, req->assoclen, rctx->dst);

drivers/crypto/amcc/crypto4xx_alg.c

80

return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst,

drivers/crypto/amcc/crypto4xx_core.c

449

struct scatterlist *dst)

drivers/crypto/amcc/crypto4xx_core.c

475

scatterwalk_map_and_copy(buf, dst, dst_start, to_copy, 1);

drivers/crypto/amcc/crypto4xx_core.c

511

struct scatterlist *dst;

drivers/crypto/amcc/crypto4xx_core.c

517

req->cryptlen, req->dst);

drivers/crypto/amcc/crypto4xx_core.c

519

dst = pd_uinfo->dest_va;

drivers/crypto/amcc/crypto4xx_core.c

520

dma_unmap_page(dev->core_dev->device, pd->dest, dst->length,

drivers/crypto/amcc/crypto4xx_core.c

545

struct scatterlist *dst = pd_uinfo->dest_va;

drivers/crypto/amcc/crypto4xx_core.c

554

dst);

drivers/crypto/amcc/crypto4xx_core.c

556

dma_unmap_page(dev->core_dev->device, pd->dest, dst->length,

drivers/crypto/amcc/crypto4xx_core.c

565

scatterwalk_map_and_copy(icv, dst, aead_req->cryptlen,

drivers/crypto/amcc/crypto4xx_core.c

644

struct scatterlist *dst,

drivers/crypto/amcc/crypto4xx_core.c

696

dst = scatterwalk_ffwd(_dst, dst, assoclen);

drivers/crypto/amcc/crypto4xx_core.c

700

if (sg_is_last(dst) && force_sd == false) {

drivers/crypto/amcc/crypto4xx_core.c

777

pd_uinfo->dest_va = dst;

drivers/crypto/amcc/crypto4xx_core.c

842

sg_page(dst), dst->offset,

drivers/crypto/amcc/crypto4xx_core.c

843

min(datalen, dst->length),

drivers/crypto/amcc/crypto4xx_core.h

130

struct scatterlist dst[2];

drivers/crypto/amcc/crypto4xx_core.h

159

struct scatterlist *dst,

drivers/crypto/amcc/crypto4xx_core.h

188

static inline void crypto4xx_memcpy_swab32(u32 *dst, const void *buf,

drivers/crypto/amcc/crypto4xx_core.h

192

*dst++ = __swab32p((u32 *) buf);

drivers/crypto/amcc/crypto4xx_core.h

199

*dst = (tmp[2] << 16) |

drivers/crypto/amcc/crypto4xx_core.h

204

*dst = (tmp[1] << 8) |

drivers/crypto/amcc/crypto4xx_core.h

208

*dst = tmp[0];

drivers/crypto/amcc/crypto4xx_core.h

216

static inline void crypto4xx_memcpy_from_le32(u32 *dst, const void *buf,

drivers/crypto/amcc/crypto4xx_core.h

219

crypto4xx_memcpy_swab32(dst, buf, len);

drivers/crypto/amcc/crypto4xx_core.h

222

static inline void crypto4xx_memcpy_to_le32(__le32 *dst, const void *buf,

drivers/crypto/amcc/crypto4xx_core.h

225

crypto4xx_memcpy_swab32((u32 *)dst, buf, len);

drivers/crypto/amlogic/amlogic-gxl-cipher.c

177

if (areq->src == areq->dst) {

drivers/crypto/amlogic/amlogic-gxl-cipher.c

194

nr_sgd = dma_map_sg(mc->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/amlogic/amlogic-gxl-cipher.c

204

dst_sg = areq->dst;

drivers/crypto/amlogic/amlogic-gxl-cipher.c

238

if (areq->src == areq->dst) {

drivers/crypto/amlogic/amlogic-gxl-cipher.c

242

dma_unmap_sg(mc->dev, areq->dst, sg_nents(areq->dst), DMA_FROM_DEVICE);

drivers/crypto/amlogic/amlogic-gxl-cipher.c

249

scatterwalk_map_and_copy(areq->iv, areq->dst,

drivers/crypto/amlogic/amlogic-gxl-cipher.c

28

struct scatterlist *dst_sg = areq->dst;

drivers/crypto/amlogic/amlogic-gxl-cipher.c

74

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/amlogic/amlogic-gxl-cipher.c

95

struct scatterlist *dst_sg = areq->dst;

drivers/crypto/aspeed/aspeed-acry.c

303

struct scatterlist *out_sg = req->dst;

drivers/crypto/aspeed/aspeed-hace-crypto.c

140

if (req->src == req->dst) {

drivers/crypto/aspeed/aspeed-hace-crypto.c

144

dma_unmap_sg(dev, req->dst, rctx->dst_nents, DMA_FROM_DEVICE);

drivers/crypto/aspeed/aspeed-hace-crypto.c

161

out_sg = req->dst;

drivers/crypto/aspeed/aspeed-hace-crypto.c

241

if (req->dst == req->src) {

drivers/crypto/aspeed/aspeed-hace-crypto.c

258

dst_sg_len = dma_map_sg(hace_dev->dev, req->dst,

drivers/crypto/aspeed/aspeed-hace-crypto.c

293

if (req->dst == req->src) {

drivers/crypto/aspeed/aspeed-hace-crypto.c

302

for_each_sg(req->dst, s, dst_sg_len, i) {

drivers/crypto/aspeed/aspeed-hace-crypto.c

343

if (req->dst == req->src) {

drivers/crypto/aspeed/aspeed-hace-crypto.c

348

dma_unmap_sg(hace_dev->dev, req->dst, rctx->dst_nents,

drivers/crypto/aspeed/aspeed-hace-crypto.c

37

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/aspeed/aspeed-hace-crypto.c

380

rctx->dst_nents = sg_nents(req->dst);

drivers/crypto/atmel-aes.c

1004

dst = ((req->src == req->dst) ? src :

drivers/crypto/atmel-aes.c

1005

scatterwalk_ffwd(ctx->dst, req->dst, ctx->offset));

drivers/crypto/atmel-aes.c

1019

return atmel_aes_dma_start(dd, src, dst, datalen,

drivers/crypto/atmel-aes.c

1022

return atmel_aes_cpu_start(dd, src, dst, datalen,

drivers/crypto/atmel-aes.c

1054

skcipher_request_set_crypt(&rctx->fallback_req, req->src, req->dst,

drivers/crypto/atmel-aes.c

110

struct scatterlist dst[2];

drivers/crypto/atmel-aes.c

118

struct scatterlist dst[2];

drivers/crypto/atmel-aes.c

1411

struct scatterlist *src, *dst;

drivers/crypto/atmel-aes.c

1434

dst = ((req->src == req->dst) ? src :

drivers/crypto/atmel-aes.c

1435

scatterwalk_ffwd(ctx->dst, req->dst, req->assoclen));

drivers/crypto/atmel-aes.c

1446

return atmel_aes_dma_start(dd, src, dst, ctx->textlen,

drivers/crypto/atmel-aes.c

1450

return atmel_aes_cpu_start(dd, src, dst, ctx->textlen,

drivers/crypto/atmel-aes.c

1517

scatterwalk_map_and_copy(otag, req->dst, offset, authsize, 1);

drivers/crypto/atmel-aes.c

155

struct scatterlist dst[2];

drivers/crypto/atmel-aes.c

1669

return atmel_aes_dma_start(dd, req->src, req->dst,

drivers/crypto/atmel-aes.c

1673

return atmel_aes_cpu_start(dd, req->src, req->dst, req->cryptlen,

drivers/crypto/atmel-aes.c

1826

struct scatterlist *src, *dst;

drivers/crypto/atmel-aes.c

1837

dst = src;

drivers/crypto/atmel-aes.c

1839

if (req->src != req->dst)

drivers/crypto/atmel-aes.c

1840

dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);

drivers/crypto/atmel-aes.c

1859

return atmel_aes_dma_start(dd, src, dst, rctx->textlen,

drivers/crypto/atmel-aes.c

1893

scatterwalk_map_and_copy(odigest, req->dst, offs, authsize, 1);

drivers/crypto/atmel-aes.c

201

struct atmel_aes_dma dst;

drivers/crypto/atmel-aes.c

2148

dd->dst.chan = dma_request_chan(dd->dev, "rx");

drivers/crypto/atmel-aes.c

2149

if (IS_ERR(dd->dst.chan)) {

drivers/crypto/atmel-aes.c

2150

ret = PTR_ERR(dd->dst.chan);

drivers/crypto/atmel-aes.c

2165

dma_release_channel(dd->dst.chan);

drivers/crypto/atmel-aes.c

2414

dma_chan_name(aes_dd->dst.chan));

drivers/crypto/atmel-aes.c

485

scatterwalk_map_and_copy(req->iv, req->dst,

drivers/crypto/atmel-aes.c

622

struct scatterlist *dst,

drivers/crypto/atmel-aes.c

634

dd->real_dst = dst;

drivers/crypto/atmel-aes.c

699

struct scatterlist *dst,

drivers/crypto/atmel-aes.c

707

dd->dst.sg = dst;

drivers/crypto/atmel-aes.c

708

dd->real_dst = dst;

drivers/crypto/atmel-aes.c

711

if (src == dst)

drivers/crypto/atmel-aes.c

714

dst_aligned = atmel_aes_check_aligned(dd, dst, len, &dd->dst);

drivers/crypto/atmel-aes.c

729

dd->dst.sg = &dd->aligned_sg;

drivers/crypto/atmel-aes.c

730

dd->dst.nents = 1;

drivers/crypto/atmel-aes.c

731

dd->dst.remainder = 0;

drivers/crypto/atmel-aes.c

738

if (dd->src.sg == dd->dst.sg) {

drivers/crypto/atmel-aes.c

741

dd->dst.sg_len = dd->src.sg_len;

drivers/crypto/atmel-aes.c

750

dd->dst.sg_len = dma_map_sg(dd->dev, dd->dst.sg, dd->dst.nents,

drivers/crypto/atmel-aes.c

752

if (!dd->dst.sg_len) {

drivers/crypto/atmel-aes.c

764

if (dd->src.sg == dd->dst.sg) {

drivers/crypto/atmel-aes.c

771

dma_unmap_sg(dd->dev, dd->dst.sg, dd->dst.nents,

drivers/crypto/atmel-aes.c

774

if (dd->dst.sg != &dd->aligned_sg)

drivers/crypto/atmel-aes.c

775

atmel_aes_restore_sg(&dd->dst);

drivers/crypto/atmel-aes.c

784

if (dd->dst.sg == &dd->aligned_sg)

drivers/crypto/atmel-aes.c

814

dma = &dd->dst;

drivers/crypto/atmel-aes.c

842

struct scatterlist *dst,

drivers/crypto/atmel-aes.c

861

err = atmel_aes_map(dd, src, dst, len);

drivers/crypto/atmel-aes.c

882

dmaengine_terminate_sync(dd->dst.chan);

drivers/crypto/atmel-aes.c

962

return atmel_aes_dma_start(dd, req->src, req->dst,

drivers/crypto/atmel-aes.c

966

return atmel_aes_cpu_start(dd, req->src, req->dst, req->cryptlen,

drivers/crypto/atmel-aes.c

974

struct scatterlist *src, *dst;

drivers/crypto/atmel-ecc.c

156

copied = sg_copy_from_buffer(req->dst,

drivers/crypto/atmel-ecc.c

157

sg_nents_for_len(req->dst, nbytes),

drivers/crypto/atmel-ecc.c

62

copied = sg_copy_from_buffer(req->dst, sg_nents_for_len(req->dst, n_sz),

drivers/crypto/atmel-tdes.c

533

scatterwalk_map_and_copy(req->iv, req->dst,

drivers/crypto/atmel-tdes.c

591

dd->out_sg = req->dst;

drivers/crypto/axis/artpec6_crypto.c

1001

create_hash_pad(int oper, unsigned char *dst, u64 dgstlen, u64 bitcount)

drivers/crypto/axis/artpec6_crypto.c

1026

memset(dst + 1, 0, pad_bytes);

drivers/crypto/axis/artpec6_crypto.c

1027

dst[0] = 0x80;

drivers/crypto/axis/artpec6_crypto.c

1030

memset(dst + 1 + pad_bytes, 0, 8);

drivers/crypto/axis/artpec6_crypto.c

1031

memcpy(dst + 1 + pad_bytes + 8, &bits, 8);

drivers/crypto/axis/artpec6_crypto.c

1033

memcpy(dst + 1 + pad_bytes, &bits, 8);

drivers/crypto/axis/artpec6_crypto.c

1118

req->dst, req->cryptlen);

drivers/crypto/axis/artpec6_crypto.c

1163

req->dst, req->cryptlen);

drivers/crypto/axis/artpec6_crypto.c

1210

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/axis/artpec6_crypto.c

1794

artpec6_crypto_walk_init(&walk, areq->dst);

drivers/crypto/axis/artpec6_crypto.c

1977

artpec6_crypto_walk_init(&walk, areq->dst);

drivers/crypto/axis/artpec6_crypto.c

2177

scatterwalk_map_and_copy(cipher_req->iv, cipher_req->dst,

drivers/crypto/axis/artpec6_crypto.c

579

void *dst, unsigned int len, bool eop)

drivers/crypto/axis/artpec6_crypto.c

597

memcpy(d->shrt.data, dst, len);

drivers/crypto/axis/artpec6_crypto.c

706

void *dst, unsigned int len, bool eop,

drivers/crypto/axis/artpec6_crypto.c

710

return artpec6_crypto_setup_out_descr_short(common, dst, len,

drivers/crypto/axis/artpec6_crypto.c

716

ret = artpec6_crypto_dma_map_single(common, dst, len,

drivers/crypto/bcm/cipher.c

1076

mssg->spu.dst = kmalloc_objs(struct scatterlist, rx_frag_num, rctx->gfp);

drivers/crypto/bcm/cipher.c

1077

if (!mssg->spu.dst)

drivers/crypto/bcm/cipher.c

1080

sg = mssg->spu.dst;

drivers/crypto/bcm/cipher.c

144

mssg->spu.dst = kmalloc_objs(struct scatterlist, rx_frag_num, rctx->gfp);

drivers/crypto/bcm/cipher.c

145

if (!mssg->spu.dst)

drivers/crypto/bcm/cipher.c

148

sg = mssg->spu.dst;

drivers/crypto/bcm/cipher.c

1555

sg_copy_part_from_buf(req->dst, rctx->msg_buf.digest,

drivers/crypto/bcm/cipher.c

1561

dump_sg(req->dst, req->assoclen, result_len);

drivers/crypto/bcm/cipher.c

1589

kfree(mssg->spu.dst);

drivers/crypto/bcm/cipher.c

1731

rctx->dst_sg = req->dst;

drivers/crypto/bcm/cipher.c

2588

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

drivers/crypto/bcm/cipher.c

2642

if (req->dst == req->src) {

drivers/crypto/bcm/cipher.c

2651

if (spu_sg_at_offset(req->dst, req->assoclen, &rctx->dst_sg,

drivers/crypto/bcm/cipher.c

2679

flow_log(" dst sg: %p\n", req->dst);

drivers/crypto/bcm/cipher.c

355

sg_copy_part_to_buf(req->dst, rctx->msg_buf.iv_ctr,

drivers/crypto/bcm/cipher.c

494

dump_sg(req->dst, rctx->total_received, payload_len);

drivers/crypto/bcm/cipher.c

533

mssg->spu.dst = kmalloc_objs(struct scatterlist, rx_frag_num, rctx->gfp);

drivers/crypto/bcm/cipher.c

534

if (!mssg->spu.dst)

drivers/crypto/bcm/cipher.c

537

sg = mssg->spu.dst;

drivers/crypto/caam/caamalg.c

1004

struct scatterlist *dst, int src_nents,

drivers/crypto/caam/caamalg.c

1009

if (dst != src) {

drivers/crypto/caam/caamalg.c

1013

dma_unmap_sg(dev, dst, dst_nents, DMA_FROM_DEVICE);

drivers/crypto/caam/caamalg.c

1029

caam_unmap(dev, req->src, req->dst,

drivers/crypto/caam/caamalg.c

1040

caam_unmap(dev, req->src, req->dst,

drivers/crypto/caam/caamalg.c

1120

DUMP_PREFIX_ADDRESS, 16, 4, req->dst,

drivers/crypto/caam/caamalg.c

1174

if (unlikely(req->src != req->dst)) {

drivers/crypto/caam/caamalg.c

1179

dst_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caamalg.c

1350

if (likely(req->src == req->dst)) {

drivers/crypto/caam/caamalg.c

1354

dst_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caamalg.c

1401

if (unlikely(req->dst != req->src)) {

drivers/crypto/caam/caamalg.c

1412

dst_nents = sg_nents_for_len(req->dst, dst_len);

drivers/crypto/caam/caamalg.c

1430

if (likely(req->src == req->dst)) {

drivers/crypto/caam/caamalg.c

1452

mapped_dst_nents = dma_map_sg(jrdev, req->dst,

drivers/crypto/caam/caamalg.c

1481

caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg.c

1504

sg_to_sec4_sg_last(req->dst, dst_len,

drivers/crypto/caam/caamalg.c

1716

if (req->dst != req->src) {

drivers/crypto/caam/caamalg.c

1717

dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/caam/caamalg.c

1725

if (likely(req->src == req->dst)) {

drivers/crypto/caam/caamalg.c

1739

mapped_dst_nents = dma_map_sg(jrdev, req->dst, dst_nents,

drivers/crypto/caam/caamalg.c

1767

if (req->src == req->dst)

drivers/crypto/caam/caamalg.c

1789

caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg.c

1811

caam_unmap(jrdev, req->src, req->dst, src_nents,

drivers/crypto/caam/caamalg.c

1823

if (req->src != req->dst && (ivsize || mapped_dst_nents > 1))

drivers/crypto/caam/caamalg.c

1824

sg_to_sec4_sg(req->dst, req->cryptlen, edesc->sec4_sg +

drivers/crypto/caam/caamalg.c

1841

caam_unmap(jrdev, req->src, req->dst, src_nents,

drivers/crypto/caam/caamalg.c

1920

req->dst, req->cryptlen, req->iv);

drivers/crypto/caam/caamalg_desc.c

1369

dma_addr_t src, dma_addr_t dst, unsigned int data_sz,

drivers/crypto/caam/caamalg_desc.c

1390

append_seq_out_ptr(desc, dst, data_sz, out_options);

drivers/crypto/caam/caamalg_desc.h

123

dma_addr_t src, dma_addr_t dst, unsigned int data_sz,

drivers/crypto/caam/caamalg_qi.c

1004

dst_nents = sg_nents_for_len(req->dst, dst_len);

drivers/crypto/caam/caamalg_qi.c

1025

mapped_dst_nents = dma_map_sg(qidev, req->dst,

drivers/crypto/caam/caamalg_qi.c

1058

else if ((req->src == req->dst) && (mapped_src_nents > 1))

drivers/crypto/caam/caamalg_qi.c

1070

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi.c

1085

caam_unmap(qidev, req->src, req->dst, src_nents,

drivers/crypto/caam/caamalg_qi.c

1104

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi.c

1120

sg_to_qm_sg_last(req->dst, dst_len, sg_table + qm_sg_index, 0);

drivers/crypto/caam/caamalg_qi.c

1126

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi.c

1142

if (req->dst == req->src) {

drivers/crypto/caam/caamalg_qi.c

1151

dma_to_qm_sg_one(&fd_sgt[0], sg_dma_address(req->dst), out_len,

drivers/crypto/caam/caamalg_qi.c

1237

DUMP_PREFIX_ADDRESS, 16, 4, req->dst,

drivers/crypto/caam/caamalg_qi.c

1283

if (unlikely(req->src != req->dst)) {

drivers/crypto/caam/caamalg_qi.c

1284

dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/caam/caamalg_qi.c

1298

mapped_dst_nents = dma_map_sg(qidev, req->dst, dst_nents,

drivers/crypto/caam/caamalg_qi.c

1325

if (req->src != req->dst)

drivers/crypto/caam/caamalg_qi.c

1339

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi.c

1348

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi.c

1368

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi.c

1379

if (req->src != req->dst)

drivers/crypto/caam/caamalg_qi.c

1380

sg_to_qm_sg(req->dst, req->cryptlen, sg_table + dst_sg_idx, 0);

drivers/crypto/caam/caamalg_qi.c

1389

caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi.c

1400

if (req->src == req->dst)

drivers/crypto/caam/caamalg_qi.c

1446

req->dst, req->cryptlen, req->iv);

drivers/crypto/caam/caamalg_qi.c

873

struct scatterlist *dst, int src_nents,

drivers/crypto/caam/caamalg_qi.c

878

if (dst != src) {

drivers/crypto/caam/caamalg_qi.c

882

dma_unmap_sg(dev, dst, dst_nents, DMA_FROM_DEVICE);

drivers/crypto/caam/caamalg_qi.c

900

caam_unmap(dev, req->src, req->dst, edesc->src_nents, edesc->dst_nents,

drivers/crypto/caam/caamalg_qi.c

912

caam_unmap(dev, req->src, req->dst, edesc->src_nents, edesc->dst_nents,

drivers/crypto/caam/caamalg_qi.c

973

if (likely(req->src == req->dst)) {

drivers/crypto/caam/caamalg_qi2.c

1138

if (unlikely(req->dst != req->src)) {

drivers/crypto/caam/caamalg_qi2.c

1139

dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/caam/caamalg_qi2.c

1153

mapped_dst_nents = dma_map_sg(dev, req->dst, dst_nents,

drivers/crypto/caam/caamalg_qi2.c

1180

if (req->src != req->dst)

drivers/crypto/caam/caamalg_qi2.c

1190

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi2.c

1199

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi2.c

1212

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi2.c

1226

if (req->src != req->dst)

drivers/crypto/caam/caamalg_qi2.c

1227

sg_to_qm_sg(req->dst, req->cryptlen, sg_table + dst_sg_idx, 0);

drivers/crypto/caam/caamalg_qi2.c

1236

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi2.c

1252

if (req->src == req->dst)

drivers/crypto/caam/caamalg_qi2.c

1268

caam_unmap(dev, req->src, req->dst, edesc->src_nents, edesc->dst_nents,

drivers/crypto/caam/caamalg_qi2.c

1280

caam_unmap(dev, req->src, req->dst, edesc->src_nents, edesc->dst_nents,

drivers/crypto/caam/caamalg_qi2.c

1413

DUMP_PREFIX_ADDRESS, 16, 4, req->dst,

drivers/crypto/caam/caamalg_qi2.c

1451

DUMP_PREFIX_ADDRESS, 16, 4, req->dst,

drivers/crypto/caam/caamalg_qi2.c

1502

req->dst, req->cryptlen, req->iv);

drivers/crypto/caam/caamalg_qi2.c

152

struct scatterlist *dst, int src_nents,

drivers/crypto/caam/caamalg_qi2.c

1552

req->dst, req->cryptlen, req->iv);

drivers/crypto/caam/caamalg_qi2.c

157

if (dst != src) {

drivers/crypto/caam/caamalg_qi2.c

161

dma_unmap_sg(dev, dst, dst_nents, DMA_FROM_DEVICE);

drivers/crypto/caam/caamalg_qi2.c

382

if (unlikely(req->dst != req->src)) {

drivers/crypto/caam/caamalg_qi2.c

394

dst_nents = sg_nents_for_len(req->dst, dst_len);

drivers/crypto/caam/caamalg_qi2.c

415

mapped_dst_nents = dma_map_sg(dev, req->dst, dst_nents,

drivers/crypto/caam/caamalg_qi2.c

466

else if ((req->src == req->dst) && (mapped_src_nents > 1))

drivers/crypto/caam/caamalg_qi2.c

479

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents, 0,

drivers/crypto/caam/caamalg_qi2.c

494

caam_unmap(dev, req->src, req->dst, src_nents,

drivers/crypto/caam/caamalg_qi2.c

518

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi2.c

534

sg_to_qm_sg_last(req->dst, dst_len, sg_table + qm_sg_index, 0);

drivers/crypto/caam/caamalg_qi2.c

540

caam_unmap(dev, req->src, req->dst, src_nents, dst_nents,

drivers/crypto/caam/caamalg_qi2.c

559

if (req->dst == req->src) {

drivers/crypto/caam/caamalg_qi2.c

578

dpaa2_fl_set_addr(out_fle, sg_dma_address(req->dst));

drivers/crypto/caam/caampkc.c

292

dst_nents = sg_nents_for_len(req->dst, req->dst_len);

drivers/crypto/caam/caampkc.c

300

mapped_dst_nents = dma_map_sg(dev, req->dst, dst_nents,

drivers/crypto/caam/caampkc.c

335

sg_to_sec4_sg_last(req->dst, req->dst_len,

drivers/crypto/caam/caampkc.c

368

dma_unmap_sg(dev, req->dst, dst_nents, DMA_FROM_DEVICE);

drivers/crypto/caam/caampkc.c

441

pdb->g_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caampkc.c

489

pdb->f_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caampkc.c

54

dma_unmap_sg(dev, req->dst, edesc->dst_nents, DMA_FROM_DEVICE);

drivers/crypto/caam/caampkc.c

554

pdb->f_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caampkc.c

643

pdb->f_dma = sg_dma_address(req->dst);

drivers/crypto/caam/caampkc.c

902

u8 *dst;

drivers/crypto/caam/caampkc.c

908

dst = kzalloc(dstlen, GFP_KERNEL);

drivers/crypto/caam/caampkc.c

909

if (!dst)

drivers/crypto/caam/caampkc.c

912

memcpy(dst + (dstlen - nbytes), ptr, nbytes);

drivers/crypto/caam/caampkc.c

914

return dst;

drivers/crypto/caam/caamprng.c

129

memcpy(dst, buf, dlen);

drivers/crypto/caam/caamprng.c

78

u8 *dst, unsigned int dlen)

drivers/crypto/caam/caamrng.c

147

static int caam_read(struct hwrng *rng, void *dst, size_t max, bool wait)

drivers/crypto/caam/caamrng.c

155

return caam_rng_read_one(ctx->jrdev, dst, max,

drivers/crypto/caam/caamrng.c

159

out = kfifo_out(&ctx->fifo, dst, max);

drivers/crypto/caam/caamrng.c

85

void *dst, int len,

drivers/crypto/caam/caamrng.c

98

dst_dma = dma_map_single(jrdev, dst, len, DMA_FROM_DEVICE);

drivers/crypto/cavium/cpt/cptvf_algs.c

189

update_output_data(req_info, req->dst, req->cryptlen, &argcnt);

drivers/crypto/cavium/nitrox/nitrox_aead.c

117

struct scatterlist *dst, int ivsize, int buflen)

drivers/crypto/cavium/nitrox/nitrox_aead.c

119

int nents = sg_nents_for_len(dst, buflen);

drivers/crypto/cavium/nitrox/nitrox_aead.c

136

nitrox_creq_set_dst_sg(nkreq, nents, ivsize, dst, buflen);

drivers/crypto/cavium/nitrox/nitrox_aead.c

148

kfree(nkreq->dst);

drivers/crypto/cavium/nitrox/nitrox_aead.c

180

ret = alloc_dst_sglist(&rctx->nkreq, rctx->dst, rctx->ivsize,

drivers/crypto/cavium/nitrox/nitrox_aead.c

236

rctx->dst = areq->dst;

drivers/crypto/cavium/nitrox/nitrox_aead.c

270

rctx->dst = areq->dst;

drivers/crypto/cavium/nitrox/nitrox_aead.c

410

if (areq->src != areq->dst) {

drivers/crypto/cavium/nitrox/nitrox_aead.c

411

sg_init_table(rctx->dst, 3);

drivers/crypto/cavium/nitrox/nitrox_aead.c

412

sg_set_buf(rctx->dst, rctx->assoc, assoclen);

drivers/crypto/cavium/nitrox/nitrox_aead.c

413

sg = scatterwalk_ffwd(rctx->dst + 1, areq->dst, areq->assoclen);

drivers/crypto/cavium/nitrox/nitrox_aead.c

414

if (sg != rctx->dst + 1)

drivers/crypto/cavium/nitrox/nitrox_aead.c

415

sg_chain(rctx->dst, 2, sg);

drivers/crypto/cavium/nitrox/nitrox_aead.c

419

aead_rctx->dst = (areq->src == areq->dst) ? rctx->src : rctx->dst;

drivers/crypto/cavium/nitrox/nitrox_req.h

215

u8 *dst;

drivers/crypto/cavium/nitrox/nitrox_req.h

245

struct scatterlist *dst;

drivers/crypto/cavium/nitrox/nitrox_req.h

259

struct scatterlist dst[3];

drivers/crypto/cavium/nitrox/nitrox_req.h

632

static inline void nitrox_creq_copy_iv(char *dst, char *src, int size)

drivers/crypto/cavium/nitrox/nitrox_req.h

634

memcpy(dst, src, size);

drivers/crypto/cavium/nitrox/nitrox_req.h

672

nkreq->dst = alloc_req_buf(nents, extralen, creq->gfp);

drivers/crypto/cavium/nitrox/nitrox_req.h

673

if (!nkreq->dst)

drivers/crypto/cavium/nitrox/nitrox_req.h

683

creq->orh = (u64 *)(nkreq->dst);

drivers/crypto/cavium/nitrox/nitrox_req.h

691

creq->comp = (u64 *)(nkreq->dst + ORH_HLEN);

drivers/crypto/cavium/nitrox/nitrox_req.h

695

static inline struct scatterlist *nitrox_creq_dst_sg(char *dst)

drivers/crypto/cavium/nitrox/nitrox_req.h

697

return (struct scatterlist *)(dst + ORH_HLEN + COMP_HLEN);

drivers/crypto/cavium/nitrox/nitrox_req.h

702

struct scatterlist *dst, int buflen)

drivers/crypto/cavium/nitrox/nitrox_req.h

708

creq->dst = nitrox_creq_dst_sg(nkreq->dst);

drivers/crypto/cavium/nitrox/nitrox_req.h

709

sg = creq->dst;

drivers/crypto/cavium/nitrox/nitrox_req.h

723

sg = create_multi_sg(sg, dst, buflen);

drivers/crypto/cavium/nitrox/nitrox_req.h

80

struct scatterlist *dst;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

193

nents = dma_map_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

198

sr->out.sg = req->dst;

drivers/crypto/cavium/nitrox/nitrox_reqmgr.c

207

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_BIDIRECTIONAL);

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

229

int nents = sg_nents(skreq->dst) + 3;

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

241

nitrox_creq_set_dst_sg(nkreq, nents, ivsize, skreq->dst,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

299

if (skreq->src != skreq->dst)

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

62

kfree(nkreq->dst);

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

93

scatterwalk_map_and_copy(skreq->iv, skreq->dst, start, ivsize,

drivers/crypto/cavium/nitrox/nitrox_skcipher.c

96

if (skreq->src != skreq->dst) {

drivers/crypto/ccp/ccp-crypto-aes-cmac.c

168

rctx->cmd.u.aes.dst = NULL;

drivers/crypto/ccp/ccp-crypto-aes-galois.c

132

rctx->cmd.u.aes.dst = req->dst;

drivers/crypto/ccp/ccp-crypto-aes-xts.c

158

req->dst, req->cryptlen, req->iv);

drivers/crypto/ccp/ccp-crypto-aes-xts.c

180

rctx->cmd.u.xts.dst = req->dst;

drivers/crypto/ccp/ccp-crypto-aes.c

106

rctx->cmd.u.aes.dst = req->dst;

drivers/crypto/ccp/ccp-crypto-des3.c

102

rctx->cmd.u.des3.dst = req->dst;

drivers/crypto/ccp/ccp-crypto-rsa.c

87

rctx->cmd.u.rsa.dst = req->dst;

drivers/crypto/ccp/ccp-dev-v3.c

163

cr[4] = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

165

| ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

193

cr[4] = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

195

| ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

246

cr[4] = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

248

| ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

265

cr[1] = op->dst.u.dma.length - 1;

drivers/crypto/ccp/ccp-dev-v3.c

279

if (op->dst.type == CCP_MEMTYPE_SYSTEM) {

drivers/crypto/ccp/ccp-dev-v3.c

280

cr[4] = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

282

| ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

284

cr[4] = op->dst.u.sb * CCP_SB_BYTES;

drivers/crypto/ccp/ccp-dev-v3.c

307

cr[4] = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v3.c

309

| ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

310

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

311

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

353

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

354

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

437

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

438

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

479

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

480

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

496

struct ccp_dma_info *daddr = &op->dst.u.dma;

drivers/crypto/ccp/ccp-dev-v5.c

537

if (op->dst.type == CCP_MEMTYPE_SYSTEM) {

drivers/crypto/ccp/ccp-dev-v5.c

538

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

539

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

542

u32 key_addr = op->dst.u.sb * CCP_SB_BYTES;

drivers/crypto/ccp/ccp-dev-v5.c

580

CCP5_CMD_DST_LO(&desc) = ccp_addr_lo(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev-v5.c

581

CCP5_CMD_DST_HI(&desc) = ccp_addr_hi(&op->dst.u.dma);

drivers/crypto/ccp/ccp-dev.h

543

struct ccp_mem dst;

drivers/crypto/ccp/ccp-dmaengine.c

479

struct dma_chan *dma_chan, dma_addr_t dst, dma_addr_t src, size_t len,

drivers/crypto/ccp/ccp-dmaengine.c

489

__func__, &src, &dst, len, flags);

drivers/crypto/ccp/ccp-dmaengine.c

492

sg_dma_address(&dst_sg) = dst;

drivers/crypto/ccp/ccp-ops.c

1029

if (sg_virt(aes->src) == sg_virt(aes->dst))

drivers/crypto/ccp/ccp-ops.c

1039

dst = src;

drivers/crypto/ccp/ccp-ops.c

1041

ret = ccp_init_data(&dst, cmd_q, aes->dst, aes->src_len,

drivers/crypto/ccp/ccp-ops.c

1049

ccp_prepare_data(&src, &dst, &op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

1067

ccp_process_data(&src, &dst, &op);

drivers/crypto/ccp/ccp-ops.c

1088

ccp_free_data(&dst, cmd_q);

drivers/crypto/ccp/ccp-ops.c

1107

struct ccp_data src, dst;

drivers/crypto/ccp/ccp-ops.c

1149

if (!xts->key || !xts->iv || !xts->src || !xts->dst)

drivers/crypto/ccp/ccp-ops.c

1239

if (sg_virt(xts->src) == sg_virt(xts->dst))

drivers/crypto/ccp/ccp-ops.c

1249

dst = src;

drivers/crypto/ccp/ccp-ops.c

1251

ret = ccp_init_data(&dst, cmd_q, xts->dst, xts->src_len,

drivers/crypto/ccp/ccp-ops.c

1259

ccp_prepare_data(&src, &dst, &op, unit_size, true);

drivers/crypto/ccp/ccp-ops.c

1269

ccp_process_data(&src, &dst, &op);

drivers/crypto/ccp/ccp-ops.c

1288

ccp_free_data(&dst, cmd_q);

drivers/crypto/ccp/ccp-ops.c

1308

struct ccp_data src, dst;

drivers/crypto/ccp/ccp-ops.c

1330

if (!des3->key || !des3->src || !des3->dst)

drivers/crypto/ccp/ccp-ops.c

1428

if (sg_virt(des3->src) == sg_virt(des3->dst))

drivers/crypto/ccp/ccp-ops.c

1438

dst = src;

drivers/crypto/ccp/ccp-ops.c

1440

ret = ccp_init_data(&dst, cmd_q, des3->dst, des3->src_len,

drivers/crypto/ccp/ccp-ops.c

1448

ccp_prepare_data(&src, &dst, &op, DES3_EDE_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

1465

ccp_process_data(&src, &dst, &op);

drivers/crypto/ccp/ccp-ops.c

1483

ccp_free_data(&dst, cmd_q);

drivers/crypto/ccp/ccp-ops.c

1848

struct ccp_dm_workarea exp, src, dst;

drivers/crypto/ccp/ccp-ops.c

1857

if (!rsa->exp || !rsa->mod || !rsa->src || !rsa->dst)

drivers/crypto/ccp/ccp-ops.c

1937

ret = ccp_init_dm_workarea(&dst, cmd_q, o_len, DMA_FROM_DEVICE);

drivers/crypto/ccp/ccp-ops.c

1945

op.dst.u.dma.address = dst.dma.address;

drivers/crypto/ccp/ccp-ops.c

1946

op.dst.u.dma.offset = 0;

drivers/crypto/ccp/ccp-ops.c

1947

op.dst.u.dma.length = o_len;

drivers/crypto/ccp/ccp-ops.c

1958

ccp_reverse_get_dm_area(&dst, 0, rsa->dst, 0, rsa->mod_len);

drivers/crypto/ccp/ccp-ops.c

1961

ccp_dm_free(&dst);

drivers/crypto/ccp/ccp-ops.c

1981

struct ccp_data src, dst;

drivers/crypto/ccp/ccp-ops.c

1990

if (!pt->src || !pt->dst)

drivers/crypto/ccp/ccp-ops.c

2032

if (sg_virt(pt->src) == sg_virt(pt->dst))

drivers/crypto/ccp/ccp-ops.c

2042

dst = src;

drivers/crypto/ccp/ccp-ops.c

2044

ret = ccp_init_data(&dst, cmd_q, pt->dst, pt->src_len,

drivers/crypto/ccp/ccp-ops.c

2057

dst.sg_wa.sg_used = 0;

drivers/crypto/ccp/ccp-ops.c

2059

if (!dst.sg_wa.sg ||

drivers/crypto/ccp/ccp-ops.c

2060

(sg_dma_len(dst.sg_wa.sg) < sg_dma_len(src.sg_wa.sg))) {

drivers/crypto/ccp/ccp-ops.c

2075

op.dst.type = CCP_MEMTYPE_SYSTEM;

drivers/crypto/ccp/ccp-ops.c

2076

op.dst.u.dma.address = sg_dma_address(dst.sg_wa.sg);

drivers/crypto/ccp/ccp-ops.c

2077

op.dst.u.dma.offset = dst.sg_wa.sg_used;

drivers/crypto/ccp/ccp-ops.c

2078

op.dst.u.dma.length = op.src.u.dma.length;

drivers/crypto/ccp/ccp-ops.c

2086

dst.sg_wa.sg_used += sg_dma_len(src.sg_wa.sg);

drivers/crypto/ccp/ccp-ops.c

2087

if (dst.sg_wa.sg_used == sg_dma_len(dst.sg_wa.sg)) {

drivers/crypto/ccp/ccp-ops.c

2088

dst.sg_wa.sg = sg_next(dst.sg_wa.sg);

drivers/crypto/ccp/ccp-ops.c

2089

dst.sg_wa.sg_used = 0;

drivers/crypto/ccp/ccp-ops.c

2096

ccp_free_data(&dst, cmd_q);

drivers/crypto/ccp/ccp-ops.c

2161

op.dst.type = CCP_MEMTYPE_SYSTEM;

drivers/crypto/ccp/ccp-ops.c

2162

op.dst.u.dma.address = pt->dst_dma;

drivers/crypto/ccp/ccp-ops.c

2163

op.dst.u.dma.offset = 0;

drivers/crypto/ccp/ccp-ops.c

2164

op.dst.u.dma.length = pt->src_len;

drivers/crypto/ccp/ccp-ops.c

2176

struct ccp_dm_workarea src, dst;

drivers/crypto/ccp/ccp-ops.c

2239

ret = ccp_init_dm_workarea(&dst, cmd_q, CCP_ECC_DST_BUF_SIZE,

drivers/crypto/ccp/ccp-ops.c

2248

op.dst.u.dma.address = dst.dma.address;

drivers/crypto/ccp/ccp-ops.c

2249

op.dst.u.dma.offset = 0;

drivers/crypto/ccp/ccp-ops.c

2250

op.dst.u.dma.length = dst.length;

drivers/crypto/ccp/ccp-ops.c

2261

(const __le16 *)(dst.address + CCP_ECC_RESULT_OFFSET));

drivers/crypto/ccp/ccp-ops.c

2268

ccp_reverse_get_dm_area(&dst, 0, ecc->u.mm.result, 0,

drivers/crypto/ccp/ccp-ops.c

2272

ccp_dm_free(&dst);

drivers/crypto/ccp/ccp-ops.c

2283

struct ccp_dm_workarea src, dst;

drivers/crypto/ccp/ccp-ops.c

2397

ret = ccp_init_dm_workarea(&dst, cmd_q, CCP_ECC_DST_BUF_SIZE,

drivers/crypto/ccp/ccp-ops.c

2406

op.dst.u.dma.address = dst.dma.address;

drivers/crypto/ccp/ccp-ops.c

2407

op.dst.u.dma.offset = 0;

drivers/crypto/ccp/ccp-ops.c

2408

op.dst.u.dma.length = dst.length;

drivers/crypto/ccp/ccp-ops.c

2419

(const __le16 *)(dst.address + CCP_ECC_RESULT_OFFSET));

drivers/crypto/ccp/ccp-ops.c

2428

save = dst.address;

drivers/crypto/ccp/ccp-ops.c

2431

ccp_reverse_get_dm_area(&dst, 0, ecc->u.pm.result.x, 0,

drivers/crypto/ccp/ccp-ops.c

2433

dst.address += CCP_ECC_OUTPUT_SIZE;

drivers/crypto/ccp/ccp-ops.c

2434

ccp_reverse_get_dm_area(&dst, 0, ecc->u.pm.result.y, 0,

drivers/crypto/ccp/ccp-ops.c

2438

dst.address = save;

drivers/crypto/ccp/ccp-ops.c

2441

ccp_dm_free(&dst);

drivers/crypto/ccp/ccp-ops.c

343

static void ccp_prepare_data(struct ccp_data *src, struct ccp_data *dst,

drivers/crypto/ccp/ccp-ops.c

357

if (dst) {

drivers/crypto/ccp/ccp-ops.c

358

sg_dst_len = sg_dma_len(dst->sg_wa.dma_sg) - dst->sg_wa.sg_used;

drivers/crypto/ccp/ccp-ops.c

395

if (dst) {

drivers/crypto/ccp/ccp-ops.c

402

op->dst.u.dma.address = dst->dm_wa.dma.address;

drivers/crypto/ccp/ccp-ops.c

403

op->dst.u.dma.offset = 0;

drivers/crypto/ccp/ccp-ops.c

404

op->dst.u.dma.length = op->src.u.dma.length;

drivers/crypto/ccp/ccp-ops.c

409

op->dst.u.dma.address = sg_dma_address(dst->sg_wa.dma_sg);

drivers/crypto/ccp/ccp-ops.c

410

op->dst.u.dma.offset = dst->sg_wa.sg_used;

drivers/crypto/ccp/ccp-ops.c

411

op->dst.u.dma.length = op->src.u.dma.length;

drivers/crypto/ccp/ccp-ops.c

416

static void ccp_process_data(struct ccp_data *src, struct ccp_data *dst,

drivers/crypto/ccp/ccp-ops.c

421

if (dst) {

drivers/crypto/ccp/ccp-ops.c

422

if (op->dst.u.dma.address == dst->dm_wa.dma.address)

drivers/crypto/ccp/ccp-ops.c

423

ccp_empty_queue_buf(dst);

drivers/crypto/ccp/ccp-ops.c

425

ccp_update_sg_workarea(&dst->sg_wa,

drivers/crypto/ccp/ccp-ops.c

426

op->dst.u.dma.length);

drivers/crypto/ccp/ccp-ops.c

446

op.dst.type = CCP_MEMTYPE_SYSTEM;

drivers/crypto/ccp/ccp-ops.c

447

op.dst.u.dma.address = wa->dma.address;

drivers/crypto/ccp/ccp-ops.c

448

op.dst.u.dma.length = wa->length;

drivers/crypto/ccp/ccp-ops.c

453

op.dst.type = CCP_MEMTYPE_SB;

drivers/crypto/ccp/ccp-ops.c

454

op.dst.u.sb = sb;

drivers/crypto/ccp/ccp-ops.c

642

struct ccp_data dst;

drivers/crypto/ccp/ccp-ops.c

696

p_outp = scatterwalk_ffwd(sg_outp, aes->dst, aes->aad_len);

drivers/crypto/ccp/ccp-ops.c

797

wa->dst = wa->src;

drivers/crypto/ccp/ccp-ops.c

799

ret = ccp_init_data(&wa->dst, cmd_q, p_outp, ilen,

drivers/crypto/ccp/ccp-ops.c

809

ccp_prepare_data(&wa->src, &wa->dst, &wa->op, AES_BLOCK_SIZE, true);

drivers/crypto/ccp/ccp-ops.c

825

ccp_process_data(&wa->src, &wa->dst, &wa->op);

drivers/crypto/ccp/ccp-ops.c

872

wa->op.dst.type = CCP_MEMTYPE_SYSTEM;

drivers/crypto/ccp/ccp-ops.c

873

wa->op.dst.u.dma.address = wa->final.dma.address;

drivers/crypto/ccp/ccp-ops.c

874

wa->op.dst.u.dma.length = AES_BLOCK_SIZE;

drivers/crypto/ccp/ccp-ops.c

906

ccp_free_data(&wa->dst, cmd_q);

drivers/crypto/ccp/ccp-ops.c

930

struct ccp_data src, dst;

drivers/crypto/ccp/ccp-ops.c

946

if (!aes->key || !aes->src || !aes->dst)

drivers/crypto/ccree/cc_aead.c

1906

sg_virt(req->dst), req->dst->offset, req->cryptlen);

drivers/crypto/ccree/cc_aead.c

235

sg_zero_buffer(areq->dst, sg_nents(areq->dst),

drivers/crypto/ccree/cc_aead.c

801

mlli_addr = areq_ctx->dst.sram_addr;

drivers/crypto/ccree/cc_aead.c

802

mlli_nents = areq_ctx->dst.mlli_nents;

drivers/crypto/ccree/cc_aead.c

858

set_dout_mlli(&desc[idx], areq_ctx->dst.sram_addr,

drivers/crypto/ccree/cc_aead.c

859

areq_ctx->dst.mlli_nents, NS_BIT, 0);

drivers/crypto/ccree/cc_aead.h

87

struct cc_mlli dst;

drivers/crypto/ccree/cc_buffer_mgr.c

1057

(req->src == req->dst)) {

drivers/crypto/ccree/cc_buffer_mgr.c

1062

(req->src != req->dst ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL),

drivers/crypto/ccree/cc_buffer_mgr.c

1132

dev_dbg(dev, "dst params mn %d\n", areq_ctx->dst.mlli_nents);

drivers/crypto/ccree/cc_buffer_mgr.c

341

struct scatterlist *dst)

drivers/crypto/ccree/cc_buffer_mgr.c

359

if (src != dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

361

dma_unmap_sg(dev, dst, req_ctx->out_nents, DMA_FROM_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

362

dev_dbg(dev, "Unmapped req->dst=%p\n", sg_virt(dst));

drivers/crypto/ccree/cc_buffer_mgr.c

373

struct scatterlist *dst, gfp_t flags)

drivers/crypto/ccree/cc_buffer_mgr.c

382

int src_direction = (src != dst ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL);

drivers/crypto/ccree/cc_buffer_mgr.c

412

if (src == dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

422

rc = cc_map_sg(dev, dst, nbytes, DMA_FROM_DEVICE,

drivers/crypto/ccree/cc_buffer_mgr.c

434

cc_add_sg_entry(dev, &sg_data, req_ctx->out_nents, dst,

drivers/crypto/ccree/cc_buffer_mgr.c

453

cc_unmap_cipher_request(dev, req_ctx, ivsize, src, dst);

drivers/crypto/ccree/cc_buffer_mgr.c

462

int src_direction = (req->src != req->dst ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL);

drivers/crypto/ccree/cc_buffer_mgr.c

522

if (req->src != req->dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

524

sg_virt(req->dst));

drivers/crypto/ccree/cc_buffer_mgr.c

525

dma_unmap_sg(dev, req->dst, areq_ctx->dst.mapped_nents, DMA_FROM_DEVICE);

drivers/crypto/ccree/cc_buffer_mgr.c

529

req->src == req->dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

663

if ((req->src == req->dst) || direct == DRV_CRYPTO_DIRECTION_DECRYPT) {

drivers/crypto/ccree/cc_buffer_mgr.c

687

if (req->src == req->dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

733

cc_add_sg_entry(dev, sg_data, areq_ctx->dst.nents,

drivers/crypto/ccree/cc_buffer_mgr.c

736

&areq_ctx->dst.mlli_nents);

drivers/crypto/ccree/cc_buffer_mgr.c

761

cc_add_sg_entry(dev, sg_data, areq_ctx->dst.nents,

drivers/crypto/ccree/cc_buffer_mgr.c

764

&areq_ctx->dst.mlli_nents);

drivers/crypto/ccree/cc_buffer_mgr.c

771

cc_is_icv_frag(areq_ctx->dst.nents, authsize,

drivers/crypto/ccree/cc_buffer_mgr.c

775

sg = &areq_ctx->dst_sgl[areq_ctx->dst.nents - 1];

drivers/crypto/ccree/cc_buffer_mgr.c

813

areq_ctx->dst_sgl = req->dst;

drivers/crypto/ccree/cc_buffer_mgr.c

840

if (req->src != req->dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

848

rc = cc_map_sg(dev, req->dst, size_for_map, DMA_FROM_DEVICE,

drivers/crypto/ccree/cc_buffer_mgr.c

849

&areq_ctx->dst.mapped_nents,

drivers/crypto/ccree/cc_buffer_mgr.c

856

dst_mapped_nents = cc_get_sgl_nents(dev, req->dst, size_for_map,

drivers/crypto/ccree/cc_buffer_mgr.c

876

areq_ctx->dst.nents = dst_mapped_nents;

drivers/crypto/ccree/cc_buffer_mgr.c

909

if (req->src == req->dst) {

drivers/crypto/ccree/cc_buffer_mgr.c

910

areq_ctx->dst.mlli_nents = areq_ctx->src.mlli_nents;

drivers/crypto/ccree/cc_buffer_mgr.c

913

areq_ctx->dst.sram_addr = areq_ctx->src.sram_addr;

drivers/crypto/ccree/cc_buffer_mgr.c

923

areq_ctx->dst.sram_addr =

drivers/crypto/ccree/cc_buffer_mgr.c

931

areq_ctx->dst.sram_addr =

drivers/crypto/ccree/cc_buffer_mgr.c

935

areq_ctx->dst.sram_addr +

drivers/crypto/ccree/cc_buffer_mgr.c

936

areq_ctx->dst.mlli_nents *

drivers/crypto/ccree/cc_buffer_mgr.c

940

areq_ctx->dst.mlli_nents;

drivers/crypto/ccree/cc_buffer_mgr.c

968

req->src == req->dst)

drivers/crypto/ccree/cc_buffer_mgr.h

47

struct scatterlist *dst, gfp_t flags);

drivers/crypto/ccree/cc_buffer_mgr.h

50

struct scatterlist *src, struct scatterlist *dst);

drivers/crypto/ccree/cc_cipher.c

766

struct scatterlist *dst, struct scatterlist *src,

drivers/crypto/ccree/cc_cipher.c

793

struct scatterlist *dst, struct scatterlist *src,

drivers/crypto/ccree/cc_cipher.c

808

&sg_dma_address(dst), nbytes);

drivers/crypto/ccree/cc_cipher.c

812

set_dout_dlli(&desc[*seq_size], sg_dma_address(dst),

drivers/crypto/ccree/cc_cipher.c

855

struct scatterlist *dst = req->dst;

drivers/crypto/ccree/cc_cipher.c

863

cc_unmap_cipher_request(dev, req_ctx, ivsize, src, dst);

drivers/crypto/ccree/cc_cipher.c

878

struct scatterlist *dst = req->dst;

drivers/crypto/ccree/cc_cipher.c

944

req_ctx->iv, src, dst, flags);

drivers/crypto/ccree/cc_cipher.c

955

cc_setup_mlli_desc(tfm, req_ctx, dst, src, nbytes, req, desc, &seq_len);

drivers/crypto/ccree/cc_cipher.c

961

cc_setup_flow_desc(tfm, req_ctx, dst, src, nbytes, desc, &seq_len);

drivers/crypto/ccree/cc_cipher.c

973

cc_unmap_cipher_request(dev, req_ctx, ivsize, src, dst);

drivers/crypto/ccree/cc_sram_mgr.c

77

void cc_set_sram_desc(const u32 *src, u32 dst, unsigned int nelement,

drivers/crypto/ccree/cc_sram_mgr.c

86

set_dout_sram(&seq[idx], dst + (i * sizeof(u32)), sizeof(u32));

drivers/crypto/ccree/cc_sram_mgr.h

49

void cc_set_sram_desc(const u32 *src, u32 dst, unsigned int nelement,

drivers/crypto/chelsio/chcr_algo.c

1256

dnents = sg_nents_xlen(req->dst, req->cryptlen,

drivers/crypto/chelsio/chcr_algo.c

1270

bytes = chcr_sg_ent_in_wr(req->src, req->dst, 0,

drivers/crypto/chelsio/chcr_algo.c

1311

reqctx->dstsg = req->dst;

drivers/crypto/chelsio/chcr_algo.c

2340

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

drivers/crypto/chelsio/chcr_algo.c

2386

dnents = sg_nents_xlen(req->dst, req->assoclen + req->cryptlen +

drivers/crypto/chelsio/chcr_algo.c

2502

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2522

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2534

error = dma_map_sg(dev, req->dst,

drivers/crypto/chelsio/chcr_algo.c

2535

sg_nents_for_len(req->dst, dst_len),

drivers/crypto/chelsio/chcr_algo.c

2563

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2578

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2586

dma_unmap_sg(dev, req->dst,

drivers/crypto/chelsio/chcr_algo.c

2587

sg_nents_for_len(req->dst, dst_len),

drivers/crypto/chelsio/chcr_algo.c

2636

dsgl_walk_add_sg(&dsgl_walk, req->dst, temp, 0);

drivers/crypto/chelsio/chcr_algo.c

2750

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2760

error = dma_map_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/chelsio/chcr_algo.c

2777

if (req->src == req->dst) {

drivers/crypto/chelsio/chcr_algo.c

2783

dma_unmap_sg(dev, req->dst, sg_nents(req->dst),

drivers/crypto/chelsio/chcr_algo.c

2980

dnents = sg_nents_xlen(req->dst, req->assoclen + req->cryptlen

drivers/crypto/chelsio/chcr_algo.c

3076

dnents = sg_nents_xlen(req->dst, req->assoclen + req->cryptlen +

drivers/crypto/chelsio/chcr_algo.c

608

struct scatterlist *dst,

drivers/crypto/chelsio/chcr_algo.c

622

if (sg_dma_len(dst) == dstskip) {

drivers/crypto/chelsio/chcr_algo.c

623

dst = sg_next(dst);

drivers/crypto/chelsio/chcr_algo.c

627

while (src && dst &&

drivers/crypto/chelsio/chcr_algo.c

634

while (dst && ((dstsg + 1) <= MAX_DSGL_ENT) &&

drivers/crypto/chelsio/chcr_algo.c

638

less = min_t(unsigned int, sg_dma_len(dst) - offset -

drivers/crypto/chelsio/chcr_algo.c

642

if ((offset + dstskip) == sg_dma_len(dst)) {

drivers/crypto/chelsio/chcr_algo.c

643

dst = sg_next(dst);

drivers/crypto/chelsio/chcr_algo.c

671

skcipher_request_set_crypt(&reqctx->fallback_req, req->src, req->dst,

drivers/crypto/exynos-rng.c

141

u8 *dst, unsigned int dlen,

drivers/crypto/exynos-rng.c

165

memcpy_fromio(dst, rng->mem + EXYNOS_RNG_OUT_BASE, *read);

drivers/crypto/exynos-rng.c

196

u8 *dst, unsigned int dlen)

drivers/crypto/exynos-rng.c

209

ret = exynos_rng_get_random(rng, dst, dlen, &read);

drivers/crypto/exynos-rng.c

214

dst += read;

drivers/crypto/gemini/sl3516-ce-cipher.c

118

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/gemini/sl3516-ce-cipher.c

153

if (areq->src == areq->dst) {

drivers/crypto/gemini/sl3516-ce-cipher.c

170

nr_sgd = dma_map_sg(ce->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/gemini/sl3516-ce-cipher.c

203

sg = areq->dst;

drivers/crypto/gemini/sl3516-ce-cipher.c

250

if (areq->src == areq->dst) {

drivers/crypto/gemini/sl3516-ce-cipher.c

256

dma_unmap_sg(ce->dev, areq->dst, sg_nents(areq->dst),

drivers/crypto/gemini/sl3516-ce-cipher.c

48

if (sg_nents(areq->dst) > MAXDESC) {

drivers/crypto/gemini/sl3516-ce-cipher.c

69

sg = areq->dst;

drivers/crypto/gemini/sl3516-ce-cipher.c

88

out_sg = areq->dst;

drivers/crypto/geode-aes.c

285

geode_aes_crypt(tctx, walk.src.virt.addr, walk.dst.virt.addr,

drivers/crypto/geode-aes.c

47

do_crypt(const void *src, void *dst, u32 len, u32 flags)

drivers/crypto/geode-aes.c

53

iowrite32(virt_to_phys(dst), _iobase + AES_DSTA_REG);

drivers/crypto/geode-aes.c

71

void *dst, u32 len, u8 *iv, int mode, int dir)

drivers/crypto/geode-aes.c

99

ret = do_crypt(src, dst, len, flags);

drivers/crypto/hifn_795x.c

1304

struct scatterlist *src, struct scatterlist *dst,

drivers/crypto/hifn_795x.c

1333

BUG_ON(!sg_page(dst));

drivers/crypto/hifn_795x.c

1334

dpage = sg_page(dst);

drivers/crypto/hifn_795x.c

1335

doff = dst->offset;

drivers/crypto/hifn_795x.c

1336

len = dst->length;

drivers/crypto/hifn_795x.c

1342

dst++;

drivers/crypto/hifn_795x.c

1392

static int skcipher_add(unsigned int *drestp, struct scatterlist *dst,

drivers/crypto/hifn_795x.c

1402

copy = min3(drest, size, dst->length);

drivers/crypto/hifn_795x.c

1411

dst++;

drivers/crypto/hifn_795x.c

1424

struct scatterlist *dst, *t;

drivers/crypto/hifn_795x.c

1434

dst = &req->dst[idx];

drivers/crypto/hifn_795x.c

1437

__func__, dst->length, dst->offset, offset, nbytes);

drivers/crypto/hifn_795x.c

1439

if (!IS_ALIGNED(dst->offset, HIFN_D_DST_DALIGN) ||

drivers/crypto/hifn_795x.c

1440

!IS_ALIGNED(dst->length, HIFN_D_DST_DALIGN) ||

drivers/crypto/hifn_795x.c

1442

unsigned slen = min(dst->length - offset, nbytes);

drivers/crypto/hifn_795x.c

1447

err = skcipher_add(&dlen, dst, slen, &nbytes);

drivers/crypto/hifn_795x.c

1484

dst = &req->dst[idx];

drivers/crypto/hifn_795x.c

1486

err = skcipher_add(&dlen, dst, nbytes, &nbytes);

drivers/crypto/hifn_795x.c

1496

nbytes -= min(dst->length, nbytes);

drivers/crypto/hifn_795x.c

1514

struct scatterlist *dst;

drivers/crypto/hifn_795x.c

1522

dst = &req->dst[idx];

drivers/crypto/hifn_795x.c

1523

dlen = min(dst->length, nbytes);

drivers/crypto/hifn_795x.c

1525

if (!IS_ALIGNED(dst->offset, HIFN_D_DST_DALIGN) ||

drivers/crypto/hifn_795x.c

1551

err = hifn_setup_dma(dev, ctx, rctx, req->src, req->dst, req->cryptlen, req);

drivers/crypto/hifn_795x.c

1599

struct scatterlist *dst, unsigned int size, unsigned int *nbytesp)

drivers/crypto/hifn_795x.c

1609

copy = min3(srest, dst->length, size);

drivers/crypto/hifn_795x.c

1611

daddr = kmap_atomic(sg_page(dst));

drivers/crypto/hifn_795x.c

1612

memcpy(daddr + dst->offset + offset, saddr, copy);

drivers/crypto/hifn_795x.c

1624

dst++;

drivers/crypto/hifn_795x.c

1655

struct scatterlist *dst, *t;

drivers/crypto/hifn_795x.c

1660

dst = &req->dst[idx];

drivers/crypto/hifn_795x.c

1666

sg_page(dst), dst->length, nbytes);

drivers/crypto/hifn_795x.c

1669

nbytes -= min(dst->length, nbytes);

drivers/crypto/hifn_795x.c

1677

dst, nbytes, &nbytes);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

130

char *dst;

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1400

struct scatterlist *dst,

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1418

if (req->dst)

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1419

dma_free_coherent(dev, ctx->key_sz << 1, req->dst, dma);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1420

if (dst)

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1443

hpre_ecdh_hw_data_clr_all(ctx, req, areq->dst, areq->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1445

p = sg_virt(areq->dst);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1528

hpre_req->dst = NULL;

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1565

ret = hpre_ecdh_dst_data_init(hpre_req, req->dst, req->dst_len);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

1579

hpre_ecdh_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

173

hpre_req->dst = NULL;

drivers/crypto/hisilicon/hpre/hpre_crypto.c

206

hpre_req->dst = ptr;

drivers/crypto/hisilicon/hpre/hpre_crypto.c

241

struct scatterlist *dst,

drivers/crypto/hisilicon/hpre/hpre_crypto.c

263

if (req->dst) {

drivers/crypto/hisilicon/hpre/hpre_crypto.c

264

if (dst)

drivers/crypto/hisilicon/hpre/hpre_crypto.c

265

scatterwalk_map_and_copy(req->dst, dst, 0,

drivers/crypto/hisilicon/hpre/hpre_crypto.c

267

dma_free_coherent(dev, ctx->key_sz, req->dst, tmp);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

342

hpre_hw_data_clr_all(ctx, req, areq->dst, areq->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

363

hpre_hw_data_clr_all(ctx, req, areq->dst, areq->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

497

ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 1);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

512

hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

526

kpp_request_set_output(fb_req, req->dst, req->dst_len);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

780

ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 0);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

790

hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

833

ret = hpre_hw_data_init(hpre_req, req->dst, req->dst_len, 0, 0);

drivers/crypto/hisilicon/hpre/hpre_crypto.c

843

hpre_hw_data_clr_all(ctx, hpre_req, req->dst, req->src);

drivers/crypto/hisilicon/sec/sec_algs.c

534

if (skreq->src != skreq->dst)

drivers/crypto/hisilicon/sec/sec_algs.c

535

dma_unmap_sg(dev, skreq->dst, sec_req->len_out,

drivers/crypto/hisilicon/sec/sec_algs.c

723

bool split = skreq->src != skreq->dst;

drivers/crypto/hisilicon/sec/sec_algs.c

744

sec_req->len_out = sg_nents(skreq->dst);

drivers/crypto/hisilicon/sec/sec_algs.c

745

ret = sec_map_and_split_sg(skreq->dst, split_sizes, steps,

drivers/crypto/hisilicon/sec/sec_algs.c

776

skreq->src != skreq->dst,

drivers/crypto/hisilicon/sec/sec_algs.c

850

sec_unmap_sg_on_err(skreq->dst, steps, splits_out,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1014

struct scatterlist *dst)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1029

pbuf_length = sg_copy_from_buffer(dst, sg_nents(dst), buf->pbuf, copy_size);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1031

pbuf_length = sg_copy_from_buffer(dst, sg_nents(dst), qp_ctx->res[req_id].pbuf,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1112

struct scatterlist *src, struct scatterlist *dst)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1118

if (dst == src) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

1129

ret = sec_cipher_to_hw_sgl(dev, dst, dst_out, &req->buf.out_dma,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1140

struct scatterlist *src, struct scatterlist *dst)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1172

src_direction = dst == src ? DMA_BIDIRECTIONAL : DMA_TO_DEVICE;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1191

if (dst == src) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

1195

c_req->c_out = hisi_acc_sg_buf_map_to_hw_sgl(dev, dst,

drivers/crypto/hisilicon/sec2/sec_crypto.c

1212

struct scatterlist *src, struct scatterlist *dst)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1221

return sec_cipher_map_inner(ctx, req, src, dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1258

ret = sec_cipher_map_sgl(dev, req, src, dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1278

struct scatterlist *src, struct scatterlist *dst)

drivers/crypto/hisilicon/sec2/sec_crypto.c

1286

sec_cipher_pbuf_unmap(ctx, req, dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1288

if (dst != src) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

1289

hisi_acc_sg_buf_unmap(dev, dst, c_req->c_out, DMA_FROM_DEVICE);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1299

sec_cipher_pbuf_unmap(ctx, req, dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1301

if (dst != src) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

1302

sec_cipher_put_hw_sgl(dev, dst, req->buf.out_dma, DMA_FROM_DEVICE);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1320

return sec_cipher_map(ctx, req, sq->src, sq->dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1327

sec_cipher_unmap(ctx, req, sq->src, sq->dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1476

return sec_cipher_map(ctx, req, aq->src, aq->dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1483

sec_cipher_unmap(ctx, req, aq->src, aq->dst);

drivers/crypto/hisilicon/sec2/sec_crypto.c

1653

sgl = req->c_req.encrypt ? sk_req->dst : sk_req->src;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1657

sgl = req->c_req.encrypt ? aead_req->dst : aead_req->src;

drivers/crypto/hisilicon/sec2/sec_crypto.c

1933

sz = sg_pcopy_from_buffer(a_req->dst, sg_nents(a_req->dst), req->aead_req.out_mac,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2265

if (unlikely(!sk_req->src || !sk_req->dst)) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

2313

skcipher_request_set_crypt(subreq, sreq->src, sreq->dst,

drivers/crypto/hisilicon/sec2/sec_crypto.c

2498

if (unlikely(!req->src || !req->dst)) {

drivers/crypto/hisilicon/sec2/sec_crypto.c

2544

aead_request_set_crypt(subreq, aead_req->src, aead_req->dst,

drivers/crypto/hisilicon/zip/zip_crypto.c

261

if (unlikely(!a_req->src || !a_req->slen || !a_req->dst || !a_req->dlen))

drivers/crypto/hisilicon/zip/zip_crypto.c

273

req->hw_dst = hisi_acc_sg_buf_map_to_hw_sgl(dev, a_req->dst, pool,

drivers/crypto/hisilicon/zip/zip_crypto.c

298

hisi_acc_sg_buf_unmap(dev, a_req->dst, req->hw_dst, DMA_FROM_DEVICE);

drivers/crypto/hisilicon/zip/zip_crypto.c

336

hisi_acc_sg_buf_unmap(dev, acomp_req->dst, req->hw_dst, DMA_FROM_DEVICE);

drivers/crypto/inside-secure/eip93/eip93-aead.c

205

rctx->sg_dst = req->dst;

drivers/crypto/inside-secure/eip93/eip93-aead.c

37

eip93_unmap_dma(eip93, rctx, req->src, req->dst);

drivers/crypto/inside-secure/eip93/eip93-cipher.c

166

rctx->sg_dst = req->dst;

drivers/crypto/inside-secure/eip93/eip93-cipher.c

27

eip93_unmap_dma(eip93, rctx, req->src, req->dst);

drivers/crypto/inside-secure/eip93/eip93-common.c

150

static int eip93_make_sg_copy(struct scatterlist *src, struct scatterlist **dst,

drivers/crypto/inside-secure/eip93/eip93-common.c

155

*dst = kmalloc_obj(**dst);

drivers/crypto/inside-secure/eip93/eip93-common.c

156

if (!*dst)

drivers/crypto/inside-secure/eip93/eip93-common.c

162

kfree(*dst);

drivers/crypto/inside-secure/eip93/eip93-common.c

163

*dst = NULL;

drivers/crypto/inside-secure/eip93/eip93-common.c

167

sg_init_table(*dst, 1);

drivers/crypto/inside-secure/eip93/eip93-common.c

168

sg_set_buf(*dst, pages, len);

drivers/crypto/inside-secure/eip93/eip93-common.c

204

struct scatterlist *dst = rctx->sg_dst;

drivers/crypto/inside-secure/eip93/eip93-common.c

231

dst_nents = sg_nents_for_len(dst, totlen_dst);

drivers/crypto/inside-secure/eip93/eip93-common.c

235

if (src == dst) {

drivers/crypto/inside-secure/eip93/eip93-common.c

252

if (src == dst)

drivers/crypto/inside-secure/eip93/eip93-common.c

255

dst_align = eip93_is_sg_aligned(dst, totlen_dst, blksize);

drivers/crypto/inside-secure/eip93/eip93-common.c

262

if (src == dst)

drivers/crypto/inside-secure/eip93/eip93-common.c

265

dst_align = eip93_is_sg_aligned(dst, totlen_dst, blksize);

drivers/crypto/inside-secure/eip93/eip93-common.c

276

err = eip93_make_sg_copy(dst, &rctx->sg_dst, copy_len, false);

drivers/crypto/inside-secure/eip93/eip93-common.c

517

struct scatterlist *dst = rctx->sg_dst;

drivers/crypto/inside-secure/eip93/eip93-common.c

608

if (!dma_map_sg(eip93->dev, dst, rctx->dst_nents, DMA_BIDIRECTIONAL)) {

drivers/crypto/inside-secure/eip93/eip93-common.c

613

if (src != dst &&

drivers/crypto/inside-secure/eip93/eip93-common.c

622

dma_unmap_sg(eip93->dev, dst, rctx->dst_nents, DMA_BIDIRECTIONAL);

drivers/crypto/inside-secure/safexcel_cipher.c

1014

req->dst,

drivers/crypto/inside-secure/safexcel_cipher.c

1063

req->dst, req->cryptlen, 0, 0, input_iv,

drivers/crypto/inside-secure/safexcel_cipher.c

1086

ret = safexcel_send_req(async, ring, sreq, req->src, req->dst,

drivers/crypto/inside-secure/safexcel_cipher.c

2863

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

drivers/crypto/inside-secure/safexcel_cipher.c

3256

aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,

drivers/crypto/inside-secure/safexcel_cipher.c

610

struct scatterlist *dst,

drivers/crypto/inside-secure/safexcel_cipher.c

643

if (src == dst) {

drivers/crypto/inside-secure/safexcel_cipher.c

652

dma_unmap_sg(priv->dev, dst, sreq->nr_dst,

drivers/crypto/inside-secure/safexcel_cipher.c

662

sg_pcopy_to_buffer(dst, sreq->nr_dst, areq->iv,

drivers/crypto/inside-secure/safexcel_cipher.c

675

struct scatterlist *src, struct scatterlist *dst,

drivers/crypto/inside-secure/safexcel_cipher.c

727

sreq->nr_dst = sg_nents_for_len(dst, totlen_dst);

drivers/crypto/inside-secure/safexcel_cipher.c

736

if (src == dst) {

drivers/crypto/inside-secure/safexcel_cipher.c

767

!dma_map_sg(priv->dev, dst, sreq->nr_dst, DMA_FROM_DEVICE)) {

drivers/crypto/inside-secure/safexcel_cipher.c

832

for_each_sg(dst, sg, sreq->nr_dst, i) {

drivers/crypto/inside-secure/safexcel_cipher.c

901

if (src == dst) {

drivers/crypto/inside-secure/safexcel_cipher.c

910

dma_unmap_sg(priv->dev, dst, sreq->nr_dst,

drivers/crypto/inside-secure/safexcel_cipher.c

991

req->dst, req->cryptlen, sreq,

drivers/crypto/intel/iaa/iaa_crypto_main.c

1091

dma_unmap_sg(dev, ctx->req->dst, sg_nents(ctx->req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1097

dma_unmap_sg(dev, ctx->req->dst, sg_nents(ctx->req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1229

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1245

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1254

*dst_addr = sg_dma_address(req->dst);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1257

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1523

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1531

dst_addr = sg_dma_address(req->dst);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1534

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1553

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_TO_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1562

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1621

nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1629

dst_addr = sg_dma_address(req->dst);

drivers/crypto/intel/iaa/iaa_crypto_main.c

1632

req->dst, req->dlen, sg_dma_len(req->dst));

drivers/crypto/intel/iaa/iaa_crypto_main.c

1642

dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1021

if (req->src != req->dst) {

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1027

req_ctx->dst = NULL;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1028

if (!chainup_buffers(dev, req->dst, nbytes, &dst_hook,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1032

req_ctx->dst = dst_hook.next;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1035

req_ctx->dst = NULL;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1052

if (req->src != req->dst)

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1053

free_buf_chain(dev, req_ctx->dst, crypt->dst_buf);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1152

req_ctx->dst = NULL;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1154

if (req->src != req->dst) {

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1160

buf = chainup_buffers(dev, req->dst, crypt->auth_len,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1162

req_ctx->dst = dst_hook.next;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

1199

free_buf_chain(dev, req_ctx->dst, crypt->dst_buf);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

151

struct buffer_desc *dst;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

159

struct buffer_desc *dst;

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

360

scatterwalk_map_and_copy(req_ctx->hmac_virt, req->dst,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

383

free_buf_chain(dev, req_ctx->dst, crypt->dst_buf);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

400

scatterwalk_map_and_copy(req->iv, req->dst,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

408

if (req_ctx->dst)

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

409

free_buf_chain(dev, req_ctx->dst, crypt->dst_buf);

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

967

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/intel/ixp4xx/ixp4xx_crypto.c

992

if (sg_nents(req->src) > 1 || sg_nents(req->dst) > 1)

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

325

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

387

dma_unmap_sg(dev, req->dst, rctx->dst_nents, rctx->in_place ?

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

419

sg_swap_blocks(req->dst, rctx->dst_nents,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

424

rctx->dst_dma_count = dma_map_sg(tctx->aes_dev->dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

432

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

474

rctx->dst_dma_count = dma_map_sg(tctx->aes_dev->dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

482

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

523

rctx->dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

539

rctx->in_place = (req->src == req->dst);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

560

sg_swap_blocks(req->dst, rctx->dst_nents,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

570

scatterwalk_map_and_copy(req->iv, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

651

aead_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

694

dma_unmap_sg(dev, req->dst, rctx->dst_nents, rctx->in_place ?

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

783

rctx->dst_nents = sg_nents_for_len(req->dst, dst_size);

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

787

rctx->in_place = (req->src == req->dst) ? 1 : 0;

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

790

rctx->dst_dma_count = dma_map_sg(tctx->aes_dev->dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

800

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

808

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

833

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

839

rc = ocs_create_linked_list_from_sg(tctx->aes_dev, req->dst,

drivers/crypto/intel/keembay/keembay-ocs-aes-core.c

933

sg_pcopy_from_buffer(req->dst, rctx->dst_nents, rctx->out_tag,

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

639

copied = sg_copy_from_buffer(req->dst,

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

640

sg_nents_for_len(req->dst, nbytes),

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

692

copied = sg_copy_from_buffer(req->dst,

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

693

sg_nents_for_len(req->dst, pubk_len),

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

733

if (!req->dst)

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

758

if (!req->dst)

drivers/crypto/intel/qat/qat_common/adf_gen4_vf_mig.c

255

u64 src = 0, dst = 0;

drivers/crypto/intel/qat/qat_common/adf_gen4_vf_mig.c

264

memcpy(&dst, dinfo->addr, dinfo->size);

drivers/crypto/intel/qat/qat_common/adf_gen4_vf_mig.c

266

pr_debug("QAT: Check cap compatibility of cap %llu %llu\n", src, dst);

drivers/crypto/intel/qat/qat_common/adf_gen4_vf_mig.c

268

if (src == dst)

drivers/crypto/intel/qat/qat_common/adf_gen4_vf_mig.c

271

if ((src | dst) == dst)

drivers/crypto/intel/qat/qat_common/adf_telemetry.c

145

void *dst = telemetry->regs_hist_buff[telemetry->hb_num];

drivers/crypto/intel/qat/qat_common/adf_telemetry.c

148

memcpy(dst, src, size);

drivers/crypto/intel/qat/qat_common/qat_algs.c

1022

ret = qat_bl_sgl_to_bufl(ctx->inst->accel_dev, req->src, req->dst,

drivers/crypto/intel/qat/qat_common/qat_algs.c

633

sgl = sreq->dst;

drivers/crypto/intel/qat/qat_common/qat_algs.c

725

ret = qat_bl_sgl_to_bufl(ctx->inst->accel_dev, areq->src, areq->dst,

drivers/crypto/intel/qat/qat_common/qat_algs.c

769

ret = qat_bl_sgl_to_bufl(ctx->inst->accel_dev, areq->src, areq->dst,

drivers/crypto/intel/qat/qat_common/qat_algs.c

955

ret = qat_bl_sgl_to_bufl(ctx->inst->accel_dev, req->src, req->dst,

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

178

scatterwalk_map_and_copy(req->dst_align, areq->dst, 0,

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

318

if (sg_is_last(req->dst) && req->dst_len == ctx->p_size) {

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

320

vaddr = sg_virt(req->dst);

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

585

scatterwalk_map_and_copy(req->dst_align, areq->dst, 0,

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

768

if (sg_is_last(req->dst) && req->dst_len == ctx->key_sz) {

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

770

vaddr = sg_virt(req->dst);

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

912

if (sg_is_last(req->dst) && req->dst_len == ctx->key_sz) {

drivers/crypto/intel/qat/qat_common/qat_asym_algs.c

914

vaddr = sg_virt(req->dst);

drivers/crypto/intel/qat/qat_common/qat_comp_algs.c

185

if (!areq->dst || !dlen)

drivers/crypto/intel/qat/qat_common/qat_comp_algs.c

194

ret = qat_bl_sgl_to_bufl(ctx->inst->accel_dev, areq->src, areq->dst,

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

12

u64 dst, u32 dlen, u64 opaque)

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

21

fw_req->comn_mid.dest_data_addr = dst;

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

30

u64 dst, u32 dlen,

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

33

qat_comp_create_req(ctx, req, src, slen, dst, dlen, opaque);

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

38

u64 dst, u32 dlen,

drivers/crypto/intel/qat/qat_common/qat_comp_req.h

44

qat_comp_create_req(fw_tmpl, req, src, slen, dst, dlen, opaque);

drivers/crypto/marvell/cesa/cesa.h

306

__le32 dst;

drivers/crypto/marvell/cesa/cesa.h

866

dma_addr_t dst, dma_addr_t src, u32 size,

drivers/crypto/marvell/cesa/cipher.c

134

len = mv_cesa_sg_copy_from_sram(engine, req->dst, creq->dst_nents,

drivers/crypto/marvell/cesa/cipher.c

328

if (req->src != req->dst) {

drivers/crypto/marvell/cesa/cipher.c

334

ret = dma_map_sg(cesa_dev->dev, req->dst, creq->dst_nents,

drivers/crypto/marvell/cesa/cipher.c

37

struct mv_cesa_sg_dma_iter dst;

drivers/crypto/marvell/cesa/cipher.c

376

&iter.dst, flags);

drivers/crypto/marvell/cesa/cipher.c

397

if (req->dst != req->src)

drivers/crypto/marvell/cesa/cipher.c

398

dma_unmap_sg(cesa_dev->dev, req->dst, creq->dst_nents,

drivers/crypto/marvell/cesa/cipher.c

403

req->dst != req->src ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL);

drivers/crypto/marvell/cesa/cipher.c

440

creq->dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/marvell/cesa/cipher.c

46

mv_cesa_sg_dma_iter_init(&iter->dst, req->dst, DMA_FROM_DEVICE);

drivers/crypto/marvell/cesa/cipher.c

53

iter->dst.op_offset = 0;

drivers/crypto/marvell/cesa/cipher.c

63

if (req->dst != req->src) {

drivers/crypto/marvell/cesa/cipher.c

64

dma_unmap_sg(cesa_dev->dev, req->dst, creq->dst_nents,

drivers/crypto/marvell/cesa/tdma.c

293

dma_addr_t dst, dma_addr_t src, u32 size,

drivers/crypto/marvell/cesa/tdma.c

304

tdma->dst_dma = dst;

drivers/crypto/marvell/cesa/tdma.c

343

dma_addr_t dst, src;

drivers/crypto/marvell/cesa/tdma.c

348

dst = CESA_SA_DATA_SRAM_OFFSET + sgiter->op_offset;

drivers/crypto/marvell/cesa/tdma.c

351

dst = sg_dma_address(sgiter->sg) + sgiter->offset;

drivers/crypto/marvell/cesa/tdma.c

355

ret = mv_cesa_dma_add_data_transfer(chain, dst, src, len,

drivers/crypto/marvell/cesa/tdma.c

95

tdma->dst = cpu_to_le32(tdma->dst_dma + engine->sram_dma);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1025

update_output_data(req_info, req->dst, 0, outputlen, &argcnt);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1055

struct scatterlist *dst;

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1069

if (req->src != req->dst) {

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1085

status = sg_copy_from_buffer(req->dst, sg_nents(req->dst), ptr,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1099

dst = req->dst;

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1101

while (offset >= dst->length) {

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1102

offset -= dst->length;

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1103

dst = sg_next(dst);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1104

if (!dst) {

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

1110

update_output_data(req_info, dst, offset, mac_len, &argcnt);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

165

scatterwalk_map_and_copy(sreq->iv, sreq->dst, start,

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

168

if (sreq->src != sreq->dst) {

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

259

req->src == req->dst) {

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

337

update_output_data(req_info, req->dst, 0, req->cryptlen, &argcnt);

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

711

__be64 *dst = buf;

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

715

for (i = 0 ; i < len / 8; i++, src++, dst++)

drivers/crypto/marvell/octeontx/otx_cptvf_algs.c

716

*dst = cpu_to_be64p(src);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1112

update_output_data(req_info, req->dst, 0, outputlen, &argcnt);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1138

struct scatterlist *dst;

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1152

if (req->src != req->dst) {

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1166

status = sg_copy_from_buffer(req->dst, sg_nents(req->dst), ptr,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1180

dst = req->dst;

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1182

while (offset >= dst->length) {

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1183

offset -= dst->length;

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1184

dst = sg_next(dst);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1185

if (!dst)

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1189

update_output_data(req_info, dst, offset, mac_len, &argcnt);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

1227

req->dst, req->cryptlen, req->iv);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

148

scatterwalk_map_and_copy(sreq->iv, sreq->dst, start,

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

151

if (sreq->src != sreq->dst) {

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

245

req->src == req->dst) {

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

323

update_output_data(req_info, req->dst, 0, req->cryptlen, &argcnt);

drivers/crypto/marvell/octeontx2/otx2_cptvf_algs.c

341

req->dst, req->cryptlen, req->iv);

drivers/crypto/mxs-dcp.c

321

struct scatterlist *dst = req->dst;

drivers/crypto/mxs-dcp.c

323

int dst_nents = sg_nents(dst);

drivers/crypto/mxs-dcp.c

385

sg_pcopy_from_buffer(dst, dst_nents, out_buf,

drivers/crypto/mxs-dcp.c

457

skcipher_request_set_crypt(&rctx->fallback_req, req->src, req->dst,

drivers/crypto/nx/nx-842.c

172

u8 *src = p->in, *dst = p->out;

drivers/crypto/nx/nx-842.c

199

dst += hdrsize;

drivers/crypto/nx/nx-842.c

202

if ((u64)dst % c->alignment) {

drivers/crypto/nx/nx-842.c

203

dskip = (int)(PTR_ALIGN(dst, c->alignment) - dst);

drivers/crypto/nx/nx-842.c

204

dst += dskip;

drivers/crypto/nx/nx-842.c

211

dst = ctx->dbounce;

drivers/crypto/nx/nx-842.c

224

ret = ctx->driver->compress(src, slen, dst, &dlen, ctx->wmem);

drivers/crypto/nx/nx-842.c

228

if (ret == -ENOSPC && dst != ctx->dbounce)

drivers/crypto/nx/nx-842.c

236

if (dst == ctx->dbounce)

drivers/crypto/nx/nx-842.c

237

memcpy(p->out + dskip, dst, dlen);

drivers/crypto/nx/nx-842.c

256

u8 *dst, unsigned int *dlen, void *pctx)

drivers/crypto/nx/nx-842.c

273

p.out = dst;

drivers/crypto/nx/nx-842.c

328

ret = nx842_crypto_add_header(hdr, dst);

drivers/crypto/nx/nx-842.c

352

u8 *src = p->in, *dst = p->out;

drivers/crypto/nx/nx-842.c

390

if (dlen < required_len || (u64)dst % c->alignment) {

drivers/crypto/nx/nx-842.c

391

dst = ctx->dbounce;

drivers/crypto/nx/nx-842.c

404

ret = ctx->driver->decompress(src, slen, dst, &dlen, ctx->wmem);

drivers/crypto/nx/nx-842.c

412

dst = p->out;

drivers/crypto/nx/nx-842.c

415

dst = ctx->dbounce;

drivers/crypto/nx/nx-842.c

419

ret = sw842_decompress(src, slen, dst, &dlen);

drivers/crypto/nx/nx-842.c

430

if (dst == ctx->dbounce)

drivers/crypto/nx/nx-842.c

431

memcpy(p->out, dst, dlen);

drivers/crypto/nx/nx-842.c

441

u8 *dst, unsigned int *dlen, void *pctx)

drivers/crypto/nx/nx-842.c

454

p.out = dst;

drivers/crypto/nx/nx-842.h

190

u8 *dst, unsigned int *dlen, void *ctx);

drivers/crypto/nx/nx-842.h

193

u8 *dst, unsigned int *dlen, void *ctx);

drivers/crypto/nx/nx-aes-cbc.c

75

rc = nx_build_sg_lists(nx_ctx, req->iv, req->dst, req->src,

drivers/crypto/nx/nx-aes-ccm.c

364

rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,

drivers/crypto/nx/nx-aes-ccm.c

433

rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,

drivers/crypto/nx/nx-aes-ccm.c

465

memcpy_to_sglist(req->dst, nbytes + req->assoclen,

drivers/crypto/nx/nx-aes-ctr.c

88

rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,

drivers/crypto/nx/nx-aes-ecb.c

75

rc = nx_build_sg_lists(nx_ctx, NULL, req->dst, req->src,

drivers/crypto/nx/nx-aes-gcm.c

354

rc = nx_build_sg_lists(nx_ctx, rctx->iv, req->dst,

drivers/crypto/nx/nx-aes-gcm.c

392

req->dst, req->assoclen + nbytes,

drivers/crypto/nx/nx.c

237

struct scatterlist *dst,

drivers/crypto/nx/nx.c

259

nx_outsg = nx_walk_and_build(nx_outsg, max_sg_len, dst,

drivers/crypto/nx/nx.h

165

struct scatterlist *dst, struct scatterlist *src,

drivers/crypto/omap-aes-gcm.c

152

dd->out_sg = req->dst;

drivers/crypto/omap-aes-gcm.c

153

dd->orig_out = req->dst;

drivers/crypto/omap-aes-gcm.c

155

dd->out_sg = scatterwalk_ffwd(sg_arr, req->dst, req->assoclen);

drivers/crypto/omap-aes-gcm.c

158

if (req->src == req->dst || dd->out_sg == sg_arr)

drivers/crypto/omap-aes-gcm.c

259

scatterwalk_map_and_copy(rctx->auth_tag, req->dst, 0, authlen,

drivers/crypto/omap-aes-gcm.c

68

dd->aead_req->dst,

drivers/crypto/omap-aes.c

441

dd->out_sg = req->dst;

drivers/crypto/omap-aes.c

442

dd->orig_out = req->dst;

drivers/crypto/omap-aes.c

445

if (req->src == req->dst)

drivers/crypto/omap-aes.c

551

req->dst, req->cryptlen, req->iv);

drivers/crypto/omap-aes.c

866

u32 *src, *dst;

drivers/crypto/omap-aes.c

906

dst = sg_virt(dd->out_sg) + dd->out_sg_offset;

drivers/crypto/omap-aes.c

909

*dst = omap_aes_read(dd, AES_REG_DATA_N(dd, i));

drivers/crypto/omap-aes.c

915

dst = sg_virt(dd->out_sg);

drivers/crypto/omap-aes.c

918

dst++;

drivers/crypto/omap-crypto.c

158

struct scatterlist *dst,

drivers/crypto/omap-crypto.c

165

while (src && dst && len) {

drivers/crypto/omap-crypto.c

172

if (dsto >= dst->length) {

drivers/crypto/omap-crypto.c

173

dsto -= dst->length;

drivers/crypto/omap-crypto.c

174

dst = sg_next(dst);

drivers/crypto/omap-crypto.c

178

amt = min(src->length - srco, dst->length - dsto);

drivers/crypto/omap-crypto.c

182

dstb = kmap_atomic(sg_page(dst)) + dsto + dst->offset;

drivers/crypto/omap-crypto.c

186

flush_dcache_page(sg_page(dst));

drivers/crypto/omap-des.c

531

dd->out_sg = req->dst;

drivers/crypto/omap-des.c

532

dd->orig_out = req->dst;

drivers/crypto/omap-des.c

535

if (req->src == req->dst)

drivers/crypto/omap-des.c

828

u32 *src, *dst;

drivers/crypto/omap-des.c

868

dst = sg_virt(dd->out_sg) + dd->out_sg_offset;

drivers/crypto/omap-des.c

871

*dst = omap_des_read(dd, DES_REG_DATA_N(dd, i));

drivers/crypto/omap-des.c

877

dst = sg_virt(dd->out_sg);

drivers/crypto/omap-des.c

880

dst++;

drivers/crypto/padlock-aes.c

357

padlock_xcrypt_ecb(walk.src.virt.addr, walk.dst.virt.addr,

drivers/crypto/padlock-aes.c

382

padlock_xcrypt_ecb(walk.src.virt.addr, walk.dst.virt.addr,

drivers/crypto/padlock-aes.c

423

walk.dst.virt.addr, ctx->E,

drivers/crypto/padlock-aes.c

449

padlock_xcrypt_cbc(walk.src.virt.addr, walk.dst.virt.addr,

drivers/crypto/padlock-sha.c

96

uint32_t *dst, size_t count)

drivers/crypto/padlock-sha.c

99

*dst++ = swab32(*src++);

drivers/crypto/qce/aead.c

125

rctx->dst_nents = sg_nents_for_len(req->dst, totallen);

drivers/crypto/qce/aead.c

143

msg_sg = scatterwalk_ffwd(__sg, req->dst, assoclen);

drivers/crypto/qce/aead.c

160

sg = qce_sgtable_add(&rctx->dst_tbl, req->dst, totallen);

drivers/crypto/qce/aead.c

236

diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/aead.c

307

bool diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/aead.c

335

bool diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/aead.c

40

diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/aead.c

436

diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/aead.c

533

req->dst, req->cryptlen, req->iv);

drivers/crypto/qce/aead.c

73

scatterwalk_map_and_copy(rctx->ccmresult_buf, req->dst,

drivers/crypto/qce/aead.c

76

scatterwalk_map_and_copy(result_buf->auth_iv, req->dst,

drivers/crypto/qce/common.c

281

static void qce_xts_swapiv(__be32 *dst, const u8 *src, unsigned int ivsize)

drivers/crypto/qce/common.c

295

qce_cpu_to_be32p_array(dst, swap, QCE_AES_IV_LENGTH);

drivers/crypto/qce/common.c

405

static unsigned int qce_be32_to_cpu_array(u32 *dst, const u8 *src, unsigned int len)

drivers/crypto/qce/common.c

407

u32 *d = dst;

drivers/crypto/qce/common.c

67

void qce_cpu_to_be32p_array(__be32 *dst, const u8 *src, unsigned int len)

drivers/crypto/qce/common.c

69

__be32 *d = dst;

drivers/crypto/qce/common.h

99

void qce_cpu_to_be32p_array(__be32 *dst, const u8 *src, unsigned int len);

drivers/crypto/qce/skcipher.c

110

sg = qce_sgtable_add(&rctx->dst_tbl, req->dst, req->cryptlen);

drivers/crypto/qce/skcipher.c

301

req->dst, req->cryptlen, req->iv);

drivers/crypto/qce/skcipher.c

40

diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/skcipher.c

81

diff_dst = (req->src != req->dst) ? true : false;

drivers/crypto/qce/skcipher.c

87

rctx->dst_nents = sg_nents_for_len(req->dst, req->cryptlen);

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

333

sgd = areq->dst;

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

37

sgd = req->dst;

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

409

scatterwalk_map_and_copy(areq->iv, areq->dst, offset,

drivers/crypto/rockchip/rk3288_crypto_skcipher.c

82

skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,

drivers/crypto/s5p-sss.c

1853

sg = req->dst;

drivers/crypto/s5p-sss.c

468

memcpy_to_sglist(dev->req->dst, 0, sg_virt(dev->sg_dst_cpy),

drivers/crypto/s5p-sss.c

497

struct scatterlist **dst)

drivers/crypto/s5p-sss.c

502

*dst = kmalloc_obj(**dst, GFP_ATOMIC);

drivers/crypto/s5p-sss.c

503

if (!*dst)

drivers/crypto/s5p-sss.c

509

kfree(*dst);

drivers/crypto/s5p-sss.c

510

*dst = NULL;

drivers/crypto/s5p-sss.c

516

sg_init_table(*dst, 1);

drivers/crypto/s5p-sss.c

517

sg_set_buf(*dst, pages, len);

drivers/crypto/sa2ul.c

1089

struct scatterlist *src, *dst;

drivers/crypto/sa2ul.c

1106

if (req->src != req->dst) {

drivers/crypto/sa2ul.c

1200

dst = src;

drivers/crypto/sa2ul.c

1202

dst_nents = sg_nents_for_len(req->dst, req->size);

drivers/crypto/sa2ul.c

1205

if (dst_nents == 1 && split_size <= req->dst->length) {

drivers/crypto/sa2ul.c

1206

dst = &mapped_sg->static_sg;

drivers/crypto/sa2ul.c

1208

sg_init_table(dst, 1);

drivers/crypto/sa2ul.c

1209

sg_set_page(dst, sg_page(req->dst), split_size,

drivers/crypto/sa2ul.c

1210

req->dst->offset);

drivers/crypto/sa2ul.c

1212

mapped_sg->sgt.sgl = dst;

drivers/crypto/sa2ul.c

1222

mapped_sg->sgt.sgl = req->dst;

drivers/crypto/sa2ul.c

1233

0, 1, &split_size, &dst, &dst_nents,

drivers/crypto/sa2ul.c

1237

dst = mapped_sg->sgt.sgl;

drivers/crypto/sa2ul.c

1239

mapped_sg->split_sg = dst;

drivers/crypto/sa2ul.c

1244

rxd->tx_in = dmaengine_prep_slave_sg(dma_rx, dst, dst_nents,

drivers/crypto/sa2ul.c

1320

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/sa2ul.c

1331

sa_req.dst = req->dst;

drivers/crypto/sa2ul.c

1432

sa_req.dst = req->src;

drivers/crypto/sa2ul.c

1684

scatterwalk_map_and_copy(&mdptr[4], req->dst, start, authsize,

drivers/crypto/sa2ul.c

1902

aead_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/sa2ul.c

1923

sa_req.dst = req->dst;

drivers/crypto/sa2ul.c

235

struct scatterlist *dst;

drivers/crypto/sahara.c

548

sg_pcopy_to_buffer(req->dst, sg_nents(req->dst), req->iv,

drivers/crypto/sahara.c

567

req->cryptlen, req->src, req->dst);

drivers/crypto/sahara.c

572

dev->out_sg = req->dst;

drivers/crypto/sahara.c

656

req->dst, req->cryptlen, req->iv);

drivers/crypto/starfive/jh7110-aes.c

439

struct scatterlist *dst,

drivers/crypto/starfive/jh7110-aes.c

452

out_save = sg_dma_len(dst);

drivers/crypto/starfive/jh7110-aes.c

458

sg_dma_len(dst) = ALIGN(len, AES_BLOCK_SIZE);

drivers/crypto/starfive/jh7110-aes.c

460

out_desc = dmaengine_prep_slave_sg(cryp->rx, dst, 1, DMA_DEV_TO_MEM,

drivers/crypto/starfive/jh7110-aes.c

490

sg_dma_len(dst) = out_save;

drivers/crypto/starfive/jh7110-aes.c

501

struct scatterlist *dst)

drivers/crypto/starfive/jh7110-aes.c

509

if (src == dst) {

drivers/crypto/starfive/jh7110-aes.c

510

for (stsg = src, dtsg = dst; remain > 0;

drivers/crypto/starfive/jh7110-aes.c

527

for (stsg = src, dtsg = dst;;) {

drivers/crypto/starfive/jh7110-aes.c

582

rctx->out_sg = req->dst;

drivers/crypto/starfive/jh7110-aes.c

650

if (req->src == req->dst)

drivers/crypto/starfive/jh7110-aes.c

653

rctx->out_sg = scatterwalk_ffwd(_dst, req->dst, cryp->assoclen);

drivers/crypto/starfive/jh7110-aes.c

751

struct scatterlist *dst)

drivers/crypto/starfive/jh7110-aes.c

762

if (src != dst)

drivers/crypto/starfive/jh7110-aes.c

763

for_each_sg(dst, tsg, sg_nents(dst), i)

drivers/crypto/starfive/jh7110-aes.c

782

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/starfive/jh7110-aes.c

803

if (starfive_aes_check_unaligned(cryp, req->src, req->dst))

drivers/crypto/starfive/jh7110-aes.c

819

aead_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/starfive/jh7110-aes.c

831

struct scatterlist *src, *dst, _src[2], _dst[2];

drivers/crypto/starfive/jh7110-aes.c

844

if (req->src == req->dst)

drivers/crypto/starfive/jh7110-aes.c

845

dst = src;

drivers/crypto/starfive/jh7110-aes.c

847

dst = scatterwalk_ffwd(_dst, req->dst, req->assoclen);

drivers/crypto/starfive/jh7110-aes.c

849

if (starfive_aes_check_unaligned(cryp, src, dst))

drivers/crypto/starfive/jh7110-rsa.c

310

rctx->out_sg = req->dst;

drivers/crypto/starfive/jh7110-rsa.c

341

rctx->out_sg = req->dst;

drivers/crypto/stm32/stm32-cryp.c

1699

out_sg = req->dst;

drivers/crypto/stm32/stm32-cryp.c

1737

out_sg = areq->dst;

drivers/crypto/stm32/stm32-cryp.c

942

if (cryp->out_sg != cryp->req->dst)

drivers/crypto/talitos.c

1004

talitos_sg_unmap(dev, edesc, areq->src, areq->dst,

drivers/crypto/talitos.c

1014

sg_pcopy_to_buffer(areq->dst, dst_nents, ctx->iv, ivsize,

drivers/crypto/talitos.c

1226

(areq->src == areq->dst) ?

drivers/crypto/talitos.c

1264

if (areq->src != areq->dst) {

drivers/crypto/talitos.c

1267

dma_map_sg(dev, areq->dst, sg_count, DMA_FROM_DEVICE);

drivers/crypto/talitos.c

1274

ret = talitos_sg_map_ext(dev, areq->dst, cryptlen, edesc, &desc->ptr[5],

drivers/crypto/talitos.c

1294

talitos_sg_map(dev, areq->dst, authsize, edesc, &desc->ptr[6],

drivers/crypto/talitos.c

1321

struct scatterlist *dst,

drivers/crypto/talitos.c

1345

if (!dst || dst == src) {

drivers/crypto/talitos.c

1353

dst_nents = dst ? src_nents : 0;

drivers/crypto/talitos.c

1364

dst_nents = sg_nents_for_len(dst, dst_len);

drivers/crypto/talitos.c

1392

if (is_sec1 && !dst)

drivers/crypto/talitos.c

1426

return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst,

drivers/crypto/talitos.c

1538

talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->cryptlen, 0);

drivers/crypto/talitos.c

1599

(areq->src == areq->dst) ?

drivers/crypto/talitos.c

1610

if (areq->src != areq->dst) {

drivers/crypto/talitos.c

1613

dma_map_sg(dev, areq->dst, sg_count, DMA_FROM_DEVICE);

drivers/crypto/talitos.c

1616

ret = talitos_sg_map(dev, areq->dst, cryptlen, edesc, &desc->ptr[4],

drivers/crypto/talitos.c

1646

return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst,

drivers/crypto/talitos.c

962

struct scatterlist *dst,

drivers/crypto/talitos.c

970

if (is_sec1 && dst && dst_nents > 1) {

drivers/crypto/talitos.c

973

sg_pcopy_from_buffer(dst, dst_nents, edesc->buf + offset, len,

drivers/crypto/talitos.c

976

if (src != dst) {

drivers/crypto/talitos.c

980

if (dst && (dst_nents == 1 || !is_sec1))

drivers/crypto/talitos.c

981

dma_unmap_sg(dev, dst, dst_nents, DMA_FROM_DEVICE);

drivers/crypto/tegra/tegra-se-aes.c

1166

rctx->dst_sg = req->dst;

drivers/crypto/tegra/tegra-se-aes.c

1279

rctx->dst_sg = req->dst;

drivers/crypto/tegra/tegra-se-aes.c

322

scatterwalk_map_and_copy(rctx->datbuf.buf, req->dst, 0, req->cryptlen, 1);

drivers/crypto/ti/dthev2-aes.c

271

struct scatterlist *dst = req->dst;

drivers/crypto/ti/dthev2-aes.c

298

if (src == dst) {

drivers/crypto/ti/dthev2-aes.c

321

dst_nents = sg_nents_for_len(dst, len);

drivers/crypto/ti/dthev2-aes.c

322

dst_mapped_nents = dma_map_sg(rx_dev, dst, dst_nents, dst_dir);

drivers/crypto/ti/dthev2-aes.c

330

desc_in = dmaengine_prep_slave_sg(dev_data->dma_aes_rx, dst, dst_mapped_nents,

drivers/crypto/ti/dthev2-aes.c

391

dma_unmap_sg(rx_dev, dst, dst_nents, dst_dir);

drivers/crypto/ti/dthev2-aes.c

418

skcipher_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/virtio/virtio_crypto_akcipher_algs.c

92

sg_copy_from_buffer(akcipher_req->dst, sg_nents(akcipher_req->dst),

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

347

dst_nents = sg_nents(req->dst);

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

385

dst_len = virtio_crypto_alg_sg_nents_length(req->dst);

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

437

for (sg = req->dst; sg; sg = sg_next(sg))

drivers/crypto/virtio/virtio_crypto_skcipher_algs.c

553

scatterwalk_map_and_copy(req->iv, req->dst,

drivers/crypto/xilinx/xilinx-trng.c

250

u8 *dst, u32 dlen)

drivers/crypto/xilinx/xilinx-trng.c

256

ret = xtrng_random_bytes_generate(ctx->rng, dst, dlen, true);

drivers/crypto/xilinx/zynqmp-aes-gcm.c

174

hwreq->dst = dma_addr_data;

drivers/crypto/xilinx/zynqmp-aes-gcm.c

228

sg_copy_from_buffer(req->dst, sg_nents(req->dst),

drivers/crypto/xilinx/zynqmp-aes-gcm.c

354

sg_copy_from_buffer(req->dst, sg_nents(req->dst),

drivers/crypto/xilinx/zynqmp-aes-gcm.c

591

aead_request_set_crypt(subreq, req->src, req->dst,

drivers/crypto/xilinx/zynqmp-aes-gcm.c

68

u64 dst;

drivers/dma-buf/dma-resv.c

521

int dma_resv_copy_fences(struct dma_resv *dst, struct dma_resv *src)

drivers/dma-buf/dma-resv.c

527

dma_resv_assert_held(dst);

drivers/dma-buf/dma-resv.c

551

list = rcu_replace_pointer(dst->fences, list, dma_resv_held(dst));

drivers/dma/altera-msgdma.c

266

dma_addr_t dst, dma_addr_t src, size_t len,

drivers/dma/altera-msgdma.c

271

desc->write_addr_lo = lower_32_bits(dst);

drivers/dma/altera-msgdma.c

275

desc->write_addr_hi = upper_32_bits(dst);

drivers/dma/amba-pl08x.c

1642

static u32 pl08x_select_bus(bool ftdmac020, u8 src, u8 dst)

drivers/dma/amba-pl08x.c

1657

if (!(dst & PL08X_AHB1) || ((dst & PL08X_AHB2) && (src & PL08X_AHB1)))

drivers/dma/amba-pl08x.c

1659

if (!(src & PL08X_AHB1) || ((src & PL08X_AHB2) && !(dst & PL08X_AHB2)))

drivers/dma/amd/ptdma/ptdma-dmaengine.c

381

dma_addr_t dst,

drivers/dma/amd/ptdma/ptdma-dmaengine.c

403

pt_engine->dst_dma = dst;

drivers/dma/amd/ptdma/ptdma-dmaengine.c

423

pt_prep_dma_memcpy(struct dma_chan *dma_chan, dma_addr_t dst,

drivers/dma/amd/ptdma/ptdma-dmaengine.c

428

desc = pt_create_desc(dma_chan, dst, src, len, flags);

drivers/dma/amd/qdma/qdma.c

662

u64 addr, *src, *dst;

drivers/dma/amd/qdma/qdma.c

671

dst = &vdesc->dev_addr;

drivers/dma/amd/qdma/qdma.c

674

dst = &addr;

drivers/dma/amd/qdma/qdma.c

690

desc->dst_addr = cpu_to_le64(*dst);

drivers/dma/at_hdmac.c

531

static inline unsigned int atc_get_xfer_width(dma_addr_t src, dma_addr_t dst,

drivers/dma/at_hdmac.c

536

if (!((src | dst | len) & 3))

drivers/dma/at_hdmac.c

538

else if (!((src | dst | len) & 1))

drivers/dma/at_xdmac.c

1006

dwidth = at_xdmac_align_width(chan, src | dst | chunk->size);

drivers/dma/at_xdmac.c

1046

desc->lld.mbr_da = dst;

drivers/dma/at_xdmac.c

978

dma_addr_t src, dma_addr_t dst,

drivers/dma/bcm-sba-raid.c

1334

sba_prep_dma_pq(struct dma_chan *dchan, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/bcm-sba-raid.c

1354

dst_p = &dst[0];

drivers/dma/bcm-sba-raid.c

1356

dst_q = &dst[1];

drivers/dma/bcm-sba-raid.c

645

dma_addr_t dst, dma_addr_t src)

drivers/dma/bcm-sba-raid.c

690

cmdsp->data = dst + msg_offset;

drivers/dma/bcm-sba-raid.c

704

dma_addr_t off, dma_addr_t dst, dma_addr_t src,

drivers/dma/bcm-sba-raid.c

718

off, len, dst, src);

drivers/dma/bcm-sba-raid.c

728

sba_prep_dma_memcpy(struct dma_chan *dchan, dma_addr_t dst, dma_addr_t src,

drivers/dma/bcm-sba-raid.c

740

req = sba_prep_dma_memcpy_req(sba, off, dst, src,

drivers/dma/bcm-sba-raid.c

764

dma_addr_t dst, dma_addr_t *src, u32 src_cnt)

drivers/dma/bcm-sba-raid.c

829

cmdsp->data = dst + msg_offset;

drivers/dma/bcm-sba-raid.c

843

dma_addr_t off, dma_addr_t dst, dma_addr_t *src,

drivers/dma/bcm-sba-raid.c

857

off, len, dst, src, src_cnt);

drivers/dma/bcm-sba-raid.c

867

sba_prep_dma_xor(struct dma_chan *dchan, dma_addr_t dst, dma_addr_t *src,

drivers/dma/bcm-sba-raid.c

883

req = sba_prep_dma_xor_req(sba, off, dst, src, src_cnt,

drivers/dma/bcm2835-dma.c

286

dma_addr_t src, dma_addr_t dst, size_t buf_len,

drivers/dma/bcm2835-dma.c

323

control_block->dst = dst;

drivers/dma/bcm2835-dma.c

345

if (dst && (info & BCM2835_DMA_D_INC))

drivers/dma/bcm2835-dma.c

346

dst += control_block->length;

drivers/dma/bcm2835-dma.c

385

cb->cb->dst = addr;

drivers/dma/bcm2835-dma.c

532

dma = control_block->dst;

drivers/dma/bcm2835-dma.c

56

uint32_t dst;

drivers/dma/bcm2835-dma.c

596

struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,

drivers/dma/bcm2835-dma.c

607

if (!src || !dst || !len)

drivers/dma/bcm2835-dma.c

616

src, dst, len, 0, GFP_KERNEL);

drivers/dma/bcm2835-dma.c

631

dma_addr_t src = 0, dst = 0;

drivers/dma/bcm2835-dma.c

653

dst = c->cfg.dst_addr;

drivers/dma/bcm2835-dma.c

663

frames, src, dst, 0, 0,

drivers/dma/bcm2835-dma.c

683

dma_addr_t src, dst;

drivers/dma/bcm2835-dma.c

723

dst = buf_addr;

drivers/dma/bcm2835-dma.c

728

dst = c->cfg.dst_addr;

drivers/dma/bcm2835-dma.c

750

frames, src, dst, buf_len,

drivers/dma/dmatest.c

235

struct dmatest_data dst;

drivers/dma/dmatest.c

593

struct dmatest_data *dst;

drivers/dma/dmatest.c

619

dst = &thread->dst;

drivers/dma/dmatest.c

623

src->cnt = dst->cnt = 1;

drivers/dma/dmatest.c

627

src->cnt = dst->cnt = 1;

drivers/dma/dmatest.c

632

dst->cnt = 1;

drivers/dma/dmatest.c

638

dst->cnt = 2;

drivers/dma/dmatest.c

652

if ((src->cnt + dst->cnt) >= 255) {

drivers/dma/dmatest.c

654

src->cnt + dst->cnt);

drivers/dma/dmatest.c

666

dst->gfp_flags = GFP_KERNEL;

drivers/dma/dmatest.c

669

dst->gfp_flags = GFP_DMA;

drivers/dma/dmatest.c

675

if (dmatest_alloc_test_data(dst, buf_size, align) < 0)

drivers/dma/dmatest.c

684

dma_pq = kzalloc_objs(dma_addr_t, dst->cnt);

drivers/dma/dmatest.c

729

dst->off = 0;

drivers/dma/dmatest.c

732

dst->off = dmatest_random() % (buf_size - len + 1);

drivers/dma/dmatest.c

735

dst->off = (dst->off >> align) << align;

drivers/dma/dmatest.c

742

dmatest_init_dsts(dst->aligned, dst->off, len,

drivers/dma/dmatest.c

749

um = dmaengine_get_unmap_data(dma_dev, src->cnt + dst->cnt,

drivers/dma/dmatest.c

754

src->off, dst->off, len, ret);

drivers/dma/dmatest.c

770

src->off, dst->off, len, ret);

drivers/dma/dmatest.c

777

for (i = 0; i < dst->cnt; i++) {

drivers/dma/dmatest.c

778

void *buf = dst->aligned[i];

drivers/dma/dmatest.c

787

src->off, dst->off, len, ret);

drivers/dma/dmatest.c

795

dsts[0] + dst->off,

drivers/dma/dmatest.c

799

dsts[0] + dst->off,

drivers/dma/dmatest.c

804

dsts[0] + dst->off,

drivers/dma/dmatest.c

808

for (i = 0; i < dst->cnt; i++)

drivers/dma/dmatest.c

809

dma_pq[i] = dsts[i] + dst->off;

drivers/dma/dmatest.c

817

dst->off, len, ret);

drivers/dma/dmatest.c

831

dst->off, len, ret);

drivers/dma/dmatest.c

853

result("test timed out", total_tests, src->off, dst->off,

drivers/dma/dmatest.c

863

dst->off, len, ret);

drivers/dma/dmatest.c

871

dst->off, len, 0);

drivers/dma/dmatest.c

887

error_count += dmatest_verify(dst->aligned, 0, dst->off,

drivers/dma/dmatest.c

890

error_count += dmatest_verify(dst->aligned, dst->off,

drivers/dma/dmatest.c

891

dst->off + len, src->off,

drivers/dma/dmatest.c

894

error_count += dmatest_verify(dst->aligned, dst->off + len,

drivers/dma/dmatest.c

895

buf_size, dst->off + len,

drivers/dma/dmatest.c

902

result("data error", total_tests, src->off, dst->off,

drivers/dma/dmatest.c

907

dst->off, len, 0);

drivers/dma/dmatest.c

926

dmatest_free_test_data(dst);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

280

dma_addr_t dst, size_t len)

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

284

return __ffs(src | dst | len | BIT(max_width));

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

209

dma_addr_t dst, dma_addr_t src,

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

230

dpaa2_fl_set_addr(f_list, dst);

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

241

*dpaa2_qdma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst,

drivers/dma/fsl-dpaa2-qdma/dpaa2-qdma.c

267

dpaa2_qdma_populate_frames(f_list, dst, src, len, QDMA_FL_FMT_SBF);

drivers/dma/fsl-edma-common.c

481

struct fsl_edma_hw_tcd *tcd, dma_addr_t src, dma_addr_t dst,

drivers/dma/fsl-edma-common.c

497

fsl_edma_set_tcd_to_le(fsl_chan, tcd, dst, daddr);

drivers/dma/fsl-qdma.c

363

dma_addr_t dst, dma_addr_t src, u32 len)

drivers/dma/fsl-qdma.c

388

qdma_desc_addr_set64(csgf_dest, dst);

drivers/dma/fsl-qdma.c

975

fsl_qdma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst,

drivers/dma/fsl-qdma.c

986

fsl_qdma_comp_fill_memcpy(fsl_comp, dst, src, len);

drivers/dma/fsldma.c

111

struct fsl_dma_ld_hw *hw, dma_addr_t dst)

drivers/dma/fsldma.c

117

hw->dst_addr = CPU_TO_DMA(chan, snoop_bits | dst, 64);

drivers/dma/hisi_dma.c

482

hisi_dma_prep_dma_memcpy(struct dma_chan *c, dma_addr_t dst, dma_addr_t src,

drivers/dma/hisi_dma.c

494

desc->sqe.dst_addr = cpu_to_le64(dst);

drivers/dma/img-mdc-dma.c

207

dma_addr_t src, dma_addr_t dst, size_t len)

drivers/dma/img-mdc-dma.c

220

ldesc->write_addr = dst;

drivers/dma/img-mdc-dma.c

228

if (IS_ALIGNED(dst, mdma->bus_width) &&

drivers/dma/ioat/dma.h

371

ioat_prep_pq(struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/ioat/dma.h

379

ioat_prep_pqxor(struct dma_chan *chan, dma_addr_t dst, dma_addr_t *src,

drivers/dma/ioat/prep.c

107

dma_addr_t dst = dma_dest;

drivers/dma/ioat/prep.c

131

hw->dst_addr = dst;

drivers/dma/ioat/prep.c

134

dst += copy;

drivers/dma/ioat/prep.c

340

const dma_addr_t *dst, const dma_addr_t *src,

drivers/dma/ioat/prep.c

410

pq_set_src(descs, dst[1], offset, 1, s++);

drivers/dma/ioat/prep.c

412

pq_set_src(descs, dst[0], offset, 0, s++);

drivers/dma/ioat/prep.c

413

pq_set_src(descs, dst[1], offset, 1, s++);

drivers/dma/ioat/prep.c

414

pq_set_src(descs, dst[1], offset, 0, s++);

drivers/dma/ioat/prep.c

417

pq->p_addr = dst[0] + offset;

drivers/dma/ioat/prep.c

418

pq->q_addr = dst[1] + offset;

drivers/dma/ioat/prep.c

464

const dma_addr_t *dst, const dma_addr_t *src,

drivers/dma/ioat/prep.c

523

pq16_set_src(descs, dst[1], offset, 1, s++);

drivers/dma/ioat/prep.c

525

pq16_set_src(descs, dst[0], offset, 0, s++);

drivers/dma/ioat/prep.c

526

pq16_set_src(descs, dst[1], offset, 1, s++);

drivers/dma/ioat/prep.c

527

pq16_set_src(descs, dst[1], offset, 0, s++);

drivers/dma/ioat/prep.c

531

pq->p_addr = dst[0] + offset;

drivers/dma/ioat/prep.c

532

pq->q_addr = dst[1] + offset;

drivers/dma/ioat/prep.c

574

ioat_prep_pq(struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/ioat/prep.c

585

dst[0] = dst[1];

drivers/dma/ioat/prep.c

587

dst[1] = dst[0];

drivers/dma/ioat/prep.c

603

__ioat_prep_pq16_lock(chan, NULL, dst, single_source,

drivers/dma/ioat/prep.c

606

__ioat_prep_pq_lock(chan, NULL, dst, single_source, 2,

drivers/dma/ioat/prep.c

611

__ioat_prep_pq16_lock(chan, NULL, dst, src, src_cnt,

drivers/dma/ioat/prep.c

613

__ioat_prep_pq_lock(chan, NULL, dst, src, src_cnt,

drivers/dma/ioat/prep.c

647

ioat_prep_pqxor(struct dma_chan *chan, dma_addr_t dst, dma_addr_t *src,

drivers/dma/ioat/prep.c

661

pq[0] = dst;

drivers/dma/ioat/prep.c

663

pq[1] = dst; /* specify valid address for disabled result */

drivers/dma/k3dma.c

446

static void k3_dma_fill_desc(struct k3_dma_desc_sw *ds, dma_addr_t dst,

drivers/dma/k3dma.c

456

ds->desc_hw[num].daddr = dst;

drivers/dma/k3dma.c

489

struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,

drivers/dma/k3dma.c

519

k3_dma_fill_desc(ds, dst, src, copy, num++, c->ccfg);

drivers/dma/k3dma.c

522

dst += copy;

drivers/dma/k3dma.c

538

dma_addr_t addr, src = 0, dst = 0;

drivers/dma/k3dma.c

563

dst = c->dev_addr;

drivers/dma/k3dma.c

566

dst = addr;

drivers/dma/k3dma.c

569

k3_dma_fill_desc(ds, dst, src, len, num++, c->ccfg);

drivers/dma/k3dma.c

590

dma_addr_t addr, src = 0, dst = 0;

drivers/dma/k3dma.c

622

dst = c->dev_addr;

drivers/dma/k3dma.c

625

dst = addr;

drivers/dma/k3dma.c

635

k3_dma_fill_desc(ds, dst, src, len, num++, c->ccfg | en_tc2);

drivers/dma/milbeaut-xdmac.c

124

val = md->dst;

drivers/dma/milbeaut-xdmac.c

189

milbeaut_xdmac_prep_memcpy(struct dma_chan *chan, dma_addr_t dst,

drivers/dma/milbeaut-xdmac.c

201

md->dst = dst;

drivers/dma/milbeaut-xdmac.c

65

dma_addr_t dst;

drivers/dma/mpc512x_dma.c

601

mpc_dma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,

drivers/dma/mpc512x_dma.c

632

if (IS_ALIGNED(src | dst | len, 32)) {

drivers/dma/mpc512x_dma.c

637

} else if (!mdma->is_mpc8308 && IS_ALIGNED(src | dst | len, 16)) {

drivers/dma/mpc512x_dma.c

643

} else if (IS_ALIGNED(src | dst | len, 4)) {

drivers/dma/mpc512x_dma.c

648

} else if (IS_ALIGNED(src | dst | len, 2)) {

drivers/dma/mpc512x_dma.c

661

tcd->daddr = dst;

drivers/dma/nbpfaxi.c

1002

struct dma_chan *dchan, dma_addr_t dst, dma_addr_t src,

drivers/dma/nbpfaxi.c

1012

sg_dma_address(&dst_sg) = dst;

drivers/dma/nbpfaxi.c

1019

__func__, len, &src, &dst);

drivers/dma/nbpfaxi.c

507

dma_addr_t src, dma_addr_t dst, size_t size, bool last)

drivers/dma/nbpfaxi.c

520

hwdesc->dst_addr = dst;

drivers/dma/nbpfaxi.c

580

hwdesc->config, size, &src, &dst);

drivers/dma/owl-dma.c

1012

dst = sconfig->dst_addr;

drivers/dma/owl-dma.c

1015

dst = buf_addr + (period_len * i);

drivers/dma/owl-dma.c

1018

ret = owl_dma_cfg_lli(vchan, lli, src, dst, period_len,

drivers/dma/owl-dma.c

383

dma_addr_t src, dma_addr_t dst,

drivers/dma/owl-dma.c

441

lli->hw[OWL_DMADESC_DADDR] = dst;

drivers/dma/owl-dma.c

868

dma_addr_t dst, dma_addr_t src,

drivers/dma/owl-dma.c

897

ret = owl_dma_cfg_lli(vchan, lli, src + offset, dst + offset,

drivers/dma/owl-dma.c

928

dma_addr_t addr, src = 0, dst = 0;

drivers/dma/owl-dma.c

956

dst = sconfig->dst_addr;

drivers/dma/owl-dma.c

959

dst = addr;

drivers/dma/owl-dma.c

962

ret = owl_dma_cfg_lli(vchan, lli, src, dst, len, dir, sconfig,

drivers/dma/owl-dma.c

992

dma_addr_t src = 0, dst = 0;

drivers/dma/pl330.c

2625

dma_addr_t dst, dma_addr_t src, size_t len)

drivers/dma/pl330.c

2628

px->dst_addr = dst;

drivers/dma/pl330.c

2633

__pl330_prep_dma_memcpy(struct dma_pl330_chan *pch, dma_addr_t dst,

drivers/dma/pl330.c

2654

fill_px(&desc->px, dst, src, len);

drivers/dma/pl330.c

2686

dma_addr_t dst;

drivers/dma/pl330.c

2734

dst = pch->fifo_dma;

drivers/dma/pl330.c

2740

dst = dma_addr;

drivers/dma/pl330.c

2750

fill_px(&desc->px, dst, src, period_len);

drivers/dma/pl330.c

2769

pl330_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,

drivers/dma/pl330.c

2782

desc = __pl330_prep_dma_memcpy(pch, dst, src, len);

drivers/dma/pl330.c

2798

while ((src | dst | len) & (burst - 1))

drivers/dma/pl330.c

719

enum dmamov_dst dst, u32 val)

drivers/dma/pl330.c

725

buf[1] = dst;

drivers/dma/pl330.c

732

dst == SAR ? "SAR" : (dst == DAR ? "DAR" : "CCR"), val);

drivers/dma/ppc4xx/adma.c

180

static void prep_dma_xor_dbg(int id, dma_addr_t dst, dma_addr_t *src,

drivers/dma/ppc4xx/adma.c

188

pr_debug("dst:\n\t0x%016llx\n", dst);

drivers/dma/ppc4xx/adma.c

191

static void prep_dma_pq_dbg(int id, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/ppc4xx/adma.c

201

pr_debug("\t0x%016llx ", dst[i]);

drivers/dma/ppc4xx/adma.c

2084

dma_addr_t *dst, int dst_cnt, dma_addr_t *src, int src_cnt,

drivers/dma/ppc4xx/adma.c

2123

DMA_CUED_XOR_BASE, dst[0], 0);

drivers/dma/ppc4xx/adma.c

2124

ppc440spe_desc_set_dest_addr(iter, chan, 0, dst[1], 1);

drivers/dma/ppc4xx/adma.c

2147

DMA_CUED_XOR_HB, dst[1]);

drivers/dma/ppc4xx/adma.c

2149

DMA_CUED_XOR_BASE, dst[0], 0);

drivers/dma/ppc4xx/adma.c

2170

dma_addr_t *dst, dma_addr_t *src, int src_cnt,

drivers/dma/ppc4xx/adma.c

2206

*dst, 0);

drivers/dma/ppc4xx/adma.c

2234

*dst, 0);

drivers/dma/ppc4xx/adma.c

2259

*dst, 0);

drivers/dma/ppc4xx/adma.c

2274

dma_addr_t *dst, int dst_cnt, dma_addr_t *src, int src_cnt,

drivers/dma/ppc4xx/adma.c

2385

__func__, dst[0], dst[1]);

drivers/dma/ppc4xx/adma.c

2386

ppc440spe_adma_pq_set_dest(sw_desc, dst, flags);

drivers/dma/ppc4xx/adma.c

2419

dma_addr_t *dst, int dst_cnt, dma_addr_t *src, int src_cnt,

drivers/dma/ppc4xx/adma.c

2484

ppc440spe_adma_pq_set_dest(sw_desc, dst, flags);

drivers/dma/ppc4xx/adma.c

2507

struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/ppc4xx/adma.c

2518

dst, src, src_cnt));

drivers/dma/ppc4xx/adma.c

2523

if (src_cnt == 1 && dst[1] == src[0]) {

drivers/dma/ppc4xx/adma.c

2527

dest[0] = dst[1];

drivers/dma/ppc4xx/adma.c

2535

if (src_cnt == 2 && dst[1] == src[1]) {

drivers/dma/ppc4xx/adma.c

2537

&dst[1], src, 2, scf, len, flags);

drivers/dma/ppc4xx/adma.c

2542

BUG_ON(!dst[0]);

drivers/dma/ppc4xx/adma.c

2548

BUG_ON(!dst[1]);

drivers/dma/ppc4xx/adma.c

2564

dst, dst_cnt, src, src_cnt, scf,

drivers/dma/ppc4xx/adma.c

2570

dst, dst_cnt, src, src_cnt, scf,

drivers/dma/qcom/qcom_adm.c

240

u32 *src, *dst;

drivers/dma/qcom/qcom_adm.c

246

dst = &mem_addr;

drivers/dma/qcom/qcom_adm.c

251

dst = &achan->slave.dst_addr;

drivers/dma/qcom/qcom_adm.c

259

box_desc->dst_addr = *dst;

drivers/dma/qcom/qcom_adm.c

277

single_desc->dst_addr = *dst;

drivers/dma/qcom/qcom_adm.c

306

u32 *src, *dst;

drivers/dma/qcom/qcom_adm.c

310

dst = &mem_addr;

drivers/dma/qcom/qcom_adm.c

313

dst = &achan->slave.dst_addr;

drivers/dma/qcom/qcom_adm.c

320

single_desc->dst_addr = *dst;

drivers/dma/sf-pdma/sf-pdma.c

69

u64 dst, u64 src, u64 size)

drivers/dma/sf-pdma/sf-pdma.c

73

desc->dst_addr = dst;

drivers/dma/sh/rcar-dmac.c

1160

dev_addr = rchan->dst.slave_addr;

drivers/dma/sh/rcar-dmac.c

1161

dev_size = rchan->dst.xfer_size;

drivers/dma/sh/rcar-dmac.c

1289

rchan->dst.slave_addr = cfg->dst_addr;

drivers/dma/sh/rcar-dmac.c

1291

rchan->dst.xfer_size = cfg->dst_addr_width;

drivers/dma/sh/rcar-dmac.c

166

struct rcar_dmac_chan_slave dst;

drivers/dma/sh/rcar-dmac.c

902

xfer_size = chan->dst.xfer_size;

drivers/dma/sh/shdma-base.c

515

unsigned long flags, dma_addr_t *dst, dma_addr_t *src, size_t *len,

drivers/dma/sh/shdma-base.c

533

ops->desc_setup(schan, new, *src, *dst, &copy_size);

drivers/dma/sh/shdma-base.c

546

copy_size, *len, src, dst, &new->async_tx,

drivers/dma/sh/shdma-base.c

558

*dst += copy_size;

drivers/dma/sh/shdmac.c

387

dma_addr_t src, dma_addr_t dst, size_t *len)

drivers/dma/sh/shdmac.c

396

sh_desc->hw.dar = dst;

drivers/dma/sprd-dma.c

1000

dst = slave_cfg->dst_addr;

drivers/dma/sprd-dma.c

1003

dst = sg_dma_address(sg);

drivers/dma/sprd-dma.c

1008

start_dst = dst;

drivers/dma/sprd-dma.c

1019

ret = sprd_dma_fill_linklist_desc(chan, sglen, i, src, dst, len,

drivers/dma/sprd-dma.c

745

dma_addr_t src, dma_addr_t dst, u32 len,

drivers/dma/sprd-dma.c

803

hw->wrap_to = (dst >> SPRD_DMA_HIGH_ADDR_OFFSET) & SPRD_DMA_HIGH_ADDR_MASK;

drivers/dma/sprd-dma.c

805

hw->des_addr = dst & SPRD_DMA_LOW_ADDR_MASK;

drivers/dma/sprd-dma.c

862

hw->wrap_to |= dst & SPRD_DMA_WRAP_ADDR_MASK;

drivers/dma/sprd-dma.c

876

dma_addr_t src, dma_addr_t dst, u32 len,

drivers/dma/sprd-dma.c

890

return sprd_dma_fill_desc(chan, hw, sglen, sg_index, src, dst, len,

drivers/dma/sprd-dma.c

956

dma_addr_t src = 0, dst = 0;

drivers/dma/st_fdma.c

312

struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,

drivers/dma/st_fdma.c

339

hw_node->daddr = dst;

drivers/dma/ste_dma40.c

2145

desc->lli_log.dst,

drivers/dma/ste_dma40.c

2175

desc->lli_phy.dst,

drivers/dma/ste_dma40.c

2176

virt_to_phys(desc->lli_phy.dst),

drivers/dma/ste_dma40.c

2490

dma_addr_t dst,

drivers/dma/ste_dma40.c

2501

sg_dma_address(&dst_sg) = dst;

drivers/dma/ste_dma40.c

685

d40d->lli_log.dst = d40d->lli_log.src + lli_len;

drivers/dma/ste_dma40.c

690

d40d->lli_phy.dst = d40d->lli_phy.src + lli_len;

drivers/dma/ste_dma40.c

719

d40d->lli_log.dst = NULL;

drivers/dma/ste_dma40.c

721

d40d->lli_phy.dst = NULL;

drivers/dma/ste_dma40.c

831

struct d40_phy_lli *lli_dst = desc->lli_phy.dst;

drivers/dma/ste_dma40.c

900

&lli->dst[lli_current],

drivers/dma/ste_dma40.c

928

&lli->dst[lli_current],

drivers/dma/ste_dma40.c

938

&lli->dst[lli_current],

drivers/dma/ste_dma40_ll.c

100

dst |= BIT(D40_SREG_CFG_EIM_POS);

drivers/dma/ste_dma40_ll.c

108

dst |= BIT(D40_SREG_CFG_PHY_PEN_POS);

drivers/dma/ste_dma40_ll.c

109

dst |= cfg->dst_info.psize << D40_SREG_CFG_PSIZE_POS;

drivers/dma/ste_dma40_ll.c

115

dst |= d40_width_to_bits(cfg->dst_info.data_width)

drivers/dma/ste_dma40_ll.c

121

dst |= BIT(D40_SREG_CFG_PRI_POS);

drivers/dma/ste_dma40_ll.c

127

dst |= BIT(D40_SREG_CFG_LBE_POS);

drivers/dma/ste_dma40_ll.c

130

*dst_cfg = dst;

drivers/dma/ste_dma40_ll.c

288

dma_addr_t dst = target ?: sg_addr;

drivers/dma/ste_dma40_ll.c

298

lli = d40_phy_buf_to_lli(lli, dst, len, l_phys, lli_phys,

drivers/dma/ste_dma40_ll.c

71

u32 dst = 0;

drivers/dma/ste_dma40_ll.c

87

dst |= BIT(D40_SREG_CFG_MST_POS);

drivers/dma/ste_dma40_ll.c

88

dst |= D40_TYPE_TO_EVENT(cfg->dev_type);

drivers/dma/ste_dma40_ll.c

91

dst |= BIT(D40_SREG_CFG_PHY_TM_POS);

drivers/dma/ste_dma40_ll.c

93

dst |= 3 << D40_SREG_CFG_PHY_TM_POS;

drivers/dma/ste_dma40_ll.c

96

dst |= BIT(D40_SREG_CFG_TIM_POS);

drivers/dma/ste_dma40_ll.h

362

struct d40_phy_lli *dst;

drivers/dma/ste_dma40_ll.h

392

struct d40_log_lli *dst;

drivers/dma/stm32/stm32-dma3.c

1209

dma_addr_t dst, dma_addr_t src)

drivers/dma/stm32/stm32-dma3.c

1230

chan->dma_config.dst_addr = dst;

drivers/dma/stm32/stm32-dma3.c

1235

dma_addr_t dst, dma_addr_t src,

drivers/dma/stm32/stm32-dma3.c

1256

stm32_dma3_init_chan_config_for_memcpy(chan, dst, src);

drivers/dma/stm32/stm32-dma3.c

1270

src + offset, dst + offset, next_size);

drivers/dma/stm32/stm32-dma3.c

1274

stm32_dma3_chan_prep_hwdesc(chan, swdesc, i, src + offset, dst + offset, next_size,

drivers/dma/stm32/stm32-dma3.c

1303

dma_addr_t sg_addr, dev_addr, src, dst;

drivers/dma/stm32/stm32-dma3.c

1338

dst = dev_addr;

drivers/dma/stm32/stm32-dma3.c

1341

src, dst, chunk);

drivers/dma/stm32/stm32-dma3.c

1347

dst = sg_addr;

drivers/dma/stm32/stm32-dma3.c

1350

src, dst, chunk);

drivers/dma/stm32/stm32-dma3.c

1359

stm32_dma3_chan_prep_hwdesc(chan, swdesc, j, src, dst, chunk,

drivers/dma/stm32/stm32-dma3.c

1395

dma_addr_t src, dst;

drivers/dma/stm32/stm32-dma3.c

1420

dst = chan->dma_config.dst_addr;

drivers/dma/stm32/stm32-dma3.c

1423

src, dst, period_len);

drivers/dma/stm32/stm32-dma3.c

1426

dst = buf_addr;

drivers/dma/stm32/stm32-dma3.c

1429

src, dst, period_len);

drivers/dma/stm32/stm32-dma3.c

1441

dst = chan->dma_config.dst_addr;

drivers/dma/stm32/stm32-dma3.c

1444

dst = buf_addr + i * period_len;

drivers/dma/stm32/stm32-dma3.c

1447

stm32_dma3_chan_prep_hwdesc(chan, swdesc, i, src, dst, period_len,

drivers/dma/stm32/stm32-dma3.c

501

u32 curr, dma_addr_t src, dma_addr_t dst, u32 len,

drivers/dma/stm32/stm32-dma3.c

513

hwdesc->cdar = dst;

drivers/dma/sun4i-dma.c

207

dma_addr_t dst;

drivers/dma/sun4i-dma.c

362

writel_relaxed(d->dst, pchan->base + SUN4I_DDMA_DST_ADDR_REG);

drivers/dma/sun4i-dma.c

368

writel_relaxed(d->dst, pchan->base + SUN4I_NDMA_DST_ADDR_REG);

drivers/dma/sun4i-dma.c

540

promise->dst = dest;

drivers/dma/sun4i-dma.c

603

promise->dst = dest;

drivers/dma/sun6i-dma.c

158

u32 dst;

drivers/dma/sun6i-dma.c

405

v_lli->cfg, v_lli->src, v_lli->dst,

drivers/dma/sun6i-dma.c

653

dma_addr_t src, dma_addr_t dst)

drivers/dma/sun6i-dma.c

656

v_lli->dst = lower_32_bits(dst);

drivers/dma/sun6i-dma.c

660

DST_HIGH_ADDR(upper_32_bits(dst));

drivers/dma/ti/edma.c

1279

param->dst = xt->dst_start;

drivers/dma/ti/edma.c

1425

edesc->pset[i].param.dst,

drivers/dma/ti/edma.c

144

u32 dst;

drivers/dma/ti/edma.c

1767

bool dst = edesc->direction == DMA_DEV_TO_MEM;

drivers/dma/ti/edma.c

1782

pos = edma_get_position(echan->ecc, echan->slot[0], dst);

drivers/dma/ti/edma.c

1799

pos = edma_get_position(echan->ecc, echan->slot[0], dst);

drivers/dma/ti/edma.c

529

bool dst)

drivers/dma/ti/edma.c

535

offs += dst ? PARM_DST : PARM_SRC;

drivers/dma/ti/edma.c

762

edesc->pset[j].param.dst,

drivers/dma/ti/edma.c

992

param->dst = dst_addr;

drivers/dma/ti/k3-psil-am62.c

184

.dst = am62_dst_ep_map,

drivers/dma/ti/k3-psil-am62a.c

194

.dst = am62a_dst_ep_map,

drivers/dma/ti/k3-psil-am62p.c

323

.dst = am62p_dst_ep_map,

drivers/dma/ti/k3-psil-am64.c

156

.dst = am64_dst_ep_map,

drivers/dma/ti/k3-psil-am654.c

173

.dst = am654_dst_ep_map,

drivers/dma/ti/k3-psil-j7200.c

240

.dst = j7200_dst_ep_map,

drivers/dma/ti/k3-psil-j721e.c

375

.dst = j721e_dst_ep_map,

drivers/dma/ti/k3-psil-j721s2.c

257

.dst = j721s2_dst_ep_map,

drivers/dma/ti/k3-psil-j784s4.c

352

.dst = j784s4_dst_ep_map,

drivers/dma/ti/k3-psil-priv.h

33

struct psil_ep *dst;

drivers/dma/ti/k3-psil.c

54

if (thread_id & K3_PSIL_DST_THREAD_ID_OFFSET && soc_ep_map->dst) {

drivers/dma/ti/k3-psil.c

57

if (soc_ep_map->dst[i].thread_id == thread_id)

drivers/dma/ti/k3-psil.c

58

return &soc_ep_map->dst[i].ep_config;

drivers/dma/uniphier-xdmac.c

141

dst_addr = xd->nodes[xd->cur_node].dst;

drivers/dma/uniphier-xdmac.c

281

uniphier_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,

drivers/dma/uniphier-xdmac.c

303

xd->nodes[i].dst = dst;

drivers/dma/uniphier-xdmac.c

308

dst += tlen;

drivers/dma/uniphier-xdmac.c

359

xd->nodes[i].dst = (direction == DMA_MEM_TO_DEV)

drivers/dma/uniphier-xdmac.c

72

dma_addr_t dst;

drivers/dma/xgene-dma.c

416

dma_addr_t *dst, dma_addr_t *src,

drivers/dma/xgene-dma.c

432

desc1->m3 |= cpu_to_le64(*dst);

drivers/dma/xgene-dma.c

451

*dst += XGENE_DMA_MAX_BYTE_CNT;

drivers/dma/xgene-dma.c

839

struct dma_chan *dchan, dma_addr_t dst, dma_addr_t *src,

drivers/dma/xgene-dma.c

859

xgene_dma_prep_xor_desc(chan, new, &dst, src,

drivers/dma/xgene-dma.c

887

struct dma_chan *dchan, dma_addr_t *dst, dma_addr_t *src,

drivers/dma/xgene-dma.c

934

xgene_dma_prep_xor_desc(chan, new, &dst[0], src,

drivers/dma/xgene-dma.c

944

xgene_dma_prep_xor_desc(chan, new, &dst[1], _src,

drivers/dma/xilinx/xdma.c

608

u64 addr, dev_addr, *src, *dst;

drivers/dma/xilinx/xdma.c

623

dst = &dev_addr;

drivers/dma/xilinx/xdma.c

627

dst = &addr;

drivers/dma/xilinx/xdma.c

633

desc_num += xdma_fill_descs(sw_desc, *src, *dst, sg_dma_len(sg), desc_num);

drivers/dma/xilinx/xdma.c

669

u64 addr, dev_addr, *src, *dst;

drivers/dma/xilinx/xdma.c

700

dst = &dev_addr;

drivers/dma/xilinx/xdma.c

704

dst = &addr;

drivers/dma/xilinx/xdma.c

709

desc_num += xdma_fill_descs(sw_desc, *src, *dst, period_size, desc_num);

drivers/dma/xilinx/zynqmp_dma.c

182

u64 dst;

drivers/dma/xilinx/zynqmp_dma.c

317

dma_addr_t src, dma_addr_t dst, size_t len,

drivers/dma/xilinx/zynqmp_dma.c

324

ddesc->addr = dst;

drivers/dpll/dpll_core.c

592

struct dpll_pin_properties *dst)

drivers/dpll/dpll_core.c

597

memcpy(dst, src, sizeof(*dst));

drivers/dpll/dpll_core.c

601

dst->freq_supported = kmemdup(src->freq_supported,

drivers/dpll/dpll_core.c

603

if (!dst->freq_supported)

drivers/dpll/dpll_core.c

607

dst->board_label = kstrdup(src->board_label, GFP_KERNEL);

drivers/dpll/dpll_core.c

608

if (!dst->board_label)

drivers/dpll/dpll_core.c

612

dst->panel_label = kstrdup(src->panel_label, GFP_KERNEL);

drivers/dpll/dpll_core.c

613

if (!dst->panel_label)

drivers/dpll/dpll_core.c

617

dst->package_label = kstrdup(src->package_label, GFP_KERNEL);

drivers/dpll/dpll_core.c

618

if (!dst->package_label)

drivers/dpll/dpll_core.c

625

kfree(dst->panel_label);

drivers/dpll/dpll_core.c

627

kfree(dst->board_label);

drivers/dpll/dpll_core.c

629

kfree(dst->freq_supported);

drivers/edac/ghes_edac.c

446

struct dimm_info *src, *dst;

drivers/edac/ghes_edac.c

449

mci_for_each_dimm(mci, dst) {

drivers/edac/ghes_edac.c

452

dst->idx = src->idx;

drivers/edac/ghes_edac.c

453

dst->smbios_handle = src->smbios_handle;

drivers/edac/ghes_edac.c

454

dst->nr_pages = src->nr_pages;

drivers/edac/ghes_edac.c

455

dst->mtype = src->mtype;

drivers/edac/ghes_edac.c

456

dst->edac_mode = src->edac_mode;

drivers/edac/ghes_edac.c

457

dst->dtype = src->dtype;

drivers/edac/ghes_edac.c

458

dst->grain = src->grain;

drivers/edac/ghes_edac.c

465

memcpy(dst->label, src->label, sizeof(src->label));

drivers/edac/versalnet_edac.c

728

chinfo.dst = rpdev->dst;

drivers/firmware/arm_ffa/driver.c

656

static void ffa_emad_impdef_value_init(u32 version, void *dst, void *src)

drivers/firmware/arm_ffa/driver.c

661

memcpy(dst, src, sizeof(ep_mem_access->impdef_val));

drivers/firmware/efi/earlycon.c

107

dst = efi_earlycon_map(i*len, len);

drivers/firmware/efi/earlycon.c

108

if (!dst)

drivers/firmware/efi/earlycon.c

113

efi_earlycon_unmap(dst, len);

drivers/firmware/efi/earlycon.c

117

memmove(dst, src, maxlen);

drivers/firmware/efi/earlycon.c

120

efi_earlycon_unmap(dst, len);

drivers/firmware/efi/earlycon.c

124

static void efi_earlycon_write_char(u32 *dst, unsigned char c, unsigned int h,

drivers/firmware/efi/earlycon.c

140

*dst = color_white;

drivers/firmware/efi/earlycon.c

142

*dst = color_black;

drivers/firmware/efi/earlycon.c

143

dst++;

drivers/firmware/efi/earlycon.c

154

void *dst;

drivers/firmware/efi/earlycon.c

169

dst = efi_earlycon_map((efi_y + h) * len, len);

drivers/firmware/efi/earlycon.c

170

if (!dst)

drivers/firmware/efi/earlycon.c

178

efi_earlycon_write_char(dst + x * 4, *s, h, si);

drivers/firmware/efi/earlycon.c

183

efi_earlycon_unmap(dst, len);

drivers/firmware/efi/earlycon.c

77

unsigned long *dst;

drivers/firmware/efi/earlycon.c

81

dst = efi_earlycon_map(y*len, len);

drivers/firmware/efi/earlycon.c

82

if (!dst)

drivers/firmware/efi/earlycon.c

85

memset(dst, 0, len);

drivers/firmware/efi/earlycon.c

86

efi_earlycon_unmap(dst, len);

drivers/firmware/efi/earlycon.c

91

unsigned long *dst, *src;

drivers/firmware/efi/libstub/intrinsics.c

18

static void *efistub_memmove(u8 *dst, const u8 *src, size_t len)

drivers/firmware/efi/libstub/intrinsics.c

20

if (src > dst || dst >= (src + len))

drivers/firmware/efi/libstub/intrinsics.c

22

dst[i] = src[i];

drivers/firmware/efi/libstub/intrinsics.c

25

dst[i] = src[i];

drivers/firmware/efi/libstub/intrinsics.c

27

return dst;

drivers/firmware/efi/libstub/intrinsics.c

30

static void *efistub_memset(void *dst, int c, size_t len)

drivers/firmware/efi/libstub/intrinsics.c

32

for (u8 *d = dst; len--; d++)

drivers/firmware/efi/libstub/intrinsics.c

35

return dst;

drivers/firmware/efi/libstub/intrinsics.c

38

void *memcpy(void *dst, const void *src, size_t len)

drivers/firmware/efi/libstub/intrinsics.c

41

return efistub_memmove(dst, src, len);

drivers/firmware/efi/libstub/intrinsics.c

43

efi_bs_call(copy_mem, dst, src, len);

drivers/firmware/efi/libstub/intrinsics.c

44

return dst;

drivers/firmware/efi/libstub/intrinsics.c

47

extern void *memmove(void *dst, const void *src, size_t len) __alias(memcpy);

drivers/firmware/efi/libstub/intrinsics.c

49

void *memset(void *dst, int c, size_t len)

drivers/firmware/efi/libstub/intrinsics.c

52

return efistub_memset(dst, c, len);

drivers/firmware/efi/libstub/intrinsics.c

54

efi_bs_call(set_mem, dst, len, c & U8_MAX);

drivers/firmware/efi/libstub/intrinsics.c

55

return dst;

drivers/firmware/efi/test/efi_test.c

111

copy_ucs2_from_user(efi_char16_t **dst, efi_char16_t __user *src)

drivers/firmware/efi/test/efi_test.c

118

return copy_ucs2_from_user_len(dst, src, len);

drivers/firmware/efi/test/efi_test.c

131

copy_ucs2_to_user_len(efi_char16_t __user *dst, efi_char16_t *src, size_t len)

drivers/firmware/efi/test/efi_test.c

136

return copy_to_user(dst, src, len);

drivers/firmware/efi/test/efi_test.c

63

copy_ucs2_from_user_len(efi_char16_t **dst, efi_char16_t __user *src,

drivers/firmware/efi/test/efi_test.c

69

*dst = NULL;

drivers/firmware/efi/test/efi_test.c

75

*dst = NULL;

drivers/firmware/efi/test/efi_test.c

78

*dst = buf;

drivers/firmware/smccc/soc_id.c

39

static inline void str_fragment_from_reg(char *dst, unsigned long reg)

drivers/firmware/smccc/soc_id.c

41

dst[0] = (reg >> 0) & 0xff;

drivers/firmware/smccc/soc_id.c

42

dst[1] = (reg >> 8) & 0xff;

drivers/firmware/smccc/soc_id.c

43

dst[2] = (reg >> 16) & 0xff;

drivers/firmware/smccc/soc_id.c

44

dst[3] = (reg >> 24) & 0xff;

drivers/firmware/smccc/soc_id.c

45

dst[4] = (reg >> 32) & 0xff;

drivers/firmware/smccc/soc_id.c

46

dst[5] = (reg >> 40) & 0xff;

drivers/firmware/smccc/soc_id.c

47

dst[6] = (reg >> 48) & 0xff;

drivers/firmware/smccc/soc_id.c

48

dst[7] = (reg >> 56) & 0xff;

drivers/firmware/tegra/ivc.c

625

static inline void iosys_map_copy(struct iosys_map *dst, const struct iosys_map *src)

drivers/firmware/tegra/ivc.c

627

*dst = *src;

drivers/firmware/turris-mox-rwtm.c

283

static void mox_ecc_number_to_bin(void *dst, const u32 *src)

drivers/firmware/turris-mox-rwtm.c

289

memcpy(dst, (void *)tmp + 2, MOX_ECC_NUM_LEN);

drivers/firmware/turris-mox-rwtm.c

292

static void mox_ecc_public_key_to_bin(void *dst, u32 src_first,

drivers/firmware/turris-mox-rwtm.c

296

u8 *p = dst;

drivers/gpu/drm/adp/adp_drv.c

173

dst_pos = new_state->dst.x1 << 16 | new_state->dst.y1;

drivers/gpu/drm/adp/adp_drv.c

175

dst_size = drm_rect_width(&new_state->dst) << 16 |

drivers/gpu/drm/adp/adp_drv.c

176

drm_rect_height(&new_state->dst);

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

284

#define read_user_wptr(mmptr, wptr, dst) \

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

290

valid = !get_user((dst), (wptr)); \

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

293

valid = !get_user((dst), (wptr)); \

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

1641

void amdgpu_atombios_copy_swap(u8 *dst, u8 *src, u8 num_bytes, bool to_le)

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

1652

memcpy(dst, dst_tmp, align_num_bytes);

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

1657

memcpy(dst, dst_tmp, num_bytes);

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

1660

memcpy(dst, src, num_bytes);

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

202

void amdgpu_atombios_copy_swap(u8 *dst, u8 *src, u8 num_bytes, bool to_le);

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

349

void *dst)

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

363

amdgpu_gmc_set_pte_pde(adev, dst, t, page_base, flags);

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

388

uint64_t flags, void *dst)

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

399

amdgpu_gmc_set_pte_pde(adev, dst,

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

427

void *dst;

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

436

dst = adev->gart.ptr;

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

441

amdgpu_gmc_set_pte_pde(adev, dst, t, page_base, flags);

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

443

amdgpu_gmc_set_pte_pde(adev, dst, t, page_base, ctrl_flags);

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

64

void *dst);

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

71

uint64_t flags, void *dst);

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

341

uint32_t wave, uint32_t *dst, int *no_fields);

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

344

uint32_t size, uint32_t *dst);

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

347

uint32_t *dst);

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

167

u64 *dst, u64 *flags);

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

368

#define amdgpu_gmc_get_vm_pde(adev, level, dst, flags) (adev)->gmc.gmc_funcs->get_vm_pde((adev), (level), (dst), (flags))

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

417

void amdgpu_sync_move(struct amdgpu_sync *src, struct amdgpu_sync *dst)

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

421

amdgpu_sync_free(dst);

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

424

hlist_move_list(&src->fences[i], &dst->fences[i]);

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

60

void amdgpu_sync_move(struct amdgpu_sync *src, struct amdgpu_sync *dst);

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

325

unsigned int nptes, uint64_t dst,

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

328

TP_ARGS(p, start, end, nptes, dst, incr, flags, pid, vm_ctx),

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

337

__dynamic_array(u64, dst, nptes)

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

352

p->pages_addr, dst) : dst;

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

354

((u64 *)__get_dynamic_array(dst))[i] = addr;

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

355

dst += incr;

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

362

__get_dynamic_array(dst), __entry->nptes, 8))

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

2555

struct amdgpu_res_cursor dst;

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

2564

amdgpu_res_first(bo->tbo.resource, 0, amdgpu_bo_size(bo), &dst);

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

2567

while (dst.remaining) {

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

2572

cur_size = min(dst.size, 256ULL << 20);

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

2574

r = amdgpu_ttm_map_buffer(entity, &bo->tbo, bo->tbo.resource, &dst,

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

2588

amdgpu_res_next(&dst, cur_size);

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

296

const struct amdgpu_copy_mem *dst,

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

314

amdgpu_res_first(dst->mem, dst->offset, size, &dst_mm);

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

331

r = amdgpu_ttm_map_buffer(entity, dst->bo, dst->mem, &dst_mm,

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

337

abo_dst = ttm_to_amdgpu_bo(dst->bo);

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

344

(dst->mem->mem_type == TTM_PL_VRAM)) {

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

389

struct amdgpu_copy_mem src, dst;

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

394

dst.bo = bo;

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

396

dst.mem = new_mem;

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

398

dst.offset = 0;

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

402

&src, &dst,

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

613

uint64_t dst, uint64_t flags);

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

800

uint64_t dst, uint64_t flags)

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

905

min(nptes, 32u), dst, incr,

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

910

cursor.level, pe_start, dst,

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

914

dst += nptes * incr;

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

1000

dst >>= shift;

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

1001

dst &= atom_arg_mask[dst_align];

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

1002

dst >>= atom_arg_shift[dst_align];

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

1004

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

1010

uint32_t dst, src, saved;

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

1013

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

1016

dst -= src;

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

1018

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

1051

uint32_t dst, src;

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

1053

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

1056

ctx->ctx->cs_equal = ((dst & src) == 0);

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

1063

uint32_t dst, src, saved;

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

1066

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

1069

dst ^= src;

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

1071

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

602

uint32_t dst, src, saved;

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

605

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

608

dst += src;

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

610

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

616

uint32_t dst, src, saved;

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

619

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

622

dst &= src;

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

624

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

663

uint32_t dst, src;

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

665

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

668

ctx->ctx->cs_equal = (dst == src);

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

669

ctx->ctx->cs_above = (dst > src);

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

689

uint32_t dst, src;

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

691

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

695

ctx->ctx->divmul[0] = dst / src;

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

696

ctx->ctx->divmul[1] = dst % src;

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

707

uint32_t dst, src;

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

709

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

713

val64 = dst;

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

786

uint32_t dst, mask, src, saved;

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

789

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

794

dst &= mask;

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

795

dst |= src;

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

797

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

820

uint32_t dst, src;

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

822

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

825

ctx->ctx->divmul[0] = dst * src;

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

832

uint32_t dst, src;

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

834

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

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

837

val64 = (uint64_t)dst * (uint64_t)src;

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

850

uint32_t dst, src, saved;

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

853

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

856

dst |= src;

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

858

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

940

uint32_t saved, dst;

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

945

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

948

dst <<= shift;

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

950

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

956

uint32_t saved, dst;

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

961

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

964

dst >>= shift;

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

966

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

972

uint32_t saved, dst;

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

976

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

978

dst = saved;

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

981

dst <<= shift;

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

982

dst &= atom_arg_mask[dst_align];

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

983

dst >>= atom_arg_shift[dst_align];

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

985

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

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

991

uint32_t saved, dst;

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

995

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

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

997

dst = saved;

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

4498

static void gfx_v10_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

4507

dst[(*no_fields)++] = 2;

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

4508

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_STATUS);

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

4509

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_LO);

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

4510

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_HI);

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

4511

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_LO);

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

4512

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_HI);

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

4513

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID1);

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

4514

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID2);

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

4515

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_INST_DW0);

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

4516

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_GPR_ALLOC);

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

4517

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_LDS_ALLOC);

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

4518

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_TRAPSTS);

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

4519

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS);

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

4520

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS2);

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

4521

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_DBG1);

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

4522

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_M0);

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

4523

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_MODE);

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

4528

uint32_t size, uint32_t *dst)

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

4534

dst);

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

4540

uint32_t *dst)

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

4544

start + SQIND_WAVE_VGPRS_OFFSET, size, dst);

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

1006

dst[(*no_fields)++] = 3;

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

1007

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_STATUS);

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

1008

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_LO);

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

1009

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_HI);

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

1010

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_LO);

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

1011

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_HI);

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

1012

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID1);

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

1013

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID2);

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

1014

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_GPR_ALLOC);

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

1015

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_LDS_ALLOC);

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

1016

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_TRAPSTS);

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

1017

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS);

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

1018

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS2);

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

1019

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_DBG1);

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

1020

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_M0);

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

1021

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_MODE);

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

1026

uint32_t size, uint32_t *dst)

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

1032

dst);

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

1038

uint32_t *dst)

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

1042

start + SQIND_WAVE_VGPRS_OFFSET, size, dst);

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

998

static void gfx_v11_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

840

uint32_t *dst, int *no_fields)

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

848

dst[(*no_fields)++] = 4;

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

849

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_STATUS);

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

850

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_LO);

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

851

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_PC_HI);

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

852

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_LO);

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

853

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXEC_HI);

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

854

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID1);

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

855

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_HW_ID2);

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

856

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_GPR_ALLOC);

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

857

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_LDS_ALLOC);

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

858

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS);

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

859

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_STS2);

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

860

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_IB_DBG1);

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

861

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_M0);

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

862

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_MODE);

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

863

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_STATE_PRIV);

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

864

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXCP_FLAG_PRIV);

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

865

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_EXCP_FLAG_USER);

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

866

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_TRAP_CTRL);

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

867

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_ACTIVE);

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

868

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_VALID_AND_IDLE);

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

869

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_DVGPR_ALLOC_LO);

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

870

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_DVGPR_ALLOC_HI);

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

871

dst[(*no_fields)++] = wave_read_ind(adev, wave, ixSQ_WAVE_SCHED_MODE);

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

877

uint32_t size, uint32_t *dst)

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

883

dst);

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

890

uint32_t *dst)

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

894

start + SQIND_WAVE_VGPRS_OFFSET, size, dst);

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

653

uint32_t *dst, int *no_fields)

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

661

dst[(*no_fields)++] = 4;

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

662

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_STATUS);

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

663

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_PC_LO);

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

664

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_PC_HI);

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

665

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_EXEC_LO);

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

666

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_EXEC_HI);

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

667

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_HW_ID1);

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

668

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_HW_ID2);

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

669

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_GPR_ALLOC);

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

670

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_LDS_ALLOC);

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

671

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_IB_STS);

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

672

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_IB_STS2);

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

673

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_IB_DBG1);

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

674

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_M0);

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

675

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_MODE);

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

676

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_STATE_PRIV);

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

677

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_EXCP_FLAG_PRIV);

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

678

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_EXCP_FLAG_USER);

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

679

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_TRAP_CTRL);

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

680

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_ACTIVE);

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

681

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_VALID_AND_IDLE);

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

682

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_DVGPR_ALLOC_LO);

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

683

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_DVGPR_ALLOC_HI);

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

684

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, wave, ixSQ_WAVE_SCHED_MODE);

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

690

uint32_t size, uint32_t *dst)

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

696

size, dst);

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

703

uint32_t *dst)

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

707

size, dst);

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

2968

static void gfx_v6_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

2971

dst[(*no_fields)++] = 0;

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

2972

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_STATUS);

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

2973

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_LO);

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

2974

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_HI);

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

2975

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_LO);

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

2976

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_HI);

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

2977

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_HW_ID);

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

2978

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW0);

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

2979

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW1);

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

2980

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_GPR_ALLOC);

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

2981

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_LDS_ALLOC);

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

2982

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TRAPSTS);

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

2983

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_STS);

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

2984

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_LO);

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

2985

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_HI);

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

2986

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_LO);

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

2987

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_HI);

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

2988

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_DBG0);

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

2989

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_M0);

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

2990

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_MODE);

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

2995

uint32_t size, uint32_t *dst)

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

2999

start + SQIND_WAVE_SGPRS_OFFSET, size, dst);

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

4030

static void gfx_v7_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

4033

dst[(*no_fields)++] = 0;

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

4034

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_STATUS);

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

4035

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_LO);

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

4036

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_HI);

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

4037

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_LO);

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

4038

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_HI);

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

4039

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_HW_ID);

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

4040

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW0);

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

4041

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW1);

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

4042

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_GPR_ALLOC);

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

4043

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_LDS_ALLOC);

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

4044

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TRAPSTS);

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

4045

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_STS);

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

4046

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_LO);

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

4047

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_HI);

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

4048

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_LO);

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

4049

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_HI);

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

4050

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_DBG0);

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

4051

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_M0);

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

4052

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_MODE);

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

4057

uint32_t size, uint32_t *dst)

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

4061

start + SQIND_WAVE_SGPRS_OFFSET, size, dst);

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

5180

static void gfx_v8_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

5183

dst[(*no_fields)++] = 0;

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

5184

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_STATUS);

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

5185

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_LO);

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

5186

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_HI);

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

5187

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_LO);

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

5188

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_HI);

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

5189

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_HW_ID);

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

5190

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW0);

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

5191

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW1);

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

5192

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_GPR_ALLOC);

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

5193

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_LDS_ALLOC);

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

5194

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TRAPSTS);

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

5195

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_STS);

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

5196

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_LO);

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

5197

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TBA_HI);

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

5198

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_LO);

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

5199

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TMA_HI);

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

5200

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_DBG0);

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

5201

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_M0);

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

5202

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_MODE);

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

5207

uint32_t size, uint32_t *dst)

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

5211

start + SQIND_WAVE_SGPRS_OFFSET, size, dst);

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

1955

static void gfx_v9_0_read_wave_data(struct amdgpu_device *adev, uint32_t xcc_id, uint32_t simd, uint32_t wave, uint32_t *dst, int *no_fields)

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

1958

dst[(*no_fields)++] = 1;

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

1959

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_STATUS);

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

1960

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_LO);

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

1961

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_PC_HI);

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

1962

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_LO);

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

1963

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_EXEC_HI);

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

1964

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_HW_ID);

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

1965

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW0);

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

1966

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_INST_DW1);

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

1967

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_GPR_ALLOC);

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

1968

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_LDS_ALLOC);

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

1969

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_TRAPSTS);

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

1970

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_STS);

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

1971

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_IB_DBG0);

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

1972

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_M0);

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

1973

dst[(*no_fields)++] = wave_read_ind(adev, simd, wave, ixSQ_WAVE_MODE);

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

1978

uint32_t size, uint32_t *dst)

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

1982

start + SQIND_WAVE_SGPRS_OFFSET, size, dst);

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

1988

uint32_t *dst)

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

1992

start + SQIND_WAVE_VGPRS_OFFSET, size, dst);

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

743

uint32_t *dst, int *no_fields)

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

746

dst[(*no_fields)++] = 1;

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

747

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_STATUS);

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

748

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_PC_LO);

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

749

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_PC_HI);

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

750

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_EXEC_LO);

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

751

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_EXEC_HI);

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

752

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_HW_ID);

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

753

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_INST_DW0);

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

754

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_INST_DW1);

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

755

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_GPR_ALLOC);

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

756

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_LDS_ALLOC);

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

757

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_TRAPSTS);

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

758

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_IB_STS);

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

759

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_IB_DBG0);

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

760

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_M0);

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

761

dst[(*no_fields)++] = wave_read_ind(adev, xcc_id, simd, wave, ixSQ_WAVE_MODE);

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

766

uint32_t size, uint32_t *dst)

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

769

start + SQIND_WAVE_SGPRS_OFFSET, size, dst);

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

775

uint32_t *dst)

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

778

start + SQIND_WAVE_VGPRS_OFFSET, size, dst);

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

874

void __user *dst;

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

886

dst = &data[i].memory_exception_data;

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

890

dst = &data[i].memory_exception_data;

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

895

dst = &data[i].signal_event_data.last_event_age;

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

899

if (size && copy_to_user(dst, src, size))

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

275

if (migrate->dst[i] & MIGRATE_PFN_VALID &&

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

293

u64 *dst;

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

301

dst = (u64 *)(scratch + npages);

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

309

dst[i] = cursor.start + (j << PAGE_SHIFT);

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

310

migrate->dst[i] = svm_migrate_addr_to_pfn(adev, dst[i]);

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

311

svm_migrate_get_vram_page(prange, migrate->dst[i]);

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

312

migrate->dst[i] = migrate_pfn(migrate->dst[i]);

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

329

dst + i - j, j,

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

347

dst + i - j, j + 1,

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

359

r = svm_migrate_copy_memory_gart(adev, src + i - j, dst + i - j, j,

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

366

if (!dst[i])

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

368

svm_migrate_put_vram_page(adev, dst[i]);

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

369

migrate->dst[i] = 0;

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

378

svm_migrate_put_vram_page(adev, dst[i]);

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

379

migrate->dst[i] = 0;

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

380

svm_migrate_put_vram_page(adev, dst[i + 1]);

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

381

migrate->dst[i + 1] = 0;

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

382

svm_migrate_put_vram_page(adev, dst[i + 2]);

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

383

migrate->dst[i + 2] = 0;

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

384

svm_migrate_put_vram_page(adev, dst[i + 3]);

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

385

migrate->dst[i + 3] = 0;

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

423

migrate.dst = migrate.src + npages;

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

424

scratch = (dma_addr_t *)(migrate.dst + npages);

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

594

dma_addr_t *dst;

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

606

dst = scratch;

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

616

r = svm_migrate_copy_memory_gart(adev, dst + i - j,

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

628

r = svm_migrate_copy_memory_gart(adev, dst + i - j,

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

645

dst[i] = dma_map_page(dev, dpage, 0, PAGE_SIZE, DMA_BIDIRECTIONAL);

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

646

r = dma_mapping_error(dev, dst[i]);

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

653

dst[i] >> PAGE_SHIFT, page_to_pfn(dpage));

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

655

migrate->dst[i] = migrate_pfn(page_to_pfn(dpage));

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

659

r = svm_migrate_copy_memory_gart(adev, dst + i - j, src + i - j, j,

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

666

svm_migrate_put_sys_page(dst[i]);

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

667

migrate->dst[i] = 0;

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

725

migrate.dst = migrate.src + npages;

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

727

scratch = (dma_addr_t *)(migrate.dst + npages);

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

912

unsigned char *dst;

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

915

dst = kvmalloc_array(num_elements, size, GFP_KERNEL);

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

916

if (!dst)

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

920

memcpy(dst, src, num_elements * size);

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

921

return (void *)dst;

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

927

temp = (dma_addr_t *)dst + i;

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

933

return (void *)dst;

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

937

svm_range_copy_dma_addrs(struct svm_range *dst, struct svm_range *src)

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

944

dst->dma_addr[i] = svm_range_copy_array(src->dma_addr[i],

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

946

if (!dst->dma_addr[i])

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

10220

bundle->stream_update.dst = acrtc_state->stream->dst;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

10944

stream_update.dst = dm_new_crtc_state->stream->dst;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6460

struct rect dst = { 0 }; /* stream addressable area */

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6469

dst.width = stream->timing.h_addressable;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6470

dst.height = stream->timing.v_addressable;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6475

if (src.width * dst.height <

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6476

src.height * dst.width) {

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6478

dst.width = src.width *

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6479

dst.height / src.height;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6482

dst.height = src.height *

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6483

dst.width / src.width;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6486

dst = src;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6489

dst.x = (stream->timing.h_addressable - dst.width) / 2;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6490

dst.y = (stream->timing.v_addressable - dst.height) / 2;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6493

dst.x += dm_state->underscan_hborder / 2;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6494

dst.y += dm_state->underscan_vborder / 2;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6495

dst.width -= dm_state->underscan_hborder;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6496

dst.height -= dm_state->underscan_vborder;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6501

stream->dst = dst;

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

6504

dst.x, dst.y, dst.width, dst.height);

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2976

} else if (pipe[i].stream->dst.width != 0 &&

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2977

pipe[i].stream->dst.height != 0 &&

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2983

data->h_taps[num_displays + 4] = pipe[i].stream->src.width == pipe[i].stream->dst.width ? bw_int_to_fixed(1) : bw_int_to_fixed(2);

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2984

data->v_taps[num_displays + 4] = pipe[i].stream->src.height == pipe[i].stream->dst.height ? bw_int_to_fixed(1) : bw_int_to_fixed(2);

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2985

data->h_scale_ratio[num_displays + 4] = bw_frc_to_fixed(pipe[i].stream->src.width, pipe[i].stream->dst.width);

drivers/gpu/drm/amd/display/dc/basics/dce_calcs.c

2986

data->v_scale_ratio[num_displays + 4] = bw_frc_to_fixed(pipe[i].stream->src.height, pipe[i].stream->dst.height);

drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c

3537

void *dst)

drivers/gpu/drm/amd/display/dc/core/dc.c

2987

(stream_update->dst.height != 0 && stream_update->dst.width != 0) ||

drivers/gpu/drm/amd/display/dc/core/dc.c

3245

if (update->dst.height && update->dst.width)

drivers/gpu/drm/amd/display/dc/core/dc.c

3246

stream->dst = update->dst;

drivers/gpu/drm/amd/display/dc/core/dc.c

5169

(stream_update->dst.height != 0 && stream_update->dst.width != 0) ||

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1156

&pipe_ctx->stream->dst);

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1187

const int out_w = stream->dst.width;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1188

const int out_h = stream->dst.height;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1510

pipe_ctx->stream->dst.x += timing->h_border_left;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1511

pipe_ctx->stream->dst.y += timing->v_border_top;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1677

pipe_ctx->stream->dst.x -= timing->h_border_left;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

1678

pipe_ctx->stream->dst.y -= timing->v_border_top;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

3585

if (memcmp(&old_stream->dst,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

3586

&stream->dst,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

920

temp = dc_fixpt_from_fraction(rec_in->x * (long long)stream->dst.width,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

922

rec_out.x = stream->dst.x + dc_fixpt_round(temp);

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

925

(rec_in->x + rec_in->width) * (long long)stream->dst.width,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

927

rec_out.width = stream->dst.x + dc_fixpt_round(temp) - rec_out.x;

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

929

temp = dc_fixpt_from_fraction(rec_in->y * (long long)stream->dst.height,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

931

rec_out.y = stream->dst.y + dc_fixpt_round(temp);

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

934

(rec_in->y + rec_in->height) * (long long)stream->dst.height,

drivers/gpu/drm/amd/display/dc/core/dc_resource.c

936

rec_out.height = stream->dst.y + dc_fixpt_round(temp) - rec_out.y;

drivers/gpu/drm/amd/display/dc/core/dc_stream.c

901

stream->dst.x,

drivers/gpu/drm/amd/display/dc/core/dc_stream.c

902

stream->dst.y,

drivers/gpu/drm/amd/display/dc/core/dc_stream.c

903

stream->dst.width,

drivers/gpu/drm/amd/display/dc/core/dc_stream.c

904

stream->dst.height,

drivers/gpu/drm/amd/display/dc/core/dc_surface.c

300

void dc_plane_copy_config(struct dc_plane_state *dst, const struct dc_plane_state *src)

drivers/gpu/drm/amd/display/dc/core/dc_surface.c

305

memcpy(&temp_refcount, &dst->refcount, sizeof(struct kref));

drivers/gpu/drm/amd/display/dc/core/dc_surface.c

308

memcpy(dst, src, sizeof(struct dc_plane_state));

drivers/gpu/drm/amd/display/dc/core/dc_surface.c

311

memcpy(&dst->refcount, &temp_refcount, sizeof(struct kref));

drivers/gpu/drm/amd/display/dc/dc_bios_types.h

143

void *dst);

drivers/gpu/drm/amd/display/dc/dc_dmub_srv.c

820

reduce_fraction(subvp_pipe->stream->src.height, subvp_pipe->stream->dst.height,

drivers/gpu/drm/amd/display/dc/dc_plane.h

49

void dc_plane_copy_config(struct dc_plane_state *dst, const struct dc_plane_state *src);

drivers/gpu/drm/amd/display/dc/dc_spl_translate.c

106

populate_splrect_from_rect(&spl_in->basic_out.dst_rect, &stream->dst);

drivers/gpu/drm/amd/display/dc/dc_stream.h

214

struct rect dst; /* stream addressable area */

drivers/gpu/drm/amd/display/dc/dc_stream.h

335

struct rect dst;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1002

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1003

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1004

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1026

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1191

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1194

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1196

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1198

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1204

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1206

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1215

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1217

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1240

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1242

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1251

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1253

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1279

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1281

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1289

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1291

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1311

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1313

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1321

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

1323

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

788

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

798

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

800

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

801

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

802

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

808

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20.c

809

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1003

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1004

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1005

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1027

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1192

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1195

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1197

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1199

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1205

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1207

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1216

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1218

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1241

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1243

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1252

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1254

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1280

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1282

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1290

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1292

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1312

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1314

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1322

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

1324

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

788

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

798

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

800

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

801

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

802

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

808

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn20/display_rq_dlg_calc_20v2.c

809

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1042

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1043

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1044

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1066

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1243

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1247

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1249

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1251

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1258

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1260

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1270

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1272

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1297

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1299

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1309

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1311

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1340

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1342

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1351

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1353

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1376

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1378

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1387

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

1389

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

834

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

844

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

846

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

847

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

848

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

854

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn21/display_rq_dlg_calc_21.c

855

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1103

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1104

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1105

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1127

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1179

if (dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1209

if (dst->odm_combine == dm_odm_combine_mode_disabled) {

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1212

unsigned int odm_combine_factor = (dst->odm_combine == dm_odm_combine_mode_2to1 ? 2 : 4); // TODO: We should really check that 4to1 is supported before setting it to 4

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1214

disp_dlg_regs->refcyc_h_blank_end = (unsigned int)(((double) hblank_end + odm_pipe_index * (double) dst->hactive / odm_combine_factor) * ref_freq_to_pix_freq);

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1347

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1350

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1352

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1354

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1360

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1362

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1371

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1373

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1396

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1398

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1407

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1409

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1450

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1452

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1460

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1462

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1482

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1484

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1492

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

1494

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

900

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

910

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

912

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

913

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

914

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

920

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn30/display_rq_dlg_calc_30.c

921

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1022

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1023

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1024

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1026

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1054

if (dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1083

if (dst->odm_combine == dm_odm_combine_mode_disabled) {

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1086

unsigned int odm_combine_factor = (dst->odm_combine == dm_odm_combine_mode_2to1 ? 2 : 4); // TODO: We should really check that 4to1 is supported before setting it to 4

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1088

disp_dlg_regs->refcyc_h_blank_end = (unsigned int) (((double) hblank_end + odm_pipe_index * (double) dst->hactive / odm_combine_factor) * ref_freq_to_pix_freq);

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1192

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1194

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1196

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1198

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1205

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1207

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1217

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1219

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1243

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1245

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1255

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1257

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1290

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1292

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1302

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1304

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1328

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1330

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1339

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

1341

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

863

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

873

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

874

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

875

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

876

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

880

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn31/display_rq_dlg_calc_31.c

881

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1069

(vba__min_dst_y_next_start * dst->hactive) / (unsigned int) dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1109

vupdate_offset = dst->vupdate_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1110

vupdate_width = dst->vupdate_width;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1111

vready_offset = dst->vready_offset;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1113

vstartup_start = dst->vstartup_start;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1141

if (dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1170

if (dst->odm_combine == dm_odm_combine_mode_disabled) {

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1173

unsigned int odm_combine_factor = (dst->odm_combine == dm_odm_combine_mode_2to1 ? 2 : 4); // TODO: We should really check that 4to1 is supported before setting it to 4

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1176

disp_dlg_regs->refcyc_h_blank_end = (unsigned int) (((double) hblank_end + odm_pipe_index * (double) dst->hactive / odm_combine_factor) * ref_freq_to_pix_freq);

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1280

if (dst->full_recout_width == 0 && !dst->odm_combine) {

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1282

full_recout_width = dst->recout_width * 2; // assume half split for dcn1

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1284

full_recout_width = dst->full_recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1286

full_recout_width = dst->recout_width;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1293

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1295

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1305

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1307

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1331

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1333

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1343

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1345

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1378

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1380

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1390

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1392

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1416

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1418

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1427

dst->odm_combine,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

1429

dst->hactive,

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

948

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

958

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

959

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

960

unsigned int vblank_start = dst->vblank_start;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

961

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

965

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn314/display_rq_dlg_calc_314.c

966

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

1387

stream->src.width > stream->dst.width)

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

529

phantom_stream->dst.y = 0;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

530

phantom_stream->dst.height = phantom_vactive;

drivers/gpu/drm/amd/display/dc/dml/dcn32/dcn32_fpu.c

537

phantom_stream->src.height = (double)phantom_vactive * (double)main_stream->src.height / (double)main_stream->dst.height;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

213

const display_pipe_dest_params_st *dst = &e2e_pipe_param[pipe_idx].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

229

unsigned int htotal = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

230

unsigned int hblank_end = dst->hblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

231

unsigned int vblank_end = dst->vblank_end;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

232

bool interlaced = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

233

double pclk_freq_in_mhz = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

301

if (dst->odm_combine == dm_odm_combine_mode_2to1 || dst->odm_combine == dm_odm_combine_mode_4to1) {

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

331

if (dst->odm_combine == dm_odm_combine_mode_disabled) {

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

335

if (dst->odm_combine == dm_odm_combine_mode_2to1 || dst->odm_combine == dm_odm_combine_mode_4to1) {

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

337

unsigned int odm_combine_factor = (dst->odm_combine == dm_odm_combine_mode_2to1 ? 2 : 4);

drivers/gpu/drm/amd/display/dc/dml/dcn32/display_rq_dlg_calc_32.c

341

+ odm_pipe_index * (double) dst->hactive / odm_combine_factor) * ref_freq_to_pix_freq);

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

534

display_pipe_dest_params_st *dst = &pipes[j].pipe.dest;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

570

mode_lib->vba.RefreshRate[mode_lib->vba.NumberOfActivePlanes] = dst->refresh_rate; //todo remove this

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

572

mode_lib->vba.ODMUse[mode_lib->vba.NumberOfActivePlanes] = dst->odm_combine_policy;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

594

mode_lib->vba.Interlace[mode_lib->vba.NumberOfActivePlanes] = dst->interlaced;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

595

if (dst->interlaced && !ip->ptoi_supported) {

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

603

mode_lib->vba.HTotal[mode_lib->vba.NumberOfActivePlanes] = dst->htotal;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

604

mode_lib->vba.VTotal[mode_lib->vba.NumberOfActivePlanes] = dst->vtotal;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

605

mode_lib->vba.VFrontPorch[mode_lib->vba.NumberOfActivePlanes] = dst->vfront_porch;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

606

mode_lib->vba.VBlankNom[mode_lib->vba.NumberOfActivePlanes] = dst->vblank_nom;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

617

mode_lib->vba.HActive[mode_lib->vba.NumberOfActivePlanes] = dst->hactive;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

618

mode_lib->vba.VActive[mode_lib->vba.NumberOfActivePlanes] = dst->vactive;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

622

dst->recout_width; // TODO: or should this be full_recout_width???...maybe only when in hsplit mode?

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

624

dst->odm_combine;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

705

mode_lib->vba.PixelClock[mode_lib->vba.NumberOfActivePlanes] = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

706

mode_lib->vba.PixelClockBackEnd[mode_lib->vba.NumberOfActivePlanes] = dst->pixel_rate_mhz;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

708

mode_lib->vba.DRRDisplay[mode_lib->vba.NumberOfActiveSurfaces] = dst->drr_display;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

769

OTGInstPlane[mode_lib->vba.NumberOfActivePlanes] = dst->otg_inst;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

772

mode_lib->vba.UseMaximumVStartup = dst->use_maximum_vstartup;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

775

|| dst->use_maximum_vstartup;

drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c

777

if (dst->odm_combine && !src->is_hsplit)

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_translation_helper.c

640

stream->dst.height >= stream->timing.v_addressable;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_utils.c

257

memcpy(&phantom_stream->dst, &main_stream->dst, sizeof(phantom_stream->dst));

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_utils.c

265

phantom_stream->dst.y = 0;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_utils.c

266

phantom_stream->dst.height = stream_programming->phantom_stream.descriptor.timing.v_active;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/dml21_utils.c

269

phantom_stream->src.height = (double)phantom_stream_descriptor->timing.v_active * (double)main_stream->src.height / (double)main_stream->dst.height;

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_top/dml2_top_soc15.c

24

static void copy_display_configuration_with_meta(struct display_configuation_with_meta *dst, const struct display_configuation_with_meta *src)

drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_top/dml2_top_soc15.c

26

memcpy(dst, src, sizeof(struct display_configuation_with_meta));

drivers/gpu/drm/amd/display/dc/dml2_0/dml2_mall_phantom.c

700

phantom_stream->dst.y = 0;

drivers/gpu/drm/amd/display/dc/dml2_0/dml2_mall_phantom.c

701

phantom_stream->dst.height = phantom_vactive;

drivers/gpu/drm/amd/display/dc/dml2_0/dml2_mall_phantom.c

725

memcpy(&phantom_stream->dst, &ref_pipe->stream->dst, sizeof(phantom_stream->dst));

drivers/gpu/drm/amd/display/dc/hwss/dcn401/dcn401_hwseq.c

1137

x_pos = pipe_ctx->stream->dst.x + x_pos * pipe_ctx->stream->dst.width /

drivers/gpu/drm/amd/display/dc/hwss/dcn401/dcn401_hwseq.c

1139

y_pos = pipe_ctx->stream->dst.y + y_pos * pipe_ctx->stream->dst.height /

drivers/gpu/drm/amd/display/dc/resource/dcn315/dcn315_resource.c

1682

if (res_ctx->pipe_ctx[i].stream->src.width != res_ctx->pipe_ctx[i].stream->dst.width ||

drivers/gpu/drm/amd/display/dc/resource/dcn315/dcn315_resource.c

1683

res_ctx->pipe_ctx[i].stream->src.height != res_ctx->pipe_ctx[i].stream->dst.height ||

drivers/gpu/drm/amd/display/dc/resource/dcn32/dcn32_resource.c

1734

memcpy(&phantom_stream->dst, &ref_pipe->stream->dst, sizeof(phantom_stream->dst));

drivers/gpu/drm/amd/display/dc/resource/dcn32/dcn32_resource_helpers.c

217

if (pipe->stream->timing.v_addressable != pipe->stream->dst.height ||

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7292

uint8_t *dst = (uint8_t *)(rb->base_address) + rb->wrpt;

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7304

*dst++ = *src++;

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7325

uint8_t *dst = (uint8_t *)(rb->base_address) + rb->wrpt;

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7334

dmub_memcpy(dst, src, DMUB_RB_CMD_SIZE);

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7420

uint64_t *dst = (uint64_t *)cmd;

drivers/gpu/drm/amd/display/dmub/inc/dmub_cmd.h

7428

*dst++ = *src++;

drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c

1166

uint64_t *dst = (uint64_t *)entry;

drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c

1176

*dst++ = *src++;

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1768

#define smu_memcpy_trailing(dst, first_dst_member, last_dst_member, \

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1773

size_t __dst_offset = offsetof(typeof(*(dst)), first_dst_member); \

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1774

size_t __dst_size = offsetofend(typeof(*(dst)), last_dst_member) - \

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

1777

__builtin_memcpy((u8 *)(dst) + __dst_offset, \

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

2071

static inline void smu_feature_bits_copy(struct smu_feature_bits *dst,

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

2075

bitmap_copy(dst->bits, src, nbits);

drivers/gpu/drm/amd/ras/rascore/ras_cmd.h

337

struct ras_cmd_dev_handle dst;

drivers/gpu/drm/arm/hdlcd_crtc.c

282

dest_h = drm_rect_height(&new_plane_state->dst);

drivers/gpu/drm/armada/armada_overlay.c

168

drm_rect_width(&old_state->dst) != drm_rect_width(&new_state->dst)) {

drivers/gpu/drm/armada/armada_overlay.c

171

drm_rect_width(&new_state->dst))

drivers/gpu/drm/armada/armada_plane.c

107

if ((new_plane_state->dst.y1 | new_plane_state->dst.y2) & 1)

drivers/gpu/drm/armada/armada_plane.c

110

st->dst_yx = new_plane_state->dst.y1 >> 1;

drivers/gpu/drm/armada/armada_plane.c

111

st->dst_hw = drm_rect_height(&new_plane_state->dst) >> 1;

drivers/gpu/drm/armada/armada_plane.c

114

st->dst_yx = new_plane_state->dst.y1;

drivers/gpu/drm/armada/armada_plane.c

115

st->dst_hw = drm_rect_height(&new_plane_state->dst);

drivers/gpu/drm/armada/armada_plane.c

121

st->dst_yx |= new_plane_state->dst.x1 & 0x0000ffff;

drivers/gpu/drm/armada/armada_plane.c

123

st->dst_hw |= drm_rect_width(&new_plane_state->dst) & 0x0000ffff;

drivers/gpu/drm/armada/armada_plane.c

208

drm_rect_width(&old_state->dst) != drm_rect_width(&new_state->dst)) {

drivers/gpu/drm/armada/armada_plane.c

211

drm_rect_width(&new_state->dst))

drivers/gpu/drm/ast/ast_cursor.c

103

writew(swab16(*(const __u16 *)&src[i]), &dst[i]);

drivers/gpu/drm/ast/ast_cursor.c

105

memcpy_toio(dst, src, AST_HWC_SIZE);

drivers/gpu/drm/ast/ast_cursor.c

109

dst += AST_HWC_SIZE;

drivers/gpu/drm/ast/ast_cursor.c

110

writel(csum, dst);

drivers/gpu/drm/ast/ast_cursor.c

111

writel(width, dst + AST_HWC_SIGNATURE_SizeX);

drivers/gpu/drm/ast/ast_cursor.c

112

writel(height, dst + AST_HWC_SIGNATURE_SizeY);

drivers/gpu/drm/ast/ast_cursor.c

113

writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTX);

drivers/gpu/drm/ast/ast_cursor.c

114

writel(0, dst + AST_HWC_SIGNATURE_HOTSPOTY);

drivers/gpu/drm/ast/ast_cursor.c

258

u8 __iomem *dst = ast_plane_vaddr(ast_plane); /* TODO: Use mapping abstraction properly */

drivers/gpu/drm/ast/ast_cursor.c

259

u8 __iomem *sig = dst + AST_HWC_SIZE; /* TODO: Use mapping abstraction properly */

drivers/gpu/drm/ast/ast_cursor.c

95

u8 __iomem *dst = ast_plane_vaddr(&ast->cursor_plane.base);

drivers/gpu/drm/ast/ast_mode.c

532

struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(ast_plane_vaddr(ast_plane));

drivers/gpu/drm/ast/ast_mode.c

534

iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, clip));

drivers/gpu/drm/ast/ast_mode.c

537

drm_fb_swab(&dst, fb->pitches, src, fb, clip, !src[0].is_iomem, fmtcnv_state);

drivers/gpu/drm/ast/ast_mode.c

539

drm_fb_memcpy(&dst, fb->pitches, src, fb, clip);

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c

750

hstate->crtc_x = s->dst.x1;

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c

751

hstate->crtc_y = s->dst.y1;

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c

752

hstate->crtc_w = drm_rect_width(&s->dst);

drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c

753

hstate->crtc_h = drm_rect_height(&s->dst);

drivers/gpu/drm/bridge/sil-sii8620.c

473

static void sii8620_update_array(u8 *dst, u8 *src, int count)

drivers/gpu/drm/bridge/sil-sii8620.c

476

*src ^= *dst;

drivers/gpu/drm/bridge/sil-sii8620.c

477

*dst++ ^= *src++;

drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c

158

u32 *dst = dw->buf_dst + offset;

drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c

168

*dst++ = sample | b;

drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c

186

u32 *dst = dw->buf_dst + offset;

drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c

205

*dst++ = sample;

drivers/gpu/drm/clients/drm_log.c

73

static void drm_log_blit(struct iosys_map *dst, unsigned int dst_pitch,

drivers/gpu/drm/clients/drm_log.c

79

drm_draw_blit16(dst, dst_pitch, src, src_pitch, height, width, scale, color);

drivers/gpu/drm/clients/drm_log.c

82

drm_draw_blit24(dst, dst_pitch, src, src_pitch, height, width, scale, color);

drivers/gpu/drm/clients/drm_log.c

85

drm_draw_blit32(dst, dst_pitch, src, src_pitch, height, width, scale, color);

drivers/gpu/drm/display/drm_dp_mst_topology.c

2764

struct drm_dp_mst_branch *mstb = txmsg->dst;

drivers/gpu/drm/display/drm_dp_mst_topology.c

2930

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3007

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3032

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3150

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3194

txmsg->dst = port->parent;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3243

txmsg->dst = mgr->mst_primary;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3480

txmsg->dst = port->parent;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3531

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3569

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3951

const struct drm_dp_mst_branch *mstb = txmsg->dst;

drivers/gpu/drm/display/drm_dp_mst_topology.c

3989

if (!txmsg || txmsg->dst != mstb) {

drivers/gpu/drm/display/drm_dp_mst_topology.c

5050

if (txmsg->dst != mstb)

drivers/gpu/drm/display/drm_dp_mst_topology.c

5852

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

5900

txmsg->dst = mstb;

drivers/gpu/drm/display/drm_dp_mst_topology.c

708

drm_dp_mst_rad_to_str(txmsg->dst->rad, txmsg->dst->lct, buf,

drivers/gpu/drm/drm_atomic_helper.c

902

struct drm_rect *dst = &plane_state->dst;

drivers/gpu/drm/drm_atomic_helper.c

910

*dst = drm_plane_state_dest(plane_state);

drivers/gpu/drm/drm_atomic_helper.c

932

hscale = drm_rect_calc_hscale(src, dst, min_scale, max_scale);

drivers/gpu/drm/drm_atomic_helper.c

933

vscale = drm_rect_calc_vscale(src, dst, min_scale, max_scale);

drivers/gpu/drm/drm_atomic_helper.c

938

drm_rect_debug_print("dst: ", &plane_state->dst, false);

drivers/gpu/drm/drm_atomic_helper.c

945

plane_state->visible = drm_rect_clip_scaled(src, dst, &clip);

drivers/gpu/drm/drm_atomic_helper.c

959

if (!can_position && !drm_rect_equals(dst, &clip)) {

drivers/gpu/drm/drm_atomic_helper.c

962

drm_rect_debug_print("dst: ", dst, false);

drivers/gpu/drm/drm_cache.c

211

static void memcpy_fallback(struct iosys_map *dst,

drivers/gpu/drm/drm_cache.c

215

if (!dst->is_iomem && !src->is_iomem) {

drivers/gpu/drm/drm_cache.c

216

memcpy(dst->vaddr, src->vaddr, len);

drivers/gpu/drm/drm_cache.c

218

iosys_map_memcpy_to(dst, 0, src->vaddr, len);

drivers/gpu/drm/drm_cache.c

219

} else if (!dst->is_iomem) {

drivers/gpu/drm/drm_cache.c

220

memcpy_fromio(dst->vaddr, src->vaddr_iomem, len);

drivers/gpu/drm/drm_cache.c

229

void __iomem *_dst = dst->vaddr_iomem;

drivers/gpu/drm/drm_cache.c

249

static void __memcpy_ntdqa(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/drm_cache.c

262

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/drm_cache.c

264

dst += 64;

drivers/gpu/drm/drm_cache.c

270

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/drm_cache.c

272

dst += 16;

drivers/gpu/drm/drm_cache.c

284

static void __drm_memcpy_from_wc(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/drm_cache.c

286

if (unlikely(((unsigned long)dst | (unsigned long)src | len) & 15))

drivers/gpu/drm/drm_cache.c

287

memcpy(dst, src, len);

drivers/gpu/drm/drm_cache.c

289

__memcpy_ntdqa(dst, src, len >> 4);

drivers/gpu/drm/drm_cache.c

302

void drm_memcpy_from_wc(struct iosys_map *dst,

drivers/gpu/drm/drm_cache.c

307

memcpy_fallback(dst, src, len);

drivers/gpu/drm/drm_cache.c

312

__drm_memcpy_from_wc(dst->is_iomem ?

drivers/gpu/drm/drm_cache.c

313

(void __force *)dst->vaddr_iomem :

drivers/gpu/drm/drm_cache.c

314

dst->vaddr,

drivers/gpu/drm/drm_cache.c

322

memcpy_fallback(dst, src, len);

drivers/gpu/drm/drm_cache.c

340

void drm_memcpy_from_wc(struct iosys_map *dst,

drivers/gpu/drm/drm_cache.c

346

memcpy_fallback(dst, src, len);

drivers/gpu/drm/drm_client_modeset.c

272

const struct drm_display_mode **dst,

drivers/gpu/drm/drm_client_modeset.c

275

drm_mode_destroy(dev, (struct drm_display_mode *)*dst);

drivers/gpu/drm/drm_client_modeset.c

277

*dst = src ? drm_mode_duplicate(dev, src) : NULL;

drivers/gpu/drm/drm_fbdev_dma.c

111

struct iosys_map *dst)

drivers/gpu/drm/drm_fbdev_dma.c

139

iosys_map_incr(dst, offset); /* go to first pixel within clip rect */

drivers/gpu/drm/drm_fbdev_dma.c

142

iosys_map_memcpy_to(dst, 0, src, len);

drivers/gpu/drm/drm_fbdev_dma.c

143

iosys_map_incr(dst, fb->pitches[0]);

drivers/gpu/drm/drm_fbdev_dma.c

152

struct iosys_map dst;

drivers/gpu/drm/drm_fbdev_dma.c

161

dst = buffer->map;

drivers/gpu/drm/drm_fbdev_dma.c

162

drm_fbdev_dma_damage_blit_real(fb_helper, clip, &dst);

drivers/gpu/drm/drm_fbdev_ttm.c

100

iosys_map_memcpy_to(dst, 0, src, len);

drivers/gpu/drm/drm_fbdev_ttm.c

101

iosys_map_incr(dst, fb->pitches[0]);

drivers/gpu/drm/drm_fbdev_ttm.c

110

struct iosys_map map, dst;

drivers/gpu/drm/drm_fbdev_ttm.c

130

dst = map;

drivers/gpu/drm/drm_fbdev_ttm.c

131

drm_fbdev_ttm_damage_blit_real(fb_helper, clip, &dst);

drivers/gpu/drm/drm_fbdev_ttm.c

69

struct iosys_map *dst)

drivers/gpu/drm/drm_fbdev_ttm.c

97

iosys_map_incr(dst, offset); /* go to first pixel within clip rect */

drivers/gpu/drm/drm_format_helper.c

1029

void drm_fb_xrgb8888_to_xrgb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1038

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

1070

void drm_fb_xrgb8888_to_argb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1079

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

1115

void drm_fb_xrgb8888_to_gray8(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1123

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

1155

void drm_fb_argb8888_to_argb4444(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1163

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

1235

void drm_fb_xrgb8888_to_mono(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1250

u8 *mono = dst[0].vaddr, *gray8;

drivers/gpu/drm/drm_format_helper.c

1323

void drm_fb_xrgb8888_to_gray2(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

1338

u8 *gray2 = dst[0].vaddr, *gray8;

drivers/gpu/drm/drm_format_helper.c

139

static int __drm_fb_xfrm(void *dst, unsigned long dst_pitch, unsigned long dst_pixsize,

drivers/gpu/drm/drm_format_helper.c

172

xfrm_line(dst, sbuf, linepixels);

drivers/gpu/drm/drm_format_helper.c

174

dst += dst_pitch;

drivers/gpu/drm/drm_format_helper.c

181

static int __drm_fb_xfrm_toio(void __iomem *dst, unsigned long dst_pitch, unsigned long dst_pixsize,

drivers/gpu/drm/drm_format_helper.c

216

memcpy_toio(dst, dbuf, dbuf_len);

drivers/gpu/drm/drm_format_helper.c

218

dst += dst_pitch;

drivers/gpu/drm/drm_format_helper.c

225

static int drm_fb_xfrm(struct iosys_map *dst,

drivers/gpu/drm/drm_format_helper.c

240

if (dst[0].is_iomem)

drivers/gpu/drm/drm_format_helper.c

241

return __drm_fb_xfrm_toio(dst[0].vaddr_iomem, dst_pitch[0], dst_pixsize[0],

drivers/gpu/drm/drm_format_helper.c

245

return __drm_fb_xfrm(dst[0].vaddr, dst_pitch[0], dst_pixsize[0],

drivers/gpu/drm/drm_format_helper.c

414

void drm_fb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

433

struct iosys_map dst_i = dst[i];

drivers/gpu/drm/drm_format_helper.c

492

void drm_fb_swab(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

514

drm_fb_xfrm(dst, dst_pitch, &cpp, src, fb, clip, cached, state, swab_line);

drivers/gpu/drm/drm_format_helper.c

544

void drm_fb_xrgb8888_to_rgb332(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

552

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

583

void drm_fb_xrgb8888_to_rgb565(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

591

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

623

void drm_fb_xrgb8888_to_rgb565be(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

631

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

663

void drm_fb_xrgb8888_to_xrgb1555(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

671

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

703

void drm_fb_xrgb8888_to_argb1555(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

711

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

743

void drm_fb_xrgb8888_to_rgba5551(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

751

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

783

void drm_fb_xrgb8888_to_rgb888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

791

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

823

void drm_fb_xrgb8888_to_bgr888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

831

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

863

void drm_fb_xrgb8888_to_argb8888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

871

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

903

void drm_fb_xrgb8888_to_abgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

913

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

945

void drm_fb_xrgb8888_to_xbgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

955

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_format_helper.c

987

void drm_fb_xrgb8888_to_bgrx8888(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/drm_format_helper.c

997

drm_fb_xfrm(dst, dst_pitch, dst_pixsize, src, fb, clip, false, state,

drivers/gpu/drm/drm_mipi_dbi.c

207

int mipi_dbi_buf_copy(void *dst, struct iosys_map *src, struct drm_framebuffer *fb,

drivers/gpu/drm/drm_mipi_dbi.c

213

struct iosys_map dst_map = IOSYS_MAP_INIT_VADDR(dst);

drivers/gpu/drm/drm_mipi_dbi.c

892

u8 *dst;

drivers/gpu/drm/drm_mipi_dbi.c

906

dst = dbi->tx_buf9;

drivers/gpu/drm/drm_mipi_dbi.c

907

memset(dst, 0, 9);

drivers/gpu/drm/drm_mipi_dbi.c

908

dst[8] = *src;

drivers/gpu/drm/drm_mipi_dbi.c

926

dst = dbi->tx_buf9;

drivers/gpu/drm/drm_mipi_dbi.c

932

memset(dst, 0, 9);

drivers/gpu/drm/drm_mipi_dbi.c

937

*dst++ = carry | BIT(8 - i) | (val >> i);

drivers/gpu/drm/drm_mipi_dbi.c

941

*dst++ = carry | BIT(8 - i) | (val >> i);

drivers/gpu/drm/drm_mipi_dbi.c

945

*dst++ = carry;

drivers/gpu/drm/drm_mipi_dbi.c

949

*dst++ = carry | BIT(8 - i) | (val >> i);

drivers/gpu/drm/drm_mipi_dbi.c

952

*dst++ = carry;

drivers/gpu/drm/drm_mipi_dbi.c

960

*dst++ = BIT(7) | (src[1] >> 1);

drivers/gpu/drm/drm_mipi_dbi.c

961

*dst++ = (src[1] << 7) | BIT(6) | (src[0] >> 2);

drivers/gpu/drm/drm_mipi_dbi.c

962

*dst++ = (src[0] << 6) | BIT(5) | (src[3] >> 3);

drivers/gpu/drm/drm_mipi_dbi.c

963

*dst++ = (src[3] << 5) | BIT(4) | (src[2] >> 4);

drivers/gpu/drm/drm_mipi_dbi.c

964

*dst++ = (src[2] << 4) | BIT(3) | (src[5] >> 5);

drivers/gpu/drm/drm_mipi_dbi.c

965

*dst++ = (src[5] << 3) | BIT(2) | (src[4] >> 6);

drivers/gpu/drm/drm_mipi_dbi.c

966

*dst++ = (src[4] << 2) | BIT(1) | (src[7] >> 7);

drivers/gpu/drm/drm_mipi_dbi.c

967

*dst++ = (src[7] << 1) | BIT(0);

drivers/gpu/drm/drm_mipi_dbi.c

968

*dst++ = src[6];

drivers/gpu/drm/drm_mipi_dbi.c

970

*dst++ = BIT(7) | (src[0] >> 1);

drivers/gpu/drm/drm_mipi_dbi.c

971

*dst++ = (src[0] << 7) | BIT(6) | (src[1] >> 2);

drivers/gpu/drm/drm_mipi_dbi.c

972

*dst++ = (src[1] << 6) | BIT(5) | (src[2] >> 3);

drivers/gpu/drm/drm_mipi_dbi.c

973

*dst++ = (src[2] << 5) | BIT(4) | (src[3] >> 4);

drivers/gpu/drm/drm_mipi_dbi.c

974

*dst++ = (src[3] << 4) | BIT(3) | (src[4] >> 5);

drivers/gpu/drm/drm_mipi_dbi.c

975

*dst++ = (src[4] << 3) | BIT(2) | (src[5] >> 6);

drivers/gpu/drm/drm_mipi_dbi.c

976

*dst++ = (src[5] << 2) | BIT(1) | (src[6] >> 7);

drivers/gpu/drm/drm_mipi_dbi.c

977

*dst++ = (src[6] << 1) | BIT(0);

drivers/gpu/drm/drm_mipi_dbi.c

978

*dst++ = src[7];

drivers/gpu/drm/drm_modes.c

1420

void drm_mode_copy(struct drm_display_mode *dst, const struct drm_display_mode *src)

drivers/gpu/drm/drm_modes.c

1422

struct list_head head = dst->head;

drivers/gpu/drm/drm_modes.c

1424

*dst = *src;

drivers/gpu/drm/drm_modes.c

1425

dst->head = head;

drivers/gpu/drm/drm_modes.c

1439

void drm_mode_init(struct drm_display_mode *dst, const struct drm_display_mode *src)

drivers/gpu/drm/drm_modes.c

1441

memset(dst, 0, sizeof(*dst));

drivers/gpu/drm/drm_modes.c

1442

drm_mode_copy(dst, src);

drivers/gpu/drm/drm_pagemap.c

1001

drm_pagemap_migration_unlock_put_pages(npages, dst);

drivers/gpu/drm/drm_pagemap.c

1002

migrate_device_pages(src, dst, npages);

drivers/gpu/drm/drm_pagemap.c

1003

migrate_device_finalize(src, dst, npages);

drivers/gpu/drm/drm_pagemap.c

1004

drm_pagemap_migrate_unmap_pages(devmem_allocation->dev, pagemap_addr, dst, npages,

drivers/gpu/drm/drm_pagemap.c

1088

migrate.dst = migrate.src + npages;

drivers/gpu/drm/drm_pagemap.c

1102

migrate.src, migrate.dst,

drivers/gpu/drm/drm_pagemap.c

1107

err = drm_pagemap_migrate_map_pages(dev, zdd->dpagemap, pagemap_addr, migrate.dst, npages,

drivers/gpu/drm/drm_pagemap.c

1121

drm_pagemap_migration_unlock_put_pages(npages, migrate.dst);

drivers/gpu/drm/drm_pagemap.c

1125

drm_pagemap_migrate_unmap_pages(dev, pagemap_addr, migrate.dst,

drivers/gpu/drm/drm_pagemap.c

537

migrate.dst = migrate.src + npages;

drivers/gpu/drm/drm_pagemap.c

583

err = ops->populate_devmem_pfn(devmem_allocation, npages, migrate.dst);

drivers/gpu/drm/drm_pagemap.c

590

struct page *page = pfn_to_page(migrate.dst[i]);

drivers/gpu/drm/drm_pagemap.c

600

migrate.dst[i] = 0;

drivers/gpu/drm/drm_pagemap.c

617

migrate.dst[i] = migrate_pfn(migrate.dst[i]);

drivers/gpu/drm/drm_pagemap.c

621

err = drm_pagemap_migrate_range(devmem_allocation, migrate.src, migrate.dst,

drivers/gpu/drm/drm_pagemap.c

631

err = drm_pagemap_migrate_range(devmem_allocation, migrate.src, migrate.dst,

drivers/gpu/drm/drm_pagemap.c

647

drm_pagemap_migration_unlock_put_pages(npages, migrate.dst);

drivers/gpu/drm/drm_pagemap.c

949

unsigned long *src, *dst;

drivers/gpu/drm/drm_pagemap.c

968

dst = buf + (sizeof(*src) * npages);

drivers/gpu/drm/drm_pagemap.c

981

src, dst, 0);

drivers/gpu/drm/drm_pagemap.c

987

dst, npages, DMA_FROM_DEVICE,

drivers/gpu/drm/drm_plane_helper.c

115

.crtc_x = dst->x1,

drivers/gpu/drm/drm_plane_helper.c

116

.crtc_y = dst->y1,

drivers/gpu/drm/drm_plane_helper.c

117

.crtc_w = drm_rect_width(dst),

drivers/gpu/drm/drm_plane_helper.c

118

.crtc_h = drm_rect_height(dst),

drivers/gpu/drm/drm_plane_helper.c

136

*dst = plane_state.dst;

drivers/gpu/drm/drm_plane_helper.c

99

struct drm_rect *dst,

drivers/gpu/drm/drm_rect.c

102

dst->x1 += diff;

drivers/gpu/drm/drm_rect.c

104

diff = clip->y1 - dst->y1;

drivers/gpu/drm/drm_rect.c

107

drm_rect_height(dst), &diff);

drivers/gpu/drm/drm_rect.c

110

dst->y1 += diff;

drivers/gpu/drm/drm_rect.c

112

diff = dst->x2 - clip->x2;

drivers/gpu/drm/drm_rect.c

115

drm_rect_width(dst), &diff);

drivers/gpu/drm/drm_rect.c

118

dst->x2 -= diff;

drivers/gpu/drm/drm_rect.c

120

diff = dst->y2 - clip->y2;

drivers/gpu/drm/drm_rect.c

123

drm_rect_height(dst), &diff);

drivers/gpu/drm/drm_rect.c

126

dst->y2 -= diff;

drivers/gpu/drm/drm_rect.c

129

return drm_rect_visible(dst);

drivers/gpu/drm/drm_rect.c

133

static int drm_calc_scale(int src, int dst)

drivers/gpu/drm/drm_rect.c

137

if (WARN_ON(src < 0 || dst < 0))

drivers/gpu/drm/drm_rect.c

140

if (dst == 0)

drivers/gpu/drm/drm_rect.c

143

if (src > (dst << 16))

drivers/gpu/drm/drm_rect.c

144

return DIV_ROUND_UP(src, dst);

drivers/gpu/drm/drm_rect.c

146

scale = src / dst;

drivers/gpu/drm/drm_rect.c

169

const struct drm_rect *dst,

drivers/gpu/drm/drm_rect.c

173

int dst_w = drm_rect_width(dst);

drivers/gpu/drm/drm_rect.c

204

const struct drm_rect *dst,

drivers/gpu/drm/drm_rect.c

208

int dst_h = drm_rect_height(dst);

drivers/gpu/drm/drm_rect.c

55

static u32 clip_scaled(int src, int dst, int *clip)

drivers/gpu/drm/drm_rect.c

59

if (dst == 0)

drivers/gpu/drm/drm_rect.c

63

*clip = min(*clip, dst);

drivers/gpu/drm/drm_rect.c

65

tmp = mul_u32_u32(src, dst - *clip);

drivers/gpu/drm/drm_rect.c

71

if (src < (dst << 16))

drivers/gpu/drm/drm_rect.c

72

return DIV_ROUND_UP_ULL(tmp, dst);

drivers/gpu/drm/drm_rect.c

74

return DIV_ROUND_DOWN_ULL(tmp, dst);

drivers/gpu/drm/drm_rect.c

91

bool drm_rect_clip_scaled(struct drm_rect *src, struct drm_rect *dst,

drivers/gpu/drm/drm_rect.c

96

diff = clip->x1 - dst->x1;

drivers/gpu/drm/drm_rect.c

99

drm_rect_width(dst), &diff);

drivers/gpu/drm/exynos/exynos_drm_fimc.c

1100

fimc_dst_set_fmt(ctx, task->dst.buf.fourcc, task->dst.buf.modifier);

drivers/gpu/drm/exynos/exynos_drm_fimc.c

1102

fimc_dst_set_size(ctx, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_fimc.c

1103

fimc_dst_set_addr(ctx, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_fimc.c

1104

fimc_set_prescaler(ctx, &ctx->sc, &task->src.rect, &task->dst.rect);

drivers/gpu/drm/exynos/exynos_drm_fimc.c

738

struct drm_exynos_ipp_task_rect *dst)

drivers/gpu/drm/exynos/exynos_drm_fimc.c

756

dst_w = dst->h;

drivers/gpu/drm/exynos/exynos_drm_fimc.c

757

dst_h = dst->w;

drivers/gpu/drm/exynos/exynos_drm_fimc.c

759

dst_w = dst->w;

drivers/gpu/drm/exynos/exynos_drm_fimc.c

760

dst_h = dst->h;

drivers/gpu/drm/exynos/exynos_drm_gsc.c

1139

gsc_dst_set_fmt(ctx, task->dst.buf.fourcc, task->dst.buf.modifier);

drivers/gpu/drm/exynos/exynos_drm_gsc.c

1140

gsc_dst_set_size(ctx, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_gsc.c

1141

gsc_dst_set_addr(ctx, 0, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_gsc.c

1142

gsc_set_prescaler(ctx, &ctx->sc, &task->src.rect, &task->dst.rect);

drivers/gpu/drm/exynos/exynos_drm_gsc.c

708

static int gsc_get_ratio_shift(struct gsc_context *ctx, u32 src, u32 dst,

drivers/gpu/drm/exynos/exynos_drm_gsc.c

711

DRM_DEV_DEBUG_KMS(ctx->dev, "src[%d]dst[%d]\n", src, dst);

drivers/gpu/drm/exynos/exynos_drm_gsc.c

713

if (src >= dst * 8) {

drivers/gpu/drm/exynos/exynos_drm_gsc.c

716

} else if (src >= dst * 4)

drivers/gpu/drm/exynos/exynos_drm_gsc.c

718

else if (src >= dst * 2)

drivers/gpu/drm/exynos/exynos_drm_gsc.c

745

struct drm_exynos_ipp_task_rect *dst)

drivers/gpu/drm/exynos/exynos_drm_gsc.c

755

dst_w = dst->h;

drivers/gpu/drm/exynos/exynos_drm_gsc.c

756

dst_h = dst->w;

drivers/gpu/drm/exynos/exynos_drm_gsc.c

758

dst_w = dst->w;

drivers/gpu/drm/exynos/exynos_drm_gsc.c

759

dst_h = dst->h;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

271

task->src.rect.w = task->dst.rect.w = UINT_MAX;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

272

task->src.rect.h = task->dst.rect.h = UINT_MAX;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

293

offsetof(struct exynos_drm_ipp_task, dst.buf),

drivers/gpu/drm/exynos/exynos_drm_ipp.c

302

offsetof(struct exynos_drm_ipp_task, dst.rect),

drivers/gpu/drm/exynos/exynos_drm_ipp.c

401

exynos_drm_ipp_task_release_buf(&task->dst);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

507

static inline bool __scale_limit_check(unsigned int src, unsigned int dst,

drivers/gpu/drm/exynos/exynos_drm_ipp.c

510

if ((max && (dst << 16) > src * max) ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

511

(min && (dst << 16) < src * min)) {

drivers/gpu/drm/exynos/exynos_drm_ipp.c

513

src, dst,

drivers/gpu/drm/exynos/exynos_drm_ipp.c

523

struct drm_exynos_ipp_task_rect *dst,

drivers/gpu/drm/exynos/exynos_drm_ipp.c

539

dw = (!swap) ? dst->w : dst->h;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

540

dh = (!swap) ? dst->h : dst->w;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

552

struct exynos_drm_ipp_buffer *dst,

drivers/gpu/drm/exynos/exynos_drm_ipp.c

594

buf == dst ? swap : false);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

597

ret = exynos_drm_ipp_check_scale_limits(&src->rect, &dst->rect,

drivers/gpu/drm/exynos/exynos_drm_ipp.c

606

struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

619

if (dst->rect.w == UINT_MAX)

drivers/gpu/drm/exynos/exynos_drm_ipp.c

620

dst->rect.w = dst->buf.width;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

621

if (dst->rect.h == UINT_MAX)

drivers/gpu/drm/exynos/exynos_drm_ipp.c

622

dst->rect.h = dst->buf.height;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

626

dst->rect.x + dst->rect.w > (dst->buf.width) ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

627

dst->rect.y + dst->rect.h > (dst->buf.height)) {

drivers/gpu/drm/exynos/exynos_drm_ipp.c

634

if ((!swap && (src->rect.w != dst->rect.w ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

635

src->rect.h != dst->rect.h)) ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

636

(swap && (src->rect.w != dst->rect.h ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

637

src->rect.h != dst->rect.w)))

drivers/gpu/drm/exynos/exynos_drm_ipp.c

641

(src->rect.x || src->rect.y || dst->rect.x || dst->rect.y)) ||

drivers/gpu/drm/exynos/exynos_drm_ipp.c

645

src->buf.fourcc != dst->buf.fourcc)) {

drivers/gpu/drm/exynos/exynos_drm_ipp.c

651

ret = exynos_drm_ipp_check_format(task, src, src, dst, rotate, swap);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

655

ret = exynos_drm_ipp_check_format(task, dst, src, dst, false, swap);

drivers/gpu/drm/exynos/exynos_drm_ipp.c

668

struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst;

drivers/gpu/drm/exynos/exynos_drm_ipp.c

681

ret = exynos_drm_ipp_task_setup_buffer(dst, filp);

drivers/gpu/drm/exynos/exynos_drm_ipp.h

88

struct exynos_drm_ipp_buffer dst;

drivers/gpu/drm/exynos/exynos_drm_rotator.c

234

rotator_dst_set_buf(rot, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_scaler.c

364

struct drm_exynos_ipp_task_rect *dst_pos = &task->dst.rect;

drivers/gpu/drm/exynos/exynos_drm_scaler.c

369

dst_fmt = scaler_get_format(task->dst.buf.fourcc);

drivers/gpu/drm/exynos/exynos_drm_scaler.c

388

scaler_set_dst_base(scaler, &task->dst);

drivers/gpu/drm/exynos/exynos_drm_scaler.c

389

scaler_set_dst_span(scaler, &task->dst);

drivers/gpu/drm/gma500/cdv_intel_dp.c

557

unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)

drivers/gpu/drm/gma500/cdv_intel_dp.c

563

dst[i] = src >> ((3-i) * 8);

drivers/gpu/drm/gud/gud_internal.h

129

static inline void gud_from_display_mode(struct gud_display_mode_req *dst,

drivers/gpu/drm/gud/gud_internal.h

137

dst->clock = cpu_to_le32(src->clock);

drivers/gpu/drm/gud/gud_internal.h

138

dst->hdisplay = cpu_to_le16(src->hdisplay);

drivers/gpu/drm/gud/gud_internal.h

139

dst->hsync_start = cpu_to_le16(src->hsync_start);

drivers/gpu/drm/gud/gud_internal.h

140

dst->hsync_end = cpu_to_le16(src->hsync_end);

drivers/gpu/drm/gud/gud_internal.h

141

dst->htotal = cpu_to_le16(src->htotal);

drivers/gpu/drm/gud/gud_internal.h

142

dst->vdisplay = cpu_to_le16(src->vdisplay);

drivers/gpu/drm/gud/gud_internal.h

143

dst->vsync_start = cpu_to_le16(src->vsync_start);

drivers/gpu/drm/gud/gud_internal.h

144

dst->vsync_end = cpu_to_le16(src->vsync_end);

drivers/gpu/drm/gud/gud_internal.h

145

dst->vtotal = cpu_to_le16(src->vtotal);

drivers/gpu/drm/gud/gud_internal.h

146

dst->flags = cpu_to_le32(flags);

drivers/gpu/drm/gud/gud_internal.h

149

static inline void gud_to_display_mode(struct drm_display_mode *dst,

drivers/gpu/drm/gud/gud_internal.h

154

memset(dst, 0, sizeof(*dst));

drivers/gpu/drm/gud/gud_internal.h

155

dst->clock = le32_to_cpu(src->clock);

drivers/gpu/drm/gud/gud_internal.h

156

dst->hdisplay = le16_to_cpu(src->hdisplay);

drivers/gpu/drm/gud/gud_internal.h

157

dst->hsync_start = le16_to_cpu(src->hsync_start);

drivers/gpu/drm/gud/gud_internal.h

158

dst->hsync_end = le16_to_cpu(src->hsync_end);

drivers/gpu/drm/gud/gud_internal.h

159

dst->htotal = le16_to_cpu(src->htotal);

drivers/gpu/drm/gud/gud_internal.h

160

dst->vdisplay = le16_to_cpu(src->vdisplay);

drivers/gpu/drm/gud/gud_internal.h

161

dst->vsync_start = le16_to_cpu(src->vsync_start);

drivers/gpu/drm/gud/gud_internal.h

162

dst->vsync_end = le16_to_cpu(src->vsync_end);

drivers/gpu/drm/gud/gud_internal.h

163

dst->vtotal = le16_to_cpu(src->vtotal);

drivers/gpu/drm/gud/gud_internal.h

164

dst->flags = flags & GUD_DISPLAY_MODE_FLAG_USER_MASK;

drivers/gpu/drm/gud/gud_internal.h

165

dst->type = DRM_MODE_TYPE_DRIVER;

drivers/gpu/drm/gud/gud_internal.h

167

dst->type |= DRM_MODE_TYPE_PREFERRED;

drivers/gpu/drm/gud/gud_internal.h

168

drm_mode_set_name(dst);

drivers/gpu/drm/gud/gud_pipe.c

101

static size_t gud_xrgb8888_to_color(u8 *dst, const struct drm_format_info *format,

drivers/gpu/drm/gud/gud_pipe.c

107

u8 r, g, b, pix, *block = dst; /* Assign to silence compiler warning */

drivers/gpu/drm/gud/gud_pipe.c

127

block = dst++;

drivers/gpu/drm/gud/gud_pipe.c

159

struct iosys_map dst;

drivers/gpu/drm/gud/gud_pipe.c

174

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/gud/gud_pipe.c

186

drm_fb_xrgb8888_to_gray8(&dst, NULL, src, fb, rect, fmtcnv_state);

drivers/gpu/drm/gud/gud_pipe.c

188

drm_fb_xrgb8888_to_rgb332(&dst, NULL, src, fb, rect, fmtcnv_state);

drivers/gpu/drm/gud/gud_pipe.c

191

drm_fb_xrgb8888_to_rgb565be(&dst, NULL, src, fb, rect,

drivers/gpu/drm/gud/gud_pipe.c

194

drm_fb_xrgb8888_to_rgb565(&dst, NULL, src, fb, rect,

drivers/gpu/drm/gud/gud_pipe.c

198

drm_fb_xrgb8888_to_rgb888(&dst, NULL, src, fb, rect, fmtcnv_state);

drivers/gpu/drm/gud/gud_pipe.c

203

drm_fb_swab(&dst, NULL, src, fb, rect, cached_reads, fmtcnv_state);

drivers/gpu/drm/gud/gud_pipe.c

208

drm_fb_memcpy(&dst, NULL, src, fb, rect);

drivers/gpu/drm/gud/gud_pipe.c

51

static size_t gud_xrgb8888_to_r124(u8 *dst, const struct drm_format_info *format,

drivers/gpu/drm/gud/gud_pipe.c

59

u8 pix, *pix8, *block = dst; /* Assign to silence compiler warning */

drivers/gpu/drm/gud/gud_pipe.c

87

block = dst++;

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

183

dst_clip = new_state->dst;

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

33

struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(hv->vram);

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

39

iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, rect));

drivers/gpu/drm/hyperv/hyperv_drm_modeset.c

40

drm_fb_memcpy(&dst, fb->pitches, vmap, fb, rect);

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

451

int crtc_x = plane_state->uapi.dst.x1;

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

452

int crtc_y = plane_state->uapi.dst.y1;

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

453

int crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

454

int crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

487

int crtc_x = plane_state->uapi.dst.x1;

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

488

int crtc_y = plane_state->uapi.dst.y1;

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

489

int crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

490

int crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

733

drm_rect_width(&old_plane_state->uapi.dst) != drm_rect_width(&new_plane_state->uapi.dst) ||

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

734

drm_rect_height(&old_plane_state->uapi.dst) != drm_rect_height(&new_plane_state->uapi.dst))

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

43

int intel_bo_read_from_page(struct drm_gem_object *obj, u64 offset, void *dst, int size)

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

45

return i915_gem_object_read_from_page(to_intel_bo(obj), offset, dst, size);

drivers/gpu/drm/i915/display/intel_bo.h

21

int intel_bo_read_from_page(struct drm_gem_object *obj, u64 offset, void *dst, int size);

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

458

struct intel_csc_matrix *dst,

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

461

*dst = *src;

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

464

memset(dst->postoff, 0, sizeof(dst->postoff));

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

136

DRM_RECT_ARG(&plane_state->uapi.dst));

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

344

DRM_RECT_ARG(&pipe_config->pch_pfit.dst),

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

144

const struct drm_rect dst = plane_state->uapi.dst;

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

162

plane_state->uapi.dst = dst;

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

165

drm_rect_translate(&plane_state->uapi.dst,

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

217

int width = drm_rect_width(&plane_state->uapi.dst);

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

247

drm_rect_width(&plane_state->uapi.dst),

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

248

drm_rect_height(&plane_state->uapi.dst));

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

283

unsigned int width = drm_rect_width(&plane_state->uapi.dst);

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

284

unsigned int height = drm_rect_height(&plane_state->uapi.dst);

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

408

switch (drm_rect_width(&plane_state->uapi.dst)) {

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

419

MISSING_CASE(drm_rect_width(&plane_state->uapi.dst));

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

436

int width = drm_rect_width(&plane_state->uapi.dst);

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

437

int height = drm_rect_height(&plane_state->uapi.dst);

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

45

int x = plane_state->uapi.dst.x1;

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

46

int y = plane_state->uapi.dst.y1;

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

492

drm_rect_width(&plane_state->uapi.dst),

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

493

drm_rect_height(&plane_state->uapi.dst));

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

501

drm_rect_width(&plane_state->uapi.dst) * fb->format->cpp[0]) {

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

505

fb->pitches[0], drm_rect_width(&plane_state->uapi.dst));

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

520

plane_state->uapi.visible && plane_state->uapi.dst.x1 < 0) {

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

55

y = max(-1 * drm_rect_height(&plane_state->uapi.dst) + 1,

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

659

int width = drm_rect_width(&plane_state->uapi.dst);

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

660

int height = drm_rect_height(&plane_state->uapi.dst);

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

77

int width = drm_rect_width(&plane_state->uapi.dst);

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

78

int height = drm_rect_height(&plane_state->uapi.dst);

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

2206

return intel_adjusted_rate(&src, &crtc_state->pch_pfit.dst,

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

5360

PIPE_CONF_CHECK_RECT(pch_pfit.dst);

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

6189

!drm_rect_equals(&old_plane_state->uapi.dst, &new_plane_state->uapi.dst)) {

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

347

struct drm_rect src, dst;

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

351

dst = drm_plane_state_dest(&plane_state->uapi);

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

365

DRM_RECT_FP_ARG(&src), DRM_RECT_ARG(&dst), rot_str);

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

392

DRM_RECT_ARG(&plane_state->uapi.dst),

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

1650

static void display_platforms_or(struct intel_display_platforms *dst,

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

1653

bitmap_or(dst->bitmap, dst->bitmap, src->bitmap, display_platforms_num_bits());

drivers/gpu/drm/i915/display/intel_display_trace.h

421

__array(int, dst, 4)

drivers/gpu/drm/i915/display/intel_display_trace.h

433

memcpy(__entry->dst, &plane_state->uapi.dst, sizeof(__entry->dst));

drivers/gpu/drm/i915/display/intel_display_trace.h

440

DRM_RECT_ARG((const struct drm_rect *)__entry->dst))

drivers/gpu/drm/i915/display/intel_display_trace.h

454

__array(int, dst, 4)

drivers/gpu/drm/i915/display/intel_display_trace.h

466

memcpy(__entry->dst, &plane_state->uapi.dst, sizeof(__entry->dst));

drivers/gpu/drm/i915/display/intel_display_trace.h

473

DRM_RECT_ARG((const struct drm_rect *)__entry->dst))

drivers/gpu/drm/i915/display/intel_display_types.h

1225

struct drm_rect dst;

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

47

static void intel_dp_aux_unpack(u32 src, u8 *dst, int dst_bytes)

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

54

dst[i] = src >> ((3 - i) * 8);

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

112

const struct drm_rect *dst = &crtc_state->pch_pfit.dst;

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

120

hscale = drm_rect_calc_hscale(&src, dst, 0, max_scale);

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

125

pipe_src_w, drm_rect_width(dst),

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

130

vscale = drm_rect_calc_vscale(&src, dst, 0, max_scale);

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

135

pipe_src_h, drm_rect_height(dst),

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

25

const struct drm_rect *dst = &crtc_state->pch_pfit.dst;

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

252

drm_rect_init(&crtc_state->pch_pfit.dst,

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

26

int width = drm_rect_width(dst);

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

27

int height = drm_rect_height(dst);

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

28

int x = dst->x1;

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

29

int y = dst->y1;

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

35

crtc->base.base.id, crtc->base.name, DRM_RECT_ARG(dst));

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

52

crtc->base.base.id, crtc->base.name, DRM_RECT_ARG(dst));

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

575

const struct drm_rect *dst = &crtc_state->pch_pfit.dst;

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

577

int width = drm_rect_width(dst);

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

578

int height = drm_rect_height(dst);

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

579

int x = dst->x1;

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

580

int y = dst->y1;

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

63

crtc->base.base.id, crtc->base.name, DRM_RECT_ARG(dst));

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

640

drm_rect_init(&crtc_state->pch_pfit.dst,

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

1022

struct drm_rect *dst = &plane_state->uapi.dst;

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

1035

hscale = drm_rect_calc_hscale(src, dst, min_scale, max_scale);

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

1036

vscale = drm_rect_calc_vscale(src, dst, min_scale, max_scale);

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

1041

DRM_RECT_FP_ARG(src), DRM_RECT_ARG(dst));

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

1049

plane_state->uapi.visible = drm_rect_clip_scaled(src, dst, clip);

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

1054

!drm_rect_equals(dst, clip)) {

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

1058

DRM_RECT_ARG(dst), DRM_RECT_ARG(clip));

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

1063

drm_rect_translate(dst, -clip->x1, -clip->y1);

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

1505

y_plane_state->uapi.dst = uv_plane_state->uapi.dst;

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

207

const struct drm_rect *dst,

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

214

dst_w = drm_rect_width(dst);

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

215

dst_h = drm_rect_height(dst);

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

241

&plane_state->uapi.dst,

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

295

&plane_state->uapi.dst,

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

422

plane_state->uapi.dst = drm_plane_state_dest(&from_plane_state->uapi);

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

467

int dst_w = drm_rect_width(&plane_state->uapi.dst);

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

468

int dst_h = drm_rect_height(&plane_state->uapi.dst);

drivers/gpu/drm/i915/display/intel_plane.h

29

const struct drm_rect *dst,

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

2757

if (!drm_rect_intersect(&inter, &new_plane_state->uapi.dst))

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

2760

clip_area_update(&crtc_state->psr2_su_area, &new_plane_state->uapi.dst,

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

2777

if (plane_state->uapi.dst.y1 < 0 ||

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

2778

plane_state->uapi.dst.x1 < 0 ||

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

2903

!drm_rect_equals(&new_plane_state->uapi.dst,

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

2904

&old_plane_state->uapi.dst)) {

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

2906

damaged_area.y1 = old_plane_state->uapi.dst.y1;

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

2907

damaged_area.y2 = old_plane_state->uapi.dst.y2;

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

2913

damaged_area.y1 = new_plane_state->uapi.dst.y1;

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

2914

damaged_area.y2 = new_plane_state->uapi.dst.y2;

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

2921

damaged_area.y1 = new_plane_state->uapi.dst.y1;

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

2922

damaged_area.y2 = new_plane_state->uapi.dst.y2;

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

2935

damaged_area.y1 += new_plane_state->uapi.dst.y1 - src.y1;

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

2936

damaged_area.y2 += new_plane_state->uapi.dst.y1 - src.y1;

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

2937

damaged_area.x1 += new_plane_state->uapi.dst.x1 - src.x1;

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

2938

damaged_area.x2 += new_plane_state->uapi.dst.x1 - src.x1;

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

3007

if (!drm_rect_intersect(&inter, &new_plane_state->uapi.dst)) {

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

3026

sel_fetch_area->y1 = inter.y1 - new_plane_state->uapi.dst.y1;

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

3027

sel_fetch_area->y2 = inter.y2 - new_plane_state->uapi.dst.y1;

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

1142

int crtc_x = plane_state->uapi.dst.x1;

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

1143

int crtc_y = plane_state->uapi.dst.y1;

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

1144

u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

1145

u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

1277

const struct drm_rect *dst = &plane_state->uapi.dst;

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

1286

crtc_w = drm_rect_width(dst);

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

1287

crtc_h = drm_rect_height(dst);

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

374

int crtc_x = plane_state->uapi.dst.x1;

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

375

int crtc_y = plane_state->uapi.dst.y1;

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

376

u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

377

u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

582

dst_w = drm_rect_width(&plane_state->uapi.dst);

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

796

int crtc_x = plane_state->uapi.dst.x1;

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

797

int crtc_y = plane_state->uapi.dst.y1;

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

798

u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

799

u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

931

&plane_state->uapi.dst,

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

275

width = drm_rect_width(&crtc_state->pch_pfit.dst);

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

276

height = drm_rect_height(&crtc_state->pch_pfit.dst);

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

319

drm_rect_width(&plane_state->uapi.dst),

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

320

drm_rect_height(&plane_state->uapi.dst),

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

449

const struct drm_rect *dst = &plane_state->uapi.dst;

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

462

hscale = drm_rect_calc_hscale(src, dst, 1, max_hscale);

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

463

vscale = drm_rect_calc_vscale(src, dst, 1, max_vscale);

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

470

drm_rect_debug_print("dst: ", dst, false);

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

497

hscale = drm_rect_calc_hscale(&src, &crtc_state->pch_pfit.dst,

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

499

vscale = drm_rect_calc_vscale(&src, &crtc_state->pch_pfit.dst,

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

507

drm_rect_debug_print("dst: ", &crtc_state->pch_pfit.dst, false);

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

807

const struct drm_rect *dst = &crtc_state->pch_pfit.dst;

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

810

int width = drm_rect_width(dst);

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

811

int height = drm_rect_height(dst);

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

812

int x = dst->x1;

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

813

int y = dst->y1;

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

833

hscale = drm_rect_calc_hscale(&src, dst, 0, INT_MAX);

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

834

vscale = drm_rect_calc_vscale(&src, dst, 0, INT_MAX);

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

873

int crtc_x = plane_state->uapi.dst.x1;

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

874

int crtc_y = plane_state->uapi.dst.y1;

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

875

u32 crtc_w = drm_rect_width(&plane_state->uapi.dst);

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

876

u32 crtc_h = drm_rect_height(&plane_state->uapi.dst);

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

883

&plane_state->uapi.dst,

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

886

&plane_state->uapi.dst,

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

996

drm_rect_init(&crtc_state->pch_pfit.dst,

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

1413

int crtc_x = plane_state->uapi.dst.x1;

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

1414

int crtc_y = plane_state->uapi.dst.y1;

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

1519

y = max(0, plane_state->uapi.dst.y1 - crtc_state->psr2_su_area.y1);

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

1521

y = (clip->y1 + plane_state->uapi.dst.y1);

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

1523

val |= plane_state->uapi.dst.x1;

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

1559

int crtc_x = plane_state->uapi.dst.x1;

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

1560

int crtc_y = plane_state->uapi.dst.y1;

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

1851

int crtc_x = plane_state->uapi.dst.x1;

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

1852

int crtc_w = drm_rect_width(&plane_state->uapi.dst);

drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c

32

struct scatterlist *src, *dst;

drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c

49

dst = sgt->sgl;

drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c

51

sg_set_page(dst, sg_page(src), src->length, 0);

drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c

52

dst = sg_next(dst);

drivers/gpu/drm/i915/gem/i915_gem_object.c

502

i915_gem_object_read_from_page_kmap(struct drm_i915_gem_object *obj, u64 offset, void *dst, int size)

drivers/gpu/drm/i915/gem/i915_gem_object.c

511

memcpy(dst, src_ptr, size);

drivers/gpu/drm/i915/gem/i915_gem_object.c

517

i915_gem_object_read_from_page_iomap(struct drm_i915_gem_object *obj, u64 offset, void *dst, int size)

drivers/gpu/drm/i915/gem/i915_gem_object.c

529

if (!i915_memcpy_from_wc(dst, (void __force *)src_ptr, size))

drivers/gpu/drm/i915/gem/i915_gem_object.c

530

memcpy_fromio(dst, src_ptr, size);

drivers/gpu/drm/i915/gem/i915_gem_object.c

559

int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, void *dst, int size)

drivers/gpu/drm/i915/gem/i915_gem_object.c

567

i915_gem_object_read_from_page_kmap(obj, offset, dst, size);

drivers/gpu/drm/i915/gem/i915_gem_object.c

569

i915_gem_object_read_from_page_iomap(obj, offset, dst, size);

drivers/gpu/drm/i915/gem/i915_gem_object.h

814

int i915_gem_object_read_from_page(struct drm_i915_gem_object *obj, u64 offset, void *dst, int size);

drivers/gpu/drm/i915/gem/i915_gem_phys.c

29

void *dst;

drivers/gpu/drm/i915/gem/i915_gem_phys.c

65

dst = vaddr;

drivers/gpu/drm/i915/gem/i915_gem_phys.c

73

memcpy_from_page(dst, page, 0, PAGE_SIZE);

drivers/gpu/drm/i915/gem/i915_gem_phys.c

74

drm_clflush_virt_range(dst, PAGE_SIZE);

drivers/gpu/drm/i915/gem/i915_gem_phys.c

77

dst += PAGE_SIZE;

drivers/gpu/drm/i915/gem/i915_gem_ttm_move.c

704

int i915_gem_obj_copy_ttm(struct drm_i915_gem_object *dst,

drivers/gpu/drm/i915/gem/i915_gem_ttm_move.c

708

struct ttm_buffer_object *dst_bo = i915_gem_to_ttm(dst);

drivers/gpu/drm/i915/gem/i915_gem_ttm_move.c

718

assert_object_held(dst);

drivers/gpu/drm/i915/gem/i915_gem_ttm_move.c

742

dst_rsgt = i915_ttm_resource_get_st(dst, dst_bo->resource);

drivers/gpu/drm/i915/gem/i915_gem_ttm_move.h

27

int i915_gem_obj_copy_ttm(struct drm_i915_gem_object *dst,

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

144

struct blit_buffer *dst,

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

157

if (fast_blit_ok(dst) && fast_blit_ok(src)) {

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

182

if (dst->tiling == CLIENT_TILING_Y) {

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

186

} else if (dst->tiling == CLIENT_TILING_X) {

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

197

*cs++ = lower_32_bits(i915_vma_offset(dst->vma));

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

198

*cs++ = upper_32_bits(i915_vma_offset(dst->vma));

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

210

if (dst->tiling == CLIENT_TILING_Y)

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

234

if (dst->tiling) {

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

243

*cs++ = lower_32_bits(i915_vma_offset(dst->vma));

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

245

*cs++ = upper_32_bits(i915_vma_offset(dst->vma));

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

475

struct blit_buffer *dst, u64 dst_addr,

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

487

err = pin_buffer(dst->vma, dst_addr);

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

499

err = prepare_blit(t, dst, src, t->batch->obj);

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

513

err = igt_vma_move_to_active_unlocked(dst->vma, rq, 0);

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

525

dst->start_val = src->start_val;

drivers/gpu/drm/i915/gem/selftests/i915_gem_client_blt.c

529

i915_vma_unpin(dst->vma);

drivers/gpu/drm/i915/gem/selftests/i915_gem_migrate.c

47

enum intel_region_id dst)

drivers/gpu/drm/i915/gem/selftests/i915_gem_migrate.c

51

struct intel_memory_region *dst_mr = i915->mm.regions[dst];

drivers/gpu/drm/i915/gem/selftests/i915_gem_migrate.c

73

err = i915_gem_object_migrate(obj, &ww, dst);

drivers/gpu/drm/i915/gt/intel_engine_regs.h

141

#define BLIT_CCTL_MOCS(dst, src) \

drivers/gpu/drm/i915/gt/intel_engine_regs.h

142

(REG_FIELD_PREP(BLIT_CCTL_DST_MOCS_MASK, (dst) << 1) | \

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1630

copy_ports(struct i915_request **dst, struct i915_request **src, int count)

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1634

WRITE_ONCE(*dst++, *src++); /* avoid write tearing */

drivers/gpu/drm/i915/gt/intel_migrate.c

1084

struct scatterlist *dst,

drivers/gpu/drm/i915/gt/intel_migrate.c

1107

dst, dst_pat_index, dst_is_lmem,

drivers/gpu/drm/i915/gt/intel_migrate.c

683

struct scatterlist *dst,

drivers/gpu/drm/i915/gt/intel_migrate.c

688

struct sgt_dma it_src = sg_sgt(src), it_dst = sg_sgt(dst), it_ccs;

drivers/gpu/drm/i915/gt/intel_migrate.c

712

dst_sz = scatter_list_length(dst);

drivers/gpu/drm/i915/gt/intel_migrate.h

30

struct scatterlist *dst,

drivers/gpu/drm/i915/gt/intel_migrate.h

40

struct scatterlist *dst,

drivers/gpu/drm/i915/gt/selftest_migrate.c

100

i915_gem_object_unpin_map(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

1006

dst->mm.pages->sgl,

drivers/gpu/drm/i915/gt/selftest_migrate.c

1009

i915_gem_object_is_lmem(dst),

drivers/gpu/drm/i915/gt/selftest_migrate.c

1012

i915_gem_object_unlock(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

1013

i915_gem_object_put(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

126

i915_gem_object_unpin_map(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

130

i915_gem_object_put(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

40

struct drm_i915_gem_object *dst,

drivers/gpu/drm/i915/gt/selftest_migrate.c

413

struct drm_i915_gem_object *dst,

drivers/gpu/drm/i915/gt/selftest_migrate.c

419

dst->mm.pages->sgl, dst->pat_index,

drivers/gpu/drm/i915/gt/selftest_migrate.c

420

i915_gem_object_is_lmem(dst),

drivers/gpu/drm/i915/gt/selftest_migrate.c

427

struct drm_i915_gem_object *dst,

drivers/gpu/drm/i915/gt/selftest_migrate.c

433

dst->mm.pages->sgl, dst->pat_index,

drivers/gpu/drm/i915/gt/selftest_migrate.c

434

i915_gem_object_is_lmem(dst),

drivers/gpu/drm/i915/gt/selftest_migrate.c

45

struct drm_i915_gem_object *src, *dst;

drivers/gpu/drm/i915/gt/selftest_migrate.c

57

dst = i915_gem_object_create_internal(i915, sz);

drivers/gpu/drm/i915/gt/selftest_migrate.c

58

if (IS_ERR(dst))

drivers/gpu/drm/i915/gt/selftest_migrate.c

66

err = i915_gem_object_lock(dst, &ww);

drivers/gpu/drm/i915/gt/selftest_migrate.c

80

vaddr = i915_gem_object_pin_map(dst, I915_MAP_WC);

drivers/gpu/drm/i915/gt/selftest_migrate.c

88

i915_gem_object_flush_map(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

90

err = fn(migrate, &ww, src, dst, &rq);

drivers/gpu/drm/i915/gt/selftest_migrate.c

903

struct drm_i915_gem_object *dst;

drivers/gpu/drm/i915/gt/selftest_migrate.c

906

dst = create_init_lmem_internal(gt, sizes[i], true);

drivers/gpu/drm/i915/gt/selftest_migrate.c

907

if (IS_ERR(dst))

drivers/gpu/drm/i915/gt/selftest_migrate.c

908

return PTR_ERR(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

911

dst->mm.pages->sgl,

drivers/gpu/drm/i915/gt/selftest_migrate.c

914

i915_gem_object_is_lmem(dst),

drivers/gpu/drm/i915/gt/selftest_migrate.c

917

i915_gem_object_unlock(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

918

i915_gem_object_put(dst);

drivers/gpu/drm/i915/gt/selftest_migrate.c

930

struct scatterlist *dst,

drivers/gpu/drm/i915/gt/selftest_migrate.c

948

dst, dst_pat_index,

drivers/gpu/drm/i915/gt/selftest_migrate.c

986

struct drm_i915_gem_object *src, *dst;

drivers/gpu/drm/i915/gt/selftest_migrate.c

995

dst = create_init_lmem_internal(gt, sz, false);

drivers/gpu/drm/i915/gt/selftest_migrate.c

996

if (IS_ERR(dst)) {

drivers/gpu/drm/i915/gt/selftest_migrate.c

997

err = PTR_ERR(dst);

drivers/gpu/drm/i915/gt/shmem_utils.c

162

int shmem_read(struct file *file, loff_t off, void *dst, size_t len)

drivers/gpu/drm/i915/gt/shmem_utils.c

164

return __shmem_rw(file, off, dst, len, false);

drivers/gpu/drm/i915/gt/shmem_utils.h

23

int shmem_read(struct file *file, loff_t off, void *dst, size_t len);

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1277

size_t intel_uc_fw_copy_rsa(struct intel_uc_fw *uc_fw, void *dst, u32 max_len)

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1302

memcpy_from_page(dst, page, offset, len);

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1305

dst += len;

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1325

memcpy_fromio(dst, vaddr + offset, len);

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.c

1329

dst += len;

drivers/gpu/drm/i915/gt/uc/intel_uc_fw.h

310

size_t intel_uc_fw_copy_rsa(struct intel_uc_fw *uc_fw, void *dst, u32 max_len);

drivers/gpu/drm/i915/gvt/scheduler.c

141

void *dst;

drivers/gpu/drm/i915/gvt/scheduler.c

244

dst = context_base + (i << I915_GTT_PAGE_SHIFT);

drivers/gpu/drm/i915/gvt/scheduler.c

256

intel_gvt_read_gpa(vgpu, gpa_base, dst, gpa_size);

drivers/gpu/drm/i915/gvt/scheduler.c

259

dst = context_base + (i << I915_GTT_PAGE_SHIFT);

drivers/gpu/drm/i915/i915_cmd_parser.c

1164

void *dst, *src;

drivers/gpu/drm/i915/i915_cmd_parser.c

1171

dst = i915_gem_object_pin_map(dst_obj, I915_MAP_WB);

drivers/gpu/drm/i915/i915_cmd_parser.c

1173

if (IS_ERR(dst))

drivers/gpu/drm/i915/i915_cmd_parser.c

1174

return dst;

drivers/gpu/drm/i915/i915_cmd_parser.c

1186

i915_unaligned_memcpy_from_wc(dst,

drivers/gpu/drm/i915/i915_cmd_parser.c

1209

ptr = dst;

drivers/gpu/drm/i915/i915_cmd_parser.c

1228

memset32(dst + length, 0, (dst_obj->base.size - length) / sizeof(u32));

drivers/gpu/drm/i915/i915_cmd_parser.c

1233

return dst;

drivers/gpu/drm/i915/i915_gpu_error.c

1149

struct i915_vma_coredump *dst;

drivers/gpu/drm/i915/i915_gpu_error.c

1158

dst = kmalloc_obj(*dst, ALLOW_FAIL);

drivers/gpu/drm/i915/i915_gpu_error.c

1159

if (!dst)

drivers/gpu/drm/i915/i915_gpu_error.c

1163

kfree(dst);

drivers/gpu/drm/i915/i915_gpu_error.c

1167

INIT_LIST_HEAD(&dst->page_list);

drivers/gpu/drm/i915/i915_gpu_error.c

1168

strscpy(dst->name, name);

drivers/gpu/drm/i915/i915_gpu_error.c

1169

dst->next = NULL;

drivers/gpu/drm/i915/i915_gpu_error.c

1171

dst->gtt_offset = vma_res->start;

drivers/gpu/drm/i915/i915_gpu_error.c

1172

dst->gtt_size = vma_res->node_size;

drivers/gpu/drm/i915/i915_gpu_error.c

1173

dst->gtt_page_sizes = vma_res->page_sizes_gtt;

drivers/gpu/drm/i915/i915_gpu_error.c

1174

dst->unused = 0;

drivers/gpu/drm/i915/i915_gpu_error.c

1197

(void __force *)s, dst,

drivers/gpu/drm/i915/i915_gpu_error.c

1222

(void __force *)s, dst,

drivers/gpu/drm/i915/i915_gpu_error.c

1237

ret = compress_page(compress, s, dst, false);

drivers/gpu/drm/i915/i915_gpu_error.c

1247

if (ret || compress_flush(compress, dst)) {

drivers/gpu/drm/i915/i915_gpu_error.c

1250

list_for_each_entry_safe_reverse(page, n, &dst->page_list, lru) {

drivers/gpu/drm/i915/i915_gpu_error.c

1255

kfree(dst);

drivers/gpu/drm/i915/i915_gpu_error.c

1256

dst = NULL;

drivers/gpu/drm/i915/i915_gpu_error.c

1260

return dst;

drivers/gpu/drm/i915/i915_gpu_error.c

287

struct i915_vma_coredump *dst)

drivers/gpu/drm/i915/i915_gpu_error.c

297

list_add_tail(&page->lru, &dst->page_list);

drivers/gpu/drm/i915/i915_gpu_error.c

303

struct i915_vma_coredump *dst,

drivers/gpu/drm/i915/i915_gpu_error.c

315

zstream->next_out = compress_next_page(c, dst);

drivers/gpu/drm/i915/i915_gpu_error.c

336

struct i915_vma_coredump *dst)

drivers/gpu/drm/i915/i915_gpu_error.c

343

zstream->next_out = compress_next_page(c, dst);

drivers/gpu/drm/i915/i915_gpu_error.c

360

dst->unused = zstream->avail_out;

drivers/gpu/drm/i915/i915_gpu_error.c

400

struct i915_vma_coredump *dst,

drivers/gpu/drm/i915/i915_gpu_error.c

411

list_add_tail(&virt_to_page(ptr)->lru, &dst->page_list);

drivers/gpu/drm/i915/i915_gpu_error.c

418

struct i915_vma_coredump *dst)

drivers/gpu/drm/i915/i915_memcpy.c

117

bool i915_memcpy_from_wc(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/i915/i915_memcpy.c

119

if (unlikely(((unsigned long)dst | (unsigned long)src | len) & 15))

drivers/gpu/drm/i915/i915_memcpy.c

124

__memcpy_ntdqa(dst, src, len >> 4);

drivers/gpu/drm/i915/i915_memcpy.c

142

void i915_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/i915/i915_memcpy.c

152

memcpy(dst, src, x);

drivers/gpu/drm/i915/i915_memcpy.c

155

dst += x;

drivers/gpu/drm/i915/i915_memcpy.c

160

__memcpy_ntdqu(dst, src, DIV_ROUND_UP(len, 16));

drivers/gpu/drm/i915/i915_memcpy.c

42

static void __memcpy_ntdqa(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/i915/i915_memcpy.c

55

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/i915/i915_memcpy.c

57

dst += 64;

drivers/gpu/drm/i915/i915_memcpy.c

63

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/i915/i915_memcpy.c

65

dst += 16;

drivers/gpu/drm/i915/i915_memcpy.c

71

static void __memcpy_ntdqu(void *dst, const void *src, unsigned long len)

drivers/gpu/drm/i915/i915_memcpy.c

84

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/i915/i915_memcpy.c

86

dst += 64;

drivers/gpu/drm/i915/i915_memcpy.c

92

:: "r" (src), "r" (dst) : "memory");

drivers/gpu/drm/i915/i915_memcpy.c

94

dst += 16;

drivers/gpu/drm/i915/i915_memcpy.h

15

bool i915_memcpy_from_wc(void *dst, const void *src, unsigned long len);

drivers/gpu/drm/i915/i915_memcpy.h

16

void i915_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len);

drivers/gpu/drm/i915/i915_memcpy.h

28

#define i915_can_memcpy_from_wc(dst, src, len) \

drivers/gpu/drm/i915/i915_memcpy.h

29

i915_memcpy_from_wc((void *)((unsigned long)(dst) | (unsigned long)(src) | (len)), NULL, 0)

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1186

static void igt_memcpy_long(void *dst, const void *src, size_t size)

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1188

unsigned long *tmp = dst;

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1196

static inline void igt_memcpy(void *dst, const void *src, size_t size)

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1198

memcpy(dst, src, size);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1201

static inline void igt_memcpy_from_wc(void *dst, const void *src, size_t size)

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1203

i915_memcpy_from_wc(dst, src, size);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1213

void (*copy)(void *dst, const void *src, size_t size);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1230

struct drm_i915_gem_object *src, *dst;

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1241

dst = create_region_for_mapping(dst_mr, size, dst_type, &dst_addr);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1242

if (IS_ERR(dst)) {

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1243

ret = PTR_ERR(dst);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1289

i915_gem_object_unpin_map(dst);

drivers/gpu/drm/i915/selftests/intel_memory_region.c

1290

i915_gem_object_put(dst);

drivers/gpu/drm/imx/dc/dc-plane.c

167

dc_lb_position(lb, new_state->dst.x1, new_state->dst.y1);

drivers/gpu/drm/imx/dcss/dcss-plane.c

282

struct drm_rect src, dst;

drivers/gpu/drm/imx/dcss/dcss-plane.c

299

dst = plane->state->dst;

drivers/gpu/drm/imx/dcss/dcss-plane.c

306

dst_w = drm_rect_width(&dst);

drivers/gpu/drm/imx/dcss/dcss-plane.c

307

dst_h = drm_rect_height(&dst);

drivers/gpu/drm/imx/dcss/dcss-plane.c

337

dst.x1, dst.y1, dst_w, dst_h);

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

408

if (drm_rect_width(&new_state->dst) < 13)

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

418

if (drm_rect_height(&new_state->dst) < 2)

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

429

(drm_rect_width(&new_state->dst) != drm_rect_width(&old_state->dst) ||

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

430

drm_rect_height(&new_state->dst) != drm_rect_height(&old_state->dst) ||

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

585

struct drm_rect *dst = &new_state->dst;

drivers/gpu/drm/imx/ipuv3/ipuv3-plane.c

596

ipu_dp_set_window_pos(ipu_plane->dp, dst->x1, dst->y1);

drivers/gpu/drm/lima/lima_drv.c

283

void *dst;

drivers/gpu/drm/lima/lima_drv.c

299

memcpy(reader->dst, src + (reader->off - reader->base), size);

drivers/gpu/drm/lima/lima_drv.c

301

reader->dst += size;

drivers/gpu/drm/lima/lima_drv.c

320

.dst = buf,

drivers/gpu/drm/loongson/lsdc_pixpll.c

253

union lsdc_pixpll_reg_bitmap *dst)

drivers/gpu/drm/loongson/lsdc_pixpll.c

256

dst->d = readq(this->mmio);

drivers/gpu/drm/loongson/lsdc_pixpll.c

258

dst->w[0] = readl(this->mmio);

drivers/gpu/drm/loongson/lsdc_pixpll.c

259

dst->w[1] = readl(this->mmio + 4);

drivers/gpu/drm/mediatek/mtk_hdmi.c

320

static void mtk_hdmi_hw_audio_config(struct mtk_hdmi *hdmi, bool dst)

drivers/gpu/drm/mediatek/mtk_hdmi.c

328

if (dst)

drivers/gpu/drm/mediatek/mtk_hdmi.c

619

bool dst;

drivers/gpu/drm/mediatek/mtk_hdmi.c

634

dst = ((hdmi->aud_param.aud_input_type == HDMI_AUD_INPUT_SPDIF) &&

drivers/gpu/drm/mediatek/mtk_hdmi.c

636

mtk_hdmi_hw_audio_config(hdmi, dst);

drivers/gpu/drm/mediatek/mtk_plane.c

187

mtk_plane_state->pending.x = new_state->dst.x1;

drivers/gpu/drm/mediatek/mtk_plane.c

188

mtk_plane_state->pending.y = new_state->dst.y1;

drivers/gpu/drm/mediatek/mtk_plane.c

189

mtk_plane_state->pending.width = drm_rect_width(&new_state->dst);

drivers/gpu/drm/mediatek/mtk_plane.c

190

mtk_plane_state->pending.height = drm_rect_height(&new_state->dst);

drivers/gpu/drm/mediatek/mtk_plane.c

210

plane->state->dst.x1 = new_state->dst.x1;

drivers/gpu/drm/mediatek/mtk_plane.c

211

plane->state->dst.y1 = new_state->dst.y1;

drivers/gpu/drm/mgag200/mgag200_mode.c

453

struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(mdev->vram);

drivers/gpu/drm/mgag200/mgag200_mode.c

455

iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, clip));

drivers/gpu/drm/mgag200/mgag200_mode.c

456

drm_fb_memcpy(&dst, fb->pitches, vmap, fb, clip);

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

117

void *dst = state_kcalloc(a6xx_state, 1, size);

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

119

if (dst)

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

120

memcpy(dst, src, size);

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

121

return dst;

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

295

u32 phase_init, preload, src_y_rgb, src_uv, dst;

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

323

dst = (scaler3_cfg->dst_width & 0x1FFFF) |

drivers/gpu/drm/msm/disp/dpu1/dpu_hw_util.c

374

DPU_REG_WRITE(c, QSEED3_DST_SIZE + scaler_offset, dst);

drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c

1496

crtc->base.id, DRM_RECT_ARG(&state->dst),

drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c

749

drm_rect_width(&new_plane_state->dst)) ||

drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c

751

drm_rect_height(&new_plane_state->dst))))

drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c

859

pipe_cfg->dst_rect = new_plane_state->dst;

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

359

&new_state->src, &new_state->dst);

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

438

&new_state->src, &new_state->dst);

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

548

static int calc_phase_step(uint32_t src, uint32_t dst, uint32_t *out_phase)

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

552

if (src == 0 || dst == 0)

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

561

if (src > (dst * DOWN_SCALE_RATIO_MAX))

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

565

*out_phase = mult_frac(unit, src, dst);

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

617

uint32_t src, uint32_t dst, bool horz)

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

621

bool scaling = yuv ? true : (src != dst);

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

630

uv_filter = ((src / sub) <= dst) ?

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

633

ya_filter = (src <= dst) ? SCALE_FILTER_BIL : SCALE_FILTER_PCMN;

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

648

uint32_t src, uint32_t dst, uint32_t phase_step[2],

drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c

652

bool scaling = MSM_FORMAT_IS_YUV(format) ? true : (src != dst);

drivers/gpu/drm/nouveau/dispnv04/crtc.c

920

struct nouveau_bo *dst)

drivers/gpu/drm/nouveau/dispnv04/crtc.c

930

nouveau_bo_wr16(dst, i*width + j, (pixel & 0x80000000) >> 16

drivers/gpu/drm/nouveau/dispnv04/crtc.c

939

struct nouveau_bo *dst)

drivers/gpu/drm/nouveau/dispnv04/crtc.c

975

nouveau_bo_wr32(dst, i, pixel);

drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h

39

void nvkm_gpuobj_memcpy_to(struct nvkm_gpuobj *dst, u32 dstoffset, void *src,

drivers/gpu/drm/nouveau/include/nvkm/core/gpuobj.h

41

void nvkm_gpuobj_memcpy_from(void *dst, struct nvkm_gpuobj *src, u32 srcoffset,

drivers/gpu/drm/nouveau/nouveau_dmem.c

199

.dst = NULL,

drivers/gpu/drm/nouveau/nouveau_dmem.c

225

args.dst = kcalloc(nr, sizeof(*args.dst), GFP_KERNEL);

drivers/gpu/drm/nouveau/nouveau_dmem.c

227

if (!args.src || !args.dst) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

252

args.dst[0] = migrate_pfn(page_to_pfn(dpage));

drivers/gpu/drm/nouveau/nouveau_dmem.c

254

args.dst[0] |= MIGRATE_PFN_COMPOUND;

drivers/gpu/drm/nouveau/nouveau_dmem.c

276

kfree(args.dst);

drivers/gpu/drm/nouveau/nouveau_dmem.c

794

args->dst[i] = nouveau_dmem_migrate_copy_one(drm, svmm,

drivers/gpu/drm/nouveau/nouveau_dmem.c

796

if (!args->dst[i]) {

drivers/gpu/drm/nouveau/nouveau_dmem.c

803

folio = page_folio(migrate_pfn_to_page(args->dst[i]));

drivers/gpu/drm/nouveau/nouveau_dmem.c

854

args.dst = kcalloc(max, sizeof(*args.dst), GFP_KERNEL);

drivers/gpu/drm/nouveau/nouveau_dmem.c

855

if (!args.dst)

drivers/gpu/drm/nouveau/nouveau_dmem.c

888

kfree(args.dst);

drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c

261

nvkm_gpuobj_memcpy_to(struct nvkm_gpuobj *dst, u32 dstoffset, void *src,

drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c

267

nvkm_wo32(dst, dstoffset + i, *(u32 *)(src + i));

drivers/gpu/drm/nouveau/nvkm/core/gpuobj.c

271

nvkm_gpuobj_memcpy_from(void *dst, struct nvkm_gpuobj *src, u32 srcoffset,

drivers/gpu/drm/nouveau/nvkm/falcon/base.c

111

dst += dmalen;

drivers/gpu/drm/nouveau/nvkm/falcon/base.c

63

u32 dst, src, cmd;

drivers/gpu/drm/nouveau/nvkm/falcon/base.c

83

dst = mem_base;

drivers/gpu/drm/nouveau/nvkm/falcon/base.c

87

dma->xfer(falcon, dst, src - dma_start, cmd);

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

35

u32 src, dst, len, i;

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

46

dst = fw->sig_base_img;

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

48

FLCNFW_DBG(fw, "patch idx:%d src:%08x dst:%08x", idx, sig_base_src + src, dst);

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

54

printk(KERN_INFO "sig -> %08x:", dst);

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

58

*(u32 *)(fw->fw.img + dst) = sig;

drivers/gpu/drm/nouveau/nvkm/falcon/fw.c

60

dst += 4;

drivers/gpu/drm/omapdrm/dss/base.c

142

struct omap_dss_device *dst)

drivers/gpu/drm/omapdrm/dss/base.c

145

dst ? dev_name(dst->dev) : "NULL");

drivers/gpu/drm/omapdrm/dss/base.c

147

if (!dst)

drivers/gpu/drm/omapdrm/dss/base.c

150

if (omapdss_device_is_connected(dst))

drivers/gpu/drm/omapdrm/dss/base.c

153

dst->dss = dss;

drivers/gpu/drm/omapdrm/dss/base.c

159

struct omap_dss_device *dst)

drivers/gpu/drm/omapdrm/dss/base.c

162

dst ? dev_name(dst->dev) : "NULL");

drivers/gpu/drm/omapdrm/dss/base.c

164

if (WARN_ON(!dst))

drivers/gpu/drm/omapdrm/dss/base.c

167

if (!dst->id && !omapdss_device_is_connected(dst)) {

drivers/gpu/drm/omapdrm/dss/base.c

172

dst->dss = NULL;

drivers/gpu/drm/omapdrm/dss/omapdss.h

245

struct omap_dss_device *dst);

drivers/gpu/drm/omapdrm/dss/omapdss.h

247

struct omap_dss_device *dst);

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

106

dma_addr_t src, dst;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

110

dst = dmm->wa_dma_handle;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

112

r = dmm_dma_copy(dmm, src, dst);

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

129

dma_addr_t src, dst;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

142

dst = dmm->phys_base + reg;

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

144

r = dmm_dma_copy(dmm, src, dst);

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

78

static int dmm_dma_copy(struct dmm *dmm, dma_addr_t src, dma_addr_t dst)

drivers/gpu/drm/omapdrm/omap_dmm_tiler.c

84

tx = dmaengine_prep_dma_memcpy(dmm->wa_dma_chan, dst, src, 4, 0);

drivers/gpu/drm/radeon/atom.c

1014

uint32_t dst, src;

drivers/gpu/drm/radeon/atom.c

1016

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

drivers/gpu/drm/radeon/atom.c

1019

ctx->ctx->cs_equal = ((dst & src) == 0);

drivers/gpu/drm/radeon/atom.c

1026

uint32_t dst, src, saved;

drivers/gpu/drm/radeon/atom.c

1029

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

1032

dst ^= src;

drivers/gpu/drm/radeon/atom.c

1034

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

601

uint32_t dst, src, saved;

drivers/gpu/drm/radeon/atom.c

604

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

607

dst += src;

drivers/gpu/drm/radeon/atom.c

609

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

615

uint32_t dst, src, saved;

drivers/gpu/drm/radeon/atom.c

618

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

621

dst &= src;

drivers/gpu/drm/radeon/atom.c

623

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

662

uint32_t dst, src;

drivers/gpu/drm/radeon/atom.c

664

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

drivers/gpu/drm/radeon/atom.c

667

ctx->ctx->cs_equal = (dst == src);

drivers/gpu/drm/radeon/atom.c

668

ctx->ctx->cs_above = (dst > src);

drivers/gpu/drm/radeon/atom.c

688

uint32_t dst, src;

drivers/gpu/drm/radeon/atom.c

690

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

drivers/gpu/drm/radeon/atom.c

694

ctx->ctx->divmul[0] = dst / src;

drivers/gpu/drm/radeon/atom.c

695

ctx->ctx->divmul[1] = dst % src;

drivers/gpu/drm/radeon/atom.c

763

uint32_t dst, mask, src, saved;

drivers/gpu/drm/radeon/atom.c

766

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

771

dst &= mask;

drivers/gpu/drm/radeon/atom.c

772

dst |= src;

drivers/gpu/drm/radeon/atom.c

774

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

797

uint32_t dst, src;

drivers/gpu/drm/radeon/atom.c

799

dst = atom_get_dst(ctx, arg, attr, ptr, NULL, 1);

drivers/gpu/drm/radeon/atom.c

802

ctx->ctx->divmul[0] = dst * src;

drivers/gpu/drm/radeon/atom.c

813

uint32_t dst, src, saved;

drivers/gpu/drm/radeon/atom.c

816

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

819

dst |= src;

drivers/gpu/drm/radeon/atom.c

821

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

903

uint32_t saved, dst;

drivers/gpu/drm/radeon/atom.c

908

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

911

dst <<= shift;

drivers/gpu/drm/radeon/atom.c

913

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

919

uint32_t saved, dst;

drivers/gpu/drm/radeon/atom.c

924

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

927

dst >>= shift;

drivers/gpu/drm/radeon/atom.c

929

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

935

uint32_t saved, dst;

drivers/gpu/drm/radeon/atom.c

939

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

941

dst = saved;

drivers/gpu/drm/radeon/atom.c

944

dst <<= shift;

drivers/gpu/drm/radeon/atom.c

945

dst &= atom_arg_mask[dst_align];

drivers/gpu/drm/radeon/atom.c

946

dst >>= atom_arg_shift[dst_align];

drivers/gpu/drm/radeon/atom.c

948

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

954

uint32_t saved, dst;

drivers/gpu/drm/radeon/atom.c

958

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

960

dst = saved;

drivers/gpu/drm/radeon/atom.c

963

dst >>= shift;

drivers/gpu/drm/radeon/atom.c

964

dst &= atom_arg_mask[dst_align];

drivers/gpu/drm/radeon/atom.c

965

dst >>= atom_arg_shift[dst_align];

drivers/gpu/drm/radeon/atom.c

967

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atom.c

973

uint32_t dst, src, saved;

drivers/gpu/drm/radeon/atom.c

976

dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);

drivers/gpu/drm/radeon/atom.c

979

dst -= src;

drivers/gpu/drm/radeon/atom.c

981

atom_put_dst(ctx, arg, attr, &dptr, dst, saved);

drivers/gpu/drm/radeon/atombios_dp.c

57

void radeon_atom_copy_swap(u8 *dst, u8 *src, u8 num_bytes, bool to_le)

drivers/gpu/drm/radeon/atombios_dp.c

68

memcpy(dst, dst_tmp, align_num_bytes);

drivers/gpu/drm/radeon/atombios_dp.c

73

memcpy(dst, dst_tmp, num_bytes);

drivers/gpu/drm/radeon/atombios_dp.c

76

memcpy(dst, src, num_bytes);

drivers/gpu/drm/radeon/radeon_fence.c

727

struct radeon_fence_driver *dst, *src;

drivers/gpu/drm/radeon/radeon_fence.c

738

dst = &fence->rdev->fence_drv[dst_ring];

drivers/gpu/drm/radeon/radeon_fence.c

743

dst->sync_seq[i] = max(dst->sync_seq[i], src->sync_seq[i]);

drivers/gpu/drm/radeon/radeon_mode.h

738

void radeon_atom_copy_swap(u8 *dst, u8 *src, u8 num_bytes, bool to_le);

drivers/gpu/drm/radeon/radeon_vm.c

815

uint64_t dst, uint32_t flags)

drivers/gpu/drm/radeon/radeon_vm.c

853

last_dst = dst;

drivers/gpu/drm/radeon/radeon_vm.c

859

dst += nptes * RADEON_GPU_PAGE_SIZE;

drivers/gpu/drm/renesas/rcar-du/rcar_du_plane.c

539

const struct drm_rect *dst = &state->state.dst;

drivers/gpu/drm/renesas/rcar-du/rcar_du_plane.c

547

rcar_du_plane_write(rgrp, index, PnDSXR, drm_rect_width(dst));

drivers/gpu/drm/renesas/rcar-du/rcar_du_plane.c

548

rcar_du_plane_write(rgrp, index, PnDSYR, drm_rect_height(dst));

drivers/gpu/drm/renesas/rcar-du/rcar_du_plane.c

549

rcar_du_plane_write(rgrp, index, PnDPXR, dst->x1);

drivers/gpu/drm/renesas/rcar-du/rcar_du_plane.c

550

rcar_du_plane_write(rgrp, index, PnDPYR, dst->y1);

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

240

cfg.dst.left = state->state.dst.x1;

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

241

cfg.dst.top = state->state.dst.y1;

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

242

cfg.dst.width = drm_rect_width(&state->state.dst);

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

243

cfg.dst.height = drm_rect_height(&state->state.dst);

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

271

struct scatterlist *dst;

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

286

dst = sgt->sgl;

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

288

sg_set_page(dst, sg_page(src), src->length,

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

291

dst = sg_next(dst);

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

67

.dst.x1 = 0,

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

68

.dst.y1 = 0,

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

69

.dst.x2 = mode->hdisplay,

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

70

.dst.y2 = mode->vdisplay,

drivers/gpu/drm/renesas/rz-du/rzg2l_du_vsp.c

138

cfg.dst.left = state->state.dst.x1;

drivers/gpu/drm/renesas/rz-du/rzg2l_du_vsp.c

139

cfg.dst.top = state->state.dst.y1;

drivers/gpu/drm/renesas/rz-du/rzg2l_du_vsp.c

140

cfg.dst.width = drm_rect_width(&state->state.dst);

drivers/gpu/drm/renesas/rz-du/rzg2l_du_vsp.c

141

cfg.dst.height = drm_rect_height(&state->state.dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

349

uint32_t dst, bool is_horizontal,

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

359

val = GET_SCL_FT_BIC(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

361

val = GET_SCL_FT_BILI_DN(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

365

val = GET_SCL_FT_BILI_UP(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

367

val = GET_SCL_FT_BIC(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

370

*vskiplines = scl_get_vskiplines(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

371

val = scl_get_bili_dn_vskip(src, dst,

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

374

val = GET_SCL_FT_BILI_DN(src, dst);

drivers/gpu/drm/rockchip/rockchip_drm_vop.c

924

struct drm_rect *dest = &new_state->dst;

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

356

static inline uint16_t scl_cal_scale(int src, int dst, int shift)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

358

return ((src * 2 - 3) << (shift - 1)) / (dst - 1);

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

361

static inline uint16_t scl_cal_scale2(int src, int dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

363

return ((src - 1) << 12) / (dst - 1);

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

366

#define GET_SCL_FT_BILI_DN(src, dst) scl_cal_scale(src, dst, 12)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

367

#define GET_SCL_FT_BILI_UP(src, dst) scl_cal_scale(src, dst, 16)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

368

#define GET_SCL_FT_BIC(src, dst) scl_cal_scale(src, dst, 16)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

383

static inline enum scale_mode scl_get_scl_mode(int src, int dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

385

if (src < dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop.h

387

else if (src > dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1172

struct drm_rect *dest = &pstate->dst;

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1910

struct drm_rect *src, *dst;

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1929

dst = &pstate->dst;

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1947

seq_printf(s, "\tdst: pos[%d, %d] rect[%d x %d]\n", dst->x1, dst->y1,

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

1948

drm_rect_width(dst), drm_rect_height(dst));

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

519

static u16 vop2_scale_factor(u32 src, u32 dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

524

if (src == dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

527

if (dst < 2)

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

533

if (src > dst)

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

539

dst--;

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

541

fac = DIV_ROUND_UP(src << shift, dst) - 1;

drivers/gpu/drm/rockchip/rockchip_drm_vop2.c

992

struct drm_rect *dest = &pstate->dst;

drivers/gpu/drm/sitronix/st7571.c

160

struct iosys_map dst;

drivers/gpu/drm/sitronix/st7571.c

166

iosys_map_set_vaddr(&dst, st7571->hwbuf);

drivers/gpu/drm/sitronix/st7571.c

168

drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/sitronix/st7571.c

186

struct iosys_map dst;

drivers/gpu/drm/sitronix/st7571.c

191

iosys_map_set_vaddr(&dst, st7571->hwbuf);

drivers/gpu/drm/sitronix/st7571.c

193

drm_fb_xrgb8888_to_gray2(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/sitronix/st7586.c

107

st7586_xrgb8888_to_gray332(dst, src->vaddr, fb, clip, fmtcnv_state);

drivers/gpu/drm/sitronix/st7586.c

67

static void st7586_xrgb8888_to_gray332(u8 *dst, void *vaddr,

drivers/gpu/drm/sitronix/st7586.c

91

*dst++ = val;

drivers/gpu/drm/sitronix/st7586.c

98

static int st7586_buf_copy(void *dst, struct iosys_map *src, struct drm_framebuffer *fb,

drivers/gpu/drm/sitronix/st7920.c

322

struct iosys_map dst;

drivers/gpu/drm/sitronix/st7920.c

332

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/sitronix/st7920.c

333

drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/sitronix/st7920.c

412

dst_clip = plane_state->dst;

drivers/gpu/drm/solomon/ssd130x.c

1008

struct iosys_map dst;

drivers/gpu/drm/solomon/ssd130x.c

1018

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/solomon/ssd130x.c

1019

drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/solomon/ssd130x.c

1034

struct iosys_map dst;

drivers/gpu/drm/solomon/ssd130x.c

1044

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/solomon/ssd130x.c

1045

drm_fb_xrgb8888_to_gray8(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/solomon/ssd130x.c

1060

struct iosys_map dst;

drivers/gpu/drm/solomon/ssd130x.c

1068

iosys_map_set_vaddr(&dst, data_array);

drivers/gpu/drm/solomon/ssd130x.c

1069

drm_fb_xrgb8888_to_rgb332(&dst, &dst_pitch, vmap, fb, rect, fmtcnv_state);

drivers/gpu/drm/solomon/ssd130x.c

1221

dst_clip = plane_state->dst;

drivers/gpu/drm/solomon/ssd130x.c

1262

dst_clip = plane_state->dst;

drivers/gpu/drm/solomon/ssd130x.c

1302

dst_clip = plane_state->dst;

drivers/gpu/drm/sti/sti_cursor.c

151

u8 *dst = cursor->pixmap.base;

drivers/gpu/drm/sti/sti_cursor.c

162

*dst = a << 6 | r << 4 | g << 2 | b;

drivers/gpu/drm/sti/sti_cursor.c

164

dst++;

drivers/gpu/drm/sti/sti_gdp.c

606

static int sti_gdp_get_dst(struct device *dev, int dst, int src)

drivers/gpu/drm/sti/sti_gdp.c

608

if (dst == src)

drivers/gpu/drm/sti/sti_gdp.c

609

return dst;

drivers/gpu/drm/sti/sti_gdp.c

611

if (dst < src) {

drivers/gpu/drm/sti/sti_gdp.c

613

return dst;

drivers/gpu/drm/sun4i/sun8i_mixer.c

281

x = plane_state->dst.x1;

drivers/gpu/drm/sun4i/sun8i_mixer.c

282

y = plane_state->dst.y1;

drivers/gpu/drm/sun4i/sun8i_mixer.c

283

w = drm_rect_width(&plane_state->dst);

drivers/gpu/drm/sun4i/sun8i_mixer.c

284

h = drm_rect_height(&plane_state->dst);

drivers/gpu/drm/sun4i/sun8i_ui_layer.c

75

dst_w = drm_rect_width(&state->dst);

drivers/gpu/drm/sun4i/sun8i_ui_layer.c

76

dst_h = drm_rect_height(&state->dst);

drivers/gpu/drm/sun4i/sun8i_vi_layer.c

85

dst_w = drm_rect_width(&state->dst);

drivers/gpu/drm/sun4i/sun8i_vi_layer.c

86

dst_h = drm_rect_height(&state->dst);

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

194

static void drm_sysfb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

198

drm_fb_memcpy(dst, dst_pitch, src, fb, clip);

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

356

struct iosys_map dst = sysfb->fb_addr;

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

357

struct drm_rect dst_clip = plane_state->dst;

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

362

iosys_map_incr(&dst, drm_fb_clip_offset(dst_pitch, dst_format, &dst_clip));

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

363

blit_to_crtc(&dst, &dst_pitch, shadow_plane_state->data, fb, &damage,

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

378

struct iosys_map dst = sysfb->fb_addr;

drivers/gpu/drm/sysfb/drm_sysfb_modeset.c

380

void __iomem *dst_vmap = dst.vaddr_iomem; /* TODO: Use mapping abstraction */

drivers/gpu/drm/tegra/dc.c

2067

window.dst.h = drm_rect_height(&plane->state->dst);

drivers/gpu/drm/tegra/dc.c

2070

old_window.dst.h = drm_rect_height(&old_plane_state->dst);

drivers/gpu/drm/tegra/dc.c

2335

unsigned int dst_w = drm_rect_width(&state->dst);

drivers/gpu/drm/tegra/dc.c

2370

rect = plane_state->dst;

drivers/gpu/drm/tegra/dc.c

2385

if (drm_rect_intersect(&rect, &other_state->dst))

drivers/gpu/drm/tegra/dc.c

320

if (window->src.w == window->dst.w)

drivers/gpu/drm/tegra/dc.c

335

if (window->src.h == window->dst.h)

drivers/gpu/drm/tegra/dc.c

369

value = V_POSITION(window->dst.y) | H_POSITION(window->dst.x);

drivers/gpu/drm/tegra/dc.c

372

value = V_SIZE(window->dst.h) | H_SIZE(window->dst.w);

drivers/gpu/drm/tegra/dc.c

396

h_dda = compute_dda_inc(window->src.w, window->dst.w, false, bpp);

drivers/gpu/drm/tegra/dc.c

397

v_dda = compute_dda_inc(window->src.h, window->dst.h, true, bpp);

drivers/gpu/drm/tegra/dc.c

750

window.dst.x = new_state->dst.x1;

drivers/gpu/drm/tegra/dc.c

751

window.dst.y = new_state->dst.y1;

drivers/gpu/drm/tegra/dc.c

752

window.dst.w = drm_rect_width(&new_state->dst);

drivers/gpu/drm/tegra/dc.c

753

window.dst.h = drm_rect_height(&new_state->dst);

drivers/gpu/drm/tegra/dc.c

981

x = new_state->dst.x1;

drivers/gpu/drm/tegra/dc.c

982

y = new_state->dst.y1;

drivers/gpu/drm/tegra/dc.h

147

} dst;

drivers/gpu/drm/tegra/plane.c

243

dst_w = drm_rect_width(&state->dst);

drivers/gpu/drm/tegra/plane.c

244

dst_h = drm_rect_height(&state->dst);

drivers/gpu/drm/tests/drm_format_helper_test.c

1001

drm_fb_xrgb8888_to_argb8888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1013

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1026

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1035

drm_fb_xrgb8888_to_xrgb2101010(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1039

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

1042

drm_fb_xrgb8888_to_xrgb2101010(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1054

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1067

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1076

drm_fb_xrgb8888_to_argb2101010(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1080

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

1083

drm_fb_xrgb8888_to_argb2101010(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1095

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1108

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1117

drm_fb_xrgb8888_to_mono(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1128

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1141

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1150

drm_fb_swab(&dst, dst_pitch, &src, &fb, &params->clip, false, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1154

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

1157

drm_fb_swab(&dst, dst_pitch, &src, &fb, &params->clip, false, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1161

buf = dst.vaddr;

drivers/gpu/drm/tests/drm_format_helper_test.c

1164

drm_fb_xrgb8888_to_bgrx8888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1168

buf = dst.vaddr;

drivers/gpu/drm/tests/drm_format_helper_test.c

1176

drm_fb_swab(&dst, dst_pitch, &src, &fb, &params->clip, false, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1188

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1201

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1210

drm_fb_xrgb8888_to_abgr8888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1222

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

1235

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

1244

drm_fb_xrgb8888_to_xbgr8888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

1666

struct iosys_map dst[DRM_FORMAT_MAX_PLANES];

drivers/gpu/drm/tests/drm_format_helper_test.c

1682

iosys_map_set_vaddr(&dst[i], buf[i]);

drivers/gpu/drm/tests/drm_format_helper_test.c

1691

drm_fb_memcpy(dst, dst_pitches, src, &fb, &params->clip);

drivers/gpu/drm/tests/drm_format_helper_test.c

1701

drm_fb_memcpy(dst, dst_pitches, src, &fb, &params->clip);

drivers/gpu/drm/tests/drm_format_helper_test.c

590

u16 *dst = NULL;

drivers/gpu/drm/tests/drm_format_helper_test.c

593

dst = kunit_kzalloc(test, sizeof(*dst) * buf_size, GFP_KERNEL);

drivers/gpu/drm/tests/drm_format_helper_test.c

594

if (!dst)

drivers/gpu/drm/tests/drm_format_helper_test.c

598

dst[n] = le16_to_cpu(buf[n]);

drivers/gpu/drm/tests/drm_format_helper_test.c

600

return dst;

drivers/gpu/drm/tests/drm_format_helper_test.c

605

u32 *dst = NULL;

drivers/gpu/drm/tests/drm_format_helper_test.c

608

dst = kunit_kzalloc(test, sizeof(*dst) * buf_size, GFP_KERNEL);

drivers/gpu/drm/tests/drm_format_helper_test.c

609

if (!dst)

drivers/gpu/drm/tests/drm_format_helper_test.c

613

dst[n] = le32_to_cpu((__force __le32)buf[n]);

drivers/gpu/drm/tests/drm_format_helper_test.c

615

return dst;

drivers/gpu/drm/tests/drm_format_helper_test.c

620

__le32 *dst = NULL;

drivers/gpu/drm/tests/drm_format_helper_test.c

623

dst = kunit_kzalloc(test, sizeof(*dst) * buf_size, GFP_KERNEL);

drivers/gpu/drm/tests/drm_format_helper_test.c

624

if (!dst)

drivers/gpu/drm/tests/drm_format_helper_test.c

628

dst[n] = cpu_to_le32(buf[n]);

drivers/gpu/drm/tests/drm_format_helper_test.c

630

return dst;

drivers/gpu/drm/tests/drm_format_helper_test.c

649

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

662

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

671

drm_fb_xrgb8888_to_gray8(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

682

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

695

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

704

drm_fb_xrgb8888_to_rgb332(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

715

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

728

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

737

drm_fb_xrgb8888_to_rgb565(&dst, dst_pitch, &src, &fb, &params->clip,

drivers/gpu/drm/tests/drm_format_helper_test.c

742

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

743

drm_fb_xrgb8888_to_rgb565be(&dst, &result->dst_pitch, &src, &fb, &params->clip,

drivers/gpu/drm/tests/drm_format_helper_test.c

748

buf = dst.vaddr;

drivers/gpu/drm/tests/drm_format_helper_test.c

751

drm_fb_xrgb8888_to_rgb565(&dst, dst_pitch, &src, &fb, &params->clip,

drivers/gpu/drm/tests/drm_format_helper_test.c

764

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

777

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

786

drm_fb_xrgb8888_to_xrgb1555(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

790

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

793

drm_fb_xrgb8888_to_xrgb1555(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

805

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

818

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

827

drm_fb_xrgb8888_to_argb1555(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

831

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

834

drm_fb_xrgb8888_to_argb1555(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

846

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

859

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

868

drm_fb_xrgb8888_to_rgba5551(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

872

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

875

drm_fb_xrgb8888_to_rgba5551(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

887

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

900

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

913

drm_fb_xrgb8888_to_rgb888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

916

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

919

drm_fb_xrgb8888_to_rgb888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

930

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

943

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

953

drm_fb_xrgb8888_to_bgr888(&dst, &result->dst_pitch, &src, &fb, &params->clip,

drivers/gpu/drm/tests/drm_format_helper_test.c

957

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_format_helper_test.c

960

drm_fb_xrgb8888_to_bgr888(&dst, &result->dst_pitch, &src, &fb, &params->clip,

drivers/gpu/drm/tests/drm_format_helper_test.c

972

struct iosys_map dst, src;

drivers/gpu/drm/tests/drm_format_helper_test.c

985

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tests/drm_format_helper_test.c

994

drm_fb_xrgb8888_to_argb8888(&dst, dst_pitch, &src, &fb, &params->clip, &fmtcnv_state);

drivers/gpu/drm/tests/drm_format_helper_test.c

998

buf = dst.vaddr; /* restore original value of buf */

drivers/gpu/drm/tests/drm_plane_helper_test.c

107

KUNIT_EXPECT_TRUE_MSG(test, drm_rect_equals(&plane_state->dst, &expected),

drivers/gpu/drm/tests/drm_plane_helper_test.c

109

DRM_RECT_ARG(&plane_state->dst), DRM_RECT_ARG(&expected));

drivers/gpu/drm/tests/drm_rect_test.c

101

struct drm_rect src, dst, clip;

drivers/gpu/drm/tests/drm_rect_test.c

106

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

109

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

113

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 1 ||

drivers/gpu/drm/tests/drm_rect_test.c

114

dst.y1 != 0 || dst.y2 != 1, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

120

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

123

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

127

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 1 || dst.x2 != 2 || dst.y1 != 1 ||

drivers/gpu/drm/tests/drm_rect_test.c

128

dst.y2 != 2, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

134

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

137

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

141

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 1 || dst.y1 != 0 ||

drivers/gpu/drm/tests/drm_rect_test.c

142

dst.y2 != 1, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

148

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

151

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

155

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 1 || dst.x2 != 2 || dst.y1 != 1 ||

drivers/gpu/drm/tests/drm_rect_test.c

156

dst.y2 != 2, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

162

drm_rect_init(&dst, 0, 0, 4, 4);

drivers/gpu/drm/tests/drm_rect_test.c

165

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

169

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 2 || dst.y1 != 0 ||

drivers/gpu/drm/tests/drm_rect_test.c

170

dst.y2 != 2, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

176

drm_rect_init(&dst, 0, 0, 4, 4);

drivers/gpu/drm/tests/drm_rect_test.c

179

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

183

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 2 || dst.x2 != 4 || dst.y1 != 2 ||

drivers/gpu/drm/tests/drm_rect_test.c

184

dst.y2 != 4, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

191

struct drm_rect src, dst, clip;

drivers/gpu/drm/tests/drm_rect_test.c

203

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

206

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

27

struct drm_rect src, dst, clip;

drivers/gpu/drm/tests/drm_rect_test.c

35

drm_rect_init(&dst, 0, 0, 0, 0);

drivers/gpu/drm/tests/drm_rect_test.c

350

struct drm_rect src, dst;

drivers/gpu/drm/tests/drm_rect_test.c

359

.dst = DRM_RECT_INIT(0, 0, 1 << 16, 1 << 16),

drivers/gpu/drm/tests/drm_rect_test.c

366

.dst = DRM_RECT_INIT(0, 0, 1 << 16, 1 << 16),

drivers/gpu/drm/tests/drm_rect_test.c

37

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

373

.dst = DRM_RECT_INIT(0, 0, 1 << 16, 1 << 16),

drivers/gpu/drm/tests/drm_rect_test.c

380

.dst = DRM_RECT_INIT(0, 0, 0 << 16, 0 << 16),

drivers/gpu/drm/tests/drm_rect_test.c

387

.dst = DRM_RECT_INIT(0, 0, 1 << 16, 1 << 16),

drivers/gpu/drm/tests/drm_rect_test.c

394

.dst = DRM_RECT_INIT(0, 0, -(1 << 16), -(1 << 16)),

drivers/gpu/drm/tests/drm_rect_test.c

412

scaling_factor = drm_rect_calc_hscale(&params->src, &params->dst,

drivers/gpu/drm/tests/drm_rect_test.c

423

scaling_factor = drm_rect_calc_vscale(&params->src, &params->dst,

drivers/gpu/drm/tests/drm_rect_test.c

43

drm_rect_init(&dst, 3, 3, 0, 0);

drivers/gpu/drm/tests/drm_rect_test.c

45

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

53

struct drm_rect src, dst, clip;

drivers/gpu/drm/tests/drm_rect_test.c

58

drm_rect_init(&dst, 0, 0, 1, 1);

drivers/gpu/drm/tests/drm_rect_test.c

61

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

65

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 1 ||

drivers/gpu/drm/tests/drm_rect_test.c

66

dst.y1 != 0 || dst.y2 != 1, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

72

drm_rect_init(&dst, 0, 0, 1, 1);

drivers/gpu/drm/tests/drm_rect_test.c

75

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

79

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 1 ||

drivers/gpu/drm/tests/drm_rect_test.c

80

dst.y1 != 0 || dst.y2 != 1, "Destination badly clipped\n");

drivers/gpu/drm/tests/drm_rect_test.c

86

drm_rect_init(&dst, 0, 0, 2, 2);

drivers/gpu/drm/tests/drm_rect_test.c

89

visible = drm_rect_clip_scaled(&src, &dst, &clip);

drivers/gpu/drm/tests/drm_rect_test.c

93

KUNIT_EXPECT_FALSE_MSG(test, dst.x1 != 0 || dst.x2 != 2 ||

drivers/gpu/drm/tests/drm_rect_test.c

94

dst.y1 != 0 || dst.y2 != 2, "Destination badly clipped\n");

drivers/gpu/drm/tiny/appletbdrm.c

411

struct drm_rect dst_clip = state->dst;

drivers/gpu/drm/tiny/appletbdrm.c

412

struct iosys_map dst = IOSYS_MAP_INIT_VADDR(frame->buf);

drivers/gpu/drm/tiny/appletbdrm.c

431

drm_fb_xrgb8888_to_bgr888(&dst, NULL, &shadow_plane_state->data[0], fb, &damage, &shadow_plane_state->fmtcnv_state);

drivers/gpu/drm/tiny/appletbdrm.c

434

drm_fb_memcpy(&dst, NULL, &shadow_plane_state->data[0], fb, &damage);

drivers/gpu/drm/tiny/bochs.c

461

struct iosys_map dst = IOSYS_MAP_INIT_VADDR_IOMEM(bochs->fb_map);

drivers/gpu/drm/tiny/bochs.c

463

iosys_map_incr(&dst, drm_fb_clip_offset(fb->pitches[0], fb->format, &damage));

drivers/gpu/drm/tiny/bochs.c

464

drm_fb_memcpy(&dst, fb->pitches, shadow_plane_state->data, fb, &damage);

drivers/gpu/drm/tiny/cirrus-qemu.c

356

struct iosys_map dst = IOSYS_MAP_INIT_OFFSET(&vaddr, offset);

drivers/gpu/drm/tiny/cirrus-qemu.c

358

drm_fb_memcpy(&dst, fb->pitches, shadow_plane_state->data, fb, &damage);

drivers/gpu/drm/tiny/gm12u320.c

244

static void gm12u320_32bpp_to_24bpp_packed(u8 *dst, u8 *src, int len)

drivers/gpu/drm/tiny/gm12u320.c

247

*dst++ = *src++;

drivers/gpu/drm/tiny/gm12u320.c

248

*dst++ = *src++;

drivers/gpu/drm/tiny/gm12u320.c

249

*dst++ = *src++;

drivers/gpu/drm/tiny/repaper.c

519

struct iosys_map dst;

drivers/gpu/drm/tiny/repaper.c

548

iosys_map_set_vaddr(&dst, buf);

drivers/gpu/drm/tiny/repaper.c

549

drm_fb_xrgb8888_to_mono(&dst, &dst_pitch, vmap, fb, &clip, fmtcnv_state);

drivers/gpu/drm/tiny/sharp-memory.c

135

struct iosys_map dst;

drivers/gpu/drm/tiny/sharp-memory.c

141

iosys_map_set_vaddr(&dst, buffer);

drivers/gpu/drm/tiny/sharp-memory.c

143

drm_fb_xrgb8888_to_mono(&dst, &pitch, vmap, fb, &clip, fmtcnv_state);

drivers/gpu/drm/ttm/ttm_backup.c

51

int ttm_backup_copy_page(struct file *backup, struct page *dst,

drivers/gpu/drm/ttm/ttm_backup.c

62

copy_highpage(dst, folio_file_page(from_folio, idx));

drivers/gpu/drm/v3d/v3d_sched.c

515

static void write_to_buffer_32(u32 *dst, unsigned int idx, u32 value)

drivers/gpu/drm/v3d/v3d_sched.c

517

dst[idx] = value;

drivers/gpu/drm/v3d/v3d_sched.c

520

static void write_to_buffer_64(u64 *dst, unsigned int idx, u64 value)

drivers/gpu/drm/v3d/v3d_sched.c

522

dst[idx] = value;

drivers/gpu/drm/v3d/v3d_sched.c

526

write_to_buffer(void *dst, unsigned int idx, bool do_64bit, u64 value)

drivers/gpu/drm/v3d/v3d_sched.c

529

write_to_buffer_64(dst, idx, value);

drivers/gpu/drm/v3d/v3d_sched.c

531

write_to_buffer_32(dst, idx, value);

drivers/gpu/drm/vboxvideo/vbox_mode.c

376

static void copy_cursor_image(u8 *src, u8 *dst, u32 width, u32 height,

drivers/gpu/drm/vboxvideo/vbox_mode.c

382

memcpy(dst + mask_size, src, width * height * 4);

drivers/gpu/drm/vboxvideo/vbox_mode.c

386

dst[i * line_size + j / 8] |= (0x80 >> (j % 8));

drivers/gpu/drm/vboxvideo/vbva_base.c

34

u8 *dst = &vbva->data[offset];

drivers/gpu/drm/vboxvideo/vbva_base.c

39

memcpy(dst, p, len);

drivers/gpu/drm/vboxvideo/vbva_base.c

42

memcpy(dst, p, bytes_till_boundary);

drivers/gpu/drm/vc4/vc4_plane.c

2293

plane->state->dst = new_plane_state->dst;

drivers/gpu/drm/vc4/vc4_plane.c

265

static enum vc4_scaling_mode vc4_get_scaling_mode(u32 src, u32 dst)

drivers/gpu/drm/vc4/vc4_plane.c

267

if (dst == src >> 16)

drivers/gpu/drm/vc4/vc4_plane.c

269

if (3 * dst >= 2 * (src >> 16))

drivers/gpu/drm/vc4/vc4_plane.c

517

vc4_state->crtc_x = state->dst.x1;

drivers/gpu/drm/vc4/vc4_plane.c

518

vc4_state->crtc_y = state->dst.y1;

drivers/gpu/drm/vc4/vc4_plane.c

519

vc4_state->crtc_w = state->dst.x2 - state->dst.x1;

drivers/gpu/drm/vc4/vc4_plane.c

520

vc4_state->crtc_h = state->dst.y2 - state->dst.y1;

drivers/gpu/drm/vc4/vc4_plane.c

570

static void vc4_write_tpz(struct vc4_plane_state *vc4_state, u32 src, u32 dst)

drivers/gpu/drm/vc4/vc4_plane.c

577

scale = src / dst;

drivers/gpu/drm/vc4/vc4_plane.c

599

static void vc4_write_ppf(struct vc4_plane_state *vc4_state, u32 src, u32 dst,

drivers/gpu/drm/vc4/vc4_plane.c

603

u32 scale = src / dst;

drivers/gpu/drm/vc4/vc4_plane.c

640

offset2 = src - dst * scale;

drivers/gpu/drm/virtio/virtgpu_vq.c

46

static void convert_to_hw_box(struct virtio_gpu_box *dst,

drivers/gpu/drm/virtio/virtgpu_vq.c

49

dst->x = cpu_to_le32(src->x);

drivers/gpu/drm/virtio/virtgpu_vq.c

50

dst->y = cpu_to_le32(src->y);

drivers/gpu/drm/virtio/virtgpu_vq.c

51

dst->z = cpu_to_le32(src->z);

drivers/gpu/drm/virtio/virtgpu_vq.c

52

dst->w = cpu_to_le32(src->w);

drivers/gpu/drm/virtio/virtgpu_vq.c

53

dst->h = cpu_to_le32(src->h);

drivers/gpu/drm/virtio/virtgpu_vq.c

54

dst->d = cpu_to_le32(src->d);

drivers/gpu/drm/vkms/vkms_composer.c

20

static u16 pre_mul_blend_channel(u16 src, u16 dst, u16 alpha)

drivers/gpu/drm/vkms/vkms_composer.c

24

new_color = (src * 0xffff + dst * (0xffff - alpha));

drivers/gpu/drm/vkms/vkms_composer.c

308

*dst_x_start = current_plane->frame_info->dst.x1;

drivers/gpu/drm/vkms/vkms_composer.c

371

if (y < current_plane->frame_info->dst.y1 ||

drivers/gpu/drm/vkms/vkms_composer.c

372

y >= current_plane->frame_info->dst.y2)

drivers/gpu/drm/vkms/vkms_composer.c

380

dst_line = DRM_RECT_INIT(current_plane->frame_info->dst.x1, y,

drivers/gpu/drm/vkms/vkms_composer.c

381

drm_rect_width(&current_plane->frame_info->dst),

drivers/gpu/drm/vkms/vkms_composer.c

408

drm_rect_translate(&src_line, -current_plane->frame_info->dst.x1,

drivers/gpu/drm/vkms/vkms_composer.c

409

-current_plane->frame_info->dst.y1);

drivers/gpu/drm/vkms/vkms_drv.h

43

struct drm_rect src, dst;

drivers/gpu/drm/vkms/vkms_formats.c

672

int x_dst = frame_info->dst.x1;

drivers/gpu/drm/vkms/vkms_formats.c

678

int x_limit = min_t(size_t, drm_rect_width(&frame_info->dst), src_buffer->n_pixels);

drivers/gpu/drm/vkms/vkms_plane.c

144

memcpy(&frame_info->dst, &new_state->dst, sizeof(struct drm_rect));

drivers/gpu/drm/vkms/vkms_writeback.c

156

drm_rect_init(&wb_frame_info->dst, 0, 0, crtc_width, crtc_height);

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

866

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

876

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

888

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

899

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

910

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/device_include/svga3d_cmd.h

927

SVGA3dSurfaceImageId dst;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

107

unsigned int spill = SPILL(dst, _type); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

113

diff_offs = vmw_find_first_diff_u8(dst, src, spill); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

117

dst += spill; \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

127

((_type *) dst, (_type *) src, to_copy); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

131

dst += diff_offs; \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

150

static size_t vmw_find_first_diff(const u8 *dst, const u8 *src, size_t size,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

166

return round_down(offset + vmw_find_first_diff_u8(dst, src, size),

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

180

unsigned int spill = SPILL(dst, _type); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

185

diff_offs = vmw_find_last_diff_u8(dst, src, spill); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

191

dst -= spill; \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

200

((_type *) dst, (_type *) src, to_copy); \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

205

dst -= to_copy - diff_offs; \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

222

static ssize_t vmw_find_last_diff(const u8 *dst, const u8 *src, size_t size,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

225

dst += size;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

234

return round_down(vmw_find_last_diff_u8(dst, src, size) - 1,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

40

(const _type * dst, const _type * src, size_t size)\

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

45

if (*dst++ != *src++) \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

456

static int vmw_external_bo_copy(struct vmw_bo *dst, u32 dst_offset,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

463

container_of(dst->tbo.bdev, struct vmw_private, bdev);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

464

size_t dst_size = dst->tbo.resource->size;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

480

vdst = map_external(dst, &dst_map);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

512

unmap_external(dst, &dst_map);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

549

struct ttm_buffer_object *dst = &vmw_dst->tbo;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

560

bool dst_external = (dst->ttm->page_flags & TTM_TT_FLAG_EXTERNAL) != 0;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

562

if (WARN_ON(dst == src))

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

566

if (!(dst->pin_count))

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

567

dma_resv_assert_held(dst->base.resv);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

571

if (!ttm_tt_is_populated(dst->ttm)) {

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

572

ret = dst->bdev->funcs->ttm_tt_populate(dst->bdev, dst->ttm, &ctx);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

597

if (!dst->ttm->pages && dst->ttm->sg) {

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

598

dst_pages = kvmalloc_objs(struct page *, dst->ttm->num_pages);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

603

ret = drm_prime_sg_to_page_array(dst->ttm->sg, dst_pages,

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

604

dst->ttm->num_pages);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

61

const _type * dst, const _type * src, size_t size) \

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

613

d.dst_pages = dst->ttm->pages ? dst->ttm->pages : dst_pages;

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

615

d.dst_num_pages = PFN_UP(dst->resource->size);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

617

d.dst_prot = ttm_io_prot(dst, dst->resource, PAGE_KERNEL);

drivers/gpu/drm/vmwgfx/vmwgfx_blit.c

64

if (*--dst != *--src) \

drivers/gpu/drm/vmwgfx/vmwgfx_devcaps.c

127

void *dst, uint32_t dst_size)

drivers/gpu/drm/vmwgfx/vmwgfx_devcaps.c

132

memcpy(dst, vmw->devcaps, dst_size);

drivers/gpu/drm/vmwgfx/vmwgfx_devcaps.c

134

ret = vmw_fill_compat_cap(vmw, dst, dst_size);

drivers/gpu/drm/vmwgfx/vmwgfx_devcaps.c

139

memcpy(dst, &fifo_mem[SVGA_FIFO_3D_CAPS], dst_size);

drivers/gpu/drm/vmwgfx/vmwgfx_devcaps.h

39

void *dst, uint32_t dst_size);

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

1344

int vmw_bo_cpu_blit(struct vmw_bo *dst,

drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

152

items[SVGA_VIDEO_DST_X].value = arg->dst.x;

drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

153

items[SVGA_VIDEO_DST_Y].value = arg->dst.y;

drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

154

items[SVGA_VIDEO_DST_WIDTH].value = arg->dst.w;

drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

155

items[SVGA_VIDEO_DST_HEIGHT].value = arg->dst.h;

drivers/gpu/drm/xe/display/intel_bo.c

43

int intel_bo_read_from_page(struct drm_gem_object *obj, u64 offset, void *dst, int size)

drivers/gpu/drm/xe/display/intel_bo.c

47

return xe_bo_read(bo, offset, dst, size);

drivers/gpu/drm/xe/tests/xe_migrate.c

378

struct ttm_resource *src = src_bo->ttm.resource, *dst = dst_bo->ttm.resource;

drivers/gpu/drm/xe/tests/xe_migrate.c

384

bool dst_is_vram = mem_type_is_vram(dst->mem_type);

drivers/gpu/drm/xe/tests/xe_migrate.c

394

xe_res_first(dst, 0, size, &dst_it);

drivers/gpu/drm/xe/tests/xe_migrate.c

418

batch_size += pte_update_size(m, pte_flags, dst, &dst_it, &src_L0,

drivers/gpu/drm/xe/tests/xe_migrate.c

442

&dst_it, src_L0, dst);

drivers/gpu/drm/xe/xe_bo.c

2049

int xe_bo_read(struct xe_bo *bo, u64 offset, void *dst, int size)

drivers/gpu/drm/xe/xe_bo.c

2053

ret = ttm_bo_access(&bo->ttm, offset, dst, size, 0);

drivers/gpu/drm/xe/xe_bo.h

276

int xe_bo_read(struct xe_bo *bo, u64 offset, void *dst, int size);

drivers/gpu/drm/xe/xe_ggtt.c

1048

int xe_ggtt_node_save(struct xe_ggtt_node *node, void *dst, size_t size, u16 vfid)

drivers/gpu/drm/xe/xe_ggtt.c

1052

u64 *buf = dst;

drivers/gpu/drm/xe/xe_ggtt.h

50

int xe_ggtt_node_save(struct xe_ggtt_node *node, void *dst, size_t size, u16 vfid);

drivers/gpu/drm/xe/xe_gt_sriov_pf_migration.c

182

void *dst, size_t size)

drivers/gpu/drm/xe/xe_gt_sriov_pf_migration.c

205

memcpy(dst, xe_guc_buf_sync_read(buf), ret * sizeof(u32));

drivers/gpu/drm/xe/xe_gt_topology.c

108

gen_l3_mask_from_pattern(struct xe_device *xe, xe_l3_bank_mask_t dst,

drivers/gpu/drm/xe/xe_gt_topology.c

122

bitmap_or(dst, dst, shifted_pattern, XE_MAX_L3_BANK_MASK_BITS);

drivers/gpu/drm/xe/xe_guc_hwconfig.c

104

xe_map_memcpy_from(xe, dst, &guc->hwconfig.bo->vmap, 0,

drivers/gpu/drm/xe/xe_guc_hwconfig.c

98

void xe_guc_hwconfig_copy(struct xe_guc *guc, void *dst)

drivers/gpu/drm/xe/xe_guc_hwconfig.h

16

void xe_guc_hwconfig_copy(struct xe_guc *guc, void *dst);

drivers/gpu/drm/xe/xe_map.h

23

static inline void xe_map_memcpy_to(struct xe_device *xe, struct iosys_map *dst,

drivers/gpu/drm/xe/xe_map.h

28

iosys_map_memcpy_to(dst, dst_offset, src, len);

drivers/gpu/drm/xe/xe_map.h

31

static inline void xe_map_memcpy_from(struct xe_device *xe, void *dst,

drivers/gpu/drm/xe/xe_map.h

36

iosys_map_memcpy_from(dst, src, src_offset, len);

drivers/gpu/drm/xe/xe_map.h

40

struct iosys_map *dst, size_t offset,

drivers/gpu/drm/xe/xe_map.h

44

iosys_map_memset(dst, offset, value, len);

drivers/gpu/drm/xe/xe_migrate.c

1503

struct ttm_resource *dst,

drivers/gpu/drm/xe/xe_migrate.c

1506

bool clear_vram = mem_type_is_vram(dst->mem_type);

drivers/gpu/drm/xe/xe_migrate.c

1515

struct ttm_resource *src = dst;

drivers/gpu/drm/xe/xe_migrate.c

1572

clear_only_system_ccs, &src_it, clear_L0, dst);

drivers/gpu/drm/xe/xe_migrate.c

862

struct ttm_resource *dst,

drivers/gpu/drm/xe/xe_migrate.c

876

bool dst_is_pltt = dst->mem_type == XE_PL_TT;

drivers/gpu/drm/xe/xe_migrate.c

878

bool dst_is_vram = mem_type_is_vram(dst->mem_type);

drivers/gpu/drm/xe/xe_migrate.c

901

xe_res_first(dst, 0, size, &dst_it);

drivers/gpu/drm/xe/xe_migrate.c

938

batch_size += pte_update_size(m, pte_flags, dst,

drivers/gpu/drm/xe/xe_migrate.c

974

&dst_it, src_L0, dst);

drivers/gpu/drm/xe/xe_migrate.h

132

struct ttm_resource *dst,

drivers/gpu/drm/xe/xe_migrate.h

157

struct ttm_resource *dst,

drivers/gpu/drm/xe/xe_uc_fw.c

309

size_t xe_uc_fw_copy_rsa(struct xe_uc_fw *uc_fw, void *dst, u32 max_len)

drivers/gpu/drm/xe/xe_uc_fw.c

317

xe_map_memcpy_from(xe, dst, &uc_fw->bo->vmap,

drivers/gpu/drm/xe/xe_uc_fw.h

18

size_t xe_uc_fw_copy_rsa(struct xe_uc_fw *uc_fw, void *dst, u32 max_len);

drivers/hid/hid-picolcd_debugfs.c

369

static void dump_buff_as_hex(char *dst, size_t dst_sz, const u8 *data,

drivers/hid/hid-picolcd_debugfs.c

374

dst[j++] = hex_asc[(data[i] >> 4) & 0x0f];

drivers/hid/hid-picolcd_debugfs.c

375

dst[j++] = hex_asc[data[i] & 0x0f];

drivers/hid/hid-picolcd_debugfs.c

376

dst[j++] = ' ';

drivers/hid/hid-picolcd_debugfs.c

378

dst[j] = '\0';

drivers/hid/hid-picolcd_debugfs.c

380

dst[j-1] = '\n';

drivers/hid/hid-picolcd_debugfs.c

382

dst[j-2] = dst[j-3] = '.';

drivers/hid/intel-ish-hid/ishtp/loader.c

379

static void copy_ish_version(struct version_in_manifest *src, struct ish_version *dst)

drivers/hid/intel-ish-hid/ishtp/loader.c

381

dst->major = le16_to_cpu(src->major);

drivers/hid/intel-ish-hid/ishtp/loader.c

382

dst->minor = le16_to_cpu(src->minor);

drivers/hid/intel-ish-hid/ishtp/loader.c

383

dst->hotfix = le16_to_cpu(src->hotfix);

drivers/hid/intel-ish-hid/ishtp/loader.c

384

dst->build = le16_to_cpu(src->build);

drivers/hwmon/hp-wmi-sensors.c

422

char *dst;

drivers/hwmon/hp-wmi-sensors.c

435

dst = kmalloc((len + 1) * sizeof(*dst), GFP_KERNEL);

drivers/hwmon/hp-wmi-sensors.c

436

if (!dst)

drivers/hwmon/hp-wmi-sensors.c

439

i = utf16s_to_utf8s(++src, cps, UTF16_LITTLE_ENDIAN, dst, len);

drivers/hwmon/hp-wmi-sensors.c

440

dst[i] = '\0';

drivers/hwmon/hp-wmi-sensors.c

442

return dst;

drivers/hwmon/hp-wmi-sensors.c

448

char *dst;

drivers/hwmon/hp-wmi-sensors.c

453

dst = devm_kmalloc(dev, (len + 1) * sizeof(*dst), GFP_KERNEL);

drivers/hwmon/hp-wmi-sensors.c

454

if (!dst)

drivers/hwmon/hp-wmi-sensors.c

457

strscpy(dst, src, len + 1);

drivers/hwmon/hp-wmi-sensors.c

459

return dst;

drivers/hwmon/hp-wmi-sensors.c

466

char *dst;

drivers/hwmon/hp-wmi-sensors.c

472

dst = hp_wmi_strdup(dev, strim(src)); /* Note: Copy is trimmed. */

drivers/hwmon/hp-wmi-sensors.c

476

return dst;

drivers/hwtracing/intel_th/core.c

718

int src = 0, dst = 0;

drivers/hwtracing/intel_th/core.c

720

for (src = 0, dst = 0; dst <= th->num_thdevs; src++, dst++) {

drivers/hwtracing/intel_th/core.c

735

for (; dst < th->num_thdevs; dst++) {

drivers/hwtracing/intel_th/core.c

736

if (th->thdev[dst]->type != INTEL_TH_OUTPUT)

drivers/hwtracing/intel_th/core.c

739

if (th->thdev[dst]->output.type != otype)

drivers/hwtracing/intel_th/core.c

749

if (dst == th->num_thdevs)

drivers/i2c/busses/i2c-highlander.c

100

static void smbus_read_data(u16 *src, u8 *dst, int len)

drivers/i2c/busses/i2c-highlander.c

103

*(__be16 *)dst = cpu_to_be16p(src++);

drivers/i2c/busses/i2c-highlander.c

104

dst += 2;

drivers/i2c/busses/i2c-highlander.c

108

*dst = *src >> 8;

drivers/i2c/busses/i2c-highlander.c

89

static void smbus_write_data(u8 *src, u16 *dst, int len)

drivers/i2c/busses/i2c-highlander.c

92

*dst++ = be16_to_cpup((__be16 *)src);

drivers/i2c/busses/i2c-highlander.c

97

*dst = *src << 8;

drivers/i3c/master/svc-i3c-master.c

981

static int svc_i3c_master_readb(struct svc_i3c_master *master, u8 *dst,

drivers/i3c/master/svc-i3c-master.c

995

dst[i] = readl(master->regs + SVC_I3C_MRDATAB);

drivers/iio/imu/bno055/bno055.c

1397

__le16 *dst, *src;

drivers/iio/imu/bno055/bno055.c

1433

dst = buf + *buf_idx;

drivers/iio/imu/bno055/bno055.c

1438

if (dst != src)

drivers/iio/imu/bno055/bno055.c

1439

memcpy(dst, src, n * sizeof(__le16));

drivers/iio/pressure/bmp280-core.c

2203

u16 *dst = val;

drivers/iio/pressure/bmp280-core.c

2220

while (bytes >= sizeof(*dst)) {

drivers/iio/pressure/bmp280-core.c

2221

addr = bmp580_nvmem_addrs[offset / sizeof(*dst)];

drivers/iio/pressure/bmp280-core.c

2241

*dst++ = le16_to_cpu(data->le16);

drivers/iio/pressure/bmp280-core.c

2242

bytes -= sizeof(*dst);

drivers/iio/pressure/bmp280-core.c

2243

offset += sizeof(*dst);

drivers/infiniband/core/addr.c

313

static int dst_fetch_ha(const struct dst_entry *dst,

drivers/infiniband/core/addr.c

320

n = dst_neigh_lookup(dst, daddr);

drivers/infiniband/core/addr.c

328

neigh_ha_snapshot(dev_addr->dst_dev_addr, n, dst->dev);

drivers/infiniband/core/addr.c

336

static bool has_gateway(const struct dst_entry *dst, sa_family_t family)

drivers/infiniband/core/addr.c

339

return dst_rtable(dst)->rt_uses_gateway;

drivers/infiniband/core/addr.c

341

return dst_rt6_info(dst)->rt6i_flags & RTF_GATEWAY;

drivers/infiniband/core/addr.c

344

static int fetch_ha(const struct dst_entry *dst, struct rdma_dev_addr *dev_addr,

drivers/infiniband/core/addr.c

359

if (has_gateway(dst, family) && dev_addr->network == RDMA_NETWORK_IB)

drivers/infiniband/core/addr.c

362

return dst_fetch_ha(dst, dev_addr, daddr);

drivers/infiniband/core/addr.c

391

addr->hoplimit = ip4_dst_hoplimit(&rt->dst);

drivers/infiniband/core/addr.c

407

struct dst_entry *dst;

drivers/infiniband/core/addr.c

414

dst = ipv6_stub->ipv6_dst_lookup_flow(addr->net, NULL, &fl6, NULL);

drivers/infiniband/core/addr.c

415

if (IS_ERR(dst))

drivers/infiniband/core/addr.c

416

return PTR_ERR(dst);

drivers/infiniband/core/addr.c

421

addr->hoplimit = ip6_dst_hoplimit(dst);

drivers/infiniband/core/addr.c

423

*pdst = dst;

drivers/infiniband/core/addr.c

436

static bool is_dst_local(const struct dst_entry *dst)

drivers/infiniband/core/addr.c

438

if (dst->ops->family == AF_INET)

drivers/infiniband/core/addr.c

439

return !!(dst_rtable(dst)->rt_type & RTN_LOCAL);

drivers/infiniband/core/addr.c

440

else if (dst->ops->family == AF_INET6)

drivers/infiniband/core/addr.c

441

return !!(dst_rt6_info(dst)->rt6i_flags & RTF_LOCAL);

drivers/infiniband/core/addr.c

446

static int addr_resolve_neigh(const struct dst_entry *dst,

drivers/infiniband/core/addr.c

451

if (is_dst_local(dst)) {

drivers/infiniband/core/addr.c

459

return fetch_ha(dst, addr, dst_in, seq);

drivers/infiniband/core/addr.c

464

const struct dst_entry *dst)

drivers/infiniband/core/addr.c

466

struct net_device *ndev = READ_ONCE(dst->dev);

drivers/infiniband/core/addr.c

469

if (is_dst_local(dst)) {

drivers/infiniband/core/addr.c

484

rdma_copy_src_l2_addr(dev_addr, dst->dev);

drivers/infiniband/core/addr.c

492

if (has_gateway(dst, dst_in->sa_family) &&

drivers/infiniband/core/addr.c

536

struct dst_entry *dst = NULL;

drivers/infiniband/core/addr.c

565

dst = &rt->dst;

drivers/infiniband/core/addr.c

567

ret = addr6_resolve(src_in, dst_in, addr, &dst);

drivers/infiniband/core/addr.c

573

ret = rdma_set_src_addr_rcu(addr, dst_in, dst);

drivers/infiniband/core/addr.c

581

ret = addr_resolve_neigh(dst, dst_in, addr, seq);

drivers/infiniband/core/addr.c

586

dst_release(dst);

drivers/infiniband/core/cma.c

1365

static int cma_addr_cmp(const struct sockaddr *src, const struct sockaddr *dst)

drivers/infiniband/core/cma.c

1367

if (src->sa_family != dst->sa_family)

drivers/infiniband/core/cma.c

1373

((struct sockaddr_in *)dst)->sin_addr.s_addr;

drivers/infiniband/core/cma.c

1376

struct sockaddr_in6 *dst_addr6 = (struct sockaddr_in6 *)dst;

drivers/infiniband/core/cma.c

1392

&((struct sockaddr_ib *) dst)->sib_addr);

drivers/infiniband/core/multicast.c

284

struct ib_sa_mcmember_rec *dst, ib_sa_comp_mask comp_mask)

drivers/infiniband/core/multicast.c

289

memcmp(&src->port_gid, &dst->port_gid, sizeof src->port_gid))

drivers/infiniband/core/multicast.c

291

if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey)

drivers/infiniband/core/multicast.c

293

if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid)

drivers/infiniband/core/multicast.c

296

IB_SA_MCMEMBER_REC_MTU, dst->mtu_selector,

drivers/infiniband/core/multicast.c

297

src->mtu, dst->mtu))

drivers/infiniband/core/multicast.c

300

src->traffic_class != dst->traffic_class)

drivers/infiniband/core/multicast.c

302

if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey)

drivers/infiniband/core/multicast.c

305

IB_SA_MCMEMBER_REC_RATE, dst->rate_selector,

drivers/infiniband/core/multicast.c

306

src->rate, dst->rate))

drivers/infiniband/core/multicast.c

311

dst->packet_life_time_selector,

drivers/infiniband/core/multicast.c

312

src->packet_life_time, dst->packet_life_time))

drivers/infiniband/core/multicast.c

314

if (comp_mask & IB_SA_MCMEMBER_REC_SL && src->sl != dst->sl)

drivers/infiniband/core/multicast.c

317

src->flow_label != dst->flow_label)

drivers/infiniband/core/multicast.c

320

src->hop_limit != dst->hop_limit)

drivers/infiniband/core/multicast.c

322

if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE && src->scope != dst->scope)

drivers/infiniband/core/restrack.c

152

void rdma_restrack_parent_name(struct rdma_restrack_entry *dst,

drivers/infiniband/core/restrack.c

156

dst->kern_name = parent->kern_name;

drivers/infiniband/core/restrack.c

158

rdma_restrack_attach_task(dst, parent->task);

drivers/infiniband/core/restrack.h

34

void rdma_restrack_parent_name(struct rdma_restrack_entry *dst,

drivers/infiniband/core/ucma.c

1103

struct rdma_conn_param *dst,

drivers/infiniband/core/ucma.c

1106

dst->private_data = src->private_data;

drivers/infiniband/core/ucma.c

1107

dst->private_data_len = src->private_data_len;

drivers/infiniband/core/ucma.c

1108

dst->responder_resources = src->responder_resources;

drivers/infiniband/core/ucma.c

1109

dst->initiator_depth = src->initiator_depth;

drivers/infiniband/core/ucma.c

1110

dst->flow_control = src->flow_control;

drivers/infiniband/core/ucma.c

1111

dst->retry_count = src->retry_count;

drivers/infiniband/core/ucma.c

1112

dst->rnr_retry_count = src->rnr_retry_count;

drivers/infiniband/core/ucma.c

1113

dst->srq = src->srq;

drivers/infiniband/core/ucma.c

1114

dst->qp_num = src->qp_num & 0xFFFFFF;

drivers/infiniband/core/ucma.c

1115

dst->qkey = (id->route.addr.src_addr.ss_family == AF_IB) ? src->qkey : 0;

drivers/infiniband/core/ucma.c

231

static void ucma_copy_conn_event(struct rdma_ucm_conn_param *dst,

drivers/infiniband/core/ucma.c

235

memcpy(dst->private_data, src->private_data,

drivers/infiniband/core/ucma.c

237

dst->private_data_len = src->private_data_len;

drivers/infiniband/core/ucma.c

238

dst->responder_resources = src->responder_resources;

drivers/infiniband/core/ucma.c

239

dst->initiator_depth = src->initiator_depth;

drivers/infiniband/core/ucma.c

240

dst->flow_control = src->flow_control;

drivers/infiniband/core/ucma.c

241

dst->retry_count = src->retry_count;

drivers/infiniband/core/ucma.c

242

dst->rnr_retry_count = src->rnr_retry_count;

drivers/infiniband/core/ucma.c

243

dst->srq = src->srq;

drivers/infiniband/core/ucma.c

244

dst->qp_num = src->qp_num;

drivers/infiniband/core/ucma.c

248

struct rdma_ucm_ud_param *dst,

drivers/infiniband/core/ucma.c

252

memcpy(dst->private_data, src->private_data,

drivers/infiniband/core/ucma.c

254

dst->private_data_len = src->private_data_len;

drivers/infiniband/core/ucma.c

255

ib_copy_ah_attr_to_user(device, &dst->ah_attr, &src->ah_attr);

drivers/infiniband/core/ucma.c

256

dst->qp_num = src->qp_num;

drivers/infiniband/core/ucma.c

257

dst->qkey = src->qkey;

drivers/infiniband/core/umem.c

312

int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,

drivers/infiniband/core/umem.c

325

umem->sgt_append.sgt.orig_nents, dst, length,

drivers/infiniband/core/uverbs_marshall.c

100

dst->qp_state = src->qp_state;

drivers/infiniband/core/uverbs_marshall.c

101

dst->cur_qp_state = src->cur_qp_state;

drivers/infiniband/core/uverbs_marshall.c

102

dst->path_mtu = src->path_mtu;

drivers/infiniband/core/uverbs_marshall.c

103

dst->path_mig_state = src->path_mig_state;

drivers/infiniband/core/uverbs_marshall.c

104

dst->qkey = src->qkey;

drivers/infiniband/core/uverbs_marshall.c

105

dst->rq_psn = src->rq_psn;

drivers/infiniband/core/uverbs_marshall.c

106

dst->sq_psn = src->sq_psn;

drivers/infiniband/core/uverbs_marshall.c

107

dst->dest_qp_num = src->dest_qp_num;

drivers/infiniband/core/uverbs_marshall.c

108

dst->qp_access_flags = src->qp_access_flags;

drivers/infiniband/core/uverbs_marshall.c

110

dst->max_send_wr = src->cap.max_send_wr;

drivers/infiniband/core/uverbs_marshall.c

111

dst->max_recv_wr = src->cap.max_recv_wr;

drivers/infiniband/core/uverbs_marshall.c

112

dst->max_send_sge = src->cap.max_send_sge;

drivers/infiniband/core/uverbs_marshall.c

113

dst->max_recv_sge = src->cap.max_recv_sge;

drivers/infiniband/core/uverbs_marshall.c

114

dst->max_inline_data = src->cap.max_inline_data;

drivers/infiniband/core/uverbs_marshall.c

116

ib_copy_ah_attr_to_user(device, &dst->ah_attr, &src->ah_attr);

drivers/infiniband/core/uverbs_marshall.c

117

ib_copy_ah_attr_to_user(device, &dst->alt_ah_attr, &src->alt_ah_attr);

drivers/infiniband/core/uverbs_marshall.c

119

dst->pkey_index = src->pkey_index;

drivers/infiniband/core/uverbs_marshall.c

120

dst->alt_pkey_index = src->alt_pkey_index;

drivers/infiniband/core/uverbs_marshall.c

121

dst->en_sqd_async_notify = src->en_sqd_async_notify;

drivers/infiniband/core/uverbs_marshall.c

122

dst->sq_draining = src->sq_draining;

drivers/infiniband/core/uverbs_marshall.c

123

dst->max_rd_atomic = src->max_rd_atomic;

drivers/infiniband/core/uverbs_marshall.c

124

dst->max_dest_rd_atomic = src->max_dest_rd_atomic;

drivers/infiniband/core/uverbs_marshall.c

125

dst->min_rnr_timer = src->min_rnr_timer;

drivers/infiniband/core/uverbs_marshall.c

126

dst->port_num = src->port_num;

drivers/infiniband/core/uverbs_marshall.c

127

dst->timeout = src->timeout;

drivers/infiniband/core/uverbs_marshall.c

128

dst->retry_cnt = src->retry_cnt;

drivers/infiniband/core/uverbs_marshall.c

129

dst->rnr_retry = src->rnr_retry;

drivers/infiniband/core/uverbs_marshall.c

130

dst->alt_port_num = src->alt_port_num;

drivers/infiniband/core/uverbs_marshall.c

131

dst->alt_timeout = src->alt_timeout;

drivers/infiniband/core/uverbs_marshall.c

132

memset(dst->reserved, 0, sizeof(dst->reserved));

drivers/infiniband/core/uverbs_marshall.c

136

static void __ib_copy_path_rec_to_user(struct ib_user_path_rec *dst,

drivers/infiniband/core/uverbs_marshall.c

139

memcpy(dst->dgid, src->dgid.raw, sizeof(src->dgid));

drivers/infiniband/core/uverbs_marshall.c

140

memcpy(dst->sgid, src->sgid.raw, sizeof(src->sgid));

drivers/infiniband/core/uverbs_marshall.c

142

dst->dlid = htons(ntohl(sa_path_get_dlid(src)));

drivers/infiniband/core/uverbs_marshall.c

143

dst->slid = htons(ntohl(sa_path_get_slid(src)));

drivers/infiniband/core/uverbs_marshall.c

144

dst->raw_traffic = sa_path_get_raw_traffic(src);

drivers/infiniband/core/uverbs_marshall.c

145

dst->flow_label = src->flow_label;

drivers/infiniband/core/uverbs_marshall.c

146

dst->hop_limit = src->hop_limit;

drivers/infiniband/core/uverbs_marshall.c

147

dst->traffic_class = src->traffic_class;

drivers/infiniband/core/uverbs_marshall.c

148

dst->reversible = src->reversible;

drivers/infiniband/core/uverbs_marshall.c

149

dst->numb_path = src->numb_path;

drivers/infiniband/core/uverbs_marshall.c

150

dst->pkey = src->pkey;

drivers/infiniband/core/uverbs_marshall.c

151

dst->sl = src->sl;

drivers/infiniband/core/uverbs_marshall.c

152

dst->mtu_selector = src->mtu_selector;

drivers/infiniband/core/uverbs_marshall.c

153

dst->mtu = src->mtu;

drivers/infiniband/core/uverbs_marshall.c

154

dst->rate_selector = src->rate_selector;

drivers/infiniband/core/uverbs_marshall.c

155

dst->rate = src->rate;

drivers/infiniband/core/uverbs_marshall.c

156

dst->packet_life_time = src->packet_life_time;

drivers/infiniband/core/uverbs_marshall.c

157

dst->preference = src->preference;

drivers/infiniband/core/uverbs_marshall.c

158

dst->packet_life_time_selector = src->packet_life_time_selector;

drivers/infiniband/core/uverbs_marshall.c

161

void ib_copy_path_rec_to_user(struct ib_user_path_rec *dst,

drivers/infiniband/core/uverbs_marshall.c

168

__ib_copy_path_rec_to_user(dst, &rec);

drivers/infiniband/core/uverbs_marshall.c

171

__ib_copy_path_rec_to_user(dst, src);

drivers/infiniband/core/uverbs_marshall.c

63

struct ib_uverbs_ah_attr *dst,

drivers/infiniband/core/uverbs_marshall.c

69

memset(&dst->grh, 0, sizeof(dst->grh));

drivers/infiniband/core/uverbs_marshall.c

76

dst->dlid = rdma_ah_get_dlid(src);

drivers/infiniband/core/uverbs_marshall.c

77

dst->sl = rdma_ah_get_sl(src);

drivers/infiniband/core/uverbs_marshall.c

78

dst->src_path_bits = rdma_ah_get_path_bits(src);

drivers/infiniband/core/uverbs_marshall.c

79

dst->static_rate = rdma_ah_get_static_rate(src);

drivers/infiniband/core/uverbs_marshall.c

80

dst->is_global = rdma_ah_get_ah_flags(src) &

drivers/infiniband/core/uverbs_marshall.c

82

if (dst->is_global) {

drivers/infiniband/core/uverbs_marshall.c

85

memcpy(dst->grh.dgid, grh->dgid.raw, sizeof(grh->dgid));

drivers/infiniband/core/uverbs_marshall.c

86

dst->grh.flow_label = grh->flow_label;

drivers/infiniband/core/uverbs_marshall.c

87

dst->grh.sgid_index = grh->sgid_index;

drivers/infiniband/core/uverbs_marshall.c

88

dst->grh.hop_limit = grh->hop_limit;

drivers/infiniband/core/uverbs_marshall.c

89

dst->grh.traffic_class = grh->traffic_class;

drivers/infiniband/core/uverbs_marshall.c

91

dst->port_num = rdma_ah_get_port_num(src);

drivers/infiniband/core/uverbs_marshall.c

92

dst->reserved = 0;

drivers/infiniband/core/uverbs_marshall.c

97

struct ib_uverbs_qp_attr *dst,

drivers/infiniband/hw/cxgb4/cm.c

1232

dst_confirm(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2074

struct dst_entry *dst, struct c4iw_dev *cdev,

drivers/infiniband/hw/cxgb4/cm.c

2081

n = dst_neigh_lookup(dst, peer_ip);

drivers/infiniband/hw/cxgb4/cm.c

2128

ep->mtu = dst_mtu(dst);

drivers/infiniband/hw/cxgb4/cm.c

2203

ep->dst = cxgb_find_route(&ep->com.dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

2211

ep->dst = cxgb_find_route6(&ep->com.dev->rdev.lldi,

drivers/infiniband/hw/cxgb4/cm.c

2222

if (!ep->dst) {

drivers/infiniband/hw/cxgb4/cm.c

2227

err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, false,

drivers/infiniband/hw/cxgb4/cm.c

2249

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2340

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2377

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2521

struct dst_entry *dst;

drivers/infiniband/hw/cxgb4/cm.c

2557

dst = cxgb_find_route(&dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

2565

dst = cxgb_find_route6(&dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

2571

if (!dst) {

drivers/infiniband/hw/cxgb4/cm.c

2579

dst_release(dst);

drivers/infiniband/hw/cxgb4/cm.c

2583

err = import_ep(child_ep, iptype, peer_ip, dst, dev, false,

drivers/infiniband/hw/cxgb4/cm.c

2587

dst_release(dst);

drivers/infiniband/hw/cxgb4/cm.c

2645

child_ep->dst = dst;

drivers/infiniband/hw/cxgb4/cm.c

2698

dst_confirm(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2727

dst_confirm(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2930

dst_confirm(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

2964

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

3077

dst_confirm(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

3396

ep->dst = cxgb_find_route(&dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

3419

ep->dst = cxgb_find_route6(&dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

3426

if (!ep->dst) {

drivers/infiniband/hw/cxgb4/cm.c

3432

err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, true,

drivers/infiniband/hw/cxgb4/cm.c

3453

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

3795

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

407

dst_release(ep->dst);

drivers/infiniband/hw/cxgb4/cm.c

4072

struct dst_entry *dst;

drivers/infiniband/hw/cxgb4/cm.c

4141

dst = cxgb_find_route(&dev->rdev.lldi, get_real_dev,

drivers/infiniband/hw/cxgb4/cm.c

4144

if (!dst) {

drivers/infiniband/hw/cxgb4/cm.c

4148

neigh = dst_neigh_lookup_skb(dst, skb);

drivers/infiniband/hw/cxgb4/cm.c

4198

dst_release(dst);

drivers/infiniband/hw/cxgb4/iw_cxgb4.h

913

struct dst_entry *dst;

drivers/infiniband/hw/cxgb4/qp.c

2667

u64 *src, *dst;

drivers/infiniband/hw/cxgb4/qp.c

2670

dst = (u64 *)((u8 *)srq->queue + srq->wq_pidx * T4_EQ_ENTRY_SIZE);

drivers/infiniband/hw/cxgb4/qp.c

2672

*dst++ = *src++;

drivers/infiniband/hw/cxgb4/qp.c

2673

if (dst >= (u64 *)&srq->queue[srq->size])

drivers/infiniband/hw/cxgb4/qp.c

2674

dst = (u64 *)srq->queue;

drivers/infiniband/hw/cxgb4/qp.c

2675

*dst++ = *src++;

drivers/infiniband/hw/cxgb4/qp.c

2676

if (dst >= (u64 *)&srq->queue[srq->size])

drivers/infiniband/hw/cxgb4/qp.c

2677

dst = (u64 *)srq->queue;

drivers/infiniband/hw/cxgb4/t4.h

570

static inline void pio_copy(u64 __iomem *dst, u64 *src)

drivers/infiniband/hw/cxgb4/t4.h

575

writeq(*src, dst);

drivers/infiniband/hw/cxgb4/t4.h

577

dst++;

drivers/infiniband/hw/irdma/cm.c

1996

neigh = dst_neigh_lookup(&rt->dst, &dst_ipaddr);

drivers/infiniband/hw/irdma/cm.c

2020

struct dst_entry *dst = NULL;

drivers/infiniband/hw/irdma/cm.c

2030

dst = ip6_route_output(&init_net, NULL, &fl6);

drivers/infiniband/hw/irdma/cm.c

2033

return dst;

drivers/infiniband/hw/irdma/cm.c

2048

struct dst_entry *dst;

drivers/infiniband/hw/irdma/cm.c

2056

dst = irdma_get_dst_ipv6(&src_addr, &dst_addr);

drivers/infiniband/hw/irdma/cm.c

2057

if (!dst || dst->error) {

drivers/infiniband/hw/irdma/cm.c

2058

if (dst) {

drivers/infiniband/hw/irdma/cm.c

2059

dst_release(dst);

drivers/infiniband/hw/irdma/cm.c

2062

dst->error);

drivers/infiniband/hw/irdma/cm.c

2067

neigh = dst_neigh_lookup(dst, dst_addr.sin6_addr.in6_u.u6_addr32);

drivers/infiniband/hw/irdma/cm.c

2083

dst_release(dst);

drivers/infiniband/hw/irdma/cm.c

48

void irdma_copy_ip_ntohl(u32 *dst, __be32 *src)

drivers/infiniband/hw/irdma/cm.c

50

*dst++ = ntohl(*src++);

drivers/infiniband/hw/irdma/cm.c

51

*dst++ = ntohl(*src++);

drivers/infiniband/hw/irdma/cm.c

52

*dst++ = ntohl(*src++);

drivers/infiniband/hw/irdma/cm.c

53

*dst = ntohl(*src);

drivers/infiniband/hw/irdma/cm.c

61

void irdma_copy_ip_htonl(__be32 *dst, u32 *src)

drivers/infiniband/hw/irdma/cm.c

63

*dst++ = htonl(*src++);

drivers/infiniband/hw/irdma/cm.c

64

*dst++ = htonl(*src++);

drivers/infiniband/hw/irdma/cm.c

65

*dst++ = htonl(*src++);

drivers/infiniband/hw/irdma/cm.c

66

*dst = htonl(*src);

drivers/infiniband/hw/irdma/main.h

556

void irdma_copy_ip_ntohl(u32 *dst, __be32 *src);

drivers/infiniband/hw/irdma/main.h

557

void irdma_copy_ip_htonl(__be32 *dst, u32 *src);

drivers/infiniband/hw/mana/mana_ib.h

605

static inline void copy_in_reverse(u8 *dst, const u8 *src, u32 size)

drivers/infiniband/hw/mana/mana_ib.h

610

dst[size - 1 - i] = src[i];

drivers/infiniband/hw/mlx4/mcg.c

384

struct ib_sa_mcmember_data *dst, ib_sa_comp_mask comp_mask)

drivers/infiniband/hw/mlx4/mcg.c

391

if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey)

drivers/infiniband/hw/mlx4/mcg.c

393

if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid)

drivers/infiniband/hw/mlx4/mcg.c

397

src->mtusel_mtu, dst->mtusel_mtu))

drivers/infiniband/hw/mlx4/mcg.c

400

src->tclass != dst->tclass)

drivers/infiniband/hw/mlx4/mcg.c

402

if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey)

drivers/infiniband/hw/mlx4/mcg.c

406

src->ratesel_rate, dst->ratesel_rate))

drivers/infiniband/hw/mlx4/mcg.c

411

src->lifetmsel_lifetm, dst->lifetmsel_lifetm))

drivers/infiniband/hw/mlx4/mcg.c

415

(be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0xf0000000))

drivers/infiniband/hw/mlx4/mcg.c

419

(be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x0fffff00))

drivers/infiniband/hw/mlx4/mcg.c

423

(be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x000000ff))

drivers/infiniband/hw/mlx4/mcg.c

427

(dst->scope_join_state & 0xf0))

drivers/infiniband/hw/mlx5/fs.c

1043

struct mlx5_flow_destination dst;

drivers/infiniband/hw/mlx5/fs.c

1135

dst.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;

drivers/infiniband/hw/mlx5/fs.c

1136

dst.counter = opfc->fc;

drivers/infiniband/hw/mlx5/fs.c

1143

&flow_act, &dst, 1);

drivers/infiniband/hw/mlx5/fs.c

1229

struct mlx5_flow_destination dst;

drivers/infiniband/hw/mlx5/fs.c

1317

dst.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;

drivers/infiniband/hw/mlx5/fs.c

1318

dst.counter = opfc->fc;

drivers/infiniband/hw/mlx5/fs.c

1325

&flow_act, &dst, 1);

drivers/infiniband/hw/mlx5/fs.c

1512

struct mlx5_flow_destination *dst,

drivers/infiniband/hw/mlx5/fs.c

1555

if (dst && !(flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DROP)) {

drivers/infiniband/hw/mlx5/fs.c

1556

memcpy(&dest_arr[0], dst, sizeof(*dst));

drivers/infiniband/hw/mlx5/fs.c

1640

struct mlx5_flow_destination *dst)

drivers/infiniband/hw/mlx5/fs.c

1642

return _create_flow_rule(dev, ft_prio, flow_attr, dst, 0, NULL);

drivers/infiniband/hw/mlx5/fs.c

1648

struct mlx5_flow_destination *dst)

drivers/infiniband/hw/mlx5/fs.c

1675

handler = create_flow_rule(dev, ft_prio, &leftovers_wc.flow_attr, dst);

drivers/infiniband/hw/mlx5/fs.c

1679

&leftovers_uc.flow_attr, dst);

drivers/infiniband/hw/mlx5/fs.c

1696

struct mlx5_flow_destination *dst)

drivers/infiniband/hw/mlx5/fs.c

1707

handler_rx = create_flow_rule(dev, ft_rx, &flow_attr, dst);

drivers/infiniband/hw/mlx5/fs.c

1713

handler_tx = create_flow_rule(dev, ft_tx, &flow_attr, dst);

drivers/infiniband/hw/mlx5/fs.c

1738

struct mlx5_flow_destination *dst = NULL;

drivers/infiniband/hw/mlx5/fs.c

1795

dst = kzalloc_obj(*dst);

drivers/infiniband/hw/mlx5/fs.c

1796

if (!dst) {

drivers/infiniband/hw/mlx5/fs.c

1819

dst->type = MLX5_FLOW_DESTINATION_TYPE_PORT;

drivers/infiniband/hw/mlx5/fs.c

1821

dst->type = MLX5_FLOW_DESTINATION_TYPE_TIR;

drivers/infiniband/hw/mlx5/fs.c

1823

dst->tir_num = mqp->rss_qp.tirn;

drivers/infiniband/hw/mlx5/fs.c

1825

dst->tir_num = mqp->raw_packet_qp.rq.tirn;

drivers/infiniband/hw/mlx5/fs.c

1833

handler = _create_flow_rule(dev, ft_prio, flow_attr, dst,

drivers/infiniband/hw/mlx5/fs.c

1838

handler = create_leftovers_rule(dev, ft_prio, flow_attr, dst);

drivers/infiniband/hw/mlx5/fs.c

1841

handler = create_sniffer_rule(dev, ft_prio, ft_prio_tx, dst);

drivers/infiniband/hw/mlx5/fs.c

1855

kfree(dst);

drivers/infiniband/hw/mlx5/fs.c

1866

kfree(dst);

drivers/infiniband/hw/mlx5/fs.c

2051

struct mlx5_flow_destination *dst,

drivers/infiniband/hw/mlx5/fs.c

2079

flow_act, dst, dst_num);

drivers/infiniband/hw/mlx5/fs.c

2143

struct mlx5_flow_destination *dst;

drivers/infiniband/hw/mlx5/fs.c

2156

dst = kzalloc_objs(*dst, 2);

drivers/infiniband/hw/mlx5/fs.c

2157

if (!dst)

drivers/infiniband/hw/mlx5/fs.c

2173

dst[dst_num].type = dest_type;

drivers/infiniband/hw/mlx5/fs.c

2174

dst[dst_num++].tir_num = dest_id;

drivers/infiniband/hw/mlx5/fs.c

2178

dst[dst_num].type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE_NUM;

drivers/infiniband/hw/mlx5/fs.c

2179

dst[dst_num++].ft_num = dest_id;

drivers/infiniband/hw/mlx5/fs.c

2183

dst[dst_num++].type = MLX5_FLOW_DESTINATION_TYPE_PORT;

drivers/infiniband/hw/mlx5/fs.c

2195

dst[dst_num].type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;

drivers/infiniband/hw/mlx5/fs.c

2196

dst[dst_num].counter = counter;

drivers/infiniband/hw/mlx5/fs.c

2200

handler = _create_raw_flow_rule(dev, ft_prio, dst_num ? dst : NULL,

drivers/infiniband/hw/mlx5/fs.c

2213

kfree(dst);

drivers/infiniband/hw/mlx5/fs.c

2221

kfree(dst);

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

48

static inline void ocrdma_cpu_to_le32(void *dst, u32 len)

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

52

u32 *src_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

53

u32 *dst_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

59

static inline void ocrdma_le32_to_cpu(void *dst, u32 len)

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

63

u32 *src_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

64

u32 *dst_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

70

static inline void ocrdma_copy_cpu_to_le32(void *dst, void *src, u32 len)

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

75

u32 *dst_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

79

memcpy(dst, src, len);

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

83

static inline void ocrdma_copy_le32_to_cpu(void *dst, void *src, u32 len)

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

88

u32 *dst_ptr = dst;

drivers/infiniband/hw/ocrdma/ocrdma_hw.h

92

memcpy(dst, src, len);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

457

neigh = dst_neigh_lookup(&rt->dst, &dst_ip);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

482

struct dst_entry *dst;

drivers/infiniband/hw/qedr/qedr_iw_cm.c

490

dst = ip6_route_output(&init_net, NULL, &fl6);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

492

if ((!dst) || dst->error) {

drivers/infiniband/hw/qedr/qedr_iw_cm.c

493

if (dst) {

drivers/infiniband/hw/qedr/qedr_iw_cm.c

496

dst->error);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

497

dst_release(dst);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

501

neigh = dst_neigh_lookup(dst, &fl6.daddr);

drivers/infiniband/hw/qedr/qedr_iw_cm.c

514

dst_release(dst);

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

516

void pvrdma_qp_cap_to_ib(struct ib_qp_cap *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

518

void ib_qp_cap_to_pvrdma(struct pvrdma_qp_cap *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

520

void pvrdma_gid_to_ib(union ib_gid *dst, const union pvrdma_gid *src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

521

void ib_gid_to_pvrdma(union pvrdma_gid *dst, const union ib_gid *src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

522

void pvrdma_global_route_to_ib(struct ib_global_route *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

524

void ib_global_route_to_pvrdma(struct pvrdma_global_route *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

526

void pvrdma_ah_attr_to_rdma(struct rdma_ah_attr *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

528

void rdma_ah_attr_to_pvrdma(struct pvrdma_ah_attr *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

223

void pvrdma_qp_cap_to_ib(struct ib_qp_cap *dst, const struct pvrdma_qp_cap *src)

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

225

dst->max_send_wr = src->max_send_wr;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

226

dst->max_recv_wr = src->max_recv_wr;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

227

dst->max_send_sge = src->max_send_sge;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

228

dst->max_recv_sge = src->max_recv_sge;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

229

dst->max_inline_data = src->max_inline_data;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

232

void ib_qp_cap_to_pvrdma(struct pvrdma_qp_cap *dst, const struct ib_qp_cap *src)

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

234

dst->max_send_wr = src->max_send_wr;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

235

dst->max_recv_wr = src->max_recv_wr;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

236

dst->max_send_sge = src->max_send_sge;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

237

dst->max_recv_sge = src->max_recv_sge;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

238

dst->max_inline_data = src->max_inline_data;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

241

void pvrdma_gid_to_ib(union ib_gid *dst, const union pvrdma_gid *src)

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

244

memcpy(dst, src, sizeof(*src));

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

247

void ib_gid_to_pvrdma(union pvrdma_gid *dst, const union ib_gid *src)

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

250

memcpy(dst, src, sizeof(*src));

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

253

void pvrdma_global_route_to_ib(struct ib_global_route *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

256

pvrdma_gid_to_ib(&dst->dgid, &src->dgid);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

257

dst->flow_label = src->flow_label;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

258

dst->sgid_index = src->sgid_index;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

259

dst->hop_limit = src->hop_limit;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

260

dst->traffic_class = src->traffic_class;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

263

void ib_global_route_to_pvrdma(struct pvrdma_global_route *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

266

ib_gid_to_pvrdma(&dst->dgid, &src->dgid);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

267

dst->flow_label = src->flow_label;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

268

dst->sgid_index = src->sgid_index;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

269

dst->hop_limit = src->hop_limit;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

270

dst->traffic_class = src->traffic_class;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

273

void pvrdma_ah_attr_to_rdma(struct rdma_ah_attr *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

276

dst->type = RDMA_AH_ATTR_TYPE_ROCE;

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

277

pvrdma_global_route_to_ib(rdma_ah_retrieve_grh(dst), &src->grh);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

278

rdma_ah_set_dlid(dst, src->dlid);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

279

rdma_ah_set_sl(dst, src->sl);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

280

rdma_ah_set_path_bits(dst, src->src_path_bits);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

281

rdma_ah_set_static_rate(dst, src->static_rate);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

282

rdma_ah_set_ah_flags(dst, src->ah_flags);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

283

rdma_ah_set_port_num(dst, src->port_num);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

284

memcpy(dst->roce.dmac, &src->dmac, ETH_ALEN);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

287

void rdma_ah_attr_to_pvrdma(struct pvrdma_ah_attr *dst,

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

290

ib_global_route_to_pvrdma(&dst->grh, rdma_ah_read_grh(src));

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

291

dst->dlid = rdma_ah_get_dlid(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

292

dst->sl = rdma_ah_get_sl(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

293

dst->src_path_bits = rdma_ah_get_path_bits(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

294

dst->static_rate = rdma_ah_get_static_rate(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

295

dst->ah_flags = rdma_ah_get_ah_flags(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

296

dst->port_num = rdma_ah_get_port_num(src);

drivers/infiniband/hw/vmw_pvrdma/pvrdma_misc.c

297

memcpy(&dst->dmac, src->roce.dmac, sizeof(dst->dmac));

drivers/infiniband/sw/rdmavt/qp.c

100

__copy_user_nocache(dst, (void __user *)src, n);

drivers/infiniband/sw/rdmavt/qp.c

92

static void cacheless_memcpy(void *dst, void *src, size_t n)

drivers/infiniband/sw/rxe/rxe_net.c

123

return &rt->dst;

drivers/infiniband/sw/rxe/rxe_net.c

176

struct dst_entry *dst = NULL;

drivers/infiniband/sw/rxe/rxe_net.c

179

dst = sk_dst_get(qp->sk->sk);

drivers/infiniband/sw/rxe/rxe_net.c

181

if (!dst || !dst_check(dst, qp->dst_cookie)) {

drivers/infiniband/sw/rxe/rxe_net.c

182

if (dst)

drivers/infiniband/sw/rxe/rxe_net.c

183

dst_release(dst);

drivers/infiniband/sw/rxe/rxe_net.c

191

dst = rxe_find_route4(qp, ndev, saddr, daddr);

drivers/infiniband/sw/rxe/rxe_net.c

198

dst = rxe_find_route6(qp, ndev, saddr6, daddr6);

drivers/infiniband/sw/rxe/rxe_net.c

200

if (dst)

drivers/infiniband/sw/rxe/rxe_net.c

202

rt6_get_cookie((struct rt6_info *)dst);

drivers/infiniband/sw/rxe/rxe_net.c

206

if (dst && (qp_type(qp) == IB_QPT_RC)) {

drivers/infiniband/sw/rxe/rxe_net.c

207

dst_hold(dst);

drivers/infiniband/sw/rxe/rxe_net.c

208

sk_dst_set(qp->sk->sk, dst);

drivers/infiniband/sw/rxe/rxe_net.c

211

return dst;

drivers/infiniband/sw/rxe/rxe_net.c

307

static void prepare_ipv4_hdr(struct dst_entry *dst, struct sk_buff *skb,

drivers/infiniband/sw/rxe/rxe_net.c

316

skb_dst_set(skb, dst_clone(dst));

drivers/infiniband/sw/rxe/rxe_net.c

333

__ip_select_ident(dev_net(dst->dev), iph,

drivers/infiniband/sw/rxe/rxe_net.c

337

static void prepare_ipv6_hdr(struct dst_entry *dst, struct sk_buff *skb,

drivers/infiniband/sw/rxe/rxe_net.c

346

skb_dst_set(skb, dst_clone(dst));

drivers/infiniband/sw/rxe/rxe_net.c

364

struct dst_entry *dst;

drivers/infiniband/sw/rxe/rxe_net.c

370

dst = rxe_find_route(skb->dev, qp, av);

drivers/infiniband/sw/rxe/rxe_net.c

371

if (!dst) {

drivers/infiniband/sw/rxe/rxe_net.c

379

prepare_ipv4_hdr(dst, skb, saddr->s_addr, daddr->s_addr, IPPROTO_UDP,

drivers/infiniband/sw/rxe/rxe_net.c

382

dst_release(dst);

drivers/infiniband/sw/rxe/rxe_net.c

390

struct dst_entry *dst;

drivers/infiniband/sw/rxe/rxe_net.c

394

dst = rxe_find_route(skb->dev, qp, av);

drivers/infiniband/sw/rxe/rxe_net.c

395

if (!dst) {

drivers/infiniband/sw/rxe/rxe_net.c

403

prepare_ipv6_hdr(dst, skb, saddr, daddr, IPPROTO_UDP,

drivers/infiniband/sw/rxe/rxe_net.c

407

dst_release(dst);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

111

for (dst = &cntrs->tx_unicast, src = &vstats.tx_grp.unicast;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

112

dst < &cntrs->reserved[0]; dst++, src++) {

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

113

*dst = cpu_to_be64(*src);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

198

struct __opa_vesw_info *dst = &adapter->info.vesw;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

201

dst->fabric_id = be16_to_cpu(info->fabric_id);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

202

dst->vesw_id = be16_to_cpu(info->vesw_id);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

203

memcpy(dst->rsvd0, info->rsvd0, ARRAY_SIZE(info->rsvd0));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

204

dst->def_port_mask = be16_to_cpu(info->def_port_mask);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

205

memcpy(dst->rsvd1, info->rsvd1, ARRAY_SIZE(info->rsvd1));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

206

dst->pkey = be16_to_cpu(info->pkey);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

208

memcpy(dst->rsvd2, info->rsvd2, ARRAY_SIZE(info->rsvd2));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

209

dst->u_mcast_dlid = be32_to_cpu(info->u_mcast_dlid);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

211

dst->u_ucast_dlid[i] = be32_to_cpu(info->u_ucast_dlid[i]);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

213

dst->rc = be32_to_cpu(info->rc);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

215

memcpy(dst->rsvd3, info->rsvd3, ARRAY_SIZE(info->rsvd3));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

216

dst->eth_mtu = be16_to_cpu(info->eth_mtu);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

217

memcpy(dst->rsvd4, info->rsvd4, ARRAY_SIZE(info->rsvd4));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

279

struct __opa_per_veswport_info *dst = &adapter->info.vport;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

281

dst->port_num = be32_to_cpu(info->port_num);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

282

memcpy(dst->rsvd0, info->rsvd0, ARRAY_SIZE(info->rsvd0));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

284

memcpy(dst->base_mac_addr, info->base_mac_addr,

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

285

ARRAY_SIZE(dst->base_mac_addr));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

286

dst->config_state = info->config_state;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

287

memcpy(dst->rsvd1, info->rsvd1, ARRAY_SIZE(info->rsvd1));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

289

dst->encap_slid = be32_to_cpu(info->encap_slid);

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

290

memcpy(dst->pcp_to_sc_uc, info->pcp_to_sc_uc,

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

291

ARRAY_SIZE(dst->pcp_to_sc_uc));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

292

memcpy(dst->pcp_to_vl_uc, info->pcp_to_vl_uc,

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

293

ARRAY_SIZE(dst->pcp_to_vl_uc));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

294

memcpy(dst->pcp_to_sc_mc, info->pcp_to_sc_mc,

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

295

ARRAY_SIZE(dst->pcp_to_sc_mc));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

296

memcpy(dst->pcp_to_vl_mc, info->pcp_to_vl_mc,

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

297

ARRAY_SIZE(dst->pcp_to_vl_mc));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

298

dst->non_vlan_sc_uc = info->non_vlan_sc_uc;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

299

dst->non_vlan_vl_uc = info->non_vlan_vl_uc;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

300

dst->non_vlan_sc_mc = info->non_vlan_sc_mc;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

301

dst->non_vlan_vl_mc = info->non_vlan_vl_mc;

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

302

memcpy(dst->rsvd2, info->rsvd2, ARRAY_SIZE(info->rsvd2));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

303

memcpy(dst->rsvd3, info->rsvd3, ARRAY_SIZE(info->rsvd3));

drivers/infiniband/ulp/opa_vnic/opa_vnic_vema_iface.c

88

__be64 *dst;

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

171

.dst = &dstaddr

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

434

.dst = &clt_path->s.dst_addr,

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

1561

memcpy(&clt_path->s.dst_addr, path->dst,

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

1562

rdma_addr_size((struct sockaddr *)path->dst));

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

2637

.dst = &clt_path->s.dst_addr,

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

268

.dst = &srv_path->s.src_addr,

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

1838

path.dst = &srv_path->s.dst_addr;

drivers/infiniband/ulp/rtrs/rtrs.c

418

short port, struct sockaddr_storage *dst)

drivers/infiniband/ulp/rtrs/rtrs.c

420

struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst;

drivers/infiniband/ulp/rtrs/rtrs.c

456

u16 port, struct sockaddr_storage *dst)

drivers/infiniband/ulp/rtrs/rtrs.c

459

return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst);

drivers/infiniband/ulp/rtrs/rtrs.c

468

cpy, port_str, dst) : -ENOMEM;

drivers/infiniband/ulp/rtrs/rtrs.c

520

sockaddr_to_str((struct sockaddr *)addr->dst,

drivers/infiniband/ulp/rtrs/rtrs.c

558

return rtrs_str_to_sockaddr(str, len, port, addr->dst);

drivers/infiniband/ulp/rtrs/rtrs.h

42

struct sockaddr_storage *dst;

drivers/infiniband/ulp/srp/ib_srp.c

3446

ret = srp_parse_in(net, &target->rdma_cm.dst.ss, p,

drivers/infiniband/ulp/srp/ib_srp.c

347

&target->rdma_cm.dst.sa,

drivers/infiniband/ulp/srp/ib_srp.c

351

&target->rdma_cm.src, &target->rdma_cm.dst, ret);

drivers/infiniband/ulp/srp/ib_srp.c

361

&target->rdma_cm.dst, ret);

drivers/infiniband/ulp/srp/ib_srp.c

3748

&target->rdma_cm.dst);

drivers/infiniband/ulp/srp/ib_srp.c

3845

char dst[64];

drivers/infiniband/ulp/srp/ib_srp.c

3848

snprintf(dst, sizeof(dst), "%pIS",

drivers/infiniband/ulp/srp/ib_srp.c

3849

&target->rdma_cm.dst);

drivers/infiniband/ulp/srp/ib_srp.c

3851

snprintf(dst, sizeof(dst), "%pI6",

drivers/infiniband/ulp/srp/ib_srp.c

3856

target->ch_count, dst);

drivers/infiniband/ulp/srp/ib_srp.c

3881

target->sgid.raw, &target->rdma_cm.dst);

drivers/infiniband/ulp/srp/ib_srp.h

255

} dst;

drivers/input/input-mt.c

15

static void copy_abs(struct input_dev *dev, unsigned int dst, unsigned int src)

drivers/input/input-mt.c

18

dev->absinfo[dst] = dev->absinfo[src];

drivers/input/input-mt.c

19

dev->absinfo[dst].fuzz = 0;

drivers/input/input-mt.c

20

__set_bit(dst, dev->absbit);

drivers/input/input.c

488

void input_copy_abs(struct input_dev *dst, unsigned int dst_axis,

drivers/input/input.c

504

input_set_capability(dst, EV_ABS, dst_axis);

drivers/input/input.c

505

if (!dst->absinfo)

drivers/input/input.c

508

dst->absinfo[dst_axis] = src->absinfo[src_axis];

drivers/input/serio/i8042-acpipnpio.h

1480

static void i8042_pnp_id_to_string(struct pnp_id *id, char *dst, int dst_size)

drivers/input/serio/i8042-acpipnpio.h

1482

strscpy(dst, "PNP:", dst_size);

drivers/input/serio/i8042-acpipnpio.h

1485

strlcat(dst, " ", dst_size);

drivers/input/serio/i8042-acpipnpio.h

1486

strlcat(dst, id->id, dst_size);

drivers/input/touchscreen/himax_hx83112b.c

101

static int himax_bus_read(struct himax_ts_data *ts, u32 address, void *dst,

drivers/input/touchscreen/himax_hx83112b.c

123

dst, length);

drivers/input/touchscreen/himax_hx83112b.c

126

dst);

drivers/interconnect/core.c

1006

struct icc_node *dst;

drivers/interconnect/core.c

1015

dst = node_find(dst_id);

drivers/interconnect/core.c

1016

if (!dst) {

drivers/interconnect/core.c

1017

dst = icc_node_create_nolock(dst_id);

drivers/interconnect/core.c

1019

if (IS_ERR(dst)) {

drivers/interconnect/core.c

1020

ret = PTR_ERR(dst);

drivers/interconnect/core.c

1034

node->links[node->num_links++] = dst;

drivers/interconnect/core.c

168

static struct icc_path *path_init(struct device *dev, struct icc_node *dst,

drivers/interconnect/core.c

171

struct icc_node *node = dst;

drivers/interconnect/core.c

199

struct icc_node *dst)

drivers/interconnect/core.c

218

if (node == dst) {

drivers/interconnect/core.c

259

path = path_init(dev, dst, depth);

drivers/interconnect/core.c

602

struct icc_path *icc_get(struct device *dev, const char *src, const char *dst)

drivers/interconnect/core.c

615

dst_node = node_find_by_name(dst);

drivers/interconnect/core.c

617

dev_err(dev, "%s: invalid dst=%s\n", __func__, dst);

drivers/interconnect/debugfs-client.c

106

kfree(dst);

drivers/interconnect/debugfs-client.c

34

const char *dst;

drivers/interconnect/debugfs-client.c

39

static struct icc_path *get_path(const char *src, const char *dst)

drivers/interconnect/debugfs-client.c

44

if (!strcmp(path->src, src) && !strcmp(path->dst, dst))

drivers/interconnect/debugfs-client.c

54

char *src, *dst;

drivers/interconnect/debugfs-client.c

61

dst = rcu_dereference(dst_node);

drivers/interconnect/debugfs-client.c

68

cur_path = get_path(src, dst);

drivers/interconnect/debugfs-client.c

75

dst = kstrdup(dst, GFP_ATOMIC);

drivers/interconnect/debugfs-client.c

78

if (!src || !dst) {

drivers/interconnect/debugfs-client.c

83

cur_path = icc_get(&pdev->dev, src, dst);

drivers/interconnect/debugfs-client.c

97

debugfs_path->dst = dst;

drivers/interconnect/icc-clk.c

25

static int icc_clk_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/icc-kunit.c

66

static int icc_test_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/imx/imx.c

87

static int imx_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/imx/imx.c

95

return imx_icc_node_set(dst);

drivers/interconnect/internal.h

44

struct icc_path *icc_get(struct device *dev, const char *src, const char *dst);

drivers/interconnect/mediatek/icc-emi.c

37

static int mtk_emi_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/mediatek/icc-emi.c

39

struct mtk_icc_node *node = dst->data;

drivers/interconnect/qcom/icc-rpm.c

345

static int qcom_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/qcom/icc-rpm.c

355

if (dst)

drivers/interconnect/qcom/icc-rpm.c

356

dst_qn = dst->data;

drivers/interconnect/qcom/icc-rpmh.c

121

int qcom_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/qcom/icc-rpmh.c

127

node = dst;

drivers/interconnect/qcom/icc-rpmh.h

161

int qcom_icc_set(struct icc_node *src, struct icc_node *dst);

drivers/interconnect/qcom/msm8974.c

579

static int msm8974_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/qcom/msm8974.c

590

dst_qn = dst->data;

drivers/interconnect/qcom/osm-l3.c

111

static int qcom_osm_l3_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/qcom/osm-l3.c

123

rate = icc_units_to_bps(dst->peak_bw);

drivers/interconnect/samsung/exynos.c

61

static int exynos_generic_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/interconnect/samsung/exynos.c

63

struct exynos_icc_priv *src_priv = src->data, *dst_priv = dst->data;

drivers/interconnect/samsung/exynos.c

65

s32 dst_freq = max(dst->avg_bw, dst->peak_bw) / dst_priv->bus_clk_ratio;

drivers/interconnect/samsung/exynos.c

78

dst->name);

drivers/iommu/apple-dart.c

868

static int apple_dart_merge_master_cfg(struct apple_dart_master_cfg *dst,

drivers/iommu/apple-dart.c

879

if (dst->stream_maps[1].dart)

drivers/iommu/apple-dart.c

881

if (src->stream_maps[0].dart != dst->stream_maps[0].dart)

drivers/iommu/apple-dart.c

884

bitmap_or(dst->stream_maps[0].sidmap,

drivers/iommu/apple-dart.c

885

dst->stream_maps[0].sidmap,

drivers/iommu/apple-dart.c

887

dst->stream_maps[0].dart->num_streams);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1303

static void arm_smmu_write_cd_l1_desc(struct arm_smmu_cdtab_l1 *dst,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1309

WRITE_ONCE(dst->l2ptr, cpu_to_le64(val));

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1570

static void arm_smmu_write_strtab_l1_desc(struct arm_smmu_strtab_l1 *dst,

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

1579

WRITE_ONCE(dst->l2ptr, cpu_to_le64(val));

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

241

static void queue_write(__le64 *dst, u64 *src, size_t n_dwords)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

246

*dst++ = cpu_to_le64(*src++);

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

249

static void queue_read(u64 *dst, __le64 *src, size_t n_dwords)

drivers/iommu/arm/arm-smmu-v3/arm-smmu-v3.c

254

*dst++ = le64_to_cpu(*src++);

drivers/isdn/hardware/mISDN/hfcpci.c

670

u_char *src, *dst, new_f1;

drivers/isdn/hardware/mISDN/hfcpci.c

716

dst = df->data + le16_to_cpu(df->za[df->f1 & D_FREG_MASK].z1);

drivers/isdn/hardware/mISDN/hfcpci.c

721

memcpy(dst, src, maxlen); /* first copy */

drivers/isdn/hardware/mISDN/hfcpci.c

725

dst = df->data; /* start of buffer */

drivers/isdn/hardware/mISDN/hfcpci.c

727

memcpy(dst, src, count);

drivers/isdn/hardware/mISDN/hfcpci.c

748

u_char new_f1, *src, *dst;

drivers/isdn/hardware/mISDN/hfcpci.c

787

dst = bdata + (le16_to_cpu(*z1t) - B_SUB_VAL);

drivers/isdn/hardware/mISDN/hfcpci.c

793

fcnt, maxlen, new_z1, dst);

drivers/isdn/hardware/mISDN/hfcpci.c

796

memset(dst, bch->fill[0], maxlen); /* first copy */

drivers/isdn/hardware/mISDN/hfcpci.c

799

dst = bdata; /* start of buffer */

drivers/isdn/hardware/mISDN/hfcpci.c

800

memset(dst, bch->fill[0], count);

drivers/isdn/hardware/mISDN/hfcpci.c

823

dst = bdata + (le16_to_cpu(*z1t) - B_SUB_VAL);

drivers/isdn/hardware/mISDN/hfcpci.c

829

fcnt, maxlen, new_z1, dst);

drivers/isdn/hardware/mISDN/hfcpci.c

834

memcpy(dst, src, maxlen); /* first copy */

drivers/isdn/hardware/mISDN/hfcpci.c

837

dst = bdata; /* start of buffer */

drivers/isdn/hardware/mISDN/hfcpci.c

839

memcpy(dst, src, count);

drivers/isdn/hardware/mISDN/hfcpci.c

885

dst = bdata + (le16_to_cpu(bz->za[bz->f1].z1) - B_SUB_VAL);

drivers/isdn/hardware/mISDN/hfcpci.c

890

memcpy(dst, src, maxlen); /* first copy */

drivers/isdn/hardware/mISDN/hfcpci.c

894

dst = bdata; /* start of buffer */

drivers/isdn/hardware/mISDN/hfcpci.c

896

memcpy(dst, src, count);

drivers/isdn/hardware/mISDN/isdnhdlc.c

119

int *count, u8 *dst, int dsize)

drivers/isdn/hardware/mISDN/isdnhdlc.c

289

dst[hdlc->dstpos++] = hdlc->shift_reg;

drivers/isdn/hardware/mISDN/isdnhdlc.c

342

int *count, u8 *dst, int dsize)

drivers/isdn/hardware/mISDN/isdnhdlc.c

386

*dst++ = 0xff;

drivers/isdn/hardware/mISDN/isdnhdlc.c

393

*dst++ = bitrev8(hdlc->ffvalue);

drivers/isdn/hardware/mISDN/isdnhdlc.c

395

*dst++ = hdlc->ffvalue;

drivers/isdn/hardware/mISDN/isdnhdlc.c

583

*dst++ = bitrev8(hdlc->cbin);

drivers/isdn/hardware/mISDN/isdnhdlc.c

585

*dst++ = hdlc->cbin;

drivers/isdn/hardware/mISDN/isdnhdlc.c

605

*dst++ = bitrev8(hdlc->cbin);

drivers/isdn/hardware/mISDN/isdnhdlc.c

607

*dst++ = hdlc->cbin;

drivers/isdn/hardware/mISDN/isdnhdlc.h

62

int slen, int *count, u8 *dst, int dsize);

drivers/isdn/hardware/mISDN/isdnhdlc.h

67

u16 slen, int *count, u8 *dst, int dsize);

drivers/isdn/mISDN/dsp_blowfish.c

558

encrypt_block(const u32 *P, const u32 *S, u32 *dst, u32 *src)

drivers/isdn/mISDN/dsp_blowfish.c

583

dst[0] = yr;

drivers/isdn/mISDN/dsp_blowfish.c

584

dst[1] = yl;

drivers/mailbox/bcm-flexrm-mailbox.c

567

if (!msg->spu.src || !msg->spu.dst)

drivers/mailbox/bcm-flexrm-mailbox.c

578

for (sg = msg->spu.dst; sg; sg = sg_next(sg)) {

drivers/mailbox/bcm-flexrm-mailbox.c

595

struct scatterlist *src_sg = msg->spu.src, *dst_sg = msg->spu.dst;

drivers/mailbox/bcm-flexrm-mailbox.c

627

rc = dma_map_sg(dev, msg->spu.dst, sg_nents(msg->spu.dst),

drivers/mailbox/bcm-flexrm-mailbox.c

640

dma_unmap_sg(dev, msg->spu.dst, sg_nents(msg->spu.dst),

drivers/mailbox/bcm-flexrm-mailbox.c

654

struct scatterlist *src_sg = msg->spu.src, *dst_sg = msg->spu.dst;

drivers/mailbox/bcm-pdc-mailbox.c

1212

dst_nent = sg_nents(mssg->spu.dst);

drivers/mailbox/bcm-pdc-mailbox.c

1214

nent = dma_map_sg(dev, mssg->spu.dst, dst_nent,

drivers/mailbox/bcm-pdc-mailbox.c

1233

rx_desc_req = pdc_desc_count(mssg->spu.dst);

drivers/mailbox/bcm-pdc-mailbox.c

1238

err = pdc_rx_list_init(pdcs, mssg->spu.dst, mssg->ctx);

drivers/mailbox/bcm-pdc-mailbox.c

1239

err |= pdc_rx_list_sg_add(pdcs, mssg->spu.dst);

drivers/md/bcache/request.c

152

struct bkey *src = op->insert_keys.keys, *dst = op->insert_keys.keys;

drivers/md/bcache/request.c

158

memmove(dst, src, bkey_bytes(src));

drivers/md/bcache/request.c

160

dst = bkey_next(dst);

drivers/md/bcache/request.c

164

op->insert_keys.top = dst;

drivers/md/dm-crypt.c

567

u8 *dst;

drivers/md/dm-crypt.c

573

dst = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

574

crypt_iv_lmk_one(cc, iv, dmreq, dst + sg->offset);

drivers/md/dm-crypt.c

577

crypto_xor(dst + sg->offset, iv, cc->iv_size);

drivers/md/dm-crypt.c

579

kunmap_local(dst);

drivers/md/dm-crypt.c

694

u8 *dst;

drivers/md/dm-crypt.c

701

dst = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

702

crypt_iv_tcw_whitening(cc, dmreq, dst + sg->offset);

drivers/md/dm-crypt.c

703

kunmap_local(dst);

drivers/md/dm-crypt.c

737

struct scatterlist src, dst;

drivers/md/dm-crypt.c

757

sg_init_one(&dst, iv, cc->iv_size);

drivers/md/dm-crypt.c

758

skcipher_request_set_crypt(req, &src, &dst, cc->iv_size, buf);

drivers/md/dm-crypt.c

943

struct scatterlist *sg, *sg2, src, dst;

drivers/md/dm-crypt.c

960

sg_init_one(&dst, ks, 16);

drivers/md/dm-crypt.c

961

skcipher_request_set_crypt(req, &src, &dst, 16, NULL);

drivers/md/dm-crypt.c

969

sg_init_one(&dst, &ks[16], 16);

drivers/md/dm-integrity.c

1016

req->dst = target_sg[section];

drivers/md/dm-integrity.c

691

static void block_bitmap_copy(struct dm_integrity_c *ic, struct page_list *dst, struct page_list *src)

drivers/md/dm-integrity.c

697

unsigned long *dst_data = lowmem_page_address(dst[i].page);

drivers/md/dm-log-writes.c

735

void *dst;

drivers/md/dm-log-writes.c

747

dst = kmap_local_page(page);

drivers/md/dm-log-writes.c

748

memcpy_from_bvec(dst, &bv);

drivers/md/dm-log-writes.c

749

kunmap_local(dst);

drivers/md/dm-pcache/cache.h

402

static inline void cache_pos_copy(struct pcache_cache_pos *dst, struct pcache_cache_pos *src)

drivers/md/dm-pcache/cache.h

404

memcpy(dst, src, sizeof(struct pcache_cache_pos));

drivers/md/dm-pcache/segment.c

34

void *dst;

drivers/md/dm-pcache/segment.c

42

dst = segment->data + data_off;

drivers/md/dm-pcache/segment.c

43

copied = _copy_from_iter_flushcache(dst, data_len, &iter);

drivers/md/dm-zoned-reclaim.c

121

struct dm_io_region src, dst;

drivers/md/dm-zoned-reclaim.c

169

dst.bdev = dst_zone->dev->bdev;

drivers/md/dm-zoned-reclaim.c

170

dst.sector = dmz_blk2sect(dst_zone_block + block);

drivers/md/dm-zoned-reclaim.c

171

dst.count = src.count;

drivers/md/dm-zoned-reclaim.c

175

dm_kcopyd_copy(zrc->kc, &src, 1, &dst, flags,

drivers/media/cec/core/cec-adap.c

1223

struct cec_msg *dst = &data->msg;

drivers/media/cec/core/cec-adap.c

1230

if (!abort && dst->msg[1] == CEC_MSG_INITIATE_ARC &&

drivers/media/cec/core/cec-adap.c

1235

dst->reply = cmd;

drivers/media/cec/core/cec-adap.c

1240

if ((abort && cmd != dst->msg[1]) ||

drivers/media/cec/core/cec-adap.c

1245

if (msg_init != cec_msg_destination(dst) &&

drivers/media/cec/core/cec-adap.c

1246

!cec_msg_is_broadcast(dst))

drivers/media/cec/core/cec-adap.c

1250

memcpy(dst->msg, msg->msg, msg->len);

drivers/media/cec/core/cec-adap.c

1251

dst->len = msg->len;

drivers/media/cec/core/cec-adap.c

1252

dst->rx_ts = msg->rx_ts;

drivers/media/cec/core/cec-adap.c

1253

dst->rx_status = msg->rx_status;

drivers/media/cec/core/cec-adap.c

1255

dst->rx_status |= CEC_RX_STATUS_FEATURE_ABORT;

drivers/media/cec/core/cec-adap.c

1256

msg->flags = dst->flags;

drivers/media/cec/core/cec-adap.c

1257

msg->sequence = dst->sequence;

drivers/media/common/siano/smscoreapi.h

570

#define SMS_INIT_MSG_EX(ptr, type, src, dst, len) do { \

drivers/media/common/siano/smscoreapi.h

573

(ptr)->msg_dst_id = dst; \

drivers/media/dvb-frontends/rtl2832_sdr.c

172

void *dst, const u8 *src, unsigned int src_len)

drivers/media/dvb-frontends/rtl2832_sdr.c

179

memcpy(dst, src, src_len);

drivers/media/dvb-frontends/rtl2832_sdr.c

184

u16 *u16dst = dst;

drivers/media/i2c/cx25840/cx25840-vbi.c

22

static int decode_vps(u8 * dst, u8 * p)

drivers/media/i2c/cx25840/cx25840-vbi.c

66

dst[i / 2] = c;

drivers/media/i2c/ir-kbd-i2c.c

488

static void copy_codes(u8 *dst, u8 *src, unsigned int count)

drivers/media/i2c/ir-kbd-i2c.c

495

*dst++ = 0x70 | (c & 0xf);

drivers/media/i2c/ir-kbd-i2c.c

497

*dst++ = c;

drivers/media/i2c/saa7115.c

668

static int saa711x_decode_vps(u8 *dst, u8 *p)

drivers/media/i2c/saa7115.c

710

dst[i / 2] = c;

drivers/media/i2c/tvp7002.c

442

static int tvp7002_read(struct v4l2_subdev *sd, u8 addr, u8 *dst)

drivers/media/i2c/tvp7002.c

452

*dst = (u8)error;

drivers/media/i2c/tvp7002.c

473

u8 *dst, int *err)

drivers/media/i2c/tvp7002.c

476

*err = tvp7002_read(sd, reg, dst);

drivers/media/pci/bt8xx/dst_ca.c

657

struct dvb_device *dst_ca_attach(struct dst_state *dst, struct dvb_adapter *dvb_adapter)

drivers/media/pci/bt8xx/dst_ca.c

662

if (dvb_register_device(dvb_adapter, &dvbdev, &dvbdev_ca, dst,

drivers/media/pci/bt8xx/dst_ca.c

664

dst->dst_ca = dvbdev;

drivers/media/pci/bt8xx/dst_ca.c

665

return dst->dst_ca;

drivers/media/pci/bt8xx/dst_ca.h

41

struct dst_state *dst;

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

273

static void pb_sample_cpy(u8 *dst, const u8 *src, u32 len, bool is_s32)

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

280

u8 *out = dst + offset;

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

75

static void sample_cpy(u8 *dst, const u8 *src, u32 len, bool is_s32)

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

86

*dst++ = 0;

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

87

*dst++ = val & 0xff;

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

89

*dst++ = (val >> 8) & 0xff;

drivers/media/pci/cobalt/cobalt-alsa-pcm.c

90

*dst++ = (val >> 16) & 0xff;

drivers/media/pci/cx18/cx18-av-vbi.c

104

dst[i / 2] = c;

drivers/media/pci/cx18/cx18-av-vbi.c

60

static int decode_vps(u8 *dst, u8 *p)

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

107

cx18_raw_writel(cx, *src, dst);

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

108

if (cx18_raw_readl(cx, dst) != *src) {

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

114

dst++;

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

126

static int load_apu_fw_direct(const char *fn, u8 __iomem *dst, struct cx18 *cx,

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

177

dst + seghdr.addr + j);

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

178

if (cx18_raw_readl(cx, dst + seghdr.addr + j)

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

92

u32 __iomem *dst = (u32 __iomem *)mem;

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

15

u8 __iomem *dst = addr;

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

20

if ((count > 0) && ((unsigned long)dst & 1)) {

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

21

cx18_writeb(cx, (u8) val, dst);

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

23

dst++;

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

25

if ((count > 1) && ((unsigned long)dst & 2)) {

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

26

cx18_writew(cx, val2, dst);

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

28

dst += 2;

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

31

cx18_writel(cx, val4, dst);

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

33

dst += 4;

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

36

cx18_writew(cx, val2, dst);

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

38

dst += 2;

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

41

cx18_writeb(cx, (u8) val, dst);

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

46

u8 *dst = &cx->vbi.sliced_mpeg_data[idx][0];

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

63

dst[sd + 12 + line * 43] = cx18_service2vbi(sdata->id);

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

64

memcpy(dst + sd + 12 + line * 43 + 1, sdata->data, 42);

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

67

memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));

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

72

memcpy(dst + sd, "ITV0", 4);

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

73

memmove(dst + sd + 4, dst + sd + 12, line * 43);

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

76

memcpy(dst + sd, "itv0", 4);

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

79

memcpy(dst + sd + 4, &linemask[0], 8);

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

82

dst[4+16] = (size + 10) >> 8;

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

83

dst[5+16] = (size + 10) & 0xff;

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

84

dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);

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

85

dst[10+16] = (pts_stamp >> 22) & 0xff;

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

86

dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);

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

87

dst[12+16] = (pts_stamp >> 7) & 0xff;

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

88

dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);

drivers/media/pci/ddbridge/ddbridge-io.h

44

static inline void ddbcpyfrom(struct ddb *dev, void *dst, u32 adr, long count)

drivers/media/pci/ddbridge/ddbridge-io.h

46

memcpy_fromio(dst, dev->regs + adr, count);

drivers/media/pci/ivtv/ivtv-driver.h

259

__le32 dst;

drivers/media/pci/ivtv/ivtv-driver.h

265

u32 dst;

drivers/media/pci/ivtv/ivtv-firmware.c

48

volatile u32 __iomem *dst = (volatile u32 __iomem *)mem;

drivers/media/pci/ivtv/ivtv-firmware.c

63

__raw_writel(*src, dst);

drivers/media/pci/ivtv/ivtv-firmware.c

64

dst++;

drivers/media/pci/ivtv/ivtv-irq.c

222

s->sg_pending[idx].dst = buf->dma_handle;

drivers/media/pci/ivtv/ivtv-irq.c

356

s->sg_pending[idx].dst = offset;

drivers/media/pci/ivtv/ivtv-irq.c

368

s->sg_pending[idx].dst = offset;

drivers/media/pci/ivtv/ivtv-irq.c

375

s->sg_pending[idx].dst = offset;

drivers/media/pci/ivtv/ivtv-irq.c

383

s->sg_pending[idx].dst = offset;

drivers/media/pci/ivtv/ivtv-irq.c

419

s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);

drivers/media/pci/ivtv/ivtv-irq.c

435

s->sg_dma->dst = cpu_to_le32(s->sg_processing[s->sg_processed].dst);

drivers/media/pci/ivtv/ivtv-udma.c

70

dma->SGarray[i].dst = cpu_to_le32(buffer_offset);

drivers/media/pci/ivtv/ivtv-vbi.c

188

u8 *dst = &itv->vbi.sliced_mpeg_data[idx][0];

drivers/media/pci/ivtv/ivtv-vbi.c

204

dst[sd + 12 + line * 43] =

drivers/media/pci/ivtv/ivtv-vbi.c

206

memcpy(dst + sd + 12 + line * 43 + 1, itv->vbi.sliced_data[i].data, 42);

drivers/media/pci/ivtv/ivtv-vbi.c

209

memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));

drivers/media/pci/ivtv/ivtv-vbi.c

214

memcpy(dst + sd, "ITV0", 4);

drivers/media/pci/ivtv/ivtv-vbi.c

215

memmove(dst + sd + 4, dst + sd + 12, line * 43);

drivers/media/pci/ivtv/ivtv-vbi.c

218

memcpy(dst + sd, "itv0", 4);

drivers/media/pci/ivtv/ivtv-vbi.c

221

memcpy(dst + sd + 4, &linemask[0], 8);

drivers/media/pci/ivtv/ivtv-vbi.c

224

dst[4+16] = (size + 10) >> 8;

drivers/media/pci/ivtv/ivtv-vbi.c

225

dst[5+16] = (size + 10) & 0xff;

drivers/media/pci/ivtv/ivtv-vbi.c

226

dst[9+16] = 0x21 | ((pts_stamp >> 29) & 0x6);

drivers/media/pci/ivtv/ivtv-vbi.c

227

dst[10+16] = (pts_stamp >> 22) & 0xff;

drivers/media/pci/ivtv/ivtv-vbi.c

228

dst[11+16] = 1 | ((pts_stamp >> 14) & 0xff);

drivers/media/pci/ivtv/ivtv-vbi.c

229

dst[12+16] = (pts_stamp >> 7) & 0xff;

drivers/media/pci/ivtv/ivtv-vbi.c

230

dst[13+16] = 1 | ((pts_stamp & 0x7f) << 1);

drivers/media/pci/ivtv/ivtv-yuv.c

1132

dma_args.dst = yi->main_rect;

drivers/media/pci/ivtv/ivtv-yuv.c

131

dma->SGarray[dma->SG_length].dst = cpu_to_le32(IVTV_DECODER_OFFSET + yuv_offset[frame]);

drivers/media/pci/ivtv/ivtv-yuv.c

991

nf->dst_x = args->dst.left;

drivers/media/pci/ivtv/ivtv-yuv.c

992

nf->dst_y = args->dst.top;

drivers/media/pci/ivtv/ivtv-yuv.c

993

nf->dst_w = args->dst.width;

drivers/media/pci/ivtv/ivtv-yuv.c

994

nf->dst_h = args->dst.height;

drivers/media/pci/ivtv/ivtv-yuv.c

995

nf->tru_x = args->dst.left;

drivers/media/pci/ivtv/ivtvfb.c

372

void *dst;

drivers/media/pci/ivtv/ivtvfb.c

404

dst = (void __force *) (info->screen_base + p);

drivers/media/pci/ivtv/ivtvfb.c

412

((unsigned long)buf & 3) == ((unsigned long)dst & 3)) {

drivers/media/pci/ivtv/ivtvfb.c

414

if ((unsigned long)dst & 3) {

drivers/media/pci/ivtv/ivtvfb.c

415

lead = 4 - ((unsigned long)dst & 3);

drivers/media/pci/ivtv/ivtvfb.c

416

if (copy_from_user(dst, buf, lead))

drivers/media/pci/ivtv/ivtvfb.c

419

dst += lead;

drivers/media/pci/ivtv/ivtvfb.c

430

dst += dma_size;

drivers/media/pci/ivtv/ivtvfb.c

433

if (tail && copy_from_user(dst, buf, tail))

drivers/media/pci/ivtv/ivtvfb.c

435

} else if (copy_from_user(dst, buf, count)) {

drivers/media/pci/ngene/ngene-core.c

47

#define ngcpyfrom(dst, adr, count) memcpy_fromio((dst), dev->iomem + (adr), (count))

drivers/media/pci/saa7164/saa7164-fw.c

125

memcpy_toio(dst, srcbuf + offset, dstsize);

drivers/media/pci/saa7164/saa7164-fw.c

143

memcpy_toio(dst, srcbuf+offset, srcsize);

drivers/media/pci/saa7164/saa7164-fw.c

61

u32 dlflags, u8 __iomem *dst, u32 dstsize)

drivers/media/pci/saa7164/saa7164-fw.c

75

__func__, src, srcsize, dlflags, dst, dstsize);

drivers/media/pci/saa7164/saa7164-fw.c

77

if ((src == NULL) || (dst == NULL)) {

drivers/media/pci/solo6x10/solo6x10-g723.c

208

unsigned long pos, struct iov_iter *dst,

drivers/media/pci/solo6x10/solo6x10-g723.c

226

if (copy_to_iter(solo_pcm->g723_buf, G723_PERIOD_BYTES, dst) !=

drivers/media/pci/tw5864/tw5864-video.c

1218

u8 *dst;

drivers/media/pci/tw5864/tw5864-video.c

1234

dst = vb2_plane_vaddr(&vb->vb.vb2_buf, 0);

drivers/media/pci/tw5864/tw5864-video.c

1253

tw5864_h264_put_stream_header(&dst, &dst_space, input->qp,

drivers/media/pci/tw5864/tw5864-video.c

1257

tw5864_h264_put_slice_header(&dst, &dst_space, input->h264_idr_pic_id,

drivers/media/pci/tw5864/tw5864-video.c

1261

input->buf_cur_ptr = dst;

drivers/media/pci/tw5864/tw5864-video.c

1369

u8 *dst = input->buf_cur_ptr;

drivers/media/pci/tw5864/tw5864-video.c

1412

dst[0] = (input->tail & tail_mask) | (vlc_first_byte & vlc_mask);

drivers/media/pci/tw5864/tw5864-video.c

1414

dst++;

drivers/media/pci/tw5864/tw5864-video.c

1428

*dst++ = 0x03;

drivers/media/pci/tw5864/tw5864-video.c

1431

*dst++ = *src;

drivers/media/pci/tw5864/tw5864-video.c

1435

dst - (u8 *)vb2_plane_vaddr(&vb->vb.vb2_buf, 0));

drivers/media/platform/allegro-dvt/allegro-core.c

873

u32 *dst, size_t nbyte)

drivers/media/platform/allegro-dvt/allegro-core.c

895

dst, sizeof(*header) / stride);

drivers/media/platform/allegro-dvt/allegro-core.c

896

header = (void *)dst;

drivers/media/platform/allegro-dvt/allegro-core.c

917

dst + (sizeof(*header) / sizeof(*dst)),

drivers/media/platform/allegro-dvt/allegro-core.c

920

dst + (sizeof(*header) + body_no_wrap) / sizeof(*dst),

drivers/media/platform/allegro-dvt/allegro-mail.c

101

dst[i++] = param->videomode;

drivers/media/platform/allegro-dvt/allegro-mail.c

102

dst[i++] = param->format;

drivers/media/platform/allegro-dvt/allegro-mail.c

104

dst[i++] = param->colorspace;

drivers/media/platform/allegro-dvt/allegro-mail.c

105

dst[i++] = param->src_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

107

dst[i++] = param->src_bit_depth;

drivers/media/platform/allegro-dvt/allegro-mail.c

108

dst[i++] = FIELD_PREP(GENMASK(31, 24), codec) |

drivers/media/platform/allegro-dvt/allegro-mail.c

111

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->tier) |

drivers/media/platform/allegro-dvt/allegro-mail.c

121

dst[i++] = val;

drivers/media/platform/allegro-dvt/allegro-mail.c

127

dst[i++] = val;

drivers/media/platform/allegro-dvt/allegro-mail.c

133

dst[i++] = val;

drivers/media/platform/allegro-dvt/allegro-mail.c

139

dst[i++] = val;

drivers/media/platform/allegro-dvt/allegro-mail.c

142

dst[i++] = val;

drivers/media/platform/allegro-dvt/allegro-mail.c

145

dst[i++] = FIELD_PREP(GENMASK(15, 8), param->beta_offset) |

drivers/media/platform/allegro-dvt/allegro-mail.c

147

dst[i++] = param->unknown11;

drivers/media/platform/allegro-dvt/allegro-mail.c

148

dst[i++] = param->unknown12;

drivers/media/platform/allegro-dvt/allegro-mail.c

149

dst[i++] = param->num_slices;

drivers/media/platform/allegro-dvt/allegro-mail.c

150

dst[i++] = param->encoder_buffer_offset;

drivers/media/platform/allegro-dvt/allegro-mail.c

151

dst[i++] = param->encoder_buffer_enabled;

drivers/media/platform/allegro-dvt/allegro-mail.c

153

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->clip_vrt_range) |

drivers/media/platform/allegro-dvt/allegro-mail.c

155

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->me_range[1]) |

drivers/media/platform/allegro-dvt/allegro-mail.c

157

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->me_range[3]) |

drivers/media/platform/allegro-dvt/allegro-mail.c

159

dst[i++] = FIELD_PREP(GENMASK(31, 24), param->min_tu_size) |

drivers/media/platform/allegro-dvt/allegro-mail.c

163

dst[i++] = FIELD_PREP(GENMASK(15, 8), param->max_transfo_depth_intra) |

drivers/media/platform/allegro-dvt/allegro-mail.c

165

dst[i++] = param->entropy_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

166

dst[i++] = param->wp_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

168

dst[i++] = param->rate_control_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

169

dst[i++] = param->initial_rem_delay;

drivers/media/platform/allegro-dvt/allegro-mail.c

170

dst[i++] = param->cpb_size;

drivers/media/platform/allegro-dvt/allegro-mail.c

171

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->clk_ratio) |

drivers/media/platform/allegro-dvt/allegro-mail.c

173

dst[i++] = param->target_bitrate;

drivers/media/platform/allegro-dvt/allegro-mail.c

174

dst[i++] = param->max_bitrate;

drivers/media/platform/allegro-dvt/allegro-mail.c

175

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->min_qp) |

drivers/media/platform/allegro-dvt/allegro-mail.c

177

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->ip_delta) |

drivers/media/platform/allegro-dvt/allegro-mail.c

179

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->golden_ref) |

drivers/media/platform/allegro-dvt/allegro-mail.c

181

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->golden_ref_frequency) |

drivers/media/platform/allegro-dvt/allegro-mail.c

184

dst[i++] = param->rate_control_option;

drivers/media/platform/allegro-dvt/allegro-mail.c

186

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

189

dst[i++] = param->num_pixel;

drivers/media/platform/allegro-dvt/allegro-mail.c

190

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->max_pixel_value) |

drivers/media/platform/allegro-dvt/allegro-mail.c

193

dst[i++] = param->maxpicturesize[j];

drivers/media/platform/allegro-dvt/allegro-mail.c

197

dst[i++] = param->gop_ctrl_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

199

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

202

dst[i++] = FIELD_PREP(GENMASK(31, 24), param->freq_golden_ref) |

drivers/media/platform/allegro-dvt/allegro-mail.c

205

dst[i++] = param->freq_idr;

drivers/media/platform/allegro-dvt/allegro-mail.c

207

dst[i++] = param->enable_lt;

drivers/media/platform/allegro-dvt/allegro-mail.c

208

dst[i++] = param->freq_lt;

drivers/media/platform/allegro-dvt/allegro-mail.c

209

dst[i++] = param->gdr_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

211

dst[i++] = FIELD_PREP(GENMASK(31, 24), param->freq_golden_ref) |

drivers/media/platform/allegro-dvt/allegro-mail.c

216

dst[i++] = param->tmpdqp;

drivers/media/platform/allegro-dvt/allegro-mail.c

218

dst[i++] = param->subframe_latency;

drivers/media/platform/allegro-dvt/allegro-mail.c

219

dst[i++] = param->lda_control_mode;

drivers/media/platform/allegro-dvt/allegro-mail.c

221

dst[i++] = param->unknown41;

drivers/media/platform/allegro-dvt/allegro-mail.c

225

dst[i++] = param->lda_factors[j];

drivers/media/platform/allegro-dvt/allegro-mail.c

226

dst[i++] = param->max_num_merge_cand;

drivers/media/platform/allegro-dvt/allegro-mail.c

229

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

233

allegro_enc_create_channel(u32 *dst, struct mcu_msg_create_channel *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

238

dst[i++] = msg->user_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

241

dst[i++] = msg->blob_mcu_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

243

memcpy(&dst[i], msg->blob, msg->blob_size);

drivers/media/platform/allegro-dvt/allegro-mail.c

244

i += msg->blob_size / sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

248

dst[i++] = msg->ep1_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

250

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

271

allegro_enc_destroy_channel(u32 *dst, struct mcu_msg_destroy_channel *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

275

dst[i++] = msg->channel_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

277

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

281

allegro_enc_push_buffers(u32 *dst, struct mcu_msg_push_buffers_internal *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

288

dst[i++] = msg->channel_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

292

dst[i++] = buffer->dma_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

293

dst[i++] = buffer->mcu_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

294

dst[i++] = buffer->size;

drivers/media/platform/allegro-dvt/allegro-mail.c

297

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

301

allegro_enc_put_stream_buffer(u32 *dst,

drivers/media/platform/allegro-dvt/allegro-mail.c

306

dst[i++] = msg->channel_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

307

dst[i++] = msg->dma_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

308

dst[i++] = msg->mcu_addr;

drivers/media/platform/allegro-dvt/allegro-mail.c

309

dst[i++] = msg->size;

drivers/media/platform/allegro-dvt/allegro-mail.c

310

dst[i++] = msg->offset;

drivers/media/platform/allegro-dvt/allegro-mail.c

311

dst[i++] = lower_32_bits(msg->dst_handle);

drivers/media/platform/allegro-dvt/allegro-mail.c

312

dst[i++] = upper_32_bits(msg->dst_handle);

drivers/media/platform/allegro-dvt/allegro-mail.c

314

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

318

allegro_enc_encode_frame(u32 *dst, struct mcu_msg_encode_frame *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

323

dst[i++] = msg->channel_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

325

dst[i++] = msg->reserved;

drivers/media/platform/allegro-dvt/allegro-mail.c

326

dst[i++] = msg->encoding_options;

drivers/media/platform/allegro-dvt/allegro-mail.c

327

dst[i++] = FIELD_PREP(GENMASK(31, 16), msg->padding) |

drivers/media/platform/allegro-dvt/allegro-mail.c

331

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

332

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

333

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

334

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

337

dst[i++] = lower_32_bits(msg->user_param);

drivers/media/platform/allegro-dvt/allegro-mail.c

338

dst[i++] = upper_32_bits(msg->user_param);

drivers/media/platform/allegro-dvt/allegro-mail.c

339

dst[i++] = lower_32_bits(msg->src_handle);

drivers/media/platform/allegro-dvt/allegro-mail.c

340

dst[i++] = upper_32_bits(msg->src_handle);

drivers/media/platform/allegro-dvt/allegro-mail.c

341

dst[i++] = msg->request_options;

drivers/media/platform/allegro-dvt/allegro-mail.c

342

dst[i++] = msg->src_y;

drivers/media/platform/allegro-dvt/allegro-mail.c

343

dst[i++] = msg->src_uv;

drivers/media/platform/allegro-dvt/allegro-mail.c

345

dst[i++] = msg->is_10_bit;

drivers/media/platform/allegro-dvt/allegro-mail.c

346

dst[i++] = msg->stride;

drivers/media/platform/allegro-dvt/allegro-mail.c

348

dst[i++] = msg->format;

drivers/media/platform/allegro-dvt/allegro-mail.c

349

dst[i++] = msg->ep2;

drivers/media/platform/allegro-dvt/allegro-mail.c

350

dst[i++] = lower_32_bits(msg->ep2_v);

drivers/media/platform/allegro-dvt/allegro-mail.c

351

dst[i++] = upper_32_bits(msg->ep2_v);

drivers/media/platform/allegro-dvt/allegro-mail.c

353

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

44

allegro_enc_init(u32 *dst, struct mcu_msg_init_request *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

468

ssize_t allegro_encode_mail(u32 *dst, void *msg)

drivers/media/platform/allegro-dvt/allegro-mail.c

473

if (!msg || !dst)

drivers/media/platform/allegro-dvt/allegro-mail.c

478

size = allegro_enc_init(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

481

size = allegro_enc_create_channel(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

484

size = allegro_enc_destroy_channel(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

487

size = allegro_enc_encode_frame(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

49

dst[i++] = msg->reserved0;

drivers/media/platform/allegro-dvt/allegro-mail.c

490

size = allegro_enc_put_stream_buffer(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

494

size = allegro_enc_push_buffers(&dst[1], msg);

drivers/media/platform/allegro-dvt/allegro-mail.c

50

dst[i++] = msg->suballoc_dma;

drivers/media/platform/allegro-dvt/allegro-mail.c

505

dst[0] = FIELD_PREP(GENMASK(31, 16), header->type) |

drivers/media/platform/allegro-dvt/allegro-mail.c

508

return size + sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

51

dst[i++] = msg->suballoc_size;

drivers/media/platform/allegro-dvt/allegro-mail.c

52

dst[i++] = msg->encoder_buffer_size;

drivers/media/platform/allegro-dvt/allegro-mail.c

53

dst[i++] = msg->encoder_buffer_color_depth;

drivers/media/platform/allegro-dvt/allegro-mail.c

54

dst[i++] = msg->num_cores;

drivers/media/platform/allegro-dvt/allegro-mail.c

56

dst[i++] = msg->clk_rate;

drivers/media/platform/allegro-dvt/allegro-mail.c

57

dst[i++] = 0;

drivers/media/platform/allegro-dvt/allegro-mail.c

60

return i * sizeof(*dst);

drivers/media/platform/allegro-dvt/allegro-mail.c

88

allegro_encode_config_blob(u32 *dst, struct create_channel_param *param)

drivers/media/platform/allegro-dvt/allegro-mail.c

97

dst[i++] = param->layer_id;

drivers/media/platform/allegro-dvt/allegro-mail.c

98

dst[i++] = FIELD_PREP(GENMASK(31, 16), param->height) |

drivers/media/platform/allegro-dvt/allegro-mail.h

289

ssize_t allegro_encode_config_blob(u32 *dst, struct create_channel_param *param);

drivers/media/platform/allegro-dvt/allegro-mail.h

295

ssize_t allegro_encode_mail(u32 *dst, void *msg);

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

301

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

307

dst = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

310

dst->sequence = ctx->sequence_cap++;

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

312

dst->timecode = src->timecode;

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

313

dst->vb2_buf.timestamp = src->vb2_buf.timestamp;

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

314

dst->flags = src->flags;

drivers/media/platform/amlogic/meson-ge2d/ge2d.c

317

v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);

drivers/media/platform/amphion/venc.c

809

void *dst = vb2_plane_vaddr(&vbuf->vb2_buf, 0);

drivers/media/platform/amphion/venc.c

812

&rptr, frame->bytesused, dst);

drivers/media/platform/amphion/vpu_helpers.c

237

u32 *rptr, u32 size, void *dst)

drivers/media/platform/amphion/vpu_helpers.c

244

if (!stream_buffer || !rptr || !dst)

drivers/media/platform/amphion/vpu_helpers.c

259

memcpy(dst, virt + (offset - start), size);

drivers/media/platform/amphion/vpu_helpers.c

261

memcpy(dst, virt + (offset - start), end - offset);

drivers/media/platform/amphion/vpu_helpers.c

262

memcpy(dst + end - offset, virt, size + offset - end);

drivers/media/platform/amphion/vpu_helpers.c

431

return pairs[i].dst;

drivers/media/platform/amphion/vpu_helpers.c

437

int vpu_find_src_by_dst(struct vpu_pair *pairs, u32 cnt, u32 dst)

drivers/media/platform/amphion/vpu_helpers.c

445

if (pairs[i].dst == dst)

drivers/media/platform/amphion/vpu_helpers.h

13

u32 dst;

drivers/media/platform/amphion/vpu_helpers.h

27

u32 *rptr, u32 size, void *dst);

drivers/media/platform/amphion/vpu_helpers.h

69

int vpu_find_src_by_dst(struct vpu_pair *pairs, u32 cnt, u32 dst);

drivers/media/platform/amphion/vpu_malone.c

1159

static void set_payload_hdr(u8 *dst, u32 scd_type, u32 codec_id,

drivers/media/platform/amphion/vpu_malone.c

1166

dst[0] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1167

dst[1] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1168

dst[2] = 0x01;

drivers/media/platform/amphion/vpu_malone.c

1169

dst[3] = scd_type;

drivers/media/platform/amphion/vpu_malone.c

1172

dst[4] = ((payload_size >> 16) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1173

dst[5] = ((payload_size >> 8) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1174

dst[6] = 0x4e;

drivers/media/platform/amphion/vpu_malone.c

1175

dst[7] = ((payload_size >> 0) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1178

dst[8] = codec_id;

drivers/media/platform/amphion/vpu_malone.c

1179

dst[9] = MALONE_CODEC_VERSION_ID;

drivers/media/platform/amphion/vpu_malone.c

1182

dst[10] = ((width >> 8) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1183

dst[11] = ((width >> 0) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1184

dst[12] = 0x58;

drivers/media/platform/amphion/vpu_malone.c

1187

dst[13] = ((height >> 8) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1188

dst[14] = ((height >> 0) & 0xff);

drivers/media/platform/amphion/vpu_malone.c

1189

dst[15] = 0x50;

drivers/media/platform/amphion/vpu_malone.c

1192

static void set_vp8_ivf_seqhdr(u8 *dst, u32 width, u32 height)

drivers/media/platform/amphion/vpu_malone.c

1195

dst[0] = 0x44;

drivers/media/platform/amphion/vpu_malone.c

1196

dst[1] = 0x4b;

drivers/media/platform/amphion/vpu_malone.c

1197

dst[2] = 0x49;

drivers/media/platform/amphion/vpu_malone.c

1198

dst[3] = 0x46;

drivers/media/platform/amphion/vpu_malone.c

1200

dst[4] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1201

dst[5] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1203

dst[6] = MALONE_VP8_IVF_SEQ_HEADER_LEN;

drivers/media/platform/amphion/vpu_malone.c

1204

dst[7] = MALONE_VP8_IVF_SEQ_HEADER_LEN >> 8;

drivers/media/platform/amphion/vpu_malone.c

1206

dst[8] = 0x56;

drivers/media/platform/amphion/vpu_malone.c

1207

dst[9] = 0x50;

drivers/media/platform/amphion/vpu_malone.c

1208

dst[10] = 0x38;

drivers/media/platform/amphion/vpu_malone.c

1209

dst[11] = 0x30;

drivers/media/platform/amphion/vpu_malone.c

1211

dst[12] = width;

drivers/media/platform/amphion/vpu_malone.c

1212

dst[13] = width >> 8;

drivers/media/platform/amphion/vpu_malone.c

1214

dst[14] = height;

drivers/media/platform/amphion/vpu_malone.c

1215

dst[15] = height >> 8;

drivers/media/platform/amphion/vpu_malone.c

1217

dst[16] = 0xe8;

drivers/media/platform/amphion/vpu_malone.c

1218

dst[17] = 0x03;

drivers/media/platform/amphion/vpu_malone.c

1219

dst[18] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1220

dst[19] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1222

dst[20] = 0x01;

drivers/media/platform/amphion/vpu_malone.c

1223

dst[21] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1224

dst[22] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1225

dst[23] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1227

dst[24] = 0xdf;

drivers/media/platform/amphion/vpu_malone.c

1228

dst[25] = 0xf9;

drivers/media/platform/amphion/vpu_malone.c

1229

dst[26] = 0x09;

drivers/media/platform/amphion/vpu_malone.c

1230

dst[27] = 0x00;

drivers/media/platform/amphion/vpu_malone.c

1234

static void set_vp8_ivf_pichdr(u8 *dst, u32 frame_size)

drivers/media/platform/amphion/vpu_malone.c

1243

static void set_vc1_rcv_seqhdr(u8 *dst, u8 *src, u32 width, u32 height)

drivers/media/platform/amphion/vpu_malone.c

1249

dst[0] = frames;

drivers/media/platform/amphion/vpu_malone.c

1250

dst[1] = frames >> 8;

drivers/media/platform/amphion/vpu_malone.c

1251

dst[2] = frames >> 16;

drivers/media/platform/amphion/vpu_malone.c

1254

dst[3] = MALONE_VC1_RCV_CODEC_V1_VERSION;

drivers/media/platform/amphion/vpu_malone.c

1257

dst[4] = ext_data_size;

drivers/media/platform/amphion/vpu_malone.c

1258

dst[5] = ext_data_size >> 8;

drivers/media/platform/amphion/vpu_malone.c

1259

dst[6] = ext_data_size >> 16;

drivers/media/platform/amphion/vpu_malone.c

1260

dst[7] = ext_data_size >> 24;

drivers/media/platform/amphion/vpu_malone.c

1262

dst[8] = src[0];

drivers/media/platform/amphion/vpu_malone.c

1263

dst[9] = src[1];

drivers/media/platform/amphion/vpu_malone.c

1264

dst[10] = src[2];

drivers/media/platform/amphion/vpu_malone.c

1265

dst[11] = src[3];

drivers/media/platform/amphion/vpu_malone.c

1268

dst[12] = height;

drivers/media/platform/amphion/vpu_malone.c

1269

dst[13] = (height >> 8) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1270

dst[14] = (height >> 16) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1271

dst[15] = (height >> 24) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1273

dst[16] = width;

drivers/media/platform/amphion/vpu_malone.c

1274

dst[17] = (width >> 8) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1275

dst[18] = (width >> 16) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1276

dst[19] = (width >> 24) & 0xff;

drivers/media/platform/amphion/vpu_malone.c

1279

static void set_vc1_rcv_pichdr(u8 *dst, u32 buffer_size)

drivers/media/platform/amphion/vpu_malone.c

1281

dst[0] = buffer_size;

drivers/media/platform/amphion/vpu_malone.c

1282

dst[1] = buffer_size >> 8;

drivers/media/platform/amphion/vpu_malone.c

1283

dst[2] = buffer_size >> 16;

drivers/media/platform/amphion/vpu_malone.c

1284

dst[3] = buffer_size >> 24;

drivers/media/platform/amphion/vpu_malone.c

1287

static void create_vc1_nal_pichdr(u8 *dst)

drivers/media/platform/amphion/vpu_malone.c

1290

dst[0] = 0x0;

drivers/media/platform/amphion/vpu_malone.c

1291

dst[1] = 0x0;

drivers/media/platform/amphion/vpu_malone.c

1292

dst[2] = 0x01;

drivers/media/platform/amphion/vpu_malone.c

1293

dst[3] = 0x0D;

drivers/media/platform/arm/mali-c55/mali-c55-stats.c

210

void *dst;

drivers/media/platform/arm/mali-c55/mali-c55-stats.c

213

dst = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);

drivers/media/platform/arm/mali-c55/mali-c55-stats.c

214

memcpy_fromio(dst, src, MALI_C55_1024BIN_HIST_SIZE);

drivers/media/platform/arm/mali-c55/mali-c55-stats.c

217

dst += MALI_C55_1024BIN_HIST_SIZE;

drivers/media/platform/arm/mali-c55/mali-c55-stats.c

219

memcpy_fromio(dst, src, length);

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

2943

u32 *dst = dev->codebuf.vaddr;

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

2949

dst[i] = (src[i] << 16) | (src[i] >> 16);

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

2952

dst[i] = (src[i + 1] << 16) | (src[i + 1] >> 16);

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

2953

dst[i + 1] = (src[i] << 16) | (src[i] >> 16);

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

204

u32 *dst = parabuf + desc->offset;

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

210

dst[i + 1] = swab32(src[i]);

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

211

dst[i] = swab32(src[i + 1]);

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

383

static inline int coda_jpeg_scale(int src, int dst)

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

385

return (dst <= src / 8) ? 3 :

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

386

(dst <= src / 4) ? 2 :

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

387

(dst <= src / 2) ? 1 : 0;

drivers/media/platform/chips-media/coda/imx-vdoa.c

148

void vdoa_device_run(struct vdoa_ctx *ctx, dma_addr_t dst, dma_addr_t src)

drivers/media/platform/chips-media/coda/imx-vdoa.c

175

val = dst;

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

20

void vdoa_device_run(struct vdoa_ctx *ctx, dma_addr_t dst, dma_addr_t src);

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

41

dma_addr_t dst, dma_addr_t src) { };

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1068

struct vb2_v4l2_buffer *dst;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1075

dst = &lat_buf->ts_info;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1076

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1077

vsi->frame.cur_ts = dst->vb2_buf.timestamp;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1777

struct vb2_v4l2_buffer *dst;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1779

dst = v4l2_m2m_next_dst_buf(instance->ctx->m2m_ctx);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1780

if (!dst)

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_av1_req_lat_if.c

1783

v4l2_m2m_buf_copy_metadata(&lat_buf->ts_info, dst);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1649

struct vb2_v4l2_buffer *dst;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1651

dst = v4l2_m2m_next_dst_buf(instance->ctx->m2m_ctx);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1652

if (!dst)

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

1655

v4l2_m2m_buf_copy_metadata(&lat_buf->ts_info, dst);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

699

struct vb2_v4l2_buffer *dst;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

705

dst = v4l2_m2m_next_dst_buf(instance->ctx->m2m_ctx);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

706

if (!dst)

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

709

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

718

struct vb2_v4l2_buffer *dst;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

726

dst = &lat_buf->ts_info;

drivers/media/platform/mediatek/vcodec/decoder/vdec/vdec_vp9_req_lat_if.c

727

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/nvidia/tegra-vde/h264.c

650

struct vb2_v4l2_buffer *dst,

drivers/media/platform/nvidia/tegra-vde/h264.c

665

return &dst->vb2_buf;

drivers/media/platform/nvidia/tegra-vde/h264.c

755

struct vb2_v4l2_buffer *dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/nvidia/tegra-vde/h264.c

757

struct tegra_m2m_buffer *tb = vb_to_tegra_buf(&dst->vb2_buf);

drivers/media/platform/nvidia/tegra-vde/h264.c

779

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/nvidia/tegra-vde/h264.c

786

err = tegra_vde_h264_setup_frame(ctx, h264, NULL, &dst->vb2_buf, 0,

drivers/media/platform/nvidia/tegra-vde/h264.c

808

ref = get_ref_buf(ctx, dst, dpb_idx);

drivers/media/platform/nxp/imx8-isi/imx8-isi-hw.c

171

const struct v4l2_rect *dst)

drivers/media/platform/nxp/imx8-isi/imx8-isi-hw.c

178

if (src->height == dst->height && src->width == dst->width) {

drivers/media/platform/nxp/imx8-isi/imx8-isi-hw.c

184

val0 = CHNL_CROP_ULC_X(dst->left) | CHNL_CROP_ULC_Y(dst->top);

drivers/media/platform/nxp/imx8-isi/imx8-isi-hw.c

185

val1 = CHNL_CROP_LRC_X(dst->width) | CHNL_CROP_LRC_Y(dst->height);

drivers/media/platform/raspberrypi/pisp_be/pisp_be.c

839

void *dst = &node->pispbe->config[vb->index];

drivers/media/platform/raspberrypi/pisp_be/pisp_be.c

842

memcpy(dst, src, sizeof(struct pisp_be_tiles_config));

drivers/media/platform/raspberrypi/pisp_be/pisp_be.c

844

return pisp_be_validate_config(pispbe, dst);

drivers/media/platform/raspberrypi/rp1-cfe/cfe.c

2123

struct media_entity *src, *dst;

drivers/media/platform/raspberrypi/rp1-cfe/cfe.c

2130

dst = &node->video_dev.entity;

drivers/media/platform/raspberrypi/rp1-cfe/cfe.c

2134

dst = &cfe->fe.sd.entity;

drivers/media/platform/raspberrypi/rp1-cfe/cfe.c

2140

ret = media_create_pad_link(src, src_pad, dst, dst_pad, 0);

drivers/media/platform/renesas/rcar_fdp1.c

1218

job->dst = &fbuf->fields[0];

drivers/media/platform/renesas/rcar_fdp1.c

1221

job->dst->vb->sequence = ctx->sequence;

drivers/media/platform/renesas/rcar_fdp1.c

1238

job->dst->vb->vb2_buf.timestamp = job->active->vb->vb2_buf.timestamp;

drivers/media/platform/renesas/rcar_fdp1.c

1240

job->dst->vb->flags = job->active->vb->flags &

drivers/media/platform/renesas/rcar_fdp1.c

1334

v4l2_m2m_buf_done(job->dst->vb, state);

drivers/media/platform/renesas/rcar_fdp1.c

1335

job->dst = NULL;

drivers/media/platform/renesas/rcar_fdp1.c

2009

v4l2_m2m_buf_done(job->dst->vb, VB2_BUF_STATE_ERROR);

drivers/media/platform/renesas/rcar_fdp1.c

2010

job->dst = NULL;

drivers/media/platform/renesas/rcar_fdp1.c

549

struct fdp1_field_buffer *dst;

drivers/media/platform/renesas/rcar_fdp1.c

994

fdp1_write(fdp1, job->dst->addrs[0], FD1_WPF_ADDR_Y);

drivers/media/platform/renesas/rcar_fdp1.c

995

fdp1_write(fdp1, job->dst->addrs[1], FD1_WPF_ADDR_C0);

drivers/media/platform/renesas/rcar_fdp1.c

996

fdp1_write(fdp1, job->dst->addrs[2], FD1_WPF_ADDR_C1);

drivers/media/platform/renesas/vsp1/vsp1_drm.c

858

cfg->dst.left, cfg->dst.top, cfg->dst.width, cfg->dst.height,

drivers/media/platform/renesas/vsp1/vsp1_drm.c

880

input->compose = cfg->dst;

drivers/media/platform/rockchip/rga/rga-hw.c

26

static unsigned int rga_get_scaling(unsigned int src, unsigned int dst)

drivers/media/platform/rockchip/rga/rga-hw.c

36

return (src > dst) ? ((dst << 16) / src) : ((src << 16) / dst);

drivers/media/platform/rockchip/rga/rga-hw.c

413

struct rga_vb_buffer *src, struct rga_vb_buffer *dst)

drivers/media/platform/rockchip/rga/rga-hw.c

424

rga_cmd_set_src1_addr(ctx, dst->dma_desc_pa);

drivers/media/platform/rockchip/rga/rga-hw.c

426

rga_cmd_set_dst_addr(ctx, dst->dma_desc_pa);

drivers/media/platform/rockchip/rga/rga-hw.c

430

rga_cmd_set_dst_info(ctx, &dst->offset);

drivers/media/platform/rockchip/rga/rga-hw.c

441

struct rga_vb_buffer *src, struct rga_vb_buffer *dst)

drivers/media/platform/rockchip/rga/rga-hw.c

445

rga_cmd_set(ctx, src, dst);

drivers/media/platform/rockchip/rga/rga.c

38

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/rockchip/rga/rga.c

48

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/rockchip/rga/rga.c

50

rga_hw_start(rga, vb_to_rga(src), vb_to_rga(dst));

drivers/media/platform/rockchip/rga/rga.c

65

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/rockchip/rga/rga.c

73

dst = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);

drivers/media/platform/rockchip/rga/rga.c

76

WARN_ON(!dst);

drivers/media/platform/rockchip/rga/rga.c

78

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/rockchip/rga/rga.c

80

dst->sequence = ctx->csequence++;

drivers/media/platform/rockchip/rga/rga.c

83

v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);

drivers/media/platform/rockchip/rga/rga.h

148

struct rga_vb_buffer *src, struct rga_vb_buffer *dst);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

259

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

436

return &run->base.bufs.dst->vb2_buf;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

415

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

217

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

389

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

319

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

410

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

352

get_ref_buf(struct rkvdec_ctx *ctx, struct vb2_v4l2_buffer *dst, u64 timestamp)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

364

buf = &dst->vb2_buf;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

396

if (&ref_buf->base.vb == run->base.bufs.dst)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

481

struct rkvdec_decoded_buffer *dst, *last, *mv_ref;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

491

dst = vb2_to_rkvdec_decoded_buf(&run->base.bufs.dst->vb2_buf);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

492

ref_bufs[0] = get_ref_buf(ctx, &dst->base.vb, dec_params->last_frame_ts);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

493

ref_bufs[1] = get_ref_buf(ctx, &dst->base.vb, dec_params->golden_frame_ts);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

494

ref_bufs[2] = get_ref_buf(ctx, &dst->base.vb, dec_params->alt_frame_ts);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

497

last = get_ref_buf(ctx, &dst->base.vb, vp9_ctx->last.timestamp);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

499

last = dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

501

update_dec_buf_info(dst, dec_params);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

502

update_ctx_cur_info(vp9_ctx, dst, dec_params);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

609

last->vp9.width == dst->vp9.width &&

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

610

last->vp9.height == dst->vp9.height;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

621

hscale = (refw << 14) / dst->vp9.width;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

622

vscale = (refh << 14) / dst->vp9.height;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

628

addr = vb2_dma_contig_plane_dma_addr(&dst->base.vb.vb2_buf, 0);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

651

mv_ref = dst;

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1108

run->bufs.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1115

v4l2_m2m_buf_copy_metadata(run->bufs.src, run->bufs.dst);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1138

void rkvdec_memcpy_toio(void __iomem *dst, void *src, size_t len)

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1141

__iowrite32_copy(dst, src, len / 4);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1143

memcpy_toio(dst, src, len);

drivers/media/platform/rockchip/rkvdec/rkvdec.h

181

void rkvdec_memcpy_toio(void __iomem *dst, void *src, size_t len);

drivers/media/platform/rockchip/rkvdec/rkvdec.h

47

struct vb2_v4l2_buffer *dst;

drivers/media/platform/samsung/exynos-gsc/gsc-core.c

239

int gsc_cal_prescaler_ratio(struct gsc_variant *var, u32 src, u32 dst,

drivers/media/platform/samsung/exynos-gsc/gsc-core.c

242

if ((dst > src) || (dst >= src / var->poly_sc_down_max)) {

drivers/media/platform/samsung/exynos-gsc/gsc-core.c

247

if ((src / var->poly_sc_down_max / var->pre_sc_down_max) > dst) {

drivers/media/platform/samsung/exynos-gsc/gsc-core.c

252

*ratio = (dst > (src / 8)) ? 2 : 4;

drivers/media/platform/samsung/exynos-gsc/gsc-core.h

402

int gsc_cal_prescaler_ratio(struct gsc_variant *var, u32 src, u32 dst,

drivers/media/platform/samsung/exynos4-is/fimc-capture.c

568

const struct fimc_frame *dst = &ctx->d_frame;

drivers/media/platform/samsung/exynos4-is/fimc-capture.c

614

min_w = dst->offs_h + dst->width;

drivers/media/platform/samsung/exynos4-is/fimc-capture.c

615

min_h = dst->offs_v + dst->height;

drivers/media/platform/samsung/exynos4-is/fimc-capture.c

632

dst->f_width, dst->f_height);

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

33

static void __hw_param_copy(void *dst, void *src)

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

35

memcpy(dst, src, FIMC_IS_PARAM_MAX_SIZE);

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

40

struct param_global_shotmode *dst, *src;

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

42

dst = &is->is_p_region->parameter.global.shotmode;

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

44

__hw_param_copy(dst, src);

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

49

struct param_sensor_framerate *dst, *src;

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

51

dst = &is->is_p_region->parameter.sensor.frame_rate;

drivers/media/platform/samsung/exynos4-is/fimc-is-param.c

53

__hw_param_copy(dst, src);

drivers/media/platform/samsung/s5p-g2d/g2d-hw.c

84

struct g2d_frame *dst)

drivers/media/platform/samsung/s5p-g2d/g2d-hw.c

89

w((src->c_width << 16) / dst->c_width, SRC_XSCALE_REG);

drivers/media/platform/samsung/s5p-g2d/g2d-hw.c

90

w((src->c_height << 16) / dst->c_height, SRC_YSCALE_REG);

drivers/media/platform/samsung/s5p-g2d/g2d.c

501

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/samsung/s5p-g2d/g2d.c

508

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/samsung/s5p-g2d/g2d.c

519

g2d_set_dst_addr(dev, vb2_dma_contig_plane_dma_addr(&dst->vb2_buf, 0));

drivers/media/platform/samsung/s5p-g2d/g2d.c

542

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/samsung/s5p-g2d/g2d.c

550

dst = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);

drivers/media/platform/samsung/s5p-g2d/g2d.c

553

BUG_ON(dst == NULL);

drivers/media/platform/samsung/s5p-g2d/g2d.c

555

dst->timecode = src->timecode;

drivers/media/platform/samsung/s5p-g2d/g2d.c

556

dst->vb2_buf.timestamp = src->vb2_buf.timestamp;

drivers/media/platform/samsung/s5p-g2d/g2d.c

557

dst->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;

drivers/media/platform/samsung/s5p-g2d/g2d.c

558

dst->flags |=

drivers/media/platform/samsung/s5p-g2d/g2d.c

562

v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);

drivers/media/platform/samsung/s5p-g2d/g2d.h

83

struct g2d_frame *src, struct g2d_frame *dst);

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

444

struct bdisp_frame src, dst;

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

452

dst = request->dst;

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

457

bdisp_fmt_to_str(src), bdisp_fmt_to_str(dst));

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

461

dst.crop.left, dst.crop.top,

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

462

dst.crop.width, dst.crop.height);

drivers/media/platform/st/sti/bdisp/bdisp-debug.c

464

src.width, src.height, dst.width, dst.height);

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

1056

request->dst = ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

634

dst_w = ctx->dst.crop.width;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

635

dst_h = ctx->dst.crop.height;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

662

struct bdisp_frame *dst = &ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

681

c->dst_nbp = dst->fmt->nb_planes;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

682

c->dst_yuv = (dst->fmt->pixelformat == V4L2_PIX_FMT_NV12) ||

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

683

(dst->fmt->pixelformat == V4L2_PIX_FMT_YUV420);

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

763

struct bdisp_frame *dst = &ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

766

struct v4l2_rect dst_rect = dst->crop;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

768

s32 dst_width = dst->crop.width;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

787

dst_fmt = dst->fmt->pixelformat;

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

828

node->tba = (t_plan == BDISP_CBCR) ? dst->paddr[1] : dst->paddr[0];

drivers/media/platform/st/sti/bdisp/bdisp-hw.c

830

node->tty = dst->bytesperline;

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

174

return &ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

286

struct bdisp_frame *src, *dst;

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

291

dst = &ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

299

ret = bdisp_get_addr(ctx, &dst_vb->vb2_buf, dst, dst->paddr);

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

613

ctx->dst = bdisp_dflt_fmt;

drivers/media/platform/st/sti/bdisp/bdisp-v4l2.c

813

&ctx->src : &ctx->dst;

drivers/media/platform/st/sti/bdisp/bdisp.h

115

struct bdisp_frame dst;

drivers/media/platform/st/sti/bdisp/bdisp.h

91

struct bdisp_frame dst;

drivers/media/platform/st/stm32/dma2d/dma2d.c

470

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/st/stm32/dma2d/dma2d.c

477

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/st/stm32/dma2d/dma2d.c

478

if (!dst || !src)

drivers/media/platform/st/stm32/dma2d/dma2d.c

487

dst->sequence = frm_cap->sequence++;

drivers/media/platform/st/stm32/dma2d/dma2d.c

488

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/st/stm32/dma2d/dma2d.c

506

vb2_dma_contig_plane_dma_addr(&dst->vb2_buf, 0));

drivers/media/platform/st/stm32/dma2d/dma2d.c

518

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/st/stm32/dma2d/dma2d.c

528

dst = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);

drivers/media/platform/st/stm32/dma2d/dma2d.c

530

WARN_ON(!dst);

drivers/media/platform/st/stm32/dma2d/dma2d.c

534

v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

152

addr = vb2_dma_contig_plane_dma_addr(&dst->vb2_buf, 0);

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

220

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

249

dst = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

250

v4l2_m2m_buf_done(dst, state);

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

66

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

72

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/sunxi/sun8i-di/sun8i-di.c

74

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/sunxi/sun8i-rotate/sun8i-formats.h

23

int rotate_enum_fmt(struct v4l2_fmtdesc *f, bool dst);

drivers/media/platform/sunxi/sun8i-rotate/sun8i_formats.c

252

int rotate_enum_fmt(struct v4l2_fmtdesc *f, bool dst)

drivers/media/platform/sunxi/sun8i-rotate/sun8i_formats.c

260

if (dst && !(rotate_formats[i].flags & ROTATE_FLAG_OUTPUT))

drivers/media/platform/sunxi/sun8i-rotate/sun8i_rotate.c

116

rotate_calc_addr_pitch(vb2_dma_contig_plane_dma_addr(&dst->vb2_buf, 0),

drivers/media/platform/sunxi/sun8i-rotate/sun8i_rotate.c

65

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/sunxi/sun8i-rotate/sun8i_rotate.c

71

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/sunxi/sun8i-rotate/sun8i_rotate.c

73

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/verisilicon/hantro_drv.c

173

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/verisilicon/hantro_drv.c

177

dst = hantro_get_dst_buf(ctx);

drivers/media/platform/verisilicon/hantro_drv.c

187

v4l2_m2m_buf_copy_metadata(src, dst);

drivers/media/platform/verisilicon/hantro_drv.c

66

struct vb2_v4l2_buffer *src, *dst;

drivers/media/platform/verisilicon/hantro_drv.c

69

dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/verisilicon/hantro_drv.c

73

if (WARN_ON(!dst))

drivers/media/platform/verisilicon/hantro_drv.c

77

dst->sequence = ctx->sequence_cap++;

drivers/media/platform/verisilicon/hantro_drv.c

80

dst->flags |= V4L2_BUF_FLAG_LAST;

drivers/media/platform/verisilicon/hantro_g2_hevc_dec.c

384

struct hantro_decoded_buffer *dst;

drivers/media/platform/verisilicon/hantro_g2_hevc_dec.c

476

dst = vb2_to_hantro_decoded_buf(&vb2_dst->vb2_buf);

drivers/media/platform/verisilicon/hantro_g2_hevc_dec.c

477

luma_addr = hantro_get_dec_buf_addr(ctx, &dst->base.vb.vb2_buf);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

104

buf = &dst->vb2_buf;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

129

struct hantro_decoded_buffer *dst,

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

138

luma_addr = hantro_get_dec_buf_addr(ctx, &dst->base.vb.vb2_buf);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

143

dst->vp9.chroma_offset = hantro_g2_chroma_offset(ctx);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

147

dst->vp9.mv_offset = hantro_g2_motion_vectors_offset(ctx);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

160

struct hantro_decoded_buffer *dst,

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

169

buf = get_ref_buf(ctx, &dst->base.vb, ref_ts);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

176

hantro_reg_write(ctx->dev, &ref_reg->hor_scale, (refw << 14) / dst->vp9.width);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

177

hantro_reg_write(ctx->dev, &ref_reg->ver_scale, (refh << 14) / dst->vp9.height);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

188

struct hantro_decoded_buffer *dst,

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

220

config_ref(ctx, dst, &ref_regs[0], dec_params, dec_params->last_frame_ts);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

221

config_ref(ctx, dst, &ref_regs[1], dec_params, dec_params->golden_frame_ts);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

222

config_ref(ctx, dst, &ref_regs[2], dec_params, dec_params->alt_frame_ts);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

308

struct hantro_decoded_buffer *dst)

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

324

unsigned int sbs_r = hantro_vp9_num_sbs(dst->vp9.height);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

325

unsigned int sbs_c = hantro_vp9_num_sbs(dst->vp9.width);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

337

tile_mem[0] = hantro_vp9_num_sbs(dst->vp9.width);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

338

tile_mem[1] = hantro_vp9_num_sbs(dst->vp9.height);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

486

static void config_picture_dimensions(struct hantro_ctx *ctx, struct hantro_decoded_buffer *dst)

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

490

hantro_reg_write(ctx->dev, &g2_pic_width_in_cbs, (dst->vp9.width + 7) / 8);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

491

hantro_reg_write(ctx->dev, &g2_pic_height_in_cbs, (dst->vp9.height + 7) / 8);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

492

pic_w_4x4 = roundup(dst->vp9.width, 8) >> 2;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

493

pic_h_4x4 = roundup(dst->vp9.height, 8) >> 2;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

812

struct hantro_decoded_buffer *dst, *last, *mv_ref;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

818

dst = vb2_to_hantro_decoded_buf(&vb2_dst->vb2_buf);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

821

last = get_ref_buf(ctx, &dst->base.vb, vp9_ctx->last.timestamp);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

823

last = dst;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

825

update_dec_buf_info(dst, dec_params);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

826

update_ctx_cur_info(vp9_ctx, dst, dec_params);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

838

mv_ref = dst;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

840

resolution_change = dst->vp9.width != last->vp9.width ||

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

841

dst->vp9.height != last->vp9.height;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

869

config_output(ctx, dst, dec_params);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

872

config_ref_registers(ctx, dec_params, dst, mv_ref);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

874

config_tiles(ctx, dec_params, dst);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

877

config_picture_dimensions(ctx, dst);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

893

struct vb2_v4l2_buffer *dst;

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

903

dst = hantro_get_dst_buf(ctx);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

905

config_registers(ctx, decode_params, src, dst);

drivers/media/platform/verisilicon/hantro_g2_vp9_dec.c

92

get_ref_buf(struct hantro_ctx *ctx, struct vb2_v4l2_buffer *dst, u64 timestamp)

drivers/media/platform/verisilicon/hantro_h264.c

211

u32 *dst = (u32 *)tbl->scaling_list;

drivers/media/platform/verisilicon/hantro_h264.c

221

*dst++ = swab32(src[j]);

drivers/media/platform/verisilicon/hantro_h264.c

228

*dst++ = swab32(src[j]);

drivers/media/platform/verisilicon/hantro_vp8.c

100

dst[1] = entropy->mv_probs[i][1 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

101

dst[2] = entropy->mv_probs[i][2 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

102

dst[3] = entropy->mv_probs[i][3 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

103

dst[4] = entropy->mv_probs[i][4 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

104

dst[5] = entropy->mv_probs[i][5 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

105

dst[6] = entropy->mv_probs[i][6 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

106

dst[7] = 0; /*unused */

drivers/media/platform/verisilicon/hantro_vp8.c

107

dst += 8;

drivers/media/platform/verisilicon/hantro_vp8.c

111

dst = ctx->vp8_dec.prob_tbl.cpu;

drivers/media/platform/verisilicon/hantro_vp8.c

112

dst += (8 * 7);

drivers/media/platform/verisilicon/hantro_vp8.c

116

dst[0] = entropy->coeff_probs[i][j][k][0];

drivers/media/platform/verisilicon/hantro_vp8.c

117

dst[1] = entropy->coeff_probs[i][j][k][1];

drivers/media/platform/verisilicon/hantro_vp8.c

118

dst[2] = entropy->coeff_probs[i][j][k][2];

drivers/media/platform/verisilicon/hantro_vp8.c

119

dst[3] = entropy->coeff_probs[i][j][k][3];

drivers/media/platform/verisilicon/hantro_vp8.c

120

dst += 4;

drivers/media/platform/verisilicon/hantro_vp8.c

126

dst = ctx->vp8_dec.prob_tbl.cpu;

drivers/media/platform/verisilicon/hantro_vp8.c

127

dst += (8 * 55);

drivers/media/platform/verisilicon/hantro_vp8.c

131

dst[0] = entropy->coeff_probs[i][j][k][4];

drivers/media/platform/verisilicon/hantro_vp8.c

132

dst[1] = entropy->coeff_probs[i][j][k][5];

drivers/media/platform/verisilicon/hantro_vp8.c

133

dst[2] = entropy->coeff_probs[i][j][k][6];

drivers/media/platform/verisilicon/hantro_vp8.c

134

dst[3] = entropy->coeff_probs[i][j][k][7];

drivers/media/platform/verisilicon/hantro_vp8.c

135

dst[4] = entropy->coeff_probs[i][j][k][8];

drivers/media/platform/verisilicon/hantro_vp8.c

136

dst[5] = entropy->coeff_probs[i][j][k][9];

drivers/media/platform/verisilicon/hantro_vp8.c

137

dst[6] = entropy->coeff_probs[i][j][k][10];

drivers/media/platform/verisilicon/hantro_vp8.c

138

dst[7] = 0; /*unused */

drivers/media/platform/verisilicon/hantro_vp8.c

139

dst += 8;

drivers/media/platform/verisilicon/hantro_vp8.c

54

u8 *dst;

drivers/media/platform/verisilicon/hantro_vp8.c

57

dst = ctx->vp8_dec.prob_tbl.cpu;

drivers/media/platform/verisilicon/hantro_vp8.c

59

dst[0] = hdr->prob_skip_false;

drivers/media/platform/verisilicon/hantro_vp8.c

60

dst[1] = hdr->prob_intra;

drivers/media/platform/verisilicon/hantro_vp8.c

61

dst[2] = hdr->prob_last;

drivers/media/platform/verisilicon/hantro_vp8.c

62

dst[3] = hdr->prob_gf;

drivers/media/platform/verisilicon/hantro_vp8.c

63

dst[4] = hdr->segment.segment_probs[0];

drivers/media/platform/verisilicon/hantro_vp8.c

64

dst[5] = hdr->segment.segment_probs[1];

drivers/media/platform/verisilicon/hantro_vp8.c

65

dst[6] = hdr->segment.segment_probs[2];

drivers/media/platform/verisilicon/hantro_vp8.c

66

dst[7] = 0;

drivers/media/platform/verisilicon/hantro_vp8.c

68

dst += 8;

drivers/media/platform/verisilicon/hantro_vp8.c

69

dst[0] = entropy->y_mode_probs[0];

drivers/media/platform/verisilicon/hantro_vp8.c

70

dst[1] = entropy->y_mode_probs[1];

drivers/media/platform/verisilicon/hantro_vp8.c

71

dst[2] = entropy->y_mode_probs[2];

drivers/media/platform/verisilicon/hantro_vp8.c

72

dst[3] = entropy->y_mode_probs[3];

drivers/media/platform/verisilicon/hantro_vp8.c

73

dst[4] = entropy->uv_mode_probs[0];

drivers/media/platform/verisilicon/hantro_vp8.c

74

dst[5] = entropy->uv_mode_probs[1];

drivers/media/platform/verisilicon/hantro_vp8.c

75

dst[6] = entropy->uv_mode_probs[2];

drivers/media/platform/verisilicon/hantro_vp8.c

76

dst[7] = 0; /*unused */

drivers/media/platform/verisilicon/hantro_vp8.c

79

dst += 8;

drivers/media/platform/verisilicon/hantro_vp8.c

80

dst[0] = entropy->mv_probs[0][0]; /* is short */

drivers/media/platform/verisilicon/hantro_vp8.c

81

dst[1] = entropy->mv_probs[1][0];

drivers/media/platform/verisilicon/hantro_vp8.c

82

dst[2] = entropy->mv_probs[0][1]; /* sign */

drivers/media/platform/verisilicon/hantro_vp8.c

83

dst[3] = entropy->mv_probs[1][1];

drivers/media/platform/verisilicon/hantro_vp8.c

84

dst[4] = entropy->mv_probs[0][8 + 9];

drivers/media/platform/verisilicon/hantro_vp8.c

85

dst[5] = entropy->mv_probs[0][9 + 9];

drivers/media/platform/verisilicon/hantro_vp8.c

86

dst[6] = entropy->mv_probs[1][8 + 9];

drivers/media/platform/verisilicon/hantro_vp8.c

87

dst[7] = entropy->mv_probs[1][9 + 9];

drivers/media/platform/verisilicon/hantro_vp8.c

88

dst += 8;

drivers/media/platform/verisilicon/hantro_vp8.c

91

dst[0] = entropy->mv_probs[i][j + 9 + 0];

drivers/media/platform/verisilicon/hantro_vp8.c

92

dst[1] = entropy->mv_probs[i][j + 9 + 1];

drivers/media/platform/verisilicon/hantro_vp8.c

93

dst[2] = entropy->mv_probs[i][j + 9 + 2];

drivers/media/platform/verisilicon/hantro_vp8.c

94

dst[3] = entropy->mv_probs[i][j + 9 + 3];

drivers/media/platform/verisilicon/hantro_vp8.c

95

dst += 4;

drivers/media/platform/verisilicon/hantro_vp8.c

99

dst[0] = entropy->mv_probs[i][0 + 2];

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

2109

struct hantro_decoded_buffer *dst;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

2116

dst = vb2_to_hantro_decoded_buf(&vb2_dst->vb2_buf);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

2117

luma_addr = hantro_get_dec_buf_addr(ctx, &dst->base.vb.vb2_buf);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

2121

dst->av1.chroma_offset = cr_offset;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

2122

dst->av1.mv_offset = mv_offset;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

523

u8 *dst = av1_dec->global_model.cpu;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

527

memset(dst, 0, GLOBAL_MODEL_SIZE);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

533

*(s32 *)dst =

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

536

*(s32 *)dst =

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

539

*(s32 *)dst =

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

541

dst += 4;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

548

*(s16 *)dst = alpha;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

549

dst += 2;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

550

*(s16 *)dst = beta;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

551

dst += 2;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

552

*(s16 *)dst = gamma;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

553

dst += 2;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

554

*(s16 *)dst = delta;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

555

dst += 2;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

587

u8 *dst = av1_dec->tile_info.cpu;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

591

memset(dst, 0, av1_dec->tile_info.size);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

602

*dst++ = x0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

603

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

604

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

605

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

606

*dst++ = y0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

607

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

608

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

609

*dst++ = 0;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

613

*dst++ = start & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

614

*dst++ = (start >> 8) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

615

*dst++ = (start >> 16) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

616

*dst++ = (start >> 24) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

620

*dst++ = end & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

621

*dst++ = (end >> 8) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

622

*dst++ = (end >> 16) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

623

*dst++ = (end >> 24) & 255;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

695

struct hantro_decoded_buffer *dst;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

751

dst = vb2_to_hantro_decoded_buf(&av1_dec->frame_refs[idx].vb2_ref->vb2_buf);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

752

luma_addr = hantro_get_dec_buf_addr(ctx, &dst->base.vb.vb2_buf);

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

753

chroma_addr = luma_addr + dst->av1.chroma_offset;

drivers/media/platform/verisilicon/rockchip_vpu981_hw_av1_dec.c

754

mv_addr = luma_addr + dst->av1.mv_offset;

drivers/media/test-drivers/vicodec/codec-fwht.c

577

static void fill_encoder_block(const u8 *input, s16 *dst,

drivers/media/test-drivers/vicodec/codec-fwht.c

584

*dst++ = *input;

drivers/media/test-drivers/vicodec/codec-fwht.c

643

static void fill_decoder_block(u8 *dst, const s16 *input, int stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

649

for (j = 0; j < 8; j++, input++, dst += dst_step) {

drivers/media/test-drivers/vicodec/codec-fwht.c

651

*dst = 0;

drivers/media/test-drivers/vicodec/codec-fwht.c

653

*dst = 255;

drivers/media/test-drivers/vicodec/codec-fwht.c

655

*dst = *input;

drivers/media/test-drivers/vicodec/codec-fwht.c

657

dst += stride - (8 * dst_step);

drivers/media/test-drivers/vicodec/codec-fwht.c

837

unsigned int ref_step, u8 *dst,

drivers/media/test-drivers/vicodec/codec-fwht.c

856

memcpy(dst, *rlco, width);

drivers/media/test-drivers/vicodec/codec-fwht.c

857

dst += dst_stride;

drivers/media/test-drivers/vicodec/codec-fwht.c

873

u8 *dstp = dst + j * 8 * dst_stride + i * 8 * dst_step;

drivers/media/test-drivers/vicodec/codec-fwht.c

914

struct fwht_raw_frame *dst, unsigned int dst_stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

922

ref->luma_alpha_step, dst->luma, dst_stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

923

dst->luma_alpha_step,

drivers/media/test-drivers/vicodec/codec-fwht.c

938

ref->chroma_step, dst->cb, dst_chroma_stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

939

dst->chroma_step,

drivers/media/test-drivers/vicodec/codec-fwht.c

944

ref->chroma_step, dst->cr, dst_chroma_stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

945

dst->chroma_step,

drivers/media/test-drivers/vicodec/codec-fwht.c

953

ref->luma_alpha_step, dst->alpha, dst_stride,

drivers/media/test-drivers/vicodec/codec-fwht.c

954

dst->luma_alpha_step,

drivers/media/test-drivers/vicodec/codec-fwht.h

116

struct fwht_raw_frame *dst, unsigned int dst_stride,

drivers/media/test-drivers/vim2m.c

270

u8 *src, u8 *dst, bool reverse)

drivers/media/test-drivers/vim2m.c

275

memcpy(dst, src, q_data_out->width * depth);

drivers/media/test-drivers/vim2m.c

278

memcpy(dst, src, depth);

drivers/media/test-drivers/vim2m.c

279

memcpy(dst + depth, src - depth, depth);

drivers/media/test-drivers/vim2m.c

281

dst += depth << 1;

drivers/media/test-drivers/vim2m.c

289

u8 *src[2], u8 **dst, int ypos, bool reverse)

drivers/media/test-drivers/vim2m.c

348

__le16 *dst_pix = (__le16 *)*dst;

drivers/media/test-drivers/vim2m.c

355

*dst += 2;

drivers/media/test-drivers/vim2m.c

361

__be16 *dst_pix = (__be16 *)*dst;

drivers/media/test-drivers/vim2m.c

368

*dst += 2;

drivers/media/test-drivers/vim2m.c

373

*(*dst)++ = *r++;

drivers/media/test-drivers/vim2m.c

374

*(*dst)++ = *g++;

drivers/media/test-drivers/vim2m.c

375

*(*dst)++ = *b++;

drivers/media/test-drivers/vim2m.c

380

*(*dst)++ = *b++;

drivers/media/test-drivers/vim2m.c

381

*(*dst)++ = *g++;

drivers/media/test-drivers/vim2m.c

382

*(*dst)++ = *r++;

drivers/media/test-drivers/vim2m.c

399

*(*dst)++ = y;

drivers/media/test-drivers/vim2m.c

400

*(*dst)++ = u;

drivers/media/test-drivers/vim2m.c

402

*(*dst)++ = y1;

drivers/media/test-drivers/vim2m.c

403

*(*dst)++ = v;

drivers/media/test-drivers/vim2m.c

408

*(*dst)++ = *b;

drivers/media/test-drivers/vim2m.c

409

*(*dst)++ = *++g;

drivers/media/test-drivers/vim2m.c

411

*(*dst)++ = *g;

drivers/media/test-drivers/vim2m.c

412

*(*dst)++ = *++r;

drivers/media/test-drivers/vim2m.c

417

*(*dst)++ = *g;

drivers/media/test-drivers/vim2m.c

418

*(*dst)++ = *++b;

drivers/media/test-drivers/vim2m.c

420

*(*dst)++ = *r;

drivers/media/test-drivers/vim2m.c

421

*(*dst)++ = *++g;

drivers/media/test-drivers/vim2m.c

426

*(*dst)++ = *g;

drivers/media/test-drivers/vim2m.c

427

*(*dst)++ = *++r;

drivers/media/test-drivers/vim2m.c

429

*(*dst)++ = *b;

drivers/media/test-drivers/vim2m.c

430

*(*dst)++ = *++g;

drivers/media/test-drivers/vim2m.c

435

*(*dst)++ = *r;

drivers/media/test-drivers/vim2m.c

436

*(*dst)++ = *++g;

drivers/media/test-drivers/vim2m.c

438

*(*dst)++ = *g;

drivers/media/test-drivers/vim2m.c

439

*(*dst)++ = *++b;

drivers/media/test-drivers/visl/visl-dec.c

291

run->dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

292

run->dst->vb2_buf.timestamp,

drivers/media/test-drivers/visl/visl-dec.c

293

(run->dst->field == V4L2_FIELD_ALTERNATE) ?

drivers/media/test-drivers/visl/visl-dec.c

294

(run->dst->field == V4L2_FIELD_TOP ?

drivers/media/test-drivers/visl/visl-dec.c

345

&run->dst->vb2_buf, p,

drivers/media/test-drivers/visl/visl-dec.c

355

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

356

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

361

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

362

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

370

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", line_str);

drivers/media/test-drivers/visl/visl-dec.c

373

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

388

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

399

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

404

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

407

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

431

frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);

drivers/media/test-drivers/visl/visl-dec.c

436

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

450

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

461

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

466

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

469

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

490

frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);

drivers/media/test-drivers/visl/visl-dec.c

570

run.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/test-drivers/visl/visl-dec.c

578

v4l2_m2m_buf_copy_metadata(run.src, run.dst);

drivers/media/test-drivers/visl/visl-dec.c

579

run.dst->sequence = ctx->q_data[V4L2_M2M_DST].sequence++;

drivers/media/test-drivers/visl/visl-dec.c

581

run.dst->field = ctx->decoded_fmt.fmt.pix.field;

drivers/media/test-drivers/visl/visl-dec.c

630

frame_dprintk(ctx->dev, run.dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

634

frame_dprintk(ctx->dev, run.dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

636

run.dst->sequence, run.dst->vb2_buf.timestamp);

drivers/media/test-drivers/visl/visl-dec.c

642

run.dst->sequence >= bitstream_trace_frame_start &&

drivers/media/test-drivers/visl/visl-dec.c

643

run.dst->sequence < bitstream_trace_frame_start + bitstream_trace_nframes)

drivers/media/test-drivers/visl/visl-dec.h

60

struct vb2_v4l2_buffer *dst;

drivers/media/test-drivers/vivid/vivid-kthread-cap.c

109

for (x = 0; x < dstw; x++, dst += twopixsize) {

drivers/media/test-drivers/vivid/vivid-kthread-cap.c

110

memcpy(dst, src + src_x * twopixsize, twopixsize);

drivers/media/test-drivers/vivid/vivid-kthread-cap.c

92

static void scale_line(const u8 *src, u8 *dst, unsigned srcw, unsigned dstw, unsigned twopixsize)

drivers/media/usb/airspy/airspy.c

232

void *dst, void *src, unsigned int src_len)

drivers/media/usb/airspy/airspy.c

237

memcpy(dst, src, src_len);

drivers/media/usb/as102/as102_fw.c

21

static unsigned char atohx(unsigned char *dst, char *src)

drivers/media/usb/as102/as102_fw.c

33

*dst = value = ((msb & 0xF) << 4) | (lsb & 0xF);

drivers/media/usb/as102/as102_fw.c

45

unsigned char *src, dst;

drivers/media/usb/as102/as102_fw.c

54

atohx(&dst, src);

drivers/media/usb/as102/as102_fw.c

58

*dataLength = dst;

drivers/media/usb/as102/as102_fw.c

61

addr[2] = dst;

drivers/media/usb/as102/as102_fw.c

64

addr[3] = dst;

drivers/media/usb/as102/as102_fw.c

68

if (dst == 0x04)

drivers/media/usb/as102/as102_fw.c

76

addr[(count - 4)] = dst;

drivers/media/usb/as102/as102_fw.c

78

data[(count - 4)] = dst;

drivers/media/usb/as102/as102_fw.c

81

data[(count - 4)] = dst;

drivers/media/usb/dvb-usb/vp702x-fe.c

139

struct vp702x_device_state *dst = st->d->priv;

drivers/media/usb/dvb-usb/vp702x-fe.c

146

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

148

cmd = dst->buf;

drivers/media/usb/dvb-usb/vp702x-fe.c

192

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

216

struct vp702x_device_state *dst = st->d->priv;

drivers/media/usb/dvb-usb/vp702x-fe.c

223

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

225

cmd = dst->buf;

drivers/media/usb/dvb-usb/vp702x-fe.c

238

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

254

struct vp702x_device_state *dst = st->d->priv;

drivers/media/usb/dvb-usb/vp702x-fe.c

268

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

270

buf = dst->buf;

drivers/media/usb/dvb-usb/vp702x-fe.c

279

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

288

struct vp702x_device_state *dst = st->d->priv;

drivers/media/usb/dvb-usb/vp702x-fe.c

301

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

303

buf = dst->buf;

drivers/media/usb/dvb-usb/vp702x-fe.c

312

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

40

struct vp702x_device_state *dst = st->d->priv;

drivers/media/usb/dvb-usb/vp702x-fe.c

44

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x-fe.c

45

buf = dst->buf;

drivers/media/usb/dvb-usb/vp702x-fe.c

56

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x.c

190

struct vp702x_device_state *dst = adap->dev->priv;

drivers/media/usb/dvb-usb/vp702x.c

204

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x.c

206

buf = dst->buf;

drivers/media/usb/dvb-usb/vp702x.c

211

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x.c

220

struct vp702x_device_state *dst = adap->dev->priv;

drivers/media/usb/dvb-usb/vp702x.c

233

mutex_lock(&dst->buf_mutex);

drivers/media/usb/dvb-usb/vp702x.c

234

b = dst->buf;

drivers/media/usb/dvb-usb/vp702x.c

239

mutex_unlock(&dst->buf_mutex);

drivers/media/usb/hackrf/hackrf.c

454

static void hackrf_copy_stream(struct hackrf_dev *dev, void *dst, void *src,

drivers/media/usb/hackrf/hackrf.c

457

memcpy(dst, src, src_len);

drivers/media/usb/msi2500/msi2500.c

242

static int msi2500_convert_stream(struct msi2500_dev *dev, u8 *dst, u8 *src,

drivers/media/usb/msi2500/msi2500.c

274

u8 *u8dst = (u8 *)dst;

drivers/media/usb/msi2500/msi2500.c

280

dst += 1008;

drivers/media/usb/msi2500/msi2500.c

288

u16 *u16dst = (u16 *)dst;

drivers/media/usb/msi2500/msi2500.c

302

dst += 1008;

drivers/media/usb/msi2500/msi2500.c

310

memcpy(dst, src, 984);

drivers/media/usb/msi2500/msi2500.c

312

dst += 984;

drivers/media/usb/msi2500/msi2500.c

317

memcpy(dst, src, 1008);

drivers/media/usb/msi2500/msi2500.c

319

dst += 1008;

drivers/media/usb/msi2500/msi2500.c

324

memcpy(dst, src, 1008);

drivers/media/usb/msi2500/msi2500.c

326

dst += 1008;

drivers/media/usb/msi2500/msi2500.c

331

memcpy(dst, src, 1008);

drivers/media/usb/msi2500/msi2500.c

333

dst += 1008;

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

1929

unsigned short *dst, const unsigned char *src,

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

1935

dst[cnt] = src[cnt];

drivers/media/usb/pvrusb2/pvrusb2-hdw.c

1938

dst[cnt] = I2C_CLIENT_END;

drivers/media/usb/pwc/pwc-dec23.c

349

static void copy_image_block_Y(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)

drivers/media/usb/pwc/pwc-dec23.c

354

unsigned char *d = dst;

drivers/media/usb/pwc/pwc-dec23.c

361

d = dst + bytes_per_line;

drivers/media/usb/pwc/pwc-dec23.c

367

d = dst + bytes_per_line*2;

drivers/media/usb/pwc/pwc-dec23.c

373

d = dst + bytes_per_line*3;

drivers/media/usb/pwc/pwc-dec23.c

381

unsigned char *d = dst;

drivers/media/usb/pwc/pwc-dec23.c

385

d = dst + bytes_per_line;

drivers/media/usb/pwc/pwc-dec23.c

389

d = dst + bytes_per_line*2;

drivers/media/usb/pwc/pwc-dec23.c

393

d = dst + bytes_per_line*3;

drivers/media/usb/pwc/pwc-dec23.c

403

static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)

drivers/media/usb/pwc/pwc-dec23.c

409

unsigned char *d = dst;

drivers/media/usb/pwc/pwc-dec23.c

420

d = dst + bytes_per_line;

drivers/media/usb/pwc/pwc-dec23.c

433

unsigned char *d = dst;

drivers/media/usb/pwc/pwc-dec23.c

440

d = dst + bytes_per_line;

drivers/media/usb/pwc/pwc-dec23.c

647

void *dst)

drivers/media/usb/pwc/pwc-dec23.c

664

pout_planar_y = dst;

drivers/media/usb/pwc/pwc-dec23.c

665

pout_planar_u = dst + plane_size;

drivers/media/usb/pwc/pwc-dec23.c

666

pout_planar_v = dst + plane_size + plane_size / 4;

drivers/media/usb/pwc/pwc-dec23.h

48

void *dst);

drivers/media/usb/stk1160/stk1160-video.c

105

u8 *dst = buf->mem;

drivers/media/usb/stk1160/stk1160-video.c

127

dst += bytesperline;

drivers/media/usb/stk1160/stk1160-video.c

130

dst += linesdone * bytesperline * 2 + lineoff;

drivers/media/usb/stk1160/stk1160-video.c

139

offset = dst - (u8 *)buf->mem;

drivers/media/usb/stk1160/stk1160-video.c

159

if ((unsigned long)dst + lencopy >

drivers/media/usb/stk1160/stk1160-video.c

165

memcpy(dst, src, lencopy);

drivers/media/usb/stk1160/stk1160-video.c

174

dst += lencopy + bytesperline;

drivers/media/usb/stk1160/stk1160-video.c

184

offset = dst - (u8 *)buf->mem;

drivers/media/usb/stk1160/stk1160-video.c

203

if ((unsigned long)dst + lencopy >

drivers/media/usb/stk1160/stk1160-video.c

209

memcpy(dst, src, lencopy);

drivers/media/usb/usbtv/usbtv-video.c

388

u32 *dst = &frame[part_index * USBTV_CHUNK/2];

drivers/media/usb/usbtv/usbtv-video.c

390

memcpy(dst, src, USBTV_CHUNK/2 * sizeof(*src));

drivers/media/usb/uvc/uvc_video.c

1301

memcpy(op->dst, op->src, op->len);

drivers/media/usb/uvc/uvc_video.c

1330

op->dst = buf->mem + buf->bytesused;

drivers/media/usb/uvc/uvcvideo.h

424

void *dst;

drivers/media/v4l2-core/v4l2-mem2mem.c

297

struct vb2_v4l2_buffer *dst, *src;

drivers/media/v4l2-core/v4l2-mem2mem.c

324

dst = v4l2_m2m_next_dst_buf(m2m_ctx);

drivers/media/v4l2-core/v4l2-mem2mem.c

329

if (!dst && !m2m_ctx->cap_q_ctx.buffered) {

drivers/media/v4l2-core/v4l2-mem2mem.c

336

if (src && dst && dst->is_held &&

drivers/media/v4l2-core/v4l2-mem2mem.c

337

dst->vb2_buf.copied_timestamp &&

drivers/media/v4l2-core/v4l2-mem2mem.c

338

dst->vb2_buf.timestamp != src->vb2_buf.timestamp) {

drivers/media/v4l2-core/v4l2-mem2mem.c

340

dst->is_held = false;

drivers/media/v4l2-core/v4l2-mem2mem.c

342

v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);

drivers/media/v4l2-core/v4l2-mem2mem.c

343

dst = v4l2_m2m_next_dst_buf(m2m_ctx);

drivers/media/v4l2-core/v4l2-mem2mem.c

345

if (!dst && !m2m_ctx->cap_q_ctx.buffered) {

drivers/media/v4l2-core/v4l2-mem2mem.c

351

if (src && dst && (m2m_ctx->out_q_ctx.q.subsystem_flags &

drivers/media/v4l2-core/v4l2-mem2mem.c

353

m2m_ctx->new_frame = !dst->vb2_buf.copied_timestamp ||

drivers/media/v4l2-core/v4l2-mem2mem.c

354

dst->vb2_buf.timestamp != src->vb2_buf.timestamp;

drivers/media/v4l2-core/v4l2-subdev.c

1957

struct v4l2_subdev_krouting *dst = &state->routing;

drivers/media/v4l2-core/v4l2-subdev.c

1984

kfree(dst->routes);

drivers/media/v4l2-core/v4l2-subdev.c

1985

*dst = new_routing;

drivers/memory/tegra/mc.c

781

static int tegra_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra124-emc.c

1311

static int emc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra124-emc.c

1313

struct tegra_emc *emc = to_tegra_emc_provider(dst->provider);

drivers/memory/tegra/tegra124-emc.c

1314

unsigned long long peak_bw = icc_units_to_bps(dst->peak_bw);

drivers/memory/tegra/tegra124-emc.c

1315

unsigned long long avg_bw = icc_units_to_bps(dst->avg_bw);

drivers/memory/tegra/tegra124.c

1148

static int tegra124_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra186-emc.c

228

static int tegra186_emc_icc_set_bw(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra20-emc.c

978

static int emc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra20-emc.c

980

struct tegra_emc *emc = to_tegra_emc_provider(dst->provider);

drivers/memory/tegra/tegra20-emc.c

981

unsigned long long peak_bw = icc_units_to_bps(dst->peak_bw);

drivers/memory/tegra/tegra20-emc.c

982

unsigned long long avg_bw = icc_units_to_bps(dst->avg_bw);

drivers/memory/tegra/tegra20.c

364

static int tegra20_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra234.c

1035

static int tegra234_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra234.c

1037

struct tegra_mc *mc = icc_provider_to_tegra_mc(dst->provider);

drivers/memory/tegra/tegra234.c

1050

if (src->id == dst->id)

drivers/memory/tegra/tegra264.c

204

static int tegra264_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra264.c

206

struct tegra_mc *mc = icc_provider_to_tegra_mc(dst->provider);

drivers/memory/tegra/tegra264.c

219

if (src->id == dst->id)

drivers/memory/tegra/tegra30-emc.c

1496

static int emc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra30-emc.c

1498

struct tegra_emc *emc = to_tegra_emc_provider(dst->provider);

drivers/memory/tegra/tegra30-emc.c

1499

unsigned long long peak_bw = icc_units_to_bps(dst->peak_bw);

drivers/memory/tegra/tegra30-emc.c

1500

unsigned long long avg_bw = icc_units_to_bps(dst->avg_bw);

drivers/memory/tegra/tegra30.c

1291

static int tegra30_mc_icc_set(struct icc_node *src, struct icc_node *dst)

drivers/memory/tegra/tegra30.c

1305

if (src == dst)

drivers/memory/ti-emif-pm.c

201

int ti_emif_copy_pm_function_table(struct gen_pool *sram_pool, void *dst)

drivers/memory/ti-emif-pm.c

208

copy_addr = sram_exec_copy(sram_pool, dst,

drivers/mfd/max14577.c

63

unsigned int min_ua, unsigned int max_ua, u8 *dst)

drivers/mfd/max14577.c

78

*dst = 0x0;

drivers/mfd/max14577.c

93

*dst = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;

drivers/mfd/max14577.c

95

*dst |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;

drivers/misc/bcm-vk/bcm_vk_dev.c

379

u8 *dst;

drivers/misc/bcm-vk/bcm_vk_dev.c

387

dst = (u8 *)info;

drivers/misc/bcm-vk/bcm_vk_dev.c

389

*dst++ = vkread8(vk, BAR_2, offset++);

drivers/misc/bcm-vk/bcm_vk_dev.c

442

u8 *dst;

drivers/misc/bcm-vk/bcm_vk_dev.c

467

dst = (u8 *)&mon->entries[0];

drivers/misc/bcm-vk/bcm_vk_dev.c

469

memcpy_fromio(dst, vk->bar[BAR_2] + offset, num * entry_size);

drivers/misc/bcm-vk/bcm_vk_msg.c

599

struct vk_msg_blk __iomem *dst;

drivers/misc/bcm-vk/bcm_vk_msg.c

652

dst = msgq_blk_addr(qinfo, wr_idx);

drivers/misc/bcm-vk/bcm_vk_msg.c

654

memcpy_toio(dst, src, sizeof(*dst));

drivers/misc/bcm-vk/bcm_vk_msg.c

658

dst = msgq_blk_addr(qinfo, wr_idx);

drivers/misc/bcm-vk/bcm_vk_msg.c

781

struct vk_msg_blk *dst;

drivers/misc/bcm-vk/bcm_vk_msg.c

840

dst = data;

drivers/misc/bcm-vk/bcm_vk_msg.c

842

memcpy_fromio(dst, src, sizeof(*dst));

drivers/misc/bcm-vk/bcm_vk_msg.c

844

dst++;

drivers/misc/fastrpc.c

1081

void *dst = (void *)(uintptr_t)rpra[i].buf.pv;

drivers/misc/fastrpc.c

1085

if (copy_from_user(dst, (void __user *)src,

drivers/misc/fastrpc.c

1091

memcpy(dst, src, len);

drivers/misc/fastrpc.c

1137

void *dst = (void *)(uintptr_t)ctx->args[i].ptr;

drivers/misc/fastrpc.c

1141

if (copy_to_user((void __user *)dst, src, len)) {

drivers/misc/fastrpc.c

1146

memcpy(dst, src, len);

drivers/misc/lkdtm/fortify.c

147

char dst[5];

drivers/misc/lkdtm/fortify.c

163

if (strscpy(dst, src, 0) != -E2BIG)

drivers/misc/lkdtm/fortify.c

167

if (strscpy(dst, src, sizeof(dst)) != -E2BIG)

drivers/misc/lkdtm/fortify.c

171

if (strncmp(dst, "foob", sizeof(dst)) != 0)

drivers/misc/lkdtm/fortify.c

173

dst);

drivers/misc/lkdtm/fortify.c

182

if (strscpy(dst, src, sizeof(dst)) != 3)

drivers/misc/lkdtm/fortify.c

186

if (strncmp(dst, "foo", sizeof(dst)) != 0)

drivers/misc/lkdtm/fortify.c

188

dst);

drivers/misc/lkdtm/fortify.c

204

strscpy(dst, src, strlen(src));

drivers/misc/lkdtm/perms.c

107

copied = access_process_vm(current, (unsigned long)dst, do_nothing_text,

drivers/misc/lkdtm/perms.c

111

pr_info("attempting bad execution at %px\n", dst);

drivers/misc/lkdtm/perms.c

112

func = setup_function_descriptor(&fdesc, dst);

drivers/misc/lkdtm/perms.c

60

static void *setup_function_descriptor(func_desc_t *fdesc, void *dst)

drivers/misc/lkdtm/perms.c

63

return dst;

drivers/misc/lkdtm/perms.c

66

fdesc->addr = (unsigned long)dst;

drivers/misc/lkdtm/perms.c

72

static noinline __nocfi void execute_location(void *dst, bool write)

drivers/misc/lkdtm/perms.c

81

memcpy(dst, do_nothing_ptr, EXEC_SIZE);

drivers/misc/lkdtm/perms.c

82

flush_icache_range((unsigned long)dst,

drivers/misc/lkdtm/perms.c

83

(unsigned long)dst + EXEC_SIZE);

drivers/misc/lkdtm/perms.c

85

pr_info("attempting bad execution at %px\n", dst);

drivers/misc/lkdtm/perms.c

86

func = setup_function_descriptor(&fdesc, dst);

drivers/misc/lkdtm/perms.c

95

static void execute_user_location(void *dst)

drivers/misc/mei/vsc-tp.c

174

u8 *dst = (u8 *)&ack;

drivers/misc/mei/vsc-tp.c

197

memcpy(dst, src, cpy_len);

drivers/misc/mei/vsc-tp.c

201

dst += cpy_len;

drivers/misc/mei/vsc-tp.c

212

dst = ibuf;

drivers/misc/mei/vsc-tp.c

215

dst = (u8 *)&recv_crc;

drivers/misc/mei/vsc-tp.c

231

dst = (u8 *)&recv_crc;

drivers/misc/sgi-xp/xpnet.c

153

void *dst;

drivers/misc/sgi-xp/xpnet.c

209

dst = (void *)((u64)skb->data & ~(L1_CACHE_BYTES - 1));

drivers/misc/sgi-xp/xpnet.c

211

"xp_remote_memcpy(0x%p, 0x%p, %u)\n", dst,

drivers/misc/sgi-xp/xpnet.c

214

ret = xp_remote_memcpy(xp_pa(dst), msg->buf_pa, msg->size);

drivers/misc/sgi-xp/xpnet.c

222

"returned error=0x%x\n", dst,

drivers/misc/sram-exec.c

107

dst_cpy = fncpy(dst, src, size);

drivers/misc/sram-exec.c

73

void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src,

drivers/misc/sram-exec.c

92

if (!gen_pool_has_addr(pool, (unsigned long)dst, size))

drivers/misc/vmw_vmci/vmci_context.c

250

ev.msg.hdr.dst = vmci_handle_arr_get_entry(subscriber_array, i);

drivers/misc/vmw_vmci/vmci_context.c

264

ev.msg.hdr.dst.context);

drivers/misc/vmw_vmci/vmci_datagram.c

166

if (dg->dst.context == VMCI_HYPERVISOR_CONTEXT_ID)

drivers/misc/vmw_vmci/vmci_datagram.c

186

if (dg->dst.context == VMCI_HOST_CONTEXT_ID) {

drivers/misc/vmw_vmci/vmci_datagram.c

192

dg->dst.resource == VMCI_EVENT_HANDLER) {

drivers/misc/vmw_vmci/vmci_datagram.c

196

resource = vmci_resource_by_handle(dg->dst,

drivers/misc/vmw_vmci/vmci_datagram.c

200

dg->dst.context, dg->dst.resource);

drivers/misc/vmw_vmci/vmci_datagram.c

254

if (context_id != dg->dst.context) {

drivers/misc/vmw_vmci/vmci_datagram.c

257

(dg->dst.context))) {

drivers/misc/vmw_vmci/vmci_datagram.c

266

context_id, dg->dst.context);

drivers/misc/vmw_vmci/vmci_datagram.c

276

retval = vmci_ctx_enqueue_datagram(dg->dst.context, new_dg);

drivers/misc/vmw_vmci/vmci_datagram.c

330

retval = vmci_route(&dg->src, &dg->dst, from_guest, &route);

drivers/misc/vmw_vmci/vmci_datagram.c

333

dg->src.context, dg->dst.context, retval);

drivers/misc/vmw_vmci/vmci_datagram.c

360

resource = vmci_resource_by_handle(dg->dst,

drivers/misc/vmw_vmci/vmci_datagram.c

364

dg->dst.context, dg->dst.resource);

drivers/misc/vmw_vmci/vmci_doorbell.c

233

link_msg.hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_doorbell.c

251

unlink_msg.hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_doorbell.c

314

bitmap_set_msg.hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_guest.c

272

check_msg->dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_guest.c

338

while (dg->dst.resource != VMCI_INVALID_ID ||

drivers/misc/vmw_vmci/vmci_guest.c

346

if (dg->dst.resource == VMCI_INVALID_ID) {

drivers/misc/vmw_vmci/vmci_guest.c

406

dg->dst.resource == VMCI_EVENT_HANDLER) {

drivers/misc/vmw_vmci/vmci_guest.c

414

dg->dst.resource, result);

drivers/misc/vmw_vmci/vmci_guest.c

92

get_cid_msg.dst =

drivers/misc/vmw_vmci/vmci_host.c

403

dg->dst.context, dg->dst.resource,

drivers/misc/vmw_vmci/vmci_queue_pair.c

1472

ev.msg.hdr.dst = vmci_make_handle(peer_id, VMCI_EVENT_HANDLER);

drivers/misc/vmw_vmci/vmci_queue_pair.c

2690

struct vmci_handle dst = vmci_make_handle(peer, VMCI_INVALID_ID);

drivers/misc/vmw_vmci/vmci_queue_pair.c

2715

retval = vmci_route(&src, &dst, false, &route);

drivers/misc/vmw_vmci/vmci_queue_pair.c

858

ev.msg.hdr.dst = vmci_make_handle(context_id, VMCI_EVENT_HANDLER);

drivers/misc/vmw_vmci/vmci_queue_pair.c

962

alloc_msg->hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_queue_pair.c

991

detach_msg.hdr.dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID,

drivers/misc/vmw_vmci/vmci_route.c

153

if (vmci_ctx_exists(dst->context)) {

drivers/misc/vmw_vmci/vmci_route.c

167

src->context != dst->context) {

drivers/misc/vmw_vmci/vmci_route.c

21

const struct vmci_handle *dst,

drivers/misc/vmw_vmci/vmci_route.c

42

if (VMCI_INVALID_ID == dst->context)

drivers/misc/vmw_vmci/vmci_route.c

46

if (VMCI_HYPERVISOR_CONTEXT_ID == dst->context) {

drivers/misc/vmw_vmci/vmci_route.c

85

if (VMCI_HOST_CONTEXT_ID == dst->context) {

drivers/misc/vmw_vmci/vmci_route.h

19

int vmci_route(struct vmci_handle *src, const struct vmci_handle *dst,

drivers/mmc/core/sdio_io.c

468

int sdio_memcpy_fromio(struct sdio_func *func, void *dst,

drivers/mmc/core/sdio_io.c

471

return sdio_io_rw_ext_helper(func, 0, addr, 1, dst, count);

drivers/mmc/core/sdio_io.c

502

int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr,

drivers/mmc/core/sdio_io.c

505

return sdio_io_rw_ext_helper(func, 0, addr, 0, dst, count);

drivers/mmc/host/tifm_sd.c

210

static void tifm_sd_copy_page(struct page *dst, unsigned int dst_off,

drivers/mmc/host/tifm_sd.c

215

unsigned char *dst_buf = kmap_local_page(dst) + dst_off;

drivers/mtd/devices/docg3.c

1321

static void doc_fill_autooob(u8 *dst, u8 *oobsrc)

drivers/mtd/devices/docg3.c

1323

memcpy(dst, oobsrc, DOC_LAYOUT_OOB_PAGEINFO_SZ);

drivers/mtd/devices/docg3.c

1324

dst[DOC_LAYOUT_OOB_UNUSED_OFS] = oobsrc[DOC_LAYOUT_OOB_PAGEINFO_SZ];

drivers/mtd/devices/st_spi_fsm.c

715

void __iomem *dst = fsm->base + SPI_FAST_SEQ_TRANSFER_SIZE;

drivers/mtd/devices/st_spi_fsm.c

722

writel(*src, dst);

drivers/mtd/devices/st_spi_fsm.c

724

dst += 4;

drivers/mtd/nand/ecc-mxic.c

496

u8 *dst, const u8 *src)

drivers/mtd/nand/ecc-mxic.c

502

memcpy(dst + (step * ctx->oob_step_sz),

drivers/mtd/nand/ecc-mxic.c

508

u8 *dst, const u8 *src)

drivers/mtd/nand/ecc-mxic.c

514

memcpy(dst + (step * (ctx->oob_step_sz + STAT_BYTES)),

drivers/mtd/nand/onenand/onenand_omap2.c

325

dma_addr_t src, dma_addr_t dst,

drivers/mtd/nand/onenand/onenand_omap2.c

331

tx = dmaengine_prep_dma_memcpy(c->dma_chan, dst, src, count,

drivers/mtd/nand/onenand/onenand_samsung.c

516

static int (*s5pc110_dma_ops)(dma_addr_t dst, dma_addr_t src, size_t count, int direction);

drivers/mtd/nand/onenand/onenand_samsung.c

518

static int s5pc110_dma_poll(dma_addr_t dst, dma_addr_t src, size_t count, int direction)

drivers/mtd/nand/onenand/onenand_samsung.c

525

writel(dst, base + S5PC110_DMA_DST_ADDR);

drivers/mtd/nand/onenand/onenand_samsung.c

584

static int s5pc110_dma_irq(dma_addr_t dst, dma_addr_t src, size_t count, int direction)

drivers/mtd/nand/onenand/onenand_samsung.c

596

writel(dst, base + S5PC110_DMA_DST_ADDR);

drivers/mtd/nand/raw/nand_base.c

128

void nand_extract_bits(u8 *dst, unsigned int dst_off, const u8 *src,

drivers/mtd/nand/raw/nand_base.c

133

dst += dst_off / 8;

drivers/mtd/nand/raw/nand_base.c

142

*dst &= ~GENMASK(n - 1 + dst_off, dst_off);

drivers/mtd/nand/raw/nand_base.c

143

*dst |= tmp << dst_off;

drivers/mtd/nand/raw/nand_base.c

147

dst++;

drivers/mtd/nand/raw/nand_base.c

2222

u8 *dst = buf;

drivers/mtd/nand/raw/nand_base.c

2225

dst[i] = ddrbuf[i * 2];

drivers/mtd/nand/raw/vf610_nfc.c

229

static inline void vf610_nfc_rd_from_sram(void *dst, const void __iomem *src,

drivers/mtd/nand/raw/vf610_nfc.c

238

memcpy(dst + i, &val, min(sizeof(val), len - i));

drivers/mtd/nand/raw/vf610_nfc.c

241

memcpy_fromio(dst, src, len);

drivers/mtd/nand/raw/vf610_nfc.c

264

static inline void vf610_nfc_wr_to_sram(void __iomem *dst, const void *src,

drivers/mtd/nand/raw/vf610_nfc.c

274

__raw_writel(swab32(val), dst + i);

drivers/mtd/nand/raw/vf610_nfc.c

277

memcpy_toio(dst, src, len);

drivers/mtd/nftlcore.c

231

static noinline_for_stack void NFTL_move_block(struct mtd_info *mtd, loff_t src, loff_t dst)

drivers/mtd/nftlcore.c

247

nftl_write(mtd, dst, 512, &retlen, movebuf, (char *)&oob);

drivers/mtd/ubi/eba.c

169

void ubi_eba_copy_table(struct ubi_volume *vol, struct ubi_eba_table *dst,

drivers/mtd/ubi/eba.c

175

ubi_assert(dst && vol && vol->eba_tbl);

drivers/mtd/ubi/eba.c

180

dst->entries[i].pnum = src->entries[i].pnum;

drivers/mtd/ubi/ubi.h

877

void ubi_eba_copy_table(struct ubi_volume *vol, struct ubi_eba_table *dst,

drivers/net/amt.c

1046

ip4_dst_hoplimit(&rt->dst),

drivers/net/amt.c

1104

ip4_dst_hoplimit(&rt->dst),

drivers/net/amt.c

1163

ip4_dst_hoplimit(&rt->dst),

drivers/net/amt.c

2595

skb_dst_set(skb, &rt->dst);

drivers/net/amt.c

2625

iph->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/amt.c

655

skb_dst_set(skb, &rt->dst);

drivers/net/amt.c

684

iph->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/amt.c

744

skb_dst_set(skb, &rt->dst);

drivers/net/amt.c

775

iph->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/bareudp.c

150

skb_dst_set(skb, &tun_dst->dst);

drivers/net/bareudp.c

337

skb_tunnel_check_pmtu(skb, &rt->dst,

drivers/net/bareudp.c

350

min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len +

drivers/net/bareudp.c

362

udp_tunnel_xmit_skb(rt, sock->sk, skb, saddr, info->key.u.ipv4.dst,

drivers/net/bareudp.c

370

dst_release(&rt->dst);

drivers/net/bareudp.c

383

struct dst_entry *dst = NULL;

drivers/net/bareudp.c

399

dst = udp_tunnel6_dst_lookup(skb, dev, bareudp->net, sock, 0, &saddr,

drivers/net/bareudp.c

403

if (IS_ERR(dst))

drivers/net/bareudp.c

404

return PTR_ERR(dst);

drivers/net/bareudp.c

406

skb_tunnel_check_pmtu(skb, dst, BAREUDP_IPV6_HLEN + info->options_len,

drivers/net/bareudp.c

418

min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +

drivers/net/bareudp.c

429

daddr = info->key.u.ipv6.dst;

drivers/net/bareudp.c

430

udp_tunnel6_xmit_skb(dst, sock->sk, skb, dev,

drivers/net/bareudp.c

439

dst_release(dst);

drivers/net/bareudp.c

528

struct dst_entry *dst;

drivers/net/bareudp.c

532

dst = udp_tunnel6_dst_lookup(skb, dev, bareudp->net, sock,

drivers/net/bareudp.c

536

if (IS_ERR(dst))

drivers/net/bareudp.c

537

return PTR_ERR(dst);

drivers/net/bareudp.c

539

dst_release(dst);

drivers/net/bonding/bond_main.c

3096

if (rt->dst.dev == bond->dev)

drivers/net/bonding/bond_main.c

3100

tags = bond_verify_device_path(bond->dev, rt->dst.dev, 0);

drivers/net/bonding/bond_main.c

3108

&targets[i], rt->dst.dev ? rt->dst.dev->name : "NULL");

drivers/net/bonding/bond_main.c

3114

addr = bond_confirm_addr(rt->dst.dev, targets[i], 0);

drivers/net/bonding/bond_main.c

3250

struct dst_entry *dst;

drivers/net/bonding/bond_main.c

3264

dst = ip6_route_output(dev_net(bond->dev), NULL, &fl6);

drivers/net/bonding/bond_main.c

3265

if (dst->error) {

drivers/net/bonding/bond_main.c

3266

dst_release(dst);

drivers/net/bonding/bond_main.c

3279

if (dst->dev == bond->dev)

drivers/net/bonding/bond_main.c

3283

tags = bond_verify_device_path(bond->dev, dst->dev, 0);

drivers/net/bonding/bond_main.c

3291

&targets[i], dst->dev ? dst->dev->name : "NULL");

drivers/net/bonding/bond_main.c

3293

dst_release(dst);

drivers/net/bonding/bond_main.c

3297

if (!ipv6_dev_get_saddr(dev_net(dst->dev), dst->dev, &targets[i], 0, &saddr))

drivers/net/bonding/bond_main.c

3302

dst_release(dst);

drivers/net/bonding/bond_main.c

5456

flow->addrs.v6addrs.dst = sk->sk_v6_daddr;

drivers/net/bonding/bond_main.c

5464

flow->addrs.v4addrs.dst = inet_sk(sk)->inet_daddr;

drivers/net/bonding/bond_main.c

5469

flow->ports.dst = inet_sk(sk)->inet_dport;

drivers/net/can/janz-ican3.c

395

void __iomem *dst;

drivers/net/can/janz-ican3.c

406

dst = mod->dpm;

drivers/net/can/janz-ican3.c

417

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/janz-ican3.c

418

dst += sizeof(desc);

drivers/net/can/janz-ican3.c

424

dst = mod->dpm;

drivers/net/can/janz-ican3.c

438

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/janz-ican3.c

439

dst += sizeof(desc);

drivers/net/can/janz-ican3.c

445

dst = mod->dpm;

drivers/net/can/janz-ican3.c

450

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/janz-ican3.c

455

dst = mod->dpm;

drivers/net/can/janz-ican3.c

460

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/janz-ican3.c

475

void __iomem *dst;

drivers/net/can/janz-ican3.c

501

dst = mod->dpm + addr;

drivers/net/can/janz-ican3.c

502

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/janz-ican3.c

537

dst = mod->dpm + addr;

drivers/net/can/janz-ican3.c

538

memcpy_toio(dst, &desc, sizeof(desc));

drivers/net/can/m_can/m_can_pci.c

69

void __iomem *dst = priv->base + offset;

drivers/net/can/m_can/m_can_pci.c

72

iowrite32(*(unsigned int *)val, dst);

drivers/net/can/m_can/m_can_pci.c

74

dst += 4;

drivers/net/can/m_can/m_can_platform.c

60

void __iomem *dst = priv->mram_base + offset;

drivers/net/can/m_can/m_can_platform.c

63

iowrite32(*(unsigned int *)val, dst);

drivers/net/can/m_can/m_can_platform.c

65

dst += 4;

drivers/net/dsa/bcm_sf2_cfp.c

297

reg = be16_to_cpu(ports->dst) >> 8;

drivers/net/dsa/bcm_sf2_cfp.c

308

reg = (be16_to_cpu(ports->dst) & 0xff) << 24 |

drivers/net/dsa/bcm_sf2_cfp.c

310

(be32_to_cpu(addrs->dst) & 0x0000ff00) >> 8;

drivers/net/dsa/bcm_sf2_cfp.c

321

reg = (u32)(be32_to_cpu(addrs->dst) & 0xff) << 24 |

drivers/net/dsa/bcm_sf2_cfp.c

322

(u32)(be32_to_cpu(addrs->dst) >> 16) << 8 |

drivers/net/dsa/bcm_sf2_cfp.c

801

bcm_sf2_cfp_slice_ipv6(priv, ipv6.key->dst.in6_u.u6_addr32,

drivers/net/dsa/bcm_sf2_cfp.c

802

ports.key->dst, 0, slice_num,

drivers/net/dsa/bcm_sf2_cfp.c

804

bcm_sf2_cfp_slice_ipv6(priv, ipv6.mask->dst.in6_u.u6_addr32,

drivers/net/dsa/bcm_sf2_cfp.c

805

ports.key->dst, 0, SLICE_NUM_MASK,

drivers/net/dsa/microchip/ksz9477_tc_flower.c

66

if (!is_zero_ether_addr(ematch.key->dst)) {

drivers/net/dsa/microchip/ksz9477_tc_flower.c

67

if (!is_broadcast_ether_addr(ematch.mask->dst))

drivers/net/dsa/microchip/ksz9477_tc_flower.c

70

dst_mac = ematch.key->dst;

drivers/net/dsa/microchip/ksz_common.c

2779

if (ds->dst->index != 0) {

drivers/net/dsa/microchip/ksz_common.c

2780

snprintf(bus->id, MII_BUS_ID_SIZE, "SMI-%d-%d", ds->dst->index, ds->index);

drivers/net/dsa/mv88e6xxx/chip.c

1527

struct dsa_switch_tree *dst = ds->dst;

drivers/net/dsa/mv88e6xxx/chip.c

1533

if (dev <= dst->last_switch) {

drivers/net/dsa/mv88e6xxx/chip.c

1534

list_for_each_entry(dp, &dst->ports, list) {

drivers/net/dsa/mv88e6xxx/chip.c

1546

list_for_each_entry(dp, &dst->ports, list) {

drivers/net/dsa/mv88e6xxx/chip.c

1552

if (bridge_num + dst->last_switch != dev)

drivers/net/dsa/mv88e6xxx/chip.c

1756

struct dsa_switch_tree *dst = chip->ds->dst;

drivers/net/dsa/mv88e6xxx/chip.c

1768

ds = dsa_switch_find(dst->index, dev);

drivers/net/dsa/mv88e6xxx/chip.c

3000

struct dsa_switch_tree *dst = ds->dst;

drivers/net/dsa/mv88e6xxx/chip.c

3004

list_for_each_entry(dp, &dst->ports, list) {

drivers/net/dsa/mv88e6xxx/chip.c

3035

u8 dev = bridge_num + ds->dst->last_switch;

drivers/net/dsa/mv88e6xxx/chip.c

3116

if (tree_index != ds->dst->index)

drivers/net/dsa/mv88e6xxx/chip.c

3133

if (tree_index != ds->dst->index)

drivers/net/dsa/mv88e6xxx/chip.c

3974

ds->dst->last_switch - 1;

drivers/net/dsa/mv88e6xxx/chip.c

6864

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/dsa/mv88e6xxx/chip.c

6904

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/dsa/mv88e6xxx/chip.c

6972

dsa_lags_foreach_id(id, ds->dst) {

drivers/net/dsa/mv88e6xxx/chip.c

6973

lag = dsa_lag_by_id(ds->dst, id);

drivers/net/dsa/mv88e6xxx/chip.c

6978

dsa_lag_foreach_port(dp, ds->dst, lag) {

drivers/net/dsa/mv88e6xxx/chip.c

6987

dsa_lag_foreach_port(dp, ds->dst, lag) {

drivers/net/dsa/ocelot/felix_vsc9959.c

1777

ether_addr_copy(stream->dmac, match.key->dst);

drivers/net/dsa/qca/qca8k-8xxx.c

968

ds->dst->index, ds->index);

drivers/net/dsa/qca/qca8k-common.c

1065

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/dsa/qca/qca8k-common.c

1115

dsa_lags_foreach_id(i, ds->dst)

drivers/net/dsa/qca/qca8k-common.c

1116

if (i != lag.id && dsa_lag_by_id(ds->dst, i)) {

drivers/net/dsa/sja1105/sja1105_flower.c

245

if (!ether_addr_equal(match.mask->dst, bcast)) {

drivers/net/dsa/sja1105/sja1105_flower.c

251

dmac = ether_addr_to_u64(match.key->dst);

drivers/net/dsa/sja1105/sja1105_flower.c

252

is_bcast_dmac = ether_addr_equal(match.key->dst, bcast);

drivers/net/dsa/sja1105/sja1105_main.c

222

list_for_each_entry(dp, &ds->dst->ports, list) {

drivers/net/dsa/sja1105/sja1105_main.c

2580

struct dsa_switch_tree *dst = ds->dst;

drivers/net/dsa/sja1105/sja1105_main.c

2589

list_for_each_entry(dp, &dst->ports, list) {

drivers/net/dsa/sja1105/sja1105_main.c

512

struct dsa_switch_tree *dst;

drivers/net/dsa/sja1105/sja1105_main.c

595

dst = ds->dst;

drivers/net/dsa/sja1105/sja1105_main.c

597

list_for_each_entry(dl, &dst->rtable, list) {

drivers/net/dsa/yt921x.c

1060

u32 dst;

drivers/net/dsa/yt921x.c

1067

dst = YT921X_MIRROR_PORT(to_local_port);

drivers/net/dsa/yt921x.c

1076

(val & YT921X_MIRROR_PORT_M) != dst) {

drivers/net/dsa/yt921x.c

1084

ctrl |= dst;

drivers/net/dsa/yt921x.c

1192

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/dsa/yt921x.c

1214

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/dsa/yt921x.c

1285

dsa_lags_foreach_id(i, ds->dst)

drivers/net/dsa/yt921x.c

1286

if (i != lag.id && dsa_lag_by_id(ds->dst, i)) {

drivers/net/dsa/yt921x.c

1298

dsa_lag_foreach_port(dp, ds->dst, &lag)

drivers/net/ethernet/8390/xsurf100.c

122

static void xs100_read(struct net_device *dev, void *dst, unsigned int count)

drivers/net/ethernet/8390/xsurf100.c

130

z_memcpy_fromio32(dst, xs100->data_area +

drivers/net/ethernet/8390/xsurf100.c

133

dst += XS100_8390_DATA_AREA_SIZE;

drivers/net/ethernet/8390/xsurf100.c

137

z_memcpy_fromio32(dst, xs100->data_area + XS100_8390_DATA_READ32_BASE,

drivers/net/ethernet/8390/xsurf100.c

139

dst += count & ~3;

drivers/net/ethernet/8390/xsurf100.c

141

*(uint16_t *)dst = ei_inw(ei_local->mem + NE_DATAPORT);

drivers/net/ethernet/8390/xsurf100.c

142

dst += 2;

drivers/net/ethernet/8390/xsurf100.c

145

*(uint8_t *)dst = ei_inb(ei_local->mem + NE_DATAPORT);

drivers/net/ethernet/8390/xsurf100.c

66

static void z_memcpy_fromio32(void *dst, const void __iomem *src, size_t bytes)

drivers/net/ethernet/8390/xsurf100.c

72

"adda.l #32,%1" : "=a"(src), "=a"(dst)

drivers/net/ethernet/8390/xsurf100.c

73

: "0"(src), "1"(dst) : "d0", "d1", "d2", "d3", "d4",

drivers/net/ethernet/8390/xsurf100.c

78

*(uint32_t *)dst = z_readl(src);

drivers/net/ethernet/8390/xsurf100.c

80

dst += 4;

drivers/net/ethernet/8390/xsurf100.c

85

static void z_memcpy_toio32(void __iomem *dst, const void *src, size_t bytes)

drivers/net/ethernet/8390/xsurf100.c

88

z_writel(*(const uint32_t *)src, dst);

drivers/net/ethernet/8390/xsurf100.c

90

dst += 4;

drivers/net/ethernet/actions/owl-emac.c

449

static void owl_emac_ether_addr_push(u8 **dst, const u8 *src)

drivers/net/ethernet/actions/owl-emac.c

451

u32 *a = (u32 *)(*dst);

drivers/net/ethernet/actions/owl-emac.c

458

*dst += 12;

drivers/net/ethernet/airoha/airoha_eth.c

679

&port->dsa_meta[sptag]->dst);

drivers/net/ethernet/airoha/airoha_ppe.c

1052

memcpy(data.eth.h_dest, match.key->dst, ETH_ALEN);

drivers/net/ethernet/airoha/airoha_ppe.c

1122

data.dst_port = ports.key->dst;

drivers/net/ethernet/airoha/airoha_ppe.c

1132

data.v4.dst_addr = addrs.key->dst;

drivers/net/ethernet/airoha/airoha_ppe.c

1142

data.v6.dst_addr = addrs.key->dst;

drivers/net/ethernet/amazon/ena/ena_ethtool.c

157

static void ena_safe_update_stat(u64 *src, u64 *dst,

drivers/net/ethernet/amazon/ena/ena_ethtool.c

164

*(dst) = *src;

drivers/net/ethernet/amd/atarilance.c

358

static void *slow_memcpy( void *dst, const void *src, size_t len )

drivers/net/ethernet/amd/atarilance.c

360

{ char *cto = dst;

drivers/net/ethernet/amd/atarilance.c

367

return dst;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

159

attr.dst = pdata->netdev->dev_addr;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

177

attr.dst = pdata->netdev->dev_addr;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

198

attr.dst = pdata->netdev->dev_addr;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

212

attr.dst = pdata->netdev->dev_addr;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

231

attr.dst = pdata->netdev->dev_addr;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

38

const unsigned char *dst = tdata->packet->dst;

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

65

if (dst) {

drivers/net/ethernet/amd/xgbe/xgbe-selftest.c

66

if (!ether_addr_equal_unaligned(eh->h_dest, dst))

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

139

#define PHY_CONTROL_SET(dst, val) xgene_set_bits(dst, val, 0, 16)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

157

#define CFG_TXCLK_MUXSEL0_SET(dst, val) xgene_set_bits(dst, val, 29, 3)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

158

#define CFG_RXCLK_MUXSEL0_SET(dst, val) xgene_set_bits(dst, val, 26, 3)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

160

#define CFG_CLE_IP_PROTOCOL0_SET(dst, val) xgene_set_bits(dst, val, 16, 2)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

161

#define CFG_CLE_IP_HDR_LEN_SET(dst, val) xgene_set_bits(dst, val, 8, 5)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

162

#define CFG_CLE_DSTQID0_SET(dst, val) xgene_set_bits(dst, val, 0, 12)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

163

#define CFG_CLE_FPSEL0_SET(dst, val) xgene_set_bits(dst, val, 16, 4)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

164

#define CFG_CLE_NXTFPSEL0_SET(dst, val) xgene_set_bits(dst, val, 20, 4)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

165

#define CFG_MACMODE_SET(dst, val) xgene_set_bits(dst, val, 18, 2)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

166

#define CFG_WAITASYNCRD_SET(dst, val) xgene_set_bits(dst, val, 0, 16)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

20

static inline void xgene_set_bits(u32 *dst, u32 val, u32 start, u32 len)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

205

#define PHY_ADDR_SET(dst, val) xgene_set_bits(dst, val, 8, 5)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

206

#define REG_ADDR_SET(dst, val) xgene_set_bits(dst, val, 0, 5)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

207

#define ENET_INTERFACE_MODE2_SET(dst, val) xgene_set_bits(dst, val, 8, 2)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

208

#define MGMT_CLOCK_SEL_SET(dst, val) xgene_set_bits(dst, val, 0, 3)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

25

*dst &= ~mask;

drivers/net/ethernet/apm/xgene/xgene_enet_hw.h

26

*dst |= (val << start) & mask;

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.h

58

#define RSIF_CLE_BUFF_THRESH_SET(dst, val) xgene_set_bits(dst, val, 0, 3)

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.h

61

#define RSIF_PLC_CLE_BUFF_THRESH_SET(dst, val) xgene_set_bits(dst, val, 0, 2)

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

228

bnge_hwrm_create_token(struct bnge_dev *bd, enum bnge_hwrm_chnl dst)

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

238

token->dst = dst;

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

240

if (dst == BNGE_HWRM_CHNL_CHIMP) {

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

253

if (token->dst == BNGE_HWRM_CHNL_CHIMP) {

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

291

enum bnge_hwrm_chnl dst = BNGE_HWRM_CHNL_CHIMP;

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.c

316

token = bnge_hwrm_create_token(bd, dst);

drivers/net/ethernet/broadcom/bnge/bnge_hwrm.h

46

enum bnge_hwrm_chnl dst;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c

4542

u8 *dst = (u8 *)(data->rss_key) + sizeof(data->rss_key);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sp.c

4550

*--dst = *src++;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15597

keys1->addrs.v4addrs.dst != keys2->addrs.v4addrs.dst ||

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15598

masks1->addrs.v4addrs.dst != masks2->addrs.v4addrs.dst)

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15605

!ipv6_addr_equal(&keys1->addrs.v6addrs.dst,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15606

&keys2->addrs.v6addrs.dst) ||

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15607

!ipv6_addr_equal(&masks1->addrs.v6addrs.dst,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15608

&masks2->addrs.v6addrs.dst))

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15614

keys1->ports.dst == keys2->ports.dst &&

drivers/net/ethernet/broadcom/bnxt/bnxt.c

15615

masks1->ports.dst == masks2->ports.dst &&

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16139

struct bnxt_rx_ring_info *dst,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16146

dst_ring = &dst->rx_ring_struct;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16169

dst_ring = &dst->rx_agg_ring_struct;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16174

dst->rx_page_size = src->rx_page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16182

WARN_ON(dst->rx_agg_bmap_size != src->rx_agg_bmap_size);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16192

dst->rx_agg_bmap = src->rx_agg_bmap;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

281

.dst = 0,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

286

.dst = BNXT_IPV6_MASK_NONE,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

294

.dst = cpu_to_be16(0xffff),

drivers/net/ethernet/broadcom/bnxt/bnxt.c

299

.dst = BNXT_IPV6_MASK_ALL,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

307

.dst = cpu_to_be16(0xffff),

drivers/net/ethernet/broadcom/bnxt/bnxt.c

312

.dst = cpu_to_be32(0xffffffff),

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6353

*(struct in6_addr *)&req->dst_ipaddr[0] = keys->addrs.v6addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6354

*(struct in6_addr *)&req->dst_ipaddr_mask[0] = masks->addrs.v6addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6358

req->dst_ipaddr[0] = keys->addrs.v4addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6359

req->dst_ipaddr_mask[0] = masks->addrs.v4addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6369

req->dst_port = keys->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

6370

req->dst_port_mask = masks->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt.h

1865

struct metadata_dst *dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

687

static void bnxt_copy_to_nvm_data(union bnxt_nvm_data *dst,

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

694

dst->val8 = src->vbool;

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

703

dst->val32 = cpu_to_le32(val32);

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

706

static void bnxt_copy_from_nvm_data(union devlink_param_value *dst,

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

713

dst->vbool = src->val8;

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

718

dst->vu32 = val32;

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

720

dst->vu16 = (u16)val32;

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c

722

dst->vu8 = (u8)val32;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1172

fs->h_u.tcp_ip4_spec.ip4dst = fkeys->addrs.v4addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1173

fs->m_u.tcp_ip4_spec.ip4dst = fmasks->addrs.v4addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1178

fs->h_u.tcp_ip4_spec.pdst = fkeys->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1179

fs->m_u.tcp_ip4_spec.pdst = fmasks->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1203

fkeys->addrs.v6addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1205

fmasks->addrs.v6addrs.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1210

fs->h_u.tcp_ip6_spec.pdst = fkeys->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1211

fs->m_u.tcp_ip6_spec.pdst = fmasks->ports.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1392

fkeys->addrs.v4addrs.dst = ip_spec->ip4dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1393

fmasks->addrs.v4addrs.dst = ip_mask->ip4dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1407

fkeys->addrs.v4addrs.dst = ip_spec->ip4dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1408

fmasks->addrs.v4addrs.dst = ip_mask->ip4dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1411

fkeys->ports.dst = ip_spec->pdst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1412

fmasks->ports.dst = ip_mask->pdst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1424

fkeys->addrs.v6addrs.dst = *(struct in6_addr *)&ip_spec->ip6dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1425

fmasks->addrs.v6addrs.dst = *(struct in6_addr *)&ip_mask->ip6dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1440

fkeys->addrs.v6addrs.dst = *(struct in6_addr *)&ip_spec->ip6dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1441

fmasks->addrs.v6addrs.dst = *(struct in6_addr *)&ip_mask->ip6dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1444

fkeys->ports.dst = ip_spec->pdst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

1445

fmasks->ports.dst = ip_mask->pdst;

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

2131

u8 *dst = (u8 *)(_p + BNXT_PXP_REG_LEN);

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

2145

u32 *dst32 = (u32 *)(dst + i);

drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c

2153

u64 *dst64 = (u64 *)(dst + i);

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

370

__hwrm_acquire_token(struct bnxt *bp, enum bnxt_hwrm_chnl dst)

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

380

token->dst = dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

382

if (dst == BNXT_HWRM_CHNL_CHIMP) {

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

395

if (token->dst == BNXT_HWRM_CHNL_CHIMP) {

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

462

enum bnxt_hwrm_chnl dst = BNXT_HWRM_CHNL_CHIMP;

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

495

dst = BNXT_HWRM_CHNL_KONG;

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.c

506

token = __hwrm_acquire_token(bp, dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_hwrm.h

53

enum bnxt_hwrm_chnl dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1243

flow.daddr = tun_key->u.ipv4.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1254

dst_dev = rt->dst.dev;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1280

nbr = dst_neigh_lookup(&rt->dst, &flow.daddr);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1289

tun_key->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

1338

tun_key.u.ipv4.dst = flow->tun_key.u.ipv4.src;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

406

ether_addr_copy(flow->l2_key.dmac, match.key->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

407

ether_addr_copy(flow->l2_mask.dmac, match.mask->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

432

flow->l3_key.ipv4.daddr.s_addr = match.key->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

433

flow->l3_mask.ipv4.daddr.s_addr = match.mask->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

441

flow->l3_key.ipv6.daddr = match.key->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

442

flow->l3_mask.ipv6.daddr = match.mask->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

452

flow->l4_key.ports.dport = match.key->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

453

flow->l4_mask.ports.dport = match.mask->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

474

flow->tun_key.u.ipv4.dst = match.key->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

475

flow->tun_mask.u.ipv4.dst = match.mask->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

497

flow->tun_key.tp_dst = match.key->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

498

flow->tun_mask.tp_dst = match.mask->dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

839

req->dst_ipaddr[0] = tun_key->u.ipv4.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

913

encap_ipv4->dest_ip_addr = encap_key->u.ipv4.dst;

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

124

dst_hold((struct dst_entry *)vf_rep->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

125

skb_dst_set(skb, (struct dst_entry *)vf_rep->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

126

skb->dev = vf_rep->dst->u.port_info.lower_dev;

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

301

if (vf_rep->dst) {

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

302

dst_release((struct dst_entry *)vf_rep->dst);

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

303

vf_rep->dst = NULL;

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

400

vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL);

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

401

if (!vf_rep->dst)

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

405

vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;

drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

406

vf_rep->dst->u.port_info.lower_dev = bp->dev;

drivers/net/ethernet/broadcom/cnic.c

341

memcpy(&path_req.dst.v6_addr, &csk->dst_ip[0],

drivers/net/ethernet/broadcom/cnic.c

345

memcpy(&path_req.dst.v4_addr, &csk->dst_ip[0],

drivers/net/ethernet/broadcom/cnic.c

3679

struct dst_entry **dst)

drivers/net/ethernet/broadcom/cnic.c

3687

*dst = &rt->dst;

drivers/net/ethernet/broadcom/cnic.c

3697

struct dst_entry **dst)

drivers/net/ethernet/broadcom/cnic.c

3707

*dst = ip6_route_output(&init_net, NULL, &fl6);

drivers/net/ethernet/broadcom/cnic.c

3708

if ((*dst)->error) {

drivers/net/ethernet/broadcom/cnic.c

3709

dst_release(*dst);

drivers/net/ethernet/broadcom/cnic.c

3710

*dst = NULL;

drivers/net/ethernet/broadcom/cnic.c

3723

struct dst_entry *dst;

drivers/net/ethernet/broadcom/cnic.c

3728

err = cnic_get_v4_route(dst_addr, &dst);

drivers/net/ethernet/broadcom/cnic.c

3733

err = cnic_get_v6_route(dst_addr6, &dst);

drivers/net/ethernet/broadcom/cnic.c

3740

if (!dst->dev)

drivers/net/ethernet/broadcom/cnic.c

3743

cnic_get_vlan(dst->dev, &netdev);

drivers/net/ethernet/broadcom/cnic.c

3748

dst_release(dst);

drivers/net/ethernet/broadcom/cnic.c

3767

struct dst_entry *dst = NULL;

drivers/net/ethernet/broadcom/cnic.c

3785

cnic_get_v6_route(&saddr->remote.v6, &dst);

drivers/net/ethernet/broadcom/cnic.c

3793

cnic_get_v4_route(&saddr->remote.v4, &dst);

drivers/net/ethernet/broadcom/cnic.c

3802

if (dst && dst->dev) {

drivers/net/ethernet/broadcom/cnic.c

3803

u16 vlan = cnic_get_vlan(dst->dev, &realdev);

drivers/net/ethernet/broadcom/cnic.c

3806

csk->mtu = dst_mtu(dst);

drivers/net/ethernet/broadcom/cnic.c

3829

dst_release(dst);

drivers/net/ethernet/broadcom/tg3.c

6396

static inline void tg3_rd32_loop(struct tg3 *tp, u32 *dst, u32 off, u32 len)

drivers/net/ethernet/broadcom/tg3.c

6400

dst = (u32 *)((u8 *)dst + off);

drivers/net/ethernet/broadcom/tg3.c

6402

*dst++ = tr32(off + i);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

206

u8 *src, *dst;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

209

dst = (u8 *)cmdq->addr.kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

210

dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

215

memcpy(dst, src, to_copy);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

219

dst = (u8 *)cmdq->addr.kva;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

220

dst += (cmdq->producer_index * BFI_MSGQ_CMD_ENTRY_SIZE);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

641

u8 *src, *dst;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

646

dst = buf;

drivers/net/ethernet/brocade/bna/bfa_msgq.c

651

memcpy(dst, src, to_copy);

drivers/net/ethernet/brocade/bna/bfa_msgq.c

653

dst += BFI_MSGQ_RSP_ENTRY_SIZE;

drivers/net/ethernet/cavium/thunder/thunder_bgx.c

1387

u8 *dst)

drivers/net/ethernet/cavium/thunder/thunder_bgx.c

1400

ether_addr_copy(dst, mac);

drivers/net/ethernet/chelsio/cxgb3/l2t.c

265

struct l2t_entry *t3_l2t_get(struct t3cdev *cdev, struct dst_entry *dst,

drivers/net/ethernet/chelsio/cxgb3/l2t.c

278

neigh = dst_neigh_lookup(dst, daddr);

drivers/net/ethernet/chelsio/cxgb3/l2t.h

112

struct l2t_entry *t3_l2t_get(struct t3cdev *cdev, struct dst_entry *dst,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

195

memcpy(&fs->val.lip[0], &match.key->dst, sizeof(match.key->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

197

memcpy(&fs->mask.lip[0], &match.mask->dst, sizeof(match.mask->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

201

memcpy(&fs->nat_lip[0], &match.key->dst, sizeof(match.key->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

210

memcpy(&fs->val.lip[0], match.key->dst.s6_addr,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

211

sizeof(match.key->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

214

memcpy(&fs->mask.lip[0], match.mask->dst.s6_addr,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

215

sizeof(match.mask->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

220

memcpy(&fs->nat_lip[0], match.key->dst.s6_addr,

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

221

sizeof(match.key->dst));

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

230

fs->val.lport = be16_to_cpu(match.key->dst);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

231

fs->mask.lport = be16_to_cpu(match.mask->dst);

drivers/net/ethernet/chelsio/cxgb4/sge.c

991

static void cxgb_pio_copy(u64 __iomem *dst, u64 *src)

drivers/net/ethernet/chelsio/cxgb4/sge.c

996

writeq(*src, dst);

drivers/net/ethernet/chelsio/cxgb4/sge.c

998

dst++;

drivers/net/ethernet/chelsio/cxgb4vf/sge.c

1000

__be64 __iomem *dst = (__be64 __iomem *)(tq->bar2_addr +

drivers/net/ethernet/chelsio/cxgb4vf/sge.c

1018

writeq((__force u64)*src, dst);

drivers/net/ethernet/chelsio/cxgb4vf/sge.c

1020

dst++;

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

421

struct dst_entry *dst;

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

494

dst = sk_dst_get(sk);

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

495

if (!dst) {

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

499

n = dst_neigh_lookup(dst, daaddr);

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

502

dst_release(dst);

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

508

dst_release(dst);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1123

struct dst_entry *dst;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1137

dst = inet_csk_route_child_sock(lsk, newsk, oreq);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1138

if (!dst)

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1141

n = dst_neigh_lookup(dst, &iph->saddr);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1155

dst = ip6_dst_lookup_flow(sock_net(lsk), lsk, &fl6, NULL);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1156

if (IS_ERR(dst))

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1158

n = dst_neigh_lookup(dst, &ip6h->saddr);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1217

sk_setup_caps(newsk, dst);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

1254

dst_release(dst);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

947

struct dst_entry *dst;

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

958

dst = __sk_dst_get(sk);

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.c

972

tp->advmss = dst_metric_advmss(dst);

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

106

n = dst_neigh_lookup(&rt->dst, &peer_ip);

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

112

dst_release(&rt->dst);

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

116

return &rt->dst;

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

126

struct dst_entry *dst = NULL;

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

136

dst = ip6_route_output(&init_net, NULL, &fl6);

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

137

if (dst->error ||

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

139

ip6_dst_idev(dst)->dev) &&

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

140

!(ip6_dst_idev(dst)->dev->flags & IFF_LOOPBACK))) {

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

141

dst_release(dst);

drivers/net/ethernet/chelsio/libcxgb/libcxgb_cm.c

146

return dst;

drivers/net/ethernet/cisco/enic/enic_clsf.c

163

tpos->keys.addrs.v4addrs.dst == k->addrs.v4addrs.dst &&

drivers/net/ethernet/cisco/enic/enic_clsf.c

39

data.u.ipv4.dst_addr = ntohl(keys->addrs.v4addrs.dst);

drivers/net/ethernet/cisco/enic/enic_clsf.c

41

data.u.ipv4.dst_port = ntohs(keys->ports.dst);

drivers/net/ethernet/cisco/enic/enic_ethtool.c

523

fsp->h_u.tcp_ip4_spec.pdst = n->keys.ports.dst;

drivers/net/ethernet/ezchip/nps_enet.c

35

unsigned char *dst, u32 length)

drivers/net/ethernet/ezchip/nps_enet.c

39

u32 *reg = (u32 *)dst, len = length / sizeof(u32);

drivers/net/ethernet/ezchip/nps_enet.c

40

bool dst_is_aligned = IS_ALIGNED((unsigned long)dst, sizeof(u32));

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

53

ether_addr_copy(acl_h->l2_dest_mac, &match.key->dst[0]);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

55

ether_addr_copy(acl_m->l2_dest_mac, &match.mask->dst[0]);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

79

acl_h->l3_dest_ip = be32_to_cpu(match.key->dst);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

81

acl_m->l3_dest_ip = be32_to_cpu(match.mask->dst);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

89

acl_h->l4_dest_port = be16_to_cpu(match.key->dst);

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

91

acl_m->l4_dest_port = be16_to_cpu(match.mask->dst);

drivers/net/ethernet/freescale/enetc/enetc_ethtool.c

554

static void ether_addr_copy_swap(u8 *dst, const u8 *src)

drivers/net/ethernet/freescale/enetc/enetc_ethtool.c

559

dst[i] = src[ETH_ALEN - i - 1];

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1167

if (!is_zero_ether_addr(match.mask->dst) &&

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1175

if (!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1176

if (!is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/freescale/enetc/enetc_qos.c

1182

ether_addr_copy(filter->sid.dst_mac, match.key->dst);

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

547

void *dst;

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

592

dst = copy_page_info->page_address + copy_page_info->page_offset;

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

593

memcpy(dst, src, page_info->pad + len);

drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c

1736

static void hns_dsaf_mc_mask_bit_clear(char *dst, const char *src)

drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c

1738

u16 *a = (u16 *)dst;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7030

#define flow_ip6_dst fkeys->addrs.v6addrs.dst.in6_u.u6_addr32

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7034

tuples->dst_port = be16_to_cpu(fkeys->ports.dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7038

tuples->dst_ip[3] = be32_to_cpu(fkeys->addrs.v4addrs.dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7241

ether_addr_copy(rule->tuples.dst_mac, match.key->dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7242

ether_addr_copy(rule->tuples_mask.dst_mac, match.mask->dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7290

rule->tuples.dst_ip[IPV4_INDEX] = be32_to_cpu(match.key->dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7292

be32_to_cpu(match.mask->dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7302

match.key->dst.s6_addr32);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7304

match.mask->dst.s6_addr32);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7323

rule->tuples.dst_port = be16_to_cpu(match.key->dst);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c

7324

rule->tuples_mask.dst_port = be16_to_cpu(match.mask->dst);

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

301

static void cmdq_wqe_fill(void *dst, void *src)

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

303

memcpy(dst + FIRST_DATA_TO_WRITE_LAST, src + FIRST_DATA_TO_WRITE_LAST,

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

308

*(u64 *)dst = *(u64 *)src;

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

342

struct cmdq_header *dst = (struct cmdq_header *)hw_wqe;

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

346

memcpy(dst + 1, src + 1, len);

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

349

WRITE_ONCE(*dst, *src);

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

550

static void mbox_dword_write(const void *src, void __iomem *dst, u32 count)

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

553

u32 __iomem *dst32 = dst;

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

574

u32 __iomem *dst = (u32 __iomem *)(mbox->data + MBOX_HEADER_SZ);

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

581

mbox_dword_write(src, dst, count);

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

586

mbox_dword_write(&last_dword, dst + count, 1);

drivers/net/ethernet/ibm/ibmvnic.c

2438

unsigned char *dst;

drivers/net/ethernet/ibm/ibmvnic.c

2492

dst = ltb->buff + offset;

drivers/net/ethernet/ibm/ibmvnic.c

2493

memset(dst, 0, tx_pool->buf_size);

drivers/net/ethernet/ibm/ibmvnic.c

2514

skb_copy_from_linear_data(skb, dst, skb_headlen(skb));

drivers/net/ethernet/ibm/ibmvnic.c

2521

memcpy(dst + cur, skb_frag_address(frag),

drivers/net/ethernet/ibm/ibmvnic.c

2526

skb_copy_from_linear_data(skb, dst, skb->len);

drivers/net/ethernet/ibm/ibmvnic.c

785

unsigned char *dst;

drivers/net/ethernet/ibm/ibmvnic.c

826

dst = ltb->buff + offset;

drivers/net/ethernet/ibm/ibmvnic.c

827

memset(dst, 0, pool->buff_size);

drivers/net/ethernet/ibm/ibmvnic.c

831

pool->rx_buff[bufidx].data = dst;

drivers/net/ethernet/intel/i40e/i40e.h

358

#define I40E_FLEX_SET_DST_WORD(dst) (((dst) << \

drivers/net/ethernet/intel/i40e/i40e.h

364

#define I40E_FLEX_PREP_VAL(dst, fsize, src) (I40E_FLEX_SET_DST_WORD(dst) | \

drivers/net/ethernet/intel/i40e/i40e_main.c

8619

if (!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8620

if (is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8624

match.mask->dst);

drivers/net/ethernet/intel/i40e/i40e_main.c

8638

ether_addr_copy(filter->dst_mac, match.key->dst);

drivers/net/ethernet/intel/i40e/i40e_main.c

8675

if (match.mask->dst) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8676

if (match.mask->dst == cpu_to_be32(0xffffffff)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8680

&match.mask->dst);

drivers/net/ethernet/intel/i40e/i40e_main.c

8699

filter->dst_ipv4 = match.key->dst;

drivers/net/ethernet/intel/i40e/i40e_main.c

8711

if (ipv6_addr_loopback(&match.key->dst) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8717

if (!ipv6_addr_any(&match.mask->dst) ||

drivers/net/ethernet/intel/i40e/i40e_main.c

8723

memcpy(&filter->dst_ipv6, &match.key->dst.s6_addr32,

drivers/net/ethernet/intel/i40e/i40e_main.c

8741

if (match.mask->dst) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8742

if (match.mask->dst == cpu_to_be16(0xffff)) {

drivers/net/ethernet/intel/i40e/i40e_main.c

8746

be16_to_cpu(match.mask->dst));

drivers/net/ethernet/intel/i40e/i40e_main.c

8751

filter->dst_port = match.key->dst;

drivers/net/ethernet/intel/iavf/iavf_main.c

3876

if (!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3877

if (is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3881

match.mask->dst);

drivers/net/ethernet/intel/iavf/iavf_main.c

3896

if (!is_zero_ether_addr(match.key->dst))

drivers/net/ethernet/intel/iavf/iavf_main.c

3897

if (is_valid_ether_addr(match.key->dst) ||

drivers/net/ethernet/intel/iavf/iavf_main.c

3898

is_multicast_ether_addr(match.key->dst)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3903

match.key->dst);

drivers/net/ethernet/intel/iavf/iavf_main.c

3949

if (match.mask->dst) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3950

if (match.mask->dst == cpu_to_be32(0xffffffff)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3954

be32_to_cpu(match.mask->dst));

drivers/net/ethernet/intel/iavf/iavf_main.c

3973

if (match.key->dst) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3975

vf->data.tcp_spec.dst_ip[0] = match.key->dst;

drivers/net/ethernet/intel/iavf/iavf_main.c

3989

if (ipv6_addr_any(&match.mask->dst)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

3998

if (ipv6_addr_loopback(&match.key->dst) ||

drivers/net/ethernet/intel/iavf/iavf_main.c

4004

if (!ipv6_addr_any(&match.mask->dst) ||

drivers/net/ethernet/intel/iavf/iavf_main.c

4010

memcpy(&vf->data.tcp_spec.dst_ip, &match.key->dst.s6_addr32,

drivers/net/ethernet/intel/iavf/iavf_main.c

4031

if (match.mask->dst) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4032

if (match.mask->dst == cpu_to_be16(0xffff)) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4036

be16_to_cpu(match.mask->dst));

drivers/net/ethernet/intel/iavf/iavf_main.c

4040

if (match.key->dst) {

drivers/net/ethernet/intel/iavf/iavf_main.c

4042

vf->data.tcp_spec.dst_port = match.key->dst;

drivers/net/ethernet/intel/ice/ice_arfs.c

326

fltr_info->ip.v4.dst_ip = fk->addrs.v4addrs.dst;

drivers/net/ethernet/intel/ice/ice_arfs.c

328

fltr_info->ip.v4.dst_port = fk->ports.dst;

drivers/net/ethernet/intel/ice/ice_arfs.c

336

memcpy(&fltr_info->ip.v6.dst_ip, &fk->addrs.v6addrs.dst,

drivers/net/ethernet/intel/ice/ice_arfs.c

339

fltr_info->ip.v6.dst_port = fk->ports.dst;

drivers/net/ethernet/intel/ice/ice_arfs.c

410

fltr_info->ip.v4.dst_port == fk->ports.dst &&

drivers/net/ethernet/intel/ice/ice_arfs.c

412

fltr_info->ip.v4.dst_ip == fk->addrs.v4addrs.dst &&

drivers/net/ethernet/intel/ice/ice_arfs.c

416

fltr_info->ip.v6.dst_port == fk->ports.dst &&

drivers/net/ethernet/intel/ice/ice_arfs.c

420

!memcmp(&fltr_info->ip.v6.dst_ip, &fk->addrs.v6addrs.dst,

drivers/net/ethernet/intel/ice/ice_eswitch.c

113

struct metadata_dst *dst;

drivers/net/ethernet/intel/ice/ice_eswitch.c

115

repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,

drivers/net/ethernet/intel/ice/ice_eswitch.c

117

if (!repr->dst)

drivers/net/ethernet/intel/ice/ice_eswitch.c

122

dst = repr->dst;

drivers/net/ethernet/intel/ice/ice_eswitch.c

123

dst->u.port_info.port_id = vsi->vsi_num;

drivers/net/ethernet/intel/ice/ice_eswitch.c

124

dst->u.port_info.lower_dev = uplink_vsi->netdev;

drivers/net/ethernet/intel/ice/ice_eswitch.c

190

repr->dst->u.port_info.port_id = vsi->vsi_num;

drivers/net/ethernet/intel/ice/ice_eswitch.c

226

dst_hold((struct dst_entry *)repr->dst);

drivers/net/ethernet/intel/ice/ice_eswitch.c

227

skb_dst_set(skb, (struct dst_entry *)repr->dst);

drivers/net/ethernet/intel/ice/ice_eswitch.c

228

skb->dev = repr->dst->u.port_info.lower_dev;

drivers/net/ethernet/intel/ice/ice_eswitch.c

245

struct metadata_dst *dst = skb_metadata_dst(skb);

drivers/net/ethernet/intel/ice/ice_eswitch.c

248

if (!dst) {

drivers/net/ethernet/intel/ice/ice_eswitch.c

258

dst->u.port_info.port_id);

drivers/net/ethernet/intel/ice/ice_eswitch.c

94

if (!repr->dst)

drivers/net/ethernet/intel/ice/ice_eswitch.c

98

metadata_dst_free(repr->dst);

drivers/net/ethernet/intel/ice/ice_eswitch.c

99

repr->dst = NULL;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1892

u8 *src, *dst;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1919

dst = hw->blk[block_id].xlt1.t;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1932

dst = (u8 *)hw->blk[block_id].xlt2.t;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1945

dst = (u8 *)hw->blk[block_id].prof.t;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1958

dst = hw->blk[block_id].prof_redir.t;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1972

dst = (u8 *)hw->blk[block_id].es.t;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c

1995

memcpy(dst + offset, src, sect_len);

drivers/net/ethernet/intel/ice/ice_flow.c

2289

ice_rss_config_xor_word(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst)

drivers/net/ethernet/intel/ice/ice_flow.c

2296

val = dst | GLQF_HSYMM_ENABLE_BIT;

drivers/net/ethernet/intel/ice/ice_flow.c

2312

ice_rss_config_xor(struct ice_hw *hw, u8 prof_id, u8 src, u8 dst, u8 len)

drivers/net/ethernet/intel/ice/ice_flow.c

2324

fv_last_word - (dst + i));

drivers/net/ethernet/intel/ice/ice_flow.c

2326

fv_last_word - (dst + i),

drivers/net/ethernet/intel/ice/ice_lag.c

123

repr->dst->u.port_info.lower_dev = netdev;

drivers/net/ethernet/intel/ice/ice_parser_rt.c

487

u16 dst, src, shift, imm;

drivers/net/ethernet/intel/ice/ice_parser_rt.c

497

dst = rt->gpr[alu->dst_reg_id];

drivers/net/ethernet/intel/ice/ice_parser_rt.c

507

dst = (src << shift) + imm;

drivers/net/ethernet/intel/ice/ice_parser_rt.c

508

ice_gpr_add(rt, alu->dst_reg_id, dst);

drivers/net/ethernet/intel/ice/ice_parser_rt.c

511

dst += (src << shift) + imm;

drivers/net/ethernet/intel/ice/ice_parser_rt.c

512

ice_gpr_add(rt, alu->dst_reg_id, dst);

drivers/net/ethernet/intel/ice/ice_parser_rt.c

529

dst = (src << shift) ^ imm;

drivers/net/ethernet/intel/ice/ice_parser_rt.c

530

ice_gpr_add(rt, alu->dst_reg_id, dst);

drivers/net/ethernet/intel/ice/ice_repr.h

26

struct metadata_dst *dst;

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1326

if (match->key->dst) {

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1331

headers->l3_key.dst_ipv4 = match->key->dst;

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1332

headers->l3_mask.dst_ipv4 = match->mask->dst;

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1362

if (ipv6_addr_loopback(&match->key->dst) ||

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1368

if (ipv6_addr_any(&match->mask->dst) &&

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1373

if (!ipv6_addr_any(&match->mask->dst)) {

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1398

memcpy(&l3_key->dst_ipv6_addr, &match->key->dst.s6_addr,

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1399

sizeof(match->key->dst.s6_addr));

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1400

memcpy(&l3_mask->dst_ipv6_addr, &match->mask->dst.s6_addr,

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1401

sizeof(match->mask->dst.s6_addr));

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1453

if (match.key->dst) {

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1459

headers->l4_key.dst_port = match.key->dst;

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1460

headers->l4_mask.dst_port = match.mask->dst;

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1508

if (match.key->dst) {

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1509

dst_port = be16_to_cpu(match.key->dst);

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1747

if (!is_zero_ether_addr(match.key->dst)) {

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1749

match.key->dst);

drivers/net/ethernet/intel/ice/ice_tc_lib.c

1751

match.mask->dst);

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

3467

void *dst;

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

3475

dst = page_address(hdr_page) + hdr->offset +

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

3480

memcpy(dst, src, LARGEST_ALIGN(copy));

drivers/net/ethernet/intel/igb/igb_main.c

2640

if (!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/igb/igb_main.c

2641

if (!is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/intel/igb/igb_main.c

2648

ether_addr_copy(input->filter.dst_addr, match.key->dst);

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

26

struct tc_configuration *dst = NULL;

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

44

dst = &dcfg->tc_config[i - DCB_PG_ATTR_TC_0];

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

46

if (dst->path[tx].prio_type != src->path[tx].prio_type) {

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

47

dst->path[tx].prio_type = src->path[tx].prio_type;

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

51

if (dst->path[tx].bwg_id != src->path[tx].bwg_id) {

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

52

dst->path[tx].bwg_id = src->path[tx].bwg_id;

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

56

if (dst->path[tx].bwg_percent != src->path[tx].bwg_percent) {

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

57

dst->path[tx].bwg_percent = src->path[tx].bwg_percent;

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

61

if (dst->path[tx].up_to_tc_bitmap !=

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

63

dst->path[tx].up_to_tc_bitmap =

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

68

if (dst->path[rx].prio_type != src->path[rx].prio_type) {

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

69

dst->path[rx].prio_type = src->path[rx].prio_type;

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

73

if (dst->path[rx].bwg_id != src->path[rx].bwg_id) {

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

74

dst->path[rx].bwg_id = src->path[rx].bwg_id;

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

78

if (dst->path[rx].bwg_percent != src->path[rx].bwg_percent) {

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

79

dst->path[rx].bwg_percent = src->path[rx].bwg_percent;

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

83

if (dst->path[rx].up_to_tc_bitmap !=

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

85

dst->path[rx].up_to_tc_bitmap =

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

9215

common.port.dst ^= th->source;

drivers/net/ethernet/intel/ixgbe/ixgbe_type.h

3170

__be16 dst;

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

189

void libeth_xdp_load_stash(struct libeth_xdp_buff *dst,

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

192

dst->data = src->data;

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

193

dst->base.data_end = src->data + src->len;

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

194

dst->base.data_meta = src->data;

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

195

dst->base.data_hard_start = src->data - src->headroom;

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

197

dst->base.frame_sz = src->frame_sz;

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

198

dst->base.flags = src->flags;

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

212

void libeth_xdp_save_stash(struct libeth_xdp_buff_stash *dst,

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

215

dst->data = src->data;

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

216

dst->headroom = src->data - src->base.data_hard_start;

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

217

dst->len = src->base.data_end - src->data;

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

219

dst->frame_sz = src->base.frame_sz;

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

220

dst->flags = src->base.flags;

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

222

WARN_ON_ONCE(dst->flags != src->base.flags);

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c

1297

if (match.mask->dst) {

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c

1300

rule->c2_tcam |= ((u64)ntohs(match.key->dst)) << offs;

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c

1301

rule->c2_tcam_mask |= ((u64)ntohs(match.mask->dst)) << offs;

drivers/net/ethernet/marvell/octeontx2/af/rvu_cn10k.c

388

u8 src, dst;

drivers/net/ethernet/marvell/octeontx2/af/rvu_cn10k.c

417

dst = FIELD_GET(LBK_CONST_DST, lbk_const);

drivers/net/ethernet/marvell/octeontx2/af/rvu_cn10k.c

420

if (src == dst) {

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

741

if (!is_zero_ether_addr(match.mask->dst)) {

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

742

ether_addr_copy(flow_spec->dmac, (u8 *)&match.key->dst);

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

744

(u8 *)&match.mask->dst);

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

808

flow_spec->ip4dst = match.key->dst;

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

809

flow_mask->ip4dst = match.mask->dst;

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

820

if (ipv6_addr_loopback(&match.key->dst) ||

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

827

if (!ipv6_addr_any(&match.mask->dst)) {

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

829

(struct in6_addr *)&match.key->dst,

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

832

(struct in6_addr *)&match.mask->dst,

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

853

flow_spec->dport = match.key->dst;

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

854

flow_mask->dport = match.mask->dst;

drivers/net/ethernet/marvell/prestera/prestera_flower.c

265

ETH_DMAC_0, &match.key->dst[0], 4);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

267

ETH_DMAC_1, &match.key->dst[4], 2);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

270

ETH_DMAC_0, &match.mask->dst[0], 4);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

272

ETH_DMAC_1, &match.mask->dst[4], 2);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

294

rule_match_set(r_match->key, IP_DST, match.key->dst);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

295

rule_match_set(r_match->mask, IP_DST, match.mask->dst);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

313

rule_match_set(r_match->key, L4_PORT_DST, match.key->dst);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

314

rule_match_set(r_match->mask, L4_PORT_DST, match.mask->dst);

drivers/net/ethernet/marvell/prestera/prestera_flower.c

332

tp_key = htonl(ntohs(match.key->tp_min.dst) |

drivers/net/ethernet/marvell/prestera/prestera_flower.c

333

(ntohs(match.key->tp_max.dst) << 16));

drivers/net/ethernet/marvell/prestera/prestera_flower.c

334

tp_mask = htonl(ntohs(match.mask->tp_min.dst) |

drivers/net/ethernet/marvell/prestera/prestera_flower.c

335

(ntohs(match.mask->tp_max.dst) << 16));

drivers/net/ethernet/marvell/prestera/prestera_hw.c

2062

__be32 dst, u32 dst_len, u32 grp_id)

drivers/net/ethernet/marvell/prestera/prestera_hw.c

2068

.dst.u.ipv4 = dst

drivers/net/ethernet/marvell/prestera/prestera_hw.c

2076

__be32 dst, u32 dst_len)

drivers/net/ethernet/marvell/prestera/prestera_hw.c

2081

.dst.u.ipv4 = dst

drivers/net/ethernet/marvell/prestera/prestera_hw.c

579

struct prestera_msg_ip_addr dst;

drivers/net/ethernet/marvell/prestera/prestera_hw.h

266

__be32 dst, u32 dst_len, u32 grp_id);

drivers/net/ethernet/marvell/prestera/prestera_hw.h

268

__be32 dst, u32 dst_len);

drivers/net/ethernet/marvell/prestera/prestera_router.c

101

key->addr.u.ipv4 = cpu_to_be32(fen_info->dst);

drivers/net/ethernet/marvell/prestera/prestera_router.c

1421

&fib_work->fen_info.dst,

drivers/net/ethernet/marvell/prestera/prestera_router.c

706

fri.dst = fc->key.addr.u.ipv4;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2358

skb_dst_set_noref(skb, &eth->dsa_meta[port]->dst);

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

334

memcpy(data.eth.h_dest, match.key->dst, ETH_ALEN);

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

415

data.dst_port = ports.key->dst;

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

426

data.v4.dst_addr = addrs.key->dst;

drivers/net/ethernet/mediatek/mtk_ppe_offload.c

437

data.v6.dst_addr = addrs.key->dst;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2220

static int mlx4_en_copy_priv(struct mlx4_en_priv *dst,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2226

memcpy(&dst->hwtstamp_config, &prof->hwtstamp_config,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2227

sizeof(dst->hwtstamp_config));

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2228

dst->num_tx_rings_p_up = prof->num_tx_rings_p_up;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2229

dst->rx_ring_num = prof->rx_ring_num;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2230

dst->flags = prof->flags;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2231

dst->mdev = src->mdev;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2232

dst->port = src->port;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2233

dst->dev = src->dev;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2234

dst->prof = prof;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2235

dst->stride = roundup_pow_of_two(sizeof(struct mlx4_en_rx_desc) +

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2239

dst->tx_ring_num[t] = prof->tx_ring_num[t];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2240

if (!dst->tx_ring_num[t])

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2243

dst->tx_ring[t] = kzalloc_objs(struct mlx4_en_tx_ring *,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2245

if (!dst->tx_ring[t])

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2248

dst->tx_cq[t] = kzalloc_objs(struct mlx4_en_cq *, MAX_TX_RINGS);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2249

if (!dst->tx_cq[t]) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2250

kfree(dst->tx_ring[t]);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2259

kfree(dst->tx_ring[t]);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2260

kfree(dst->tx_cq[t]);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2265

static void mlx4_en_update_priv(struct mlx4_en_priv *dst,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2269

memcpy(dst->rx_ring, src->rx_ring,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2271

memcpy(dst->rx_cq, src->rx_cq,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2273

memcpy(&dst->hwtstamp_config, &src->hwtstamp_config,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2274

sizeof(dst->hwtstamp_config));

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2276

dst->tx_ring_num[t] = src->tx_ring_num[t];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2277

dst->tx_ring[t] = src->tx_ring[t];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2278

dst->tx_cq[t] = src->tx_cq[t];

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2280

dst->num_tx_rings_p_up = src->num_tx_rings_p_up;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2281

dst->rx_ring_num = src->rx_ring_num;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2282

memcpy(dst->prof, src->prof, sizeof(struct mlx4_en_port_profile));

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

841

struct list_head *dst,

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

850

list_for_each_entry(dst_tmp, dst, list) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

867

list_for_each_entry(dst_tmp, dst, list) {

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

882

list_add_tail(&new_mc->list, dst);

drivers/net/ethernet/mellanox/mlx4/en_tx.c

740

static void mlx4_bf_copy(void __iomem *dst, const void *src,

drivers/net/ethernet/mellanox/mlx4/en_tx.c

743

__iowrite64_copy(dst, src, bytecnt / 8);

drivers/net/ethernet/mellanox/mlx4/fw.c

1968

u8 *dst = (u8 *)(inbox + INIT_HCA_DRIVER_VERSION_OFFSET / 4);

drivers/net/ethernet/mellanox/mlx4/fw.c

1970

strscpy(dst, DRV_NAME_FOR_FW, INIT_HCA_DRIVER_VERSION_SZ);

drivers/net/ethernet/mellanox/mlx4/fw.c

1971

mlx4_dbg(dev, "Reporting Driver Version to FW: %s\n", dst);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

243

const struct mlx5_flow_destination *dst,

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

248

switch (dst->type) {

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

253

trace_seq_printf(p, "vport=%u\n", dst->vport.num);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

256

trace_seq_printf(p, "ft=%p\n", dst->ft);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

259

trace_seq_printf(p, "ft_num=%u\n", dst->ft_num);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

262

trace_seq_printf(p, "tir=%u\n", dst->tir_num);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

265

trace_seq_printf(p, "sampler_id=%u\n", dst->sampler_id);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

275

fs_dest_range_field_to_str(dst->range.field),

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

276

dst->range.min, dst->range.max);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

279

trace_seq_printf(p, "flow_table_type=%u id:%u\n", dst->ft->type,

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.c

280

dst->ft->id);

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.h

57

#define __parse_fs_dst(dst, counter_id) \

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.h

58

parse_fs_dst(p, (const struct mlx5_flow_destination *)dst, counter_id)

drivers/net/ethernet/mellanox/mlx5/core/diag/fs_tracepoint.h

61

const struct mlx5_flow_destination *dst,

drivers/net/ethernet/mellanox/mlx5/core/en/ptp.h

89

fk.ports.dst == htons(PTP_EV_PORT));

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/vlan.c

78

memcpy(attr->eth.h_dest, act->vlan_push_eth.dst, ETH_ALEN);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

1049

swap(rev_tuple.port.src, rev_tuple.port.dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

132

__be16 dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

1427

tuple->port.dst = flow_keys.ports.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

1436

tuple->ip.dst_v4 = flow_keys.addrs.v4addrs.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

1442

tuple->ip.dst_v6 = flow_keys.addrs.v6addrs.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

2525

(ports.mask->src != htons(0xFFFF) || ports.mask->dst != htons(0xFFFF))) {

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

2527

ports.mask->src, ports.mask->dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

256

tuple->ip.dst_v4 = match.key->dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

262

tuple->ip.dst_v6 = match.key->dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

275

tuple->port.dst = match.key->dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

328

tuple->port.dst = cpu_to_be16(val);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

337

tuple->port.dst = cpu_to_be16(val);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

420

&match.mask->dst, sizeof(match.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

423

&match.key->dst, sizeof(match.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

439

&match.mask->dst, sizeof(match.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

442

&match.key->dst, sizeof(match.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

457

tcp_dport, ntohs(match.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

459

tcp_dport, ntohs(match.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

469

udp_dport, ntohs(match.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

471

udp_dport, ntohs(match.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

147

ret = get_route_and_out_devs(priv, rt->dst.dev, &route_dev, &out_dev);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

153

attr->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

154

n = dst_neigh_lookup(&rt->dst, &attr->fl.fl4.daddr);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

238

attr.fl.fl4.daddr = tun_key->u.ipv4.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

354

attr.fl.fl4.daddr = tun_key->u.ipv4.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

450

struct dst_entry *dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

456

dst = ipv6_stub->ipv6_dst_lookup_flow(dev_net(dev), NULL, &attr->fl.fl6,

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

458

if (IS_ERR(dst))

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

459

return PTR_ERR(dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

462

attr->ttl = ip6_dst_hoplimit(dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

464

ret = get_route_and_out_devs(priv, dst->dev, &route_dev, &out_dev);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

469

n = dst_neigh_lookup(dst, &attr->fl.fl6.daddr);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

475

dst_release(dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

484

dst_release(dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

510

attr.fl.fl6.daddr = tun_key->u.ipv6.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

625

attr.fl.fl6.daddr = tun_key->u.ipv6.dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

871

ntohl(match.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

874

ntohl(match.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

894

&match.mask->dst, MLX5_FLD_SZ_BYTES(ipv6_layout,

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

898

&match.key->dst, MLX5_FLD_SZ_BYTES(ipv6_layout,

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

969

if (memchr_inv(&enc_ports.mask->dst, 0xff,

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

970

sizeof(enc_ports.mask->dst))) {

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

984

ntohs(enc_ports.mask->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c

986

ntohs(enc_ports.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_encap.c

1757

key.endpoint_ip.v4 = htonl(fen_info->dst);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_geneve.c

37

if (be16_to_cpu(enc_ports.key->dst) != GENEVE_UDP_PORT) {

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_geneve.c

42

be16_to_cpu(enc_ports.key->dst));

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_vxlan.c

244

const struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_vxlan.c

246

return dst->remote_ifindex;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_vxlan.c

34

be16_to_cpu(enc_ports.key->dst))) {

drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun_vxlan.c

39

be16_to_cpu(enc_ports.key->dst));

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

272

u8 *dst, *src;

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

282

dst = attrs->smac;

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

303

dst = attrs->dmac;

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

341

rt_dst_entry = &rt->dst;

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

359

ether_addr_copy(dst, addr);

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

377

ether_addr_copy(dst, addr);

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

1700

dst_hold(&rx_sc->md_dst->dst);

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

1701

skb_dst_set(skb, &rx_sc->md_dst->dst);

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

615

struct mlx5_flow_destination dst = {};

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

618

dst.type = MLX5_FLOW_DESTINATION_TYPE_TIR;

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

619

dst.tir_num = mlx5e_rx_res_get_tirn_direct(priv->rx_res, rxq);

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

620

err = mlx5_modify_rule_destination(rule, &dst, NULL);

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

679

tuple->dst_ipv4 = fk->addrs.v4addrs.dst;

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

683

memcpy(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,

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

687

tuple->dst_port = fk->ports.dst;

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

700

if (tuple->src_port != fk->ports.src || tuple->dst_port != fk->ports.dst)

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

706

tuple->dst_ipv4 == fk->addrs.v4addrs.dst;

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

710

!memcmp(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,

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

721

head = arfs_hash_bucket(arfs_t, fk->ports.src, fk->ports.dst);

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

463

struct mlx5_flow_destination *dst = NULL;

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

479

dst = kzalloc_obj(*dst);

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

480

if (!dst) {

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

485

err = flow_get_tirn(priv, eth_rule, fs, rss_context, &dst->tir_num);

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

489

dst->type = MLX5_FLOW_DESTINATION_TYPE_TIR;

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

495

rule = mlx5_add_flow_rules(ft, spec, &flow_act, dst, dst ? 1 : 0);

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

504

kfree(dst);

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

2239

#define COPY_DISSECTOR(rule, diss_key, dst)\

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

2242

typeof(dst) __dst = dst;\

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

2905

match.mask->dst);

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

2908

match.key->dst);

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

2918

!is_zero_ether_addr(match.mask->dst))

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

2973

&match.mask->dst, sizeof(match.mask->dst));

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

2976

&match.key->dst, sizeof(match.key->dst));

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

2978

if (match.mask->src || match.mask->dst)

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

2995

&match.mask->dst, sizeof(match.mask->dst));

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

2998

&match.key->dst, sizeof(match.key->dst));

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

3001

ipv6_addr_type(&match.mask->dst) != IPV6_ADDR_ANY)

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

3052

tcp_dport, ntohs(match.mask->dst));

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

3054

tcp_dport, ntohs(match.key->dst));

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

3064

udp_dport, ntohs(match.mask->dst));

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

3066

udp_dport, ntohs(match.key->dst));

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

3076

if (match.mask->src || match.mask->dst)

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

5637

tun_dst = __ip_tun_set_dst(key.enc_ipv4.src, key.enc_ipv4.dst,

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

5639

key.enc_tp.dst, flags,

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

5644

tun_dst = __ipv6_tun_set_dst(&key.enc_ipv6.src, &key.enc_ipv6.dst,

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

5646

key.enc_tp.dst, 0, flags,

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/egress_lgcy.c

139

dst = &drop_ctr_dst;

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/egress_lgcy.c

144

&flow_act, dst, dest_num);

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/egress_lgcy.c

72

struct mlx5_flow_destination *dst = NULL;

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/ingress_lgcy.c

144

struct mlx5_flow_destination *dst = NULL;

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/ingress_lgcy.c

264

dst = &drop_ctr_dst;

drivers/net/ethernet/mellanox/mlx5/core/esw/acl/ingress_lgcy.c

269

&flow_act, dst, dest_num);

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

2376

struct mlx5_flow_destination *dst = NULL;

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

2416

dst = &drop_fc_dst;

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

2420

flow_rule = mlx5_add_flow_rules(table, NULL, &flow_act, dst, dst_num);

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

2432

table->id, dst ? dst->counter->id : 0);

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

180

struct mlx5_flow_act *dst)

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

184

dst->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH;

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

185

memcpy(&dst->vlan[0], &src->vlan[0], sizeof(src->vlan[0]));

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

190

dst->action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2;

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

191

memcpy(&dst->vlan[1], &src->vlan[1], sizeof(src->vlan[1]));

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

487

struct mlx5_flow_rule *dst;

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

494

list_for_each_entry(dst, &fte->node.children, node.list) {

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

495

if (dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_COUNTER ||

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

496

dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_NONE)

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

498

if ((dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_VPORT ||

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

499

dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_UPLINK) &&

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

500

dst->dest_attr.vport.flags & MLX5_FLOW_DEST_VPORT_REFORMAT_ID)

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

551

struct mlx5_flow_rule *dst;

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

662

list_for_each_entry(dst, &fte->node.children, node.list) {

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

663

enum mlx5_flow_destination_type type = dst->dest_attr.type;

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

674

id = dst->dest_attr.ft_num;

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

678

id = dst->dest_attr.ft->id;

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

685

!!(dst->dest_attr.vport.flags &

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

689

dst->dest_attr.vport.vhca_id);

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

697

id = dst->dest_attr.vport.num;

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

699

dst->dest_attr.vport.pkt_reformat) {

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

702

!!(dst->dest_attr.vport.flags &

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

706

dst->dest_attr.vport.pkt_reformat->id);

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

710

id = dst->dest_attr.sampler_id;

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

715

destination_table_type, dst->dest_attr.ft->type);

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

716

id = dst->dest_attr.ft->id;

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

720

id = dst->dest_attr.tir_num;

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

741

list_for_each_entry(dst, &fte->node.children, node.list) {

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

742

if (dst->dest_attr.type !=

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

747

mlx5_fc_id(dst->dest_attr.counter));

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

1591

static int dst = BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST);

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

1625

act_dests->modify_mask |= type ? count : dst;

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

1650

static int dst = BIT(MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST);

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

1689

*modify_mask |= type ? count : dst;

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

108

static void mlx5_lag_fib_set(struct lag_mp *mp, struct fib_info *fi, u32 dst, int dst_len)

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

112

mp->fib.dst = dst;

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

177

(mp->fib.dst != fen_info->dst || mp->fib.dst_len != fen_info->dst_len) &&

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

191

if (mp->fib.dst == fen_info->dst && mp->fib.dst_len == fen_info->dst_len)

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

210

mlx5_lag_fib_set(mp, fi, fen_info->dst, fen_info->dst_len);

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.c

225

mlx5_lag_fib_set(mp, fi, fen_info->dst, fen_info->dst_len);

drivers/net/ethernet/mellanox/mlx5/core/lag/mp.h

21

u32 dst;

drivers/net/ethernet/mellanox/mlx5/core/lib/crypto.c

114

void *dst;

drivers/net/ethernet/mellanox/mlx5/core/lib/crypto.c

126

dst = MLX5_ADDR_OF(encryption_key_obj, key_obj, key[1]);

drivers/net/ethernet/mellanox/mlx5/core/lib/crypto.c

128

dst = MLX5_ADDR_OF(encryption_key_obj, key_obj, key);

drivers/net/ethernet/mellanox/mlx5/core/lib/crypto.c

130

memcpy(dst, key, sz_bytes);

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

136

struct mlx5_flow_destination dst = {};

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

150

dst.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

151

dst.ft = roce->goto_alias_ft;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

153

dst.type = MLX5_FLOW_DESTINATION_TYPE_TABLE_TYPE;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

154

dst.ft = roce->ft_rdma;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

156

rule = mlx5_add_flow_rules(roce->ft, spec, &flow_act, &dst, 1);

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

185

dst.type = MLX5_FLOW_DESTINATION_TYPE_TABLE_TYPE;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

186

dst.ft = roce->ft_rdma;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

187

rule = mlx5_add_flow_rules(roce->nic_master_ft, NULL, &flow_act, &dst,

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

213

struct mlx5_flow_destination dst = {};

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

219

dst.type = MLX5_FLOW_DESTINATION_TYPE_TABLE_TYPE;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

220

dst.ft = pol_ft;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

221

rule = mlx5_add_flow_rules(roce->ft, NULL, &flow_act, &dst,

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

239

struct mlx5_flow_destination dst = {};

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

255

dst.type = MLX5_FLOW_DESTINATION_TYPE_TABLE_TYPE;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

256

dst.ft = roce->goto_alias_ft;

drivers/net/ethernet/mellanox/mlx5/core/lib/ipsec_fs_roce.c

257

rule = mlx5_add_flow_rules(roce->ft, spec, &flow_act, &dst, 1);

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

1323

struct mlx5_flow_destination dst = {};

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

1359

dst.type = MLX5_FLOW_DESTINATION_TYPE_TABLE_TYPE;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

1360

dst.ft = roce->ft_ip_check;

drivers/net/ethernet/mellanox/mlx5/core/lib/macsec_fs.c

1361

rule = mlx5_add_flow_rules(roce->ft, spec, &flow_act, &dst, 1);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2137

void mlx5hws_action_prepare_decap_l3_data(u8 *src, u8 *dst, u16 num_of_actions)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2152

dst += MLX5HWS_ACTION_DOUBLE_SIZE;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2154

dst += MLX5HWS_ACTION_DOUBLE_SIZE / 2;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2162

memcpy(dst, e_src, MLX5HWS_ACTION_INLINE_DATA_SIZE); /* data */

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2163

dst += MLX5HWS_ACTION_DOUBLE_SIZE;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2167

dst += MLX5HWS_ACTION_INLINE_DATA_SIZE / 2;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.c

2168

memcpy(dst, e_src, 2);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/action.h

216

void mlx5hws_action_prepare_decap_l3_data(u8 *src, u8 *dst,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

385

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

387

return xa_load(&fs_ctx->hws_pool.table_dests, dst->dest_attr.ft->id);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

392

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

394

u32 table_num = dst->dest_attr.ft_num;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

401

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

405

u32 table_num = dst->dest_attr.ft_num;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

412

struct mlx5_flow_rule *dst,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

416

struct mlx5_flow_destination *dest_attr = &dst->dest_attr;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

458

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

461

struct mlx5_flow_destination *dest_attr = &dst->dest_attr;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

538

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

543

u32 id = dst->dest_attr.sampler_id;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

756

struct mlx5_flow_rule *dst;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

876

list_for_each_entry(dst, &fte->node.children, node.list) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

879

if (dst->dest_attr.type !=

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

888

counter = dst->dest_attr.counter;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

949

list_for_each_entry(dst, &fte->node.children, node.list) {

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

950

struct mlx5_flow_destination *attr = &dst->dest_attr;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

964

dest_action = mlx5_fs_get_dest_action_ft(fs_ctx, dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

965

if (dst->dest_attr.ft->flags &

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

971

dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

975

dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

979

dest_action = mlx5_fs_create_dest_action_range(ctx, dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

984

dest_action = mlx5_fs_get_dest_action_vport(fs_ctx, dst,

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

990

dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/fs_hws.c

993

dst->dest_attr.sampler_id;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

930

union mlx5hws_matcher_size *dst = &col_matcher->attr.size[i];

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

933

dst->table.sz_row_log = src->rule.num_log;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

934

dst->table.sz_col_log = MLX5HWS_MATCHER_ASSURED_COL_TBL_DEPTH;

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

935

if (dst->table.sz_row_log > MLX5HWS_MATCHER_ASSURED_ROW_RATIO)

drivers/net/ethernet/mellanox/mlx5/core/steering/hws/matcher.c

936

dst->table.sz_row_log -=

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

185

static void dr_ste_replace(struct mlx5dr_ste *dst, struct mlx5dr_ste *src)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

187

memcpy(mlx5dr_ste_get_hw_ste(dst), mlx5dr_ste_get_hw_ste(src),

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

189

dst->next_htbl = src->next_htbl;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

190

if (dst->next_htbl)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

191

dst->next_htbl->pointing_ste = dst;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

193

dst->refcount = src->refcount;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

374

bool mlx5dr_ste_equal_tag(void *src, void *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_ste.c

377

struct dr_hw_ste_format *d_hw_ste = (struct dr_hw_ste_format *)dst;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/dr_types.h

375

bool mlx5dr_ste_equal_tag(void *src, void *dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

181

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

183

struct mlx5_flow_destination *dest_attr = &dst->dest_attr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

192

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

194

struct mlx5_flow_destination *dest_attr = &dst->dest_attr;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

201

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

203

struct mlx5_flow_table *dest_ft = dst->dest_attr.ft;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

218

struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

221

dst->dest_attr.range.field,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

222

dst->dest_attr.range.hit_ft,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

223

dst->dest_attr.range.miss_ft,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

224

dst->dest_attr.range.min,

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

225

dst->dest_attr.range.max);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

240

static bool contain_vport_reformat_action(struct mlx5_flow_rule *dst)

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

242

return (dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_VPORT ||

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

243

dst->dest_attr.type == MLX5_FLOW_DESTINATION_TYPE_UPLINK) &&

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

244

dst->dest_attr.vport.flags & MLX5_FLOW_DEST_VPORT_REFORMAT_ID;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

267

struct mlx5_flow_rule *dst;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

301

list_for_each_entry(dst, &fte->node.children, node.list) {

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

302

if (!contain_vport_reformat_action(dst))

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

426

list_for_each_entry(dst, &fte->node.children, node.list) {

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

427

enum mlx5_flow_destination_type type = dst->dest_attr.type;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

441

tmp_action = create_ft_action(domain, dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

452

create_vport_action(domain, dst) :

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

453

create_uplink_action(domain, dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

461

if (dst->dest_attr.vport.flags &

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

463

pkt_reformat = dst->dest_attr.vport.pkt_reformat;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

471

id = dst->dest_attr.ft_num;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

482

id = dst->dest_attr.sampler_id;

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

493

tmp_action = create_range_action(domain, dst);

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

509

list_for_each_entry(dst, &fte->node.children, node.list) {

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

512

if (dst->dest_attr.type !=

drivers/net/ethernet/mellanox/mlx5/core/steering/sws/fs_dr.c

522

id = mlx5_fc_id(dst->dest_attr.counter);

drivers/net/ethernet/mellanox/mlxsw/item.h

178

static inline void __mlxsw_item_memcpy_from(const char *buf, char *dst,

drivers/net/ethernet/mellanox/mlxsw/item.h

184

memcpy(dst, &buf[offset], item->size.bytes);

drivers/net/ethernet/mellanox/mlxsw/item.h

485

mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(const char *buf, char *dst) \

drivers/net/ethernet/mellanox/mlxsw/item.h

487

__mlxsw_item_memcpy_from(buf, dst, \

drivers/net/ethernet/mellanox/mlxsw/item.h

514

char *dst) \

drivers/net/ethernet/mellanox/mlxsw/item.h

516

__mlxsw_item_memcpy_from(buf, dst, \

drivers/net/ethernet/mellanox/mlxsw/reg.h

2896

MLXSW_ITEM32(reg, pprr, dst, 0x00, 28, 1);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

377

(char *) &match.key->dst,

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

378

(char *) &match.mask->dst, 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

401

&match.key->dst.s6_addr[0x0],

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

402

&match.mask->dst.s6_addr[0x0], 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

404

&match.key->dst.s6_addr[0x4],

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

405

&match.mask->dst.s6_addr[0x4], 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

407

&match.key->dst.s6_addr[0x8],

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

408

&match.mask->dst.s6_addr[0x8], 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

410

&match.key->dst.s6_addr[0xC],

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

411

&match.mask->dst.s6_addr[0xC], 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

433

ntohs(match.key->dst),

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

434

ntohs(match.mask->dst));

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

479

if (match.mask->tp_min.dst) {

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

481

.min = ntohs(match.key->tp_min.dst),

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

482

.max = ntohs(match.key->tp_max.dst),

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

642

match.key->dst,

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

643

match.mask->dst, 2);

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

646

match.key->dst + 2,

drivers/net/ethernet/mellanox/mlxsw/spectrum_flower.c

647

match.mask->dst + 2, 4);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

5996

u32 *p_dst = (u32 *) &fen_info->dst;

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6001

fri.dst = cpu_to_be32(*p_dst);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6026

fri.dst = cpu_to_be32(*p_dst);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6049

fri.dst = cpu_to_be32(*p_dst);

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6401

union mlxsw_sp_l3addr dip = { .addr4 = htonl(fen_info->dst) };

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6546

fib_node = mlxsw_sp_fib_node_lookup(fib, &fen_info->dst,

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6547

sizeof(fen_info->dst),

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c

6825

&fen_info->dst, sizeof(fen_info->dst),

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

435

dev = rt->dst.dev;

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

528

struct dst_entry *dst;

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

538

dst = ip6_route_output(t->net, NULL, &fl6);

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

539

if (!dst || dst->error)

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

542

rt6 = dst_rt6_info(dst);

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

544

dev = dst->dev;

drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

549

dst_release(dst);

drivers/net/ethernet/meta/fbnic/fbnic_tlv.c

251

ssize_t fbnic_tlv_attr_get_string(struct fbnic_tlv_msg *attr, char *dst,

drivers/net/ethernet/meta/fbnic/fbnic_tlv.c

275

memcpy(dst, &attr->value, len);

drivers/net/ethernet/meta/fbnic/fbnic_tlv.c

277

memset(dst + len, 0, dstsize - len);

drivers/net/ethernet/meta/fbnic/fbnic_tlv.h

119

ssize_t fbnic_tlv_attr_get_string(struct fbnic_tlv_msg *attr, char *dst,

drivers/net/ethernet/microchip/lan966x/lan966x_mac.c

339

struct lan966x_port *dst)

drivers/net/ethernet/microchip/lan966x/lan966x_mac.c

351

lan966x_mac_learn_locked(lan966x, dst->chip_port,

drivers/net/ethernet/microchip/lan966x/lan966x_mac.c

354

mac_entry->port_index = dst->chip_port;

drivers/net/ethernet/microchip/lan966x/lan966x_main.h

489

struct lan966x_port *dst);

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

102

out->prf(out->dst, "normal");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

105

out->prf(out->dst, "7tuple");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

108

out->prf(out->dst, "dbl_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

111

out->prf(out->dst, "dmac_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

114

out->prf(out->dst, "follow_other");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

117

out->prf(out->dst, "-");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

122

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

132

out->prf(out->dst, " port[%d] (%s): ", port->chip_port,

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

136

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

138

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

140

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

143

out->prf(out->dst, "\n Lookup %d: ", l);

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

145

out->prf(out->dst, "\n snap: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

147

out->prf(out->dst, "mac_llc");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

149

out->prf(out->dst, "mac_snap");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

15

out->prf(out->dst, " port[%d] (%s): ", port->chip_port,

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

151

out->prf(out->dst, "\n oam: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

153

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

155

out->prf(out->dst, "mac_oam");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

157

out->prf(out->dst, "\n arp: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

159

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

161

out->prf(out->dst, "mac_arp");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

163

out->prf(out->dst, "\n ipv4_other: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

165

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

167

out->prf(out->dst, "ip4_other");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

169

out->prf(out->dst, "\n ipv4_tcp_udp: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

171

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

173

out->prf(out->dst, "ipv4_tcp_udp");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

175

out->prf(out->dst, "\n ipv6: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

178

out->prf(out->dst, "ipv6_tcp_udp ipv6_tcp_udp");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

181

out->prf(out->dst, "ipv6_std");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

184

out->prf(out->dst, "ipv4_tcp_udp ipv4_tcp_udp");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

187

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

19

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

192

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

202

out->prf(out->dst, " port[%d] (%s): ", port->chip_port,

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

206

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

208

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

21

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

210

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

212

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

227

out->prf(out->dst, "%s:\n", vcap->name);

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

23

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

239

out->prf(out->dst, " no info\n");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

26

out->prf(out->dst, "\n Lookup %d: ", l);

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

30

out->prf(out->dst, "\n other: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

33

out->prf(out->dst, "normal");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

36

out->prf(out->dst, "7tuple");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

39

out->prf(out->dst, "dbl_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

42

out->prf(out->dst, "dmac_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

45

out->prf(out->dst, "-");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

49

out->prf(out->dst, "\n ipv4: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

52

out->prf(out->dst, "normal");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

55

out->prf(out->dst, "7tuple");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

58

out->prf(out->dst, "5tuple_ipv4");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

61

out->prf(out->dst, "dbl_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

64

out->prf(out->dst, "dmac_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

67

out->prf(out->dst, "-");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

71

out->prf(out->dst, "\n ipv6: ");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

74

out->prf(out->dst, "normal");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

77

out->prf(out->dst, "7tuple");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

80

out->prf(out->dst, "5tuple_ip4");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

83

out->prf(out->dst, "normal_ip6");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

86

out->prf(out->dst, "5tuple_ip6");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

89

out->prf(out->dst, "dbl_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

92

out->prf(out->dst, "dmac_vid");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

95

out->prf(out->dst, "-");

drivers/net/ethernet/microchip/lan966x/lan966x_vcap_debugfs.c

99

out->prf(out->dst, "\n rt: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

101

out->prf(out->dst, "\n ipv4: %s",

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

104

out->prf(out->dst, "\n ipv6: %s",

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

107

out->prf(out->dst, "\n mpls_uc: %s",

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

110

out->prf(out->dst, "\n mpls_mc: %s",

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

113

out->prf(out->dst, "\n mlbs: %s",

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

116

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

127

out->prf(out->dst, " port[%02d] (%s): ", port->portno,

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

130

out->prf(out->dst, "\n Lookup %d: ", lookup);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

134

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

136

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

138

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

144

out->prf(out->dst, "\n noneth: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

147

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

150

out->prf(out->dst, "custom1");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

153

out->prf(out->dst, "custom2");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

156

out->prf(out->dst, "none");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

159

out->prf(out->dst, "\n ipv4_mc: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

162

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

165

out->prf(out->dst, "ip4_tcp_udp ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

168

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

171

out->prf(out->dst, "ip4_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

174

out->prf(out->dst, "\n ipv4_uc: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

177

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

180

out->prf(out->dst, "ip4_tcp_udp ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

183

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

186

out->prf(out->dst, "\n ipv6_mc: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

189

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

192

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

195

out->prf(out->dst, "ip6_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

198

out->prf(out->dst, "ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

201

out->prf(out->dst, "ip4_tcp_udp ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

204

out->prf(out->dst, "\n ipv6_uc: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

207

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

210

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

213

out->prf(out->dst, "ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

216

out->prf(out->dst, "ip4_tcp_udp ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

219

out->prf(out->dst, "\n arp: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

222

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

225

out->prf(out->dst, "arp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

229

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

239

out->prf(out->dst, " Sticky bits: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

241

out->prf(out->dst, "\n Lookup %d: ", lookup);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

246

out->prf(out->dst, " sel_clm");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

248

out->prf(out->dst, " sel_irleg");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

250

out->prf(out->dst, " sel_erleg");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

252

out->prf(out->dst, " sel_port");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

254

out->prf(out->dst, " custom2");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

256

out->prf(out->dst, " custom1");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

258

out->prf(out->dst, " oam");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

260

out->prf(out->dst, " ip6_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

262

out->prf(out->dst, " ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

264

out->prf(out->dst, " ip6_tcpudp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

266

out->prf(out->dst, " ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

268

out->prf(out->dst, " ip4_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

270

out->prf(out->dst, " ip4_tcpudp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

272

out->prf(out->dst, " ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

274

out->prf(out->dst, " arp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

276

out->prf(out->dst, " mac_snap");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

278

out->prf(out->dst, " mac_llc");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

280

out->prf(out->dst, " mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

284

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

294

out->prf(out->dst, " port[%02d] (%s): ", port->portno,

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

296

out->prf(out->dst, "\n Lookup 0: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

300

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

302

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

304

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

306

out->prf(out->dst, "\n keyset: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

310

out->prf(out->dst, "normal");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

313

out->prf(out->dst, "isdx");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

316

out->prf(out->dst, "vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

319

out->prf(out->dst, "reserved");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

322

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

333

out->prf(out->dst, " port[%02d] (%s): ", port->portno,

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

336

out->prf(out->dst, "\n Lookup %d: ", lookup);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

341

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

343

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

345

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

347

out->prf(out->dst, "\n arp: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

350

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

353

out->prf(out->dst, "arp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

356

out->prf(out->dst, "\n ipv4: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

359

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

362

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

365

out->prf(out->dst, "ip4_tcp_udp ip4_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

368

out->prf(out->dst, "ip4_tcp_udp ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

371

out->prf(out->dst, "ip4_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

374

out->prf(out->dst, "ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

377

out->prf(out->dst, "\n ipv6: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

380

out->prf(out->dst, "mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

383

out->prf(out->dst, "ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

386

out->prf(out->dst, "ip_7tuple ip6_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

389

out->prf(out->dst, "ip_7tuple ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

392

out->prf(out->dst, "ip6_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

395

out->prf(out->dst, "ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

398

out->prf(out->dst, "ip4_downgrade");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

402

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

412

out->prf(out->dst, " Sticky bits: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

415

out->prf(out->dst, "\n Lookup %d: ", lookup);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

417

out->prf(out->dst, " ip_7tuple");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

419

out->prf(out->dst, " ip6_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

421

out->prf(out->dst, " ip6_std");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

423

out->prf(out->dst, " ip4_tcp_udp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

425

out->prf(out->dst, " ip4_vid");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

427

out->prf(out->dst, " ip4_other");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

429

out->prf(out->dst, " arp");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

431

out->prf(out->dst, " mac_etype");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

435

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

450

out->prf(out->dst, "%s:\n", vcap->name);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

467

out->prf(out->dst, " no info\n");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

84

out->prf(out->dst, " port[%02d] (%s): ", port->portno,

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

87

out->prf(out->dst, "\n Lookup %d: ", lookup);

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

92

out->prf(out->dst, "\n state: ");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

94

out->prf(out->dst, "on");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

96

out->prf(out->dst, "off");

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_debugfs.c

98

out->prf(out->dst, "\n etype: %s",

drivers/net/ethernet/microchip/vcap/vcap_api.c

1052

static void vcap_apply_width(u8 *dst, int width, int bytes)

drivers/net/ethernet/microchip/vcap/vcap_api.c

1065

dst[idx] &= bmask;

drivers/net/ethernet/microchip/vcap/vcap_api.c

1070

static void vcap_copy_from_w32be(u8 *dst, u8 *src, int size, int width)

drivers/net/ethernet/microchip/vcap/vcap_api.c

1080

dst[nidx] = src[ridx];

drivers/net/ethernet/microchip/vcap/vcap_api.c

1083

vcap_apply_width(dst, width, size);

drivers/net/ethernet/microchip/vcap/vcap_api.c

2937

void vcap_netbytes_copy(u8 *dst, u8 *src, int count)

drivers/net/ethernet/microchip/vcap/vcap_api.c

2941

for (idx = 0; idx < count; ++idx, ++dst)

drivers/net/ethernet/microchip/vcap/vcap_api.c

2942

*dst = src[count - idx - 1];

drivers/net/ethernet/microchip/vcap/vcap_api.c

517

static void vcap_copy_to_w32be(u8 *dst, const u8 *src, int size)

drivers/net/ethernet/microchip/vcap/vcap_api.c

527

dst[nidx] = src[idx];

drivers/net/ethernet/microchip/vcap/vcap_api.c

533

struct vcap_client_keyfield *dst,

drivers/net/ethernet/microchip/vcap/vcap_api.c

541

dst->ctrl.type = src->ctrl.type;

drivers/net/ethernet/microchip/vcap/vcap_api.c

542

dst->ctrl.key = src->ctrl.key;

drivers/net/ethernet/microchip/vcap/vcap_api.c

543

INIT_LIST_HEAD(&dst->ctrl.list);

drivers/net/ethernet/microchip/vcap/vcap_api.c

545

ddata = &dst->data;

drivers/net/ethernet/microchip/vcap/vcap_api.c

548

memcpy(ddata, sdata, sizeof(dst->data));

drivers/net/ethernet/microchip/vcap/vcap_api.c

552

size = keyfield_size_table[dst->ctrl.type] / 2;

drivers/net/ethernet/microchip/vcap/vcap_api.c

554

switch (dst->ctrl.type) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

557

memcpy(ddata, sdata, sizeof(dst->data));

drivers/net/ethernet/microchip/vcap/vcap_api.c

588

struct vcap_client_actionfield *dst,

drivers/net/ethernet/microchip/vcap/vcap_api.c

596

dst->ctrl.type = src->ctrl.type;

drivers/net/ethernet/microchip/vcap/vcap_api.c

597

dst->ctrl.action = src->ctrl.action;

drivers/net/ethernet/microchip/vcap/vcap_api.c

598

INIT_LIST_HEAD(&dst->ctrl.list);

drivers/net/ethernet/microchip/vcap/vcap_api.c

600

ddata = &dst->data;

drivers/net/ethernet/microchip/vcap/vcap_api.c

603

memcpy(ddata, sdata, sizeof(dst->data));

drivers/net/ethernet/microchip/vcap/vcap_api.c

607

size = actionfield_size_table[dst->ctrl.type];

drivers/net/ethernet/microchip/vcap/vcap_api.c

609

switch (dst->ctrl.type) {

drivers/net/ethernet/microchip/vcap/vcap_api.c

612

memcpy(ddata, sdata, sizeof(dst->data));

drivers/net/ethernet/microchip/vcap/vcap_api.h

216

void *dst;

drivers/net/ethernet/microchip/vcap/vcap_api_client.h

239

void vcap_netbytes_copy(u8 *dst, u8 *src, int count);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

106

out->prf(out->dst, "0x");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

108

out->prf(out->dst, "%02x", value[bytes - idx - 1]);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

109

out->prf(out->dst, "/0x");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

111

out->prf(out->dst, "%02x", mask[bytes - idx - 1]);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

113

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

127

out->prf(out->dst, " %s: W%d: ",

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

133

out->prf(out->dst, "%d", value[0]);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

138

out->prf(out->dst, "%u", val & fmsk);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

151

out->prf(out->dst, "0x");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

153

out->prf(out->dst, "%02x", value[bytes - idx - 1]);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

155

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

183

out->prf(out->dst, " keysets:");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

185

out->prf(out->dst, " %s",

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

187

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

200

out->prf(out->dst, " keyset_sw: %d\n", ri->keyset_sw);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

201

out->prf(out->dst, " keyset_sw_regs: %d\n", ri->keyset_sw_regs);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

220

out->prf(out->dst, " actionset: %s\n",

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

222

out->prf(out->dst, " actionset_sw: %d\n", ri->actionset_sw);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

223

out->prf(out->dst, " actionset_sw_regs: %d\n", ri->actionset_sw_regs);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

243

out->prf(out->dst,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

247

out->prf(out->dst, " chain_id: %d\n", ri->data.vcap_chain_id);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

248

out->prf(out->dst, " user: %d\n", ri->data.user);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

249

out->prf(out->dst, " priority: %d\n", ri->data.priority);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

250

out->prf(out->dst, " state: ");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

253

out->prf(out->dst, "permanent\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

256

out->prf(out->dst, "disabled\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

259

out->prf(out->dst, "enabled\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

272

out->prf(out->dst, "name: %s\n", vcap->name);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

273

out->prf(out->dst, "rows: %d\n", vcap->rows);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

274

out->prf(out->dst, "sw_count: %d\n", vcap->sw_count);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

275

out->prf(out->dst, "sw_width: %d\n", vcap->sw_width);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

276

out->prf(out->dst, "sticky_width: %d\n", vcap->sticky_width);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

277

out->prf(out->dst, "act_width: %d\n", vcap->act_width);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

278

out->prf(out->dst, "default_cnt: %d\n", vcap->default_cnt);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

279

out->prf(out->dst, "require_cnt_dis: %d\n", vcap->require_cnt_dis);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

280

out->prf(out->dst, "version: %d\n", vcap->version);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

281

out->prf(out->dst, "vtype: %d\n", admin->vtype);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

282

out->prf(out->dst, "vinst: %d\n", admin->vinst);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

283

out->prf(out->dst, "ingress: %d\n", admin->ingress);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

284

out->prf(out->dst, "first_cid: %d\n", admin->first_cid);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

285

out->prf(out->dst, "last_cid: %d\n", admin->last_cid);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

286

out->prf(out->dst, "lookups: %d\n", admin->lookups);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

287

out->prf(out->dst, "first_valid_addr: %d\n", admin->first_valid_addr);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

288

out->prf(out->dst, "last_valid_addr: %d\n", admin->last_valid_addr);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

289

out->prf(out->dst, "last_used_addr: %d\n", admin->last_used_addr);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

308

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

32

out->prf(out->dst, " %s: W%d: ", vcap_keyfield_name(vctrl, key),

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

354

out->prf(out->dst, " addr: %d, X%d rule, keysets:",

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

358

out->prf(out->dst, " %s",

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

361

out->prf(out->dst, "\n");

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

37

out->prf(out->dst, "%d/%d", data->u1.value, data->u1.mask);

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

374

.dst = m,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

409

.dst = m,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

426

.dst = m,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

44

out->prf(out->dst, "%pI4h/%pI4h", &data->u32.value,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

55

out->prf(out->dst, "%u/%u", data->u32.value & fmsk,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

63

out->prf(out->dst, "%pMR/%pMR", data->u48.value,

drivers/net/ethernet/microchip/vcap/vcap_api_debugfs.c

98

out->prf(out->dst, "%pI6/%pI6", nvalue, nmask);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

118

if (!ipv6_addr_any(&mt.mask->dst)) {

drivers/net/ethernet/microchip/vcap/vcap_tc.c

119

vcap_netbytes_copy(dip.value, mt.key->dst.s6_addr, 16);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

120

vcap_netbytes_copy(dip.mask, mt.mask->dst.s6_addr, 16);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

152

if (mt.mask->dst) {

drivers/net/ethernet/microchip/vcap/vcap_tc.c

153

value = be16_to_cpu(mt.key->dst);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

154

mask = be16_to_cpu(mt.mask->dst);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

45

if (!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/microchip/vcap/vcap_tc.c

46

vcap_netbytes_copy(dmac.value, match.key->dst, ETH_ALEN);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

47

vcap_netbytes_copy(dmac.mask, match.mask->dst, ETH_ALEN);

drivers/net/ethernet/microchip/vcap/vcap_tc.c

79

if (mt.mask->dst) {

drivers/net/ethernet/microchip/vcap/vcap_tc.c

82

be32_to_cpu(mt.key->dst),

drivers/net/ethernet/microchip/vcap/vcap_tc.c

83

be32_to_cpu(mt.mask->dst));

drivers/net/ethernet/mscc/ocelot.c

1526

u32 val, dst, macl, mach;

drivers/net/ethernet/mscc/ocelot.c

1549

dst = (val & ANA_TABLES_MACACCESS_DEST_IDX_M) >> 3;

drivers/net/ethernet/mscc/ocelot.c

1550

if (dst != port)

drivers/net/ethernet/mscc/ocelot_flower.c

682

!is_zero_ether_addr(match.mask->dst)) {

drivers/net/ethernet/mscc/ocelot_flower.c

690

match.key->dst);

drivers/net/ethernet/mscc/ocelot_flower.c

694

match.mask->dst);

drivers/net/ethernet/mscc/ocelot_flower.c

747

if (filter->block_id == VCAP_IS1 && *(u32 *)&match.mask->dst) {

drivers/net/ethernet/mscc/ocelot_flower.c

760

memcpy(tmp, &match.key->dst, 4);

drivers/net/ethernet/mscc/ocelot_flower.c

763

memcpy(tmp, &match.mask->dst, 4);

drivers/net/ethernet/mscc/ocelot_flower.c

784

filter->key.ipv4.dport.value = ntohs(match.key->dst);

drivers/net/ethernet/mscc/ocelot_flower.c

785

filter->key.ipv4.dport.mask = ntohs(match.mask->dst);

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

1173

myri10ge_submit_8rx(struct mcp_kreq_ether_recv __iomem * dst,

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

1180

myri10ge_pio_copy(dst, src, 4 * sizeof(*src));

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

1182

myri10ge_pio_copy(dst + 4, src + 4, 4 * sizeof(*src));

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

1185

put_be32(low, &dst->addr_low);

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

2567

struct mcp_kreq_ether_send __iomem *dstp, *dst;

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

2576

dst = dstp = &tx->lanai[idx];

drivers/net/ethernet/myricom/myri10ge/myri10ge.c

2600

put_be32(*((__be32 *) src + 3), (__be32 __iomem *) dst + 3);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1020

wrp_lmem_load(struct nfp_prog *nfp_prog, u8 dst, u8 dst_byte, s32 off,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1038

wrp_mov(nfp_prog, reg_both(dst),

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1080

emit_ld_field_any(nfp_prog, reg_both(dst), mask, reg, sc, shf, new_gpr);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1265

wrp_alu_imm(struct nfp_prog *nfp_prog, u8 dst, enum alu_op alu_op, u32 imm)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1271

wrp_immed(nfp_prog, reg_both(dst), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1277

wrp_immed(nfp_prog, reg_both(dst), ~0U);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1283

emit_alu(nfp_prog, reg_both(dst), reg_none(),

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1284

ALU_OP_NOT, reg_b(dst));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1290

emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, tmp_reg);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1315

u8 dst = meta->insn.dst_reg * 2, src = meta->insn.src_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1317

emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, reg_b(src));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1318

emit_alu(nfp_prog, reg_both(dst + 1),

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1319

reg_a(dst + 1), alu_op, reg_b(src + 1));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1329

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1331

wrp_alu_imm(nfp_prog, dst, alu_op, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1332

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1341

u8 dst = meta->insn.dst_reg * 2, src = meta->insn.src_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1343

emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, reg_b(src));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1344

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1350

wrp_test_reg_one(struct nfp_prog *nfp_prog, u8 dst, enum alu_op alu_op, u8 src,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1353

emit_alu(nfp_prog, reg_none(), reg_a(dst), alu_op, reg_b(src));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1532

static int wrp_div_imm(struct nfp_prog *nfp_prog, u8 dst, u64 imm)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1534

swreg dst_both = reg_both(dst), dst_a = reg_a(dst), dst_b = reg_a(dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1839

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1848

emit_alu(nfp_prog, reg_both(dst), stack_reg(nfp_prog),

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1850

wrp_immed(nfp_prog, reg_both(dst + 1), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1852

wrp_reg_mov(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1853

wrp_reg_mov(nfp_prog, dst + 1, src + 1);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

1996

static int __shl_imm64(struct nfp_prog *nfp_prog, u8 dst, u8 shift_amt)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2002

emit_shf(nfp_prog, reg_both(dst + 1), reg_a(dst + 1),

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2003

SHF_OP_NONE, reg_b(dst), SHF_SC_R_DSHF,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2005

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2006

reg_b(dst), SHF_SC_L_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2008

wrp_reg_mov(nfp_prog, dst + 1, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2009

wrp_immed(nfp_prog, reg_both(dst), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2011

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2012

reg_b(dst), SHF_SC_L_SHF, shift_amt - 32);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2013

wrp_immed(nfp_prog, reg_both(dst), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2022

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2024

return __shl_imm64(nfp_prog, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2027

static void shl_reg64_lt32_high(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2032

emit_shf_indir(nfp_prog, reg_both(dst + 1), reg_a(dst + 1), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2033

reg_b(dst), SHF_SC_R_DSHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2037

static void shl_reg64_lt32_low(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2040

emit_shf_indir(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2041

reg_b(dst), SHF_SC_L_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2044

static void shl_reg64_lt32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2046

shl_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2047

shl_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2050

static void shl_reg64_ge32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2053

emit_shf_indir(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2054

reg_b(dst), SHF_SC_L_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2055

wrp_immed(nfp_prog, reg_both(dst), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2062

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2064

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2068

return __shl_imm64(nfp_prog, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2072

shl_reg64_lt32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2074

shl_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2084

shl_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2088

shl_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2092

shl_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2111

static int __shr_imm64(struct nfp_prog *nfp_prog, u8 dst, u8 shift_amt)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2117

emit_shf(nfp_prog, reg_both(dst), reg_a(dst + 1), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2118

reg_b(dst), SHF_SC_R_DSHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2119

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2120

reg_b(dst + 1), SHF_SC_R_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2122

wrp_reg_mov(nfp_prog, dst, dst + 1);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2123

wrp_immed(nfp_prog, reg_both(dst + 1), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2125

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2126

reg_b(dst + 1), SHF_SC_R_SHF, shift_amt - 32);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2127

wrp_immed(nfp_prog, reg_both(dst + 1), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2136

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2138

return __shr_imm64(nfp_prog, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2142

static void shr_reg64_lt32_high(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2145

emit_shf_indir(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2146

reg_b(dst + 1), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2149

static void shr_reg64_lt32_low(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2152

emit_shf_indir(nfp_prog, reg_both(dst), reg_a(dst + 1), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2153

reg_b(dst), SHF_SC_R_DSHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2156

static void shr_reg64_lt32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2158

shr_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2159

shr_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2162

static void shr_reg64_ge32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2165

emit_shf_indir(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2166

reg_b(dst + 1), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2167

wrp_immed(nfp_prog, reg_both(dst + 1), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2174

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2176

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2180

return __shr_imm64(nfp_prog, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2184

shr_reg64_lt32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2186

shr_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2195

shr_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2199

shr_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2203

shr_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2215

static int __ashr_imm64(struct nfp_prog *nfp_prog, u8 dst, u8 shift_amt)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2221

emit_shf(nfp_prog, reg_both(dst), reg_a(dst + 1), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2222

reg_b(dst), SHF_SC_R_DSHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2224

emit_alu(nfp_prog, reg_none(), reg_a(dst + 1), ALU_OP_OR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2226

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2227

reg_b(dst + 1), SHF_SC_R_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2230

wrp_reg_mov(nfp_prog, dst, dst + 1);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2231

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2232

reg_b(dst + 1), SHF_SC_R_SHF, 31);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2234

emit_alu(nfp_prog, reg_none(), reg_a(dst + 1), ALU_OP_OR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2236

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2237

reg_b(dst + 1), SHF_SC_R_SHF, shift_amt - 32);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2238

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2239

reg_b(dst + 1), SHF_SC_R_SHF, 31);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2248

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2250

return __ashr_imm64(nfp_prog, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2253

static void ashr_reg64_lt32_high(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2258

emit_alu(nfp_prog, reg_none(), reg_a(src), ALU_OP_OR, reg_b(dst + 1));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2259

emit_shf_indir(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2260

reg_b(dst + 1), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2263

static void ashr_reg64_lt32_low(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2268

return shr_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2271

static void ashr_reg64_lt32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2273

ashr_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2274

ashr_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2277

static void ashr_reg64_ge32(struct nfp_prog *nfp_prog, u8 dst, u8 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2279

emit_alu(nfp_prog, reg_none(), reg_a(src), ALU_OP_OR, reg_b(dst + 1));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2280

emit_shf_indir(nfp_prog, reg_both(dst), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2281

reg_b(dst + 1), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2282

emit_shf(nfp_prog, reg_both(dst + 1), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2283

reg_b(dst + 1), SHF_SC_R_SHF, 31);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2291

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2293

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2297

return __ashr_imm64(nfp_prog, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2301

ashr_reg64_lt32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2303

ashr_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2309

ashr_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2313

ashr_reg64_lt32_high(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2317

ashr_reg64_ge32(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2418

u8 dst = meta->insn.dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2420

emit_alu(nfp_prog, reg_both(dst), reg_imm(0), ALU_OP_SUB, reg_b(dst));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2421

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2427

__ashr_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta, u8 dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2432

emit_alu(nfp_prog, reg_none(), reg_a(dst), ALU_OP_OR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2434

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2435

reg_b(dst), SHF_SC_R_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2437

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2446

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2448

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2452

return __ashr_imm(nfp_prog, meta, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2458

emit_alu(nfp_prog, reg_none(), reg_a(src), ALU_OP_OR, reg_b(dst));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2459

emit_shf_indir(nfp_prog, reg_both(dst), reg_none(), SHF_OP_ASHR,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2460

reg_b(dst), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2461

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2469

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2471

return __ashr_imm(nfp_prog, meta, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2475

__shr_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta, u8 dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2479

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2480

reg_b(dst), SHF_SC_R_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2481

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2488

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2490

return __shr_imm(nfp_prog, meta, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2497

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2499

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2503

return __shr_imm(nfp_prog, meta, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2507

emit_shf_indir(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2508

reg_b(dst), SHF_SC_R_SHF);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2509

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2514

__shl_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta, u8 dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2518

emit_shf(nfp_prog, reg_both(dst), reg_none(), SHF_OP_NONE,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2519

reg_b(dst), SHF_SC_L_SHF, shift_amt);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2520

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2527

u8 dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2529

return __shl_imm(nfp_prog, meta, dst, insn->imm);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2536

u8 dst, src;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2538

dst = insn->dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2542

return __shl_imm(nfp_prog, meta, dst, umin);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2545

shl_reg64_lt32_low(nfp_prog, dst, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2546

wrp_zext(nfp_prog, meta, dst);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2583

u8 dst;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2585

dst = prev->insn.dst_reg * 2;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2589

wrp_immed(nfp_prog, reg_both(dst), imm_lo);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2593

wrp_mov(nfp_prog, reg_both(dst + 1), reg_a(dst));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2595

wrp_immed(nfp_prog, reg_both(dst + 1), imm_hi);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2651

swreg dst = reg_both(meta->insn.dst_reg * 2);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2657

wrp_mov(nfp_prog, dst, plen_reg(nfp_prog));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2662

wrp_mov(nfp_prog, dst, pptr_reg(nfp_prog));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2667

emit_alu(nfp_prog, dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2682

swreg dst = reg_both(meta->insn.dst_reg * 2);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2688

wrp_mov(nfp_prog, dst, pptr_reg(nfp_prog));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

2693

emit_alu(nfp_prog, dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

294

emit_immed(struct nfp_prog *nfp_prog, swreg dst, u16 imm,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

300

if (swreg_type(dst) == NN_REG_IMM) {

drivers/net/ethernet/netronome/nfp/bpf/jit.c

305

err = swreg_to_unrestricted(dst, dst, reg_imm(imm & 0xff), &reg);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

313

swreg_type(dst) == NN_REG_NONE ? reg.dst : reg.areg,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

319

__emit_shf(struct nfp_prog *nfp_prog, u16 dst, enum alu_dst_ab dst_ab,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

351

FIELD_PREP(OP_SHF_DST, dst) |

drivers/net/ethernet/netronome/nfp/bpf/jit.c

363

emit_shf(struct nfp_prog *nfp_prog, swreg dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

369

err = swreg_to_restricted(dst, lreg, rreg, &reg, true);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

375

__emit_shf(nfp_prog, reg.dst, reg.dst_ab, sc, shift,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

381

emit_shf_indir(struct nfp_prog *nfp_prog, swreg dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

390

emit_shf(nfp_prog, dst, lreg, op, rreg, sc, 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

394

__emit_alu(struct nfp_prog *nfp_prog, u16 dst, enum alu_dst_ab dst_ab,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

403

FIELD_PREP(OP_ALU_DST, dst) |

drivers/net/ethernet/netronome/nfp/bpf/jit.c

415

emit_alu(struct nfp_prog *nfp_prog, swreg dst,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

421

err = swreg_to_unrestricted(dst, lreg, rreg, &reg);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

427

__emit_alu(nfp_prog, reg.dst, reg.dst_ab,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

471

areg = reg.dst;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

511

emit_ld_field_any(struct nfp_prog *nfp_prog, swreg dst, u8 bmask, swreg src,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

518

err = swreg_to_restricted(dst, dst, src, &reg, true);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

530

emit_ld_field(struct nfp_prog *nfp_prog, swreg dst, u8 bmask, swreg src,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

533

emit_ld_field_any(nfp_prog, dst, bmask, src, sc, shift, false);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

608

static void wrp_immed(struct nfp_prog *nfp_prog, swreg dst, u32 imm)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

614

emit_immed(nfp_prog, dst, val, IMMED_WIDTH_ALL, false, shift);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

616

emit_immed(nfp_prog, dst, val, IMMED_WIDTH_ALL, true, shift);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

618

emit_immed(nfp_prog, dst, imm & 0xffff, IMMED_WIDTH_ALL,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

620

emit_immed(nfp_prog, dst, imm >> 16, IMMED_WIDTH_WORD,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

626

wrp_zext(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta, u8 dst)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

629

wrp_immed(nfp_prog, reg_both(dst + 1), 0);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

633

wrp_immed_relo(struct nfp_prog *nfp_prog, swreg dst, u32 imm,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

641

emit_immed(nfp_prog, dst, imm, IMMED_WIDTH_ALL, false, IMMED_SHIFT_0B);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

679

static void wrp_mov(struct nfp_prog *nfp_prog, swreg dst, swreg src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

681

emit_alu(nfp_prog, dst, reg_none(), ALU_OP_NONE, src);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

684

static void wrp_reg_mov(struct nfp_prog *nfp_prog, u16 dst, u16 src)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

686

wrp_mov(nfp_prog, reg_both(dst), reg_b(src));

drivers/net/ethernet/netronome/nfp/bpf/jit.c

693

wrp_reg_subpart(struct nfp_prog *nfp_prog, swreg dst, swreg src, u8 field_len,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

699

emit_ld_field_any(nfp_prog, dst, mask, src, sc, offset * 8, true);

drivers/net/ethernet/netronome/nfp/bpf/jit.c

706

wrp_reg_or_subpart(struct nfp_prog *nfp_prog, swreg dst, swreg src,

drivers/net/ethernet/netronome/nfp/bpf/jit.c

712

emit_ld_field(nfp_prog, dst, mask, src, sc, 32 - offset * 8);

drivers/net/ethernet/netronome/nfp/bpf/offload.c

436

nfp_bpf_perf_event_copy(void *dst, const void *src,

drivers/net/ethernet/netronome/nfp/bpf/offload.c

439

memcpy(dst, src + off, len);

drivers/net/ethernet/netronome/nfp/flower/action.c

469

struct dst_entry *dst;

drivers/net/ethernet/netronome/nfp/flower/action.c

471

flow.daddr = ip_tun->key.u.ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/action.c

473

dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &flow, NULL);

drivers/net/ethernet/netronome/nfp/flower/action.c

474

if (!IS_ERR(dst)) {

drivers/net/ethernet/netronome/nfp/flower/action.c

475

set_tun->ttl = ip6_dst_hoplimit(dst);

drivers/net/ethernet/netronome/nfp/flower/action.c

476

dst_release(dst);

drivers/net/ethernet/netronome/nfp/flower/action.c

491

flow.daddr = ip_tun->key.u.ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/action.c

496

set_tun->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/ethernet/netronome/nfp/flower/action.c

514

pre_tun->ipv6_dst = ip_tun->key.u.ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/action.c

516

pre_tun->ipv4_dst = ip_tun->key.u.ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/cmsg.c

113

msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);

drivers/net/ethernet/netronome/nfp/flower/cmsg.c

87

msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);

drivers/net/ethernet/netronome/nfp/flower/cmsg.h

414

__be32 dst;

drivers/net/ethernet/netronome/nfp/flower/cmsg.h

419

struct in6_addr dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1000

entry = nfp_tunnel_add_ipv6_off(priv->app, dst);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1008

__be32 dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1014

dst = ((struct nfp_flower_ipv4_gre_tun *)key)->ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1019

flow_pay->nfp_tun_ipv4_addr = dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1020

nfp_tunnel_add_ipv4_off(priv->app, dst);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1032

struct in6_addr *dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1039

dst = &udp_match->ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1041

entry = nfp_tunnel_add_ipv6_off(priv->app, dst);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1049

__be32 dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1055

dst = ((struct nfp_flower_ipv4_udp_tun *)key)->ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1060

flow_pay->nfp_tun_ipv4_addr = dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

1061

nfp_tunnel_add_ipv4_off(priv->app, dst);

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

991

struct in6_addr *dst;

drivers/net/ethernet/netronome/nfp/flower/conntrack.c

998

dst = &gre_match->ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/main.c

913

app_priv->mtu_conf.portnum = repr->dst->u.port_info.port_id;

drivers/net/ethernet/netronome/nfp/flower/match.c

107

tmp = match.key->dst[i] & match.mask->dst[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

109

msk->mac_dst[i] |= match.mask->dst[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

202

tmp = match.key->dst & match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

204

msk->port_dst |= match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

348

tmp = match.key->dst & match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

350

msk->ipv4_dst |= match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

373

tmp = match.key->dst.s6_addr[i] &

drivers/net/ethernet/netronome/nfp/flower/match.c

374

match.mask->dst.s6_addr[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

377

msk->ipv6_dst.s6_addr[i] |= match.mask->dst.s6_addr[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

410

ext->dst |= match.key->dst & match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

412

msk->dst |= match.mask->dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

429

ext->dst.s6_addr[i] |= match.key->dst.s6_addr[i] &

drivers/net/ethernet/netronome/nfp/flower/match.c

430

match.mask->dst.s6_addr[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

432

msk->dst.s6_addr[i] |= match.mask->dst.s6_addr[i];

drivers/net/ethernet/netronome/nfp/flower/match.c

640

struct in6_addr *dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

645

dst = &gre_match->ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

649

entry = nfp_tunnel_add_ipv6_off(app, dst);

drivers/net/ethernet/netronome/nfp/flower/match.c

655

__be32 dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

659

dst = ((struct nfp_flower_ipv4_gre_tun *)ext)->ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

666

nfp_flow->nfp_tun_ipv4_addr = dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

667

nfp_tunnel_add_ipv4_off(app, dst);

drivers/net/ethernet/netronome/nfp/flower/match.c

676

struct in6_addr *dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

681

dst = &udp_match->ipv6.dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

685

entry = nfp_tunnel_add_ipv6_off(app, dst);

drivers/net/ethernet/netronome/nfp/flower/match.c

691

__be32 dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

695

dst = ((struct nfp_flower_ipv4_udp_tun *)ext)->ipv4.dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

702

nfp_flow->nfp_tun_ipv4_addr = dst;

drivers/net/ethernet/netronome/nfp/flower/match.c

703

nfp_tunnel_add_ipv4_off(app, dst);

drivers/net/ethernet/netronome/nfp/flower/offload.c

182

switch (enc_ports->dst) {

drivers/net/ethernet/netronome/nfp/flower/offload.c

349

if (memchr_inv(&ipv6_addrs.mask->dst, 0xff,

drivers/net/ethernet/netronome/nfp/flower/offload.c

350

sizeof(ipv6_addrs.mask->dst))) {

drivers/net/ethernet/netronome/nfp/flower/offload.c

356

if (ipv4_addrs.mask->dst != cpu_to_be32(~0)) {

drivers/net/ethernet/netronome/nfp/flower/offload.c

392

if (enc_ports.mask->dst != cpu_to_be16(~0)) {

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

652

struct dst_entry *dst;

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

659

dst = ip6_dst_lookup_flow(dev_net(n->dev), NULL,

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

661

if (IS_ERR(dst))

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

664

dst_release(dst);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

781

n = dst_neigh_lookup(&rt->dst, &flow.daddr);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

803

struct dst_entry *dst;

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

818

dst = ipv6_stub->ipv6_dst_lookup_flow(dev_net(netdev), NULL, &flow,

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

820

if (IS_ERR(dst))

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

826

n = dst_neigh_lookup(dst, &flow.daddr);

drivers/net/ethernet/netronome/nfp/flower/tunnel_conf.c

827

dst_release(dst);

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

168

int swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,

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

174

if (swreg_type(dst) == NN_REG_IMM)

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

177

if (swreg_type(dst) == NN_REG_GPR_B)

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

179

if (swreg_type(dst) == NN_REG_GPR_BOTH)

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

181

reg->dst = nfp_swreg_to_unreg(dst, true);

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

198

reg->dst_lmextn = swreg_lmextn(dst);

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

249

int swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,

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

255

if (swreg_type(dst) == NN_REG_IMM)

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

258

if (swreg_type(dst) == NN_REG_GPR_B)

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

260

if (swreg_type(dst) == NN_REG_GPR_BOTH)

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

262

reg->dst = nfp_swreg_to_rereg(dst, true, false, NULL);

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

279

reg->dst_lmextn = swreg_lmextn(dst);

drivers/net/ethernet/netronome/nfp/nfp_asm.h

371

u16 dst;

drivers/net/ethernet/netronome/nfp/nfp_asm.h

381

u8 dst;

drivers/net/ethernet/netronome/nfp/nfp_asm.h

390

int swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,

drivers/net/ethernet/netronome/nfp/nfp_asm.h

392

int swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,

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

192

dst_hold((struct dst_entry *)repr->dst);

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

193

skb_dst_set(skb, (struct dst_entry *)repr->dst);

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

194

skb->dev = repr->dst->u.port_info.lower_dev;

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

243

lower_dev = repr->dst->u.port_info.lower_dev;

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

284

if (repr->dst->u.port_info.lower_dev != lower)

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

296

dst_release((struct dst_entry *)repr->dst);

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

326

repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL);

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

327

if (!repr->dst)

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

329

repr->dst->u.port_info.port_id = cmsg_port_id;

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

330

repr->dst->u.port_info.lower_dev = pf_netdev;

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

408

dst_release((struct dst_entry *)repr->dst);

drivers/net/ethernet/netronome/nfp/nfp_net_repr.h

53

struct metadata_dst *dst;

drivers/net/ethernet/netronome/nfp/nfp_net_repr.h

87

return priv->dst->u.port_info.port_id;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp6000_pcie.c

1219

u32 *dst = buff;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp6000_pcie.c

1223

*(dst++) = readl(priv->data + i);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

123

static void nfp_eth_copy_mac_reverse(u8 *dst, const u8 *src)

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

128

dst[ETH_ALEN - i - 1] = src[i];

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

133

unsigned int index, struct nfp_eth_table_port *dst)

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

142

dst->eth_index = FIELD_GET(NSP_ETH_PORT_INDEX, port);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

143

dst->index = index;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

144

dst->nbi = index / NSP_ETH_NBI_PORT_COUNT;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

145

dst->base = index % NSP_ETH_NBI_PORT_COUNT;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

146

dst->lanes = FIELD_GET(NSP_ETH_PORT_LANES, port);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

148

dst->enabled = FIELD_GET(NSP_ETH_STATE_ENABLED, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

149

dst->tx_enabled = FIELD_GET(NSP_ETH_STATE_TX_ENABLED, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

150

dst->rx_enabled = FIELD_GET(NSP_ETH_STATE_RX_ENABLED, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

153

dst->speed = dst->lanes * rate;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

155

dst->interface = FIELD_GET(NSP_ETH_STATE_INTERFACE, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

156

dst->media = FIELD_GET(NSP_ETH_STATE_MEDIA, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

158

nfp_eth_copy_mac_reverse(dst->mac_addr, src->mac_addr);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

160

dst->label_port = FIELD_GET(NSP_ETH_PORT_PHYLABEL, port);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

161

dst->label_subport = FIELD_GET(NSP_ETH_PORT_LABEL, port);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

166

dst->override_changed = FIELD_GET(NSP_ETH_STATE_OVRD_CHNG, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

167

dst->aneg = FIELD_GET(NSP_ETH_STATE_ANEG, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

173

dst->fec_modes_supported |= fec << NFP_FEC_BASER_BIT;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

175

dst->fec_modes_supported |= fec << NFP_FEC_REED_SOLOMON_BIT;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

176

if (dst->fec_modes_supported)

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

177

dst->fec_modes_supported |= NFP_FEC_AUTO | NFP_FEC_DISABLED;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

179

dst->fec = FIELD_GET(NSP_ETH_STATE_FEC, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

180

dst->act_fec = dst->fec;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

185

dst->act_fec = FIELD_GET(NSP_ETH_STATE_ACT_FEC, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

186

dst->supp_aneg = FIELD_GET(NSP_ETH_PORT_SUPP_ANEG, port);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

189

dst->tx_pause = true;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

190

dst->rx_pause = true;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

194

dst->tx_pause = FIELD_GET(NSP_ETH_STATE_TX_PAUSE, state);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_nsp_eth.c

195

dst->rx_pause = FIELD_GET(NSP_ETH_STATE_RX_PAUSE, state);

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

940

static int ionic_do_module_copy(u8 *dst, u8 *src, u32 len)

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

949

memcpy(dst, src, len);

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

953

if (!memcmp(dst, tbuf, len))

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

1223

ether_addr_copy(con->remote_mac, conn_info->dst.mac);

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

1225

memcpy(con->remote_ip, conn_info->dst.ip, sizeof(con->remote_ip));

drivers/net/ethernet/qlogic/qed/qed_iscsi.c

1227

con->remote_port = conn_info->dst.port;

drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c

687

ether_addr_copy(con->remote_mac, conn_info->dst.mac);

drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c

689

memcpy(con->remote_ip, conn_info->dst.ip, sizeof(con->remote_ip));

drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c

691

con->remote_port = conn_info->dst.port;

drivers/net/ethernet/qlogic/qede/qede_filter.c

1709

(match.key->dst && match.mask->dst != htons(U16_MAX))) {

drivers/net/ethernet/qlogic/qede/qede_filter.c

1716

t->dst_port = match.key->dst;

drivers/net/ethernet/qlogic/qede/qede_filter.c

1739

(memcmp(&match.key->dst, &zero_addr, sizeof(addr)) &&

drivers/net/ethernet/qlogic/qede/qede_filter.c

1740

memcmp(&match.mask->dst, &addr, sizeof(addr)))) {

drivers/net/ethernet/qlogic/qede/qede_filter.c

1747

memcpy(&t->dst_ipv6, &match.key->dst, sizeof(addr));

drivers/net/ethernet/qlogic/qede/qede_filter.c

1769

(match.key->dst && match.mask->dst != htonl(U32_MAX))) {

drivers/net/ethernet/qlogic/qede/qede_filter.c

1776

t->dst_ipv4 = match.key->dst;

drivers/net/ethernet/qualcomm/qca_spi.c

147

qcaspi_read_burst(struct qcaspi *qca, u8 *dst, u32 len)

drivers/net/ethernet/qualcomm/qca_spi.c

160

transfer[1].rx_buf = dst;

drivers/net/ethernet/qualcomm/qca_spi.c

176

qcaspi_read_legacy(struct qcaspi *qca, u8 *dst, u32 len)

drivers/net/ethernet/qualcomm/qca_spi.c

185

transfer.rx_buf = dst;

drivers/net/ethernet/rocker/rocker_ofdpa.c

2268

static int ofdpa_port_fib_ipv4(struct ofdpa_port *ofdpa_port, __be32 dst,

drivers/net/ethernet/rocker/rocker_ofdpa.c

2303

err = ofdpa_flow_tbl_ucast4_routing(ofdpa_port, eth_type, dst,

drivers/net/ethernet/rocker/rocker_ofdpa.c

2308

err, &dst);

drivers/net/ethernet/rocker/rocker_ofdpa.c

2735

err = ofdpa_port_fib_ipv4(ofdpa_port, htonl(fen_info->dst),

drivers/net/ethernet/rocker/rocker_ofdpa.c

2758

return ofdpa_port_fib_ipv4(ofdpa_port, htonl(fen_info->dst),

drivers/net/ethernet/rocker/rocker_ofdpa.c

971

__be16 eth_type, __be32 dst,

drivers/net/ethernet/rocker/rocker_ofdpa.c

986

entry->key.ucast_routing.dst4 = dst;

drivers/net/ethernet/sfc/falcon/rx.c

873

spec.loc_host[0] = fk.addrs.v4addrs.dst;

drivers/net/ethernet/sfc/falcon/rx.c

876

memcpy(spec.loc_host, &fk.addrs.v6addrs.dst, sizeof(struct in6_addr));

drivers/net/ethernet/sfc/falcon/rx.c

880

spec.loc_port = fk.ports.dst;

drivers/net/ethernet/sfc/mae.c

1892

#define _TABLE_POPULATE(dst, dw, _field, _value) ({ \

drivers/net/ethernet/sfc/mae.c

1896

efx_mae_table_populate(_field, dst, dw, &_v, \

drivers/net/ethernet/sfc/mae.c

1899

#define TABLE_POPULATE_KEY_IPV4(dst, _table, _field, _value) \

drivers/net/ethernet/sfc/mae.c

1902

dst, efx->tc->meta_##_table.desc.key_width,\

drivers/net/ethernet/sfc/mae.c

1904

#define TABLE_POPULATE_KEY(dst, _table, _field, _value) \

drivers/net/ethernet/sfc/mae.c

1905

_TABLE_POPULATE(dst, efx->tc->meta_##_table.desc.key_width, \

drivers/net/ethernet/sfc/mae.c

1910

#define TABLE_POPULATE_RESP_BOOL(dst, _table, _field, _value) \

drivers/net/ethernet/sfc/mae.c

1913

dst, efx->tc->meta_##_table.desc.resp_width,\

drivers/net/ethernet/sfc/mae.c

1915

#define TABLE_POPULATE_RESP(dst, _table, _field, _value) \

drivers/net/ethernet/sfc/mae.c

1916

_TABLE_POPULATE(dst, efx->tc->meta_##_table.desc.resp_width, \

drivers/net/ethernet/sfc/mae.c

1921

#define TABLE_POPULATE_RESP_U24(dst, _table, _field, _value) \

drivers/net/ethernet/sfc/mae.c

1924

dst, efx->tc->meta_##_table.desc.resp_width,\

drivers/net/ethernet/sfc/rx_common.c

948

req->spec.loc_host[0] = fk.addrs.v4addrs.dst;

drivers/net/ethernet/sfc/rx_common.c

952

memcpy(req->spec.loc_host, &fk.addrs.v6addrs.dst,

drivers/net/ethernet/sfc/rx_common.c

957

req->spec.loc_port = fk.ports.dst;

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

939

req->spec.loc_host[0] = fk.addrs.v4addrs.dst;

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

943

memcpy(req->spec.loc_host, &fk.addrs.v6addrs.dst,

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

948

req->spec.loc_port = fk.ports.dst;

drivers/net/ethernet/sfc/tc.c

354

ether_addr_copy(match->value.eth_daddr, fm.key->dst);

drivers/net/ethernet/sfc/tc.c

356

ether_addr_copy(match->mask.eth_daddr, fm.mask->dst);

drivers/net/ethernet/sfc/tc.c

375

MAP_KEY_AND_MASK(IPV4_ADDRS, ipv4_addrs, dst, dst_ip);

drivers/net/ethernet/sfc/tc.c

380

MAP_KEY_AND_MASK(IPV6_ADDRS, ipv6_addrs, dst, dst_ip6);

drivers/net/ethernet/sfc/tc.c

384

MAP_KEY_AND_MASK(PORTS, ports, dst, l4_dport);

drivers/net/ethernet/sfc/tc.c

403

dst, enc_dst_ip);

drivers/net/ethernet/sfc/tc.c

410

dst, enc_dst_ip6);

drivers/net/ethernet/sfc/tc.c

422

MAP_ENC_KEY_AND_MASK(PORTS, ports, enc_ports, dst, enc_dport);

drivers/net/ethernet/sfc/tc_conntrack.c

191

if (!IS_ALL_ONES(fm.mask->dst)) {

drivers/net/ethernet/sfc/tc_conntrack.c

194

ntohl(fm.mask->dst));

drivers/net/ethernet/sfc/tc_conntrack.c

197

conn->dst_ip = fm.key->dst;

drivers/net/ethernet/sfc/tc_conntrack.c

209

if (!efx_ipv6_addr_all_ones(&fm.mask->dst)) {

drivers/net/ethernet/sfc/tc_conntrack.c

212

&fm.mask->dst);

drivers/net/ethernet/sfc/tc_conntrack.c

215

conn->dst_ip6 = fm.key->dst;

drivers/net/ethernet/sfc/tc_conntrack.c

233

if (!IS_ALL_ONES(fm.mask->dst)) {

drivers/net/ethernet/sfc/tc_conntrack.c

236

ntohs(fm.mask->dst));

drivers/net/ethernet/sfc/tc_conntrack.c

239

conn->l4_dport = fm.key->dst;

drivers/net/ethernet/sfc/tc_encap_actions.c

105

flow4.daddr = encap->key.u.ipv4.dst;

drivers/net/ethernet/sfc/tc_encap_actions.c

114

flow6.daddr = encap->key.u.ipv6.dst;

drivers/net/ethernet/sfc/tc_encap_actions.c

150

struct dst_entry *dst;

drivers/net/ethernet/sfc/tc_encap_actions.c

152

dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &flow6,

drivers/net/ethernet/sfc/tc_encap_actions.c

154

rc = PTR_ERR_OR_ZERO(dst);

drivers/net/ethernet/sfc/tc_encap_actions.c

159

neigh->egdev = dst->dev;

drivers/net/ethernet/sfc/tc_encap_actions.c

162

neigh->ttl = ip6_dst_hoplimit(dst);

drivers/net/ethernet/sfc/tc_encap_actions.c

163

n = dst_neigh_lookup(dst, &flow6.daddr);

drivers/net/ethernet/sfc/tc_encap_actions.c

164

dst_release(dst);

drivers/net/ethernet/sfc/tc_encap_actions.c

182

neigh->egdev = rt->dst.dev;

drivers/net/ethernet/sfc/tc_encap_actions.c

185

neigh->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/ethernet/sfc/tc_encap_actions.c

186

n = dst_neigh_lookup(&rt->dst, &flow4.daddr);

drivers/net/ethernet/sfc/tc_encap_actions.c

276

ip->daddr = key->u.ipv4.dst;

drivers/net/ethernet/sfc/tc_encap_actions.c

297

ip->daddr = key->u.ipv6.dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1023

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1144

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

115

if (attr->dst)

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

116

ether_addr_copy(ehdr->h_dest, attr->dst);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1182

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1203

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1225

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1247

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1291

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1330

static int __stmmac_test_l3filt(struct stmmac_priv *priv, u32 dst, u32 src,

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1382

key.dst = htonl(dst);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1384

mask.dst = dst_mask;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1392

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1393

attr.ip_dst = dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1427

static int __stmmac_test_l3filt(struct stmmac_priv *priv, u32 dst, u32 src,

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1449

static int __stmmac_test_l4filt(struct stmmac_priv *priv, u32 dst, u32 src,

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1511

keys.key.dst = htons(dst);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1513

masks.mask.dst = dst_mask;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1521

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1524

attr.dport = dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1558

static int __stmmac_test_l4filt(struct stmmac_priv *priv, u32 dst, u32 src,

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1620

unsigned char dst[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1647

attr.dst = dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1689

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1728

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1742

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

1795

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

227

NULL, attr->src, attr->dst);

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

252

const unsigned char *dst = tpriv->packet->dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

270

if (dst) {

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

271

if (!ether_addr_equal_unaligned(ehdr->h_dest, dst))

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

373

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

389

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

39

const unsigned char *dst;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

560

attr.dst = gd_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

567

attr.dst = bd_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

604

attr.dst = gd_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

611

attr.dst = bd_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

650

attr.dst = uc_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

657

attr.dst = mc_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

696

attr.dst = mc_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

703

attr.dst = uc_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

780

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

827

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

869

if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->dst))

drivers/net/ethernet/stmicro/stmmac/stmmac_selftests.c

929

attr.dst = priv->dev->dev_addr;

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c

492

hw_match = ntohl(match.key->dst) & ntohl(match.mask->dst);

drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c

540

hw_match = ntohs(match.key->dst) & ntohs(match.mask->dst);

drivers/net/ethernet/ti/am65-cpsw-qos.c

1060

if (is_broadcast_ether_addr(match.key->dst) &&

drivers/net/ethernet/ti/am65-cpsw-qos.c

1061

is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/ti/am65-cpsw-qos.c

1068

} else if (ether_addr_equal_unaligned(match.key->dst, mc_mac) &&

drivers/net/ethernet/ti/am65-cpsw-qos.c

1069

ether_addr_equal_unaligned(match.mask->dst, mc_mac)) {

drivers/net/ethernet/ti/cpsw_priv.c

1405

if (is_broadcast_ether_addr(match.key->dst) &&

drivers/net/ethernet/ti/cpsw_priv.c

1406

is_broadcast_ether_addr(match.mask->dst)) {

drivers/net/ethernet/ti/cpsw_priv.c

1413

} else if (ether_addr_equal_unaligned(match.key->dst, mc_mac) &&

drivers/net/ethernet/ti/cpsw_priv.c

1414

ether_addr_equal_unaligned(match.mask->dst, mc_mac)) {

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1940

struct icssg_firmwares *dst,

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1946

dst[i].pru = icssg_firmware_name_replace(dev, src[i].pru,

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1948

dst[i].rtu = icssg_firmware_name_replace(dev, src[i].rtu,

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1950

dst[i].txpru = icssg_firmware_name_replace(dev, src[i].txpru,

drivers/net/ethernet/wangxun/txgbe/txgbe_fdir.c

285

common.port.dst ^= th->source;

drivers/net/ethernet/wangxun/txgbe/txgbe_type.h

274

__be16 dst;

drivers/net/fddi/defza.c

123

u64 *dst = to;

drivers/net/fddi/defza.c

127

*dst++ = readq_u(src++);

drivers/net/fddi/defza.c

130

dst_trail = (u32 *)dst;

drivers/net/fddi/defza.c

135

u32 *dst = to;

drivers/net/fddi/defza.c

138

*dst++ = readl_u(src++);

drivers/net/fddi/defza.c

148

u64 __iomem *dst = to;

drivers/net/fddi/defza.c

152

writeq_u(*src++, dst++);

drivers/net/fddi/defza.c

155

dst_trail = (u32 __iomem *)dst;

drivers/net/fddi/defza.c

160

u32 __iomem *dst = to;

drivers/net/fddi/defza.c

163

writel_u(*src++, dst++);

drivers/net/fddi/defza.c

173

u64 __iomem *dst = to;

drivers/net/fddi/defza.c

177

writeq_u(readq_u(src++), dst++);

drivers/net/fddi/defza.c

180

dst_trail = (u32 __iomem *)dst;

drivers/net/fddi/defza.c

185

u32 __iomem *dst = to;

drivers/net/fddi/defza.c

188

writel_u(readl_u(src++), dst++);

drivers/net/fddi/defza.c

195

u64 __iomem *dst = to;

drivers/net/fddi/defza.c

199

writeq_u(0, dst++);

drivers/net/fddi/defza.c

201

dst_trail = (u32 __iomem *)dst;

drivers/net/fddi/defza.c

205

u32 __iomem *dst = to;

drivers/net/fddi/defza.c

208

writel_u(0, dst++);

drivers/net/geneve.c

1230

static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,

drivers/net/geneve.c

1249

min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +

drivers/net/geneve.c

1271

dst_release(dst);

drivers/net/geneve.c

1325

err = skb_tunnel_check_pmtu(skb, &rt->dst,

drivers/net/geneve.c

1330

dst_release(&rt->dst);

drivers/net/geneve.c

1341

dst_release(&rt->dst);

drivers/net/geneve.c

1345

unclone->key.u.ipv4.dst = saddr;

drivers/net/geneve.c

1346

unclone->key.u.ipv4.src = info->key.u.ipv4.dst;

drivers/net/geneve.c

1350

dst_release(&rt->dst);

drivers/net/geneve.c

1356

dst_release(&rt->dst);

drivers/net/geneve.c

1371

ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);

drivers/net/geneve.c

1389

err = geneve_build_skb(&rt->dst, skb, info, geneve,

drivers/net/geneve.c

1394

udp_tunnel_xmit_skb(rt, gs4->sock->sk, skb, saddr, info->key.u.ipv4.dst,

drivers/net/geneve.c

1409

struct dst_entry *dst = NULL;

drivers/net/geneve.c

1428

dst = udp_tunnel6_dst_lookup(skb, dev, geneve->net, gs6->sock, 0,

drivers/net/geneve.c

1433

if (IS_ERR(dst))

drivers/net/geneve.c

1434

return PTR_ERR(dst);

drivers/net/geneve.c

1436

err = skb_tunnel_check_pmtu(skb, dst,

drivers/net/geneve.c

1441

dst_release(dst);

drivers/net/geneve.c

1451

dst_release(dst);

drivers/net/geneve.c

1455

unclone->key.u.ipv6.dst = saddr;

drivers/net/geneve.c

1456

unclone->key.u.ipv6.src = info->key.u.ipv6.dst;

drivers/net/geneve.c

1460

dst_release(dst);

drivers/net/geneve.c

1466

dst_release(dst);

drivers/net/geneve.c

1478

ttl = ttl ? : ip6_dst_hoplimit(dst);

drivers/net/geneve.c

1480

err = geneve_build_skb(dst, skb, info, geneve, sizeof(struct ipv6hdr));

drivers/net/geneve.c

1484

udp_tunnel6_xmit_skb(dst, gs6->sock->sk, skb, dev,

drivers/net/geneve.c

1485

&saddr, &key->u.ipv6.dst, prio, ttl,

drivers/net/geneve.c

1581

struct dst_entry *dst;

drivers/net/geneve.c

1596

dst = udp_tunnel6_dst_lookup(skb, dev, geneve->net, gs6->sock, 0,

drivers/net/geneve.c

1600

if (IS_ERR(dst))

drivers/net/geneve.c

1601

return PTR_ERR(dst);

drivers/net/geneve.c

1603

dst_release(dst);

drivers/net/geneve.c

1820

return a->key.u.ipv4.dst == b->key.u.ipv4.dst;

drivers/net/geneve.c

1822

return ipv6_addr_equal(&a->key.u.ipv6.dst, &b->key.u.ipv6.dst);

drivers/net/geneve.c

186

addr == node->geneve->cfg.info.key.u.ipv4.dst)

drivers/net/geneve.c

1917

info->key.u.ipv4.dst =

drivers/net/geneve.c

1920

if (ipv4_is_multicast(info->key.u.ipv4.dst)) {

drivers/net/geneve.c

1935

info->key.u.ipv6.dst =

drivers/net/geneve.c

1938

if (ipv6_addr_type(&info->key.u.ipv6.dst) &

drivers/net/geneve.c

1944

if (ipv6_addr_is_multicast(&info->key.u.ipv6.dst)) {

drivers/net/geneve.c

205

ipv6_addr_equal(&addr6, &node->geneve->cfg.info.key.u.ipv6.dst))

drivers/net/geneve.c

2105

struct flowi4 fl4 = { .daddr = info->key.u.ipv4.dst };

drivers/net/geneve.c

2108

if (!IS_ERR(rt) && rt->dst.dev) {

drivers/net/geneve.c

2109

ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV4_HLEN;

drivers/net/geneve.c

2121

rt = rt6_lookup(geneve->net, &info->key.u.ipv6.dst, NULL, 0,

drivers/net/geneve.c

2124

if (rt && rt->dst.dev)

drivers/net/geneve.c

2125

ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV6_HLEN;

drivers/net/geneve.c

2295

info->key.u.ipv4.dst))

drivers/net/geneve.c

2305

&info->key.u.ipv6.dst))

drivers/net/geneve.c

301

skb_dst_set(skb, &tun_dst->dst);

drivers/net/gtp.c

1066

if (rt->dst.dev == dev) {

drivers/net/gtp.c

1076

mtu = dst_mtu(&rt->dst) - dev->hard_header_len -

drivers/net/gtp.c

1087

mtu = dst_mtu(&rt->dst);

drivers/net/gtp.c

1116

struct dst_entry *dst;

drivers/net/gtp.c

1129

dst = &rt->dst;

drivers/net/gtp.c

1131

if (rt->dst.dev == dev) {

drivers/net/gtp.c

1138

mtu = dst_mtu(&rt->dst) - dev->hard_header_len -

drivers/net/gtp.c

1163

dst_release(dst);

drivers/net/gtp.c

1305

ip4_dst_hoplimit(&pktinfo.rt->dst),

drivers/net/gtp.c

1314

udp_tunnel6_xmit_skb(&pktinfo.rt6->dst, pktinfo.sk, skb, dev,

drivers/net/gtp.c

1317

ip6_dst_hoplimit(&pktinfo.rt->dst),

drivers/net/gtp.c

2406

ip4_dst_hoplimit(&rt->dst),

drivers/net/gtp.c

369

struct dst_entry *dst;

drivers/net/gtp.c

377

dst = ipv6_stub->ipv6_dst_lookup_flow(net, sk, fl6, NULL);

drivers/net/gtp.c

378

if (IS_ERR(dst))

drivers/net/gtp.c

381

return (struct rt6_info *)dst;

drivers/net/gtp.c

445

ip4_dst_hoplimit(&rt->dst),

drivers/net/gtp.c

704

ip4_dst_hoplimit(&rt->dst),

drivers/net/ieee802154/ca8210.c

1445

command.pdata.data_req.dst.mode = dst_address_mode;

drivers/net/ieee802154/ca8210.c

1447

put_unaligned_le16(dst_pan_id, command.pdata.data_req.dst.pan_id);

drivers/net/ieee802154/ca8210.c

1449

command.pdata.data_req.dst.address[0] = LS_BYTE(

drivers/net/ieee802154/ca8210.c

1452

command.pdata.data_req.dst.address[1] = MS_BYTE(

drivers/net/ieee802154/ca8210.c

1457

command.pdata.data_req.dst.address,

drivers/net/ieee802154/ca8210.c

407

struct fulladdr dst;

drivers/net/ipvlan/ipvlan_core.c

457

skb_dst_set(skb, &rt->dst);

drivers/net/ipvlan/ipvlan_core.c

489

struct dst_entry *dst;

drivers/net/ipvlan/ipvlan_core.c

492

dst = ip6_route_output(dev_net(dev), NULL, &fl6);

drivers/net/ipvlan/ipvlan_core.c

493

err = dst->error;

drivers/net/ipvlan/ipvlan_core.c

495

dst_release(dst);

drivers/net/ipvlan/ipvlan_core.c

498

skb_dst_set(skb, dst);

drivers/net/ipvlan/ipvlan_l3s.c

65

struct dst_entry *dst;

drivers/net/ipvlan/ipvlan_l3s.c

78

dst = ip6_route_input_lookup(dev_net(sdev), sdev, &fl6,

drivers/net/ipvlan/ipvlan_l3s.c

80

skb_dst_set(skb, dst);

drivers/net/macsec.c

3438

dst_hold(&md_dst->dst);

drivers/net/macsec.c

3439

skb_dst_set(skb, &md_dst->dst);

drivers/net/macsec.c

3783

dst_release(&macsec->secy.tx_sc.md_dst->dst);

drivers/net/netdevsim/fib.c

284

nsim_fib_rt_init(data, &fib4_rt->common, &fen_info->dst, sizeof(u32),

drivers/net/netdevsim/fib.c

308

fib_rt = nsim_fib_rt_lookup(fib_rt_ht, &fen_info->dst, sizeof(u32),

drivers/net/netdevsim/fib.c

321

u32 *p_dst = (u32 *)&fen_info->dst;

drivers/net/netdevsim/fib.c

326

fri.dst = cpu_to_be32(*p_dst);

drivers/net/netdevsim/fib.c

346

fri.dst = cpu_to_be32(*p_dst);

drivers/net/ovpn/udp.c

197

dst_cache_set_ip4(cache, &rt->dst, fl.saddr);

drivers/net/ovpn/udp.c

201

ip4_dst_hoplimit(&rt->dst), 0, fl.fl4_sport,

drivers/net/ovpn/udp.c

224

struct dst_entry *dst;

drivers/net/ovpn/udp.c

238

dst = dst_cache_get_ip6(cache, &fl.saddr);

drivers/net/ovpn/udp.c

239

if (dst)

drivers/net/ovpn/udp.c

254

dst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(sk), sk, &fl, NULL);

drivers/net/ovpn/udp.c

255

if (IS_ERR(dst)) {

drivers/net/ovpn/udp.c

256

ret = PTR_ERR(dst);

drivers/net/ovpn/udp.c

262

dst_cache_set_ip6(cache, dst, &fl.saddr);

drivers/net/ovpn/udp.c

275

udp_tunnel6_xmit_skb(dst, sk, skb, skb->dev, &fl.saddr, &fl.daddr, 0,

drivers/net/ovpn/udp.c

276

ip6_dst_hoplimit(dst), 0, fl.fl6_sport,

drivers/net/phy/motorcomm.c

1901

unsigned long *dst)

drivers/net/phy/motorcomm.c

1903

linkmode_set_bit(ETHTOOL_LINK_MODE_100baseFX_Full_BIT, dst);

drivers/net/phy/motorcomm.c

1904

linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, dst);

drivers/net/phy/motorcomm.c

1905

linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, dst);

drivers/net/phy/motorcomm.c

1906

linkmode_set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, dst);

drivers/net/phy/phy_device.c

2873

static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)

drivers/net/phy/phy_device.c

2875

linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,

drivers/net/phy/phy_device.c

2877

linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,

drivers/net/phy/phylink.c

2871

static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b)

drivers/net/phy/phylink.c

2878

linkmode_and(dst, dst, mask);

drivers/net/phy/phylink.c

2879

linkmode_or(dst, dst, b);

drivers/net/ppp/pptp.c

174

tdev = rt->dst.dev;

drivers/net/ppp/pptp.c

243

if (ip_dont_fragment(sk, &rt->dst))

drivers/net/ppp/pptp.c

251

iph->ttl = ip4_dst_hoplimit(&rt->dst);

drivers/net/ppp/pptp.c

255

skb_dst_set(skb, &rt->dst);

drivers/net/ppp/pptp.c

464

sk_setup_caps(sk, &rt->dst);

drivers/net/ppp/pptp.c

466

po->chan.mtu = dst_mtu(&rt->dst);

drivers/net/usb/lan78xx.c

683

u32 *dst;

drivers/net/usb/lan78xx.c

700

dst = (u32 *)data;

drivers/net/usb/lan78xx.c

703

dst[i] = src[i];

drivers/net/vmxnet3/vmxnet3_drv.c

292

u32 *dst = (u32 *)dstDesc + 2;

drivers/net/vmxnet3/vmxnet3_drv.c

294

*dst = le32_to_cpu(*src);

drivers/net/vmxnet3/vmxnet3_drv.c

303

u32 *dst = (u32 *)(dstDesc + 1);

drivers/net/vmxnet3/vmxnet3_drv.c

308

dst--;

drivers/net/vmxnet3/vmxnet3_drv.c

309

*dst = cpu_to_le32(*src);

drivers/net/vmxnet3/vmxnet3_drv.c

319

u32 *dst = (u32 *)dstDesc;

drivers/net/vmxnet3/vmxnet3_drv.c

321

*dst = le32_to_cpu(*src);

drivers/net/vmxnet3/vmxnet3_drv.c

323

dst++;

drivers/net/vrf.c

1002

struct dst_entry *dst;

drivers/net/vrf.c

1011

dst = &rth->dst;

drivers/net/vrf.c

1012

netdev_ref_replace(dst->dev, net->loopback_dev,

drivers/net/vrf.c

1013

&dst->dev_tracker, GFP_KERNEL);

drivers/net/vrf.c

1014

dst->dev = net->loopback_dev;

drivers/net/vrf.c

1015

dst_release(dst);

drivers/net/vrf.c

1032

rth->dst.output = vrf_output;

drivers/net/vrf.c

1312

if (unlikely(&rt6->dst == &net->ipv6.ip6_null_entry->dst))

drivers/net/vrf.c

1315

skb_dst_set(skb, &rt6->dst);

drivers/net/vrf.c

1448

struct dst_entry *dst = NULL;

drivers/net/vrf.c

1456

dst = &net->ipv6.ip6_null_entry->dst;

drivers/net/vrf.c

1457

return dst;

drivers/net/vrf.c

1465

dst = &rt->dst;

drivers/net/vrf.c

1467

return dst;

drivers/net/vrf.c

359

struct dst_entry *dst)

drivers/net/vrf.c

365

skb_dst_set(skb, dst);

drivers/net/vrf.c

418

struct dst_entry *dst;

drivers/net/vrf.c

419

struct dst_entry *dst_null = &net->ipv6.ip6_null_entry->dst;

drivers/net/vrf.c

436

dst = ip6_dst_lookup_flow(net, NULL, &fl6, NULL);

drivers/net/vrf.c

437

if (IS_ERR(dst) || dst == dst_null)

drivers/net/vrf.c

445

if (dst->dev == dev)

drivers/net/vrf.c

446

return vrf_local_xmit(skb, dev, dst);

drivers/net/vrf.c

448

skb_dst_set(skb, dst);

drivers/net/vrf.c

523

if (rt->dst.dev == vrf_dev)

drivers/net/vrf.c

524

return vrf_local_xmit(skb, vrf_dev, &rt->dst);

drivers/net/vrf.c

526

skb_dst_set(skb, &rt->dst);

drivers/net/vrf.c

604

struct dst_entry *dst = skb_dst(skb);

drivers/net/vrf.c

605

struct net_device *dev = dst->dev;

drivers/net/vrf.c

616

nexthop = rt6_nexthop(dst_rt6_info(dst), &ipv6_hdr(skb)->daddr);

drivers/net/vrf.c

617

neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop);

drivers/net/vrf.c

619

neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false);

drivers/net/vrf.c

628

IP6_INC_STATS(dev_net(dst->dev),

drivers/net/vrf.c

629

ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);

drivers/net/vrf.c

651

struct dst_entry *dst = NULL;

drivers/net/vrf.c

658

dst = &rt6->dst;

drivers/net/vrf.c

659

dst_hold(dst);

drivers/net/vrf.c

664

if (unlikely(!dst)) {

drivers/net/vrf.c

670

skb_dst_set(skb, dst);

drivers/net/vrf.c

755

struct dst_entry *dst;

drivers/net/vrf.c

764

dst = &rt6->dst;

drivers/net/vrf.c

765

netdev_ref_replace(dst->dev, net->loopback_dev,

drivers/net/vrf.c

766

&dst->dev_tracker, GFP_KERNEL);

drivers/net/vrf.c

767

dst->dev = net->loopback_dev;

drivers/net/vrf.c

768

dst_release(dst);

drivers/net/vrf.c

793

rt6->dst.output = vrf_output6;

drivers/net/vrf.c

822

struct dst_entry *dst = skb_dst(skb);

drivers/net/vrf.c

823

struct rtable *rt = dst_rtable(dst);

drivers/net/vrf.c

824

struct net_device *dev = dst->dev;

drivers/net/vrf.c

881

struct dst_entry *dst = NULL;

drivers/net/vrf.c

888

dst = &rth->dst;

drivers/net/vrf.c

889

dst_hold(dst);

drivers/net/vrf.c

894

if (unlikely(!dst)) {

drivers/net/vrf.c

900

skb_dst_set(skb, dst);

drivers/net/vxlan/vxlan_core.c

2188

static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,

drivers/net/vxlan/vxlan_core.c

2211

min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len

drivers/net/vxlan/vxlan_core.c

2309

struct dst_entry *dst,

drivers/net/vxlan/vxlan_core.c

2325

dst_release(dst);

drivers/net/vxlan/vxlan_core.c

2402

key.u.ipv4.dst = rdst->remote_ip.sin.sin_addr.s_addr;

drivers/net/vxlan/vxlan_core.c

2405

key.u.ipv6.dst = rdst->remote_ip.sin6.sin6_addr;

drivers/net/vxlan/vxlan_core.c

2497

&rt->dst, rt->rt_flags);

drivers/net/vxlan/vxlan_core.c

2516

ndst = &rt->dst;

drivers/net/vxlan/vxlan_core.c

2529

unclone->key.u.ipv4.src = pkey->u.ipv4.dst;

drivers/net/vxlan/vxlan_core.c

2530

unclone->key.u.ipv4.dst = saddr;

drivers/net/vxlan/vxlan_core.c

2538

ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);

drivers/net/vxlan/vxlan_core.c

2547

pkey->u.ipv4.dst, tos, ttl, df,

drivers/net/vxlan/vxlan_core.c

2602

unclone->key.u.ipv6.src = pkey->u.ipv6.dst;

drivers/net/vxlan/vxlan_core.c

2603

unclone->key.u.ipv6.dst = saddr;

drivers/net/vxlan/vxlan_core.c

2622

&saddr, &pkey->u.ipv6.dst, tos, ttl,

drivers/net/vxlan/vxlan_core.c

3210

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

3212

dst->remote_ifindex);

drivers/net/vxlan/vxlan_core.c

3525

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

3527

dst->remote_ifindex);

drivers/net/vxlan/vxlan_core.c

3893

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

3910

dst->remote_vni = conf->vni;

drivers/net/vxlan/vxlan_core.c

3912

memcpy(&dst->remote_ip, &conf->remote_ip, sizeof(conf->remote_ip));

drivers/net/vxlan/vxlan_core.c

3915

dst->remote_ifindex = conf->remote_ifindex;

drivers/net/vxlan/vxlan_core.c

3967

struct vxlan_rdst *dst;

drivers/net/vxlan/vxlan_core.c

3970

dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

3981

if (dst->remote_ifindex) {

drivers/net/vxlan/vxlan_core.c

3982

remote_dev = __dev_get_by_index(net, dst->remote_ifindex);

drivers/net/vxlan/vxlan_core.c

3992

dst->remote_dev = remote_dev;

drivers/net/vxlan/vxlan_core.c

4000

if (!vxlan_addr_any(&dst->remote_ip)) {

drivers/net/vxlan/vxlan_core.c

4003

&dst->remote_ip,

drivers/net/vxlan/vxlan_core.c

4007

dst->remote_vni,

drivers/net/vxlan/vxlan_core.c

4008

dst->remote_vni,

drivers/net/vxlan/vxlan_core.c

4009

dst->remote_ifindex,

drivers/net/vxlan/vxlan_core.c

4421

struct vxlan_rdst *dst;

drivers/net/vxlan/vxlan_core.c

4424

dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

4434

if (dst->remote_dev == lowerdev)

drivers/net/vxlan/vxlan_core.c

4437

err = netdev_adjacent_change_prepare(dst->remote_dev, lowerdev, dev,

drivers/net/vxlan/vxlan_core.c

4442

rem_ip_changed = !vxlan_addr_equal(&conf.remote_ip, &dst->remote_ip);

drivers/net/vxlan/vxlan_core.c

4445

dst->remote_ifindex != conf.remote_ifindex);

drivers/net/vxlan/vxlan_core.c

4461

netdev_adjacent_change_abort(dst->remote_dev,

drivers/net/vxlan/vxlan_core.c

4466

if (!vxlan_addr_any(&dst->remote_ip))

drivers/net/vxlan/vxlan_core.c

4468

dst->remote_ip,

drivers/net/vxlan/vxlan_core.c

4470

dst->remote_vni,

drivers/net/vxlan/vxlan_core.c

4471

dst->remote_vni,

drivers/net/vxlan/vxlan_core.c

4472

dst->remote_ifindex,

drivers/net/vxlan/vxlan_core.c

4480

err = vxlan_vnilist_update_group(vxlan, &dst->remote_ip,

drivers/net/vxlan/vxlan_core.c

4483

netdev_adjacent_change_abort(dst->remote_dev,

drivers/net/vxlan/vxlan_core.c

4490

if (change_igmp && vxlan_addr_multicast(&dst->remote_ip))

drivers/net/vxlan/vxlan_core.c

4496

netdev_adjacent_change_commit(dst->remote_dev, lowerdev, dev);

drivers/net/vxlan/vxlan_core.c

4497

if (lowerdev && lowerdev != dst->remote_dev)

drivers/net/vxlan/vxlan_core.c

4498

dst->remote_dev = lowerdev;

drivers/net/vxlan/vxlan_core.c

4502

vxlan_addr_multicast(&dst->remote_ip))

drivers/net/vxlan/vxlan_core.c

4562

const struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

4568

if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))

drivers/net/vxlan/vxlan_core.c

4571

if (!vxlan_addr_any(&dst->remote_ip)) {

drivers/net/vxlan/vxlan_core.c

4572

if (dst->remote_ip.sa.sa_family == AF_INET) {

drivers/net/vxlan/vxlan_core.c

4574

dst->remote_ip.sin.sin_addr.s_addr))

drivers/net/vxlan/vxlan_core.c

4579

&dst->remote_ip.sin6.sin6_addr))

drivers/net/vxlan/vxlan_core.c

4585

if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))

drivers/net/vxlan/vxlan_core.c

4732

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_core.c

4740

if (dst->remote_ifindex == dev->ifindex)

drivers/net/vxlan/vxlan_mdb.c

102

const union vxlan_addr *dst = &mdb_entry->key.dst;

drivers/net/vxlan/vxlan_mdb.c

111

switch (dst->sa.sa_family) {

drivers/net/vxlan/vxlan_mdb.c

113

e->addr.u.ip4 = dst->sin.sin_addr.s_addr;

drivers/net/vxlan/vxlan_mdb.c

118

e->addr.u.ip6 = dst->sin6.sin6_addr;

drivers/net/vxlan/vxlan_mdb.c

1630

group.dst.sa.sa_family = AF_INET;

drivers/net/vxlan/vxlan_mdb.c

1631

group.dst.sin.sin_addr.s_addr = ip_hdr(skb)->daddr;

drivers/net/vxlan/vxlan_mdb.c

1639

group.dst.sa.sa_family = AF_INET6;

drivers/net/vxlan/vxlan_mdb.c

1640

group.dst.sin6.sin6_addr = ipv6_hdr(skb)->daddr;

drivers/net/vxlan/vxlan_mdb.c

1665

if (ipv4_is_local_multicast(group.dst.sin.sin_addr.s_addr))

drivers/net/vxlan/vxlan_mdb.c

1667

group.dst.sin.sin_addr.s_addr = 0;

drivers/net/vxlan/vxlan_mdb.c

1671

if (ipv6_addr_type(&group.dst.sin6.sin6_addr) &

drivers/net/vxlan/vxlan_mdb.c

1674

memset(&group.dst.sin6.sin6_addr, 0,

drivers/net/vxlan/vxlan_mdb.c

1675

sizeof(group.dst.sin6.sin6_addr));

drivers/net/vxlan/vxlan_mdb.c

20

union vxlan_addr dst;

drivers/net/vxlan/vxlan_mdb.c

387

group->dst.sa.sa_family = AF_INET;

drivers/net/vxlan/vxlan_mdb.c

388

group->dst.sin.sin_addr.s_addr = entry->addr.u.ip4;

drivers/net/vxlan/vxlan_mdb.c

392

group->dst.sa.sa_family = AF_INET6;

drivers/net/vxlan/vxlan_mdb.c

393

group->dst.sin6.sin6_addr = entry->addr.u.ip6;

drivers/net/vxlan/vxlan_mdb.c

404

return !vxlan_addr_any(&group->dst) && vxlan_addr_any(&group->src);

drivers/net/vxlan/vxlan_mdb.c

409

return !vxlan_addr_any(&group->dst) && !vxlan_addr_any(&group->src);

drivers/net/vxlan/vxlan_mdb.c

517

if (!vxlan_addr_is_multicast(&cfg->group.dst) &&

drivers/net/vxlan/vxlan_mdb.c

518

!vxlan_addr_any(&cfg->group.dst)) {

drivers/net/vxlan/vxlan_mdb.c

523

if (vxlan_addr_any(&cfg->group.dst) &&

drivers/net/vxlan/vxlan_mdb.c

797

sg_cfg.group.dst = cfg->group.dst;

drivers/net/vxlan/vxlan_mdb.c

825

sg_cfg.group.dst = group->dst;

drivers/net/vxlan/vxlan_mdb.c

928

nla_total_size(vxlan_addr_size(&group->dst)) +

drivers/net/vxlan/vxlan_mdb.c

952

nlmsg_size += nla_total_size(vxlan_addr_size(&group->dst));

drivers/net/vxlan/vxlan_vnifilter.c

480

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_vnifilter.c

492

dst->remote_ifindex,

drivers/net/vxlan/vxlan_vnifilter.c

505

dst->remote_ifindex,

drivers/net/vxlan/vxlan_vnifilter.c

520

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_vnifilter.c

533

if (!vxlan_addr_any(&dst->remote_ip))

drivers/net/vxlan/vxlan_vnifilter.c

534

newrip = &dst->remote_ip;

drivers/net/vxlan/vxlan_vnifilter.c

617

struct vxlan_rdst *dst = &vxlan->default_dst;

drivers/net/vxlan/vxlan_vnifilter.c

623

!vxlan_addr_any(&dst->remote_ip)) {

drivers/net/vxlan/vxlan_vnifilter.c

627

dst->remote_ip : vninode->remote_ip),

drivers/net/vxlan/vxlan_vnifilter.c

630

dst->remote_ifindex,

drivers/net/vxlan/vxlan_vnifilter.c

639

dst->remote_ifindex)) {

drivers/net/wireguard/allowedips.c

13

static void swap_endian(u8 *dst, const u8 *src, u8 bits)

drivers/net/wireguard/allowedips.c

16

*(u32 *)dst = be32_to_cpu(*(const __be32 *)src);

drivers/net/wireguard/allowedips.c

18

((u64 *)dst)[0] = get_unaligned_be64(src);

drivers/net/wireguard/allowedips.c

19

((u64 *)dst)[1] = get_unaligned_be64(src + 8);

drivers/net/wireguard/cookie.c

180

void wg_cookie_message_create(struct message_handshake_cookie *dst,

drivers/net/wireguard/cookie.c

188

dst->header.type = cpu_to_le32(MESSAGE_HANDSHAKE_COOKIE);

drivers/net/wireguard/cookie.c

189

dst->receiver_index = index;

drivers/net/wireguard/cookie.c

190

get_random_bytes_wait(dst->nonce, COOKIE_NONCE_LEN);

drivers/net/wireguard/cookie.c

193

xchacha20poly1305_encrypt(dst->encrypted_cookie, cookie, COOKIE_LEN,

drivers/net/wireguard/cookie.c

194

macs->mac1, COOKIE_LEN, dst->nonce,

drivers/net/wireguard/noise.c

517

wg_noise_handshake_create_initiation(struct message_handshake_initiation *dst,

drivers/net/wireguard/noise.c

535

dst->header.type = cpu_to_le32(MESSAGE_HANDSHAKE_INITIATION);

drivers/net/wireguard/noise.c

542

if (!curve25519_generate_public(dst->unencrypted_ephemeral,

drivers/net/wireguard/noise.c

545

message_ephemeral(dst->unencrypted_ephemeral,

drivers/net/wireguard/noise.c

546

dst->unencrypted_ephemeral, handshake->chaining_key,

drivers/net/wireguard/noise.c

555

message_encrypt(dst->encrypted_static,

drivers/net/wireguard/noise.c

566

message_encrypt(dst->encrypted_timestamp, timestamp,

drivers/net/wireguard/noise.c

569

dst->sender_index = wg_index_hashtable_insert(

drivers/net/wireguard/noise.c

667

bool wg_noise_handshake_create_response(struct message_handshake_response *dst,

drivers/net/wireguard/noise.c

684

dst->header.type = cpu_to_le32(MESSAGE_HANDSHAKE_RESPONSE);

drivers/net/wireguard/noise.c

685

dst->receiver_index = handshake->remote_index;

drivers/net/wireguard/noise.c

689

if (!curve25519_generate_public(dst->unencrypted_ephemeral,

drivers/net/wireguard/noise.c

692

message_ephemeral(dst->unencrypted_ephemeral,

drivers/net/wireguard/noise.c

693

dst->unencrypted_ephemeral, handshake->chaining_key,

drivers/net/wireguard/noise.c

711

message_encrypt(dst->encrypted_nothing, NULL, 0, key, handshake->hash);

drivers/net/wireguard/noise.c

713

dst->sender_index = wg_index_hashtable_insert(

drivers/net/wireguard/noise.h

120

wg_noise_handshake_create_initiation(struct message_handshake_initiation *dst,

drivers/net/wireguard/noise.h

126

bool wg_noise_handshake_create_response(struct message_handshake_response *dst,

drivers/net/wireguard/socket.c

110

struct dst_entry *dst = NULL;

drivers/net/wireguard/socket.c

129

dst = dst_cache_get_ip6(cache, &fl.saddr);

drivers/net/wireguard/socket.c

131

if (!dst) {

drivers/net/wireguard/socket.c

139

dst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(sock), sock, &fl,

drivers/net/wireguard/socket.c

141

if (IS_ERR(dst)) {

drivers/net/wireguard/socket.c

142

ret = PTR_ERR(dst);

drivers/net/wireguard/socket.c

148

dst_cache_set_ip6(cache, dst, &fl.saddr);

drivers/net/wireguard/socket.c

152

udp_tunnel6_xmit_skb(dst, sock, skb, skb->dev, &fl.saddr, &fl.daddr, ds,

drivers/net/wireguard/socket.c

153

ip6_dst_hoplimit(dst), 0, fl.fl6_sport,

drivers/net/wireguard/socket.c

64

rt->dst.dev->ifindex != endpoint->src_if4)))) {

drivers/net/wireguard/socket.c

81

dst_cache_set_ip4(cache, &rt->dst, fl.saddr);

drivers/net/wireguard/socket.c

86

ip4_dst_hoplimit(&rt->dst), 0, fl.fl4_sport,

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

947

u8 dst[ETH_ALEN];

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1454

struct ath10k_fw_stats_vdev *dst)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1458

dst->vdev_id = __le32_to_cpu(src->vdev_id);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1459

dst->beacon_snr = __le32_to_cpu(src->beacon_snr);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1460

dst->data_snr = __le32_to_cpu(src->data_snr);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1461

dst->num_rx_frames = __le32_to_cpu(src->num_rx_frames);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1462

dst->num_rts_fail = __le32_to_cpu(src->num_rts_fail);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1463

dst->num_rts_success = __le32_to_cpu(src->num_rts_success);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1464

dst->num_rx_err = __le32_to_cpu(src->num_rx_err);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1465

dst->num_rx_discard = __le32_to_cpu(src->num_rx_discard);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1466

dst->num_tx_not_acked = __le32_to_cpu(src->num_tx_not_acked);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1469

dst->num_tx_frames[i] =

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1473

dst->num_tx_frames_retries[i] =

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1477

dst->num_tx_frames_failures[i] =

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1481

dst->tx_rate_history[i] =

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1485

dst->beacon_rssi_history[i] =

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1538

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1549

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1550

if (!dst)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1553

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1554

ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1555

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1556

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1561

struct ath10k_fw_stats_vdev *dst;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1572

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1573

if (!dst)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1576

ath10k_wmi_tlv_pull_vdev_stats(src, dst);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1577

list_add_tail(&dst->list, &stats->vdevs);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1582

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1593

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1594

if (!dst)

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1597

ath10k_wmi_pull_peer_stats(&src->old, dst);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1598

dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1607

dst->rx_duration = __le32_to_cpu(extd->rx_duration);

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1616

dst->rx_duration |= (u64)rx_duration_high <<

drivers/net/wireless/ath/ath10k/wmi-tlv.c

1621

list_add_tail(&dst->list, &stats->peers);

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

2878

struct ath10k_fw_stats_pdev *dst)

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

2880

dst->ch_noise_floor = __le32_to_cpu(src->chan_nf);

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

2881

dst->tx_frame_count = __le32_to_cpu(src->tx_frame_count);

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

2882

dst->rx_frame_count = __le32_to_cpu(src->rx_frame_count);

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

2883

dst->rx_clear_count = __le32_to_cpu(src->rx_clear_count);

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

2884

dst->cycle_count = __le32_to_cpu(src->cycle_count);

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

2885

dst->phy_err_count = __le32_to_cpu(src->phy_err_count);

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

2886

dst->chan_tx_power = __le32_to_cpu(src->chan_tx_pwr);

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

2890

struct ath10k_fw_stats_pdev *dst)

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

2892

dst->comp_queued = __le32_to_cpu(src->comp_queued);

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

2893

dst->comp_delivered = __le32_to_cpu(src->comp_delivered);

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

2894

dst->msdu_enqued = __le32_to_cpu(src->msdu_enqued);

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

2895

dst->mpdu_enqued = __le32_to_cpu(src->mpdu_enqued);

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

2896

dst->wmm_drop = __le32_to_cpu(src->wmm_drop);

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

2897

dst->local_enqued = __le32_to_cpu(src->local_enqued);

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

2898

dst->local_freed = __le32_to_cpu(src->local_freed);

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

2899

dst->hw_queued = __le32_to_cpu(src->hw_queued);

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

2900

dst->hw_reaped = __le32_to_cpu(src->hw_reaped);

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

2901

dst->underrun = __le32_to_cpu(src->underrun);

drivers/net/wireless/ath/ath10k/wmi.c

2902

dst->tx_abort = __le32_to_cpu(src->tx_abort);

drivers/net/wireless/ath/ath10k/wmi.c

2903

dst->mpdus_requeued = __le32_to_cpu(src->mpdus_requeued);

drivers/net/wireless/ath/ath10k/wmi.c

2904

dst->tx_ko = __le32_to_cpu(src->tx_ko);

drivers/net/wireless/ath/ath10k/wmi.c

2905

dst->data_rc = __le32_to_cpu(src->data_rc);

drivers/net/wireless/ath/ath10k/wmi.c

2906

dst->self_triggers = __le32_to_cpu(src->self_triggers);

drivers/net/wireless/ath/ath10k/wmi.c

2907

dst->sw_retry_failure = __le32_to_cpu(src->sw_retry_failure);

drivers/net/wireless/ath/ath10k/wmi.c

2908

dst->illgl_rate_phy_err = __le32_to_cpu(src->illgl_rate_phy_err);

drivers/net/wireless/ath/ath10k/wmi.c

2909

dst->pdev_cont_xretry = __le32_to_cpu(src->pdev_cont_xretry);

drivers/net/wireless/ath/ath10k/wmi.c

2910

dst->pdev_tx_timeout = __le32_to_cpu(src->pdev_tx_timeout);

drivers/net/wireless/ath/ath10k/wmi.c

2911

dst->pdev_resets = __le32_to_cpu(src->pdev_resets);

drivers/net/wireless/ath/ath10k/wmi.c

2912

dst->phy_underrun = __le32_to_cpu(src->phy_underrun);

drivers/net/wireless/ath/ath10k/wmi.c

2913

dst->txop_ovf = __le32_to_cpu(src->txop_ovf);

drivers/net/wireless/ath/ath10k/wmi.c

2918

struct ath10k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath10k/wmi.c

2920

dst->comp_queued = __le32_to_cpu(src->comp_queued);

drivers/net/wireless/ath/ath10k/wmi.c

2921

dst->comp_delivered = __le32_to_cpu(src->comp_delivered);

drivers/net/wireless/ath/ath10k/wmi.c

2922

dst->msdu_enqued = __le32_to_cpu(src->msdu_enqued);

drivers/net/wireless/ath/ath10k/wmi.c

2923

dst->mpdu_enqued = __le32_to_cpu(src->mpdu_enqued);

drivers/net/wireless/ath/ath10k/wmi.c

2924

dst->wmm_drop = __le32_to_cpu(src->wmm_drop);

drivers/net/wireless/ath/ath10k/wmi.c

2925

dst->local_enqued = __le32_to_cpu(src->local_enqued);

drivers/net/wireless/ath/ath10k/wmi.c

2926

dst->local_freed = __le32_to_cpu(src->local_freed);

drivers/net/wireless/ath/ath10k/wmi.c

2927

dst->hw_queued = __le32_to_cpu(src->hw_queued);

drivers/net/wireless/ath/ath10k/wmi.c

2928

dst->hw_reaped = __le32_to_cpu(src->hw_reaped);

drivers/net/wireless/ath/ath10k/wmi.c

2929

dst->underrun = __le32_to_cpu(src->underrun);

drivers/net/wireless/ath/ath10k/wmi.c

2930

dst->tx_abort = __le32_to_cpu(src->tx_abort);

drivers/net/wireless/ath/ath10k/wmi.c

2931

dst->mpdus_requeued = __le32_to_cpu(src->mpdus_requeued);

drivers/net/wireless/ath/ath10k/wmi.c

2932

dst->tx_ko = __le32_to_cpu(src->tx_ko);

drivers/net/wireless/ath/ath10k/wmi.c

2933

dst->data_rc = __le32_to_cpu(src->data_rc);

drivers/net/wireless/ath/ath10k/wmi.c

2934

dst->self_triggers = __le32_to_cpu(src->self_triggers);

drivers/net/wireless/ath/ath10k/wmi.c

2935

dst->sw_retry_failure = __le32_to_cpu(src->sw_retry_failure);

drivers/net/wireless/ath/ath10k/wmi.c

2936

dst->illgl_rate_phy_err = __le32_to_cpu(src->illgl_rate_phy_err);

drivers/net/wireless/ath/ath10k/wmi.c

2937

dst->pdev_cont_xretry = __le32_to_cpu(src->pdev_cont_xretry);

drivers/net/wireless/ath/ath10k/wmi.c

2938

dst->pdev_tx_timeout = __le32_to_cpu(src->pdev_tx_timeout);

drivers/net/wireless/ath/ath10k/wmi.c

2939

dst->pdev_resets = __le32_to_cpu(src->pdev_resets);

drivers/net/wireless/ath/ath10k/wmi.c

2940

dst->phy_underrun = __le32_to_cpu(src->phy_underrun);

drivers/net/wireless/ath/ath10k/wmi.c

2941

dst->txop_ovf = __le32_to_cpu(src->txop_ovf);

drivers/net/wireless/ath/ath10k/wmi.c

2942

dst->hw_paused = __le32_to_cpu(src->hw_paused);

drivers/net/wireless/ath/ath10k/wmi.c

2943

dst->seq_posted = __le32_to_cpu(src->seq_posted);

drivers/net/wireless/ath/ath10k/wmi.c

2944

dst->seq_failed_queueing =

drivers/net/wireless/ath/ath10k/wmi.c

2946

dst->seq_completed = __le32_to_cpu(src->seq_completed);

drivers/net/wireless/ath/ath10k/wmi.c

2947

dst->seq_restarted = __le32_to_cpu(src->seq_restarted);

drivers/net/wireless/ath/ath10k/wmi.c

2948

dst->mu_seq_posted = __le32_to_cpu(src->mu_seq_posted);

drivers/net/wireless/ath/ath10k/wmi.c

2949

dst->mpdus_sw_flush = __le32_to_cpu(src->mpdus_sw_flush);

drivers/net/wireless/ath/ath10k/wmi.c

2950

dst->mpdus_hw_filter = __le32_to_cpu(src->mpdus_hw_filter);

drivers/net/wireless/ath/ath10k/wmi.c

2951

dst->mpdus_truncated = __le32_to_cpu(src->mpdus_truncated);

drivers/net/wireless/ath/ath10k/wmi.c

2952

dst->mpdus_ack_failed = __le32_to_cpu(src->mpdus_ack_failed);

drivers/net/wireless/ath/ath10k/wmi.c

2953

dst->mpdus_hw_filter = __le32_to_cpu(src->mpdus_hw_filter);

drivers/net/wireless/ath/ath10k/wmi.c

2954

dst->mpdus_expired = __le32_to_cpu(src->mpdus_expired);

drivers/net/wireless/ath/ath10k/wmi.c

2958

struct ath10k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath10k/wmi.c

2960

dst->mid_ppdu_route_change = __le32_to_cpu(src->mid_ppdu_route_change);

drivers/net/wireless/ath/ath10k/wmi.c

2961

dst->status_rcvd = __le32_to_cpu(src->status_rcvd);

drivers/net/wireless/ath/ath10k/wmi.c

2962

dst->r0_frags = __le32_to_cpu(src->r0_frags);

drivers/net/wireless/ath/ath10k/wmi.c

2963

dst->r1_frags = __le32_to_cpu(src->r1_frags);

drivers/net/wireless/ath/ath10k/wmi.c

2964

dst->r2_frags = __le32_to_cpu(src->r2_frags);

drivers/net/wireless/ath/ath10k/wmi.c

2965

dst->r3_frags = __le32_to_cpu(src->r3_frags);

drivers/net/wireless/ath/ath10k/wmi.c

2966

dst->htt_msdus = __le32_to_cpu(src->htt_msdus);

drivers/net/wireless/ath/ath10k/wmi.c

2967

dst->htt_mpdus = __le32_to_cpu(src->htt_mpdus);

drivers/net/wireless/ath/ath10k/wmi.c

2968

dst->loc_msdus = __le32_to_cpu(src->loc_msdus);

drivers/net/wireless/ath/ath10k/wmi.c

2969

dst->loc_mpdus = __le32_to_cpu(src->loc_mpdus);

drivers/net/wireless/ath/ath10k/wmi.c

2970

dst->oversize_amsdu = __le32_to_cpu(src->oversize_amsdu);

drivers/net/wireless/ath/ath10k/wmi.c

2971

dst->phy_errs = __le32_to_cpu(src->phy_errs);

drivers/net/wireless/ath/ath10k/wmi.c

2972

dst->phy_err_drop = __le32_to_cpu(src->phy_err_drop);

drivers/net/wireless/ath/ath10k/wmi.c

2973

dst->mpdu_errs = __le32_to_cpu(src->mpdu_errs);

drivers/net/wireless/ath/ath10k/wmi.c

2977

struct ath10k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath10k/wmi.c

2979

dst->ack_rx_bad = __le32_to_cpu(src->ack_rx_bad);

drivers/net/wireless/ath/ath10k/wmi.c

2980

dst->rts_bad = __le32_to_cpu(src->rts_bad);

drivers/net/wireless/ath/ath10k/wmi.c

2981

dst->rts_good = __le32_to_cpu(src->rts_good);

drivers/net/wireless/ath/ath10k/wmi.c

2982

dst->fcs_bad = __le32_to_cpu(src->fcs_bad);

drivers/net/wireless/ath/ath10k/wmi.c

2983

dst->no_beacons = __le32_to_cpu(src->no_beacons);

drivers/net/wireless/ath/ath10k/wmi.c

2984

dst->mib_int_count = __le32_to_cpu(src->mib_int_count);

drivers/net/wireless/ath/ath10k/wmi.c

2988

struct ath10k_fw_stats_peer *dst)

drivers/net/wireless/ath/ath10k/wmi.c

2990

ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);

drivers/net/wireless/ath/ath10k/wmi.c

2991

dst->peer_rssi = __le32_to_cpu(src->peer_rssi);

drivers/net/wireless/ath/ath10k/wmi.c

2992

dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

2997

struct ath10k_fw_stats_peer *dst)

drivers/net/wireless/ath/ath10k/wmi.c

2999

ether_addr_copy(dst->peer_macaddr, src->peer_macaddr.addr);

drivers/net/wireless/ath/ath10k/wmi.c

3000

dst->peer_rssi = __le32_to_cpu(src->peer_rssi);

drivers/net/wireless/ath/ath10k/wmi.c

3001

dst->peer_tx_rate = __le32_to_cpu(src->peer_tx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

3002

dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

3007

struct ath10k_fw_stats_vdev_extd *dst)

drivers/net/wireless/ath/ath10k/wmi.c

3009

dst->vdev_id = __le32_to_cpu(src->vdev_id);

drivers/net/wireless/ath/ath10k/wmi.c

3010

dst->ppdu_aggr_cnt = __le32_to_cpu(src->ppdu_aggr_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3011

dst->ppdu_noack = __le32_to_cpu(src->ppdu_noack);

drivers/net/wireless/ath/ath10k/wmi.c

3012

dst->mpdu_queued = __le32_to_cpu(src->mpdu_queued);

drivers/net/wireless/ath/ath10k/wmi.c

3013

dst->ppdu_nonaggr_cnt = __le32_to_cpu(src->ppdu_nonaggr_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3014

dst->mpdu_sw_requeued = __le32_to_cpu(src->mpdu_sw_requeued);

drivers/net/wireless/ath/ath10k/wmi.c

3015

dst->mpdu_suc_retry = __le32_to_cpu(src->mpdu_suc_retry);

drivers/net/wireless/ath/ath10k/wmi.c

3016

dst->mpdu_suc_multitry = __le32_to_cpu(src->mpdu_suc_multitry);

drivers/net/wireless/ath/ath10k/wmi.c

3017

dst->mpdu_fail_retry = __le32_to_cpu(src->mpdu_fail_retry);

drivers/net/wireless/ath/ath10k/wmi.c

3018

dst->tx_ftm_suc = __le32_to_cpu(src->tx_ftm_suc);

drivers/net/wireless/ath/ath10k/wmi.c

3019

dst->tx_ftm_suc_retry = __le32_to_cpu(src->tx_ftm_suc_retry);

drivers/net/wireless/ath/ath10k/wmi.c

3020

dst->tx_ftm_fail = __le32_to_cpu(src->tx_ftm_fail);

drivers/net/wireless/ath/ath10k/wmi.c

3021

dst->rx_ftmr_cnt = __le32_to_cpu(src->rx_ftmr_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3022

dst->rx_ftmr_dup_cnt = __le32_to_cpu(src->rx_ftmr_dup_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3023

dst->rx_iftmr_cnt = __le32_to_cpu(src->rx_iftmr_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3024

dst->rx_iftmr_dup_cnt = __le32_to_cpu(src->rx_iftmr_dup_cnt);

drivers/net/wireless/ath/ath10k/wmi.c

3043

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3049

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3050

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3053

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3054

ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3055

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3057

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi.c

3064

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3070

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3071

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3074

ath10k_wmi_pull_peer_stats(src, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3075

list_add_tail(&dst->list, &stats->peers);

drivers/net/wireless/ath/ath10k/wmi.c

3097

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3103

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3104

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3107

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3108

ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3109

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3110

ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3112

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi.c

3119

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3125

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3126

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3129

ath10k_wmi_pull_peer_stats(&src->old, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3131

dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

3133

list_add_tail(&dst->list, &stats->peers);

drivers/net/wireless/ath/ath10k/wmi.c

3158

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3164

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3165

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3168

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3169

ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3170

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3171

ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3174

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi.c

3195

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3201

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3202

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3205

ath10k_wmi_pull_peer_stats(&src->old, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3207

dst->peer_rx_rate = __le32_to_cpu(src->peer_rx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

3210

list_add_tail(&dst->list, &stats->peers);

drivers/net/wireless/ath/ath10k/wmi.c

3235

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3241

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3242

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3245

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3246

ath10k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3247

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3248

ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3251

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi.c

3272

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3284

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3285

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3288

ath10k_wmi_pull_peer_stats(&src->common.old, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3290

dst->peer_rx_rate = __le32_to_cpu(src->common.peer_rx_rate);

drivers/net/wireless/ath/ath10k/wmi.c

3293

dst->rx_duration = __le32_to_cpu(src->rx_duration);

drivers/net/wireless/ath/ath10k/wmi.c

3296

list_add_tail(&dst->list, &stats->peers);

drivers/net/wireless/ath/ath10k/wmi.c

3327

struct ath10k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3333

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3334

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3337

ath10k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3338

ath10k_wmi_10_4_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3339

ath10k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3340

dst->rx_ovfl_errs = __le32_to_cpu(src->rx_ovfl_errs);

drivers/net/wireless/ath/ath10k/wmi.c

3341

ath10k_wmi_pull_pdev_stats_extra(&src->extra, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3343

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath10k/wmi.c

3373

struct ath10k_fw_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3379

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3380

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3383

ath10k_wmi_10_4_pull_peer_stats(src, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3384

list_add_tail(&dst->list, &stats->peers);

drivers/net/wireless/ath/ath10k/wmi.c

3406

struct ath10k_fw_extd_stats_peer *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3412

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3413

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3416

ether_addr_copy(dst->peer_macaddr,

drivers/net/wireless/ath/ath10k/wmi.c

3418

dst->rx_duration = __le32_to_cpu(src->rx_duration);

drivers/net/wireless/ath/ath10k/wmi.c

3419

list_add_tail(&dst->list, &stats->peers_extd);

drivers/net/wireless/ath/ath10k/wmi.c

3426

struct ath10k_fw_stats_vdev_extd *dst;

drivers/net/wireless/ath/ath10k/wmi.c

3432

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath10k/wmi.c

3433

if (!dst)

drivers/net/wireless/ath/ath10k/wmi.c

3435

ath10k_wmi_10_4_pull_vdev_stats(src, dst);

drivers/net/wireless/ath/ath10k/wmi.c

3436

list_add_tail(&dst->list, &stats->vdevs);

drivers/net/wireless/ath/ath10k/wmi.h

7459

struct ath10k_fw_stats_pdev *dst);

drivers/net/wireless/ath/ath10k/wmi.h

7461

struct ath10k_fw_stats_pdev *dst);

drivers/net/wireless/ath/ath10k/wmi.h

7463

struct ath10k_fw_stats_pdev *dst);

drivers/net/wireless/ath/ath10k/wmi.h

7465

struct ath10k_fw_stats_pdev *dst);

drivers/net/wireless/ath/ath10k/wmi.h

7467

struct ath10k_fw_stats_peer *dst);

drivers/net/wireless/ath/ath11k/dp_rx.h

32

u8 dst[ETH_ALEN];

drivers/net/wireless/ath/ath11k/wmi.c

6474

struct ath11k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath11k/wmi.c

6476

dst->ch_noise_floor = src->chan_nf;

drivers/net/wireless/ath/ath11k/wmi.c

6477

dst->tx_frame_count = src->tx_frame_count;

drivers/net/wireless/ath/ath11k/wmi.c

6478

dst->rx_frame_count = src->rx_frame_count;

drivers/net/wireless/ath/ath11k/wmi.c

6479

dst->rx_clear_count = src->rx_clear_count;

drivers/net/wireless/ath/ath11k/wmi.c

6480

dst->cycle_count = src->cycle_count;

drivers/net/wireless/ath/ath11k/wmi.c

6481

dst->phy_err_count = src->phy_err_count;

drivers/net/wireless/ath/ath11k/wmi.c

6482

dst->chan_tx_power = src->chan_tx_pwr;

drivers/net/wireless/ath/ath11k/wmi.c

6487

struct ath11k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath11k/wmi.c

6489

dst->comp_queued = src->comp_queued;

drivers/net/wireless/ath/ath11k/wmi.c

6490

dst->comp_delivered = src->comp_delivered;

drivers/net/wireless/ath/ath11k/wmi.c

6491

dst->msdu_enqued = src->msdu_enqued;

drivers/net/wireless/ath/ath11k/wmi.c

6492

dst->mpdu_enqued = src->mpdu_enqued;

drivers/net/wireless/ath/ath11k/wmi.c

6493

dst->wmm_drop = src->wmm_drop;

drivers/net/wireless/ath/ath11k/wmi.c

6494

dst->local_enqued = src->local_enqued;

drivers/net/wireless/ath/ath11k/wmi.c

6495

dst->local_freed = src->local_freed;

drivers/net/wireless/ath/ath11k/wmi.c

6496

dst->hw_queued = src->hw_queued;

drivers/net/wireless/ath/ath11k/wmi.c

6497

dst->hw_reaped = src->hw_reaped;

drivers/net/wireless/ath/ath11k/wmi.c

6498

dst->underrun = src->underrun;

drivers/net/wireless/ath/ath11k/wmi.c

6499

dst->hw_paused = src->hw_paused;

drivers/net/wireless/ath/ath11k/wmi.c

6500

dst->tx_abort = src->tx_abort;

drivers/net/wireless/ath/ath11k/wmi.c

6501

dst->mpdus_requeued = src->mpdus_requeued;

drivers/net/wireless/ath/ath11k/wmi.c

6502

dst->tx_ko = src->tx_ko;

drivers/net/wireless/ath/ath11k/wmi.c

6503

dst->tx_xretry = src->tx_xretry;

drivers/net/wireless/ath/ath11k/wmi.c

6504

dst->data_rc = src->data_rc;

drivers/net/wireless/ath/ath11k/wmi.c

6505

dst->self_triggers = src->self_triggers;

drivers/net/wireless/ath/ath11k/wmi.c

6506

dst->sw_retry_failure = src->sw_retry_failure;

drivers/net/wireless/ath/ath11k/wmi.c

6507

dst->illgl_rate_phy_err = src->illgl_rate_phy_err;

drivers/net/wireless/ath/ath11k/wmi.c

6508

dst->pdev_cont_xretry = src->pdev_cont_xretry;

drivers/net/wireless/ath/ath11k/wmi.c

6509

dst->pdev_tx_timeout = src->pdev_tx_timeout;

drivers/net/wireless/ath/ath11k/wmi.c

6510

dst->pdev_resets = src->pdev_resets;

drivers/net/wireless/ath/ath11k/wmi.c

6511

dst->stateless_tid_alloc_failure = src->stateless_tid_alloc_failure;

drivers/net/wireless/ath/ath11k/wmi.c

6512

dst->phy_underrun = src->phy_underrun;

drivers/net/wireless/ath/ath11k/wmi.c

6513

dst->txop_ovf = src->txop_ovf;

drivers/net/wireless/ath/ath11k/wmi.c

6514

dst->seq_posted = src->seq_posted;

drivers/net/wireless/ath/ath11k/wmi.c

6515

dst->seq_failed_queueing = src->seq_failed_queueing;

drivers/net/wireless/ath/ath11k/wmi.c

6516

dst->seq_completed = src->seq_completed;

drivers/net/wireless/ath/ath11k/wmi.c

6517

dst->seq_restarted = src->seq_restarted;

drivers/net/wireless/ath/ath11k/wmi.c

6518

dst->mu_seq_posted = src->mu_seq_posted;

drivers/net/wireless/ath/ath11k/wmi.c

6519

dst->mpdus_sw_flush = src->mpdus_sw_flush;

drivers/net/wireless/ath/ath11k/wmi.c

6520

dst->mpdus_hw_filter = src->mpdus_hw_filter;

drivers/net/wireless/ath/ath11k/wmi.c

6521

dst->mpdus_truncated = src->mpdus_truncated;

drivers/net/wireless/ath/ath11k/wmi.c

6522

dst->mpdus_ack_failed = src->mpdus_ack_failed;

drivers/net/wireless/ath/ath11k/wmi.c

6523

dst->mpdus_expired = src->mpdus_expired;

drivers/net/wireless/ath/ath11k/wmi.c

6527

struct ath11k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath11k/wmi.c

6529

dst->mid_ppdu_route_change = src->mid_ppdu_route_change;

drivers/net/wireless/ath/ath11k/wmi.c

6530

dst->status_rcvd = src->status_rcvd;

drivers/net/wireless/ath/ath11k/wmi.c

6531

dst->r0_frags = src->r0_frags;

drivers/net/wireless/ath/ath11k/wmi.c

6532

dst->r1_frags = src->r1_frags;

drivers/net/wireless/ath/ath11k/wmi.c

6533

dst->r2_frags = src->r2_frags;

drivers/net/wireless/ath/ath11k/wmi.c

6534

dst->r3_frags = src->r3_frags;

drivers/net/wireless/ath/ath11k/wmi.c

6535

dst->htt_msdus = src->htt_msdus;

drivers/net/wireless/ath/ath11k/wmi.c

6536

dst->htt_mpdus = src->htt_mpdus;

drivers/net/wireless/ath/ath11k/wmi.c

6537

dst->loc_msdus = src->loc_msdus;

drivers/net/wireless/ath/ath11k/wmi.c

6538

dst->loc_mpdus = src->loc_mpdus;

drivers/net/wireless/ath/ath11k/wmi.c

6539

dst->oversize_amsdu = src->oversize_amsdu;

drivers/net/wireless/ath/ath11k/wmi.c

6540

dst->phy_errs = src->phy_errs;

drivers/net/wireless/ath/ath11k/wmi.c

6541

dst->phy_err_drop = src->phy_err_drop;

drivers/net/wireless/ath/ath11k/wmi.c

6542

dst->mpdu_errs = src->mpdu_errs;

drivers/net/wireless/ath/ath11k/wmi.c

6543

dst->rx_ovfl_errs = src->rx_ovfl_errs;

drivers/net/wireless/ath/ath11k/wmi.c

6548

struct ath11k_fw_stats_vdev *dst)

drivers/net/wireless/ath/ath11k/wmi.c

6552

dst->vdev_id = src->vdev_id;

drivers/net/wireless/ath/ath11k/wmi.c

6553

dst->beacon_snr = src->beacon_snr;

drivers/net/wireless/ath/ath11k/wmi.c

6554

dst->data_snr = src->data_snr;

drivers/net/wireless/ath/ath11k/wmi.c

6555

dst->num_rx_frames = src->num_rx_frames;

drivers/net/wireless/ath/ath11k/wmi.c

6556

dst->num_rts_fail = src->num_rts_fail;

drivers/net/wireless/ath/ath11k/wmi.c

6557

dst->num_rts_success = src->num_rts_success;

drivers/net/wireless/ath/ath11k/wmi.c

6558

dst->num_rx_err = src->num_rx_err;

drivers/net/wireless/ath/ath11k/wmi.c

6559

dst->num_rx_discard = src->num_rx_discard;

drivers/net/wireless/ath/ath11k/wmi.c

6560

dst->num_tx_not_acked = src->num_tx_not_acked;

drivers/net/wireless/ath/ath11k/wmi.c

6563

dst->num_tx_frames[i] = src->num_tx_frames[i];

drivers/net/wireless/ath/ath11k/wmi.c

6566

dst->num_tx_frames_retries[i] = src->num_tx_frames_retries[i];

drivers/net/wireless/ath/ath11k/wmi.c

6569

dst->num_tx_frames_failures[i] = src->num_tx_frames_failures[i];

drivers/net/wireless/ath/ath11k/wmi.c

6572

dst->tx_rate_history[i] = src->tx_rate_history[i];

drivers/net/wireless/ath/ath11k/wmi.c

6575

dst->beacon_rssi_history[i] = src->beacon_rssi_history[i];

drivers/net/wireless/ath/ath11k/wmi.c

6580

struct ath11k_fw_stats_bcn *dst)

drivers/net/wireless/ath/ath11k/wmi.c

6582

dst->vdev_id = src->vdev_id;

drivers/net/wireless/ath/ath11k/wmi.c

6583

dst->tx_bcn_succ_cnt = src->tx_bcn_succ_cnt;

drivers/net/wireless/ath/ath11k/wmi.c

6584

dst->tx_bcn_outage_cnt = src->tx_bcn_outage_cnt;

drivers/net/wireless/ath/ath11k/wmi.c

6682

struct ath11k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath11k/wmi.c

6695

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath11k/wmi.c

6696

if (!dst)

drivers/net/wireless/ath/ath11k/wmi.c

6699

ath11k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath11k/wmi.c

6700

ath11k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath11k/wmi.c

6701

ath11k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath11k/wmi.c

6702

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath11k/wmi.c

6707

struct ath11k_fw_stats_vdev *dst;

drivers/net/wireless/ath/ath11k/wmi.c

6738

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath11k/wmi.c

6739

if (!dst)

drivers/net/wireless/ath/ath11k/wmi.c

6742

ath11k_wmi_pull_vdev_stats(src, dst);

drivers/net/wireless/ath/ath11k/wmi.c

6743

list_add_tail(&dst->list, &stats->vdevs);

drivers/net/wireless/ath/ath11k/wmi.c

6748

struct ath11k_fw_stats_bcn *dst;

drivers/net/wireless/ath/ath11k/wmi.c

6761

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath11k/wmi.c

6762

if (!dst)

drivers/net/wireless/ath/ath11k/wmi.c

6765

ath11k_wmi_pull_bcn_stats(src, dst);

drivers/net/wireless/ath/ath11k/wmi.c

6766

list_add_tail(&dst->list, &stats->bcn);

drivers/net/wireless/ath/ath12k/wmi.c

8127

struct ath12k_fw_stats_vdev *dst)

drivers/net/wireless/ath/ath12k/wmi.c

8131

dst->vdev_id = le32_to_cpu(src->vdev_id);

drivers/net/wireless/ath/ath12k/wmi.c

8132

dst->beacon_snr = le32_to_cpu(src->beacon_snr);

drivers/net/wireless/ath/ath12k/wmi.c

8133

dst->data_snr = le32_to_cpu(src->data_snr);

drivers/net/wireless/ath/ath12k/wmi.c

8134

dst->num_rx_frames = le32_to_cpu(src->num_rx_frames);

drivers/net/wireless/ath/ath12k/wmi.c

8135

dst->num_rts_fail = le32_to_cpu(src->num_rts_fail);

drivers/net/wireless/ath/ath12k/wmi.c

8136

dst->num_rts_success = le32_to_cpu(src->num_rts_success);

drivers/net/wireless/ath/ath12k/wmi.c

8137

dst->num_rx_err = le32_to_cpu(src->num_rx_err);

drivers/net/wireless/ath/ath12k/wmi.c

8138

dst->num_rx_discard = le32_to_cpu(src->num_rx_discard);

drivers/net/wireless/ath/ath12k/wmi.c

8139

dst->num_tx_not_acked = le32_to_cpu(src->num_tx_not_acked);

drivers/net/wireless/ath/ath12k/wmi.c

8142

dst->num_tx_frames[i] =

drivers/net/wireless/ath/ath12k/wmi.c

8146

dst->num_tx_frames_retries[i] =

drivers/net/wireless/ath/ath12k/wmi.c

8150

dst->num_tx_frames_failures[i] =

drivers/net/wireless/ath/ath12k/wmi.c

8154

dst->tx_rate_history[i] =

drivers/net/wireless/ath/ath12k/wmi.c

8158

dst->beacon_rssi_history[i] =

drivers/net/wireless/ath/ath12k/wmi.c

8164

struct ath12k_fw_stats_bcn *dst)

drivers/net/wireless/ath/ath12k/wmi.c

8166

dst->vdev_id = le32_to_cpu(src->vdev_id);

drivers/net/wireless/ath/ath12k/wmi.c

8167

dst->tx_bcn_succ_cnt = le32_to_cpu(src->tx_bcn_succ_cnt);

drivers/net/wireless/ath/ath12k/wmi.c

8168

dst->tx_bcn_outage_cnt = le32_to_cpu(src->tx_bcn_outage_cnt);

drivers/net/wireless/ath/ath12k/wmi.c

8173

struct ath12k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath12k/wmi.c

8175

dst->ch_noise_floor = a_sle32_to_cpu(src->chan_nf);

drivers/net/wireless/ath/ath12k/wmi.c

8176

dst->tx_frame_count = __le32_to_cpu(src->tx_frame_count);

drivers/net/wireless/ath/ath12k/wmi.c

8177

dst->rx_frame_count = __le32_to_cpu(src->rx_frame_count);

drivers/net/wireless/ath/ath12k/wmi.c

8178

dst->rx_clear_count = __le32_to_cpu(src->rx_clear_count);

drivers/net/wireless/ath/ath12k/wmi.c

8179

dst->cycle_count = __le32_to_cpu(src->cycle_count);

drivers/net/wireless/ath/ath12k/wmi.c

8180

dst->phy_err_count = __le32_to_cpu(src->phy_err_count);

drivers/net/wireless/ath/ath12k/wmi.c

8181

dst->chan_tx_power = __le32_to_cpu(src->chan_tx_pwr);

drivers/net/wireless/ath/ath12k/wmi.c

8186

struct ath12k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath12k/wmi.c

8188

dst->comp_queued = a_sle32_to_cpu(src->comp_queued);

drivers/net/wireless/ath/ath12k/wmi.c

8189

dst->comp_delivered = a_sle32_to_cpu(src->comp_delivered);

drivers/net/wireless/ath/ath12k/wmi.c

8190

dst->msdu_enqued = a_sle32_to_cpu(src->msdu_enqued);

drivers/net/wireless/ath/ath12k/wmi.c

8191

dst->mpdu_enqued = a_sle32_to_cpu(src->mpdu_enqued);

drivers/net/wireless/ath/ath12k/wmi.c

8192

dst->wmm_drop = a_sle32_to_cpu(src->wmm_drop);

drivers/net/wireless/ath/ath12k/wmi.c

8193

dst->local_enqued = a_sle32_to_cpu(src->local_enqued);

drivers/net/wireless/ath/ath12k/wmi.c

8194

dst->local_freed = a_sle32_to_cpu(src->local_freed);

drivers/net/wireless/ath/ath12k/wmi.c

8195

dst->hw_queued = a_sle32_to_cpu(src->hw_queued);

drivers/net/wireless/ath/ath12k/wmi.c

8196

dst->hw_reaped = a_sle32_to_cpu(src->hw_reaped);

drivers/net/wireless/ath/ath12k/wmi.c

8197

dst->underrun = a_sle32_to_cpu(src->underrun);

drivers/net/wireless/ath/ath12k/wmi.c

8198

dst->tx_abort = a_sle32_to_cpu(src->tx_abort);

drivers/net/wireless/ath/ath12k/wmi.c

8199

dst->mpdus_requed = a_sle32_to_cpu(src->mpdus_requed);

drivers/net/wireless/ath/ath12k/wmi.c

8200

dst->tx_ko = __le32_to_cpu(src->tx_ko);

drivers/net/wireless/ath/ath12k/wmi.c

8201

dst->data_rc = __le32_to_cpu(src->data_rc);

drivers/net/wireless/ath/ath12k/wmi.c

8202

dst->self_triggers = __le32_to_cpu(src->self_triggers);

drivers/net/wireless/ath/ath12k/wmi.c

8203

dst->sw_retry_failure = __le32_to_cpu(src->sw_retry_failure);

drivers/net/wireless/ath/ath12k/wmi.c

8204

dst->illgl_rate_phy_err = __le32_to_cpu(src->illgl_rate_phy_err);

drivers/net/wireless/ath/ath12k/wmi.c

8205

dst->pdev_cont_xretry = __le32_to_cpu(src->pdev_cont_xretry);

drivers/net/wireless/ath/ath12k/wmi.c

8206

dst->pdev_tx_timeout = __le32_to_cpu(src->pdev_tx_timeout);

drivers/net/wireless/ath/ath12k/wmi.c

8207

dst->pdev_resets = __le32_to_cpu(src->pdev_resets);

drivers/net/wireless/ath/ath12k/wmi.c

8208

dst->stateless_tid_alloc_failure =

drivers/net/wireless/ath/ath12k/wmi.c

8210

dst->phy_underrun = __le32_to_cpu(src->phy_underrun);

drivers/net/wireless/ath/ath12k/wmi.c

8211

dst->txop_ovf = __le32_to_cpu(src->txop_ovf);

drivers/net/wireless/ath/ath12k/wmi.c

8216

struct ath12k_fw_stats_pdev *dst)

drivers/net/wireless/ath/ath12k/wmi.c

8218

dst->mid_ppdu_route_change =

drivers/net/wireless/ath/ath12k/wmi.c

8220

dst->status_rcvd = a_sle32_to_cpu(src->status_rcvd);

drivers/net/wireless/ath/ath12k/wmi.c

8221

dst->r0_frags = a_sle32_to_cpu(src->r0_frags);

drivers/net/wireless/ath/ath12k/wmi.c

8222

dst->r1_frags = a_sle32_to_cpu(src->r1_frags);

drivers/net/wireless/ath/ath12k/wmi.c

8223

dst->r2_frags = a_sle32_to_cpu(src->r2_frags);

drivers/net/wireless/ath/ath12k/wmi.c

8224

dst->r3_frags = a_sle32_to_cpu(src->r3_frags);

drivers/net/wireless/ath/ath12k/wmi.c

8225

dst->htt_msdus = a_sle32_to_cpu(src->htt_msdus);

drivers/net/wireless/ath/ath12k/wmi.c

8226

dst->htt_mpdus = a_sle32_to_cpu(src->htt_mpdus);

drivers/net/wireless/ath/ath12k/wmi.c

8227

dst->loc_msdus = a_sle32_to_cpu(src->loc_msdus);

drivers/net/wireless/ath/ath12k/wmi.c

8228

dst->loc_mpdus = a_sle32_to_cpu(src->loc_mpdus);

drivers/net/wireless/ath/ath12k/wmi.c

8229

dst->oversize_amsdu = a_sle32_to_cpu(src->oversize_amsdu);

drivers/net/wireless/ath/ath12k/wmi.c

8230

dst->phy_errs = a_sle32_to_cpu(src->phy_errs);

drivers/net/wireless/ath/ath12k/wmi.c

8231

dst->phy_err_drop = a_sle32_to_cpu(src->phy_err_drop);

drivers/net/wireless/ath/ath12k/wmi.c

8232

dst->mpdu_errs = a_sle32_to_cpu(src->mpdu_errs);

drivers/net/wireless/ath/ath12k/wmi.c

8269

struct ath12k_fw_stats_vdev *dst;

drivers/net/wireless/ath/ath12k/wmi.c

8296

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath12k/wmi.c

8297

if (!dst)

drivers/net/wireless/ath/ath12k/wmi.c

8299

ath12k_wmi_pull_vdev_stats(src, dst);

drivers/net/wireless/ath/ath12k/wmi.c

8301

list_add_tail(&dst->list, &stats->vdevs);

drivers/net/wireless/ath/ath12k/wmi.c

8305

struct ath12k_fw_stats_bcn *dst;

drivers/net/wireless/ath/ath12k/wmi.c

8315

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath12k/wmi.c

8316

if (!dst)

drivers/net/wireless/ath/ath12k/wmi.c

8318

ath12k_wmi_pull_bcn_stats(src, dst);

drivers/net/wireless/ath/ath12k/wmi.c

8320

list_add_tail(&dst->list, &stats->bcn);

drivers/net/wireless/ath/ath12k/wmi.c

8324

struct ath12k_fw_stats_pdev *dst;

drivers/net/wireless/ath/ath12k/wmi.c

8337

dst = kzalloc_obj(*dst, GFP_ATOMIC);

drivers/net/wireless/ath/ath12k/wmi.c

8338

if (!dst)

drivers/net/wireless/ath/ath12k/wmi.c

8341

ath12k_wmi_pull_pdev_stats_base(&src->base, dst);

drivers/net/wireless/ath/ath12k/wmi.c

8342

ath12k_wmi_pull_pdev_stats_tx(&src->tx, dst);

drivers/net/wireless/ath/ath12k/wmi.c

8343

ath12k_wmi_pull_pdev_stats_rx(&src->rx, dst);

drivers/net/wireless/ath/ath12k/wmi.c

8344

list_add_tail(&dst->list, &stats->pdevs);

drivers/net/wireless/ath/ath6kl/wmi.c

3733

const u8 *dst, const u8 *data,

drivers/net/wireless/ath/ath6kl/wmi.c

3749

freq, dst, data_len);

drivers/net/wireless/ath/ath6kl/wmi.c

3752

memcpy(p->destination_addr, dst, ETH_ALEN);

drivers/net/wireless/ath/ath6kl/wmi.h

2708

const u8 *dst, const u8 *data,

drivers/net/wireless/ath/ath9k/dynack.c

153

u8 *dst, *src;

drivers/net/wireless/ath/ath9k/dynack.c

162

dst = da->st_rbf.addr[da->st_rbf.h_rb].h_dest;

drivers/net/wireless/ath/ath9k/dynack.c

174

sta = ieee80211_find_sta_by_ifaddr(ah->hw, dst,

drivers/net/wireless/ath/ath9k/dynack.c

181

"%pM to %d [%u]\n", dst,

drivers/net/wireless/ath/wil6210/fw.c

19

void wil_memset_toio_32(volatile void __iomem *dst, u32 val,

drivers/net/wireless/ath/wil6210/fw.c

22

volatile u32 __iomem *d = dst;

drivers/net/wireless/ath/wil6210/fw_inc.c

273

void __iomem *dst;

drivers/net/wireless/ath/wil6210/fw_inc.c

281

if (!wil_fw_addr_check(wil, &dst, addr, s, "address"))

drivers/net/wireless/ath/wil6210/fw_inc.c

284

wil_memcpy_toio_32(dst, d->data, s);

drivers/net/wireless/ath/wil6210/fw_inc.c

302

void __iomem *dst;

drivers/net/wireless/ath/wil6210/fw_inc.c

321

if (!wil_fw_addr_check(wil, &dst, d->addr, s, "address"))

drivers/net/wireless/ath/wil6210/fw_inc.c

327

wil_memset_toio_32(dst, v, s);

drivers/net/wireless/ath/wil6210/fw_inc.c

373

void __iomem *dst;

drivers/net/wireless/ath/wil6210/fw_inc.c

378

if (!wil_fw_addr_check(wil, &dst, block[i].addr, 0, "address"))

drivers/net/wireless/ath/wil6210/fw_inc.c

381

x = readl(dst);

drivers/net/wireless/ath/wil6210/fw_inc.c

386

writel(y, dst);

drivers/net/wireless/ath/wil6210/main.c

141

void wil_memcpy_fromio_32(void *dst, const volatile void __iomem *src,

drivers/net/wireless/ath/wil6210/main.c

144

u32 *d = dst;

drivers/net/wireless/ath/wil6210/main.c

158

void wil_memcpy_toio_32(volatile void __iomem *dst, const void *src,

drivers/net/wireless/ath/wil6210/main.c

161

volatile u32 __iomem *d = dst;

drivers/net/wireless/ath/wil6210/wil6210.h

1197

void wil_memcpy_fromio_32(void *dst, const volatile void __iomem *src,

drivers/net/wireless/ath/wil6210/wil6210.h

1199

void wil_memcpy_toio_32(volatile void __iomem *dst, const void *src,

drivers/net/wireless/ath/wil6210/wmi.c

653

void __iomem *dst;

drivers/net/wireless/ath/wil6210/wmi.c

721

dst = wmi_buffer(wil, d_head.addr);

drivers/net/wireless/ath/wil6210/wmi.c

722

if (!dst) {

drivers/net/wireless/ath/wil6210/wmi.c

736

wil_memcpy_toio_32(dst, &cmd, sizeof(cmd));

drivers/net/wireless/ath/wil6210/wmi.c

737

wil_memcpy_toio_32(dst + sizeof(cmd), buf, len);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/phy/phy_n.c

24628

u32 *buf, *src, *dst, sz;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/phy/phy_n.c

24637

dst = buf + NPHY_PAPD_EPS_TBL_SIZE;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/phy/phy_n.c

24665

dst[end] = ((u32) phy_a7 << 13) | ((u32) phy_a6 & 0x1fff);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/phy/phy_n.c

24671

NPHY_TBL_ID_EPSILONTBL1, sz, start, 32, dst);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

393

struct brcms_c_rateset *dst)

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

395

memcpy(dst, src, sizeof(struct brcms_c_rateset));

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

408

brcms_c_rateset_filter(struct brcms_c_rateset *src, struct brcms_c_rateset *dst,

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

426

dst->rates[count++] = r & xmask;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

428

dst->count = count;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

429

dst->htphy_membership = src->htphy_membership;

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

432

memcpy(&dst->mcs[0], &src->mcs[0], MCSSET_LEN);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.c

434

brcms_c_rateset_mcs_clear(dst);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.h

224

struct brcms_c_rateset *dst);

drivers/net/wireless/broadcom/brcm80211/brcmsmac/rate.h

230

struct brcms_c_rateset *dst, bool basic_only,

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10291

struct sk_buff *dst;

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10301

dst = alloc_skb(len + sizeof(*rt_hdr) + sizeof(u16)*2, GFP_ATOMIC);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10302

if (!dst)

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10305

rt_hdr = skb_put(dst, sizeof(*rt_hdr));

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10312

*(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10315

*(__le16*)skb_put(dst, sizeof(u16)) =

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10319

*(__le16*)skb_put(dst, sizeof(u16)) =

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10323

*(__le16*)skb_put(dst, sizeof(u16)) =

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10327

rt_hdr->it_len = cpu_to_le16(dst->len);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10329

skb_copy_from_linear_data(src, skb_put(dst, len), len);

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10331

if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))

drivers/net/wireless/intel/ipw2x00/ipw2200.c

10332

dev_kfree_skb_any(dst);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1326

struct libipw_network *dst)

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1331

return ((src->ssid_len == dst->ssid_len) &&

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1332

(src->channel == dst->channel) &&

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1333

ether_addr_equal_64bits(src->bssid, dst->bssid) &&

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1334

!memcmp(src->ssid, dst->ssid, src->ssid_len));

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1337

static void update_network(struct libipw_network *dst,

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1348

if (dst->channel == src->stats.received_channel)

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1349

memcpy(&dst->stats, &src->stats,

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1354

dst->channel, src->stats.received_channel);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1356

dst->capability = src->capability;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1357

memcpy(dst->rates, src->rates, src->rates_len);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1358

dst->rates_len = src->rates_len;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1359

memcpy(dst->rates_ex, src->rates_ex, src->rates_ex_len);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1360

dst->rates_ex_len = src->rates_ex_len;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1362

dst->mode = src->mode;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1363

dst->flags = src->flags;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1364

dst->time_stamp[0] = src->time_stamp[0];

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1365

dst->time_stamp[1] = src->time_stamp[1];

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1367

dst->beacon_interval = src->beacon_interval;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1368

dst->listen_interval = src->listen_interval;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1369

dst->atim_window = src->atim_window;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1370

dst->erp_value = src->erp_value;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1371

dst->tim = src->tim;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1373

memcpy(dst->wpa_ie, src->wpa_ie, src->wpa_ie_len);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1374

dst->wpa_ie_len = src->wpa_ie_len;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1375

memcpy(dst->rsn_ie, src->rsn_ie, src->rsn_ie_len);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1376

dst->rsn_ie_len = src->rsn_ie_len;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1378

dst->last_scanned = jiffies;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1380

old_param = dst->qos_data.old_param_count;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1381

if (dst->flags & NETWORK_HAS_QOS_MASK)

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1382

memcpy(&dst->qos_data, &src->qos_data,

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1385

dst->qos_data.supported = src->qos_data.supported;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1386

dst->qos_data.param_count = src->qos_data.param_count;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1389

if (dst->qos_data.supported == 1) {

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1390

if (dst->ssid_len)

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1393

dst->ssid);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1398

dst->qos_data.active = qos_active;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

1399

dst->qos_data.old_param_count = old_param;

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

343

u8 dst[ETH_ALEN];

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

490

memcpy(dst, hdr->addr1, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

494

memcpy(dst, hdr->addr3, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

500

memcpy(dst, hdr->addr3, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

504

memcpy(dst, hdr->addr1, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

55

u8 * dst)

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

74

ether_addr_equal(entry->dst_addr, dst))

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

740

memcpy(skb_push(skb, ETH_ALEN), dst, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

748

memcpy(skb_push(skb, ETH_ALEN), dst, ETH_ALEN);

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

768

if (is_multicast_ether_addr(dst)) {

drivers/net/wireless/intel/ipw2x00/libipw_rx.c

776

} else if (hostap_is_sta_assoc(ieee->ap, dst)) {

drivers/net/wireless/intersil/p54/eeprom.c

420

struct p54_pa_curve_data_sample *dst;

drivers/net/wireless/intersil/p54/eeprom.c

423

(curve_data->points_per_channel*sizeof(*dst) + 2) *

drivers/net/wireless/intersil/p54/eeprom.c

435

sizeof(*dst) * curve_data->points_per_channel;

drivers/net/wireless/intersil/p54/eeprom.c

447

dst = target;

drivers/net/wireless/intersil/p54/eeprom.c

450

dst->rf_power = src->rf_power;

drivers/net/wireless/intersil/p54/eeprom.c

451

dst->pa_detector = src->pa_detector;

drivers/net/wireless/intersil/p54/eeprom.c

452

dst->data_64qam = src->pcv;

drivers/net/wireless/intersil/p54/eeprom.c

455

dst->data_16qam = SUB(src->pcv, 12);

drivers/net/wireless/intersil/p54/eeprom.c

456

dst->data_qpsk = SUB(dst->data_16qam, 12);

drivers/net/wireless/intersil/p54/eeprom.c

457

dst->data_bpsk = SUB(dst->data_qpsk, 12);

drivers/net/wireless/intersil/p54/eeprom.c

458

dst->data_barker = SUB(dst->data_bpsk, 14);

drivers/net/wireless/intersil/p54/eeprom.c

460

target += sizeof(*dst);

drivers/net/wireless/intersil/p54/eeprom.c

472

struct p54_pa_curve_data_sample *dst;

drivers/net/wireless/intersil/p54/eeprom.c

475

(curve_data->points_per_channel*sizeof(*dst) + 2) *

drivers/net/wireless/intersil/p54/eeprom.c

487

sizeof(*dst) * curve_data->points_per_channel;

drivers/net/wireless/intersil/p54/eeprom.c

501

target += sizeof(*dst);

drivers/net/wireless/intersil/p54/eeprom.c

701

struct p54_cal_database *dst;

drivers/net/wireless/intersil/p54/eeprom.c

712

dst = kmalloc(sizeof(*dst) + payload_len, GFP_KERNEL);

drivers/net/wireless/intersil/p54/eeprom.c

713

if (!dst)

drivers/net/wireless/intersil/p54/eeprom.c

716

dst->entries = entries;

drivers/net/wireless/intersil/p54/eeprom.c

717

dst->entry_size = entry_size;

drivers/net/wireless/intersil/p54/eeprom.c

718

dst->offset = offset;

drivers/net/wireless/intersil/p54/eeprom.c

719

dst->len = payload_len;

drivers/net/wireless/intersil/p54/eeprom.c

721

memcpy(dst->data, src->data, payload_len);

drivers/net/wireless/intersil/p54/eeprom.c

722

return dst;

drivers/net/wireless/intersil/p54/eeprom.c

827

u16 *dst;

drivers/net/wireless/intersil/p54/eeprom.c

838

dst = (void *) priv->rssi_db->data;

drivers/net/wireless/intersil/p54/eeprom.c

841

*(dst++) = (s16) le16_to_cpu(*(src++));

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1438

static u32 mwifiex_parse_cal_cfg(u8 *src, size_t len, u8 *dst)

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1440

u8 *s = src, *d = dst;

drivers/net/wireless/marvell/mwifiex/sta_cmd.c

1455

return d - dst;

drivers/net/wireless/quantenna/qtnfmac/commands.c

524

qtnf_sta_info_parse_flags(struct nl80211_sta_flag_update *dst,

drivers/net/wireless/quantenna/qtnfmac/commands.c

529

dst->mask = 0;

drivers/net/wireless/quantenna/qtnfmac/commands.c

530

dst->set = 0;

drivers/net/wireless/quantenna/qtnfmac/commands.c

536

dst->mask |= BIT(NL80211_STA_FLAG_AUTHORIZED);

drivers/net/wireless/quantenna/qtnfmac/commands.c

538

dst->set |= BIT(NL80211_STA_FLAG_AUTHORIZED);

drivers/net/wireless/quantenna/qtnfmac/commands.c

542

dst->mask |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);

drivers/net/wireless/quantenna/qtnfmac/commands.c

544

dst->set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);

drivers/net/wireless/quantenna/qtnfmac/commands.c

548

dst->mask |= BIT(NL80211_STA_FLAG_WME);

drivers/net/wireless/quantenna/qtnfmac/commands.c

550

dst->set |= BIT(NL80211_STA_FLAG_WME);

drivers/net/wireless/quantenna/qtnfmac/commands.c

554

dst->mask |= BIT(NL80211_STA_FLAG_MFP);

drivers/net/wireless/quantenna/qtnfmac/commands.c

556

dst->set |= BIT(NL80211_STA_FLAG_MFP);

drivers/net/wireless/quantenna/qtnfmac/commands.c

560

dst->mask |= BIT(NL80211_STA_FLAG_AUTHENTICATED);

drivers/net/wireless/quantenna/qtnfmac/commands.c

562

dst->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);

drivers/net/wireless/quantenna/qtnfmac/commands.c

566

dst->mask |= BIT(NL80211_STA_FLAG_TDLS_PEER);

drivers/net/wireless/quantenna/qtnfmac/commands.c

568

dst->set |= BIT(NL80211_STA_FLAG_TDLS_PEER);

drivers/net/wireless/quantenna/qtnfmac/commands.c

572

dst->mask |= BIT(NL80211_STA_FLAG_ASSOCIATED);

drivers/net/wireless/quantenna/qtnfmac/commands.c

574

dst->set |= BIT(NL80211_STA_FLAG_ASSOCIATED);

drivers/net/wireless/realtek/rtw88/mac.c

562

iddma_enable(struct rtw_dev *rtwdev, u32 src, u32 dst, u32 ctrl)

drivers/net/wireless/realtek/rtw88/mac.c

565

rtw_write32(rtwdev, REG_DDMA_CH0DA, dst);

drivers/net/wireless/realtek/rtw88/mac.c

574

static int iddma_download_firmware(struct rtw_dev *rtwdev, u32 src, u32 dst,

drivers/net/wireless/realtek/rtw88/mac.c

586

if (iddma_enable(rtwdev, src, dst, ch0_ctrl))

drivers/net/wireless/realtek/rtw88/mac.c

647

u32 src, u32 dst, u32 size)

drivers/net/wireless/realtek/rtw88/mac.c

680

dst + mem_offset, pkt_size,

drivers/net/wireless/realtek/rtw88/mac.c

690

if (!check_fw_checksum(rtwdev, dst))

drivers/net/wireless/realtek/rtw89/util.h

65

static inline void ether_addr_copy_mask(u8 *dst, const u8 *src, u8 mask)

drivers/net/wireless/realtek/rtw89/util.h

69

eth_zero_addr(dst);

drivers/net/wireless/realtek/rtw89/util.h

72

dst[i] = src[i];

drivers/net/wireless/silabs/wfx/bus.h

24

int (*copy_from_io)(void *bus_priv, unsigned int addr, void *dst, size_t count);

drivers/net/wireless/silabs/wfx/bus_sdio.c

53

static int wfx_sdio_copy_from_io(void *priv, unsigned int reg_id, void *dst, size_t count)

drivers/net/wireless/silabs/wfx/bus_sdio.c

60

WARN(!IS_ALIGNED((uintptr_t)dst, 4), "unaligned buffer address");

drivers/net/wireless/silabs/wfx/bus_sdio.c

66

ret = sdio_memcpy_fromio(bus->func, dst, sdio_addr, count);

drivers/net/wireless/silabs/wfx/bus_spi.c

65

static int wfx_spi_copy_from_io(void *priv, unsigned int addr, void *dst, size_t count)

drivers/net/wireless/silabs/wfx/bus_spi.c

75

.rx_buf = dst,

drivers/net/wireless/silabs/wfx/bus_spi.c

78

u16 *dst16 = dst;

drivers/net/wireless/st/cw1200/cw1200_sdio.c

62

void *dst, int count)

drivers/net/wireless/st/cw1200/cw1200_sdio.c

64

return sdio_memcpy_fromio(self->func, dst, addr, count);

drivers/net/wireless/st/cw1200/cw1200_spi.c

117

uint16_t *buf = (uint16_t *)dst;

drivers/net/wireless/st/cw1200/cw1200_spi.c

61

void *dst, int count)

drivers/net/wireless/st/cw1200/cw1200_spi.c

72

.rx_buf = dst,

drivers/net/wireless/st/cw1200/hwbus.h

21

void *dst, int count);

drivers/net/wireless/st/cw1200/scan.c

114

struct wsm_ssid *dst = &priv->scan.ssids[priv->scan.n_ssids];

drivers/net/wireless/st/cw1200/scan.c

115

memcpy(&dst->ssid[0], req->ssids[i].ssid, sizeof(dst->ssid));

drivers/net/wireless/st/cw1200/scan.c

116

dst->length = req->ssids[i].ssid_len;

drivers/net/wireless/st/cw1200/txrx.c

365

struct wsm_tx_rate_retry_policy *dst =

drivers/net/wireless/st/cw1200/txrx.c

367

dst->index = i;

drivers/net/wireless/st/cw1200/txrx.c

368

dst->short_retries = priv->short_frame_max_tx_count;

drivers/net/wireless/st/cw1200/txrx.c

369

dst->long_retries = priv->long_frame_max_tx_count;

drivers/net/wireless/st/cw1200/txrx.c

371

dst->flags = WSM_TX_RATE_POLICY_FLAG_TERMINATE_WHEN_FINISHED |

drivers/net/wireless/st/cw1200/txrx.c

373

memcpy(dst->rate_count_indices, src->tbl,

drivers/net/wireless/st/cw1200/txrx.c

374

sizeof(dst->rate_count_indices));

drivers/net/wireless/virtual/mac80211_hwsim.c

6121

const u8 *dst;

drivers/net/wireless/virtual/mac80211_hwsim.c

6133

dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);

drivers/net/wireless/virtual/mac80211_hwsim.c

6149

data2 = get_hwsim_data_ref_from_addr(dst);

drivers/net/wwan/rpmsg_wwan_ctrl.c

37

.dst = RPMSG_ADDR_ANY,

drivers/net/xen-netback/hash.c

195

memcpy(&data[4], &flow.addrs.v4addrs.dst, 4);

drivers/net/xen-netback/hash.c

197

memcpy(&data[10], &flow.ports.dst, 2);

drivers/net/xen-netback/hash.c

205

memcpy(&data[4], &flow.addrs.v4addrs.dst, 4);

drivers/net/xen-netback/hash.c

219

memcpy(&data[16], &flow.addrs.v6addrs.dst, 16);

drivers/net/xen-netback/hash.c

221

memcpy(&data[34], &flow.ports.dst, 2);

drivers/net/xen-netback/hash.c

229

memcpy(&data[16], &flow.addrs.v6addrs.dst, 16);

drivers/ntb/test/ntb_perf.c

786

void __iomem *dst, void *src, size_t len)

drivers/ntb/test/ntb_perf.c

798

memcpy_toio(dst, src, len);

drivers/ntb/test/ntb_perf.c

805

offset_in_page(dst), len))

drivers/ntb/test/ntb_perf.c

809

dst_vaddr = dst;

drivers/nvdimm/label.c

264

struct nd_namespace_index *dst,

drivers/nvdimm/label.c

268

if (!dst || !src)

drivers/nvdimm/label.c

271

memcpy(dst, src, sizeof_namespace_index(ndd));

drivers/nvme/common/auth.c

393

struct scatterlist dst;

drivers/nvme/common/auth.c

402

sg_init_one(&dst, host_key, host_key_len);

drivers/nvme/common/auth.c

403

kpp_request_set_output(req, &dst, host_key_len);

drivers/nvme/common/auth.c

419

struct scatterlist src, dst;

drivers/nvme/common/auth.c

429

sg_init_one(&dst, sess_key, sess_key_len);

drivers/nvme/common/auth.c

430

kpp_request_set_output(req, &dst, sess_key_len);

drivers/nvme/host/multipath.c

1174

struct nvme_ana_group_desc *dst = data;

drivers/nvme/host/multipath.c

1176

if (desc->grpid != dst->grpid)

drivers/nvme/host/multipath.c

1179

*dst = *desc;

drivers/nvmem/apple-efuses.c

22

u32 *dst = val;

drivers/nvmem/apple-efuses.c

25

*dst++ = readl_relaxed(priv->fuses + offset);

drivers/nvmem/lan9662-otpc.c

82

static int lan9662_otp_read_byte(struct lan9662_otp *otp, u32 offset, u8 *dst)

drivers/nvmem/lan9662-otpc.c

95

*dst = (u8) readl(OTP_OTP_RD_DATA(otp->base));

drivers/nvmem/s32g-ocotp-nvmem.c

23

u32 *dst = val;

drivers/nvmem/s32g-ocotp-nvmem.c

26

*dst++ = ioread32(s32g_data->base + offset);

drivers/perf/amlogic/meson_ddr_pmu_core.c

416

struct attribute **dst = ddr_perf_events_attrs;

drivers/perf/amlogic/meson_ddr_pmu_core.c

422

dst[j++] = &event_attrs[k].attr.attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

423

dst[j++] = &event_unit_attrs[k].attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

424

dst[j++] = &event_scale_attrs[k].attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

430

dst[j++] = &event_attrs[k].attr.attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

431

dst[j++] = &event_unit_attrs[k].attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

432

dst[j++] = &event_scale_attrs[k].attr;

drivers/perf/amlogic/meson_ddr_pmu_core.c

435

dst[j] = NULL; /* mark end */

drivers/perf/arm_cspmu/arm_cspmu.c

1311

unsigned int dst;

drivers/perf/arm_cspmu/arm_cspmu.c

1321

dst = cpumask_any_and_but(&cspmu->associated_cpus,

drivers/perf/arm_cspmu/arm_cspmu.c

1323

if (dst >= nr_cpu_ids)

drivers/perf/arm_cspmu/arm_cspmu.c

1327

perf_pmu_migrate_context(&cspmu->pmu, cpu, dst);

drivers/perf/arm_cspmu/arm_cspmu.c

1328

arm_cspmu_set_active_cpu(dst, cspmu);

drivers/perf/arm_dsu_pmu.c

823

unsigned int dst;

drivers/perf/arm_dsu_pmu.c

830

dst = cpumask_any_and_but(&dsu_pmu->associated_cpus,

drivers/perf/arm_dsu_pmu.c

833

if (dst >= nr_cpu_ids)

drivers/perf/arm_dsu_pmu.c

836

perf_pmu_migrate_context(&dsu_pmu->pmu, cpu, dst);

drivers/perf/arm_dsu_pmu.c

837

dsu_pmu_set_active_cpu(dst, dsu_pmu);

drivers/phy/phy-xgene.c

100

#define REGSPEC_CFG_I_CUSTOMER_PIN_MODE0_SET(dst, src) \

drivers/phy/phy-xgene.c

101

(((dst) & ~0x00007fff) | (((u32) (src)) & 0x00007fff))

drivers/phy/phy-xgene.c

103

#define CFG_I_SPD_SEL_CDR_OVR1_SET(dst, src) \

drivers/phy/phy-xgene.c

104

(((dst) & ~0x0000000f) | (((u32) (src)) & 0x0000000f))

drivers/phy/phy-xgene.c

110

#define CFG_IND_ADDR_SET(dst, src) \

drivers/phy/phy-xgene.c

111

(((dst) & ~0x003ffff0) | (((u32) (src) << 4) & 0x003ffff0))

drivers/phy/phy-xgene.c

115

#define I_RESET_B_SET(dst, src) \

drivers/phy/phy-xgene.c

116

(((dst) & ~0x00000001) | (((u32) (src)) & 0x00000001))

drivers/phy/phy-xgene.c

117

#define I_PLL_FBDIV_SET(dst, src) \

drivers/phy/phy-xgene.c

118

(((dst) & ~0x001ff000) | (((u32) (src) << 12) & 0x001ff000))

drivers/phy/phy-xgene.c

119

#define I_CUSTOMEROV_SET(dst, src) \

drivers/phy/phy-xgene.c

120

(((dst) & ~0x00000f80) | (((u32) (src) << 7) & 0x00000f80))

drivers/phy/phy-xgene.c

127

#define CMU_REG0_PLL_REF_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

128

(((dst) & ~0x00002000) | (((u32) (src) << 13) & 0x00002000))

drivers/phy/phy-xgene.c

130

#define CMU_REG0_CAL_COUNT_RESOL_SET(dst, src) \

drivers/phy/phy-xgene.c

131

(((dst) & ~0x000000e0) | (((u32) (src) << 5) & 0x000000e0))

drivers/phy/phy-xgene.c

133

#define CMU_REG1_PLL_CP_SET(dst, src) \

drivers/phy/phy-xgene.c

134

(((dst) & ~0x00003c00) | (((u32) (src) << 10) & 0x00003c00))

drivers/phy/phy-xgene.c

135

#define CMU_REG1_PLL_MANUALCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

136

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

137

#define CMU_REG1_PLL_CP_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

138

(((dst) & ~0x000003e0) | (((u32) (src) << 5) & 0x000003e0))

drivers/phy/phy-xgene.c

140

#define CMU_REG1_REFCLK_CMOS_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

141

(((dst) & ~0x00000001) | (((u32) (src) << 0) & 0x00000001))

drivers/phy/phy-xgene.c

143

#define CMU_REG2_PLL_REFDIV_SET(dst, src) \

drivers/phy/phy-xgene.c

144

(((dst) & ~0x0000c000) | (((u32) (src) << 14) & 0x0000c000))

drivers/phy/phy-xgene.c

145

#define CMU_REG2_PLL_LFRES_SET(dst, src) \

drivers/phy/phy-xgene.c

146

(((dst) & ~0x0000001e) | (((u32) (src) << 1) & 0x0000001e))

drivers/phy/phy-xgene.c

147

#define CMU_REG2_PLL_FBDIV_SET(dst, src) \

drivers/phy/phy-xgene.c

148

(((dst) & ~0x00003fe0) | (((u32) (src) << 5) & 0x00003fe0))

drivers/phy/phy-xgene.c

150

#define CMU_REG3_VCOVARSEL_SET(dst, src) \

drivers/phy/phy-xgene.c

151

(((dst) & ~0x0000000f) | (((u32) (src) << 0) & 0x0000000f))

drivers/phy/phy-xgene.c

152

#define CMU_REG3_VCO_MOMSEL_INIT_SET(dst, src) \

drivers/phy/phy-xgene.c

153

(((dst) & ~0x000003f0) | (((u32) (src) << 4) & 0x000003f0))

drivers/phy/phy-xgene.c

154

#define CMU_REG3_VCO_MANMOMSEL_SET(dst, src) \

drivers/phy/phy-xgene.c

155

(((dst) & ~0x0000fc00) | (((u32) (src) << 10) & 0x0000fc00))

drivers/phy/phy-xgene.c

158

#define CMU_REG5_PLL_LFSMCAP_SET(dst, src) \

drivers/phy/phy-xgene.c

159

(((dst) & ~0x0000c000) | (((u32) (src) << 14) & 0x0000c000))

drivers/phy/phy-xgene.c

160

#define CMU_REG5_PLL_LOCK_RESOLUTION_SET(dst, src) \

drivers/phy/phy-xgene.c

161

(((dst) & ~0x0000000e) | (((u32) (src) << 1) & 0x0000000e))

drivers/phy/phy-xgene.c

162

#define CMU_REG5_PLL_LFCAP_SET(dst, src) \

drivers/phy/phy-xgene.c

163

(((dst) & ~0x00003000) | (((u32) (src) << 12) & 0x00003000))

drivers/phy/phy-xgene.c

166

#define CMU_REG6_PLL_VREGTRIM_SET(dst, src) \

drivers/phy/phy-xgene.c

167

(((dst) & ~0x00000600) | (((u32) (src) << 9) & 0x00000600))

drivers/phy/phy-xgene.c

168

#define CMU_REG6_MAN_PVT_CAL_SET(dst, src) \

drivers/phy/phy-xgene.c

169

(((dst) & ~0x00000004) | (((u32) (src) << 2) & 0x00000004))

drivers/phy/phy-xgene.c

183

#define CMU_REG9_TX_WORD_MODE_CH1_SET(dst, src) \

drivers/phy/phy-xgene.c

184

(((dst) & ~0x00000380) | (((u32) (src) << 7) & 0x00000380))

drivers/phy/phy-xgene.c

185

#define CMU_REG9_TX_WORD_MODE_CH0_SET(dst, src) \

drivers/phy/phy-xgene.c

186

(((dst) & ~0x00000070) | (((u32) (src) << 4) & 0x00000070))

drivers/phy/phy-xgene.c

187

#define CMU_REG9_PLL_POST_DIVBY2_SET(dst, src) \

drivers/phy/phy-xgene.c

188

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

189

#define CMU_REG9_VBG_BYPASSB_SET(dst, src) \

drivers/phy/phy-xgene.c

190

(((dst) & ~0x00000004) | (((u32) (src) << 2) & 0x00000004))

drivers/phy/phy-xgene.c

191

#define CMU_REG9_IGEN_BYPASS_SET(dst, src) \

drivers/phy/phy-xgene.c

192

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

194

#define CMU_REG10_VREG_REFSEL_SET(dst, src) \

drivers/phy/phy-xgene.c

195

(((dst) & ~0x00000001) | (((u32) (src) << 0) & 0x00000001))

drivers/phy/phy-xgene.c

198

#define CMU_REG12_STATE_DELAY9_SET(dst, src) \

drivers/phy/phy-xgene.c

199

(((dst) & ~0x000000f0) | (((u32) (src) << 4) & 0x000000f0))

drivers/phy/phy-xgene.c

206

#define CMU_REG16_VCOCAL_WAIT_BTW_CODE_SET(dst, src) \

drivers/phy/phy-xgene.c

207

(((dst) & ~0x0000001c) | (((u32) (src) << 2) & 0x0000001c))

drivers/phy/phy-xgene.c

208

#define CMU_REG16_CALIBRATION_DONE_OVERRIDE_SET(dst, src) \

drivers/phy/phy-xgene.c

209

(((dst) & ~0x00000040) | (((u32) (src) << 6) & 0x00000040))

drivers/phy/phy-xgene.c

210

#define CMU_REG16_BYPASS_PLL_LOCK_SET(dst, src) \

drivers/phy/phy-xgene.c

211

(((dst) & ~0x00000020) | (((u32) (src) << 5) & 0x00000020))

drivers/phy/phy-xgene.c

213

#define CMU_REG17_PVT_CODE_R2A_SET(dst, src) \

drivers/phy/phy-xgene.c

214

(((dst) & ~0x00007f00) | (((u32) (src) << 8) & 0x00007f00))

drivers/phy/phy-xgene.c

215

#define CMU_REG17_RESERVED_7_SET(dst, src) \

drivers/phy/phy-xgene.c

216

(((dst) & ~0x000000e0) | (((u32) (src) << 5) & 0x000000e0))

drivers/phy/phy-xgene.c

227

#define CMU_REG26_FORCE_PLL_LOCK_SET(dst, src) \

drivers/phy/phy-xgene.c

228

(((dst) & ~0x00000001) | (((u32) (src) << 0) & 0x00000001))

drivers/phy/phy-xgene.c

233

#define CMU_REG30_LOCK_COUNT_SET(dst, src) \

drivers/phy/phy-xgene.c

234

(((dst) & ~0x00000006) | (((u32) (src) << 1) & 0x00000006))

drivers/phy/phy-xgene.c

235

#define CMU_REG30_PCIE_MODE_SET(dst, src) \

drivers/phy/phy-xgene.c

236

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

240

#define CMU_REG32_PVT_CAL_WAIT_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

241

(((dst) & ~0x00000006) | (((u32) (src) << 1) & 0x00000006))

drivers/phy/phy-xgene.c

242

#define CMU_REG32_IREF_ADJ_SET(dst, src) \

drivers/phy/phy-xgene.c

243

(((dst) & ~0x00000180) | (((u32) (src) << 7) & 0x00000180))

drivers/phy/phy-xgene.c

246

#define CMU_REG34_VCO_CAL_VTH_LO_MAX_SET(dst, src) \

drivers/phy/phy-xgene.c

247

(((dst) & ~0x0000000f) | (((u32) (src) << 0) & 0x0000000f))

drivers/phy/phy-xgene.c

248

#define CMU_REG34_VCO_CAL_VTH_HI_MAX_SET(dst, src) \

drivers/phy/phy-xgene.c

249

(((dst) & ~0x00000f00) | (((u32) (src) << 8) & 0x00000f00))

drivers/phy/phy-xgene.c

250

#define CMU_REG34_VCO_CAL_VTH_LO_MIN_SET(dst, src) \

drivers/phy/phy-xgene.c

251

(((dst) & ~0x000000f0) | (((u32) (src) << 4) & 0x000000f0))

drivers/phy/phy-xgene.c

252

#define CMU_REG34_VCO_CAL_VTH_HI_MIN_SET(dst, src) \

drivers/phy/phy-xgene.c

253

(((dst) & ~0x0000f000) | (((u32) (src) << 12) & 0x0000f000))

drivers/phy/phy-xgene.c

255

#define CMU_REG35_PLL_SSC_MOD_SET(dst, src) \

drivers/phy/phy-xgene.c

256

(((dst) & ~0x0000fe00) | (((u32) (src) << 9) & 0x0000fe00))

drivers/phy/phy-xgene.c

258

#define CMU_REG36_PLL_SSC_EN_SET(dst, src) \

drivers/phy/phy-xgene.c

259

(((dst) & ~0x00000010) | (((u32) (src) << 4) & 0x00000010))

drivers/phy/phy-xgene.c

260

#define CMU_REG36_PLL_SSC_VSTEP_SET(dst, src) \

drivers/phy/phy-xgene.c

261

(((dst) & ~0x0000ffc0) | (((u32) (src) << 6) & 0x0000ffc0))

drivers/phy/phy-xgene.c

262

#define CMU_REG36_PLL_SSC_DSMSEL_SET(dst, src) \

drivers/phy/phy-xgene.c

263

(((dst) & ~0x00000020) | (((u32) (src) << 5) & 0x00000020))

drivers/phy/phy-xgene.c

270

#define RXTX_REG0_CTLE_EQ_HR_SET(dst, src) \

drivers/phy/phy-xgene.c

271

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

272

#define RXTX_REG0_CTLE_EQ_QR_SET(dst, src) \

drivers/phy/phy-xgene.c

273

(((dst) & ~0x000007c0) | (((u32) (src) << 6) & 0x000007c0))

drivers/phy/phy-xgene.c

274

#define RXTX_REG0_CTLE_EQ_FR_SET(dst, src) \

drivers/phy/phy-xgene.c

275

(((dst) & ~0x0000003e) | (((u32) (src) << 1) & 0x0000003e))

drivers/phy/phy-xgene.c

277

#define RXTX_REG1_RXACVCM_SET(dst, src) \

drivers/phy/phy-xgene.c

278

(((dst) & ~0x0000f000) | (((u32) (src) << 12) & 0x0000f000))

drivers/phy/phy-xgene.c

279

#define RXTX_REG1_CTLE_EQ_SET(dst, src) \

drivers/phy/phy-xgene.c

280

(((dst) & ~0x00000f80) | (((u32) (src) << 7) & 0x00000f80))

drivers/phy/phy-xgene.c

281

#define RXTX_REG1_RXVREG1_SET(dst, src) \

drivers/phy/phy-xgene.c

282

(((dst) & ~0x00000060) | (((u32) (src) << 5) & 0x00000060))

drivers/phy/phy-xgene.c

283

#define RXTX_REG1_RXIREF_ADJ_SET(dst, src) \

drivers/phy/phy-xgene.c

284

(((dst) & ~0x00000006) | (((u32) (src) << 1) & 0x00000006))

drivers/phy/phy-xgene.c

286

#define RXTX_REG2_VTT_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

287

(((dst) & ~0x00000100) | (((u32) (src) << 8) & 0x00000100))

drivers/phy/phy-xgene.c

288

#define RXTX_REG2_TX_FIFO_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

289

(((dst) & ~0x00000020) | (((u32) (src) << 5) & 0x00000020))

drivers/phy/phy-xgene.c

290

#define RXTX_REG2_VTT_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

291

(((dst) & ~0x000000c0) | (((u32) (src) << 6) & 0x000000c0))

drivers/phy/phy-xgene.c

294

#define RXTX_REG4_TX_DATA_RATE_SET(dst, src) \

drivers/phy/phy-xgene.c

295

(((dst) & ~0x0000c000) | (((u32) (src) << 14) & 0x0000c000))

drivers/phy/phy-xgene.c

296

#define RXTX_REG4_TX_WORD_MODE_SET(dst, src) \

drivers/phy/phy-xgene.c

297

(((dst) & ~0x00003800) | (((u32) (src) << 11) & 0x00003800))

drivers/phy/phy-xgene.c

299

#define RXTX_REG5_TX_CN1_SET(dst, src) \

drivers/phy/phy-xgene.c

300

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

301

#define RXTX_REG5_TX_CP1_SET(dst, src) \

drivers/phy/phy-xgene.c

302

(((dst) & ~0x000007e0) | (((u32) (src) << 5) & 0x000007e0))

drivers/phy/phy-xgene.c

303

#define RXTX_REG5_TX_CN2_SET(dst, src) \

drivers/phy/phy-xgene.c

304

(((dst) & ~0x0000001f) | (((u32) (src) << 0) & 0x0000001f))

drivers/phy/phy-xgene.c

306

#define RXTX_REG6_TXAMP_CNTL_SET(dst, src) \

drivers/phy/phy-xgene.c

307

(((dst) & ~0x00000780) | (((u32) (src) << 7) & 0x00000780))

drivers/phy/phy-xgene.c

308

#define RXTX_REG6_TXAMP_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

309

(((dst) & ~0x00000040) | (((u32) (src) << 6) & 0x00000040))

drivers/phy/phy-xgene.c

310

#define RXTX_REG6_RX_BIST_ERRCNT_RD_SET(dst, src) \

drivers/phy/phy-xgene.c

311

(((dst) & ~0x00000001) | (((u32) (src) << 0) & 0x00000001))

drivers/phy/phy-xgene.c

312

#define RXTX_REG6_TX_IDLE_SET(dst, src) \

drivers/phy/phy-xgene.c

313

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

314

#define RXTX_REG6_RX_BIST_RESYNC_SET(dst, src) \

drivers/phy/phy-xgene.c

315

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

319

#define RXTX_REG7_BIST_ENA_RX_SET(dst, src) \

drivers/phy/phy-xgene.c

320

(((dst) & ~0x00000040) | (((u32) (src) << 6) & 0x00000040))

drivers/phy/phy-xgene.c

321

#define RXTX_REG7_RX_WORD_MODE_SET(dst, src) \

drivers/phy/phy-xgene.c

322

(((dst) & ~0x00003800) | (((u32) (src) << 11) & 0x00003800))

drivers/phy/phy-xgene.c

324

#define RXTX_REG8_CDR_LOOP_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

325

(((dst) & ~0x00004000) | (((u32) (src) << 14) & 0x00004000))

drivers/phy/phy-xgene.c

326

#define RXTX_REG8_CDR_BYPASS_RXLOS_SET(dst, src) \

drivers/phy/phy-xgene.c

327

(((dst) & ~0x00000800) | (((u32) (src) << 11) & 0x00000800))

drivers/phy/phy-xgene.c

328

#define RXTX_REG8_SSC_ENABLE_SET(dst, src) \

drivers/phy/phy-xgene.c

329

(((dst) & ~0x00000200) | (((u32) (src) << 9) & 0x00000200))

drivers/phy/phy-xgene.c

330

#define RXTX_REG8_SD_VREF_SET(dst, src) \

drivers/phy/phy-xgene.c

331

(((dst) & ~0x000000f0) | (((u32) (src) << 4) & 0x000000f0))

drivers/phy/phy-xgene.c

332

#define RXTX_REG8_SD_DISABLE_SET(dst, src) \

drivers/phy/phy-xgene.c

333

(((dst) & ~0x00000100) | (((u32) (src) << 8) & 0x00000100))

drivers/phy/phy-xgene.c

335

#define RXTX_REG7_RESETB_RXD_SET(dst, src) \

drivers/phy/phy-xgene.c

336

(((dst) & ~0x00000100) | (((u32) (src) << 8) & 0x00000100))

drivers/phy/phy-xgene.c

337

#define RXTX_REG7_RESETB_RXA_SET(dst, src) \

drivers/phy/phy-xgene.c

338

(((dst) & ~0x00000080) | (((u32) (src) << 7) & 0x00000080))

drivers/phy/phy-xgene.c

340

#define RXTX_REG7_LOOP_BACK_ENA_CTLE_SET(dst, src) \

drivers/phy/phy-xgene.c

341

(((dst) & ~0x00004000) | (((u32) (src) << 14) & 0x00004000))

drivers/phy/phy-xgene.c

343

#define RXTX_REG11_PHASE_ADJUST_LIMIT_SET(dst, src) \

drivers/phy/phy-xgene.c

344

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

346

#define RXTX_REG12_LATCH_OFF_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

347

(((dst) & ~0x00002000) | (((u32) (src) << 13) & 0x00002000))

drivers/phy/phy-xgene.c

348

#define RXTX_REG12_SUMOS_ENABLE_SET(dst, src) \

drivers/phy/phy-xgene.c

349

(((dst) & ~0x00000004) | (((u32) (src) << 2) & 0x00000004))

drivers/phy/phy-xgene.c

351

#define RXTX_REG12_RX_DET_TERM_ENABLE_SET(dst, src) \

drivers/phy/phy-xgene.c

352

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

355

#define RXTX_REG14_CLTE_LATCAL_MAN_PROG_SET(dst, src) \

drivers/phy/phy-xgene.c

356

(((dst) & ~0x0000003f) | (((u32) (src) << 0) & 0x0000003f))

drivers/phy/phy-xgene.c

357

#define RXTX_REG14_CTLE_LATCAL_MAN_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

358

(((dst) & ~0x00000040) | (((u32) (src) << 6) & 0x00000040))

drivers/phy/phy-xgene.c

360

#define RXTX_REG26_PERIOD_ERROR_LATCH_SET(dst, src) \

drivers/phy/phy-xgene.c

361

(((dst) & ~0x00003800) | (((u32) (src) << 11) & 0x00003800))

drivers/phy/phy-xgene.c

362

#define RXTX_REG26_BLWC_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

363

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

382

#define RXTX_REG38_CUSTOMER_PINMODE_INV_SET(dst, src) \

drivers/phy/phy-xgene.c

383

(((dst) & 0x0000fffe) | (((u32) (src) << 1) & 0x0000fffe))

drivers/phy/phy-xgene.c

402

#define RXTX_REG61_ISCAN_INBERT_SET(dst, src) \

drivers/phy/phy-xgene.c

403

(((dst) & ~0x00000010) | (((u32) (src) << 4) & 0x00000010))

drivers/phy/phy-xgene.c

404

#define RXTX_REG61_LOADFREQ_SHIFT_SET(dst, src) \

drivers/phy/phy-xgene.c

405

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

406

#define RXTX_REG61_EYE_COUNT_WIDTH_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

407

(((dst) & ~0x000000c0) | (((u32) (src) << 6) & 0x000000c0))

drivers/phy/phy-xgene.c

408

#define RXTX_REG61_SPD_SEL_CDR_SET(dst, src) \

drivers/phy/phy-xgene.c

409

(((dst) & ~0x00003c00) | (((u32) (src) << 10) & 0x00003c00))

drivers/phy/phy-xgene.c

411

#define RXTX_REG62_PERIOD_H1_QLATCH_SET(dst, src) \

drivers/phy/phy-xgene.c

412

(((dst) & ~0x00003800) | (((u32) (src) << 11) & 0x00003800))

drivers/phy/phy-xgene.c

414

#define RXTX_REG89_MU_TH7_SET(dst, src) \

drivers/phy/phy-xgene.c

415

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

416

#define RXTX_REG89_MU_TH8_SET(dst, src) \

drivers/phy/phy-xgene.c

417

(((dst) & ~0x000007c0) | (((u32) (src) << 6) & 0x000007c0))

drivers/phy/phy-xgene.c

418

#define RXTX_REG89_MU_TH9_SET(dst, src) \

drivers/phy/phy-xgene.c

419

(((dst) & ~0x0000003e) | (((u32) (src) << 1) & 0x0000003e))

drivers/phy/phy-xgene.c

421

#define RXTX_REG96_MU_FREQ1_SET(dst, src) \

drivers/phy/phy-xgene.c

422

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

423

#define RXTX_REG96_MU_FREQ2_SET(dst, src) \

drivers/phy/phy-xgene.c

424

(((dst) & ~0x000007c0) | (((u32) (src) << 6) & 0x000007c0))

drivers/phy/phy-xgene.c

425

#define RXTX_REG96_MU_FREQ3_SET(dst, src) \

drivers/phy/phy-xgene.c

426

(((dst) & ~0x0000003e) | (((u32) (src) << 1) & 0x0000003e))

drivers/phy/phy-xgene.c

428

#define RXTX_REG99_MU_PHASE1_SET(dst, src) \

drivers/phy/phy-xgene.c

429

(((dst) & ~0x0000f800) | (((u32) (src) << 11) & 0x0000f800))

drivers/phy/phy-xgene.c

430

#define RXTX_REG99_MU_PHASE2_SET(dst, src) \

drivers/phy/phy-xgene.c

431

(((dst) & ~0x000007c0) | (((u32) (src) << 6) & 0x000007c0))

drivers/phy/phy-xgene.c

432

#define RXTX_REG99_MU_PHASE3_SET(dst, src) \

drivers/phy/phy-xgene.c

433

(((dst) & ~0x0000003e) | (((u32) (src) << 1) & 0x0000003e))

drivers/phy/phy-xgene.c

435

#define RXTX_REG102_FREQLOOP_LIMIT_SET(dst, src) \

drivers/phy/phy-xgene.c

436

(((dst) & ~0x00000060) | (((u32) (src) << 5) & 0x00000060))

drivers/phy/phy-xgene.c

441

#define RXTX_REG125_PQ_REG_SET(dst, src) \

drivers/phy/phy-xgene.c

442

(((dst) & ~0x0000fe00) | (((u32) (src) << 9) & 0x0000fe00))

drivers/phy/phy-xgene.c

443

#define RXTX_REG125_SIGN_PQ_SET(dst, src) \

drivers/phy/phy-xgene.c

444

(((dst) & ~0x00000100) | (((u32) (src) << 8) & 0x00000100))

drivers/phy/phy-xgene.c

445

#define RXTX_REG125_SIGN_PQ_2C_SET(dst, src) \

drivers/phy/phy-xgene.c

446

(((dst) & ~0x00000080) | (((u32) (src) << 7) & 0x00000080))

drivers/phy/phy-xgene.c

447

#define RXTX_REG125_PHZ_MANUALCODE_SET(dst, src) \

drivers/phy/phy-xgene.c

448

(((dst) & ~0x0000007c) | (((u32) (src) << 2) & 0x0000007c))

drivers/phy/phy-xgene.c

449

#define RXTX_REG125_PHZ_MANUAL_SET(dst, src) \

drivers/phy/phy-xgene.c

450

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

454

#define RXTX_REG127_FORCE_SUM_CAL_START_SET(dst, src) \

drivers/phy/phy-xgene.c

455

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

456

#define RXTX_REG127_FORCE_LAT_CAL_START_SET(dst, src) \

drivers/phy/phy-xgene.c

457

(((dst) & ~0x00000004) | (((u32) (src) << 2) & 0x00000004))

drivers/phy/phy-xgene.c

458

#define RXTX_REG127_LATCH_MAN_CAL_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

459

(((dst) & ~0x00000008) | (((u32) (src) << 3) & 0x00000008))

drivers/phy/phy-xgene.c

460

#define RXTX_REG127_DO_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

461

(((dst) & ~0x0000fc00) | (((u32) (src) << 10) & 0x0000fc00))

drivers/phy/phy-xgene.c

462

#define RXTX_REG127_XO_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

463

(((dst) & ~0x000003f0) | (((u32) (src) << 4) & 0x000003f0))

drivers/phy/phy-xgene.c

465

#define RXTX_REG128_LATCH_CAL_WAIT_SEL_SET(dst, src) \

drivers/phy/phy-xgene.c

466

(((dst) & ~0x0000000c) | (((u32) (src) << 2) & 0x0000000c))

drivers/phy/phy-xgene.c

467

#define RXTX_REG128_EO_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

468

(((dst) & ~0x0000fc00) | (((u32) (src) << 10) & 0x0000fc00))

drivers/phy/phy-xgene.c

469

#define RXTX_REG128_SO_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

470

(((dst) & ~0x000003f0) | (((u32) (src) << 4) & 0x000003f0))

drivers/phy/phy-xgene.c

472

#define RXTX_REG129_DE_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

473

(((dst) & ~0x0000fc00) | (((u32) (src) << 10) & 0x0000fc00))

drivers/phy/phy-xgene.c

474

#define RXTX_REG129_XE_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

475

(((dst) & ~0x000003f0) | (((u32) (src) << 4) & 0x000003f0))

drivers/phy/phy-xgene.c

477

#define RXTX_REG130_EE_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

478

(((dst) & ~0x0000fc00) | (((u32) (src) << 10) & 0x0000fc00))

drivers/phy/phy-xgene.c

479

#define RXTX_REG130_SE_LATCH_MANCAL_SET(dst, src) \

drivers/phy/phy-xgene.c

480

(((dst) & ~0x000003f0) | (((u32) (src) << 4) & 0x000003f0))

drivers/phy/phy-xgene.c

482

#define RXTX_REG145_TX_IDLE_SATA_SET(dst, src) \

drivers/phy/phy-xgene.c

483

(((dst) & ~0x00000001) | (((u32) (src) << 0) & 0x00000001))

drivers/phy/phy-xgene.c

484

#define RXTX_REG145_RXES_ENA_SET(dst, src) \

drivers/phy/phy-xgene.c

485

(((dst) & ~0x00000002) | (((u32) (src) << 1) & 0x00000002))

drivers/phy/phy-xgene.c

486

#define RXTX_REG145_RXDFE_CONFIG_SET(dst, src) \

drivers/phy/phy-xgene.c

487

(((dst) & ~0x0000c000) | (((u32) (src) << 14) & 0x0000c000))

drivers/phy/phy-xgene.c

488

#define RXTX_REG145_RXVWES_LATENA_SET(dst, src) \

drivers/phy/phy-xgene.c

489

(((dst) & ~0x00000004) | (((u32) (src) << 2) & 0x00000004))

drivers/phy/phy-xgene.c

95

#define REGSPEC_CFG_I_TX_WORDMODE0_SET(dst, src) \

drivers/phy/phy-xgene.c

96

(((dst) & ~0x00070000) | (((u32) (src) << 16) & 0x00070000))

drivers/phy/phy-xgene.c

97

#define REGSPEC_CFG_I_RX_WORDMODE0_SET(dst, src) \

drivers/phy/phy-xgene.c

98

(((dst) & ~0x00e00000) | (((u32) (src) << 21) & 0x00e00000))

drivers/platform/chrome/cros_ec_rpmsg.c

207

chinfo.dst = RPMSG_ADDR_ANY;

drivers/platform/cznic/turris-omnia-mcu-gpio.c

656

omnia_mask_interleave(u8 *dst, unsigned long rising, unsigned long falling)

drivers/platform/cznic/turris-omnia-mcu-gpio.c

659

dst[2 * i] = rising >> (8 * i);

drivers/platform/cznic/turris-omnia-mcu-gpio.c

660

dst[2 * i + 1] = falling >> (8 * i);

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1510

struct vchiq_mmal_port *dst)

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1541

if (!dst) {

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1549

dst->format.encoding = src->format.encoding;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1550

dst->es.video.width = src->es.video.width;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1551

dst->es.video.height = src->es.video.height;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1552

dst->es.video.crop.x = src->es.video.crop.x;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1553

dst->es.video.crop.y = src->es.video.crop.y;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1554

dst->es.video.crop.width = src->es.video.crop.width;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1555

dst->es.video.crop.height = src->es.video.crop.height;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1556

dst->es.video.frame_rate.numerator = src->es.video.frame_rate.numerator;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1557

dst->es.video.frame_rate.denominator = src->es.video.frame_rate.denominator;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1560

ret = port_info_set(instance, dst);

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1567

ret = port_info_get(instance, dst);

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1576

dst->component->handle, dst->handle);

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1580

dst->component->handle, dst->handle);

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.c

1583

src->connected = dst;

drivers/platform/raspberrypi/vchiq-mmal/mmal-vchiq.h

149

struct vchiq_mmal_port *dst);

drivers/platform/wmi/string.c

34

ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t length)

drivers/platform/wmi/string.c

44

ret = utf16s_to_utf8s((__force const wchar_t *)str->chars, inlen, UTF16_LITTLE_ENDIAN, dst,

drivers/platform/wmi/string.c

49

dst[ret] = '\0';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

102

dst[i++] = '\\';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

108

dst[i] = 'r';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

110

dst[i] = 'n';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

112

dst[i] = 't';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

114

dst[i] = '\'';

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

116

dst[i] = *src;

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

54

int hp_get_string_from_buffer(u8 **buffer, u32 *buffer_size, char *dst, u32 dst_size)

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

94

utf16s_to_utf8s(src, src_size, UTF16_HOST_ENDIAN, dst, conv_dst_size);

drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

95

dst[conv_dst_size] = 0;

drivers/platform/x86/hp/hp-bioscfg/bioscfg.h

473

int hp_get_string_from_buffer(u8 **buffer, u32 *buffer_size, char *dst, u32 dst_size);

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

303

char *dst = NULL;

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

308

dst = kcalloc(dst_size, sizeof(char), GFP_KERNEL);

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

309

if (!dst)

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

330

hp_get_string_from_buffer(&buffer_ptr, buffer_size, dst, dst_size);

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

331

ret = kstrtoint(dst, 10, &integer_data->current_value);

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

333

pr_warn("Unable to convert string to integer: %s\n", dst);

drivers/platform/x86/hp/hp-bioscfg/int-attributes.c

334

kfree(dst);

drivers/ptp/ptp_clock.c

50

struct ptp_extts_event *dst;

drivers/ptp/ptp_clock.c

69

dst = &queue->buf[queue->tail];

drivers/ptp/ptp_clock.c

70

dst->index = src->index;

drivers/ptp/ptp_clock.c

71

dst->flags = PTP_EXTTS_EVENT_VALID;

drivers/ptp/ptp_clock.c

72

dst->t.sec = seconds;

drivers/ptp/ptp_clock.c

73

dst->t.nsec = remainder;

drivers/ptp/ptp_clock.c

75

dst->flags |= PTP_EXT_OFFSET;

drivers/rapidio/devices/rio_mport_cdev.c

1379

u16 src, u16 dst, u16 info)

drivers/rapidio/rio.c

403

void (*dinb) (struct rio_mport * mport, void *dev_id, u16 src, u16 dst,

drivers/rapidio/rio.c

438

u16 dst, u16 info))

drivers/remoteproc/imx_dsp_rproc.c

802

static int imx_dsp_rproc_memcpy(void *dst, const void *src, size_t size)

drivers/remoteproc/imx_dsp_rproc.c

804

void __iomem *dest = (void __iomem *)dst;

drivers/remoteproc/mtk_common.h

173

void scp_memcpy_aligned(void __iomem *dst, const void *src, unsigned int len);

drivers/remoteproc/mtk_scp_ipi.c

100

__iowrite32_copy(dst + i, src + i, (len - i) / 4);

drivers/remoteproc/mtk_scp_ipi.c

104

val = readl_relaxed(dst + len - remain);

drivers/remoteproc/mtk_scp_ipi.c

106

writel_relaxed(val, dst + len - remain);

drivers/remoteproc/mtk_scp_ipi.c

86

void scp_memcpy_aligned(void __iomem *dst, const void *src, unsigned int len)

drivers/remoteproc/mtk_scp_ipi.c

92

if (!IS_ALIGNED((unsigned long)dst, 4)) {

drivers/remoteproc/mtk_scp_ipi.c

93

ptr = (void __iomem *)ALIGN_DOWN((unsigned long)dst, 4);

drivers/remoteproc/mtk_scp_ipi.c

94

i = 4 - (dst - ptr);

drivers/rpmsg/mtk_rpmsg.c

213

rpdev->dst = info->dst;

drivers/rpmsg/mtk_rpmsg.c

261

info->info.dst = RPMSG_ADDR_ANY;

drivers/rpmsg/mtk_rpmsg.c

365

info->info.dst);

drivers/rpmsg/qcom_glink_native.c

1126

static int qcom_glink_set_flow_control(struct rpmsg_endpoint *ept, bool pause, u32 dst)

drivers/rpmsg/qcom_glink_native.c

1405

chinfo.dst = RPMSG_ADDR_ANY;

drivers/rpmsg/qcom_glink_native.c

1570

static int qcom_glink_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/qcom_glink_native.c

1577

static int qcom_glink_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/qcom_glink_native.c

1681

rpdev->dst = RPMSG_ADDR_ANY;

drivers/rpmsg/qcom_smd.c

1094

rpdev->dst = RPMSG_ADDR_ANY;

drivers/rpmsg/qcom_smd.c

1328

chinfo.dst = RPMSG_ADDR_ANY;

drivers/rpmsg/qcom_smd.c

466

static void smd_copy_to_fifo(void __iomem *dst,

drivers/rpmsg/qcom_smd.c

472

__iowrite32_copy(dst, src, count / sizeof(u32));

drivers/rpmsg/qcom_smd.c

474

memcpy_toio(dst, src, count);

drivers/rpmsg/qcom_smd.c

481

static void smd_copy_from_fifo(void *dst,

drivers/rpmsg/qcom_smd.c

487

__ioread32_copy(dst, src, count / sizeof(u32));

drivers/rpmsg/qcom_smd.c

489

memcpy_fromio(dst, src, count);

drivers/rpmsg/qcom_smd.c

977

static int qcom_smd_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/qcom_smd.c

984

static int qcom_smd_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/rpmsg_char.c

278

ret = rpmsg_trysendto(eptdev->ept, kbuf, len, eptdev->chinfo.dst);

drivers/rpmsg/rpmsg_char.c

282

ret = rpmsg_sendto(eptdev->ept, kbuf, len, eptdev->chinfo.dst);

drivers/rpmsg/rpmsg_char.c

335

ret = rpmsg_set_flow_control(eptdev->ept, set, eptdev->chinfo.dst);

drivers/rpmsg/rpmsg_char.c

386

return sprintf(buf, "%d\n", eptdev->chinfo.dst);

drivers/rpmsg/rpmsg_char.c

388

static DEVICE_ATTR_RO(dst);

drivers/rpmsg/rpmsg_char.c

496

chinfo.dst = rpdev->dst;

drivers/rpmsg/rpmsg_core.c

185

int rpmsg_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/rpmsg_core.c

192

return ept->ops->sendto(ept, data, len, dst);

drivers/rpmsg/rpmsg_core.c

241

int rpmsg_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst)

drivers/rpmsg/rpmsg_core.c

248

return ept->ops->trysendto(ept, data, len, dst);

drivers/rpmsg/rpmsg_core.c

280

int rpmsg_set_flow_control(struct rpmsg_endpoint *ept, bool pause, u32 dst)

drivers/rpmsg/rpmsg_core.c

287

return ept->ops->set_flow_control(ept, pause, dst);

drivers/rpmsg/rpmsg_core.c

325

if (chinfo->dst != RPMSG_ADDR_ANY && chinfo->dst != rpdev->dst)

drivers/rpmsg/rpmsg_core.c

358

rpmsg_show_attr(dst, dst, "0x%x\n");

drivers/rpmsg/rpmsg_core.c

478

chinfo.dst = RPMSG_ADDR_ANY;

drivers/rpmsg/rpmsg_core.c

557

rpdev->id.name, rpdev->src, rpdev->dst);

drivers/rpmsg/rpmsg_ctrl.c

90

chinfo.dst = eptinfo.dst;

drivers/rpmsg/rpmsg_internal.h

67

int (*sendto)(struct rpmsg_endpoint *ept, void *data, int len, u32 dst);

drivers/rpmsg/rpmsg_internal.h

70

int (*trysendto)(struct rpmsg_endpoint *ept, void *data, int len, u32 dst);

drivers/rpmsg/rpmsg_internal.h

73

int (*set_flow_control)(struct rpmsg_endpoint *ept, bool pause, u32 dst);

drivers/rpmsg/rpmsg_ns.c

24

rpdev->dst = RPMSG_NS_ADDR;

drivers/rpmsg/rpmsg_ns.c

55

chinfo.dst = rpmsg32_to_cpu(rpdev, msg->addr);

drivers/rpmsg/rpmsg_ns.c

59

"destroy" : "creat", msg->name, chinfo.dst);

drivers/rpmsg/rpmsg_ns.c

79

.dst = RPMSG_NS_ADDR,

drivers/rpmsg/virtio_rpmsg_bus.c

141

u32 dst);

drivers/rpmsg/virtio_rpmsg_bus.c

144

int len, u32 dst);

drivers/rpmsg/virtio_rpmsg_bus.c

399

chinfo->name, chinfo->src, chinfo->dst);

drivers/rpmsg/virtio_rpmsg_bus.c

413

rpdev->dst = chinfo->dst;

drivers/rpmsg/virtio_rpmsg_bus.c

492

u32 src, u32 dst,

drivers/rpmsg/virtio_rpmsg_bus.c

503

if (src == RPMSG_ADDR_ANY || dst == RPMSG_ADDR_ANY) {

drivers/rpmsg/virtio_rpmsg_bus.c

504

dev_err(dev, "invalid addr (src 0x%x, dst 0x%x)\n", src, dst);

drivers/rpmsg/virtio_rpmsg_bus.c

549

msg->dst = cpu_to_rpmsg32(rpdev, dst);

drivers/rpmsg/virtio_rpmsg_bus.c

554

src, dst, len, msg->flags, msg->reserved);

drivers/rpmsg/virtio_rpmsg_bus.c

586

u32 src = ept->addr, dst = rpdev->dst;

drivers/rpmsg/virtio_rpmsg_bus.c

588

return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, true);

drivers/rpmsg/virtio_rpmsg_bus.c

592

u32 dst)

drivers/rpmsg/virtio_rpmsg_bus.c

597

return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, true);

drivers/rpmsg/virtio_rpmsg_bus.c

603

u32 src = ept->addr, dst = rpdev->dst;

drivers/rpmsg/virtio_rpmsg_bus.c

605

return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, false);

drivers/rpmsg/virtio_rpmsg_bus.c

609

int len, u32 dst)

drivers/rpmsg/virtio_rpmsg_bus.c

614

return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, false);

drivers/rpmsg/virtio_rpmsg_bus.c

664

__rpmsg32_to_cpu(little_endian, msg->dst), msg_len,

drivers/rpmsg/virtio_rpmsg_bus.c

685

ept = idr_find(&vrp->endpoints, __rpmsg32_to_cpu(little_endian, msg->dst));

drivers/rpmsg/virtio_rpmsg_bus.c

85

__rpmsg32 dst;

drivers/s390/block/dasd_diag.c

517

char *dst;

drivers/s390/block/dasd_diag.c

556

dst = bvec_virt(&bv);

drivers/s390/block/dasd_diag.c

561

dbio->buffer = dst;

drivers/s390/block/dasd_diag.c

563

dst += blksize;

drivers/s390/block/dasd_eckd.c

3269

char *dst;

drivers/s390/block/dasd_eckd.c

3309

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

3315

if (dst && !skip_block)

drivers/s390/block/dasd_eckd.c

3316

memset(dst, 0, blksize);

drivers/s390/block/dasd_eckd.c

3319

dst += blksize;

drivers/s390/block/dasd_eckd.c

3971

char *dst;

drivers/s390/block/dasd_eckd.c

4065

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4070

memcpy(copy + bv.bv_offset, dst, bv.bv_len);

drivers/s390/block/dasd_eckd.c

4072

dst = copy + bv.bv_offset;

drivers/s390/block/dasd_eckd.c

4086

memset(dst + count, 0xe5,

drivers/s390/block/dasd_eckd.c

4106

if (idal_is_needed(dst, blksize)) {

drivers/s390/block/dasd_eckd.c

4109

idaws = idal_create_words(idaws, dst, blksize);

drivers/s390/block/dasd_eckd.c

4111

ccw->cda = virt_to_dma32(dst);

drivers/s390/block/dasd_eckd.c

4115

dst += blksize;

drivers/s390/block/dasd_eckd.c

4157

char *dst, *idaw_dst;

drivers/s390/block/dasd_eckd.c

4230

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4250

idaw_dst = dst;

drivers/s390/block/dasd_eckd.c

4259

if ((unsigned long)(dst) & (IDA_BLOCK_SIZE - 1)) {

drivers/s390/block/dasd_eckd.c

4263

idaw_dst = dst;

drivers/s390/block/dasd_eckd.c

4265

if ((idaw_dst + idaw_len) != dst) {

drivers/s390/block/dasd_eckd.c

4271

dst += part_len;

drivers/s390/block/dasd_eckd.c

4487

char *dst;

drivers/s390/block/dasd_eckd.c

4573

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4596

dst, part_len);

drivers/s390/block/dasd_eckd.c

4601

dst += part_len;

drivers/s390/block/dasd_eckd.c

4606

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4608

dst, bv.bv_len);

drivers/s390/block/dasd_eckd.c

4744

char *dst;

drivers/s390/block/dasd_eckd.c

4839

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4842

memset(dst, 0, seg_len);

drivers/s390/block/dasd_eckd.c

4856

idaws = idal_create_words(idaws, dst, seg_len);

drivers/s390/block/dasd_eckd.c

4883

char *dst, *cda;

drivers/s390/block/dasd_eckd.c

4900

dst = bvec_virt(&bv);

drivers/s390/block/dasd_eckd.c

4905

if (dst) {

drivers/s390/block/dasd_eckd.c

4910

if (dst != cda) {

drivers/s390/block/dasd_eckd.c

4912

memcpy(dst, cda, bv.bv_len);

drivers/s390/block/dasd_eckd.c

4916

dst = NULL;

drivers/s390/block/dasd_fba.c

436

char *dst;

drivers/s390/block/dasd_fba.c

499

dst = bvec_virt(&bv);

drivers/s390/block/dasd_fba.c

504

memcpy(copy + bv.bv_offset, dst, bv.bv_len);

drivers/s390/block/dasd_fba.c

506

dst = copy + bv.bv_offset;

drivers/s390/block/dasd_fba.c

525

if (idal_is_needed(dst, blksize)) {

drivers/s390/block/dasd_fba.c

528

idaws = idal_create_words(idaws, dst, blksize);

drivers/s390/block/dasd_fba.c

530

ccw->cda = virt_to_dma32(dst);

drivers/s390/block/dasd_fba.c

534

dst += blksize;

drivers/s390/block/dasd_fba.c

568

char *dst, *cda;

drivers/s390/block/dasd_fba.c

581

dst = bvec_virt(&bv);

drivers/s390/block/dasd_fba.c

586

if (dst) {

drivers/s390/block/dasd_fba.c

591

if (dst != cda) {

drivers/s390/block/dasd_fba.c

593

memcpy(dst, cda, bv.bv_len);

drivers/s390/block/dasd_fba.c

597

dst = NULL;

drivers/s390/char/sclp_ocf.c

88

void sclp_ocf_cpc_name_copy(char *dst)

drivers/s390/char/sclp_ocf.c

91

memcpy(dst, cpc_name, OCF_LENGTH_CPC_NAME);

drivers/s390/char/zcore.c

103

kvec.iov_base = dst;

drivers/s390/char/zcore.c

98

static inline int memcpy_hsa_kernel(void *dst, unsigned long src, size_t count)

drivers/s390/crypto/vfio_ap_ops.c

1694

static void ap_matrix_copy(struct ap_matrix *dst, struct ap_matrix *src)

drivers/s390/crypto/vfio_ap_ops.c

1700

bitmap_copy(dst->apm, src->apm, AP_DEVICES);

drivers/s390/crypto/vfio_ap_ops.c

1701

bitmap_copy(dst->aqm, src->aqm, AP_DOMAINS);

drivers/s390/crypto/vfio_ap_ops.c

1702

bitmap_copy(dst->adm, src->adm, AP_DOMAINS);

drivers/s390/net/qeth_core.h

956

struct dst_entry *dst = skb_dst(skb);

drivers/s390/net/qeth_core.h

959

rt = dst_rt6_info(dst);

drivers/s390/net/qeth_core.h

960

if (dst) {

drivers/s390/net/qeth_core.h

962

dst = dst_check(dst, rt6_get_cookie(rt));

drivers/s390/net/qeth_core.h

964

dst = dst_check(dst, 0);

drivers/s390/net/qeth_core.h

967

return dst;

drivers/s390/net/qeth_core.h

971

struct dst_entry *dst)

drivers/s390/net/qeth_core.h

973

return (dst) ? rt_nexthop(dst_rtable(dst), ip_hdr(skb)->daddr) :

drivers/s390/net/qeth_core.h

978

struct dst_entry *dst)

drivers/s390/net/qeth_core.h

980

struct rt6_info *rt = dst_rt6_info(dst);

drivers/s390/net/qeth_ethtool.c

62

static void qeth_add_stat_data(u64 **dst, void *src,

drivers/s390/net/qeth_ethtool.c

71

**dst = *(u64 *)stat;

drivers/s390/net/qeth_ethtool.c

72

(*dst)++;

drivers/s390/net/qeth_l3_main.c

1565

static int qeth_l3_get_cast_type_rcu(struct sk_buff *skb, struct dst_entry *dst,

drivers/s390/net/qeth_l3_main.c

1570

if (dst)

drivers/s390/net/qeth_l3_main.c

1571

n = dst_neigh_lookup_skb(dst, skb);

drivers/s390/net/qeth_l3_main.c

1604

struct dst_entry *dst;

drivers/s390/net/qeth_l3_main.c

1608

dst = qeth_dst_check_rcu(skb, proto);

drivers/s390/net/qeth_l3_main.c

1609

cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);

drivers/s390/net/qeth_l3_main.c

1633

struct dst_entry *dst;

drivers/s390/net/qeth_l3_main.c

1663

dst = qeth_dst_check_rcu(skb, proto);

drivers/s390/net/qeth_l3_main.c

1668

cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);

drivers/s390/net/qeth_l3_main.c

1674

qeth_next_hop_v4_rcu(skb, dst);

drivers/s390/net/qeth_l3_main.c

1677

l3_hdr->next_hop.addr = *qeth_next_hop_v6_rcu(skb, dst);

drivers/scsi/aic7xxx/aic79xx.h

129

#define AHD_COPY_SCB_COL_IDX(dst, src) \

drivers/scsi/aic7xxx/aic79xx.h

131

dst->hscb->scsiid = src->hscb->scsiid; \

drivers/scsi/aic7xxx/aic79xx.h

132

dst->hscb->lun = src->hscb->lun; \

drivers/scsi/aic7xxx/aic79xx_core.c

275

ahd_set_modes(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)

drivers/scsi/aic7xxx/aic79xx_core.c

277

if (ahd->src_mode == src && ahd->dst_mode == dst)

drivers/scsi/aic7xxx/aic79xx_core.c

285

ahd_build_mode_state(ahd, src, dst));

drivers/scsi/aic7xxx/aic79xx_core.c

287

ahd_outb(ahd, MODE_PTR, ahd_build_mode_state(ahd, src, dst));

drivers/scsi/aic7xxx/aic79xx_core.c

289

ahd->dst_mode = dst;

drivers/scsi/aic7xxx/aic79xx_core.c

297

ahd_mode dst;

drivers/scsi/aic7xxx/aic79xx_core.c

304

ahd_extract_mode_state(ahd, mode_ptr, &src, &dst);

drivers/scsi/aic7xxx/aic79xx_core.c

305

ahd_known_modes(ahd, src, dst);

drivers/scsi/aic7xxx/aic79xx_core.c

338

ahd_mode dst;

drivers/scsi/aic7xxx/aic79xx_core.c

340

ahd_extract_mode_state(ahd, state, &src, &dst);

drivers/scsi/aic7xxx/aic79xx_core.c

341

ahd_set_modes(ahd, src, dst);

drivers/scsi/aic7xxx/aic79xx_inline.h

149

#define AHD_COPY_COL_IDX(dst, src) \

drivers/scsi/aic7xxx/aic79xx_inline.h

151

dst->hscb->scsiid = src->hscb->scsiid; \

drivers/scsi/aic7xxx/aic79xx_inline.h

152

dst->hscb->lun = src->hscb->lun; \

drivers/scsi/aic7xxx/aic79xx_inline.h

58

ahd_mode src, ahd_mode dst);

drivers/scsi/aic7xxx/aic79xx_inline.h

61

ahd_mode dst);

drivers/scsi/aic7xxx/aic79xx_inline.h

64

ahd_mode *src, ahd_mode *dst);

drivers/scsi/aic7xxx/aic79xx_inline.h

67

ahd_mode dst);

drivers/scsi/aic7xxx/aic79xx_inline.h

76

ahd_known_modes(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)

drivers/scsi/aic7xxx/aic79xx_inline.h

79

ahd->dst_mode = dst;

drivers/scsi/aic7xxx/aic79xx_inline.h

81

ahd->saved_dst_mode = dst;

drivers/scsi/aic7xxx/aic79xx_inline.h

85

ahd_build_mode_state(struct ahd_softc *ahd, ahd_mode src, ahd_mode dst)

drivers/scsi/aic7xxx/aic79xx_inline.h

87

return ((src << SRC_MODE_SHIFT) | (dst << DST_MODE_SHIFT));

drivers/scsi/aic7xxx/aic79xx_inline.h

92

ahd_mode *src, ahd_mode *dst)

drivers/scsi/aic7xxx/aic79xx_inline.h

95

*dst = (state & DST_MODE) >> DST_MODE_SHIFT;

drivers/scsi/aic94xx/aic94xx_reg.c

284

void asd_read_reg_string(struct asd_ha_struct *asd_ha, void *dst,

drivers/scsi/aic94xx/aic94xx_reg.c

287

u8 *p = dst;

drivers/scsi/aic94xx/aic94xx_reg.h

54

void asd_read_reg_string(struct asd_ha_struct *asd_ha, void *dst,

drivers/scsi/atari_scsi.c

333

char *src, *dst;

drivers/scsi/atari_scsi.c

346

dst = phys_to_virt(phys_dst);

drivers/scsi/atari_scsi.c

347

dprintk(NDEBUG_DMA, " = virt addr %p\n", dst);

drivers/scsi/atari_scsi.c

349

*dst++ = *src++;

drivers/scsi/bnx2i/bnx2i.h

134

#define GET_STATS_64(__hba, dst, field) \

drivers/scsi/bnx2i/bnx2i.h

137

dst->field##_lo = __hba->stats.field##_lo; \

drivers/scsi/bnx2i/bnx2i.h

138

dst->field##_hi = __hba->stats.field##_hi; \

drivers/scsi/bnx2i/bnx2i.h

154

#define GET_STATS_64(__hba, dst, field) \

drivers/scsi/bnx2i/bnx2i.h

161

out = (u64 *)&dst->field##_lo; \

drivers/scsi/csiostor/csio_mb.c

1060

uint8_t *dst;

drivers/scsi/csiostor/csio_mb.c

1067

dst = (uint8_t *)(&stats) + ((portparams->idx - 1) * 8);

drivers/scsi/csiostor/csio_mb.c

1069

memcpy(dst, src, (portparams->nstats * 8));

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

1000

csk->mss_idx = cxgbi_sock_select_mss(csk, dst_mtu(dst));

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

927

csk->dst = NULL;

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

955

struct dst_entry *dst = csk->dst;

drivers/scsi/cxgbi/cxgb3i/cxgb3i.c

971

csk->l2t = t3_l2t_get(t3dev, dst, ndev,

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

1719

csk->dst = NULL;

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

1797

n = dst_neigh_lookup(csk->dst, daddr);

drivers/scsi/cxgbi/cxgb4i/cxgb4i.c

1859

csk->mtu = dst_mtu(csk->dst);

drivers/scsi/cxgbi/libcxgbi.c

1073

dst_confirm(csk->dst);

drivers/scsi/cxgbi/libcxgbi.c

1101

struct dst_entry *dst = csk->dst;

drivers/scsi/cxgbi/libcxgbi.c

1103

csk->advmss = dst_metric_advmss(dst);

drivers/scsi/cxgbi/libcxgbi.c

2216

char *dst = skb->data + task->hdr_len;

drivers/scsi/cxgbi/libcxgbi.c

2222

memcpy(dst, src + frag->offset, frag->size);

drivers/scsi/cxgbi/libcxgbi.c

2223

dst += frag->size;

drivers/scsi/cxgbi/libcxgbi.c

2228

memset(dst, 0, padlen);

drivers/scsi/cxgbi/libcxgbi.c

607

struct dst_entry *dst;

drivers/scsi/cxgbi/libcxgbi.c

627

dst = &rt->dst;

drivers/scsi/cxgbi/libcxgbi.c

628

n = dst_neigh_lookup(dst, &daddr->sin_addr.s_addr);

drivers/scsi/cxgbi/libcxgbi.c

682

csk->dst = dst;

drivers/scsi/cxgbi/libcxgbi.c

723

struct dst_entry *dst;

drivers/scsi/cxgbi/libcxgbi.c

744

dst = &rt->dst;

drivers/scsi/cxgbi/libcxgbi.c

746

n = dst_neigh_lookup(dst, &daddr6->sin6_addr);

drivers/scsi/cxgbi/libcxgbi.c

793

csk->dst = dst;

drivers/scsi/cxgbi/libcxgbi.c

834

dst_confirm(csk->dst);

drivers/scsi/cxgbi/libcxgbi.c

864

if (csk->dst)

drivers/scsi/cxgbi/libcxgbi.c

865

dst_release(csk->dst);

drivers/scsi/cxgbi/libcxgbi.c

881

if (csk->dst)

drivers/scsi/cxgbi/libcxgbi.c

882

dst_confirm(csk->dst);

drivers/scsi/cxgbi/libcxgbi.h

155

struct dst_entry *dst;

drivers/scsi/elx/efct/efct_hw.h

662

efct_hw_sequence_copy(struct efc_hw_sequence *dst,

drivers/scsi/elx/efct/efct_hw.h

666

*dst = *src;

drivers/scsi/esp_scsi.c

2830

u8 *dst = (u8 *)addr;

drivers/scsi/esp_scsi.c

2839

*dst++ = readb(esp->fifo_reg);

drivers/scsi/g_NCR5380.c

521

unsigned char *dst, int len)

drivers/scsi/g_NCR5380.c

547

dst + start, 64);

drivers/scsi/g_NCR5380.c

550

dst + start, 128);

drivers/scsi/g_NCR5380.c

552

memcpy_fromio(dst + start,

drivers/scsi/libfc/fc_exch.c

2438

int fc_exch_mgr_list_clone(struct fc_lport *src, struct fc_lport *dst)

drivers/scsi/libfc/fc_exch.c

2443

if (!fc_exch_mgr_add(dst, ema->mp, ema->match))

drivers/scsi/libfc/fc_exch.c

2448

list_for_each_entry_safe(ema, tmp, &dst->ema_list, ema_list)

drivers/scsi/libsas/sas_host_smp.c

171

u8 *dst = resp_data + 24 + i, *src =

drivers/scsi/libsas/sas_host_smp.c

173

dst[0] = src[3];

drivers/scsi/libsas/sas_host_smp.c

174

dst[1] = src[2];

drivers/scsi/libsas/sas_host_smp.c

175

dst[2] = src[1];

drivers/scsi/libsas/sas_host_smp.c

176

dst[3] = src[0];

drivers/scsi/mac_scsi.c

309

unsigned char *dst, int len)

drivers/scsi/mac_scsi.c

312

unsigned char *d = dst;

drivers/scsi/mac_scsi.c

343

__func__, d - dst, len, bytes, chunk_bytes);

drivers/scsi/mpt3sas/mpt3sas_ctl.c

1035

Mpi2SGESimple64_t tmp, *src = NULL, *dst = NULL;

drivers/scsi/mpt3sas/mpt3sas_ctl.c

1040

dst =

drivers/scsi/mpt3sas/mpt3sas_ctl.c

1042

src = (void *)dst + ioc->sge_size;

drivers/scsi/mpt3sas/mpt3sas_ctl.c

1045

memcpy(src, dst, ioc->sge_size);

drivers/scsi/mpt3sas/mpt3sas_ctl.c

1046

memcpy(dst, &tmp, ioc->sge_size);

drivers/scsi/ncr53c8xx.c

1926

(struct ncb *np, ncrcmd *src, ncrcmd *dst, int len);

drivers/scsi/ncr53c8xx.c

3484

ncr_script_copy_and_bind (struct ncb *np, ncrcmd *src, ncrcmd *dst, int len)

drivers/scsi/ncr53c8xx.c

3497

*dst++ = cpu_to_scr(opcode);

drivers/scsi/ncr53c8xx.c

3546

dst[-1] = cpu_to_scr(opcode & ~SCR_NO_FLUSH);

drivers/scsi/ncr53c8xx.c

3621

*dst++ = cpu_to_scr(new);

drivers/scsi/ncr53c8xx.c

3624

*dst++ = cpu_to_scr(*src++);

drivers/scsi/qedi/qedi_iscsi.c

1003

memcpy(&path_req.dst.v6_addr, &qedi_ep->dst_addr,

drivers/scsi/qedi/qedi_iscsi.c

516

ether_addr_copy(conn_info->dst.mac, qedi_ep->dst_mac);

drivers/scsi/qedi/qedi_iscsi.c

519

conn_info->dst.ip[0] = ntohl(qedi_ep->dst_addr[0]);

drivers/scsi/qedi/qedi_iscsi.c

529

conn_info->dst.ip[i] = ntohl(qedi_ep->dst_addr[i]);

drivers/scsi/qedi/qedi_iscsi.c

539

conn_info->dst.port = qedi_ep->dst_port;

drivers/scsi/qedi/qedi_iscsi.c

999

memcpy(&path_req.dst.v4_addr, &qedi_ep->dst_addr,

drivers/scsi/qla2xxx/qla_inline.h

82

host_to_adap(uint8_t *src, uint8_t *dst, uint32_t bsize)

drivers/scsi/qla2xxx/qla_inline.h

85

__le32 *odest = (__le32 *) dst;

drivers/scsi/qla2xxx/qla_target.c

4596

static void memcpy_atio(struct atio_from_isp *dst,

drivers/scsi/qla2xxx/qla_target.c

4601

memcpy(dst, src, sizeof(*dst));

drivers/scsi/qla2xxx/qla_target.c

4609

dst->u.isp24.fcp_cmnd.add_cdb_len = 0;

drivers/scsi/qla2xxx/qla_target.c

4610

memcpy(&dst->u.isp24.fcp_cmnd.add_cdb[0],

drivers/scsi/stex.c

430

struct st_sgtable *dst;

drivers/scsi/stex.c

438

dst = (struct st_sgtable *)req->variable;

drivers/scsi/stex.c

441

dst->sg_count = cpu_to_le16((u16)nseg);

drivers/scsi/stex.c

442

dst->max_sg_count = cpu_to_le16(hba->host->sg_tablesize);

drivers/scsi/stex.c

443

dst->sz_in_byte = cpu_to_le32(scsi_bufflen(cmd));

drivers/scsi/stex.c

445

table = (struct st_sgitem *)(dst + 1);

drivers/scsi/stex.c

462

struct st_sgtable *dst;

drivers/scsi/stex.c

470

dst = (struct st_sgtable *)req->variable;

drivers/scsi/stex.c

473

dst->sg_count = cpu_to_le16((u16)nseg);

drivers/scsi/stex.c

474

dst->max_sg_count = cpu_to_le16(hba->host->sg_tablesize);

drivers/scsi/stex.c

475

dst->sz_in_byte = cpu_to_le32(scsi_bufflen(cmd));

drivers/scsi/stex.c

477

table = (struct st_ss_sgitem *)(dst + 1);

drivers/soc/apple/rtkit.c

351

static void apple_rtkit_memcpy(struct apple_rtkit *rtk, void *dst,

drivers/soc/apple/rtkit.c

356

memcpy_fromio(dst, bfr->iomem + offset, len);

drivers/soc/apple/rtkit.c

358

memcpy(dst, bfr->buffer + offset, len);

drivers/soc/bcm/brcmstb/pm/pm-mips.c

69

void *dst;

drivers/soc/qcom/wcnss_ctrl.c

285

chinfo.dst = RPMSG_ADDR_ANY;

drivers/spi/spi-aspeed-smc.c

177

static int aspeed_spi_write_to_ahb(void __iomem *dst, const void *buf, size_t len)

drivers/spi/spi-aspeed-smc.c

181

if (IS_ALIGNED((uintptr_t)dst, sizeof(uintptr_t)) &&

drivers/spi/spi-aspeed-smc.c

183

iowrite32_rep(dst, buf, len >> 2);

drivers/spi/spi-aspeed-smc.c

187

iowrite8_rep(dst, (const u8 *)buf + offset, len);

drivers/spi/spi-aspeed-smc.c

894

void *dst, u32 len)

drivers/spi/spi-aspeed-smc.c

909

writeb(tx_buf[i], dst);

drivers/spi/spi-fsl-cpm.c

120

__le16 *dst;

drivers/spi/spi-fsl-cpm.c

123

dst = kmalloc(t->len, GFP_KERNEL);

drivers/spi/spi-fsl-cpm.c

124

if (!dst)

drivers/spi/spi-fsl-cpm.c

128

dst[i] = cpu_to_le16p(src + i);

drivers/spi/spi-fsl-cpm.c

130

mspi->tx = dst;

drivers/spi/spi-npcm-fiu.c

320

void __iomem *dst = (void __iomem *)(chip->flash_region_mapped_ptr +

drivers/spi/spi-npcm-fiu.c

327

iowrite8(*(buf_tx + i), dst + i);

drivers/spi/spi-npcm-fiu.c

329

memcpy_toio(dst, buf_tx, len);

drivers/spi/spi-sh-msiof.c

772

static void copy_bswap32(u32 *dst, const u32 *src, unsigned int words)

drivers/spi/spi-sh-msiof.c

777

*dst++ = swab32(get_unaligned(src));

drivers/spi/spi-sh-msiof.c

780

} else if ((unsigned long)dst & 3) {

drivers/spi/spi-sh-msiof.c

782

put_unaligned(swab32(*src++), dst);

drivers/spi/spi-sh-msiof.c

783

dst++;

drivers/spi/spi-sh-msiof.c

787

*dst++ = swab32(*src++);

drivers/spi/spi-sh-msiof.c

791

static void copy_wswap32(u32 *dst, const u32 *src, unsigned int words)

drivers/spi/spi-sh-msiof.c

796

*dst++ = swahw32(get_unaligned(src));

drivers/spi/spi-sh-msiof.c

799

} else if ((unsigned long)dst & 3) {

drivers/spi/spi-sh-msiof.c

801

put_unaligned(swahw32(*src++), dst);

drivers/spi/spi-sh-msiof.c

802

dst++;

drivers/spi/spi-sh-msiof.c

806

*dst++ = swahw32(*src++);

drivers/spi/spi-sh-msiof.c

810

static void copy_plain32(u32 *dst, const u32 *src, unsigned int words)

drivers/spi/spi-sh-msiof.c

812

memcpy(dst, src, words * 4);

drivers/staging/fbtft/fbtft-core.c

439

static void fbtft_merge_fbtftops(struct fbtft_ops *dst, struct fbtft_ops *src)

drivers/staging/fbtft/fbtft-core.c

442

dst->write = src->write;

drivers/staging/fbtft/fbtft-core.c

444

dst->read = src->read;

drivers/staging/fbtft/fbtft-core.c

446

dst->write_vmem = src->write_vmem;

drivers/staging/fbtft/fbtft-core.c

448

dst->write_register = src->write_register;

drivers/staging/fbtft/fbtft-core.c

450

dst->set_addr_win = src->set_addr_win;

drivers/staging/fbtft/fbtft-core.c

452

dst->reset = src->reset;

drivers/staging/fbtft/fbtft-core.c

454

dst->mkdirty = src->mkdirty;

drivers/staging/fbtft/fbtft-core.c

456

dst->update_display = src->update_display;

drivers/staging/fbtft/fbtft-core.c

458

dst->init_display = src->init_display;

drivers/staging/fbtft/fbtft-core.c

460

dst->blank = src->blank;

drivers/staging/fbtft/fbtft-core.c

462

dst->request_gpios_match = src->request_gpios_match;

drivers/staging/fbtft/fbtft-core.c

464

dst->request_gpios = src->request_gpios;

drivers/staging/fbtft/fbtft-core.c

466

dst->verify_gpios = src->verify_gpios;

drivers/staging/fbtft/fbtft-core.c

468

dst->register_backlight = src->register_backlight;

drivers/staging/fbtft/fbtft-core.c

470

dst->unregister_backlight = src->unregister_backlight;

drivers/staging/fbtft/fbtft-core.c

472

dst->set_var = src->set_var;

drivers/staging/fbtft/fbtft-core.c

474

dst->set_gamma = src->set_gamma;

drivers/staging/fbtft/fbtft-io.c

43

u8 *dst = par->extra;

drivers/staging/fbtft/fbtft-io.c

75

*(__be64 *)dst = cpu_to_be64(tmp);

drivers/staging/fbtft/fbtft-io.c

76

dst += 8;

drivers/staging/fbtft/fbtft-io.c

77

*dst++ = (u8)(*src++ & 0x00FF);

drivers/staging/media/atomisp/pci/hmm/hmm.c

296

void *dst = bo->vmap_addr;

drivers/staging/media/atomisp/pci/hmm/hmm.c

298

dst += (virt - bo->start);

drivers/staging/media/atomisp/pci/hmm/hmm.c

299

memcpy(dst, data, bytes);

drivers/staging/media/atomisp/pci/hmm/hmm.c

301

clflush_cache_range(dst, bytes);

drivers/staging/media/atomisp/pci/hmm/hmm.c

368

void *dst = bo->vmap_addr;

drivers/staging/media/atomisp/pci/hmm/hmm.c

370

dst += (virt - bo->start);

drivers/staging/media/atomisp/pci/hmm/hmm.c

371

memset(dst, c, bytes);

drivers/staging/media/atomisp/pci/hmm/hmm.c

374

clflush_cache_range(dst, bytes);

drivers/staging/media/sunxi/cedrus/cedrus.h

86

struct vb2_v4l2_buffer *dst;

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

34

run.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

93

v4l2_m2m_buf_copy_metadata(run.src, run.dst);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

120

if (run->dst->vb2_buf.timestamp == dpb->reference_ts) {

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

139

output_buf = vb2_to_cedrus_buffer(&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

445

cedrus_buf = vb2_to_cedrus_buffer(&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

775

&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

133

dst_luma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

134

dst_chroma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 1);

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

806

luma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

807

chroma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 1);

drivers/staging/rtl8723bs/core/rtw_mlme.c

356

int is_same_network(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst, u8 feature)

drivers/staging/rtl8723bs/core/rtw_mlme.c

361

if (rtw_bug_check(dst, src, &s_cap, &d_cap) == false)

drivers/staging/rtl8723bs/core/rtw_mlme.c

365

memcpy((u8 *)&tmpd, rtw_get_capability_from_ie(dst->ies), 2);

drivers/staging/rtl8723bs/core/rtw_mlme.c

370

return (src->ssid.ssid_length == dst->ssid.ssid_length) &&

drivers/staging/rtl8723bs/core/rtw_mlme.c

371

((!memcmp(src->mac_address, dst->mac_address, ETH_ALEN))) &&

drivers/staging/rtl8723bs/core/rtw_mlme.c

372

((!memcmp(src->ssid.ssid, dst->ssid.ssid, src->ssid.ssid_length))) &&

drivers/staging/rtl8723bs/core/rtw_mlme.c

418

void update_network(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src,

drivers/staging/rtl8723bs/core/rtw_mlme.c

421

long rssi_ori = dst->rssi;

drivers/staging/rtl8723bs/core/rtw_mlme.c

436

rssi_final = (src->rssi + dst->rssi * 4) / 5;

drivers/staging/rtl8723bs/core/rtw_mlme.c

441

ss_final = ((u32)(src->phy_info.signal_strength) + (u32)(dst->phy_info.signal_strength) * 4) / 5;

drivers/staging/rtl8723bs/core/rtw_mlme.c

442

sq_final = ((u32)(src->phy_info.signal_quality) + (u32)(dst->phy_info.signal_quality) * 4) / 5;

drivers/staging/rtl8723bs/core/rtw_mlme.c

443

rssi_final = (src->rssi + dst->rssi * 4) / 5;

drivers/staging/rtl8723bs/core/rtw_mlme.c

446

ss_final = dst->phy_info.signal_strength;

drivers/staging/rtl8723bs/core/rtw_mlme.c

447

sq_final = dst->phy_info.signal_quality;

drivers/staging/rtl8723bs/core/rtw_mlme.c

448

rssi_final = dst->rssi;

drivers/staging/rtl8723bs/core/rtw_mlme.c

453

dst->reserved[0] = src->reserved[0];

drivers/staging/rtl8723bs/core/rtw_mlme.c

454

dst->reserved[1] = src->reserved[1];

drivers/staging/rtl8723bs/core/rtw_mlme.c

455

memcpy((u8 *)dst, (u8 *)src, get_wlan_bssid_ex_sz(src));

drivers/staging/rtl8723bs/core/rtw_mlme.c

458

dst->phy_info.signal_strength = ss_final;

drivers/staging/rtl8723bs/core/rtw_mlme.c

459

dst->phy_info.signal_quality = sq_final;

drivers/staging/rtl8723bs/core/rtw_mlme.c

460

dst->rssi = rssi_final;

drivers/staging/rtl8723bs/core/rtw_recv.c

1306

memcpy(pattrib->dst, pda, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

1614

memcpy(ptr, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

1652

memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

1659

memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

1675

int bmcast = is_multicast_ether_addr(pattrib->dst);

drivers/staging/rtl8723bs/core/rtw_recv.c

1677

if (memcmp(pattrib->dst, myid(&padapter->eeprompriv), ETH_ALEN)) {

drivers/staging/rtl8723bs/core/rtw_recv.c

1682

psta = rtw_get_stainfo(pstapriv, pattrib->dst);

drivers/staging/rtl8723bs/core/rtw_recv.c

685

if ((!is_broadcast_ether_addr(pattrib->dst)) && (!is_multicast_ether_addr(pattrib->dst)))

drivers/staging/rtl8723bs/core/rtw_recv.c

714

signed int bmcast = is_multicast_ether_addr(pattrib->dst);

drivers/staging/rtl8723bs/core/rtw_recv.c

725

if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) {

drivers/staging/rtl8723bs/core/rtw_recv.c

756

if (memcmp(pattrib->bssid, pattrib->dst, ETH_ALEN)) {

drivers/staging/rtl8723bs/core/rtw_recv.c

765

memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

768

memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

801

signed int bmcast = is_multicast_ether_addr(pattrib->dst);

drivers/staging/rtl8723bs/core/rtw_recv.c

815

if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast)) {

drivers/staging/rtl8723bs/core/rtw_recv.c

852

memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

855

memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_recv.c

874

if (!memcmp(myhwaddr, pattrib->dst, ETH_ALEN) && (!bmcast)) {

drivers/staging/rtl8723bs/core/rtw_security.c

181

void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst)

drivers/staging/rtl8723bs/core/rtw_security.c

193

put_unaligned_le32(pmicdata->L, dst);

drivers/staging/rtl8723bs/core/rtw_security.c

194

put_unaligned_le32(pmicdata->R, dst + 4);

drivers/staging/rtl8723bs/core/rtw_xmit.c

650

memcpy(pattrib->dst, &etherhdr.h_dest, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_xmit.c

655

memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_xmit.c

661

memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_xmit.c

911

memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_xmit.c

919

memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/core/rtw_xmit.c

927

memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);

drivers/staging/rtl8723bs/include/rtw_mlme.h

381

int is_same_network(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst, u8 feature);

drivers/staging/rtl8723bs/include/rtw_mlme_ext.h

478

void update_network(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src, struct adapter *padapter, bool update_ie);

drivers/staging/rtl8723bs/include/rtw_recv.h

118

u8 dst[ETH_ALEN];

drivers/staging/rtl8723bs/include/rtw_security.h

250

void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst);

drivers/staging/rtl8723bs/include/rtw_xmit.h

153

u8 dst[ETH_ALEN];

drivers/target/iscsi/cxgbit/cxgbit.h

194

struct dst_entry *dst;

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1228

struct dst_entry *dst;

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1267

dst = cxgb_find_route(&cdev->lldi, cxgbit_get_real_dev,

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1278

dst = cxgb_find_route6(&cdev->lldi, cxgbit_get_real_dev,

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1285

if (!dst) {

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1293

dst_release(dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1298

dst, cdev);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1302

dst_release(dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1321

csk->dst = dst;

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1367

dst_release(dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1652

dst_confirm(csk->dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

1886

dst_confirm(csk->dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

812

dst_release(csk->dst);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

900

u16 local_port, struct dst_entry *dst,

drivers/target/iscsi/cxgbit/cxgbit_cm.c

911

n = dst_neigh_lookup(dst, peer_ip);

drivers/target/iscsi/cxgbit/cxgbit_cm.c

973

csk->mtu = dst_mtu(dst);

drivers/target/iscsi/iscsi_target_auth.c

212

static int chap_base64_decode(u8 *dst, const char *src, size_t len)

drivers/target/iscsi/iscsi_target_auth.c

216

u8 *cp = dst;

drivers/target/iscsi/iscsi_target_auth.c

220

return cp - dst;

drivers/target/iscsi/iscsi_target_auth.c

238

return cp - dst;

drivers/tee/optee/smc_abi.c

400

static void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages,

drivers/tee/optee/smc_abi.c

424

pages_data = (void *)dst;

drivers/tee/tee_heap.c

69

static int copy_sg_table(struct sg_table *dst, struct sg_table *src)

drivers/tee/tee_heap.c

76

ret = sg_alloc_table(dst, src->orig_nents, GFP_KERNEL);

drivers/tee/tee_heap.c

80

dst_sg = dst->sgl;

drivers/thunderbolt/path.c

102

struct tb_port *dst, int dst_hopid,

drivers/thunderbolt/path.c

114

if (src_hopid < 0 && dst) {

drivers/thunderbolt/path.c

122

src_hopid = tb_path_find_src_hopid(src, dst, dst_hopid);

drivers/thunderbolt/path.c

239

struct tb_port *dst, int dst_hopid, int link_nr,

drivers/thunderbolt/path.c

254

tb_for_each_port_on_path(src, dst, in_port) {

drivers/thunderbolt/path.c

262

if (first_port != src || last_port != dst) {

drivers/thunderbolt/path.c

282

in_port = tb_next_port_on_path(src, dst, out_port);

drivers/thunderbolt/path.c

296

out_port = tb_next_port_on_path(src, dst, in_port);

drivers/thunderbolt/path.c

66

const struct tb_port *dst, int dst_hopid)

drivers/thunderbolt/path.c

73

if (out == dst)

drivers/thunderbolt/property.c

42

static inline void parse_dwdata(void *dst, const void *src, size_t dwords)

drivers/thunderbolt/property.c

44

be32_to_cpu_array(dst, src, dwords);

drivers/thunderbolt/property.c

47

static inline void format_dwdata(void *dst, const void *src, size_t dwords)

drivers/thunderbolt/property.c

49

cpu_to_be32_array(dst, src, dwords);

drivers/thunderbolt/tb.h

1121

const struct tb_port *dst)

drivers/thunderbolt/tb.h

1123

return src->sw->config.depth < dst->sw->config.depth;

drivers/thunderbolt/tb.h

1139

#define tb_for_each_port_on_path(src, dst, p) \

drivers/thunderbolt/tb.h

1140

for ((p) = tb_next_port_on_path((src), (dst), NULL); (p); \

drivers/thunderbolt/tb.h

1141

(p) = tb_next_port_on_path((src), (dst), (p)))

drivers/thunderbolt/tb.h

1151

#define tb_for_each_upstream_port_on_path(src, dst, p) \

drivers/thunderbolt/tb.h

1152

for ((p) = tb_next_port_on_path((src), (dst), NULL); (p); \

drivers/thunderbolt/tb.h

1153

(p) = tb_next_port_on_path((src), (dst), (p))) \

drivers/thunderbolt/tb.h

1190

struct tb_port *dst, int dst_hopid,

drivers/thunderbolt/tb.h

1194

struct tb_port *dst, int dst_hopid, int link_nr,

drivers/thunderbolt/test.c

2825

struct tb_property_dir *src, *dst;

drivers/thunderbolt/test.c

2832

dst = tb_property_copy_dir(src);

drivers/thunderbolt/test.c

2833

KUNIT_ASSERT_NOT_NULL(test, dst);

drivers/thunderbolt/test.c

2836

compare_dirs(test, src, dst);

drivers/thunderbolt/test.c

2839

ret = tb_property_format_dir(dst, NULL, 0);

drivers/thunderbolt/test.c

2845

ret = tb_property_format_dir(dst, block, ARRAY_SIZE(root_directory));

drivers/thunderbolt/test.c

2851

tb_property_free_dir(dst);

drivers/thunderbolt/tunnel.c

1875

struct tb_port *dst, int transmit_path,

drivers/thunderbolt/tunnel.c

1901

tunnel->dst_port = dst;

drivers/thunderbolt/tunnel.c

1907

path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0,

drivers/thunderbolt/tunnel.c

1919

path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0,

drivers/thunderbolt/tunnel.h

126

struct tb_port *dst, int transmit_path,

drivers/tty/moxa.c

1973

u8 *dst;

drivers/tty/moxa.c

1997

len = tty_prepare_flip_string(&port->port, &dst,

drivers/tty/moxa.c

1999

memcpy_fromio(dst, ofs, len);

drivers/tty/moxa.c

2009

len = tty_prepare_flip_string(&port->port, &dst,

drivers/tty/moxa.c

2011

memcpy_fromio(dst, ofs, len);

drivers/tty/rpmsg_tty.c

198

rpdev->src, rpdev->dst, cport->id);

drivers/tty/vt/vt.c

573

u16 *clear, *dst, *src;

drivers/tty/vt/vt.c

586

dst = (u16 *)(vc->vc_origin + vc->vc_size_row * (top + nr));

drivers/tty/vt/vt.c

590

swap(src, dst);

drivers/tty/vt/vt.c

592

scr_memmovew(dst, src, (rows - nr) * vc->vc_size_row);

drivers/usb/chipidea/udc.c

593

struct scatterlist *sg, *src, *dst;

drivers/usb/chipidea/udc.c

603

dst = hwreq->sgt.sgl;

drivers/usb/chipidea/udc.c

606

memcpy(dst, src, sizeof(*src));

drivers/usb/chipidea/udc.c

609

dst = sg_next(dst);

drivers/usb/chipidea/udc.c

620

sg_set_buf(dst, buf, rounded);

drivers/usb/chipidea/udc.c

639

struct scatterlist *sg, *src, *dst;

drivers/usb/chipidea/udc.c

647

dst = hwreq->sgt.sgl;

drivers/usb/chipidea/udc.c

649

dst = sg_next(dst);

drivers/usb/chipidea/udc.c

652

sg_copy_from_buffer(dst, nents, buf, sg_dma_len(src));

drivers/usb/gadget/function/f_uvc.c

482

#define UVC_COPY_DESCRIPTOR(mem, dst, desc) \

drivers/usb/gadget/function/f_uvc.c

485

*(dst)++ = mem; \

drivers/usb/gadget/function/f_uvc.c

489

#define UVC_COPY_DESCRIPTORS(mem, dst, src) \

drivers/usb/gadget/function/f_uvc.c

494

*dst++ = mem; \

drivers/usb/gadget/function/f_uvc.c

499

#define UVC_COPY_XU_DESCRIPTOR(mem, dst, desc) \

drivers/usb/gadget/function/f_uvc.c

501

*(dst)++ = mem; \

drivers/usb/gadget/function/f_uvc.c

527

struct usb_descriptor_header **dst;

drivers/usb/gadget/function/f_uvc.c

622

dst = mem;

drivers/usb/gadget/function/f_uvc.c

626

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_iad);

drivers/usb/gadget/function/f_uvc.c

627

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_control_intf);

drivers/usb/gadget/function/f_uvc.c

630

UVC_COPY_DESCRIPTORS(mem, dst,

drivers/usb/gadget/function/f_uvc.c

634

UVC_COPY_XU_DESCRIPTOR(mem, dst, &xu->desc);

drivers/usb/gadget/function/f_uvc.c

641

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_interrupt_ep);

drivers/usb/gadget/function/f_uvc.c

644

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_ss_interrupt_comp);

drivers/usb/gadget/function/f_uvc.c

646

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_interrupt_cs_ep);

drivers/usb/gadget/function/f_uvc.c

649

UVC_COPY_DESCRIPTOR(mem, dst, &uvc_streaming_intf_alt0);

drivers/usb/gadget/function/f_uvc.c

652

UVC_COPY_DESCRIPTORS(mem, dst,

drivers/usb/gadget/function/f_uvc.c

657

UVC_COPY_DESCRIPTORS(mem, dst, uvc_streaming_std);

drivers/usb/gadget/function/f_uvc.c

659

*dst = NULL;

drivers/usb/gadget/udc/renesas_usbf.c

471

void *dst, uint count)

drivers/usb/gadget/udc/renesas_usbf.c

473

readsl(ep->regs + offset, dst, count);

drivers/usb/gadget/udc/udc-xilinx.c

317

dma_addr_t dst, u32 length)

drivers/usb/gadget/udc/udc-xilinx.c

330

udc->write_fn(udc->addr, XUSB_DMA_DDAR_ADDR_OFFSET, dst);

drivers/usb/gadget/udc/udc-xilinx.c

381

dma_addr_t dst;

drivers/usb/gadget/udc/udc-xilinx.c

391

dst = virt_to_phys(eprambase);

drivers/usb/gadget/udc/udc-xilinx.c

402

dst = virt_to_phys(eprambase);

drivers/usb/gadget/udc/udc-xilinx.c

415

return xudc_start_dma(ep, src, dst, length);

drivers/usb/gadget/udc/udc-xilinx.c

435

dma_addr_t dst;

drivers/usb/gadget/udc/udc-xilinx.c

438

dst = req->usb_req.dma + req->usb_req.actual;

drivers/usb/gadget/udc/udc-xilinx.c

464

return xudc_start_dma(ep, src, dst, length);

drivers/usb/host/max3421-hcd.c

838

void *dst = urb->transfer_buffer + urb->actual_length;

drivers/usb/host/max3421-hcd.c

840

spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);

drivers/usb/host/xhci-mem.c

136

static void xhci_link_rings(struct xhci_hcd *xhci, struct xhci_ring *src, struct xhci_ring *dst)

drivers/usb/host/xhci-mem.c

141

if (!src || !dst)

drivers/usb/host/xhci-mem.c

145

if (dst->cycle_state == 0) {

drivers/usb/host/xhci-mem.c

152

src->last_seg->next = dst->enq_seg->next;

drivers/usb/host/xhci-mem.c

153

dst->enq_seg->next = src->first_seg;

drivers/usb/host/xhci-mem.c

154

if (dst->type != TYPE_EVENT) {

drivers/usb/host/xhci-mem.c

155

chain_links = xhci_link_chain_quirk(xhci, dst->type);

drivers/usb/host/xhci-mem.c

156

xhci_set_link_trb(dst->enq_seg, chain_links);

drivers/usb/host/xhci-mem.c

159

dst->num_segs += src->num_segs;

drivers/usb/host/xhci-mem.c

161

if (dst->enq_seg == dst->last_seg) {

drivers/usb/host/xhci-mem.c

162

if (dst->type != TYPE_EVENT)

drivers/usb/host/xhci-mem.c

163

dst->last_seg->trbs[TRBS_PER_SEGMENT-1].link.control

drivers/usb/host/xhci-mem.c

166

dst->last_seg = src->last_seg;

drivers/usb/host/xhci-mem.c

167

} else if (dst->type != TYPE_EVENT) {

drivers/usb/host/xhci-mem.c

171

for (seg = dst->enq_seg; seg != dst->last_seg; seg = seg->next)

drivers/usb/isp1760/isp1760-hcd.c

320

__u32 *dst, u32 bytes)

drivers/usb/isp1760/isp1760-hcd.c

331

*dst = readl_relaxed(src);

drivers/usb/isp1760/isp1760-hcd.c

334

dst++;

drivers/usb/isp1760/isp1760-hcd.c

338

*dst = __raw_readl(src);

drivers/usb/isp1760/isp1760-hcd.c

341

dst++;

drivers/usb/isp1760/isp1760-hcd.c

356

dst_byteptr = (void *) dst;

drivers/usb/isp1760/isp1760-hcd.c

366

static void isp1760_mem_read(struct usb_hcd *hcd, u32 src_offset, void *dst,

drivers/usb/isp1760/isp1760-hcd.c

374

bank_reads8(priv->base, src_offset, ISP_BANK_0, dst, bytes);

drivers/usb/isp1760/isp1760-hcd.c

405

static void mem_read(struct usb_hcd *hcd, u32 src_offset, __u32 *dst,

drivers/usb/isp1760/isp1760-hcd.c

411

return isp1760_mem_read(hcd, src_offset, (u16 *)dst, bytes);

drivers/usb/isp1760/isp1760-hcd.c

413

isp1763_mem_read(hcd, (u16)src_offset, (u16 *)dst, bytes);

drivers/usb/isp1760/isp1760-hcd.c

419

__u32 __iomem *dst;

drivers/usb/isp1760/isp1760-hcd.c

421

dst = dst_base + dst_offset;

drivers/usb/isp1760/isp1760-hcd.c

425

writel_relaxed(*src, dst);

drivers/usb/isp1760/isp1760-hcd.c

428

dst++;

drivers/usb/isp1760/isp1760-hcd.c

432

__raw_writel(*src, dst);

drivers/usb/isp1760/isp1760-hcd.c

435

dst++;

drivers/usb/isp1760/isp1760-hcd.c

446

writel_relaxed(*src, dst);

drivers/usb/isp1760/isp1760-hcd.c

448

__raw_writel(*src, dst);

drivers/usb/mtu3/mtu3_gadget_ep0.c

100

static void ep0_read_fifo(struct mtu3_ep *mep, u8 *dst, u16 len)

drivers/usb/mtu3/mtu3_gadget_ep0.c

107

__func__, mep->epnum, len, dst);

drivers/usb/mtu3/mtu3_gadget_ep0.c

110

ioread32_rep(fifo, dst, len >> 2);

drivers/usb/mtu3/mtu3_gadget_ep0.c

115

memcpy(&dst[index], &value, len & 0x3);

drivers/usb/musb/musb_core.c

359

static void musb_default_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)

drivers/usb/musb/musb_core.c

368

'R', hw_ep->epnum, fifo, len, dst);

drivers/usb/musb/musb_core.c

371

if (likely((0x01 & (unsigned long) dst) == 0)) {

drivers/usb/musb/musb_core.c

375

if ((0x02 & (unsigned long) dst) == 0) {

drivers/usb/musb/musb_core.c

377

ioread32_rep(fifo, dst, len >> 2);

drivers/usb/musb/musb_core.c

381

*(u16 *)&dst[index] = __raw_readw(fifo);

drivers/usb/musb/musb_core.c

386

ioread16_rep(fifo, dst, len >> 1);

drivers/usb/musb/musb_core.c

391

dst[index] = __raw_readb(fifo);

drivers/usb/musb/musb_core.c

394

ioread8_rep(fifo, dst, len);

drivers/usb/musb/musb_core.c

447

void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)

drivers/usb/musb/musb_core.c

449

return hw_ep->musb->io.read_fifo(hw_ep, len, dst);

drivers/usb/musb/musb_core.h

497

extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);

drivers/usb/musb/musb_dsps.c

622

static void dsps_read_fifo32(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)

drivers/usb/musb/musb_dsps.c

627

ioread32_rep(fifo, dst, len >> 2);

drivers/usb/musb/musb_dsps.c

628

dst += len & ~0x03;

drivers/usb/musb/musb_dsps.c

635

memcpy(dst, &val, len);

drivers/usb/serial/ftdi_sio.c

1949

static int ftdi_read_eeprom(struct usb_serial *serial, void *dst, u16 addr,

drivers/usb/serial/ftdi_sio.c

1967

0, (addr + read) / 2, dst + read, 2,

drivers/usb/serial/garmin_gps.c

589

unsigned char *dst;

drivers/usb/serial/garmin_gps.c

658

dst = garmin_data_p->outbuffer+GPS_OUT_BUFSIZ-datalen;

drivers/usb/serial/garmin_gps.c

659

memcpy(dst, src, datalen);

drivers/usb/serial/garmin_gps.c

660

src = dst;

drivers/usb/serial/garmin_gps.c

663

dst = garmin_data_p->outbuffer;

drivers/usb/serial/garmin_gps.c

665

*dst++ = DLE;

drivers/usb/serial/garmin_gps.c

666

*dst++ = pktid;

drivers/usb/serial/garmin_gps.c

668

*dst++ = datalen;

drivers/usb/serial/garmin_gps.c

671

*dst++ = DLE;

drivers/usb/serial/garmin_gps.c

675

*dst++ = c;

drivers/usb/serial/garmin_gps.c

678

*dst++ = DLE;

drivers/usb/serial/garmin_gps.c

682

*dst++ = cksum;

drivers/usb/serial/garmin_gps.c

684

*dst++ = DLE;

drivers/usb/serial/garmin_gps.c

685

*dst++ = DLE;

drivers/usb/serial/garmin_gps.c

686

*dst++ = ETX;

drivers/usb/serial/garmin_gps.c

688

i = dst-garmin_data_p->outbuffer;

drivers/vdpa/ifcvf/ifcvf_base.c

289

void *dst, int length)

drivers/vdpa/ifcvf/ifcvf_base.c

297

p = dst;

drivers/vdpa/ifcvf/ifcvf_base.h

110

void *dst, int length);

drivers/vdpa/mlx5/core/mr.c

599

static int dup_iotlb(struct vhost_iotlb *dst, struct vhost_iotlb *src)

drivers/vdpa/mlx5/core/mr.c

605

if (dst == src)

drivers/vdpa/mlx5/core/mr.c

609

err = vhost_iotlb_add_range(dst, start, last, start, VHOST_ACCESS_RW);

drivers/vdpa/mlx5/core/mr.c

615

err = vhost_iotlb_add_range(dst, map->start, map->last,

drivers/vdpa/octeon_ep/octep_vdpa.h

99

void octep_read_dev_config(struct octep_hw *oct_hw, u64 offset, void *dst, int length);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

281

void octep_read_dev_config(struct octep_hw *oct_hw, u64 offset, void *dst, int length)

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

291

p = dst;

drivers/vfio/pci/vfio_pci_igd.c

47

static inline unsigned long igd_opregion_shift_copy(char __user *dst,

drivers/vfio/pci/vfio_pci_igd.c

54

if (copy_to_user(dst + (*off), src, bytes))

drivers/vhost/vringh.c

1101

static inline int copy_from_iotlb(const struct vringh *vrh, void *dst,

drivers/vhost/vringh.c

1136

size = copy_from_iter(dst, translated, &iter);

drivers/vhost/vringh.c

1141

dst += translated;

drivers/vhost/vringh.c

1148

static inline int copy_to_iotlb(const struct vringh *vrh, void *dst,

drivers/vhost/vringh.c

1167

ret = iotlb_translate(vrh, (u64)(uintptr_t)dst,

drivers/vhost/vringh.c

1188

dst += translated;

drivers/vhost/vringh.c

1268

void *dst, const void *src, size_t len)

drivers/vhost/vringh.c

1272

ret = copy_from_iotlb(vrh, dst, (void *)src, len);

drivers/vhost/vringh.c

1280

void *dst, size_t len)

drivers/vhost/vringh.c

1284

ret = copy_from_iotlb(vrh, dst, src, len);

drivers/vhost/vringh.c

1292

void *dst, void *src, size_t len)

drivers/vhost/vringh.c

1296

ret = copy_to_iotlb(vrh, dst, src, len);

drivers/vhost/vringh.c

1304

struct vring_used_elem *dst,

drivers/vhost/vringh.c

1308

int size = num * sizeof(*dst);

drivers/vhost/vringh.c

1311

ret = copy_to_iotlb(vrh, dst, (void *)src, num * sizeof(*dst));

drivers/vhost/vringh.c

1441

void *dst, size_t len)

drivers/vhost/vringh.c

1443

return vringh_iov_xfer(vrh, riov, dst, len, xfer_from_iotlb);

drivers/vhost/vringh.c

255

static int slow_copy(struct vringh *vrh, void *dst, const void *src,

drivers/vhost/vringh.c

266

void *dst, const void *src, size_t len))

drivers/vhost/vringh.c

280

err = copy(vrh, dst, src, part);

drivers/vhost/vringh.c

284

dst += part;

drivers/vhost/vringh.c

302

void *dst, const void *src, size_t len))

drivers/vhost/vringh.c

452

struct vring_used_elem *dst,

drivers/vhost/vringh.c

613

void *dst, const void *src, size_t len)

drivers/vhost/vringh.c

615

return copy_from_user(dst, (__force void __user *)src, len) ?

drivers/vhost/vringh.c

620

struct vring_used_elem *dst,

drivers/vhost/vringh.c

624

return copy_to_user((__force void __user *)dst, src,

drivers/vhost/vringh.c

625

sizeof(*dst) * num) ? -EFAULT : 0;

drivers/vhost/vringh.c

629

void *dst, size_t len)

drivers/vhost/vringh.c

631

return copy_from_user(dst, (__force void __user *)src, len) ?

drivers/vhost/vringh.c

636

void *dst, void *src, size_t len)

drivers/vhost/vringh.c

638

return copy_to_user((__force void __user *)dst, src, len) ?

drivers/vhost/vringh.c

759

ssize_t vringh_iov_pull_user(struct vringh_iov *riov, void *dst, size_t len)

drivers/vhost/vringh.c

762

dst, len, xfer_from_user);

drivers/vhost/vringh.c

872

void *dst, const void *src, size_t len)

drivers/vhost/vringh.c

874

memcpy(dst, src, len);

drivers/vhost/vringh.c

879

struct vring_used_elem *dst,

drivers/vhost/vringh.c

883

memcpy(dst, src, num * sizeof(*dst));

drivers/video/fbdev/amifb.c

2591

static void bitcpy(unsigned long *dst, int dst_idx, const unsigned long *src,

drivers/video/fbdev/amifb.c

2613

*dst = comp(*src, *dst, first);

drivers/video/fbdev/amifb.c

2618

*dst = comp(*src, *dst, first);

drivers/video/fbdev/amifb.c

2619

dst++;

drivers/video/fbdev/amifb.c

2627

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2628

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2629

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2630

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2631

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2632

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2633

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2634

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2638

*dst++ = *src++;

drivers/video/fbdev/amifb.c

2642

*dst = comp(*src, *dst, last);

drivers/video/fbdev/amifb.c

2656

*dst = comp(*src >> right, *dst, first);

drivers/video/fbdev/amifb.c

2659

*dst = comp(*src << left, *dst, first);

drivers/video/fbdev/amifb.c

2664

*dst = comp(d0 << left | d1 >> right, *dst,

drivers/video/fbdev/amifb.c

2673

*dst = comp(d0 >> right, *dst, first);

drivers/video/fbdev/amifb.c

2674

dst++;

drivers/video/fbdev/amifb.c

2679

*dst = comp(d0 << left | d1 >> right, *dst,

drivers/video/fbdev/amifb.c

2682

dst++;

drivers/video/fbdev/amifb.c

2691

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2694

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2697

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2700

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2706

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2714

*dst = comp(d0 << left, *dst, last);

drivers/video/fbdev/amifb.c

2718

*dst = comp(d0 << left | d1 >> right,

drivers/video/fbdev/amifb.c

2719

*dst, last);

drivers/video/fbdev/amifb.c

2731

static void bitcpy_rev(unsigned long *dst, int dst_idx,

drivers/video/fbdev/amifb.c

2742

dst += (n - 1) / BITS_PER_LONG;

drivers/video/fbdev/amifb.c

2746

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

2764

*dst = comp(*src, *dst, first);

drivers/video/fbdev/amifb.c

2769

*dst = comp(*src, *dst, first);

drivers/video/fbdev/amifb.c

2770

dst--;

drivers/video/fbdev/amifb.c

2778

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2779

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2780

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2781

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2782

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2783

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2784

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2785

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2789

*dst-- = *src--;

drivers/video/fbdev/amifb.c

2793

*dst = comp(*src, *dst, last);

drivers/video/fbdev/amifb.c

2807

*dst = comp(*src << left, *dst, first);

drivers/video/fbdev/amifb.c

2810

*dst = comp(*src >> right, *dst, first);

drivers/video/fbdev/amifb.c

2815

*dst = comp(d0 >> right | d1 << left, *dst,

drivers/video/fbdev/amifb.c

2824

*dst = comp(d0 << left, *dst, first);

drivers/video/fbdev/amifb.c

2825

dst--;

drivers/video/fbdev/amifb.c

2830

*dst = comp(d0 >> right | d1 << left, *dst,

drivers/video/fbdev/amifb.c

2833

dst--;

drivers/video/fbdev/amifb.c

2842

*dst-- = d0 >> right | d1 << left;

drivers/video/fbdev/amifb.c

2845

*dst-- = d0 >> right | d1 << left;

drivers/video/fbdev/amifb.c

2848

*dst-- = d0 >> right | d1 << left;

drivers/video/fbdev/amifb.c

2851

*dst-- = d0 >> right | d1 << left;

drivers/video/fbdev/amifb.c

2857

*dst-- = d0 >> right | d1 << left;

drivers/video/fbdev/amifb.c

2865

*dst = comp(d0 >> right, *dst, last);

drivers/video/fbdev/amifb.c

2869

*dst = comp(d0 >> right | d1 << left,

drivers/video/fbdev/amifb.c

2870

*dst, last);

drivers/video/fbdev/amifb.c

2883

static void bitcpy_not(unsigned long *dst, int dst_idx,

drivers/video/fbdev/amifb.c

2905

*dst = comp(~*src, *dst, first);

drivers/video/fbdev/amifb.c

2910

*dst = comp(~*src, *dst, first);

drivers/video/fbdev/amifb.c

2911

dst++;

drivers/video/fbdev/amifb.c

2919

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2920

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2921

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2922

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2923

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2924

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2925

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2926

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2930

*dst++ = ~*src++;

drivers/video/fbdev/amifb.c

2934

*dst = comp(~*src, *dst, last);

drivers/video/fbdev/amifb.c

2948

*dst = comp(~*src >> right, *dst, first);

drivers/video/fbdev/amifb.c

2951

*dst = comp(~*src << left, *dst, first);

drivers/video/fbdev/amifb.c

2956

*dst = comp(d0 << left | d1 >> right, *dst,

drivers/video/fbdev/amifb.c

2965

*dst = comp(d0 >> right, *dst, first);

drivers/video/fbdev/amifb.c

2966

dst++;

drivers/video/fbdev/amifb.c

2971

*dst = comp(d0 << left | d1 >> right, *dst,

drivers/video/fbdev/amifb.c

2974

dst++;

drivers/video/fbdev/amifb.c

2983

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2986

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2989

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2992

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

2998

*dst++ = d0 << left | d1 >> right;

drivers/video/fbdev/amifb.c

3006

*dst = comp(d0 << left, *dst, last);

drivers/video/fbdev/amifb.c

3010

*dst = comp(d0 << left | d1 >> right,

drivers/video/fbdev/amifb.c

3011

*dst, last);

drivers/video/fbdev/amifb.c

3023

static void bitfill32(unsigned long *dst, int dst_idx, u32 pat, u32 n)

drivers/video/fbdev/amifb.c

3042

*dst = comp(val, *dst, first);

drivers/video/fbdev/amifb.c

3047

*dst = comp(val, *dst, first);

drivers/video/fbdev/amifb.c

3048

dst++;

drivers/video/fbdev/amifb.c

3055

*dst++ = val;

drivers/video/fbdev/amifb.c

3056

*dst++ = val;

drivers/video/fbdev/amifb.c

3057

*dst++ = val;

drivers/video/fbdev/amifb.c

3058

*dst++ = val;

drivers/video/fbdev/amifb.c

3059

*dst++ = val;

drivers/video/fbdev/amifb.c

3060

*dst++ = val;

drivers/video/fbdev/amifb.c

3061

*dst++ = val;

drivers/video/fbdev/amifb.c

3062

*dst++ = val;

drivers/video/fbdev/amifb.c

3066

*dst++ = val;

drivers/video/fbdev/amifb.c

3070

*dst = comp(val, *dst, last);

drivers/video/fbdev/amifb.c

3079

static void bitxor32(unsigned long *dst, int dst_idx, u32 pat, u32 n)

drivers/video/fbdev/amifb.c

3098

*dst = xor(val, *dst, first);

drivers/video/fbdev/amifb.c

3103

*dst = xor(val, *dst, first);

drivers/video/fbdev/amifb.c

3104

dst++;

drivers/video/fbdev/amifb.c

3111

*dst++ ^= val;

drivers/video/fbdev/amifb.c

3112

*dst++ ^= val;

drivers/video/fbdev/amifb.c

3113

*dst++ ^= val;

drivers/video/fbdev/amifb.c

3114

*dst++ ^= val;

drivers/video/fbdev/amifb.c

3118

*dst++ ^= val;

drivers/video/fbdev/amifb.c

3122

*dst = xor(val, *dst, last);

drivers/video/fbdev/amifb.c

3127

unsigned long *dst, int dst_idx, u32 n,

drivers/video/fbdev/amifb.c

3131

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

3133

bitfill32(dst, dst_idx, color & 1 ? ~0 : 0, n);

drivers/video/fbdev/amifb.c

3142

unsigned long *dst, int dst_idx, u32 n,

drivers/video/fbdev/amifb.c

3146

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

3148

bitxor32(dst, dst_idx, color & 1 ? ~0 : 0, n);

drivers/video/fbdev/amifb.c

3162

unsigned long *dst;

drivers/video/fbdev/amifb.c

3179

dst = (unsigned long *)

drivers/video/fbdev/amifb.c

3187

par->next_plane, dst, dst_idx, width,

drivers/video/fbdev/amifb.c

3193

dst, dst_idx, width, rect->color);

drivers/video/fbdev/amifb.c

3201

unsigned long *dst, int dst_idx,

drivers/video/fbdev/amifb.c

3205

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

3209

bitcpy(dst, dst_idx, src, src_idx, n);

drivers/video/fbdev/amifb.c

3218

unsigned long *dst, int dst_idx,

drivers/video/fbdev/amifb.c

3222

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

3226

bitcpy_rev(dst, dst_idx, src, src_idx, n);

drivers/video/fbdev/amifb.c

3241

unsigned long *dst, *src;

drivers/video/fbdev/amifb.c

3272

dst = (unsigned long *)

drivers/video/fbdev/amifb.c

3274

src = dst;

drivers/video/fbdev/amifb.c

3284

par->next_plane, dst, dst_idx, src,

drivers/video/fbdev/amifb.c

3290

par->next_plane, dst, dst_idx, src,

drivers/video/fbdev/amifb.c

3300

unsigned long *dst, int dst_idx, u32 n,

drivers/video/fbdev/amifb.c

3307

dst += dst_idx >> SHIFT_PER_LONG;

drivers/video/fbdev/amifb.c

3314

bitcpy(dst, dst_idx, src, src_idx, n);

drivers/video/fbdev/amifb.c

3316

bitcpy_not(dst, dst_idx, src, src_idx, n);

drivers/video/fbdev/amifb.c

3319

bitfill32(dst, dst_idx, fgcolor & 1 ? ~0 : 0, n);

drivers/video/fbdev/amifb.c

3333

unsigned long *dst;

drivers/video/fbdev/amifb.c

3353

dst = (unsigned long *)

drivers/video/fbdev/amifb.c

3361

par->next_plane, dst, dst_idx, width,

drivers/video/fbdev/arkfb.c

181

u32 __iomem *dst;

drivers/video/fbdev/arkfb.c

191

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/arkfb.c

195

fb_writel(val, dst++);

drivers/video/fbdev/arkfb.c

208

u32 __iomem *dst;

drivers/video/fbdev/arkfb.c

215

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/arkfb.c

217

fb_writel(fg, dst++);

drivers/video/fbdev/arkfb.c

239

u32 __iomem *dst;

drivers/video/fbdev/arkfb.c

249

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/arkfb.c

253

fb_writel(val, dst++);

drivers/video/fbdev/atafb_iplan2p2.c

110

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p2.c

124

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p2.c

144

dst += next_line;

drivers/video/fbdev/atafb_iplan2p2.c

152

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p2.c

166

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p2.c

186

dst -= next_line;

drivers/video/fbdev/atafb_iplan2p2.c

39

u8 *src, *dst;

drivers/video/fbdev/atafb_iplan2p2.c

51

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p2.c

53

memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p2.c

55

dst += BPL * 2;

drivers/video/fbdev/atafb_iplan2p2.c

61

d = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p2.c

72

memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p2.c

76

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p2.c

80

dst -= BPL * 2;

drivers/video/fbdev/atafb_iplan2p2.c

81

memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p2.c

87

d = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p2.c

98

memmove32_col(dst - (width - 16) / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p4.c

110

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p4.c

124

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p4.c

151

dst += next_line;

drivers/video/fbdev/atafb_iplan2p4.c

159

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p4.c

173

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p4.c

200

dst -= next_line;

drivers/video/fbdev/atafb_iplan2p4.c

39

u8 *src, *dst;

drivers/video/fbdev/atafb_iplan2p4.c

51

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p4.c

53

memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p4.c

55

dst += BPL * 2;

drivers/video/fbdev/atafb_iplan2p4.c

61

d = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p4.c

72

memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p4.c

76

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p4.c

80

dst -= BPL * 2;

drivers/video/fbdev/atafb_iplan2p4.c

81

memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p4.c

87

d = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p4.c

98

memmove32_col(dst - (width - 16) / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p8.c

105

memmove32_col(dst - (width - 16) / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p8.c

117

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p8.c

131

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p8.c

172

dst += next_line;

drivers/video/fbdev/atafb_iplan2p8.c

180

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p8.c

194

dst32 = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p8.c

235

dst -= next_line;

drivers/video/fbdev/atafb_iplan2p8.c

46

u8 *src, *dst;

drivers/video/fbdev/atafb_iplan2p8.c

58

dst = (u8 *)info->screen_base + dy * next_line + (dx & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p8.c

60

memmove32_col(dst, src, 0xff00ff, height, next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p8.c

62

dst += BPL * 2;

drivers/video/fbdev/atafb_iplan2p8.c

68

d = (u32 *)dst;

drivers/video/fbdev/atafb_iplan2p8.c

79

memmove32_col(dst + width / (8 / BPL), src + width / (8 / BPL),

drivers/video/fbdev/atafb_iplan2p8.c

83

dst = (u8 *)info->screen_base + (dy - 1) * next_line + ((dx + width + 8) & ~15) / (8 / BPL);

drivers/video/fbdev/atafb_iplan2p8.c

87

dst -= BPL * 2;

drivers/video/fbdev/atafb_iplan2p8.c

88

memmove32_col(dst, src, 0xff00ff00, colsize, -next_line - BPL * 2);

drivers/video/fbdev/atafb_iplan2p8.c

94

d = (u32 *)dst;

drivers/video/fbdev/atafb_utils.h

220

static inline void fast_memmove(char *dst, const char *src, size_t size)

drivers/video/fbdev/atafb_utils.h

224

if (dst < src)

drivers/video/fbdev/atafb_utils.h

232

: "=a" (src), "=a" (dst), "=d" (size)

drivers/video/fbdev/atafb_utils.h

233

: "0" (src), "1" (dst), "2" (size / 16 - 1)

drivers/video/fbdev/atafb_utils.h

243

: "=a" (src), "=a" (dst), "=d" (size)

drivers/video/fbdev/atafb_utils.h

244

: "0" (src + size), "1" (dst + size), "2" (size / 16 - 1)

drivers/video/fbdev/atafb_utils.h

280

static inline void fill8_col(u8 *dst, u32 m[])

drivers/video/fbdev/atafb_utils.h

283

dst[0] = tmp;

drivers/video/fbdev/atafb_utils.h

284

dst[2] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

286

dst[4] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

287

dst[6] = tmp >> 8;

drivers/video/fbdev/atafb_utils.h

291

dst[8] = tmp;

drivers/video/fbdev/atafb_utils.h

292

dst[10] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

293

dst[12] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

294

dst[14] = tmp >> 8;

drivers/video/fbdev/atafb_utils.h

301

static inline void fill8_2col(u8 *dst, u8 fg, u8 bg, u32 mask)

drivers/video/fbdev/atafb_utils.h

312

dst[0] = tmp;

drivers/video/fbdev/atafb_utils.h

313

dst[2] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

315

dst[4] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

316

dst[6] = tmp >> 8;

drivers/video/fbdev/atafb_utils.h

320

dst[8] = tmp;

drivers/video/fbdev/atafb_utils.h

321

dst[10] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

322

dst[12] = (tmp >>= 8);

drivers/video/fbdev/atafb_utils.h

323

dst[14] = tmp >> 8;

drivers/video/fbdev/atafb_utils.h

359

static inline u32 *fill16_col(u32 *dst, int rows, u32 m[])

drivers/video/fbdev/atafb_utils.h

362

*dst++ = m[0];

drivers/video/fbdev/atafb_utils.h

364

*dst++ = m[1];

drivers/video/fbdev/atafb_utils.h

367

*dst++ = m[2];

drivers/video/fbdev/atafb_utils.h

368

*dst++ = m[3];

drivers/video/fbdev/atafb_utils.h

372

return dst;

drivers/video/fbdev/atafb_utils.h

375

static inline void memmove32_col(void *dst, void *src, u32 mask, u32 h, u32 bytes)

drivers/video/fbdev/atafb_utils.h

380

d = dst;

drivers/video/fbdev/aty/aty128fb.c

1034

u32 xres, yres, vxres, vyres, xoffset, yoffset, bpp, dst;

drivers/video/fbdev/aty/aty128fb.c

1079

dst = depth_to_dst(depth);

drivers/video/fbdev/aty/aty128fb.c

1081

if (dst == -EINVAL) {

drivers/video/fbdev/aty/aty128fb.c

1087

bytpp = mode_bytpp[dst];

drivers/video/fbdev/aty/aty128fb.c

1128

crtc->gen_cntl = 0x3000000L | c_sync | (dst << 8);

drivers/video/fbdev/aty/mach64_cursor.c

152

u8 __iomem *dst = (u8 __iomem *)info->sprite.addr;

drivers/video/fbdev/aty/mach64_cursor.c

161

fb_memset_io(dst, 0xaa, 1024);

drivers/video/fbdev/aty/mach64_cursor.c

192

fb_writeb(l & 0xff, dst++);

drivers/video/fbdev/aty/mach64_cursor.c

193

fb_writeb(l >> 8, dst++);

drivers/video/fbdev/aty/mach64_cursor.c

195

dst += offset;

drivers/video/fbdev/c2p.h

13

extern void c2p_planar(void *dst, const void *src, u32 dx, u32 dy, u32 width,

drivers/video/fbdev/c2p.h

17

extern void c2p_iplan2(void *dst, const void *src, u32 dx, u32 dy, u32 width,

drivers/video/fbdev/c2p_iplan2.c

105

p = dst;

drivers/video/fbdev/c2p_iplan2.c

149

dst += dst_nextline;

drivers/video/fbdev/c2p_iplan2.c

49

static inline void store_iplan2(void *dst, u32 bpp, u32 d[4])

drivers/video/fbdev/c2p_iplan2.c

53

for (i = 0; i < bpp/2; i++, dst += 4)

drivers/video/fbdev/c2p_iplan2.c

54

put_unaligned_be32(d[perm_c2p_16x8[i]], dst);

drivers/video/fbdev/c2p_iplan2.c

62

static inline void store_iplan2_masked(void *dst, u32 bpp, u32 d[4], u32 mask)

drivers/video/fbdev/c2p_iplan2.c

66

for (i = 0; i < bpp/2; i++, dst += 4)

drivers/video/fbdev/c2p_iplan2.c

68

get_unaligned_be32(dst), mask),

drivers/video/fbdev/c2p_iplan2.c

69

dst);

drivers/video/fbdev/c2p_iplan2.c

86

void c2p_iplan2(void *dst, const void *src, u32 dx, u32 dy, u32 width,

drivers/video/fbdev/c2p_iplan2.c

97

dst += dy*dst_nextline+(dx & ~15)*bpp;

drivers/video/fbdev/c2p_planar.c

105

p = dst;

drivers/video/fbdev/c2p_planar.c

152

dst += dst_nextline;

drivers/video/fbdev/c2p_planar.c

49

static inline void store_planar(void *dst, u32 dst_inc, u32 bpp, u32 d[8])

drivers/video/fbdev/c2p_planar.c

53

for (i = 0; i < bpp; i++, dst += dst_inc)

drivers/video/fbdev/c2p_planar.c

54

put_unaligned_be32(d[perm_c2p_32x8[i]], dst);

drivers/video/fbdev/c2p_planar.c

62

static inline void store_planar_masked(void *dst, u32 dst_inc, u32 bpp,

drivers/video/fbdev/c2p_planar.c

67

for (i = 0; i < bpp; i++, dst += dst_inc)

drivers/video/fbdev/c2p_planar.c

69

get_unaligned_be32(dst), mask),

drivers/video/fbdev/c2p_planar.c

70

dst);

drivers/video/fbdev/c2p_planar.c

87

void c2p_planar(void *dst, const void *src, u32 dx, u32 dy, u32 width,

drivers/video/fbdev/c2p_planar.c

99

dst += dy*dst_nextline+(dx & ~31);

drivers/video/fbdev/cobalt_lcdfb.c

177

char dst[LCD_CHARS_MAX];

drivers/video/fbdev/cobalt_lcdfb.c

194

if (copy_from_user(dst, buf, count))

drivers/video/fbdev/cobalt_lcdfb.c

208

lcd_write_data(info, dst[len]);

drivers/video/fbdev/core/bitblit.c

102

fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/bitblit.c

105

dst += s_pitch;

drivers/video/fbdev/core/bitblit.c

116

u8 *dst)

drivers/video/fbdev/core/bitblit.c

137

fb_pad_unaligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/bitblit.c

141

dst += (shift_low >= 8) ? s_pitch : s_pitch - 1;

drivers/video/fbdev/core/bitblit.c

162

u8 *dst, *buf = NULL;

drivers/video/fbdev/core/bitblit.c

205

dst = fb_get_buffer_offset(info, &info->pixmap, size);

drivers/video/fbdev/core/bitblit.c

206

image.data = dst;

drivers/video/fbdev/core/bitblit.c

210

width, cellsize, &image, buf, dst);

drivers/video/fbdev/core/bitblit.c

214

buf, dst);

drivers/video/fbdev/core/bitblit.c

25

static void update_attr(u8 *dst, u8 *src, int attribute,

drivers/video/fbdev/core/bitblit.c

288

u8 *dst;

drivers/video/fbdev/core/bitblit.c

290

dst = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC);

drivers/video/fbdev/core/bitblit.c

291

if (!dst)

drivers/video/fbdev/core/bitblit.c

294

par->cursor_data = dst;

drivers/video/fbdev/core/bitblit.c

295

update_attr(dst, src, attribute, vc);

drivers/video/fbdev/core/bitblit.c

296

src = dst;

drivers/video/fbdev/core/bitblit.c

42

dst[i] = c;

drivers/video/fbdev/core/bitblit.c

79

struct fb_image *image, u8 *buf, u8 *dst)

drivers/video/fbdev/core/bitblit.c

99

__fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/cfbmem.h

26

static inline void fb_write_offset(unsigned long val, int offset, const struct fb_address *dst)

drivers/video/fbdev/core/cfbmem.h

29

fb_writel(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/cfbmem.h

31

fb_writeq(val, dst->address + offset * (BITS_PER_LONG / BITS_PER_BYTE));

drivers/video/fbdev/core/fb_copyarea.h

102

first = fb_pixel_mask(dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

110

fb_copy_offset(0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

112

fb_copy_offset_masked(first, 0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

121

fb_copy_offset_masked(last, end, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

125

fb_copy_offset(end - 1, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

126

fb_copy_offset(end - 2, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

127

fb_copy_offset(end - 3, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

128

fb_copy_offset(end - 4, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

132

fb_copy_offset(--end, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

136

fb_copy_offset_masked(first, 0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

140

static inline void fb_copy_aligned(struct fb_address *dst, struct fb_address *src,

drivers/video/fbdev/core/fb_copyarea.h

146

fb_copy_aligned_rev(dst, src, width + dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

147

fb_address_backward(dst, bits_per_line);

drivers/video/fbdev/core/fb_copyarea.h

152

fb_copy_aligned_fwd(dst, src, width + dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

153

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_copyarea.h

158

static __always_inline void fb_copy_fwd(const struct fb_address *dst,

drivers/video/fbdev/core/fb_copyarea.h

166

int end = dst->bits + width;

drivers/video/fbdev/core/fb_copyarea.h

169

first = fb_pixel_mask(dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

172

shift = dst->bits - src->bits;

drivers/video/fbdev/core/fb_copyarea.h

185

fb_write_offset(reorder(d0, reverse), 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

187

fb_modify_offset(reorder(d0, reverse), last, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

190

fb_modify_offset(reorder(d0, reverse), last, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

206

fb_modify_offset(reorder(d0, reverse), first, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

216

fb_write_offset(d0, offset + 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

220

fb_write_offset(d0, offset + 1, dst);

drivers/video/fbdev/core/fb_copyarea.h

224

fb_write_offset(d0, offset + 2, dst);

drivers/video/fbdev/core/fb_copyarea.h

228

fb_write_offset(d0, offset + 3, dst);

drivers/video/fbdev/core/fb_copyarea.h

236

fb_write_offset(reorder(d0, reverse), offset, dst);

drivers/video/fbdev/core/fb_copyarea.h

248

fb_modify_offset(reorder(d0, reverse), last, offset, dst);

drivers/video/fbdev/core/fb_copyarea.h

253

static __always_inline void fb_copy_rev(const struct fb_address *dst,

drivers/video/fbdev/core/fb_copyarea.h

263

first = fb_pixel_mask(dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

266

shift = dst->bits - src->bits;

drivers/video/fbdev/core/fb_copyarea.h

279

fb_modify_offset(reorder(d0, reverse), first, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

282

if (src->bits + end - dst->bits > BITS_PER_LONG)

drivers/video/fbdev/core/fb_copyarea.h

285

fb_write_offset(reorder(d0, reverse), 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

287

fb_modify_offset(reorder(d0, reverse), first, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

305

last, end, dst);

drivers/video/fbdev/core/fb_copyarea.h

313

fb_write_offset(d0, end - 1, dst);

drivers/video/fbdev/core/fb_copyarea.h

317

fb_write_offset(d0, end - 2, dst);

drivers/video/fbdev/core/fb_copyarea.h

321

fb_write_offset(d0, end - 3, dst);

drivers/video/fbdev/core/fb_copyarea.h

325

fb_write_offset(d0, end - 4, dst);

drivers/video/fbdev/core/fb_copyarea.h

334

fb_write_offset(reorder(d0, reverse), end, dst);

drivers/video/fbdev/core/fb_copyarea.h

343

fb_modify_offset(reorder(d0, reverse), first, 0, dst);

drivers/video/fbdev/core/fb_copyarea.h

348

static __always_inline void fb_copy(struct fb_address *dst, struct fb_address *src,

drivers/video/fbdev/core/fb_copyarea.h

356

int move = src->bits < dst->bits ? -1 : 0;

drivers/video/fbdev/core/fb_copyarea.h

359

fb_copy_rev(dst, src, width + dst->bits, reorder, reverse);

drivers/video/fbdev/core/fb_copyarea.h

36

const struct fb_address *dst,

drivers/video/fbdev/core/fb_copyarea.h

360

fb_address_backward(dst, bits_per_line);

drivers/video/fbdev/core/fb_copyarea.h

366

int move = src->bits > dst->bits ? 1 : 0;

drivers/video/fbdev/core/fb_copyarea.h

369

fb_copy_fwd(dst, src, width, reorder, reverse);

drivers/video/fbdev/core/fb_copyarea.h

370

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_copyarea.h

385

struct fb_address dst = fb_address_init(p);

drivers/video/fbdev/core/fb_copyarea.h

386

struct fb_address src = dst;

drivers/video/fbdev/core/fb_copyarea.h

39

fb_modify_offset(fb_read_offset(offset, src), mask, offset, dst);

drivers/video/fbdev/core/fb_copyarea.h

393

fb_address_forward(&dst, dy*bits_per_line + area->dx*bpp);

drivers/video/fbdev/core/fb_copyarea.h

396

if (src.bits == dst.bits)

drivers/video/fbdev/core/fb_copyarea.h

397

fb_copy_aligned(&dst, &src, width, height, bits_per_line, reverse, rev_copy);

drivers/video/fbdev/core/fb_copyarea.h

399

!((src.bits ^ dst.bits) & (BITS_PER_BYTE-1)))) {

drivers/video/fbdev/core/fb_copyarea.h

400

fb_copy(&dst, &src, width, height, bits_per_line,

drivers/video/fbdev/core/fb_copyarea.h

403

fb_copy(&dst, &src, width, height, bits_per_line,

drivers/video/fbdev/core/fb_copyarea.h

43

static inline void fb_copy_offset(int offset, const struct fb_address *dst,

drivers/video/fbdev/core/fb_copyarea.h

46

fb_write_offset(fb_read_offset(offset, src), offset, dst);

drivers/video/fbdev/core/fb_copyarea.h

50

static inline void fb_copy_aligned_fwd(const struct fb_address *dst,

drivers/video/fbdev/core/fb_copyarea.h

56

first = fb_pixel_mask(dst->bits, reverse);

drivers/video/fbdev/core/fb_copyarea.h

66

fb_copy_offset(0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

68

fb_copy_offset_masked(last, 0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

75

fb_copy_offset_masked(first, 0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

80

fb_copy_offset(offset + 0, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

81

fb_copy_offset(offset + 1, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

82

fb_copy_offset(offset + 2, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

83

fb_copy_offset(offset + 3, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

87

fb_copy_offset(offset++, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

91

fb_copy_offset_masked(last, offset, dst, src);

drivers/video/fbdev/core/fb_copyarea.h

96

static inline void fb_copy_aligned_rev(const struct fb_address *dst,

drivers/video/fbdev/core/fb_draw.h

50

int offset, const struct fb_address *dst)

drivers/video/fbdev/core/fb_draw.h

52

fb_write_offset(fb_comp(val, fb_read_offset(offset, dst), mask), offset, dst);

drivers/video/fbdev/core/fb_fillrect.h

105

static __always_inline void bitfill(const struct fb_address *dst,

drivers/video/fbdev/core/fb_fillrect.h

113

end += dst->bits;

drivers/video/fbdev/core/fb_fillrect.h

114

first = fb_pixel_mask(dst->bits, pattern->reverse);

drivers/video/fbdev/core/fb_fillrect.h

121

fb_write_offset(first, 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

123

fb_modify_offset(first, last, 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

128

fb_modify_offset(get(pattern), first, 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

133

fb_write_offset(get(pattern), offset + 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

135

fb_write_offset(get(pattern), offset + 1, dst);

drivers/video/fbdev/core/fb_fillrect.h

137

fb_write_offset(get(pattern), offset + 2, dst);

drivers/video/fbdev/core/fb_fillrect.h

139

fb_write_offset(get(pattern), offset + 3, dst);

drivers/video/fbdev/core/fb_fillrect.h

143

fb_write_offset(get(pattern), offset++, dst);

drivers/video/fbdev/core/fb_fillrect.h

148

fb_modify_offset(get(pattern), last, offset, dst);

drivers/video/fbdev/core/fb_fillrect.h

153

static __always_inline void bitinvert(const struct fb_address *dst,

drivers/video/fbdev/core/fb_fillrect.h

162

end += dst->bits;

drivers/video/fbdev/core/fb_fillrect.h

163

first = fb_pixel_mask(dst->bits, pattern->reverse);

drivers/video/fbdev/core/fb_fillrect.h

175

fb_invert_offset(first, 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

181

fb_invert_offset(get(pattern), offset + 0, dst);

drivers/video/fbdev/core/fb_fillrect.h

183

fb_invert_offset(get(pattern), offset + 1, dst);

drivers/video/fbdev/core/fb_fillrect.h

185

fb_invert_offset(get(pattern), offset + 2, dst);

drivers/video/fbdev/core/fb_fillrect.h

187

fb_invert_offset(get(pattern), offset + 3, dst);

drivers/video/fbdev/core/fb_fillrect.h

191

fb_invert_offset(get(pattern), offset++, dst);

drivers/video/fbdev/core/fb_fillrect.h

198

fb_invert_offset(last, offset, dst);

drivers/video/fbdev/core/fb_fillrect.h

203

struct fb_address *dst, struct fb_pattern *pattern,

drivers/video/fbdev/core/fb_fillrect.h

214

bitinvert(dst, pattern, fb_pattern_get, fb_pattern_static, width);

drivers/video/fbdev/core/fb_fillrect.h

215

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_fillrect.h

219

bitfill(dst, pattern, fb_pattern_get, fb_pattern_static, width);

drivers/video/fbdev/core/fb_fillrect.h

220

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_fillrect.h

233

int bpp, struct fb_address *dst,

drivers/video/fbdev/core/fb_fillrect.h

244

pattern->pixels = fb_rotate(pat, dst->bits, bpp);

drivers/video/fbdev/core/fb_fillrect.h

245

bitinvert(dst, pattern, get, fb_pattern_rotate, width);

drivers/video/fbdev/core/fb_fillrect.h

246

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_fillrect.h

250

pattern->pixels = fb_rotate(pat, dst->bits, bpp);

drivers/video/fbdev/core/fb_fillrect.h

251

bitfill(dst, pattern, get, fb_pattern_rotate, width);

drivers/video/fbdev/core/fb_fillrect.h

252

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_fillrect.h

261

struct fb_address dst = fb_address_init(p);

drivers/video/fbdev/core/fb_fillrect.h

264

fb_address_forward(&dst, rect->dy * bits_per_line + rect->dx * bpp);

drivers/video/fbdev/core/fb_fillrect.h

272

fb_fillrect_rotating(rect, bpp, &dst, &pattern,

drivers/video/fbdev/core/fb_fillrect.h

275

fb_fillrect_rotating(rect, bpp, &dst, &pattern,

drivers/video/fbdev/core/fb_fillrect.h

278

fb_fillrect_static(rect, bpp, &dst, &pattern, bits_per_line);

drivers/video/fbdev/core/fb_fillrect.h

29

static inline void fb_invert_offset(unsigned long pat, int offset, const struct fb_address *dst)

drivers/video/fbdev/core/fb_fillrect.h

31

fb_write_offset(fb_read_offset(offset, dst) ^ pat, offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

129

void *iter, int bits, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

134

int shift = dst->bits;

drivers/video/fbdev/core/fb_imageblit.h

137

old = fb_read_offset(0, dst);

drivers/video/fbdev/core/fb_imageblit.h

153

fb_write_offset(val, offset++, dst);

drivers/video/fbdev/core/fb_imageblit.h

161

if (offset || !dst->bits)

drivers/video/fbdev/core/fb_imageblit.h

162

old = fb_read_offset(offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

163

fb_write_offset(fb_comp(val, old, mask), offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

168

static inline void fb_color_imageblit(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

194

fb_bitblit(fb_color_image, &iter, bpp, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

195

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_imageblit.h

215

static inline void fb_bitmap4x_imageblit(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

250

fb_bitblit(fb_bitmap4x_image, &iter, bpp * BITS_PER_BYTE/2, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

251

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_imageblit.h

256

static inline void fb_bitmap1x_imageblit(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

275

fb_bitblit(fb_bitmap_image, &iter, bpp, dst, reverse);

drivers/video/fbdev/core/fb_imageblit.h

276

fb_address_forward(dst, bits_per_line);

drivers/video/fbdev/core/fb_imageblit.h

281

static inline void fb_bitmap_1ppw(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

304

fb_write_offset(tab[(srcbyte >> 7) & 1], offset + 0, dst);

drivers/video/fbdev/core/fb_imageblit.h

305

fb_write_offset(tab[(srcbyte >> 6) & 1], offset + 1, dst);

drivers/video/fbdev/core/fb_imageblit.h

306

fb_write_offset(tab[(srcbyte >> 5) & 1], offset + 2, dst);

drivers/video/fbdev/core/fb_imageblit.h

307

fb_write_offset(tab[(srcbyte >> 4) & 1], offset + 3, dst);

drivers/video/fbdev/core/fb_imageblit.h

308

fb_write_offset(tab[(srcbyte >> 3) & 1], offset + 4, dst);

drivers/video/fbdev/core/fb_imageblit.h

309

fb_write_offset(tab[(srcbyte >> 2) & 1], offset + 5, dst);

drivers/video/fbdev/core/fb_imageblit.h

310

fb_write_offset(tab[(srcbyte >> 1) & 1], offset + 6, dst);

drivers/video/fbdev/core/fb_imageblit.h

311

fb_write_offset(tab[(srcbyte >> 0) & 1], offset + 7, dst);

drivers/video/fbdev/core/fb_imageblit.h

318

fb_write_offset(tab[(srcbyte >> 7) & 1], offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

323

fb_address_move_long(dst, words_per_line);

drivers/video/fbdev/core/fb_imageblit.h

337

static inline void fb_bitmap_2ppw(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

364

fb_write_offset(tab[(srcbyte >> 6) & 3], offset + 0, dst);

drivers/video/fbdev/core/fb_imageblit.h

365

fb_write_offset(tab[(srcbyte >> 4) & 3], offset + 1, dst);

drivers/video/fbdev/core/fb_imageblit.h

366

fb_write_offset(tab[(srcbyte >> 2) & 3], offset + 2, dst);

drivers/video/fbdev/core/fb_imageblit.h

367

fb_write_offset(tab[(srcbyte >> 0) & 3], offset + 3, dst);

drivers/video/fbdev/core/fb_imageblit.h

374

fb_write_offset(tab[(srcbyte >> 6) & 3], offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

379

fb_address_move_long(dst, words_per_line);

drivers/video/fbdev/core/fb_imageblit.h

388

static inline void fb_bitmap_4ppw(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

430

fb_write_offset((fgcolor & tab[*src >> 4]) ^ bgcolor, offset + 0, dst);

drivers/video/fbdev/core/fb_imageblit.h

431

fb_write_offset((fgcolor & tab[*src & 0xf]) ^ bgcolor, offset + 1, dst);

drivers/video/fbdev/core/fb_imageblit.h

435

fb_write_offset((fgcolor & tab[*src++ >> 4]) ^ bgcolor, offset, dst);

drivers/video/fbdev/core/fb_imageblit.h

437

fb_address_move_long(dst, words_per_line);

drivers/video/fbdev/core/fb_imageblit.h

441

static inline void fb_bitmap_imageblit(const struct fb_image *image, struct fb_address *dst,

drivers/video/fbdev/core/fb_imageblit.h

455

if (!dst->bits && !(bits_per_line & (BITS_PER_LONG-1))) {

drivers/video/fbdev/core/fb_imageblit.h

457

fb_bitmap_1ppw(image, dst, fgcolor, bgcolor,

drivers/video/fbdev/core/fb_imageblit.h

462

fb_bitmap_2ppw(image, dst, fgcolor, bgcolor,

drivers/video/fbdev/core/fb_imageblit.h

467

fb_bitmap_4ppw(image, dst, fgcolor, bgcolor,

drivers/video/fbdev/core/fb_imageblit.h

474

fb_bitmap4x_imageblit(image, dst, fgcolor, bgcolor, bpp,

drivers/video/fbdev/core/fb_imageblit.h

477

fb_bitmap1x_imageblit(image, dst, fgcolor, bgcolor, bpp,

drivers/video/fbdev/core/fb_imageblit.h

485

struct fb_address dst = fb_address_init(p);

drivers/video/fbdev/core/fb_imageblit.h

489

fb_address_forward(&dst, image->dy * bits_per_line + image->dx * bpp);

drivers/video/fbdev/core/fb_imageblit.h

492

fb_bitmap_imageblit(image, &dst, bits_per_line, palette, bpp, reverse);

drivers/video/fbdev/core/fb_imageblit.h

494

fb_color_imageblit(image, &dst, bits_per_line, palette, bpp, reverse);

drivers/video/fbdev/core/fb_io_fops.c

11

u8 *buffer, *dst;

drivers/video/fbdev/core/fb_io_fops.c

111

dst = (u8 __iomem *) (info->screen_base + p);

drivers/video/fbdev/core/fb_io_fops.c

127

fb_memcpy_toio(dst, src, c);

drivers/video/fbdev/core/fb_io_fops.c

128

dst += c;

drivers/video/fbdev/core/fb_io_fops.c

48

dst = buffer;

drivers/video/fbdev/core/fb_io_fops.c

49

fb_memcpy_fromio(dst, src, c);

drivers/video/fbdev/core/fb_io_fops.c

50

dst += c;

drivers/video/fbdev/core/fb_io_fops.c

76

u8 __iomem *dst;

drivers/video/fbdev/core/fb_logo.c

126

*dst++ = *src >> 4;

drivers/video/fbdev/core/fb_logo.c

129

*dst++ = *src & 0x0f;

drivers/video/fbdev/core/fb_logo.c

139

*dst++ = ((d >> k) & 1) ? fg : 0;

drivers/video/fbdev/core/fb_logo.c

210

static void fb_rotate_logo(struct fb_info *info, u8 *dst,

drivers/video/fbdev/core/fb_logo.c

216

fb_rotate_logo_ud(image->data, dst, image->width,

drivers/video/fbdev/core/fb_logo.c

221

fb_rotate_logo_cw(image->data, dst, image->width,

drivers/video/fbdev/core/fb_logo.c

228

fb_rotate_logo_ccw(image->data, dst, image->width,

drivers/video/fbdev/core/fb_logo.c

236

image->data = dst;

drivers/video/fbdev/core/fb_logo.c

98

const struct linux_logo *logo, u8 *dst,

drivers/video/fbdev/core/fb_sys_fops.c

103

c = copy_from_user(dst, buf, count);

drivers/video/fbdev/core/fb_sys_fops.c

67

void *dst;

drivers/video/fbdev/core/fb_sys_fops.c

98

dst = info->screen_buffer + p;

drivers/video/fbdev/core/fbcon_ccw.c

100

struct fb_image *image, u8 *buf, u8 *dst)

drivers/video/fbdev/core/fbcon_ccw.c

116

__fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_ccw.c

119

fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_ccw.c

122

dst += d_pitch * vc->vc_font.width;

drivers/video/fbdev/core/fbcon_ccw.c

141

u8 *dst, *buf = NULL;

drivers/video/fbdev/core/fbcon_ccw.c

173

dst = fb_get_buffer_offset(info, &info->pixmap, size);

drivers/video/fbdev/core/fbcon_ccw.c

174

image.data = dst;

drivers/video/fbdev/core/fbcon_ccw.c

176

width, cellsize, &image, buf, dst);

drivers/video/fbdev/core/fbcon_ccw.c

249

u8 *dst;

drivers/video/fbdev/core/fbcon_ccw.c

25

static void ccw_update_attr(u8 *dst, u8 *src, int attribute,

drivers/video/fbdev/core/fbcon_ccw.c

251

dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC);

drivers/video/fbdev/core/fbcon_ccw.c

252

if (!dst)

drivers/video/fbdev/core/fbcon_ccw.c

255

par->cursor_data = dst;

drivers/video/fbdev/core/fbcon_ccw.c

256

ccw_update_attr(dst, src, attribute, vc);

drivers/video/fbdev/core/fbcon_ccw.c

257

src = dst;

drivers/video/fbdev/core/fbcon_ccw.c

52

*(dst - width) |= c;

drivers/video/fbdev/core/fbcon_ccw.c

57

*dst++ = c;

drivers/video/fbdev/core/fbcon_cw.c

101

__fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_cw.c

104

fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_cw.c

107

dst += d_pitch * vc->vc_font.width;

drivers/video/fbdev/core/fbcon_cw.c

126

u8 *dst, *buf = NULL;

drivers/video/fbdev/core/fbcon_cw.c

156

dst = fb_get_buffer_offset(info, &info->pixmap, size);

drivers/video/fbdev/core/fbcon_cw.c

157

image.data = dst;

drivers/video/fbdev/core/fbcon_cw.c

159

width, cellsize, &image, buf, dst);

drivers/video/fbdev/core/fbcon_cw.c

232

u8 *dst;

drivers/video/fbdev/core/fbcon_cw.c

234

dst = kmalloc_array(w, vc->vc_font.width, GFP_ATOMIC);

drivers/video/fbdev/core/fbcon_cw.c

235

if (!dst)

drivers/video/fbdev/core/fbcon_cw.c

238

par->cursor_data = dst;

drivers/video/fbdev/core/fbcon_cw.c

239

cw_update_attr(dst, src, attribute, vc);

drivers/video/fbdev/core/fbcon_cw.c

240

src = dst;

drivers/video/fbdev/core/fbcon_cw.c

25

static void cw_update_attr(u8 *dst, u8 *src, int attribute,

drivers/video/fbdev/core/fbcon_cw.c

42

*dst++ = c;

drivers/video/fbdev/core/fbcon_cw.c

85

struct fb_image *image, u8 *buf, u8 *dst)

drivers/video/fbdev/core/fbcon_rotate.c

27

u8 *dst;

drivers/video/fbdev/core/fbcon_rotate.c

49

dst = kmalloc_array(len, d_cellsize, GFP_KERNEL);

drivers/video/fbdev/core/fbcon_rotate.c

51

if (dst == NULL) {

drivers/video/fbdev/core/fbcon_rotate.c

58

par->fontbuffer = dst;

drivers/video/fbdev/core/fbcon_rotate.c

61

dst = par->fontbuffer;

drivers/video/fbdev/core/fbcon_rotate.c

62

memset(dst, 0, par->fd_size);

drivers/video/fbdev/core/fbcon_rotate.c

67

rotate_ud(src, dst, vc->vc_font.width,

drivers/video/fbdev/core/fbcon_rotate.c

71

dst += d_cellsize;

drivers/video/fbdev/core/fbcon_rotate.c

76

rotate_cw(src, dst, vc->vc_font.width,

drivers/video/fbdev/core/fbcon_rotate.c

79

dst += d_cellsize;

drivers/video/fbdev/core/fbcon_rotate.c

84

rotate_ccw(src, dst, vc->vc_font.width,

drivers/video/fbdev/core/fbcon_rotate.c

87

dst += d_cellsize;

drivers/video/fbdev/core/fbcon_ud.c

103

__fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_ud.c

106

fb_pad_aligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_ud.c

109

dst += s_pitch;

drivers/video/fbdev/core/fbcon_ud.c

120

u8 *dst)

drivers/video/fbdev/core/fbcon_ud.c

137

fb_pad_unaligned_buffer(dst, d_pitch, src, idx,

drivers/video/fbdev/core/fbcon_ud.c

141

dst += (shift_low >= 8) ? s_pitch : s_pitch - 1;

drivers/video/fbdev/core/fbcon_ud.c

163

u8 *dst, *buf = NULL;

drivers/video/fbdev/core/fbcon_ud.c

196

dst = fb_get_buffer_offset(info, &info->pixmap, size);

drivers/video/fbdev/core/fbcon_ud.c

197

image.data = dst;

drivers/video/fbdev/core/fbcon_ud.c

201

width, cellsize, &image, buf, dst);

drivers/video/fbdev/core/fbcon_ud.c

205

buf, dst);

drivers/video/fbdev/core/fbcon_ud.c

25

static void ud_update_attr(u8 *dst, u8 *src, int attribute,

drivers/video/fbdev/core/fbcon_ud.c

280

u8 *dst;

drivers/video/fbdev/core/fbcon_ud.c

282

dst = kmalloc_array(w, vc->vc_font.height, GFP_ATOMIC);

drivers/video/fbdev/core/fbcon_ud.c

283

if (!dst)

drivers/video/fbdev/core/fbcon_ud.c

286

par->cursor_data = dst;

drivers/video/fbdev/core/fbcon_ud.c

287

ud_update_attr(dst, src, attribute, vc);

drivers/video/fbdev/core/fbcon_ud.c

288

src = dst;

drivers/video/fbdev/core/fbcon_ud.c

43

dst[i] = c;

drivers/video/fbdev/core/fbcon_ud.c

87

struct fb_image *image, u8 *buf, u8 *dst)

drivers/video/fbdev/core/fbmem.c

100

void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx, u32 height,

drivers/video/fbdev/core/fbmem.c

108

tmp = dst[j];

drivers/video/fbdev/core/fbmem.c

111

dst[j] = tmp;

drivers/video/fbdev/core/fbmem.c

113

dst[j+1] = tmp;

drivers/video/fbdev/core/fbmem.c

116

tmp = dst[idx];

drivers/video/fbdev/core/fbmem.c

119

dst[idx] = tmp;

drivers/video/fbdev/core/fbmem.c

122

dst[idx+1] = tmp;

drivers/video/fbdev/core/fbmem.c

125

dst += d_pitch;

drivers/video/fbdev/core/fbmem.c

94

void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height)

drivers/video/fbdev/core/fbmem.c

96

__fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, height);

drivers/video/fbdev/core/softcursor.c

29

u8 *src, *dst;

drivers/video/fbdev/core/softcursor.c

55

dst = fb_get_buffer_offset(info, &info->pixmap, size);

drivers/video/fbdev/core/softcursor.c

72

fb_pad_aligned_buffer(dst, d_pitch, src, s_pitch, image->height);

drivers/video/fbdev/core/softcursor.c

73

image->data = dst;

drivers/video/fbdev/core/svgalib.c

224

u16 __iomem *src, *dst;

drivers/video/fbdev/core/svgalib.c

229

dst = fb + area->dx * colstride + area->dy * rowstride;

drivers/video/fbdev/core/svgalib.c

233

dst = fb + (area->dx + area->width - 1) * colstride

drivers/video/fbdev/core/svgalib.c

242

u16 __iomem *dst2 = dst;

drivers/video/fbdev/core/svgalib.c

250

dst += rowstride;

drivers/video/fbdev/core/sysmem.h

26

static inline void fb_write_offset(unsigned long val, int offset, const struct fb_address *dst)

drivers/video/fbdev/core/sysmem.h

28

unsigned long *mem = dst->address;

drivers/video/fbdev/cyber2000fb.c

158

unsigned long dst, col;

drivers/video/fbdev/cyber2000fb.c

174

dst = rect->dx + rect->dy * cfb->fb.var.xres_virtual;

drivers/video/fbdev/cyber2000fb.c

176

cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);

drivers/video/fbdev/cyber2000fb.c

177

dst *= 3;

drivers/video/fbdev/cyber2000fb.c

180

cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);

drivers/video/fbdev/cyber2000fb.c

191

unsigned long src, dst;

drivers/video/fbdev/cyber2000fb.c

203

dst = region->dx + region->dy * cfb->fb.var.xres_virtual;

drivers/video/fbdev/cyber2000fb.c

207

dst += region->width - 1;

drivers/video/fbdev/cyber2000fb.c

213

dst += (region->height - 1) * cfb->fb.var.xres_virtual;

drivers/video/fbdev/cyber2000fb.c

218

cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);

drivers/video/fbdev/cyber2000fb.c

220

dst *= 3;

drivers/video/fbdev/cyber2000fb.c

223

cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);

drivers/video/fbdev/efifb.c

107

static void efifb_copy_bmp(u8 *src, u32 *dst, int width, const struct screen_info *si)

drivers/video/fbdev/efifb.c

115

*dst++ = (r << si->red_pos) |

drivers/video/fbdev/efifb.c

152

u8 *dst = info->screen_base;

drivers/video/fbdev/efifb.c

215

for (y = 0; y < si->lfb_height; y++, dst += si->lfb_linelength) {

drivers/video/fbdev/efifb.c

219

memset(dst, 0, 4 * si->lfb_width);

drivers/video/fbdev/efifb.c

228

memset(dst, 0, bgrt_tab.image_offset_x * 4);

drivers/video/fbdev/efifb.c

232

(u32 *)dst + dst_x, bmp_width, si);

drivers/video/fbdev/efifb.c

234

memset((u32 *)dst + dst_x, 0, (si->lfb_width - dst_x) * 4);

drivers/video/fbdev/i810/i810_accel.c

370

u32 fg = 0, bg = 0, size, dst;

drivers/video/fbdev/i810/i810_accel.c

390

dst = info->fix.smem_start + (image->dy * info->fix.line_length) +

drivers/video/fbdev/i810/i810_accel.c

401

PAT_COPY_ROP, dst, (u32 *) image->data,

drivers/video/fbdev/imsttfb.c

1219

u8 *dst = (u8 *) cursor->dest;

drivers/video/fbdev/imsttfb.c

1228

dst[s_idx]];

drivers/video/fbdev/leo.c

113

u32 dst;

drivers/video/fbdev/leo.c

139

u32 dst; /* Copy/Scroll/Fill (SS0 only) */

drivers/video/fbdev/matrox/matroxfb_maven.c

140

char dst;

drivers/video/fbdev/matrox/matroxfb_maven.c

151

.len = sizeof(dst),

drivers/video/fbdev/matrox/matroxfb_maven.c

152

.buf = &dst

drivers/video/fbdev/matrox/matroxfb_maven.c

160

return dst & 0xFF;

drivers/video/fbdev/matrox/matroxfb_misc.c

399

unsigned char* dst = bd->pins;

drivers/video/fbdev/matrox/matroxfb_misc.c

404

*dst++ = 0x2E;

drivers/video/fbdev/matrox/matroxfb_misc.c

405

*dst++ = 0x41;

drivers/video/fbdev/matrox/matroxfb_misc.c

406

*dst++ = pins_len;

drivers/video/fbdev/matrox/matroxfb_misc.c

409

cksum += *dst++ = readb(pins+i);

drivers/video/fbdev/matrox/matroxfb_misc.c

417

unsigned char* dst = bd->pins;

drivers/video/fbdev/matrox/matroxfb_misc.c

419

*dst++ = 0x40;

drivers/video/fbdev/matrox/matroxfb_misc.c

420

*dst++ = 0;

drivers/video/fbdev/matrox/matroxfb_misc.c

422

*dst++ = readb(pins+i);

drivers/video/fbdev/neofb.c

1364

u_long dst, rop;

drivers/video/fbdev/neofb.c

1366

dst = rect->dx + rect->dy * info->var.xres_virtual;

drivers/video/fbdev/neofb.c

1389

writel(dst * ((info->var.bits_per_pixel + 7) >> 3),

drivers/video/fbdev/neofb.c

1400

u_long src, dst, bltCntl;

drivers/video/fbdev/neofb.c

1415

dst = dx * (info->var.bits_per_pixel >> 3) + dy*info->fix.line_length;

drivers/video/fbdev/neofb.c

1423

writel(dst, &par->neo2200->dstStart);

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

248

opa362_disconnect(dssdev, dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

34

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

49

dst->src = dssdev;

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

50

dssdev->dst = dst;

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

56

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

67

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

68

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

71

dst->src = NULL;

drivers/video/fbdev/omap2/omapfb/displays/encoder-opa362.c

72

dssdev->dst = NULL;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

234

tfp410_disconnect(dssdev, dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

32

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

45

dst->src = dssdev;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

46

dssdev->dst = dst;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

52

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

61

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

62

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

65

dst->src = NULL;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tfp410.c

66

dssdev->dst = NULL;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

300

tpd_disconnect(dssdev, dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

33

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

43

dst->src = dssdev;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

44

dssdev->dst = dst;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

56

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

61

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

63

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

68

dst->src = NULL;

drivers/video/fbdev/omap2/omapfb/displays/encoder-tpd12s015.c

69

dssdev->dst = NULL;

drivers/video/fbdev/omap2/omapfb/dss/apply.c

422

while (dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/apply.c

423

dssdev = dssdev->dst;

drivers/video/fbdev/omap2/omapfb/dss/apply.c

797

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/apply.c

799

return mgr->set_output(mgr, dst);

drivers/video/fbdev/omap2/omapfb/dss/apply.c

803

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

649

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

669

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

672

dst->name);

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

681

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

683

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/dpi.c

685

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4964

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4982

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4994

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4996

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/dsi.c

4998

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/dss.h

483

struct omap_dss_device *dst);

drivers/video/fbdev/omap2/omapfb/dss/dss.h

485

struct omap_dss_device *dst);

drivers/video/fbdev/omap2/omapfb/dss/dss.h

504

struct omap_dss_device *dst);

drivers/video/fbdev/omap2/omapfb/dss/dss.h

506

struct omap_dss_device *dst);

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

413

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

430

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

433

dst->name);

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

442

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

444

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/hdmi4.c

446

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

443

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

460

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

463

dst->name);

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

472

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

474

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/hdmi5.c

476

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/omapdss-boot-init.c

60

static void __init omapdss_prefix_strcpy(char *dst, int dst_len,

drivers/video/fbdev/omap2/omapfb/dss/omapdss-boot-init.c

68

strcpy(dst, prefix);

drivers/video/fbdev/omap2/omapfb/dss/omapdss-boot-init.c

69

dst += strlen(prefix);

drivers/video/fbdev/omap2/omapfb/dss/omapdss-boot-init.c

71

strcpy(dst, src);

drivers/video/fbdev/omap2/omapfb/dss/omapdss-boot-init.c

72

dst += l;

drivers/video/fbdev/omap2/omapfb/dss/output.c

200

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/output.c

202

return dss_mgr_ops->connect(mgr, dst);

drivers/video/fbdev/omap2/omapfb/dss/output.c

207

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/output.c

209

dss_mgr_ops->disconnect(mgr, dst);

drivers/video/fbdev/omap2/omapfb/dss/output.c

28

if (out->dst) {

drivers/video/fbdev/omap2/omapfb/dss/output.c

30

out->dst->name);

drivers/video/fbdev/omap2/omapfb/dss/output.c

41

out->dst = dssdev;

drivers/video/fbdev/omap2/omapfb/dss/output.c

60

if (!out->dst) {

drivers/video/fbdev/omap2/omapfb/dss/output.c

66

if (out->dst->state != OMAP_DSS_DISPLAY_DISABLED) {

drivers/video/fbdev/omap2/omapfb/dss/output.c

68

out->dst->name);

drivers/video/fbdev/omap2/omapfb/dss/output.c

73

out->dst->src = NULL;

drivers/video/fbdev/omap2/omapfb/dss/output.c

74

out->dst = NULL;

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

270

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

287

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

290

dst->name);

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

299

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

301

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/sdi.c

303

if (dst != dssdev->dst)

drivers/video/fbdev/omap2/omapfb/dss/venc.c

680

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/venc.c

697

r = omapdss_output_set_device(dssdev, dst);

drivers/video/fbdev/omap2/omapfb/dss/venc.c

700

dst->name);

drivers/video/fbdev/omap2/omapfb/dss/venc.c

709

struct omap_dss_device *dst)

drivers/video/fbdev/omap2/omapfb/dss/venc.c

711

WARN_ON(dst != dssdev->dst);

drivers/video/fbdev/omap2/omapfb/dss/venc.c

713

if (dst != dssdev->dst)

drivers/video/fbdev/ps3fb.c

609

u64 dst;

drivers/video/fbdev/ps3fb.c

660

for (dst = 0; lines; dst += maxlines * ddr_line_length) {

drivers/video/fbdev/ps3fb.c

662

ps3fb_sync_image(info->device, 0, dst, 0, vmode->xres, l,

drivers/video/fbdev/pvr2fb.c

645

unsigned long dst, start, end, len;

drivers/video/fbdev/pvr2fb.c

682

dst = (unsigned long)fb_info->screen_base + *ppos;

drivers/video/fbdev/pvr2fb.c

696

dma_write(pvr2dma, 0, dst, len);

drivers/video/fbdev/pvr2fb.c

703

for (i = 0; i < nr_pages; i++, dst += PAGE_SIZE) {

drivers/video/fbdev/pvr2fb.c

710

dma_write_page(pvr2dma, 0, dst);

drivers/video/fbdev/s1d13xxxfb.c

435

u32 dst, src;

drivers/video/fbdev/s1d13xxxfb.c

451

dst = (((dy + height - 1) * stride) + (bpp * (dx + width - 1)));

drivers/video/fbdev/s1d13xxxfb.c

456

dst = (dy * stride) + (bpp * dx);

drivers/video/fbdev/s1d13xxxfb.c

466

s1d13xxxfb_writereg(info->par, S1DREG_BBLT_DST_START0, (dst & 0xff));

drivers/video/fbdev/s1d13xxxfb.c

467

s1d13xxxfb_writereg(info->par, S1DREG_BBLT_DST_START1, (dst >> 8) & 0x00ff);

drivers/video/fbdev/s1d13xxxfb.c

468

s1d13xxxfb_writereg(info->par, S1DREG_BBLT_DST_START2, (dst >> 16) & 0x00ff);

drivers/video/fbdev/s3fb.c

357

u32 __iomem *dst;

drivers/video/fbdev/s3fb.c

367

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/s3fb.c

371

fb_writel(val, dst++);

drivers/video/fbdev/s3fb.c

384

u32 __iomem *dst;

drivers/video/fbdev/s3fb.c

391

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/s3fb.c

393

fb_writel(fg, dst++);

drivers/video/fbdev/s3fb.c

414

u32 __iomem *dst;

drivers/video/fbdev/s3fb.c

424

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/s3fb.c

428

fb_writel(val, dst++);

drivers/video/fbdev/sm501fb.c

1126

void __iomem *dst = par->cursor.k_addr;

drivers/video/fbdev/sm501fb.c

1135

smc501_writel(0x0, dst + op);

drivers/video/fbdev/sm501fb.c

1151

op |= readb(dst + (x / 4));

drivers/video/fbdev/sm501fb.c

1152

writeb(op, dst + (x / 4));

drivers/video/fbdev/sm501fb.c

1155

dst += (64*2)/8;

drivers/video/fbdev/sm712fb.c

1031

u32 *buffer, *dst;

drivers/video/fbdev/sm712fb.c

1064

dst = buffer;

drivers/video/fbdev/sm712fb.c

1069

*dst = big_swap(val);

drivers/video/fbdev/sm712fb.c

1071

dst++;

drivers/video/fbdev/sm712fb.c

1095

u32 __iomem *dst;

drivers/video/fbdev/sm712fb.c

1126

dst = (u32 __iomem *)(info->screen_base + p);

drivers/video/fbdev/sm712fb.c

1141

fb_writel(big_swap(*src), dst);

drivers/video/fbdev/sm712fb.c

1142

dst++;

drivers/video/fbdev/tgafb.c

1115

void __iomem *dst;

drivers/video/fbdev/tgafb.c

1127

dst = tga_fb + (dy + height) * width * 4;

drivers/video/fbdev/tgafb.c

1131

dst -= 64;

drivers/video/fbdev/tgafb.c

1134

__raw_writel(0xffff, dst);

drivers/video/fbdev/tgafb.c

1139

dst = tga_fb + dy * width * 4;

drivers/video/fbdev/tgafb.c

1144

__raw_writel(0xffff, dst);

drivers/video/fbdev/tgafb.c

1147

dst += 64;

drivers/video/fbdev/vga16fb.c

1032

char __iomem *dst = NULL;

drivers/video/fbdev/vga16fb.c

1081

dst = info->screen_base + (dx/8) + dy * info->fix.line_length;

drivers/video/fbdev/vga16fb.c

1086

writeb(0, dst);

drivers/video/fbdev/vga16fb.c

1087

dst++;

drivers/video/fbdev/vga16fb.c

1091

dst += line_ofs;

drivers/video/fbdev/vga16fb.c

1094

dst = info->screen_base + (dx/8) + width +

drivers/video/fbdev/vga16fb.c

1100

dst--;

drivers/video/fbdev/vga16fb.c

1103

writeb(0, dst);

drivers/video/fbdev/vga16fb.c

1106

dst -= line_ofs;

drivers/video/fbdev/vga16fb.c

1170

char __iomem *dst;

drivers/video/fbdev/vga16fb.c

1190

dst = where;

drivers/video/fbdev/vga16fb.c

1192

writeb(*cdat++, dst++);

drivers/video/fbdev/vga16fb.c

1205

dst = where;

drivers/video/fbdev/vga16fb.c

1207

rmw(dst);

drivers/video/fbdev/vga16fb.c

1212

rmw(dst++);

drivers/video/fbdev/vga16fb.c

1238

char __iomem *dst;

drivers/video/fbdev/vga16fb.c

1251

dst = where + x/8;

drivers/video/fbdev/vga16fb.c

1256

fb_readb(dst);

drivers/video/fbdev/vga16fb.c

1257

fb_writeb(0, dst);

drivers/video/fbdev/vga16fb.c

900

char __iomem *dst;

drivers/video/fbdev/vga16fb.c

925

dst = info->screen_base + (rect->dx/8) + rect->dy * info->fix.line_length;

drivers/video/fbdev/vga16fb.c

939

writeb(0, dst);

drivers/video/fbdev/vga16fb.c

940

dst++;

drivers/video/fbdev/vga16fb.c

942

dst += line_ofs;

drivers/video/fbdev/vga16fb.c

955

rmw(dst);

drivers/video/fbdev/vga16fb.c

956

dst++;

drivers/video/fbdev/vga16fb.c

958

dst += line_ofs;

drivers/video/fbdev/vt8623fb.c

148

u32 __iomem *dst;

drivers/video/fbdev/vt8623fb.c

158

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/vt8623fb.c

162

fb_writel(val, dst++);

drivers/video/fbdev/vt8623fb.c

174

u32 __iomem *dst;

drivers/video/fbdev/vt8623fb.c

181

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/vt8623fb.c

183

fb_writel(fg, dst++);

drivers/video/fbdev/vt8623fb.c

204

u32 __iomem *dst;

drivers/video/fbdev/vt8623fb.c

214

dst = (u32 __iomem *) dst1;

drivers/video/fbdev/vt8623fb.c

218

fb_writel(val, dst++);

drivers/watchdog/dw_wdt.c

425

struct dw_wdt_timeout tout, *dst;

drivers/watchdog/dw_wdt.c

447

dst = &dw_wdt->timeouts[tidx];

drivers/watchdog/dw_wdt.c

448

if (tout.sec > dst->sec || (tout.sec == dst->sec &&

drivers/watchdog/dw_wdt.c

449

tout.msec >= dst->msec))

drivers/watchdog/dw_wdt.c

452

swap(*dst, tout);

drivers/xen/pvcalls-front.c

170

uint8_t *src, *dst;

drivers/xen/pvcalls-front.c

203

dst = (uint8_t *)&bedata->rsp[req_id] +

drivers/xen/pvcalls-front.c

206

memcpy(dst, src, sizeof(*rsp) - sizeof(rsp->req_id));

drivers/xen/xen-acpi-processor.c

158

struct xen_processor_performance *dst)

drivers/xen/xen-acpi-processor.c

168

dst->shared_type = _pr->performance->shared_type;

drivers/xen/xen-acpi-processor.c

177

dst->shared_type = CPUFREQ_SHARED_TYPE_ALL;

drivers/xen/xen-acpi-processor.c

179

dst->shared_type = CPUFREQ_SHARED_TYPE_HW;

drivers/xen/xen-acpi-processor.c

181

dst->shared_type = CPUFREQ_SHARED_TYPE_ANY;

drivers/xen/xen-acpi-processor.c

184

memcpy(&(dst->domain_info), pdomain, sizeof(struct acpi_psd_package));

drivers/xen/xenbus/xenbus_comms.c

113

void *dst;

drivers/xen/xenbus/xenbus_comms.c

129

dst = get_output_chunk(cons, prod, intf->req, &avail);

drivers/xen/xenbus/xenbus_comms.c

135

memcpy(dst, data, avail);

fs/adfs/adfs.h

176

int adfs_dir_copyfrom(void *dst, struct adfs_dir *dir, unsigned int offset,

fs/adfs/dir.c

18

int adfs_dir_copyfrom(void *dst, struct adfs_dir *dir, unsigned int offset,

fs/adfs/dir.c

31

memcpy(dst, dir->bhs[index]->b_data + offset, remain);

fs/adfs/dir.c

32

dst += remain;

fs/adfs/dir.c

38

memcpy(dst, dir->bhs[index]->b_data + offset, len);

fs/aio.c

407

static int aio_migrate_folio(struct address_space *mapping, struct folio *dst,

fs/aio.c

445

folio_get(dst);

fs/aio.c

447

rc = folio_migrate_mapping(mapping, dst, src, 1);

fs/aio.c

449

folio_put(dst);

fs/aio.c

458

folio_copy(dst, src);

fs/aio.c

459

folio_migrate_flags(dst, src);

fs/aio.c

461

ctx->ring_folios[idx] = dst;

fs/binfmt_flat.c

182

static int decompress_exec(struct linux_binprm *bprm, loff_t fpos, char *dst,

fs/binfmt_flat.c

189

pr_debug("decompress_exec(offset=%llx,buf=%p,len=%lx)\n", fpos, dst, len);

fs/binfmt_flat.c

263

strm.next_out = dst;

fs/btrfs/block-rsv.c

161

struct btrfs_block_rsv *dst, u64 num_bytes,

fs/btrfs/block-rsv.c

170

btrfs_block_rsv_add_bytes(dst, num_bytes, update_size);

fs/btrfs/ctree.c

129

static inline void copy_leaf_items(const struct extent_buffer *dst,

fs/btrfs/ctree.c

133

copy_extent_buffer(dst, src, btrfs_item_nr_offset(dst, dst_item),

fs/btrfs/ctree.c

2704

struct extent_buffer *dst,

fs/btrfs/ctree.c

2714

dst_nritems = btrfs_header_nritems(dst);

fs/btrfs/ctree.c

2717

WARN_ON(btrfs_header_generation(dst) != trans->transid);

fs/btrfs/ctree.c

2741

if (unlikely(check_sibling_keys(dst, src))) {

fs/btrfs/ctree.c

2746

ret = btrfs_tree_mod_log_eb_copy(dst, src, dst_nritems, 0, push_items);

fs/btrfs/ctree.c

2751

copy_extent_buffer(dst, src,

fs/btrfs/ctree.c

2752

btrfs_node_key_ptr_offset(dst, dst_nritems),

fs/btrfs/ctree.c

2767

btrfs_set_header_nritems(dst, dst_nritems + push_items);

fs/btrfs/ctree.c

2769

btrfs_mark_buffer_dirty(trans, dst);

fs/btrfs/ctree.c

2784

struct extent_buffer *dst,

fs/btrfs/ctree.c

2795

WARN_ON(btrfs_header_generation(dst) != trans->transid);

fs/btrfs/ctree.c

2798

dst_nritems = btrfs_header_nritems(dst);

fs/btrfs/ctree.c

2815

if (unlikely(check_sibling_keys(src, dst))) {

fs/btrfs/ctree.c

2825

memmove_extent_buffer(dst, btrfs_node_key_ptr_offset(dst, push_items),

fs/btrfs/ctree.c

2826

btrfs_node_key_ptr_offset(dst, 0),

fs/btrfs/ctree.c

2830

ret = btrfs_tree_mod_log_eb_copy(dst, src, 0, src_nritems - push_items,

fs/btrfs/ctree.c

2836

copy_extent_buffer(dst, src,

fs/btrfs/ctree.c

2837

btrfs_node_key_ptr_offset(dst, 0),

fs/btrfs/ctree.c

2842

btrfs_set_header_nritems(dst, dst_nritems + push_items);

fs/btrfs/ctree.c

2845

btrfs_mark_buffer_dirty(trans, dst);

fs/btrfs/ctree.c

35

struct extent_buffer *dst,

fs/btrfs/ctree.c

89

static inline void copy_leaf_data(const struct extent_buffer *dst,

fs/btrfs/ctree.c

94

copy_extent_buffer(dst, src, btrfs_item_nr_offset(dst, 0) + dst_offset,

fs/btrfs/disk-io.c

459

struct folio *dst, struct folio *src, enum migrate_mode mode)

fs/btrfs/disk-io.c

474

return migrate_folio(mapping, dst, src, mode);

fs/btrfs/extent_io.c

3973

char *dst = (char *)dstv;

fs/btrfs/extent_io.c

3997

memcpy(dst, kaddr + offset, cur);

fs/btrfs/extent_io.c

3999

dst += cur;

fs/btrfs/extent_io.c

4013

char __user *dst = (char __user *)dstv;

fs/btrfs/extent_io.c

4033

if (copy_to_user_nofault(dst, kaddr + offset, cur)) {

fs/btrfs/extent_io.c

4038

dst += cur;

fs/btrfs/extent_io.c

4197

void copy_extent_buffer_full(const struct extent_buffer *dst,

fs/btrfs/extent_io.c

4203

ASSERT(dst->len == src->len);

fs/btrfs/extent_io.c

4211

write_extent_buffer(dst, addr, cur, cur_len);

fs/btrfs/extent_io.c

4217

void copy_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/extent_io.c

4222

const int unit_size = dst->folio_size;

fs/btrfs/extent_io.c

4223

u64 dst_len = dst->len;

fs/btrfs/extent_io.c

4227

unsigned long i = get_eb_folio_index(dst, dst_offset);

fs/btrfs/extent_io.c

4229

if (check_eb_range(dst, dst_offset, len) ||

fs/btrfs/extent_io.c

4235

offset = get_eb_offset_in_folio(dst, dst_offset);

fs/btrfs/extent_io.c

4238

assert_eb_folio_uptodate(dst, i);

fs/btrfs/extent_io.c

4242

kaddr = folio_address(dst->folios[i]);

fs/btrfs/extent_io.c

4385

static inline bool areas_overlap(unsigned long src, unsigned long dst, unsigned long len)

fs/btrfs/extent_io.c

4387

unsigned long distance = (src > dst) ? src - dst : dst - src;

fs/btrfs/extent_io.c

4391

void memcpy_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/extent_io.c

4395

const int unit_size = dst->folio_size;

fs/btrfs/extent_io.c

4398

if (check_eb_range(dst, dst_offset, len) ||

fs/btrfs/extent_io.c

4399

check_eb_range(dst, src_offset, len))

fs/btrfs/extent_io.c

4402

if (dst->addr) {

fs/btrfs/extent_io.c

4406

memmove(dst->addr + dst_offset, dst->addr + src_offset, len);

fs/btrfs/extent_io.c

4408

memcpy(dst->addr + dst_offset, dst->addr + src_offset, len);

fs/btrfs/extent_io.c

4414

unsigned long folio_index = get_eb_folio_index(dst, cur_src);

fs/btrfs/extent_io.c

4415

unsigned long folio_off = get_eb_offset_in_folio(dst, cur_src);

fs/btrfs/extent_io.c

4418

void *src_addr = folio_address(dst->folios[folio_index]) + folio_off;

fs/btrfs/extent_io.c

4422

__write_extent_buffer(dst, src_addr, dst_offset + cur_off, cur_len,

fs/btrfs/extent_io.c

4428

void memmove_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/extent_io.c

4435

if (check_eb_range(dst, dst_offset, len) ||

fs/btrfs/extent_io.c

4436

check_eb_range(dst, src_offset, len))

fs/btrfs/extent_io.c

4440

memcpy_extent_buffer(dst, dst_offset, src_offset, len);

fs/btrfs/extent_io.c

4444

if (dst->addr) {

fs/btrfs/extent_io.c

4445

memmove(dst->addr + dst_offset, dst->addr + src_offset, len);

fs/btrfs/extent_io.c

4457

src_i = get_eb_folio_index(dst, src_end);

fs/btrfs/extent_io.c

4459

dst_off_in_folio = get_eb_offset_in_folio(dst, dst_end);

fs/btrfs/extent_io.c

4460

src_off_in_folio = get_eb_offset_in_folio(dst, src_end);

fs/btrfs/extent_io.c

4465

src_addr = folio_address(dst->folios[src_i]) + src_off_in_folio -

fs/btrfs/extent_io.c

4470

__write_extent_buffer(dst, src_addr, dst_end - cur + 1, cur,

fs/btrfs/extent_io.h

308

void read_extent_buffer(const struct extent_buffer *eb, void *dst,

fs/btrfs/extent_io.h

312

void __user *dst, unsigned long start,

fs/btrfs/extent_io.h

332

void copy_extent_buffer_full(const struct extent_buffer *dst,

fs/btrfs/extent_io.h

334

void copy_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/extent_io.h

338

void memcpy_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/extent_io.h

341

void memmove_extent_buffer(const struct extent_buffer *dst,

fs/btrfs/file-item.c

279

u64 len, u8 *dst)

fs/btrfs/file-item.c

333

read_extent_buffer(path->nodes[0], dst, (unsigned long)item,

fs/btrfs/inode.c

7653

struct folio *dst, struct folio *src,

fs/btrfs/inode.c

7656

int ret = filemap_migrate_folio(mapping, dst, src, mode);

fs/btrfs/inode.c

7663

folio_set_ordered(dst);

fs/btrfs/ioctl.c

3632

ret = btrfs_add_qgroup_relation(trans, sa->src, sa->dst, prealloc);

fs/btrfs/ioctl.c

3635

ret = btrfs_del_qgroup_relation(trans, sa->src, sa->dst);

fs/btrfs/qgroup.c

1521

u64 src, u64 dst, int sign)

fs/btrfs/qgroup.c

1530

ret = __qgroup_excl_accounting(fs_info, dst, qgroup, sign);

fs/btrfs/qgroup.c

1545

int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, u64 dst,

fs/btrfs/qgroup.c

1557

if (btrfs_qgroup_level(src) >= btrfs_qgroup_level(dst)) {

fs/btrfs/qgroup.c

1568

parent = find_qgroup_rb(fs_info, dst);

fs/btrfs/qgroup.c

1582

ret = add_qgroup_relation_item(trans, src, dst);

fs/btrfs/qgroup.c

1586

ret = add_qgroup_relation_item(trans, dst, src);

fs/btrfs/qgroup.c

1588

del_qgroup_relation_item(trans, src, dst);

fs/btrfs/qgroup.c

1599

ret = quick_update_accounting(fs_info, src, dst, 1);

fs/btrfs/qgroup.c

1609

u64 dst)

fs/btrfs/qgroup.c

1623

parent = find_qgroup_rb(fs_info, dst);

fs/btrfs/qgroup.c

1640

ret = del_qgroup_relation_item(trans, src, dst);

fs/btrfs/qgroup.c

1643

ret2 = del_qgroup_relation_item(trans, dst, src);

fs/btrfs/qgroup.c

1653

del_relation_rb(fs_info, src, dst);

fs/btrfs/qgroup.c

1654

ret = quick_update_accounting(fs_info, src, dst, -1);

fs/btrfs/qgroup.c

1664

u64 dst)

fs/btrfs/qgroup.c

1670

ret = __del_qgroup_relation(trans, src, dst);

fs/btrfs/qgroup.c

3524

struct btrfs_qgroup *dst;

fs/btrfs/qgroup.c

3530

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3532

if (!src || !dst) {

fs/btrfs/qgroup.c

3537

dst->rfer = src->rfer - level_size;

fs/btrfs/qgroup.c

3538

dst->rfer_cmpr = src->rfer_cmpr - level_size;

fs/btrfs/qgroup.c

3545

struct btrfs_qgroup *dst;

fs/btrfs/qgroup.c

3551

dst = find_qgroup_rb(fs_info, i_qgroups[1]);

fs/btrfs/qgroup.c

3553

if (!src || !dst) {

fs/btrfs/qgroup.c

3558

dst->excl = src->excl + level_size;

fs/btrfs/qgroup.c

3559

dst->excl_cmpr = src->excl_cmpr + level_size;

fs/btrfs/qgroup.c

695

u64 dst)

fs/btrfs/qgroup.c

707

key.offset = dst;

fs/btrfs/qgroup.c

713

u64 dst)

fs/btrfs/qgroup.c

726

key.offset = dst;

fs/btrfs/qgroup.h

341

int btrfs_add_qgroup_relation(struct btrfs_trans_handle *trans, u64 src, u64 dst,

fs/btrfs/qgroup.h

344

u64 dst);

fs/btrfs/raid56.c

238

phys_addr_t dst = rbio->stripe_paddrs[index];

fs/btrfs/raid56.c

241

ASSERT(dst != INVALID_PADDR);

fs/btrfs/raid56.c

244

memcpy_page(phys_to_page(dst), offset_in_page(dst),

fs/btrfs/reflink.c

633

struct btrfs_inode *dst, u64 dst_loff)

fs/btrfs/reflink.c

647

btrfs_lock_extent(&dst->io_tree, dst_loff, end, &cached_state);

fs/btrfs/reflink.c

648

ret = btrfs_clone(&src->vfs_inode, &dst->vfs_inode, loff, len,

fs/btrfs/reflink.c

650

btrfs_unlock_extent(&dst->io_tree, dst_loff, end, &cached_state);

fs/btrfs/reflink.c

658

struct inode *dst, u64 dst_loff)

fs/btrfs/reflink.c

662

struct btrfs_root *root_dst = BTRFS_I(dst)->root;

fs/btrfs/reflink.c

681

BTRFS_I(dst), dst_loff);

fs/btrfs/reflink.c

691

BTRFS_I(dst), dst_loff);

fs/btrfs/subpage.c

665

#define GET_SUBPAGE_BITMAP(fs_info, folio, name, dst) \

fs/btrfs/subpage.c

671

*dst = bitmap_read(__bfs->bitmaps, \

fs/btrfs/tree-log.c

4032

struct extent_buffer *dst;

fs/btrfs/tree-log.c

4077

dst = dst_path->nodes[0];

fs/btrfs/tree-log.c

4088

dst_offset = btrfs_item_ptr_offset(dst, dst_path->slots[0] + count - 1);

fs/btrfs/tree-log.c

4090

copy_extent_buffer(dst, src, dst_offset, src_offset, batch.total_data_size);

fs/btrfs/tree-mod-log.c

574

int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,

fs/btrfs/tree-mod-log.c

580

struct btrfs_fs_info *fs_info = dst->fs_info;

fs/btrfs/tree-mod-log.c

589

u32 dst_move_nr_items = btrfs_header_nritems(dst) - dst_offset;

fs/btrfs/tree-mod-log.c

595

if (btrfs_header_level(dst) == 0 && btrfs_header_level(src) == 0)

fs/btrfs/tree-mod-log.c

605

dst_move_tm = tree_mod_log_alloc_move(dst, dst_offset + nr_items,

fs/btrfs/tree-mod-log.c

634

tm_list_add[i] = alloc_tree_mod_elem(dst, i + dst_offset,

fs/btrfs/tree-mod-log.h

48

int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,

fs/btrfs/volumes.c

6684

u64 *length, struct btrfs_io_stripe *dst,

fs/btrfs/volumes.c

6688

dst->dev = map->stripes[io_geom->stripe_index].dev;

fs/btrfs/volumes.c

6693

io_geom->stripe_index, dst);

fs/btrfs/volumes.c

6695

dst->physical = map->stripes[io_geom->stripe_index].physical +

fs/btrfs/volumes.c

7048

struct btrfs_io_stripe *dst = &bioc->stripes[i];

fs/btrfs/volumes.c

7052

dst->dev = map->stripes[stripe_index].dev;

fs/btrfs/volumes.c

7053

dst->physical =

fs/btrfs/zstd.c

447

workspace->out_buf.dst = folio_address(out_folio);

fs/btrfs/zstd.c

490

workspace->out_buf.dst = folio_address(out_folio);

fs/btrfs/zstd.c

563

workspace->out_buf.dst = folio_address(out_folio);

fs/btrfs/zstd.c

621

workspace->out_buf.dst = workspace->buf;

fs/btrfs/zstd.c

644

ret = btrfs_decompress_buf2page(workspace->out_buf.dst,

fs/btrfs/zstd.c

707

workspace->out_buf.dst = workspace->buf;

fs/btrfs/zstd.c

726

memcpy_to_folio(dest_folio, dest_pgoff, workspace->out_buf.dst, to_copy);

fs/ceph/file.c

483

cache_file_layout(struct inode *dst, struct inode *src)

fs/ceph/file.c

485

struct ceph_inode_info *cdst = ceph_inode(dst);

fs/ceph/locks.c

34

static void ceph_fl_copy_lock(struct file_lock *dst, struct file_lock *src)

fs/ceph/locks.c

36

struct inode *inode = file_inode(dst->c.flc_file);

fs/ceph/locks.c

38

dst->fl_u.ceph.inode = igrab(inode);

fs/ceph/snap.c

490

static int dup_array(u64 **dst, __le64 *src, u32 num)

fs/ceph/snap.c

494

kfree(*dst);

fs/ceph/snap.c

496

*dst = kcalloc(num, sizeof(u64), GFP_NOFS);

fs/ceph/snap.c

497

if (!*dst)

fs/ceph/snap.c

500

(*dst)[i] = get_unaligned_le64(src + i);

fs/ceph/snap.c

502

*dst = NULL;

fs/coredump.c

1319

static struct page *dump_page_copy(struct page *src, struct page *dst)

fs/coredump.c

1322

size_t left = copy_mc_to_kernel(page_address(dst), buf, PAGE_SIZE);

fs/coredump.c

1324

return left ? NULL : dst;

fs/coredump.c

1332

static inline struct page *dump_page_copy(struct page *src, struct page *dst)

fs/cramfs/internal.h

2

int cramfs_uncompress_block(void *dst, int dstlen, void *src, int srclen);

fs/cramfs/uncompress.c

31

int cramfs_uncompress_block(void *dst, int dstlen, void *src, int srclen)

fs/cramfs/uncompress.c

38

stream.next_out = dst;

fs/cramfs/uncompress.c

55

pr_err("%p(%d)->%p(%d)\n", src, srclen, dst, dstlen);

fs/crypto/crypto.c

118

struct scatterlist dst, src;

fs/crypto/crypto.c

131

sg_init_table(&dst, 1);

fs/crypto/crypto.c

132

sg_set_page(&dst, dest_page, len, offs);

fs/crypto/crypto.c

135

skcipher_request_set_crypt(req, &src, &dst, len, &iv);

fs/crypto/keyring.c

48

static void move_master_key_secret(struct fscrypt_master_key_secret *dst,

fs/crypto/keyring.c

51

memcpy(dst, src, sizeof(*dst));

fs/d_path.c

48

static bool prepend_copy(void *dst, const void *src, int len)

fs/d_path.c

50

if (unlikely(copy_from_kernel_nofault(dst, src, len))) {

fs/d_path.c

51

memset(dst, 'x', len);

fs/dax.c

2205

struct inode *dst, loff_t dstoff, loff_t len, bool *same,

fs/dax.c

2215

.inode = dst,

fs/ecryptfs/crypto.c

103

md5(src, crypt_stat->iv_bytes + 16, dst);

fs/ecryptfs/crypto.c

104

memcpy(iv, dst, crypt_stat->iv_bytes);

fs/ecryptfs/crypto.c

1646

static void ecryptfs_encode_for_filename(unsigned char *dst, size_t *dst_size,

fs/ecryptfs/crypto.c

1675

if (!dst)

fs/ecryptfs/crypto.c

1691

dst[dst_offset++] = portable_filename_chars[dst_block[0]];

fs/ecryptfs/crypto.c

1692

dst[dst_offset++] = portable_filename_chars[dst_block[1]];

fs/ecryptfs/crypto.c

1693

dst[dst_offset++] = portable_filename_chars[dst_block[2]];

fs/ecryptfs/crypto.c

1694

dst[dst_offset++] = portable_filename_chars[dst_block[3]];

fs/ecryptfs/crypto.c

1722

ecryptfs_decode_from_filename(unsigned char *dst, size_t *dst_size,

fs/ecryptfs/crypto.c

1729

if (!dst) {

fs/ecryptfs/crypto.c

1739

dst[dst_byte_offset] = (src_byte << 2);

fs/ecryptfs/crypto.c

1743

dst[dst_byte_offset++] |= (src_byte >> 4);

fs/ecryptfs/crypto.c

1744

dst[dst_byte_offset] = ((src_byte & 0xF)

fs/ecryptfs/crypto.c

1749

dst[dst_byte_offset++] |= (src_byte >> 2);

fs/ecryptfs/crypto.c

1750

dst[dst_byte_offset] = (src_byte << 6);

fs/ecryptfs/crypto.c

1754

dst[dst_byte_offset++] |= (src_byte);

fs/ecryptfs/crypto.c

39

void ecryptfs_from_hex(char *dst, char *src, int dst_size)

fs/ecryptfs/crypto.c

47

dst[x] = (unsigned char)simple_strtol(tmp, NULL, 16);

fs/ecryptfs/crypto.c

552

char dst[MD5_DIGEST_SIZE];

fs/ecryptfs/crypto.c

563

md5(crypt_stat->key, crypt_stat->key_size, dst);

fs/ecryptfs/crypto.c

564

memcpy(crypt_stat->root_iv, dst, crypt_stat->iv_bytes);

fs/ecryptfs/crypto.c

85

char dst[MD5_DIGEST_SIZE];

fs/ecryptfs/ecryptfs_kernel.h

44

ecryptfs_to_hex(char *dst, char *src, size_t src_size)

fs/ecryptfs/ecryptfs_kernel.h

46

char *end = bin2hex(dst, src, src_size);

fs/ecryptfs/ecryptfs_kernel.h

50

extern void ecryptfs_from_hex(char *dst, char *src, int dst_size);

fs/efs/inode.c

32

static inline void extent_copy(efs_extent *src, efs_extent *dst) {

fs/efs/inode.c

39

dst->cooked.ex_magic = (unsigned int) src->raw[0];

fs/efs/inode.c

40

dst->cooked.ex_bn = ((unsigned int) src->raw[1] << 16) |

fs/efs/inode.c

43

dst->cooked.ex_length = (unsigned int) src->raw[4];

fs/efs/inode.c

44

dst->cooked.ex_offset = ((unsigned int) src->raw[5] << 16) |

fs/erofs/compress.h

74

void **dst, void **src, struct page **pgpl);

fs/erofs/decompressor.c

202

u8 *dst)

fs/erofs/decompressor.c

222

src = z_erofs_lz4_handle_overlap(rq, headpage, dst, &inputmargin,

fs/erofs/decompressor.c

227

out = dst + rq->pageofs_out;

fs/erofs/decompressor.c

259

void *dst;

fs/erofs/decompressor.c

265

dst = kmap_local_page(*rq->out);

fs/erofs/decompressor.c

273

dst = page_address(*rq->out);

fs/erofs/decompressor.c

276

dst = erofs_vm_map_ram(rq->out, rq->outpages);

fs/erofs/decompressor.c

277

if (!dst)

fs/erofs/decompressor.c

282

reason = __z_erofs_lz4_decompress(rq, dst);

fs/erofs/decompressor.c

284

kunmap_local(dst);

fs/erofs/decompressor.c

286

vm_unmap_ram(dst, rq->outpages);

fs/erofs/decompressor.c

343

void **dst, void **src, struct page **pgpl)

fs/erofs/decompressor.c

368

*dst = dctx->kout + rq->pageofs_out;

fs/erofs/decompressor.c

370

*dst = dctx->kout = NULL;

fs/erofs/decompressor.c

388

j = (u8 *)*dst - dctx->kout;

fs/erofs/decompressor.c

390

*dst = dctx->kout + j;

fs/erofs/decompressor_zstd.c

178

reason = z_erofs_stream_switch_bufs(&dctx, &out_buf.dst,

fs/erofs/zdata.c

1160

void *dst, *src;

fs/erofs/zdata.c

1166

dst = kmap_local_page(bvi->bvec.page);

fs/erofs/zdata.c

1182

memcpy(dst + cur, src + scur, len);

fs/erofs/zdata.c

1186

kunmap_local(dst);

fs/ext4/crypto.c

10

static void ext4_fname_from_fscrypt_name(struct ext4_filename *dst,

fs/ext4/crypto.c

13

memset(dst, 0, sizeof(*dst));

fs/ext4/crypto.c

15

dst->usr_fname = src->usr_fname;

fs/ext4/crypto.c

16

dst->disk_name = src->disk_name;

fs/ext4/crypto.c

17

dst->hinfo.hash = src->hash;

fs/ext4/crypto.c

18

dst->hinfo.minor_hash = src->minor_hash;

fs/ext4/crypto.c

19

dst->crypto_buf = src->crypto_buf;

fs/ext4/fast_commit.c

704

u8 *dst;

fs/ext4/fast_commit.c

719

dst = sbi->s_fc_bh->b_data + off;

fs/ext4/fast_commit.c

728

return dst;

fs/ext4/fast_commit.c

738

memcpy(dst, &tl, EXT4_FC_TAG_BASE_LEN);

fs/ext4/fast_commit.c

739

memset(dst + EXT4_FC_TAG_BASE_LEN, 0, remaining);

fs/ext4/fast_commit.c

766

u8 *dst;

fs/ext4/fast_commit.c

772

dst = ext4_fc_reserve_space(sb, EXT4_FC_TAG_BASE_LEN + sizeof(tail), &crc);

fs/ext4/fast_commit.c

773

if (!dst)

fs/ext4/fast_commit.c

782

memcpy(dst, &tl, EXT4_FC_TAG_BASE_LEN);

fs/ext4/fast_commit.c

783

dst += EXT4_FC_TAG_BASE_LEN;

fs/ext4/fast_commit.c

785

memcpy(dst, &tail.fc_tid, sizeof(tail.fc_tid));

fs/ext4/fast_commit.c

786

dst += sizeof(tail.fc_tid);

fs/ext4/fast_commit.c

788

dst - (u8 *)sbi->s_fc_bh->b_data);

fs/ext4/fast_commit.c

790

memcpy(dst, &tail.fc_crc, sizeof(tail.fc_crc));

fs/ext4/fast_commit.c

791

dst += sizeof(tail.fc_crc);

fs/ext4/fast_commit.c

792

memset(dst, 0, bsize - off); /* Don't leak uninitialized memory. */

fs/ext4/fast_commit.c

807

u8 *dst;

fs/ext4/fast_commit.c

809

dst = ext4_fc_reserve_space(sb, EXT4_FC_TAG_BASE_LEN + len, crc);

fs/ext4/fast_commit.c

810

if (!dst)

fs/ext4/fast_commit.c

816

memcpy(dst, &tl, EXT4_FC_TAG_BASE_LEN);

fs/ext4/fast_commit.c

817

memcpy(dst + EXT4_FC_TAG_BASE_LEN, val, len);

fs/ext4/fast_commit.c

829

u8 *dst = ext4_fc_reserve_space(sb,

fs/ext4/fast_commit.c

832

if (!dst)

fs/ext4/fast_commit.c

839

memcpy(dst, &tl, EXT4_FC_TAG_BASE_LEN);

fs/ext4/fast_commit.c

840

dst += EXT4_FC_TAG_BASE_LEN;

fs/ext4/fast_commit.c

841

memcpy(dst, &fcd, sizeof(fcd));

fs/ext4/fast_commit.c

842

dst += sizeof(fcd);

fs/ext4/fast_commit.c

843

memcpy(dst, fc_dentry->fcd_name.name.name, dlen);

fs/ext4/fast_commit.c

860

u8 *dst;

fs/ext4/fast_commit.c

876

dst = ext4_fc_reserve_space(inode->i_sb,

fs/ext4/fast_commit.c

878

if (!dst)

fs/ext4/fast_commit.c

881

memcpy(dst, &tl, EXT4_FC_TAG_BASE_LEN);

fs/ext4/fast_commit.c

882

dst += EXT4_FC_TAG_BASE_LEN;

fs/ext4/fast_commit.c

883

memcpy(dst, &fc_inode, sizeof(fc_inode));

fs/ext4/fast_commit.c

884

dst += sizeof(fc_inode);

fs/ext4/fast_commit.c

885

memcpy(dst, (u8 *)ext4_raw_inode(&iloc), inode_len);

fs/f2fs/compress.c

383

outbuf.dst = cc->cbuf->cdata;

fs/f2fs/compress.c

460

outbuf.dst = dic->rbuf;

fs/f2fs/file.c

1417

pgoff_t src, pgoff_t dst, pgoff_t len, bool full)

fs/f2fs/file.c

1436

ret = f2fs_get_dnode_of_data(&dn, dst + i, ALLOC_NODE);

fs/f2fs/file.c

1465

new_size = (loff_t)(dst + i) << PAGE_SHIFT;

fs/f2fs/file.c

1478

fdst = f2fs_get_new_data_folio(dst_inode, NULL, dst + i,

fs/f2fs/file.c

1504

struct inode *dst_inode, pgoff_t src, pgoff_t dst,

fs/f2fs/file.c

1535

do_replace, src, dst, olen, full);

fs/f2fs/file.c

1540

dst += olen;

fs/f2fs/file.c

3102

struct inode *dst = file_inode(file_out);

fs/f2fs/file.c

3110

src->i_sb != dst->i_sb)

fs/f2fs/file.c

3116

if (!S_ISREG(src->i_mode) || !S_ISREG(dst->i_mode))

fs/f2fs/file.c

3119

if (IS_ENCRYPTED(src) || IS_ENCRYPTED(dst))

fs/f2fs/file.c

3125

if (src == dst) {

fs/f2fs/file.c

3133

if (src != dst) {

fs/f2fs/file.c

3135

if (!inode_trylock(dst))

fs/f2fs/file.c

3139

if (f2fs_compressed_file(src) || f2fs_compressed_file(dst) ||

fs/f2fs/file.c

3140

f2fs_is_pinned_file(src) || f2fs_is_pinned_file(dst)) {

fs/f2fs/file.c

3145

if (f2fs_is_atomic_file(src) || f2fs_is_atomic_file(dst)) {

fs/f2fs/file.c

3162

dst_osize = dst->i_size;

fs/f2fs/file.c

3163

if (pos_out + olen > dst->i_size)

fs/f2fs/file.c

3176

ret = f2fs_convert_inline_inode(dst);

fs/f2fs/file.c

3186

ret = filemap_write_and_wait_range(dst->i_mapping,

fs/f2fs/file.c

3194

if (src != dst) {

fs/f2fs/file.c

3196

if (!f2fs_down_write_trylock(&F2FS_I(dst)->i_gc_rwsem[WRITE]))

fs/f2fs/file.c

3201

ret = __exchange_data_block(src, dst, F2FS_BYTES_TO_BLK(pos_in),

fs/f2fs/file.c

3207

f2fs_i_size_write(dst, dst_max_i_size);

fs/f2fs/file.c

3208

else if (dst_osize != dst->i_size)

fs/f2fs/file.c

3209

f2fs_i_size_write(dst, dst_osize);

fs/f2fs/file.c

3213

if (src != dst)

fs/f2fs/file.c

3214

f2fs_up_write(&F2FS_I(dst)->i_gc_rwsem[WRITE]);

fs/f2fs/file.c

3222

if (src != dst) {

fs/f2fs/file.c

3223

inode_set_mtime_to_ts(dst, inode_set_ctime_current(dst));

fs/f2fs/file.c

3224

f2fs_mark_inode_dirty_sync(dst, false);

fs/f2fs/file.c

3229

if (src != dst)

fs/f2fs/file.c

3230

inode_unlock(dst);

fs/f2fs/file.c

3245

CLASS(fd, dst)(range->dst_fd);

fs/f2fs/file.c

3246

if (fd_empty(dst))

fs/f2fs/file.c

3249

if (!(fd_file(dst)->f_mode & FMODE_WRITE))

fs/f2fs/file.c

3256

err = f2fs_move_file_range(filp, range->pos_in, fd_file(dst),

fs/f2fs/inline.c

417

struct f2fs_dentry_ptr src, dst;

fs/f2fs/inline.c

452

make_dentry_ptr_block(dir, &dst, dentry_blk);

fs/f2fs/inline.c

455

memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);

fs/f2fs/inline.c

456

memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);

fs/f2fs/inline.c

457

memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);

fs/f2fs/node.c

2893

struct f2fs_inode *src, *dst;

fs/f2fs/node.c

2921

dst = F2FS_INODE(ifolio);

fs/f2fs/node.c

2923

memcpy(dst, src, offsetof(struct f2fs_inode, i_ext));

fs/f2fs/node.c

2924

dst->i_size = 0;

fs/f2fs/node.c

2925

dst->i_blocks = cpu_to_le64(1);

fs/f2fs/node.c

2926

dst->i_links = cpu_to_le32(1);

fs/f2fs/node.c

2927

dst->i_xattr_nid = 0;

fs/f2fs/node.c

2928

dst->i_inline = src->i_inline & (F2FS_INLINE_XATTR | F2FS_EXTRA_ATTR);

fs/f2fs/node.c

2929

if (dst->i_inline & F2FS_EXTRA_ATTR) {

fs/f2fs/node.c

2930

dst->i_extra_isize = src->i_extra_isize;

fs/f2fs/node.c

2935

dst->i_inline_xattr_size = src->i_inline_xattr_size;

fs/f2fs/node.c

2940

dst->i_projid = src->i_projid;

fs/f2fs/node.c

2945

dst->i_crtime = src->i_crtime;

fs/f2fs/node.c

2946

dst->i_crtime_nsec = src->i_crtime_nsec;

fs/f2fs/node.h

289

static inline void copy_node_footer(const struct folio *dst,

fs/f2fs/node.h

293

struct f2fs_node *dst_rn = F2FS_NODE(dst);

fs/f2fs/node.h

82

static inline void copy_node_info(struct node_info *dst,

fs/f2fs/node.h

85

dst->nid = src->nid;

fs/f2fs/node.h

86

dst->ino = src->ino;

fs/f2fs/node.h

87

dst->blk_addr = src->blk_addr;

fs/f2fs/node.h

88

dst->version = src->version;

fs/f2fs/segment.c

2740

struct f2fs_summary_block *dst;

fs/f2fs/segment.c

2742

dst = folio_address(folio);

fs/f2fs/segment.c

2743

memset(dst, 0, PAGE_SIZE);

fs/f2fs/segment.c

2748

memcpy(sum_journal(sbi, dst), curseg->journal, sbi->sum_journal_size);

fs/f2fs/segment.c

2751

memcpy(sum_entries(dst), sum_entries(src), sbi->sum_entry_size);

fs/f2fs/segment.c

2752

memcpy(sum_footer(sbi, dst), sum_footer(sbi, src), SUM_FOOTER_SIZE);

fs/fat/fat.h

276

static inline void fat16_towchar(wchar_t *dst, const __u8 *src, size_t len)

fs/fat/fat.h

280

*dst++ = src[0] | (src[1] << 8);

fs/fat/fat.h

284

memcpy(dst, src, len * 2);

fs/fat/fat.h

303

static inline void fatwchar_to16(__u8 *dst, const wchar_t *src, size_t len)

fs/fat/fat.h

307

dst[0] = *src & 0x00FF;

fs/fat/fat.h

308

dst[1] = (*src & 0xFF00) >> 8;

fs/fat/fat.h

309

dst += 2;

fs/fat/fat.h

313

memcpy(dst, src, len * 2);

fs/fat/namei_vfat.c

1056

static void vfat_move_nlink(struct inode *src, struct inode *dst)

fs/fat/namei_vfat.c

1059

inc_nlink(dst);

fs/fcntl.c

312

uid_t __user *dst = (void __user *)arg;

fs/fcntl.c

324

err = put_user(src[0], &dst[0]);

fs/fcntl.c

325

err |= put_user(src[1], &dst[1]);

fs/fcntl.c

657

#define copy_flock_fields(dst, src) \

fs/fcntl.c

658

(dst)->l_type = (src)->l_type; \

fs/fcntl.c

659

(dst)->l_whence = (src)->l_whence; \

fs/fcntl.c

660

(dst)->l_start = (src)->l_start; \

fs/fcntl.c

661

(dst)->l_len = (src)->l_len; \

fs/fcntl.c

662

(dst)->l_pid = (src)->l_pid;

fs/fuse/ioctl.c

109

dst[i].iov_base = (void __user *) (unsigned long) fiov[i].base;

fs/fuse/ioctl.c

110

dst[i].iov_len = (size_t) fiov[i].len;

fs/fuse/ioctl.c

114

(ptr_to_compat(dst[i].iov_base) != fiov[i].base ||

fs/fuse/ioctl.c

115

(compat_size_t) dst[i].iov_len != fiov[i].len))

fs/fuse/ioctl.c

41

static int fuse_copy_ioctl_iovec_old(struct iovec *dst, void *src,

fs/fuse/ioctl.c

59

dst[i].iov_base = compat_ptr(ciov[i].iov_base);

fs/fuse/ioctl.c

60

dst[i].iov_len = ciov[i].iov_len;

fs/fuse/ioctl.c

69

memcpy(dst, src, transferred);

fs/fuse/ioctl.c

88

static int fuse_copy_ioctl_iovec(struct fuse_conn *fc, struct iovec *dst,

fs/fuse/ioctl.c

96

return fuse_copy_ioctl_iovec_old(dst, src, transferred,

fs/hfs/bnode.c

198

void hfs_bnode_copy(struct hfs_bnode *dst_node, u32 dst,

fs/hfs/bnode.c

203

hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);

fs/hfs/bnode.c

208

len = check_and_correct_requested_length(dst_node, dst, len);

fs/hfs/bnode.c

211

dst += dst_node->page_offset;

fs/hfs/bnode.c

215

memcpy_page(dst_page, dst, src_page, src, len);

fs/hfs/bnode.c

219

void hfs_bnode_move(struct hfs_bnode *node, u32 dst, u32 src, u32 len)

fs/hfs/bnode.c

224

hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);

fs/hfs/bnode.c

229

len = check_and_correct_requested_length(node, dst, len);

fs/hfs/bnode.c

232

dst += node->page_offset;

fs/hfs/bnode.c

235

memmove(ptr + dst, ptr + src, len);

fs/hfs/brec.c

182

int src, dst, len;

fs/hfs/brec.c

227

dst = fd->keyoffset;

fs/hfs/brec.c

231

hfs_bnode_move(node, dst, src, len);

fs/hfs/brec.c

233

src = dst + len;

fs/hfs/btree.h

106

extern void hfs_bnode_copy(struct hfs_bnode *dst_node, u32 dst,

fs/hfs/btree.h

108

extern void hfs_bnode_move(struct hfs_bnode *node, u32 dst, u32 src, u32 len);

fs/hfs/trans.c

102

char *dst;

fs/hfs/trans.c

107

dst = out->name;

fs/hfs/trans.c

123

size = nls_disk->uni2char(ch, dst, dstlen);

fs/hfs/trans.c

127

*dst = '?';

fs/hfs/trans.c

130

dst += size;

fs/hfs/trans.c

133

*dst++ = ch > 0xff ? '?' : ch;

fs/hfs/trans.c

143

*dst++ = (ch = *src++) == ':' ? '/' : ch;

fs/hfs/trans.c

146

out->len = dst - (char *)out->name;

fs/hfs/trans.c

149

*dst++ = 0;

fs/hfs/trans.c

38

char *dst;

fs/hfs/trans.c

45

dst = out;

fs/hfs/trans.c

65

size = nls_io->uni2char(ch, dst, dstlen);

fs/hfs/trans.c

69

*dst = '?';

fs/hfs/trans.c

72

dst += size;

fs/hfs/trans.c

79

*dst++ = (ch = *src++) == '/' ? ':' : ch;

fs/hfs/trans.c

82

return dst - out;

fs/hfsplus/bnode.c

170

void hfs_bnode_copy(struct hfs_bnode *dst_node, u32 dst,

fs/hfsplus/bnode.c

176

hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);

fs/hfsplus/bnode.c

181

len = check_and_correct_requested_length(dst_node, dst, len);

fs/hfsplus/bnode.c

184

dst += dst_node->page_offset;

fs/hfsplus/bnode.c

187

dst_page = dst_node->page + (dst >> PAGE_SHIFT);

fs/hfsplus/bnode.c

188

dst &= ~PAGE_MASK;

fs/hfsplus/bnode.c

190

if (src == dst) {

fs/hfsplus/bnode.c

204

dst_ptr = kmap_local_page(*dst_page) + dst;

fs/hfsplus/bnode.c

206

if (PAGE_SIZE - src < PAGE_SIZE - dst) {

fs/hfsplus/bnode.c

209

dst += l;

fs/hfsplus/bnode.c

211

l = PAGE_SIZE - dst;

fs/hfsplus/bnode.c

213

dst = 0;

fs/hfsplus/bnode.c

220

if (!dst)

fs/hfsplus/bnode.c

228

void hfs_bnode_move(struct hfs_bnode *node, u32 dst, u32 src, u32 len)

fs/hfsplus/bnode.c

234

hfs_dbg("dst %u, src %u, len %u\n", dst, src, len);

fs/hfsplus/bnode.c

239

len = check_and_correct_requested_length(node, dst, len);

fs/hfsplus/bnode.c

242

dst += node->page_offset;

fs/hfsplus/bnode.c

243

if (dst > src) {

fs/hfsplus/bnode.c

247

dst += len - 1;

fs/hfsplus/bnode.c

248

dst_page = node->page + (dst >> PAGE_SHIFT);

fs/hfsplus/bnode.c

249

dst = (dst & ~PAGE_MASK) + 1;

fs/hfsplus/bnode.c

251

if (src == dst) {

fs/hfsplus/bnode.c

273

dst_ptr = kmap_local_page(*dst_page) + dst;

fs/hfsplus/bnode.c

275

if (src < dst) {

fs/hfsplus/bnode.c

278

dst -= l;

fs/hfsplus/bnode.c

280

l = dst;

fs/hfsplus/bnode.c

282

dst = PAGE_SIZE;

fs/hfsplus/bnode.c

289

if (dst == PAGE_SIZE)

fs/hfsplus/bnode.c

298

dst_page = node->page + (dst >> PAGE_SHIFT);

fs/hfsplus/bnode.c

299

dst &= ~PAGE_MASK;

fs/hfsplus/bnode.c

301

if (src == dst) {

fs/hfsplus/bnode.c

322

dst_ptr = kmap_local_page(*dst_page) + dst;

fs/hfsplus/bnode.c

325

PAGE_SIZE - dst) {

fs/hfsplus/bnode.c

328

dst += l;

fs/hfsplus/bnode.c

330

l = PAGE_SIZE - dst;

fs/hfsplus/bnode.c

332

dst = 0;

fs/hfsplus/bnode.c

339

if (!dst)

fs/hfsplus/hfsplus_fs.h

374

void hfs_bnode_copy(struct hfs_bnode *dst_node, u32 dst,

fs/hfsplus/hfsplus_fs.h

376

void hfs_bnode_move(struct hfs_bnode *node, u32 dst, u32 src, u32 len);

fs/hpfs/hpfs_fn.h

175

static inline void copy_de(struct hpfs_dirent *dst, struct hpfs_dirent *src)

fs/hpfs/hpfs_fn.h

179

if (!dst || !src) return;

fs/hpfs/hpfs_fn.h

180

a = dst->down;

fs/hpfs/hpfs_fn.h

181

n = dst->not_8x3;

fs/hpfs/hpfs_fn.h

182

memcpy((char *)dst + 2, (char *)src + 2, 28);

fs/hpfs/hpfs_fn.h

183

dst->down = a;

fs/hpfs/hpfs_fn.h

184

dst->not_8x3 = n;

fs/hugetlbfs/inode.c

1056

struct folio *dst, struct folio *src,

fs/hugetlbfs/inode.c

1061

rc = migrate_huge_page_move_mapping(mapping, dst, src);

fs/hugetlbfs/inode.c

1066

hugetlb_set_folio_subpool(dst,

fs/hugetlbfs/inode.c

1071

folio_migrate_flags(dst, src);

fs/jfs/jfs_logmgr.c

350

caddr_t dst; /* destination address in log page */

fs/jfs/jfs_logmgr.c

424

dst = (caddr_t) lp + dstoffset;

fs/jfs/jfs_logmgr.c

425

memcpy(dst, src, nbytes);

fs/jfs/jfs_logmgr.c

472

dst = (caddr_t) lp + dstoffset;

fs/jfs/jfs_logmgr.c

473

memcpy(dst, src, nbytes);

fs/jfs/jfs_metapage.c

157

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

171

rc = filemap_migrate_folio(mapping, dst, src, mode);

fs/jfs/jfs_metapage.c

179

if (unlikely(insert_metapage(dst, mp))) {

fs/jfs/jfs_metapage.c

183

remove_metapage(dst, mps[j]);

fs/jfs/jfs_metapage.c

196

mp->data = folio_address(dst) + page_offset;

fs/jfs/jfs_metapage.c

197

mp->folio = dst;

fs/jfs/jfs_metapage.c

233

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

244

rc = filemap_migrate_folio(mapping, dst, src, mode);

fs/jfs/jfs_metapage.c

248

if (unlikely(insert_metapage(dst, mp)))

fs/jfs/jfs_metapage.c

252

mp->data = folio_address(dst) + page_offset;

fs/jfs/jfs_metapage.c

253

mp->folio = dst;

fs/jfs/jfs_metapage.c

646

struct folio *dst, struct folio *src,

fs/jfs/jfs_metapage.c

652

return filemap_migrate_folio(mapping, dst, src, mode);

fs/jfs/jfs_metapage.c

658

return __metapage_migrate_folio(mapping, dst, src, mode);

fs/namespace.c

5411

char *buf_end, *opt_end, *src, *dst;

fs/namespace.c

5418

dst = seq->buf + start;

fs/namespace.c

5419

src = dst + 1; /* skip initial comma */

fs/namespace.c

5430

dst += string_unescape(src, dst, 0, UNESCAPE_OCTAL) + 1;

fs/namespace.c

5434

seq->count = dst - 1 - seq->buf;

fs/nfs/delegation.c

1517

bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode)

fs/nfs/delegation.c

1527

nfs4_stateid_match_other(dst, &delegation->stateid) &&

fs/nfs/delegation.c

1528

nfs4_stateid_is_newer(&delegation->stateid, dst) &&

fs/nfs/delegation.c

1530

dst->seqid = delegation->stateid.seqid;

fs/nfs/delegation.c

1549

nfs4_stateid *dst, const struct cred **cred)

fs/nfs/delegation.c

1563

nfs4_stateid_copy(dst, &delegation->stateid);

fs/nfs/delegation.h

78

bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags, nfs4_stateid *dst, const struct cred **cred);

fs/nfs/delegation.h

79

bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode);

fs/nfs/fs_context.c

1328

static inline void compat_nfs_string(struct nfs_string *dst,

fs/nfs/fs_context.c

1331

dst->data = compat_ptr(src->data);

fs/nfs/fs_context.c

1332

dst->len = src->len;

fs/nfs/internal.h

348

nfs4_label_copy(struct nfs4_label *dst, struct nfs4_label *src)

fs/nfs/internal.h

350

if (!dst || !src)

fs/nfs/internal.h

356

dst->lfs = src->lfs;

fs/nfs/internal.h

357

dst->pi = src->pi;

fs/nfs/internal.h

358

dst->len = src->len;

fs/nfs/internal.h

359

memcpy(dst->label, src->label, src->len);

fs/nfs/internal.h

361

return dst;

fs/nfs/internal.h

375

nfs4_label_copy(struct nfs4_label *dst, struct nfs4_label *src)

fs/nfs/internal.h

603

int nfs_scan_commit_list(struct list_head *src, struct list_head *dst,

fs/nfs/internal.h

606

int nfs_scan_commit(struct inode *inode, struct list_head *dst,

fs/nfs/internal.h

624

struct list_head *dst,

fs/nfs/internal.h

667

int nfs_migrate_folio(struct address_space *, struct folio *dst,

fs/nfs/nfs42proc.c

23

static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);

fs/nfs/nfs42proc.c

238

struct file *dst,

fs/nfs/nfs42proc.c

243

struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);

fs/nfs/nfs42proc.c

309

nfs42_do_offload_cancel_async(dst, &copy->stateid);

fs/nfs/nfs42proc.c

310

if (!nfs42_files_from_same_server(src, dst))

fs/nfs/nfs42proc.c

317

status = nfs42_proc_offload_status(dst, &copy->stateid, &copied);

fs/nfs/nfs42proc.c

348

static int process_copy_commit(struct file *dst, loff_t pos_dst,

fs/nfs/nfs42proc.c

358

status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);

fs/nfs/nfs42proc.c

408

struct file *dst,

fs/nfs/nfs42proc.c

421

struct inode *dst_inode = file_inode(dst);

fs/nfs/nfs42proc.c

491

dst, &args->src_stateid, restart);

fs/nfs/nfs42proc.c

498

status = process_copy_commit(dst, pos_dst, res);

fs/nfs/nfs42proc.c

503

nfs42_copy_dest_done(dst, pos_dst, res->write_res.count, oldsize_dst);

fs/nfs/nfs42proc.c

513

struct file *dst, loff_t pos_dst, size_t count,

fs/nfs/nfs42proc.c

517

struct nfs_server *server = NFS_SERVER(file_inode(dst));

fs/nfs/nfs42proc.c

523

.dst_fh = NFS_FH(file_inode(dst)),

fs/nfs/nfs42proc.c

534

.inode = file_inode(dst),

fs/nfs/nfs42proc.c

546

dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));

fs/nfs/nfs42proc.c

555

inode_lock(file_inode(dst));

fs/nfs/nfs42proc.c

557

dst, dst_lock,

fs/nfs/nfs42proc.c

560

inode_unlock(file_inode(dst));

fs/nfs/nfs42proc.c

566

nfs42_files_from_same_server(src, dst)) {

fs/nfs/nfs42proc.c

583

!nfs42_files_from_same_server(src, dst)) {

fs/nfs/nfs42proc.c

639

static int nfs42_do_offload_cancel_async(struct file *dst,

fs/nfs/nfs42proc.c

642

struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));

fs/nfs/nfs42proc.c

644

struct nfs_open_context *ctx = nfs_file_open_context(dst);

fs/nfs/nfs42proc.c

667

data->args.osa_src_fh = NFS_FH(file_inode(dst));

fs/nfs/nfs42proc.c

746

nfs42_proc_offload_status(struct file *dst, nfs4_stateid *stateid, u64 *copied)

fs/nfs/nfs42proc.c

748

struct inode *inode = file_inode(dst);

fs/nfs/nfs42proc.c

768

status = _nfs42_proc_offload_status(server, dst, data);

fs/nfs/nfs42proc.c

787

static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,

fs/nfs/nfs42proc.c

828

int nfs42_proc_copy_notify(struct file *src, struct file *dst,

fs/nfs/nfs42proc.c

847

nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);

fs/nfs/nfs42proc.c

851

status = _nfs42_proc_copy_notify(src, dst, args, res);

fs/nfs/nfs4_fs.h

527

extern bool nfs4_copy_open_stateid(nfs4_stateid *dst,

fs/nfs/nfs4_fs.h

544

extern int nfs4_proc_commit(struct file *dst, __u64 offset, __u32 count, struct nfs_commitres *res);

fs/nfs/nfs4_fs.h

594

static inline void nfs4_stateid_copy(nfs4_stateid *dst, const nfs4_stateid *src)

fs/nfs/nfs4_fs.h

596

memcpy(dst->data, src->data, sizeof(dst->data));

fs/nfs/nfs4_fs.h

597

dst->type = src->type;

fs/nfs/nfs4_fs.h

600

static inline bool nfs4_stateid_match(const nfs4_stateid *dst, const nfs4_stateid *src)

fs/nfs/nfs4_fs.h

602

if (dst->type != src->type)

fs/nfs/nfs4_fs.h

604

return memcmp(dst->data, src->data, sizeof(dst->data)) == 0;

fs/nfs/nfs4_fs.h

607

static inline bool nfs4_stateid_match_other(const nfs4_stateid *dst, const nfs4_stateid *src)

fs/nfs/nfs4_fs.h

609

return memcmp(dst->other, src->other, NFS4_STATEID_OTHER_SIZE) == 0;

fs/nfs/nfs4_fs.h

625

static inline bool nfs4_stateid_match_or_older(const nfs4_stateid *dst, const nfs4_stateid *src)

fs/nfs/nfs4_fs.h

627

return nfs4_stateid_match_other(dst, src) &&

fs/nfs/nfs4_fs.h

628

!(src->seqid && nfs4_stateid_is_newer(dst, src));

fs/nfs/nfs4proc.c

303

static void nfs4_bitmap_copy_adjust(__u32 *dst, const __u32 *src,

fs/nfs/nfs4proc.c

308

memcpy(dst, src, NFS4_BITMASK_SZ*sizeof(*dst));

fs/nfs/nfs4proc.c

315

dst[1] &= ~FATTR4_WORD1_RAWDEV;

fs/nfs/nfs4proc.c

317

dst[0] &= ~FATTR4_WORD0_SIZE;

fs/nfs/nfs4proc.c

320

dst[0] &= ~FATTR4_WORD0_CHANGE;

fs/nfs/nfs4proc.c

323

dst[1] &= ~FATTR4_WORD1_MODE;

fs/nfs/nfs4proc.c

325

dst[1] &= ~(FATTR4_WORD1_OWNER | FATTR4_WORD1_OWNER_GROUP);

fs/nfs/nfs4proc.c

328

dst[1] &= ~FATTR4_WORD1_TIME_CREATE;

fs/nfs/nfs4proc.c

332

dst[1] &= ~(FATTR4_WORD1_TIME_ACCESS|FATTR4_WORD1_TIME_ACCESS_SET);

fs/nfs/nfs4proc.c

334

dst[1] &= ~(FATTR4_WORD1_TIME_MODIFY|FATTR4_WORD1_TIME_MODIFY_SET);

fs/nfs/nfs4proc.c

336

dst[1] &= ~(FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY_SET);

fs/nfs/nfs4proc.c

339

dst[1] &= ~(FATTR4_WORD1_TIME_ACCESS|FATTR4_WORD1_TIME_ACCESS_SET);

fs/nfs/nfs4proc.c

3442

static void nfs4_sync_open_stateid(nfs4_stateid *dst,

fs/nfs/nfs4proc.c

3453

if (!nfs4_state_match_open_stateid_other(state, dst)) {

fs/nfs/nfs4proc.c

3454

nfs4_stateid_copy(dst, &state->open_stateid);

fs/nfs/nfs4proc.c

3463

dst_seqid = be32_to_cpu(dst->seqid);

fs/nfs/nfs4proc.c

3465

dst->seqid = seqid_open;

fs/nfs/nfs4proc.c

3474

static bool nfs4_refresh_open_old_stateid(nfs4_stateid *dst,

fs/nfs/nfs4proc.c

3488

if (!nfs4_state_match_open_stateid_other(state, dst)) {

fs/nfs/nfs4proc.c

3497

dst_seqid = be32_to_cpu(dst->seqid);

fs/nfs/nfs4proc.c

3501

dst->seqid = seqid_open;

fs/nfs/nfs4proc.c

3511

trace_nfs4_close_stateid_update_wait(state->inode, dst, 0);

fs/nfs/nfs4proc.c

3527

dst->seqid = cpu_to_be32(dst_seqid + 1);

fs/nfs/nfs4proc.c

5880

static int _nfs4_proc_commit(struct file *dst, struct nfs_commitargs *args,

fs/nfs/nfs4proc.c

5883

struct inode *dst_inode = file_inode(dst);

fs/nfs/nfs4proc.c

5896

int nfs4_proc_commit(struct file *dst, __u64 offset, __u32 count, struct nfs_commitres *res)

fs/nfs/nfs4proc.c

5902

struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));

fs/nfs/nfs4proc.c

5907

status = _nfs4_proc_commit(dst, &args, res);

fs/nfs/nfs4proc.c

6975

static bool nfs4_refresh_lock_old_stateid(nfs4_stateid *dst,

fs/nfs/nfs4proc.c

6982

if (!nfs4_stateid_match_other(dst, &lsp->ls_stateid))

fs/nfs/nfs4proc.c

6984

if (!nfs4_stateid_is_newer(&lsp->ls_stateid, dst))

fs/nfs/nfs4proc.c

6985

nfs4_stateid_seqid_inc(dst);

fs/nfs/nfs4proc.c

6987

dst->seqid = lsp->ls_stateid.seqid;

fs/nfs/nfs4proc.c

6994

static bool nfs4_sync_lock_stateid(nfs4_stateid *dst,

fs/nfs/nfs4proc.c

7001

ret = !nfs4_stateid_match_other(dst, &lsp->ls_stateid);

fs/nfs/nfs4proc.c

7002

nfs4_stateid_copy(dst, &lsp->ls_stateid);

fs/nfs/nfs4session.h

144

static inline void nfs4_copy_sessionid(struct nfs4_sessionid *dst,

fs/nfs/nfs4session.h

147

memcpy(dst->data, src->data, NFS4_MAX_SESSIONID_LEN);

fs/nfs/nfs4state.c

1006

ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN;

fs/nfs/nfs4state.c

1009

dst->seqid = 0;

fs/nfs/nfs4state.c

895

static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)

fs/nfs/nfs4state.c

899

dst->fl_u.nfs4_fl.owner = lsp;

fs/nfs/nfs4state.c

927

static int nfs4_copy_lock_stateid(nfs4_stateid *dst,

fs/nfs/nfs4state.c

949

nfs4_stateid_copy(dst, &lsp->ls_stateid);

fs/nfs/nfs4state.c

958

bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)

fs/nfs/nfs4state.c

972

nfs4_stateid_copy(dst, src);

fs/nfs/nfs4state.c

983

nfs4_stateid *dst, const struct cred **cred)

fs/nfs/nfs4state.c

991

ret = nfs4_copy_lock_stateid(dst, state, l_ctx);

fs/nfs/nfs4state.c

996

if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {

fs/nfs/pnfs.c

410

bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst,

fs/nfs/pnfs.c

427

nfs4_stateid_match_other(dst, &lo->plh_stateid)) {

fs/nfs/pnfs.c

429

if (!nfs4_stateid_is_newer(&lo->plh_stateid, dst)) {

fs/nfs/pnfs.c

430

nfs4_stateid_seqid_inc(dst);

fs/nfs/pnfs.c

437

dst->seqid = lo->plh_stateid.seqid;

fs/nfs/pnfs.h

288

bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst,

fs/nfs/pnfs.h

407

void pnfs_generic_recover_commit_reqs(struct list_head *dst,

fs/nfs/pnfs.h

618

pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,

fs/nfs/pnfs.h

621

return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&

fs/nfs/pnfs.h

642

pnfs_copy_range(struct pnfs_layout_range *dst,

fs/nfs/pnfs.h

645

memcpy(dst, src, sizeof(*dst));

fs/nfs/pnfs.h

874

pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,

fs/nfs/pnfs.h

889

static inline bool nfs4_layout_refresh_old_stateid(nfs4_stateid *dst,

fs/nfs/pnfs_nfs.c

248

struct list_head *dst = &bucket->committing;

fs/nfs/pnfs_nfs.c

252

ret = nfs_scan_commit_list(src, dst, cinfo, max);

fs/nfs/pnfs_nfs.c

305

pnfs_bucket_recover_commit_reqs(struct list_head *dst,

fs/nfs/pnfs_nfs.c

317

nwritten = nfs_scan_commit_list(&b->written, dst, cinfo, 0);

fs/nfs/pnfs_nfs.c

331

void pnfs_generic_recover_commit_reqs(struct list_head *dst,

fs/nfs/pnfs_nfs.c

344

nwritten = pnfs_bucket_recover_commit_reqs(dst,

fs/nfs/write.c

1001

ret = nfs_scan_commit_list(&cinfo->mds->list, dst,

fs/nfs/write.c

2103

int nfs_migrate_folio(struct address_space *mapping, struct folio *dst,

fs/nfs/write.c

2127

return migrate_folio(mapping, dst, src, mode);

fs/nfs/write.c

783

nfs_request_add_commit_list_locked(struct nfs_page *req, struct list_head *dst,

fs/nfs/write.c

787

nfs_list_add_request(req, dst);

fs/nfs/write.c

956

nfs_scan_commit_list(struct list_head *src, struct list_head *dst,

fs/nfs/write.c

970

nfs_list_add_request(req, dst);

fs/nfs/write.c

990

nfs_scan_commit(struct inode *inode, struct list_head *dst,

fs/nfsd/nfs4proc.c

1364

stateid_t *dst_stateid, struct nfsd_file **dst)

fs/nfsd/nfs4proc.c

1377

dst_stateid, WR_STATE, dst, NULL);

fs/nfsd/nfs4proc.c

1383

!S_ISREG(file_inode((*dst)->nf_file)->i_mode)) {

fs/nfsd/nfs4proc.c

1391

nfsd_file_put(*dst);

fs/nfsd/nfs4proc.c

1392

*dst = NULL;

fs/nfsd/nfs4proc.c

1404

struct nfsd_file *src, *dst;

fs/nfsd/nfs4proc.c

1408

&clone->cl_dst_stateid, &dst);

fs/nfsd/nfs4proc.c

1413

dst, clone->cl_dst_pos, clone->cl_count,

fs/nfsd/nfs4proc.c

1416

nfsd_file_put(dst);

fs/nfsd/nfs4proc.c

142

fh_dup2(struct svc_fh *dst, struct svc_fh *src)

fs/nfsd/nfs4proc.c

144

fh_put(dst);

fs/nfsd/nfs4proc.c

148

*dst = *src;

fs/nfsd/nfs4proc.c

1834

struct nfsd_file *dst)

fs/nfsd/nfs4proc.c

1836

struct nfsd_net *nn = net_generic(dst->nf_net, nfsd_net_id);

fs/nfsd/nfs4proc.c

1867

struct nfsd_file *dst)

fs/nfsd/nfs4proc.c

1933

struct file *dst,

fs/nfsd/nfs4proc.c

1951

bytes_copied = nfsd_copy_file_range(src, src_pos, dst, dst_pos,

fs/nfsd/nfs4proc.c

1962

since = READ_ONCE(dst->f_wb_err);

fs/nfsd/nfs4proc.c

1964

status = vfs_fsync_range(dst, copy->cp_dst_pos, end, 0);

fs/nfsd/nfs4proc.c

1966

status = filemap_check_wb_err(dst->f_mapping, since);

fs/nfsd/nfs4proc.c

1974

struct file *src, struct file *dst,

fs/nfsd/nfs4proc.c

1980

bytes = _nfsd_copy_file_range(copy, dst, src);

fs/nfsd/nfs4proc.c

1994

static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)

fs/nfsd/nfs4proc.c

1996

dst->cp_src_pos = src->cp_src_pos;

fs/nfsd/nfs4proc.c

1997

dst->cp_dst_pos = src->cp_dst_pos;

fs/nfsd/nfs4proc.c

1998

dst->cp_count = src->cp_count;

fs/nfsd/nfs4proc.c

1999

dst->cp_flags = src->cp_flags;

fs/nfsd/nfs4proc.c

2000

memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));

fs/nfsd/nfs4proc.c

2001

memcpy(&dst->fh, &src->fh, sizeof(src->fh));

fs/nfsd/nfs4proc.c

2002

dst->cp_clp = src->cp_clp;

fs/nfsd/nfs4proc.c

2003

dst->nf_dst = nfsd_file_get(src->nf_dst);

fs/nfsd/nfs4proc.c

2006

dst->nf_src = nfsd_file_get(src->nf_src);

fs/nfsd/nfs4proc.c

2008

memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));

fs/nfsd/nfs4proc.c

2009

memcpy(dst->cp_src, src->cp_src, sizeof(struct nl4_server));

fs/nfsd/nfs4proc.c

2010

memcpy(&dst->stateid, &src->stateid, sizeof(src->stateid));

fs/nfsd/nfs4proc.c

2011

memcpy(&dst->c_fh, &src->c_fh, sizeof(src->c_fh));

fs/nfsd/nfs4proc.c

2012

dst->ss_nsui = src->ss_nsui;

fs/nfsd/nfs4state.c

1196

nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)

fs/nfsd/nfs4state.c

1203

memcpy(dst, src, sizeof(*dst));

fs/nfsd/nfsfh.h

231

fh_copy(struct svc_fh *dst, const struct svc_fh *src)

fs/nfsd/nfsfh.h

235

*dst = *src;

fs/nfsd/nfsfh.h

236

return dst;

fs/nfsd/nfsfh.h

240

fh_copy_shallow(struct knfsd_fh *dst, const struct knfsd_fh *src)

fs/nfsd/nfsfh.h

242

dst->fh_size = src->fh_size;

fs/nfsd/nfsfh.h

243

memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size);

fs/nfsd/state.h

807

void nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid);

fs/nfsd/vfs.c

688

struct file *dst = nf_dst->nf_file;

fs/nfsd/vfs.c

693

since = READ_ONCE(dst->f_wb_err);

fs/nfsd/vfs.c

694

cloned = vfs_clone_file_range(src, src_pos, dst, dst_pos, count, 0);

fs/nfsd/vfs.c

705

int status = vfs_fsync_range(dst, dst_pos, dst_end, 0);

fs/nfsd/vfs.c

708

status = filemap_check_wb_err(dst->f_mapping, since);

fs/nfsd/vfs.c

729

ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,

fs/nfsd/vfs.c

743

ret = vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);

fs/nfsd/vfs.c

746

ret = vfs_copy_file_range(src, src_pos, dst, dst_pos, count,

fs/nilfs2/page.c

197

static void nilfs_copy_folio(struct folio *dst, struct folio *src,

fs/nilfs2/page.c

203

BUG_ON(folio_test_writeback(dst));

fs/nilfs2/page.c

206

dbh = folio_buffers(dst);

fs/nilfs2/page.c

208

dbh = create_empty_buffers(dst, sbh->b_size, 0);

fs/nilfs2/page.c

224

folio_copy(dst, src);

fs/nilfs2/page.c

226

if (folio_test_uptodate(src) && !folio_test_uptodate(dst))

fs/nilfs2/page.c

227

folio_mark_uptodate(dst);

fs/nilfs2/page.c

228

else if (!folio_test_uptodate(src) && folio_test_uptodate(dst))

fs/nilfs2/page.c

229

folio_clear_uptodate(dst);

fs/nilfs2/page.c

230

if (folio_test_mappedtodisk(src) && !folio_test_mappedtodisk(dst))

fs/nilfs2/page.c

231

folio_set_mappedtodisk(dst);

fs/nilfs2/page.c

232

else if (!folio_test_mappedtodisk(src) && folio_test_mappedtodisk(dst))

fs/nilfs2/page.c

233

folio_clear_mappedtodisk(dst);

fs/ntfs3/lib/decompress_common.h

254

static forceinline u8 *lz_copy(u8 *dst, u32 length, u32 offset, const u8 *bufend,

fs/ntfs3/lib/decompress_common.h

257

const u8 *src = dst - offset;

fs/ntfs3/lib/decompress_common.h

273

u8 * const end = dst + length;

fs/ntfs3/lib/decompress_common.h

287

copy_unaligned_word(src, dst);

fs/ntfs3/lib/decompress_common.h

289

dst += WORDBYTES;

fs/ntfs3/lib/decompress_common.h

291

if (dst < end) {

fs/ntfs3/lib/decompress_common.h

293

copy_unaligned_word(src, dst);

fs/ntfs3/lib/decompress_common.h

295

dst += WORDBYTES;

fs/ntfs3/lib/decompress_common.h

296

} while (dst < end);

fs/ntfs3/lib/decompress_common.h

30

copy_unaligned_word(const void *src, void *dst)

fs/ntfs3/lib/decompress_common.h

305

size_t v = repeat_byte(*(dst - 1));

fs/ntfs3/lib/decompress_common.h

308

put_unaligned(v, (size_t *)dst);

fs/ntfs3/lib/decompress_common.h

310

dst += WORDBYTES;

fs/ntfs3/lib/decompress_common.h

311

} while (dst < end);

fs/ntfs3/lib/decompress_common.h

32

put_unaligned(get_unaligned((const size_t *)src), (size_t *)dst);

fs/ntfs3/lib/decompress_common.h

329

*dst++ = *src++;

fs/ntfs3/lib/decompress_common.h

333

*dst++ = *src++;

fs/ntfs3/lib/decompress_common.h

337

*dst++ = *src++;

fs/ntfs3/lib/decompress_common.h

340

return dst;

fs/ntfs3/super.c

1608

u16 *dst = sbi->upcase;

fs/ntfs3/super.c

1611

__swab16s(dst++);

fs/overlayfs/overlayfs.h

480

void ovl_stack_cpy(struct ovl_path *dst, struct ovl_path *src, unsigned int n);

fs/overlayfs/readdir.c

74

char **dst)

fs/overlayfs/readdir.c

92

*dst = cf_name;

fs/overlayfs/util.c

122

void ovl_stack_cpy(struct ovl_path *dst, struct ovl_path *src, unsigned int n)

fs/overlayfs/util.c

126

memcpy(dst, src, sizeof(struct ovl_path) * n);

fs/proc/bootconfig.c

23

#define rest(dst, end) ((end) > (dst) ? (end) - (dst) : 0)

fs/proc/bootconfig.c

26

static int __init copy_xbc_key_value_list(char *dst, size_t size)

fs/proc/bootconfig.c

29

char *key, *end = dst + size;

fs/proc/bootconfig.c

42

ret = snprintf(dst, rest(dst, end), "%s = ", key);

fs/proc/bootconfig.c

45

dst += ret;

fs/proc/bootconfig.c

53

ret = snprintf(dst, rest(dst, end), "%c%s%c%s",

fs/proc/bootconfig.c

57

dst += ret;

fs/proc/bootconfig.c

60

ret = snprintf(dst, rest(dst, end), "\"\"\n");

fs/proc/bootconfig.c

63

dst += ret;

fs/proc/bootconfig.c

67

ret = snprintf(dst, rest(dst, end), "# Parameters from bootloader:\n# %s\n",

fs/proc/bootconfig.c

70

dst += ret;

fs/proc/bootconfig.c

75

return ret < 0 ? ret : dst - (end - size);

fs/proc/vmcore.c

298

static int vmcoredd_mmap_dumps(struct vm_area_struct *vma, unsigned long dst,

fs/proc/vmcore.c

310

if (remap_vmalloc_range_partial(vma, dst, buf, 0,

fs/proc/vmcore.c

316

dst += tsz;

fs/pstore/platform.c

305

char *dst;

fs/pstore/platform.c

319

dst = big_oops_buf ?: psinfo->buf;

fs/pstore/platform.c

323

header_size = snprintf(dst, dst_size, "%s#%d Part%u\n", why,

fs/pstore/platform.c

328

if (!kmsg_dump_get_buffer(&iter, true, dst + header_size,

fs/pstore/platform.c

333

zipped_len = pstore_compress(dst, psinfo->buf,

fs/pstore/platform.c

349

memcpy(psinfo->buf, dst, psinfo->bufsize);

fs/quota/quota.c

187

static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src)

fs/quota/quota.c

189

memset(dst, 0, sizeof(*dst));

fs/quota/quota.c

190

dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);

fs/quota/quota.c

191

dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);

fs/quota/quota.c

192

dst->dqb_curspace = src->d_space;

fs/quota/quota.c

193

dst->dqb_ihardlimit = src->d_ino_hardlimit;

fs/quota/quota.c

194

dst->dqb_isoftlimit = src->d_ino_softlimit;

fs/quota/quota.c

195

dst->dqb_curinodes = src->d_ino_count;

fs/quota/quota.c

196

dst->dqb_btime = src->d_spc_timer;

fs/quota/quota.c

197

dst->dqb_itime = src->d_ino_timer;

fs/quota/quota.c

198

dst->dqb_valid = QIF_ALL;

fs/quota/quota.c

261

static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)

fs/quota/quota.c

263

dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);

fs/quota/quota.c

264

dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);

fs/quota/quota.c

265

dst->d_space = src->dqb_curspace;

fs/quota/quota.c

266

dst->d_ino_hardlimit = src->dqb_ihardlimit;

fs/quota/quota.c

267

dst->d_ino_softlimit = src->dqb_isoftlimit;

fs/quota/quota.c

268

dst->d_ino_count = src->dqb_curinodes;

fs/quota/quota.c

269

dst->d_spc_timer = src->dqb_btime;

fs/quota/quota.c

270

dst->d_ino_timer = src->dqb_itime;

fs/quota/quota.c

272

dst->d_fieldmask = 0;

fs/quota/quota.c

274

dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;

fs/quota/quota.c

276

dst->d_fieldmask |= QC_SPACE;

fs/quota/quota.c

278

dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;

fs/quota/quota.c

280

dst->d_fieldmask |= QC_INO_COUNT;

fs/quota/quota.c

282

dst->d_fieldmask |= QC_SPC_TIMER;

fs/quota/quota.c

284

dst->d_fieldmask |= QC_INO_TIMER;

fs/quota/quota.c

547

static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)

fs/quota/quota.c

549

dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);

fs/quota/quota.c

550

dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit);

fs/quota/quota.c

551

dst->d_ino_hardlimit = src->d_ino_hardlimit;

fs/quota/quota.c

552

dst->d_ino_softlimit = src->d_ino_softlimit;

fs/quota/quota.c

553

dst->d_space = quota_bbtob(src->d_bcount);

fs/quota/quota.c

554

dst->d_ino_count = src->d_icount;

fs/quota/quota.c

555

dst->d_ino_timer = copy_from_xfs_dqblk_ts(src, src->d_itimer,

fs/quota/quota.c

557

dst->d_spc_timer = copy_from_xfs_dqblk_ts(src, src->d_btimer,

fs/quota/quota.c

559

dst->d_ino_warns = src->d_iwarns;

fs/quota/quota.c

560

dst->d_spc_warns = src->d_bwarns;

fs/quota/quota.c

561

dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);

fs/quota/quota.c

562

dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);

fs/quota/quota.c

563

dst->d_rt_space = quota_bbtob(src->d_rtbcount);

fs/quota/quota.c

564

dst->d_rt_spc_timer = copy_from_xfs_dqblk_ts(src, src->d_rtbtimer,

fs/quota/quota.c

566

dst->d_rt_spc_warns = src->d_rtbwarns;

fs/quota/quota.c

567

dst->d_fieldmask = 0;

fs/quota/quota.c

569

dst->d_fieldmask |= QC_INO_SOFT;

fs/quota/quota.c

571

dst->d_fieldmask |= QC_INO_HARD;

fs/quota/quota.c

573

dst->d_fieldmask |= QC_SPC_SOFT;

fs/quota/quota.c

575

dst->d_fieldmask |= QC_SPC_HARD;

fs/quota/quota.c

577

dst->d_fieldmask |= QC_RT_SPC_SOFT;

fs/quota/quota.c

579

dst->d_fieldmask |= QC_RT_SPC_HARD;

fs/quota/quota.c

581

dst->d_fieldmask |= QC_SPC_TIMER;

fs/quota/quota.c

583

dst->d_fieldmask |= QC_INO_TIMER;

fs/quota/quota.c

585

dst->d_fieldmask |= QC_RT_SPC_TIMER;

fs/quota/quota.c

587

dst->d_fieldmask |= QC_SPC_WARNS;

fs/quota/quota.c

589

dst->d_fieldmask |= QC_INO_WARNS;

fs/quota/quota.c

591

dst->d_fieldmask |= QC_RT_SPC_WARNS;

fs/quota/quota.c

593

dst->d_fieldmask |= QC_SPACE;

fs/quota/quota.c

595

dst->d_fieldmask |= QC_INO_COUNT;

fs/quota/quota.c

597

dst->d_fieldmask |= QC_RT_SPACE;

fs/quota/quota.c

600

static void copy_qcinfo_from_xfs_dqblk(struct qc_info *dst,

fs/quota/quota.c

603

memset(dst, 0, sizeof(*dst));

fs/quota/quota.c

604

dst->i_spc_timelimit = src->d_btimer;

fs/quota/quota.c

605

dst->i_ino_timelimit = src->d_itimer;

fs/quota/quota.c

606

dst->i_rt_spc_timelimit = src->d_rtbtimer;

fs/quota/quota.c

607

dst->i_ino_warnlimit = src->d_iwarns;

fs/quota/quota.c

608

dst->i_spc_warnlimit = src->d_bwarns;

fs/quota/quota.c

609

dst->i_rt_spc_warnlimit = src->d_rtbwarns;

fs/quota/quota.c

611

dst->i_fieldmask |= QC_SPC_WARNS;

fs/quota/quota.c

613

dst->i_fieldmask |= QC_INO_WARNS;

fs/quota/quota.c

615

dst->i_fieldmask |= QC_RT_SPC_WARNS;

fs/quota/quota.c

617

dst->i_fieldmask |= QC_SPC_TIMER;

fs/quota/quota.c

619

dst->i_fieldmask |= QC_INO_TIMER;

fs/quota/quota.c

621

dst->i_fieldmask |= QC_RT_SPC_TIMER;

fs/quota/quota.c

670

static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,

fs/quota/quota.c

673

memset(dst, 0, sizeof(*dst));

fs/quota/quota.c

676

dst->d_fieldmask |= FS_DQ_BIGTIME;

fs/quota/quota.c

677

dst->d_version = FS_DQUOT_VERSION;

fs/quota/quota.c

678

dst->d_id = id;

fs/quota/quota.c

680

dst->d_flags = FS_USER_QUOTA;

fs/quota/quota.c

682

dst->d_flags = FS_PROJ_QUOTA;

fs/quota/quota.c

684

dst->d_flags = FS_GROUP_QUOTA;

fs/quota/quota.c

685

dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);

fs/quota/quota.c

686

dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);

fs/quota/quota.c

687

dst->d_ino_hardlimit = src->d_ino_hardlimit;

fs/quota/quota.c

688

dst->d_ino_softlimit = src->d_ino_softlimit;

fs/quota/quota.c

689

dst->d_bcount = quota_btobb(src->d_space);

fs/quota/quota.c

690

dst->d_icount = src->d_ino_count;

fs/quota/quota.c

691

copy_to_xfs_dqblk_ts(dst, &dst->d_itimer, &dst->d_itimer_hi,

fs/quota/quota.c

693

copy_to_xfs_dqblk_ts(dst, &dst->d_btimer, &dst->d_btimer_hi,

fs/quota/quota.c

695

dst->d_iwarns = src->d_ino_warns;

fs/quota/quota.c

696

dst->d_bwarns = src->d_spc_warns;

fs/quota/quota.c

697

dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);

fs/quota/quota.c

698

dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);

fs/quota/quota.c

699

dst->d_rtbcount = quota_btobb(src->d_rt_space);

fs/quota/quota.c

700

copy_to_xfs_dqblk_ts(dst, &dst->d_rtbtimer, &dst->d_rtbtimer_hi,

fs/quota/quota.c

702

dst->d_rtbwarns = src->d_rt_spc_warns;

fs/readdir.c

77

char __user *dst = (_dst); \

fs/readdir.c

80

unsafe_put_user(0, dst+len, label); \

fs/readdir.c

81

unsafe_copy_to_user(dst, src, len, label); \

fs/smb/client/cifs_swn.c

430

struct sockaddr_storage *dst)

fs/smb/client/cifs_swn.c

454

*dst = *new;

fs/smb/client/cifs_unicode.c

335

char *dst;

fs/smb/client/cifs_unicode.c

340

dst = kmalloc(len, GFP_KERNEL);

fs/smb/client/cifs_unicode.c

341

if (!dst)

fs/smb/client/cifs_unicode.c

343

cifs_from_utf16(dst, (__le16 *) src, len, maxlen, codepage,

fs/smb/client/cifs_unicode.c

346

dst = kstrndup(src, maxlen, GFP_KERNEL);

fs/smb/client/cifs_unicode.c

349

return dst;

fs/smb/client/cifs_unicode.c

615

__le16 *dst;

fs/smb/client/cifs_unicode.c

622

dst = kmalloc(len, GFP_KERNEL);

fs/smb/client/cifs_unicode.c

623

if (!dst) {

fs/smb/client/cifs_unicode.c

627

cifsConvertToUTF16(dst, src, strlen(src), cp, remap);

fs/smb/client/cifs_unicode.c

629

return dst;

fs/smb/client/cifsacl.c

262

cifs_copy_sid(struct smb_sid *dst, const struct smb_sid *src)

fs/smb/client/cifsacl.c

267

dst->revision = src->revision;

fs/smb/client/cifsacl.c

268

dst->num_subauth = min_t(u8, src->num_subauth, SID_MAX_SUB_AUTHORITIES);

fs/smb/client/cifsacl.c

270

dst->authority[i] = src->authority[i];

fs/smb/client/cifsacl.c

271

for (i = 0; i < dst->num_subauth; ++i)

fs/smb/client/cifsacl.c

272

dst->sub_auth[i] = src->sub_auth[i];

fs/smb/client/cifsacl.c

273

size += (dst->num_subauth * 4);

fs/smb/client/cifsacl.c

669

static __u16 cifs_copy_ace(struct smb_ace *dst, struct smb_ace *src, struct smb_sid *psid)

fs/smb/client/cifsacl.c

673

dst->type = src->type;

fs/smb/client/cifsacl.c

674

dst->flags = src->flags;

fs/smb/client/cifsacl.c

675

dst->access_req = src->access_req;

fs/smb/client/cifsacl.c

679

size += cifs_copy_sid(&dst->sid, psid);

fs/smb/client/cifsacl.c

681

size += cifs_copy_sid(&dst->sid, &src->sid);

fs/smb/client/cifsacl.c

683

dst->size = cpu_to_le16(size);

fs/smb/client/cifsglob.h

2231

static inline void move_cifs_info_to_smb2(struct smb2_file_all_info *dst, const FILE_ALL_INFO *src)

fs/smb/client/cifsglob.h

2233

memcpy(dst, src, (size_t)((u8 *)&src->EASize - (u8 *)src));

fs/smb/client/cifsglob.h

2234

dst->IndexNumber = 0;

fs/smb/client/cifsglob.h

2235

dst->EASize = src->EASize;

fs/smb/client/cifsglob.h

2236

dst->AccessFlags = 0;

fs/smb/client/cifsglob.h

2237

dst->CurrentByteOffset = 0;

fs/smb/client/cifsglob.h

2238

dst->Mode = 0;

fs/smb/client/cifsglob.h

2239

dst->AlignmentRequirement = 0;

fs/smb/client/cifsglob.h

2240

dst->FileNameLength = src->FileNameLength;

fs/smb/client/cifsproto.h

155

int cifs_convert_address(struct sockaddr *dst, const char *src, int len);

fs/smb/client/cifsproto.h

384

int copy_path_name(char *dst, const char *src);

fs/smb/client/compress.c

308

void *src, *dst = NULL;

fs/smb/client/compress.c

337

dst = kvzalloc(dlen, GFP_KERNEL);

fs/smb/client/compress.c

338

if (!dst) {

fs/smb/client/compress.c

343

ret = lz77_compress(src, slen, dst, &dlen);

fs/smb/client/compress.c

358

iov[2].iov_base = dst;

fs/smb/client/compress.c

368

kvfree(dst);

fs/smb/client/compress/lz77.c

107

return dst;

fs/smb/client/compress/lz77.c

111

lz77_write8(dst, len);

fs/smb/client/compress/lz77.c

113

return dst + 1;

fs/smb/client/compress/lz77.c

116

lz77_write8(dst, 0xff);

fs/smb/client/compress/lz77.c

117

dst++;

fs/smb/client/compress/lz77.c

120

lz77_write16(dst, len);

fs/smb/client/compress/lz77.c

122

return dst + 2;

fs/smb/client/compress/lz77.c

125

lz77_write16(dst, 0);

fs/smb/client/compress/lz77.c

126

dst += 2;

fs/smb/client/compress/lz77.c

127

lz77_write32(dst, len);

fs/smb/client/compress/lz77.c

129

return dst + 4;

fs/smb/client/compress/lz77.c

132

noinline int lz77_compress(const void *src, u32 slen, void *dst, u32 *dlen)

fs/smb/client/compress/lz77.c

142

dstp = dst;

fs/smb/client/compress/lz77.c

187

if (unlikely(dstp - dst >= slen - (slen >> 3))) {

fs/smb/client/compress/lz77.c

227

*dlen = dstp - dst;

fs/smb/client/compress/lz77.c

78

static __always_inline void *lz77_write_match(void *dst, void **nib, u32 dist, u32 len)

fs/smb/client/compress/lz77.c

85

lz77_write16(dst, dist + len);

fs/smb/client/compress/lz77.c

87

return dst + 2;

fs/smb/client/compress/lz77.c

91

lz77_write16(dst, dist);

fs/smb/client/compress/lz77.c

92

dst += 2;

fs/smb/client/compress/lz77.c

96

lz77_write8(dst, umin(len, 15));

fs/smb/client/compress/lz77.c

97

*nib = dst;

fs/smb/client/compress/lz77.c

98

dst++;

fs/smb/client/compress/lz77.h

14

int lz77_compress(const void *src, u32 slen, void *dst, u32 *dlen);

fs/smb/client/misc.c

869

int copy_path_name(char *dst, const char *src)

fs/smb/client/misc.c

877

name_len = strscpy(dst, src, PATH_MAX);

fs/smb/client/netmisc.c

33

cifs_inet_pton(const int address_family, const char *cp, int len, void *dst)

fs/smb/client/netmisc.c

39

ret = in4_pton(cp, len, dst, '\\', NULL);

fs/smb/client/netmisc.c

41

ret = in6_pton(cp, len, dst , '\\', NULL);

fs/smb/client/netmisc.c

59

cifs_convert_address(struct sockaddr *dst, const char *src, int len)

fs/smb/client/netmisc.c

64

struct sockaddr_in *s4 = (struct sockaddr_in *) dst;

fs/smb/client/netmisc.c

65

struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) dst;

fs/smb/client/smb2ops.c

1036

move_smb2_ea_to_cifs(char *dst, size_t dst_size,

fs/smb/client/smb2ops.c

1073

memcpy(dst, value, value_len);

fs/smb/client/smb2ops.c

1085

memcpy(dst, "user.", 5);

fs/smb/client/smb2ops.c

1086

dst += 5;

fs/smb/client/smb2ops.c

1087

memcpy(dst, src->ea_data, name_len);

fs/smb/client/smb2ops.c

1088

dst += name_len;

fs/smb/client/smb2ops.c

1089

*dst = 0;

fs/smb/client/smb2ops.c

1090

++dst;

fs/smb/client/unc.c

21

char *dst, *delim;

fs/smb/client/unc.c

39

dst = kmalloc((len + 1), GFP_KERNEL);

fs/smb/client/unc.c

40

if (dst == NULL)

fs/smb/client/unc.c

43

memcpy(dst, src, len);

fs/smb/client/unc.c

44

dst[len] = '\0';

fs/smb/client/unc.c

46

return dst;

fs/smb/client/unc.c

52

char *delim, *dst;

fs/smb/client/unc.c

64

dst = kstrdup(delim, GFP_KERNEL);

fs/smb/client/unc.c

65

if (!dst)

fs/smb/client/unc.c

68

return dst;

fs/smb/server/smbacl.c

116

static void smb_copy_sid(struct smb_sid *dst, const struct smb_sid *src)

fs/smb/server/smbacl.c

120

dst->revision = src->revision;

fs/smb/server/smbacl.c

121

dst->num_subauth = min_t(u8, src->num_subauth, SID_MAX_SUB_AUTHORITIES);

fs/smb/server/smbacl.c

123

dst->authority[i] = src->authority[i];

fs/smb/server/smbacl.c

124

for (i = 0; i < dst->num_subauth; ++i)

fs/smb/server/smbacl.c

125

dst->sub_auth[i] = src->sub_auth[i];

fs/smb/server/unicode.c

295

char *dst;

fs/smb/server/unicode.c

300

dst = kmalloc(len, KSMBD_DEFAULT_GFP);

fs/smb/server/unicode.c

301

if (!dst)

fs/smb/server/unicode.c

303

ret = smb_from_utf16(dst, (__le16 *)src, len, maxlen, codepage,

fs/smb/server/unicode.c

306

kfree(dst);

fs/smb/server/unicode.c

312

dst = kmalloc(len, KSMBD_DEFAULT_GFP);

fs/smb/server/unicode.c

313

if (!dst)

fs/smb/server/unicode.c

315

strscpy(dst, src, len);

fs/smb/server/unicode.c

318

return dst;

fs/squashfs/zstd_wrapper.c

110

out_buf.dst = squashfs_next_page(output);

fs/squashfs/zstd_wrapper.c

111

if (IS_ERR(out_buf.dst)) {

fs/squashfs/zstd_wrapper.c

112

error = PTR_ERR(out_buf.dst);

fs/squashfs/zstd_wrapper.c

114

} else if (out_buf.dst == NULL) {

fs/squashfs/zstd_wrapper.c

82

out_buf.dst = squashfs_first_page(output);

fs/squashfs/zstd_wrapper.c

83

if (IS_ERR(out_buf.dst)) {

fs/squashfs/zstd_wrapper.c

84

error = PTR_ERR(out_buf.dst);

fs/stack.c

11

void fsstack_copy_inode_size(struct inode *dst, struct inode *src)

fs/stack.c

54

spin_lock(&dst->i_lock);

fs/stack.c

55

i_size_write(dst, i_size);

fs/stack.c

56

dst->i_blocks = i_blocks;

fs/stack.c

58

spin_unlock(&dst->i_lock);

fs/userfaultfd.c

1632

ret = validate_range(ctx->mm, uffdio_copy.dst, uffdio_copy.len);

fs/userfaultfd.c

1642

ret = mfill_atomic_copy(ctx, uffdio_copy.dst, uffdio_copy.src,

fs/userfaultfd.c

1656

range.start = uffdio_copy.dst;

fs/userfaultfd.c

1929

ret = validate_range(mm, uffdio_move.dst, uffdio_move.len);

fs/userfaultfd.c

1942

ret = move_pages(ctx, uffdio_move.dst, uffdio_move.src,

fs/userfaultfd.c

1958

range.start = uffdio_move.dst;

fs/verity/read_metadata.c

101

if (copy_to_user(dst, src, length))

fs/verity/read_metadata.c

91

static int fsverity_read_buffer(void __user *dst, u64 offset, int length,

fs/xfs/libxfs/xfs_attr_remote.c

298

uint8_t **dst)

fs/xfs/libxfs/xfs_attr_remote.c

325

memcpy(*dst, src + hdr_size, byte_cnt);

fs/xfs/libxfs/xfs_attr_remote.c

334

*dst += byte_cnt;

fs/xfs/libxfs/xfs_attr_remote.c

349

char *dst = bp->b_addr;

fs/xfs/libxfs/xfs_attr_remote.c

361

hdr_size = xfs_attr3_rmt_hdr_set(mp, dst, ino, *offset,

fs/xfs/libxfs/xfs_attr_remote.c

364

memcpy(dst + hdr_size, *src, byte_cnt);

fs/xfs/libxfs/xfs_attr_remote.c

373

memset(dst + hdr_size + byte_cnt, 0,

fs/xfs/libxfs/xfs_attr_remote.c

379

dst += blksize;

fs/xfs/libxfs/xfs_attr_remote.c

403

uint8_t *dst = args->value;

fs/xfs/libxfs/xfs_attr_remote.c

449

args->owner, &offset, &valuelen, &dst);

fs/xfs/libxfs/xfs_bmap_btree.c

196

struct xfs_btree_cur *dst)

fs/xfs/libxfs/xfs_bmap_btree.c

198

ASSERT((dst->bc_tp->t_highest_agno != NULLAGNUMBER) ||

fs/xfs/libxfs/xfs_bmap_btree.c

199

(dst->bc_ino.ip->i_diflags & XFS_DIFLAG_REALTIME));

fs/xfs/libxfs/xfs_bmap_btree.c

201

dst->bc_bmap.allocated += src->bc_bmap.allocated;

fs/xfs/libxfs/xfs_bmap_btree.c

202

dst->bc_tp->t_highest_agno = src->bc_tp->t_highest_agno;

fs/xfs/libxfs/xfs_btree.h

144

struct xfs_btree_cur *dst);

fs/xfs/libxfs/xfs_da_btree.c

482

struct xfs_buf *dst,

fs/xfs/libxfs/xfs_da_btree.c

486

struct xfs_da3_blkinfo *da3 = dst->b_addr;

fs/xfs/libxfs/xfs_da_btree.c

488

memcpy(dst->b_addr, src->b_addr, size);

fs/xfs/libxfs/xfs_da_btree.c

489

dst->b_ops = src->b_ops;

fs/xfs/libxfs/xfs_da_btree.c

490

xfs_trans_buf_copy_type(dst, src);

fs/xfs/libxfs/xfs_da_btree.c

491

if (xfs_has_crc(dst->b_mount))

fs/xfs/libxfs/xfs_da_btree.c

492

da3->blkno = cpu_to_be64(xfs_buf_daddr(dst));

fs/xfs/libxfs/xfs_da_btree.h

226

void xfs_da_buf_copy(struct xfs_buf *dst, struct xfs_buf *src,

fs/xfs/scrub/cow_repair.c

117

struct xfs_refcount_irec *dst,

fs/xfs/scrub/cow_repair.c

122

memcpy(dst, src, sizeof(*dst));

fs/xfs/scrub/cow_repair.c

124

if (dst->rc_startblock < xc->irec_startbno) {

fs/xfs/scrub/cow_repair.c

125

adj = xc->irec_startbno - dst->rc_startblock;

fs/xfs/scrub/cow_repair.c

126

dst->rc_blockcount -= adj;

fs/xfs/scrub/cow_repair.c

127

dst->rc_startblock += adj;

fs/xfs/scrub/cow_repair.c

130

if (dst->rc_startblock + dst->rc_blockcount >

fs/xfs/scrub/cow_repair.c

132

adj = (dst->rc_startblock + dst->rc_blockcount) -

fs/xfs/scrub/cow_repair.c

134

dst->rc_blockcount -= adj;

fs/xfs/xfs_bmap_item.c

624

struct xfs_bui_log_format *dst,

fs/xfs/xfs_bmap_item.c

629

memcpy(dst, src, offsetof(struct xfs_bui_log_format, bui_extents));

fs/xfs/xfs_bmap_item.c

632

memcpy(&dst->bui_extents[i], &src->bui_extents[i],

fs/xfs/xfs_ioctl.c

1063

struct xfs_icwalk *dst)

fs/xfs/xfs_ioctl.c

1075

dst->icw_flags = 0;

fs/xfs/xfs_ioctl.c

1077

dst->icw_flags |= XFS_ICWALK_FLAG_SYNC;

fs/xfs/xfs_ioctl.c

1079

dst->icw_flags |= XFS_ICWALK_FLAG_UID;

fs/xfs/xfs_ioctl.c

1081

dst->icw_flags |= XFS_ICWALK_FLAG_GID;

fs/xfs/xfs_ioctl.c

1083

dst->icw_flags |= XFS_ICWALK_FLAG_PRID;

fs/xfs/xfs_ioctl.c

1085

dst->icw_flags |= XFS_ICWALK_FLAG_MINFILESIZE;

fs/xfs/xfs_ioctl.c

1087

dst->icw_prid = src->eof_prid;

fs/xfs/xfs_ioctl.c

1088

dst->icw_min_file_size = src->eof_min_file_size;

fs/xfs/xfs_ioctl.c

1090

dst->icw_uid = INVALID_UID;

fs/xfs/xfs_ioctl.c

1092

dst->icw_uid = make_kuid(current_user_ns(), src->eof_uid);

fs/xfs/xfs_ioctl.c

1093

if (!uid_valid(dst->icw_uid))

fs/xfs/xfs_ioctl.c

1097

dst->icw_gid = INVALID_GID;

fs/xfs/xfs_ioctl.c

1099

dst->icw_gid = make_kgid(current_user_ns(), src->eof_gid);

fs/xfs/xfs_ioctl.c

1100

if (!gid_valid(dst->icw_gid))

fs/xfs/xfs_qm.h

160

struct qc_dqblk *dst);

fs/xfs/xfs_qm.h

164

struct qc_dqblk *dst);

fs/xfs/xfs_qm_syscalls.c

400

struct qc_dqblk *dst)

fs/xfs/xfs_qm_syscalls.c

402

memset(dst, 0, sizeof(*dst));

fs/xfs/xfs_qm_syscalls.c

403

dst->d_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_blk.hardlimit);

fs/xfs/xfs_qm_syscalls.c

404

dst->d_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_blk.softlimit);

fs/xfs/xfs_qm_syscalls.c

405

dst->d_ino_hardlimit = dqp->q_ino.hardlimit;

fs/xfs/xfs_qm_syscalls.c

406

dst->d_ino_softlimit = dqp->q_ino.softlimit;

fs/xfs/xfs_qm_syscalls.c

407

dst->d_space = XFS_FSB_TO_B(mp, dqp->q_blk.reserved);

fs/xfs/xfs_qm_syscalls.c

408

dst->d_ino_count = dqp->q_ino.reserved;

fs/xfs/xfs_qm_syscalls.c

409

dst->d_spc_timer = dqp->q_blk.timer;

fs/xfs/xfs_qm_syscalls.c

410

dst->d_ino_timer = dqp->q_ino.timer;

fs/xfs/xfs_qm_syscalls.c

411

dst->d_ino_warns = 0;

fs/xfs/xfs_qm_syscalls.c

412

dst->d_spc_warns = 0;

fs/xfs/xfs_qm_syscalls.c

413

dst->d_rt_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.hardlimit);

fs/xfs/xfs_qm_syscalls.c

414

dst->d_rt_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.softlimit);

fs/xfs/xfs_qm_syscalls.c

415

dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_rtb.reserved);

fs/xfs/xfs_qm_syscalls.c

416

dst->d_rt_spc_timer = dqp->q_rtb.timer;

fs/xfs/xfs_qm_syscalls.c

417

dst->d_rt_spc_warns = 0;

fs/xfs/xfs_qm_syscalls.c

425

dst->d_spc_timer = 0;

fs/xfs/xfs_qm_syscalls.c

426

dst->d_ino_timer = 0;

fs/xfs/xfs_qm_syscalls.c

427

dst->d_rt_spc_timer = 0;

fs/xfs/xfs_qm_syscalls.c

437

struct qc_dqblk *dst)

fs/xfs/xfs_qm_syscalls.c

467

xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst);

fs/xfs/xfs_qm_syscalls.c

484

struct qc_dqblk *dst)

fs/xfs/xfs_qm_syscalls.c

500

xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst);

fs/xfs/xfs_refcount_item.c

687

struct xfs_cui_log_format *dst,

fs/xfs/xfs_refcount_item.c

692

memcpy(dst, src, offsetof(struct xfs_cui_log_format, cui_extents));

fs/xfs/xfs_refcount_item.c

695

memcpy(&dst->cui_extents[i], &src->cui_extents[i],

fs/xfs/xfs_rmap_item.c

716

struct xfs_rui_log_format *dst,

fs/xfs/xfs_rmap_item.c

721

memcpy(dst, src, offsetof(struct xfs_rui_log_format, rui_extents));

fs/xfs/xfs_rmap_item.c

724

memcpy(&dst->rui_extents[i], &src->rui_extents[i],

fs/xfs/xfs_trans_priv.h

150

xfs_lsn_t *dst,

fs/xfs/xfs_trans_priv.h

155

*dst = *src;

fs/xfs/xfs_trans_priv.h

162

xfs_lsn_t *dst,

fs/xfs/xfs_trans_priv.h

166

*dst = *src;

include/acpi/acpi_bus.h

38

void acpi_handle_list_replace(struct acpi_handle_list *dst,

include/asm-generic/cacheflush.h

107

#define copy_to_user_page(vma, page, vaddr, dst, src, len) \

include/asm-generic/cacheflush.h

109

instrument_copy_to_user((void __user *)dst, src, len); \

include/asm-generic/cacheflush.h

110

memcpy(dst, src, len); \

include/asm-generic/cacheflush.h

117

#define copy_from_user_page(vma, page, vaddr, dst, src, len) \

include/asm-generic/cacheflush.h

119

instrument_copy_from_user_before(dst, (void __user *)src, \

include/asm-generic/cacheflush.h

121

memcpy(dst, src, len); \

include/asm-generic/cacheflush.h

122

instrument_copy_from_user_after(dst, (void __user *)src, len, \

include/asm-generic/io.h

1268

void memcpy_fromio(void *dst, const volatile void __iomem *src, size_t count);

include/asm-generic/io.h

1280

void memcpy_toio(volatile void __iomem *dst, const void *src, size_t count);

include/asm-generic/uaccess.h

231

__must_check long strncpy_from_user(char *dst, const char __user *src,

include/asm-generic/uaccess.h

67

#define __get_kernel_nofault(dst, src, type, err_label) \

include/asm-generic/uaccess.h

69

*((type *)dst) = get_unaligned((type *)(src)); \

include/asm-generic/uaccess.h

74

#define __put_kernel_nofault(dst, src, type, err_label) \

include/asm-generic/uaccess.h

76

put_unaligned(*((type *)src), (type *)(dst)); \

include/crypto/acompress.h

349

struct scatterlist *dst,

include/crypto/acompress.h

354

req->dst = dst;

include/crypto/acompress.h

454

struct scatterlist *dst,

include/crypto/acompress.h

457

req->dst = dst;

include/crypto/acompress.h

475

u8 *dst, unsigned int dlen)

include/crypto/acompress.h

477

req->dvirt = dst;

include/crypto/acompress.h

495

u8 *dst, unsigned int dlen)

include/crypto/acompress.h

497

req->dvirt = dst;

include/crypto/acompress.h

66

u8 *dst;

include/crypto/acompress.h

92

struct scatterlist *dst;

include/crypto/aead.h

607

struct scatterlist *dst,

include/crypto/aead.h

611

req->dst = dst;

include/crypto/aead.h

99

struct scatterlist *dst;

include/crypto/aes.h

330

void aescfb_encrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,

include/crypto/aes.h

332

void aescfb_decrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,

include/crypto/akcipher.h

238

struct scatterlist *dst,

include/crypto/akcipher.h

243

req->dst = dst;

include/crypto/akcipher.h

315

void *dst, unsigned int dlen);

include/crypto/akcipher.h

33

struct scatterlist *dst;

include/crypto/akcipher.h

333

void *dst, unsigned int dlen);

include/crypto/cast5.h

21

void __cast5_encrypt(struct cast5_ctx *ctx, u8 *dst, const u8 *src);

include/crypto/cast5.h

22

void __cast5_decrypt(struct cast5_ctx *ctx, u8 *dst, const u8 *src);

include/crypto/cast6.h

21

void __cast6_encrypt(const void *ctx, u8 *dst, const u8 *src);

include/crypto/cast6.h

22

void __cast6_decrypt(const void *ctx, u8 *dst, const u8 *src);

include/crypto/chacha.h

88

void chacha_crypt(struct chacha_state *state, u8 *dst, const u8 *src,

include/crypto/chacha.h

92

u8 *dst, const u8 *src, unsigned int bytes)

include/crypto/chacha.h

94

chacha_crypt(state, dst, src, bytes, 20);

include/crypto/chacha20poly1305.h

18

void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

include/crypto/chacha20poly1305.h

24

chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,

include/crypto/chacha20poly1305.h

28

void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

include/crypto/chacha20poly1305.h

34

u8 *dst, const u8 *src, const size_t src_len,

include/crypto/des.h

27

void des_encrypt(const struct des_ctx *ctx, u8 *dst, const u8 *src);

include/crypto/des.h

28

void des_decrypt(const struct des_ctx *ctx, u8 *dst, const u8 *src);

include/crypto/des.h

30

void des3_ede_encrypt(const struct des3_ede_ctx *dctx, u8 *dst, const u8 *src);

include/crypto/des.h

31

void des3_ede_decrypt(const struct des3_ede_ctx *dctx, u8 *dst, const u8 *src);

include/crypto/gcm.h

76

void aesgcm_encrypt(const struct aesgcm_ctx *ctx, u8 *dst, const u8 *src,

include/crypto/gcm.h

80

bool __must_check aesgcm_decrypt(const struct aesgcm_ctx *ctx, u8 *dst,

include/crypto/hash.h

168

int (*clone_tfm)(struct crypto_ahash *dst, struct crypto_ahash *src);

include/crypto/hash.h

266

int (*clone_tfm)(struct crypto_shash *dst, struct crypto_shash *src);

include/crypto/if_alg.h

234

void af_alg_pull_tsgl(struct sock *sk, size_t used, struct scatterlist *dst);

include/crypto/internal/acompress.h

238

req->dst = old->dst;

include/crypto/internal/acompress.h

92

} dst;

include/crypto/internal/cipher.h

165

u8 *dst, const u8 *src);

include/crypto/internal/cipher.h

177

u8 *dst, const u8 *src);

include/crypto/internal/kdf_selftest.h

31

u8 *dst, unsigned int dlen))

include/crypto/internal/poly1305.h

31

void *dst);

include/crypto/internal/scompress.h

28

unsigned int slen, u8 *dst, unsigned int *dlen,

include/crypto/internal/scompress.h

31

unsigned int slen, u8 *dst, unsigned int *dlen,

include/crypto/internal/scompress.h

69

u8 *dst, unsigned int *dlen, void *ctx)

include/crypto/internal/scompress.h

71

return crypto_scomp_alg(tfm)->compress(tfm, src, slen, dst, dlen, ctx);

include/crypto/internal/scompress.h

76

u8 *dst, unsigned int *dlen,

include/crypto/internal/scompress.h

79

return crypto_scomp_alg(tfm)->decompress(tfm, src, slen, dst, dlen,

include/crypto/internal/skcipher.h

76

} dst;

include/crypto/kdf_sp800108.h

33

u8 *dst, unsigned int dlen);

include/crypto/kpp.h

253

req->dst = output;

include/crypto/kpp.h

34

struct scatterlist *dst;

include/crypto/rng.h

142

u8 *dst, unsigned int dlen)

include/crypto/rng.h

144

return crypto_rng_alg(tfm)->generate(tfm, src, slen, dst, dlen);

include/crypto/rng.h

46

u8 *dst, unsigned int dlen);

include/crypto/scatterwalk.h

238

void memcpy_sglist(struct scatterlist *dst, struct scatterlist *src,

include/crypto/scatterwalk.h

252

struct scatterlist *scatterwalk_ffwd(struct scatterlist dst[2],

include/crypto/serpent.h

25

void __serpent_encrypt(const void *ctx, u8 *dst, const u8 *src);

include/crypto/serpent.h

26

void __serpent_decrypt(const void *ctx, u8 *dst, const u8 *src);

include/crypto/sig.h

194

void *dst, unsigned int dlen)

include/crypto/sig.h

198

return alg->sign(tfm, src, slen, dst, dlen);

include/crypto/sig.h

56

void *dst, unsigned int dlen);

include/crypto/skcipher.h

206

u8 *dst, unsigned len, u8 *siv, u32 flags);

include/crypto/skcipher.h

208

u8 *dst, unsigned len, u8 *siv, u32 flags);

include/crypto/skcipher.h

46

struct scatterlist *dst;

include/crypto/skcipher.h

765

u8 *dst, unsigned len, u8 *siv);

include/crypto/skcipher.h

785

u8 *dst, unsigned len, u8 *siv);

include/crypto/skcipher.h

930

struct scatterlist *src, struct scatterlist *dst,

include/crypto/skcipher.h

934

req->dst = dst;

include/crypto/utils.h

14

void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int size);

include/crypto/utils.h

16

static inline void crypto_xor(u8 *dst, const u8 *src, unsigned int size)

include/crypto/utils.h

21

unsigned long *d = (unsigned long *)dst;

include/crypto/utils.h

31

__crypto_xor(dst, dst, src, size);

include/crypto/utils.h

35

static inline void crypto_xor_cpy(u8 *dst, const u8 *src1, const u8 *src2,

include/crypto/utils.h

41

unsigned long *d = (unsigned long *)dst;

include/crypto/utils.h

52

__crypto_xor(dst, src1, src2, size);

include/drm/display/drm_dp_mst_helper.h

503

struct drm_dp_mst_branch *dst;

include/drm/drm_cache.h

85

void drm_memcpy_from_wc(struct iosys_map *dst,

include/drm/drm_format_helper.h

101

void drm_fb_xrgb8888_to_bgr888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

104

void drm_fb_xrgb8888_to_argb8888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

107

void drm_fb_xrgb8888_to_abgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

110

void drm_fb_xrgb8888_to_xbgr8888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

113

void drm_fb_xrgb8888_to_bgrx8888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

116

void drm_fb_xrgb8888_to_xrgb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

120

void drm_fb_xrgb8888_to_argb2101010(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

124

void drm_fb_xrgb8888_to_gray8(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

127

void drm_fb_argb8888_to_argb4444(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

131

void drm_fb_xrgb8888_to_mono(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

135

void drm_fb_xrgb8888_to_gray2(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

73

void drm_fb_memcpy(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

76

void drm_fb_swab(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

80

void drm_fb_xrgb8888_to_rgb332(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

83

void drm_fb_xrgb8888_to_rgb565(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

86

void drm_fb_xrgb8888_to_rgb565be(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

89

void drm_fb_xrgb8888_to_xrgb1555(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

92

void drm_fb_xrgb8888_to_argb1555(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

95

void drm_fb_xrgb8888_to_rgba5551(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_format_helper.h

98

void drm_fb_xrgb8888_to_rgb888(struct iosys_map *dst, const unsigned int *dst_pitch,

include/drm/drm_mipi_dbi.h

205

int mipi_dbi_buf_copy(void *dst, struct iosys_map *src, struct drm_framebuffer *fb,

include/drm/drm_modes.h

537

void drm_mode_copy(struct drm_display_mode *dst,

include/drm/drm_modes.h

539

void drm_mode_init(struct drm_display_mode *dst,

include/drm/drm_plane.h

229

struct drm_rect src, dst;

include/drm/drm_rect.h

233

static inline void drm_rect_fp_to_int(struct drm_rect *dst,

include/drm/drm_rect.h

236

drm_rect_init(dst, src->x1 >> 16, src->y1 >> 16,

include/drm/drm_rect.h

257

bool drm_rect_clip_scaled(struct drm_rect *src, struct drm_rect *dst,

include/drm/drm_rect.h

260

const struct drm_rect *dst,

include/drm/drm_rect.h

263

const struct drm_rect *dst,

include/drm/ttm/ttm_backup.h

58

int ttm_backup_copy_page(struct file *backup, struct page *dst,

include/linux/async_tx.h

100

#define async_tx_find_channel(dep, type, dst, dst_count, src, src_count, len) \

include/linux/async_tx.h

119

enum dma_transaction_type tx_type, struct page **dst,

include/linux/base64.h

19

int base64_encode(const u8 *src, int len, char *dst, bool padding, enum base64_variant variant);

include/linux/base64.h

20

int base64_decode(const char *src, int len, u8 *dst, bool padding, enum base64_variant variant);

include/linux/bio.h

480

extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,

include/linux/bio.h

482

extern void bio_copy_data(struct bio *dst, struct bio *src);

include/linux/bio.h

505

void bio_clone_blkg_association(struct bio *dst, struct bio *src);

include/linux/bio.h

512

static inline void bio_clone_blkg_association(struct bio *dst,

include/linux/bitmap-str.h

13

int bitmap_parse(const char *buf, unsigned int buflen, unsigned long *dst, int nbits);

include/linux/bitmap-str.h

16

unsigned long *dst, int nbits);

include/linux/bitmap-str.h

7

int bitmap_parse_user(const char __user *ubuf, unsigned int ulen, unsigned long *dst, int nbits);

include/linux/bitmap.h

157

void __bitmap_complement(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

159

void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

161

void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

163

void bitmap_cut(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

165

bool __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bitmap.h

167

void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bitmap.h

169

unsigned int __bitmap_weighted_or(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bitmap.h

171

void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bitmap.h

173

bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bitmap.h

175

void __bitmap_replace(unsigned long *dst,

include/linux/bitmap.h

220

void bitmap_remap(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

224

void bitmap_onto(unsigned long *dst, const unsigned long *orig,

include/linux/bitmap.h

226

void bitmap_fold(unsigned long *dst, const unsigned long *orig,

include/linux/bitmap.h

234

static __always_inline void bitmap_zero(unsigned long *dst, unsigned int nbits)

include/linux/bitmap.h

239

*dst = 0;

include/linux/bitmap.h

241

memset(dst, 0, len);

include/linux/bitmap.h

244

static __always_inline void bitmap_fill(unsigned long *dst, unsigned int nbits)

include/linux/bitmap.h

249

*dst = ~0UL;

include/linux/bitmap.h

251

memset(dst, 0xff, len);

include/linux/bitmap.h

255

void bitmap_copy(unsigned long *dst, const unsigned long *src, unsigned int nbits)

include/linux/bitmap.h

260

*dst = *src;

include/linux/bitmap.h

262

memcpy(dst, src, len);

include/linux/bitmap.h

269

void bitmap_copy_clear_tail(unsigned long *dst, const unsigned long *src, unsigned int nbits)

include/linux/bitmap.h

271

bitmap_copy(dst, src, nbits);

include/linux/bitmap.h

273

dst[nbits / BITS_PER_LONG] &= BITMAP_LAST_WORD_MASK(nbits);

include/linux/bitmap.h

325

bool bitmap_and(unsigned long *dst, const unsigned long *src1,

include/linux/bitmap.h

329

return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;

include/linux/bitmap.h

330

return __bitmap_and(dst, src1, src2, nbits);

include/linux/bitmap.h

334

void bitmap_or(unsigned long *dst, const unsigned long *src1,

include/linux/bitmap.h

338

*dst = *src1 | *src2;

include/linux/bitmap.h

340

__bitmap_or(dst, src1, src2, nbits);

include/linux/bitmap.h

344

unsigned int bitmap_weighted_or(unsigned long *dst, const unsigned long *src1,

include/linux/bitmap.h

348

*dst = *src1 | *src2;

include/linux/bitmap.h

349

return hweight_long(*dst & BITMAP_LAST_WORD_MASK(nbits));

include/linux/bitmap.h

351

return __bitmap_weighted_or(dst, src1, src2, nbits);

include/linux/bitmap.h

356

void bitmap_xor(unsigned long *dst, const unsigned long *src1,

include/linux/bitmap.h

360

*dst = *src1 ^ *src2;

include/linux/bitmap.h

362

__bitmap_xor(dst, src1, src2, nbits);

include/linux/bitmap.h

366

bool bitmap_andnot(unsigned long *dst, const unsigned long *src1,

include/linux/bitmap.h

370

return (*dst = *src1 & ~(*src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;

include/linux/bitmap.h

371

return __bitmap_andnot(dst, src1, src2, nbits);

include/linux/bitmap.h

375

void bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int nbits)

include/linux/bitmap.h

378

*dst = ~(*src);

include/linux/bitmap.h

380

__bitmap_complement(dst, src, nbits);

include/linux/bitmap.h

515

void bitmap_shift_right(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

519

*dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> shift;

include/linux/bitmap.h

521

__bitmap_shift_right(dst, src, shift, nbits);

include/linux/bitmap.h

525

void bitmap_shift_left(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

529

*dst = (*src << shift) & BITMAP_LAST_WORD_MASK(nbits);

include/linux/bitmap.h

531

__bitmap_shift_left(dst, src, shift, nbits);

include/linux/bitmap.h

535

void bitmap_replace(unsigned long *dst,

include/linux/bitmap.h

542

*dst = (*old & ~(*mask)) | (*new & *mask);

include/linux/bitmap.h

544

__bitmap_replace(dst, old, new, mask, nbits);

include/linux/bitmap.h

583

void bitmap_scatter(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

589

bitmap_zero(dst, nbits);

include/linux/bitmap.h

592

__assign_bit(bit, dst, test_bit(n++, src));

include/linux/bitmap.h

640

void bitmap_gather(unsigned long *dst, const unsigned long *src,

include/linux/bitmap.h

646

bitmap_zero(dst, nbits);

include/linux/bitmap.h

649

__assign_bit(n++, dst, test_bit(bit, src));

include/linux/bitmap.h

766

static __always_inline void bitmap_from_u64(unsigned long *dst, u64 mask)

include/linux/bitmap.h

768

bitmap_from_arr64(dst, &mask, 64);

include/linux/blk-crypto-profile.h

225

void blk_crypto_update_capabilities(struct blk_crypto_profile *dst,

include/linux/blk-crypto.h

206

int __bio_crypt_clone(struct bio *dst, struct bio *src, gfp_t gfp_mask);

include/linux/blk-crypto.h

218

static inline int bio_crypt_clone(struct bio *dst, struct bio *src,

include/linux/blk-crypto.h

222

return __bio_crypt_clone(dst, src, gfp_mask);

include/linux/bpf.h

1118

struct bpf_insn *dst,

include/linux/bpf.h

1442

int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u64 offset,

include/linux/bpf.h

2336

typedef unsigned long (*bpf_ctx_copy_t)(void *dst, const void *src,

include/linux/bpf.h

2340

struct bpf_insn *dst,

include/linux/bpf.h

2937

int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_frame *xdpf,

include/linux/bpf.h

2941

int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,

include/linux/bpf.h

3206

int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_frame *xdpf,

include/linux/bpf.h

3221

static inline int dev_map_generic_redirect(struct bpf_dtab_netdev *dst,

include/linux/bpf.h

3384

bpf_probe_read_kernel_common(void *dst, u32 size, const void *unsafe_ptr)

include/linux/bpf.h

3389

ret = copy_from_kernel_nofault(dst, unsafe_ptr, size);

include/linux/bpf.h

3391

memset(dst, 0, size);

include/linux/bpf.h

3865

void *bpf_arch_text_copy(void *dst, void *src, size_t len);

include/linux/bpf.h

3866

int bpf_arch_text_invalidate(void *dst, size_t len);

include/linux/bpf.h

508

static inline void check_and_init_map_value(struct bpf_map *map, void *dst)

include/linux/bpf.h

510

bpf_obj_init(map->record, dst);

include/linux/bpf.h

519

static inline void bpf_long_memcpy(void *dst, const void *src, u32 size)

include/linux/bpf.h

522

long *ldst = dst;

include/linux/bpf.h

531

void *dst, void *src, u32 size,

include/linux/bpf.h

539

bpf_long_memcpy(dst, src, round_up(size, 8));

include/linux/bpf.h

541

memcpy(dst, src, size);

include/linux/bpf.h

549

memcpy(dst + curr_off, src + curr_off, sz);

include/linux/bpf.h

552

memcpy(dst + curr_off, src + curr_off, size - curr_off);

include/linux/bpf.h

555

static inline void copy_map_value(struct bpf_map *map, void *dst, void *src)

include/linux/bpf.h

557

bpf_obj_memcpy(map->record, dst, src, map->value_size, false);

include/linux/bpf.h

560

static inline void copy_map_value_long(struct bpf_map *map, void *dst, void *src)

include/linux/bpf.h

562

bpf_obj_memcpy(map->record, dst, src, map->value_size, true);

include/linux/bpf.h

565

static inline void bpf_obj_swap_uptrs(const struct btf_record *rec, void *dst, void *src)

include/linux/bpf.h

579

dst_uptr = dst + field->offset;

include/linux/bpf.h

584

static inline void bpf_obj_memzero(struct btf_record *rec, void *dst, u32 size)

include/linux/bpf.h

590

memset(dst, 0, size);

include/linux/bpf.h

598

memset(dst + curr_off, 0, sz);

include/linux/bpf.h

601

memset(dst + curr_off, 0, size - curr_off);

include/linux/bpf.h

604

static inline void zero_map_value(struct bpf_map *map, void *dst)

include/linux/bpf.h

606

bpf_obj_memzero(map->record, dst, map->value_size);

include/linux/bpf.h

609

void copy_map_value_locked(struct bpf_map *map, void *dst, void *src,

include/linux/bpf.h

620

int bpf_obj_name_cpy(char *dst, const char *src, unsigned int size);

include/linux/bpf_crypto.h

12

int (*encrypt)(void *tfm, const u8 *src, u8 *dst, unsigned int len, u8 *iv);

include/linux/bpf_crypto.h

13

int (*decrypt)(void *tfm, const u8 *src, u8 *dst, unsigned int len, u8 *iv);

include/linux/bpf_mprog.h

253

static inline void bpf_mprog_entry_copy(struct bpf_mprog_entry *dst,

include/linux/bpf_mprog.h

256

memcpy(dst->fp_items, src->fp_items, sizeof(src->fp_items));

include/linux/bpf_mprog.h

259

static inline void bpf_mprog_entry_clear(struct bpf_mprog_entry *dst)

include/linux/bpf_mprog.h

261

memset(dst->fp_items, 0, sizeof(dst->fp_items));

include/linux/bpfptr.h

49

static inline int copy_from_bpfptr_offset(void *dst, bpfptr_t src,

include/linux/bpfptr.h

53

return copy_from_user(dst, src.user + offset, size);

include/linux/bpfptr.h

54

return copy_from_kernel_nofault(dst, src.kernel + offset, size);

include/linux/bpfptr.h

57

static inline int copy_from_bpfptr(void *dst, bpfptr_t src, size_t size)

include/linux/bpfptr.h

59

return copy_from_bpfptr_offset(dst, src, 0, size);

include/linux/bpfptr.h

62

static inline int copy_to_bpfptr_offset(bpfptr_t dst, size_t offset,

include/linux/bpfptr.h

65

return copy_to_sockptr_offset((sockptr_t) dst, offset, src, size);

include/linux/bpfptr.h

82

static inline long strncpy_from_bpfptr(char *dst, bpfptr_t src, size_t count)

include/linux/bpfptr.h

85

return strncpy_from_kernel_nofault(dst, src.kernel, count);

include/linux/bpfptr.h

86

return strncpy_from_user(dst, src.user, count);

include/linux/buffer_head.h

282

struct folio *dst, struct folio *src, enum migrate_mode);

include/linux/buffer_head.h

284

struct folio *dst, struct folio *src, enum migrate_mode);

include/linux/byteorder/generic.h

192

static inline void memcpy_from_le32(u32 *dst, const __le32 *src, size_t words)

include/linux/byteorder/generic.h

197

dst[i] = le32_to_cpu(src[i]);

include/linux/byteorder/generic.h

200

static inline void memcpy_to_le32(__le32 *dst, const u32 *src, size_t words)

include/linux/byteorder/generic.h

205

dst[i] = cpu_to_le32(src[i]);

include/linux/byteorder/generic.h

223

static inline void cpu_to_be32_array(__be32 *dst, const u32 *src, size_t len)

include/linux/byteorder/generic.h

228

dst[i] = cpu_to_be32(src[i]);

include/linux/byteorder/generic.h

231

static inline void be32_to_cpu_array(u32 *dst, const __be32 *src, size_t len)

include/linux/byteorder/generic.h

236

dst[i] = be32_to_cpu(src[i]);

include/linux/ccp.h

182

struct scatterlist *src, *dst;

include/linux/ccp.h

242

struct scatterlist *src, *dst;

include/linux/ccp.h

353

struct scatterlist *src, *dst;

include/linux/ccp.h

381

struct scatterlist *src, *dst;

include/linux/ccp.h

440

struct scatterlist *src, *dst;

include/linux/cgroup.h

802

struct cgroup *dst);

include/linux/clk-provider.h

1434

static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)

include/linux/clk-provider.h

1436

dst->clk = src->clk;

include/linux/clk-provider.h

1437

dst->core = src->core;

include/linux/crypto.h

256

void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);

include/linux/crypto.h

257

void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);

include/linux/damon.h

940

int damos_commit_quota_goals(struct damos_quota *dst, struct damos_quota *src);

include/linux/dma-resv.h

479

int dma_resv_copy_fences(struct dma_resv *dst, struct dma_resv *src);

include/linux/dmaengine.h

904

struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,

include/linux/dmaengine.h

907

struct dma_chan *chan, dma_addr_t dst, dma_addr_t *src,

include/linux/dmaengine.h

913

struct dma_chan *chan, dma_addr_t *dst, dma_addr_t *src,

include/linux/dmar.h

274

static inline void dmar_copy_shared_irte(struct irte *dst, struct irte *src)

include/linux/dmar.h

276

dst->present = src->present;

include/linux/dmar.h

277

dst->fpd = src->fpd;

include/linux/dmar.h

278

dst->avail = src->avail;

include/linux/dmar.h

279

dst->pst = src->pst;

include/linux/dmar.h

280

dst->vector = src->vector;

include/linux/dmar.h

281

dst->sid = src->sid;

include/linux/dmar.h

282

dst->sq = src->sq;

include/linux/dmar.h

283

dst->svt = src->svt;

include/linux/dsa/ocelot.h

182

BUG_ON(ds->dst->tag_ops->proto != DSA_TAG_PROTO_OCELOT_8021Q);

include/linux/dsa/sja1105.h

69

BUG_ON(ds->dst->tag_ops->proto != DSA_TAG_PROTO_SJA1105 &&

include/linux/dsa/sja1105.h

70

ds->dst->tag_ops->proto != DSA_TAG_PROTO_SJA1110);

include/linux/etherdevice.h

302

static inline void ether_addr_copy(u8 *dst, const u8 *src)

include/linux/etherdevice.h

305

*(u32 *)dst = *(const u32 *)src;

include/linux/etherdevice.h

306

*(u16 *)(dst + 4) = *(const u16 *)(src + 4);

include/linux/etherdevice.h

308

u16 *a = (u16 *)dst;

include/linux/etherdevice.h

337

static inline void eth_hw_addr_inherit(struct net_device *dst,

include/linux/etherdevice.h

340

dst->addr_assign_type = src->addr_assign_type;

include/linux/etherdevice.h

341

eth_hw_addr_set(dst, src->dev_addr);

include/linux/ethtool.h

344

void ethtool_intersect_link_masks(struct ethtool_link_ksettings *dst,

include/linux/ethtool.h

347

void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst,

include/linux/fb.h

204

void (*writeio)(struct fb_info *info, void __iomem *dst, void *src, unsigned int size);

include/linux/fb.h

205

void (*readio) (struct fb_info *info, void *dst, void __iomem *src, unsigned int size);

include/linux/fb.h

608

extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,

include/linux/fb.h

610

extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);

include/linux/fb.h

636

static inline void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch,

include/linux/fb.h

646

*dst++ = *src++;

include/linux/fb.h

647

dst += d_pitch;

include/linux/filter.h

1590

int copy_bpf_fprog_from_user(struct sock_fprog *dst, sockptr_t src, int len);

include/linux/fortify-string.h

140

#define unsafe_memcpy(dst, src, bytes, justification) \

include/linux/fortify-string.h

141

__underlying_memcpy(dst, src, bytes)

include/linux/fs.h

431

int (*migrate_folio)(struct address_space *, struct folio *dst,

include/linux/fs_stack.h

13

extern void fsstack_copy_inode_size(struct inode *dst, struct inode *src);

include/linux/hex.h

30

extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);

include/linux/hex.h

31

extern char *bin2hex(char *dst, const void *src, size_t count);

include/linux/highmem.h

490

char *dst = kmap_local_page(dst_page);

include/linux/highmem.h

494

memcpy(dst + dst_off, src + src_off, len);

include/linux/highmem.h

496

kunmap_local(dst);

include/linux/highmem.h

506

char *dst = kmap_local_folio(dst_folio, dst_off);

include/linux/highmem.h

516

memcpy(dst, src, chunk);

include/linux/highmem.h

518

kunmap_local(dst);

include/linux/hugetlb.h

333

static inline int copy_hugetlb_page_range(struct mm_struct *dst,

include/linux/if_bridge.h

29

} dst;

include/linux/if_vlan.h

506

static inline void __vlan_hwaccel_copy_tag(struct sk_buff *dst, const struct sk_buff *src)

include/linux/if_vlan.h

508

dst->vlan_all = src->vlan_all;

include/linux/inet.h

53

extern int in4_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);

include/linux/inet.h

54

extern int in6_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);

include/linux/inetdevice.h

199

__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope);

include/linux/inetdevice.h

200

__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev, __be32 dst,

include/linux/input.h

492

void input_copy_abs(struct input_dev *dst, unsigned int dst_axis,

include/linux/interconnect-provider.h

63

int (*set)(struct icc_node *src, struct icc_node *dst);

include/linux/iosys-map.h

281

static inline void iosys_map_memcpy_to(struct iosys_map *dst, size_t dst_offset,

include/linux/iosys-map.h

284

if (dst->is_iomem)

include/linux/iosys-map.h

285

memcpy_toio(dst->vaddr_iomem + dst_offset, src, len);

include/linux/iosys-map.h

287

memcpy(dst->vaddr + dst_offset, src, len);

include/linux/iosys-map.h

301

static inline void iosys_map_memcpy_from(void *dst, const struct iosys_map *src,

include/linux/iosys-map.h

305

memcpy_fromio(dst, src->vaddr_iomem + src_offset, len);

include/linux/iosys-map.h

307

memcpy(dst, src->vaddr + src_offset, len);

include/linux/iosys-map.h

336

static inline void iosys_map_memset(struct iosys_map *dst, size_t offset,

include/linux/iosys-map.h

339

if (dst->is_iomem)

include/linux/iosys-map.h

340

memset_io(dst->vaddr_iomem + offset, value, len);

include/linux/iosys-map.h

342

memset(dst->vaddr + offset, value, len);

include/linux/kernel_stat.h

105

extern void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu);

include/linux/kernel_stat.h

113

static inline void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu)

include/linux/kernel_stat.h

115

*dst = kcpustat_cpu(cpu);

include/linux/kmsan.h

328

static inline void kmsan_copy_page_meta(struct page *dst, struct page *src)

include/linux/kmsan.h

89

void kmsan_copy_page_meta(struct page *dst, struct page *src);

include/linux/kmsan_string.h

17

void *__msan_memcpy(void *dst, const void *src, size_t size);

include/linux/linkmode.h

10

bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

13

static inline void linkmode_fill(unsigned long *dst)

include/linux/linkmode.h

15

bitmap_fill(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

18

static inline void linkmode_copy(unsigned long *dst, const unsigned long *src)

include/linux/linkmode.h

20

bitmap_copy(dst, src, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

23

static inline void linkmode_and(unsigned long *dst, const unsigned long *a,

include/linux/linkmode.h

26

bitmap_and(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

29

static inline void linkmode_or(unsigned long *dst, const unsigned long *a,

include/linux/linkmode.h

32

bitmap_or(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

40

static inline bool linkmode_andnot(unsigned long *dst,

include/linux/linkmode.h

44

return bitmap_andnot(dst, src1, src2, __ETHTOOL_LINK_MODE_MASK_NBITS);

include/linux/linkmode.h

8

static inline void linkmode_zero(unsigned long *dst)

include/linux/lz4.h

346

int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity,

include/linux/lz4.h

416

char *dst, int srcSize, int maxDstSize);

include/linux/lz4.h

508

char *dst, int srcSize, int maxDstSize, int acceleration);

include/linux/lzo.h

25

unsigned char *dst, size_t *dst_len, void *wrkmem);

include/linux/lzo.h

29

unsigned char *dst, size_t *dst_len, void *wrkmem);

include/linux/lzo.h

33

unsigned char *dst, size_t *dst_len, void *wrkmem);

include/linux/lzo.h

37

unsigned char *dst, size_t *dst_len, void *wrkmem);

include/linux/lzo.h

41

unsigned char *dst, size_t *dst_len);

include/linux/mailbox/brcm-message.h

48

struct scatterlist *dst;

include/linux/mempolicy.h

123

int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst);

include/linux/mempolicy.h

237

vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)

include/linux/mfd/max14577.h

96

unsigned int min_ua, unsigned int max_ua, u8 *dst);

include/linux/migrate.h

168

unsigned long *dst;

include/linux/migrate.h

46

int (*migrate_page)(struct page *dst, struct page *src,

include/linux/migrate.h

57

int migrate_folio(struct address_space *mapping, struct folio *dst,

include/linux/migrate.h

67

struct folio *dst, struct folio *src);

include/linux/migrate.h

91

struct folio *dst, struct folio *src)

include/linux/mm.h

1645

void folio_copy(struct folio *dst, struct folio *src);

include/linux/mm.h

1646

int folio_mc_copy(struct folio *dst, struct folio *src);

include/linux/mm.h

4693

int copy_user_large_folio(struct folio *dst, struct folio *src,

include/linux/mmc/sdio_func.h

148

extern int sdio_memcpy_fromio(struct sdio_func *func, void *dst,

include/linux/mmc/sdio_func.h

150

extern int sdio_readsb(struct sdio_func *func, void *dst,

include/linux/mtd/rawnand.h

1612

void nand_extract_bits(u8 *dst, unsigned int dst_off, const u8 *src,

include/linux/net.h

228

#define DECLARE_SOCKADDR(type, dst, src) \

include/linux/net.h

229

type dst = ({ __sockaddr_check_size(sizeof(*dst)); (type) src; })

include/linux/netfilter.h

375

int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl,

include/linux/netfilter/x_tables.h

153

void (*compat_from_user)(void *dst, const void *src);

include/linux/netfilter/x_tables.h

154

int (*compat_to_user)(void __user *dst, const void *src);

include/linux/netfilter/x_tables.h

194

void (*compat_from_user)(void *dst, const void *src);

include/linux/netfilter/x_tables.h

195

int (*compat_to_user)(void __user *dst, const void *src);

include/linux/netfilter/x_tables.h

291

int xt_data_to_user(void __user *dst, const void *src,

include/linux/netfilter_bridge.h

21

struct dst_entry *dst = skb_dst(skb);

include/linux/netfilter_bridge.h

23

if (dst && (dst->flags & DST_FAKE_RTABLE))

include/linux/netfilter_ipv4.h

26

int nf_ip_route(struct net *net, struct dst_entry **dst, struct flowi *fl,

include/linux/netfilter_ipv4.h

34

static inline int nf_ip_route(struct net *net, struct dst_entry **dst,

include/linux/netfilter_ipv6.h

106

return v6ops->route(net, dst, fl, strict);

include/linux/netfilter_ipv6.h

111

return __nf_ip6_route(net, dst, fl, strict);

include/linux/netfilter_ipv6.h

49

int (*route)(struct net *net, struct dst_entry **dst, struct flowi *fl,

include/linux/netfilter_ipv6.h

96

int __nf_ip6_route(struct net *net, struct dst_entry **dst,

include/linux/netfilter_ipv6.h

99

static inline int nf_ip6_route(struct net *net, struct dst_entry **dst,

include/linux/nodemask.h

124

#define node_set(node, dst) __node_set((node), &(dst))

include/linux/nodemask.h

130

#define node_clear(node, dst) __node_clear((node), &(dst))

include/linux/nodemask.h

136

#define nodes_setall(dst) __nodes_setall(&(dst), MAX_NUMNODES)

include/linux/nodemask.h

142

#define nodes_clear(dst) __nodes_clear(&(dst), MAX_NUMNODES)

include/linux/nodemask.h

158

#define nodes_and(dst, src1, src2) \

include/linux/nodemask.h

159

__nodes_and(&(dst), &(src1), &(src2), MAX_NUMNODES)

include/linux/nodemask.h

166

#define nodes_or(dst, src1, src2) \

include/linux/nodemask.h

167

__nodes_or(&(dst), &(src1), &(src2), MAX_NUMNODES)

include/linux/nodemask.h

174

#define nodes_xor(dst, src1, src2) \

include/linux/nodemask.h

175

__nodes_xor(&(dst), &(src1), &(src2), MAX_NUMNODES)

include/linux/nodemask.h

182

#define nodes_andnot(dst, src1, src2) \

include/linux/nodemask.h

183

__nodes_andnot(&(dst), &(src1), &(src2), MAX_NUMNODES)

include/linux/nodemask.h

190

#define nodes_copy(dst, src) __nodes_copy(&(dst), &(src), MAX_NUMNODES)

include/linux/nodemask.h

197

#define nodes_complement(dst, src) \

include/linux/nodemask.h

198

__nodes_complement(&(dst), &(src), MAX_NUMNODES)

include/linux/nodemask.h

325

#define nodemask_parse_user(ubuf, ulen, dst) \

include/linux/nodemask.h

326

__nodemask_parse_user((ubuf), (ulen), &(dst), MAX_NUMNODES)

include/linux/nodemask.h

333

#define nodelist_parse(buf, dst) __nodelist_parse((buf), &(dst), MAX_NUMNODES)

include/linux/nodemask.h

347

#define nodes_remap(dst, src, old, new) \

include/linux/nodemask.h

348

__nodes_remap(&(dst), &(src), &(old), &(new), MAX_NUMNODES)

include/linux/nodemask.h

355

#define nodes_onto(dst, orig, relmap) \

include/linux/nodemask.h

356

__nodes_onto(&(dst), &(orig), &(relmap), MAX_NUMNODES)

include/linux/nodemask.h

363

#define nodes_fold(dst, orig, sz) \

include/linux/nodemask.h

364

__nodes_fold(&(dst), &(orig), sz, MAX_NUMNODES)

include/linux/pagemap.h

1268

int filemap_migrate_folio(struct address_space *mapping, struct folio *dst,

include/linux/perf_event.h

72

typedef unsigned long (*perf_copy_f)(void *dst, const void *src,

include/linux/phy.h

182

static inline void phy_interface_and(unsigned long *dst, const unsigned long *a,

include/linux/phy.h

185

bitmap_and(dst, a, b, PHY_INTERFACE_MODE_MAX);

include/linux/phy.h

188

static inline void phy_interface_or(unsigned long *dst, const unsigned long *a,

include/linux/phy.h

191

bitmap_or(dst, a, b, PHY_INTERFACE_MODE_MAX);

include/linux/ptrace.h

51

extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);

include/linux/ptrace.h

52

extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);

include/linux/qed/qed_iscsi_if.h

60

struct qed_iscsi_id_params dst;

include/linux/qed/qed_nvmetcp_if.h

47

struct qed_nvmetcp_id_params dst;

include/linux/rio.h

234

void (*dinb) (struct rio_mport *mport, void *dev_id, u16 src, u16 dst, u16 info);

include/linux/rmap.h

937

void remove_migration_ptes(struct folio *src, struct folio *dst,

include/linux/rpmsg.h

186

int rpmsg_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst);

include/linux/rpmsg.h

189

int rpmsg_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst);

include/linux/rpmsg.h

196

int rpmsg_set_flow_control(struct rpmsg_endpoint *ept, bool pause, u32 dst);

include/linux/rpmsg.h

261

u32 dst)

include/linux/rpmsg.h

279

int len, u32 dst)

include/linux/rpmsg.h

304

static inline int rpmsg_set_flow_control(struct rpmsg_endpoint *ept, bool pause, u32 dst)

include/linux/rpmsg.h

37

u32 dst;

include/linux/rpmsg.h

58

u32 dst;

include/linux/rtnetlink.h

25

extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,

include/linux/sched.h

1900

extern int dup_user_cpus_ptr(struct task_struct *dst, struct task_struct *src, int node);

include/linux/skbuff.h

1215

static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)

include/linux/skbuff.h

1218

skb->slow_gro |= !!dst;

include/linux/skbuff.h

1219

skb->_skb_refdst = (unsigned long)dst;

include/linux/skbuff.h

1232

static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)

include/linux/skbuff.h

1236

skb->slow_gro |= !!dst;

include/linux/skbuff.h

1237

skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;

include/linux/skbuff.h

1436

struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);

include/linux/skbuff.h

4260

int skb_eth_push(struct sk_buff *skb, const unsigned char *dst,

include/linux/skbuff.h

5041

static inline void __skb_ext_copy(struct sk_buff *dst,

include/linux/skbuff.h

5044

dst->active_extensions = src->active_extensions;

include/linux/skbuff.h

5050

dst->extensions = ext;

include/linux/skbuff.h

5054

static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *src)

include/linux/skbuff.h

5056

skb_ext_put(dst);

include/linux/skbuff.h

5057

__skb_ext_copy(dst, src);

include/linux/skbuff.h

5105

static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *s) {}

include/linux/skbuff.h

5132

static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src,

include/linux/skbuff.h

5136

dst->_nfct = src->_nfct;

include/linux/skbuff.h

5141

dst->nf_trace = src->nf_trace;

include/linux/skbuff.h

5145

static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)

include/linux/skbuff.h

5148

nf_conntrack_put(skb_nfct(dst));

include/linux/skbuff.h

5150

dst->slow_gro = src->slow_gro;

include/linux/skbuff.h

5151

__nf_copy(dst, src, true);

include/linux/skmsg.h

128

int sk_msg_clone(struct sock *sk, struct sk_msg *dst, struct sk_msg *src,

include/linux/skmsg.h

198

static inline void sk_msg_xfer(struct sk_msg *dst, struct sk_msg *src,

include/linux/skmsg.h

201

dst->sg.data[which] = src->sg.data[which];

include/linux/skmsg.h

202

dst->sg.data[which].length = size;

include/linux/skmsg.h

203

dst->sg.size += size;

include/linux/skmsg.h

209

static inline void sk_msg_xfer_full(struct sk_msg *dst, struct sk_msg *src)

include/linux/skmsg.h

211

memcpy(dst, src, sizeof(*src));

include/linux/smp_types.h

65

u16 src, dst;

include/linux/sockptr.h

106

memcpy(dst, src.kernel, size);

include/linux/sockptr.h

110

static inline int copy_to_sockptr_offset(sockptr_t dst, size_t offset,

include/linux/sockptr.h

113

if (!sockptr_is_kernel(dst))

include/linux/sockptr.h

114

return copy_to_user(dst.user + offset, src, size);

include/linux/sockptr.h

115

memcpy(dst.kernel + offset, src, size);

include/linux/sockptr.h

119

static inline int copy_to_sockptr(sockptr_t dst, const void *src, size_t size)

include/linux/sockptr.h

121

return copy_to_sockptr_offset(dst, 0, src, size);

include/linux/sockptr.h

153

static inline long strncpy_from_sockptr(char *dst, sockptr_t src, size_t count)

include/linux/sockptr.h

158

memcpy(dst, src.kernel, len);

include/linux/sockptr.h

161

return strncpy_from_user(dst, src.user, count);

include/linux/sockptr.h

44

static inline int copy_from_sockptr_offset(void *dst, sockptr_t src,

include/linux/sockptr.h

48

return copy_from_user(dst, src.user + offset, size);

include/linux/sockptr.h

49

memcpy(dst, src.kernel + offset, size);

include/linux/sockptr.h

59

static inline int copy_from_sockptr(void *dst, sockptr_t src, size_t size)

include/linux/sockptr.h

61

return copy_from_sockptr_offset(dst, src, 0, size);

include/linux/sockptr.h

77

static inline int copy_safe_from_sockptr(void *dst, size_t ksize,

include/linux/sockptr.h

82

if (copy_from_sockptr(dst, optval, ksize))

include/linux/sockptr.h

87

static inline int copy_struct_from_sockptr(void *dst, size_t ksize,

include/linux/sockptr.h

94

return copy_struct_from_user(dst, ksize, src.user, size);

include/linux/sockptr.h

97

memset(dst + size, 0, rest);

include/linux/sram.h

11

static inline void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src,

include/linux/sram.h

9

void *sram_exec_copy(struct gen_pool *pool, void *dst, void *src, size_t size);

include/linux/string.h

113

#define strscpy(dst, src, ...) \

include/linux/string.h

114

CONCATENATE(__strscpy, COUNT_ARGS(__VA_ARGS__))(dst, src, __VA_ARGS__)

include/linux/string.h

148

#define strscpy_pad(dst, src, ...) \

include/linux/string.h

149

CONCATENATE(__strscpy_pad, COUNT_ARGS(__VA_ARGS__))(dst, src, __VA_ARGS__)

include/linux/string.h

278

static inline void memcpy_flushcache(void *dst, const void *src, size_t cnt)

include/linux/string.h

280

memcpy(dst, src, cnt);

include/linux/string.h

389

#define unsafe_memcpy(dst, src, bytes, justification) \

include/linux/string.h

390

memcpy(dst, src, bytes)

include/linux/string.h

79

#define __strscpy0(dst, src, ...) \

include/linux/string.h

80

sized_strscpy(dst, src, sizeof(dst) + __must_be_array(dst) + \

include/linux/string.h

81

__must_be_cstr(dst) + __must_be_cstr(src))

include/linux/string.h

82

#define __strscpy1(dst, src, size) \

include/linux/string.h

83

sized_strscpy(dst, src, size + __must_be_cstr(dst) + __must_be_cstr(src))

include/linux/string.h

85

#define __strscpy_pad0(dst, src, ...) \

include/linux/string.h

86

sized_strscpy_pad(dst, src, sizeof(dst) + __must_be_array(dst) + \

include/linux/string.h

87

__must_be_cstr(dst) + __must_be_cstr(src))

include/linux/string.h

88

#define __strscpy_pad1(dst, src, size) \

include/linux/string.h

89

sized_strscpy_pad(dst, src, size + __must_be_cstr(dst) + __must_be_cstr(src))

include/linux/string_helpers.h

102

*dst++ = toupper(*src);

include/linux/string_helpers.h

106

static inline void string_lower(char *dst, const char *src)

include/linux/string_helpers.h

109

*dst++ = tolower(*src);

include/linux/string_helpers.h

46

int string_unescape(char *src, char *dst, size_t size, unsigned int flags);

include/linux/string_helpers.h

53

static inline int string_unescape_any(char *src, char *dst, size_t size)

include/linux/string_helpers.h

55

return string_unescape(src, dst, size, UNESCAPE_ANY);

include/linux/string_helpers.h

78

int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,

include/linux/string_helpers.h

82

char *dst, size_t osz, const char *only)

include/linux/string_helpers.h

84

return string_escape_mem(src, isz, dst, osz, ESCAPE_ANY_NP, only);

include/linux/string_helpers.h

87

static inline int string_escape_str(const char *src, char *dst, size_t sz,

include/linux/string_helpers.h

90

return string_escape_mem(src, strlen(src), dst, sz, flags, only);

include/linux/string_helpers.h

93

static inline int string_escape_str_any_np(const char *src, char *dst,

include/linux/string_helpers.h

96

return string_escape_str(src, dst, sz, ESCAPE_ANY_NP, only);

include/linux/string_helpers.h

99

static inline void string_upper(char *dst, const char *src)

include/linux/sunrpc/addr.h

103

static inline bool __rpc_copy_addr6(struct sockaddr *dst,

include/linux/sunrpc/addr.h

157

static inline bool rpc_copy_addr(struct sockaddr *dst,

include/linux/sunrpc/addr.h

162

return __rpc_copy_addr4(dst, src);

include/linux/sunrpc/addr.h

164

return __rpc_copy_addr6(dst, src);

include/linux/sunrpc/addr.h

59

static inline bool __rpc_copy_addr4(struct sockaddr *dst,

include/linux/sunrpc/addr.h

63

struct sockaddr_in *dsin = (struct sockaddr_in *) dst;

include/linux/sunrpc/addr.h

85

static inline bool __rpc_copy_addr6(struct sockaddr *dst,

include/linux/sunrpc/addr.h

89

struct sockaddr_in6 *dsin6 = (struct sockaddr_in6 *) dst;

include/linux/sunrpc/xdr.h

173

static inline void xdr_netobj_dup(struct xdr_netobj *dst,

include/linux/sunrpc/xdr.h

176

dst->data = kmemdup(src->data, src->len, gfp_mask);

include/linux/sunrpc/xdr.h

177

dst->len = src->len;

include/linux/sw842.h

11

u8 *dst, unsigned int *destlen);

include/linux/sw842.h

8

u8 *dst, unsigned int *destlen, void *wmem);

include/linux/task_io_accounting_ops.h

102

static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,

include/linux/task_io_accounting_ops.h

108

static inline void task_io_accounting_add(struct task_io_accounting *dst,

include/linux/task_io_accounting_ops.h

111

task_chr_io_accounting_add(dst, src);

include/linux/task_io_accounting_ops.h

112

task_blk_io_accounting_add(dst, src);

include/linux/task_io_accounting_ops.h

49

static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,

include/linux/task_io_accounting_ops.h

52

dst->read_bytes += src->read_bytes;

include/linux/task_io_accounting_ops.h

53

dst->write_bytes += src->write_bytes;

include/linux/task_io_accounting_ops.h

54

dst->cancelled_write_bytes += src->cancelled_write_bytes;

include/linux/task_io_accounting_ops.h

85

static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,

include/linux/task_io_accounting_ops.h

93

static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,

include/linux/task_io_accounting_ops.h

96

dst->rchar += src->rchar;

include/linux/task_io_accounting_ops.h

97

dst->wchar += src->wchar;

include/linux/task_io_accounting_ops.h

98

dst->syscr += src->syscr;

include/linux/task_io_accounting_ops.h

99

dst->syscw += src->syscw;

include/linux/tcp.h

647

static inline bool dst_tcp_usec_ts(const struct dst_entry *dst)

include/linux/tcp.h

649

return dst_feature(dst, RTAX_FEATURE_TCP_USEC_TS);

include/linux/text-patching.h

10

return memcpy(dst, src, len);

include/linux/text-patching.h

8

static inline void *text_poke_copy(void *dst, const void *src, size_t len)

include/linux/textsearch.h

78

const u8 **dst,

include/linux/thread_info.h

233

int arch_dup_task_struct(struct task_struct *dst,

include/linux/ti-emif-sram.h

135

int ti_emif_copy_pm_function_table(struct gen_pool *sram_pool, void *dst);

include/linux/turris-omnia-mcu-interface.h

328

unsigned long bits, unsigned long *dst)

include/linux/turris-omnia-mcu-interface.h

334

*dst = 0;

include/linux/turris-omnia-mcu-interface.h

343

*dst = le32_to_cpu(reply) & bits;

include/linux/turris-omnia-mcu-interface.h

362

u32 *dst)

include/linux/turris-omnia-mcu-interface.h

371

*dst = le32_to_cpu(reply);

include/linux/turris-omnia-mcu-interface.h

377

u16 *dst)

include/linux/turris-omnia-mcu-interface.h

386

*dst = le16_to_cpu(reply);

include/linux/u64_stats_sync.h

137

static inline void *u64_stats_copy(void *dst, const void *src, size_t len)

include/linux/u64_stats_sync.h

140

return memcpy(dst, src, len);

include/linux/u64_stats_sync.h

82

static inline void *u64_stats_copy(void *dst, const void *src, size_t len)

include/linux/u64_stats_sync.h

86

((u64 *)dst)[i] = local64_read(&((local64_t *)src)[i]);

include/linux/u64_stats_sync.h

87

return dst;

include/linux/uaccess.h

246

copy_mc_to_kernel(void *dst, const void *src, size_t cnt)

include/linux/uaccess.h

248

memcpy(dst, src, cnt);

include/linux/uaccess.h

395

copy_struct_from_user(void *dst, size_t ksize, const void __user *src,

include/linux/uaccess.h

402

if (WARN_ON_ONCE(ksize > __builtin_object_size(dst, 1)))

include/linux/uaccess.h

407

memset(dst + size, 0, rest);

include/linux/uaccess.h

414

if (copy_from_user(dst, src, size))

include/linux/uaccess.h

492

copy_struct_to_user(void __user *dst, size_t usize, const void *src,

include/linux/uaccess.h

504

if (clear_user(dst + size, rest))

include/linux/uaccess.h

511

if (copy_to_user(dst, src, size))

include/linux/uaccess.h

518

long copy_from_kernel_nofault(void *dst, const void *src, size_t size);

include/linux/uaccess.h

519

long notrace copy_to_kernel_nofault(void *dst, const void *src, size_t size);

include/linux/uaccess.h

521

long copy_from_user_nofault(void *dst, const void __user *src, size_t size);

include/linux/uaccess.h

522

long notrace copy_to_user_nofault(void __user *dst, const void *src,

include/linux/uaccess.h

525

long strncpy_from_kernel_nofault(char *dst, const void *unsafe_addr,

include/linux/uaccess.h

528

long strncpy_from_user_nofault(char *dst, const void __user *unsafe_addr,

include/linux/uaccess.h

538

#define __get_kernel_nofault(dst, src, type, label) \

include/linux/uaccess.h

541

arch_get_kernel_nofault(dst, src, type, local_label); \

include/linux/uaccess.h

548

#define __put_kernel_nofault(dst, src, type, label) \

include/linux/uaccess.h

551

arch_put_kernel_nofault(dst, src, type, local_label); \

include/linux/uaccess.h

560

#define __get_kernel_nofault(dst, src, type, label) \

include/linux/uaccess.h

566

*(type *)dst = data; \

include/linux/uaccess.h

569

#define __put_kernel_nofault(dst, src, type, label) \

include/linux/uaccess.h

571

type __user *p = (type __force __user *)(dst); \

include/linux/ucs2_string.h

13

ssize_t ucs2_strscpy(ucs2_char_t *dst, const ucs2_char_t *src, size_t count);

include/linux/uprobes.h

240

extern void uprobe_copy_from_page(struct page *page, unsigned long vaddr, void *dst, int len);

include/linux/uuid.h

51

static inline void guid_copy(guid_t *dst, const guid_t *src)

include/linux/uuid.h

53

memcpy(dst, src, sizeof(guid_t));

include/linux/uuid.h

56

static inline void import_guid(guid_t *dst, const __u8 *src)

include/linux/uuid.h

58

memcpy(dst, src, sizeof(guid_t));

include/linux/uuid.h

61

static inline void export_guid(__u8 *dst, const guid_t *src)

include/linux/uuid.h

63

memcpy(dst, src, sizeof(guid_t));

include/linux/uuid.h

76

static inline void uuid_copy(uuid_t *dst, const uuid_t *src)

include/linux/uuid.h

78

memcpy(dst, src, sizeof(uuid_t));

include/linux/uuid.h

81

static inline void import_uuid(uuid_t *dst, const __u8 *src)

include/linux/uuid.h

83

memcpy(dst, src, sizeof(uuid_t));

include/linux/uuid.h

86

static inline void export_uuid(__u8 *dst, const uuid_t *src)

include/linux/uuid.h

88

memcpy(dst, src, sizeof(uuid_t));

include/linux/vmw_vmci_defs.h

517

struct vmci_handle dst;

include/linux/vringh.h

166

ssize_t vringh_iov_pull_user(struct vringh_iov *riov, void *dst, size_t len);

include/linux/vringh.h

310

void *dst, size_t len);

include/linux/wmi.h

65

ssize_t wmi_string_to_utf8s(const struct wmi_string *str, u8 *dst, size_t length);

include/linux/xarray.h

367

unsigned int xa_extract(struct xarray *, void **dst, unsigned long start,

include/linux/zlib.h

597

extern int zlib_inflate_blob(void *dst, unsigned dst_sz, const void *src, unsigned src_sz);

include/linux/zstd.h

241

size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,

include/linux/zstd.h

305

size_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,

include/linux/zstd.h

346

size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,

include/linux/zstd.h

410

void *dst, size_t dst_capacity, const void *src, size_t src_size,

include/linux/zstd.h

686

size_t zstd_compress_sequences_and_literals(zstd_cctx *cctx, void* dst, size_t dst_capacity,

include/linux/zstd_lib.h

1013

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

139

ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

152

ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1648

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1673

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1692

ZSTDLIB_STATIC_API size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1707

ZSTDLIB_STATIC_API size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1957

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

1969

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

2404

void* dst, size_t dstCapacity, size_t* dstPos,

include/linux/zstd_lib.h

2579

void* dst, size_t dstCapacity, size_t* dstPos,

include/linux/zstd_lib.h

272

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

292

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

3003

ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

include/linux/zstd_lib.h

3005

ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

include/linux/zstd_lib.h

3096

ZSTDLIB_STATIC_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

include/linux/zstd_lib.h

3153

ZSTDLIB_STATIC_API size_t ZSTD_compressBlock (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

include/linux/zstd_lib.h

3155

ZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

include/linux/zstd_lib.h

603

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

687

void* dst; /*< start of output buffer */

include/linux/zstd_lib.h

944

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

956

void* dst, size_t dstCapacity,

include/linux/zstd_lib.h

992

void* dst, size_t dstCapacity,

include/media/dvb_demux.h

213

void (*memcopy)(struct dvb_demux_feed *feed, u8 *dst,

include/media/vsp1.h

68

struct v4l2_rect dst;

include/net/af_vsock.h

219

struct sockaddr_vm *dst);

include/net/af_vsock.h

223

struct sockaddr_vm *dst,

include/net/bluetooth/bluetooth.h

387

static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)

include/net/bluetooth/bluetooth.h

389

memcpy(dst, src, sizeof(bdaddr_t));

include/net/bluetooth/bluetooth.h

392

void baswap(bdaddr_t *dst, const bdaddr_t *src);

include/net/bluetooth/hci.h

3413

static inline void hci_cpu_to_le24(__u32 val, __u8 dst[3])

include/net/bluetooth/hci.h

3415

dst[0] = val & 0xff;

include/net/bluetooth/hci.h

3416

dst[1] = (val & 0xff00) >> 8;

include/net/bluetooth/hci.h

3417

dst[2] = (val & 0xff0000) >> 16;

include/net/bluetooth/hci_core.h

1159

if (bacmp(&c->dst, ba) || c->type != BIS_LINK)

include/net/bluetooth/hci_core.h

1207

if (bacmp(&c->dst, ba) || c->type != BIS_LINK ||

include/net/bluetooth/hci_core.h

1250

if (c->type == type && !bacmp(&c->dst, ba)) {

include/net/bluetooth/hci_core.h

1271

if (c->type == type && c->role == role && !bacmp(&c->dst, ba)) {

include/net/bluetooth/hci_core.h

1295

if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {

include/net/bluetooth/hci_core.h

1330

if (!ba || (ba_type == c->dst_type && !bacmp(&c->dst, ba))) {

include/net/bluetooth/hci_core.h

1576

struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1579

bdaddr_t *dst, u8 dst_type, u8 role);

include/net/bluetooth/hci_core.h

1588

struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1592

struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1596

struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1599

struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1602

struct hci_conn *hci_bind_cis(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1605

struct hci_conn *hci_bind_bis(struct hci_dev *hdev, bdaddr_t *dst, __u8 sid,

include/net/bluetooth/hci_core.h

1608

int hci_past_bis(struct hci_conn *conn, bdaddr_t *dst, __u8 dst_type);

include/net/bluetooth/hci_core.h

1609

struct hci_conn *hci_connect_cis(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1612

struct hci_conn *hci_connect_bis(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1616

struct hci_conn *hci_pa_create_sync(struct hci_dev *hdev, bdaddr_t *dst,

include/net/bluetooth/hci_core.h

1757

struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);

include/net/bluetooth/hci_core.h

684

bdaddr_t dst;

include/net/bluetooth/l2cap.h

521

bdaddr_t dst;

include/net/bluetooth/l2cap.h

958

bdaddr_t *dst, u8 dst_type, u16 timeout);

include/net/bluetooth/rfcomm.h

236

int rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst,

include/net/bluetooth/rfcomm.h

244

struct rfcomm_dlc *rfcomm_dlc_exists(bdaddr_t *src, bdaddr_t *dst, u8 channel);

include/net/bluetooth/rfcomm.h

277

bdaddr_t *dst);

include/net/bluetooth/rfcomm.h

306

bdaddr_t dst;

include/net/bluetooth/rfcomm.h

343

bdaddr_t dst;

include/net/bluetooth/rfcomm.h

352

bdaddr_t dst;

include/net/bonding.h

459

static inline void bond_hw_addr_copy(u8 *dst, const u8 *src, unsigned int len)

include/net/bonding.h

462

ether_addr_copy(dst, src);

include/net/bonding.h

466

memcpy(dst, src, len);

include/net/bonding.h

656

static inline __be32 bond_confirm_addr(struct net_device *dev, __be32 dst, __be32 local)

include/net/bonding.h

665

addr = inet_confirm_addr(dev_net(dev), in_dev, dst, local,

include/net/cfg80211.h

3740

__be32 src, dst;

include/net/cfg80211.h

4968

const u8 *dst, const u8 *next_hop);

include/net/cfg80211.h

4970

const u8 *dst);

include/net/cfg80211.h

4972

const u8 *dst, const u8 *next_hop);

include/net/cfg80211.h

4974

u8 *dst, u8 *next_hop, struct mpath_info *pinfo);

include/net/cfg80211.h

4976

int idx, u8 *dst, u8 *next_hop,

include/net/cfg80211.h

4979

u8 *dst, u8 *mpp, struct mpath_info *pinfo);

include/net/cfg80211.h

4981

int idx, u8 *dst, u8 *mpp,

include/net/checksum.h

28

__wsum csum_and_copy_from_user (const void __user *src, void *dst,

include/net/checksum.h

31

if (copy_from_user(dst, src, len))

include/net/checksum.h

33

return csum_partial(dst, len, ~0U);

include/net/checksum.h

39

(const void *src, void __user *dst, int len)

include/net/checksum.h

43

if (copy_to_user(dst, src, len) == 0)

include/net/checksum.h

51

csum_partial_copy_nocheck(const void *src, void *dst, int len)

include/net/checksum.h

53

memcpy(dst, src, len);

include/net/checksum.h

54

return csum_partial(dst, len, 0);

include/net/dsa.h

184

list_for_each_entry((_dp), &(_ds)->dst->ports, list) \

include/net/dsa.h

187

static inline struct dsa_lag *dsa_lag_by_id(struct dsa_switch_tree *dst,

include/net/dsa.h

191

return dst->lags[id - 1];

include/net/dsa.h

194

static inline int dsa_lag_id(struct dsa_switch_tree *dst,

include/net/dsa.h

199

dsa_lags_foreach_id(id, dst) {

include/net/dsa.h

200

struct dsa_lag *lag = dsa_lag_by_id(dst, id);

include/net/dsa.h

254

struct dsa_switch_tree *dst;

include/net/dsa.h

385

struct dsa_switch_tree *dst;

include/net/dsa.h

515

struct dsa_switch_tree *dst = ds->dst;

include/net/dsa.h

518

list_for_each_entry(dp, &dst->ports, list)

include/net/dsa.h

584

list_for_each_entry((_dp), &(_ds)->dst->ports, list) \

include/net/dsa.h

588

list_for_each_entry_safe((_dp), (_next), &(_ds)->dst->ports, list) \

include/net/dsa.h

592

list_for_each_entry_continue_reverse((_dp), &(_ds)->dst->ports, list) \

include/net/dsa.h

640

struct dsa_switch_tree *dst = ds->dst;

include/net/dsa.h

643

list_for_each_entry(dl, &dst->rtable, list)

include/net/dsa.h

808

static inline bool dsa_tree_offloads_bridge_port(struct dsa_switch_tree *dst,

include/net/dsa.h

813

list_for_each_entry(dp, &dst->ports, list)

include/net/dsa.h

822

dsa_tree_offloads_bridge_dev(struct dsa_switch_tree *dst,

include/net/dsa.h

827

list_for_each_entry(dp, &dst->ports, list)

include/net/dsa.h

837

return a->ds->dst == b->ds->dst;

include/net/dst.h

106

u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old);

include/net/dst.h

115

static inline bool dst_metrics_read_only(const struct dst_entry *dst)

include/net/dst.h

117

return dst->_metrics & DST_METRICS_READ_ONLY;

include/net/dst.h

120

void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old);

include/net/dst.h

122

static inline void dst_destroy_metrics_generic(struct dst_entry *dst)

include/net/dst.h

124

unsigned long val = dst->_metrics;

include/net/dst.h

126

__dst_destroy_metrics_generic(dst, val);

include/net/dst.h

129

static inline u32 *dst_metrics_write_ptr(struct dst_entry *dst)

include/net/dst.h

131

unsigned long p = dst->_metrics;

include/net/dst.h

136

return dst->ops->cow_metrics(dst, p);

include/net/dst.h

143

static inline void dst_init_metrics(struct dst_entry *dst,

include/net/dst.h

147

dst->_metrics = ((unsigned long) src_metrics) |

include/net/dst.h

162

static inline u32 *dst_metrics_ptr(struct dst_entry *dst)

include/net/dst.h

164

return DST_METRICS_PTR(dst);

include/net/dst.h

168

dst_metric_raw(const struct dst_entry *dst, const int metric)

include/net/dst.h

170

u32 *p = DST_METRICS_PTR(dst);

include/net/dst.h

176

dst_metric(const struct dst_entry *dst, const int metric)

include/net/dst.h

181

return dst_metric_raw(dst, metric);

include/net/dst.h

185

dst_metric_advmss(const struct dst_entry *dst)

include/net/dst.h

187

u32 advmss = dst_metric_raw(dst, RTAX_ADVMSS);

include/net/dst.h

190

advmss = dst->ops->default_advmss(dst);

include/net/dst.h

195

static inline void dst_metric_set(struct dst_entry *dst, int metric, u32 val)

include/net/dst.h

197

u32 *p = dst_metrics_write_ptr(dst);

include/net/dst.h

210

dst_feature(const struct dst_entry *dst, u32 feature)

include/net/dst.h

212

return dst_metric(dst, RTAX_FEATURES) & feature;

include/net/dst.h

217

static inline u32 dst_mtu(const struct dst_entry *dst)

include/net/dst.h

219

return INDIRECT_CALL_INET(dst->ops->mtu, ip6_mtu, ipv4_mtu, dst);

include/net/dst.h

223

static inline u32 dst4_mtu(const struct dst_entry *dst)

include/net/dst.h

225

return INDIRECT_CALL_1(dst->ops->mtu, ipv4_mtu, dst);

include/net/dst.h

229

static inline unsigned long dst_metric_rtt(const struct dst_entry *dst, int metric)

include/net/dst.h

231

return msecs_to_jiffies(dst_metric(dst, metric));

include/net/dst.h

235

dst_metric_locked(const struct dst_entry *dst, int metric)

include/net/dst.h

237

return dst_metric(dst, RTAX_LOCK) & (1 << metric);

include/net/dst.h

240

static inline void dst_hold(struct dst_entry *dst)

include/net/dst.h

247

WARN_ON(!rcuref_get(&dst->__rcuref));

include/net/dst.h

250

static inline void dst_use_noref(struct dst_entry *dst, unsigned long time)

include/net/dst.h

252

if (unlikely(time != READ_ONCE(dst->lastuse))) {

include/net/dst.h

253

dst->__use++;

include/net/dst.h

254

WRITE_ONCE(dst->lastuse, time);

include/net/dst.h

258

static inline struct dst_entry *dst_clone(struct dst_entry *dst)

include/net/dst.h

260

if (dst)

include/net/dst.h

261

dst_hold(dst);

include/net/dst.h

262

return dst;

include/net/dst.h

265

void dst_release(struct dst_entry *dst);

include/net/dst.h

267

void dst_release_immediate(struct dst_entry *dst);

include/net/dst.h

309

static inline bool dst_hold_safe(struct dst_entry *dst)

include/net/dst.h

311

return rcuref_get(&dst->__rcuref);

include/net/dst.h

324

struct dst_entry *dst = skb_dst(skb);

include/net/dst.h

327

if (!dst_hold_safe(dst))

include/net/dst.h

328

dst = NULL;

include/net/dst.h

330

skb->_skb_refdst = (unsigned long)dst;

include/net/dst.h

331

skb->slow_gro |= !!dst;

include/net/dst.h

383

const struct dst_entry *dst;

include/net/dst.h

385

dst = skb_dst(skb);

include/net/dst.h

386

if (dst)

include/net/dst.h

387

return dst->tclassid;

include/net/dst.h

399

void dst_init(struct dst_entry *dst, struct dst_ops *ops,

include/net/dst.h

402

void dst_dev_put(struct dst_entry *dst);

include/net/dst.h

404

static inline void dst_confirm(struct dst_entry *dst)

include/net/dst.h

408

static inline struct neighbour *dst_neigh_lookup(const struct dst_entry *dst, const void *daddr)

include/net/dst.h

410

struct neighbour *n = dst->ops->neigh_lookup(dst, NULL, daddr);

include/net/dst.h

414

static inline struct neighbour *dst_neigh_lookup_skb(const struct dst_entry *dst,

include/net/dst.h

419

if (WARN_ON_ONCE(!dst->ops->neigh_lookup))

include/net/dst.h

422

n = dst->ops->neigh_lookup(dst, skb, NULL);

include/net/dst.h

427

static inline void dst_confirm_neigh(const struct dst_entry *dst,

include/net/dst.h

430

if (dst->ops->confirm_neigh)

include/net/dst.h

431

dst->ops->confirm_neigh(dst, daddr);

include/net/dst.h

436

struct dst_entry *dst = skb_dst(skb);

include/net/dst.h

437

if (dst && dst->ops && dst->ops->link_failure)

include/net/dst.h

438

dst->ops->link_failure(skb);

include/net/dst.h

441

static inline void dst_set_expires(struct dst_entry *dst, int timeout)

include/net/dst.h

448

old = READ_ONCE(dst->expires);

include/net/dst.h

451

WRITE_ONCE(dst->expires, expires);

include/net/dst.h

454

static inline unsigned int dst_dev_overhead(struct dst_entry *dst,

include/net/dst.h

457

if (likely(dst))

include/net/dst.h

458

return LL_RESERVED_SPACE(dst->dev);

include/net/dst.h

488

static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)

include/net/dst.h

490

if (READ_ONCE(dst->obsolete))

include/net/dst.h

491

dst = INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check,

include/net/dst.h

492

ipv4_dst_check, dst, cookie);

include/net/dst.h

493

return dst;

include/net/dst.h

531

static inline struct xfrm_state *dst_xfrm(const struct dst_entry *dst)

include/net/dst.h

552

static inline struct xfrm_state *dst_xfrm(const struct dst_entry *dst)

include/net/dst.h

554

return dst->xfrm;

include/net/dst.h

560

struct dst_entry *dst = skb_dst(skb);

include/net/dst.h

562

if (dst && dst->ops->update_pmtu)

include/net/dst.h

563

dst->ops->update_pmtu(dst, NULL, skb, mtu, true);

include/net/dst.h

569

struct dst_entry *dst = skb_dst(skb);

include/net/dst.h

571

if (dst && dst->ops->update_pmtu)

include/net/dst.h

572

dst->ops->update_pmtu(dst, NULL, skb, mtu, false);

include/net/dst.h

575

static inline struct net_device *dst_dev(const struct dst_entry *dst)

include/net/dst.h

577

return READ_ONCE(dst->dev);

include/net/dst.h

580

static inline struct net_device *dst_dev_rcu(const struct dst_entry *dst)

include/net/dst.h

582

return rcu_dereference(dst->dev_rcu);

include/net/dst.h

585

static inline struct net *dst_dev_net_rcu(const struct dst_entry *dst)

include/net/dst.h

587

return dev_net_rcu(dst_dev_rcu(dst));

include/net/dst.h

610

struct dst_entry *dst_blackhole_check(struct dst_entry *dst, u32 cookie);

include/net/dst.h

611

void dst_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,

include/net/dst.h

613

void dst_blackhole_redirect(struct dst_entry *dst, struct sock *sk,

include/net/dst.h

615

u32 *dst_blackhole_cow_metrics(struct dst_entry *dst, unsigned long old);

include/net/dst.h

616

struct neighbour *dst_blackhole_neigh_lookup(const struct dst_entry *dst,

include/net/dst.h

619

unsigned int dst_blackhole_mtu(const struct dst_entry *dst);

include/net/dst_cache.h

43

void dst_cache_set_ip4(struct dst_cache *dst_cache, struct dst_entry *dst,

include/net/dst_cache.h

56

void dst_cache_set_ip6(struct dst_cache *dst_cache, struct dst_entry *dst,

include/net/dst_metadata.h

183

skb_dst_set(skb, &new_md->dst);

include/net/dst_metadata.h

189

struct metadata_dst *dst;

include/net/dst_metadata.h

191

dst = tun_dst_unclone(skb);

include/net/dst_metadata.h

192

if (IS_ERR(dst))

include/net/dst_metadata.h

195

return &dst->u.tun_info;

include/net/dst_metadata.h

259

info->key.u.ipv6.dst = *daddr;

include/net/dst_metadata.h

34

struct dst_entry dst;

include/net/dst_metadata.h

48

if (md_dst && md_dst->dst.flags & DST_METADATA)

include/net/dst_metadata.h

58

struct dst_entry *dst;

include/net/dst_metadata.h

63

dst = skb_dst(skb);

include/net/dst_metadata.h

64

if (dst && dst->lwtstate &&

include/net/dst_metadata.h

65

(dst->lwtstate->type == LWTUNNEL_ENCAP_IP ||

include/net/dst_metadata.h

66

dst->lwtstate->type == LWTUNNEL_ENCAP_IP6))

include/net/dst_metadata.h

67

return lwt_tun_info(dst->lwtstate);

include/net/dst_metadata.h

80

struct dst_entry *dst;

include/net/dst_metadata.h

85

dst = skb_dst(skb);

include/net/dst_metadata.h

86

if (dst && dst->lwtstate &&

include/net/dst_metadata.h

87

dst->lwtstate->type == LWTUNNEL_ENCAP_XFRM)

include/net/dst_metadata.h

88

return lwt_xfrm_info(dst->lwtstate);

include/net/dst_metadata.h

95

struct dst_entry *dst = skb_dst(skb);

include/net/dst_metadata.h

97

return dst && !(dst->flags & DST_METADATA);

include/net/dst_ops.h

29

void (*update_pmtu)(struct dst_entry *dst, struct sock *sk,

include/net/dst_ops.h

32

void (*redirect)(struct dst_entry *dst, struct sock *sk,

include/net/dst_ops.h

35

struct neighbour * (*neigh_lookup)(const struct dst_entry *dst,

include/net/dst_ops.h

38

void (*confirm_neigh)(const struct dst_entry *dst,

include/net/dst_ops.h

46

static inline int dst_entries_get_fast(struct dst_ops *dst)

include/net/dst_ops.h

48

return percpu_counter_read_positive(&dst->pcpuc_entries);

include/net/dst_ops.h

51

static inline int dst_entries_get_slow(struct dst_ops *dst)

include/net/dst_ops.h

53

return percpu_counter_sum_positive(&dst->pcpuc_entries);

include/net/dst_ops.h

57

static inline void dst_entries_add(struct dst_ops *dst, int val)

include/net/dst_ops.h

59

percpu_counter_add_batch(&dst->pcpuc_entries, val,

include/net/dst_ops.h

63

static inline int dst_entries_init(struct dst_ops *dst)

include/net/dst_ops.h

65

return percpu_counter_init(&dst->pcpuc_entries, 0, GFP_KERNEL);

include/net/dst_ops.h

68

static inline void dst_entries_destroy(struct dst_ops *dst)

include/net/dst_ops.h

70

percpu_counter_destroy(&dst->pcpuc_entries);

include/net/flow_dissector.h

128

__be32 dst;

include/net/flow_dissector.h

139

struct in6_addr dst;

include/net/flow_dissector.h

191

__be16 dst;

include/net/flow_dissector.h

233

unsigned char dst[ETH_ALEN];

include/net/flow_offload.h

266

unsigned char dst[ETH_ALEN];

include/net/gre.h

65

static inline void gre_flags_to_tnl_flags(unsigned long *dst, __be16 flags)

include/net/gre.h

77

ip_tunnel_flags_copy(dst, res);

include/net/inet6_connection_sock.h

22

struct dst_entry *dst,

include/net/inet_connection_sock.h

43

struct dst_entry *dst,

include/net/inet_sock.h

175

struct dst_entry *dst;

include/net/ip.h

430

static inline int ip_mtu_locked(const struct dst_entry *dst)

include/net/ip.h

432

const struct rtable *rt = dst_rtable(dst);

include/net/ip.h

434

return rt->rt_mtu_locked || dst_metric_locked(dst, RTAX_MTU);

include/net/ip.h

438

int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst)

include/net/ip.h

444

!ip_mtu_locked(dst));

include/net/ip.h

467

static inline unsigned int ip_dst_mtu_maybe_forward(const struct dst_entry *dst,

include/net/ip.h

470

const struct rtable *rt = dst_rtable(dst);

include/net/ip.h

477

dev = dst_dev_rcu(dst);

include/net/ip.h

480

ip_mtu_locked(dst) ||

include/net/ip.h

483

if (mtu && time_before(jiffies, READ_ONCE(rt->dst.expires)))

include/net/ip.h

488

mtu = dst_metric_raw(dst, RTAX_MTU);

include/net/ip.h

494

if (unlikely(ip_mtu_locked(dst))) {

include/net/ip.h

502

res = mtu - lwtunnel_headroom(dst->lwtstate, mtu);

include/net/ip.h

512

const struct dst_entry *dst = skb_dst(skb);

include/net/ip.h

518

return ip_dst_mtu_maybe_forward(dst, forwarding);

include/net/ip.h

521

mtu = min(READ_ONCE(dst_dev(dst)->mtu), IP_MAX_MTU);

include/net/ip.h

522

return mtu - lwtunnel_headroom(dst->lwtstate, mtu);

include/net/ip.h

536

void ip_dst_init_metrics(struct dst_entry *dst, struct dst_metrics *fib_metrics)

include/net/ip.h

538

dst_init_metrics(dst, fib_metrics->metrics, true);

include/net/ip.h

541

dst->_metrics |= DST_METRICS_REFCOUNTED;

include/net/ip.h

547

void ip_dst_metrics_put(struct dst_entry *dst)

include/net/ip.h

549

struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);

include/net/ip.h

608

BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=

include/net/ip6_fib.h

208

struct dst_entry dst;

include/net/ip6_fib.h

238

#define dst_rt6_info(_ptr) container_of_const(_ptr, struct rt6_info, dst)

include/net/ip6_fib.h

240

static inline struct inet6_dev *ip6_dst_idev(const struct dst_entry *dst)

include/net/ip6_fib.h

242

return dst_rt6_info(dst)->rt6i_idev;

include/net/ip6_fib.h

323

BUILD_BUG_ON(offsetof(struct rt6_info, dst) != 0);

include/net/ip6_fib.h

324

dst_release(&rt->dst);

include/net/ip6_fib.h

672

fl6->fl6_dport = flkeys->ports.dst;

include/net/ip6_route.h

102

!list_empty(&rt->dst.rt_uncached))

include/net/ip6_route.h

220

const struct dst_entry *dst = skb_dst(skb);

include/net/ip6_route.h

222

if (dst)

include/net/ip6_route.h

223

return dst_rt6_info(dst);

include/net/ip6_route.h

231

static inline void ip6_dst_store(struct sock *sk, struct dst_entry *dst,

include/net/ip6_route.h

237

np->dst_cookie = rt6_get_cookie(dst_rt6_info(dst));

include/net/ip6_route.h

238

sk_setup_caps(sk, dst);

include/net/ip6_route.h

245

void ip6_sk_dst_store_flow(struct sock *sk, struct dst_entry *dst,

include/net/ip6_route.h

255

static inline bool ipv6_anycast_destination(const struct dst_entry *dst,

include/net/ip6_route.h

258

const struct rt6_info *rt = dst_rt6_info(dst);

include/net/ip6_route.h

270

static inline u32 dst6_mtu(const struct dst_entry *dst)

include/net/ip6_route.h

272

return INDIRECT_CALL_1(dst->ops->mtu, ip6_mtu, dst);

include/net/ip6_route.h

279

const struct dst_entry *dst = skb_dst(skb);

include/net/ip6_route.h

283

mtu = READ_ONCE(dst_dev(dst)->mtu);

include/net/ip6_route.h

284

mtu -= lwtunnel_headroom(dst->lwtstate, mtu);

include/net/ip6_route.h

286

mtu = dst_mtu(dst);

include/net/ip6_route.h

332

static inline unsigned int ip6_dst_mtu_maybe_forward(const struct dst_entry *dst,

include/net/ip6_route.h

338

if (!forwarding || dst_metric_locked(dst, RTAX_MTU)) {

include/net/ip6_route.h

339

mtu = dst_metric_raw(dst, RTAX_MTU);

include/net/ip6_route.h

346

idev = __in6_dev_get(dst_dev_rcu(dst));

include/net/ip6_route.h

352

return mtu - lwtunnel_headroom(dst->lwtstate, mtu);

include/net/ip_fib.h

219

__be32 dst;

include/net/ip_fib.h

231

u32 dst;

include/net/ip_fib.h

433

fl4->fl4_dport = flkeys->ports.dst;

include/net/ip_fib.h

453

int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,

include/net/ip_fib.h

458

fib_validate_source_reason(struct sk_buff *skb, __be32 src, __be32 dst,

include/net/ip_fib.h

462

int err = fib_validate_source(skb, src, dst, dscp, oif, dev, idev,

include/net/ip_tunnels.h

271

static inline void ip_tunnel_flags_from_be16(unsigned long *dst, __be16 flags)

include/net/ip_tunnels.h

273

ip_tunnel_flags_zero(dst);

include/net/ip_tunnels.h

275

bitmap_write(dst, be16_to_cpu(flags), 0, BITS_PER_TYPE(__be16));

include/net/ip_tunnels.h

276

__assign_bit(IP_TUNNEL_VTI_BIT, dst, flags & VTI_ISVTI);

include/net/ip_tunnels.h

299

key->u.ipv4.dst = daddr;

include/net/ip_tunnels.h

44

#define IP_TUNNEL_KEY_IPV4_PAD offsetofend(struct ip_tunnel_key, u.ipv4.dst)

include/net/ip_tunnels.h

625

__be32 src, __be32 dst, u8 proto,

include/net/ip_tunnels.h

72

__be32 dst;

include/net/ip_tunnels.h

76

struct in6_addr dst;

include/net/ip_vs.h

151

static inline void ip_vs_addr_copy(int af, union nf_inet_addr *dst,

include/net/ip_vs.h

156

dst->in6 = src->in6;

include/net/ip_vs.h

159

dst->ip = src->ip;

include/net/ip_vs.h

1595

void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats);

include/net/ip_vs.h

162

static inline void ip_vs_addr_set(int af, union nf_inet_addr *dst,

include/net/ip_vs.h

167

dst->in6 = src->in6;

include/net/ip_vs.h

171

dst->ip = src->ip;

include/net/ip_vs.h

172

dst->all[1] = 0;

include/net/ip_vs.h

173

dst->all[2] = 0;

include/net/ip_vs.h

174

dst->all[3] = 0;

include/net/ipv6.h

1045

int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst,

include/net/ipv6.h

1302

static inline void ipv6_addr_cpu_to_be32(__be32 *dst, const u32 *src)

include/net/ipv6.h

1304

cpu_to_be32_array(dst, src, IPV6_ADDR_WORDS);

include/net/ipv6.h

1307

static inline void ipv6_addr_be32_to_cpu(u32 *dst, const __be32 *src)

include/net/ipv6.h

1309

be32_to_cpu_array(dst, src, IPV6_ADDR_WORDS);

include/net/ipv6.h

320

struct in6_addr dst;

include/net/ipv6.h

823

int ip6_dst_hoplimit(struct dst_entry *dst);

include/net/ipv6.h

826

struct dst_entry *dst)

include/net/ipv6.h

835

hlimit = ip6_dst_hoplimit(dst);

include/net/ipv6.h

846

BUILD_BUG_ON(offsetof(typeof(flow->addrs), v6addrs.dst) !=

include/net/libeth/xdp.h

1163

void libeth_xdp_load_stash(struct libeth_xdp_buff *dst,

include/net/libeth/xdp.h

1165

void libeth_xdp_save_stash(struct libeth_xdp_buff_stash *dst,

include/net/libeth/xdp.h

1180

libeth_xdp_init_buff(struct libeth_xdp_buff *dst,

include/net/libeth/xdp.h

1185

dst->data = NULL;

include/net/libeth/xdp.h

1187

libeth_xdp_load_stash(dst, src);

include/net/libeth/xdp.h

1189

dst->base.rxq = rxq;

include/net/libeth/xdp.h

1201

static inline void libeth_xdp_save_buff(struct libeth_xdp_buff_stash *dst,

include/net/libeth/xdp.h

1205

dst->data = NULL;

include/net/libeth/xdp.h

1207

libeth_xdp_save_stash(dst, src);

include/net/lwtunnel.h

138

static inline void lwtunnel_set_redirect(struct dst_entry *dst)

include/net/lwtunnel.h

140

if (lwtunnel_output_redirect(dst->lwtstate)) {

include/net/lwtunnel.h

141

dst->lwtstate->orig_output = READ_ONCE(dst->output);

include/net/lwtunnel.h

142

WRITE_ONCE(dst->output, lwtunnel_output);

include/net/lwtunnel.h

144

if (lwtunnel_input_redirect(dst->lwtstate)) {

include/net/lwtunnel.h

145

dst->lwtstate->orig_input = READ_ONCE(dst->input);

include/net/lwtunnel.h

146

WRITE_ONCE(dst->input, lwtunnel_input);

include/net/lwtunnel.h

180

static inline void lwtunnel_set_redirect(struct dst_entry *dst)

include/net/mctp.h

255

int (*output)(struct mctp_dst *dst,

include/net/mctp.h

278

int (*output)(struct mctp_dst *dst, struct sk_buff *skb);

include/net/mctp.h

281

int mctp_dst_from_extaddr(struct mctp_dst *dst, struct net *net, int ifindex,

include/net/mctp.h

286

mctp_eid_t daddr, struct mctp_dst *dst);

include/net/mctp.h

288

void mctp_dst_release(struct mctp_dst *dst);

include/net/mctp.h

291

int mctp_local_output(struct sock *sk, struct mctp_dst *dst,

include/net/neighbour.h

592

static inline void neigh_ha_snapshot(char *dst, const struct neighbour *n,

include/net/neighbour.h

599

memcpy(dst, n->ha, dev->addr_len);

include/net/netfilter/nf_conntrack.h

137

tuplehash[hash->tuple.dst.dir]);

include/net/netfilter/nf_conntrack.h

147

return ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;

include/net/netfilter/nf_conntrack_tuple.h

101

t->dst.u3.all, ntohs(t->dst.u.all));

include/net/netfilter/nf_conntrack_tuple.h

119

((enum ip_conntrack_dir)(h)->tuple.dst.dir)

include/net/netfilter/nf_conntrack_tuple.h

138

return (nf_inet_addr_cmp(&t1->dst.u3, &t2->dst.u3) &&

include/net/netfilter/nf_conntrack_tuple.h

139

t1->dst.u.all == t2->dst.u.all &&

include/net/netfilter/nf_conntrack_tuple.h

140

t1->dst.protonum == t2->dst.protonum);

include/net/netfilter/nf_conntrack_tuple.h

175

t1->dst.protonum != t2->dst.protonum)

include/net/netfilter/nf_conntrack_tuple.h

75

} dst;

include/net/netfilter/nf_conntrack_tuple.h

89

t, t->dst.protonum,

include/net/netfilter/nf_conntrack_tuple.h

91

&t->dst.u3.ip, ntohs(t->dst.u.all));

include/net/netfilter/nf_conntrack_tuple.h

99

t, t->dst.protonum,

include/net/netfilter/nf_flow_table.h

218

struct dst_entry *dst;

include/net/netfilter/nf_tables.h

190

static inline void nft_data_copy(u32 *dst, const struct nft_data *src,

include/net/netfilter/nf_tables.h

194

dst[len / NFT_REG32_SIZE] = 0;

include/net/netfilter/nf_tables.h

195

memcpy(dst, src, len);

include/net/netfilter/nf_tables.h

424

int nft_expr_clone(struct nft_expr *dst, struct nft_expr *src, gfp_t gfp);

include/net/netfilter/nf_tables.h

957

int (*clone)(struct nft_expr *dst,

include/net/netlink.h

549

ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize);

include/net/phonet/pn_dev.h

45

void rtm_phonet_notify(struct net *net, int event, u32 ifindex, u8 dst);

include/net/pkt_cls.h

374

void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src);

include/net/route.h

229

ip_route_input(struct sk_buff *skb, __be32 dst, __be32 src, dscp_t dscp,

include/net/route.h

235

reason = ip_route_input_noref(skb, dst, src, dscp, devin);

include/net/route.h

284

BUILD_BUG_ON(offsetof(struct rtable, dst) != 0);

include/net/route.h

285

dst_release(&rt->dst);

include/net/route.h

319

static inline void ip_route_connect_init(struct flowi4 *fl4, __be32 dst,

include/net/route.h

333

ip_sock_rt_scope(sk), protocol, flow_flags, dst,

include/net/route.h

337

static inline struct rtable *ip_route_connect(struct flowi4 *fl4, __be32 dst,

include/net/route.h

345

ip_route_connect_init(fl4, dst, src, oif, protocol, sport, dport, sk);

include/net/route.h

347

if (!dst || !src) {

include/net/route.h

385

static inline int ip4_dst_hoplimit(const struct dst_entry *dst)

include/net/route.h

387

int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);

include/net/route.h

393

net = dst_dev_net_rcu(dst);

include/net/route.h

416

struct net_device *dev = rt->dst.dev;

include/net/route.h

58

struct dst_entry dst;

include/net/route.h

80

#define dst_rtable(_ptr) container_of_const(_ptr, struct rtable, dst)

include/net/sctp/sctp.h

560

if (t->dst && !dst_check(t->dst, t->dst_cookie))

include/net/sctp/sctp.h

563

return t->dst;

include/net/sctp/sctp.h

595

static inline __u32 sctp_dst_mtu(const struct dst_entry *dst)

include/net/sctp/sctp.h

597

return SCTP_TRUNC4(max_t(__u32, dst_mtu(dst),

include/net/sctp/sctp.h

603

__u32 pmtu = sctp_dst_mtu(t->dst);

include/net/sctp/structs.h

449

void (*addr_copy) (union sctp_addr *dst,

include/net/sctp/structs.h

845

struct dst_entry *dst;

include/net/selftests.h

10

const unsigned char *dst;

include/net/sock.h

2192

struct dst_entry *dst;

include/net/sock.h

2195

dst = rcu_dereference(sk->sk_dst_cache);

include/net/sock.h

2196

if (dst && !rcuref_get(&dst->__rcuref))

include/net/sock.h

2197

dst = NULL;

include/net/sock.h

2199

return dst;

include/net/sock.h

2204

struct dst_entry *dst = __sk_dst_get(sk);

include/net/sock.h

2206

if (dst && dst->ops->negative_advice)

include/net/sock.h

2207

dst->ops->negative_advice(sk, dst);

include/net/sock.h

2217

__sk_dst_set(struct sock *sk, struct dst_entry *dst)

include/net/sock.h

2225

rcu_assign_pointer(sk->sk_dst_cache, dst);

include/net/sock.h

2230

sk_dst_set(struct sock *sk, struct dst_entry *dst)

include/net/sock.h

2236

old_dst = unrcu_pointer(xchg(&sk->sk_dst_cache, RCU_INITIALIZER(dst)));

include/net/sock.h

2280

void sk_setup_caps(struct sock *sk, struct dst_entry *dst);

include/net/tcp.h

1507

__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst);

include/net/tcp.h

1780

const struct dst_entry *dst);

include/net/tcp.h

2097

const struct dst_entry *dst);

include/net/tcp.h

2471

int (*send_synack)(const struct sock *sk, struct dst_entry *dst,

include/net/tcp.h

484

bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst);

include/net/tcp.h

543

void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst);

include/net/tcp.h

546

struct dst_entry *dst,

include/net/tcp.h

560

struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,

include/net/tcp.h

574

struct dst_entry *dst);

include/net/tcp.h

693

static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *dst)

include/net/tcp.h

696

dst_feature(dst, RTAX_FEATURE_ECN);

include/net/tcp.h

881

const struct dst_entry *dst = __sk_dst_get(sk);

include/net/tcp.h

884

if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))

include/net/tcp.h

885

rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);

include/net/tcp.h

894

static inline bool tcp_ca_dst_locked(const struct dst_entry *dst)

include/net/tcp.h

896

return dst_metric_locked(dst, RTAX_CC_ALGO);

include/net/tcp_ecn.h

611

const struct dst_entry *dst = __sk_dst_get(sk);

include/net/tcp_ecn.h

613

if (dst && dst_feature(dst, RTAX_FEATURE_ECN))

include/net/udp.h

414

bool udp_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst);

include/net/udp.h

422

void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst);

include/net/udp_tunnel.h

140

__be32 src, __be32 dst, __u8 tos, __u8 ttl,

include/net/udp_tunnel.h

144

void udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,

include/net/xfrm.h

1058

struct dst_entry dst;

include/net/xfrm.h

1075

static inline struct dst_entry *xfrm_dst_path(const struct dst_entry *dst)

include/net/xfrm.h

1078

if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {

include/net/xfrm.h

1079

const struct xfrm_dst *xdst = (const struct xfrm_dst *) dst;

include/net/xfrm.h

1084

return (struct dst_entry *) dst;

include/net/xfrm.h

1087

static inline struct dst_entry *xfrm_dst_child(const struct dst_entry *dst)

include/net/xfrm.h

1090

if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {

include/net/xfrm.h

1091

struct xfrm_dst *xdst = (struct xfrm_dst *) dst;

include/net/xfrm.h

1108

if (likely(xdst->u.dst.xfrm))

include/net/xfrm.h

1109

xfrm_state_put(xdst->u.dst.xfrm);

include/net/xfrm.h

1113

void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);

include/net/xfrm.h

1732

void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,

include/net/xfrm.h

1734

void xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,

include/net/xfrm.h

2089

static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)

include/net/xfrm.h

2091

struct xfrm_state *x = dst->xfrm;

include/net/xfrm.h

2097

xdst = (struct xfrm_dst *) dst;

include/net/xfrm.h

2100

if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&

include/net/xfrm.h

2179

static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)

include/rdma/ib_marshall.h

15

struct ib_uverbs_qp_attr *dst,

include/rdma/ib_marshall.h

19

struct ib_uverbs_ah_attr *dst,

include/rdma/ib_marshall.h

22

void ib_copy_path_rec_to_user(struct ib_user_path_rec *dst,

include/rdma/ib_umem.h

114

int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,

include/rdma/ib_umem.h

192

static inline int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,

include/scsi/iscsi_if.h

345

} dst;

include/scsi/libfc.h

1012

int fc_exch_mgr_list_clone(struct fc_lport *src, struct fc_lport *dst);

include/soc/tegra/bpmp.h

40

#define tegra_bpmp_mb_read(dst, mb, size) \

include/soc/tegra/bpmp.h

41

iosys_map_memcpy_from(dst, mb, offsetof(struct tegra_bpmp_mb_data, data), size)

include/soc/tegra/mc.h

146

int (*set)(struct icc_node *src, struct icc_node *dst);

include/sound/core.h

269

int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count);

include/sound/core.h

270

int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count);

include/sound/emu10k1.h

1849

void snd_emu1010_fpga_link_dst_src_write(struct snd_emu10k1 *emu, u32 dst, u32 src);

include/sound/emu10k1.h

1850

u32 snd_emu1010_fpga_link_dst_src_read(struct snd_emu10k1 *emu, u32 dst);

include/sound/pcm.h

1537

size_t copy_from_iter_toio(void __iomem *dst, size_t bytes,

include/sound/ump_convert.h

35

int snd_ump_convert_from_ump(const u32 *data, unsigned char *dst,

include/trace/events/bridge.h

152

memcpy(__entry->grpmac, group->dst.mac_addr, ETH_ALEN);

include/trace/events/bridge.h

160

ipv6_addr_set_v4mapped(group->dst.ip4, in6);

include/trace/events/bridge.h

172

*in6 = group->dst.ip6;

include/trace/events/bridge.h

77

__string(dev, f->dst ? f->dst->dev->name : "null")

include/trace/events/dlm.h

330

TP_PROTO(uint32_t dst, uint32_t h_seq, const struct dlm_rcom *rc),

include/trace/events/dlm.h

332

TP_ARGS(dst, h_seq, rc),

include/trace/events/dlm.h

335

__field(uint32_t, dst)

include/trace/events/dlm.h

352

__entry->dst = dst;

include/trace/events/dlm.h

371

"rc_buf=0x%s", __entry->dst, __entry->h_seq,

include/trace/events/dlm.h

384

TP_PROTO(uint32_t dst, uint32_t h_seq, const struct dlm_rcom *rc),

include/trace/events/dlm.h

385

TP_ARGS(dst, h_seq, rc));

include/trace/events/dlm.h

388

TP_PROTO(uint32_t dst, uint32_t h_seq, const struct dlm_rcom *rc),

include/trace/events/dlm.h

389

TP_ARGS(dst, h_seq, rc));

include/trace/events/dlm.h

393

TP_PROTO(uint32_t dst, uint32_t h_seq, const struct dlm_message *ms,

include/trace/events/dlm.h

396

TP_ARGS(dst, h_seq, ms, name, namelen),

include/trace/events/dlm.h

399

__field(uint32_t, dst)

include/trace/events/dlm.h

430

__entry->dst = dst;

include/trace/events/dlm.h

467

"m_extra=0x%s res_name=0x%s", __entry->dst,

include/trace/events/dlm.h

491

TP_PROTO(uint32_t dst, uint32_t h_seq, const struct dlm_message *ms),

include/trace/events/dlm.h

493

TP_ARGS(dst, h_seq, ms),

include/trace/events/dlm.h

496

__field(uint32_t, dst)

include/trace/events/dlm.h

526

__entry->dst = dst;

include/trace/events/dlm.h

561

"m_extra=0x%s", __entry->dst,

include/trace/events/fib.h

32

__array( __u8, dst, 4 )

include/trace/events/fib.h

56

p32 = (__be32 *) __entry->dst;

include/trace/events/fib.h

97

__entry->src, __entry->sport, __entry->dst, __entry->dport,

include/trace/events/fib6.h

30

__array( __u8, dst, 16 )

include/trace/events/fib6.h

54

in6 = (struct in6_addr *)__entry->dst;

include/trace/events/fib6.h

83

__entry->src, __entry->sport, __entry->dst, __entry->dport,

include/trace/stages/stage6_event_callback.h

109

#define __assign_rel_bitmask(dst, src, nr_bits) \

include/trace/stages/stage6_event_callback.h

110

memcpy(__get_rel_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits))

include/trace/stages/stage6_event_callback.h

119

#define __assign_rel_cpumask(dst, src) \

include/trace/stages/stage6_event_callback.h

120

memcpy(__get_rel_cpumask(dst), (src), __bitmask_size_in_bytes(nr_cpumask_bits))

include/trace/stages/stage6_event_callback.h

34

#define __assign_str(dst) \

include/trace/stages/stage6_event_callback.h

36

char *__str__ = __get_str(dst); \

include/trace/stages/stage6_event_callback.h

37

int __len__ = __get_dynamic_array_len(dst) - 1; \

include/trace/stages/stage6_event_callback.h

38

memcpy(__str__, __data_offsets.dst##_ptr_ ? : \

include/trace/stages/stage6_event_callback.h

44

#define __assign_vstr(dst, fmt, va) \

include/trace/stages/stage6_event_callback.h

48

vsnprintf(__get_str(dst), TRACE_EVENT_STR_MAX, fmt, __cp_va); \

include/trace/stages/stage6_event_callback.h

59

#define __assign_bitmask(dst, src, nr_bits) \

include/trace/stages/stage6_event_callback.h

60

memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits))

include/trace/stages/stage6_event_callback.h

69

#define __assign_cpumask(dst, src) \

include/trace/stages/stage6_event_callback.h

70

memcpy(__get_cpumask(dst), (src), __bitmask_size_in_bytes(nr_cpumask_bits))

include/trace/stages/stage6_event_callback.h

93

#define __assign_rel_str(dst) \

include/trace/stages/stage6_event_callback.h

95

char *__str__ = __get_rel_str(dst); \

include/trace/stages/stage6_event_callback.h

96

int __len__ = __get_rel_dynamic_array_len(dst) - 1; \

include/trace/stages/stage6_event_callback.h

97

memcpy(__str__, __data_offsets.dst##_ptr_ ? : \

include/uapi/drm/vmwgfx_drm.h

512

struct drm_vmw_rect dst;

include/uapi/linux/batadv_packet.h

294

__u8 dst[ETH_ALEN];

include/uapi/linux/batadv_packet.h

317

__u8 dst[ETH_ALEN];

include/uapi/linux/batadv_packet.h

346

__u8 dst[ETH_ALEN];

include/uapi/linux/batadv_packet.h

385

__u8 dst[ETH_ALEN];

include/uapi/linux/batadv_packet.h

567

__u8 dst[ETH_ALEN];

include/uapi/linux/btrfs.h

791

__u64 dst;

include/uapi/linux/ivtv.h

57

struct v4l2_rect dst;

include/uapi/linux/netfilter/xt_HMARK.h

30

__u16 dst;

include/uapi/linux/netfilter/xt_HMARK.h

34

__be16 dst;

include/uapi/linux/netfilter_ipv4/ip_tables.h

73

struct in_addr src, dst;

include/uapi/linux/netfilter_ipv6/ip6_tables.h

66

struct in6_addr src, dst;

include/uapi/linux/rpmsg.h

23

__u32 dst;

include/uapi/linux/userfaultfd.h

276

__u64 dst;

include/uapi/linux/userfaultfd.h

360

__u64 dst;

include/video/omapfb_dss.h

439

struct omap_dss_device *dst);

include/video/omapfb_dss.h

441

struct omap_dss_device *dst);

include/video/omapfb_dss.h

458

struct omap_dss_device *dst);

include/video/omapfb_dss.h

460

struct omap_dss_device *dst);

include/video/omapfb_dss.h

477

struct omap_dss_device *dst);

include/video/omapfb_dss.h

479

struct omap_dss_device *dst);

include/video/omapfb_dss.h

494

struct omap_dss_device *dst);

include/video/omapfb_dss.h

496

struct omap_dss_device *dst);

include/video/omapfb_dss.h

519

struct omap_dss_device *dst);

include/video/omapfb_dss.h

521

struct omap_dss_device *dst);

include/video/omapfb_dss.h

543

struct omap_dss_device *dst);

include/video/omapfb_dss.h

545

struct omap_dss_device *dst);

include/video/omapfb_dss.h

686

struct omap_dss_device *dst;

init/main.c

327

#define rest(dst, end) ((end) > (dst) ? (end) - (dst) : 0)

io_uring/bpf_filter.c

246

void io_bpf_filter_clone(struct io_restriction *dst, struct io_restriction *src)

io_uring/bpf_filter.c

256

dst->bpf_filters = src->bpf_filters;

io_uring/bpf_filter.c

257

dst->bpf_filters_cow = true;

io_uring/bpf_filter.h

16

void io_bpf_filter_clone(struct io_restriction *dst, struct io_restriction *src);

io_uring/bpf_filter.h

42

static inline void io_bpf_filter_clone(struct io_restriction *dst,

io_uring/io_uring.c

2908

void io_restriction_clone(struct io_restriction *dst, struct io_restriction *src)

io_uring/io_uring.c

2910

memcpy(&dst->register_op, &src->register_op, sizeof(dst->register_op));

io_uring/io_uring.c

2911

memcpy(&dst->sqe_op, &src->sqe_op, sizeof(dst->sqe_op));

io_uring/io_uring.c

2912

dst->sqe_flags_allowed = src->sqe_flags_allowed;

io_uring/io_uring.c

2913

dst->sqe_flags_required = src->sqe_flags_required;

io_uring/io_uring.c

2914

dst->op_registered = src->op_registered;

io_uring/io_uring.c

2915

dst->reg_registered = src->reg_registered;

io_uring/io_uring.c

2917

io_bpf_filter_clone(dst, src);

io_uring/io_uring.c

2923

struct io_restriction *dst = &ctx->restrictions;

io_uring/io_uring.c

2925

io_restriction_clone(dst, src);

io_uring/io_uring.c

2926

if (dst->bpf_filters)

io_uring/io_uring.c

2927

WRITE_ONCE(ctx->bpf_filters, dst->bpf_filters->filters);

io_uring/io_uring.c

2928

if (dst->op_registered)

io_uring/io_uring.c

2930

if (dst->reg_registered)

io_uring/io_uring.h

214

void io_restriction_clone(struct io_restriction *dst, struct io_restriction *src);

ipc/msgutil.c

126

struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst)

ipc/msgutil.c

132

if (src->m_ts > dst->m_ts)

ipc/msgutil.c

136

memcpy(dst + 1, src + 1, alen);

ipc/msgutil.c

138

for (dst_pseg = dst->next, src_pseg = src->next;

ipc/msgutil.c

147

dst->m_type = src->m_type;

ipc/msgutil.c

148

dst->m_ts = src->m_ts;

ipc/msgutil.c

150

return dst;

ipc/msgutil.c

153

struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst)

ipc/util.h

200

extern struct msg_msg *copy_msg(struct msg_msg *src, struct msg_msg *dst);

kernel/bpf/bpf_lsm.c

166

BPF_CALL_3(bpf_ima_inode_hash, struct inode *, inode, void *, dst, u32, size)

kernel/bpf/bpf_lsm.c

168

return ima_inode_hash(inode, dst, size);

kernel/bpf/bpf_lsm.c

190

BPF_CALL_3(bpf_ima_file_hash, struct file *, file, void *, dst, u32, size)

kernel/bpf/bpf_lsm.c

192

return ima_file_hash(file, dst, size);

kernel/bpf/cgroup.c

2274

static int copy_sysctl_value(char *dst, size_t dst_len, char *src,

kernel/bpf/cgroup.c

2277

if (!dst)

kernel/bpf/cgroup.c

2284

memset(dst, 0, dst_len);

kernel/bpf/cgroup.c

2288

memcpy(dst, src, min(dst_len, src_len));

kernel/bpf/cgroup.c

2291

memset(dst + src_len, '\0', dst_len - src_len);

kernel/bpf/cgroup.c

2295

dst[dst_len - 1] = '\0';

kernel/bpf/cgroup.c

269

static void bpf_cgroup_storages_assign(struct bpf_cgroup_storage *dst[],

kernel/bpf/cgroup.c

275

dst[stype] = src[stype];

kernel/bpf/core.c

304

struct bpf_insn *dst;

kernel/bpf/core.c

308

dst = vmalloc(size);

kernel/bpf/core.c

309

if (!dst)

kernel/bpf/core.c

316

dst[i] = fp->insnsi[i];

kernel/bpf/core.c

318

dst[i].code == (BPF_LD | BPF_IMM | BPF_DW) &&

kernel/bpf/core.c

319

(dst[i].src_reg == BPF_PSEUDO_MAP_FD ||

kernel/bpf/core.c

320

dst[i].src_reg == BPF_PSEUDO_MAP_VALUE)) {

kernel/bpf/core.c

3214

void * __weak bpf_arch_text_copy(void *dst, void *src, size_t len)

kernel/bpf/core.c

3219

int __weak bpf_arch_text_invalidate(void *dst, size_t len)

kernel/bpf/core.c

322

dst[i].imm = 0;

kernel/bpf/core.c

324

dst[i].code == 0 &&

kernel/bpf/core.c

325

dst[i].dst_reg == 0 &&

kernel/bpf/core.c

326

dst[i].src_reg == 0 &&

kernel/bpf/core.c

327

dst[i].off == 0) {

kernel/bpf/core.c

329

dst[i].imm = 0;

kernel/bpf/core.c

334

sha256((u8 *)dst, size, fp->digest);

kernel/bpf/core.c

335

vfree(dst);

kernel/bpf/cpumask.c

268

__bpf_kfunc bool bpf_cpumask_and(struct bpf_cpumask *dst,

kernel/bpf/cpumask.c

272

return cpumask_and((struct cpumask *)dst, src1, src2);

kernel/bpf/cpumask.c

283

__bpf_kfunc void bpf_cpumask_or(struct bpf_cpumask *dst,

kernel/bpf/cpumask.c

287

cpumask_or((struct cpumask *)dst, src1, src2);

kernel/bpf/cpumask.c

298

__bpf_kfunc void bpf_cpumask_xor(struct bpf_cpumask *dst,

kernel/bpf/cpumask.c

302

cpumask_xor((struct cpumask *)dst, src1, src2);

kernel/bpf/cpumask.c

390

__bpf_kfunc void bpf_cpumask_copy(struct bpf_cpumask *dst, const struct cpumask *src)

kernel/bpf/cpumask.c

392

cpumask_copy((struct cpumask *)dst, src);

kernel/bpf/crypto.c

272

const struct bpf_dynptr_kern *dst,

kernel/bpf/crypto.c

281

if (__bpf_dynptr_is_rdonly(dst))

kernel/bpf/crypto.c

286

dst_len = __bpf_dynptr_size(dst);

kernel/bpf/crypto.c

296

pdst = __bpf_dynptr_data_rw(dst, dst_len);

kernel/bpf/crypto.c

321

const struct bpf_dynptr *dst,

kernel/bpf/crypto.c

325

const struct bpf_dynptr_kern *dst_kern = (struct bpf_dynptr_kern *)dst;

kernel/bpf/crypto.c

342

const struct bpf_dynptr *dst,

kernel/bpf/crypto.c

346

const struct bpf_dynptr_kern *dst_kern = (struct bpf_dynptr_kern *)dst;

kernel/bpf/devmap.c

515

static u32 dev_map_bpf_prog_run_skb(struct sk_buff *skb, struct bpf_dtab_netdev *dst)

kernel/bpf/devmap.c

517

struct xdp_txq_info txq = { .dev = dst->dev };

kernel/bpf/devmap.c

521

if (!dst->xdp_prog)

kernel/bpf/devmap.c

527

act = bpf_prog_run_generic_xdp(skb, &xdp, dst->xdp_prog);

kernel/bpf/devmap.c

533

bpf_warn_invalid_xdp_action(NULL, dst->xdp_prog, act);

kernel/bpf/devmap.c

536

trace_xdp_exception(dst->dev, dst->xdp_prog, act);

kernel/bpf/devmap.c

552

int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_frame *xdpf,

kernel/bpf/devmap.c

555

struct net_device *dev = dst->dev;

kernel/bpf/devmap.c

557

return __xdp_enqueue(dev, xdpf, dev_rx, dst->xdp_prog);

kernel/bpf/devmap.c

626

struct bpf_dtab_netdev *dst, *last_dst = NULL;

kernel/bpf/devmap.c

644

dst = rcu_dereference_check(dtab->netdev_map[i],

kernel/bpf/devmap.c

646

if (!is_valid_dst(dst, xdpf))

kernel/bpf/devmap.c

649

if (is_ifindex_excluded(excluded_devices, num_excluded, dst->dev->ifindex))

kernel/bpf/devmap.c

654

last_dst = dst;

kernel/bpf/devmap.c

662

last_dst = dst;

kernel/bpf/devmap.c

667

hlist_for_each_entry_rcu(dst, head, index_hlist,

kernel/bpf/devmap.c

669

if (!is_valid_dst(dst, xdpf))

kernel/bpf/devmap.c

673

dst->dev->ifindex))

kernel/bpf/devmap.c

678

last_dst = dst;

kernel/bpf/devmap.c

686

last_dst = dst;

kernel/bpf/devmap.c

700

int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,

kernel/bpf/devmap.c

705

err = xdp_ok_fwd_dev(dst->dev, skb->len);

kernel/bpf/devmap.c

713

if (dev_map_bpf_prog_run_skb(skb, dst) != XDP_PASS)

kernel/bpf/devmap.c

716

skb->dev = dst->dev;

kernel/bpf/devmap.c

722

static int dev_map_redirect_clone(struct bpf_dtab_netdev *dst,

kernel/bpf/devmap.c

733

err = dev_map_generic_redirect(dst, nskb, xdp_prog);

kernel/bpf/devmap.c

747

struct bpf_dtab_netdev *dst, *last_dst = NULL;

kernel/bpf/devmap.c

766

dst = rcu_dereference_check(dtab->netdev_map[i],

kernel/bpf/devmap.c

768

if (!dst)

kernel/bpf/devmap.c

771

if (is_ifindex_excluded(excluded_devices, num_excluded, dst->dev->ifindex))

kernel/bpf/devmap.c

776

last_dst = dst;

kernel/bpf/devmap.c

784

last_dst = dst;

kernel/bpf/devmap.c

790

hlist_for_each_entry_safe(dst, next, head, index_hlist) {

kernel/bpf/devmap.c

792

dst->dev->ifindex))

kernel/bpf/devmap.c

797

last_dst = dst;

kernel/bpf/devmap.c

805

last_dst = dst;

kernel/bpf/helpers.c

1716

BPF_CALL_2(bpf_kptr_xchg, void *, dst, void *, ptr)

kernel/bpf/helpers.c

1718

unsigned long *kptr = dst;

kernel/bpf/helpers.c

1881

static int __bpf_dynptr_read(void *dst, u64 len, const struct bpf_dynptr_kern *src,

kernel/bpf/helpers.c

1903

memmove(dst, src->data + src->offset + offset, len);

kernel/bpf/helpers.c

1906

return __bpf_skb_load_bytes(src->data, src->offset + offset, dst, len);

kernel/bpf/helpers.c

1908

return __bpf_xdp_load_bytes(src->data, src->offset + offset, dst, len);

kernel/bpf/helpers.c

1910

memmove(dst, bpf_skb_meta_pointer(src->data, src->offset + offset), len);

kernel/bpf/helpers.c

1913

return bpf_file_fetch_bytes(src->data, offset, dst, len);

kernel/bpf/helpers.c

1920

BPF_CALL_5(bpf_dynptr_read, void *, dst, u64, len, const struct bpf_dynptr_kern *, src,

kernel/bpf/helpers.c

1923

return __bpf_dynptr_read(dst, len, src, offset, flags);

kernel/bpf/helpers.c

1937

int __bpf_dynptr_write(const struct bpf_dynptr_kern *dst, u64 offset, void *src,

kernel/bpf/helpers.c

1943

if (!dst->data || __bpf_dynptr_is_rdonly(dst))

kernel/bpf/helpers.c

1946

err = bpf_dynptr_check_off_len(dst, offset, len);

kernel/bpf/helpers.c

1950

type = bpf_dynptr_get_type(dst);

kernel/bpf/helpers.c

1961

memmove(dst->data + dst->offset + offset, src, len);

kernel/bpf/helpers.c

1964

return __bpf_skb_store_bytes(dst->data, dst->offset + offset, src, len,

kernel/bpf/helpers.c

1969

return __bpf_xdp_store_bytes(dst->data, dst->offset + offset, src, len);

kernel/bpf/helpers.c

1971

return __bpf_skb_meta_store_bytes(dst->data, dst->offset + offset, src,

kernel/bpf/helpers.c

1979

BPF_CALL_5(bpf_dynptr_write, const struct bpf_dynptr_kern *, dst, u64, offset, void *, src,

kernel/bpf/helpers.c

1982

return __bpf_dynptr_write(dst, offset, src, len, flags);

kernel/bpf/helpers.c

3006

struct bpf_dynptr_kern *dst = (struct bpf_dynptr_kern *)dst_ptr;

kernel/bpf/helpers.c

3021

return __bpf_dynptr_write(dst, dst_off, src_slice, size, 0);

kernel/bpf/helpers.c

3026

if (bpf_dynptr_check_off_len(dst, dst_off, size) ||

kernel/bpf/helpers.c

3038

err = __bpf_dynptr_write(dst, dst_off + off, buf, chunk_sz, 0);

kernel/bpf/helpers.c

3389

__bpf_kfunc int bpf_copy_from_user_str(void *dst, u32 dst__sz, const void __user *unsafe_ptr__ign, u64 flags)

kernel/bpf/helpers.c

3399

ret = strncpy_from_user(dst, unsafe_ptr__ign, dst__sz - 1);

kernel/bpf/helpers.c

3402

memset((char *)dst, 0, dst__sz);

kernel/bpf/helpers.c

3408

memset((char *)dst + ret, 0, dst__sz - ret);

kernel/bpf/helpers.c

3410

((char *)dst)[ret] = '\0';

kernel/bpf/helpers.c

3434

__bpf_kfunc int bpf_copy_from_user_task_str(void *dst, u32 dst__sz,

kernel/bpf/helpers.c

3446

ret = copy_remote_vm_str(tsk, (unsigned long)unsafe_ptr__ign, dst, dst__sz, 0);

kernel/bpf/helpers.c

3449

memset(dst, 0, dst__sz);

kernel/bpf/helpers.c

3454

memset(dst + ret, 0, dst__sz - ret);

kernel/bpf/helpers.c

378

void copy_map_value_locked(struct bpf_map *map, void *dst, void *src,

kernel/bpf/helpers.c

386

lock = dst + map->record->spin_lock_off;

kernel/bpf/helpers.c

389

copy_map_value(map, dst, src);

kernel/bpf/helpers.c

659

BPF_CALL_3(bpf_copy_from_user, void *, dst, u32, size,

kernel/bpf/helpers.c

662

int ret = copy_from_user(dst, user_ptr, size);

kernel/bpf/helpers.c

665

memset(dst, 0, size);

kernel/bpf/helpers.c

682

BPF_CALL_5(bpf_copy_from_user_task, void *, dst, u32, size,

kernel/bpf/helpers.c

694

ret = access_process_vm(tsk, (unsigned long)user_ptr, dst, size, 0);

kernel/bpf/helpers.c

698

memset(dst, 0, size);

kernel/bpf/queue_stack_maps.c

188

void *dst;

kernel/bpf/queue_stack_maps.c

212

dst = &qs->elements[qs->head * qs->map.value_size];

kernel/bpf/queue_stack_maps.c

213

memcpy(dst, value, qs->map.value_size);

kernel/bpf/syscall.c

1215

int bpf_obj_name_cpy(char *dst, const char *src, unsigned int size)

kernel/bpf/syscall.c

1220

memset(dst, 0, size);

kernel/bpf/syscall.c

1226

*dst++ = *src++;

kernel/bpf/verifier.c

1394

static void *copy_array(void *dst, const void *src, size_t n, size_t size, gfp_t flags)

kernel/bpf/verifier.c

1397

void *orig = dst;

kernel/bpf/verifier.c

1407

dst = krealloc(orig, alloc_bytes, flags);

kernel/bpf/verifier.c

1408

if (!dst) {

kernel/bpf/verifier.c

1413

memcpy(dst, src, bytes);

kernel/bpf/verifier.c

1415

return dst ? dst : ZERO_SIZE_PTR;

kernel/bpf/verifier.c

1446

static int copy_reference_state(struct bpf_verifier_state *dst, const struct bpf_verifier_state *src)

kernel/bpf/verifier.c

1448

dst->refs = copy_array(dst->refs, src->refs, src->acquired_refs,

kernel/bpf/verifier.c

1450

if (!dst->refs)

kernel/bpf/verifier.c

1453

dst->acquired_refs = src->acquired_refs;

kernel/bpf/verifier.c

1454

dst->active_locks = src->active_locks;

kernel/bpf/verifier.c

1455

dst->active_preempt_locks = src->active_preempt_locks;

kernel/bpf/verifier.c

1456

dst->active_rcu_locks = src->active_rcu_locks;

kernel/bpf/verifier.c

1457

dst->active_irq_id = src->active_irq_id;

kernel/bpf/verifier.c

1458

dst->active_lock_id = src->active_lock_id;

kernel/bpf/verifier.c

1459

dst->active_lock_ptr = src->active_lock_ptr;

kernel/bpf/verifier.c

1463

static int copy_stack_state(struct bpf_func_state *dst, const struct bpf_func_state *src)

kernel/bpf/verifier.c

1467

dst->stack = copy_array(dst->stack, src->stack, n, sizeof(struct bpf_stack_state),

kernel/bpf/verifier.c

1469

if (!dst->stack)

kernel/bpf/verifier.c

1472

dst->allocated_stack = src->allocated_stack;

kernel/bpf/verifier.c

14761

u32 dst = insn->dst_reg, src = insn->src_reg;

kernel/bpf/verifier.c

14766

off_reg == dst_reg ? dst : src, err);

kernel/bpf/verifier.c

14770

off_reg == dst_reg ? src : dst, err);

kernel/bpf/verifier.c

14774

dst, op, err);

kernel/bpf/verifier.c

14778

dst, op, err);

kernel/bpf/verifier.c

14782

dst, err);

kernel/bpf/verifier.c

14830

u32 dst = insn->dst_reg;

kernel/bpf/verifier.c

14840

if (check_stack_access_for_ptr_arithmetic(env, dst, dst_reg,

kernel/bpf/verifier.c

14845

if (check_map_access(env, dst, dst_reg->off, 1, false, ACCESS_HELPER)) {

kernel/bpf/verifier.c

14847

"prohibited for !root\n", dst);

kernel/bpf/verifier.c

14878

u32 dst = insn->dst_reg;

kernel/bpf/verifier.c

14881

dst_reg = &regs[dst];

kernel/bpf/verifier.c

14901

dst);

kernel/bpf/verifier.c

14907

dst, reg_type_str(env, ptr_reg->type));

kernel/bpf/verifier.c

14943

dst, reg_type_str(env, ptr_reg->type));

kernel/bpf/verifier.c

15016

dst);

kernel/bpf/verifier.c

15025

dst);

kernel/bpf/verifier.c

15074

dst, bpf_alu_string[opcode >> 4]);

kernel/bpf/verifier.c

15079

dst, bpf_alu_string[opcode >> 4]);

kernel/bpf/verifier.c

1744

static int copy_func_state(struct bpf_func_state *dst,

kernel/bpf/verifier.c

1747

memcpy(dst, src, offsetof(struct bpf_func_state, stack));

kernel/bpf/verifier.c

1748

return copy_stack_state(dst, src);

kernel/bpf/verifier.c

1754

struct bpf_func_state *dst;

kernel/bpf/verifier.c

1787

dst = dst_state->frame[i];

kernel/bpf/verifier.c

1788

if (!dst) {

kernel/bpf/verifier.c

1789

dst = kzalloc_obj(*dst, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

1790

if (!dst)

kernel/bpf/verifier.c

1792

dst_state->frame[i] = dst;

kernel/bpf/verifier.c

1794

err = copy_func_state(dst, src->frame[i]);

kernel/bpf/verifier.c

25549

u16 dst = BIT(insn->dst_reg);

kernel/bpf/verifier.c

25559

def = dst;

kernel/bpf/verifier.c

25573

def = dst;

kernel/bpf/verifier.c

25582

use = dst;

kernel/bpf/verifier.c

25590

use = dst | src;

kernel/bpf/verifier.c

25595

use = r0 | dst | src;

kernel/bpf/verifier.c

25599

def = dst;

kernel/bpf/verifier.c

25604

use = dst | src;

kernel/bpf/verifier.c

25607

use = dst | src;

kernel/bpf/verifier.c

25620

use = dst;

kernel/bpf/verifier.c

25621

def = dst;

kernel/bpf/verifier.c

25624

def = dst;

kernel/bpf/verifier.c

25631

def = dst;

kernel/bpf/verifier.c

25633

use = dst;

kernel/bpf/verifier.c

25635

use = dst | src;

kernel/bpf/verifier.c

25644

use = dst;

kernel/bpf/verifier.c

25665

use = dst;

kernel/bpf/verifier.c

25667

use = dst | src;

kernel/bpf/verifier.c

5187

static void copy_register_state(struct bpf_reg_state *dst, const struct bpf_reg_state *src)

kernel/bpf/verifier.c

5189

*dst = *src;

kernel/cgroup/freezer.c

226

struct cgroup *src, struct cgroup *dst)

kernel/cgroup/freezer.c

241

!test_bit(CGRP_FREEZE, &dst->flags) &&

kernel/cgroup/freezer.c

251

cgroup_inc_frozen_cnt(dst);

kernel/cgroup/freezer.c

254

cgroup_update_frozen(dst);

kernel/cgroup/freezer.c

260

cgroup_freeze_task(task, test_bit(CGRP_FREEZE, &dst->flags));

kernel/events/internal.h

179

memcpy_common(void *dst, const void *src, unsigned long n)

kernel/events/internal.h

181

memcpy(dst, src, n);

kernel/events/internal.h

188

memcpy_skip(void *dst, const void *src, unsigned long n)

kernel/events/internal.h

199

arch_perf_out_copy_user(void *dst, const void *src, unsigned long n)

kernel/events/internal.h

204

ret = __copy_from_user_inatomic(dst, src, n);

kernel/events/uprobes.c

180

void uprobe_copy_from_page(struct page *page, unsigned long vaddr, void *dst, int len)

kernel/events/uprobes.c

183

memcpy(dst, kaddr + (vaddr & ~PAGE_MASK), len);

kernel/fork.c

894

int __weak arch_dup_task_struct(struct task_struct *dst,

kernel/fork.c

897

*dst = *src;

kernel/gcov/clang.c

272

void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)

kernel/gcov/clang.c

278

list_for_each_entry(dfn_ptr, &dst->functions, head) {

kernel/gcov/gcc_4_7.c

246

void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)

kernel/gcov/gcc_4_7.c

255

dci_ptr = dst->functions[fi_idx]->ctrs;

kernel/kcsan/core.c

1344

void *__tsan_memmove(void *dst, const void *src, size_t len);

kernel/kcsan/core.c

1345

noinline void *__tsan_memmove(void *dst, const void *src, size_t len)

kernel/kcsan/core.c

1349

check_access(dst, check_len, KCSAN_ACCESS_WRITE, _RET_IP_);

kernel/kcsan/core.c

1351

return memmove(dst, src, len);

kernel/kcsan/core.c

1354

void *__tsan_memmove(void *dst, const void *src, size_t len) __alias(memmove);

kernel/kcsan/core.c

1359

void *__tsan_memcpy(void *dst, const void *src, size_t len);

kernel/kcsan/core.c

1360

noinline void *__tsan_memcpy(void *dst, const void *src, size_t len)

kernel/kcsan/core.c

1364

check_access(dst, check_len, KCSAN_ACCESS_WRITE, _RET_IP_);

kernel/kcsan/core.c

1366

return memcpy(dst, src, len);

kernel/kcsan/core.c

1369

void *__tsan_memcpy(void *dst, const void *src, size_t len) __alias(memcpy);

kernel/kexec_file.c

1046

void *src, *dst;

kernel/kexec_file.c

1089

dst = pi->purgatory_buf + offset;

kernel/kexec_file.c

1090

memcpy(dst, src, sechdrs[i].sh_size);

kernel/locking/lockdep.c

285

static inline void lock_time_add(struct lock_time *src, struct lock_time *dst)

kernel/locking/lockdep.c

290

if (src->max > dst->max)

kernel/locking/lockdep.c

291

dst->max = src->max;

kernel/locking/lockdep.c

293

if (src->min < dst->min || !dst->nr)

kernel/locking/lockdep.c

294

dst->min = src->min;

kernel/locking/lockdep.c

296

dst->total += src->total;

kernel/locking/lockdep.c

297

dst->nr += src->nr;

kernel/module/decompress.c

265

zstd_dec.dst = kmap_local_page(page);

kernel/module/decompress.c

270

kunmap_local(zstd_dec.dst);

kernel/module/kallsyms.c

174

Elf_Sym *dst;

kernel/module/kallsyms.c

194

mod->core_kallsyms.symtab = dst = data_base + info->symoffs;

kernel/module/kallsyms.c

208

dst[ndst] = src[i];

kernel/module/kallsyms.c

209

dst[ndst++].st_name = s - mod->core_kallsyms.strtab;

kernel/module/main.c

2399

static int copy_chunked_from_user(void *dst, const void __user *usrc, unsigned long len)

kernel/module/main.c

2404

if (copy_from_user(dst, usrc, n) != 0)

kernel/module/main.c

2407

dst += n;

kernel/power/snapshot.c

1431

static inline bool do_copy_page(long *dst, long *src)

kernel/power/snapshot.c

1438

*dst++ = *src++;

kernel/power/snapshot.c

1452

static bool safe_copy_page(void *dst, struct page *s_page)

kernel/power/snapshot.c

1457

zeros_only = do_copy_page(dst, page_address(s_page));

kernel/power/snapshot.c

1460

zeros_only = do_copy_page(dst, page_address(s_page));

kernel/power/snapshot.c

1476

void *src, *dst;

kernel/power/snapshot.c

1483

dst = kmap_local_page(d_page);

kernel/power/snapshot.c

1484

zeros_only = do_copy_page(dst, src);

kernel/power/snapshot.c

1485

kunmap_local(dst);

kernel/power/snapshot.c

1494

dst = kmap_local_page(d_page);

kernel/power/snapshot.c

1495

copy_page(dst, buffer);

kernel/power/snapshot.c

1496

kunmap_local(dst);

kernel/power/snapshot.c

2282

static void duplicate_memory_bitmap(struct memory_bitmap *dst,

kernel/power/snapshot.c

2290

memory_bm_set_bit(dst, pfn);

kernel/power/snapshot.c

2559

void *dst;

kernel/power/snapshot.c

2561

dst = kmap_local_page(last_highmem_page);

kernel/power/snapshot.c

2562

copy_page(dst, buffer);

kernel/power/snapshot.c

2563

kunmap_local(dst);

kernel/power/snapshot.c

471

struct rtree_node *node, *block, **dst;

kernel/power/snapshot.c

503

dst = &zone->rtree;

kernel/power/snapshot.c

513

*dst = node;

kernel/power/snapshot.c

518

dst = (struct rtree_node **)&((*dst)->data[index]);

kernel/power/snapshot.c

519

node = *dst;

kernel/power/snapshot.c

523

*dst = block;

kernel/ptrace.c

607

int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)

kernel/ptrace.c

623

if (copy_to_user(dst, buf, retval))

kernel/ptrace.c

627

dst += retval;

kernel/ptrace.c

633

int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)

kernel/ptrace.c

644

retval = ptrace_access_vm(tsk, dst, buf, this_len,

kernel/ptrace.c

653

dst += retval;

kernel/sched/core.c

2728

int dup_user_cpus_ptr(struct task_struct *dst, struct task_struct *src,

kernel/sched/core.c

2738

dst->user_cpus_ptr = NULL;

kernel/sched/core.c

2760

swap(dst->user_cpus_ptr, user_mask);

kernel/sched/core.c

2761

cpumask_copy(dst->user_cpus_ptr, src->user_cpus_ptr);

kernel/sched/core.c

6251

struct rq *dst = cpu_rq(this), *src = cpu_rq(that);

kernel/sched/core.c

6257

guard(double_rq_lock)(dst, src);

kernel/sched/core.c

6259

cookie = dst->core->core_cookie;

kernel/sched/core.c

6263

if (dst->curr != dst->idle)

kernel/sched/core.c

6277

if (p->core_occupation > dst->idle->core_occupation)

kernel/sched/core.c

6288

move_queued_task_locked(src, dst, p);

kernel/sched/core.c

6289

resched_curr(dst);

kernel/sched/cputime.c

1012

static int kcpustat_cpu_fetch_vtime(struct kernel_cpustat *dst,

kernel/sched/cputime.c

1030

*dst = *src;

kernel/sched/cputime.c

1031

cpustat = dst->cpustat;

kernel/sched/cputime.c

1065

void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu)

kernel/sched/cputime.c

1072

*dst = *src;

kernel/sched/cputime.c

1085

*dst = *src;

kernel/sched/cputime.c

1089

err = kcpustat_cpu_fetch_vtime(dst, src, curr, cpu);

kernel/smp.c

209

return csd->node.dst; /* Other CSD_TYPE_ values might not have ->dst. */

kernel/smp.c

681

csd->node.dst = cpu;

kernel/smp.c

836

csd->node.dst = cpu;

kernel/time/clocksource.c

1346

ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt)

kernel/time/clocksource.c

1358

memcpy(dst, buf, cnt);

kernel/time/clocksource.c

1359

dst[cnt] = 0;

kernel/time/tick-internal.h

213

extern ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt);

kernel/trace/bpf_trace.c

173

bpf_probe_read_user_common(void *dst, u32 size, const void __user *unsafe_ptr)

kernel/trace/bpf_trace.c

177

ret = copy_from_user_nofault(dst, unsafe_ptr, size);

kernel/trace/bpf_trace.c

179

memset(dst, 0, size);

kernel/trace/bpf_trace.c

183

BPF_CALL_3(bpf_probe_read_user, void *, dst, u32, size,

kernel/trace/bpf_trace.c

186

return bpf_probe_read_user_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

199

bpf_probe_read_user_str_common(void *dst, u32 size,

kernel/trace/bpf_trace.c

214

ret = strncpy_from_user_nofault(dst, unsafe_ptr, size);

kernel/trace/bpf_trace.c

216

memset(dst, 0, size);

kernel/trace/bpf_trace.c

220

BPF_CALL_3(bpf_probe_read_user_str, void *, dst, u32, size,

kernel/trace/bpf_trace.c

223

return bpf_probe_read_user_str_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

235

BPF_CALL_3(bpf_probe_read_kernel, void *, dst, u32, size,

kernel/trace/bpf_trace.c

238

return bpf_probe_read_kernel_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

251

bpf_probe_read_kernel_str_common(void *dst, u32 size, const void *unsafe_ptr)

kernel/trace/bpf_trace.c

264

ret = strncpy_from_kernel_nofault(dst, unsafe_ptr, size);

kernel/trace/bpf_trace.c

266

memset(dst, 0, size);

kernel/trace/bpf_trace.c

270

BPF_CALL_3(bpf_probe_read_kernel_str, void *, dst, u32, size,

kernel/trace/bpf_trace.c

273

return bpf_probe_read_kernel_str_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

286

BPF_CALL_3(bpf_probe_read_compat, void *, dst, u32, size,

kernel/trace/bpf_trace.c

290

return bpf_probe_read_user_common(dst, size,

kernel/trace/bpf_trace.c

293

return bpf_probe_read_kernel_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

305

BPF_CALL_3(bpf_probe_read_compat_str, void *, dst, u32, size,

kernel/trace/bpf_trace.c

309

return bpf_probe_read_user_str_common(dst, size,

kernel/trace/bpf_trace.c

312

return bpf_probe_read_kernel_str_common(dst, size, unsafe_ptr);

kernel/trace/bpf_trace.c

3391

typedef int (*copy_fn_t)(void *dst, const void *src, u32 size, struct task_struct *tsk);

kernel/trace/bpf_trace.c

3405

struct bpf_dynptr_kern *dst;

kernel/trace/bpf_trace.c

3415

dst = (struct bpf_dynptr_kern *)dptr;

kernel/trace/bpf_trace.c

3416

if (bpf_dynptr_check_off_len(dst, doff, size))

kernel/trace/bpf_trace.c

3428

err = __bpf_dynptr_write(dst, doff + off, buf, cnt, 0);

kernel/trace/bpf_trace.c

3441

struct bpf_dynptr_kern *dst;

kernel/trace/bpf_trace.c

3451

dst = (struct bpf_dynptr_kern *)dptr;

kernel/trace/bpf_trace.c

3452

if (bpf_dynptr_check_off_len(dst, doff, size))

kernel/trace/bpf_trace.c

3460

err = __bpf_dynptr_write(dst, doff + off, buf, chunk_sz, 0);

kernel/trace/bpf_trace.c

3467

static __always_inline int copy_user_data_nofault(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3470

return copy_from_user_nofault(dst, (const void __user *)unsafe_src, size);

kernel/trace/bpf_trace.c

3473

static __always_inline int copy_user_data_sleepable(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3479

ret = copy_from_user(dst, (const void __user *)unsafe_src, size);

kernel/trace/bpf_trace.c

3485

ret = access_process_vm(tsk, (unsigned long)unsafe_src, dst, size, 0);

kernel/trace/bpf_trace.c

3491

static __always_inline int copy_kernel_data_nofault(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3494

return copy_from_kernel_nofault(dst, unsafe_src, size);

kernel/trace/bpf_trace.c

3497

static __always_inline int copy_user_str_nofault(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3500

return strncpy_from_user_nofault(dst, (const void __user *)unsafe_src, size);

kernel/trace/bpf_trace.c

3503

static __always_inline int copy_user_str_sleepable(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3512

ret = copy_remote_vm_str(tsk, (unsigned long)unsafe_src, dst, size, 0);

kernel/trace/bpf_trace.c

3514

ret = strncpy_from_user(dst, (const void __user *)unsafe_src, size - 1);

kernel/trace/bpf_trace.c

3517

((char *)dst)[ret] = '\0';

kernel/trace/bpf_trace.c

3525

static __always_inline int copy_kernel_str_nofault(void *dst, const void *unsafe_src,

kernel/trace/bpf_trace.c

3528

return strncpy_from_kernel_nofault(dst, unsafe_src, size);

kernel/trace/ftrace.c

1504

struct ftrace_hash **dst, struct ftrace_hash *src)

kernel/trace/ftrace.c

1533

rcu_assign_pointer(*dst, new_hash);

kernel/trace/trace.h

1582

typedef int (*trace_user_buf_copy)(char *dst, const char __user *src,

kernel/trace/trace_osnoise.c

828

copy_int_safe_time(struct osnoise_variables *osn_var, u64 *dst, u64 *src)

kernel/trace/trace_osnoise.c

837

*dst = *src;

kernel/trace/trace_uprobe.c

152

u8 *dst = get_loc_data(dest, base);

kernel/trace/trace_uprobe.c

159

ret = strscpy(dst, current->comm, maxlen);

kernel/trace/trace_uprobe.c

161

ret = strncpy_from_user(dst, src, maxlen);

kernel/trace/trace_uprobe.c

164

dst[ret - 1] = '\0';

kernel/trace/trace_uprobe.c

172

*(u32 *)dest = make_data_loc(ret, (void *)dst - base);

kernel/trace/trace_uprobe.c

174

*(u32 *)dest = make_data_loc(0, (void *)dst - base);

lib/base64.c

116

return cp - dst;

lib/base64.c

133

int base64_decode(const char *src, int srclen, u8 *dst, bool padding, enum base64_variant variant)

lib/base64.c

135

u8 *bp = dst;

lib/base64.c

166

return bp - dst;

lib/base64.c

182

return bp - dst;

lib/base64.c

80

int base64_encode(const u8 *src, int srclen, char *dst, bool padding, enum base64_variant variant)

lib/base64.c

83

char *cp = dst;

lib/bch.c

152

static void load_ecc8(struct bch_control *bch, uint32_t *dst,

lib/bch.c

159

dst[i] = ((u32)swap_bits(bch, src[0]) << 24) |

lib/bch.c

165

dst[nwords] = ((u32)swap_bits(bch, pad[0]) << 24) |

lib/bch.c

174

static void store_ecc8(struct bch_control *bch, uint8_t *dst,

lib/bch.c

181

*dst++ = swap_bits(bch, src[i] >> 24);

lib/bch.c

182

*dst++ = swap_bits(bch, src[i] >> 16);

lib/bch.c

183

*dst++ = swap_bits(bch, src[i] >> 8);

lib/bch.c

184

*dst++ = swap_bits(bch, src[i]);

lib/bch.c

190

memcpy(dst, pad, BCH_ECC_BYTES(bch)-4*nwords);

lib/bch.c

404

static void gf_poly_copy(struct gf_poly *dst, struct gf_poly *src)

lib/bch.c

406

memcpy(dst, src, GF_POLY_SZ(src->deg));

lib/bitmap.c

117

dst[k] = lower | upper;

lib/bitmap.c

120

memset(&dst[lim - off], 0, off*sizeof(unsigned long));

lib/bitmap.c

137

void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,

lib/bitmap.c

155

dst[k + off] = lower | upper;

lib/bitmap.c

158

memset(dst, 0, off*sizeof(unsigned long));

lib/bitmap.c

199

void bitmap_cut(unsigned long *dst, const unsigned long *src,

lib/bitmap.c

211

memmove(dst, src, len * sizeof(*dst));

lib/bitmap.c

216

carry = dst[i + 1] & 1UL;

lib/bitmap.c

220

dst[i] = (dst[i] >> 1) | (carry << (BITS_PER_LONG - 1));

lib/bitmap.c

224

dst[first / BITS_PER_LONG] &= ~0UL << (first % BITS_PER_LONG);

lib/bitmap.c

225

dst[first / BITS_PER_LONG] |= keep;

lib/bitmap.c

229

bool __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,

lib/bitmap.c

237

result |= (dst[k] = bitmap1[k] & bitmap2[k]);

lib/bitmap.c

239

result |= (dst[k] = bitmap1[k] & bitmap2[k] &

lib/bitmap.c

245

void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,

lib/bitmap.c

252

dst[k] = bitmap1[k] | bitmap2[k];

lib/bitmap.c

256

void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,

lib/bitmap.c

263

dst[k] = bitmap1[k] ^ bitmap2[k];

lib/bitmap.c

267

bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,

lib/bitmap.c

275

result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);

lib/bitmap.c

277

result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &

lib/bitmap.c

283

void __bitmap_replace(unsigned long *dst,

lib/bitmap.c

291

dst[k] = (old[k] & ~mask[k]) | (new[k] & mask[k]);

lib/bitmap.c

358

unsigned int __bitmap_weighted_or(unsigned long *dst, const unsigned long *bitmap1,

lib/bitmap.c

361

return BITMAP_WEIGHT(({dst[idx] = bitmap1[idx] | bitmap2[idx]; dst[idx]; }), bits);

lib/bitmap.c

503

void bitmap_remap(unsigned long *dst, const unsigned long *src,

lib/bitmap.c

509

if (dst == src) /* following doesn't handle inplace remaps */

lib/bitmap.c

511

bitmap_zero(dst, nbits);

lib/bitmap.c

518

set_bit(oldbit, dst); /* identity map */

lib/bitmap.c

520

set_bit(find_nth_bit(new, nbits, n % w), dst);

lib/bitmap.c

670

void bitmap_onto(unsigned long *dst, const unsigned long *orig,

lib/bitmap.c

675

if (dst == orig) /* following doesn't handle inplace mappings */

lib/bitmap.c

677

bitmap_zero(dst, bits);

lib/bitmap.c

693

set_bit(n, dst);

lib/bitmap.c

709

void bitmap_fold(unsigned long *dst, const unsigned long *orig,

lib/bitmap.c

714

if (dst == orig) /* following doesn't handle inplace mappings */

lib/bitmap.c

716

bitmap_zero(dst, nbits);

lib/bitmap.c

719

set_bit(oldbit % sz, dst);

lib/bitmap.c

73

void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)

lib/bitmap.c

77

dst[k] = ~src[k];

lib/bitmap.c

92

void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,

lib/crypto/aescfb.c

14

static void aescfb_encrypt_block(const struct aes_enckey *key, void *dst,

lib/crypto/aescfb.c

28

aes_encrypt(key, dst, src);

lib/crypto/aescfb.c

41

void aescfb_encrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,

lib/crypto/aescfb.c

49

crypto_xor_cpy(dst, src, ks, min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

50

v = dst;

lib/crypto/aescfb.c

52

dst += AES_BLOCK_SIZE;

lib/crypto/aescfb.c

70

void aescfb_decrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,

lib/crypto/aescfb.c

86

crypto_xor_cpy(dst, src, ks[i], min(len, AES_BLOCK_SIZE));

lib/crypto/aescfb.c

88

dst += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

107

static void aesgcm_crypt(const struct aesgcm_ctx *ctx, u8 *dst, const u8 *src,

lib/crypto/aesgcm.c

123

crypto_xor_cpy(dst, src, buf, min(len, AES_BLOCK_SIZE));

lib/crypto/aesgcm.c

125

dst += AES_BLOCK_SIZE;

lib/crypto/aesgcm.c

147

void aesgcm_encrypt(const struct aesgcm_ctx *ctx, u8 *dst, const u8 *src,

lib/crypto/aesgcm.c

15

static void aesgcm_encrypt_block(const struct aes_enckey *key, void *dst,

lib/crypto/aesgcm.c

155

aesgcm_crypt(ctx, dst, src, crypt_len, ctr);

lib/crypto/aesgcm.c

156

aesgcm_mac(ctx, dst, crypt_len, assoc, assoc_len, ctr, authtag);

lib/crypto/aesgcm.c

177

bool __must_check aesgcm_decrypt(const struct aesgcm_ctx *ctx, u8 *dst,

lib/crypto/aesgcm.c

192

aesgcm_crypt(ctx, dst, src, crypt_len, ctr);

lib/crypto/aesgcm.c

29

aes_encrypt(key, dst, src);

lib/crypto/arm/chacha.h

18

u8 *dst, const u8 *src, int nrounds);

lib/crypto/arm/chacha.h

20

u8 *dst, const u8 *src,

lib/crypto/arm/chacha.h

27

asmlinkage void chacha_doarm(u8 *dst, const u8 *src, unsigned int bytes,

lib/crypto/arm/chacha.h

37

static void chacha_doneon(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/arm/chacha.h

45

chacha_4block_xor_neon(state, dst, src, nrounds, l);

lib/crypto/arm/chacha.h

48

dst += l;

lib/crypto/arm/chacha.h

53

u8 *d = dst;

lib/crypto/arm/chacha.h

58

if (d != dst)

lib/crypto/arm/chacha.h

59

memcpy(dst, buf, bytes);

lib/crypto/arm/chacha.h

75

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/arm/chacha.h

80

chacha_doarm(dst, src, bytes, state, nrounds);

lib/crypto/arm/chacha.h

89

chacha_doneon(state, dst, src, todo, nrounds);

lib/crypto/arm/chacha.h

93

dst += todo;

lib/crypto/arm64/chacha.h

29

u8 *dst, const u8 *src, int nrounds);

lib/crypto/arm64/chacha.h

31

u8 *dst, const u8 *src,

lib/crypto/arm64/chacha.h

38

static void chacha_doneon(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/arm64/chacha.h

49

memcpy(dst, buf, l);

lib/crypto/arm64/chacha.h

53

chacha_4block_xor_neon(state, dst, src, nrounds, l);

lib/crypto/arm64/chacha.h

56

dst += l;

lib/crypto/arm64/chacha.h

72

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/arm64/chacha.h

77

return chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/arm64/chacha.h

83

chacha_doneon(state, dst, src, todo, nrounds);

lib/crypto/arm64/chacha.h

87

dst += todo;

lib/crypto/chacha.c

15

chacha_crypt_generic(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/chacha.c

23

crypto_xor_cpy(dst, src, stream, CHACHA_BLOCK_SIZE);

lib/crypto/chacha.c

25

dst += CHACHA_BLOCK_SIZE;

lib/crypto/chacha.c

30

crypto_xor_cpy(dst, src, stream, bytes);

lib/crypto/chacha.c

41

void chacha_crypt(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/chacha.c

44

chacha_crypt_arch(state, dst, src, bytes, nrounds);

lib/crypto/chacha20poly1305-selftest.c

8828

chacha20poly1305_encrypt_bignonce(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305-selftest.c

8852

chacha20_crypt(&chacha20_state, dst, src, src_len);

lib/crypto/chacha20poly1305-selftest.c

8853

poly1305_update(&poly1305_state, dst, src_len);

lib/crypto/chacha20poly1305-selftest.c

8858

poly1305_final(&poly1305_state, dst + src_len);

lib/crypto/chacha20poly1305-selftest.c

8862

chacha20poly1305_selftest_encrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305-selftest.c

8868

chacha20poly1305_encrypt(dst, src, src_len, ad, ad_len,

lib/crypto/chacha20poly1305-selftest.c

8871

chacha20poly1305_encrypt_bignonce(dst, src, src_len, ad,

lib/crypto/chacha20poly1305.c

104

__chacha20poly1305_encrypt(dst, src, src_len, ad, ad_len,

lib/crypto/chacha20poly1305.c

112

void xchacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305.c

120

__chacha20poly1305_encrypt(dst, src, src_len, ad, ad_len,

lib/crypto/chacha20poly1305.c

126

__chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305.c

163

chacha20_crypt(chacha_state, dst, src, dst_len);

lib/crypto/chacha20poly1305.c

170

bool chacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305.c

186

ret = __chacha20poly1305_decrypt(dst, src, src_len, ad, ad_len,

lib/crypto/chacha20poly1305.c

196

bool xchacha20poly1305_decrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305.c

204

return __chacha20poly1305_decrypt(dst, src, src_len, ad, ad_len,

lib/crypto/chacha20poly1305.c

55

__chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/chacha20poly1305.c

73

chacha20_crypt(chacha_state, dst, src, src_len);

lib/crypto/chacha20poly1305.c

75

poly1305_update(&poly1305_state, dst, src_len);

lib/crypto/chacha20poly1305.c

83

poly1305_final(&poly1305_state, dst + src_len);

lib/crypto/chacha20poly1305.c

89

void chacha20poly1305_encrypt(u8 *dst, const u8 *src, const size_t src_len,

lib/crypto/des.c

780

void des_encrypt(const struct des_ctx *ctx, u8 *dst, const u8 *src)

lib/crypto/des.c

796

put_unaligned_le32(R, dst);

lib/crypto/des.c

797

put_unaligned_le32(L, dst + 4);

lib/crypto/des.c

801

void des_decrypt(const struct des_ctx *ctx, u8 *dst, const u8 *src)

lib/crypto/des.c

817

put_unaligned_le32(R, dst);

lib/crypto/des.c

818

put_unaligned_le32(L, dst + 4);

lib/crypto/des.c

843

void des3_ede_encrypt(const struct des3_ede_ctx *dctx, u8 *dst, const u8 *src)

lib/crypto/des.c

867

put_unaligned_le32(R, dst);

lib/crypto/des.c

868

put_unaligned_le32(L, dst + 4);

lib/crypto/des.c

872

void des3_ede_decrypt(const struct des3_ede_ctx *dctx, u8 *dst, const u8 *src)

lib/crypto/des.c

896

put_unaligned_le32(R, dst);

lib/crypto/des.c

897

put_unaligned_le32(L, dst + 4);

lib/crypto/mips/chacha.h

11

u8 *dst, const u8 *src,

lib/crypto/poly1305-donna32.c

122

void *dst)

lib/crypto/poly1305-donna32.c

124

u8 *mac = dst;

lib/crypto/poly1305-donna64.c

113

void *dst)

lib/crypto/poly1305-donna64.c

115

u8 *mac = dst;

lib/crypto/poly1305.c

70

void poly1305_final(struct poly1305_desc_ctx *desc, u8 *dst)

lib/crypto/poly1305.c

80

poly1305_emit(&desc->state.h, dst, desc->s);

lib/crypto/powerpc/chacha.h

15

asmlinkage void chacha_p10le_8x(const struct chacha_state *state, u8 *dst,

lib/crypto/powerpc/chacha.h

32

static void chacha_p10_do_8x(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/powerpc/chacha.h

38

chacha_p10le_8x(state, dst, src, l, nrounds);

lib/crypto/powerpc/chacha.h

41

dst += l;

lib/crypto/powerpc/chacha.h

46

chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/powerpc/chacha.h

51

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/powerpc/chacha.h

56

return chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/powerpc/chacha.h

62

chacha_p10_do_8x(state, dst, src, todo, nrounds);

lib/crypto/powerpc/chacha.h

67

dst += todo;

lib/crypto/riscv/chacha.h

21

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/riscv/chacha.h

29

return chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/riscv/chacha.h

33

chacha_zvkb(state, src, dst, full_blocks, nrounds);

lib/crypto/riscv/chacha.h

35

dst += full_blocks * CHACHA_BLOCK_SIZE;

lib/crypto/riscv/chacha.h

40

memcpy(dst, block_buffer, tail_bytes);

lib/crypto/s390/chacha.h

17

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/s390/chacha.h

25

chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/s390/chacha.h

30

chacha20_vx(dst, src, bytes, &state->x[4], &state->x[12]);

lib/crypto/tests/mldsa_kunit.c

65

u8 *dst = kunit_kmalloc(test, len, GFP_KERNEL);

lib/crypto/tests/mldsa_kunit.c

67

KUNIT_ASSERT_NOT_NULL(test, dst);

lib/crypto/tests/mldsa_kunit.c

68

return memcpy(dst, src, len);

lib/crypto/utils.c

18

void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int len)

lib/crypto/utils.c

24

int d = (((unsigned long)dst ^ (unsigned long)src1) |

lib/crypto/utils.c

25

((unsigned long)dst ^ (unsigned long)src2)) &

lib/crypto/utils.c

36

while (((unsigned long)dst & (relalign - 1)) && len > 0) {

lib/crypto/utils.c

37

*dst++ = *src1++ ^ *src2++;

lib/crypto/utils.c

46

put_unaligned(l, (u64 *)dst);

lib/crypto/utils.c

48

*(u64 *)dst = *(u64 *)src1 ^ *(u64 *)src2;

lib/crypto/utils.c

50

dst += 8;

lib/crypto/utils.c

60

put_unaligned(l, (u32 *)dst);

lib/crypto/utils.c

62

*(u32 *)dst = *(u32 *)src1 ^ *(u32 *)src2;

lib/crypto/utils.c

64

dst += 4;

lib/crypto/utils.c

74

put_unaligned(l, (u16 *)dst);

lib/crypto/utils.c

76

*(u16 *)dst = *(u16 *)src1 ^ *(u16 *)src2;

lib/crypto/utils.c

78

dst += 2;

lib/crypto/utils.c

85

*dst++ = *src1++ ^ *src2++;

lib/crypto/x86/chacha.h

103

chacha_2block_xor_avx2(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

110

chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

113

dst += CHACHA_BLOCK_SIZE * 4;

lib/crypto/x86/chacha.h

117

chacha_4block_xor_ssse3(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

122

chacha_block_xor_ssse3(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

139

static void chacha_crypt_arch(struct chacha_state *state, u8 *dst,

lib/crypto/x86/chacha.h

14

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

144

return chacha_crypt_generic(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

150

chacha_dosimd(state, dst, src, todo, nrounds);

lib/crypto/x86/chacha.h

155

dst += todo;

lib/crypto/x86/chacha.h

17

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

23

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

26

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

29

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

33

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

36

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

39

u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

52

static void chacha_dosimd(struct chacha_state *state, u8 *dst, const u8 *src,

lib/crypto/x86/chacha.h

57

chacha_8block_xor_avx512vl(state, dst, src, bytes,

lib/crypto/x86/chacha.h

61

dst += CHACHA_BLOCK_SIZE * 8;

lib/crypto/x86/chacha.h

65

chacha_8block_xor_avx512vl(state, dst, src, bytes,

lib/crypto/x86/chacha.h

71

chacha_4block_xor_avx512vl(state, dst, src, bytes,

lib/crypto/x86/chacha.h

77

chacha_2block_xor_avx512vl(state, dst, src, bytes,

lib/crypto/x86/chacha.h

86

chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

89

dst += CHACHA_BLOCK_SIZE * 8;

lib/crypto/x86/chacha.h

93

chacha_8block_xor_avx2(state, dst, src, bytes, nrounds);

lib/crypto/x86/chacha.h

98

chacha_4block_xor_avx2(state, dst, src, bytes, nrounds);

lib/debugobjects.c

152

static bool pool_move_batch(struct obj_pool *dst, struct obj_pool *src)

lib/debugobjects.c

157

if (dst->cnt >= dst->max_cnt || !src->cnt)

lib/debugobjects.c

171

last->next = dst->objects.first;

lib/debugobjects.c

174

first_batch->pprev = &dst->objects.first;

lib/debugobjects.c

175

dst->objects.first = first_batch;

lib/debugobjects.c

178

WRITE_ONCE(dst->cnt, dst->cnt + ODEBUG_BATCH_SIZE);

lib/debugobjects.c

182

static bool pool_push_batch(struct obj_pool *dst, struct hlist_head *head)

lib/debugobjects.c

187

if (dst->cnt >= dst->max_cnt)

lib/debugobjects.c

193

hlist_splice_init(head, last, &dst->objects);

lib/debugobjects.c

194

WRITE_ONCE(dst->cnt, dst->cnt + ODEBUG_BATCH_SIZE);

lib/decompress_unzstd.c

238

out.dst = out_buf;

lib/decompress_unzstd.c

309

if (out.pos != flush(out.dst, out.pos)) {

lib/hexdump.c

64

int hex2bin(u8 *dst, const char *src, size_t count)

lib/hexdump.c

76

*dst++ = (hi << 4) | lo;

lib/hexdump.c

88

char *bin2hex(char *dst, const void *src, size_t count)

lib/hexdump.c

93

dst = hex_byte_pack(dst, *_src++);

lib/hexdump.c

94

return dst;

lib/iomap.c

310

static inline void mmio_insb(const void __iomem *addr, u8 *dst, int count)

lib/iomap.c

314

*dst = data;

lib/iomap.c

315

dst++;

lib/iomap.c

318

static inline void mmio_insw(const void __iomem *addr, u16 *dst, int count)

lib/iomap.c

322

*dst = data;

lib/iomap.c

323

dst++;

lib/iomap.c

326

static inline void mmio_insl(const void __iomem *addr, u32 *dst, int count)

lib/iomap.c

330

*dst = data;

lib/iomap.c

331

dst++;

lib/iomap.c

360

void ioread8_rep(const void __iomem *addr, void *dst, unsigned long count)

lib/iomap.c

362

IO_COND(addr, insb(port,dst,count), mmio_insb(addr, dst, count));

lib/iomap.c

364

kmsan_unpoison_memory(dst, count);

lib/iomap.c

366

void ioread16_rep(const void __iomem *addr, void *dst, unsigned long count)

lib/iomap.c

368

IO_COND(addr, insw(port,dst,count), mmio_insw(addr, dst, count));

lib/iomap.c

370

kmsan_unpoison_memory(dst, count * 2);

lib/iomap.c

372

void ioread32_rep(const void __iomem *addr, void *dst, unsigned long count)

lib/iomap.c

374

IO_COND(addr, insl(port,dst,count), mmio_insl(addr, dst, count));

lib/iomap.c

376

kmsan_unpoison_memory(dst, count * 4);

lib/iomap_copy.c

22

u32 __iomem *dst = to;

lib/iomap_copy.c

27

__raw_writel(*src++, dst++);

lib/iomap_copy.c

44

u32 *dst = to;

lib/iomap_copy.c

49

*dst++ = __raw_readl(src++);

lib/iomap_copy.c

67

u64 __iomem *dst = to;

lib/iomap_copy.c

72

__raw_writeq(*src++, dst++);

lib/iomem_copy.c

104

void memcpy_toio(volatile void __iomem *dst, const void *src, size_t count)

lib/iomem_copy.c

106

while (count && !IS_ALIGNED((long)dst, sizeof(long))) {

lib/iomem_copy.c

107

__raw_writeb(*(u8 *)src, dst);

lib/iomem_copy.c

109

dst++;

lib/iomem_copy.c

116

__raw_writeq(val, dst);

lib/iomem_copy.c

118

__raw_writel(val, dst);

lib/iomem_copy.c

122

dst += sizeof(long);

lib/iomem_copy.c

127

__raw_writeb(*(u8 *)src, dst);

lib/iomem_copy.c

129

dst++;

lib/iomem_copy.c

62

void memcpy_fromio(void *dst, const volatile void __iomem *src, size_t count)

lib/iomem_copy.c

65

*(u8 *)dst = __raw_readb(src);

lib/iomem_copy.c

67

dst++;

lib/iomem_copy.c

77

put_unaligned(val, (long *)dst);

lib/iomem_copy.c

81

dst += sizeof(long);

lib/iomem_copy.c

86

*(u8 *)dst = __raw_readb(src);

lib/iomem_copy.c

88

dst++;

lib/kfifo.c

129

static void kfifo_copy_out(struct __kfifo *fifo, void *dst,

lib/kfifo.c

144

memcpy(dst, fifo->data + off, l);

lib/kfifo.c

145

memcpy(dst + l, fifo->data, len - l);

lib/lz4/lz4_compress.c

524

char * const dst,

lib/lz4/lz4_compress.c

537

BYTE *op = (BYTE *) dst;

lib/lz4/lz4_compress.c

716

return (int) (((char *)op) - dst);

lib/lz4/lz4_compress.c

722

char *dst,

lib/lz4/lz4_compress.c

737

state, src, dst, *srcSizePtr,

lib/lz4/lz4_compress.c

743

src, dst, srcSizePtr,

lib/lz4/lz4_compress.c

748

src, dst, srcSizePtr,

lib/lz4/lz4_compress.c

756

char *dst,

lib/lz4/lz4_compress.c

761

return LZ4_compress_destSize_extState(wrkmem, src, dst, srcSizePtr,

lib/lz4/lz4_decompress.c

448

return (int) (((char *)op) - dst);

lib/lz4/lz4_decompress.c

468

int LZ4_decompress_safe_partial(const char *src, char *dst,

lib/lz4/lz4_decompress.c

472

return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,

lib/lz4/lz4_decompress.c

474

noDict, (BYTE *)dst, NULL, 0);

lib/lz4/lz4_decompress.c

61

char * const dst,

lib/lz4/lz4_decompress.c

85

BYTE *op = (BYTE *) dst;

lib/lz4/lz4defs.h

150

#define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)

lib/lz4/lz4defs.h

151

#define LZ4_memmove(dst, src, size) __builtin_memmove(dst, src, size)

lib/lz4/lz4defs.h

153

static FORCE_INLINE void LZ4_copy8(void *dst, const void *src)

lib/lz4/lz4defs.h

158

put_unaligned(a, (U64 *)dst);

lib/lz4/lz4defs.h

163

put_unaligned(a, (U32 *)dst);

lib/lz4/lz4defs.h

164

put_unaligned(b, (U32 *)dst + 1);

lib/lz4/lz4hc_compress.c

583

char *dst,

lib/lz4/lz4hc_compress.c

600

return LZ4HC_compress_generic(ctx, src, dst,

lib/lz4/lz4hc_compress.c

603

return LZ4HC_compress_generic(ctx, src, dst,

lib/lz4/lz4hc_compress.c

607

int LZ4_compress_HC(const char *src, char *dst, int srcSize,

lib/lz4/lz4hc_compress.c

610

return LZ4_compress_HC_extStateHC(wrkmem, src, dst,

lib/lzo/lzodefs.h

22

#define COPY4(dst, src) \

lib/lzo/lzodefs.h

23

put_unaligned(get_unaligned((const u32 *)(src)), (u32 *)(dst))

lib/lzo/lzodefs.h

25

#define COPY8(dst, src) \

lib/lzo/lzodefs.h

26

put_unaligned(get_unaligned((const u64 *)(src)), (u64 *)(dst))

lib/lzo/lzodefs.h

28

#define COPY8(dst, src) \

lib/lzo/lzodefs.h

29

COPY4(dst, src); COPY4((dst) + 4, (src) + 4)

lib/nlattr.c

772

ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize)

lib/nlattr.c

793

memcpy(dst, src, len);

lib/nlattr.c

795

memset(dst + len, 0, dstsize - len);

lib/nlattr.c

811

char *src = nla_data(nla), *dst;

lib/nlattr.c

816

dst = kmalloc(srclen + 1, flags);

lib/nlattr.c

817

if (dst != NULL) {

lib/nlattr.c

818

memcpy(dst, src, srclen);

lib/nlattr.c

819

dst[srclen] = '\0';

lib/nlattr.c

821

return dst;

lib/string_helpers.c

189

static bool unescape_space(char **src, char **dst)

lib/string_helpers.c

191

char *p = *dst, *q = *src;

lib/string_helpers.c

212

*dst += 1;

lib/string_helpers.c

217

static bool unescape_octal(char **src, char **dst)

lib/string_helpers.c

219

char *p = *dst, *q = *src;

lib/string_helpers.c

231

*dst += 1;

lib/string_helpers.c

236

static bool unescape_hex(char **src, char **dst)

lib/string_helpers.c

238

char *p = *dst, *q = *src;

lib/string_helpers.c

255

*dst += 1;

lib/string_helpers.c

260

static bool unescape_special(char **src, char **dst)

lib/string_helpers.c

262

char *p = *dst, *q = *src;

lib/string_helpers.c

280

*dst += 1;

lib/string_helpers.c

324

int string_unescape(char *src, char *dst, size_t size, unsigned int flags)

lib/string_helpers.c

326

char *out = dst;

lib/string_helpers.c

358

return out - dst;

lib/string_helpers.c

362

static bool escape_passthrough(unsigned char c, char **dst, char *end)

lib/string_helpers.c

364

char *out = *dst;

lib/string_helpers.c

368

*dst = out + 1;

lib/string_helpers.c

372

static bool escape_space(unsigned char c, char **dst, char *end)

lib/string_helpers.c

374

char *out = *dst;

lib/string_helpers.c

404

*dst = out;

lib/string_helpers.c

408

static bool escape_special(unsigned char c, char **dst, char *end)

lib/string_helpers.c

410

char *out = *dst;

lib/string_helpers.c

437

*dst = out;

lib/string_helpers.c

441

static bool escape_null(unsigned char c, char **dst, char *end)

lib/string_helpers.c

443

char *out = *dst;

lib/string_helpers.c

455

*dst = out;

lib/string_helpers.c

459

static bool escape_octal(unsigned char c, char **dst, char *end)

lib/string_helpers.c

461

char *out = *dst;

lib/string_helpers.c

476

*dst = out;

lib/string_helpers.c

480

static bool escape_hex(unsigned char c, char **dst, char *end)

lib/string_helpers.c

482

char *out = *dst;

lib/string_helpers.c

497

*dst = out;

lib/string_helpers.c

578

int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,

lib/string_helpers.c

581

char *p = dst;

lib/string_helpers.c

644

return p - dst;

lib/string_helpers.c

655

char *dst;

lib/string_helpers.c

664

dst = kmalloc(dlen + 1, gfp);

lib/string_helpers.c

665

if (!dst)

lib/string_helpers.c

668

WARN_ON(string_escape_mem(src, slen, dst, dlen, flags, esc) != dlen);

lib/string_helpers.c

669

dst[dlen] = '\0';

lib/string_helpers.c

671

return dst;

lib/string_helpers.c

741

char *dst;

lib/string_helpers.c

743

dst = kstrdup(src, gfp);

lib/string_helpers.c

744

if (!dst)

lib/string_helpers.c

747

return strreplace(dst, old, new);

lib/strncpy_from_user.c

113

long strncpy_from_user(char *dst, const char __user *src, long count)

lib/strncpy_from_user.c

123

kasan_check_write(dst, count);

lib/strncpy_from_user.c

124

check_object_size(dst, count, false);

lib/strncpy_from_user.c

130

retval = do_strncpy_from_user(dst, src, count, count);

lib/strncpy_from_user.c

149

retval = do_strncpy_from_user(dst, src, count, max);

lib/strncpy_from_user.c

16

#define IS_UNALIGNED(src, dst) 0

lib/strncpy_from_user.c

18

#define IS_UNALIGNED(src, dst) \

lib/strncpy_from_user.c

19

(((long) dst | (long) src) & (sizeof(long) - 1))

lib/strncpy_from_user.c

28

static __always_inline long do_strncpy_from_user(char *dst, const char __user *src,

lib/strncpy_from_user.c

34

if (IS_UNALIGNED(src, dst))

lib/strncpy_from_user.c

58

*(unsigned long *)(dst+res) = c & mask;

lib/strncpy_from_user.c

62

*(unsigned long *)(dst+res) = c;

lib/strncpy_from_user.c

73

dst[res] = c;

lib/test_bpf.c

1001

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

1010

if (__bpf_alu_result(&res, (u32)dst, (u32)src, op)) {

lib/test_bpf.c

1011

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

11934

#define BPF_TEST_CLOBBER_ALU(alu, op, dst, src) \

lib/test_bpf.c

11936

#alu "_" #op " to " #dst ": no clobbering", \

lib/test_bpf.c

11948

BPF_##alu(BPF_ ##op, dst, src), \

lib/test_bpf.c

11949

BPF_ALU32_IMM(BPF_MOV, dst, dst), \

lib/test_bpf.c

1242

u64 dst, res;

lib/test_bpf.c

1253

dst = 0x76543210U;

lib/test_bpf.c

1255

dst = 0x7edcba9876543210ULL;

lib/test_bpf.c

1261

__bpf_alu_result(&res, dst, imm, op);

lib/test_bpf.c

1268

i += __bpf_ld_imm64(&insns[i], rd, dst);

lib/test_bpf.c

1424

u64 dst, src, res, same;

lib/test_bpf.c

1435

dst = 0x76543210U;

lib/test_bpf.c

1438

dst = 0x7edcba9876543210ULL;

lib/test_bpf.c

1445

__bpf_alu_result(&res, dst, src, op);

lib/test_bpf.c

1458

i += __bpf_ld_imm64(&insns[i], rd, dst);

lib/test_bpf.c

1615

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

1629

__bpf_alu_result(&res, dst, src, BPF_OP(op));

lib/test_bpf.c

1634

fetch = dst;

lib/test_bpf.c

1639

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

1662

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

1676

__bpf_alu_result(&res, (u32)dst, (u32)src, BPF_OP(op));

lib/test_bpf.c

1681

fetch = (u32)dst;

lib/test_bpf.c

1686

i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);

lib/test_bpf.c

1709

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

1716

i += __bpf_ld_imm64(&insns[i], R0, ~dst);

lib/test_bpf.c

1717

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

1749

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

1756

i += __bpf_ld_imm64(&insns[i], R0, ~dst);

lib/test_bpf.c

1757

i += __bpf_ld_imm64(&insns[i], R1, (u32)dst);

lib/test_bpf.c

1775

i += __bpf_ld_imm64(&insns[i], R0, dst);

lib/test_bpf.c

2323

struct bpf_insn *insns, s64 dst, s64 imm)

lib/test_bpf.c

2328

bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);

lib/test_bpf.c

2333

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

2346

struct bpf_insn *insns, s64 dst, s64 imm)

lib/test_bpf.c

2351

bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);

lib/test_bpf.c

2354

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

2367

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

2372

bool match = __bpf_match_jmp_cond(dst, src, op);

lib/test_bpf.c

2375

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

2389

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

2394

bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);

lib/test_bpf.c

2397

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

877

s64 dst, src;

lib/test_bpf.c

879

dst = value(di, db, sgn[k][0]);

lib/test_bpf.c

883

dst, src);

lib/test_bpf.c

895

s64 dst, src;

lib/test_bpf.c

897

dst = value(bt % dbits, db, sgn[k][0]);

lib/test_bpf.c

900

dst, src);

lib/test_bpf.c

937

struct bpf_insn *insns, s64 dst, s64 imm)

lib/test_bpf.c

946

if (__bpf_alu_result(&res, dst, (s32)imm, op)) {

lib/test_bpf.c

947

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

958

struct bpf_insn *insns, s64 dst, s64 imm)

lib/test_bpf.c

967

if (__bpf_alu_result(&res, (u32)dst, (u32)imm, op)) {

lib/test_bpf.c

968

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_bpf.c

979

struct bpf_insn *insns, s64 dst, s64 src)

lib/test_bpf.c

988

if (__bpf_alu_result(&res, dst, src, op)) {

lib/test_bpf.c

989

i += __bpf_ld_imm64(&insns[i], R1, dst);

lib/test_firmware.c

214

static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp)

lib/test_firmware.c

216

*dst = kstrndup(name, count, gfp);

lib/test_firmware.c

217

if (!*dst)

lib/test_firmware.c

352

static ssize_t config_test_show_str(char *dst,

lib/test_firmware.c

358

len = snprintf(dst, PAGE_SIZE, "%s\n", src);

lib/test_hmm.c

1005

dst[i] = migrate_pfn(page_to_pfn(dpage));

lib/test_hmm.c

1020

dst += 1 << order;

lib/test_hmm.c

1078

args.dst = dst_pfns;

lib/test_hmm.c

1152

args.dst = dst_pfns;

lib/test_hmm.c

1657

args.dst = kcalloc(nr, sizeof(unsigned long), GFP_KERNEL);

lib/test_hmm.c

1662

if (!args.src || !args.dst) {

lib/test_hmm.c

1685

kfree(args.dst);

lib/test_hmm.c

681

unsigned long *dst = args->dst;

lib/test_hmm.c

732

*dst = migrate_pfn(page_to_pfn(dpage)) | write;

lib/test_hmm.c

740

dst++;

lib/test_hmm.c

759

*dst = migrate_pfn(page_to_pfn(dpage)) | write;

lib/test_hmm.c

764

*dst |= MIGRATE_PFN_COMPOUND;

lib/test_hmm.c

778

dst++;

lib/test_hmm.c

792

dst++;

lib/test_hmm.c

838

const unsigned long *dst = args->dst;

lib/test_hmm.c

846

for (pfn = start_pfn; pfn < end_pfn; pfn++, src++, dst++) {

lib/test_hmm.c

855

dpage = migrate_pfn_to_page(*dst);

lib/test_hmm.c

859

if (*dst & MIGRATE_PFN_COMPOUND)

lib/test_hmm.c

871

if (*dst & MIGRATE_PFN_WRITE)

lib/test_hmm.c

946

unsigned long *dst = args->dst;

lib/test_hmm.c

971

*dst = MIGRATE_PFN_COMPOUND;

lib/test_hmm.c

973

*dst |= MIGRATE_PFN_WRITE;

lib/test_hmm.c

977

*dst &= ~MIGRATE_PFN_COMPOUND;

lib/test_hmm.c

994

*dst |= migrate_pfn(page_to_pfn(dpage));

lib/test_kmod.c

608

static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp)

lib/test_kmod.c

610

*dst = kstrndup(name, count, gfp);

lib/test_kmod.c

611

if (!*dst)

lib/test_kmod.c

679

char *dst,

lib/test_kmod.c

685

len = snprintf(dst, PAGE_SIZE, "%s\n", src);

lib/test_ubsan.c

106

volatile char *dst, *src;

lib/test_ubsan.c

112

dst = (char *)&val;

lib/test_ubsan.c

114

*dst = *src;

lib/test_ubsan.c

120

dst = (char *)&eval;

lib/test_ubsan.c

122

*dst = *src;

lib/tests/base64_kunit.c

12

static u64 bench_encode_ns(const u8 *data, int len, char *dst, int reps,

lib/tests/base64_kunit.c

19

base64_encode(data, len, dst, true, variant);

lib/tests/base64_kunit.c

25

static u64 bench_decode_ns(const char *data, int len, u8 *dst, int reps,

lib/tests/base64_kunit.c

32

base64_decode(data, len, dst, true, variant);

lib/tests/string_helpers_kunit.c

482

static void __strchrcut(char *dst, const char *src, const char *cut)

lib/tests/string_helpers_kunit.c

489

memcpy(dst, from, len);

lib/tests/string_helpers_kunit.c

490

dst += len;

lib/tests/string_helpers_kunit.c

493

*dst = '\0';

lib/tests/string_helpers_kunit.c

568

char *dst;

lib/tests/string_helpers_kunit.c

575

dst = kmalloc(len, GFP_KERNEL);

lib/tests/string_helpers_kunit.c

576

KUNIT_ASSERT_NOT_NULL(test, dst);

lib/tests/string_helpers_kunit.c

578

string_upper(dst, s);

lib/tests/string_helpers_kunit.c

579

KUNIT_EXPECT_STREQ(test, dst, strings_upper[i].out);

lib/tests/string_helpers_kunit.c

580

kfree(dst);

lib/tests/string_helpers_kunit.c

587

dst = kmalloc(len, GFP_KERNEL);

lib/tests/string_helpers_kunit.c

588

KUNIT_ASSERT_NOT_NULL(test, dst);

lib/tests/string_helpers_kunit.c

590

string_lower(dst, s);

lib/tests/string_helpers_kunit.c

591

KUNIT_EXPECT_STREQ(test, dst, strings_lower[i].out);

lib/tests/string_helpers_kunit.c

592

kfree(dst);

lib/textsearch.c

204

static unsigned int get_linear_data(unsigned int consumed, const u8 **dst,

lib/textsearch.c

211

*dst = st->data + consumed;

lib/ucs2_string.c

52

ssize_t ucs2_strscpy(ucs2_char_t *dst, const ucs2_char_t *src, size_t count)

lib/ucs2_string.c

60

if (count == 0 || WARN_ON_ONCE(count > INT_MAX / sizeof(*dst)))

lib/ucs2_string.c

71

dst[res] = c;

lib/ucs2_string.c

82

dst[count - 1] = 0;

lib/vdso/getrandom.c

23

#define MEMCPY_AND_ZERO_SRC(type, dst, src, len) do { \

lib/vdso/getrandom.c

25

__put_unaligned_t(type, __get_unaligned_t(type, src), dst); \

lib/vdso/getrandom.c

27

dst += sizeof(type); \

lib/vdso/getrandom.c

33

static void memcpy_and_zero_src(void *dst, void *src, size_t len)

lib/vdso/getrandom.c

37

MEMCPY_AND_ZERO_SRC(u64, dst, src, len);

lib/vdso/getrandom.c

38

MEMCPY_AND_ZERO_SRC(u32, dst, src, len);

lib/vdso/getrandom.c

39

MEMCPY_AND_ZERO_SRC(u16, dst, src, len);

lib/vdso/getrandom.c

41

MEMCPY_AND_ZERO_SRC(u8, dst, src, len);

lib/xarray.c

2270

static unsigned int xas_extract_present(struct xa_state *xas, void **dst,

lib/xarray.c

2280

dst[i++] = entry;

lib/xarray.c

2289

static unsigned int xas_extract_marked(struct xa_state *xas, void **dst,

lib/xarray.c

2299

dst[i++] = entry;

lib/xarray.c

2336

unsigned int xa_extract(struct xarray *xa, void **dst, unsigned long start,

lib/xarray.c

2345

return xas_extract_marked(&xas, dst, max, n, filter);

lib/xarray.c

2346

return xas_extract_present(&xas, dst, max, n);

lib/zstd/common/fse.h

131

FSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);

lib/zstd/common/fse.h

275

size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2);

lib/zstd/common/fse_decompress.c

175

void* dst, size_t maxDstSize,

lib/zstd/common/fse_decompress.c

179

BYTE* const ostart = (BYTE*) dst;

lib/zstd/common/fse_decompress.c

245

void* dst, size_t dstCapacity,

lib/zstd/common/fse_decompress.c

287

if (fastMode) return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 1);

lib/zstd/common/fse_decompress.c

288

return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 0);

lib/zstd/common/fse_decompress.c

293

static size_t FSE_decompress_wksp_body_default(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)

lib/zstd/common/fse_decompress.c

295

return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 0);

lib/zstd/common/fse_decompress.c

299

BMI2_TARGET_ATTRIBUTE static size_t FSE_decompress_wksp_body_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)

lib/zstd/common/fse_decompress.c

301

return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 1);

lib/zstd/common/fse_decompress.c

305

size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2)

lib/zstd/common/fse_decompress.c

309

return FSE_decompress_wksp_body_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);

lib/zstd/common/fse_decompress.c

313

return FSE_decompress_wksp_body_default(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);

lib/zstd/common/huf.h

135

size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog, void* workspace, size_t workspaceSize);

lib/zstd/common/huf.h

136

size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);

lib/zstd/common/huf.h

152

size_t HUF_compress4X_repeat(void* dst, size_t dstSize,

lib/zstd/common/huf.h

244

size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);

lib/zstd/common/huf.h

251

size_t HUF_compress1X_repeat(void* dst, size_t dstSize,

lib/zstd/common/huf.h

257

size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);

lib/zstd/common/huf.h

259

size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags); /*< double-symbols decoder */

lib/zstd/common/huf.h

265

size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);

lib/zstd/common/huf.h

267

size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);

lib/zstd/common/huf.h

269

size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);

lib/zstd/common/huf.h

270

size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);

lib/zstd/common/zstd_internal.h

164

static void ZSTD_copy8(void* dst, const void* src) {

lib/zstd/common/zstd_internal.h

166

vst1_u8((uint8_t*)dst, vld1_u8((const uint8_t*)src));

lib/zstd/common/zstd_internal.h

168

ZSTD_memcpy(dst, src, 8);

lib/zstd/common/zstd_internal.h

177

static void ZSTD_copy16(void* dst, const void* src) {

lib/zstd/common/zstd_internal.h

179

vst1q_u8((uint8_t*)dst, vld1q_u8((const uint8_t*)src));

lib/zstd/common/zstd_internal.h

181

_mm_storeu_si128((__m128i*)dst, _mm_loadu_si128((const __m128i*)src));

lib/zstd/common/zstd_internal.h

183

ZSTD_memmove(dst, src, 16);

lib/zstd/common/zstd_internal.h

188

ZSTD_memcpy(dst, copy16_buf, 16);

lib/zstd/common/zstd_internal.h

210

void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e const ovtype)

lib/zstd/common/zstd_internal.h

212

ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;

lib/zstd/common/zstd_internal.h

214

BYTE* op = (BYTE*)dst;

lib/zstd/common/zstd_internal.h

242

MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/common/zstd_internal.h

246

ZSTD_memcpy(dst, src, length);

lib/zstd/compress/fse_compress.c

552

static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,

lib/zstd/compress/fse_compress.c

565

{ size_t const initError = BIT_initCStream(&bitC, dst, dstSize);

lib/zstd/compress/fse_compress.c

611

size_t FSE_compress_usingCTable (void* dst, size_t dstSize,

lib/zstd/compress/fse_compress.c

618

return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);

lib/zstd/compress/fse_compress.c

620

return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);

lib/zstd/compress/huf_compress.c

1054

HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1061

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/huf_compress.c

1121

HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1125

return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);

lib/zstd/compress/huf_compress.c

1129

HUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1133

return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);

lib/zstd/compress/huf_compress.c

1137

HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1142

return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);

lib/zstd/compress/huf_compress.c

1144

return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);

lib/zstd/compress/huf_compress.c

1150

HUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1155

return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);

lib/zstd/compress/huf_compress.c

1160

size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)

lib/zstd/compress/huf_compress.c

1162

return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);

lib/zstd/compress/huf_compress.c

1166

HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1173

BYTE* const ostart = (BYTE*) dst;

lib/zstd/compress/huf_compress.c

1215

size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)

lib/zstd/compress/huf_compress.c

1217

return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);

lib/zstd/compress/huf_compress.c

1287

{ BYTE* dst = (BYTE*)workSpace + sizeof(HUF_WriteCTableWksp);

lib/zstd/compress/huf_compress.c

1306

hSize = HUF_writeCTable_wksp(dst, dstSize, table, maxSymbolValue, (U32)maxBits, workSpace, wkspSize);

lib/zstd/compress/huf_compress.c

1331

HUF_compress_internal (void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1339

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/huf_compress.c

1434

size_t HUF_compress1X_repeat (void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1441

return HUF_compress_internal(dst, dstSize, src, srcSize,

lib/zstd/compress/huf_compress.c

145

HUF_compressWeights(void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1451

size_t HUF_compress4X_repeat (void* dst, size_t dstSize,

lib/zstd/compress/huf_compress.c

1458

return HUF_compress_internal(dst, dstSize, src, srcSize,

lib/zstd/compress/huf_compress.c

149

BYTE* const ostart = (BYTE*) dst;

lib/zstd/compress/huf_compress.c

246

size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,

lib/zstd/compress/huf_compress.c

251

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

2312

static void ZSTD_copyCDictTableIntoCCtx(U32* dst, U32 const* src, size_t tableSize,

lib/zstd/compress/zstd_compress.c

2321

dst[i] = index;

lib/zstd/compress/zstd_compress.c

2324

ZSTD_memcpy(dst, src, tableSize * sizeof(U32));

lib/zstd/compress/zstd_compress.c

2680

BYTE* dst, const BYTE* const dstEnd,

lib/zstd/compress/zstd_compress.c

2684

BYTE* const ostart = dst;

lib/zstd/compress/zstd_compress.c

2803

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

2822

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

2921

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

2932

dst, dstCapacity,

lib/zstd/compress/zstd_compress.c

2964

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

2970

dst, dstCapacity,

lib/zstd/compress/zstd_compress.c

3438

void* dst; /* Make C90 happy. */

lib/zstd/compress/zstd_compress.c

3451

dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);

lib/zstd/compress/zstd_compress.c

3452

RETURN_ERROR_IF(dst == NULL, memory_allocation, "NULL pointer!");

lib/zstd/compress/zstd_compress.c

3461

const size_t ret = ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

3462

ZSTD_customFree(dst, ZSTD_defaultCMem);

lib/zstd/compress/zstd_compress.c

4022

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4027

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4176

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4182

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4269

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4283

cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);

lib/zstd/compress/zstd_compress.c

4291

cSize = ZSTD_compressBlock_splitBlock_internal(zc, dst, dstCapacity, src, srcSize, lastBlock, nbSeq);

lib/zstd/compress/zstd_compress.c

4298

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4308

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4332

dst, dstCapacity,

lib/zstd/compress/zstd_compress.c

4365

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4379

return ZSTD_rleCompressBlock(dst, dstCapacity, *(BYTE const*)src, srcSize, lastBlock);

lib/zstd/compress/zstd_compress.c

4400

ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);

lib/zstd/compress/zstd_compress.c

4417

return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);

lib/zstd/compress/zstd_compress.c

4421

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4431

cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);

lib/zstd/compress/zstd_compress.c

4506

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4513

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4609

static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4613

BYTE* const op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4631

MEM_writeLE32(dst, ZSTD_MAGICNUMBER);

lib/zstd/compress/zstd_compress.c

4665

size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4667

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

4684

size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)

lib/zstd/compress/zstd_compress.c

4689

MEM_writeLE24(dst, cBlockHeader24);

lib/zstd/compress/zstd_compress.c

4707

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4720

fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,

lib/zstd/compress/zstd_compress.c

4725

dst = (char*)dst + fhSize;

lib/zstd/compress/zstd_compress.c

4748

ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :

lib/zstd/compress/zstd_compress.c

4749

ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);

lib/zstd/compress/zstd_compress.c

4768

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4772

return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);

lib/zstd/compress/zstd_compress.c

4777

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

4780

return ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

4797

size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/compress/zstd_compress.c

4803

return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);

lib/zstd/compress/zstd_compress.c

4807

size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/compress/zstd_compress.c

4809

return ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

5255

static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)

lib/zstd/compress/zstd_compress.c

5257

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

5265

size_t fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);

lib/zstd/compress/zstd_compress.c

5301

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5306

dst, dstCapacity, src, srcSize,

lib/zstd/compress/zstd_compress.c

5309

endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);

lib/zstd/compress/zstd_compress.c

5328

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5331

return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

5335

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5344

dst, dstCapacity,

lib/zstd/compress/zstd_compress.c

5353

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5362

return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

5366

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5377

return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);

lib/zstd/compress/zstd_compress.c

5381

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5387

return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);

lib/zstd/compress/zstd_compress.c

5390

size_t ZSTD_compress(void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5397

result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);

lib/zstd/compress/zstd_compress.c

5774

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5779

return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress.c

5786

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5790

return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);

lib/zstd/compress/zstd_compress.c

5799

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

5804

return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);

lib/zstd/compress/zstd_compress.c

5997

char* const ostart = (assert(output != NULL), (char*)output->dst);

lib/zstd/compress/zstd_compress.c

6021

if (output->dst == NULL) assert(output->size == 0);

lib/zstd/compress/zstd_compress.c

6339

void* dst, size_t dstCapacity, size_t* dstPos,

lib/zstd/compress/zstd_compress.c

6345

output.dst = dst;

lib/zstd/compress/zstd_compress.c

6360

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

6373

dst, dstCapacity, &oPos,

lib/zstd/compress/zstd_compress.c

6737

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

6746

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

6855

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

6859

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

6895

MEM_writeLE32((char*)dst + cSize, checksum);

lib/zstd/compress/zstd_compress.c

7270

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

7276

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress.c

7377

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress.c

7382

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress_internal.h

1570

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_internal.h

1581

size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);

lib/zstd/compress/zstd_compress_internal.h

1618

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_internal.h

1622

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_internal.h

1625

size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);

lib/zstd/compress/zstd_compress_internal.h

642

ZSTD_noCompressBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)

lib/zstd/compress/zstd_compress_internal.h

648

MEM_writeLE24(dst, cBlockHeader24);

lib/zstd/compress/zstd_compress_internal.h

649

ZSTD_memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);

lib/zstd/compress/zstd_compress_internal.h

654

ZSTD_rleCompressBlock(void* dst, size_t dstCapacity, BYTE src, size_t srcSize, U32 lastBlock)

lib/zstd/compress/zstd_compress_internal.h

656

BYTE* const op = (BYTE*)dst;

lib/zstd/compress/zstd_compress_literals.c

131

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_literals.c

142

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_literals.c

156

return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress_literals.c

160

return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress_literals.c

191

return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress_literals.c

201

return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);

lib/zstd/compress/zstd_compress_literals.c

40

size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/compress/zstd_compress_literals.c

42

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_literals.c

82

size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/compress/zstd_compress_literals.c

84

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_literals.h

18

size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize);

lib/zstd/compress/zstd_compress_literals.h

24

size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize);

lib/zstd/compress/zstd_compress_literals.h

31

size_t ZSTD_compressLiterals (void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

244

ZSTD_buildCTable(void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

252

BYTE* op = (BYTE*)dst;

lib/zstd/compress/zstd_compress_sequences.c

293

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

305

ERR_isError(BIT_initCStream(&blockStream, dst, dstCapacity)),

lib/zstd/compress/zstd_compress_sequences.c

387

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

393

return ZSTD_encodeSequences_body(dst, dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

405

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

411

return ZSTD_encodeSequences_body(dst, dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

421

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

430

return ZSTD_encodeSequences_bmi2(dst, dstCapacity,

lib/zstd/compress/zstd_compress_sequences.c

438

return ZSTD_encodeSequences_default(dst, dstCapacity,

lib/zstd/compress/zstd_compress_sequences.h

34

ZSTD_buildCTable(void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_sequences.h

43

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

169

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

173

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_superblock.c

270

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

276

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_superblock.c

46

void* dst, size_t dstSize,

lib/zstd/compress/zstd_compress_superblock.c

485

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

500

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_superblock.c

51

BYTE* const ostart = (BYTE*)dst;

lib/zstd/compress/zstd_compress_superblock.c

63

return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);

lib/zstd/compress/zstd_compress_superblock.c

66

return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);

lib/zstd/compress/zstd_compress_superblock.c

667

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

685

dst, dstCapacity,

lib/zstd/compress/zstd_compress_superblock.c

91

return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);

lib/zstd/compress/zstd_compress_superblock.c

97

return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);

lib/zstd/compress/zstd_compress_superblock.h

29

void* dst, size_t dstCapacity,

lib/zstd/compress/zstd_cwksp.h

605

MEM_STATIC void ZSTD_cwksp_move(ZSTD_cwksp* dst, ZSTD_cwksp* src) {

lib/zstd/compress/zstd_cwksp.h

606

*dst = *src;

lib/zstd/decompress/huf_decompress.c

102

return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \

lib/zstd/decompress/huf_decompress.c

106

void* dst, size_t dstSize, \

lib/zstd/decompress/huf_decompress.c

110

return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \

lib/zstd/decompress/huf_decompress.c

113

static size_t fn(void* dst, size_t dstSize, void const* cSrc, \

lib/zstd/decompress/huf_decompress.c

117

return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable); \

lib/zstd/decompress/huf_decompress.c

119

return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable); \

lib/zstd/decompress/huf_decompress.c

125

static size_t fn(void* dst, size_t dstSize, void const* cSrc, \

lib/zstd/decompress/huf_decompress.c

129

return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable); \

lib/zstd/decompress/huf_decompress.c

1351

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1361

{ BYTE* const ostart = (BYTE*) dst;

lib/zstd/decompress/huf_decompress.c

1382

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1390

BYTE* const ostart = (BYTE*) dst;

lib/zstd/decompress/huf_decompress.c

1502

size_t HUF_decompress4X2_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

1504

return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

1509

size_t HUF_decompress4X2_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

1511

return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

1665

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1671

BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);

lib/zstd/decompress/huf_decompress.c

1674

size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

1697

BYTE* segmentEnd = (BYTE*)dst;

lib/zstd/decompress/huf_decompress.c

1716

static size_t HUF_decompress4X2_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

1731

return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

1742

size_t const ret = HUF_decompress4X2_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);

lib/zstd/decompress/huf_decompress.c

1746

return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

1751

size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1763

return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, flags);

lib/zstd/decompress/huf_decompress.c

1766

static size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1778

return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);

lib/zstd/decompress/huf_decompress.c

1842

size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

1849

if (cSrcSize == dstSize) { ZSTD_memcpy(dst, cSrc, dstSize); return dstSize; } /* not compressed */

lib/zstd/decompress/huf_decompress.c

1850

if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; } /* RLE */

lib/zstd/decompress/huf_decompress.c

1856

return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,

lib/zstd/decompress/huf_decompress.c

1861

return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,

lib/zstd/decompress/huf_decompress.c

1864

return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,

lib/zstd/decompress/huf_decompress.c

1866

HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,

lib/zstd/decompress/huf_decompress.c

1873

size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)

lib/zstd/decompress/huf_decompress.c

1879

return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

188

static size_t HUF_DecompressFastArgs_init(HUF_DecompressFastArgs* args, void* dst, size_t dstSize, void const* src, size_t srcSize, const HUF_DTable* DTable)

lib/zstd/decompress/huf_decompress.c

1883

return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

1885

return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :

lib/zstd/decompress/huf_decompress.c

1886

HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

1891

size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)

lib/zstd/decompress/huf_decompress.c

1900

return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);

lib/zstd/decompress/huf_decompress.c

1904

size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)

lib/zstd/decompress/huf_decompress.c

1910

return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

1914

return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

1916

return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :

lib/zstd/decompress/huf_decompress.c

1917

HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);

lib/zstd/decompress/huf_decompress.c

1921

size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)

lib/zstd/decompress/huf_decompress.c

1931

return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);

lib/zstd/decompress/huf_decompress.c

1935

return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);

lib/zstd/decompress/huf_decompress.c

1937

return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags) :

lib/zstd/decompress/huf_decompress.c

1938

HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);

lib/zstd/decompress/huf_decompress.c

195

BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);

lib/zstd/decompress/huf_decompress.c

206

assert(dst != NULL);

lib/zstd/decompress/huf_decompress.c

244

args->op[0] = (BYTE*)dst;

lib/zstd/decompress/huf_decompress.c

573

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

577

BYTE* op = (BYTE*)dst;

lib/zstd/decompress/huf_decompress.c

600

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

609

BYTE* const ostart = (BYTE*) dst;

lib/zstd/decompress/huf_decompress.c

699

size_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

701

return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

706

size_t HUF_decompress4X1_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

708

return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

838

void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

845

BYTE* const oend = ZSTD_maybeNullPtrAdd((BYTE*)dst, dstSize);

lib/zstd/decompress/huf_decompress.c

847

{ size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

872

BYTE* segmentEnd = (BYTE*)dst;

lib/zstd/decompress/huf_decompress.c

88

typedef size_t (*HUF_DecompressUsingDTableFn)(void *dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

894

static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,

lib/zstd/decompress/huf_decompress.c

909

return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

920

size_t const ret = HUF_decompress4X1_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);

lib/zstd/decompress/huf_decompress.c

924

return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);

lib/zstd/decompress/huf_decompress.c

927

static size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,

lib/zstd/decompress/huf_decompress.c

938

return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);

lib/zstd/decompress/huf_decompress.c

98

void* dst, size_t dstSize, \

lib/zstd/decompress/zstd_decompress.c

1027

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

1032

void* const dststart = dst;

lib/zstd/decompress/zstd_decompress.c

1068

ZSTD_checkContinuity(dctx, dst, dstCapacity);

lib/zstd/decompress/zstd_decompress.c

1070

{ const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,

lib/zstd/decompress/zstd_decompress.c

1086

dst = (BYTE*)dst + res;

lib/zstd/decompress/zstd_decompress.c

1094

return (size_t)((BYTE*)dst - (BYTE*)dststart);

lib/zstd/decompress/zstd_decompress.c

1098

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

1102

return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);

lib/zstd/decompress/zstd_decompress.c

1123

size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/decompress/zstd_decompress.c

1125

return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));

lib/zstd/decompress/zstd_decompress.c

1129

size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/decompress/zstd_decompress.c

1135

regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);

lib/zstd/decompress/zstd_decompress.c

1141

return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);

lib/zstd/decompress/zstd_decompress.c

1201

size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)

lib/zstd/decompress/zstd_decompress.c

1206

ZSTD_checkContinuity(dctx, dst, dstCapacity);

lib/zstd/decompress/zstd_decompress.c

1274

rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, is_streaming);

lib/zstd/decompress/zstd_decompress.c

1279

rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);

lib/zstd/decompress/zstd_decompress.c

1285

rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);

lib/zstd/decompress/zstd_decompress.c

1296

if (dctx->validateChecksum) xxh64_update(&dctx->xxhState, dst, rSize);

lib/zstd/decompress/zstd_decompress.c

1297

dctx->previousDstEnd = (char*)dst + rSize;

lib/zstd/decompress/zstd_decompress.c

1580

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

1585

return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,

lib/zstd/decompress/zstd_decompress.c

1970

if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)

lib/zstd/decompress/zstd_decompress.c

2015

char* const dst = (char*)output->dst;

lib/zstd/decompress/zstd_decompress.c

2016

char* const ostart = output->pos != 0 ? dst + output->pos : dst;

lib/zstd/decompress/zstd_decompress.c

2017

char* const oend = output->size != 0 ? dst + output->size : dst;

lib/zstd/decompress/zstd_decompress.c

2244

output->pos = (size_t)(op - (char*)(output->dst));

lib/zstd/decompress/zstd_decompress.c

2287

void* dst, size_t dstCapacity, size_t* dstPos,

lib/zstd/decompress/zstd_decompress.c

2292

output.dst = dst;

lib/zstd/decompress/zstd_decompress.c

592

size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

608

if (skippableContentSize > 0 && dst != NULL)

lib/zstd/decompress/zstd_decompress.c

609

ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize);

lib/zstd/decompress/zstd_decompress.c

870

static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

875

if (dst == NULL) {

lib/zstd/decompress/zstd_decompress.c

879

ZSTD_memmove(dst, src, srcSize);

lib/zstd/decompress/zstd_decompress.c

883

static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

888

if (dst == NULL) {

lib/zstd/decompress/zstd_decompress.c

892

ZSTD_memset(dst, b, regenSize);

lib/zstd/decompress/zstd_decompress.c

910

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress.c

915

BYTE* const ostart = (BYTE*)dst;

lib/zstd/decompress/zstd_decompress_block.c

115

dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize + ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;

lib/zstd/decompress/zstd_decompress_block.c

119

dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize;

lib/zstd/decompress/zstd_decompress_block.c

120

dctx->litBufferEnd = (BYTE*)dst + expectedWriteSize;

lib/zstd/decompress/zstd_decompress_block.c

123

assert(dctx->litBufferEnd <= (BYTE*)dst + expectedWriteSize);

lib/zstd/decompress/zstd_decompress_block.c

137

void* dst, size_t dstCapacity, const streaming_operation streaming)

lib/zstd/decompress/zstd_decompress_block.c

1405

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1411

BYTE* const ostart = (BYTE*)dst;

lib/zstd/decompress/zstd_decompress_block.c

1432

assert(dst != NULL);

lib/zstd/decompress/zstd_decompress_block.c

1617

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1623

BYTE* const ostart = (BYTE*)dst;

lib/zstd/decompress/zstd_decompress_block.c

1644

assert(dst != NULL);

lib/zstd/decompress/zstd_decompress_block.c

1695

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1699

return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1704

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1708

return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1736

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1742

BYTE* const ostart = (BYTE*)dst;

lib/zstd/decompress/zstd_decompress_block.c

1764

assert(dst != NULL);

lib/zstd/decompress/zstd_decompress_block.c

186

RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");

lib/zstd/decompress/zstd_decompress_block.c

1893

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1897

return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1909

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1913

return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1918

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1922

return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1929

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1933

return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

194

ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 0);

lib/zstd/decompress/zstd_decompress_block.c

1941

ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1948

return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1951

return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1954

ZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1961

return ZSTD_decompressSequencesSplitLitBuffer_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1964

return ZSTD_decompressSequencesSplitLitBuffer_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1977

void* dst, size_t maxDstSize,

lib/zstd/decompress/zstd_decompress_block.c

1984

return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

1987

return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

2068

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress_block.c

2085

{ size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, streaming);

lib/zstd/decompress/zstd_decompress_block.c

2098

size_t const totalHistorySize = ZSTD_totalHistorySize(ZSTD_maybeNullPtrAdd((BYTE*)dst, blockSizeMax), (BYTE const*)dctx->virtualStart);

lib/zstd/decompress/zstd_decompress_block.c

2130

RETURN_ERROR_IF((dst == NULL || dstCapacity == 0) && nbSeq > 0, dstSize_tooSmall, "NULL not handled");

lib/zstd/decompress/zstd_decompress_block.c

2131

RETURN_ERROR_IF(MEM_64bits() && sizeof(size_t) == sizeof(void*) && (size_t)(-1) - (size_t)dst < (size_t)(1 << 20), dstSize_tooSmall,

lib/zstd/decompress/zstd_decompress_block.c

2163

return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

2170

return ZSTD_decompressSequencesSplitLitBuffer(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

2172

return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);

lib/zstd/decompress/zstd_decompress_block.c

2179

void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)

lib/zstd/decompress/zstd_decompress_block.c

2181

if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */

lib/zstd/decompress/zstd_decompress_block.c

2183

dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));

lib/zstd/decompress/zstd_decompress_block.c

2184

dctx->prefixStart = dst;

lib/zstd/decompress/zstd_decompress_block.c

2185

dctx->previousDstEnd = dst;

lib/zstd/decompress/zstd_decompress_block.c

2191

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress_block.c

2196

ZSTD_checkContinuity(dctx, dst, dstCapacity);

lib/zstd/decompress/zstd_decompress_block.c

2197

dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, not_streaming);

lib/zstd/decompress/zstd_decompress_block.c

2199

dctx->previousDstEnd = (char*)dst + dSize;

lib/zstd/decompress/zstd_decompress_block.c

2206

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress_block.c

2209

return ZSTD_decompressBlock_deprecated(dctx, dst, dstCapacity, src, srcSize);

lib/zstd/decompress/zstd_decompress_block.c

239

assert(dctx->litBufferEnd <= (BYTE*)dst + blockSizeMax);

lib/zstd/decompress/zstd_decompress_block.c

272

RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");

lib/zstd/decompress/zstd_decompress_block.c

275

ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);

lib/zstd/decompress/zstd_decompress_block.c

320

RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");

lib/zstd/decompress/zstd_decompress_block.c

323

ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);

lib/zstd/decompress/zstd_decompress_block.c

346

void* dst, size_t dstCapacity);

lib/zstd/decompress/zstd_decompress_block.c

349

void* dst, size_t dstCapacity)

lib/zstd/decompress/zstd_decompress_block.c

352

return ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, not_streaming);

lib/zstd/decompress/zstd_decompress_block.c

48

static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }

lib/zstd/decompress/zstd_decompress_block.c

81

static void ZSTD_allocateLiteralsBuffer(ZSTD_DCtx* dctx, void* const dst, const size_t dstCapacity, const size_t litSize,

lib/zstd/decompress/zstd_decompress_block.c

94

dctx->litBuffer = (BYTE*)dst + blockSizeMax + WILDCOPY_OVERLENGTH;

lib/zstd/decompress/zstd_decompress_block.h

50

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress_block.h

70

void* dst, size_t dstCapacity,

lib/zstd/decompress/zstd_decompress_internal.h

230

void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize);

lib/zstd/zstd_compress_module.c

189

size_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,

lib/zstd/zstd_compress_module.c

193

return ZSTD_compress2(cctx, dst, dst_capacity, src, src_size);

lib/zstd/zstd_compress_module.c

197

size_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,

lib/zstd/zstd_compress_module.c

201

return ZSTD_compress_usingCDict(cctx, dst, dst_capacity,

lib/zstd/zstd_compress_module.c

274

size_t zstd_compress_sequences_and_literals(zstd_cctx *cctx, void* dst, size_t dst_capacity,

lib/zstd/zstd_compress_module.c

279

return ZSTD_compressSequencesAndLiterals(cctx, dst, dst_capacity, in_seqs,

lib/zstd/zstd_decompress_module.c

82

size_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,

lib/zstd/zstd_decompress_module.c

85

return ZSTD_decompressDCtx(dctx, dst, dst_capacity, src, src_size);

lib/zstd/zstd_decompress_module.c

90

void *dst, size_t dst_capacity, const void* src, size_t src_size,

lib/zstd/zstd_decompress_module.c

93

return ZSTD_decompress_usingDDict(dctx, dst, dst_capacity, src,

mm/compaction.c

1800

struct folio *dst;

mm/compaction.c

1834

dst = (struct folio *)freepage;

mm/compaction.c

1836

post_alloc_hook(&dst->page, order, __GFP_MOVABLE);

mm/compaction.c

1837

set_page_refcounted(&dst->page);

mm/compaction.c

1839

prep_compound_page(&dst->page, order);

mm/compaction.c

1842

return page_rmappable_folio(&dst->page);

mm/compaction.c

1855

static void compaction_free(struct folio *dst, unsigned long data)

mm/compaction.c

1858

int order = folio_order(dst);

mm/compaction.c

1859

struct page *page = &dst->page;

mm/compaction.c

1861

if (folio_put_testzero(dst)) {

mm/compaction.c

1863

list_add(&dst->lru, &cc->freepages[order]);

mm/damon/core.c

1005

static int damos_commit_dests(struct damos_migrate_dests *dst,

mm/damon/core.c

1008

if (dst->nr_dests != src->nr_dests) {

mm/damon/core.c

1009

kfree(dst->node_id_arr);

mm/damon/core.c

1010

kfree(dst->weight_arr);

mm/damon/core.c

1012

dst->node_id_arr = kmalloc_array(src->nr_dests,

mm/damon/core.c

1013

sizeof(*dst->node_id_arr), GFP_KERNEL);

mm/damon/core.c

1014

if (!dst->node_id_arr) {

mm/damon/core.c

1015

dst->weight_arr = NULL;

mm/damon/core.c

1019

dst->weight_arr = kmalloc_array(src->nr_dests,

mm/damon/core.c

1020

sizeof(*dst->weight_arr), GFP_KERNEL);

mm/damon/core.c

1021

if (!dst->weight_arr) {

mm/damon/core.c

1027

dst->nr_dests = src->nr_dests;

mm/damon/core.c

1029

dst->node_id_arr[i] = src->node_id_arr[i];

mm/damon/core.c

1030

dst->weight_arr[i] = src->weight_arr[i];

mm/damon/core.c

1036

static int damos_commit_filters(struct damos *dst, struct damos *src)

mm/damon/core.c

1040

err = damos_commit_core_filters(dst, src);

mm/damon/core.c

1043

err = damos_commit_ops_filters(dst, src);

mm/damon/core.c

1046

damos_set_filters_default_reject(dst);

mm/damon/core.c

1062

static int damos_commit(struct damos *dst, struct damos *src)

mm/damon/core.c

1066

dst->pattern = src->pattern;

mm/damon/core.c

1067

dst->action = src->action;

mm/damon/core.c

1068

dst->apply_interval_us = src->apply_interval_us;

mm/damon/core.c

1070

err = damos_commit_quota(&dst->quota, &src->quota);

mm/damon/core.c

1074

dst->wmarks = src->wmarks;

mm/damon/core.c

1075

dst->target_nid = src->target_nid;

mm/damon/core.c

1077

err = damos_commit_dests(&dst->migrate_dests, &src->migrate_dests);

mm/damon/core.c

1081

err = damos_commit_filters(dst, src);

mm/damon/core.c

1085

dst->max_nr_snapshots = src->max_nr_snapshots;

mm/damon/core.c

1089

static int damon_commit_schemes(struct damon_ctx *dst, struct damon_ctx *src)

mm/damon/core.c

1094

damon_for_each_scheme_safe(dst_scheme, next, dst) {

mm/damon/core.c

1120

damon_add_scheme(dst, new_scheme);

mm/damon/core.c

1144

static int damon_commit_target_regions(struct damon_target *dst,

mm/damon/core.c

1162

err = damon_set_regions(dst, ranges, i, src_min_region_sz);

mm/damon/core.c

1168

struct damon_target *dst, bool dst_has_pid,

mm/damon/core.c

1174

err = damon_commit_target_regions(dst, src, src_min_region_sz);

mm/damon/core.c

1178

put_pid(dst->pid);

mm/damon/core.c

1181

dst->pid = src->pid;

mm/damon/core.c

1186

struct damon_ctx *dst, struct damon_ctx *src)

mm/damon/core.c

1191

damon_for_each_target_safe(dst_target, next, dst) {

mm/damon/core.c

1199

dst_target, damon_target_has_pid(dst),

mm/damon/core.c

1207

damon_destroy_target(dst_target, dst);

mm/damon/core.c

1208

damon_for_each_scheme(s, dst) {

mm/damon/core.c

1233

damon_add_target(dst, new_target);

mm/damon/core.c

1251

int damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src)

mm/damon/core.c

1255

dst->maybe_corrupted = true;

mm/damon/core.c

1259

err = damon_commit_schemes(dst, src);

mm/damon/core.c

1262

err = damon_commit_targets(dst, src);

mm/damon/core.c

1272

if (!damon_attrs_equals(&dst->attrs, &src->attrs)) {

mm/damon/core.c

1273

err = damon_set_attrs(dst, &src->attrs);

mm/damon/core.c

1277

dst->ops = src->ops;

mm/damon/core.c

1278

dst->addr_unit = src->addr_unit;

mm/damon/core.c

1279

dst->min_region_sz = src->min_region_sz;

mm/damon/core.c

1281

dst->maybe_corrupted = false;

mm/damon/core.c

788

struct damos_quota_goal *dst, struct damos_quota_goal *src)

mm/damon/core.c

790

switch (dst->metric) {

mm/damon/core.c

793

dst->nid = src->nid;

mm/damon/core.c

797

dst->nid = src->nid;

mm/damon/core.c

798

dst->memcg_id = src->memcg_id;

mm/damon/core.c

806

struct damos_quota_goal *dst, struct damos_quota_goal *src)

mm/damon/core.c

808

dst->metric = src->metric;

mm/damon/core.c

809

dst->target_value = src->target_value;

mm/damon/core.c

810

if (dst->metric == DAMOS_QUOTA_USER_INPUT)

mm/damon/core.c

811

dst->current_value = src->current_value;

mm/damon/core.c

813

damos_commit_quota_goal_union(dst, src);

mm/damon/core.c

828

int damos_commit_quota_goals(struct damos_quota *dst, struct damos_quota *src)

mm/damon/core.c

833

damos_for_each_quota_goal_safe(dst_goal, next, dst) {

mm/damon/core.c

848

damos_add_quota_goal(dst, new_goal);

mm/damon/core.c

853

static int damos_commit_quota(struct damos_quota *dst, struct damos_quota *src)

mm/damon/core.c

857

dst->reset_interval = src->reset_interval;

mm/damon/core.c

858

dst->ms = src->ms;

mm/damon/core.c

859

dst->sz = src->sz;

mm/damon/core.c

860

err = damos_commit_quota_goals(dst, src);

mm/damon/core.c

863

dst->weight_sz = src->weight_sz;

mm/damon/core.c

864

dst->weight_nr_accesses = src->weight_nr_accesses;

mm/damon/core.c

865

dst->weight_age = src->weight_age;

mm/damon/core.c

894

struct damos_filter *dst, struct damos_filter *src)

mm/damon/core.c

896

switch (dst->type) {

mm/damon/core.c

898

dst->memcg_id = src->memcg_id;

mm/damon/core.c

901

dst->addr_range = src->addr_range;

mm/damon/core.c

904

dst->target_idx = src->target_idx;

mm/damon/core.c

907

dst->sz_range = src->sz_range;

mm/damon/core.c

915

struct damos_filter *dst, struct damos_filter *src)

mm/damon/core.c

917

dst->type = src->type;

mm/damon/core.c

918

dst->matching = src->matching;

mm/damon/core.c

919

dst->allow = src->allow;

mm/damon/core.c

920

damos_commit_filter_arg(dst, src);

mm/damon/core.c

923

static int damos_commit_core_filters(struct damos *dst, struct damos *src)

mm/damon/core.c

928

damos_for_each_core_filter_safe(dst_filter, next, dst) {

mm/damon/core.c

946

damos_add_filter(dst, new_filter);

mm/damon/core.c

951

static int damos_commit_ops_filters(struct damos *dst, struct damos *src)

mm/damon/core.c

956

damos_for_each_ops_filter_safe(dst_filter, next, dst) {

mm/damon/core.c

974

damos_add_filter(dst, new_filter);

mm/damon/tests/core-kunit.h

527

struct damos_quota_goal *dst,

mm/damon/tests/core-kunit.h

532

if (dst->metric == DAMOS_QUOTA_SOME_MEM_PSI_US)

mm/damon/tests/core-kunit.h

533

dst_last_psi_total = dst->last_psi_total;

mm/damon/tests/core-kunit.h

534

damos_commit_quota_goal(dst, src);

mm/damon/tests/core-kunit.h

536

KUNIT_EXPECT_EQ(test, dst->metric, src->metric);

mm/damon/tests/core-kunit.h

537

KUNIT_EXPECT_EQ(test, dst->target_value, src->target_value);

mm/damon/tests/core-kunit.h

539

KUNIT_EXPECT_EQ(test, dst->current_value, src->current_value);

mm/damon/tests/core-kunit.h

541

KUNIT_EXPECT_EQ(test, dst->last_psi_total, dst_last_psi_total);

mm/damon/tests/core-kunit.h

542

switch (dst->metric) {

mm/damon/tests/core-kunit.h

545

KUNIT_EXPECT_EQ(test, dst->nid, src->nid);

mm/damon/tests/core-kunit.h

549

KUNIT_EXPECT_EQ(test, dst->nid, src->nid);

mm/damon/tests/core-kunit.h

550

KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);

mm/damon/tests/core-kunit.h

559

struct damos_quota_goal dst = {

mm/damon/tests/core-kunit.h

566

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

571

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

578

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

585

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

593

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

601

damos_test_commit_quota_goal_for(test, &dst,

mm/damon/tests/core-kunit.h

614

struct damos_quota dst, src;

mm/damon/tests/core-kunit.h

619

INIT_LIST_HEAD(&dst.goals);

mm/damon/tests/core-kunit.h

632

damos_add_quota_goal(&dst, goal);

mm/damon/tests/core-kunit.h

638

damos_commit_quota_goals(&dst, &src);

mm/damon/tests/core-kunit.h

641

damos_for_each_quota_goal(goal, (&dst)) {

mm/damon/tests/core-kunit.h

649

damos_for_each_quota_goal_safe(goal, next, (&dst))

mm/damon/tests/core-kunit.h

692

struct damos_quota dst = {

mm/damon/tests/core-kunit.h

709

INIT_LIST_HEAD(&dst.goals);

mm/damon/tests/core-kunit.h

712

damos_commit_quota(&dst, &src);

mm/damon/tests/core-kunit.h

714

KUNIT_EXPECT_EQ(test, dst.reset_interval, src.reset_interval);

mm/damon/tests/core-kunit.h

715

KUNIT_EXPECT_EQ(test, dst.ms, src.ms);

mm/damon/tests/core-kunit.h

716

KUNIT_EXPECT_EQ(test, dst.sz, src.sz);

mm/damon/tests/core-kunit.h

717

KUNIT_EXPECT_EQ(test, dst.weight_sz, src.weight_sz);

mm/damon/tests/core-kunit.h

718

KUNIT_EXPECT_EQ(test, dst.weight_nr_accesses, src.weight_nr_accesses);

mm/damon/tests/core-kunit.h

719

KUNIT_EXPECT_EQ(test, dst.weight_age, src.weight_age);

mm/damon/tests/core-kunit.h

758

struct damos_migrate_dests dst = {}, src = {};

mm/damon/tests/core-kunit.h

762

err = damos_test_help_dests_setup(&dst, dst_node_id_arr,

mm/damon/tests/core-kunit.h

769

damos_test_help_dests_free(&dst);

mm/damon/tests/core-kunit.h

772

err = damos_commit_dests(&dst, &src);

mm/damon/tests/core-kunit.h

777

KUNIT_EXPECT_EQ(test, dst.nr_dests, src_nr_dests);

mm/damon/tests/core-kunit.h

778

for (i = 0; i < dst.nr_dests; i++) {

mm/damon/tests/core-kunit.h

779

KUNIT_EXPECT_EQ(test, dst.node_id_arr[i], src_node_id_arr[i]);

mm/damon/tests/core-kunit.h

780

KUNIT_EXPECT_EQ(test, dst.weight_arr[i], src_weight_arr[i]);

mm/damon/tests/core-kunit.h

784

damos_test_help_dests_free(&dst);

mm/damon/tests/core-kunit.h

817

struct damos_filter *dst, struct damos_filter *src)

mm/damon/tests/core-kunit.h

819

damos_commit_filter(dst, src);

mm/damon/tests/core-kunit.h

820

KUNIT_EXPECT_EQ(test, dst->type, src->type);

mm/damon/tests/core-kunit.h

821

KUNIT_EXPECT_EQ(test, dst->matching, src->matching);

mm/damon/tests/core-kunit.h

822

KUNIT_EXPECT_EQ(test, dst->allow, src->allow);

mm/damon/tests/core-kunit.h

825

KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);

mm/damon/tests/core-kunit.h

828

KUNIT_EXPECT_EQ(test, dst->addr_range.start,

mm/damon/tests/core-kunit.h

830

KUNIT_EXPECT_EQ(test, dst->addr_range.end,

mm/damon/tests/core-kunit.h

834

KUNIT_EXPECT_EQ(test, dst->target_idx, src->target_idx);

mm/damon/tests/core-kunit.h

837

KUNIT_EXPECT_EQ(test, dst->sz_range.min, src->sz_range.min);

mm/damon/tests/core-kunit.h

838

KUNIT_EXPECT_EQ(test, dst->sz_range.max, src->sz_range.max);

mm/damon/tests/core-kunit.h

847

struct damos_filter dst = {

mm/damon/tests/core-kunit.h

853

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

859

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

866

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

872

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

879

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

885

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

892

damos_test_commit_filter_for(test, &dst,

mm/damon/tests/core-kunit.h

908

static void damos_test_commit_for(struct kunit *test, struct damos *dst,

mm/damon/tests/core-kunit.h

913

damos_test_help_initailize_scheme(dst);

mm/damon/tests/core-kunit.h

916

err = damos_commit(dst, src);

mm/damon/tests/core-kunit.h

920

KUNIT_EXPECT_EQ(test, dst->pattern.min_sz_region,

mm/damon/tests/core-kunit.h

922

KUNIT_EXPECT_EQ(test, dst->pattern.max_sz_region,

mm/damon/tests/core-kunit.h

924

KUNIT_EXPECT_EQ(test, dst->pattern.min_nr_accesses,

mm/damon/tests/core-kunit.h

926

KUNIT_EXPECT_EQ(test, dst->pattern.max_nr_accesses,

mm/damon/tests/core-kunit.h

928

KUNIT_EXPECT_EQ(test, dst->pattern.min_age_region,

mm/damon/tests/core-kunit.h

930

KUNIT_EXPECT_EQ(test, dst->pattern.max_age_region,

mm/damon/tests/core-kunit.h

933

KUNIT_EXPECT_EQ(test, dst->action, src->action);

mm/damon/tests/core-kunit.h

934

KUNIT_EXPECT_EQ(test, dst->apply_interval_us, src->apply_interval_us);

mm/damon/tests/core-kunit.h

936

KUNIT_EXPECT_EQ(test, dst->wmarks.metric, src->wmarks.metric);

mm/damon/tests/core-kunit.h

937

KUNIT_EXPECT_EQ(test, dst->wmarks.interval, src->wmarks.interval);

mm/damon/tests/core-kunit.h

938

KUNIT_EXPECT_EQ(test, dst->wmarks.high, src->wmarks.high);

mm/damon/tests/core-kunit.h

939

KUNIT_EXPECT_EQ(test, dst->wmarks.mid, src->wmarks.mid);

mm/damon/tests/core-kunit.h

940

KUNIT_EXPECT_EQ(test, dst->wmarks.low, src->wmarks.low);

mm/damon/tests/core-kunit.h

945

KUNIT_EXPECT_EQ(test, dst->target_nid, src->target_nid);

mm/hugetlb.c

3969

static long demote_free_hugetlb_folios(struct hstate *src, struct hstate *dst,

mm/hugetlb.c

3988

mutex_lock(&dst->resize_lock);

mm/hugetlb.c

4001

split_page_owner(&folio->page, huge_page_order(src), huge_page_order(dst));

mm/hugetlb.c

4002

pgalloc_tag_split(folio, huge_page_order(src), huge_page_order(dst));

mm/hugetlb.c

4004

for (i = 0; i < pages_per_huge_page(src); i += pages_per_huge_page(dst)) {

mm/hugetlb.c

4010

prep_compound_page(page, dst->order);

mm/hugetlb.c

4021

prep_and_add_allocated_folios(dst, &dst_list);

mm/hugetlb.c

4023

mutex_unlock(&dst->resize_lock);

mm/hugetlb.c

4033

struct hstate *dst;

mm/hugetlb.c

4044

dst = size_to_hstate(PAGE_SIZE << src->demote_order);

mm/hugetlb.c

4063

rc = demote_free_hugetlb_folios(src, dst, &list);

mm/hugetlb.c

4083

dst->max_huge_pages += nr_demoted << (huge_page_order(src) - huge_page_order(dst));

mm/hugetlb.c

4885

int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,

mm/hugetlb.c

4926

dst_pte = huge_pte_alloc(dst, dst_vma, addr, sz);

mm/hugetlb.c

4940

dst_ptl = huge_pte_lock(h, dst, dst_pte);

mm/hugetlb.c

4954

set_huge_pte_at(dst, addr, dst_pte, entry, sz);

mm/hugetlb.c

4972

set_huge_pte_at(dst, addr, dst_pte, entry, sz);

mm/hugetlb.c

4977

set_huge_pte_at(dst, addr, dst_pte,

mm/hugetlb.c

5018

dst_ptl = huge_pte_lock(h, dst, dst_pte);

mm/hugetlb.c

5049

set_huge_pte_at(dst, addr, dst_pte, entry, sz);

mm/hugetlb.c

5050

hugetlb_count_add(npages, dst);

mm/internal.h

258

int anon_vma_clone(struct vm_area_struct *dst, struct vm_area_struct *src,

mm/kfence/kfence_test.c

391

char dst;

mm/kfence/kfence_test.c

398

ret = copy_from_kernel_nofault(&dst, addr, 1);

mm/khugepaged.c

1853

struct page *dst;

mm/khugepaged.c

2104

dst = folio_page(new_folio, 0);

mm/khugepaged.c

2109

clear_highpage(dst);

mm/khugepaged.c

2111

dst++;

mm/khugepaged.c

2115

if (copy_mc_highpage(dst, folio_page(folio, i)) > 0) {

mm/khugepaged.c

2120

dst++;

mm/khugepaged.c

2124

clear_highpage(dst);

mm/khugepaged.c

2126

dst++;

mm/kmsan/core.c

100

kmsan_internal_unpoison_memory(dst, n, /*checked*/ false);

mm/kmsan/core.c

105

origin_dst = kmsan_get_metadata(dst, KMSAN_META_ORIGIN);

mm/kmsan/core.c

109

backwards = dst > src;

mm/kmsan/core.c

113

dst_off = (u64)dst % KMSAN_ORIGIN_SIZE;

mm/kmsan/core.c

80

void kmsan_internal_memmove_metadata(void *dst, void *src, size_t n)

mm/kmsan/core.c

90

shadow_dst = kmsan_get_metadata(dst, KMSAN_META_SHADOW);

mm/kmsan/core.c

93

KMSAN_WARN_ON(!kmsan_metadata_is_contiguous(dst, n));

mm/kmsan/instrumentation.c

157

void *__msan_memmove(void *dst, const void *src, uintptr_t n);

mm/kmsan/instrumentation.c

158

void *__msan_memmove(void *dst, const void *src, uintptr_t n)

mm/kmsan/instrumentation.c

165

result = __memmove(dst, src, n);

mm/kmsan/instrumentation.c

173

kmsan_internal_memmove_metadata(dst, (void *)src, n);

mm/kmsan/instrumentation.c

182

void *__msan_memcpy(void *dst, const void *src, uintptr_t n);

mm/kmsan/instrumentation.c

183

void *__msan_memcpy(void *dst, const void *src, uintptr_t n)

mm/kmsan/instrumentation.c

190

result = __memcpy(dst, src, n);

mm/kmsan/instrumentation.c

200

kmsan_internal_memmove_metadata(dst, (void *)src, n);

mm/kmsan/instrumentation.c

209

void *__msan_memset(void *dst, int c, uintptr_t n);

mm/kmsan/instrumentation.c

210

void *__msan_memset(void *dst, int c, uintptr_t n)

mm/kmsan/instrumentation.c

217

result = __memset(dst, c, n);

mm/kmsan/instrumentation.c

226

kmsan_internal_unpoison_memory(dst, n, /*checked*/ false);

mm/kmsan/kmsan.h

154

void kmsan_internal_memmove_metadata(void *dst, void *src, size_t n);

mm/kmsan/kmsan_test.c

481

static noinline void *memcpy_noinline(volatile void *dst,

mm/kmsan/kmsan_test.c

484

return memcpy((void *)dst, (const void *)src, size);

mm/kmsan/kmsan_test.c

492

volatile long long dst = 0;

mm/kmsan/kmsan_test.c

498

memcpy_noinline((void *)&dst, (void *)&src, sizeof(src));

mm/kmsan/kmsan_test.c

499

kmsan_check_memory((void *)&dst, sizeof(dst));

mm/kmsan/kmsan_test.c

511

volatile int dst = 0;

mm/kmsan/kmsan_test.c

516

memcpy_noinline((void *)&dst, (void *)&uninit_src, sizeof(uninit_src));

mm/kmsan/kmsan_test.c

517

kmsan_check_memory((void *)&dst, sizeof(dst));

mm/kmsan/kmsan_test.c

533

volatile char dst[8] = { 0 };

mm/kmsan/kmsan_test.c

539

memcpy_noinline((void *)&dst[1], (void *)&uninit_src,

mm/kmsan/kmsan_test.c

541

kmsan_check_memory((void *)dst, 4);

mm/kmsan/kmsan_test.c

544

kmsan_check_memory((void *)&dst[4], sizeof(uninit_src));

mm/kmsan/kmsan_test.c

574

volatile char dst[8] = { 0 };

mm/kmsan/kmsan_test.c

588

memcpy_noinline((void *)&dst[0], (void *)&uninit_src[2], 8);

mm/kmsan/kmsan_test.c

590

kmsan_check_memory((void *)&dst[0], 4);

mm/kmsan/kmsan_test.c

593

kmsan_check_memory((void *)&dst[2], 4);

mm/kmsan/kmsan_test.c

596

kmsan_check_memory((void *)&dst[4], 4);

mm/kmsan/shadow.c

151

void kmsan_copy_page_meta(struct page *dst, struct page *src)

mm/kmsan/shadow.c

155

if (!dst || !page_has_metadata(dst))

mm/kmsan/shadow.c

158

kmsan_internal_unpoison_memory(page_address(dst), PAGE_SIZE,

mm/kmsan/shadow.c

164

__memcpy(shadow_ptr_for(dst), shadow_ptr_for(src), PAGE_SIZE);

mm/kmsan/shadow.c

165

__memcpy(origin_ptr_for(dst), origin_ptr_for(src), PAGE_SIZE);

mm/list_lru.c

448

struct list_lru_one *dst;

mm/list_lru.c

451

dst = list_lru_from_memcg_idx(lru, nid, dst_idx);

mm/list_lru.c

452

spin_lock_nested(&dst->lock, SINGLE_DEPTH_NESTING);

mm/list_lru.c

454

list_splice_init(&src->list, &dst->list);

mm/list_lru.c

457

dst->nr_items += src->nr_items;

mm/list_lru.c

463

spin_unlock(&dst->lock);

mm/maccess.c

100

} while (dst[-1] && src - unsafe_addr < count);

mm/maccess.c

103

dst[-1] = '\0';

mm/maccess.c

107

dst[0] = '\0';

mm/maccess.c

120

long copy_from_user_nofault(void *dst, const void __user *src, size_t size)

mm/maccess.c

131

ret = __copy_from_user_inatomic(dst, src, size);

mm/maccess.c

149

long copy_to_user_nofault(void __user *dst, const void *src, size_t size)

mm/maccess.c

153

if (access_ok(dst, size)) {

mm/maccess.c

155

ret = __copy_to_user_inatomic(dst, src, size);

mm/maccess.c

183

long strncpy_from_user_nofault(char *dst, const void __user *unsafe_addr,

mm/maccess.c

192

ret = strncpy_from_user(dst, unsafe_addr, count);

mm/maccess.c

197

dst[ret - 1] = '\0';

mm/maccess.c

20

#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \

mm/maccess.c

22

__get_kernel_nofault(dst, src, type, err_label); \

mm/maccess.c

24

dst += sizeof(type); \

mm/maccess.c

29

long copy_from_kernel_nofault(void *dst, const void *src, size_t size)

mm/maccess.c

34

align = (unsigned long)dst | (unsigned long)src;

mm/maccess.c

41

copy_from_kernel_nofault_loop(dst, src, size, u64, Efault);

mm/maccess.c

43

copy_from_kernel_nofault_loop(dst, src, size, u32, Efault);

mm/maccess.c

45

copy_from_kernel_nofault_loop(dst, src, size, u16, Efault);

mm/maccess.c

46

copy_from_kernel_nofault_loop(dst, src, size, u8, Efault);

mm/maccess.c

55

#define copy_to_kernel_nofault_loop(dst, src, len, type, err_label) \

mm/maccess.c

57

__put_kernel_nofault(dst, src, type, err_label); \

mm/maccess.c

58

instrument_write(dst, sizeof(type)); \

mm/maccess.c

59

dst += sizeof(type); \

mm/maccess.c

64

long copy_to_kernel_nofault(void *dst, const void *src, size_t size)

mm/maccess.c

69

align = (unsigned long)dst | (unsigned long)src;

mm/maccess.c

73

copy_to_kernel_nofault_loop(dst, src, size, u64, Efault);

mm/maccess.c

75

copy_to_kernel_nofault_loop(dst, src, size, u32, Efault);

mm/maccess.c

77

copy_to_kernel_nofault_loop(dst, src, size, u16, Efault);

mm/maccess.c

78

copy_to_kernel_nofault_loop(dst, src, size, u8, Efault);

mm/maccess.c

86

long strncpy_from_kernel_nofault(char *dst, const void *unsafe_addr, long count)

mm/maccess.c

97

__get_kernel_nofault(dst, src, u8, Efault);

mm/maccess.c

98

dst++;

mm/memory.c

3460

static inline int __wp_page_copy_user(struct page *dst, struct page *src,

mm/memory.c

3471

if (copy_mc_user_highpage(dst, src, addr, vma))

mm/memory.c

3482

kaddr = kmap_local_page(dst);

mm/memory.c

3553

flush_dcache_page(dst);

mm/memory.c

7368

static int copy_user_gigantic_page(struct folio *dst, struct folio *src,

mm/memory.c

7373

unsigned long addr = ALIGN_DOWN(addr_hint, folio_size(dst));

mm/memory.c

7379

dst_page = folio_page(dst, i);

mm/memory.c

7391

struct folio *dst;

mm/memory.c

7399

struct page *dst = folio_page(copy_arg->dst, idx);

mm/memory.c

7402

if (copy_mc_user_highpage(dst, src, addr, copy_arg->vma))

mm/memory.c

7407

int copy_user_large_folio(struct folio *dst, struct folio *src,

mm/memory.c

7410

unsigned int nr_pages = folio_nr_pages(dst);

mm/memory.c

7412

.dst = dst,

mm/memory.c

7418

return copy_user_gigantic_page(dst, src, addr_hint, vma, nr_pages);

mm/mempolicy.c

2802

int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)

mm/mempolicy.c

2808

dst->vm_policy = pol;

mm/migrate.c

1021

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1023

return __buffer_migrate_folio(mapping, dst, src, mode, false);

mm/migrate.c

1042

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1044

return __buffer_migrate_folio(mapping, dst, src, mode, true);

mm/migrate.c

1050

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1052

return __migrate_folio(mapping, dst, src, folio_get_private(src), mode);

mm/migrate.c

1060

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/migrate.c

1075

return migrate_folio(mapping, dst, src, mode);

mm/migrate.c

1090

static int move_to_new_folio(struct folio *dst, struct folio *src,

mm/migrate.c

1097

VM_BUG_ON_FOLIO(!folio_test_locked(dst), dst);

mm/migrate.c

1100

rc = migrate_folio(mapping, dst, src, mode);

mm/migrate.c

1111

rc = mapping->a_ops->migrate_folio(mapping, dst, src,

mm/migrate.c

1114

rc = fallback_migrate_folio(mapping, dst, src, mode);

mm/migrate.c

1124

if (likely(!folio_is_zone_device(dst)))

mm/migrate.c

1125

flush_dcache_folio(dst);

mm/migrate.c

1141

static void __migrate_folio_record(struct folio *dst,

mm/migrate.c

1145

dst->private = (void *)anon_vma + old_page_state;

mm/migrate.c

1148

static void __migrate_folio_extract(struct folio *dst,

mm/migrate.c

1152

unsigned long private = (unsigned long)dst->private;

mm/migrate.c

1156

dst->private = NULL;

mm/migrate.c

1178

static void migrate_folio_undo_dst(struct folio *dst, bool locked,

mm/migrate.c

1182

folio_unlock(dst);

mm/migrate.c

1184

put_new_folio(dst, private);

mm/migrate.c

1186

folio_put(dst);

mm/migrate.c

1208

struct folio *dst;

mm/migrate.c

1215

dst = get_new_folio(src, private);

mm/migrate.c

1216

if (!dst)

mm/migrate.c

1218

*dstp = dst;

mm/migrate.c

1220

dst->private = NULL;

mm/migrate.c

1298

if (unlikely(!folio_trylock(dst)))

mm/migrate.c

1303

__migrate_folio_record(dst, old_page_state, anon_vma);

mm/migrate.c

1333

__migrate_folio_record(dst, old_page_state, anon_vma);

mm/migrate.c

1347

migrate_folio_undo_dst(dst, dst_locked, put_new_folio, private);

mm/migrate.c

1354

struct folio *src, struct folio *dst,

mm/migrate.c

1363

__migrate_folio_extract(dst, &old_page_state, &anon_vma);

mm/migrate.c

1364

prev = dst->lru.prev;

mm/migrate.c

1365

list_del(&dst->lru);

mm/migrate.c

1368

rc = migrate_movable_ops_page(&dst->page, &src->page, mode);

mm/migrate.c

1374

rc = move_to_new_folio(dst, src, mode);

mm/migrate.c

1387

folio_add_lru(dst);

mm/migrate.c

1392

remove_migration_ptes(src, dst, 0);

mm/migrate.c

1395

folio_unlock(dst);

mm/migrate.c

1396

folio_set_owner_migrate_reason(dst, reason);

mm/migrate.c

1402

folio_put(dst);

mm/migrate.c

1422

list_add(&dst->lru, prev);

mm/migrate.c

1423

__migrate_folio_record(dst, old_page_state, anon_vma);

mm/migrate.c

1429

migrate_folio_undo_dst(dst, true, put_new_folio, private);

mm/migrate.c

1457

struct folio *dst;

mm/migrate.c

1470

dst = get_new_folio(src, private);

mm/migrate.c

1471

if (!dst)

mm/migrate.c

1499

if (unlikely(!folio_trylock(dst)))

mm/migrate.c

1522

rc = move_to_new_folio(dst, src, mode);

mm/migrate.c

1525

remove_migration_ptes(src, !rc ? dst : src, ttu);

mm/migrate.c

1531

folio_unlock(dst);

mm/migrate.c

1538

move_hugetlb_state(src, dst, reason);

mm/migrate.c

1556

put_new_folio(dst, private);

mm/migrate.c

1558

folio_put(dst);

mm/migrate.c

1708

struct folio *folio, *folio2, *dst, *dst2;

mm/migrate.c

1713

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

1714

dst2 = list_next_entry(dst, lru);

mm/migrate.c

1722

folio, dst, mode,

mm/migrate.c

1746

dst = dst2;

mm/migrate.c

1747

dst2 = list_next_entry(dst, lru);

mm/migrate.c

1756

struct folio *folio, *folio2, *dst, *dst2;

mm/migrate.c

1758

dst = list_first_entry(dst_folios, struct folio, lru);

mm/migrate.c

1759

dst2 = list_next_entry(dst, lru);

mm/migrate.c

1764

__migrate_folio_extract(dst, &old_page_state, &anon_vma);

mm/migrate.c

1767

list_del(&dst->lru);

mm/migrate.c

1768

migrate_folio_undo_dst(dst, true, put_new_folio, private);

mm/migrate.c

1769

dst = dst2;

mm/migrate.c

1770

dst2 = list_next_entry(dst, lru);

mm/migrate.c

1796

struct folio *folio, *folio2, *dst = NULL;

mm/migrate.c

1891

private, folio, &dst, mode, ret_folios);

mm/migrate.c

1947

list_add_tail(&dst->lru, &dst_folios);

mm/migrate.c

236

static int migrate_movable_ops_page(struct page *dst, struct page *src,

mm/migrate.c

243

rc = page_movable_ops(src)->migrate_page(dst, src, mode);

mm/migrate.c

455

void remove_migration_ptes(struct folio *src, struct folio *dst,

mm/migrate.c

468

VM_BUG_ON_FOLIO((flags & TTU_USE_SHARED_ZEROPAGE) && (src != dst), src);

mm/migrate.c

471

rmap_walk_locked(dst, &rwc);

mm/migrate.c

473

rmap_walk(dst, &rwc);

mm/migrate.c

725

struct folio *dst, struct folio *src)

mm/migrate.c

733

rc = folio_mc_copy(dst, src);

mm/migrate.c

743

dst->index = src->index;

mm/migrate.c

744

dst->mapping = src->mapping;

mm/migrate.c

746

folio_ref_add(dst, folio_nr_pages(dst));

mm/migrate.c

748

xas_store(&xas, dst);

mm/migrate.c

855

static int __migrate_folio(struct address_space *mapping, struct folio *dst,

mm/migrate.c

865

rc = folio_mc_copy(dst, src);

mm/migrate.c

869

rc = __folio_migrate_mapping(mapping, dst, src, expected_count);

mm/migrate.c

874

folio_attach_private(dst, folio_detach_private(src));

mm/migrate.c

876

folio_migrate_flags(dst, src);

mm/migrate.c

892

int migrate_folio(struct address_space *mapping, struct folio *dst,

mm/migrate.c

896

return __migrate_folio(mapping, dst, src, NULL, mode);

mm/migrate.c

935

struct folio *dst, struct folio *src, enum migrate_mode mode,

mm/migrate.c

944

return migrate_folio(mapping, dst, src, mode);

mm/migrate.c

983

rc = filemap_migrate_folio(mapping, dst, src, mode);

mm/migrate.c

989

folio_set_bh(bh, dst, bh_offset(bh));

mm/migrate_device.c

1002

if (thp_migration_supported() && (*dst & MIGRATE_PFN_COMPOUND)) {

mm/migrate_device.c

1267

__migrate_device_pages(migrate->src, migrate->dst, migrate->npages, migrate);

mm/migrate_device.c

1281

struct folio *dst = NULL, *src = NULL;

mm/migrate_device.c

1286

dst = page_folio(newpage);

mm/migrate_device.c

1289

if (dst) {

mm/migrate_device.c

1290

WARN_ON_ONCE(fault_folio == dst);

mm/migrate_device.c

1291

folio_unlock(dst);

mm/migrate_device.c

1292

folio_put(dst);

mm/migrate_device.c

1299

if (!(src_pfns[i] & MIGRATE_PFN_MIGRATE) || !dst) {

mm/migrate_device.c

1300

if (dst) {

mm/migrate_device.c

1301

WARN_ON_ONCE(fault_folio == dst);

mm/migrate_device.c

1302

folio_unlock(dst);

mm/migrate_device.c

1303

folio_put(dst);

mm/migrate_device.c

1305

dst = src;

mm/migrate_device.c

1308

if (!folio_is_zone_device(dst))

mm/migrate_device.c

1309

folio_add_lru(dst);

mm/migrate_device.c

1310

remove_migration_ptes(src, dst, 0);

mm/migrate_device.c

1315

if (dst != src) {

mm/migrate_device.c

1316

WARN_ON_ONCE(fault_folio == dst);

mm/migrate_device.c

1317

folio_unlock(dst);

mm/migrate_device.c

1318

folio_put(dst);

mm/migrate_device.c

1353

__migrate_device_finalize(migrate->src, migrate->dst, migrate->npages,

mm/migrate_device.c

215

migrate->dst[migrate->npages++] = 0;

mm/migrate_device.c

222

migrate->dst[migrate->npages] = 0;

mm/migrate_device.c

29

migrate->dst[migrate->npages] = 0;

mm/migrate_device.c

480

migrate->dst[migrate->npages] = 0;

mm/migrate_device.c

54

migrate->dst[migrate->npages] = 0;

mm/migrate_device.c

67

migrate->dst[migrate->npages] = 0;

mm/migrate_device.c

751

if (!args->src || !args->dst)

mm/migrate_device.c

970

unsigned long *dst,

mm/migrate_device.c

973

struct page *page = migrate_pfn_to_page(*dst);

mm/numa_memblks.c

182

static void __init numa_move_tail_memblk(struct numa_meminfo *dst, int idx,

mm/numa_memblks.c

185

dst->blk[dst->nr_blks++] = src->blk[idx];

mm/rmap.c

235

static void check_anon_vma_clone(struct vm_area_struct *dst,

mm/rmap.c

242

VM_WARN_ON_ONCE(operation != VMA_OP_FORK && dst->vm_mm != src->vm_mm);

mm/rmap.c

246

VM_WARN_ON_ONCE(!src->anon_vma && dst->anon_vma);

mm/rmap.c

248

VM_WARN_ON_ONCE(!list_empty(&dst->anon_vma_chain));

mm/rmap.c

253

VM_WARN_ON_ONCE(dst->anon_vma && dst->anon_vma != src->anon_vma);

mm/rmap.c

259

!dst->anon_vma);

mm/rmap.c

266

vma_is_attached(dst));

mm/rmap.c

270

static void maybe_reuse_anon_vma(struct vm_area_struct *dst,

mm/rmap.c

274

if (dst->anon_vma)

mm/rmap.c

286

dst->anon_vma = anon_vma;

mm/rmap.c

320

int anon_vma_clone(struct vm_area_struct *dst, struct vm_area_struct *src,

mm/rmap.c

326

check_anon_vma_clone(dst, src, operation);

mm/rmap.c

346

anon_vma_chain_assign(dst, avc, pavc->anon_vma);

mm/rmap.c

354

list_for_each_entry_reverse(avc, &dst->anon_vma_chain, same_vma) {

mm/rmap.c

359

maybe_reuse_anon_vma(dst, anon_vma);

mm/rmap.c

363

dst->anon_vma->num_active_vmas++;

mm/rmap.c

369

cleanup_partial_anon_vmas(dst);

mm/secretmem.c

147

struct folio *dst, struct folio *src, enum migrate_mode mode)

mm/util.c

721

void folio_copy(struct folio *dst, struct folio *src)

mm/util.c

727

copy_highpage(folio_page(dst, i), folio_page(src, i));

mm/util.c

735

int folio_mc_copy(struct folio *dst, struct folio *src)

mm/util.c

741

if (copy_mc_highpage(folio_page(dst, i), folio_page(src, i)))

mm/vma.c

609

static int dup_anon_vma(struct vm_area_struct *dst,

mm/vma.c

626

if (src->anon_vma && !dst->anon_vma) {

mm/vma.c

629

vma_assert_write_locked(dst);

mm/vma.c

630

dst->anon_vma = src->anon_vma;

mm/vma.c

631

ret = anon_vma_clone(dst, src, VMA_OP_MERGE_UNFAULTED);

mm/vma.c

635

*dup = dst;

mm/vmscan.c

1007

dst = alloc_migration_target(src, (unsigned long)mtc);

mm/vmscan.c

1008

if (dst)

mm/vmscan.c

1009

return dst;

mm/vmscan.c

1711

struct lruvec *lruvec, struct list_head *dst,

mm/vmscan.c

1773

move_to = dst;

mm/vmscan.c

989

struct folio *dst;

mm/zsmalloc.c

1203

void *dst = kmap_local_zpdesc(zpdesc);

mm/zsmalloc.c

1205

memcpy(dst + off, handle_mem, mem_len);

mm/zsmalloc.c

1206

kunmap_local(dst);

mm/zsmalloc.c

1419

static void zs_object_copy(struct size_class *class, unsigned long dst,

mm/zsmalloc.c

1432

obj_to_location(dst, &d_zpdesc, &d_objidx);

mm/zswap.c

862

u8 *dst;

mm/zswap.c

866

dst = acomp_ctx->buffer;

mm/zswap.c

870

sg_init_one(&output, dst, PAGE_SIZE);

mm/zswap.c

903

dst = kmap_local_page(page);

mm/zswap.c

914

zs_obj_write(pool->zs_pool, handle, dst, dlen);

mm/zswap.c

920

kunmap_local(dst);

mm/zswap.c

945

void *dst;

mm/zswap.c

949

dst = kmap_local_folio(folio, 0);

mm/zswap.c

950

memcpy_from_sglist(dst, input, 0, PAGE_SIZE);

mm/zswap.c

952

kunmap_local(dst);

net/atm/clip.c

343

struct dst_entry *dst = skb_dst(skb);

net/atm/clip.c

353

if (!dst) {

net/atm/clip.c

359

rt = dst_rtable(dst);

net/atm/clip.c

364

n = dst_neigh_lookup(dst, daddr);

net/atm/clip.c

482

neigh = __neigh_lookup(&arp_tbl, &ip, rt->dst.dev, 1);

net/atm/lec.c

223

unsigned char *dst;

net/atm/lec.c

292

dst = lec_h->h_dest;

net/atm/lec.c

294

vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry);

net/atm/lec.c

639

unsigned char *src, *dst;

net/atm/lec.c

652

dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest;

net/atm/lec.c

669

if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */

net/atm/lec.c

671

memcmp(dst, dev->dev_addr, dev->addr_len)) {

net/ax25/ax25_ip.c

105

ax25_address *src, *dst;

net/ax25/ax25_ip.c

111

dst = (ax25_address *)(bp + 1);

net/ax25/ax25_ip.c

115

route = ax25_get_route(dst, NULL);

net/ax25/ax25_ip.c

197

if ((ourskb = ax25_rt_build_path(skb, src, dst, route->digipeat)) == NULL)

net/batman-adv/distributed-arp-table.c

273

u8 *dst = batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4;

net/batman-adv/distributed-arp-table.c

275

return *(__force __be32 *)dst;

net/batman-adv/multicast.c

557

static void batadv_mcast_mla_br_addr_cpy(char *dst, const struct br_ip *src)

net/batman-adv/multicast.c

560

ip_eth_mc_map(src->dst.ip4, dst);

net/batman-adv/multicast.c

563

ipv6_eth_mc_map(&src->dst.ip6, dst);

net/batman-adv/multicast.c

566

eth_zero_addr(dst);

net/batman-adv/multicast.c

607

ipv4_is_local_multicast(br_ip_entry->addr.dst.ip4))

net/batman-adv/multicast.c

611

!ipv4_is_local_multicast(br_ip_entry->addr.dst.ip4))

net/batman-adv/multicast.c

621

ipv6_addr_is_ll_all_nodes(&br_ip_entry->addr.dst.ip6))

net/batman-adv/multicast.c

625

IPV6_ADDR_MC_SCOPE(&br_ip_entry->addr.dst.ip6) >

net/batman-adv/netlink.c

627

int batadv_netlink_tpmeter_notify(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/netlink.c

659

if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, dst))

net/batman-adv/netlink.c

694

u8 *dst;

net/batman-adv/netlink.c

703

dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);

net/batman-adv/netlink.c

721

batadv_tp_start(bat_priv, dst, test_length, &cookie);

net/batman-adv/netlink.c

747

u8 *dst;

net/batman-adv/netlink.c

753

dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);

net/batman-adv/netlink.c

755

batadv_tp_stop(bat_priv, dst, BATADV_TP_REASON_CANCEL);

net/batman-adv/netlink.h

22

int batadv_netlink_tpmeter_notify(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/routing.c

243

ether_addr_copy(icmph->dst, icmph->orig);

net/batman-adv/routing.c

290

icmp_packet->orig, icmp_packet->dst);

net/batman-adv/routing.c

309

ether_addr_copy(icmp_packet->dst, icmp_packet->orig);

net/batman-adv/routing.c

391

if (batadv_is_my_mac(bat_priv, icmph->dst))

net/batman-adv/routing.c

399

orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);

net/batman-adv/send.c

397

u8 *src, *dst;

net/batman-adv/send.c

401

dst = ethhdr->h_dest;

net/batman-adv/send.c

406

dst = dst_hint;

net/batman-adv/send.c

408

orig_node = batadv_transtable_search(bat_priv, src, dst, vid);

net/batman-adv/tp_meter.c

1039

dst, test_length);

net/batman-adv/tp_meter.c

1059

void batadv_tp_stop(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/tp_meter.c

1066

"Meter: stopping test towards %pM\n", dst);

net/batman-adv/tp_meter.c

1068

orig_node = batadv_orig_hash_find(bat_priv, dst);

net/batman-adv/tp_meter.c

1154

static int batadv_tp_send_ack(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/tp_meter.c

1164

orig_node = batadv_orig_hash_find(bat_priv, dst);

net/batman-adv/tp_meter.c

1188

ether_addr_copy(icmp->dst, orig_node->orig);

net/batman-adv/tp_meter.c

215

const u8 *dst, struct batadv_priv *bat_priv,

net/batman-adv/tp_meter.c

233

batadv_netlink_tpmeter_notify(bat_priv, dst, result, test_time,

net/batman-adv/tp_meter.c

245

const u8 *dst,

net/batman-adv/tp_meter.c

249

batadv_tp_batctl_notify(reason, dst, bat_priv, 0, 0, cookie);

net/batman-adv/tp_meter.c

263

const u8 *dst)

net/batman-adv/tp_meter.c

269

if (!batadv_compare_eth(pos->other_end, dst))

net/batman-adv/tp_meter.c

301

batadv_tp_list_find_session(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/tp_meter.c

308

if (!batadv_compare_eth(pos->other_end, dst))

net/batman-adv/tp_meter.c

596

ether_addr_copy(icmp->dst, orig_node->orig);

net/batman-adv/tp_meter.c

935

void batadv_tp_start(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/tp_meter.c

950

tp_vars = batadv_tp_list_find(bat_priv, dst);

net/batman-adv/tp_meter.c

957

dst, bat_priv, session_cookie);

net/batman-adv/tp_meter.c

965

batadv_tp_batctl_error_notify(BATADV_TP_REASON_TOO_MANY, dst,

net/batman-adv/tp_meter.c

977

dst, bat_priv, session_cookie);

net/batman-adv/tp_meter.c

982

ether_addr_copy(tp_vars->other_end, dst);

net/batman-adv/tp_meter.h

16

void batadv_tp_start(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/tp_meter.h

18

void batadv_tp_stop(struct batadv_priv *bat_priv, const u8 *dst,

net/batman-adv/translation-table.c

3685

bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,

net/batman-adv/translation-table.c

3700

tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);

net/batman-adv/translation-table.c

3980

u8 *src, u8 *dst,

net/batman-adv/translation-table.c

4011

ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);

net/batman-adv/translation-table.c

4020

dst, tt_flag);

net/batman-adv/translation-table.c

4028

if (batadv_is_my_mac(bat_priv, dst)) {

net/batman-adv/translation-table.c

4040

"Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);

net/batman-adv/translation-table.c

4062

u8 *src, u8 *dst,

net/batman-adv/translation-table.c

4073

if (!batadv_is_my_mac(bat_priv, dst))

net/batman-adv/translation-table.h

41

bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,

net/batman-adv/tvlv.c

372

u8 *src, *dst;

net/batman-adv/tvlv.c

399

dst = ((struct batadv_unicast_tvlv_packet *)skb->data)->dst;

net/batman-adv/tvlv.c

402

dst, tvlv_value,

net/batman-adv/tvlv.c

542

u8 *src, u8 *dst,

net/batman-adv/tvlv.c

618

const u8 *dst, u8 type, u8 version,

net/batman-adv/tvlv.c

629

orig_node = batadv_orig_hash_find(bat_priv, dst);

net/batman-adv/tvlv.c

650

ether_addr_copy(unicast_tvlv_packet->dst, dst);

net/batman-adv/tvlv.h

35

u8 *src, u8 *dst,

net/batman-adv/tvlv.h

49

const u8 *dst, u8 type, u8 version,

net/batman-adv/types.h

2169

u8 *src, u8 *dst,

net/bluetooth/6lowpan.c

1018

BT_DBG("conn %p dst %pMR type %u", *conn, &hcon->dst, hcon->dst_type);

net/bluetooth/6lowpan.c

1176

&conn->hcon->dst, conn->hcon->dst_type,

net/bluetooth/6lowpan.c

1212

&peer->chan->dst, peer->chan->dst_type);

net/bluetooth/6lowpan.c

179

&peer->chan->dst, peer->chan->dst_type,

net/bluetooth/6lowpan.c

410

*peer_addr = peer->chan->dst;

net/bluetooth/6lowpan.c

492

&pentry->chan->dst, pentry->chan->dst_type,

net/bluetooth/6lowpan.c

654

baswap((void *)peer->lladdr, &chan->dst);

net/bluetooth/6lowpan.c

712

netdev->ifindex, &chan->dst, chan->dst_type,

net/bluetooth/bnep/bnep.h

118

__u8 dst[ETH_ALEN];

net/bluetooth/bnep/bnep.h

125

__u8 dst[ETH_ALEN];

net/bluetooth/bnep/core.c

48

static struct bnep_session *__bnep_get_session(u8 *dst)

net/bluetooth/bnep/core.c

55

if (ether_addr_equal(dst, s->eh.h_source))

net/bluetooth/bnep/core.c

562

u8 dst[ETH_ALEN], src[ETH_ALEN];

net/bluetooth/bnep/core.c

573

baswap((void *) dst, &l2cap_pi(sock->sk)->chan->dst);

net/bluetooth/bnep/core.c

586

ss = __bnep_get_session(dst);

net/bluetooth/bnep/core.c

597

memcpy(s->eh.h_source, &dst, ETH_ALEN);

net/bluetooth/bnep/core.c

664

s = __bnep_get_session(req->dst);

net/bluetooth/bnep/core.c

680

memcpy(ci->dst, s->eh.h_source, ETH_ALEN);

net/bluetooth/bnep/core.c

722

s = __bnep_get_session(ci->dst);

net/bluetooth/cmtp/core.c

350

s = __cmtp_get_session(&l2cap_pi(sock->sk)->chan->dst);

net/bluetooth/cmtp/core.c

356

bacpy(&session->bdaddr, &l2cap_pi(sock->sk)->chan->dst);

net/bluetooth/ecdh_helper.c

150

struct scatterlist dst;

net/bluetooth/ecdh_helper.c

163

sg_init_one(&dst, tmp, 64);

net/bluetooth/ecdh_helper.c

165

kpp_request_set_output(req, &dst, 64);

net/bluetooth/ecdh_helper.c

50

struct scatterlist src, dst;

net/bluetooth/ecdh_helper.c

67

sg_init_one(&dst, secret, 32);

net/bluetooth/ecdh_helper.c

69

kpp_request_set_output(req, &dst, 32);

net/bluetooth/hci_conn.c

1080

bdaddr_t *dst, u8 dst_type, u8 role)

net/bluetooth/hci_conn.c

1084

bt_dev_dbg(hdev, "dst %pMR", dst);

net/bluetooth/hci_conn.c

1090

return __hci_conn_add(hdev, type, dst, dst_type, role, handle);

net/bluetooth/hci_conn.c

1093

struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1099

return __hci_conn_add(hdev, type, dst, dst_type, role, handle);

net/bluetooth/hci_conn.c

1246

struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, uint8_t src_type)

net/bluetooth/hci_conn.c

1251

BT_DBG("%pMR -> %pMR", src, dst);

net/bluetooth/hci_conn.c

1292

if (bacmp(&d->bdaddr, dst)) {

net/bluetooth/hci_conn.c

1376

struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1403

conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);

net/bluetooth/hci_conn.c

1421

irk = hci_find_irk_by_addr(hdev, dst, dst_type);

net/bluetooth/hci_conn.c

1423

dst = &irk->rpa;

net/bluetooth/hci_conn.c

1429

bacpy(&conn->dst, dst);

net/bluetooth/hci_conn.c

1431

conn = hci_conn_add_unset(hdev, LE_LINK, dst, dst_type, role);

net/bluetooth/hci_conn.c

145

hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_conn.c

148

hci_remove_link_key(hdev, &conn->dst);

net/bluetooth/hci_conn.c

1569

static struct hci_conn *hci_add_bis(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1592

conn = hci_conn_hash_lookup_per_adv_bis(hdev, dst, qos->bcast.big,

net/bluetooth/hci_conn.c

1607

conn = hci_conn_add_unset(hdev, BIS_LINK, dst, 0, HCI_ROLE_MASTER);

net/bluetooth/hci_conn.c

1620

struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1644

conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);

net/bluetooth/hci_conn.c

1653

conn = hci_conn_add_unset(hdev, LE_LINK, dst, dst_type,

net/bluetooth/hci_conn.c

1658

if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0) {

net/bluetooth/hci_conn.c

1677

struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1693

if (!bacmp(&hdev->bdaddr, dst)) {

net/bluetooth/hci_conn.c

1695

dst);

net/bluetooth/hci_conn.c

1699

acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);

net/bluetooth/hci_conn.c

1701

acl = hci_conn_add_unset(hdev, ACL_LINK, dst, 0,

net/bluetooth/hci_conn.c

1756

struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1764

acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING,

net/bluetooth/hci_conn.c

1769

sco = hci_conn_hash_lookup_ba(hdev, type, dst);

net/bluetooth/hci_conn.c

1771

sco = hci_conn_add_unset(hdev, type, dst, 0, HCI_ROLE_MASTER);

net/bluetooth/hci_conn.c

1962

struct hci_conn *hci_bind_cis(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

1968

cis = hci_conn_hash_lookup_cis(hdev, dst, dst_type, qos->ucast.cig,

net/bluetooth/hci_conn.c

1971

cis = hci_conn_add_unset(hdev, CIS_LINK, dst, dst_type,

net/bluetooth/hci_conn.c

2152

struct hci_conn *hci_pa_create_sync(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

2158

bt_dev_dbg(hdev, "dst %pMR type %d sid %d", dst, dst_type, sid);

net/bluetooth/hci_conn.c

2160

conn = hci_conn_add_unset(hdev, PA_LINK, dst, dst_type, HCI_ROLE_SLAVE);

net/bluetooth/hci_conn.c

2214

struct hci_conn *hci_bind_bis(struct hci_dev *hdev, bdaddr_t *dst, __u8 sid,

net/bluetooth/hci_conn.c

2237

conn = hci_add_bis(hdev, dst, sid, qos, base_len, eir, timeout);

net/bluetooth/hci_conn.c

2270

int hci_past_bis(struct hci_conn *conn, bdaddr_t *dst, __u8 dst_type)

net/bluetooth/hci_conn.c

2275

le = hci_conn_hash_lookup_le(conn->hdev, dst, dst_type);

net/bluetooth/hci_conn.c

2287

if (bacmp(&conn->dst, BDADDR_ANY))

net/bluetooth/hci_conn.c

2298

struct hci_conn *hci_connect_bis(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

2307

conn = hci_bind_bis(hdev, dst, sid, qos, base_len, base, timeout);

net/bluetooth/hci_conn.c

2349

struct hci_conn *hci_connect_cis(struct hci_dev *hdev, bdaddr_t *dst,

net/bluetooth/hci_conn.c

2358

le = hci_connect_le(hdev, dst, dst_type, false,

net/bluetooth/hci_conn.c

2363

le = hci_connect_le_scan(hdev, dst, dst_type,

net/bluetooth/hci_conn.c

2377

cis = hci_bind_cis(hdev, dst, dst_type, qos, timeout);

net/bluetooth/hci_conn.c

2600

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_conn.c

2707

bacpy(&(ci + n)->bdaddr, &c->dst);

net/bluetooth/hci_conn.c

2743

bacpy(&ci.bdaddr, &conn->dst);

net/bluetooth/hci_conn.c

3255

key = hci_find_link_key(conn->hdev, &conn->dst);

net/bluetooth/hci_conn.c

3263

ltk = hci_find_ltk(conn->hdev, &conn->dst, conn->dst_type,

net/bluetooth/hci_conn.c

492

params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_conn.c

622

hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),

net/bluetooth/hci_conn.c

623

&conn->dst);

net/bluetooth/hci_conn.c

689

if (bacmp(&conn->dst, BDADDR_ANY))

net/bluetooth/hci_conn.c

79

bdaddr = &conn->dst;

net/bluetooth/hci_conn.c

884

if (!bacmp(&conn->dst, BDADDR_ANY) || d->cig != conn->iso_qos.ucast.cig)

net/bluetooth/hci_conn.c

926

bdaddr_t *dst, u8 dst_type,

net/bluetooth/hci_conn.c

942

irk = hci_get_irk(hdev, dst, dst_type);

net/bluetooth/hci_conn.c

949

irk = hci_get_irk(hdev, dst, dst_type);

net/bluetooth/hci_conn.c

961

bt_dev_dbg(hdev, "dst %pMR handle 0x%4.4x", dst, handle);

net/bluetooth/hci_conn.c

969

bacpy(&conn->dst, dst);

net/bluetooth/hci_conn.c

972

bacpy(&conn->dst, &irk->bdaddr);

net/bluetooth/hci_core.c

3478

&c->dst);

net/bluetooth/hci_event.c

2715

mgmt_disconnect_failed(hdev, &conn->dst, conn->type,

net/bluetooth/hci_event.c

2739

hci_remove_link_key(hdev, &conn->dst);

net/bluetooth/hci_event.c

2742

params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_event.c

2761

mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,

net/bluetooth/hci_event.c

3417

mgmt_disconnect_failed(hdev, &conn->dst, conn->type,

net/bluetooth/hci_event.c

3431

mgmt_device_disconnected(hdev, &conn->dst, conn->type, conn->dst_type,

net/bluetooth/hci_event.c

3436

hci_remove_link_key(hdev, &conn->dst);

net/bluetooth/hci_event.c

3445

params = hci_conn_params_lookup(hdev, &conn->dst,

net/bluetooth/hci_event.c

3754

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_event.c

3875

if (!conn || !bacmp(&conn->dst, BDADDR_ANY))

net/bluetooth/hci_event.c

4812

ie = hci_inquiry_cache_lookup(hdev, &conn->dst);

net/bluetooth/hci_event.c

4965

ie = hci_inquiry_cache_lookup(hdev, &conn->dst);

net/bluetooth/hci_event.c

4993

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_event.c

5269

data = hci_find_remote_oob_data(hdev, &conn->dst, BDADDR_BREDR);

net/bluetooth/hci_event.c

5509

mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,

net/bluetooth/hci_event.c

5548

mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,

net/bluetooth/hci_event.c

5804

irk = hci_get_irk(hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_event.c

5806

bacpy(&conn->dst, &irk->bdaddr);

net/bluetooth/hci_event.c

5831

if (hci_bdaddr_list_lookup(&hdev->reject_list, &conn->dst, addr_type)) {

net/bluetooth/hci_event.c

5861

params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,

net/bluetooth/hci_event.c

6711

ltk = hci_find_ltk(hdev, &conn->dst, conn->dst_type, conn->role);

net/bluetooth/hci_event.c

6812

params = hci_conn_params_lookup(hdev, &hcon->dst,

net/bluetooth/hci_event.c

6824

mgmt_new_conn_param(hdev, &hcon->dst, hcon->dst_type,

net/bluetooth/hci_event.c

7051

mask = hci_proto_connect_ind(hdev, &acl->dst, CIS_LINK, &flags);

net/bluetooth/hci_event.c

7059

cis = hci_conn_add(hdev, CIS_LINK, &acl->dst, acl->dst_type,

net/bluetooth/hci_event.c

7241

mgmt_device_disconnected(hdev, &bis->dst, bis->type,

net/bluetooth/hci_sync.c

2794

bacpy(&pa.addr, &conn->dst);

net/bluetooth/hci_sync.c

5656

6, &conn->dst,

net/bluetooth/hci_sync.c

5661

6, &conn->dst, HCI_CMD_TIMEOUT);

net/bluetooth/hci_sync.c

5670

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_sync.c

5711

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_sync.c

6425

bacpy(&cp.peer_addr, &conn->dst);

net/bluetooth/hci_sync.c

6499

bacpy(&cp.direct_addr, &conn->dst);

net/bluetooth/hci_sync.c

6543

bacpy(&cp->peer_addr, &conn->dst);

net/bluetooth/hci_sync.c

6620

params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_sync.c

6662

bacpy(&cp.peer_addr, &conn->dst);

net/bluetooth/hci_sync.c

6942

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/hci_sync.c

6945

ie = hci_inquiry_cache_lookup(hdev, &conn->dst);

net/bluetooth/hci_sync.c

7160

le = hci_conn_hash_lookup_le(hdev, &conn->dst, conn->dst_type);

net/bluetooth/hci_sync.c

7164

params = hci_conn_params_lookup(hdev, &le->dst, le->dst_type);

net/bluetooth/hci_sync.c

7187

bacpy(&cp.addr, &conn->dst);

net/bluetooth/hidp/core.c

1337

bacmp(&ctrl_chan->dst, &intr_chan->dst))

net/bluetooth/hidp/core.c

1348

session = hidp_session_find(&ctrl_chan->dst);

net/bluetooth/hidp/core.c

1385

ret = hidp_session_new(&session, &chan->dst, ctrl_sock,

net/bluetooth/hidp/core.c

791

&l2cap_pi(session->ctrl_sock->sk)->chan->dst);

net/bluetooth/iso.c

1068

if (!bacmp(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr) ||

net/bluetooth/iso.c

1191

bacpy(&iso_pi(sk)->dst, &sa->iso_bdaddr);

net/bluetooth/iso.c

1196

if (bacmp(&iso_pi(sk)->dst, BDADDR_ANY))

net/bluetooth/iso.c

1223

&iso_pi(sk)->dst, iso_pi(sk)->bc_sid);

net/bluetooth/iso.c

1227

if (__iso_get_sock_listen_by_sid(&iso_pi(sk)->src, &iso_pi(sk)->dst,

net/bluetooth/iso.c

1236

hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,

net/bluetooth/iso.c

1251

hcon = hci_pa_create_sync(hdev, &iso_pi(sk)->dst,

net/bluetooth/iso.c

1287

if (__iso_get_sock_listen_by_addr(&iso_pi(sk)->src, &iso_pi(sk)->dst))

net/bluetooth/iso.c

1315

if (!bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) {

net/bluetooth/iso.c

1450

bacpy(&sa->iso_bdaddr, &iso_pi(sk)->dst);

net/bluetooth/iso.c

1569

hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,

net/bluetooth/iso.c

1898

!bacmp(&iso_pi(sk)->dst, BDADDR_ANY)) {

net/bluetooth/iso.c

2027

return !bacmp(&iso_pi(sk)->dst, (bdaddr_t *)data);

net/bluetooth/iso.c

2048

!bacmp(&conn->hcon->dst, BDADDR_ANY)) {

net/bluetooth/iso.c

2076

parent = iso_get_sock(hdev, &hcon->src, &hcon->dst,

net/bluetooth/iso.c

2084

parent = iso_get_sock(hdev, &hcon->src, &hcon->dst,

net/bluetooth/iso.c

2090

&hcon->dst,

net/bluetooth/iso.c

2098

&hcon->dst,

net/bluetooth/iso.c

2106

&hcon->dst,

net/bluetooth/iso.c

2143

if (!bacmp(&hcon->dst, BDADDR_ANY)) {

net/bluetooth/iso.c

2144

bacpy(&hcon->dst, &iso_pi(parent)->dst);

net/bluetooth/iso.c

2158

bacpy(&iso_pi(sk)->dst, &hcon->dst);

net/bluetooth/iso.c

2421

BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);

net/bluetooth/iso.c

2628

&iso_pi(sk)->dst, sk->sk_state);

net/bluetooth/iso.c

344

hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,

net/bluetooth/iso.c

371

hcon = hci_bind_bis(hdev, &iso_pi(sk)->dst, iso_pi(sk)->bc_sid,

net/bluetooth/iso.c

380

hcon = hci_connect_bis(hdev, &iso_pi(sk)->dst,

net/bluetooth/iso.c

439

BT_DBG("%pMR -> %pMR", &iso_pi(sk)->src, &iso_pi(sk)->dst);

net/bluetooth/iso.c

441

hdev = hci_get_route(&iso_pi(sk)->dst, &iso_pi(sk)->src,

net/bluetooth/iso.c

475

hcon = hci_bind_cis(hdev, &iso_pi(sk)->dst,

net/bluetooth/iso.c

484

hcon = hci_connect_cis(hdev, &iso_pi(sk)->dst,

net/bluetooth/iso.c

594

static struct sock *__iso_get_sock_listen_by_addr(bdaddr_t *src, bdaddr_t *dst)

net/bluetooth/iso.c

602

if (bacmp(&iso_pi(sk)->dst, dst))

net/bluetooth/iso.c

624

if (bacmp(&iso_pi(sk)->dst, bc))

net/bluetooth/iso.c

64

bdaddr_t dst;

net/bluetooth/iso.c

642

bdaddr_t *dst, enum bt_sock_state state,

net/bluetooth/iso.c

654

if (bacmp(dst, BDADDR_ANY) && bacmp(&iso_pi(sk)->dst, dst)) {

net/bluetooth/iso.c

658

irk1 = hci_find_irk_by_rpa(hdev, dst);

net/bluetooth/iso.c

663

if (bacmp(&iso_pi(sk)->dst, &irk1->bdaddr)) {

net/bluetooth/iso.c

668

&iso_pi(sk)->dst);

net/bluetooth/iso.c

703

bdaddr_t *dst, uint8_t big)

net/bluetooth/iso.c

721

if (bacmp(&iso_pi(sk)->dst, dst))

net/bluetooth/iso.c

805

&iso_pi(sk)->dst,

net/bluetooth/iso.c

91

bdaddr_t *dst, enum bt_sock_state state,

net/bluetooth/iso.c

979

bacpy(&iso_pi(sk)->dst, &sa->iso_bc->bc_bdaddr);

net/bluetooth/l2cap_core.c

1846

bdaddr_t *dst,

net/bluetooth/l2cap_core.c

1869

dst_match = !bacmp(&c->dst, dst);

net/bluetooth/l2cap_core.c

1880

dst_any = !bacmp(&c->dst, BDADDR_ANY);

net/bluetooth/l2cap_core.c

4023

&conn->hcon->dst, ACL_LINK);

net/bluetooth/l2cap_core.c

4066

bacpy(&chan->dst, &conn->hcon->dst);

net/bluetooth/l2cap_core.c

4714

mgmt_new_conn_param(hcon->hdev, &hcon->dst, hcon->dst_type,

net/bluetooth/l2cap_core.c

4926

&conn->hcon->dst, LE_LINK);

net/bluetooth/l2cap_core.c

4971

bacpy(&chan->dst, &conn->hcon->dst);

net/bluetooth/l2cap_core.c

5144

&conn->hcon->dst, LE_LINK);

net/bluetooth/l2cap_core.c

5195

bacpy(&chan->dst, &conn->hcon->dst);

net/bluetooth/l2cap_core.c

6881

chan = l2cap_global_chan_by_psm(0, psm, &hcon->src, &hcon->dst,

net/bluetooth/l2cap_core.c

6897

bacpy(&bt_cb(skb)->l2cap.bdaddr, &hcon->dst);

net/bluetooth/l2cap_core.c

6939

hci_bdaddr_list_lookup(&hcon->hdev->reject_list, &hcon->dst,

net/bluetooth/l2cap_core.c

7076

bdaddr_t *dst, u8 dst_type, u16 timeout)

net/bluetooth/l2cap_core.c

7084

dst, dst_type, __le16_to_cpu(psm), chan->mode);

net/bluetooth/l2cap_core.c

7086

hdev = hci_get_route(dst, &chan->src, chan->src_type);

net/bluetooth/l2cap_core.c

7153

bacpy(&chan->dst, dst);

net/bluetooth/l2cap_core.c

7168

hcon = hci_connect_le(hdev, dst, dst_type, false,

net/bluetooth/l2cap_core.c

7172

hcon = hci_connect_le_scan(hdev, dst, dst_type,

net/bluetooth/l2cap_core.c

7178

hcon = hci_connect_acl(hdev, dst, chan->sec_level, auth_type,

net/bluetooth/l2cap_core.c

7366

BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);

net/bluetooth/l2cap_core.c

7380

if (hci_bdaddr_list_lookup(&hdev->reject_list, &hcon->dst, dst_type))

net/bluetooth/l2cap_core.c

7400

bacpy(&chan->dst, &hcon->dst);

net/bluetooth/l2cap_core.c

750

bacpy(&chan->dst, &hcon->dst);

net/bluetooth/l2cap_core.c

7785

&c->src, c->src_type, &c->dst, c->dst_type,

net/bluetooth/l2cap_sock.c

405

bacpy(&la->l2_bdaddr, &chan->dst);

net/bluetooth/lib.c

42

void baswap(bdaddr_t *dst, const bdaddr_t *src)

net/bluetooth/lib.c

45

unsigned char *d = (unsigned char *)dst;

net/bluetooth/mgmt.c

10050

bacpy(&ev.addr.bdaddr, &conn->dst);

net/bluetooth/mgmt.c

3378

bacpy(&rp->addr[i].bdaddr, &c->dst);

net/bluetooth/mgmt.c

3528

bacpy(&rp.addr.bdaddr, &conn->dst);

net/bluetooth/mgmt.c

3761

if (bacmp(&addr->bdaddr, &conn->dst) != 0) {

net/bluetooth/mgmt.c

9784

bacpy(&ev->addr.bdaddr, &conn->dst);

net/bluetooth/mgmt.c

9902

mgmt_device_disconnected(hdev, &conn->dst, conn->type,

net/bluetooth/mgmt.c

9907

bacpy(&ev.addr.bdaddr, &conn->dst);

net/bluetooth/rfcomm/core.c

2145

s = rfcomm_session_get(&conn->hdev->bdaddr, &conn->dst);

net/bluetooth/rfcomm/core.c

2198

&chan->src, &chan->dst,

net/bluetooth/rfcomm/core.c

371

static int __rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)

net/bluetooth/rfcomm/core.c

378

d, d->state, src, dst, channel);

net/bluetooth/rfcomm/core.c

386

s = rfcomm_session_get(src, dst);

net/bluetooth/rfcomm/core.c

388

s = rfcomm_session_create(src, dst, d->sec_level, &err);

net/bluetooth/rfcomm/core.c

425

int rfcomm_dlc_open(struct rfcomm_dlc *d, bdaddr_t *src, bdaddr_t *dst, u8 channel)

net/bluetooth/rfcomm/core.c

431

r = __rfcomm_dlc_open(d, src, dst, channel);

net/bluetooth/rfcomm/core.c

537

struct rfcomm_dlc *rfcomm_dlc_exists(bdaddr_t *src, bdaddr_t *dst, u8 channel)

net/bluetooth/rfcomm/core.c

547

s = rfcomm_session_get(src, dst);

net/bluetooth/rfcomm/core.c

69

bdaddr_t *dst,

net/bluetooth/rfcomm/core.c

72

static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst);

net/bluetooth/rfcomm/core.c

730

static struct rfcomm_session *rfcomm_session_get(bdaddr_t *src, bdaddr_t *dst)

net/bluetooth/rfcomm/core.c

738

!bacmp(&chan->dst, dst))

net/bluetooth/rfcomm/core.c

764

bdaddr_t *dst,

net/bluetooth/rfcomm/core.c

773

BT_DBG("%pMR -> %pMR", src, dst);

net/bluetooth/rfcomm/core.c

806

bacpy(&addr.l2_bdaddr, dst);

net/bluetooth/rfcomm/core.c

822

void rfcomm_session_getaddr(struct rfcomm_session *s, bdaddr_t *src, bdaddr_t *dst)

net/bluetooth/rfcomm/core.c

827

if (dst)

net/bluetooth/rfcomm/core.c

828

bacpy(dst, &chan->dst);

net/bluetooth/rfcomm/sock.c

402

bacpy(&rfcomm_pi(sk)->dst, &sa->rc_bdaddr);

net/bluetooth/rfcomm/sock.c

548

bacpy(&sa->rc_bdaddr, &rfcomm_pi(sk)->dst);

net/bluetooth/rfcomm/sock.c

936

bdaddr_t src, dst;

net/bluetooth/rfcomm/sock.c

941

rfcomm_session_getaddr(s, &src, &dst);

net/bluetooth/rfcomm/sock.c

964

bacpy(&rfcomm_pi(sk)->dst, &dst);

net/bluetooth/rfcomm/sock.c

991

&rfcomm_pi(sk)->src, &rfcomm_pi(sk)->dst,

net/bluetooth/rfcomm/tty.c

115

err = rfcomm_dlc_open(dev->dlc, &dev->src, &dev->dst, dev->channel);

net/bluetooth/rfcomm/tty.c

180

hdev = hci_get_route(&dev->dst, &dev->src, BDADDR_BREDR);

net/bluetooth/rfcomm/tty.c

188

conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);

net/bluetooth/rfcomm/tty.c

204

return sysfs_emit(buf, "%pMR\n", &dev->dst);

net/bluetooth/rfcomm/tty.c

266

bacpy(&dev->dst, &req->dst);

net/bluetooth/rfcomm/tty.c

414

dlc = rfcomm_dlc_exists(&req.src, &req.dst, req.channel);

net/bluetooth/rfcomm/tty.c

530

bacpy(&di[n].dst, &dev->dst);

net/bluetooth/rfcomm/tty.c

564

bacpy(&di.dst, &dev->dst);

net/bluetooth/rfcomm/tty.c

57

bdaddr_t dst;

net/bluetooth/rfcomm/tty.c

745

BT_DBG("dev %p dst %pMR channel %d opened %d", dev, &dev->dst,

net/bluetooth/sco.c

1013

hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,

net/bluetooth/sco.c

1209

hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);

net/bluetooth/sco.c

1405

bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);

net/bluetooth/sco.c

1458

BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);

net/bluetooth/sco.c

1531

&sco_pi(sk)->dst, sk->sk_state);

net/bluetooth/sco.c

317

BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);

net/bluetooth/sco.c

319

hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);

net/bluetooth/sco.c

339

hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,

net/bluetooth/sco.c

683

bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);

net/bluetooth/sco.c

69

bdaddr_t dst;

net/bluetooth/sco.c

805

bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);

net/bluetooth/sco.c

866

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/sco.c

873

bacpy(&cp.bdaddr, &conn->dst);

net/bluetooth/sco.c

978

hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,

net/bluetooth/smp.c

1027

hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,

net/bluetooth/smp.c

1067

bacpy(&hcon->dst, &smp->remote_irk->bdaddr);

net/bluetooth/smp.c

1080

bacpy(&smp->csrk->bdaddr, &hcon->dst);

net/bluetooth/smp.c

1086

bacpy(&smp->responder_csrk->bdaddr, &hcon->dst);

net/bluetooth/smp.c

1092

bacpy(&smp->ltk->bdaddr, &hcon->dst);

net/bluetooth/smp.c

1098

bacpy(&smp->responder_ltk->bdaddr, &hcon->dst);

net/bluetooth/smp.c

1113

key = hci_add_link_key(hdev, smp->conn->hcon, &hcon->dst,

net/bluetooth/smp.c

1145

smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,

net/bluetooth/smp.c

1208

key = hci_find_link_key(hdev, &hcon->dst);

net/bluetooth/smp.c

1300

ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,

net/bluetooth/smp.c

157

static inline void swap_buf(const u8 *src, u8 *dst, size_t len)

net/bluetooth/smp.c

162

dst[len - 1 - i] = src[i];

net/bluetooth/smp.c

2219

err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,

net/bluetooth/smp.c

2234

key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);

net/bluetooth/smp.c

2267

hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))

net/bluetooth/smp.c

2504

&conn->hcon->dst);

net/bluetooth/smp.c

2543

ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,

net/bluetooth/smp.c

2569

&conn->hcon->dst);

net/bluetooth/smp.c

2625

if (hci_is_identity_address(&hcon->dst, hcon->dst_type) &&

net/bluetooth/smp.c

2626

(bacmp(&info->bdaddr, &hcon->dst) ||

net/bluetooth/smp.c

2636

if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))

net/bluetooth/smp.c

2637

bacpy(&rpa, &hcon->dst);

net/bluetooth/smp.c

2817

if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,

net/bluetooth/smp.c

2840

if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,

net/bluetooth/smp.c

3065

code, &hcon->dst);

net/bluetooth/smp.c

686

oob_data = hci_find_remote_oob_data(hdev, &hcon->dst,

net/bluetooth/smp.c

890

ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,

net/bluetooth/smp.c

934

ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,

net/bluetooth/smp.c

937

ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,

net/bluetooth/smp.c

941

ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,

net/bridge/br_arp_nd_proxy.c

208

(f->dst && (f->dst->flags & BR_PROXYARP_WIFI)) ||

net/bridge/br_arp_nd_proxy.c

209

br_is_neigh_suppress_enabled(f->dst, vid)) {

net/bridge/br_arp_nd_proxy.c

475

if (br_is_neigh_suppress_enabled(f->dst, vid)) {

net/bridge/br_device.c

109

} else if ((dst = br_fdb_find_rcu(br, dest, vid)) != NULL) {

net/bridge/br_device.c

110

br_forward(dst->dst, skb, false, true);

net/bridge/br_device.c

214

dst_metric_set(&br->fake_rtable.dst, RTAX_MTU, new_mtu);

net/bridge/br_device.c

36

struct net_bridge_fdb_entry *dst;

net/bridge/br_device.c

389

struct net_bridge_port *dst;

net/bridge/br_device.c

403

dst = READ_ONCE(f->dst);

net/bridge/br_device.c

404

if (!dst)

net/bridge/br_device.c

407

if (br_vlan_fill_forward_path_mode(br, dst, path))

net/bridge/br_device.c

411

path->dev = dst->br->dev;

net/bridge/br_device.c

412

ctx->dev = dst->dev;

net/bridge/br_fdb.c

1021

if (unlikely(source != READ_ONCE(fdb->dst) &&

net/bridge/br_fdb.c

1024

WRITE_ONCE(fdb->dst, source);

net/bridge/br_fdb.c

1088

if (filter_dev && (!f->dst || f->dst->dev != filter_dev)) {

net/bridge/br_fdb.c

1096

if (f->dst)

net/bridge/br_fdb.c

1099

if (!filter_dev && f->dst)

net/bridge/br_fdb.c

110

ndm->ndm_ifindex = dst ? dst->dev->ifindex : br->dev->ifindex;

net/bridge/br_fdb.c

1216

if (READ_ONCE(fdb->dst) != source) {

net/bridge/br_fdb.c

1217

WRITE_ONCE(fdb->dst, source);

net/bridge/br_fdb.c

1408

if (!fdb || READ_ONCE(fdb->dst) != p)

net/bridge/br_fdb.c

1564

READ_ONCE(fdb->dst) != p)) {

net/bridge/br_fdb.c

1571

if (READ_ONCE(fdb->dst) != p) {

net/bridge/br_fdb.c

1572

WRITE_ONCE(fdb->dst, p);

net/bridge/br_fdb.c

1655

if (f->dst == p && f->key.vlan_id == vid)

net/bridge/br_fdb.c

251

if (f && f->dst)

net/bridge/br_fdb.c

252

dev = f->dst->dev;

net/bridge/br_fdb.c

349

f->dst = op;

net/bridge/br_fdb.c

360

f->dst = NULL;

net/bridge/br_fdb.c

377

!test_bit(BR_FDB_ADDED_BY_USER, &f->flags) && f->dst == p)

net/bridge/br_fdb.c

407

WRITE_ONCE(fdb->dst, source);

net/bridge/br_fdb.c

469

if (f->dst == p && test_bit(BR_FDB_LOCAL, &f->flags) &&

net/bridge/br_fdb.c

515

!f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))

net/bridge/br_fdb.c

531

!f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))

net/bridge/br_fdb.c

691

const struct net_bridge_port *dst = READ_ONCE(f->dst);

net/bridge/br_fdb.c

692

int port_ifidx = dst ? dst->dev->ifindex : br->dev->ifindex;

net/bridge/br_fdb.c

877

if (f->dst != p)

net/bridge/br_fdb.c

909

const struct net_bridge_port *dst = NULL;

net/bridge/br_fdb.c

913

dst = READ_ONCE(fdb->dst);

net/bridge/br_fdb.c

915

ret = dst && dst->dev != dev &&

net/bridge/br_fdb.c

916

dst->state == BR_STATE_FORWARDING;

net/bridge/br_fdb.c

93

const struct net_bridge_port *dst = READ_ONCE(fdb->dst);

net/bridge/br_fdb.c

947

if (!f->dst)

net/bridge/br_fdb.c

959

fe->port_no = f->dst->port_no;

net/bridge/br_fdb.c

960

fe->port_hi = f->dst->port_no >> 8;

net/bridge/br_input.c

126

} else if (READ_ONCE(fdb_src->dst) != p ||

net/bridge/br_input.c

204

dst = br_fdb_find_rcu(br, eth_hdr(skb)->h_dest, vid);

net/bridge/br_input.c

205

if (unlikely(!dst && vid &&

net/bridge/br_input.c

207

dst = br_fdb_find_rcu(br, eth_hdr(skb)->h_dest, 0);

net/bridge/br_input.c

208

if (dst &&

net/bridge/br_input.c

209

(!test_bit(BR_FDB_LOCAL, &dst->flags) ||

net/bridge/br_input.c

210

test_bit(BR_FDB_ADDED_BY_USER, &dst->flags)))

net/bridge/br_input.c

211

dst = NULL;

net/bridge/br_input.c

218

if (dst) {

net/bridge/br_input.c

221

if (test_bit(BR_FDB_LOCAL, &dst->flags))

net/bridge/br_input.c

224

if (now != READ_ONCE(dst->used))

net/bridge/br_input.c

225

WRITE_ONCE(dst->used, now);

net/bridge/br_input.c

226

br_forward(dst->dst, skb, local_rcv, false);

net/bridge/br_input.c

81

struct net_bridge_fdb_entry *dst = NULL;

net/bridge/br_mdb.c

159

ip->dst.ip4 = entry->addr.u.ip4;

net/bridge/br_mdb.c

165

ip->dst.ip6 = entry->addr.u.ip6;

net/bridge/br_mdb.c

171

ether_addr_copy(ip->dst.mac_addr, entry->addr.u.mac_addr);

net/bridge/br_mdb.c

257

e.addr.u.ip4 = mp->addr.dst.ip4;

net/bridge/br_mdb.c

260

e.addr.u.ip6 = mp->addr.dst.ip6;

net/bridge/br_mdb.c

263

ether_addr_copy(e.addr.u.mac_addr, mp->addr.dst.mac_addr);

net/bridge/br_mdb.c

300

ether_addr_copy(e.addr.u.mac_addr, mp->addr.dst.mac_addr);

net/bridge/br_mrp.c

134

const u8 *src, const u8 *dst)

net/bridge/br_mrp.c

150

ether_addr_copy(eth_hdr->h_dest, dst);

net/bridge/br_multicast.c

100

struct br_ip *dst)

net/bridge/br_multicast.c

102

return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);

net/bridge/br_multicast.c

106

struct br_ip *dst)

net/bridge/br_multicast.c

113

ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);

net/bridge/br_multicast.c

120

__be32 dst, __u16 vid)

net/bridge/br_multicast.c

1249

ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);

net/bridge/br_multicast.c

125

br_dst.dst.ip4 = dst;

net/bridge/br_multicast.c

1251

ip4_dst, group->dst.ip4,

net/bridge/br_multicast.c

1260

ip6_dst = ip_dst->dst.ip6;

net/bridge/br_multicast.c

1266

&ip6_dst, &group->dst.ip6,

net/bridge/br_multicast.c

134

const struct in6_addr *dst,

net/bridge/br_multicast.c

140

br_dst.dst.ip6 = *dst;

net/bridge/br_multicast.c

1590

br_group.dst.ip4 = group;

net/bridge/br_multicast.c

1614

br_group.dst.ip6 = *group;

net/bridge/br_multicast.c

168

ip.dst.ip4 = ip_hdr(skb)->daddr;

net/bridge/br_multicast.c

181

ip.dst.ip6 = ipv6_hdr(skb)->daddr;

net/bridge/br_multicast.c

1861

memset(&br_group.dst, 0, sizeof(br_group.dst));

net/bridge/br_multicast.c

195

ether_addr_copy(ip.dst.mac_addr, eth_hdr(skb)->h_dest);

net/bridge/br_multicast.c

3771

br_group.dst.ip4 = group;

net/bridge/br_multicast.c

3796

br_group.dst.ip6 = *group;

net/bridge/br_multicast.c

5165

static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src)

net/bridge/br_multicast.c

5167

dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];

net/bridge/br_multicast.c

5168

dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];

net/bridge/br_netfilter_hooks.c

278

struct dst_entry *dst;

net/bridge/br_netfilter_hooks.c

283

dst = skb_dst(skb);

net/bridge/br_netfilter_hooks.c

284

neigh = dst_neigh_lookup_skb(dst, skb);

net/bridge/br_netfilter_hooks.c

419

skb_dst_set_noref(skb, &rt->dst);

net/bridge/br_netfilter_ipv6.c

148

skb_dst_set_noref(skb, &rt->dst);

net/bridge/br_nf_core.c

24

static void fake_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/bridge/br_nf_core.c

30

static void fake_redirect(struct dst_entry *dst, struct sock *sk,

net/bridge/br_nf_core.c

35

static u32 *fake_cow_metrics(struct dst_entry *dst, unsigned long old)

net/bridge/br_nf_core.c

40

static struct neighbour *fake_neigh_lookup(const struct dst_entry *dst,

net/bridge/br_nf_core.c

47

static unsigned int fake_mtu(const struct dst_entry *dst)

net/bridge/br_nf_core.c

49

return dst->dev->mtu;

net/bridge/br_nf_core.c

72

rcuref_init(&rt->dst.__rcuref, 1);

net/bridge/br_nf_core.c

73

rt->dst.dev = br->dev;

net/bridge/br_nf_core.c

74

dst_init_metrics(&rt->dst, br->metrics, false);

net/bridge/br_nf_core.c

75

dst_metric_set(&rt->dst, RTAX_MTU, br->dev->mtu);

net/bridge/br_nf_core.c

76

rt->dst.flags = DST_NOXFRM | DST_FAKE_RTABLE;

net/bridge/br_nf_core.c

77

rt->dst.ops = &fake_dst_ops;

net/bridge/br_private.h

1632

struct net_bridge_port *dst,

net/bridge/br_private.h

1804

struct net_bridge_port *dst,

net/bridge/br_private.h

292

struct net_bridge_port *dst;

net/bridge/br_private.h

999

br_mdb_ip_get(struct net_bridge *br, struct br_ip *dst);

net/bridge/br_switchdev.c

133

const struct net_bridge_port *p = READ_ONCE(fdb->dst);

net/bridge/br_switchdev.c

539

ip_eth_mc_map(mp->addr.dst.ip4, mdb->addr);

net/bridge/br_switchdev.c

542

ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb->addr);

net/bridge/br_switchdev.c

545

ether_addr_copy(mdb->addr, mp->addr.dst.mac_addr);

net/bridge/br_vlan.c

1475

struct net_bridge_port *dst,

net/bridge/br_vlan.c

1484

vg = nbp_vlan_group_rcu(dst);

net/bridge/br_vlan_tunnel.c

220

skb_dst_set(skb, &tunnel_dst->dst);

net/bridge/br_vlan_tunnel.c

226

if (tunnel_dst && dst_hold_safe(&tunnel_dst->dst))

net/bridge/br_vlan_tunnel.c

227

skb_dst_set(skb, &tunnel_dst->dst);

net/bridge/br_vlan_tunnel.c

50

dst_release(&tdst->dst);

net/bridge/netfilter/ebt_ip.c

26

__be16 dst;

net/bridge/netfilter/ebt_ip.c

75

u32 dst = ntohs(pptr->tcpudphdr.dst);

net/bridge/netfilter/ebt_ip.c

77

dst < info->dport[0] ||

net/bridge/netfilter/ebt_ip.c

78

dst > info->dport[1]))

net/bridge/netfilter/ebt_ip6.c

29

__be16 dst;

net/bridge/netfilter/ebt_ip6.c

82

u16 dst = ntohs(pptr->tcpudphdr.dst);

net/bridge/netfilter/ebt_ip6.c

84

dst < info->dport[0] ||

net/bridge/netfilter/ebt_ip6.c

85

dst > info->dport[1]))

net/bridge/netfilter/ebt_log.c

42

__be16 dst;

net/bridge/netfilter/ebt_log.c

69

pr_cont(" SPT=%u DPT=%u", ntohs(pptr->src), ntohs(pptr->dst));

net/bridge/netfilter/ebt_mark.c

62

static void mark_tg_compat_from_user(void *dst, const void *src)

net/bridge/netfilter/ebt_mark.c

65

struct ebt_mark_t_info *kern = dst;

net/bridge/netfilter/ebt_mark.c

71

static int mark_tg_compat_to_user(void __user *dst, const void *src)

net/bridge/netfilter/ebt_mark.c

73

struct compat_ebt_mark_t_info __user *user = dst;

net/bridge/netfilter/ebt_mark_m.c

46

static void mark_mt_compat_from_user(void *dst, const void *src)

net/bridge/netfilter/ebt_mark_m.c

49

struct ebt_mark_m_info *kern = dst;

net/bridge/netfilter/ebt_mark_m.c

57

static int mark_mt_compat_to_user(void __user *dst, const void *src)

net/bridge/netfilter/ebt_mark_m.c

59

struct compat_ebt_mark_m_info __user *user = dst;

net/bridge/netfilter/ebtables.c

1963

void *dst = NULL;

net/bridge/netfilter/ebtables.c

1971

dst = state->buf_kern_start + state->buf_kern_offset;

net/bridge/netfilter/ebtables.c

1981

if (dst) {

net/bridge/netfilter/ebtables.c

1983

match->compat_from_user(dst, mwt->data);

net/bridge/netfilter/ebtables.c

1985

memcpy(dst, mwt->data, match_size);

net/bridge/netfilter/ebtables.c

2001

if (dst) {

net/bridge/netfilter/ebtables.c

2003

wt->compat_from_user(dst, mwt->data);

net/bridge/netfilter/ebtables.c

2005

memcpy(dst, mwt->data, match_size);

net/bridge/netfilter/ebtables.c

2020

if (pad > 0 && dst) {

net/bridge/netfilter/ebtables.c

2025

memset(dst + size_kern, 0, pad);

net/bridge/netfilter/ebtables.c

60

static void ebt_standard_compat_from_user(void *dst, const void *src)

net/bridge/netfilter/ebtables.c

66

memcpy(dst, &v, sizeof(v));

net/bridge/netfilter/ebtables.c

69

static int ebt_standard_compat_to_user(void __user *dst, const void *src)

net/bridge/netfilter/ebtables.c

75

return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0;

net/caif/cfpkt_skbuff.c

291

struct sk_buff *dst = pkt_to_skb(dstpkt);

net/caif/cfpkt_skbuff.c

304

if (dst->tail + neededtailspace > dst->end) {

net/caif/cfpkt_skbuff.c

307

dstlen = skb_headlen(dst);

net/caif/cfpkt_skbuff.c

313

skb_put_data(tmp, dst->data, dstlen);

net/caif/cfpkt_skbuff.c

315

dst = tmp;

net/caif/cfpkt_skbuff.c

317

skb_put_data(dst, add->data, skb_headlen(add));

net/caif/cfpkt_skbuff.c

319

return skb_to_pkt(dst);

net/can/gw.c

1166

gwj->dst.dev = __dev_get_by_index(net, gwj->ccgw.dst_idx);

net/can/gw.c

1168

if (!gwj->dst.dev)

net/can/gw.c

1171

if (gwj->dst.dev->type != ARPHRD_CAN)

net/can/gw.c

1175

if (gwj->src.dev == gwj->dst.dev &&

net/can/gw.c

142

} dst;

net/can/gw.c

265

static void canframecpy(struct canfd_frame *dst, struct can_frame *src)

net/can/gw.c

272

dst->can_id = src->can_id;

net/can/gw.c

273

dst->len = src->len;

net/can/gw.c

274

*(u64 *)dst->data = *(u64 *)src->data;

net/can/gw.c

277

static void canfdframecpy(struct canfd_frame *dst, struct canfd_frame *src)

net/can/gw.c

284

dst->can_id = src->can_id;

net/can/gw.c

285

dst->flags = src->flags;

net/can/gw.c

286

dst->len = src->len;

net/can/gw.c

287

memcpy(dst->data, src->data, CANFD_MAX_DLEN);

net/can/gw.c

490

if (!(gwj->dst.dev->flags & IFF_UP)) {

net/can/gw.c

497

csx->can_iif == gwj->dst.dev->ifindex)

net/can/gw.c

534

nskb->dev = gwj->dst.dev;

net/can/gw.c

622

if (gwj->src.dev == dev || gwj->dst.dev == dev) {

net/ceph/armor.c

101

*dst++ = ((c & 3) << 6) | d;

net/ceph/armor.c

37

int ceph_armor(char *dst, const char *src, const char *end)

net/ceph/armor.c

46

*dst++ = encode_bits(a >> 2);

net/ceph/armor.c

49

*dst++ = encode_bits(((a & 3) << 4) | (b >> 4));

net/ceph/armor.c

5

int ceph_armor(char *dst, const char *src, const char *end);

net/ceph/armor.c

52

*dst++ = encode_bits(((b & 15) << 2) |

net/ceph/armor.c

54

*dst++ = encode_bits(c & 63);

net/ceph/armor.c

56

*dst++ = encode_bits((b & 15) << 2);

net/ceph/armor.c

57

*dst++ = '=';

net/ceph/armor.c

6

int ceph_unarmor(char *dst, const char *src, const char *end);

net/ceph/armor.c

60

*dst++ = encode_bits(((a & 3) << 4));

net/ceph/armor.c

61

*dst++ = '=';

net/ceph/armor.c

62

*dst++ = '=';

net/ceph/armor.c

68

*(dst++) = '\n';

net/ceph/armor.c

75

int ceph_unarmor(char *dst, const char *src, const char *end)

net/ceph/armor.c

95

*dst++ = (a << 2) | (b >> 4);

net/ceph/armor.c

98

*dst++ = ((b & 15) << 4) | (c >> 2);

net/ceph/ceph_common.c

353

static int get_secret(struct ceph_crypto_key *dst, const char *name,

net/ceph/ceph_common.c

388

err = ceph_crypto_key_clone(dst, ckey);

net/ceph/crypto.c

100

dst->type = src->type;

net/ceph/crypto.c

101

dst->created = src->created;

net/ceph/crypto.c

102

dst->len = src->len;

net/ceph/crypto.c

104

dst->key = kmemdup(src->key, src->len, GFP_NOIO);

net/ceph/crypto.c

105

if (!dst->key)

net/ceph/crypto.c

97

int ceph_crypto_key_clone(struct ceph_crypto_key *dst,

net/ceph/crypto.h

33

int ceph_crypto_key_clone(struct ceph_crypto_key *dst,

net/ceph/crypto.h

50

int ceph_armor(char *dst, const char *src, const char *end);

net/ceph/crypto.h

51

int ceph_unarmor(char *dst, const char *src, const char *end);

net/ceph/messenger_v2.c

812

struct scatterlist *src, struct scatterlist *dst,

net/ceph/messenger_v2.c

821

aead_request_set_crypt(con->v2.gcm_req, src, dst, src_len, (u8 *)nonce);

net/ceph/osd_client.c

1004

dst->alloc_hint.expected_object_size =

net/ceph/osd_client.c

1006

dst->alloc_hint.expected_write_size =

net/ceph/osd_client.c

1008

dst->alloc_hint.flags = cpu_to_le32(src->alloc_hint.flags);

net/ceph/osd_client.c

1012

dst->xattr.name_len = cpu_to_le32(src->xattr.name_len);

net/ceph/osd_client.c

1013

dst->xattr.value_len = cpu_to_le32(src->xattr.value_len);

net/ceph/osd_client.c

1014

dst->xattr.cmp_op = src->xattr.cmp_op;

net/ceph/osd_client.c

1015

dst->xattr.cmp_mode = src->xattr.cmp_mode;

net/ceph/osd_client.c

1021

dst->copy_from.snapid = cpu_to_le64(src->copy_from.snapid);

net/ceph/osd_client.c

1022

dst->copy_from.src_version =

net/ceph/osd_client.c

1024

dst->copy_from.flags = src->copy_from.flags;

net/ceph/osd_client.c

1025

dst->copy_from.src_fadvise_flags =

net/ceph/osd_client.c

1029

dst->assert_ver.unused = cpu_to_le64(0);

net/ceph/osd_client.c

1030

dst->assert_ver.ver = cpu_to_le64(src->assert_ver.ver);

net/ceph/osd_client.c

1040

dst->op = cpu_to_le16(src->op);

net/ceph/osd_client.c

1041

dst->flags = cpu_to_le32(src->flags);

net/ceph/osd_client.c

1042

dst->payload_len = cpu_to_le32(src->indata_len);

net/ceph/osd_client.c

966

static u32 osd_req_encode_op(struct ceph_osd_op *dst,

net/ceph/osd_client.c

978

dst->extent.offset = cpu_to_le64(src->extent.offset);

net/ceph/osd_client.c

979

dst->extent.length = cpu_to_le64(src->extent.length);

net/ceph/osd_client.c

980

dst->extent.truncate_size =

net/ceph/osd_client.c

982

dst->extent.truncate_seq =

net/ceph/osd_client.c

986

dst->cls.class_len = src->cls.class_len;

net/ceph/osd_client.c

987

dst->cls.method_len = src->cls.method_len;

net/ceph/osd_client.c

988

dst->cls.indata_len = cpu_to_le32(src->cls.indata_len);

net/ceph/osd_client.c

991

dst->watch.cookie = cpu_to_le64(src->watch.cookie);

net/ceph/osd_client.c

992

dst->watch.ver = cpu_to_le64(0);

net/ceph/osd_client.c

993

dst->watch.op = src->watch.op;

net/ceph/osd_client.c

994

dst->watch.gen = cpu_to_le32(src->watch.gen);

net/ceph/osd_client.c

999

dst->notify.cookie = cpu_to_le64(src->notify.cookie);

net/core/dev.c

11812

u64 *dst = (u64 *)stats64;

net/core/dev.c

11816

dst[i] = (unsigned long)atomic_long_read(&src[i]);

net/core/devmem.c

371

struct dst_entry *dst;

net/core/devmem.c

381

dst = __sk_dst_get(sk);

net/core/devmem.c

383

if (unlikely(!dst)) {

net/core/devmem.c

388

dst = __sk_dst_get(sk);

net/core/devmem.c

389

if (unlikely(!dst)) {

net/core/devmem.c

398

dst_dev = dst_dev_rcu(dst);

net/core/dst.c

100

static void dst_destroy(struct dst_entry *dst)

net/core/dst.c

107

if (dst->xfrm) {

net/core/dst.c

108

struct xfrm_dst *xdst = (struct xfrm_dst *) dst;

net/core/dst.c

113

if (dst->ops->destroy)

net/core/dst.c

114

dst->ops->destroy(dst);

net/core/dst.c

115

netdev_put(dst->dev, &dst->dev_tracker);

net/core/dst.c

117

lwtstate_put(dst->lwtstate);

net/core/dst.c

119

if (dst->flags & DST_METADATA)

net/core/dst.c

120

metadata_dst_free((struct metadata_dst *)dst);

net/core/dst.c

122

kmem_cache_free(dst->ops->kmem_cachep, dst);

net/core/dst.c

124

dst = child;

net/core/dst.c

125

if (dst)

net/core/dst.c

126

dst_release_immediate(dst);

net/core/dst.c

131

struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head);

net/core/dst.c

133

dst_destroy(dst);

net/core/dst.c

145

void dst_dev_put(struct dst_entry *dst)

net/core/dst.c

147

struct net_device *dev = dst->dev;

net/core/dst.c

149

WRITE_ONCE(dst->obsolete, DST_OBSOLETE_DEAD);

net/core/dst.c

150

if (dst->ops->ifdown)

net/core/dst.c

151

dst->ops->ifdown(dst, dev);

net/core/dst.c

152

WRITE_ONCE(dst->input, dst_discard);

net/core/dst.c

153

WRITE_ONCE(dst->output, dst_discard_out);

net/core/dst.c

154

rcu_assign_pointer(dst->dev_rcu, blackhole_netdev);

net/core/dst.c

155

netdev_ref_replace(dev, blackhole_netdev, &dst->dev_tracker,

net/core/dst.c

160

static void dst_count_dec(struct dst_entry *dst)

net/core/dst.c

162

if (!(dst->flags & DST_NOCOUNT))

net/core/dst.c

163

dst_entries_add(dst->ops, -1);

net/core/dst.c

166

void dst_release(struct dst_entry *dst)

net/core/dst.c

168

if (dst && rcuref_put(&dst->__rcuref)) {

net/core/dst.c

170

if (dst->flags & DST_METADATA) {

net/core/dst.c

171

struct metadata_dst *md_dst = (struct metadata_dst *)dst;

net/core/dst.c

177

dst_count_dec(dst);

net/core/dst.c

178

call_rcu_hurry(&dst->rcu_head, dst_destroy_rcu);

net/core/dst.c

183

void dst_release_immediate(struct dst_entry *dst)

net/core/dst.c

185

if (dst && rcuref_put(&dst->__rcuref)) {

net/core/dst.c

186

dst_count_dec(dst);

net/core/dst.c

187

dst_destroy(dst);

net/core/dst.c

192

u32 *dst_cow_metrics_generic(struct dst_entry *dst, unsigned long old)

net/core/dst.c

204

prev = cmpxchg(&dst->_metrics, old, new);

net/core/dst.c

222

void __dst_destroy_metrics_generic(struct dst_entry *dst, unsigned long old)

net/core/dst.c

227

prev = cmpxchg(&dst->_metrics, old, new);

net/core/dst.c

233

struct dst_entry *dst_blackhole_check(struct dst_entry *dst, u32 cookie)

net/core/dst.c

238

u32 *dst_blackhole_cow_metrics(struct dst_entry *dst, unsigned long old)

net/core/dst.c

243

struct neighbour *dst_blackhole_neigh_lookup(const struct dst_entry *dst,

net/core/dst.c

250

void dst_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/core/dst.c

257

void dst_blackhole_redirect(struct dst_entry *dst, struct sock *sk,

net/core/dst.c

263

unsigned int dst_blackhole_mtu(const struct dst_entry *dst)

net/core/dst.c

265

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

net/core/dst.c

267

return mtu ? : dst_dev(dst)->mtu;

net/core/dst.c

284

struct dst_entry *dst;

net/core/dst.c

286

dst = &md_dst->dst;

net/core/dst.c

287

dst_init(dst, &dst_blackhole_ops, NULL, DST_OBSOLETE_NONE,

net/core/dst.c

289

memset(dst + 1, 0, sizeof(*md_dst) + optslen - sizeof(*dst));

net/core/dst.c

47

void dst_init(struct dst_entry *dst, struct dst_ops *ops,

net/core/dst.c

51

dst->dev = dev;

net/core/dst.c

52

netdev_hold(dev, &dst->dev_tracker, GFP_ATOMIC);

net/core/dst.c

53

dst->ops = ops;

net/core/dst.c

54

dst_init_metrics(dst, dst_default_metrics.metrics, true);

net/core/dst.c

55

dst->expires = 0UL;

net/core/dst.c

57

dst->xfrm = NULL;

net/core/dst.c

59

dst->input = dst_discard;

net/core/dst.c

60

dst->output = dst_discard_out;

net/core/dst.c

61

dst->error = 0;

net/core/dst.c

62

dst->obsolete = initial_obsolete;

net/core/dst.c

63

dst->header_len = 0;

net/core/dst.c

64

dst->trailer_len = 0;

net/core/dst.c

66

dst->tclassid = 0;

net/core/dst.c

68

dst->lwtstate = NULL;

net/core/dst.c

69

rcuref_init(&dst->__rcuref, 1);

net/core/dst.c

70

INIT_LIST_HEAD(&dst->rt_uncached);

net/core/dst.c

71

dst->rt_uncached_list = NULL;

net/core/dst.c

72

dst->__use = 0;

net/core/dst.c

73

dst->lastuse = jiffies;

net/core/dst.c

74

dst->flags = flags;

net/core/dst.c

83

struct dst_entry *dst;

net/core/dst.c

90

dst = kmem_cache_alloc(ops->kmem_cachep, GFP_ATOMIC);

net/core/dst.c

91

if (!dst)

net/core/dst.c

94

dst_init(dst, ops, dev, initial_obsolete, flags);

net/core/dst.c

96

return dst;

net/core/dst_cache.c

103

void dst_cache_set_ip4(struct dst_cache *dst_cache, struct dst_entry *dst,

net/core/dst_cache.c

113

dst_cache_per_cpu_dst_set(idst, dst, 0);

net/core/dst_cache.c

120

void dst_cache_set_ip6(struct dst_cache *dst_cache, struct dst_entry *dst,

net/core/dst_cache.c

131

dst_cache_per_cpu_dst_set(idst, dst,

net/core/dst_cache.c

132

rt6_get_cookie(dst_rt6_info(dst)));

net/core/dst_cache.c

142

struct dst_entry *dst;

net/core/dst_cache.c

150

dst = dst_cache_per_cpu_get(dst_cache, idst);

net/core/dst_cache.c

151

if (!dst) {

net/core/dst_cache.c

158

return dst;

net/core/dst_cache.c

187

dst_release(per_cpu_ptr(dst_cache->cache, i)->dst);

net/core/dst_cache.c

19

struct dst_entry *dst;

net/core/dst_cache.c

203

struct dst_entry *dst = idst->dst;

net/core/dst_cache.c

206

idst->dst = NULL;

net/core/dst_cache.c

207

dst_release(dst);

net/core/dst_cache.c

29

struct dst_entry *dst, u32 cookie)

net/core/dst_cache.c

32

dst_release(dst_cache->dst);

net/core/dst_cache.c

33

if (dst)

net/core/dst_cache.c

34

dst_hold(dst);

net/core/dst_cache.c

37

dst_cache->dst = dst;

net/core/dst_cache.c

43

struct dst_entry *dst;

net/core/dst_cache.c

46

dst = idst->dst;

net/core/dst_cache.c

47

if (!dst)

net/core/dst_cache.c

51

dst_hold(dst);

net/core/dst_cache.c

55

(READ_ONCE(dst->obsolete) && !dst->ops->check(dst, idst->cookie)))) {

net/core/dst_cache.c

57

dst_release(dst);

net/core/dst_cache.c

60

return dst;

net/core/dst_cache.c

69

struct dst_entry *dst;

net/core/dst_cache.c

75

dst = dst_cache_per_cpu_get(dst_cache, this_cpu_ptr(dst_cache->cache));

net/core/dst_cache.c

77

return dst;

net/core/dst_cache.c

84

struct dst_entry *dst;

net/core/dst_cache.c

91

dst = dst_cache_per_cpu_get(dst_cache, idst);

net/core/dst_cache.c

92

if (!dst) {

net/core/dst_cache.c

99

return dst_rtable(dst);

net/core/filter.c

106

memset(dst, 0, sizeof(*dst));

net/core/filter.c

107

dst->len = f32.len;

net/core/filter.c

108

dst->filter = compat_ptr(f32.filter);

net/core/filter.c

110

if (len != sizeof(*dst))

net/core/filter.c

112

if (copy_from_sockptr(dst, src, sizeof(*dst)))

net/core/filter.c

2214

struct dst_entry *dst = NULL;

net/core/filter.c

2236

dst = skb_dst(skb);

net/core/filter.c

2237

nexthop = rt6_nexthop(dst_rt6_info(dst),

net/core/filter.c

2256

if (dst)

net/core/filter.c

2257

IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);

net/core/filter.c

2271

struct dst_entry *dst;

net/core/filter.c

2282

dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &fl6, NULL);

net/core/filter.c

2283

if (IS_ERR(dst))

net/core/filter.c

2287

skb_dst_set(skb, dst);

net/core/filter.c

2400

skb_dst_set(skb, &rt->dst);

net/core/filter.c

4018

void *src, *dst;

net/core/filter.c

4023

dst = flush ? xdp->data + off : buf;

net/core/filter.c

4024

memcpy(dst, src, len);

net/core/filter.c

4041

dst = flush ? ptr_buf + copy_off : buf;

net/core/filter.c

4042

memcpy(dst, src, copy_len);

net/core/filter.c

4779

memcpy(to->local_ipv6, &info->key.u.ipv6.dst,

net/core/filter.c

4785

to->local_ipv4 = be32_to_cpu(info->key.u.ipv4.dst);

net/core/filter.c

4901

memcpy(&info->key.u.ipv6.dst, from->remote_ipv6,

net/core/filter.c

4908

info->key.u.ipv4.dst = cpu_to_be32(from->remote_ipv4);

net/core/filter.c

5090

static unsigned long bpf_xdp_copy(void *dst, const void *ctx,

net/core/filter.c

5095

bpf_xdp_copy_buf(xdp, off, dst, len, false);

net/core/filter.c

6212

struct in6_addr *dst = (struct in6_addr *)params->ipv6_dst;

net/core/filter.c

6215

*dst = nhc->nhc_gw.ipv6;

net/core/filter.c

6242

struct in6_addr *dst = (struct in6_addr *) params->ipv6_dst;

net/core/filter.c

6253

if (rt6_need_strict(dst) || rt6_need_strict(src))

net/core/filter.c

6278

fl6.daddr = *dst;

net/core/filter.c

6333

mtu = ipv6_stub->ip6_mtu_from_fib6(&res, dst, src);

net/core/filter.c

6344

*dst = res.nh->fib_nh_gw6;

net/core/filter.c

6368

neigh = __ipv6_neigh_lookup_noref_stub(dev, dst);

net/core/filter.c

97

int copy_bpf_fprog_from_user(struct sock_fprog *dst, sockptr_t src, int len)

net/core/flow_dissector.c

1221

memcpy(&key_addrs->v4addrs.dst, &iph->daddr,

net/core/flow_dissector.c

1222

sizeof(key_addrs->v4addrs.dst));

net/core/flow_dissector.c

1268

memcpy(&key_addrs->v6addrs.dst, &iph->daddr,

net/core/flow_dissector.c

1269

sizeof(key_addrs->v6addrs.dst));

net/core/flow_dissector.c

1754

return flow->addrs.v4addrs.dst;

net/core/flow_dissector.c

1757

&flow->addrs.v6addrs.dst);

net/core/flow_dissector.c

1773

if ((__force u32)keys->addrs.v4addrs.dst <

net/core/flow_dissector.c

1775

swap(keys->addrs.v4addrs.src, keys->addrs.v4addrs.dst);

net/core/flow_dissector.c

1777

if ((__force u16)keys->ports.dst <

net/core/flow_dissector.c

1779

swap(keys->ports.src, keys->ports.dst);

net/core/flow_dissector.c

1783

addr_diff = memcmp(&keys->addrs.v6addrs.dst,

net/core/flow_dissector.c

1785

sizeof(keys->addrs.v6addrs.dst));

net/core/flow_dissector.c

1789

keys->addrs.v6addrs.dst.s6_addr32[i]);

net/core/flow_dissector.c

1791

if ((__force u16)keys->ports.dst <

net/core/flow_dissector.c

1793

swap(keys->ports.src, keys->ports.dst);

net/core/flow_dissector.c

1844

__be32 dst;

net/core/flow_dissector.c

1861

data->dst = flow->addrs.v4addrs.dst;

net/core/flow_dissector.c

1996

memcpy(&keys->addrs.v6addrs.dst, &fl6->daddr,

net/core/flow_dissector.c

1997

sizeof(keys->addrs.v6addrs.dst));

net/core/flow_dissector.c

2000

keys->ports.dst = fl6->fl6_dport;

net/core/flow_dissector.c

419

ipv4->dst = key->u.ipv4.dst;

net/core/flow_dissector.c

434

ipv6->dst = key->u.ipv6.dst;

net/core/flow_dissector.c

459

tp->dst = key->tp_dst;

net/core/flow_dissector.c

964

key_addrs->v4addrs.dst = flow_keys->ipv4_dst;

net/core/flow_dissector.c

974

memcpy(&key_addrs->v6addrs.dst, &flow_keys->ipv6_dst,

net/core/flow_dissector.c

975

sizeof(key_addrs->v6addrs.dst));

net/core/flow_dissector.c

984

key_ports->dst = flow_keys->dport;

net/core/flow_dissector.c

992

key_ports_range->tp.dst = flow_keys->dport;

net/core/lwt_bpf.c

122

struct dst_entry *dst = skb_dst(skb);

net/core/lwt_bpf.c

126

bpf = bpf_lwt_lwtunnel(dst->lwtstate);

net/core/lwt_bpf.c

128

ret = run_lwt_bpf(skb, &bpf->in, dst, NO_REDIRECT);

net/core/lwt_bpf.c

135

if (unlikely(!dst->lwtstate->orig_input)) {

net/core/lwt_bpf.c

140

return dst->lwtstate->orig_input(skb);

net/core/lwt_bpf.c

145

struct dst_entry *dst = skb_dst(skb);

net/core/lwt_bpf.c

149

bpf = bpf_lwt_lwtunnel(dst->lwtstate);

net/core/lwt_bpf.c

151

ret = run_lwt_bpf(skb, &bpf->out, dst, NO_REDIRECT);

net/core/lwt_bpf.c

156

if (unlikely(!dst->lwtstate->orig_output)) {

net/core/lwt_bpf.c

163

return dst->lwtstate->orig_output(net, sk, skb);

net/core/lwt_bpf.c

182

struct dst_entry *dst = NULL;

net/core/lwt_bpf.c

223

dst = &rt->dst;

net/core/lwt_bpf.c

236

dst = ipv6_stub->ipv6_dst_lookup_flow(net, skb->sk, &fl6, NULL);

net/core/lwt_bpf.c

237

if (IS_ERR(dst)) {

net/core/lwt_bpf.c

238

err = PTR_ERR(dst);

net/core/lwt_bpf.c

242

if (unlikely(dst->error)) {

net/core/lwt_bpf.c

243

err = dst->error;

net/core/lwt_bpf.c

244

dst_release(dst);

net/core/lwt_bpf.c

253

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst->dev));

net/core/lwt_bpf.c

258

skb_dst_set(skb, dst);

net/core/lwt_bpf.c

274

struct dst_entry *dst = skb_dst(skb);

net/core/lwt_bpf.c

277

bpf = bpf_lwt_lwtunnel(dst->lwtstate);

net/core/lwt_bpf.c

279

int hh_len = dst->dev->hard_header_len;

net/core/lwt_bpf.c

283

ret = run_lwt_bpf(skb, &bpf->xmit, dst, CAN_REDIRECT);

net/core/lwt_bpf.c

41

struct dst_entry *dst, bool can_redirect)

net/core/lwtunnel.c

324

struct dst_entry *dst;

net/core/lwtunnel.c

336

dst = skb_dst(skb);

net/core/lwtunnel.c

337

if (!dst) {

net/core/lwtunnel.c

341

lwtstate = dst->lwtstate;

net/core/lwtunnel.c

377

struct dst_entry *dst;

net/core/lwtunnel.c

389

dst = skb_dst(skb);

net/core/lwtunnel.c

390

if (!dst) {

net/core/lwtunnel.c

395

lwtstate = dst->lwtstate;

net/core/lwtunnel.c

431

struct dst_entry *dst;

net/core/lwtunnel.c

443

dst = skb_dst(skb);

net/core/lwtunnel.c

444

if (!dst) {

net/core/lwtunnel.c

448

lwtstate = dst->lwtstate;

net/core/neighbour.c

1322

struct dst_entry *dst = skb_dst(skb);

net/core/neighbour.c

1337

if (dst &&

net/core/neighbour.c

1338

READ_ONCE(dst->obsolete) != DST_OBSOLETE_DEAD) {

net/core/neighbour.c

1339

n2 = dst_neigh_lookup_skb(dst, skb);

net/core/neighbour.c

2029

void *dst, *lladdr;

net/core/neighbour.c

2078

dst = nla_data(tb[NDA_DST]);

net/core/neighbour.c

2089

err = pneigh_create(tbl, net, dst, dev, ndm_flags, protocol,

net/core/neighbour.c

2104

neigh = neigh_lookup(tbl, dst, dev);

net/core/neighbour.c

2137

neigh = ___neigh_create(tbl, dst, dev,

net/core/neighbour.c

3076

void *dst;

net/core/neighbour.c

3105

dst = nla_data(tb[NDA_DST]);

net/core/neighbour.c

3119

pn = pneigh_lookup(tbl, net, dst, dev);

net/core/neighbour.c

3130

neigh = neigh_lookup(tbl, dst, dev);

net/core/pktgen.c

2717

skb->_skb_refdst = (unsigned long)&pkt_dev->xdst.u.dst | SKB_DST_NOREF;

net/core/pktgen.c

3897

pkt_dev->xdst.u.dst.dev = pkt_dev->odev;

net/core/pktgen.c

3898

dst_init_metrics(&pkt_dev->xdst.u.dst, pktgen_dst_metrics, false);

net/core/pktgen.c

3899

pkt_dev->xdst.child = &pkt_dev->xdst.u.dst;

net/core/pktgen.c

3900

pkt_dev->xdst.u.dst.ops = &pkt_dev->dstops;

net/core/rtnetlink.c

1028

int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,

net/core/rtnetlink.c

1037

if (dst) {

net/core/rtnetlink.c

1038

delta = jiffies - READ_ONCE(dst->lastuse);

net/core/rtnetlink.c

1040

ci.rta_used = dst->__use;

net/core/rtnetlink.c

1041

ci.rta_clntref = rcuref_read(&dst->__rcuref);

net/core/selftests.c

166

const unsigned char *dst = tpriv->packet->dst;

net/core/selftests.c

183

if (dst) {

net/core/selftests.c

184

if (!ether_addr_equal_unaligned(ehdr->h_dest, dst))

net/core/selftests.c

316

attr.dst = ndev->dev_addr;

net/core/selftests.c

324

attr.dst = ndev->dev_addr;

net/core/selftests.c

333

attr.dst = ndev->dev_addr;

net/core/selftests.c

368

attr.dst = ndev->dev_addr;

net/core/selftests.c

62

if (attr->dst)

net/core/selftests.c

63

ether_addr_copy(ehdr->h_dest, attr->dst);

net/core/skbuff.c

1676

struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src)

net/core/skbuff.c

1678

skb_release_all(dst, SKB_CONSUMED);

net/core/skbuff.c

1679

return __skb_clone(dst, src);

net/core/skbuff.c

6526

int skb_eth_push(struct sk_buff *skb, const unsigned char *dst,

net/core/skbuff.c

6544

ether_addr_copy(eth->h_dest, dst);

net/core/skmsg.c

110

if (dst->sg.end)

net/core/skmsg.c

111

sgd = sk_msg_elem(dst, dst->sg.end - 1);

net/core/skmsg.c

117

dst->sg.size += sge_len;

net/core/skmsg.c

118

} else if (!sk_msg_full(dst)) {

net/core/skmsg.c

120

sk_msg_page_add(dst, sg_page(sge), sge_len, sge_off);

net/core/skmsg.c

87

int sk_msg_clone(struct sock *sk, struct sk_msg *dst, struct sk_msg *src,

net/core/sock.c

1710

static int groups_to_user(sockptr_t dst, const struct group_info *src)

net/core/sock.c

1718

if (copy_to_sockptr_offset(dst, i * sizeof(gid), &gid, sizeof(gid)))

net/core/sock.c

2626

void sk_setup_caps(struct sock *sk, struct dst_entry *dst)

net/core/sock.c

2632

dev = dst_dev_rcu(dst);

net/core/sock.c

2638

icsk->icsk_ack.dst_quick_ack = dst_metric(dst, RTAX_QUICKACK);

net/core/sock.c

2645

if (dst->header_len && !xfrm_dst_offload_ok(dst)) {

net/core/sock.c

2655

sk_dst_set(sk, dst);

net/core/sock.c

609

struct dst_entry *dst = __sk_dst_get(sk);

net/core/sock.c

611

if (dst && READ_ONCE(dst->obsolete) &&

net/core/sock.c

612

INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check, ipv4_dst_check,

net/core/sock.c

613

dst, cookie) == NULL) {

net/core/sock.c

617

dst_release(dst);

net/core/sock.c

621

return dst;

net/core/sock.c

627

struct dst_entry *dst = sk_dst_get(sk);

net/core/sock.c

629

if (dst && READ_ONCE(dst->obsolete) &&

net/core/sock.c

630

INDIRECT_CALL_INET(dst->ops->check, ip6_dst_check, ipv4_dst_check,

net/core/sock.c

631

dst, cookie) == NULL) {

net/core/sock.c

633

dst_release(dst);

net/core/sock.c

637

return dst;

net/core/utils.c

120

u8 *dst,

net/core/utils.c

165

memcpy(dst, dbuf, sizeof(dbuf));

net/core/utils.c

186

u8 *dst,

net/core/utils.c

286

dst[i--] = *d--;

net/core/utils.c

288

dst[i--] = 0;

net/core/utils.c

290

dst[i--] = *d--;

net/core/utils.c

292

memcpy(dst, dbuf, sizeof(dbuf));

net/dsa/conduit.c

114

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/conduit.c

124

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/conduit.c

176

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/conduit.c

190

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/conduit.c

239

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/conduit.c

258

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/conduit.c

281

struct dsa_switch_tree *dst;

net/dsa/conduit.c

284

dst = ds->dst;

net/dsa/conduit.c

286

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/conduit.c

395

err = dsa_tree_change_tag_proto(cpu_dp->ds->dst, new_tag_ops,

net/dsa/devlink.c

305

struct dsa_switch_tree *dst = dp->ds->dst;

net/dsa/devlink.c

322

id = (const unsigned char *)&dst->index;

net/dsa/devlink.c

323

len = sizeof(dst->index);

net/dsa/dsa.c

1008

err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);

net/dsa/dsa.c

1012

err = dsa_tree_bind_tag_proto(dst, tag_ops);

net/dsa/dsa.c

1022

dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);

net/dsa/dsa.c

1028

static void dsa_tree_conduit_state_change(struct dsa_switch_tree *dst,

net/dsa/dsa.c

1037

dsa_tree_notify(dst, DSA_NOTIFIER_CONDUIT_STATE_CHANGE, &info);

net/dsa/dsa.c

1040

void dsa_tree_conduit_admin_state_change(struct dsa_switch_tree *dst,

net/dsa/dsa.c

105

struct dsa_lag *dsa_tree_lag_find(struct dsa_switch_tree *dst,

net/dsa/dsa.c

1060

dsa_tree_conduit_state_change(dst, conduit);

net/dsa/dsa.c

1063

void dsa_tree_conduit_oper_state_change(struct dsa_switch_tree *dst,

net/dsa/dsa.c

1083

dsa_tree_conduit_state_change(dst, conduit);

net/dsa/dsa.c

1088

struct dsa_switch_tree *dst = ds->dst;

net/dsa/dsa.c

110

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

1108

list_add_tail(&dp->list, &dst->ports);

net/dsa/dsa.c

1159

struct dsa_switch_tree *dst = ds->dst;

net/dsa/dsa.c

1164

if (dst->default_proto) {

net/dsa/dsa.c

1165

if (dst->default_proto != default_proto) {

net/dsa/dsa.c

117

struct dsa_bridge *dsa_tree_bridge_find(struct dsa_switch_tree *dst,

net/dsa/dsa.c

1171

dst->default_proto = default_proto;

net/dsa/dsa.c

1201

if (dst->tag_ops) {

net/dsa/dsa.c

1202

if (dst->tag_ops != tag_ops) {

net/dsa/dsa.c

1215

dst->tag_ops = tag_ops;

net/dsa/dsa.c

122

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

1220

dsa_port_set_tag_protocol(dp, dst->tag_ops);

net/dsa/dsa.c

1221

dp->dst = dst;

net/dsa/dsa.c

131

struct dsa_switch_tree *dst;

net/dsa/dsa.c

133

list_for_each_entry(dst, &dsa_tree_list, list) {

net/dsa/dsa.c

1337

ds->dst = dsa_tree_touch(m[0]);

net/dsa/dsa.c

1338

if (!ds->dst)

net/dsa/dsa.c

1341

if (dsa_switch_find(ds->dst->index, ds->index)) {

net/dsa/dsa.c

1344

ds->index, ds->dst->index);

net/dsa/dsa.c

1348

if (ds->dst->last_switch < ds->index)

net/dsa/dsa.c

1349

ds->dst->last_switch = ds->index;

net/dsa/dsa.c

136

bridge = dsa_tree_bridge_find(dst, bridge_dev);

net/dsa/dsa.c

1474

ds->dst = dsa_tree_touch(0);

net/dsa/dsa.c

1475

if (!ds->dst)

net/dsa/dsa.c

1535

struct dsa_switch_tree *dst;

net/dsa/dsa.c

1564

dst = ds->dst;

net/dsa/dsa.c

1565

dsa_tree_get(dst);

net/dsa/dsa.c

1566

err = dsa_tree_setup(dst);

net/dsa/dsa.c

1569

dsa_tree_put(dst);

net/dsa/dsa.c

1581

dsa_tree_put(ds->dst);

net/dsa/dsa.c

1590

struct dsa_switch_tree *dst = ds->dst;

net/dsa/dsa.c

1592

dsa_tree_teardown(dst);

net/dsa/dsa.c

1594

dsa_tree_put(dst);

net/dsa/dsa.c

182

struct dsa_switch_tree *dst;

net/dsa/dsa.c

185

list_for_each_entry(dst, &dsa_tree_list, list) {

net/dsa/dsa.c

186

if (dst->index != tree_index)

net/dsa/dsa.c

189

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

203

struct dsa_switch_tree *dst;

net/dsa/dsa.c

205

list_for_each_entry(dst, &dsa_tree_list, list)

net/dsa/dsa.c

206

if (dst->index == index)

net/dsa/dsa.c

207

return dst;

net/dsa/dsa.c

214

struct dsa_switch_tree *dst;

net/dsa/dsa.c

216

dst = kzalloc_obj(*dst);

net/dsa/dsa.c

217

if (!dst)

net/dsa/dsa.c

220

dst->index = index;

net/dsa/dsa.c

222

INIT_LIST_HEAD(&dst->rtable);

net/dsa/dsa.c

224

INIT_LIST_HEAD(&dst->ports);

net/dsa/dsa.c

226

INIT_LIST_HEAD(&dst->list);

net/dsa/dsa.c

227

list_add_tail(&dst->list, &dsa_tree_list);

net/dsa/dsa.c

229

kref_init(&dst->refcount);

net/dsa/dsa.c

231

return dst;

net/dsa/dsa.c

234

static void dsa_tree_free(struct dsa_switch_tree *dst)

net/dsa/dsa.c

236

if (dst->tag_ops)

net/dsa/dsa.c

237

dsa_tag_driver_put(dst->tag_ops);

net/dsa/dsa.c

238

list_del(&dst->list);

net/dsa/dsa.c

239

kfree(dst);

net/dsa/dsa.c

242

static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)

net/dsa/dsa.c

244

if (dst)

net/dsa/dsa.c

245

kref_get(&dst->refcount);

net/dsa/dsa.c

247

return dst;

net/dsa/dsa.c

252

struct dsa_switch_tree *dst;

net/dsa/dsa.c

254

dst = dsa_tree_find(index);

net/dsa/dsa.c

255

if (dst)

net/dsa/dsa.c

256

return dsa_tree_get(dst);

net/dsa/dsa.c

263

struct dsa_switch_tree *dst;

net/dsa/dsa.c

265

dst = container_of(ref, struct dsa_switch_tree, refcount);

net/dsa/dsa.c

267

dsa_tree_free(dst);

net/dsa/dsa.c

270

static void dsa_tree_put(struct dsa_switch_tree *dst)

net/dsa/dsa.c

272

if (dst)

net/dsa/dsa.c

273

kref_put(&dst->refcount, dsa_tree_release);

net/dsa/dsa.c

276

static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,

net/dsa/dsa.c

281

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

292

struct dsa_switch_tree *dst;

net/dsa/dsa.c

295

dst = ds->dst;

net/dsa/dsa.c

297

list_for_each_entry(dl, &dst->rtable, list)

net/dsa/dsa.c

309

list_add_tail(&dl->list, &dst->rtable);

net/dsa/dsa.c

317

struct dsa_switch_tree *dst = ds->dst;

net/dsa/dsa.c

325

link_dp = dsa_tree_find_port_by_node(dst, it.node);

net/dsa/dsa.c

341

static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)

net/dsa/dsa.c

346

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

357

static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)

net/dsa/dsa.c

361

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

368

struct net_device *dsa_tree_find_first_conduit(struct dsa_switch_tree *dst)

net/dsa/dsa.c

372

cpu_dp = dsa_tree_find_first_cpu(dst);

net/dsa/dsa.c

379

static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)

net/dsa/dsa.c

383

cpu_dp = dsa_tree_find_first_cpu(dst);

net/dsa/dsa.c

385

pr_err("DSA: tree %d has no CPU port\n", dst->index);

net/dsa/dsa.c

389

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

423

static int dsa_tree_setup_cpu_ports(struct dsa_switch_tree *dst)

net/dsa/dsa.c

427

list_for_each_entry(cpu_dp, &dst->ports, list) {

net/dsa/dsa.c

446

return dsa_tree_setup_default_cpu(dst);

net/dsa/dsa.c

449

static void dsa_tree_teardown_cpu_ports(struct dsa_switch_tree *dst)

net/dsa/dsa.c

453

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

571

const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;

net/dsa/dsa.c

572

struct dsa_switch_tree *dst = ds->dst;

net/dsa/dsa.c

575

if (tag_ops->proto == dst->default_proto)

net/dsa/dsa.c

615

const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;

net/dsa/dsa.c

64

void dsa_lag_map(struct dsa_switch_tree *dst, struct dsa_lag *lag)

net/dsa/dsa.c

68

for (id = 1; id <= dst->lags_len; id++) {

net/dsa/dsa.c

69

if (!dsa_lag_by_id(dst, id)) {

net/dsa/dsa.c

70

dst->lags[id - 1] = lag;

net/dsa/dsa.c

714

static void dsa_tree_teardown_ports(struct dsa_switch_tree *dst)

net/dsa/dsa.c

718

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

724

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

729

static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)

net/dsa/dsa.c

733

list_for_each_entry(dp, &dst->ports, list)

net/dsa/dsa.c

738

static int dsa_tree_setup_ports(struct dsa_switch_tree *dst)

net/dsa/dsa.c

743

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

751

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

765

dsa_tree_teardown_ports(dst);

net/dsa/dsa.c

770

static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)

net/dsa/dsa.c

775

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

778

dsa_tree_teardown_switches(dst);

net/dsa/dsa.c

786

static int dsa_tree_setup_conduit(struct dsa_switch_tree *dst)

net/dsa/dsa.c

793

dsa_tree_for_each_cpu_port(cpu_dp, dst) {

net/dsa/dsa.c

803

dsa_tree_conduit_admin_state_change(dst, conduit, admin_up);

net/dsa/dsa.c

804

dsa_tree_conduit_oper_state_change(dst, conduit,

net/dsa/dsa.c

813

static void dsa_tree_teardown_conduit(struct dsa_switch_tree *dst)

net/dsa/dsa.c

819

dsa_tree_for_each_cpu_port(cpu_dp, dst) {

net/dsa/dsa.c

826

dsa_tree_conduit_admin_state_change(dst, conduit, false);

net/dsa/dsa.c

834

static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)

net/dsa/dsa.c

839

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/dsa.c

847

dst->lags = kzalloc_objs(*dst->lags, len);

net/dsa/dsa.c

848

if (!dst->lags)

net/dsa/dsa.c

851

dst->lags_len = len;

net/dsa/dsa.c

855

static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)

net/dsa/dsa.c

857

kfree(dst->lags);

net/dsa/dsa.c

860

static void dsa_tree_teardown_routing_table(struct dsa_switch_tree *dst)

net/dsa/dsa.c

864

list_for_each_entry_safe(dl, next, &dst->rtable, list) {

net/dsa/dsa.c

870

static int dsa_tree_setup(struct dsa_switch_tree *dst)

net/dsa/dsa.c

875

if (dst->setup) {

net/dsa/dsa.c

877

dst->index);

net/dsa/dsa.c

881

complete = dsa_tree_setup_routing_table(dst);

net/dsa/dsa.c

885

err = dsa_tree_setup_cpu_ports(dst);

net/dsa/dsa.c

889

err = dsa_tree_setup_switches(dst);

net/dsa/dsa.c

893

err = dsa_tree_setup_ports(dst);

net/dsa/dsa.c

897

err = dsa_tree_setup_conduit(dst);

net/dsa/dsa.c

901

err = dsa_tree_setup_lags(dst);

net/dsa/dsa.c

905

dst->setup = true;

net/dsa/dsa.c

907

pr_info("DSA: tree %d setup\n", dst->index);

net/dsa/dsa.c

912

dsa_tree_teardown_conduit(dst);

net/dsa/dsa.c

914

dsa_tree_teardown_ports(dst);

net/dsa/dsa.c

916

dsa_tree_teardown_switches(dst);

net/dsa/dsa.c

918

dsa_tree_teardown_cpu_ports(dst);

net/dsa/dsa.c

92

void dsa_lag_unmap(struct dsa_switch_tree *dst, struct dsa_lag *lag)

net/dsa/dsa.c

920

dsa_tree_teardown_routing_table(dst);

net/dsa/dsa.c

925

static void dsa_tree_teardown(struct dsa_switch_tree *dst)

net/dsa/dsa.c

927

if (!dst->setup)

net/dsa/dsa.c

930

dsa_tree_teardown_lags(dst);

net/dsa/dsa.c

932

dsa_tree_teardown_conduit(dst);

net/dsa/dsa.c

934

dsa_tree_teardown_ports(dst);

net/dsa/dsa.c

936

dsa_tree_teardown_switches(dst);

net/dsa/dsa.c

938

dsa_tree_teardown_cpu_ports(dst);

net/dsa/dsa.c

940

dsa_tree_teardown_routing_table(dst);

net/dsa/dsa.c

942

pr_info("DSA: tree %d torn down\n", dst->index);

net/dsa/dsa.c

944

dst->setup = false;

net/dsa/dsa.c

947

static int dsa_tree_bind_tag_proto(struct dsa_switch_tree *dst,

net/dsa/dsa.c

950

const struct dsa_device_ops *old_tag_ops = dst->tag_ops;

net/dsa/dsa.c

954

dst->tag_ops = tag_ops;

net/dsa/dsa.c

96

dsa_lags_foreach_id(id, dst) {

net/dsa/dsa.c

960

err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_CONNECT, &info);

net/dsa/dsa.c

966

dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info);

net/dsa/dsa.c

97

if (dsa_lag_by_id(dst, id) == lag) {

net/dsa/dsa.c

972

dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info);

net/dsa/dsa.c

973

dst->tag_ops = old_tag_ops;

net/dsa/dsa.c

98

dst->lags[id - 1] = NULL;

net/dsa/dsa.c

982

int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,

net/dsa/dsa.c

998

dsa_tree_for_each_user_port(dp, dst) {

net/dsa/dsa.h

20

void dsa_lag_map(struct dsa_switch_tree *dst, struct dsa_lag *lag);

net/dsa/dsa.h

21

void dsa_lag_unmap(struct dsa_switch_tree *dst, struct dsa_lag *lag);

net/dsa/dsa.h

22

struct dsa_lag *dsa_tree_lag_find(struct dsa_switch_tree *dst,

net/dsa/dsa.h

24

struct net_device *dsa_tree_find_first_conduit(struct dsa_switch_tree *dst);

net/dsa/dsa.h

25

int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,

net/dsa/dsa.h

28

void dsa_tree_conduit_admin_state_change(struct dsa_switch_tree *dst,

net/dsa/dsa.h

31

void dsa_tree_conduit_oper_state_change(struct dsa_switch_tree *dst,

net/dsa/dsa.h

37

struct dsa_bridge *dsa_tree_bridge_find(struct dsa_switch_tree *dst,

net/dsa/port.c

35

return dsa_tree_notify(dp->ds->dst, e, v);

net/dsa/port.c

427

bridge = dsa_tree_bridge_find(ds->dst, br);

net/dsa/port.c

613

lag = dsa_tree_lag_find(ds->dst, lag_dev);

net/dsa/port.c

628

dsa_lag_map(ds->dst, lag);

net/dsa/port.c

645

dsa_lag_unmap(dp->ds->dst, lag);

net/dsa/switch.c

101

info->dp->ds->dst->index,

net/dsa/switch.c

1084

int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v)

net/dsa/switch.c

1086

struct raw_notifier_head *nh = &dst->nh;

net/dsa/switch.c

1108

struct dsa_switch_tree *dst;

net/dsa/switch.c

1111

list_for_each_entry(dst, &dsa_tree_list, list) {

net/dsa/switch.c

1112

err = dsa_tree_notify(dst, e, v);

net/dsa/switch.c

1124

return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);

net/dsa/switch.c

1131

err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);

net/dsa/switch.c

120

ds->ops->crosschip_bridge_leave(ds, info->dp->ds->dst->index,

net/dsa/switch.h

117

int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v);

net/dsa/tag.h

194

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/tag.h

200

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/tag.h

36

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/tag.h

39

list_for_each_entry(dp, &dst->ports, list)

net/dsa/tag_8021q.c

478

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/tag_8021q.c

484

dsa_tree_for_each_user_port(dp, dst) {

net/dsa/tag_dsa.c

140

struct dsa_switch_tree *dst = dp->ds->dst;

net/dsa/tag_dsa.c

148

tag_dev = dst->last_switch + bridge_num;

net/dsa/tag_dsa.c

267

lag = dsa_lag_by_id(cpu_dp->dst, source_port + 1);

net/dsa/tag_ksz.c

70

ds->dst->index, ds->index);

net/dsa/tag_sja1105.c

538

ds = dsa_switch_find(cpu_dp->dst->index, switch_id);

net/dsa/tag_sja1105.c

711

ds->dst->index, ds->index);

net/dsa/user.c

2038

struct dsa_switch_tree *dst;

net/dsa/user.c

2054

list_for_each_entry(dst, &dsa_tree_list, list) {

net/dsa/user.c

2055

list_for_each_entry(other_dp, &dst->ports, list) {

net/dsa/user.c

2120

dsa_tree_for_each_user_port(other_dp, ds->dst) {

net/dsa/user.c

2826

ret, ds->dst->index, ds->index, port->index);

net/dsa/user.c

3348

static void dsa_tree_migrate_ports_from_lag_conduit(struct dsa_switch_tree *dst,

net/dsa/user.c

3351

struct net_device *new_conduit = dsa_tree_find_first_conduit(dst);

net/dsa/user.c

3355

dsa_tree_for_each_user_port(dp, dst) {

net/dsa/user.c

3374

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/user.c

3382

dsa_tree_for_each_user_port(dp, dst) {

net/dsa/user.c

3394

dsa_tree_for_each_user_port_continue_reverse(dp, dst) {

net/dsa/user.c

3415

struct dsa_switch_tree *dst = cpu_dp->dst;

net/dsa/user.c

3431

dsa_tree_for_each_user_port(dp, dst)

net/dsa/user.c

3444

dsa_tree_migrate_ports_from_lag_conduit(dst, lag_dev);

net/dsa/user.c

346

ds->dst->index, ds->index);

net/dsa/user.c

3561

struct dsa_switch_tree *dst = cpu_dp->ds->dst;

net/dsa/user.c

3564

dsa_tree_conduit_oper_state_change(dst, dev,

net/dsa/user.c

3575

dsa_tree_conduit_admin_state_change(dst, dev,

net/dsa/user.c

3585

struct dsa_switch_tree *dst;

net/dsa/user.c

3592

dst = cpu_dp->ds->dst;

net/dsa/user.c

3594

dsa_tree_conduit_admin_state_change(dst, dev, false);

net/dsa/user.c

3596

list_for_each_entry(dp, &dst->ports, list) {

net/dsa/user.c

3683

struct dsa_switch_tree *dst = dp->ds->dst;

net/dsa/user.c

3686

return !dsa_tree_offloads_bridge_dev(dst, foreign_dev);

net/dsa/user.c

3689

return !dsa_tree_offloads_bridge_port(dst, foreign_dev);

net/ethtool/bitset.c

128

static void ethnl_bitmap32_update(u32 *dst, unsigned int nbits,

net/ethtool/bitset.c

137

new_value = (*dst & ~real_mask) | (*value & real_mask);

net/ethtool/bitset.c

138

if (new_value != *dst) {

net/ethtool/bitset.c

139

*dst = new_value;

net/ethtool/bitset.c

145

dst++;

net/ethtool/bitset.c

250

u32 *dst;

net/ethtool/bitset.c

255

dst = nla_data(attr);

net/ethtool/bitset.c

256

memcpy(dst, val, nbytes);

net/ethtool/bitset.c

258

dst[nwords - 1] &= ethnl_lower_bits(nbits);

net/ethtool/bitset.c

264

dst = nla_data(attr);

net/ethtool/bitset.c

265

memcpy(dst, mask, nbytes);

net/ethtool/bitset.c

267

dst[nwords - 1] &= ethnl_lower_bits(nbits);

net/ethtool/bitset.c

34

static void ethnl_bitmap32_clear(u32 *dst, unsigned int start, unsigned int end,

net/ethtool/bitset.c

49

if (dst[start_word] & mask) {

net/ethtool/bitset.c

50

dst[start_word] &= ~mask;

net/ethtool/bitset.c

55

if (dst[start_word] & mask) {

net/ethtool/bitset.c

56

dst[start_word] &= ~mask;

net/ethtool/bitset.c

63

if (dst[i]) {

net/ethtool/bitset.c

64

dst[i] = 0;

net/ethtool/bitset.c

70

if (dst[end_word] & mask) {

net/ethtool/bitset.c

71

dst[end_word] &= ~mask;

net/ethtool/coalesce.c

440

struct dim_cq_moder __rcu **dst,

net/ethtool/coalesce.c

455

if (!*dst)

net/ethtool/coalesce.c

458

old_profile = rtnl_dereference(*dst);

net/ethtool/coalesce.c

500

rcu_assign_pointer(*dst, new_profile);

net/ethtool/ioctl.c

344

void ethtool_intersect_link_masks(struct ethtool_link_ksettings *dst,

net/ethtool/ioctl.c

351

dst->link_modes.supported[idx] &=

net/ethtool/ioctl.c

353

dst->link_modes.advertising[idx] &=

net/ethtool/ioctl.c

359

void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst,

net/ethtool/ioctl.c

362

linkmode_zero(dst);

net/ethtool/ioctl.c

363

dst[0] = legacy_u32;

net/ethtool/ioctl.c

3661

ether_addr_copy(match->key.eth_addrs.dst,

net/ethtool/ioctl.c

3663

ether_addr_copy(match->mask.eth_addrs.dst,

net/ethtool/ioctl.c

3686

match->key.ipv4.dst = v4_spec->ip4dst;

net/ethtool/ioctl.c

3687

match->mask.ipv4.dst = v4_m_spec->ip4dst;

net/ethtool/ioctl.c

3701

match->key.tp.dst = v4_spec->pdst;

net/ethtool/ioctl.c

3702

match->mask.tp.dst = v4_m_spec->pdst;

net/ethtool/ioctl.c

3736

memcpy(&match->key.ipv6.dst, v6_spec->ip6dst,

net/ethtool/ioctl.c

3737

sizeof(match->key.ipv6.dst));

net/ethtool/ioctl.c

3738

memcpy(&match->mask.ipv6.dst, v6_m_spec->ip6dst,

net/ethtool/ioctl.c

3739

sizeof(match->mask.ipv6.dst));

net/ethtool/ioctl.c

3753

match->key.tp.dst = v6_spec->pdst;

net/ethtool/ioctl.c

3754

match->mask.tp.dst = v6_m_spec->pdst;

net/ethtool/ioctl.c

3833

memcpy(match->key.eth_addrs.dst, ext_h_spec->h_dest,

net/ethtool/ioctl.c

3835

memcpy(match->mask.eth_addrs.dst, ext_m_spec->h_dest,

net/ethtool/netlink.h

103

static inline void ethnl_update_u8(u8 *dst, const struct nlattr *attr,

net/ethtool/netlink.h

111

if (*dst == val)

net/ethtool/netlink.h

114

*dst = val;

net/ethtool/netlink.h

129

static inline void ethnl_update_bool32(u32 *dst, const struct nlattr *attr,

net/ethtool/netlink.h

137

if (!!*dst == val)

net/ethtool/netlink.h

140

*dst = val;

net/ethtool/netlink.h

155

static inline void ethnl_update_bool(bool *dst, const struct nlattr *attr,

net/ethtool/netlink.h

163

if (!!*dst == val)

net/ethtool/netlink.h

166

*dst = val;

net/ethtool/netlink.h

182

static inline void ethnl_update_binary(void *dst, unsigned int len,

net/ethtool/netlink.h

189

if (!memcmp(dst, nla_data(attr), len))

net/ethtool/netlink.h

192

memcpy(dst, nla_data(attr), len);

net/ethtool/netlink.h

206

static inline void ethnl_update_bitfield32(u32 *dst, const struct nlattr *attr,

net/ethtool/netlink.h

215

newval = (*dst & ~change.selector) | (change.value & change.selector);

net/ethtool/netlink.h

216

if (*dst == newval)

net/ethtool/netlink.h

219

*dst = newval;

net/ethtool/netlink.h

77

static inline void ethnl_update_u32(u32 *dst, const struct nlattr *attr,

net/ethtool/netlink.h

85

if (*dst == val)

net/ethtool/netlink.h

88

*dst = val;

net/ethtool/plca.c

31

static void plca_update_sint(int *dst, struct nlattr **tb, u32 attrid,

net/ethtool/plca.c

42

*dst = nla_get_u8(attr);

net/ethtool/plca.c

45

*dst = nla_get_u32(attr);

net/hsr/hsr_forward.c

154

unsigned char *dst, *src;

net/hsr/hsr_forward.c

171

dst = skb_mac_header(skb);

net/hsr/hsr_forward.c

172

memcpy(dst, src, copylen);

net/hsr/hsr_forward.c

334

unsigned char *dst, *src;

net/hsr/hsr_forward.c

364

dst = skb_push(skb, HSR_HLEN);

net/hsr/hsr_forward.c

365

memmove(dst, src, movelen);

net/ieee802154/6lowpan/6lowpan_i.h

24

struct ieee802154_addr dst;

net/ieee802154/6lowpan/reassembly.c

67

const struct ieee802154_addr *dst)

net/ieee802154/6lowpan/reassembly.c

77

key.dst = *dst;

net/ipv4/af_inet.c

1294

sk_setup_caps(sk, &rt->dst);

net/ipv4/af_inet.c

1304

sk_setup_caps(sk, &rt->dst);

net/ipv4/af_inet.c

1339

sk_setup_caps(sk, &rt->dst);

net/ipv4/arp.c

1054

dev = rt->dst.dev;

net/ipv4/arp.c

307

struct dst_entry *dst)

net/ipv4/arp.c

320

skb_dst_set(skb, dst_clone(dst));

net/ipv4/arp.c

342

struct dst_entry *dst = NULL;

net/ipv4/arp.c

392

dst = skb_dst(skb);

net/ipv4/arp.c

394

dst_hw, dev->dev_addr, NULL, dst);

net/ipv4/arp.c

464

if (rt->dst.dev != dev) {

net/ipv4/arp.c

481

if (rt->dst.dev == dev)

net/ipv4/arp.c

494

out_dev = __in_dev_get_rcu(rt->dst.dev);

net/ipv4/arp.c

525

if (rt->dst.dev != dev)

net/ipv4/arp.c

868

(rt->dst.dev != dev &&

net/ipv4/datagram.c

105

struct dst_entry *dst;

net/ipv4/datagram.c

111

dst = __sk_dst_get(sk);

net/ipv4/datagram.c

112

if (!dst || !READ_ONCE(dst->obsolete) || dst->ops->check(dst, 0)) {

net/ipv4/datagram.c

119

dst = !IS_ERR(rt) ? &rt->dst : NULL;

net/ipv4/datagram.c

120

sk_dst_set(sk, dst);

net/ipv4/datagram.c

80

sk_dst_set(sk, &rt->dst);

net/ipv4/devinet.c

1359

__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)

net/ipv4/devinet.c

1382

if (!dst || inet_ifa_match(dst, ifa)) {

net/ipv4/devinet.c

1430

static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,

net/ipv4/devinet.c

1453

(!dst || inet_ifa_match(dst, ifa));

net/ipv4/devinet.c

1455

if (local || !dst)

net/ipv4/devinet.c

1483

__be32 dst, __be32 local, int scope)

net/ipv4/devinet.c

1489

return confirm_addr_indev(in_dev, dst, local, scope);

net/ipv4/devinet.c

1495

addr = confirm_addr_indev(in_dev, dst, local, scope);

net/ipv4/esp4.c

116

if (req->src != req->dst)

net/ipv4/esp4.c

179

struct dst_entry *dst = skb_dst(skb);

net/ipv4/esp4.c

180

struct xfrm_state *x = dst->xfrm;

net/ipv4/esp4.c

637

struct xfrm_dst *dst = (struct xfrm_dst *)skb_dst(skb);

net/ipv4/esp4.c

640

padto = min(x->tfcpad, xfrm_state_mtu(x, dst->child_mtu_cached));

net/ipv4/fib_frontend.c

1099

static void fib_magic(int cmd, int type, __be32 dst, int dst_len,

net/ipv4/fib_frontend.c

1108

.fc_dst = dst,

net/ipv4/fib_frontend.c

345

static int __fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,

net/ipv4/fib_frontend.c

361

fl4.saddr = dst;

net/ipv4/fib_frontend.c

429

int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,

net/ipv4/fib_frontend.c

459

return __fib_validate_source(skb, src, dst, dscp, oif, dev, r, idev,

net/ipv4/fib_rules.c

189

((daddr ^ r->dst) & r->dstmask))

net/ipv4/fib_rules.c

327

rule4->dst = nla_get_in_addr(tb[FRA_DST]);

net/ipv4/fib_rules.c

415

if (frh->dst_len && (rule4->dst != nla_get_in_addr(tb[FRA_DST])))

net/ipv4/fib_rules.c

441

nla_put_in_addr(skb, FRA_DST, rule4->dst)) ||

net/ipv4/fib_rules.c

45

__be32 dst;

net/ipv4/fib_semantics.c

151

dst_dev_put(&rt->dst);

net/ipv4/fib_semantics.c

152

dst_release_immediate(&rt->dst);

net/ipv4/fib_semantics.c

1752

nla_put_in_addr(skb, RTA_DST, fri->dst))

net/ipv4/fib_semantics.c

195

dst_dev_put(&rt->dst);

net/ipv4/fib_semantics.c

196

dst_release_immediate(&rt->dst);

net/ipv4/fib_semantics.c

557

fri.dst = key;

net/ipv4/fib_trie.c

100

.dst = dst,

net/ipv4/fib_trie.c

1024

l = fib_find_node(t, &tp, be32_to_cpu(fri->dst));

net/ipv4/fib_trie.c

2290

fri.dst = xkey;

net/ipv4/fib_trie.c

77

enum fib_event_type event_type, u32 dst,

net/ipv4/fib_trie.c

83

.dst = dst,

net/ipv4/fib_trie.c

94

enum fib_event_type event_type, u32 dst,

net/ipv4/icmp.c

1444

struct net *net = dev_net_rcu(rt->dst.dev);

net/ipv4/icmp.c

316

struct dst_entry *dst = &rt->dst;

net/ipv4/icmp.c

331

dev = dst_dev_rcu(dst);

net/ipv4/icmp.c

418

struct net *net = dev_net_rcu(rt->dst.dev);

net/ipv4/icmp.c

485

const struct dst_entry *dst;

net/ipv4/icmp.c

489

dst = skb_dst(skb);

net/ipv4/icmp.c

490

return dst ? dst_dev(dst) : NULL;

net/ipv4/icmp.c

500

struct dst_entry *dst, *dst2;

net/ipv4/icmp.c

526

dst = xfrm_lookup(net, &rt->dst,

net/ipv4/icmp.c

528

rt = dst_rtable(dst);

net/ipv4/icmp.c

529

if (!IS_ERR(dst)) {

net/ipv4/icmp.c

535

} else if (PTR_ERR(dst) == -EPERM) {

net/ipv4/icmp.c

562

dscp, rt2->dst.dev) ? -EINVAL : 0;

net/ipv4/icmp.c

564

dst_release(&rt2->dst);

net/ipv4/icmp.c

581

dst_release(&rt2->dst);

net/ipv4/icmp.c

589

dst2 = xfrm_lookup(net, &rt2->dst, flowi4_to_flowi(&fl4_dec), NULL,

net/ipv4/icmp.c

593

dst_release(&rt->dst);

net/ipv4/icmp.c

598

dst_release(&rt->dst);

net/ipv4/icmp.c

825

if (rt->dst.dev)

net/ipv4/icmp.c

826

net = dev_net_rcu(rt->dst.dev);

net/ipv4/icmp.c

970

room = dst4_mtu(&rt->dst);

net/ipv4/igmp.c

1936

dev = rt->dst.dev;

net/ipv4/igmp.c

383

skb_dst_set(skb, &rt->dst);

net/ipv4/igmp.c

740

__be32 dst;

net/ipv4/igmp.c

751

dst = IGMP_ALL_ROUTER;

net/ipv4/igmp.c

753

dst = group;

net/ipv4/igmp.c

755

rt = ip_route_output_ports(net, &fl4, NULL, dst, 0,

net/ipv4/igmp.c

770

skb_dst_set(skb, &rt->dst);

net/ipv4/igmp.c

783

iph->daddr = dst;

net/ipv4/inet_connection_sock.c

1541

sk_setup_caps(sk, &rt->dst);

net/ipv4/inet_connection_sock.c

1544

return &rt->dst;

net/ipv4/inet_connection_sock.c

1549

struct dst_entry *dst = __sk_dst_check(sk, 0);

net/ipv4/inet_connection_sock.c

1552

if (!dst) {

net/ipv4/inet_connection_sock.c

1553

dst = inet_csk_rebuild_route(sk, &inet->cork.fl);

net/ipv4/inet_connection_sock.c

1554

if (!dst)

net/ipv4/inet_connection_sock.c

1557

dst->ops->update_pmtu(dst, sk, NULL, mtu, true);

net/ipv4/inet_connection_sock.c

1559

dst = __sk_dst_check(sk, 0);

net/ipv4/inet_connection_sock.c

1560

if (!dst)

net/ipv4/inet_connection_sock.c

1561

dst = inet_csk_rebuild_route(sk, &inet->cork.fl);

net/ipv4/inet_connection_sock.c

1563

return dst;

net/ipv4/inet_connection_sock.c

785

return &rt->dst;

net/ipv4/inet_connection_sock.c

821

return &rt->dst;

net/ipv4/ip_forward.c

134

mtu = ip_dst_mtu_maybe_forward(&rt->dst, true);

net/ipv4/ip_forward.c

144

if (skb_cow(skb, LL_RESERVED_SPACE(rt->dst.dev)+rt->dst.header_len))

net/ipv4/ip_forward.c

163

net, NULL, skb, skb->dev, rt->dst.dev,

net/ipv4/ip_gre.c

638

ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,

net/ipv4/ip_gre.c

955

dev = rt->dst.dev;

net/ipv4/ip_input.c

610

struct dst_entry *dst;

net/ipv4/ip_input.c

622

dst = skb_dst(skb);

net/ipv4/ip_input.c

623

if (curr_dst != dst) {

net/ipv4/ip_input.c

631

curr_dst = dst;

net/ipv4/ip_output.c

1002

rt->dst.dev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM) &&

net/ipv4/ip_output.c

1004

(!exthdrlen || (rt->dst.dev->features & NETIF_F_HW_ESP_TX_CSUM)))

net/ipv4/ip_output.c

1017

if ((rt->dst.dev->features & NETIF_F_SG) &&

net/ipv4/ip_output.c

1029

if (rt->dst.dev->features & NETIF_F_SG &&

net/ipv4/ip_output.c

1041

if (rt->dst.dev->features & NETIF_F_SG &&

net/ipv4/ip_output.c

1110

alloc_extra += rt->dst.trailer_len;

net/ipv4/ip_output.c

1113

!(rt->dst.dev->features&NETIF_F_SG))

net/ipv4/ip_output.c

1117

!(rt->dst.dev->features & NETIF_F_SG)))

net/ipv4/ip_output.c

1213

if (!(rt->dst.dev->features&NETIF_F_SG) &&

net/ipv4/ip_output.c

1303

dst4_mtu(&rt->dst) : READ_ONCE(rt->dst.dev->mtu);

net/ipv4/ip_output.c

1326

cork->dst = &rt->dst;

net/ipv4/ip_output.c

138

const struct dst_entry *dst)

net/ipv4/ip_output.c

1388

dst_release(cork->dst);

net/ipv4/ip_output.c

1389

cork->dst = NULL;

net/ipv4/ip_output.c

1406

struct rtable *rt = dst_rtable(cork->dst);

net/ipv4/ip_output.c

143

ttl = ip4_dst_hoplimit(dst);

net/ipv4/ip_output.c

1442

(skb->len <= dst4_mtu(&rt->dst) &&

net/ipv4/ip_output.c

1443

ip_dont_fragment(sk, &rt->dst)))

net/ipv4/ip_output.c

1454

ttl = ip_select_ttl(inet, &rt->dst);

net/ipv4/ip_output.c

1481

cork->dst = NULL;

net/ipv4/ip_output.c

1482

skb_dst_set(skb, &rt->dst);

net/ipv4/ip_output.c

167

iph->ttl = ip_select_ttl(inet, &rt->dst);

net/ipv4/ip_output.c

172

if (skb->len <= IPV4_MIN_MTU || ip_dont_fragment(sk, &rt->dst)) {

net/ipv4/ip_output.c

202

struct dst_entry *dst = skb_dst(skb);

net/ipv4/ip_output.c

203

struct rtable *rt = dst_rtable(dst);

net/ipv4/ip_output.c

204

struct net_device *dev = dst_dev(dst);

net/ipv4/ip_output.c

223

if (lwtunnel_xmit_redirect(dst->lwtstate)) {

net/ipv4/ip_output.c

361

skb_dst_set(skb, &new_rt->dst);

net/ipv4/ip_output.c

371

struct net_device *dev = rt->dst.dev;

net/ipv4/ip_output.c

499

sk_setup_caps(sk, &rt->dst);

net/ipv4/ip_output.c

501

skb_dst_set_noref(skb, &rt->dst);

net/ipv4/ip_output.c

512

if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)

net/ipv4/ip_output.c

516

iph->ttl = ip_select_ttl(inet, &rt->dst);

net/ipv4/ip_output.c

796

ll_rs = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv4/ip_output.c

973

struct rtable *rt = dst_rtable(cork->dst);

net/ipv4/ip_output.c

980

exthdrlen = !skb ? rt->dst.header_len : 0;

net/ipv4/ip_output.c

984

hh_len = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv4/ip_sockglue.c

1633

struct dst_entry *dst;

net/ipv4/ip_sockglue.c

1635

dst = sk_dst_get(sk);

net/ipv4/ip_sockglue.c

1636

if (dst) {

net/ipv4/ip_sockglue.c

1637

val = dst4_mtu(dst);

net/ipv4/ip_sockglue.c

1638

dst_release(dst);

net/ipv4/ip_tunnel.c

303

tdev = rt->dst.dev;

net/ipv4/ip_tunnel.c

515

int tunnel_hlen, __be32 dst, bool md)

net/ipv4/ip_tunnel.c

526

mtu = dst_mtu(&rt->dst) - (sizeof(struct iphdr) + tunnel_hlen);

net/ipv4/ip_tunnel.c

550

daddr = md ? dst : tunnel->parms.iph.daddr;

net/ipv4/ip_tunnel.c

599

ip_tunnel_init_flow(&fl4, proto, key->u.ipv4.dst, key->u.ipv4.src,

net/ipv4/ip_tunnel.c

620

dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,

net/ipv4/ip_tunnel.c

623

if (rt->dst.dev == dev) {

net/ipv4/ip_tunnel.c

632

key->u.ipv4.dst, true)) {

net/ipv4/ip_tunnel.c

645

ttl = ip4_dst_hoplimit(&rt->dst);

net/ipv4/ip_tunnel.c

648

headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len;

net/ipv4/ip_tunnel.c

683

__be32 dst;

net/ipv4/ip_tunnel.c

692

dst = tnl_params->daddr;

net/ipv4/ip_tunnel.c

693

if (dst == 0) {

net/ipv4/ip_tunnel.c

704

tun_info->key.u.ipv4.dst) {

net/ipv4/ip_tunnel.c

705

dst = tun_info->key.u.ipv4.dst;

net/ipv4/ip_tunnel.c

710

dst = rt_nexthop(rt, inner_iph->daddr);

net/ipv4/ip_tunnel.c

736

dst = addr6->s6_addr32[3];

net/ipv4/ip_tunnel.c

762

ip_tunnel_init_flow(&fl4, protocol, dst, tnl_params->saddr,

net/ipv4/ip_tunnel.c

788

dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,

net/ipv4/ip_tunnel.c

791

dst_cache_set_ip4(&tunnel->dst_cache, &rt->dst,

net/ipv4/ip_tunnel.c

795

if (rt->dst.dev == dev) {

net/ipv4/ip_tunnel.c

830

ttl = ip4_dst_hoplimit(&rt->dst);

net/ipv4/ip_tunnel.c

833

max_headroom = LL_RESERVED_SPACE(rt->dst.dev) + sizeof(struct iphdr)

net/ipv4/ip_tunnel.c

834

+ rt->dst.header_len + ip_encap_hlen(&tunnel->encap);

net/ipv4/ip_tunnel_core.c

1007

tun_info->key.u.ipv6.dst = nla_get_in6_addr(tb[LWTUNNEL_IP6_DST]);

net/ipv4/ip_tunnel_core.c

1045

nla_put_in6_addr(skb, LWTUNNEL_IP6_DST, &tun_info->key.u.ipv6.dst) ||

net/ipv4/ip_tunnel_core.c

147

struct ip_tunnel_info *dst, *src;

net/ipv4/ip_tunnel_core.c

158

dst = &res->u.tun_info;

net/ipv4/ip_tunnel_core.c

159

dst->key.tun_id = src->key.tun_id;

net/ipv4/ip_tunnel_core.c

161

memcpy(&dst->key.u.ipv6.dst, &src->key.u.ipv6.src,

net/ipv4/ip_tunnel_core.c

164

dst->key.u.ipv4.dst = src->key.u.ipv4.src;

net/ipv4/ip_tunnel_core.c

165

ip_tunnel_flags_copy(dst->key.tun_flags, src->key.tun_flags);

net/ipv4/ip_tunnel_core.c

166

dst->mode = src->mode | IP_TUNNEL_INFO_TX;

net/ipv4/ip_tunnel_core.c

167

ip_tunnel_info_opts_set(dst, ip_tunnel_info_opts(src),

net/ipv4/ip_tunnel_core.c

51

__be32 src, __be32 dst, __u8 proto,

net/ipv4/ip_tunnel_core.c

56

struct net *net = dev_net(rt->dst.dev);

net/ipv4/ip_tunnel_core.c

721

tun_info->key.u.ipv4.dst = nla_get_in_addr(tb[LWTUNNEL_IP_DST]);

net/ipv4/ip_tunnel_core.c

77

skb_dst_set(skb, &rt->dst);

net/ipv4/ip_tunnel_core.c

875

nla_put_in_addr(skb, LWTUNNEL_IP_DST, tun_info->key.u.ipv4.dst) ||

net/ipv4/ip_tunnel_core.c

89

iph->frag_off = ip_mtu_locked(&rt->dst) ? 0 : df;

net/ipv4/ip_tunnel_core.c

92

iph->daddr = dst;

net/ipv4/ip_vti.c

148

static bool vti_state_check(const struct xfrm_state *x, __be32 dst, __be32 src)

net/ipv4/ip_vti.c

150

xfrm_address_t *daddr = (xfrm_address_t *)&dst;

net/ipv4/ip_vti.c

160

if (!dst)

net/ipv4/ip_vti.c

174

struct dst_entry *dst = skb_dst(skb);

net/ipv4/ip_vti.c

180

if (!dst) {

net/ipv4/ip_vti.c

192

dst = &rt->dst;

net/ipv4/ip_vti.c

193

skb_dst_set(skb, dst);

net/ipv4/ip_vti.c

200

dst = ip6_route_output(dev_net(dev), NULL, &fl->u.ip6);

net/ipv4/ip_vti.c

201

if (dst->error) {

net/ipv4/ip_vti.c

202

dst_release(dst);

net/ipv4/ip_vti.c

203

dst = NULL;

net/ipv4/ip_vti.c

207

skb_dst_set(skb, dst);

net/ipv4/ip_vti.c

216

dst_hold(dst);

net/ipv4/ip_vti.c

217

dst = xfrm_lookup_route(tunnel->net, dst, fl, NULL, 0);

net/ipv4/ip_vti.c

218

if (IS_ERR(dst)) {

net/ipv4/ip_vti.c

223

if (dst->flags & DST_XFRM_QUEUE)

net/ipv4/ip_vti.c

226

if (!vti_state_check(dst->xfrm, parms->iph.daddr, parms->iph.saddr)) {

net/ipv4/ip_vti.c

228

dst_release(dst);

net/ipv4/ip_vti.c

232

tdev = dst_dev(dst);

net/ipv4/ip_vti.c

235

dst_release(dst);

net/ipv4/ip_vti.c

240

mtu = dst_mtu(dst);

net/ipv4/ip_vti.c

255

dst_release(dst);

net/ipv4/ip_vti.c

261

skb_dst_set(skb, dst);

net/ipv4/ipip.c

374

ctx->dev = rt->dst.dev;

net/ipv4/ipmr.c

1898

if (skb->len+encap > dst4_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {

net/ipv4/ipmr.c

1908

encap += LL_RESERVED_SPACE(dst_dev_rcu(&rt->dst)) + rt->dst.header_len;

net/ipv4/ipmr.c

1919

skb_dst_set(skb, &rt->dst);

net/ipv4/ipmr.c

1961

net, NULL, skb, skb->dev, dst_dev_rcu(&rt->dst),

net/ipv4/ipmr.c

2305

dev = dst_dev_rcu(&rt->dst);

net/ipv4/netfilter.c

59

skb_dst_set(skb, &rt->dst);

net/ipv4/netfilter.c

67

struct dst_entry *dst = skb_dst(skb);

net/ipv4/netfilter.c

72

dst = xfrm_lookup(net, dst, flowi4_to_flowi(&fl4), sk, 0);

net/ipv4/netfilter.c

73

if (IS_ERR(dst))

net/ipv4/netfilter.c

74

return PTR_ERR(dst);

net/ipv4/netfilter.c

75

skb_dst_set(skb, dst);

net/ipv4/netfilter.c

90

int nf_ip_route(struct net *net, struct dst_entry **dst, struct flowi *fl,

net/ipv4/netfilter.c

96

*dst = &rt->dst;

net/ipv4/netfilter/arp_tables.c

718

static void compat_standard_from_user(void *dst, const void *src)

net/ipv4/netfilter/arp_tables.c

724

memcpy(dst, &v, sizeof(v));

net/ipv4/netfilter/arp_tables.c

727

static int compat_standard_to_user(void __user *dst, const void *src)

net/ipv4/netfilter/arp_tables.c

733

return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0;

net/ipv4/netfilter/ip_tables.c

54

(ip->daddr & ipinfo->dmsk.s_addr) != ipinfo->dst.s_addr))

net/ipv4/netfilter/ip_tables.c

871

static void compat_standard_from_user(void *dst, const void *src)

net/ipv4/netfilter/ip_tables.c

877

memcpy(dst, &v, sizeof(v));

net/ipv4/netfilter/ip_tables.c

880

static int compat_standard_to_user(void __user *dst, const void *src)

net/ipv4/netfilter/ip_tables.c

886

return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0;

net/ipv4/netfilter/nf_dup_ipv4.c

44

skb_dst_set(skb, &rt->dst);

net/ipv4/netfilter/nf_dup_ipv4.c

45

skb->dev = rt->dst.dev;

net/ipv4/netfilter/nf_nat_h323.c

118

&ct->tuplehash[!dir].tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

123

tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

125

} else if (addr.ip == ct->tuplehash[dir].tuple.dst.u3.ip &&

net/ipv4/netfilter/nf_nat_h323.c

161

&ct->tuplehash[!dir].tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

162

ntohs(ct->tuplehash[!dir].tuple.dst.u.udp.port));

net/ipv4/netfilter/nf_nat_h323.c

164

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

166

dst.u.udp.port);

net/ipv4/netfilter/nf_nat_h323.c

188

rtp_exp->saved_proto.udp.port = rtp_exp->tuple.dst.u.udp.port;

net/ipv4/netfilter/nf_nat_h323.c

191

rtcp_exp->saved_proto.udp.port = rtcp_exp->tuple.dst.u.udp.port;

net/ipv4/netfilter/nf_nat_h323.c

202

rtp_exp->tuple.dst.u.udp.port = info->rtp_port[i][dir];

net/ipv4/netfilter/nf_nat_h323.c

203

rtcp_exp->tuple.dst.u.udp.port =

net/ipv4/netfilter/nf_nat_h323.c

219

for (nated_port = ntohs(rtp_exp->tuple.dst.u.udp.port);

net/ipv4/netfilter/nf_nat_h323.c

223

rtp_exp->tuple.dst.u.udp.port = htons(nated_port);

net/ipv4/netfilter/nf_nat_h323.c

226

rtcp_exp->tuple.dst.u.udp.port =

net/ipv4/netfilter/nf_nat_h323.c

252

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

268

&rtp_exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

269

ntohs(rtp_exp->tuple.dst.u.udp.port));

net/ipv4/netfilter/nf_nat_h323.c

273

&rtcp_exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

274

ntohs(rtcp_exp->tuple.dst.u.udp.port));

net/ipv4/netfilter/nf_nat_h323.c

290

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/ipv4/netfilter/nf_nat_h323.c

302

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

311

&exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

312

ntohs(exp->tuple.dst.u.tcp.port));

net/ipv4/netfilter/nf_nat_h323.c

329

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/ipv4/netfilter/nf_nat_h323.c

345

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

358

&exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

359

ntohs(exp->tuple.dst.u.tcp.port));

net/ipv4/netfilter/nf_nat_h323.c

408

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/ipv4/netfilter/nf_nat_h323.c

424

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

439

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

450

&exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

451

ntohs(exp->tuple.dst.u.tcp.port));

net/ipv4/netfilter/nf_nat_h323.c

490

exp->saved_addr = exp->tuple.dst.u3;

net/ipv4/netfilter/nf_nat_h323.c

491

exp->tuple.dst.u3.ip = ct->tuplehash[!dir].tuple.dst.u3.ip;

net/ipv4/netfilter/nf_nat_h323.c

492

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/ipv4/netfilter/nf_nat_h323.c

504

&ct->tuplehash[!dir].tuple.dst.u3,

net/ipv4/netfilter/nf_nat_h323.c

514

&exp->tuple.dst.u3.ip,

net/ipv4/netfilter/nf_nat_h323.c

515

ntohs(exp->tuple.dst.u.tcp.port));

net/ipv4/netfilter/nf_nat_pptp.c

100

= ct->master->tuplehash[!exp->dir].tuple.dst.u3;

net/ipv4/netfilter/nf_nat_pptp.c

156

new_callid = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u.tcp.port;

net/ipv4/netfilter/nf_nat_pptp.c

219

expect_orig->tuple.dst.u.gre.key = ct_pptp_info->pac_call_id;

net/ipv4/netfilter/nf_nat_pptp.c

225

expect_reply->tuple.dst.u.gre.key = ct_pptp_info->pns_call_id;

net/ipv4/netfilter/nf_nat_pptp.c

69

t.dst.u3.ip = master->tuplehash[!exp->dir].tuple.dst.u3.ip;

net/ipv4/netfilter/nf_nat_pptp.c

70

t.dst.u.gre.key = ct_pptp_info->pns_call_id;

net/ipv4/netfilter/nf_nat_pptp.c

71

t.dst.protonum = IPPROTO_GRE;

net/ipv4/netfilter/nf_nat_pptp.c

78

t.dst.u3.ip = master->tuplehash[!exp->dir].tuple.dst.u3.ip;

net/ipv4/netfilter/nf_nat_pptp.c

79

t.dst.u.gre.key = nat_pptp_info->pac_call_id;

net/ipv4/netfilter/nf_nat_pptp.c

80

t.dst.protonum = IPPROTO_GRE;

net/ipv4/netfilter/nf_nat_snmp_basic_main.c

137

ctx.to = ct->tuplehash[!dir].tuple.dst.u3.ip;

net/ipv4/netfilter/nf_nat_snmp_basic_main.c

140

ctx.to = ct->tuplehash[dir].tuple.dst.u3.ip;

net/ipv4/netfilter/nf_nat_snmp_basic_main.c

212

.tuple.dst.protonum = IPPROTO_UDP,

net/ipv4/netfilter/nf_reject_ipv4.c

257

struct dst_entry *dst = NULL;

net/ipv4/netfilter/nf_reject_ipv4.c

262

nf_ip_route(dev_net(skb_in->dev), &dst, &fl, false);

net/ipv4/netfilter/nf_reject_ipv4.c

263

if (!dst)

net/ipv4/netfilter/nf_reject_ipv4.c

266

skb_dst_set(skb_in, dst);

net/ipv4/netfilter/nft_fib_ipv4.c

32

u32 *dst = &regs->data[priv->dreg];

net/ipv4/netfilter/nft_fib_ipv4.c

54

*dst = inet_dev_addr_type(nft_net(pkt), dev, addr);

net/ipv4/netfilter/nft_fib_ipv4.c

58

*dst = inet_addr_type_dev_table(nft_net(pkt), pkt->skb->dev, addr);

net/ipv4/ping.c

844

dst_confirm_neigh(&rt->dst, &fl4.daddr);

net/ipv4/raw.c

340

if (length > rt->dst.dev->mtu) {

net/ipv4/raw.c

342

rt->dst.dev->mtu);

net/ipv4/raw.c

351

hlen = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv4/raw.c

352

tlen = rt->dst.dev->needed_tailroom;

net/ipv4/raw.c

364

skb_dst_set(skb, &rt->dst);

net/ipv4/raw.c

413

net, sk, skb, NULL, rt->dst.dev,

net/ipv4/raw.c

676

dst_confirm_neigh(&rt->dst, &fl4.daddr);

net/ipv4/route.c

1021

struct dst_entry *dst = &rt->dst;

net/ipv4/route.c

1027

if (ip_mtu_locked(dst))

net/ipv4/route.c

1030

old_mtu = ipv4_mtu(dst);

net/ipv4/route.c

1035

net = dst_dev_net_rcu(dst);

net/ipv4/route.c

1042

time_before(jiffies, READ_ONCE(dst->expires) -

net/ipv4/route.c

1070

static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv4/route.c

1074

struct rtable *rt = dst_rtable(dst);

net/ipv4/route.c

1154

__ip_rt_update_pmtu(dst_rtable(xfrm_dst_path(&rt->dst)), &fl4, mtu);

net/ipv4/route.c

1156

if (!dst_check(&rt->dst, 0)) {

net/ipv4/route.c

1158

dst_release(&rt->dst);

net/ipv4/route.c

1168

sk_dst_set(sk, &rt->dst);

net/ipv4/route.c

1208

INDIRECT_CALLABLE_SCOPE struct dst_entry *ipv4_dst_check(struct dst_entry *dst,

net/ipv4/route.c

1211

struct rtable *rt = dst_rtable(dst);

net/ipv4/route.c

1221

if (READ_ONCE(dst->obsolete) != DST_OBSOLETE_FORCE_CHK ||

net/ipv4/route.c

1224

return dst;

net/ipv4/route.c

1248

dev = skb->dev ? skb->dev : skb_rtable(skb)->dst.dev;

net/ipv4/route.c

1266

dst_set_expires(&rt->dst, 0);

net/ipv4/route.c

129

struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);

net/ipv4/route.c

130

static unsigned int ipv4_default_advmss(const struct dst_entry *dst);

net/ipv4/route.c

1301

.flowi4_oif = rt->dst.dev->ifindex,

net/ipv4/route.c

1307

if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)

net/ipv4/route.c

1308

src = fib_result_prefsrc(dev_net(rt->dst.dev), &res);

net/ipv4/route.c

1310

src = inet_select_addr(rt->dst.dev,

net/ipv4/route.c

132

unsigned int ipv4_mtu(const struct dst_entry *dst);

net/ipv4/route.c

1321

if (!(rt->dst.tclassid & 0xFFFF))

net/ipv4/route.c

1322

rt->dst.tclassid |= tag & 0xFFFF;

net/ipv4/route.c

1323

if (!(rt->dst.tclassid & 0xFFFF0000))

net/ipv4/route.c

1324

rt->dst.tclassid |= tag & 0xFFFF0000;

net/ipv4/route.c

1328

static unsigned int ipv4_default_advmss(const struct dst_entry *dst)

net/ipv4/route.c

1335

net = dst_dev_net_rcu(dst);

net/ipv4/route.c

1336

advmss = max_t(unsigned int, ipv4_mtu(dst) - header_size,

net/ipv4/route.c

134

struct dst_entry *dst);

net/ipv4/route.c

1343

INDIRECT_CALLABLE_SCOPE unsigned int ipv4_mtu(const struct dst_entry *dst)

net/ipv4/route.c

1345

return ip_dst_mtu_maybe_forward(dst, false);

net/ipv4/route.c

136

static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv4/route.c

139

static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,

net/ipv4/route.c

141

static void ipv4_dst_destroy(struct dst_entry *dst);

net/ipv4/route.c

143

static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)

net/ipv4/route.c

1450

int genid = fnhe_genid(dev_net(rt->dst.dev));

net/ipv4/route.c

1474

dst_hold(&rt->dst);

net/ipv4/route.c

1477

dst_dev_put(&orig->dst);

net/ipv4/route.c

1478

dst_release(&orig->dst);

net/ipv4/route.c

149

static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,

net/ipv4/route.c

1505

dst_hold(&rt->dst);

net/ipv4/route.c

1510

dst_release(&orig->dst);

net/ipv4/route.c

1513

dst_release(&rt->dst);

net/ipv4/route.c

152

static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);

net/ipv4/route.c

1531

rt->dst.rt_uncached_list = ul;

net/ipv4/route.c

1534

list_add_tail(&rt->dst.rt_uncached, &ul->head);

net/ipv4/route.c

1540

struct uncached_list *ul = rt->dst.rt_uncached_list;

net/ipv4/route.c

1544

list_del_init(&rt->dst.rt_uncached);

net/ipv4/route.c

1549

static void ipv4_dst_destroy(struct dst_entry *dst)

net/ipv4/route.c

1551

ip_dst_metrics_put(dst);

net/ipv4/route.c

1552

rt_del_uncached_list(dst_rtable(dst));

net/ipv4/route.c

1567

list_for_each_entry_safe(rt, safe, &ul->head, dst.rt_uncached) {

net/ipv4/route.c

1568

if (rt->dst.dev != dev)

net/ipv4/route.c

1570

rt->dst.dev = blackhole_netdev;

net/ipv4/route.c

1572

&rt->dst.dev_tracker, GFP_ATOMIC);

net/ipv4/route.c

1573

list_del_init(&rt->dst.rt_uncached);

net/ipv4/route.c

1582

READ_ONCE(rt->dst.obsolete) == DST_OBSOLETE_FORCE_CHK &&

net/ipv4/route.c

1607

ip_dst_init_metrics(&rt->dst, fi->fib_metrics);

net/ipv4/route.c

1614

rt->dst.tclassid = nh->nh_tclassid;

net/ipv4/route.c

1617

rt->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);

net/ipv4/route.c

1666

rt->dst.output = ip_output;

net/ipv4/route.c

1668

rt->dst.input = ip_local_deliver;

net/ipv4/route.c

1680

rt->dst.flags);

net/ipv4/route.c

1696

new_rt->dst.input = READ_ONCE(rt->dst.input);

net/ipv4/route.c

1697

new_rt->dst.output = READ_ONCE(rt->dst.output);

net/ipv4/route.c

1698

new_rt->dst.error = rt->dst.error;

net/ipv4/route.c

1699

new_rt->dst.lastuse = jiffies;

net/ipv4/route.c

1700

new_rt->dst.lwtstate = lwtstate_get(rt->dst.lwtstate);

net/ipv4/route.c

1768

rth->dst.tclassid = itag;

net/ipv4/route.c

1770

rth->dst.output = ip_rt_bug;

net/ipv4/route.c

1775

rth->dst.input = ip_mr_input;

net/ipv4/route.c

1780

skb_dst_set(skb, &rth->dst);

net/ipv4/route.c

1879

skb_dst_set_noref(skb, &rth->dst);

net/ipv4/route.c

1894

rth->dst.input = ip_forward;

net/ipv4/route.c

1898

lwtunnel_set_redirect(&rth->dst);

net/ipv4/route.c

1899

skb_dst_set(skb, &rth->dst);

net/ipv4/route.c

1943

hash_keys->addrs.v4addrs.dst = key_iph->daddr;

net/ipv4/route.c

1963

hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;

net/ipv4/route.c

1969

hash_keys.ports.dst = keys.ports.dst;

net/ipv4/route.c

2003

hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;

net/ipv4/route.c

2009

hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;

net/ipv4/route.c

2019

hash_keys.ports.dst = keys.ports.dst;

net/ipv4/route.c

2050

hash_keys.addrs.v4addrs.dst = fl4->daddr;

net/ipv4/route.c

2060

hash_keys.ports.dst = fl4->fl4_dport;

net/ipv4/route.c

2081

hash_keys.addrs.v4addrs.dst = fl4->daddr;

net/ipv4/route.c

2104

hash_keys.addrs.v4addrs.dst = flkeys->addrs.v4addrs.dst;

net/ipv4/route.c

2106

hash_keys.ports.dst = flkeys->ports.dst;

net/ipv4/route.c

2112

hash_keys.addrs.v4addrs.dst = fl4->daddr;

net/ipv4/route.c

2117

hash_keys.ports.dst = fl4->fl4_dport;

net/ipv4/route.c

2133

hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;

net/ipv4/route.c

2137

hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;

net/ipv4/route.c

2149

hash_keys.addrs.v4addrs.dst = fl4->daddr;

net/ipv4/route.c

2423

skb_dst_set_noref(skb, &rth->dst);

net/ipv4/route.c

2434

rth->dst.output= ip_rt_bug;

net/ipv4/route.c

2436

rth->dst.tclassid = itag;

net/ipv4/route.c

2442

rth->dst.input= ip_error;

net/ipv4/route.c

2443

rth->dst.error= -err;

net/ipv4/route.c

2450

rth->dst.lwtstate = lwtstate_get(nhc->nhc_lwtstate);

net/ipv4/route.c

2451

if (lwtunnel_input_redirect(rth->dst.lwtstate)) {

net/ipv4/route.c

2452

WARN_ON(rth->dst.input == lwtunnel_input);

net/ipv4/route.c

2453

rth->dst.lwtstate->orig_input = rth->dst.input;

net/ipv4/route.c

2454

rth->dst.input = lwtunnel_input;

net/ipv4/route.c

2460

skb_dst_set(skb, &rth->dst);

net/ipv4/route.c

2650

if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))

net/ipv4/route.c

2667

rth->dst.output = ip_mc_output;

net/ipv4/route.c

2674

rth->dst.input = ip_mr_input;

net/ipv4/route.c

2675

rth->dst.output = ip_mr_output;

net/ipv4/route.c

2682

lwtunnel_set_redirect(&rth->dst);

net/ipv4/route.c

2899

struct dst_entry *new = &rt->dst;

net/ipv4/route.c

2926

return rt ? &rt->dst : ERR_PTR(-ENOMEM);

net/ipv4/route.c

2938

flp4->flowi4_oif = rt->dst.dev->ifindex;

net/ipv4/route.c

2939

rt = dst_rtable(xfrm_lookup_route(net, &rt->dst,

net/ipv4/route.c

2949

static int rt_fill_info(struct net *net, __be32 dst, __be32 src,

net/ipv4/route.c

2981

if (nla_put_in_addr(skb, RTA_DST, dst))

net/ipv4/route.c

2988

if (rt->dst.dev &&

net/ipv4/route.c

2989

nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))

net/ipv4/route.c

2991

if (lwtunnel_fill_encap(skb, rt->dst.lwtstate, RTA_ENCAP, RTA_ENCAP_TYPE) < 0)

net/ipv4/route.c

2994

if (rt->dst.tclassid &&

net/ipv4/route.c

2995

nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))

net/ipv4/route.c

3022

expires = READ_ONCE(rt->dst.expires);

net/ipv4/route.c

3032

memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));

net/ipv4/route.c

3053

if (ipv4_is_multicast(dst) &&

net/ipv4/route.c

3054

!ipv4_is_local_multicast(dst) &&

net/ipv4/route.c

3072

error = rt->dst.error;

net/ipv4/route.c

3074

if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)

net/ipv4/route.c

315

struct ip_rt_acct *dst, *src;

net/ipv4/route.c

3160

static struct sk_buff *inet_rtm_getroute_build_skb(__be32 src, __be32 dst,

net/ipv4/route.c

318

dst = kzalloc_objs(struct ip_rt_acct, 256);

net/ipv4/route.c

3180

iph->daddr = dst;

net/ipv4/route.c

319

if (!dst)

net/ipv4/route.c

3206

src, dst, 0);

net/ipv4/route.c

325

dst[j].o_bytes += src[j].o_bytes;

net/ipv4/route.c

326

dst[j].o_packets += src[j].o_packets;

net/ipv4/route.c

327

dst[j].i_bytes += src[j].i_bytes;

net/ipv4/route.c

328

dst[j].i_packets += src[j].i_packets;

net/ipv4/route.c

3303

__be32 dst = 0;

net/ipv4/route.c

3317

dst = nla_get_in_addr_default(tb[RTA_DST], 0);

net/ipv4/route.c

332

seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));

net/ipv4/route.c

333

kfree(dst);

net/ipv4/route.c

3339

skb = inet_rtm_getroute_build_skb(src, dst, ip_proto, sport, dport);

net/ipv4/route.c

3343

fl4.daddr = dst;

net/ipv4/route.c

3369

err = ip_route_input_rcu(skb, dst, src, dscp, dev,

net/ipv4/route.c

3373

if (err == 0 && rt->dst.error)

net/ipv4/route.c

3374

err = -rt->dst.error;

net/ipv4/route.c

3383

skb_dst_set(skb, &rt->dst);

net/ipv4/route.c

3412

fri.dst = res.prefix;

net/ipv4/route.c

3441

err = rt_fill_info(net, dst, src, rt, table_id, res.dscp, &fl4,

net/ipv4/route.c

401

res = rth->rt_genid != rt_genid_ipv4(dev_net_rcu(rth->dst.dev));

net/ipv4/route.c

412

static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,

net/ipv4/route.c

416

const struct rtable *rt = container_of(dst, struct rtable, dst);

net/ipv4/route.c

421

dev = dst_dev_rcu(dst);

net/ipv4/route.c

441

static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)

net/ipv4/route.c

443

const struct rtable *rt = container_of(dst, struct rtable, dst);

net/ipv4/route.c

444

struct net_device *dev = dst_dev(dst);

net/ipv4/route.c

583

dst_dev_put(&rt->dst);

net/ipv4/route.c

584

dst_release(&rt->dst);

net/ipv4/route.c

589

dst_dev_put(&rt->dst);

net/ipv4/route.c

590

dst_release(&rt->dst);

net/ipv4/route.c

634

rt->dst.expires = fnhe->fnhe_expires;

net/ipv4/route.c

726

WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);

net/ipv4/route.c

734

WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);

net/ipv4/route.c

789

n = __ipv4_neigh_lookup(rt->dst.dev, (__force u32)new_gw);

net/ipv4/route.c

791

n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);

net/ipv4/route.c

806

WRITE_ONCE(rt->dst.obsolete, DST_OBSOLETE_KILL);

net/ipv4/route.c

829

static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)

net/ipv4/route.c

840

rt = dst_rtable(dst);

net/ipv4/route.c

847

struct dst_entry *dst)

net/ipv4/route.c

849

struct rtable *rt = dst_rtable(dst);

net/ipv4/route.c

851

if ((READ_ONCE(dst->obsolete) > 0) ||

net/ipv4/route.c

853

READ_ONCE(rt->dst.expires))

net/ipv4/route.c

883

in_dev = __in_dev_get_rcu(rt->dst.dev);

net/ipv4/route.c

889

vif = l3mdev_master_ifindex_rcu(rt->dst.dev);

net/ipv4/route.c

891

net = dev_net(rt->dst.dev);

net/ipv4/route.c

962

net = dev_net(rt->dst.dev);

net/ipv4/route.c

964

switch (rt->dst.error) {

net/ipv4/route.c

978

switch (rt->dst.error) {

net/ipv4/syncookies.c

199

struct dst_entry *dst)

net/ipv4/syncookies.c

205

child = icsk->icsk_af_ops->syn_recv_sock(sk, skb, req, dst,

net/ipv4/syncookies.c

476

dst_metric(&rt->dst, RTAX_WINDOW);

net/ipv4/syncookies.c

486

dst_metric(&rt->dst, RTAX_INITRWND));

net/ipv4/syncookies.c

493

ireq->ecn_ok &= cookie_ecn_ok(net, &rt->dst);

net/ipv4/syncookies.c

496

ret = tcp_get_cookie_sock(sk, skb, req, &rt->dst);

net/ipv4/tcp_fastopen.c

425

const struct dst_entry *dst,

net/ipv4/tcp_fastopen.c

430

(dst && dst_metric(dst, RTAX_FASTOPEN_NO_COOKIE));

net/ipv4/tcp_fastopen.c

440

const struct dst_entry *dst)

net/ipv4/tcp_fastopen.c

458

if (tcp_fastopen_no_cookie(sk, dst, TFO_SERVER_COOKIE_NOT_REQD))

net/ipv4/tcp_fastopen.c

508

const struct dst_entry *dst;

net/ipv4/tcp_fastopen.c

518

dst = __sk_dst_get(sk);

net/ipv4/tcp_fastopen.c

520

if (tcp_fastopen_no_cookie(sk, dst, TFO_CLIENT_NO_COOKIE)) {

net/ipv4/tcp_fastopen.c

649

struct dst_entry *dst;

net/ipv4/tcp_fastopen.c

666

dst = __sk_dst_get(sk);

net/ipv4/tcp_fastopen.c

667

dev = dst ? dst_dev_rcu(dst) : NULL;

net/ipv4/tcp_input.c

1203

__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)

net/ipv4/tcp_input.c

1205

__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

net/ipv4/tcp_input.c

7476

const struct dst_entry *dst)

net/ipv4/tcp_input.c

7498

ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);

net/ipv4/tcp_input.c

7652

struct dst_entry *dst;

net/ipv4/tcp_input.c

7715

dst = af_ops->route_req(sk, skb, &fl, req, isn);

net/ipv4/tcp_input.c

7716

if (!dst)

net/ipv4/tcp_input.c

7723

tcp_rsk(req)->req_usec_ts = dst_tcp_usec_ts(dst);

net/ipv4/tcp_input.c

7733

!tcp_peer_is_proven(req, dst)) {

net/ipv4/tcp_input.c

7749

tcp_ecn_create_request(req, skb, sk, dst);

net/ipv4/tcp_input.c

7772

tcp_openreq_init_rwin(req, sk, dst);

net/ipv4/tcp_input.c

7776

fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);

net/ipv4/tcp_input.c

7779

af_ops->send_synack(fastopen_sk, dst, &fl, req,

net/ipv4/tcp_input.c

7795

dst_release(dst);

net/ipv4/tcp_input.c

7798

af_ops->send_synack(sk, dst, &fl, req, &foc,

net/ipv4/tcp_input.c

7811

dst_release(dst);

net/ipv4/tcp_ipv4.c

1182

static int tcp_v4_send_synack(const struct sock *sk, struct dst_entry *dst,

net/ipv4/tcp_ipv4.c

1196

if (!dst && (dst = inet_csk_route_req(sk, &fl4, req)) == NULL)

net/ipv4/tcp_ipv4.c

1199

skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);

net/ipv4/tcp_ipv4.c

1704

struct dst_entry *dst,

net/ipv4/tcp_ipv4.c

1751

if (!dst) {

net/ipv4/tcp_ipv4.c

1752

dst = inet_csk_route_child_sock(sk, newsk, req);

net/ipv4/tcp_ipv4.c

1753

if (!dst)

net/ipv4/tcp_ipv4.c

1758

sk_setup_caps(newsk, dst);

net/ipv4/tcp_ipv4.c

1764

tcp_ca_openreq_child(newsk, dst);

net/ipv4/tcp_ipv4.c

1766

tcp_sync_mss(newsk, dst4_mtu(dst));

net/ipv4/tcp_ipv4.c

1767

newtp->advmss = tcp_mss_clamp(tcp_sk(sk), dst_metric_advmss(dst));

net/ipv4/tcp_ipv4.c

1811

dst_release(dst);

net/ipv4/tcp_ipv4.c

1869

struct dst_entry *dst;

net/ipv4/tcp_ipv4.c

1871

dst = rcu_dereference_protected(sk->sk_rx_dst,

net/ipv4/tcp_ipv4.c

1876

if (dst) {

net/ipv4/tcp_ipv4.c

1878

!INDIRECT_CALL_1(dst->ops->check, ipv4_dst_check,

net/ipv4/tcp_ipv4.c

1879

dst, 0)) {

net/ipv4/tcp_ipv4.c

1881

dst_release(dst);

net/ipv4/tcp_ipv4.c

1961

struct dst_entry *dst = rcu_dereference(sk->sk_rx_dst);

net/ipv4/tcp_ipv4.c

1963

if (dst)

net/ipv4/tcp_ipv4.c

1964

dst = dst_check(dst, 0);

net/ipv4/tcp_ipv4.c

1965

if (dst &&

net/ipv4/tcp_ipv4.c

1967

skb_dst_set_noref(skb, dst);

net/ipv4/tcp_ipv4.c

2419

struct dst_entry *dst = skb_dst(skb);

net/ipv4/tcp_ipv4.c

2421

if (dst && dst_hold_safe(dst)) {

net/ipv4/tcp_ipv4.c

2422

rcu_assign_pointer(sk->sk_rx_dst, dst);

net/ipv4/tcp_ipv4.c

320

tp->tcp_usec_ts = dst_tcp_usec_ts(&rt->dst);

net/ipv4/tcp_ipv4.c

323

sk_setup_caps(sk, &rt->dst);

net/ipv4/tcp_ipv4.c

375

struct dst_entry *dst;

net/ipv4/tcp_ipv4.c

381

dst = inet_csk_update_pmtu(sk, mtu);

net/ipv4/tcp_ipv4.c

382

if (!dst)

net/ipv4/tcp_ipv4.c

388

dmtu = dst4_mtu(dst);

net/ipv4/tcp_ipv4.c

389

if (mtu < dmtu && ip_dont_fragment(sk, dst))

net/ipv4/tcp_ipv4.c

409

struct dst_entry *dst = __sk_dst_check(sk, 0);

net/ipv4/tcp_ipv4.c

411

if (dst)

net/ipv4/tcp_ipv4.c

412

dst->ops->redirect(dst, sk, skb);

net/ipv4/tcp_metrics.c

108

if (dst_metric_locked(dst, RTAX_RTT))

net/ipv4/tcp_metrics.c

110

if (dst_metric_locked(dst, RTAX_RTTVAR))

net/ipv4/tcp_metrics.c

112

if (dst_metric_locked(dst, RTAX_SSTHRESH))

net/ipv4/tcp_metrics.c

114

if (dst_metric_locked(dst, RTAX_CWND))

net/ipv4/tcp_metrics.c

116

if (dst_metric_locked(dst, RTAX_REORDERING))

net/ipv4/tcp_metrics.c

121

msval = dst_metric_raw(dst, RTAX_RTT);

net/ipv4/tcp_metrics.c

124

msval = dst_metric_raw(dst, RTAX_RTTVAR);

net/ipv4/tcp_metrics.c

127

dst_metric_raw(dst, RTAX_SSTHRESH));

net/ipv4/tcp_metrics.c

129

dst_metric_raw(dst, RTAX_CWND));

net/ipv4/tcp_metrics.c

131

dst_metric_raw(dst, RTAX_REORDERING));

net/ipv4/tcp_metrics.c

146

const struct dst_entry *dst)

net/ipv4/tcp_metrics.c

154

tcpm_suck_dst(tm, dst, false);

net/ipv4/tcp_metrics.c

163

static struct tcp_metrics_block *tcpm_new(struct dst_entry *dst,

net/ipv4/tcp_metrics.c

173

net = dst_dev_net_rcu(dst);

net/ipv4/tcp_metrics.c

184

tcpm_check_stamp(tm, dst);

net/ipv4/tcp_metrics.c

210

tcpm_suck_dst(tm, dst, reclaim);

net/ipv4/tcp_metrics.c

250

struct dst_entry *dst)

net/ipv4/tcp_metrics.c

276

net = dst_dev_net_rcu(dst);

net/ipv4/tcp_metrics.c

287

tcpm_check_stamp(tm, dst);

net/ipv4/tcp_metrics.c

292

struct dst_entry *dst,

net/ipv4/tcp_metrics.c

321

net = dst_dev_net_rcu(dst);

net/ipv4/tcp_metrics.c

329

tm = tcpm_new(dst, &saddr, &daddr, hash);

net/ipv4/tcp_metrics.c

331

tcpm_check_stamp(tm, dst);

net/ipv4/tcp_metrics.c

343

struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_metrics.c

352

if (READ_ONCE(net->ipv4.sysctl_tcp_nometrics_save) || !dst)

net/ipv4/tcp_metrics.c

361

tm = tcp_get_metrics(sk, dst, false);

net/ipv4/tcp_metrics.c

366

tm = tcp_get_metrics(sk, dst, true);

net/ipv4/tcp_metrics.c

466

struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_metrics.c

477

if (!dst)

net/ipv4/tcp_metrics.c

481

tm = tcp_get_metrics(sk, dst, false);

net/ipv4/tcp_metrics.c

542

bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst)

net/ipv4/tcp_metrics.c

547

if (!dst)

net/ipv4/tcp_metrics.c

551

tm = __tcp_get_metrics_req(req, dst);

net/ipv4/tcp_metrics.c

588

struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_metrics.c

591

if (!dst)

net/ipv4/tcp_metrics.c

594

tm = tcp_get_metrics(sk, dst, true);

net/ipv4/tcp_metrics.c

99

const struct dst_entry *dst,

net/ipv4/tcp_minisocks.c

435

const struct dst_entry *dst)

net/ipv4/tcp_minisocks.c

445

mss = tcp_mss_clamp(tp, dst_metric_advmss(dst));

net/ipv4/tcp_minisocks.c

448

req->rsk_window_clamp = window_clamp ? : dst_metric(dst, RTAX_WINDOW);

net/ipv4/tcp_minisocks.c

457

rcv_wnd = dst_metric(dst, RTAX_INITRWND);

net/ipv4/tcp_minisocks.c

499

void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst)

net/ipv4/tcp_minisocks.c

502

u32 ca_key = dst_metric(dst, RTAX_CC_ALGO);

net/ipv4/tcp_minisocks.c

511

icsk->icsk_ca_dst_locked = tcp_ca_dst_locked(dst);

net/ipv4/tcp_output.c

148

const struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_output.c

151

if (dst) {

net/ipv4/tcp_output.c

152

unsigned int metric = dst_metric_advmss(dst);

net/ipv4/tcp_output.c

2085

const struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_output.c

2093

if (dst) {

net/ipv4/tcp_output.c

2094

u32 mtu = dst_mtu(dst);

net/ipv4/tcp_output.c

2643

struct sk_buff *dst,

net/ipv4/tcp_output.c

2646

TCP_SKB_CB(dst)->tcp_flags |= TCP_SKB_CB(src)->tcp_flags;

net/ipv4/tcp_output.c

2647

TCP_SKB_CB(dst)->eor = TCP_SKB_CB(src)->eor;

net/ipv4/tcp_output.c

2648

tcp_skb_collapse_tstamp(dst, src);

net/ipv4/tcp_output.c

3933

struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,

net/ipv4/tcp_output.c

3951

dst_release(dst);

net/ipv4/tcp_output.c

3975

skb_dst_set(skb, dst);

net/ipv4/tcp_output.c

3977

mss = tcp_mss_clamp(tp, dst_metric_advmss(dst));

net/ipv4/tcp_output.c

4084

static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst)

net/ipv4/tcp_output.c

4088

u32 ca_key = dst_metric(dst, RTAX_CC_ALGO);

net/ipv4/tcp_output.c

4097

icsk->icsk_ca_dst_locked = tcp_ca_dst_locked(dst);

net/ipv4/tcp_output.c

4106

const struct dst_entry *dst = __sk_dst_get(sk);

net/ipv4/tcp_output.c

4127

tcp_sync_mss(sk, dst_mtu(dst));

net/ipv4/tcp_output.c

4129

tcp_ca_dst_init(sk, dst);

net/ipv4/tcp_output.c

4132

WRITE_ONCE(tp->window_clamp, dst_metric(dst, RTAX_WINDOW));

net/ipv4/tcp_output.c

4133

tp->advmss = tcp_mss_clamp(tp, dst_metric_advmss(dst));

net/ipv4/tcp_output.c

4144

rcv_wnd = dst_metric(dst, RTAX_INITRWND);

net/ipv4/udp.c

1052

void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst)

net/ipv4/udp.c

1066

uh->check = ~csum_tcpudp_magic(src, dst, len,

net/ipv4/udp.c

1084

uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);

net/ipv4/udp.c

1465

sk_dst_set(sk, dst_clone(&rt->dst));

net/ipv4/udp.c

1544

dst_confirm_neigh(&rt->dst, &fl4->daddr);

net/ipv4/udp.c

2537

bool udp_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst)

net/ipv4/udp.c

2541

if (dst_hold_safe(dst)) {

net/ipv4/udp.c

2542

old = unrcu_pointer(xchg(&sk->sk_rx_dst, RCU_INITIALIZER(dst)));

net/ipv4/udp.c

2544

return old != dst;

net/ipv4/udp.c

2736

struct dst_entry *dst = skb_dst(skb);

net/ipv4/udp.c

2739

if (unlikely(rcu_dereference(sk->sk_rx_dst) != dst))

net/ipv4/udp.c

2740

udp_sk_rx_dst_set(sk, dst);

net/ipv4/udp.c

2872

struct dst_entry *dst;

net/ipv4/udp.c

2909

dst = rcu_dereference(sk->sk_rx_dst);

net/ipv4/udp.c

2911

if (dst)

net/ipv4/udp.c

2912

dst = dst_check(dst, 0);

net/ipv4/udp.c

2913

if (dst) {

net/ipv4/udp.c

2920

skb_dst_set_noref(skb, dst);

net/ipv4/udp_tunnel_core.c

175

__be32 src, __be32 dst, __u8 tos, __u8 ttl,

net/ipv4/udp_tunnel_core.c

191

udp_set_csum(nocheck, skb, src, dst, skb->len);

net/ipv4/udp_tunnel_core.c

193

iptunnel_xmit(sk, rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df, xnet,

net/ipv4/udp_tunnel_core.c

253

fl4.daddr = key->u.ipv4.dst;

net/ipv4/udp_tunnel_core.c

265

if (rt->dst.dev == dev) { /* is this necessary? */

net/ipv4/udp_tunnel_core.c

272

dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr);

net/ipv4/xfrm4_policy.c

100

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv4/xfrm4_policy.c

106

static void xfrm4_redirect(struct dst_entry *dst, struct sock *sk,

net/ipv4/xfrm4_policy.c

109

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv4/xfrm4_policy.c

115

static void xfrm4_dst_destroy(struct dst_entry *dst)

net/ipv4/xfrm4_policy.c

117

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv4/xfrm4_policy.c

119

dst_destroy_metrics_generic(dst);

net/ipv4/xfrm4_policy.c

39

return &rt->dst;

net/ipv4/xfrm4_policy.c

54

struct dst_entry *dst;

net/ipv4/xfrm4_policy.c

57

dst = __xfrm4_dst_lookup(&fl4, params);

net/ipv4/xfrm4_policy.c

58

if (IS_ERR(dst))

net/ipv4/xfrm4_policy.c

62

dst_release(dst);

net/ipv4/xfrm4_policy.c

74

xdst->u.dst.dev = dev;

net/ipv4/xfrm4_policy.c

75

netdev_hold(dev, &xdst->u.dst.dev_tracker, GFP_ATOMIC);

net/ipv4/xfrm4_policy.c

96

static void xfrm4_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv6/addrconf.c

1586

struct ipv6_saddr_dst *dst,

net/ipv6/addrconf.c

1612

ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);

net/ipv6/addrconf.c

1637

if (ret >= dst->scope)

net/ipv6/addrconf.c

1658

int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);

net/ipv6/addrconf.c

1665

ret = (!dst->ifindex ||

net/ipv6/addrconf.c

1666

dst->ifindex == score->ifa->idev->dev->ifindex);

net/ipv6/addrconf.c

1672

score->ifa->idev->dev->ifindex) == dst->label;

net/ipv6/addrconf.c

1679

int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?

net/ipv6/addrconf.c

1680

!!(dst->prefs & IPV6_PREFER_SRC_TMP) :

net/ipv6/addrconf.c

1690

ipv6_addr_orchid(dst->addr));

net/ipv6/addrconf.c

1694

ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);

net/ipv6/addrconf.c

1719

struct ipv6_saddr_dst *dst,

net/ipv6/addrconf.c

1758

minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i);

net/ipv6/addrconf.c

1759

miniscore = ipv6_get_saddr_eval(net, score, dst, i);

net/ipv6/addrconf.c

1793

struct ipv6_saddr_dst *dst,

net/ipv6/addrconf.c

1801

hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,

net/ipv6/addrconf.c

1806

hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,

net/ipv6/addrconf.c

1817

struct ipv6_saddr_dst dst;

net/ipv6/addrconf.c

1826

dst.addr = daddr;

net/ipv6/addrconf.c

1827

dst.ifindex = dst_dev ? dst_dev->ifindex : 0;

net/ipv6/addrconf.c

1828

dst.scope = __ipv6_addr_src_scope(dst_type);

net/ipv6/addrconf.c

1829

dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);

net/ipv6/addrconf.c

1830

dst.prefs = prefs;

net/ipv6/addrconf.c

1856

dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||

net/ipv6/addrconf.c

1864

hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);

net/ipv6/addrconf.c

1878

master, &dst,

net/ipv6/addrconf.c

1895

hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);

net/ipv6/addrconf.c

6660

rt->dst.flags |= DST_NOPOLICY;

net/ipv6/addrconf.c

6662

rt->dst.flags &= ~DST_NOPOLICY;

net/ipv6/af_inet6.c

821

struct dst_entry *dst;

net/ipv6/af_inet6.c

824

dst = __sk_dst_check(sk, np->dst_cookie);

net/ipv6/af_inet6.c

825

if (dst)

net/ipv6/af_inet6.c

845

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_p);

net/ipv6/af_inet6.c

846

if (IS_ERR(dst)) {

net/ipv6/af_inet6.c

848

WRITE_ONCE(sk->sk_err_soft, -PTR_ERR(dst));

net/ipv6/af_inet6.c

849

return PTR_ERR(dst);

net/ipv6/af_inet6.c

852

ip6_dst_store(sk, dst, false, false);

net/ipv6/anycast.c

107

dev = dst_dev_rcu(&rt->dst);

net/ipv6/datagram.c

115

ip6_sk_dst_store_flow(sk, dst, fl6);

net/ipv6/datagram.c

124

struct dst_entry *dst;

net/ipv6/datagram.c

130

dst = __sk_dst_get(sk);

net/ipv6/datagram.c

131

if (!dst || !READ_ONCE(dst->obsolete) ||

net/ipv6/datagram.c

132

dst->ops->check(dst, inet6_sk(sk)->dst_cookie)) {

net/ipv6/datagram.c

79

struct dst_entry *dst;

net/ipv6/datagram.c

97

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_p);

net/ipv6/datagram.c

98

if (IS_ERR(dst)) {

net/ipv6/datagram.c

99

err = PTR_ERR(dst);

net/ipv6/esp6.c

133

if (req->src != req->dst)

net/ipv6/esp6.c

196

struct dst_entry *dst = skb_dst(skb);

net/ipv6/esp6.c

197

struct xfrm_state *x = dst->xfrm;

net/ipv6/esp6.c

669

struct xfrm_dst *dst = (struct xfrm_dst *)skb_dst(skb);

net/ipv6/esp6.c

672

padto = min(x->tfcpad, xfrm_state_mtu(x, dst->child_mtu_cached));

net/ipv6/exthdrs.c

302

struct dst_entry *dst = skb_dst(skb);

net/ipv6/exthdrs.c

309

__IP6_INC_STATS(dev_net(dst_dev(dst)), idev,

net/ipv6/fib6_rules.c

116

return &res.rt6->dst;

net/ipv6/fib6_rules.c

122

if (rt != net->ipv6.ip6_null_entry && rt->dst.error != -EAGAIN)

net/ipv6/fib6_rules.c

123

return &rt->dst;

net/ipv6/fib6_rules.c

127

if (rt->dst.error != -EAGAIN)

net/ipv6/fib6_rules.c

128

return &rt->dst;

net/ipv6/fib6_rules.c

133

dst_hold(&net->ipv6.ip6_null_entry->dst);

net/ipv6/fib6_rules.c

134

return &net->ipv6.ip6_null_entry->dst;

net/ipv6/fib6_rules.c

240

struct inet6_dev *idev = ip6_dst_idev(&rt->dst);

net/ipv6/fib6_rules.c

250

err = rt->dst.error;

net/ipv6/fib6_rules.c

262

dst_hold(&rt->dst);

net/ipv6/fib6_rules.c

28

struct rt6key dst;

net/ipv6/fib6_rules.c

317

if (r->dst.plen &&

net/ipv6/fib6_rules.c

318

!ipv6_prefix_equal(&fl6->daddr, &r->dst.addr, r->dst.plen))

net/ipv6/fib6_rules.c

40

if (r->dst.plen || r->src.plen || r->dscp || r->flowlabel_mask)

net/ipv6/fib6_rules.c

466

rule6->dst.addr = nla_get_in6_addr(tb[FRA_DST]);

net/ipv6/fib6_rules.c

469

rule6->dst.plen = frh->dst_len;

net/ipv6/fib6_rules.c

499

if (frh->dst_len && (rule6->dst.plen != frh->dst_len))

net/ipv6/fib6_rules.c

536

nla_memcmp(tb[FRA_DST], &rule6->dst.addr, sizeof(struct in6_addr)))

net/ipv6/fib6_rules.c

547

frh->dst_len = rule6->dst.plen;

net/ipv6/fib6_rules.c

566

if ((rule6->dst.plen &&

net/ipv6/fib6_rules.c

567

nla_put_in6_addr(skb, FRA_DST, &rule6->dst.addr)) ||

net/ipv6/icmp.c

1009

ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);

net/ipv6/icmp.c

1020

dst_rt6_info(dst), MSG_DONTWAIT)) {

net/ipv6/icmp.c

1029

dst_release(dst);

net/ipv6/icmp.c

200

struct dst_entry *dst;

net/ipv6/icmp.c

211

dst = ip6_route_output(net, sk, fl6);

net/ipv6/icmp.c

213

dev = dst_dev_rcu(dst);

net/ipv6/icmp.c

214

if (dst->error) {

net/ipv6/icmp.c

215

IP6_INC_STATS(net, ip6_dst_idev(dst),

net/ipv6/icmp.c

235

dst_release(dst);

net/ipv6/icmp.c

243

struct dst_entry *dst;

net/ipv6/icmp.c

246

dst = ip6_route_output(net, sk, fl6);

net/ipv6/icmp.c

247

if (!dst->error) {

net/ipv6/icmp.c

248

struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/icmp.c

254

dst_release(dst);

net/ipv6/icmp.c

359

struct dst_entry *dst, *dst2;

net/ipv6/icmp.c

363

err = ip6_dst_lookup(net, sk, &dst, fl6);

net/ipv6/icmp.c

372

ipv6_anycast_destination(dst, &fl6->daddr)) {

net/ipv6/icmp.c

374

dst_release(dst);

net/ipv6/icmp.c

379

dst2 = dst;

net/ipv6/icmp.c

381

dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);

net/ipv6/icmp.c

382

if (!IS_ERR(dst)) {

net/ipv6/icmp.c

383

if (dst != dst2)

net/ipv6/icmp.c

384

return dst;

net/ipv6/icmp.c

386

if (PTR_ERR(dst) == -EPERM)

net/ipv6/icmp.c

387

dst = NULL;

net/ipv6/icmp.c

389

return dst;

net/ipv6/icmp.c

402

dst_release(dst);

net/ipv6/icmp.c

403

dst = dst2;

net/ipv6/icmp.c

407

dst_release(dst);

net/ipv6/icmp.c

414

if (dst)

net/ipv6/icmp.c

415

return dst;

net/ipv6/icmp.c

648

struct dst_entry *dst;

net/ipv6/icmp.c

793

dst = icmpv6_route_lookup(net, skb, sk, &fl6);

net/ipv6/icmp.c

794

if (IS_ERR(dst))

net/ipv6/icmp.c

797

ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);

net/ipv6/icmp.c

821

&ipc6, &fl6, dst_rt6_info(dst),

net/ipv6/icmp.c

833

dst_release(dst);

net/ipv6/icmp.c

888

if (rt && rt->dst.dev)

net/ipv6/icmp.c

889

skb2->dev = rt->dst.dev;

net/ipv6/icmp.c

933

struct dst_entry *dst;

net/ipv6/icmp.c

990

if (ip6_dst_lookup(net, sk, &dst, &fl6))

net/ipv6/icmp.c

992

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);

net/ipv6/icmp.c

993

if (IS_ERR(dst))

net/ipv6/ila/ila_lwt.c

100

skb_dst_set(skb, dst);

net/ipv6/ila/ila_lwt.c

110

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ila/ila_lwt.c

111

struct ila_lwt *ilwt = ila_lwt_lwtunnel(dst->lwtstate);

net/ipv6/ila/ila_lwt.c

118

ila_params_lwtunnel(dst->lwtstate),

net/ipv6/ila/ila_lwt.c

121

return dst->lwtstate->orig_input(skb);

net/ipv6/ila/ila_lwt.c

43

struct dst_entry *dst;

net/ipv6/ila/ila_lwt.c

62

dst = dst_cache_get(&ilwt->dst_cache);

net/ipv6/ila/ila_lwt.c

64

if (unlikely(!dst)) {

net/ipv6/ila/ila_lwt.c

78

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/ila/ila_lwt.c

79

if (dst->error) {

net/ipv6/ila/ila_lwt.c

81

dst_release(dst);

net/ipv6/ila/ila_lwt.c

85

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);

net/ipv6/ila/ila_lwt.c

86

if (IS_ERR(dst)) {

net/ipv6/ila/ila_lwt.c

87

err = PTR_ERR(dst);

net/ipv6/ila/ila_lwt.c

92

if (ilwt->connected && orig_dst->lwtstate != dst->lwtstate) {

net/ipv6/ila/ila_lwt.c

94

dst_cache_set_ip6(&ilwt->dst_cache, dst, &fl6.saddr);

net/ipv6/inet6_connection_sock.c

100

if (unlikely(!dst)) {

net/ipv6/inet6_connection_sock.c

101

dst = inet6_csk_route_socket(sk, fl6);

net/ipv6/inet6_connection_sock.c

102

if (IS_ERR(dst)) {

net/ipv6/inet6_connection_sock.c

103

WRITE_ONCE(sk->sk_err_soft, -PTR_ERR(dst));

net/ipv6/inet6_connection_sock.c

106

return PTR_ERR(dst);

net/ipv6/inet6_connection_sock.c

113

skb_dst_set_noref(skb, dst);

net/ipv6/inet6_connection_sock.c

125

struct dst_entry *dst;

net/ipv6/inet6_connection_sock.c

127

dst = inet6_csk_route_socket(sk, fl6);

net/ipv6/inet6_connection_sock.c

129

if (IS_ERR(dst))

net/ipv6/inet6_connection_sock.c

131

dst->ops->update_pmtu(dst, sk, NULL, mtu, true);

net/ipv6/inet6_connection_sock.c

133

dst = inet6_csk_route_socket(sk, fl6);

net/ipv6/inet6_connection_sock.c

134

return IS_ERR(dst) ? NULL : dst;

net/ipv6/inet6_connection_sock.c

28

struct dst_entry *dst,

net/ipv6/inet6_connection_sock.c

51

if (!dst) {

net/ipv6/inet6_connection_sock.c

52

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_p);

net/ipv6/inet6_connection_sock.c

53

if (IS_ERR(dst))

net/ipv6/inet6_connection_sock.c

56

return dst;

net/ipv6/inet6_connection_sock.c

65

struct dst_entry *dst;

net/ipv6/inet6_connection_sock.c

84

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_p);

net/ipv6/inet6_connection_sock.c

86

if (!IS_ERR(dst))

net/ipv6/inet6_connection_sock.c

87

ip6_dst_store(sk, dst, false, false);

net/ipv6/inet6_connection_sock.c

89

return dst;

net/ipv6/inet6_connection_sock.c

96

struct dst_entry *dst;

net/ipv6/inet6_connection_sock.c

99

dst = __sk_dst_check(sk, np->dst_cookie);

net/ipv6/ioam6_iptunnel.c

299

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ioam6_iptunnel.c

330

ipv6_dev_get_saddr(net, dst_dev(dst), &hdr->daddr,

net/ipv6/ioam6_iptunnel.c

341

struct dst_entry *dst = NULL;

net/ipv6/ioam6_iptunnel.c

357

dst = dst_cache_get(&ilwt->cache);

net/ipv6/ioam6_iptunnel.c

363

if (dst == &ilwt->null_dst) {

net/ipv6/ioam6_iptunnel.c

364

dst_release(dst);

net/ipv6/ioam6_iptunnel.c

366

dst = orig_dst;

net/ipv6/ioam6_iptunnel.c

368

dst_hold(dst);

net/ipv6/ioam6_iptunnel.c

378

err = ioam6_do_inline(net, skb, &ilwt->tuninfo, dst);

net/ipv6/ioam6_iptunnel.c

388

&ilwt->tundst, dst);

net/ipv6/ioam6_iptunnel.c

406

if (unlikely(!dst)) {

net/ipv6/ioam6_iptunnel.c

417

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/ioam6_iptunnel.c

418

if (dst->error) {

net/ipv6/ioam6_iptunnel.c

419

err = dst->error;

net/ipv6/ioam6_iptunnel.c

430

if (orig_dst->lwtstate == dst->lwtstate)

net/ipv6/ioam6_iptunnel.c

434

dst_cache_set_ip6(&ilwt->cache, dst, &fl6.saddr);

net/ipv6/ioam6_iptunnel.c

437

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst_dev(dst)));

net/ipv6/ioam6_iptunnel.c

445

if (orig_dst->lwtstate != dst->lwtstate) {

net/ipv6/ioam6_iptunnel.c

447

skb_dst_set(skb, dst);

net/ipv6/ioam6_iptunnel.c

451

dst_release(dst);

net/ipv6/ioam6_iptunnel.c

454

dst_release(dst);

net/ipv6/ip6_fib.c

328

if (rt->dst.error == -EAGAIN) {

net/ipv6/ip6_fib.c

332

dst_hold(&rt->dst);

net/ipv6/ip6_fib.c

335

return &rt->dst;

net/ipv6/ip6_flowlabel.c

434

fl->dst = freq->flr_dst;

net/ipv6/ip6_flowlabel.c

522

freq->flr_dst = sfl->fl->dst;

net/ipv6/ip6_flowlabel.c

849

&fl->dst,

net/ipv6/ip6_gre.c

1058

if (!t->parms.collect_md && dst) {

net/ipv6/ip6_gre.c

1059

mtu = READ_ONCE(dst_dev(dst)->mtu);

net/ipv6/ip6_gre.c

1060

if (dst6_mtu(dst) > mtu)

net/ipv6/ip6_gre.c

1061

dst->ops->update_pmtu(dst, NULL, skb, mtu, false);

net/ipv6/ip6_gre.c

1138

if (rt->dst.dev) {

net/ipv6/ip6_gre.c

1139

unsigned short dst_len = rt->dst.dev->hard_header_len +

net/ipv6/ip6_gre.c

1148

int mtu = rt->dst.dev->mtu - t_hlen;

net/ipv6/ip6_gre.c

750

fl6->daddr = key->u.ipv6.dst;

net/ipv6/ip6_gre.c

921

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_gre.c

985

fl6.daddr = key->u.ipv6.dst;

net/ipv6/ip6_input.c

117

struct dst_entry *dst;

net/ipv6/ip6_input.c

131

dst = skb_dst(skb);

net/ipv6/ip6_input.c

132

if (curr_dst != dst) {

net/ipv6/ip6_input.c

140

curr_dst = dst;

net/ipv6/ip6_output.c

1007

ip6_frag_init(skb, hlen, mtu, rt->dst.dev->needed_tailroom,

net/ipv6/ip6_output.c

1008

LL_RESERVED_SPACE(rt->dst.dev), prevhdr, nexthdr, frag_id,

net/ipv6/ip6_output.c

1058

struct dst_entry *dst,

net/ipv6/ip6_output.c

1064

if (!dst)

net/ipv6/ip6_output.c

1067

if (dst->ops->family != AF_INET6) {

net/ipv6/ip6_output.c

1068

dst_release(dst);

net/ipv6/ip6_output.c

1072

rt = dst_rt6_info(dst);

net/ipv6/ip6_output.c

1096

(fl6->flowi6_oif && fl6->flowi6_oif != dst_dev(dst)->ifindex)) {

net/ipv6/ip6_output.c

1097

dst_release(dst);

net/ipv6/ip6_output.c

1098

dst = NULL;

net/ipv6/ip6_output.c

1102

return dst;

net/ipv6/ip6_output.c

1106

struct dst_entry **dst, struct flowi6 *fl6)

net/ipv6/ip6_output.c

1128

*dst = ip6_route_output(net, sk, fl6);

net/ipv6/ip6_output.c

1129

rt = (*dst)->error ? NULL : dst_rt6_info(*dst);

net/ipv6/ip6_output.c

114

if (lwtunnel_xmit_redirect(dst->lwtstate)) {

net/ipv6/ip6_output.c

1146

if ((*dst)->error) {

net/ipv6/ip6_output.c

1147

dst_release(*dst);

net/ipv6/ip6_output.c

1148

*dst = NULL;

net/ipv6/ip6_output.c

1155

if (!*dst)

net/ipv6/ip6_output.c

1156

*dst = ip6_route_output_flags(net, sk, fl6, flags);

net/ipv6/ip6_output.c

1158

err = (*dst)->error;

net/ipv6/ip6_output.c

1171

rt = dst_rt6_info(*dst);

net/ipv6/ip6_output.c

1173

n = __ipv6_neigh_lookup_noref(rt->dst.dev,

net/ipv6/ip6_output.c

1184

(*dst)->dev, 1);

net/ipv6/ip6_output.c

1195

dst_release(*dst);

net/ipv6/ip6_output.c

1198

*dst = ip6_route_output(net, sk, &fl_gw6);

net/ipv6/ip6_output.c

1199

err = (*dst)->error;

net/ipv6/ip6_output.c

1214

dst_release(*dst);

net/ipv6/ip6_output.c

1215

*dst = NULL;

net/ipv6/ip6_output.c

123

nexthop = rt6_nexthop(dst_rt6_info(dst), daddr);

net/ipv6/ip6_output.c

1233

int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst,

net/ipv6/ip6_output.c

1236

*dst = NULL;

net/ipv6/ip6_output.c

1237

return ip6_dst_lookup_tail(net, sk, dst, fl6);

net/ipv6/ip6_output.c

1256

struct dst_entry *dst = NULL;

net/ipv6/ip6_output.c

1259

err = ip6_dst_lookup_tail(net, sk, &dst, fl6);

net/ipv6/ip6_output.c

1265

return xfrm_lookup_route(net, dst, flowi6_to_flowi(fl6), sk, 0);

net/ipv6/ip6_output.c

1291

struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);

net/ipv6/ip6_output.c

1293

dst = ip6_sk_dst_check(sk, dst, fl6);

net/ipv6/ip6_output.c

1294

if (dst)

net/ipv6/ip6_output.c

1295

return dst;

net/ipv6/ip6_output.c

1297

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_dst);

net/ipv6/ip6_output.c

1298

if (connected && !IS_ERR(dst))

net/ipv6/ip6_output.c

1299

ip6_sk_dst_store_flow(sk, dst_clone(dst), fl6);

net/ipv6/ip6_output.c

1301

return dst;

net/ipv6/ip6_output.c

1324

if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {

net/ipv6/ip6_output.c

1327

*mtu = orig_mtu - rt->dst.header_len;

net/ipv6/ip6_output.c

1353

cork->base.dst = &rt->dst;

net/ipv6/ip6_output.c

1391

if (rt->dst.flags & DST_XFRM_TUNNEL)

net/ipv6/ip6_output.c

1393

READ_ONCE(rt->dst.dev->mtu) : dst6_mtu(&rt->dst);

net/ipv6/ip6_output.c

1396

READ_ONCE(rt->dst.dev->mtu) : dst6_mtu(xfrm_dst_path(&rt->dst));

net/ipv6/ip6_output.c

1441

struct rt6_info *rt = dst_rt6_info(cork->dst);

net/ipv6/ip6_output.c

1451

dst_exthdrlen = rt->dst.header_len - rt->rt6i_nfheader_len;

net/ipv6/ip6_output.c

1458

hh_len = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv6/ip6_output.c

1508

rt->dst.dev->features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))

net/ipv6/ip6_output.c

1521

if ((rt->dst.dev->features & NETIF_F_SG) &&

net/ipv6/ip6_output.c

1533

if (rt->dst.dev->features & NETIF_F_SG &&

net/ipv6/ip6_output.c

1545

if (rt->dst.dev->features & NETIF_F_SG &&

net/ipv6/ip6_output.c

1617

datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len;

net/ipv6/ip6_output.c

1623

alloc_extra += rt->dst.trailer_len;

net/ipv6/ip6_output.c

1632

!(rt->dst.dev->features&NETIF_F_SG))

net/ipv6/ip6_output.c

1636

!(rt->dst.dev->features & NETIF_F_SG)))

net/ipv6/ip6_output.c

1649

datalen += rt->dst.trailer_len;

net/ipv6/ip6_output.c

1745

if (!(rt->dst.dev->features&NETIF_F_SG) &&

net/ipv6/ip6_output.c

1843

dst_hold(&rt->dst);

net/ipv6/ip6_output.c

1865

struct dst_entry *dst = cork->base.dst;

net/ipv6/ip6_output.c

1867

cork->base.dst = NULL;

net/ipv6/ip6_output.c

1868

skb_dst_set(skb, dst);

net/ipv6/ip6_output.c

1886

if (cork->base.dst) {

net/ipv6/ip6_output.c

1887

dst_release(cork->base.dst);

net/ipv6/ip6_output.c

1888

cork->base.dst = NULL;

net/ipv6/ip6_output.c

1902

struct rt6_info *rt = dst_rt6_info(cork->base.dst);

net/ipv6/ip6_output.c

2044

dst_release(&rt->dst);

net/ipv6/ip6_output.c

228

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_output.c

235

dev = dst_dev_rcu(dst);

net/ipv6/ip6_output.c

236

idev = ip6_dst_idev(dst);

net/ipv6/ip6_output.c

273

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_output.c

274

struct inet6_dev *idev = ip6_dst_idev(dst);

net/ipv6/ip6_output.c

286

dev = dst_dev_rcu(dst);

net/ipv6/ip6_output.c

326

hlimit = ip6_dst_hoplimit(dst);

net/ipv6/ip6_output.c

342

mtu = dst6_mtu(dst);

net/ipv6/ip6_output.c

499

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_output.c

502

struct net *net = dev_net(dst_dev(dst));

net/ipv6/ip6_output.c

591

dst = skb_dst(skb);

net/ipv6/ip6_output.c

592

dev = dst_dev(dst);

net/ipv6/ip6_output.c

608

rt = dst_rt6_info(dst);

net/ipv6/ip6_output.c

62

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_output.c

63

struct net_device *dev = dst_dev_rcu(dst);

net/ipv6/ip6_output.c

637

__IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);

net/ipv6/ip6_output.c

639

mtu = ip6_dst_mtu_maybe_forward(dst, true);

net/ipv6/ip6_output.c

64

struct inet6_dev *idev = ip6_dst_idev(dst);

net/ipv6/ip6_output.c

648

__IP6_INC_STATS(net, ip6_dst_idev(dst),

net/ipv6/ip6_output.c

655

__IP6_INC_STATS(net, ip6_dst_idev(dst),

net/ipv6/ip6_output.c

919

hroom = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv6/ip6_output.c

967

IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),

net/ipv6/ip6_output.c

979

IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),

net/ipv6/ip6_output.c

987

IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),

net/ipv6/ip6_tunnel.c

1098

struct dst_entry *dst = NULL, *ndst = NULL;

net/ipv6/ip6_tunnel.c

1160

dst = dst_cache_get(&t->dst_cache);

net/ipv6/ip6_tunnel.c

1165

if (!dst) {

net/ipv6/ip6_tunnel.c

1170

dst = ip6_route_output(net, NULL, fl6);

net/ipv6/ip6_tunnel.c

1172

if (dst->error)

net/ipv6/ip6_tunnel.c

1174

dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), NULL, 0);

net/ipv6/ip6_tunnel.c

1175

if (IS_ERR(dst)) {

net/ipv6/ip6_tunnel.c

1176

err = PTR_ERR(dst);

net/ipv6/ip6_tunnel.c

1177

dst = NULL;

net/ipv6/ip6_tunnel.c

1181

ipv6_dev_get_saddr(net, ip6_dst_idev(dst)->dev,

net/ipv6/ip6_tunnel.c

1184

ndst = dst;

net/ipv6/ip6_tunnel.c

1187

tdev = dst_dev(dst);

net/ipv6/ip6_tunnel.c

1195

mtu = dst6_mtu(dst) - eth_hlen - psh_hlen - t->tun_hlen;

net/ipv6/ip6_tunnel.c

1249

skb_dst_set(skb, dst);

net/ipv6/ip6_tunnel.c

1257

hop_limit = ip6_dst_hoplimit(dst);

net/ipv6/ip6_tunnel.c

1264

+ dst->header_len + t->hlen;

net/ipv6/ip6_tunnel.c

1291

dst_release(dst);

net/ipv6/ip6_tunnel.c

1327

fl6.daddr = key->u.ipv6.dst;

net/ipv6/ip6_tunnel.c

1509

tdev = rt->dst.dev;

net/ipv6/ip6_tunnel.c

1843

struct dst_entry *dst;

net/ipv6/ip6_tunnel.c

1846

dst = ip6_route_output(dev_net(ctx->dev), NULL, &fl6);

net/ipv6/ip6_tunnel.c

1847

if (!dst->error) {

net/ipv6/ip6_tunnel.c

1853

ctx->dev = dst->dev;

net/ipv6/ip6_tunnel.c

1856

err = dst->error;

net/ipv6/ip6_tunnel.c

1857

dst_release(dst);

net/ipv6/ip6_tunnel.c

622

skb2->dev = rt->dst.dev;

net/ipv6/ip6_tunnel.c

631

if (IS_ERR(rt) || rt->dst.dev->type != ARPHRD_TUNNEL6) {

net/ipv6/ip6_tunnel.c

636

skb_dst_set(skb2, &rt->dst);

net/ipv6/ip6_tunnel.c

688

if (rt && rt->dst.dev)

net/ipv6/ip6_tunnel.c

689

skb2->dev = rt->dst.dev;

net/ipv6/ip6_udp_tunnel.c

145

struct dst_entry *dst = NULL;

net/ipv6/ip6_udp_tunnel.c

150

dst = dst_cache_get_ip6(dst_cache, saddr);

net/ipv6/ip6_udp_tunnel.c

151

if (dst)

net/ipv6/ip6_udp_tunnel.c

152

return dst;

net/ipv6/ip6_udp_tunnel.c

159

fl6.daddr = key->u.ipv6.dst;

net/ipv6/ip6_udp_tunnel.c

165

dst = ipv6_stub->ipv6_dst_lookup_flow(net, sock->sk, &fl6,

net/ipv6/ip6_udp_tunnel.c

167

if (IS_ERR(dst)) {

net/ipv6/ip6_udp_tunnel.c

171

if (dst_dev(dst) == dev) { /* is this necessary? */

net/ipv6/ip6_udp_tunnel.c

173

dst_release(dst);

net/ipv6/ip6_udp_tunnel.c

178

dst_cache_set_ip6(dst_cache, dst, &fl6.saddr);

net/ipv6/ip6_udp_tunnel.c

181

return dst;

net/ipv6/ip6_udp_tunnel.c

77

void udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,

net/ipv6/ip6_udp_tunnel.c

98

skb_dst_set(skb, dst);

net/ipv6/ip6_vti.c

412

const struct in6_addr *dst,

net/ipv6/ip6_vti.c

415

xfrm_address_t *daddr = (xfrm_address_t *)dst;

net/ipv6/ip6_vti.c

425

if (ipv6_addr_any(dst))

net/ipv6/ip6_vti.c

444

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ip6_vti.c

451

if (!dst) {

net/ipv6/ip6_vti.c

461

dst = &rt->dst;

net/ipv6/ip6_vti.c

462

skb_dst_set(skb, dst);

net/ipv6/ip6_vti.c

468

dst = ip6_route_output(dev_net(dev), NULL, &fl->u.ip6);

net/ipv6/ip6_vti.c

469

if (dst->error) {

net/ipv6/ip6_vti.c

470

dst_release(dst);

net/ipv6/ip6_vti.c

471

dst = NULL;

net/ipv6/ip6_vti.c

474

skb_dst_set(skb, dst);

net/ipv6/ip6_vti.c

481

dst_hold(dst);

net/ipv6/ip6_vti.c

482

dst = xfrm_lookup_route(t->net, dst, fl, NULL, 0);

net/ipv6/ip6_vti.c

483

if (IS_ERR(dst)) {

net/ipv6/ip6_vti.c

484

err = PTR_ERR(dst);

net/ipv6/ip6_vti.c

485

dst = NULL;

net/ipv6/ip6_vti.c

489

if (dst->flags & DST_XFRM_QUEUE)

net/ipv6/ip6_vti.c

492

x = dst->xfrm;

net/ipv6/ip6_vti.c

500

tdev = dst_dev(dst);

net/ipv6/ip6_vti.c

509

mtu = dst_mtu(dst);

net/ipv6/ip6_vti.c

531

skb_dst_set(skb, dst);

net/ipv6/ip6_vti.c

532

skb->dev = dst_dev(dst);

net/ipv6/ip6_vti.c

544

dst_release(dst);

net/ipv6/ip6_vti.c

682

tdev = rt->dst.dev;

net/ipv6/ip6mr.c

2044

struct dst_entry *dst;

net/ipv6/ip6mr.c

2069

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/ip6mr.c

2070

if (dst->error) {

net/ipv6/ip6mr.c

2071

dst_release(dst);

net/ipv6/ip6mr.c

2076

skb_dst_set(skb, dst);

net/ipv6/ipv6_sockglue.c

1181

struct dst_entry *dst;

net/ipv6/ipv6_sockglue.c

1185

dst = __sk_dst_get(sk);

net/ipv6/ipv6_sockglue.c

1186

if (dst)

net/ipv6/ipv6_sockglue.c

1187

val = dst6_mtu(dst);

net/ipv6/ipv6_sockglue.c

1274

struct dst_entry *dst;

net/ipv6/ipv6_sockglue.c

1284

dst = __sk_dst_get(sk);

net/ipv6/ipv6_sockglue.c

1285

if (dst)

net/ipv6/ipv6_sockglue.c

1286

mtuinfo.ip6m_mtu = dst6_mtu(dst);

net/ipv6/ipv6_sockglue.c

1314

struct dst_entry *dst;

net/ipv6/ipv6_sockglue.c

1323

dst = __sk_dst_get(sk);

net/ipv6/ipv6_sockglue.c

1324

if (dst)

net/ipv6/ipv6_sockglue.c

1325

val = ip6_dst_hoplimit(dst);

net/ipv6/mcast.c

1825

struct dst_entry *dst;

net/ipv6/mcast.c

183

dev = dst_dev_rcu(&rt->dst);

net/ipv6/mcast.c

1844

dst = icmp6_dst_alloc(skb->dev, &fl6);

net/ipv6/mcast.c

1847

if (IS_ERR(dst)) {

net/ipv6/mcast.c

1848

err = PTR_ERR(dst);

net/ipv6/mcast.c

1849

dst = NULL;

net/ipv6/mcast.c

1851

skb_dst_set(skb, dst);

net/ipv6/mcast.c

2170

struct dst_entry *dst;

net/ipv6/mcast.c

2226

dst = icmp6_dst_alloc(skb->dev, &fl6);

net/ipv6/mcast.c

2227

if (IS_ERR(dst)) {

net/ipv6/mcast.c

2228

err = PTR_ERR(dst);

net/ipv6/mcast.c

2232

skb_dst_set(skb, dst);

net/ipv6/mip6.c

112

struct in6_addr dst;

net/ipv6/mip6.c

176

const struct in6_addr *dst,

net/ipv6/mip6.c

185

!ipv6_addr_equal(&mip6_report_rl.dst, dst)) {

net/ipv6/mip6.c

189

mip6_report_rl.dst = *dst;

net/ipv6/ndisc.c

1667

struct dst_entry *dst;

net/ipv6/ndisc.c

1694

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/ndisc.c

1695

if (dst->error) {

net/ipv6/ndisc.c

1696

dst_release(dst);

net/ipv6/ndisc.c

1699

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);

net/ipv6/ndisc.c

1700

if (IS_ERR(dst))

net/ipv6/ndisc.c

1703

rt = dst_rt6_info(dst);

net/ipv6/ndisc.c

1770

skb_dst_set(buff, dst);

net/ipv6/ndisc.c

1775

dst_release(dst);

net/ipv6/ndisc.c

472

struct dst_entry *dst = skb_dst(skb);

net/ipv6/ndisc.c

486

if (!dst) {

net/ipv6/ndisc.c

491

dst = icmp6_dst_alloc(skb->dev, &fl6);

net/ipv6/ndisc.c

492

if (IS_ERR(dst)) {

net/ipv6/ndisc.c

498

skb_dst_set(skb, dst);

net/ipv6/ndisc.c

508

dev = dst_dev_rcu(dst);

net/ipv6/netfilter.c

103

int __nf_ip6_route(struct net *net, struct dst_entry **dst,

net/ipv6/netfilter.c

121

*dst = result;

net/ipv6/netfilter.c

30

struct dst_entry *dst;

net/ipv6/netfilter.c

49

dst = ip6_route_output(net, sk, &fl6);

net/ipv6/netfilter.c

50

err = dst->error;

net/ipv6/netfilter.c

52

IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);

net/ipv6/netfilter.c

54

dst_release(dst);

net/ipv6/netfilter.c

61

skb_dst_set(skb, dst);

net/ipv6/netfilter.c

70

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);

net/ipv6/netfilter.c

71

if (IS_ERR(dst))

net/ipv6/netfilter.c

72

return PTR_ERR(dst);

net/ipv6/netfilter.c

73

skb_dst_set(skb, dst);

net/ipv6/netfilter/ip6_tables.c

62

&ip6info->dst)))

net/ipv6/netfilter/ip6_tables.c

887

static void compat_standard_from_user(void *dst, const void *src)

net/ipv6/netfilter/ip6_tables.c

893

memcpy(dst, &v, sizeof(v));

net/ipv6/netfilter/ip6_tables.c

896

static int compat_standard_to_user(void __user *dst, const void *src)

net/ipv6/netfilter/ip6_tables.c

902

return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0;

net/ipv6/netfilter/ip6t_rpfilter.c

64

if (rt->dst.error)

net/ipv6/netfilter/nf_dup_ipv6.c

23

struct dst_entry *dst;

net/ipv6/netfilter/nf_dup_ipv6.c

34

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/netfilter/nf_dup_ipv6.c

35

if (dst->error) {

net/ipv6/netfilter/nf_dup_ipv6.c

36

dst_release(dst);

net/ipv6/netfilter/nf_dup_ipv6.c

40

skb_dst_set(skb, dst);

net/ipv6/netfilter/nf_dup_ipv6.c

41

skb->dev = dst_dev(dst);

net/ipv6/netfilter/nf_reject_ipv6.c

298

struct dst_entry *dst = NULL;

net/ipv6/netfilter/nf_reject_ipv6.c

303

nf_ip6_route(dev_net(skb_in->dev), &dst, &fl, false);

net/ipv6/netfilter/nf_reject_ipv6.c

304

if (!dst)

net/ipv6/netfilter/nf_reject_ipv6.c

307

skb_dst_set(skb_in, dst);

net/ipv6/netfilter/nf_reject_ipv6.c

315

struct dst_entry *dst = NULL;

net/ipv6/netfilter/nf_reject_ipv6.c

340

nf_ip6_route(net, &dst, flowi6_to_flowi(&fl6), false);

net/ipv6/netfilter/nf_reject_ipv6.c

341

if (!dst)

net/ipv6/netfilter/nf_reject_ipv6.c

343

skb_dst_set(oldskb, dst);

net/ipv6/netfilter/nf_reject_ipv6.c

349

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/netfilter/nf_reject_ipv6.c

350

if (dst->error) {

net/ipv6/netfilter/nf_reject_ipv6.c

351

dst_release(dst);

net/ipv6/netfilter/nf_reject_ipv6.c

354

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);

net/ipv6/netfilter/nf_reject_ipv6.c

355

if (IS_ERR(dst))

net/ipv6/netfilter/nf_reject_ipv6.c

359

sizeof(struct tcphdr) + dst->trailer_len,

net/ipv6/netfilter/nf_reject_ipv6.c

364

dst_release(dst);

net/ipv6/netfilter/nf_reject_ipv6.c

368

skb_dst_set(nskb, dst);

net/ipv6/netfilter/nf_reject_ipv6.c

373

nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, ip6_dst_hoplimit(dst));

net/ipv6/netfilter/nft_fib_ipv6.c

198

if (rt->dst.error)

net/ipv6/netfilter/nft_fib_ipv6.c

88

route_err = rt->dst.error;

net/ipv6/netfilter/nft_fib_ipv6.c

89

dst_release(&rt->dst);

net/ipv6/netfilter/nft_fib_ipv6.c

98

dst_release(&rt->dst);

net/ipv6/output_core.c

104

int ip6_dst_hoplimit(struct dst_entry *dst)

net/ipv6/output_core.c

106

int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);

net/ipv6/output_core.c

110

struct net_device *dev = dst_dev_rcu(dst);

net/ipv6/output_core.c

15

const struct in6_addr *dst,

net/ipv6/ping.c

152

dst = ip6_sk_dst_lookup_flow(sk, &fl6, daddr, false);

net/ipv6/ping.c

153

if (IS_ERR(dst))

net/ipv6/ping.c

154

return PTR_ERR(dst);

net/ipv6/ping.c

155

rt = dst_rt6_info(dst);

net/ipv6/ping.c

172

ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);

net/ipv6/ping.c

189

dst_release(dst);

net/ipv6/ping.c

72

struct dst_entry *dst;

net/ipv6/raw.c

603

int hlen = LL_RESERVED_SPACE(rt->dst.dev);

net/ipv6/raw.c

604

int tlen = rt->dst.dev->needed_tailroom;

net/ipv6/raw.c

606

if (length > rt->dst.dev->mtu) {

net/ipv6/raw.c

607

ipv6_local_error(sk, EMSGSIZE, fl6, rt->dst.dev->mtu);

net/ipv6/raw.c

646

skb_dst_set(skb, &rt->dst);

net/ipv6/raw.c

663

NULL, rt->dst.dev, dst_output);

net/ipv6/raw.c

752

struct dst_entry *dst = NULL;

net/ipv6/raw.c

894

dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);

net/ipv6/raw.c

895

if (IS_ERR(dst)) {

net/ipv6/raw.c

896

err = PTR_ERR(dst);

net/ipv6/raw.c

900

ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);

net/ipv6/raw.c

907

err = rawv6_send_hdrinc(sk, msg, len, &fl6, &dst,

net/ipv6/raw.c

913

len, 0, &ipc6, &fl6, dst_rt6_info(dst),

net/ipv6/raw.c

923

dst_release(dst);

net/ipv6/raw.c

930

dst_confirm_neigh(dst, &fl6.daddr);

net/ipv6/route.c

102

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv6/route.c

105

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,

net/ipv6/route.c

111

struct fib6_info *rt, struct dst_entry *dst,

net/ipv6/route.c

1112

rt->dst.error = ip6_rt_type_to_error(fib6_type);

net/ipv6/route.c

1116

rt->dst.output = dst_discard_out;

net/ipv6/route.c

1117

rt->dst.input = dst_discard;

net/ipv6/route.c

1120

rt->dst.output = ip6_pkt_prohibit_out;

net/ipv6/route.c

1121

rt->dst.input = ip6_pkt_prohibit;

net/ipv6/route.c

1126

rt->dst.output = ip6_pkt_discard_out;

net/ipv6/route.c

1127

rt->dst.input = ip6_pkt_discard;

net/ipv6/route.c

1141

rt->dst.error = 0;

net/ipv6/route.c

1142

rt->dst.output = ip6_output;

net/ipv6/route.c

1145

rt->dst.input = ip6_input;

net/ipv6/route.c

1147

rt->dst.input = ip6_mc_input;

net/ipv6/route.c

1148

rt->dst.output = ip6_mr_output;

net/ipv6/route.c

1150

rt->dst.input = ip6_forward;

net/ipv6/route.c

1154

rt->dst.lwtstate = lwtstate_get(res->nh->fib_nh_lws);

net/ipv6/route.c

1155

lwtunnel_set_redirect(&rt->dst);

net/ipv6/route.c

1158

rt->dst.lastuse = jiffies;

net/ipv6/route.c

1166

ip_dst_init_metrics(&rt->dst, from->fib6_metrics);

net/ipv6/route.c

1213

if (dst_hold_safe(&rt->dst))

net/ipv6/route.c

1217

dst_hold(&rt->dst);

net/ipv6/route.c

1248

dst_hold(&nrt->dst);

net/ipv6/route.c

1278

dst_hold(&rt->dst);

net/ipv6/route.c

1291

dst_use_noref(&rt->dst, jiffies);

net/ipv6/route.c

1320

struct dst_entry *dst;

net/ipv6/route.c

1328

dst = fib6_rule_lookup(net, &fl6, skb, flags, ip6_pol_route_lookup);

net/ipv6/route.c

1329

if (dst->error == 0)

net/ipv6/route.c

1330

return dst_rt6_info(dst);

net/ipv6/route.c

1332

dst_release(dst);

net/ipv6/route.c

142

rt->dst.rt_uncached_list = ul;

net/ipv6/route.c

1436

return rt6->sernum == rt_genid_ipv6(dev_net(rt6->dst.dev));

net/ipv6/route.c

145

list_add_tail(&rt->dst.rt_uncached, &ul->head);

net/ipv6/route.c

1453

dst_dev_put(&prev->dst);

net/ipv6/route.c

1454

dst_release(&prev->dst);

net/ipv6/route.c

1482

dst_dev_put(&pcpu_rt->dst);

net/ipv6/route.c

1483

dst_release(&pcpu_rt->dst);

net/ipv6/route.c

151

struct uncached_list *ul = rt->dst.rt_uncached_list;

net/ipv6/route.c

1512

net = dev_net(rt6_ex->rt6i->dst.dev);

net/ipv6/route.c

1518

dst_dev_put(&rt6_ex->rt6i->dst);

net/ipv6/route.c

1521

dst_release(&rt6_ex->rt6i->dst);

net/ipv6/route.c

1544

static u32 rt6_exception_hash(const struct in6_addr *dst,

net/ipv6/route.c

1549

struct in6_addr dst;

net/ipv6/route.c

155

list_del_init(&rt->dst.rt_uncached);

net/ipv6/route.c

1552

.dst = *dst,

net/ipv6/route.c

1713

struct net *net = dev_net(nrt->dst.dev);

net/ipv6/route.c

172

list_for_each_entry_safe(rt, safe, &ul->head, dst.rt_uncached) {

net/ipv6/route.c

174

struct net_device *rt_dev = rt->dst.dev;

net/ipv6/route.c

1753

if (dst_metric_raw(&nrt->dst, RTAX_MTU) >= fib6_mtu(res)) {

net/ipv6/route.c

184

rt->dst.dev = blackhole_netdev;

net/ipv6/route.c

186

&rt->dst.dev_tracker,

net/ipv6/route.c

191

list_del_init(&rt->dst.rt_uncached);

net/ipv6/route.c

2033

.dev = rt->dst.dev,

net/ipv6/route.c

2053

u32 dmtu = dst6_mtu(&rt->dst);

net/ipv6/route.c

2093

if (dst_metric_raw(&entry->dst, RTAX_MTU) &&

net/ipv6/route.c

2095

dst_metric_set(&entry->dst, RTAX_MTU, mtu);

net/ipv6/route.c

2150

if (time_after_eq(now, READ_ONCE(rt->dst.lastuse) +

net/ipv6/route.c

2156

} else if (time_after(jiffies, READ_ONCE(rt->dst.expires))) {

net/ipv6/route.c

2165

neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);

net/ipv6/route.c

224

static struct neighbour *ip6_dst_neigh_lookup(const struct dst_entry *dst,

net/ipv6/route.c

228

const struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/route.c

231

dst_dev(dst), skb, daddr);

net/ipv6/route.c

234

static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)

net/ipv6/route.c

236

const struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/route.c

237

struct net_device *dev = dst_dev(dst);

net/ipv6/route.c

2390

keys->addrs.v6addrs.dst = _flkeys->addrs.v6addrs.dst;

net/ipv6/route.c

2395

keys->addrs.v6addrs.dst = key_iph->daddr;

net/ipv6/route.c

2418

hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;

net/ipv6/route.c

2426

hash_keys.ports.dst = keys.ports.dst;

net/ipv6/route.c

2460

hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;

net/ipv6/route.c

2466

hash_keys.addrs.v6addrs.dst = keys.addrs.v6addrs.dst;

net/ipv6/route.c

2476

hash_keys.ports.dst = keys.ports.dst;

net/ipv6/route.c

2507

hash_keys.addrs.v6addrs.dst = fl6->daddr;

net/ipv6/route.c

2519

hash_keys.ports.dst = fl6->fl6_dport;

net/ipv6/route.c

2539

hash_keys.addrs.v6addrs.dst = fl6->daddr;

net/ipv6/route.c

2562

hash_keys.addrs.v6addrs.dst = flkeys->addrs.v6addrs.dst;

net/ipv6/route.c

2564

hash_keys.ports.dst = flkeys->ports.dst;

net/ipv6/route.c

2570

hash_keys.addrs.v6addrs.dst = fl6->daddr;

net/ipv6/route.c

2575

hash_keys.ports.dst = fl6->fl6_dport;

net/ipv6/route.c

2595

hash_keys.addrs.v4addrs.dst = flkeys->addrs.v4addrs.dst;

net/ipv6/route.c

2599

hash_keys.addrs.v6addrs.dst = flkeys->addrs.v6addrs.dst;

net/ipv6/route.c

2611

hash_keys.addrs.v6addrs.dst = fl6->daddr;

net/ipv6/route.c

2677

struct dst_entry *dst;

net/ipv6/route.c

2680

dst = l3mdev_link_scope_lookup(net, fl6);

net/ipv6/route.c

2681

if (dst)

net/ipv6/route.c

2682

return dst;

net/ipv6/route.c

2706

struct dst_entry *dst;

net/ipv6/route.c

2710

dst = ip6_route_output_flags_noref(net, sk, fl6, flags);

net/ipv6/route.c

2711

rt6 = dst_rt6_info(dst);

net/ipv6/route.c

2713

if (list_empty(&rt6->dst.rt_uncached) && !dst_hold_safe(dst)) {

net/ipv6/route.c

2714

dst = &net->ipv6.ip6_null_entry->dst;

net/ipv6/route.c

2715

dst_hold(dst);

net/ipv6/route.c

2719

return dst;

net/ipv6/route.c

2735

new = &rt->dst;

net/ipv6/route.c

2740

dst_copy_metrics(new, &ort->dst);

net/ipv6/route.c

2786

return &rt->dst;

net/ipv6/route.c

2794

READ_ONCE(rt->dst.obsolete) == DST_OBSOLETE_FORCE_CHK &&

net/ipv6/route.c

2796

return &rt->dst;

net/ipv6/route.c

2800

INDIRECT_CALLABLE_SCOPE struct dst_entry *ip6_dst_check(struct dst_entry *dst,

net/ipv6/route.c

2807

rt = dst_rt6_info(dst);

net/ipv6/route.c

2810

return rt6_is_valid(rt) ? dst : NULL;

net/ipv6/route.c

2822

unlikely(!list_empty(&rt->dst.rt_uncached))))

net/ipv6/route.c

2834

struct dst_entry *dst)

net/ipv6/route.c

2836

struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/route.c

2887

WRITE_ONCE(rt0->dst.expires, from->expires);

net/ipv6/route.c

2891

dst_set_expires(&rt0->dst, timeout);

net/ipv6/route.c

2897

struct net *net = dev_net(rt->dst.dev);

net/ipv6/route.c

2899

dst_metric_set(&rt->dst, RTAX_MTU, mtu);

net/ipv6/route.c

2910

static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,

net/ipv6/route.c

2915

struct rt6_info *rt6 = dst_rt6_info(dst);

net/ipv6/route.c

2934

dst_confirm_neigh(dst, daddr);

net/ipv6/route.c

2938

if (mtu >= dst6_mtu(dst))

net/ipv6/route.c

294

.dst = {

net/ipv6/route.c

2960

.dev = dst_dev_rcu(dst),

net/ipv6/route.c

2982

dst_release_immediate(&nrt6->dst);

net/ipv6/route.c

2989

static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv6/route.c

2993

__ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu,

net/ipv6/route.c

3001

struct dst_entry *dst;

net/ipv6/route.c

3011

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/route.c

3012

if (!dst->error)

net/ipv6/route.c

3013

__ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu), true);

net/ipv6/route.c

3014

dst_release(dst);

net/ipv6/route.c

3021

struct dst_entry *dst;

net/ipv6/route.c

3029

dst = __sk_dst_get(sk);

net/ipv6/route.c

3030

if (!dst || !READ_ONCE(dst->obsolete) ||

net/ipv6/route.c

3031

dst->ops->check(dst, inet6_sk(sk)->dst_cookie))

net/ipv6/route.c

3041

void ip6_sk_dst_store_flow(struct sock *sk, struct dst_entry *dst,

net/ipv6/route.c

3048

ip6_dst_store(sk, dst,

net/ipv6/route.c

308

.dst = {

net/ipv6/route.c

320

.dst = {

net/ipv6/route.c

3210

struct dst_entry *dst;

net/ipv6/route.c

3221

dst = ip6_route_redirect(net, &fl6, skb, &ipv6_hdr(skb)->saddr);

net/ipv6/route.c

3222

rt6_do_redirect(dst, NULL, skb);

net/ipv6/route.c

3223

dst_release(dst);

net/ipv6/route.c

3231

struct dst_entry *dst;

net/ipv6/route.c

3240

dst = ip6_route_redirect(net, &fl6, skb, &iph->saddr);

net/ipv6/route.c

3241

rt6_do_redirect(dst, NULL, skb);

net/ipv6/route.c

3242

dst_release(dst);

net/ipv6/route.c

3252

static unsigned int ip6_default_advmss(const struct dst_entry *dst)

net/ipv6/route.c

3254

unsigned int mtu = dst6_mtu(dst);

net/ipv6/route.c

3261

net = dst_dev_net_rcu(dst);

net/ipv6/route.c

3278

INDIRECT_CALLABLE_SCOPE unsigned int ip6_mtu(const struct dst_entry *dst)

net/ipv6/route.c

3280

return ip6_dst_mtu_maybe_forward(dst, false);

net/ipv6/route.c

3310

mtu = dst_metric_raw(&rt->dst, RTAX_MTU);

net/ipv6/route.c

3328

struct dst_entry *dst;

net/ipv6/route.c

3339

dst = ERR_PTR(-ENOMEM);

net/ipv6/route.c

3343

rt->dst.input = ip6_input;

net/ipv6/route.c

3344

rt->dst.output = ip6_output;

net/ipv6/route.c

3349

dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);

net/ipv6/route.c

335

memset_after(rt, 0, dst);

net/ipv6/route.c

3356

dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);

net/ipv6/route.c

3359

return dst;

net/ipv6/route.c

354

static void ip6_dst_destroy(struct dst_entry *dst)

net/ipv6/route.c

356

struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/route.c

360

ip_dst_metrics_put(dst);

net/ipv6/route.c

373

static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev)

net/ipv6/route.c

3741

dst_dev_put(&pcpu_rt->dst);

net/ipv6/route.c

3742

dst_release(&pcpu_rt->dst);

net/ipv6/route.c

375

struct rt6_info *rt = dst_rt6_info(dst);

net/ipv6/route.c

394

return time_after(jiffies, READ_ONCE(rt->dst.expires));

net/ipv6/route.c

405

if (time_after(jiffies, READ_ONCE(rt->dst.expires)))

net/ipv6/route.c

4075

if (cfg->fc_ifindex && rt->dst.dev->ifindex != cfg->fc_ifindex)

net/ipv6/route.c

408

return READ_ONCE(rt->dst.obsolete) != DST_OBSOLETE_FORCE_CHK ||

net/ipv6/route.c

4214

static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)

net/ipv6/route.c

4277

rt = dst_rt6_info(dst);

net/ipv6/route.c

4287

dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);

net/ipv6/route.c

4311

.dev = dst_dev_rcu(dst),

net/ipv6/route.c

4342

dst_release_immediate(&nrt->dst);

net/ipv6/route.c

4346

netevent.old = &rt->dst;

net/ipv6/route.c

4347

netevent.new = &nrt->dst;

net/ipv6/route.c

4596

struct dst_entry *dst = skb_dst(skb);

net/ipv6/route.c

4597

struct net_device *dev = dst_dev(dst);

net/ipv6/route.c

4607

idev = ip6_dst_idev(dst);

net/ipv6/route.c

5756

struct fib6_info *rt, struct dst_entry *dst,

net/ipv6/route.c

5761

struct rt6_info *rt6 = dst_rt6_info(dst);

net/ipv6/route.c

5847

pmetrics = dst ? dst_metrics_ptr(dst) : rt->fib6_metrics->metrics;

net/ipv6/route.c

5864

dev = dst_dev(dst);

net/ipv6/route.c

5868

if (lwtunnel_fill_encap(skb, dst->lwtstate, RTA_ENCAP, RTA_ENCAP_TYPE) < 0)

net/ipv6/route.c

5920

expires = dst ? READ_ONCE(dst->expires) : rt->expires;

net/ipv6/route.c

5924

if (!dst) {

net/ipv6/route.c

5933

if (rtnl_put_cacheinfo(skb, dst, 0, expires, dst ? dst->error : 0) < 0)

net/ipv6/route.c

6034

&rt6_ex->rt6i->dst, NULL, NULL, 0,

net/ipv6/route.c

6199

struct dst_entry *dst;

net/ipv6/route.c

6279

dst = ip6_route_input_lookup(net, dev, &fl6, NULL, flags);

net/ipv6/route.c

6285

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/route.c

6289

rt = dst_rt6_info(dst);

net/ipv6/route.c

6290

if (rt->dst.error) {

net/ipv6/route.c

6291

err = rt->dst.error;

net/ipv6/route.c

6297

err = rt->dst.error;

net/ipv6/route.c

6309

skb_dst_set(skb, &rt->dst);

net/ipv6/route.c

6320

err = rt6_fill_node(net, skb, from, dst, &fl6.daddr,

net/ipv6/route.c

6472

net->ipv6.ip6_null_entry->dst.dev = dev;

net/ipv6/route.c

6475

net->ipv6.ip6_prohibit_entry->dst.dev = dev;

net/ipv6/route.c

6477

net->ipv6.ip6_blk_hole_entry->dst.dev = dev;

net/ipv6/route.c

6676

net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;

net/ipv6/route.c

6677

dst_init_metrics(&net->ipv6.ip6_null_entry->dst,

net/ipv6/route.c

6679

INIT_LIST_HEAD(&net->ipv6.ip6_null_entry->dst.rt_uncached);

net/ipv6/route.c

6688

net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;

net/ipv6/route.c

6689

dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,

net/ipv6/route.c

6691

INIT_LIST_HEAD(&net->ipv6.ip6_prohibit_entry->dst.rt_uncached);

net/ipv6/route.c

6698

net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;

net/ipv6/route.c

6699

dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,

net/ipv6/route.c

6701

INIT_LIST_HEAD(&net->ipv6.ip6_blk_hole_entry->dst.rt_uncached);

net/ipv6/route.c

6819

init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;

net/ipv6/route.c

6822

init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;

net/ipv6/route.c

6824

init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;

net/ipv6/route.c

86

struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);

net/ipv6/route.c

87

static unsigned int ip6_default_advmss(const struct dst_entry *dst);

net/ipv6/route.c

89

unsigned int ip6_mtu(const struct dst_entry *dst);

net/ipv6/route.c

91

struct dst_entry *dst);

net/ipv6/rpl.c

13

static void ipv6_rpl_addr_decompress(struct in6_addr *dst,

net/ipv6/rpl.c

17

memcpy(dst, daddr, pfx);

net/ipv6/rpl.c

18

memcpy(&dst->s6_addr[pfx], post, IPV6_PFXTAIL_LEN(pfx));

net/ipv6/rpl.c

21

static void ipv6_rpl_addr_compress(void *dst, const struct in6_addr *addr,

net/ipv6/rpl.c

24

memcpy(dst, &addr->s6_addr[pfx], IPV6_PFXTAIL_LEN(pfx));

net/ipv6/rpl_iptunnel.c

193

struct dst_entry *dst = skb_dst(skb);

net/ipv6/rpl_iptunnel.c

199

tinfo = rpl_encap_lwtunnel(dst->lwtstate);

net/ipv6/rpl_iptunnel.c

207

struct dst_entry *dst = NULL;

net/ipv6/rpl_iptunnel.c

214

dst = dst_cache_get(&rlwt->cache);

net/ipv6/rpl_iptunnel.c

217

err = rpl_do_srh(skb, rlwt, dst);

net/ipv6/rpl_iptunnel.c

221

if (unlikely(!dst)) {

net/ipv6/rpl_iptunnel.c

232

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/rpl_iptunnel.c

233

if (dst->error) {

net/ipv6/rpl_iptunnel.c

234

err = dst->error;

net/ipv6/rpl_iptunnel.c

239

if (orig_dst->lwtstate != dst->lwtstate) {

net/ipv6/rpl_iptunnel.c

241

dst_cache_set_ip6(&rlwt->cache, dst, &fl6.saddr);

net/ipv6/rpl_iptunnel.c

245

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst_dev(dst)));

net/ipv6/rpl_iptunnel.c

251

skb_dst_set(skb, dst);

net/ipv6/rpl_iptunnel.c

256

dst_release(dst);

net/ipv6/rpl_iptunnel.c

264

struct dst_entry *dst = NULL;

net/ipv6/rpl_iptunnel.c

279

dst = dst_cache_get(&rlwt->cache);

net/ipv6/rpl_iptunnel.c

282

err = rpl_do_srh(skb, rlwt, dst);

net/ipv6/rpl_iptunnel.c

284

dst_release(dst);

net/ipv6/rpl_iptunnel.c

288

if (!dst) {

net/ipv6/rpl_iptunnel.c

290

dst = skb_dst(skb);

net/ipv6/rpl_iptunnel.c

293

if (!dst->error && lwtst != dst->lwtstate) {

net/ipv6/rpl_iptunnel.c

295

dst_cache_set_ip6(&rlwt->cache, dst,

net/ipv6/rpl_iptunnel.c

300

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst_dev(dst)));

net/ipv6/rpl_iptunnel.c

305

skb_dst_set(skb, dst);

net/ipv6/seg6_iptunnel.c

131

struct dst_entry *dst = skb_dst(skb);

net/ipv6/seg6_iptunnel.c

132

struct net_device *dev = dst_dev(dst);

net/ipv6/seg6_iptunnel.c

216

struct dst_entry *dst = skb_dst(skb);

net/ipv6/seg6_iptunnel.c

217

struct net_device *dev = dst_dev(dst);

net/ipv6/seg6_iptunnel.c

385

struct dst_entry *dst = skb_dst(skb);

net/ipv6/seg6_iptunnel.c

389

tinfo = seg6_encap_lwtunnel(dst->lwtstate);

net/ipv6/seg6_iptunnel.c

477

struct dst_entry *dst = NULL;

net/ipv6/seg6_iptunnel.c

492

dst = dst_cache_get(&slwt->cache_input);

net/ipv6/seg6_iptunnel.c

495

err = seg6_do_srh(skb, dst);

net/ipv6/seg6_iptunnel.c

497

dst_release(dst);

net/ipv6/seg6_iptunnel.c

501

if (!dst) {

net/ipv6/seg6_iptunnel.c

503

dst = skb_dst(skb);

net/ipv6/seg6_iptunnel.c

506

if (!dst->error && lwtst != dst->lwtstate) {

net/ipv6/seg6_iptunnel.c

508

dst_cache_set_ip6(&slwt->cache_input, dst,

net/ipv6/seg6_iptunnel.c

513

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst_dev(dst)));

net/ipv6/seg6_iptunnel.c

518

skb_dst_set(skb, dst);

net/ipv6/seg6_iptunnel.c

561

struct dst_entry *dst = NULL;

net/ipv6/seg6_iptunnel.c

568

dst = dst_cache_get(&slwt->cache_output);

net/ipv6/seg6_iptunnel.c

571

err = seg6_do_srh(skb, dst);

net/ipv6/seg6_iptunnel.c

575

if (unlikely(!dst)) {

net/ipv6/seg6_iptunnel.c

586

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/seg6_iptunnel.c

587

if (dst->error) {

net/ipv6/seg6_iptunnel.c

588

err = dst->error;

net/ipv6/seg6_iptunnel.c

593

if (orig_dst->lwtstate != dst->lwtstate) {

net/ipv6/seg6_iptunnel.c

595

dst_cache_set_ip6(&slwt->cache_output, dst, &fl6.saddr);

net/ipv6/seg6_iptunnel.c

599

err = skb_cow_head(skb, LL_RESERVED_SPACE(dst_dev(dst)));

net/ipv6/seg6_iptunnel.c

605

skb_dst_set(skb, dst);

net/ipv6/seg6_iptunnel.c

609

NULL, dst_dev(dst), dst_output);

net/ipv6/seg6_iptunnel.c

613

dst_release(dst);

net/ipv6/seg6_local.c

278

struct dst_entry *dst = NULL;

net/ipv6/seg6_local.c

296

dst = ip6_route_input_lookup(net, skb->dev, &fl6, skb, flags);

net/ipv6/seg6_local.c

305

dst = &rt->dst;

net/ipv6/seg6_local.c

307

dst = ip6_route_output(net, NULL, &fl6);

net/ipv6/seg6_local.c

316

if (dst && (dst_dev(dst)->flags & dev_flags) && !dst->error) {

net/ipv6/seg6_local.c

317

dst_release(dst);

net/ipv6/seg6_local.c

318

dst = NULL;

net/ipv6/seg6_local.c

322

if (!dst) {

net/ipv6/seg6_local.c

324

dst = &rt->dst;

net/ipv6/seg6_local.c

325

dst_hold(dst);

net/ipv6/seg6_local.c

329

skb_dst_set(skb, dst);

net/ipv6/seg6_local.c

330

return dst->error;

net/ipv6/sit.c

1112

tdev = rt->dst.dev;

net/ipv6/sit.c

846

__be32 dst = 0;

net/ipv6/sit.c

847

check_6rd(tunnel, v6dst, &dst);

net/ipv6/sit.c

848

return dst;

net/ipv6/sit.c

851

static bool ipip6_tunnel_dst_find(struct sk_buff *skb, __be32 *dst,

net/ipv6/sit.c

874

*dst = addr6->s6_addr32[3];

net/ipv6/sit.c

884

*dst = addr6->s6_addr32[3];

net/ipv6/sit.c

910

__be32 dst = tiph->daddr;

net/ipv6/sit.c

922

!ipip6_tunnel_dst_find(skb, &dst, true))

net/ipv6/sit.c

925

if (!dst)

net/ipv6/sit.c

926

dst = try_6rd(tunnel, &iph6->daddr);

net/ipv6/sit.c

928

if (!dst && !ipip6_tunnel_dst_find(skb, &dst, false))

net/ipv6/sit.c

933

IPPROTO_IPV6, 0, dst, tiph->saddr, 0, 0,

net/ipv6/sit.c

943

dst_cache_set_ip4(&tunnel->dst_cache, &rt->dst, fl4.saddr);

net/ipv6/sit.c

951

tdev = rt->dst.dev;

net/ipv6/sit.c

965

mtu = dst4_mtu(&rt->dst) - t_hlen;

net/ipv6/syncookies.c

182

struct dst_entry *dst;

net/ipv6/syncookies.c

248

dst = ip6_dst_lookup_flow(net, sk, &fl6, final_p);

net/ipv6/syncookies.c

249

if (IS_ERR(dst)) {

net/ipv6/syncookies.c

255

req->rsk_window_clamp = READ_ONCE(tp->window_clamp) ? :dst_metric(dst, RTAX_WINDOW);

net/ipv6/syncookies.c

265

dst_metric(dst, RTAX_INITRWND));

net/ipv6/syncookies.c

272

ireq->ecn_ok &= cookie_ecn_ok(net, dst);

net/ipv6/syncookies.c

275

ret = tcp_get_cookie_sock(sk, skb, req, dst);

net/ipv6/tcp_ipv6.c

101

if (dst && dst_hold_safe(dst)) {

net/ipv6/tcp_ipv6.c

102

rcu_assign_pointer(sk->sk_rx_dst, dst);

net/ipv6/tcp_ipv6.c

104

sk->sk_rx_dst_cookie = rt6_get_cookie(dst_rt6_info(dst));

net/ipv6/tcp_ipv6.c

1350

struct dst_entry *dst,

net/ipv6/tcp_ipv6.c

1371

return tcp_v4_syn_recv_sock(sk, skb, req, dst,

net/ipv6/tcp_ipv6.c

1379

dst = inet6_csk_route_req(sk, dst, &fl6, req, IPPROTO_TCP);

net/ipv6/tcp_ipv6.c

1380

if (!dst)

net/ipv6/tcp_ipv6.c

1407

ip6_dst_store(newsk, dst, false, false);

net/ipv6/tcp_ipv6.c

145

struct dst_entry *dst;

net/ipv6/tcp_ipv6.c

1453

tcp_ca_openreq_child(newsk, dst);

net/ipv6/tcp_ipv6.c

1455

tcp_sync_mss(newsk, dst6_mtu(dst));

net/ipv6/tcp_ipv6.c

1456

newtp->advmss = tcp_mss_clamp(tcp_sk(sk), dst_metric_advmss(dst));

net/ipv6/tcp_ipv6.c

1512

dst_release(dst);

net/ipv6/tcp_ipv6.c

1577

struct dst_entry *dst;

net/ipv6/tcp_ipv6.c

1579

dst = rcu_dereference_protected(sk->sk_rx_dst,

net/ipv6/tcp_ipv6.c

1584

if (dst) {

net/ipv6/tcp_ipv6.c

1586

INDIRECT_CALL_1(dst->ops->check, ip6_dst_check,

net/ipv6/tcp_ipv6.c

1587

dst, sk->sk_rx_dst_cookie) == NULL) {

net/ipv6/tcp_ipv6.c

1589

dst_release(dst);

net/ipv6/tcp_ipv6.c

1987

struct dst_entry *dst = rcu_dereference(sk->sk_rx_dst);

net/ipv6/tcp_ipv6.c

1989

if (dst)

net/ipv6/tcp_ipv6.c

1990

dst = dst_check(dst, sk->sk_rx_dst_cookie);

net/ipv6/tcp_ipv6.c

1991

if (dst &&

net/ipv6/tcp_ipv6.c

1993

skb_dst_set_noref(skb, dst);

net/ipv6/tcp_ipv6.c

278

dst = ip6_dst_lookup_flow(net, sk, fl6, final_p);

net/ipv6/tcp_ipv6.c

279

if (IS_ERR(dst)) {

net/ipv6/tcp_ipv6.c

280

err = PTR_ERR(dst);

net/ipv6/tcp_ipv6.c

284

tp->tcp_usec_ts = dst_tcp_usec_ts(dst);

net/ipv6/tcp_ipv6.c

300

ip6_dst_store(sk, dst, false, false);

net/ipv6/tcp_ipv6.c

353

struct dst_entry *dst;

net/ipv6/tcp_ipv6.c

367

dst = inet6_csk_update_pmtu(sk, mtu);

net/ipv6/tcp_ipv6.c

368

if (!dst)

net/ipv6/tcp_ipv6.c

371

dmtu = dst6_mtu(dst);

net/ipv6/tcp_ipv6.c

449

struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);

net/ipv6/tcp_ipv6.c

451

if (dst)

net/ipv6/tcp_ipv6.c

452

dst->ops->redirect(dst, sk, skb);

net/ipv6/tcp_ipv6.c

525

static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,

net/ipv6/tcp_ipv6.c

541

if (!dst && (dst = inet6_csk_route_req(sk, NULL, fl6, req,

net/ipv6/tcp_ipv6.c

545

skb = tcp_make_synack(sk, dst, req, foc, synack_type, syn_skb);

net/ipv6/tcp_ipv6.c

832

struct dst_entry *dst;

net/ipv6/tcp_ipv6.c

955

dst = ip6_dst_lookup_flow(net, sk, &fl6, NULL); /*sk's xfrm_policy can be referred*/

net/ipv6/tcp_ipv6.c

957

dst = ip6_dst_lookup_flow(net, ctl_sk, &fl6, NULL);

net/ipv6/tcp_ipv6.c

958

if (!IS_ERR(dst)) {

net/ipv6/tcp_ipv6.c

959

skb_dst_set(buff, dst);

net/ipv6/tcp_ipv6.c

99

struct dst_entry *dst = skb_dst(skb);

net/ipv6/udp.c

1047

static void udp6_sk_rx_dst_set(struct sock *sk, struct dst_entry *dst)

net/ipv6/udp.c

1049

if (udp_sk_rx_dst_set(sk, dst))

net/ipv6/udp.c

1050

sk->sk_rx_dst_cookie = rt6_get_cookie(dst_rt6_info(dst));

net/ipv6/udp.c

1123

struct dst_entry *dst = skb_dst(skb);

net/ipv6/udp.c

1126

if (unlikely(rcu_dereference(sk->sk_rx_dst) != dst))

net/ipv6/udp.c

1127

udp6_sk_rx_dst_set(sk, dst);

net/ipv6/udp.c

1228

struct dst_entry *dst;

net/ipv6/udp.c

1252

dst = rcu_dereference(sk->sk_rx_dst);

net/ipv6/udp.c

1254

if (dst)

net/ipv6/udp.c

1255

dst = dst_check(dst, sk->sk_rx_dst_cookie);

net/ipv6/udp.c

1256

if (dst) {

net/ipv6/udp.c

1261

skb_dst_set_noref(skb, dst);

net/ipv6/udp.c

1490

struct dst_entry *dst;

net/ipv6/udp.c

1572

dst = NULL;

net/ipv6/udp.c

1709

dst = ip6_sk_dst_lookup_flow(sk, fl6, final_p, connected);

net/ipv6/udp.c

1710

if (IS_ERR(dst)) {

net/ipv6/udp.c

1711

err = PTR_ERR(dst);

net/ipv6/udp.c

1712

dst = NULL;

net/ipv6/udp.c

1717

ipc6.hlimit = ip6_sk_dst_hoplimit(np, fl6, dst);

net/ipv6/udp.c

1729

dst_rt6_info(dst),

net/ipv6/udp.c

1754

&ipc6, fl6, dst_rt6_info(dst),

net/ipv6/udp.c

1768

dst_release(dst);

net/ipv6/udp.c

1789

dst_confirm_neigh(dst, &fl6->daddr);

net/ipv6/xfrm6_input.c

258

xfrm_address_t *dst, *src;

net/ipv6/xfrm6_input.c

262

dst = daddr;

net/ipv6/xfrm6_input.c

267

dst = daddr;

net/ipv6/xfrm6_input.c

272

dst = (xfrm_address_t *)&in6addr_any;

net/ipv6/xfrm6_input.c

277

x = xfrm_state_lookup_byaddr(net, skb->mark, dst, src, proto, AF_INET6);

net/ipv6/xfrm6_output.c

63

struct dst_entry *dst = skb_dst(skb);

net/ipv6/xfrm6_output.c

64

struct xfrm_state *x = dst->xfrm;

net/ipv6/xfrm6_policy.c

107

static void xfrm6_update_pmtu(struct dst_entry *dst, struct sock *sk,

net/ipv6/xfrm6_policy.c

111

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv6/xfrm6_policy.c

117

static void xfrm6_redirect(struct dst_entry *dst, struct sock *sk,

net/ipv6/xfrm6_policy.c

120

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv6/xfrm6_policy.c

126

static void xfrm6_dst_destroy(struct dst_entry *dst)

net/ipv6/xfrm6_policy.c

128

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/ipv6/xfrm6_policy.c

130

dst_destroy_metrics_generic(dst);

net/ipv6/xfrm6_policy.c

137

static void xfrm6_dst_ifdown(struct dst_entry *dst, struct net_device *dev)

net/ipv6/xfrm6_policy.c

141

xdst = (struct xfrm_dst *)dst;

net/ipv6/xfrm6_policy.c

150

xdst = (struct xfrm_dst *)xfrm_dst_child(&xdst->u.dst);

net/ipv6/xfrm6_policy.c

151

} while (xdst->u.dst.xfrm);

net/ipv6/xfrm6_policy.c

156

xfrm_dst_ifdown(dst, dev);

net/ipv6/xfrm6_policy.c

29

struct dst_entry *dst;

net/ipv6/xfrm6_policy.c

43

dst = ip6_route_output(params->net, NULL, &fl6);

net/ipv6/xfrm6_policy.c

45

err = dst->error;

net/ipv6/xfrm6_policy.c

46

if (dst->error) {

net/ipv6/xfrm6_policy.c

47

dst_release(dst);

net/ipv6/xfrm6_policy.c

48

dst = ERR_PTR(err);

net/ipv6/xfrm6_policy.c

51

return dst;

net/ipv6/xfrm6_policy.c

57

struct dst_entry *dst;

net/ipv6/xfrm6_policy.c

62

dst = xfrm6_dst_lookup(params);

net/ipv6/xfrm6_policy.c

63

if (IS_ERR(dst))

net/ipv6/xfrm6_policy.c

66

idev = ip6_dst_idev(dst);

net/ipv6/xfrm6_policy.c

68

dst_release(dst);

net/ipv6/xfrm6_policy.c

74

dst_release(dst);

net/ipv6/xfrm6_policy.c

85

xdst->u.dst.dev = dev;

net/ipv6/xfrm6_policy.c

86

netdev_hold(dev, &xdst->u.dst.dev_tracker, GFP_ATOMIC);

net/ipv6/xfrm6_policy.c

90

netdev_put(dev, &xdst->u.dst.dev_tracker);

net/ipv6/xfrm6_protocol.c

79

struct dst_entry *dst;

net/ipv6/xfrm6_protocol.c

89

dst = ip6_route_input_lookup(dev_net(skb->dev), skb->dev, &fl6,

net/ipv6/xfrm6_protocol.c

91

if (dst->error)

net/ipv6/xfrm6_protocol.c

93

skb_dst_set(skb, dst);

net/iucv/af_iucv.c

101

static inline void high_nmcpy(unsigned char *dst, char *src)

net/iucv/af_iucv.c

103

memcpy(dst, src, 8);

net/iucv/af_iucv.c

106

static inline void low_nmcpy(unsigned char *dst, char *src)

net/iucv/af_iucv.c

108

memcpy(&dst[8], src, 8);

net/key/af_key.c

3538

const xfrm_address_t *src, const xfrm_address_t *dst)

net/key/af_key.c

3557

!pfkey_sockaddr_fill(dst, 0, (struct sockaddr *)(sa + socklen), family))

net/key/af_key.c

486

const struct sadb_address *dst)

net/key/af_key.c

490

if (!src || !dst)

net/key/af_key.c

494

d_addr = (const struct sockaddr *)(dst + 1);

net/l2tp/l2tp_core.h

289

struct dst_entry *dst;

net/l2tp/l2tp_core.h

292

dst = sk_dst_get(tunnel->sock);

net/l2tp/l2tp_core.h

293

if (!dst)

net/l2tp/l2tp_core.h

296

mtu = dst_mtu(dst);

net/l2tp/l2tp_core.h

297

dst_release(dst);

net/l2tp/l2tp_ip.c

506

sk_setup_caps(sk, &rt->dst);

net/l2tp/l2tp_ip.c

508

skb_dst_set(skb, &rt->dst);

net/l2tp/l2tp_ip.c

516

skb_dst_set_noref(skb, &rt->dst);

net/l2tp/l2tp_ip6.c

527

struct dst_entry *dst = NULL;

net/l2tp/l2tp_ip6.c

640

dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);

net/l2tp/l2tp_ip6.c

641

if (IS_ERR(dst)) {

net/l2tp/l2tp_ip6.c

642

err = PTR_ERR(dst);

net/l2tp/l2tp_ip6.c

647

ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);

net/l2tp/l2tp_ip6.c

657

&fl6, dst_rt6_info(dst),

net/l2tp/l2tp_ip6.c

665

dst_release(dst);

net/l2tp/l2tp_ip6.c

674

dst_confirm_neigh(dst, &fl6.daddr);

net/l3mdev/l3mdev.c

221

struct dst_entry *dst = NULL;

net/l3mdev/l3mdev.c

232

dst = dev->l3mdev_ops->l3mdev_link_scope_lookup(dev, fl6);

net/l3mdev/l3mdev.c

235

return dst;

net/mac80211/cfg.c

1286

ieee80211_copy_mbssid_beacon(u8 *pos, struct cfg80211_mbssid_elems *dst,

net/mac80211/cfg.c

1291

dst->cnt = src->cnt;

net/mac80211/cfg.c

1294

dst->elem[i].len = src->elem[i].len;

net/mac80211/cfg.c

1295

dst->elem[i].data = pos + offset;

net/mac80211/cfg.c

1296

offset += dst->elem[i].len;

net/mac80211/cfg.c

1303

ieee80211_copy_rnr_beacon(u8 *pos, struct cfg80211_rnr_elems *dst,

net/mac80211/cfg.c

1308

dst->cnt = src->cnt;

net/mac80211/cfg.c

1311

dst->elem[i].len = src->elem[i].len;

net/mac80211/cfg.c

1312

dst->elem[i].data = pos + offset;

net/mac80211/cfg.c

1313

offset += dst->elem[i].len;

net/mac80211/cfg.c

2549

const u8 *dst, const u8 *next_hop)

net/mac80211/cfg.c

2564

mpath = mesh_path_add(sdata, dst);

net/mac80211/cfg.c

2577

const u8 *dst)

net/mac80211/cfg.c

2581

if (dst)

net/mac80211/cfg.c

2582

return mesh_path_del(sdata, dst);

net/mac80211/cfg.c

2589

const u8 *dst, const u8 *next_hop)

net/mac80211/cfg.c

2605

mpath = mesh_path_lookup(sdata, dst);

net/mac80211/cfg.c

2664

u8 *dst, u8 *next_hop, struct mpath_info *pinfo)

net/mac80211/cfg.c

2673

mpath = mesh_path_lookup(sdata, dst);

net/mac80211/cfg.c

2678

memcpy(dst, mpath->dst, ETH_ALEN);

net/mac80211/cfg.c

2685

int idx, u8 *dst, u8 *next_hop,

net/mac80211/cfg.c

2699

memcpy(dst, mpath->dst, ETH_ALEN);

net/mac80211/cfg.c

2715

u8 *dst, u8 *mpp, struct mpath_info *pinfo)

net/mac80211/cfg.c

2724

mpath = mpp_path_lookup(sdata, dst);

net/mac80211/cfg.c

2729

memcpy(dst, mpath->dst, ETH_ALEN);

net/mac80211/cfg.c

2736

int idx, u8 *dst, u8 *mpp,

net/mac80211/cfg.c

2750

memcpy(dst, mpath->dst, ETH_ALEN);

net/mac80211/cfg.c

356

static int ieee80211_nan_conf_copy(struct cfg80211_nan_conf *dst,

net/mac80211/cfg.c

361

dst->master_pref = src->master_pref;

net/mac80211/cfg.c

364

dst->bands = src->bands;

net/mac80211/cfg.c

367

dst->scan_period = src->scan_period;

net/mac80211/cfg.c

368

dst->scan_dwell_time = src->scan_dwell_time;

net/mac80211/cfg.c

369

dst->discovery_beacon_interval =

net/mac80211/cfg.c

371

dst->enable_dw_notification = src->enable_dw_notification;

net/mac80211/cfg.c

372

memcpy(&dst->band_cfgs, &src->band_cfgs,

net/mac80211/cfg.c

373

sizeof(dst->band_cfgs));

net/mac80211/cfg.c

375

kfree(dst->cluster_id);

net/mac80211/cfg.c

376

dst->cluster_id = NULL;

net/mac80211/cfg.c

378

kfree(dst->extra_nan_attrs);

net/mac80211/cfg.c

379

dst->extra_nan_attrs = NULL;

net/mac80211/cfg.c

380

dst->extra_nan_attrs_len = 0;

net/mac80211/cfg.c

382

kfree(dst->vendor_elems);

net/mac80211/cfg.c

383

dst->vendor_elems = NULL;

net/mac80211/cfg.c

384

dst->vendor_elems_len = 0;

net/mac80211/cfg.c

387

dst->cluster_id = kmemdup(src->cluster_id, ETH_ALEN,

net/mac80211/cfg.c

389

if (!dst->cluster_id)

net/mac80211/cfg.c

394

dst->extra_nan_attrs = kmemdup(src->extra_nan_attrs,

net/mac80211/cfg.c

397

if (!dst->extra_nan_attrs)

net/mac80211/cfg.c

400

dst->extra_nan_attrs_len = src->extra_nan_attrs_len;

net/mac80211/cfg.c

404

dst->vendor_elems = kmemdup(src->vendor_elems,

net/mac80211/cfg.c

407

if (!dst->vendor_elems)

net/mac80211/cfg.c

410

dst->vendor_elems_len = src->vendor_elems_len;

net/mac80211/cfg.c

417

ieee80211_nan_conf_free(dst);

net/mac80211/fils_aead.c

133

sg_init_one(dst, out + AES_BLOCK_SIZE, plain_len);

net/mac80211/fils_aead.c

134

skcipher_request_set_crypt(req, src, dst, plain_len, v);

net/mac80211/fils_aead.c

152

struct scatterlist src[1], dst[1];

net/mac80211/fils_aead.c

192

sg_init_one(dst, out, crypt_len);

net/mac80211/fils_aead.c

193

skcipher_request_set_crypt(req, src, dst, crypt_len, iv);

net/mac80211/fils_aead.c

76

struct scatterlist src[1], dst[1];

net/mac80211/ieee80211_i.h

2641

const u8 *src, const u8 *dst,

net/mac80211/ieee80211_i.h

358

u8 dst[ETH_ALEN];

net/mac80211/mesh.c

843

entry->mpath->dst, sdata->vif.addr);

net/mac80211/mesh.h

106

u8 dst[ETH_ALEN];

net/mac80211/mesh.h

309

const u8 *dst);

net/mac80211/mesh.h

311

const u8 *dst);

net/mac80211/mesh.h

313

const u8 *dst, const u8 *mpp);

net/mac80211/mesh.h

323

mesh_path_add(struct ieee80211_sub_if_data *sdata, const u8 *dst);

net/mac80211/mesh_hwmp.c

1031

memcpy(preq_node->dst, mpath->dst, ETH_ALEN);

net/mac80211/mesh_hwmp.c

1084

mpath = mesh_path_lookup(sdata, preq_node->dst);

net/mac80211/mesh_hwmp.c

1135

target_flags, mpath->dst, mpath->sn, da, 0,

net/mac80211/mesh_pathtbl.c

1030

if (ether_addr_equal(mpath->dst, preq->dst)) {

net/mac80211/mesh_pathtbl.c

221

prepare_for_gate(skb, gate_mpath->dst, gate_mpath);

net/mac80211/mesh_pathtbl.c

232

gate_mpath->dst, skb_queue_len(&gate_mpath->frame_queue));

net/mac80211/mesh_pathtbl.c

243

static struct mesh_path *mpath_lookup(struct mesh_table *tbl, const u8 *dst,

net/mac80211/mesh_pathtbl.c

248

mpath = rhashtable_lookup(&tbl->rhead, dst, mesh_rht_params);

net/mac80211/mesh_pathtbl.c

268

mesh_path_lookup(struct ieee80211_sub_if_data *sdata, const u8 *dst)

net/mac80211/mesh_pathtbl.c

270

return mpath_lookup(&sdata->u.mesh.mesh_paths, dst, sdata);

net/mac80211/mesh_pathtbl.c

274

mpp_path_lookup(struct ieee80211_sub_if_data *sdata, const u8 *dst)

net/mac80211/mesh_pathtbl.c

276

return mpath_lookup(&sdata->u.mesh.mpp_paths, dst, sdata);

net/mac80211/mesh_pathtbl.c

32

.key_offset = offsetof(struct mesh_path, dst),

net/mac80211/mesh_pathtbl.c

362

mpath->dst, mpath->sdata->u.mesh.num_gates);

net/mac80211/mesh_pathtbl.c

388

mpath->dst, mpath->sdata->u.mesh.num_gates);

net/mac80211/mesh_pathtbl.c

404

const u8 *dst, gfp_t gfp_flags)

net/mac80211/mesh_pathtbl.c

412

memcpy(new_mpath->dst, dst, ETH_ALEN);

net/mac80211/mesh_pathtbl.c

557

memcpy(build.key.addr, mppath->dst, ETH_ALEN);

net/mac80211/mesh_pathtbl.c

681

const u8 *dst)

net/mac80211/mesh_pathtbl.c

686

if (ether_addr_equal(dst, sdata->vif.addr))

net/mac80211/mesh_pathtbl.c

690

if (is_multicast_ether_addr(dst))

net/mac80211/mesh_pathtbl.c

696

new_mpath = mesh_path_new(sdata, dst, GFP_ATOMIC);

net/mac80211/mesh_pathtbl.c

723

const u8 *dst, const u8 *mpp)

net/mac80211/mesh_pathtbl.c

729

if (ether_addr_equal(dst, sdata->vif.addr))

net/mac80211/mesh_pathtbl.c

733

if (is_multicast_ether_addr(dst))

net/mac80211/mesh_pathtbl.c

736

new_mpath = mesh_path_new(sdata, dst, GFP_ATOMIC);

net/mac80211/mesh_pathtbl.c

755

mesh_fast_tx_flush_addr(sdata, dst);

net/mac80211/mesh_pathtbl.c

788

mpath->dst, mpath->sn,

net/mac80211/mesh_pathtbl.c

816

mesh_fast_tx_flush_addr(mpath->sdata, mpath->dst);

net/mac80211/mesh_pathtbl.c

976

mpath_dbg(sdata, "Forwarding to %pM\n", gate->dst);

net/mac80211/mesh_pathtbl.c

983

gate->dst, gate->flags);

net/mac80211/mesh_pathtbl.c

988

mpath_dbg(sdata, "Sending to %pM\n", gate->dst);

net/mac80211/mlme.c

4463

const u8 *src, const u8 *dst,

net/mac80211/mlme.c

4469

skb = ieee80211_build_probe_req(sdata, src, dst, (u32)-1, channel,

net/mac80211/mlme.c

4479

u8 *dst = sdata->vif.cfg.ap_addr;

net/mac80211/mlme.c

4491

dst = NULL;

net/mac80211/mlme.c

4502

if (dst) {

net/mac80211/mlme.c

4503

sta = sta_info_get(sdata, dst);

net/mac80211/mlme.c

4512

ieee80211_mlme_send_probe_req(sdata, sdata->vif.addr, dst,

net/mac80211/scan.c

661

const u8 *src, const u8 *dst,

net/mac80211/scan.c

669

skb = ieee80211_build_probe_req(sdata, src, dst, ratemask, channel,

net/mac80211/tx.c

2726

mesh_path_del(sdata, mpath->dst);

net/mac80211/tx.c

2753

mesh_da = mpath->dst;

net/mac80211/util.c

1529

const u8 *src, const u8 *dst,

net/mac80211/util.c

1564

if (dst) {

net/mac80211/util.c

1566

memcpy(mgmt->da, dst, ETH_ALEN);

net/mac80211/util.c

1567

memcpy(mgmt->bssid, dst, ETH_ALEN);

net/mctp/af_mctp.c

197

struct mctp_dst dst;

net/mctp/af_mctp.c

236

rc = mctp_dst_from_extaddr(&dst, sock_net(sk),

net/mctp/af_mctp.c

245

addr->smctp_addr.s_addr, &dst);

net/mctp/af_mctp.c

250

hlen = LL_RESERVED_SPACE(dst.dev->dev) + sizeof(struct mctp_hdr);

net/mctp/af_mctp.c

270

rc = mctp_local_output(sk, &dst, skb, addr->smctp_addr.s_addr,

net/mctp/af_mctp.c

273

mctp_dst_release(&dst);

net/mctp/af_mctp.c

279

mctp_dst_release(&dst);

net/mctp/route.c

1011

mctp_dst_from_route(dst, 0, 0, rt);

net/mctp/route.c

1021

static int mctp_do_fragment_route(struct mctp_dst *dst, struct sk_buff *skb,

net/mctp/route.c

1094

rc = dst->output(dst, skb2);

net/mctp/route.c

1106

int mctp_local_output(struct sock *sk, struct mctp_dst *dst,

net/mctp/route.c

1119

KUNIT_STATIC_STUB_REDIRECT(mctp_local_output, sk, dst, skb, daddr,

net/mctp/route.c

1124

spin_lock_irqsave(&dst->dev->addrs_lock, flags);

net/mctp/route.c

1125

if (dst->dev->num_addrs == 0) {

net/mctp/route.c

1129

saddr = dst->dev->addrs[0];

net/mctp/route.c

1132

spin_unlock_irqrestore(&dst->dev->addrs_lock, flags);

net/mctp/route.c

1133

netid = READ_ONCE(dst->dev->net);

net/mctp/route.c

1165

skb->dev = dst->dev->dev;

net/mctp/route.c

1173

mtu = dst->mtu;

net/mctp/route.c

1178

rc = dst->output(dst, skb);

net/mctp/route.c

1180

rc = mctp_do_fragment_route(dst, skb, mtu, tag);

net/mctp/route.c

1325

struct mctp_dst dst;

net/mctp/route.c

1369

rc = mctp_route_lookup(net, cb->net, mh->dest, &dst);

net/mctp/route.c

1373

rc = mctp_route_lookup_null(net, dev, &dst);

net/mctp/route.c

1378

dst.output(&dst, skb);

net/mctp/route.c

1379

mctp_dst_release(&dst);

net/mctp/route.c

37

static int mctp_dst_discard(struct mctp_dst *dst, struct sk_buff *skb)

net/mctp/route.c

434

static int mctp_dst_input(struct mctp_dst *dst, struct sk_buff *skb)

net/mctp/route.c

621

static int mctp_dst_output(struct mctp_dst *dst, struct sk_buff *skb)

net/mctp/route.c

629

skb->dev = dst->dev->dev;

net/mctp/route.c

631

if (skb->len > dst->mtu) {

net/mctp/route.c

637

if (dst->halen) {

net/mctp/route.c

638

if (dst->halen != skb->dev->addr_len) {

net/mctp/route.c

643

daddr = dst->haddr;

net/mctp/route.c

646

if (mctp_neigh_lookup(dst->dev, dst->nexthop, daddr_buf) == 0)

net/mctp/route.c

657

mctp_flow_prepare_output(skb, dst->dev);

net/mctp/route.c

884

static void mctp_dst_from_route(struct mctp_dst *dst, mctp_eid_t eid,

net/mctp/route.c

888

dst->nexthop = eid;

net/mctp/route.c

889

dst->dev = route->dev;

net/mctp/route.c

890

dst->mtu = READ_ONCE(dst->dev->dev->mtu);

net/mctp/route.c

892

dst->mtu = min(dst->mtu, mtu);

net/mctp/route.c

893

dst->halen = 0;

net/mctp/route.c

894

dst->output = route->output;

net/mctp/route.c

897

int mctp_dst_from_extaddr(struct mctp_dst *dst, struct net *net, int ifindex,

net/mctp/route.c

904

if (halen > sizeof(dst->haddr))

net/mctp/route.c

922

dst->dev = dev;

net/mctp/route.c

923

dst->mtu = READ_ONCE(netdev->mtu);

net/mctp/route.c

924

dst->halen = halen;

net/mctp/route.c

925

dst->output = mctp_dst_output;

net/mctp/route.c

926

dst->nexthop = 0;

net/mctp/route.c

927

memcpy(dst->haddr, haddr, halen);

net/mctp/route.c

936

void mctp_dst_release(struct mctp_dst *dst)

net/mctp/route.c

938

mctp_dev_put(dst->dev);

net/mctp/route.c

957

mctp_eid_t daddr, struct mctp_dst *dst)

net/mctp/route.c

981

if (dst)

net/mctp/route.c

982

mctp_dst_from_route(dst, daddr, mtu, rt);

net/mctp/route.c

997

struct mctp_dst *dst)

net/mctp/test/route-test.c

1022

mctp_test_flow_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

1048

struct mctp_dst dst;

net/mctp/test/route-test.c

1057

mctp_test_dst_setup(test, &dst, dev, 68);

net/mctp/test/route-test.c

1082

rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);

net/mctp/test/route-test.c

1104

mctp_dst_release(&dst);

net/mctp/test/route-test.c

1115

struct mctp_dst dst;

net/mctp/test/route-test.c

1125

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

1137

rc = mctp_dst_input(&dst, skb);

net/mctp/test/route-test.c

1154

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

1160

struct mctp_dst dst = { 0 };

net/mctp/test/route-test.c

1173

rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);

net/mctp/test/route-test.c

1175

KUNIT_EXPECT_PTR_EQ(test, dst.dev, dev->mdev);

net/mctp/test/route-test.c

1176

KUNIT_EXPECT_EQ(test, dst.mtu, dev->ndev->mtu);

net/mctp/test/route-test.c

1177

KUNIT_EXPECT_EQ(test, dst.nexthop, 9);

net/mctp/test/route-test.c

1178

KUNIT_EXPECT_EQ(test, dst.halen, 0);

net/mctp/test/route-test.c

1180

mctp_dst_release(&dst);

net/mctp/test/route-test.c

1190

struct mctp_dst dst = { 0 };

net/mctp/test/route-test.c

1204

rc = mctp_route_lookup(&init_net, dev->mdev->net, 10, &dst);

net/mctp/test/route-test.c

1214

unsigned int dev, neigh, gw, dst;

net/mctp/test/route-test.c

1222

t->dev, t->neigh, t->gw, t->dst, t->exp);

net/mctp/test/route-test.c

1247

struct mctp_dst dst = { 0 };

net/mctp/test/route-test.c

1266

rt3 = mctp_test_create_route_gw(&init_net, netid, 11, 10, mtus->dst);

net/mctp/test/route-test.c

1269

rc = mctp_route_lookup(&init_net, dev->mdev->net, 11, &dst);

net/mctp/test/route-test.c

1271

KUNIT_EXPECT_EQ(test, dst.mtu, mtus->exp);

net/mctp/test/route-test.c

1273

mctp_dst_release(&dst);

net/mctp/test/route-test.c

1285

unsigned char dst[MCTP_TEST_LLADDR_LEN];

net/mctp/test/route-test.c

1303

memcpy(&hdr->dst, daddr, sizeof(hdr->dst));

net/mctp/test/route-test.c

1322

struct mctp_dst dst = { 0 };

net/mctp/test/route-test.c

1333

dst.dev = dev->mdev;

net/mctp/test/route-test.c

1334

__mctp_dev_get(dst.dev->dev);

net/mctp/test/route-test.c

1335

dst.mtu = 68;

net/mctp/test/route-test.c

1336

dst.nexthop = 9;

net/mctp/test/route-test.c

1369

rc = mctp_dst_output(&dst, skb);

net/mctp/test/route-test.c

1372

mctp_dst_release(&dst);

net/mctp/test/route-test.c

1380

KUNIT_EXPECT_MEMEQ(test, ll_hdr->dst, haddr_peer, sizeof(haddr_peer));

net/mctp/test/route-test.c

1396

#define LK(src, dst) RX_HDR(1, (src), (dst), FL_S | FL_E | FL_TO)

net/mctp/test/route-test.c

1507

struct mctp_dst dst;

net/mctp/test/route-test.c

1512

__mctp_route_test_init(test, &dev, &dst, &sock_ty0, rx->net);

net/mctp/test/route-test.c

1533

rc = mctp_dst_input(&dst, skb_pkt);

net/mctp/test/route-test.c

1565

__mctp_route_test_fini(test, dev, &dst, sock_ty0);

net/mctp/test/route-test.c

176

struct mctp_dst *dst,

net/mctp/test/route-test.c

190

mctp_test_dst_setup(test, dst, dev, 68);

net/mctp/test/route-test.c

208

struct mctp_dst *dst,

net/mctp/test/route-test.c

212

mctp_dst_release(dst);

net/mctp/test/route-test.c

227

struct mctp_dst dst;

net/mctp/test/route-test.c

233

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

240

rc = mctp_dst_input(&dst, skb);

net/mctp/test/route-test.c

25

struct mctp_dst dst;

net/mctp/test/route-test.c

257

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

296

struct mctp_dst dst;

net/mctp/test/route-test.c

303

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

312

rc = mctp_dst_input(&dst, skb);

net/mctp/test/route-test.c

326

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

435

struct mctp_dst dst;

net/mctp/test/route-test.c

446

mctp_test_dst_setup(test, &dst, dev, 68);

net/mctp/test/route-test.c

45

mctp_test_dst_setup(test, &dst, dev, mtu);

net/mctp/test/route-test.c

47

rc = mctp_do_fragment_route(&dst, skb, mtu, MCTP_TAG_OWNER);

net/mctp/test/route-test.c

472

rc = mctp_dst_input(&dst, skb);

net/mctp/test/route-test.c

486

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

561

struct mctp_dst dst;

net/mctp/test/route-test.c

579

__mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid);

net/mctp/test/route-test.c

590

__mctp_route_test_fini(test, t->dev, &t->dst, t->sock);

net/mctp/test/route-test.c

611

rc = mctp_dst_input(&t1.dst, t1.skb);

net/mctp/test/route-test.c

613

rc = mctp_dst_input(&t2.dst, t2.skb);

net/mctp/test/route-test.c

647

__mctp_route_test_init(test, &t->dev, &t->dst, &t->sock, t->netid);

net/mctp/test/route-test.c

670

__mctp_route_test_fini(test, t->dev, &t->dst, t->sock);

net/mctp/test/route-test.c

692

rc = mctp_dst_input(&t1.dst, t1.skb);

net/mctp/test/route-test.c

694

rc = mctp_dst_input(&t2.dst, t2.skb);

net/mctp/test/route-test.c

724

struct mctp_dst dst;

net/mctp/test/route-test.c

729

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

745

rc = mctp_dst_input(&dst, skb);

net/mctp/test/route-test.c

752

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

762

struct mctp_dst dst;

net/mctp/test/route-test.c

767

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

784

rc = mctp_dst_input(&dst, skbs[0]);

net/mctp/test/route-test.c

788

rc = mctp_dst_input(&dst, skbs[1]);

net/mctp/test/route-test.c

798

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

819

struct mctp_dst dst;

net/mctp/test/route-test.c

827

__mctp_route_test_init(test, &dev, &dst, &sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

866

rc = mctp_dst_input(&dst, skb[i]);

net/mctp/test/route-test.c

904

__mctp_route_test_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

911

struct mctp_dst *dst,

net/mctp/test/route-test.c

925

__mctp_route_test_init(test, &dev, dst, sock, MCTP_NET_ANY);

net/mctp/test/route-test.c

945

struct mctp_dst *dst,

net/mctp/test/route-test.c

948

__mctp_route_test_fini(test, dev, dst, sock);

net/mctp/test/route-test.c

956

struct mctp_dst dst;

net/mctp/test/route-test.c

962

mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 30);

net/mctp/test/route-test.c

964

rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);

net/mctp/test/route-test.c

979

mctp_test_flow_fini(test, dev, &dst, sock);

net/mctp/test/route-test.c

99

mctp_dst_release(&dst);

net/mctp/test/route-test.c

990

struct mctp_dst dst;

net/mctp/test/route-test.c

996

mctp_test_flow_init(test, &dev, &dst, &sock, &skb, 100);

net/mctp/test/route-test.c

998

rc = mctp_local_output(sock->sk, &dst, skb, dst_eid, MCTP_TAG_OWNER);

net/mctp/test/sock-test.c

73

struct mctp_dst *dst,

net/mctp/test/sock-test.c

80

KUNIT_EXPECT_PTR_EQ(test, dst->dev, cfg->dev->mdev);

net/mctp/test/sock-test.c

81

KUNIT_EXPECT_EQ(test, dst->halen, cfg->halen);

net/mctp/test/sock-test.c

82

KUNIT_EXPECT_MEMEQ(test, dst->haddr, cfg->haddr, dst->halen);

net/mctp/test/utils.c

171

void mctp_test_dst_setup(struct kunit *test, struct mctp_dst *dst,

net/mctp/test/utils.c

176

memset(dst, 0, sizeof(*dst));

net/mctp/test/utils.c

178

dst->dev = dev->mdev;

net/mctp/test/utils.c

179

__mctp_dev_get(dst->dev->dev);

net/mctp/test/utils.c

180

dst->mtu = mtu;

net/mctp/test/utils.c

181

dst->output = mctp_test_dst_output;

net/mctp/test/utils.c

96

static int mctp_test_dst_output(struct mctp_dst *dst, struct sk_buff *skb)

net/mctp/test/utils.c

98

skb->dev = dst->dev->dev;

net/mctp/test/utils.h

58

void mctp_test_dst_setup(struct kunit *test, struct mctp_dst *dst,

net/mpls/af_mpls.c

635

dev = rt->dst.dev;

net/mpls/af_mpls.c

656

struct dst_entry *dst;

net/mpls/af_mpls.c

664

dst = ipv6_stub->ipv6_dst_lookup_flow(net, NULL, &fl6, NULL);

net/mpls/af_mpls.c

665

if (IS_ERR(dst))

net/mpls/af_mpls.c

666

return ERR_CAST(dst);

net/mpls/af_mpls.c

668

dev = dst->dev;

net/mpls/af_mpls.c

670

dst_release(dst);

net/mpls/mpls_iptunnel.c

44

struct dst_entry *dst = skb_dst(skb);

net/mpls/mpls_iptunnel.c

55

out_dev = dst->dev;

net/mpls/mpls_iptunnel.c

59

!dst->lwtstate || skb_warn_if_lro(skb))

net/mpls/mpls_iptunnel.c

64

tun_encap_info = mpls_lwtunnel_encap(dst->lwtstate);

net/mpls/mpls_iptunnel.c

76

if (dst->ops->family == AF_INET) {

net/mpls/mpls_iptunnel.c

84

rt = dst_rtable(dst);

net/mpls/mpls_iptunnel.c

85

} else if (dst->ops->family == AF_INET6) {

net/mpls/mpls_iptunnel.c

93

rt6 = dst_rt6_info(dst);

net/mptcp/ctrl.c

505

struct dst_entry *dst;

net/mptcp/ctrl.c

508

dst = __sk_dst_get(sk);

net/mptcp/ctrl.c

509

dev = dst ? dst_dev_rcu(dst) : NULL;

net/mptcp/subflow.c

322

struct dst_entry *dst;

net/mptcp/subflow.c

328

dst = tcp_request_sock_ipv4_ops.route_req(sk, skb, fl, req, tw_isn);

net/mptcp/subflow.c

329

if (!dst)

net/mptcp/subflow.c

334

return dst;

net/mptcp/subflow.c

336

dst_release(dst);

net/mptcp/subflow.c

358

static int subflow_v4_send_synack(const struct sock *sk, struct dst_entry *dst,

net/mptcp/subflow.c

367

return tcp_request_sock_ipv4_ops.send_synack(sk, dst, fl, req, foc,

net/mptcp/subflow.c

372

static int subflow_v6_send_synack(const struct sock *sk, struct dst_entry *dst,

net/mptcp/subflow.c

381

return tcp_request_sock_ipv6_ops.send_synack(sk, dst, fl, req, foc,

net/mptcp/subflow.c

391

struct dst_entry *dst;

net/mptcp/subflow.c

397

dst = tcp_request_sock_ipv6_ops.route_req(sk, skb, fl, req, tw_isn);

net/mptcp/subflow.c

398

if (!dst)

net/mptcp/subflow.c

403

return dst;

net/mptcp/subflow.c

405

dst_release(dst);

net/mptcp/subflow.c

809

struct dst_entry *dst,

net/mptcp/subflow.c

859

child = listener->icsk_af_ops->syn_recv_sock(sk, skb, req, dst,

net/netfilter/ipvs/ip_vs_core.c

729

struct dst_entry *dst = skb_dst(skb);

net/netfilter/ipvs/ip_vs_core.c

731

if (dst->dev && !(dst->dev->flags & IFF_LOOPBACK) &&

net/netfilter/ipvs/ip_vs_ctl.c

2841

ip_vs_copy_service(struct ip_vs_service_entry *dst, struct ip_vs_service *src)

net/netfilter/ipvs/ip_vs_ctl.c

2849

dst->protocol = src->protocol;

net/netfilter/ipvs/ip_vs_ctl.c

2850

dst->addr = src->addr.ip;

net/netfilter/ipvs/ip_vs_ctl.c

2851

dst->port = src->port;

net/netfilter/ipvs/ip_vs_ctl.c

2852

dst->fwmark = src->fwmark;

net/netfilter/ipvs/ip_vs_ctl.c

2853

strscpy(dst->sched_name, sched_name, sizeof(dst->sched_name));

net/netfilter/ipvs/ip_vs_ctl.c

2854

dst->flags = src->flags;

net/netfilter/ipvs/ip_vs_ctl.c

2855

dst->timeout = src->timeout / HZ;

net/netfilter/ipvs/ip_vs_ctl.c

2856

dst->netmask = src->netmask;

net/netfilter/ipvs/ip_vs_ctl.c

2857

dst->num_dests = src->num_dests;

net/netfilter/ipvs/ip_vs_ctl.c

2859

ip_vs_export_stats_user(&dst->stats, &kstats);

net/netfilter/ipvs/ip_vs_ctl.c

77

struct dst_entry *dst = ip6_route_output(net, NULL, &fl6);

net/netfilter/ipvs/ip_vs_ctl.c

80

is_local = !dst->error && dst->dev && (dst->dev->flags & IFF_LOOPBACK);

net/netfilter/ipvs/ip_vs_ctl.c

82

dst_release(dst);

net/netfilter/ipvs/ip_vs_ctl.c

869

ip_vs_copy_stats(struct ip_vs_kstats *dst, struct ip_vs_stats *src)

net/netfilter/ipvs/ip_vs_ctl.c

871

#define IP_VS_SHOW_STATS_COUNTER(c) dst->c = src->kstats.c - src->kstats0.c

net/netfilter/ipvs/ip_vs_ctl.c

881

ip_vs_read_estimator(dst, src);

net/netfilter/ipvs/ip_vs_ctl.c

887

ip_vs_export_stats_user(struct ip_vs_stats_user *dst, struct ip_vs_kstats *src)

net/netfilter/ipvs/ip_vs_ctl.c

889

dst->conns = (u32)src->conns;

net/netfilter/ipvs/ip_vs_ctl.c

890

dst->inpkts = (u32)src->inpkts;

net/netfilter/ipvs/ip_vs_ctl.c

891

dst->outpkts = (u32)src->outpkts;

net/netfilter/ipvs/ip_vs_ctl.c

892

dst->inbytes = src->inbytes;

net/netfilter/ipvs/ip_vs_ctl.c

893

dst->outbytes = src->outbytes;

net/netfilter/ipvs/ip_vs_ctl.c

894

dst->cps = (u32)src->cps;

net/netfilter/ipvs/ip_vs_ctl.c

895

dst->inpps = (u32)src->inpps;

net/netfilter/ipvs/ip_vs_ctl.c

896

dst->outpps = (u32)src->outpps;

net/netfilter/ipvs/ip_vs_ctl.c

897

dst->inbps = (u32)src->inbps;

net/netfilter/ipvs/ip_vs_ctl.c

898

dst->outbps = (u32)src->outbps;

net/netfilter/ipvs/ip_vs_est.c

918

void ip_vs_read_estimator(struct ip_vs_kstats *dst, struct ip_vs_stats *stats)

net/netfilter/ipvs/ip_vs_est.c

922

dst->cps = (e->cps + 0x1FF) >> 10;

net/netfilter/ipvs/ip_vs_est.c

923

dst->inpps = (e->inpps + 0x1FF) >> 10;

net/netfilter/ipvs/ip_vs_est.c

924

dst->outpps = (e->outpps + 0x1FF) >> 10;

net/netfilter/ipvs/ip_vs_est.c

925

dst->inbps = (e->inbps + 0xF) >> 5;

net/netfilter/ipvs/ip_vs_est.c

926

dst->outbps = (e->outbps + 0xF) >> 5;

net/netfilter/ipvs/ip_vs_nfct.c

109

if (new_tuple.dst.protonum != IPPROTO_ICMP &&

net/netfilter/ipvs/ip_vs_nfct.c

110

new_tuple.dst.protonum != IPPROTO_ICMPV6)

net/netfilter/ipvs/ip_vs_nfct.c

113

new_tuple.dst.u3 = cp->vaddr;

net/netfilter/ipvs/ip_vs_nfct.c

114

if (new_tuple.dst.protonum != IPPROTO_ICMP &&

net/netfilter/ipvs/ip_vs_nfct.c

115

new_tuple.dst.protonum != IPPROTO_ICMPV6)

net/netfilter/ipvs/ip_vs_nfct.c

116

new_tuple.dst.u.tcp.port = cp->vport;

net/netfilter/ipvs/ip_vs_nfct.c

157

ip_vs_conn_fill_param(net_ipvs(net), exp->tuple.src.l3num, orig->dst.protonum,

net/netfilter/ipvs/ip_vs_nfct.c

159

&orig->dst.u3, orig->dst.u.tcp.port, &p);

net/netfilter/ipvs/ip_vs_nfct.c

170

new_reply.dst.u3 = cp->vaddr;

net/netfilter/ipvs/ip_vs_nfct.c

171

new_reply.dst.u.tcp.port = cp->vport;

net/netfilter/ipvs/ip_vs_nfct.c

251

.dst = { .protonum = cp->protocol, .dir = IP_CT_DIR_ORIGINAL } };

net/netfilter/ipvs/ip_vs_nfct.c

255

tuple.dst.u3 = cp->vaddr;

net/netfilter/ipvs/ip_vs_nfct.c

256

tuple.dst.u.all = cp->vport;

net/netfilter/ipvs/ip_vs_nfct.c

56

IP_VS_DBG_ADDR((T)->src.l3num, &(T)->dst.u3), \

net/netfilter/ipvs/ip_vs_nfct.c

57

ntohs((T)->dst.u.all), \

net/netfilter/ipvs/ip_vs_nfct.c

58

(T)->dst.protonum

net/netfilter/ipvs/ip_vs_xmit.c

100

dst->ops->check(dst, dest_dst->dst_cookie) == NULL)

net/netfilter/ipvs/ip_vs_xmit.c

1164

tdev = rt->dst.dev;

net/netfilter/ipvs/ip_vs_xmit.c

1309

tdev = rt->dst.dev;

net/netfilter/ipvs/ip_vs_xmit.c

153

return rt->dst.dev && rt->dst.dev->flags & IFF_LOOPBACK;

net/netfilter/ipvs/ip_vs_xmit.c

1558

if (skb_cow(skb, rt->dst.dev->hard_header_len))

net/netfilter/ipvs/ip_vs_xmit.c

1642

if (skb_cow(skb, rt->dst.dev->hard_header_len))

net/netfilter/ipvs/ip_vs_xmit.c

203

ort->dst.ops->update_pmtu(&ort->dst, sk, NULL, mtu, true);

net/netfilter/ipvs/ip_vs_xmit.c

256

struct dst_entry *dst = skb_dst(skb);

net/netfilter/ipvs/ip_vs_xmit.c

263

skb->dev = dst->dev;

net/netfilter/ipvs/ip_vs_xmit.c

341

if (!rt_dev_is_down(dst_dev_rcu(&rt->dst)))

net/netfilter/ipvs/ip_vs_xmit.c

342

__ip_vs_dst_set(dest, dest_dst, &rt->dst, 0);

net/netfilter/ipvs/ip_vs_xmit.c

348

rcuref_read(&rt->dst.__rcuref));

net/netfilter/ipvs/ip_vs_xmit.c

385

mtu = dst_mtu(&rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

387

mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);

net/netfilter/ipvs/ip_vs_xmit.c

415

skb_dst_set_noref(skb, &rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

417

skb_dst_set(skb, &rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

439

struct dst_entry *dst;

net/netfilter/ipvs/ip_vs_xmit.c

447

dst = ip6_route_output(net, NULL, &fl6);

net/netfilter/ipvs/ip_vs_xmit.c

448

if (dst->error)

net/netfilter/ipvs/ip_vs_xmit.c

451

return dst;

net/netfilter/ipvs/ip_vs_xmit.c

453

ipv6_dev_get_saddr(net, ip6_dst_idev(dst)->dev,

net/netfilter/ipvs/ip_vs_xmit.c

457

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);

net/netfilter/ipvs/ip_vs_xmit.c

458

if (IS_ERR(dst)) {

net/netfilter/ipvs/ip_vs_xmit.c

459

dst = NULL;

net/netfilter/ipvs/ip_vs_xmit.c

464

return dst;

net/netfilter/ipvs/ip_vs_xmit.c

467

dst_release(dst);

net/netfilter/ipvs/ip_vs_xmit.c

484

struct dst_entry *dst;

net/netfilter/ipvs/ip_vs_xmit.c

504

dst = __ip_vs_route_output_v6(net, &dest->addr.in6,

net/netfilter/ipvs/ip_vs_xmit.c

507

if (!dst) {

net/netfilter/ipvs/ip_vs_xmit.c

513

rt = dst_rt6_info(dst);

net/netfilter/ipvs/ip_vs_xmit.c

518

if (!rt_dev_is_down(dst_dev_rcu(&rt->dst)))

net/netfilter/ipvs/ip_vs_xmit.c

519

__ip_vs_dst_set(dest, dest_dst, &rt->dst, cookie);

net/netfilter/ipvs/ip_vs_xmit.c

525

rcuref_read(&rt->dst.__rcuref));

net/netfilter/ipvs/ip_vs_xmit.c

533

dst = __ip_vs_route_output_v6(net, daddr, ret_saddr, do_xfrm,

net/netfilter/ipvs/ip_vs_xmit.c

535

if (!dst)

net/netfilter/ipvs/ip_vs_xmit.c

537

rt = dst_rt6_info(dst);

net/netfilter/ipvs/ip_vs_xmit.c

552

dst_release(&rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

561

mtu = dst_mtu(&rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

563

mtu = dst_mtu(&rt->dst) - sizeof(struct ipv6hdr);

net/netfilter/ipvs/ip_vs_xmit.c

592

skb_dst_set_noref(skb, &rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

594

skb_dst_set(skb, &rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

600

dst_release(&rt->dst);

net/netfilter/ipvs/ip_vs_xmit.c

73

struct dst_entry *dst, u32 dst_cookie)

net/netfilter/ipvs/ip_vs_xmit.c

81

dest_dst->dst_cache = dst;

net/netfilter/ipvs/ip_vs_xmit.c

829

if (skb_cow(skb, rt->dst.dev->hard_header_len))

net/netfilter/ipvs/ip_vs_xmit.c

914

if (skb_cow(skb, rt->dst.dev->hard_header_len))

net/netfilter/ipvs/ip_vs_xmit.c

94

struct dst_entry *dst;

net/netfilter/ipvs/ip_vs_xmit.c

98

dst = dest_dst->dst_cache;

net/netfilter/ipvs/ip_vs_xmit.c

99

if (READ_ONCE(dst->obsolete) &&

net/netfilter/nf_conntrack_amanda.c

155

&tuple->src.u3, &tuple->dst.u3,

net/netfilter/nf_conntrack_amanda.c

185

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_amanda.c

195

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_bpf.c

102

tuple->dst.protonum = protonum;

net/netfilter/nf_conntrack_bpf.c

103

tuple->dst.dir = dir;

net/netfilter/nf_conntrack_bpf.c

72

union nf_inet_addr *src = dir ? &tuple->dst.u3 : &tuple->src.u3;

net/netfilter/nf_conntrack_bpf.c

73

union nf_inet_addr *dst = dir ? &tuple->src.u3 : &tuple->dst.u3;

net/netfilter/nf_conntrack_bpf.c

74

union nf_conntrack_man_proto *sport = dir ? (void *)&tuple->dst.u

net/netfilter/nf_conntrack_bpf.c

77

: (void *)&tuple->dst.u;

net/netfilter/nf_conntrack_bpf.c

89

dst->ip = bpf_tuple->ipv4.daddr;

net/netfilter/nf_conntrack_bpf.c

96

memcpy(dst->ip6, bpf_tuple->ipv6.daddr, sizeof(bpf_tuple->ipv6.daddr));

net/netfilter/nf_conntrack_broadcast.c

40

in_dev = __in_dev_get_rcu(rt->dst.dev);

net/netfilter/nf_conntrack_core.c

2139

nla_put_be16(skb, CTA_PROTO_DST_PORT, tuple->dst.u.tcp.port))

net/netfilter/nf_conntrack_core.c

2169

t->dst.u.tcp.port = nla_get_be16(tb[CTA_PROTO_DST_PORT]);

net/netfilter/nf_conntrack_core.c

224

offsetofend(struct nf_conntrack_tuple, dst.__nfct_hash_offsetend),

net/netfilter/nf_conntrack_core.c

2300

src_tuple = nf_ct_tuple(ct, !hash->tuple.dst.dir);

net/netfilter/nf_conntrack_core.c

262

tuple->dst.u.udp.port = inet_hdr->dport;

net/netfilter/nf_conntrack_core.c

302

tuple->dst.u3.ip = ap[1];

net/netfilter/nf_conntrack_core.c

306

memcpy(tuple->dst.u3.ip6, ap + 4, sizeof(tuple->dst.u3.ip6));

net/netfilter/nf_conntrack_core.c

310

tuple->dst.protonum = protonum;

net/netfilter/nf_conntrack_core.c

311

tuple->dst.dir = IP_CT_DIR_ORIGINAL;

net/netfilter/nf_conntrack_core.c

441

inverse->src.u3.ip = orig->dst.u3.ip;

net/netfilter/nf_conntrack_core.c

442

inverse->dst.u3.ip = orig->src.u3.ip;

net/netfilter/nf_conntrack_core.c

445

inverse->src.u3.in6 = orig->dst.u3.in6;

net/netfilter/nf_conntrack_core.c

446

inverse->dst.u3.in6 = orig->src.u3.in6;

net/netfilter/nf_conntrack_core.c

452

inverse->dst.dir = !orig->dst.dir;

net/netfilter/nf_conntrack_core.c

454

inverse->dst.protonum = orig->dst.protonum;

net/netfilter/nf_conntrack_core.c

456

switch (orig->dst.protonum) {

net/netfilter/nf_conntrack_core.c

465

inverse->src.u.all = orig->dst.u.all;

net/netfilter/nf_conntrack_core.c

466

inverse->dst.u.all = orig->src.u.all;

net/netfilter/nf_conntrack_expect.c

100

combined.dport = (__force __u16)tuple->dst.u.all;

net/netfilter/nf_conntrack_expect.c

102

combined.protonum = tuple->dst.protonum;

net/netfilter/nf_conntrack_expect.c

325

u_int8_t proto, const __be16 *src, const __be16 *dst)

net/netfilter/nf_conntrack_expect.c

352

exp->tuple.dst.protonum = proto;

net/netfilter/nf_conntrack_expect.c

377

memcpy(&exp->tuple.dst.u3, daddr, len);

net/netfilter/nf_conntrack_expect.c

378

if (sizeof(exp->tuple.dst.u3) > len)

net/netfilter/nf_conntrack_expect.c

380

memset((void *)&exp->tuple.dst.u3 + len, 0x00,

net/netfilter/nf_conntrack_expect.c

381

sizeof(exp->tuple.dst.u3) - len);

net/netfilter/nf_conntrack_expect.c

383

exp->tuple.dst.u.all = *dst;

net/netfilter/nf_conntrack_expect.c

671

expect->tuple.dst.protonum);

net/netfilter/nf_conntrack_expect.c

673

nf_ct_l4proto_find(expect->tuple.dst.protonum));

net/netfilter/nf_conntrack_expect.c

98

combined.dst_addr = tuple->dst.u3;

net/netfilter/nf_conntrack_ftp.c

109

get_ipv6_addr(const char *src, size_t dlen, struct in6_addr *dst, u_int8_t term)

net/netfilter/nf_conntrack_ftp.c

112

int ret = in6_pton(src, min_t(size_t, dlen, 0xffff), (u8 *)dst, term, &end);

net/netfilter/nf_conntrack_ftp.c

484

daddr = &ct->tuplehash[!dir].tuple.dst.u3;

net/netfilter/nf_conntrack_h323_main.c

1149

.tuple.dst.protonum = IPPROTO_TCP,

net/netfilter/nf_conntrack_h323_main.c

1158

.tuple.dst.protonum = IPPROTO_TCP,

net/netfilter/nf_conntrack_h323_main.c

1192

.dst.protonum = IPPROTO_TCP,

net/netfilter/nf_conntrack_h323_main.c

1193

.dst.u.tcp.port = port,

net/netfilter/nf_conntrack_h323_main.c

1196

memcpy(&tuple.dst.u3, addr, sizeof(tuple.dst.u3));

net/netfilter/nf_conntrack_h323_main.c

1235

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

1393

exp = find_expect(ct, &ct->tuplehash[dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

1469

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

1482

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

1506

if (!memcmp(&addr, &ct->tuplehash[dir].tuple.dst.u3, sizeof(addr))) {

net/netfilter/nf_conntrack_h323_main.c

1720

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_h323_main.c

1729

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_h323_main.c

236

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

246

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

251

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

305

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

311

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

584

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_h323_main.c

644

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

650

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

676

const union nf_inet_addr *dst,

net/netfilter/nf_conntrack_h323_main.c

690

fl2.daddr = dst->ip;

net/netfilter/nf_conntrack_h323_main.c

697

rt1->dst.dev == rt2->dst.dev)

net/netfilter/nf_conntrack_h323_main.c

699

dst_release(&rt2->dst);

net/netfilter/nf_conntrack_h323_main.c

701

dst_release(&rt1->dst);

net/netfilter/nf_conntrack_h323_main.c

714

fl2.daddr = dst->in6;

net/netfilter/nf_conntrack_h323_main.c

721

rt1->dst.dev == rt2->dst.dev)

net/netfilter/nf_conntrack_h323_main.c

723

dst_release(&rt2->dst);

net/netfilter/nf_conntrack_h323_main.c

725

dst_release(&rt1->dst);

net/netfilter/nf_conntrack_h323_main.c

774

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

841

memcmp(&addr, &ct->tuplehash[!dir].tuple.dst.u3, sizeof(addr))) {

net/netfilter/nf_conntrack_h323_main.c

843

&addr, ntohs(port), &ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

844

ntohs(ct->tuplehash[!dir].tuple.dst.u.tcp.port));

net/netfilter/nf_conntrack_h323_main.c

847

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_conntrack_h323_main.c

848

ct->tuplehash[!dir].tuple.dst.u.tcp.port);

net/netfilter/nf_conntrack_helper.c

370

cur->tuple.dst.protonum == me->tuple.dst.protonum) {

net/netfilter/nf_conntrack_helper.c

441

helper->tuple.dst.protonum = protonum;

net/netfilter/nf_conntrack_helper.c

47

return (((tuple->src.l3num << 8) | tuple->dst.protonum) ^

net/netfilter/nf_conntrack_helper.c

66

if (h->tuple.dst.protonum == protonum)

net/netfilter/nf_conntrack_irc.c

221

ct->tuplehash[!dir].tuple.dst.u3.ip != dcc_ip) ||

net/netfilter/nf_conntrack_irc.c

240

NULL, &tuple->dst.u3,

net/netfilter/nf_conntrack_labels.c

35

u32 *dst;

net/netfilter/nf_conntrack_labels.c

45

dst = (u32 *) labels->bits;

net/netfilter/nf_conntrack_labels.c

47

changed |= replace_u32(&dst[i], mask ? ~mask[i] : 0, data[i]);

net/netfilter/nf_conntrack_labels.c

51

replace_u32(&dst[i], 0, 0);

net/netfilter/nf_conntrack_netbios_ns.c

51

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_netlink.c

106

nla_put_in6_addr(skb, CTA_IP_V6_DST, &tuple->dst.u3.in6))

net/netfilter/nf_conntrack_netlink.c

1095

filter_tuple->dst.u3.ip != ct_tuple->dst.u3.ip)

net/netfilter/nf_conntrack_netlink.c

1105

!ipv6_addr_cmp(&filter_tuple->dst.u3.in6,

net/netfilter/nf_conntrack_netlink.c

1106

&ct_tuple->dst.u3.in6))

net/netfilter/nf_conntrack_netlink.c

1112

filter_tuple->dst.protonum != ct_tuple->dst.protonum)

net/netfilter/nf_conntrack_netlink.c

1115

switch (ct_tuple->dst.protonum) {

net/netfilter/nf_conntrack_netlink.c

1123

filter_tuple->dst.u.tcp.port != ct_tuple->dst.u.tcp.port)

net/netfilter/nf_conntrack_netlink.c

1128

filter_tuple->dst.u.icmp.type != ct_tuple->dst.u.icmp.type)

net/netfilter/nf_conntrack_netlink.c

1131

filter_tuple->dst.u.icmp.code != ct_tuple->dst.u.icmp.code)

net/netfilter/nf_conntrack_netlink.c

1139

filter_tuple->dst.u.icmp.type != ct_tuple->dst.u.icmp.type)

net/netfilter/nf_conntrack_netlink.c

1142

filter_tuple->dst.u.icmp.code != ct_tuple->dst.u.icmp.code)

net/netfilter/nf_conntrack_netlink.c

1317

t->dst.u3.ip = nla_get_in_addr(tb[CTA_IP_V4_DST]);

net/netfilter/nf_conntrack_netlink.c

1338

t->dst.u3.in6 = nla_get_in6_addr(tb[CTA_IP_V6_DST]);

net/netfilter/nf_conntrack_netlink.c

1391

tuple->dst.protonum = nla_get_u8(tb[CTA_PROTO_NUM]);

net/netfilter/nf_conntrack_netlink.c

1394

l4proto = nf_ct_l4proto_find(tuple->dst.protonum);

net/netfilter/nf_conntrack_netlink.c

148

l4proto = nf_ct_l4proto_find(tuple->dst.protonum);

net/netfilter/nf_conntrack_netlink.c

1516

tuple->dst.dir = IP_CT_DIR_REPLY;

net/netfilter/nf_conntrack_netlink.c

1518

tuple->dst.dir = IP_CT_DIR_ORIGINAL;

net/netfilter/nf_conntrack_netlink.c

2433

if (otuple.dst.protonum != rtuple.dst.protonum)

net/netfilter/nf_conntrack_netlink.c

2944

m.dst.protonum = tuple->dst.protonum;

net/netfilter/nf_conntrack_netlink.c

2953

l4proto = nf_ct_l4proto_find(tuple->dst.protonum);

net/netfilter/nf_conntrack_netlink.c

3029

nat_tuple.dst.protonum = nf_ct_protonum(master);

net/netfilter/nf_conntrack_netlink.c

79

if (nla_put_u8(skb, CTA_PROTO_NUM, tuple->dst.protonum))

net/netfilter/nf_conntrack_netlink.c

97

nla_put_in_addr(skb, CTA_IP_V4_DST, tuple->dst.u3.ip))

net/netfilter/nf_conntrack_ovs.c

60

if (helper->tuple.dst.protonum != proto)

net/netfilter/nf_conntrack_pptp.c

171

t.dst.protonum = IPPROTO_GRE;

net/netfilter/nf_conntrack_pptp.c

173

t.dst.u.gre.key = ct_pptp_info->pac_call_id;

net/netfilter/nf_conntrack_pptp.c

179

t.dst.protonum = IPPROTO_GRE;

net/netfilter/nf_conntrack_pptp.c

181

t.dst.u.gre.key = ct_pptp_info->pns_call_id;

net/netfilter/nf_conntrack_pptp.c

207

&ct->tuplehash[dir].tuple.dst.u3,

net/netfilter/nf_conntrack_pptp.c

216

&ct->tuplehash[dir].tuple.dst.u3,

net/netfilter/nf_conntrack_pptp.c

594

.tuple.dst.protonum = IPPROTO_TCP,

net/netfilter/nf_conntrack_proto.c

276

tuple.dst.u3.ip = inet->inet_daddr;

net/netfilter/nf_conntrack_proto.c

277

tuple.dst.u.tcp.port = inet->inet_dport;

net/netfilter/nf_conntrack_proto.c

279

tuple.dst.protonum = sk->sk_protocol;

net/netfilter/nf_conntrack_proto.c

283

if (tuple.dst.protonum != IPPROTO_TCP &&

net/netfilter/nf_conntrack_proto.c

284

tuple.dst.protonum != IPPROTO_SCTP)

net/netfilter/nf_conntrack_proto.c

297

.tuple.dst.u.tcp.port;

net/netfilter/nf_conntrack_proto.c

299

.tuple.dst.u3.ip;

net/netfilter/nf_conntrack_proto.c

335

tuple.dst.u3.in6 = sk->sk_v6_daddr;

net/netfilter/nf_conntrack_proto.c

336

tuple.dst.u.tcp.port = inet->inet_dport;

net/netfilter/nf_conntrack_proto.c

337

tuple.dst.protonum = sk->sk_protocol;

net/netfilter/nf_conntrack_proto.c

342

if (tuple.dst.protonum != IPPROTO_TCP &&

net/netfilter/nf_conntrack_proto.c

343

tuple.dst.protonum != IPPROTO_SCTP)

net/netfilter/nf_conntrack_proto.c

356

sin6.sin6_port = ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u.tcp.port;

net/netfilter/nf_conntrack_proto.c

359

&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3.in6,

net/netfilter/nf_conntrack_proto_gre.c

167

tuple->dst.u.all = 0;

net/netfilter/nf_conntrack_proto_gre.c

181

tuple->dst.u.gre.key = pgrehdr->call_id;

net/netfilter/nf_conntrack_proto_gre.c

65

!memcmp(&km->tuple.dst.u3, &t->dst.u3, sizeof(t->dst.u3)) &&

net/netfilter/nf_conntrack_proto_gre.c

66

km->tuple.dst.protonum == t->dst.protonum &&

net/netfilter/nf_conntrack_proto_gre.c

67

km->tuple.dst.u.all == t->dst.u.all;

net/netfilter/nf_conntrack_proto_icmp.c

170

ct_daddr = &ct->tuplehash[dir].tuple.dst.u3;

net/netfilter/nf_conntrack_proto_icmp.c

259

nla_put_u8(skb, CTA_PROTO_ICMP_TYPE, t->dst.u.icmp.type) ||

net/netfilter/nf_conntrack_proto_icmp.c

260

nla_put_u8(skb, CTA_PROTO_ICMP_CODE, t->dst.u.icmp.code))

net/netfilter/nf_conntrack_proto_icmp.c

282

tuple->dst.u.icmp.type = nla_get_u8(tb[CTA_PROTO_ICMP_TYPE]);

net/netfilter/nf_conntrack_proto_icmp.c

283

if (tuple->dst.u.icmp.type >= sizeof(invmap) ||

net/netfilter/nf_conntrack_proto_icmp.c

284

!invmap[tuple->dst.u.icmp.type])

net/netfilter/nf_conntrack_proto_icmp.c

292

tuple->dst.u.icmp.code = nla_get_u8(tb[CTA_PROTO_ICMP_CODE]);

net/netfilter/nf_conntrack_proto_icmp.c

37

tuple->dst.u.icmp.type = hp->type;

net/netfilter/nf_conntrack_proto_icmp.c

39

tuple->dst.u.icmp.code = hp->code;

net/netfilter/nf_conntrack_proto_icmp.c

59

if (orig->dst.u.icmp.type >= sizeof(invmap) ||

net/netfilter/nf_conntrack_proto_icmp.c

60

!invmap[orig->dst.u.icmp.type])

net/netfilter/nf_conntrack_proto_icmp.c

64

tuple->dst.u.icmp.type = invmap[orig->dst.u.icmp.type] - 1;

net/netfilter/nf_conntrack_proto_icmp.c

65

tuple->dst.u.icmp.code = orig->dst.u.icmp.code;

net/netfilter/nf_conntrack_proto_icmp.c

89

if (ct->tuplehash[0].tuple.dst.u.icmp.type >= sizeof(valid_new) ||

net/netfilter/nf_conntrack_proto_icmp.c

90

!valid_new[ct->tuplehash[0].tuple.dst.u.icmp.type]) {

net/netfilter/nf_conntrack_proto_icmp.c

93

ct->tuplehash[0].tuple.dst.u.icmp.type);

net/netfilter/nf_conntrack_proto_icmpv6.c

104

int type = ct->tuplehash[0].tuple.dst.u.icmp.type - 128;

net/netfilter/nf_conntrack_proto_icmpv6.c

236

nla_put_u8(skb, CTA_PROTO_ICMPV6_TYPE, t->dst.u.icmp.type) ||

net/netfilter/nf_conntrack_proto_icmpv6.c

237

nla_put_u8(skb, CTA_PROTO_ICMPV6_CODE, t->dst.u.icmp.code))

net/netfilter/nf_conntrack_proto_icmpv6.c

259

tuple->dst.u.icmp.type = nla_get_u8(tb[CTA_PROTO_ICMPV6_TYPE]);

net/netfilter/nf_conntrack_proto_icmpv6.c

260

if (tuple->dst.u.icmp.type < 128 ||

net/netfilter/nf_conntrack_proto_icmpv6.c

261

tuple->dst.u.icmp.type - 128 >= sizeof(invmap) ||

net/netfilter/nf_conntrack_proto_icmpv6.c

262

!invmap[tuple->dst.u.icmp.type - 128])

net/netfilter/nf_conntrack_proto_icmpv6.c

270

tuple->dst.u.icmp.code = nla_get_u8(tb[CTA_PROTO_ICMPV6_CODE]);

net/netfilter/nf_conntrack_proto_icmpv6.c

42

tuple->dst.u.icmp.type = hp->icmp6_type;

net/netfilter/nf_conntrack_proto_icmpv6.c

44

tuple->dst.u.icmp.code = hp->icmp6_code;

net/netfilter/nf_conntrack_proto_icmpv6.c

73

int type = orig->dst.u.icmp.type - 128;

net/netfilter/nf_conntrack_proto_icmpv6.c

78

tuple->dst.u.icmp.type = invmap[type] - 1;

net/netfilter/nf_conntrack_proto_icmpv6.c

79

tuple->dst.u.icmp.code = orig->dst.u.icmp.code;

net/netfilter/nf_conntrack_sane.c

153

&tuple->src.u3, &tuple->dst.u3,

net/netfilter/nf_conntrack_sip.c

1378

if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, &addr))

net/netfilter/nf_conntrack_sip.c

814

!nf_inet_addr_cmp(&exp->tuple.dst.u3, addr) ||

net/netfilter/nf_conntrack_sip.c

815

exp->tuple.dst.protonum != proto ||

net/netfilter/nf_conntrack_sip.c

816

exp->tuple.dst.u.udp.port != port)

net/netfilter/nf_conntrack_sip.c

874

struct dst_entry *dst = NULL;

net/netfilter/nf_conntrack_sip.c

881

nf_ip_route(net, &dst, &fl, false);

net/netfilter/nf_conntrack_sip.c

886

nf_ip6_route(net, &dst, &fl, false);

net/netfilter/nf_conntrack_sip.c

893

if (dst) {

net/netfilter/nf_conntrack_sip.c

894

bool external_media = (dst->dev == dev);

net/netfilter/nf_conntrack_sip.c

896

dst_release(dst);

net/netfilter/nf_conntrack_sip.c

919

tuple.dst.protonum = IPPROTO_UDP;

net/netfilter/nf_conntrack_sip.c

920

tuple.dst.u3 = *daddr;

net/netfilter/nf_conntrack_sip.c

921

tuple.dst.u.udp.port = port;

net/netfilter/nf_conntrack_sip.c

932

(!nf_inet_addr_cmp(&exp->saved_addr, &exp->tuple.dst.u3) ||

net/netfilter/nf_conntrack_sip.c

933

exp->saved_proto.udp.port != exp->tuple.dst.u.udp.port) &&

net/netfilter/nf_conntrack_sip.c

936

tuple.dst.u3 = exp->saved_addr;

net/netfilter/nf_conntrack_sip.c

937

tuple.dst.u.udp.port = exp->saved_proto.udp.port;

net/netfilter/nf_conntrack_sip.c

944

base_port = ntohs(tuple.dst.u.udp.port) & ~1;

net/netfilter/nf_conntrack_snmp.c

57

.tuple.dst.protonum = IPPROTO_UDP,

net/netfilter/nf_conntrack_standalone.c

42

&tuple->src.u3.ip, &tuple->dst.u3.ip);

net/netfilter/nf_conntrack_standalone.c

46

tuple->src.u3.ip6, tuple->dst.u3.ip6);

net/netfilter/nf_conntrack_standalone.c

55

tuple->dst.u.icmp.type,

net/netfilter/nf_conntrack_standalone.c

56

tuple->dst.u.icmp.code,

net/netfilter/nf_conntrack_standalone.c

62

ntohs(tuple->dst.u.tcp.port));

net/netfilter/nf_conntrack_standalone.c

68

ntohs(tuple->dst.u.udp.port));

net/netfilter/nf_conntrack_standalone.c

74

ntohs(tuple->dst.u.sctp.port));

net/netfilter/nf_conntrack_standalone.c

78

tuple->dst.u.icmp.type,

net/netfilter/nf_conntrack_standalone.c

79

tuple->dst.u.icmp.code,

net/netfilter/nf_conntrack_standalone.c

85

ntohs(tuple->dst.u.gre.key));

net/netfilter/nf_conntrack_tftp.c

73

&tuple->src.u3, &tuple->dst.u3,

net/netfilter/nf_conntrack_tftp.c

74

IPPROTO_UDP, NULL, &tuple->dst.u.udp.port);

net/netfilter/nf_flow_table_core.c

102

struct dst_entry *dst = nft_route_dst_fetch(route, dir);

net/netfilter/nf_flow_table_core.c

107

flow_tuple->mtu = ip_dst_mtu_maybe_forward(dst, true);

net/netfilter/nf_flow_table_core.c

110

flow_tuple->mtu = ip6_dst_mtu_maybe_forward(dst, true);

net/netfilter/nf_flow_table_core.c

134

dst_release(dst);

net/netfilter/nf_flow_table_core.c

139

flow_tuple->dst_cache = dst;

net/netfilter/nf_flow_table_core.c

33

ft->dst_v4 = ctt->dst.u3.in;

net/netfilter/nf_flow_table_core.c

37

ft->dst_v6 = ctt->dst.u3.in6;

net/netfilter/nf_flow_table_core.c

42

ft->l4proto = ctt->dst.protonum;

net/netfilter/nf_flow_table_core.c

44

switch (ctt->dst.protonum) {

net/netfilter/nf_flow_table_core.c

48

ft->dst_port = ctt->dst.u.tcp.port;

net/netfilter/nf_flow_table_core.c

90

struct dst_entry *dst = route->tuple[dir].dst;

net/netfilter/nf_flow_table_core.c

92

route->tuple[dir].dst = NULL;

net/netfilter/nf_flow_table_core.c

94

return dst;

net/netfilter/nf_flow_table_ip.c

1110

return nf_flow_xmit_xfrm(skb, state, &rt->dst);

net/netfilter/nf_flow_table_ip.c

1133

neigh = ip_neigh_gw6(rt->dst.dev, rt6_nexthop(rt, ip6_daddr));

net/netfilter/nf_flow_table_ip.c

1139

skb_dst_set_noref(skb, &rt->dst);

net/netfilter/nf_flow_table_ip.c

311

struct dst_entry *dst)

net/netfilter/nf_flow_table_ip.c

314

skb_dst_set_noref(skb, dst);

net/netfilter/nf_flow_table_ip.c

601

headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len;

net/netfilter/nf_flow_table_ip.c

616

iph->frag_off = ip_mtu_locked(&rt->dst) ? 0 : frag_off;

net/netfilter/nf_flow_table_ip.c

668

headroom = sizeof(*ip6h) + LL_RESERVED_SPACE(rt->dst.dev) +

net/netfilter/nf_flow_table_ip.c

669

rt->dst.header_len;

net/netfilter/nf_flow_table_ip.c

677

mtu = dst_mtu(&rt->dst) - sizeof(*ip6h);

net/netfilter/nf_flow_table_ip.c

789

return nf_flow_xmit_xfrm(skb, state, &rt->dst);

net/netfilter/nf_flow_table_ip.c

811

neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, ip_daddr));

net/netfilter/nf_flow_table_ip.c

817

skb_dst_set_noref(skb, &rt->dst);

net/netfilter/nf_flow_table_offload.c

154

key->ipv4.dst = tuple->dst_v4.s_addr;

net/netfilter/nf_flow_table_offload.c

155

mask->ipv4.dst = 0xffffffff;

net/netfilter/nf_flow_table_offload.c

162

key->ipv6.dst = tuple->dst_v6;

net/netfilter/nf_flow_table_offload.c

163

memset(&mask->ipv6.dst, 0xff, sizeof(mask->ipv6.dst));

net/netfilter/nf_flow_table_offload.c

197

key->tp.dst = tuple->dst_port;

net/netfilter/nf_flow_table_offload.c

198

mask->tp.dst = 0xffff;

net/netfilter/nf_flow_table_offload.c

55

key->enc_ipv4.src = tun_info->key.u.ipv4.dst;

net/netfilter/nf_flow_table_offload.c

56

key->enc_ipv4.dst = tun_info->key.u.ipv4.src;

net/netfilter/nf_flow_table_offload.c

59

if (key->enc_ipv4.dst)

net/netfilter/nf_flow_table_offload.c

60

mask->enc_ipv4.dst = 0xffffffff;

net/netfilter/nf_flow_table_offload.c

630

struct dst_entry *dst;

net/netfilter/nf_flow_table_offload.c

636

dst = this_tuple->dst_cache;

net/netfilter/nf_flow_table_offload.c

637

if (dst && dst->lwtstate) {

net/netfilter/nf_flow_table_offload.c

64

memcpy(&key->enc_ipv6.src, &tun_info->key.u.ipv6.dst,

net/netfilter/nf_flow_table_offload.c

640

tun_info = lwt_tun_info(dst->lwtstate);

net/netfilter/nf_flow_table_offload.c

659

struct dst_entry *dst;

net/netfilter/nf_flow_table_offload.c

66

memcpy(&key->enc_ipv6.dst, &tun_info->key.u.ipv6.src,

net/netfilter/nf_flow_table_offload.c

665

dst = other_tuple->dst_cache;

net/netfilter/nf_flow_table_offload.c

666

if (dst && dst->lwtstate) {

net/netfilter/nf_flow_table_offload.c

669

tun_info = lwt_tun_info(dst->lwtstate);

net/netfilter/nf_flow_table_offload.c

72

if (memcmp(&key->enc_ipv6.dst, &in6addr_any,

net/netfilter/nf_flow_table_offload.c

74

memset(&mask->enc_ipv6.dst, 0xff,

net/netfilter/nf_flow_table_path.c

19

static enum flow_offload_xmit_type nft_xmit_type(struct dst_entry *dst)

net/netfilter/nf_flow_table_path.c

206

struct dst_entry *cur_dst = route->tuple[dir].dst;

net/netfilter/nf_flow_table_path.c

21

if (dst_xfrm(dst))

net/netfilter/nf_flow_table_path.c

233

route->tuple[dir].dst = tun_dst;

net/netfilter/nf_flow_table_path.c

245

const struct dst_entry *dst = route->tuple[dir].dst;

net/netfilter/nf_flow_table_path.c

251

if (nft_dev_fill_forward_path(route, dst, ct, dir, ha, &stack) >= 0)

net/netfilter/nf_flow_table_path.c

32

route->tuple[dir].dst = dst_cache;

net/netfilter/nf_nat_amanda.c

39

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/netfilter/nf_nat_core.c

100

if (t->dst.protonum == IPPROTO_TCP ||

net/netfilter/nf_nat_core.c

101

t->dst.protonum == IPPROTO_UDP ||

net/netfilter/nf_nat_core.c

102

t->dst.protonum == IPPROTO_UDPLITE ||

net/netfilter/nf_nat_core.c

103

t->dst.protonum == IPPROTO_SCTP)

net/netfilter/nf_nat_core.c

104

fl6->fl6_dport = t->dst.u.all;

net/netfilter/nf_nat_core.c

111

if (t->dst.protonum == IPPROTO_TCP ||

net/netfilter/nf_nat_core.c

112

t->dst.protonum == IPPROTO_UDP ||

net/netfilter/nf_nat_core.c

113

t->dst.protonum == IPPROTO_UDPLITE ||

net/netfilter/nf_nat_core.c

114

t->dst.protonum == IPPROTO_SCTP)

net/netfilter/nf_nat_core.c

171

combined.protonum = tuple->dst.protonum;

net/netfilter/nf_nat_core.c

352

tuple->dst.protonum != IPPROTO_TCP ||

net/netfilter/nf_nat_core.c

370

if (thash->tuple.dst.dir == IP_CT_DIR_ORIGINAL)

net/netfilter/nf_nat_core.c

410

switch (tuple->dst.protonum) {

net/netfilter/nf_nat_core.c

423

port = tuple->dst.u.all;

net/netfilter/nf_nat_core.c

459

return (t->dst.protonum == tuple->dst.protonum &&

net/netfilter/nf_nat_core.c

482

result->dst = tuple->dst;

net/netfilter/nf_nat_core.c

517

var_ipp = &tuple->dst.u3;

net/netfilter/nf_nat_core.c

539

0 : (__force u32)tuple->dst.u3.all[max] ^ zone->id);

net/netfilter/nf_nat_core.c

561

j ^= (__force u32)tuple->dst.u3.all[i];

net/netfilter/nf_nat_core.c

579

switch (tuple->dst.protonum) {

net/netfilter/nf_nat_core.c

603

keyptr = &tuple->dst.u.gre.key;

net/netfilter/nf_nat_core.c

621

keyptr = &tuple->dst.u.all;

net/netfilter/nf_nat_core.c

68

fl4->daddr = t->dst.u3.ip;

net/netfilter/nf_nat_core.c

69

if (t->dst.protonum == IPPROTO_TCP ||

net/netfilter/nf_nat_core.c

70

t->dst.protonum == IPPROTO_UDP ||

net/netfilter/nf_nat_core.c

71

t->dst.protonum == IPPROTO_UDPLITE ||

net/netfilter/nf_nat_core.c

72

t->dst.protonum == IPPROTO_SCTP)

net/netfilter/nf_nat_core.c

73

fl4->fl4_dport = t->dst.u.all;

net/netfilter/nf_nat_core.c

80

if (t->dst.protonum == IPPROTO_TCP ||

net/netfilter/nf_nat_core.c

81

t->dst.protonum == IPPROTO_UDP ||

net/netfilter/nf_nat_core.c

82

t->dst.protonum == IPPROTO_UDPLITE ||

net/netfilter/nf_nat_core.c

83

t->dst.protonum == IPPROTO_SCTP)

net/netfilter/nf_nat_core.c

848

ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3 :

net/netfilter/nf_nat_core.c

99

fl6->daddr = t->dst.u3.in6;

net/netfilter/nf_nat_ftp.c

81

newaddr = ct->tuplehash[!dir].tuple.dst.u3;

net/netfilter/nf_nat_ftp.c

82

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/netfilter/nf_nat_helper.c

190

= ct->master->tuplehash[!exp->dir].tuple.dst.u3;

net/netfilter/nf_nat_helper.c

218

exp->tuple.dst.u.tcp.port = htons(port);

net/netfilter/nf_nat_irc.c

45

newaddr = ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3;

net/netfilter/nf_nat_irc.c

47

exp->saved_proto.tcp.port = exp->tuple.dst.u.tcp.port;

net/netfilter/nf_nat_masquerade.c

179

return nf_inet_addr_cmp(&w->addr, &tuple->dst.u3);

net/netfilter/nf_nat_proto.c

1026

if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3,

net/netfilter/nf_nat_proto.c

1034

ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMPV6 &&

net/netfilter/nf_nat_proto.c

1035

ct->tuplehash[dir].tuple.dst.u.all !=

net/netfilter/nf_nat_proto.c

126

hdr->dest = tuple->dst.u.sctp.port;

net/netfilter/nf_nat_proto.c

168

newport = tuple->dst.u.tcp.port;

net/netfilter/nf_nat_proto.c

267

pr_debug("call_id -> 0x%04x\n", ntohs(tuple->dst.u.gre.key));

net/netfilter/nf_nat_proto.c

268

pgreh->call_id = tuple->dst.u.gre.key;

net/netfilter/nf_nat_proto.c

283

switch (tuple->dst.protonum) {

net/netfilter/nf_nat_proto.c

333

csum_replace4(&iph->check, iph->daddr, target->dst.u3.ip);

net/netfilter/nf_nat_proto.c

334

iph->daddr = target->dst.u3.ip;

net/netfilter/nf_nat_proto.c

371

ipv6h->daddr = target->dst.u3.in6;

net/netfilter/nf_nat_proto.c

416

newip = t->dst.u3.ip;

net/netfilter/nf_nat_proto.c

435

newip = &t->dst.u3.in6;

net/netfilter/nf_nat_proto.c

53

newport = tuple->dst.u.udp.port;

net/netfilter/nf_nat_proto.c

574

target.dst.protonum = IPPROTO_ICMP;

net/netfilter/nf_nat_proto.c

624

struct dst_entry *dst;

net/netfilter/nf_nat_proto.c

633

dst = skb_dst(skb);

net/netfilter/nf_nat_proto.c

634

if (dst->xfrm)

net/netfilter/nf_nat_proto.c

635

dst = ((struct xfrm_dst *)dst)->route;

net/netfilter/nf_nat_proto.c

636

if (!dst_hold_safe(dst))

net/netfilter/nf_nat_proto.c

642

dst = xfrm_lookup(net, dst, &fl, sk, 0);

net/netfilter/nf_nat_proto.c

643

if (IS_ERR(dst))

net/netfilter/nf_nat_proto.c

644

return PTR_ERR(dst);

net/netfilter/nf_nat_proto.c

647

skb_dst_set(skb, dst);

net/netfilter/nf_nat_proto.c

680

return ct->tuplehash[!dir].tuple.dst.u.all != sport;

net/netfilter/nf_nat_proto.c

736

ct->tuplehash[!dir].tuple.dst.u3.ip ||

net/netfilter/nf_nat_proto.c

737

(ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMP &&

net/netfilter/nf_nat_proto.c

739

ct->tuplehash[!dir].tuple.dst.u.all)) {

net/netfilter/nf_nat_proto.c

766

if (ct->tuplehash[dir].tuple.dst.u3.ip !=

net/netfilter/nf_nat_proto.c

774

ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMP &&

net/netfilter/nf_nat_proto.c

775

ct->tuplehash[dir].tuple.dst.u.all !=

net/netfilter/nf_nat_proto.c

890

target.dst.protonum = IPPROTO_ICMPV6;

net/netfilter/nf_nat_proto.c

995

&ct->tuplehash[!dir].tuple.dst.u3) ||

net/netfilter/nf_nat_proto.c

996

(ct->tuplehash[dir].tuple.dst.protonum != IPPROTO_ICMPV6 &&

net/netfilter/nf_nat_proto.c

998

ct->tuplehash[!dir].tuple.dst.u.all)) {

net/netfilter/nf_nat_sip.c

109

newaddr = ct->tuplehash[!dir].tuple.dst.u3;

net/netfilter/nf_nat_sip.c

110

newport = ct->tuplehash[!dir].tuple.dst.u.udp.port;

net/netfilter/nf_nat_sip.c

111

} else if (nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, addr) &&

net/netfilter/nf_nat_sip.c

112

ct->tuplehash[dir].tuple.dst.u.udp.port == port) {

net/netfilter/nf_nat_sip.c

194

&ct->tuplehash[dir].tuple.dst.u3) ||

net/netfilter/nf_nat_sip.c

195

port != ct->tuplehash[dir].tuple.dst.u.udp.port)

net/netfilter/nf_nat_sip.c

214

!nf_inet_addr_cmp(&addr, &ct->tuplehash[!dir].tuple.dst.u3)) {

net/netfilter/nf_nat_sip.c

216

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nf_nat_sip.c

230

nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.dst.u3) &&

net/netfilter/nf_nat_sip.c

247

htons(n) == ct->tuplehash[dir].tuple.dst.u.udp.port &&

net/netfilter/nf_nat_sip.c

342

pair_exp->tuple.dst.protonum == ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum &&

net/netfilter/nf_nat_sip.c

346

range.min_proto.all = range.max_proto.all = pair_exp->tuple.dst.u.all;

net/netfilter/nf_nat_sip.c

347

range.min_addr = range.max_addr = pair_exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

364

= ct->master->tuplehash[!exp->dir].tuple.dst.u3;

net/netfilter/nf_nat_sip.c

392

&ct->tuplehash[!dir].tuple.dst.u3))

net/netfilter/nf_nat_sip.c

393

newaddr = exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

395

newaddr = ct->tuplehash[!dir].tuple.dst.u3;

net/netfilter/nf_nat_sip.c

402

if (exp->tuple.dst.u.udp.port == srcport)

net/netfilter/nf_nat_sip.c

403

port = ntohs(ct->tuplehash[!dir].tuple.dst.u.udp.port);

net/netfilter/nf_nat_sip.c

405

port = ntohs(exp->tuple.dst.u.udp.port);

net/netfilter/nf_nat_sip.c

407

exp->saved_addr = exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

408

exp->tuple.dst.u3 = newaddr;

net/netfilter/nf_nat_sip.c

409

exp->saved_proto.udp.port = exp->tuple.dst.u.udp.port;

net/netfilter/nf_nat_sip.c

419

if (!nf_inet_addr_cmp(&exp->tuple.dst.u3, &exp->saved_addr) ||

net/netfilter/nf_nat_sip.c

420

exp->tuple.dst.u.udp.port != exp->saved_proto.udp.port) {

net/netfilter/nf_nat_sip.c

575

&ct->tuplehash[!dir].tuple.dst.u3))

net/netfilter/nf_nat_sip.c

576

*rtp_addr = rtp_exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

578

*rtp_addr = ct->tuplehash[!dir].tuple.dst.u3;

net/netfilter/nf_nat_sip.c

580

rtp_exp->saved_addr = rtp_exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

581

rtp_exp->tuple.dst.u3 = *rtp_addr;

net/netfilter/nf_nat_sip.c

582

rtp_exp->saved_proto.udp.port = rtp_exp->tuple.dst.u.udp.port;

net/netfilter/nf_nat_sip.c

586

rtcp_exp->saved_addr = rtcp_exp->tuple.dst.u3;

net/netfilter/nf_nat_sip.c

587

rtcp_exp->tuple.dst.u3 = *rtp_addr;

net/netfilter/nf_nat_sip.c

588

rtcp_exp->saved_proto.udp.port = rtcp_exp->tuple.dst.u.udp.port;

net/netfilter/nf_nat_sip.c

593

for (port = ntohs(rtp_exp->tuple.dst.u.udp.port);

net/netfilter/nf_nat_sip.c

597

rtp_exp->tuple.dst.u.udp.port = htons(port);

net/netfilter/nf_nat_sip.c

606

rtcp_exp->tuple.dst.u.udp.port = htons(port + 1);

net/netfilter/nf_nat_sip.c

627

if (rtp_exp->tuple.dst.u.udp.port != rtp_exp->saved_proto.udp.port &&

net/netfilter/nf_synproxy_core.c

819

struct dst_entry *dst;

net/netfilter/nf_synproxy_core.c

836

err = nf_ip6_route(net, &dst, flowi6_to_flowi(&fl6), false);

net/netfilter/nf_synproxy_core.c

841

dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);

net/netfilter/nf_synproxy_core.c

842

if (IS_ERR(dst))

net/netfilter/nf_synproxy_core.c

845

skb_dst_set(nskb, dst);

net/netfilter/nf_tables_api.c

3615

int nft_expr_clone(struct nft_expr *dst, struct nft_expr *src, gfp_t gfp)

net/netfilter/nf_tables_api.c

3622

dst->ops = src->ops;

net/netfilter/nf_tables_api.c

3623

err = src->ops->clone(dst, src, gfp);

net/netfilter/nf_tables_core.c

79

u32 *dst = &regs->data[priv->dreg];

net/netfilter/nf_tables_core.c

81

*dst = (*src & priv->mask) ^ priv->xor;

net/netfilter/nfnetlink_cthelper.c

445

tuple.dst.protonum != cur->tuple.dst.protonum))

net/netfilter/nfnetlink_cthelper.c

477

if (nla_put_u8(skb, NFCTH_TUPLE_L4PROTONUM, helper->tuple.dst.protonum))

net/netfilter/nfnetlink_cthelper.c

654

tuple.dst.protonum != cur->tuple.dst.protonum))

net/netfilter/nfnetlink_cthelper.c

714

tuple.dst.protonum != cur->tuple.dst.protonum))

net/netfilter/nfnetlink_cthelper.c

90

tuple->dst.protonum = nla_get_u8(tb[NFCTH_TUPLE_L4PROTONUM]);

net/netfilter/nft_bitwise.c

103

nft_bitwise_eval_lshift(dst, src, priv);

net/netfilter/nft_bitwise.c

107

nft_bitwise_eval_rshift(dst, src, priv);

net/netfilter/nft_bitwise.c

114

nft_bitwise_eval_and(dst, src, src2, priv);

net/netfilter/nft_bitwise.c

118

nft_bitwise_eval_or(dst, src, src2, priv);

net/netfilter/nft_bitwise.c

122

nft_bitwise_eval_xor(dst, src, src2, priv);

net/netfilter/nft_bitwise.c

29

static void nft_bitwise_eval_mask_xor(u32 *dst, const u32 *src,

net/netfilter/nft_bitwise.c

35

dst[i] = (src[i] & priv->mask.data[i]) ^ priv->xor.data[i];

net/netfilter/nft_bitwise.c

38

static void nft_bitwise_eval_lshift(u32 *dst, const u32 *src,

net/netfilter/nft_bitwise.c

46

dst[i - 1] = (src[i - 1] << shift) | carry;

net/netfilter/nft_bitwise.c

51

static void nft_bitwise_eval_rshift(u32 *dst, const u32 *src,

net/netfilter/nft_bitwise.c

59

dst[i] = carry | (src[i] >> shift);

net/netfilter/nft_bitwise.c

64

static void nft_bitwise_eval_and(u32 *dst, const u32 *src, const u32 *src2,

net/netfilter/nft_bitwise.c

70

dst[i] = src[i] & src2[i];

net/netfilter/nft_bitwise.c

73

static void nft_bitwise_eval_or(u32 *dst, const u32 *src, const u32 *src2,

net/netfilter/nft_bitwise.c

79

dst[i] = src[i] | src2[i];

net/netfilter/nft_bitwise.c

82

static void nft_bitwise_eval_xor(u32 *dst, const u32 *src, const u32 *src2,

net/netfilter/nft_bitwise.c

88

dst[i] = src[i] ^ src2[i];

net/netfilter/nft_bitwise.c

96

u32 *dst = &regs->data[priv->dreg];

net/netfilter/nft_bitwise.c

99

nft_bitwise_eval_mask_xor(dst, src, priv);

net/netfilter/nft_byteorder.c

32

u32 *dst = &regs->data[priv->dreg];

net/netfilter/nft_byteorder.c

37

d16 = (void *)dst;

net/netfilter/nft_byteorder.c

41

u64 *dst64 = (void *)dst;

net/netfilter/nft_byteorder.c

66

dst[i] = ntohl((__force __be32)src[i]);

net/netfilter/nft_byteorder.c

70

dst[i] = (__force __u32)htonl(src[i]);

net/netfilter/nft_connlimit.c

218

static int nft_connlimit_clone(struct nft_expr *dst, const struct nft_expr *src, gfp_t gfp)

net/netfilter/nft_connlimit.c

220

struct nft_connlimit *priv_dst = nft_expr_priv(dst);

net/netfilter/nft_counter.c

250

static int nft_counter_clone(struct nft_expr *dst, const struct nft_expr *src, gfp_t gfp)

net/netfilter/nft_counter.c

253

struct nft_counter_percpu_priv *priv_clone = nft_expr_priv(dst);

net/netfilter/nft_ct.c

1378

&ct->tuplehash[!dir].tuple.dst.u3,

net/netfilter/nft_ct.c

187

memcpy(dest, tuple->dst.u3.all,

net/netfilter/nft_ct.c

194

nft_reg_store16(dest, (__force u16)tuple->dst.u.all);

net/netfilter/nft_ct.c

204

*dest = (__force __u32)tuple->dst.u3.ip;

net/netfilter/nft_ct.c

214

memcpy(dest, tuple->dst.u3.ip6, sizeof(struct in6_addr));

net/netfilter/nft_flow_offload.c

130

dst_release(route.tuple[dir].dst);

net/netfilter/nft_flow_offload.c

131

dst_release(route.tuple[!dir].dst);

net/netfilter/nft_flow_offload.c

71

switch (ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum) {

net/netfilter/nft_flow_offload.c

89

if (tuple->src.u.gre.key || tuple->dst.u.gre.key)

net/netfilter/nft_last.c

105

static int nft_last_clone(struct nft_expr *dst, const struct nft_expr *src, gfp_t gfp)

net/netfilter/nft_last.c

107

struct nft_last_priv *priv_dst = nft_expr_priv(dst);

net/netfilter/nft_limit.c

226

static int nft_limit_pkts_clone(struct nft_expr *dst, const struct nft_expr *src,

net/netfilter/nft_limit.c

229

struct nft_limit_priv_pkts *priv_dst = nft_expr_priv(dst);

net/netfilter/nft_limit.c

285

static int nft_limit_bytes_clone(struct nft_expr *dst, const struct nft_expr *src,

net/netfilter/nft_limit.c

288

struct nft_limit_priv *priv_dst = nft_expr_priv(dst);

net/netfilter/nft_meta.c

277

const struct dst_entry *dst = skb_dst(skb);

net/netfilter/nft_meta.c

279

if (!dst)

net/netfilter/nft_meta.c

282

*dest = dst->tclassid;

net/netfilter/nft_payload.c

325

dst, ETH_ALEN, reg);

net/netfilter/nft_payload.c

396

NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV4_ADDRS, ipv4, dst,

net/netfilter/nft_payload.c

436

NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV6_ADDRS, ipv6, dst,

net/netfilter/nft_payload.c

493

NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_PORTS, tp, dst,

net/netfilter/nft_payload.c

521

NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_PORTS, tp, dst,

net/netfilter/nft_quota.c

243

static int nft_quota_clone(struct nft_expr *dst, const struct nft_expr *src, gfp_t gfp)

net/netfilter/nft_quota.c

245

struct nft_quota *priv_dst = nft_expr_priv(dst);

net/netfilter/nft_rt.c

25

struct dst_entry *dst = NULL;

net/netfilter/nft_rt.c

41

nf_route(nft_net(pkt), &dst, &fl, false, nft_pf(pkt));

net/netfilter/nft_rt.c

42

if (dst) {

net/netfilter/nft_rt.c

43

mtu = min(mtu, dst_mtu(dst));

net/netfilter/nft_rt.c

44

dst_release(dst);

net/netfilter/nft_rt.c

60

const struct dst_entry *dst;

net/netfilter/nft_rt.c

62

dst = skb_dst(skb);

net/netfilter/nft_rt.c

63

if (!dst)

net/netfilter/nft_rt.c

69

*dest = dst->tclassid;

net/netfilter/nft_rt.c

76

*dest = (__force u32)rt_nexthop(dst_rtable(dst),

net/netfilter/nft_rt.c

83

memcpy(dest, rt6_nexthop(dst_rt6_info(dst),

net/netfilter/nft_rt.c

88

nft_reg_store16(dest, get_tcpmss(pkt, dst));

net/netfilter/nft_rt.c

92

nft_reg_store8(dest, !!dst->xfrm);

net/netfilter/nft_set_pipapo.c

1412

struct nft_pipapo_field *dst, *src;

net/netfilter/nft_set_pipapo.c

1436

dst = new->f;

net/netfilter/nft_set_pipapo.c

1442

memcpy(dst, src, offsetof(struct nft_pipapo_field, lt));

net/netfilter/nft_set_pipapo.c

1452

dst->lt = new_lt;

net/netfilter/nft_set_pipapo.c

1456

src->bsize * sizeof(*dst->lt) *

net/netfilter/nft_set_pipapo.c

1463

dst->mt = kvmalloc_objs(*src->mt, src->rules_alloc,

net/netfilter/nft_set_pipapo.c

1465

if (!dst->mt)

net/netfilter/nft_set_pipapo.c

1468

memcpy(dst->mt, src->mt, src->rules * sizeof(*src->mt));

net/netfilter/nft_set_pipapo.c

1470

dst->mt = NULL;

net/netfilter/nft_set_pipapo.c

1471

dst->rules_alloc = 0;

net/netfilter/nft_set_pipapo.c

1475

dst++;

net/netfilter/nft_set_pipapo.c

1481

kvfree(dst->lt);

net/netfilter/nft_set_pipapo.c

1483

for (dst--; i > 0; i--) {

net/netfilter/nft_set_pipapo.c

1484

kvfree(dst->mt);

net/netfilter/nft_set_pipapo.c

1485

kvfree(dst->lt);

net/netfilter/nft_set_pipapo.c

1486

dst--;

net/netfilter/nft_set_pipapo.c

363

unsigned long *dst,

net/netfilter/nft_set_pipapo.c

389

bitmap_set(dst, mt[i].to, mt[i].n);

net/netfilter/nft_set_pipapo.h

182

unsigned long *dst,

net/netfilter/nft_set_pipapo.h

192

unsigned long *dst,

net/netfilter/nft_set_pipapo.h

202

__bitmap_and(dst, dst, lt + v * f->bsize,

net/netfilter/nft_set_pipapo.h

207

__bitmap_and(dst, dst, lt + v * f->bsize,

net/netfilter/nft_set_pipapo.h

220

unsigned long *dst,

net/netfilter/nft_set_pipapo.h

227

__bitmap_and(dst, dst, lt + *data * f->bsize,

net/netfilter/nft_set_pipapo_avx2.c

153

unsigned long *dst,

net/netfilter/nft_set_pipapo_avx2.c

167

nft_pipapo_avx2_fill(dst, mt[i].to, mt[i].n); \

net/netfilter/nft_set_pipapo_avx2.c

55

#define NFT_PIPAPO_AVX2_AND(dst, a, b) \

net/netfilter/nft_set_pipapo_avx2.c

56

asm volatile("vpand %ymm" #a ", %ymm" #b ", %ymm" #dst)

net/netfilter/nft_tunnel.c

209

info->key.u.ipv4.dst = nla_get_be32(tb[NFTA_TUNNEL_KEY_IP_DST]);

net/netfilter/nft_tunnel.c

241

memcpy(&info->key.u.ipv6.dst,

net/netfilter/nft_tunnel.c

553

&info->key.u.ipv6.dst) < 0 ||

net/netfilter/nft_tunnel.c

569

info->key.u.ipv4.dst) < 0) {

net/netfilter/nft_xfrm.c

180

const struct dst_entry *dst = skb_dst(pkt->skb);

net/netfilter/nft_xfrm.c

183

for (i = 0; dst && dst->xfrm;

net/netfilter/nft_xfrm.c

184

dst = ((const struct xfrm_dst *)dst)->child, i++) {

net/netfilter/nft_xfrm.c

188

nft_xfrm_state_get_key(priv, regs, dst->xfrm);

net/netfilter/utils.c

163

int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl,

net/netfilter/utils.c

171

ret = nf_ip_route(net, dst, fl, strict);

net/netfilter/utils.c

174

ret = nf_ip6_route(net, dst, fl, strict);

net/netfilter/x_tables.c

312

int xt_data_to_user(void __user *dst, const void *src,

net/netfilter/x_tables.c

316

if (copy_to_user(dst, src, usersize))

net/netfilter/x_tables.c

319

clear_user(dst + usersize, aligned_size - usersize))

net/netfilter/xt_HMARK.c

103

t->uports.b16.dst = rtuple->src.u.all;

net/netfilter/xt_HMARK.c

120

u32 dst = ntohl(t->dst);

net/netfilter/xt_HMARK.c

122

if (dst < src)

net/netfilter/xt_HMARK.c

123

swap(src, dst);

net/netfilter/xt_HMARK.c

125

hash = jhash_3words(src, dst, t->uports.v32, info->hashrnd);

net/netfilter/xt_HMARK.c

194

t->dst = hmark_addr6_mask(ip6->daddr.s6_addr32, info->dst_mask.ip6);

net/netfilter/xt_HMARK.c

267

t->dst = ip->daddr & info->dst_mask.ip;

net/netfilter/xt_HMARK.c

35

__be32 dst;

net/netfilter/xt_HMARK.c

64

u16 src, dst;

net/netfilter/xt_HMARK.c

68

dst = ntohs(hp.b16.dst);

net/netfilter/xt_HMARK.c

70

if (dst > src)

net/netfilter/xt_HMARK.c

71

uports->v32 = (dst << 16) | src;

net/netfilter/xt_HMARK.c

73

uports->v32 = (src << 16) | dst;

net/netfilter/xt_HMARK.c

94

t->dst = hmark_addr_mask(otuple->src.l3num, rtuple->src.u3.ip6,

net/netfilter/xt_TCPMSS.c

64

mtu = dst_mtu(&rt->dst);

net/netfilter/xt_TCPMSS.c

65

dst_release(&rt->dst);

net/netfilter/xt_addrtype.c

64

dst_release(&rt->dst);

net/netfilter/xt_conntrack.c

106

(tuple->dst.u.all == info->repldst_port) ^

net/netfilter/xt_conntrack.c

140

ntohs(tuple->dst.u.all),

net/netfilter/xt_conntrack.c

154

ntohs(tuple->dst.u.all),

net/netfilter/xt_conntrack.c

53

return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.u3,

net/netfilter/xt_conntrack.c

71

return conntrack_addrcmp(&ct->tuplehash[IP_CT_DIR_REPLY].tuple.dst.u3,

net/netfilter/xt_conntrack.c

94

(tuple->dst.u.all == info->origdst_port) ^

net/netfilter/xt_hashlimit.c

1103

&ent->dst.ip.src,

net/netfilter/xt_hashlimit.c

1104

ntohs(ent->dst.src_port),

net/netfilter/xt_hashlimit.c

1105

&ent->dst.ip.dst,

net/netfilter/xt_hashlimit.c

1106

ntohs(ent->dst.dst_port),

net/netfilter/xt_hashlimit.c

1114

&ent->dst.ip6.src,

net/netfilter/xt_hashlimit.c

1115

ntohs(ent->dst.src_port),

net/netfilter/xt_hashlimit.c

1116

&ent->dst.ip6.dst,

net/netfilter/xt_hashlimit.c

1117

ntohs(ent->dst.dst_port),

net/netfilter/xt_hashlimit.c

179

return !memcmp(&ent->dst, b, sizeof(ent->dst));

net/netfilter/xt_hashlimit.c

183

hash_dst(const struct xt_hashlimit_htable *ht, const struct dsthash_dst *dst)

net/netfilter/xt_hashlimit.c

185

u_int32_t hash = jhash2((const u32 *)dst,

net/netfilter/xt_hashlimit.c

186

sizeof(*dst)/sizeof(u32),

net/netfilter/xt_hashlimit.c

199

const struct dsthash_dst *dst)

net/netfilter/xt_hashlimit.c

202

u_int32_t hash = hash_dst(ht, dst);

net/netfilter/xt_hashlimit.c

206

if (dst_cmp(ent, dst)) {

net/netfilter/xt_hashlimit.c

217

const struct dsthash_dst *dst, bool *race)

net/netfilter/xt_hashlimit.c

226

ent = dsthash_find(ht, dst);

net/netfilter/xt_hashlimit.c

247

memcpy(&ent->dst, dst, sizeof(ent->dst));

net/netfilter/xt_hashlimit.c

251

hlist_add_head_rcu(&ent->node, &ht->hash[hash_dst(ht, dst)]);

net/netfilter/xt_hashlimit.c

640

struct dsthash_dst *dst,

net/netfilter/xt_hashlimit.c

647

memset(dst, 0, sizeof(*dst));

net/netfilter/xt_hashlimit.c

652

dst->ip.dst = maskl(ip_hdr(skb)->daddr,

net/netfilter/xt_hashlimit.c

655

dst->ip.src = maskl(ip_hdr(skb)->saddr,

net/netfilter/xt_hashlimit.c

669

memcpy(&dst->ip6.dst, &ipv6_hdr(skb)->daddr,

net/netfilter/xt_hashlimit.c

670

sizeof(dst->ip6.dst));

net/netfilter/xt_hashlimit.c

671

hashlimit_ipv6_mask(dst->ip6.dst, hinfo->cfg.dstmask);

net/netfilter/xt_hashlimit.c

674

memcpy(&dst->ip6.src, &ipv6_hdr(skb)->saddr,

net/netfilter/xt_hashlimit.c

675

sizeof(dst->ip6.src));

net/netfilter/xt_hashlimit.c

676

hashlimit_ipv6_mask(dst->ip6.src, hinfo->cfg.srcmask);

net/netfilter/xt_hashlimit.c

705

dst->src_port = ports[0];

net/netfilter/xt_hashlimit.c

707

dst->dst_port = ports[1];

net/netfilter/xt_hashlimit.c

733

struct dsthash_dst dst;

net/netfilter/xt_hashlimit.c

737

if (hashlimit_init_dst(hinfo, &dst, skb, par->thoff) < 0)

net/netfilter/xt_hashlimit.c

741

dh = dsthash_find(hinfo, &dst);

net/netfilter/xt_hashlimit.c

743

dh = dsthash_alloc_init(hinfo, &dst, &race);

net/netfilter/xt_hashlimit.c

75

__be32 dst;

net/netfilter/xt_hashlimit.c

80

__be32 dst[4];

net/netfilter/xt_hashlimit.c

91

struct dsthash_dst dst;

net/netfilter/xt_limit.c

157

static void limit_mt_compat_from_user(void *dst, const void *src)

net/netfilter/xt_limit.c

168

memcpy(dst, &m, sizeof(m));

net/netfilter/xt_limit.c

171

static int limit_mt_compat_to_user(void __user *dst, const void *src)

net/netfilter/xt_limit.c

183

return copy_to_user(dst, &cm, sizeof(cm)) ? -EFAULT : 0;

net/netfilter/xt_multiport.c

29

u_int16_t src, u_int16_t dst)

net/netfilter/xt_multiport.c

48

if (dst >= s && dst <= e)

net/netfilter/xt_multiport.c

52

if ((dst >= s && dst <= e) ||

net/netfilter/xt_multiport.c

69

if (dst == s)

net/netfilter/xt_multiport.c

73

if (src == s || dst == s)

net/netfilter/xt_nat.c

37

static void xt_nat_convert_range(struct nf_nat_range2 *dst,

net/netfilter/xt_nat.c

40

memset(&dst->min_addr, 0, sizeof(dst->min_addr));

net/netfilter/xt_nat.c

41

memset(&dst->max_addr, 0, sizeof(dst->max_addr));

net/netfilter/xt_nat.c

42

memset(&dst->base_proto, 0, sizeof(dst->base_proto));

net/netfilter/xt_nat.c

44

dst->flags = src->flags;

net/netfilter/xt_nat.c

45

dst->min_addr.ip = src->min_ip;

net/netfilter/xt_nat.c

46

dst->max_addr.ip = src->max_ip;

net/netfilter/xt_nat.c

47

dst->min_proto = src->min;

net/netfilter/xt_nat.c

48

dst->max_proto = src->max;

net/netfilter/xt_policy.c

100

if (match_xfrm_state(dst->xfrm, e, family)) {

net/netfilter/xt_policy.c

86

const struct dst_entry *dst = skb_dst(skb);

net/netfilter/xt_policy.c

90

if (dst->xfrm == NULL)

net/netfilter/xt_policy.c

93

for (i = 0; dst && dst->xfrm;

net/netfilter/xt_policy.c

94

dst = ((struct xfrm_dst *)dst)->child, i++) {

net/netfilter/xt_realm.c

25

const struct dst_entry *dst = skb_dst(skb);

net/netfilter/xt_realm.c

27

return (info->id == (dst->tclassid & info->mask)) ^ info->invert;

net/netlink/af_netlink.c

343

static void netlink_deliver_tap_kernel(struct sock *dst, struct sock *src,

net/netlink/af_netlink.c

346

if (!(netlink_is_kernel(dst) && netlink_is_kernel(src)))

net/netlink/af_netlink.c

347

netlink_deliver_tap(sock_net(dst), skb);

net/netlink/genetlink.c

388

genl_op_iter_copy(struct genl_op_iter *dst, struct genl_op_iter *src)

net/netlink/genetlink.c

390

*dst = *src;

net/openvswitch/actions.c

216

u16 *dst = (u16 *)dst_;

net/openvswitch/actions.c

220

OVS_SET_MASKED(dst[0], src[0], mask[0]);

net/openvswitch/actions.c

221

OVS_SET_MASKED(dst[1], src[1], mask[1]);

net/openvswitch/actions.c

222

OVS_SET_MASKED(dst[2], src[2], mask[2]);

net/openvswitch/actions.c

245

ether_addr_copy(flow_key->eth.dst, eth_hdr(skb)->h_dest);

net/openvswitch/actions.c

485

flow_key->ipv4.addr.dst = new_addr;

net/openvswitch/actions.c

554

memcpy(&flow_key->ipv6.addr.dst, masked,

net/openvswitch/actions.c

555

sizeof(flow_key->ipv6.addr.dst));

net/openvswitch/actions.c

589

__be16 src, dst;

net/openvswitch/actions.c

600

dst = OVS_MASKED(uh->dest, key->udp_dst, mask->udp_dst);

net/openvswitch/actions.c

607

if (likely(dst != uh->dest)) {

net/openvswitch/actions.c

608

set_tp_port(skb, &uh->dest, dst, &uh->check);

net/openvswitch/actions.c

609

flow_key->tp.dst = dst;

net/openvswitch/actions.c

616

uh->dest = dst;

net/openvswitch/actions.c

618

flow_key->tp.dst = dst;

net/openvswitch/actions.c

632

__be16 src, dst;

net/openvswitch/actions.c

646

dst = OVS_MASKED(th->dest, key->tcp_dst, mask->tcp_dst);

net/openvswitch/actions.c

647

if (likely(dst != th->dest)) {

net/openvswitch/actions.c

648

set_tp_port(skb, &th->dest, dst, &th->check);

net/openvswitch/actions.c

649

flow_key->tp.dst = dst;

net/openvswitch/actions.c

685

flow_key->tp.dst = sh->dest;

net/openvswitch/actions.c

701

__skb_dst_copy(skb, data->dst);

net/openvswitch/actions.c

726

ovs_dst_get_mtu(const struct dst_entry *dst)

net/openvswitch/actions.c

728

return dst->dev->mtu;

net/openvswitch/actions.c

746

data->dst = skb->_skb_refdst;

net/openvswitch/actions.c

788

dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL,

net/openvswitch/actions.c

790

ovs_rt.dst.dev = vport->dev;

net/openvswitch/actions.c

793

skb_dst_set_noref(skb, &ovs_rt.dst);

net/openvswitch/actions.c

805

dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL,

net/openvswitch/actions.c

807

ovs_rt.dst.dev = vport->dev;

net/openvswitch/actions.c

810

skb_dst_set_noref(skb, &ovs_rt.dst);

net/openvswitch/conntrack.c

188

key->ct_orig_proto = orig->dst.protonum;

net/openvswitch/conntrack.c

189

if (orig->dst.protonum == icmp_proto) {

net/openvswitch/conntrack.c

190

key->ct.orig_tp.src = htons(orig->dst.u.icmp.type);

net/openvswitch/conntrack.c

191

key->ct.orig_tp.dst = htons(orig->dst.u.icmp.code);

net/openvswitch/conntrack.c

194

key->ct.orig_tp.dst = orig->dst.u.all;

net/openvswitch/conntrack.c

219

key->ipv4.ct_orig.dst = orig->dst.u3.ip;

net/openvswitch/conntrack.c

226

key->ipv6.ct_orig.dst = orig->dst.u3.in6;

net/openvswitch/conntrack.c

315

orig.ipv4_dst = output->ipv4.ct_orig.dst;

net/openvswitch/conntrack.c

317

orig.dst_port = output->ct.orig_tp.dst;

net/openvswitch/conntrack.c

329

memcpy(orig.ipv6_dst, output->ipv6.ct_orig.dst.s6_addr32,

net/openvswitch/conntrack.c

332

orig.dst_port = output->ct.orig_tp.dst;

net/openvswitch/conntrack.c

403

u32 *dst = (u32 *)cl->bits;

net/openvswitch/conntrack.c

407

dst[i] = (dst[i] & ~mask->ct_labels_32[i]) |

net/openvswitch/conntrack.c

526

h = &ct->tuplehash[!h->tuple.dst.dir];

net/openvswitch/conntrack.c

642

__be16 dst;

net/openvswitch/conntrack.c

646

key->ipv4.addr.dst = ip_hdr(skb)->daddr;

net/openvswitch/conntrack.c

648

memcpy(&key->ipv6.addr.dst, &ipv6_hdr(skb)->daddr,

net/openvswitch/conntrack.c

649

sizeof(key->ipv6.addr.dst));

net/openvswitch/conntrack.c

654

dst = udp_hdr(skb)->dest;

net/openvswitch/conntrack.c

656

dst = tcp_hdr(skb)->dest;

net/openvswitch/conntrack.c

658

dst = sctp_hdr(skb)->dest;

net/openvswitch/conntrack.c

662

key->tp.dst = dst;

net/openvswitch/datapath.h

182

unsigned long dst;

net/openvswitch/flow.c

403

key->ipv6.addr.dst = nh->daddr;

net/openvswitch/flow.c

559

key->tp.dst = htons(icmp->icmp6_code);

net/openvswitch/flow.c

701

key->ipv4.addr.dst = nh->daddr;

net/openvswitch/flow.c

724

key->tp.dst = tcp->dest;

net/openvswitch/flow.c

734

key->tp.dst = udp->dest;

net/openvswitch/flow.c

742

key->tp.dst = sctp->dest;

net/openvswitch/flow.c

753

key->tp.dst = htons(icmp->code);

net/openvswitch/flow.c

779

memcpy(&key->ipv4.addr.dst, arp->ar_tip, sizeof(key->ipv4.addr.dst));

net/openvswitch/flow.c

848

key->tp.dst = tcp->dest;

net/openvswitch/flow.c

857

key->tp.dst = udp->dest;

net/openvswitch/flow.c

865

key->tp.dst = sctp->dest;

net/openvswitch/flow.c

931

ether_addr_copy(key->eth.dst, eth->h_dest);

net/openvswitch/flow.h

111

__be16 dst; /* TCP/UDP/SCTP destination port. */

net/openvswitch/flow.h

118

__be32 dst; /* IP destination address. */

net/openvswitch/flow.h

123

__be32 dst;

net/openvswitch/flow.h

134

struct in6_addr dst; /* IPv6 destination address. */

net/openvswitch/flow.h

141

struct in6_addr dst;

net/openvswitch/flow.h

161

__be16 dst; /* CT orig tuple tp dst port. */

net/openvswitch/flow.h

173

key->tp.dst == 0 &&

net/openvswitch/flow.h

90

u8 dst[ETH_ALEN]; /* Ethernet destination address. */

net/openvswitch/flow_netlink.c

1268

SW_FLOW_KEY_PUT(match, ipv4.ct_orig.dst, ct->ipv4_dst, is_mask);

net/openvswitch/flow_netlink.c

1270

SW_FLOW_KEY_PUT(match, ct.orig_tp.dst, ct->dst_port, is_mask);

net/openvswitch/flow_netlink.c

1282

SW_FLOW_KEY_MEMCPY(match, ipv6.ct_orig.dst, &ct->ipv6_dst,

net/openvswitch/flow_netlink.c

1283

sizeof(match->key->ipv6.ct_orig.dst),

net/openvswitch/flow_netlink.c

1286

SW_FLOW_KEY_PUT(match, ct.orig_tp.dst, ct->dst_port, is_mask);

net/openvswitch/flow_netlink.c

1502

SW_FLOW_KEY_MEMCPY(match, eth.dst,

net/openvswitch/flow_netlink.c

1546

SW_FLOW_KEY_PUT(match, ipv4.addr.dst,

net/openvswitch/flow_netlink.c

1581

SW_FLOW_KEY_MEMCPY(match, ipv6.addr.dst,

net/openvswitch/flow_netlink.c

1583

sizeof(match->key->ipv6.addr.dst),

net/openvswitch/flow_netlink.c

1612

SW_FLOW_KEY_PUT(match, ipv4.addr.dst,

net/openvswitch/flow_netlink.c

1661

SW_FLOW_KEY_PUT(match, tp.dst, tcp_key->tcp_dst, is_mask);

net/openvswitch/flow_netlink.c

1677

SW_FLOW_KEY_PUT(match, tp.dst, udp_key->udp_dst, is_mask);

net/openvswitch/flow_netlink.c

1686

SW_FLOW_KEY_PUT(match, tp.dst, sctp_key->sctp_dst, is_mask);

net/openvswitch/flow_netlink.c

1696

SW_FLOW_KEY_PUT(match, tp.dst,

net/openvswitch/flow_netlink.c

1707

SW_FLOW_KEY_PUT(match, tp.dst,

net/openvswitch/flow_netlink.c

2042

ether_addr_copy(eth_key->eth_dst, output->eth.dst);

net/openvswitch/flow_netlink.c

2095

ipv4_key->ipv4_dst = output->ipv4.addr.dst;

net/openvswitch/flow_netlink.c

2110

memcpy(ipv6_key->ipv6_dst, &output->ipv6.addr.dst,

net/openvswitch/flow_netlink.c

2137

arp_key->arp_tip = output->ipv4.addr.dst;

net/openvswitch/flow_netlink.c

2168

tcp_key->tcp_dst = output->tp.dst;

net/openvswitch/flow_netlink.c

2180

udp_key->udp_dst = output->tp.dst;

net/openvswitch/flow_netlink.c

2189

sctp_key->sctp_dst = output->tp.dst;

net/openvswitch/flow_netlink.c

2199

icmp_key->icmp_code = ntohs(output->tp.dst);

net/openvswitch/flow_netlink.c

2210

icmpv6_key->icmpv6_code = ntohs(output->tp.dst);

net/openvswitch/flow_netlink.c

2789

else if (key.tun_proto == AF_INET && key.tun_key.u.ipv4.dst == 0)

net/openvswitch/flow_netlink.c

716

SW_FLOW_KEY_PUT(match, tun_key.u.ipv4.dst,

net/openvswitch/flow_netlink.c

726

SW_FLOW_KEY_PUT(match, tun_key.u.ipv6.dst,

net/openvswitch/flow_netlink.c

838

match->key->tun_key.u.ipv4.dst ||

net/openvswitch/flow_netlink.c

847

} else if (!match->key->tun_key.u.ipv4.dst) {

net/openvswitch/flow_netlink.c

852

if (ipv6 && ipv6_addr_any(&match->key->tun_key.u.ipv6.dst)) {

net/openvswitch/flow_netlink.c

903

if (output->u.ipv4.dst &&

net/openvswitch/flow_netlink.c

905

output->u.ipv4.dst))

net/openvswitch/flow_netlink.c

913

if (!ipv6_addr_any(&output->u.ipv6.dst) &&

net/openvswitch/flow_netlink.c

915

&output->u.ipv6.dst))

net/openvswitch/flow_table.c

53

void ovs_flow_mask_key(struct sw_flow_key *dst, const struct sw_flow_key *src,

net/openvswitch/flow_table.c

57

int len = full ? sizeof *dst : range_n_bytes(&mask->range);

net/openvswitch/flow_table.c

60

long *d = (long *)((u8 *)dst + start);

net/openvswitch/flow_table.h

107

void ovs_flow_mask_key(struct sw_flow_key *dst, const struct sw_flow_key *src,

net/phonet/af_phonet.c

152

u16 dst, u16 src, u8 res)

net/phonet/af_phonet.c

164

if (pn_addr(dst) == PNADDR_BROADCAST) {

net/phonet/af_phonet.c

174

ph->pn_rdev = pn_dev(dst);

net/phonet/af_phonet.c

178

ph->pn_robj = pn_obj(dst);

net/phonet/af_phonet.c

208

u16 dst, u16 src, u8 res)

net/phonet/af_phonet.c

214

if (phonet_address_lookup(dev_net(dev), pn_addr(dst)) == 0)

net/phonet/af_phonet.c

220

return pn_send(skb, dev, dst, src, res);

net/phonet/af_phonet.c

234

u16 src, dst;

net/phonet/af_phonet.c

239

dst = pn_sockaddr_get_object(target);

net/phonet/af_phonet.c

242

dst = pn->dobject;

net/phonet/af_phonet.c

245

daddr = pn_addr(dst);

net/phonet/af_phonet.c

253

} else if (dst == 0) {

net/phonet/af_phonet.c

275

err = pn_send(skb, dev, dst, src, res);

net/phonet/pep.c

196

struct sockaddr_pn dst;

net/phonet/pep.c

213

pn_skb_get_src_sockaddr(oskb, &dst);

net/phonet/pep.c

214

return pn_skb_send(sk, skb, &dst);

net/phonet/pep.c

626

const struct sockaddr_pn *dst,

net/phonet/pep.c

630

u16 dobj = pn_sockaddr_get_object(dst);

net/phonet/pep.c

659

struct sockaddr_pn dst;

net/phonet/pep.c

670

pn_skb_get_dst_sockaddr(skb, &dst);

net/phonet/pep.c

673

sknode = pep_find_pipe(&pn->hlist, &dst, pipe_handle);

net/phonet/pep.c

769

struct sockaddr_pn dst, src;

net/phonet/pep.c

829

pn_skb_get_dst_sockaddr(skb, &dst);

net/phonet/pep.c

830

newsk = pep_find_pipe(&pn->hlist, &dst, pipe_handle);

net/phonet/pep.c

855

newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);

net/phonet/pep.c

857

newpn->pn_sk.resource = pn_sockaddr_get_resource(&dst);

net/phonet/pn_netlink.c

173

static int fill_route(struct sk_buff *skb, u32 ifindex, u8 dst,

net/phonet/pn_netlink.c

193

if (nla_put_u8(skb, RTA_DST, dst) || nla_put_u32(skb, RTA_OIF, ifindex))

net/phonet/pn_netlink.c

203

void rtm_phonet_notify(struct net *net, int event, u32 ifindex, u8 dst)

net/phonet/pn_netlink.c

213

err = fill_route(skb, ifindex, dst, 0, 0, event);

net/phonet/pn_netlink.c

241

u8 dst;

net/phonet/pn_netlink.c

259

dst = nla_get_u8(tb[RTA_DST]);

net/phonet/pn_netlink.c

260

if (dst & 3) /* Phonet addresses only have 6 high-order bits */

net/phonet/pn_netlink.c

274

err = phonet_route_add(dev, dst);

net/phonet/pn_netlink.c

276

err = phonet_route_del(dev, dst);

net/phonet/pn_netlink.c

288

rtm_phonet_notify(net, nlh->nlmsg_type, ifindex, dst);

net/psample/psample.c

239

if (tun_key->u.ipv4.dst &&

net/psample/psample.c

241

tun_key->u.ipv4.dst))

net/psample/psample.c

249

if (!ipv6_addr_any(&tun_key->u.ipv6.dst) &&

net/psample/psample.c

251

&tun_key->u.ipv6.dst))

net/psample/psample.c

328

if (tun_key->u.ipv4.dst)

net/psample/psample.c

334

if (!ipv6_addr_any(&tun_key->u.ipv6.dst))

net/psp/psp_sock.c

15

struct dst_entry *dst;

net/psp/psp_sock.c

18

dst = __sk_dst_get(sk);

net/psp/psp_sock.c

19

if (dst) {

net/psp/psp_sock.c

20

psd = rcu_dereference(dst_dev_rcu(dst)->psp_dev);

net/qrtr/af_qrtr.c

620

struct sockaddr_qrtr dst = {AF_QIPCRTR, qrtr_local_nid, QRTR_PORT_CTRL};

net/qrtr/af_qrtr.c

642

qrtr_local_enqueue(NULL, skb, QRTR_TYPE_BYE, &src, &dst);

net/rds/ib_recv.c

811

__le64 *src, *dst;

net/rds/ib_recv.c

820

dst = (void *)map->m_page_addrs[map_page] + map_off;

net/rds/ib_recv.c

824

uncongested |= ~(*src) & *dst;

net/rds/ib_recv.c

825

*dst++ = *src++;

net/rds/message.c

246

unsigned char *dst;

net/rds/message.c

253

if (rds_find_next_ext_space(hdr, len, &dst))

net/rds/message.c

256

*dst++ = type;

net/rds/message.c

257

memcpy(dst, data, len);

net/rxrpc/peer_object.c

155

struct dst_entry *dst;

net/rxrpc/peer_object.c

181

dst = &rt->dst;

net/rxrpc/peer_object.c

193

dst = ip6_route_output(net, NULL, fl6);

net/rxrpc/peer_object.c

194

if (dst->error) {

net/rxrpc/peer_object.c

195

_leave(" [route err %d]", dst->error);

net/rxrpc/peer_object.c

205

peer->if_mtu = dst_mtu(dst);

net/rxrpc/peer_object.c

206

peer->hdrsize += dst->header_len + dst->trailer_len;

net/rxrpc/peer_object.c

207

peer->tx_seg_max = dst->dev->gso_max_segs;

net/rxrpc/peer_object.c

208

dst_release(dst);

net/sched/act_ct.c

107

if (memcmp(&target.dst.u3, &tuple->dst.u3, sizeof(target.dst.u3)))

net/sched/act_ct.c

111

be32_to_cpu(target.dst.u3.ip));

net/sched/act_ct.c

136

if (memcmp(&target.dst.u3, &tuple->dst.u3, sizeof(target.dst.u3)))

net/sched/act_ct.c

137

tcf_ct_add_ipv6_addr_mangle_action(action, &target.dst.u3,

net/sched/act_ct.c

148

__be16 target_dst = target.dst.u.tcp.port;

net/sched/act_ct.c

1524

nla_put_u8(skb, TCA_CT_HELPER_PROTO, helper->tuple.dst.protonum))

net/sched/act_ct.c

154

if (target_dst != tuple->dst.u.tcp.port)

net/sched/act_ct.c

166

__be16 target_dst = target.dst.u.udp.port;

net/sched/act_ct.c

172

if (target_dst != tuple->dst.u.udp.port)

net/sched/act_ct.c

496

if (tuple->src.u.gre.key || tuple->dst.u.gre.key)

net/sched/act_gate.c

233

static int tcf_gate_copy_entries(struct tcf_gate_params *dst,

net/sched/act_gate.c

254

list_add_tail(&new->list, &dst->entries);

net/sched/act_gate.c

258

dst->num_entries = i;

net/sched/act_tunnel_key.c

118

if (dst) {

net/sched/act_tunnel_key.c

119

struct geneve_opt *opt = dst;

net/sched/act_tunnel_key.c

138

tunnel_key_copy_vxlan_opt(const struct nlattr *nla, void *dst, int dst_len,

net/sched/act_tunnel_key.c

154

if (dst) {

net/sched/act_tunnel_key.c

155

struct vxlan_metadata *md = dst;

net/sched/act_tunnel_key.c

165

tunnel_key_copy_erspan_opt(const struct nlattr *nla, void *dst, int dst_len,

net/sched/act_tunnel_key.c

199

if (dst) {

net/sched/act_tunnel_key.c

200

struct erspan_metadata *md = dst;

net/sched/act_tunnel_key.c

217

static int tunnel_key_copy_opts(const struct nlattr *nla, u8 *dst,

net/sched/act_tunnel_key.c

235

opt_len = tunnel_key_copy_geneve_opt(attr, dst,

net/sched/act_tunnel_key.c

244

if (dst) {

net/sched/act_tunnel_key.c

246

dst += opt_len;

net/sched/act_tunnel_key.c

255

opt_len = tunnel_key_copy_vxlan_opt(attr, dst,

net/sched/act_tunnel_key.c

267

opt_len = tunnel_key_copy_erspan_opt(attr, dst,

net/sched/act_tunnel_key.c

350

dst_release(&p->tcft_enc_metadata->dst);

net/sched/act_tunnel_key.c

44

skb_dst_set(skb, dst_clone(&params->tcft_enc_metadata->dst));

net/sched/act_tunnel_key.c

551

dst_release(&metadata->dst);

net/sched/act_tunnel_key.c

694

__be32 daddr = info->key.u.ipv4.dst;

net/sched/act_tunnel_key.c

703

const struct in6_addr *daddr6 = &info->key.u.ipv6.dst;

net/sched/act_tunnel_key.c

86

tunnel_key_copy_geneve_opt(const struct nlattr *nla, void *dst, int dst_len,

net/sched/act_vlan.c

382

tcf_vlan_push_eth(entry->vlan_push_eth.src, entry->vlan_push_eth.dst, act);

net/sched/cls_api.c

3455

void tcf_exts_change(struct tcf_exts *dst, struct tcf_exts *src)

net/sched/cls_api.c

3458

struct tcf_exts old = *dst;

net/sched/cls_api.c

3460

*dst = *src;

net/sched/cls_flow.c

106

return ntohs(flow->ports.dst);

net/sched/cls_flow.c

170

return ntohl(CTTUPLE(skb, dst.u3.ip));

net/sched/cls_flow.c

172

return ntohl(CTTUPLE(skb, dst.u3.ip6[3]));

net/sched/cls_flow.c

189

return ntohs(CTTUPLE(skb, dst.u.all));

net/sched/cls_flow.c

79

__be32 dst = flow_get_u32_dst(flow);

net/sched/cls_flow.c

81

if (dst)

net/sched/cls_flow.c

82

return ntohl(dst);

net/sched/cls_flower.c

1889

fl_set_key_val(tb, key->eth.dst, TCA_FLOWER_KEY_ETH_DST,

net/sched/cls_flower.c

1890

mask->eth.dst, TCA_FLOWER_KEY_ETH_DST_MASK,

net/sched/cls_flower.c

1891

sizeof(key->eth.dst));

net/sched/cls_flower.c

1939

fl_set_key_val(tb, &key->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST,

net/sched/cls_flower.c

1940

&mask->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST_MASK,

net/sched/cls_flower.c

1941

sizeof(key->ipv4.dst));

net/sched/cls_flower.c

1948

fl_set_key_val(tb, &key->ipv6.dst, TCA_FLOWER_KEY_IPV6_DST,

net/sched/cls_flower.c

1949

&mask->ipv6.dst, TCA_FLOWER_KEY_IPV6_DST_MASK,

net/sched/cls_flower.c

1950

sizeof(key->ipv6.dst));

net/sched/cls_flower.c

1957

fl_set_key_val(tb, &key->tp.dst, TCA_FLOWER_KEY_TCP_DST,

net/sched/cls_flower.c

1958

&mask->tp.dst, TCA_FLOWER_KEY_TCP_DST_MASK,

net/sched/cls_flower.c

1959

sizeof(key->tp.dst));

net/sched/cls_flower.c

1967

fl_set_key_val(tb, &key->tp.dst, TCA_FLOWER_KEY_UDP_DST,

net/sched/cls_flower.c

1968

&mask->tp.dst, TCA_FLOWER_KEY_UDP_DST_MASK,

net/sched/cls_flower.c

1969

sizeof(key->tp.dst));

net/sched/cls_flower.c

1974

fl_set_key_val(tb, &key->tp.dst, TCA_FLOWER_KEY_SCTP_DST,

net/sched/cls_flower.c

1975

&mask->tp.dst, TCA_FLOWER_KEY_SCTP_DST_MASK,

net/sched/cls_flower.c

1976

sizeof(key->tp.dst));

net/sched/cls_flower.c

2053

fl_set_key_val(tb, &key->enc_ipv4.dst,

net/sched/cls_flower.c

2055

&mask->enc_ipv4.dst,

net/sched/cls_flower.c

2057

sizeof(key->enc_ipv4.dst));

net/sched/cls_flower.c

2069

fl_set_key_val(tb, &key->enc_ipv6.dst,

net/sched/cls_flower.c

2071

&mask->enc_ipv6.dst,

net/sched/cls_flower.c

2073

sizeof(key->enc_ipv6.dst));

net/sched/cls_flower.c

2084

fl_set_key_val(tb, &key->enc_tp.dst, TCA_FLOWER_KEY_ENC_UDP_DST_PORT,

net/sched/cls_flower.c

2085

&mask->enc_tp.dst, TCA_FLOWER_KEY_ENC_UDP_DST_PORT_MASK,

net/sched/cls_flower.c

2086

sizeof(key->enc_tp.dst));

net/sched/cls_flower.c

2120

static void fl_mask_copy(struct fl_flow_mask *dst,

net/sched/cls_flower.c

2124

void *pdst = fl_key_get_start(&dst->key, src);

net/sched/cls_flower.c

2127

dst->range = src->range;

net/sched/cls_flower.c

2246

if ((newmask->key.tp_range.tp_min.dst &&

net/sched/cls_flower.c

2247

newmask->key.tp_range.tp_max.dst) ||

net/sched/cls_flower.c

230

min_mask = ntohs(filter->mask->key.tp_range.tp_min.dst);

net/sched/cls_flower.c

231

max_mask = ntohs(filter->mask->key.tp_range.tp_max.dst);

net/sched/cls_flower.c

232

min_val = ntohs(filter->key.tp_range.tp_min.dst);

net/sched/cls_flower.c

233

max_val = ntohs(filter->key.tp_range.tp_max.dst);

net/sched/cls_flower.c

236

if (ntohs(key->tp_range.tp.dst) < min_val ||

net/sched/cls_flower.c

237

ntohs(key->tp_range.tp.dst) > max_val)

net/sched/cls_flower.c

241

mkey->tp_range.tp_min.dst = filter->mkey.tp_range.tp_min.dst;

net/sched/cls_flower.c

242

mkey->tp_range.tp_max.dst = filter->mkey.tp_range.tp_max.dst;

net/sched/cls_flower.c

2905

if (fl_dump_key_val(skb, &key->tp_range.tp_min.dst,

net/sched/cls_flower.c

2907

&mask->tp_range.tp_min.dst, TCA_FLOWER_UNSPEC,

net/sched/cls_flower.c

2908

sizeof(key->tp_range.tp_min.dst)) ||

net/sched/cls_flower.c

2909

fl_dump_key_val(skb, &key->tp_range.tp_max.dst,

net/sched/cls_flower.c

2911

&mask->tp_range.tp_max.dst, TCA_FLOWER_UNSPEC,

net/sched/cls_flower.c

2912

sizeof(key->tp_range.tp_max.dst)) ||

net/sched/cls_flower.c

3455

if (fl_dump_key_val(skb, key->eth.dst, TCA_FLOWER_KEY_ETH_DST,

net/sched/cls_flower.c

3456

mask->eth.dst, TCA_FLOWER_KEY_ETH_DST_MASK,

net/sched/cls_flower.c

3457

sizeof(key->eth.dst)) ||

net/sched/cls_flower.c

3521

fl_dump_key_val(skb, &key->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST,

net/sched/cls_flower.c

3522

&mask->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST_MASK,

net/sched/cls_flower.c

3523

sizeof(key->ipv4.dst))))

net/sched/cls_flower.c

3529

fl_dump_key_val(skb, &key->ipv6.dst, TCA_FLOWER_KEY_IPV6_DST,

net/sched/cls_flower.c

3530

&mask->ipv6.dst, TCA_FLOWER_KEY_IPV6_DST_MASK,

net/sched/cls_flower.c

3531

sizeof(key->ipv6.dst))))

net/sched/cls_flower.c

3538

fl_dump_key_val(skb, &key->tp.dst, TCA_FLOWER_KEY_TCP_DST,

net/sched/cls_flower.c

3539

&mask->tp.dst, TCA_FLOWER_KEY_TCP_DST_MASK,

net/sched/cls_flower.c

3540

sizeof(key->tp.dst)) ||

net/sched/cls_flower.c

3549

fl_dump_key_val(skb, &key->tp.dst, TCA_FLOWER_KEY_UDP_DST,

net/sched/cls_flower.c

3550

&mask->tp.dst, TCA_FLOWER_KEY_UDP_DST_MASK,

net/sched/cls_flower.c

3551

sizeof(key->tp.dst))))

net/sched/cls_flower.c

3557

fl_dump_key_val(skb, &key->tp.dst, TCA_FLOWER_KEY_SCTP_DST,

net/sched/cls_flower.c

3558

&mask->tp.dst, TCA_FLOWER_KEY_SCTP_DST_MASK,

net/sched/cls_flower.c

3559

sizeof(key->tp.dst))))

net/sched/cls_flower.c

3629

fl_dump_key_val(skb, &key->enc_ipv4.dst,

net/sched/cls_flower.c

3630

TCA_FLOWER_KEY_ENC_IPV4_DST, &mask->enc_ipv4.dst,

net/sched/cls_flower.c

3632

sizeof(key->enc_ipv4.dst))))

net/sched/cls_flower.c

3639

fl_dump_key_val(skb, &key->enc_ipv6.dst,

net/sched/cls_flower.c

3641

&mask->enc_ipv6.dst,

net/sched/cls_flower.c

3643

sizeof(key->enc_ipv6.dst))))

net/sched/cls_flower.c

3654

fl_dump_key_val(skb, &key->enc_tp.dst,

net/sched/cls_flower.c

3656

&mask->enc_tp.dst,

net/sched/cls_flower.c

3658

sizeof(key->enc_tp.dst)) ||

net/sched/cls_flower.c

848

fl_set_key_val(tb, &key->tp_range.tp_min.dst,

net/sched/cls_flower.c

849

TCA_FLOWER_KEY_PORT_DST_MIN, &mask->tp_range.tp_min.dst,

net/sched/cls_flower.c

850

TCA_FLOWER_UNSPEC, sizeof(key->tp_range.tp_min.dst));

net/sched/cls_flower.c

851

fl_set_key_val(tb, &key->tp_range.tp_max.dst,

net/sched/cls_flower.c

852

TCA_FLOWER_KEY_PORT_DST_MAX, &mask->tp_range.tp_max.dst,

net/sched/cls_flower.c

853

TCA_FLOWER_UNSPEC, sizeof(key->tp_range.tp_max.dst));

net/sched/cls_flower.c

861

if (mask->tp_range.tp_min.dst != mask->tp_range.tp_max.dst) {

net/sched/cls_flower.c

871

if (mask->tp_range.tp_min.dst && mask->tp_range.tp_max.dst &&

net/sched/cls_flower.c

872

ntohs(key->tp_range.tp_max.dst) <=

net/sched/cls_flower.c

873

ntohs(key->tp_range.tp_min.dst)) {

net/sched/cls_route.c

130

struct dst_entry *dst;

net/sched/cls_route.c

136

dst = skb_dst(skb);

net/sched/cls_route.c

137

if (!dst)

net/sched/cls_route.c

140

id = dst->tclassid;

net/sched/em_meta.c

101

struct meta_obj *dst, int *err)

net/sched/em_meta.c

109

get_random_bytes(&dst->value, sizeof(dst->value));

net/sched/em_meta.c

122

dst->value = fixed_loadavg(avenrun[0]);

net/sched/em_meta.c

127

dst->value = fixed_loadavg(avenrun[1]);

net/sched/em_meta.c

132

dst->value = fixed_loadavg(avenrun[2]);

net/sched/em_meta.c

139

static inline int int_dev(struct net_device *dev, struct meta_obj *dst)

net/sched/em_meta.c

144

dst->value = dev->ifindex;

net/sched/em_meta.c

148

static inline int var_dev(struct net_device *dev, struct meta_obj *dst)

net/sched/em_meta.c

153

dst->value = (unsigned long) dev->name;

net/sched/em_meta.c

154

dst->len = strlen(dev->name);

net/sched/em_meta.c

160

*err = int_dev(skb->dev, dst);

net/sched/em_meta.c

165

*err = var_dev(skb->dev, dst);

net/sched/em_meta.c

177

dst->value = skb_vlan_tag_get(skb);

net/sched/em_meta.c

179

dst->value = tag;

net/sched/em_meta.c

192

dst->value = skb->priority;

net/sched/em_meta.c

198

dst->value = skb_protocol(skb, false);

net/sched/em_meta.c

203

dst->value = skb->pkt_type;

net/sched/em_meta.c

208

dst->value = skb->len;

net/sched/em_meta.c

213

dst->value = skb->data_len;

net/sched/em_meta.c

218

dst->value = skb->mac_len;

net/sched/em_meta.c

223

dst->value = skb_get_hash(skb);

net/sched/em_meta.c

232

dst->value = skb->mark;

net/sched/em_meta.c

241

dst->value = skb->tc_index;

net/sched/em_meta.c

254

dst->value = skb_dst(skb)->tclassid;

net/sched/em_meta.c

256

dst->value = 0;

net/sched/em_meta.c

265

dst->value = inet_iif(skb);

net/sched/em_meta.c

281

dst->value = skb->sk->sk_family;

net/sched/em_meta.c

290

dst->value = skb->sk->sk_state;

net/sched/em_meta.c

299

dst->value = skb->sk->sk_reuse;

net/sched/em_meta.c

309

dst->value = skb->sk->sk_bound_dev_if;

net/sched/em_meta.c

323

dst->value = (unsigned long) "any";

net/sched/em_meta.c

324

dst->len = 3;

net/sched/em_meta.c

331

*err = var_dev(dev, dst);

net/sched/em_meta.c

342

dst->value = refcount_read(&skb->sk->sk_refcnt);

net/sched/em_meta.c

353

dst->value = sk->sk_rcvbuf;

net/sched/em_meta.c

364

dst->value = sk->sk_shutdown;

net/sched/em_meta.c

375

dst->value = sk->sk_protocol;

net/sched/em_meta.c

386

dst->value = sk->sk_type;

net/sched/em_meta.c

397

dst->value = sk_rmem_alloc_get(sk);

net/sched/em_meta.c

408

dst->value = sk_wmem_alloc_get(sk);

net/sched/em_meta.c

419

dst->value = atomic_read(&sk->sk_omem_alloc);

net/sched/em_meta.c

430

dst->value = sk->sk_receive_queue.qlen;

net/sched/em_meta.c

441

dst->value = sk->sk_write_queue.qlen;

net/sched/em_meta.c

452

dst->value = READ_ONCE(sk->sk_wmem_queued);

net/sched/em_meta.c

463

dst->value = READ_ONCE(sk->sk_forward_alloc);

net/sched/em_meta.c

474

dst->value = sk->sk_sndbuf;

net/sched/em_meta.c

485

dst->value = (__force int) sk->sk_allocation;

net/sched/em_meta.c

494

dst->value = skb->sk->sk_hash;

net/sched/em_meta.c

505

dst->value = READ_ONCE(sk->sk_lingertime) / HZ;

net/sched/em_meta.c

516

dst->value = sk->sk_error_queue.qlen;

net/sched/em_meta.c

527

dst->value = READ_ONCE(sk->sk_ack_backlog);

net/sched/em_meta.c

538

dst->value = READ_ONCE(sk->sk_max_ack_backlog);

net/sched/em_meta.c

549

dst->value = READ_ONCE(sk->sk_priority);

net/sched/em_meta.c

560

dst->value = READ_ONCE(sk->sk_rcvlowat);

net/sched/em_meta.c

571

dst->value = READ_ONCE(sk->sk_rcvtimeo) / HZ;

net/sched/em_meta.c

582

dst->value = READ_ONCE(sk->sk_sndtimeo) / HZ;

net/sched/em_meta.c

593

dst->value = sk->sk_frag.offset;

net/sched/em_meta.c

604

dst->value = sk->sk_write_pending;

net/sched/em_meta.c

695

static int meta_var_change(struct meta_value *dst, struct nlattr *nla)

net/sched/em_meta.c

699

dst->val = (unsigned long)kmemdup(nla_data(nla), len, GFP_KERNEL);

net/sched/em_meta.c

700

if (dst->val == 0UL)

net/sched/em_meta.c

702

dst->len = len;

net/sched/em_meta.c

712

struct meta_obj *dst)

net/sched/em_meta.c

716

if (shift && shift < dst->len)

net/sched/em_meta.c

717

dst->len -= shift;

net/sched/em_meta.c

748

static int meta_int_change(struct meta_value *dst, struct nlattr *nla)

net/sched/em_meta.c

751

dst->val = *(unsigned long *) nla_data(nla);

net/sched/em_meta.c

752

dst->len = sizeof(unsigned long);

net/sched/em_meta.c

754

dst->val = nla_get_u32(nla);

net/sched/em_meta.c

755

dst->len = sizeof(u32);

net/sched/em_meta.c

763

struct meta_obj *dst)

net/sched/em_meta.c

766

dst->value >>= v->hdr.shift;

net/sched/em_meta.c

769

dst->value &= v->val;

net/sched/em_meta.c

826

struct meta_value *v, struct meta_obj *dst)

net/sched/em_meta.c

831

dst->value = v->val;

net/sched/em_meta.c

832

dst->len = v->len;

net/sched/em_meta.c

836

meta_ops(v)->get(skb, info, v, dst, &err);

net/sched/em_meta.c

841

meta_type_ops(v)->apply_extras(v, dst);

net/sched/em_meta.c

885

static inline int meta_change_data(struct meta_value *dst, struct nlattr *nla)

net/sched/em_meta.c

891

return meta_type_ops(dst)->change(dst, nla);

net/sched/sch_cake.c

601

ip = rev ? tuple.dst.u3.ip : tuple.src.u3.ip;

net/sched/sch_cake.c

606

ip = rev ? tuple.src.u3.ip : tuple.dst.u3.ip;

net/sched/sch_cake.c

607

if (ip != keys->addrs.v4addrs.dst) {

net/sched/sch_cake.c

608

keys->addrs.v4addrs.dst = ip;

net/sched/sch_cake.c

615

port = rev ? tuple.dst.u.all : tuple.src.u.all;

net/sched/sch_cake.c

620

port = rev ? tuple.src.u.all : tuple.dst.u.all;

net/sched/sch_cake.c

621

if (port != keys->ports.dst) {

net/sched/sch_cake.c

622

port = keys->ports.dst;

net/sched/sch_cake.c

752

host_keys.addrs.v4addrs.dst = 0;

net/sched/sch_cake.c

761

memset(&host_keys.addrs.v6addrs.dst, 0,

net/sched/sch_cake.c

762

sizeof(host_keys.addrs.v6addrs.dst));

net/sched/sch_frag.c

104

dst_init(&sch_frag_rt.dst, &sch_frag_dst_ops, NULL,

net/sched/sch_frag.c

106

sch_frag_rt.dst.dev = skb->dev;

net/sched/sch_frag.c

109

skb_dst_set_noref(skb, &sch_frag_rt.dst);

net/sched/sch_frag.c

11

unsigned long dst;

net/sched/sch_frag.c

122

dst_init(&sch_frag_rt.dst, &sch_frag_dst_ops, NULL,

net/sched/sch_frag.c

124

sch_frag_rt.dst.dev = skb->dev;

net/sched/sch_frag.c

127

skb_dst_set_noref(skb, &sch_frag_rt.dst);

net/sched/sch_frag.c

36

__skb_dst_copy(skb, data->dst);

net/sched/sch_frag.c

61

data->dst = skb->_skb_refdst;

net/sched/sch_frag.c

78

sch_frag_dst_get_mtu(const struct dst_entry *dst)

net/sched/sch_frag.c

80

return dst->dev->mtu;

net/sched/sch_qfq.c

788

int src, int dst)

net/sched/sch_qfq.c

790

q->bitmaps[dst] |= q->bitmaps[src] & mask;

net/sched/sch_teql.c

222

struct dst_entry *dst)

net/sched/sch_teql.c

227

n = dst_neigh_lookup_skb(dst, skb);

net/sched/sch_teql.c

231

if (dst->dev != dev) {

net/sched/sch_teql.c

263

struct dst_entry *dst = skb_dst(skb);

net/sched/sch_teql.c

269

if (!dev->header_ops || !dst)

net/sched/sch_teql.c

273

res = __teql_resolve(skb, skb_res, dev, txq, dst);

net/sctp/associola.c

1418

if (t->pmtu_pending && t->dst) {

net/sctp/diag.c

31

struct dst_entry *dst;

net/sctp/diag.c

37

dst = asoc->peer.primary_path->dst;

net/sctp/diag.c

42

r->id.idiag_if = dst ? dst->dev->ifindex : 0;

net/sctp/input.c

411

struct dst_entry *dst;

net/sctp/input.c

415

dst = sctp_transport_dst_check(t);

net/sctp/input.c

416

if (dst)

net/sctp/input.c

417

dst->ops->redirect(dst, sk, skb);

net/sctp/ipv6.c

222

struct dst_entry *dst = dst_clone(t->dst);

net/sctp/ipv6.c

246

skb_dst_set(skb, dst);

net/sctp/ipv6.c

264

udp_tunnel6_xmit_skb(dst, sk, skb, NULL, &fl6->saddr, &fl6->daddr,

net/sctp/ipv6.c

265

tclass, ip6_dst_hoplimit(dst), label,

net/sctp/ipv6.c

277

struct dst_entry *dst = NULL;

net/sctp/ipv6.c

327

dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_p);

net/sctp/ipv6.c

329

t->dst = dst;

net/sctp/ipv6.c

339

if (!IS_ERR(dst)) {

net/sctp/ipv6.c

355

t->dst = dst;

net/sctp/ipv6.c

364

dst_release(dst);

net/sctp/ipv6.c

365

dst = NULL;

net/sctp/ipv6.c

392

if (!IS_ERR_OR_NULL(dst))

net/sctp/ipv6.c

393

dst_release(dst);

net/sctp/ipv6.c

394

dst = bdst;

net/sctp/ipv6.c

395

t->dst = dst;

net/sctp/ipv6.c

406

if (!IS_ERR_OR_NULL(dst))

net/sctp/ipv6.c

407

dst_release(dst);

net/sctp/ipv6.c

408

dst = bdst;

net/sctp/ipv6.c

410

t->dst = dst;

net/sctp/ipv6.c

416

if (!IS_ERR_OR_NULL(dst)) {

net/sctp/ipv6.c

419

rt = dst_rt6_info(dst);

net/sctp/ipv6.c

425

t->dst = NULL;

net/sctp/ipv6.c

449

pr_debug("%s: asoc:%p dst:%p\n", __func__, t->asoc, t->dst);

net/sctp/ipv6.c

451

if (t->dst) {

net/sctp/output.c

128

if (!tp->dst)

net/sctp/output.c

133

if (__sk_dst_get(sk) != tp->dst) {

net/sctp/output.c

134

dst_hold(tp->dst);

net/sctp/output.c

135

sk_setup_caps(sk, tp->dst);

net/sctp/output.c

137

packet->max_size = sk_can_gso(sk) ? min(READ_ONCE(tp->dst->dev->gso_max_size),

net/sctp/output.c

547

if (!(tp->dst->dev->features & NETIF_F_SCTP_CRC) ||

net/sctp/output.c

548

dst_xfrm(tp->dst) || packet->ipfragok || tp->encap_port) {

net/sctp/output.c

614

if (!tp->dst) {

net/sctp/outqueue.c

1168

if (t->dst && __sk_dst_get(sk) != t->dst) {

net/sctp/outqueue.c

1169

dst_hold(t->dst);

net/sctp/outqueue.c

1170

sk_setup_caps(sk, t->dst);

net/sctp/outqueue.c

1699

if (transport->dst)

net/sctp/protocol.c

1041

struct dst_entry *dst = dst_clone(t->dst);

net/sctp/protocol.c

1059

skb_dst_set(skb, dst);

net/sctp/protocol.c

1066

if (ip_dont_fragment(sk, dst) && !skb->ignore_df)

net/sctp/protocol.c

1073

udp_tunnel_xmit_skb(dst_rtable(dst), sk, skb, fl4->saddr,

net/sctp/protocol.c

1074

fl4->daddr, dscp, ip4_dst_hoplimit(dst), df,

net/sctp/protocol.c

426

struct dst_entry *dst = NULL;

net/sctp/protocol.c

457

dst = &rt->dst;

net/sctp/protocol.c

458

t->dst = dst;

net/sctp/protocol.c

470

if (dst) {

net/sctp/protocol.c

489

dst_release(dst);

net/sctp/protocol.c

490

dst = NULL;

net/sctp/protocol.c

521

if (!dst) {

net/sctp/protocol.c

522

dst = &rt->dst;

net/sctp/protocol.c

523

t->dst = dst;

net/sctp/protocol.c

526

dst_release(&rt->dst);

net/sctp/protocol.c

531

dst_release(dst);

net/sctp/protocol.c

532

dst = &rt->dst;

net/sctp/protocol.c

533

t->dst = dst;

net/sctp/protocol.c

541

if (dst) {

net/sctp/protocol.c

545

t->dst = NULL;

net/sctp/protocol.c

558

struct rtable *rt = dst_rtable(t->dst);

net/sctp/sm_sideeffect.c

809

if (t->dst)

net/sctp/transport.c

144

dst_release(transport->dst);

net/sctp/transport.c

234

if (!transport->dst || READ_ONCE(transport->dst->obsolete)) {

net/sctp/transport.c

249

if (transport->dst)

net/sctp/transport.c

250

transport->pathmtu = sctp_dst_mtu(transport->dst);

net/sctp/transport.c

396

struct dst_entry *dst;

net/sctp/transport.c

410

dst = sctp_transport_dst_check(t);

net/sctp/transport.c

411

if (dst) {

net/sctp/transport.c

412

struct sctp_pf *pf = sctp_get_pf_specific(dst->ops->family);

net/sctp/transport.c

417

dst->ops->update_pmtu(dst, sk, NULL, pmtu, true);

net/sctp/transport.c

420

dst = sctp_transport_dst_check(t);

net/sctp/transport.c

423

if (!dst) {

net/sctp/transport.c

425

dst = t->dst;

net/sctp/transport.c

428

if (dst) {

net/sctp/transport.c

430

pmtu = sctp_dst_mtu(dst);

net/sctp/transport.c

460

if (transport->dst && asoc &&

net/sctp/transport.c

843

dst_release(t->dst);

net/sctp/transport.c

844

t->dst = NULL;

net/smc/af_smc.c

125

struct dst_entry *dst,

net/smc/af_smc.c

153

child = smc->ori_af_ops->syn_recv_sock(sk, skb, req, dst, req_unhash,

net/smc/af_smc.c

167

dst_release(dst);

net/smc/smc_clc.c

571

struct dst_entry *dst;

net/smc/smc_clc.c

583

dst = __sk_dst_get(clcsock->sk);

net/smc/smc_clc.c

584

dev = dst ? dst_dev_rcu(dst) : NULL;

net/smc/smc_clc.c

661

struct dst_entry *dst;

net/smc/smc_clc.c

666

dst = __sk_dst_get(clcsock->sk);

net/smc/smc_clc.c

667

dev = dst ? dst_dev_rcu(dst) : NULL;

net/smc/smc_core.c

1902

struct dst_entry *dst;

net/smc/smc_core.c

1909

dst = __sk_dst_get(clcsock->sk);

net/smc/smc_core.c

1910

ndev = dst ? dst_dev_rcu(dst) : NULL;

net/smc/smc_ib.c

213

neigh = dst_neigh_lookup(&rt->dst, &fl4.daddr);

net/smc/smc_pnet.c

1130

struct dst_entry *dst;

net/smc/smc_pnet.c

1133

dst = __sk_dst_get(sk);

net/smc/smc_pnet.c

1134

dev = dst ? dst_dev_rcu(dst) : NULL;

net/smc/smc_pnet.c

1147

struct dst_entry *dst;

net/smc/smc_pnet.c

1152

dst = __sk_dst_get(sk);

net/smc/smc_pnet.c

1153

dev = dst ? dst_dev_rcu(dst) : NULL;

net/sunrpc/auth_gss/svcauth_gss.c

146

static int dup_to_netobj(struct xdr_netobj *dst, char *src, int len)

net/sunrpc/auth_gss/svcauth_gss.c

148

dst->len = len;

net/sunrpc/auth_gss/svcauth_gss.c

149

dst->data = (len ? kmemdup(src, len, GFP_KERNEL) : NULL);

net/sunrpc/auth_gss/svcauth_gss.c

150

if (len && !dst->data)

net/sunrpc/auth_gss/svcauth_gss.c

155

static inline int dup_netobj(struct xdr_netobj *dst, struct xdr_netobj *src)

net/sunrpc/auth_gss/svcauth_gss.c

157

return dup_to_netobj(dst, src->data, src->len);

net/sunrpc/rpc_pipe.c

105

char __user *dst, size_t buflen)

net/sunrpc/rpc_pipe.c

111

left = copy_to_user(dst, data, mlen);

net/sunrpc/sunrpc.h

28

struct dst_entry *dst;

net/sunrpc/sunrpc.h

31

dst = rcu_dereference(sk->sk_dst_cache);

net/sunrpc/sunrpc.h

32

if (dst && dst->dev &&

net/sunrpc/sunrpc.h

33

(dst->dev->features & NETIF_F_LOOPBACK))

net/sunrpc/svc.c

1779

char *result, *dst;

net/sunrpc/svc.c

1785

dst = result;

net/sunrpc/svc.c

1790

memcpy(dst, first->iov_base, len);

net/sunrpc/svc.c

1791

dst += len;

net/sunrpc/svc.c

1797

memcpy(dst, p, len);

net/sunrpc/svc.c

1798

dst += len;

net/sunrpc/svc.c

1801

*dst = '\0';

net/sunrpc/svcsock.c

1089

struct kvec *src, *dst;

net/sunrpc/svcsock.c

1106

dst = &req->rq_private_buf.head[0];

net/sunrpc/svcsock.c

1108

if (dst->iov_len < src->iov_len)

net/sunrpc/svcsock.c

1110

memcpy(dst->iov_base, src->iov_base, src->iov_len);

net/sunrpc/xprtrdma/rpc_rdma.c

666

unsigned char *dst;

net/sunrpc/xprtrdma/rpc_rdma.c

668

dst = (unsigned char *)xdr->head[0].iov_base;

net/sunrpc/xprtrdma/rpc_rdma.c

669

dst += xdr->head[0].iov_len + xdr->page_len;

net/sunrpc/xprtrdma/rpc_rdma.c

670

memmove(dst, xdr->tail[0].iov_base, xdr->tail[0].iov_len);

net/sunrpc/xprtrdma/rpc_rdma.c

682

unsigned char *src, *dst;

net/sunrpc/xprtrdma/rpc_rdma.c

684

dst = (unsigned char *)xdr->head[0].iov_base;

net/sunrpc/xprtrdma/rpc_rdma.c

685

dst += xdr->head[0].iov_len;

net/sunrpc/xprtrdma/rpc_rdma.c

693

memcpy(dst, src, len);

net/sunrpc/xprtrdma/rpc_rdma.c

697

dst += len;

net/sunrpc/xprtrdma/svc_rdma_backchannel.c

26

struct kvec *dst, *src = &rcvbuf->head[0];

net/sunrpc/xprtrdma/svc_rdma_backchannel.c

36

dst = &req->rq_private_buf.head[0];

net/sunrpc/xprtrdma/svc_rdma_backchannel.c

38

if (dst->iov_len < src->iov_len)

net/sunrpc/xprtrdma/svc_rdma_backchannel.c

40

memcpy(dst->iov_base, src->iov_base, src->iov_len);

net/sunrpc/xprtrdma/svc_rdma_rw.c

854

unsigned char *dst, *src = head->rc_recv_buf;

net/sunrpc/xprtrdma/svc_rdma_rw.c

870

dst = page_address(rqstp->rq_pages[head->rc_curpage]);

net/sunrpc/xprtrdma/svc_rdma_rw.c

871

memcpy((unsigned char *)dst + head->rc_pageoff, src + offset, page_len);

net/tipc/bcast.c

291

struct tipc_dest *dst, *tmp;

net/tipc/bcast.c

298

list_for_each_entry_safe(dst, tmp, &dests->list, list) {

net/tipc/bcast.c

299

dnode = dst->node;

net/tipc/bearer.c

586

struct tipc_media_addr *dst,

net/tipc/bearer.c

603

tipc_crypto_xmit(net, &skb, b, dst, __dnode);

net/tipc/bearer.c

606

b->media->send_msg(net, skb, b, dst);

net/tipc/bearer.c

620

struct tipc_media_addr *dst;

net/tipc/bearer.c

635

dst = &b->bcast_addr;

net/tipc/bearer.c

637

tipc_crypto_xmit(net, &skb, b, dst, NULL);

net/tipc/bearer.c

640

b->media->send_msg(net, skb, b, dst);

net/tipc/bearer.h

242

struct tipc_media_addr *dst,

net/tipc/crypto.c

1652

struct tipc_media_addr *dst,

net/tipc/crypto.c

1660

tipc_crypto_xmit(net, &skb, b, dst, __dnode);

net/tipc/crypto.c

1662

b->media->send_msg(net, skb, b, dst);

net/tipc/crypto.c

1690

struct tipc_bearer *b, struct tipc_media_addr *dst,

net/tipc/crypto.c

1721

tipc_crypto_clone_msg(net, *skb, b, dst, __dnode,

net/tipc/crypto.c

1745

tipc_crypto_clone_msg(net, *skb, b, dst,

net/tipc/crypto.c

1765

rc = tipc_aead_encrypt(aead, *skb, b, dst, __dnode);

net/tipc/crypto.c

242

struct tipc_media_addr dst;

net/tipc/crypto.c

261

static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src);

net/tipc/crypto.c

268

struct tipc_media_addr *dst,

net/tipc/crypto.c

294

struct tipc_media_addr *dst,

net/tipc/crypto.c

626

static int tipc_aead_clone(struct tipc_aead **dst, struct tipc_aead *src)

net/tipc/crypto.c

637

if (unlikely(*dst))

net/tipc/crypto.c

666

*dst = aead;

net/tipc/crypto.c

734

struct tipc_media_addr *dst,

net/tipc/crypto.c

812

memcpy(&tx_ctx->dst, dst, sizeof(*dst));

net/tipc/crypto.c

855

b->media->send_msg(net, skb, b, &tx_ctx->dst);

net/tipc/crypto.h

164

struct tipc_bearer *b, struct tipc_media_addr *dst,

net/tipc/discover.c

102

static void tipc_disc_msg_xmit(struct net *net, u32 mtyp, u32 dst,

net/tipc/discover.c

116

msg_set_dest_domain(hdr, dst);

net/tipc/discover.c

144

u32 dst, u32 src,

net/tipc/discover.c

159

if (dst != tn->trial_addr)

net/tipc/discover.c

204

u32 dst = msg_dest_domain(hdr);

net/tipc/discover.c

236

if (tipc_disc_addr_trial_msg(b->disc, &maddr, b, dst,

net/tipc/discover.c

246

if (!tipc_in_scope(legacy, dst, self))

net/tipc/msg.c

801

bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg,

net/tipc/msg.c

812

msg_set_destnode(buf_msg(_skb), dst);

net/tipc/msg.h

1178

bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg,

net/tipc/name_table.c

1145

struct tipc_dest *dst;

net/tipc/name_table.c

1147

list_for_each_entry(dst, l, list) {

net/tipc/name_table.c

1148

if (dst->node == node && dst->port == port)

net/tipc/name_table.c

1149

return dst;

net/tipc/name_table.c

1156

struct tipc_dest *dst;

net/tipc/name_table.c

1161

dst = kmalloc_obj(*dst, GFP_ATOMIC);

net/tipc/name_table.c

1162

if (unlikely(!dst))

net/tipc/name_table.c

1164

dst->node = node;

net/tipc/name_table.c

1165

dst->port = port;

net/tipc/name_table.c

1166

list_add(&dst->list, l);

net/tipc/name_table.c

1172

struct tipc_dest *dst;

net/tipc/name_table.c

1176

dst = list_first_entry(l, typeof(*dst), list);

net/tipc/name_table.c

1178

*port = dst->port;

net/tipc/name_table.c

1180

*node = dst->node;

net/tipc/name_table.c

1181

list_del(&dst->list);

net/tipc/name_table.c

1182

kfree(dst);

net/tipc/name_table.c

1188

struct tipc_dest *dst;

net/tipc/name_table.c

1190

dst = tipc_dest_find(l, node, port);

net/tipc/name_table.c

1191

if (!dst)

net/tipc/name_table.c

1193

list_del(&dst->list);

net/tipc/name_table.c

1194

kfree(dst);

net/tipc/name_table.c

1200

struct tipc_dest *dst, *tmp;

net/tipc/name_table.c

1202

list_for_each_entry_safe(dst, tmp, l, list) {

net/tipc/name_table.c

1203

list_del(&dst->list);

net/tipc/name_table.c

1204

kfree(dst);

net/tipc/node.c

1792

u32 dst;

net/tipc/node.c

1805

dst = n->addr;

net/tipc/node.c

1806

if (in_own_node(net, dst))

net/tipc/node.c

1813

msg_set_destnode(buf_msg(txskb), dst);

net/tipc/node.c

1814

tipc_node_xmit_skb(net, txskb, dst, 0);

net/tipc/socket.c

2575

struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest;

net/tipc/socket.c

2591

if (dst->family == AF_UNSPEC) {

net/tipc/socket.c

2597

if (!tipc_sockaddr_is_sane(dst)) {

net/tipc/socket.c

2605

} else if (dst->addrtype == TIPC_SERVICE_RANGE) {

net/tipc/udp_media.c

172

struct udp_media_addr *dst, struct dst_cache *cache)

net/tipc/udp_media.c

179

if (dst->proto == htons(ETH_P_IP)) {

net/tipc/udp_media.c

184

.daddr = dst->ipv4.s_addr,

net/tipc/udp_media.c

194

dst_cache_set_ip4(cache, &rt->dst, fl.saddr);

net/tipc/udp_media.c

197

ttl = ip4_dst_hoplimit(&rt->dst);

net/tipc/udp_media.c

199

dst->ipv4.s_addr, 0, ttl, 0, src->port,

net/tipc/udp_media.c

200

dst->port, false, true, 0);

net/tipc/udp_media.c

206

.daddr = dst->ipv6,

net/tipc/udp_media.c

221

&src->ipv6, &dst->ipv6, 0, ttl, 0,

net/tipc/udp_media.c

222

src->port, dst->port, false, 0);

net/tipc/udp_media.c

239

struct udp_media_addr *dst = (struct udp_media_addr *)&addr->value;

net/tipc/udp_media.c

258

return tipc_udp_xmit(net, skb, ub, src, dst,

net/tipc/udp_media.c

337

struct udp_media_addr *dst;

net/tipc/udp_media.c

339

dst = (struct udp_media_addr *)&b->bcast_addr.value;

net/tipc/udp_media.c

340

if (tipc_udp_is_mcast_addr(dst))

net/tipc/udp_media.c

547

struct udp_media_addr *dst;

net/tipc/udp_media.c

562

dst = (struct udp_media_addr *)&b->bcast_addr.value;

net/tipc/udp_media.c

563

if (__tipc_nl_add_udp_addr(msg->skb, dst, TIPC_NLA_UDP_REMOTE))

net/tipc/udp_media.c

631

struct udp_media_addr *dst;

net/tipc/udp_media.c

643

dst = (struct udp_media_addr *)&b->bcast_addr.value;

net/tipc/udp_media.c

644

if (tipc_udp_is_mcast_addr(dst)) {

net/tls/tls.h

204

int tls_strp_msg_hold(struct tls_strparser *strp, struct sk_buff_head *dst);

net/tls/tls_device.c

127

struct dst_entry *dst;

net/tls/tls_device.c

130

dst = __sk_dst_get(sk);

net/tls/tls_device.c

131

dev = dst ? dst_dev_rcu(dst) : NULL;

net/tls/tls_strp.c

145

int tls_strp_msg_hold(struct tls_strparser *strp, struct sk_buff_head *dst)

net/tls/tls_strp.c

159

__skb_queue_tail(dst, strp->anchor);

net/tls/tls_strp.c

181

__skb_queue_tail(dst, clone);

net/tls/tls_sw.c

191

struct scatterlist *sgout = aead_req->dst;

net/vmw_vsock/af_vsock.c

236

#define VSOCK_CONN_HASH(src, dst) \

net/vmw_vsock/af_vsock.c

237

(((src)->svm_cid ^ (dst)->svm_port) % VSOCK_HASH_SIZE)

net/vmw_vsock/af_vsock.c

238

#define vsock_connected_sockets(src, dst) \

net/vmw_vsock/af_vsock.c

239

(&vsock_connected_table[VSOCK_CONN_HASH(src, dst)])

net/vmw_vsock/af_vsock.c

323

struct sockaddr_vm *dst, struct net *net)

net/vmw_vsock/af_vsock.c

327

list_for_each_entry(vsk, vsock_connected_sockets(src, dst),

net/vmw_vsock/af_vsock.c

332

dst->svm_port == vsk->local_addr.svm_port &&

net/vmw_vsock/af_vsock.c

415

struct sockaddr_vm *dst,

net/vmw_vsock/af_vsock.c

421

sk = __vsock_find_connected_socket_net(src, dst, net);

net/vmw_vsock/af_vsock.c

437

struct sockaddr_vm *dst)

net/vmw_vsock/af_vsock.c

439

return vsock_find_connected_socket_net(src, dst, NULL);

net/vmw_vsock/virtio_transport_common.c

143

void *dst,

net/vmw_vsock/virtio_transport_common.c

150

kvec.iov_base = dst;

net/vmw_vsock/virtio_transport_common.c

1612

struct sockaddr_vm src, dst;

net/vmw_vsock/virtio_transport_common.c

1619

vsock_addr_init(&dst, le64_to_cpu(hdr->dst_cid),

net/vmw_vsock/virtio_transport_common.c

1623

dst.svm_cid, dst.svm_port,

net/vmw_vsock/virtio_transport_common.c

1639

sk = vsock_find_connected_socket_net(&src, &dst, net);

net/vmw_vsock/virtio_transport_common.c

1641

sk = vsock_find_bound_socket_net(&dst, net);

net/vmw_vsock/virtio_transport_common.c

1678

vsk->local_addr.svm_cid = dst.svm_cid;

net/vmw_vsock/vmci_transport.c

1024

vsock_addr_init(&vpending->local_addr, pkt->dg.dst.context,

net/vmw_vsock/vmci_transport.c

114

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

129

pkt->dg.dst = vmci_make_handle(dst->svm_cid,

net/vmw_vsock/vmci_transport.c

130

vmci_transport_peer_rid(dst->svm_cid));

net/vmw_vsock/vmci_transport.c

135

pkt->dst_port = dst->svm_port;

net/vmw_vsock/vmci_transport.c

1418

vsk->local_addr.svm_cid = pkt->dg.dst.context;

net/vmw_vsock/vmci_transport.c

1728

dg->dst = vmci_make_handle(remote_addr->svm_cid,

net/vmw_vsock/vmci_transport.c

180

vsock_addr_init(local, pkt->dg.dst.context, pkt->dst_port);

net/vmw_vsock/vmci_transport.c

187

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

198

vmci_transport_packet_init(pkt, src, dst, type, size, mode, wait,

net/vmw_vsock/vmci_transport.c

216

struct sockaddr_vm src, dst;

net/vmw_vsock/vmci_transport.c

221

vmci_transport_packet_get_addresses(pkt, &src, &dst);

net/vmw_vsock/vmci_transport.c

222

return __vmci_transport_send_control_pkt(&reply, &src, &dst,

net/vmw_vsock/vmci_transport.c

232

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

246

return __vmci_transport_send_control_pkt(&pkt, src, dst, type,

net/vmw_vsock/vmci_transport.c

254

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

269

err = __vmci_transport_send_control_pkt(pkt, src, dst, type, size,

net/vmw_vsock/vmci_transport.c

302

static int vmci_transport_send_reset_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

309

dst, src,

net/vmw_vsock/vmci_transport.c

318

struct sockaddr_vm dst;

net/vmw_vsock/vmci_transport.c

332

vsock_addr_init(&dst, pkt->dg.src.context,

net/vmw_vsock/vmci_transport.c

334

dst_ptr = &dst;

net/vmw_vsock/vmci_transport.c

389

static int vmci_transport_send_invalid_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

393

dst, src,

net/vmw_vsock/vmci_transport.c

398

int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

402

dst, src,

net/vmw_vsock/vmci_transport.c

407

int vmci_transport_send_read_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.c

411

dst, src,

net/vmw_vsock/vmci_transport.c

678

struct sockaddr_vm dst;

net/vmw_vsock/vmci_transport.c

706

vsock_addr_init(&dst, pkt->dg.dst.context, pkt->dst_port);

net/vmw_vsock/vmci_transport.c

708

sk = vsock_find_connected_socket(&src, &dst);

net/vmw_vsock/vmci_transport.c

710

sk = vsock_find_bound_socket(&dst);

net/vmw_vsock/vmci_transport.c

721

if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)

net/vmw_vsock/vmci_transport.c

734

vmci_transport_send_invalid_bh(&dst, &src);

net/vmw_vsock/vmci_transport.c

769

vsk->local_addr.svm_cid = dst.svm_cid;

net/vmw_vsock/vmci_transport.c

773

sk, pkt, true, &dst, &src,

net/vmw_vsock/vmci_transport.c

784

if (vmci_transport_send_reset_bh(&dst, &src, pkt) < 0)

net/vmw_vsock/vmci_transport.c

913

vsock_sk(sk)->local_addr.svm_cid = pkt->dg.dst.context;

net/vmw_vsock/vmci_transport.c

970

vsock_sk(pending)->local_addr.svm_cid = pkt->dg.dst.context;

net/vmw_vsock/vmci_transport.h

119

int vmci_transport_send_wrote_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport.h

121

int vmci_transport_send_read_bh(struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify.c

108

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify.c

124

sent = vmci_transport_send_wrote_bh(dst, src) > 0;

net/vmw_vsock/vmci_transport_notify.c

138

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify.c

154

sent = vmci_transport_send_read_bh(dst, src) > 0;

net/vmw_vsock/vmci_transport_notify.c

168

struct sockaddr_vm *dst, struct sockaddr_vm *src)

net/vmw_vsock/vmci_transport_notify.c

304

struct sockaddr_vm *dst, struct sockaddr_vm *src)

net/vmw_vsock/vmci_transport_notify.c

602

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify.c

609

vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);

net/vmw_vsock/vmci_transport_notify.c

613

vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);

net/vmw_vsock/vmci_transport_notify.c

618

dst, src);

net/vmw_vsock/vmci_transport_notify.c

624

dst, src);

net/vmw_vsock/vmci_transport_notify.h

47

bool bottom_half, struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify_qstate.c

346

struct sockaddr_vm *dst,

net/vmw_vsock/vmci_transport_notify_qstate.c

353

vmci_transport_handle_wrote(sk, pkt, bottom_half, dst, src);

net/vmw_vsock/vmci_transport_notify_qstate.c

357

vmci_transport_handle_read(sk, pkt, bottom_half, dst, src);

net/vmw_vsock/vmci_transport_notify_qstate.c

76

struct sockaddr_vm *dst, struct sockaddr_vm *src)

net/vmw_vsock/vmci_transport_notify_qstate.c

85

struct sockaddr_vm *dst, struct sockaddr_vm *src)

net/wireless/nl80211.c

14592

nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||

net/wireless/nl80211.c

14872

cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);

net/wireless/nl80211.c

8980

u8 *dst, u8 *next_hop,

net/wireless/nl80211.c

8991

nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||

net/wireless/nl80211.c

9044

u8 dst[ETH_ALEN];

net/wireless/nl80211.c

9066

err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,

net/wireless/nl80211.c

9075

wdev->netdev, dst, next_hop,

net/wireless/nl80211.c

9097

u8 *dst = NULL;

net/wireless/nl80211.c

9105

dst = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

9113

err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);

net/wireless/nl80211.c

9122

dev, dst, next_hop, &pinfo) < 0) {

net/wireless/nl80211.c

9134

u8 *dst = NULL;

net/wireless/nl80211.c

9143

dst = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

9152

return rdev_change_mpath(rdev, dev, dst, next_hop);

net/wireless/nl80211.c

9159

u8 *dst = NULL;

net/wireless/nl80211.c

9168

dst = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

9177

return rdev_add_mpath(rdev, dev, dst, next_hop);

net/wireless/nl80211.c

9184

u8 *dst = NULL;

net/wireless/nl80211.c

9187

dst = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

9195

return rdev_del_mpath(rdev, dev, dst);

net/wireless/nl80211.c

9205

u8 *dst = NULL;

net/wireless/nl80211.c

9213

dst = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

9221

err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);

net/wireless/nl80211.c

9230

dev, dst, mpp, &pinfo) < 0) {

net/wireless/nl80211.c

9244

u8 dst[ETH_ALEN];

net/wireless/nl80211.c

9266

err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,

net/wireless/nl80211.c

9275

wdev->netdev, dst, mpp,

net/wireless/rdev-ops.h

251

struct net_device *dev, u8 *dst, u8 *next_hop)

net/wireless/rdev-ops.h

254

trace_rdev_add_mpath(&rdev->wiphy, dev, dst, next_hop);

net/wireless/rdev-ops.h

255

ret = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);

net/wireless/rdev-ops.h

261

struct net_device *dev, u8 *dst)

net/wireless/rdev-ops.h

264

trace_rdev_del_mpath(&rdev->wiphy, dev, dst);

net/wireless/rdev-ops.h

265

ret = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);

net/wireless/rdev-ops.h

271

struct net_device *dev, u8 *dst,

net/wireless/rdev-ops.h

275

trace_rdev_change_mpath(&rdev->wiphy, dev, dst, next_hop);

net/wireless/rdev-ops.h

276

ret = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);

net/wireless/rdev-ops.h

282

struct net_device *dev, u8 *dst, u8 *next_hop,

net/wireless/rdev-ops.h

286

trace_rdev_get_mpath(&rdev->wiphy, dev, dst, next_hop);

net/wireless/rdev-ops.h

287

ret = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, pinfo);

net/wireless/rdev-ops.h

294

struct net_device *dev, u8 *dst, u8 *mpp,

net/wireless/rdev-ops.h

299

trace_rdev_get_mpp(&rdev->wiphy, dev, dst, mpp);

net/wireless/rdev-ops.h

300

ret = rdev->ops->get_mpp(&rdev->wiphy, dev, dst, mpp, pinfo);

net/wireless/rdev-ops.h

306

struct net_device *dev, int idx, u8 *dst,

net/wireless/rdev-ops.h

311

trace_rdev_dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop);

net/wireless/rdev-ops.h

312

ret = rdev->ops->dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop,

net/wireless/rdev-ops.h

319

struct net_device *dev, int idx, u8 *dst,

net/wireless/rdev-ops.h

325

trace_rdev_dump_mpp(&rdev->wiphy, dev, idx, dst, mpp);

net/wireless/rdev-ops.h

326

ret = rdev->ops->dump_mpp(&rdev->wiphy, dev, idx, dst, mpp, pinfo);

net/wireless/trace.h

1061

TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,

net/wireless/trace.h

1063

TP_ARGS(wiphy, netdev, dst, next_hop),

net/wireless/trace.h

1067

MAC_ENTRY(dst)

net/wireless/trace.h

1073

MAC_ASSIGN(dst, dst);

net/wireless/trace.h

1077

WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst,

net/wireless/trace.h

1082

TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,

net/wireless/trace.h

1084

TP_ARGS(wiphy, netdev, dst, next_hop)

net/wireless/trace.h

1088

TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,

net/wireless/trace.h

1090

TP_ARGS(wiphy, netdev, dst, next_hop)

net/wireless/trace.h

1094

TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,

net/wireless/trace.h

1096

TP_ARGS(wiphy, netdev, dst, next_hop)

net/wireless/trace.h

1101

u8 *dst, u8 *next_hop),

net/wireless/trace.h

1102

TP_ARGS(wiphy, netdev, _idx, dst, next_hop),

net/wireless/trace.h

1106

MAC_ENTRY(dst)

net/wireless/trace.h

1113

MAC_ASSIGN(dst, dst);

net/wireless/trace.h

1118

WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,

net/wireless/trace.h

1124

u8 *dst, u8 *mpp),

net/wireless/trace.h

1125

TP_ARGS(wiphy, netdev, dst, mpp),

net/wireless/trace.h

1129

MAC_ENTRY(dst)

net/wireless/trace.h

1135

MAC_ASSIGN(dst, dst);

net/wireless/trace.h

1140

__entry->dst, __entry->mpp)

net/wireless/trace.h

1145

u8 *dst, u8 *mpp),

net/wireless/trace.h

1146

TP_ARGS(wiphy, netdev, _idx, dst, mpp),

net/wireless/trace.h

1150

MAC_ENTRY(dst)

net/wireless/trace.h

1157

MAC_ASSIGN(dst, dst);

net/wireless/trace.h

1162

WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,

net/xfrm/xfrm_compat.c

232

static int xfrm_nla_cpy(struct sk_buff *dst, const struct nlattr *src, int len)

net/xfrm/xfrm_compat.c

234

return nla_put(dst, src->nla_type, len, nla_data(src));

net/xfrm/xfrm_compat.c

237

static int xfrm_xlate64_attr(struct sk_buff *dst, const struct nlattr *src)

net/xfrm/xfrm_compat.c

249

return xfrm_nla_cpy(dst, src, nla_len(src));

net/xfrm/xfrm_compat.c

251

return xfrm_nla_cpy(dst, src, XMSGSIZE(compat_xfrm_usersa_info));

net/xfrm/xfrm_compat.c

253

return xfrm_nla_cpy(dst, src, XMSGSIZE(compat_xfrm_userpolicy_info));

net/xfrm/xfrm_compat.c

255

return xfrm_nla_cpy(dst, src, nla_len(src));

net/xfrm/xfrm_compat.c

257

return nla_put_64bit(dst, src->nla_type, nla_len(src),

net/xfrm/xfrm_compat.c

264

return xfrm_nla_cpy(dst, src, nla_len(src));

net/xfrm/xfrm_compat.c

266

return nla_put_64bit(dst, src->nla_type, nla_len(src),

net/xfrm/xfrm_compat.c

293

return xfrm_nla_cpy(dst, src, nla_len(src));

net/xfrm/xfrm_compat.c

302

static int xfrm_xlate64(struct sk_buff *dst, const struct nlmsghdr *nlh_src)

net/xfrm/xfrm_compat.c

309

nlh_dst = xfrm_nlmsg_put_compat(dst, nlh_src, type);

net/xfrm/xfrm_compat.c

321

err = xfrm_nla_cpy(dst, nla, nla_len(nla));

net/xfrm/xfrm_compat.c

324

err = xfrm_xlate64_attr(dst, nla);

net/xfrm/xfrm_compat.c

331

nlmsg_end(dst, nlh_dst);

net/xfrm/xfrm_compat.c

412

static int xfrm_attr_cpy32(void *dst, size_t *pos, const struct nlattr *src,

net/xfrm/xfrm_compat.c

415

struct nlmsghdr *nlmsg = dst;

net/xfrm/xfrm_compat.c

428

nla = dst + *pos;

net/xfrm/xfrm_compat.c

435

memset(dst + *pos, 0, payload - copy_len);

net/xfrm/xfrm_compat.c

441

static int xfrm_xlate32_attr(void *dst, const struct nlattr *nla,

net/xfrm/xfrm_compat.c

469

err = xfrm_attr_cpy32(dst, pos, nla, size, pol_len32, pol_len64);

net/xfrm/xfrm_compat.c

474

return xfrm_attr_cpy32(dst, pos, nla, size, nla_len(nla), nla_len(nla));

net/xfrm/xfrm_compat.c

477

static int xfrm_xlate32(struct nlmsghdr *dst, const struct nlmsghdr *src,

net/xfrm/xfrm_compat.c

485

memcpy(dst, src, NLMSG_HDRLEN);

net/xfrm/xfrm_compat.c

486

dst->nlmsg_len = NLMSG_HDRLEN + xfrm_msg_min[type];

net/xfrm/xfrm_compat.c

487

memset(nlmsg_data(dst), 0, xfrm_msg_min[type]);

net/xfrm/xfrm_compat.c

506

memcpy(nlmsg_data(dst), nlmsg_data(src), compat_msg_min[type]);

net/xfrm/xfrm_compat.c

513

memcpy(nlmsg_data(dst), nlmsg_data(src), compat_msg_min[type]);

net/xfrm/xfrm_compat.c

517

struct xfrm_user_expire *dst_ue = nlmsg_data(dst);

net/xfrm/xfrm_compat.c

526

struct xfrm_user_acquire *dst_ua = nlmsg_data(dst);

net/xfrm/xfrm_compat.c

537

struct xfrm_user_polexpire *dst_upe = nlmsg_data(dst);

net/xfrm/xfrm_compat.c

546

struct xfrm_userspi_info *dst_usi = nlmsg_data(dst);

net/xfrm/xfrm_compat.c

558

pos = dst->nlmsg_len;

net/xfrm/xfrm_compat.c

571

err = xfrm_attr_cpy32(dst, &pos, attrs[i], size,

net/xfrm/xfrm_compat.c

588

err = xfrm_xlate32_attr(dst, attrs[i], &pos, size, extack);

net/xfrm/xfrm_device.c

236

struct dst_entry *dst;

net/xfrm/xfrm_device.c

285

dst = __xfrm_dst_lookup(x->props.family, &params);

net/xfrm/xfrm_device.c

286

if (IS_ERR(dst))

net/xfrm/xfrm_device.c

289

dev = dst->dev;

net/xfrm/xfrm_device.c

292

dst_release(dst);

net/xfrm/xfrm_device.c

414

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_device.c

415

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/xfrm/xfrm_device.c

423

if ((!dev || dev == xfrm_dst_path(dst)->dev) &&

net/xfrm/xfrm_interface_core.c

427

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_interface_core.c

444

struct dst_entry *tmp_dst = dst;

net/xfrm/xfrm_interface_core.c

446

dst = md_info->dst_orig;

net/xfrm/xfrm_interface_core.c

447

skb_dst_set(skb, dst);

net/xfrm/xfrm_interface_core.c

455

dst_hold(dst);

net/xfrm/xfrm_interface_core.c

456

dst = xfrm_lookup_with_ifid(xi->net, dst, fl, NULL, 0, if_id);

net/xfrm/xfrm_interface_core.c

457

if (IS_ERR(dst)) {

net/xfrm/xfrm_interface_core.c

458

err = PTR_ERR(dst);

net/xfrm/xfrm_interface_core.c

459

dst = NULL;

net/xfrm/xfrm_interface_core.c

463

x = dst->xfrm;

net/xfrm/xfrm_interface_core.c

470

tdev = dst->dev;

net/xfrm/xfrm_interface_core.c

479

mtu = dst_mtu(dst);

net/xfrm/xfrm_interface_core.c

499

dst_release(dst);

net/xfrm/xfrm_interface_core.c

505

skb_dst_set(skb, dst);

net/xfrm/xfrm_interface_core.c

521

dst_release(dst);

net/xfrm/xfrm_interface_core.c

528

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_interface_core.c

538

if (!dst) {

net/xfrm/xfrm_interface_core.c

541

dst = ip6_route_output(dev_net(dev), NULL, &fl.u.ip6);

net/xfrm/xfrm_interface_core.c

542

if (dst->error) {

net/xfrm/xfrm_interface_core.c

543

dst_release(dst);

net/xfrm/xfrm_interface_core.c

547

skb_dst_set(skb, dst);

net/xfrm/xfrm_interface_core.c

553

if (!dst) {

net/xfrm/xfrm_interface_core.c

563

skb_dst_set(skb, &rt->dst);

net/xfrm/xfrm_iptfs.c

1832

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_iptfs.c

1833

struct xfrm_state *x = dst->xfrm;

net/xfrm/xfrm_iptfs.c

2369

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_iptfs.c

2391

top_iph->ttl = ip4_dst_hoplimit(xfrm_dst_child(dst));

net/xfrm/xfrm_iptfs.c

2394

ip_select_ident(dev_net(dst->dev), skb, NULL);

net/xfrm/xfrm_iptfs.c

2415

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_iptfs.c

2439

top_iph->hop_limit = ip6_dst_hoplimit(xfrm_dst_child(dst));

net/xfrm/xfrm_iptfs.c

267

struct dst_entry *dst = skb_dst(tpl);

net/xfrm/xfrm_iptfs.c

269

resv = LL_RESERVED_SPACE(dst->dev) + dst->header_len;

net/xfrm/xfrm_nat_keepalive.c

101

dst = ipv6_stub->ipv6_dst_lookup_flow(net, sk, &fl6, NULL);

net/xfrm/xfrm_nat_keepalive.c

102

if (IS_ERR(dst)) {

net/xfrm/xfrm_nat_keepalive.c

104

return PTR_ERR(dst);

net/xfrm/xfrm_nat_keepalive.c

107

skb_dst_set(skb, dst);

net/xfrm/xfrm_nat_keepalive.c

61

skb_dst_set(skb, &rt->dst);

net/xfrm/xfrm_nat_keepalive.c

78

struct dst_entry *dst;

net/xfrm/xfrm_output.c

276

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

309

top_iph->ttl = ip4_dst_hoplimit(xfrm_dst_child(dst));

net/xfrm/xfrm_output.c

313

ip_select_ident(dev_net(dst->dev), skb, NULL);

net/xfrm/xfrm_output.c

321

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

33

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

34

int nhead = dst->header_len + LL_RESERVED_SPACE(dst->dev)

net/xfrm/xfrm_output.c

348

top_iph->hop_limit = ip6_dst_hoplimit(xfrm_dst_child(dst));

net/xfrm/xfrm_output.c

36

int ntail = dst->dev->needed_tailroom - skb_tailroom(skb);

net/xfrm/xfrm_output.c

494

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

495

struct xfrm_state *x = dst->xfrm;

net/xfrm/xfrm_output.c

566

dst = skb_dst_pop(skb);

net/xfrm/xfrm_output.c

567

if (!dst) {

net/xfrm/xfrm_output.c

572

skb_dst_set(skb, dst);

net/xfrm/xfrm_output.c

573

x = dst->xfrm;

net/xfrm/xfrm_output.c

618

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

622

dst = skb_dst_pop(skb);

net/xfrm/xfrm_output.c

623

if (!dst) {

net/xfrm/xfrm_output.c

628

skb_dst_set(skb, dst);

net/xfrm/xfrm_output.c

886

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_output.c

892

mtu = dst_mtu(dst);

net/xfrm/xfrm_output.c

899

skb->dev = dst->dev;

net/xfrm/xfrm_policy.c

186

static int stale_bundle(struct dst_entry *dst);

net/xfrm/xfrm_policy.c

2626

memset_after(xdst, 0, u.dst);

net/xfrm/xfrm_policy.c

2635

static void xfrm_init_path(struct xfrm_dst *path, struct dst_entry *dst,

net/xfrm/xfrm_policy.c

2638

if (dst->ops->family == AF_INET6) {

net/xfrm/xfrm_policy.c

2639

path->path_cookie = rt6_get_cookie(dst_rt6_info(dst));

net/xfrm/xfrm_policy.c

2648

xfrm_policy_get_afinfo(xdst->u.dst.ops->family);

net/xfrm/xfrm_policy.c

2671

struct dst_entry *dst)

net/xfrm/xfrm_policy.c

2693

dst_hold(dst);

net/xfrm/xfrm_policy.c

2697

struct dst_entry *dst1 = &xdst->u.dst;

net/xfrm/xfrm_policy.c

2701

dst_release(dst);

net/xfrm/xfrm_policy.c

2712

xfrm_dst_set_child(xdst_prev, &xdst->u.dst);

net/xfrm/xfrm_policy.c

2719

dst_release(dst);

net/xfrm/xfrm_policy.c

2725

xdst->route = dst;

net/xfrm/xfrm_policy.c

2726

dst_copy_metrics(dst1, dst);

net/xfrm/xfrm_policy.c

2739

dst = xfrm_dst_lookup(xfrm[i], dscp, oif, &saddr,

net/xfrm/xfrm_policy.c

2741

err = PTR_ERR(dst);

net/xfrm/xfrm_policy.c

2742

if (IS_ERR(dst))

net/xfrm/xfrm_policy.c

2745

dst_hold(dst);

net/xfrm/xfrm_policy.c

277

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

2775

xfrm_dst_set_child(xdst_prev, dst);

net/xfrm/xfrm_policy.c

2776

xdst0->path = dst;

net/xfrm/xfrm_policy.c

2779

dev = dst->dev;

net/xfrm/xfrm_policy.c

2783

xfrm_init_path(xdst0, dst, nfheader_len);

net/xfrm/xfrm_policy.c

2786

for (xdst_prev = xdst0; xdst_prev != (struct xfrm_dst *)dst;

net/xfrm/xfrm_policy.c

2787

xdst_prev = (struct xfrm_dst *) xfrm_dst_child(&xdst_prev->u.dst)) {

net/xfrm/xfrm_policy.c

2792

xdst_prev->u.dst.header_len = header_len;

net/xfrm/xfrm_policy.c

2793

xdst_prev->u.dst.trailer_len = trailer_len;

net/xfrm/xfrm_policy.c

2794

header_len -= xdst_prev->u.dst.xfrm->props.header_len;

net/xfrm/xfrm_policy.c

2795

trailer_len -= xdst_prev->u.dst.xfrm->props.trailer_len;

net/xfrm/xfrm_policy.c

2798

return &xdst0->u.dst;

net/xfrm/xfrm_policy.c

2805

dst_release_immediate(&xdst0->u.dst);

net/xfrm/xfrm_policy.c

283

dst = afinfo->dst_lookup(params);

net/xfrm/xfrm_policy.c

2867

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

287

return dst;

net/xfrm/xfrm_policy.c

2881

dst = xfrm_bundle_create(pols[0], xfrm, bundle, err, fl, dst_orig);

net/xfrm/xfrm_policy.c

2882

if (IS_ERR(dst)) {

net/xfrm/xfrm_policy.c

2884

return ERR_CAST(dst);

net/xfrm/xfrm_policy.c

2887

xdst = (struct xfrm_dst *)dst;

net/xfrm/xfrm_policy.c

2900

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

2914

dst = skb_dst(skb);

net/xfrm/xfrm_policy.c

2920

xfrm_decode_session(net, skb, &fl, dst->ops->family);

net/xfrm/xfrm_policy.c

2924

dst_hold(xfrm_dst_path(dst));

net/xfrm/xfrm_policy.c

2925

dst = xfrm_lookup(net, xfrm_dst_path(dst), &fl, sk, XFRM_LOOKUP_QUEUE);

net/xfrm/xfrm_policy.c

2926

if (IS_ERR(dst))

net/xfrm/xfrm_policy.c

2929

if (dst->flags & DST_XFRM_QUEUE) {

net/xfrm/xfrm_policy.c

2930

dst_release(dst);

net/xfrm/xfrm_policy.c

2941

dst_release(dst);

net/xfrm/xfrm_policy.c

2960

dst = xfrm_lookup(net, xfrm_dst_path(skb_dst(skb)), &fl, skb->sk, 0);

net/xfrm/xfrm_policy.c

2961

if (IS_ERR(dst)) {

net/xfrm/xfrm_policy.c

2968

skb_dst_set(skb, dst);

net/xfrm/xfrm_policy.c

2986

struct dst_entry *dst = skb_dst(skb);

net/xfrm/xfrm_policy.c

2987

struct xfrm_dst *xdst = (struct xfrm_dst *) dst;

net/xfrm/xfrm_policy.c

301

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

3033

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

3046

dst = xflo->dst_orig;

net/xfrm/xfrm_policy.c

3047

dst1 = &xdst->u.dst;

net/xfrm/xfrm_policy.c

3048

dst_hold(dst);

net/xfrm/xfrm_policy.c

3049

xdst->route = dst;

net/xfrm/xfrm_policy.c

3051

dst_copy_metrics(dst1, dst);

net/xfrm/xfrm_policy.c

3060

dst_hold(dst);

net/xfrm/xfrm_policy.c

3061

xfrm_dst_set_child(xdst, dst);

net/xfrm/xfrm_policy.c

3062

xdst->path = dst;

net/xfrm/xfrm_policy.c

3064

xfrm_init_path((struct xfrm_dst *)dst1, dst, 0);

net/xfrm/xfrm_policy.c

3067

dev = dst->dev;

net/xfrm/xfrm_policy.c

3180

struct dst_entry *dst, *route;

net/xfrm/xfrm_policy.c

3185

dst = NULL;

net/xfrm/xfrm_policy.c

3251

dst = &xdst->u.dst;

net/xfrm/xfrm_policy.c

3294

dst_release(dst);

net/xfrm/xfrm_policy.c

3295

dst = dst_orig;

net/xfrm/xfrm_policy.c

3300

if (dst->xfrm &&

net/xfrm/xfrm_policy.c

3301

(dst->xfrm->props.mode == XFRM_MODE_TUNNEL ||

net/xfrm/xfrm_policy.c

3302

dst->xfrm->props.mode == XFRM_MODE_IPTFS))

net/xfrm/xfrm_policy.c

3303

dst->flags |= DST_XFRM_TUNNEL;

net/xfrm/xfrm_policy.c

3304

return dst;

net/xfrm/xfrm_policy.c

3313

dst = dst_orig;

net/xfrm/xfrm_policy.c

3318

dst_release(dst);

net/xfrm/xfrm_policy.c

334

dst = __xfrm_dst_lookup(family, &params);

net/xfrm/xfrm_policy.c

3347

struct dst_entry *dst = xfrm_lookup(net, dst_orig, fl, sk,

net/xfrm/xfrm_policy.c

3351

if (PTR_ERR(dst) == -EREMOTE)

net/xfrm/xfrm_policy.c

3354

if (IS_ERR(dst))

net/xfrm/xfrm_policy.c

3357

return dst;

net/xfrm/xfrm_policy.c

336

if (!IS_ERR(dst)) {

net/xfrm/xfrm_policy.c

343

return dst;

net/xfrm/xfrm_policy.c

3443

fl4->saddr = flkeys->addrs.ipv4.dst;

net/xfrm/xfrm_policy.c

3445

fl4->fl4_sport = flkeys->ports.dst;

net/xfrm/xfrm_policy.c

3449

fl4->daddr = flkeys->addrs.ipv4.dst;

net/xfrm/xfrm_policy.c

3451

fl4->fl4_dport = flkeys->ports.dst;

net/xfrm/xfrm_policy.c

3477

fl6->saddr = flkeys->addrs.ipv6.dst;

net/xfrm/xfrm_policy.c

3479

fl6->fl6_sport = flkeys->ports.dst;

net/xfrm/xfrm_policy.c

3483

fl6->daddr = flkeys->addrs.ipv6.dst;

net/xfrm/xfrm_policy.c

3485

fl6->fl6_dport = flkeys->ports.dst;

net/xfrm/xfrm_policy.c

3648

unsigned short family, struct dst_entry *dst)

net/xfrm/xfrm_policy.c

3656

return dst;

net/xfrm/xfrm_policy.c

3658

dst_hold(dst);

net/xfrm/xfrm_policy.c

3660

dst2 = xfrm_lookup(net, dst, &fl1, NULL, (XFRM_LOOKUP_QUEUE | XFRM_LOOKUP_ICMP));

net/xfrm/xfrm_policy.c

3663

return dst;

net/xfrm/xfrm_policy.c

3666

dst_release(dst);

net/xfrm/xfrm_policy.c

3667

dst = dst2;

net/xfrm/xfrm_policy.c

3673

return dst;

net/xfrm/xfrm_policy.c

3882

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

3891

dst = skb_dst(skb);

net/xfrm/xfrm_policy.c

3892

if (!dst) {

net/xfrm/xfrm_policy.c

3902

dst = xfrm_lookup(net, dst, &fl, NULL, XFRM_LOOKUP_QUEUE);

net/xfrm/xfrm_policy.c

3903

if (IS_ERR(dst)) {

net/xfrm/xfrm_policy.c

3905

dst = NULL;

net/xfrm/xfrm_policy.c

3908

if (dst && !dst->xfrm)

net/xfrm/xfrm_policy.c

3909

dst = xfrm_out_fwd_icmp(skb, &fl, family, dst);

net/xfrm/xfrm_policy.c

3911

skb_dst_set(skb, dst);

net/xfrm/xfrm_policy.c

3918

static struct dst_entry *xfrm_dst_check(struct dst_entry *dst, u32 cookie)

net/xfrm/xfrm_policy.c

3941

if (READ_ONCE(dst->obsolete) < 0 && !stale_bundle(dst))

net/xfrm/xfrm_policy.c

3942

return dst;

net/xfrm/xfrm_policy.c

3947

static int stale_bundle(struct dst_entry *dst)

net/xfrm/xfrm_policy.c

3949

return !xfrm_bundle_ok((struct xfrm_dst *)dst);

net/xfrm/xfrm_policy.c

3952

void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev)

net/xfrm/xfrm_policy.c

3954

while ((dst = xfrm_dst_child(dst)) && dst->xfrm && dst->dev == dev) {

net/xfrm/xfrm_policy.c

3955

dst->dev = blackhole_netdev;

net/xfrm/xfrm_policy.c

3956

dev_hold(dst->dev);

net/xfrm/xfrm_policy.c

3967

static void xfrm_negative_advice(struct sock *sk, struct dst_entry *dst)

net/xfrm/xfrm_policy.c

3969

if (READ_ONCE(dst->obsolete))

net/xfrm/xfrm_policy.c

3978

struct dst_entry *dst;

net/xfrm/xfrm_policy.c

3980

dst = &xdst->u.dst;

net/xfrm/xfrm_policy.c

3981

pmtu = dst_mtu(xfrm_dst_child(dst));

net/xfrm/xfrm_policy.c

3984

pmtu = xfrm_state_mtu(dst->xfrm, pmtu);

net/xfrm/xfrm_policy.c

3992

dst_metric_set(dst, RTAX_MTU, pmtu);

net/xfrm/xfrm_policy.c

4003

struct dst_entry *dst = &first->u.dst;

net/xfrm/xfrm_policy.c

4008

if (!dst_check(xfrm_dst_path(dst), ((struct xfrm_dst *)dst)->path_cookie) ||

net/xfrm/xfrm_policy.c

4009

(dst->dev && !netif_running(dst->dev)))

net/xfrm/xfrm_policy.c

4012

if (dst->flags & DST_XFRM_QUEUE)

net/xfrm/xfrm_policy.c

4017

struct xfrm_dst *xdst = (struct xfrm_dst *)dst;

net/xfrm/xfrm_policy.c

4019

if (dst->xfrm->km.state != XFRM_STATE_VALID)

net/xfrm/xfrm_policy.c

4021

if (xdst->xfrm_genid != dst->xfrm->genid)

net/xfrm/xfrm_policy.c

4029

mtu = dst_mtu(xfrm_dst_child(dst));

net/xfrm/xfrm_policy.c

4043

dst = xfrm_dst_child(dst);

net/xfrm/xfrm_policy.c

4044

} while (dst->xfrm);

net/xfrm/xfrm_policy.c

4052

dst = &xdst->u.dst;

net/xfrm/xfrm_policy.c

4054

mtu = xfrm_state_mtu(dst->xfrm, mtu);

net/xfrm/xfrm_policy.c

4057

dst_metric_set(dst, RTAX_MTU, mtu);

net/xfrm/xfrm_policy.c

4068

static unsigned int xfrm_default_advmss(const struct dst_entry *dst)

net/xfrm/xfrm_policy.c

4070

return dst_metric_advmss(xfrm_dst_path(dst));

net/xfrm/xfrm_policy.c

4073

static unsigned int xfrm_mtu(const struct dst_entry *dst)

net/xfrm/xfrm_policy.c

4075

unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

net/xfrm/xfrm_policy.c

4077

return mtu ? : dst_mtu(xfrm_dst_path(dst));

net/xfrm/xfrm_policy.c

4080

static const void *xfrm_get_dst_nexthop(const struct dst_entry *dst,

net/xfrm/xfrm_policy.c

4083

while (dst->xfrm) {

net/xfrm/xfrm_policy.c

4084

const struct xfrm_state *xfrm = dst->xfrm;

net/xfrm/xfrm_policy.c

4086

dst = xfrm_dst_child(dst);

net/xfrm/xfrm_policy.c

4098

static struct neighbour *xfrm_neigh_lookup(const struct dst_entry *dst,

net/xfrm/xfrm_policy.c

4102

const struct dst_entry *path = xfrm_dst_path(dst);

net/xfrm/xfrm_policy.c

4105

daddr = xfrm_get_dst_nexthop(dst, daddr);

net/xfrm/xfrm_policy.c

4109

static void xfrm_confirm_neigh(const struct dst_entry *dst, const void *daddr)

net/xfrm/xfrm_policy.c

4111

const struct dst_entry *path = xfrm_dst_path(dst);

net/xfrm/xfrm_policy.c

4113

daddr = xfrm_get_dst_nexthop(dst, daddr);

net/xfrm/xfrm_state.c

2376

__xfrm6_sort(void **dst, void **src, int n,

net/xfrm/xfrm_state.c

2394

dst[count[class[i] - 1]++] = src[i];

net/xfrm/xfrm_state.c

2461

__xfrm6_sort(void **dst, void **src, int n,

net/xfrm/xfrm_state.c

2467

dst[i] = src[i];

net/xfrm/xfrm_state.c

2472

xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,

net/xfrm/xfrm_state.c

2478

__xfrm6_sort((void **)dst, (void **)src, n,

net/xfrm/xfrm_state.c

2482

dst[i] = src[i];

net/xfrm/xfrm_state.c

2486

xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,

net/xfrm/xfrm_state.c

2492

__xfrm6_sort((void **)dst, (void **)src, n,

net/xfrm/xfrm_state.c

2496

dst[i] = src[i];

samples/bpf/sockex2_kern.c

20

__be32 dst;

samples/bpf/sockex2_kern.c

209

key = flow.dst;

samples/bpf/sockex2_kern.c

73

flow->dst = load_word(skb, nhoff + offsetof(struct iphdr, daddr));

samples/bpf/sockex2_kern.c

92

flow->dst = ipv6_addr_hash(skb,

samples/bpf/sockex3_kern.c

175

g->flow.dst = load_word(skb, nhoff + offsetof(struct iphdr, daddr));

samples/bpf/sockex3_kern.c

201

g->flow.dst = ipv6_addr_hash(skb,

samples/bpf/sockex3_kern.c

32

__be32 dst;

samples/bpf/sockex3_user.c

12

__be32 dst;

samples/bpf/sockex3_user.c

90

inet_ntoa((struct in_addr){htonl(next_key.dst)}),

samples/bpf/xdp_fwd_kern.c

81

struct in6_addr *dst = (struct in6_addr *) fib_params.ipv6_dst;

samples/bpf/xdp_fwd_kern.c

97

*dst = ip6h->daddr;

samples/bpf/xdp_router_ipv4.bpf.c

32

__be32 dst;

samples/bpf/xdp_router_ipv4_user.c

102

__be32 dst, gw;

samples/bpf/xdp_router_ipv4_user.c

107

__be32 dst;

samples/bpf/xdp_router_ipv4_user.c

148

route.dst = atoi(dsts);

samples/bpf/xdp_router_ipv4_user.c

173

direct_entry.arp.dst = 0;

samples/bpf/xdp_router_ipv4_user.c

177

&route.dst) == 0);

samples/bpf/xdp_router_ipv4_user.c

180

&route.dst,

samples/bpf/xdp_router_ipv4_user.c

182

direct_entry.arp.dst = route.dst;

samples/bpf/xdp_router_ipv4_user.c

184

&route.dst,

samples/bpf/xdp_router_ipv4_user.c

189

prefix_key->data[i] = (route.dst >> i * 8) & 0xff;

samples/bpf/xdp_router_ipv4_user.c

325

__be32 dst;

samples/bpf/xdp_router_ipv4_user.c

352

arp_entry.dst = atoi(dsts);

samples/bpf/xdp_router_ipv4_user.c

357

&arp_entry.dst,

samples/bpf/xdp_router_ipv4_user.c

360

direct_entry.arp.dst = 0;

samples/bpf/xdp_router_ipv4_user.c

363

direct_entry.arp.dst = arp_entry.dst;

samples/bpf/xdp_router_ipv4_user.c

367

&arp_entry.dst,

samples/bpf/xdp_router_ipv4_user.c

374

&arp_entry.dst) == 0);

samples/bpf/xdp_router_ipv4_user.c

377

&arp_entry.dst,

samples/bpf/xdp_sample.bpf.h

37

unsigned short dst[3];

samples/bpf/xdp_sample.bpf.h

39

dst[0] = p[0];

samples/bpf/xdp_sample.bpf.h

40

dst[1] = p[1];

samples/bpf/xdp_sample.bpf.h

41

dst[2] = p[2];

samples/bpf/xdp_sample.bpf.h

45

p[3] = dst[0];

samples/bpf/xdp_sample.bpf.h

46

p[4] = dst[1];

samples/bpf/xdp_sample.bpf.h

47

p[5] = dst[2];

samples/bpf/xdp_sample_user.h

52

static inline char *safe_strncpy(char *dst, const char *src, size_t size)

samples/bpf/xdp_sample_user.h

55

return dst;

samples/bpf/xdp_sample_user.h

56

strncpy(dst, src, size - 1);

samples/bpf/xdp_sample_user.h

57

dst[size - 1] = '\0';

samples/bpf/xdp_sample_user.h

58

return dst;

samples/rpmsg/rpmsg_client_sample.c

57

rpdev->src, rpdev->dst);

security/apparmor/apparmorfs.c

1407

static int decompress_zstd(char *src, size_t slen, char *dst, size_t dlen)

security/apparmor/apparmorfs.c

1426

out_len = zstd_decompress_dctx(ctx, dst, dlen, src, slen);

security/apparmor/apparmorfs.c

1438

memcpy(dst, src, slen);

security/apparmor/policy_unpack.c

1616

static int compress_zstd(const char *src, size_t slen, char **dst, size_t *dlen)

security/apparmor/policy_unpack.c

1653

*dst = kvzalloc(out_len, GFP_KERNEL);

security/apparmor/policy_unpack.c

1654

if (*dst) {

security/apparmor/policy_unpack.c

1655

memcpy(*dst, out, out_len);

security/apparmor/policy_unpack.c

1665

*dst = krealloc(out, out_len, GFP_KERNEL);

security/apparmor/policy_unpack.c

1668

if (!*dst) {

security/apparmor/policy_unpack.c

1678

*dst = NULL;

security/landlock/cred.h

70

static inline void landlock_cred_copy(struct landlock_cred_security *dst,

security/landlock/cred.h

73

landlock_put_ruleset(dst->domain);

security/landlock/cred.h

75

*dst = *src;

security/landlock/ruleset.c

318

static int merge_tree(struct landlock_ruleset *const dst,

security/landlock/ruleset.c

327

lockdep_assert_held(&dst->lock);

security/landlock/ruleset.c

338

.level = dst->num_layers,

security/landlock/ruleset.c

353

err = insert_rule(dst, id, &layers, ARRAY_SIZE(layers));

security/landlock/ruleset.c

360

static int merge_ruleset(struct landlock_ruleset *const dst,

security/landlock/ruleset.c

370

if (WARN_ON_ONCE(!dst || !dst->hierarchy))

security/landlock/ruleset.c

374

mutex_lock(&dst->lock);

security/landlock/ruleset.c

378

if (WARN_ON_ONCE(src->num_layers != 1 || dst->num_layers < 1)) {

security/landlock/ruleset.c

382

dst->access_masks[dst->num_layers - 1] =

security/landlock/ruleset.c

386

err = merge_tree(dst, src, LANDLOCK_KEY_INODE);

security/landlock/ruleset.c

392

err = merge_tree(dst, src, LANDLOCK_KEY_NET_PORT);

security/landlock/ruleset.c

399

mutex_unlock(&dst->lock);

security/landlock/syscalls.c

65

copy_min_struct_from_user(void *const dst, const size_t ksize,

security/landlock/syscalls.c

70

BUILD_BUG_ON(!dst);

security/landlock/syscalls.c

83

return copy_struct_from_user(dst, ksize, src, usize);

security/safesetid/lsm.c

34

kid_t src, kid_t dst)

security/safesetid/lsm.c

43

if (uid_eq(rule->dst_id.uid, dst.uid))

security/safesetid/lsm.c

51

if (gid_eq(rule->dst_id.gid, dst.gid)){

security/safesetid/lsm.c

67

static enum sid_policy_type setid_policy_lookup(kid_t src, kid_t dst, enum setid_type new_type)

security/safesetid/lsm.c

85

result = _setid_policy_lookup(pol, src, dst);

security/safesetid/lsm.h

68

kid_t src, kid_t dst);

security/selinux/ss/avtab.c

35

struct avtab_node **dst,

security/selinux/ss/avtab.c

58

newnode->next = *dst;

security/selinux/ss/avtab.c

59

*dst = newnode;

security/selinux/ss/conditional.c

250

struct avtab_node **dst;

security/selinux/ss/conditional.c

316

*data->dst = node_ptr;

security/selinux/ss/conditional.c

344

data.dst = &list->nodes[i];

security/selinux/ss/context.h

102

static inline int mls_context_glblub(struct context *dst,

security/selinux/ss/context.h

106

struct mls_range *dr = &dst->range;

security/selinux/ss/context.h

156

static inline int context_cpy(struct context *dst, const struct context *src)

security/selinux/ss/context.h

160

dst->user = src->user;

security/selinux/ss/context.h

161

dst->role = src->role;

security/selinux/ss/context.h

162

dst->type = src->type;

security/selinux/ss/context.h

164

dst->str = kstrdup(src->str, GFP_ATOMIC);

security/selinux/ss/context.h

165

if (!dst->str)

security/selinux/ss/context.h

167

dst->len = src->len;

security/selinux/ss/context.h

169

dst->str = NULL;

security/selinux/ss/context.h

170

dst->len = 0;

security/selinux/ss/context.h

172

rc = mls_context_cpy(dst, src);

security/selinux/ss/context.h

174

kfree(dst->str);

security/selinux/ss/context.h

175

dst->str = NULL;

security/selinux/ss/context.h

176

dst->len = 0;

security/selinux/ss/context.h

42

static inline int mls_context_cpy(struct context *dst,

security/selinux/ss/context.h

47

dst->range.level[0].sens = src->range.level[0].sens;

security/selinux/ss/context.h

48

rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);

security/selinux/ss/context.h

52

dst->range.level[1].sens = src->range.level[1].sens;

security/selinux/ss/context.h

53

rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[1].cat);

security/selinux/ss/context.h

55

ebitmap_destroy(&dst->range.level[0].cat);

security/selinux/ss/context.h

63

static inline int mls_context_cpy_low(struct context *dst,

security/selinux/ss/context.h

68

dst->range.level[0].sens = src->range.level[0].sens;

security/selinux/ss/context.h

69

rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[0].cat);

security/selinux/ss/context.h

73

dst->range.level[1].sens = src->range.level[0].sens;

security/selinux/ss/context.h

74

rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[0].cat);

security/selinux/ss/context.h

76

ebitmap_destroy(&dst->range.level[0].cat);

security/selinux/ss/context.h

84

static inline int mls_context_cpy_high(struct context *dst,

security/selinux/ss/context.h

89

dst->range.level[0].sens = src->range.level[1].sens;

security/selinux/ss/context.h

90

rc = ebitmap_cpy(&dst->range.level[0].cat, &src->range.level[1].cat);

security/selinux/ss/context.h

94

dst->range.level[1].sens = src->range.level[1].sens;

security/selinux/ss/context.h

95

rc = ebitmap_cpy(&dst->range.level[1].cat, &src->range.level[1].cat);

security/selinux/ss/context.h

97

ebitmap_destroy(&dst->range.level[0].cat);

security/selinux/ss/ebitmap.c

49

int ebitmap_cpy(struct ebitmap *dst, const struct ebitmap *src)

security/selinux/ss/ebitmap.c

54

ebitmap_init(dst);

security/selinux/ss/ebitmap.c

60

ebitmap_destroy(dst);

security/selinux/ss/ebitmap.c

69

dst->node = new;

security/selinux/ss/ebitmap.c

74

dst->highbit = src->highbit;

security/selinux/ss/ebitmap.c

78

int ebitmap_and(struct ebitmap *dst, const struct ebitmap *e1,

security/selinux/ss/ebitmap.c

85

ebitmap_init(dst);

security/selinux/ss/ebitmap.c

90

rc = ebitmap_set_bit(dst, bit, 1);

security/selinux/ss/ebitmap.h

124

int ebitmap_cpy(struct ebitmap *dst, const struct ebitmap *src);

security/selinux/ss/ebitmap.h

125

int ebitmap_and(struct ebitmap *dst, const struct ebitmap *e1,

security/selinux/ss/hashtab.c

52

int __hashtab_insert(struct hashtab *h, struct hashtab_node **dst, void *key,

security/selinux/ss/hashtab.c

62

newnode->next = *dst;

security/selinux/ss/hashtab.c

63

*dst = newnode;

security/selinux/ss/hashtab.h

51

int __hashtab_insert(struct hashtab *h, struct hashtab_node **dst, void *key,

security/selinux/ss/policydb.c

2006

struct filename_trans_datum **dst, *datum, *first = NULL;

security/selinux/ss/policydb.c

2037

dst = &first;

security/selinux/ss/policydb.c

2045

*dst = datum;

security/selinux/ss/policydb.c

2058

dst = &datum->next;

security/selinux/ss/sidtab.c

273

struct sidtab_entry *dst, *dst_convert;

security/selinux/ss/sidtab.c

306

dst = sidtab_do_lookup(s, count, 1);

security/selinux/ss/sidtab.c

307

if (!dst)

security/selinux/ss/sidtab.c

310

dst->sid = index_to_sid(count);

security/selinux/ss/sidtab.c

311

dst->hash = hash;

security/selinux/ss/sidtab.c

313

rc = context_cpy(&dst->context, context);

security/selinux/ss/sidtab.c

328

context_destroy(&dst->context);

security/selinux/ss/sidtab.c

336

context_destroy(&dst->context);

security/selinux/ss/sidtab.c

355

hash_add_rcu(s->context_to_sid, &dst->list, dst->hash);

security/selinux/xfrm.c

209

struct dst_entry *dst = skb_dst(skb);

security/selinux/xfrm.c

212

if (dst == NULL)

security/selinux/xfrm.c

214

x = dst->xfrm;

security/selinux/xfrm.c

435

struct dst_entry *dst;

security/selinux/xfrm.c

449

dst = skb_dst(skb);

security/selinux/xfrm.c

450

if (dst) {

security/selinux/xfrm.c

453

for (iter = dst; iter != NULL; iter = xfrm_dst_child(iter)) {

security/smack/smack_lsm.c

671

struct smack_mnt_opts *dst, *src = src_fc->security;

security/smack/smack_lsm.c

680

dst = fc->security;

security/smack/smack_lsm.c

681

dst->fsdefault = src->fsdefault;

security/smack/smack_lsm.c

682

dst->fsfloor = src->fsfloor;

security/smack/smack_lsm.c

683

dst->fshat = src->fshat;

security/smack/smack_lsm.c

684

dst->fsroot = src->fsroot;

security/smack/smack_lsm.c

685

dst->fstransmute = src->fstransmute;

sound/core/control.c

1461

char *dst = ue->elem_data +

sound/core/control.c

1468

change = memcmp(&ucontrol->value, dst, size) != 0;

sound/core/control.c

1470

memcpy(dst, &ucontrol->value, size);

sound/core/memory.c

103

size_t copy_from_iter_toio(void __iomem *dst, size_t count,

sound/core/memory.c

107

return copy_from_iter((void __force *)dst, count, src);

sound/core/memory.c

118

memcpy_toio(dst, buf, c);

sound/core/memory.c

120

dst += c;

sound/core/memory.c

24

int copy_to_user_fromio(void __user *dst, const volatile void __iomem *src, size_t count)

sound/core/memory.c

28

if (import_ubuf(ITER_DEST, dst, count, &iter))

sound/core/memory.c

47

struct iov_iter *dst)

sound/core/memory.c

50

return copy_to_iter((const void __force *)src, count, dst);

sound/core/memory.c

60

if (copy_to_iter(buf, c, dst) != c)

sound/core/memory.c

81

int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size_t count)

sound/core/memory.c

87

if (copy_from_iter_toio((void __iomem *)dst, count, &iter) != count)

sound/core/oss/linear.c

28

unsigned char *dst, unsigned char *src)

sound/core/oss/linear.c

37

memcpy(dst, p + data->dst_ofs, data->dst_bytes);

sound/core/oss/linear.c

50

char *dst;

sound/core/oss/linear.c

61

dst = dst_channels[channel].area.addr + dst_channels[channel].area.first / 8;

sound/core/oss/linear.c

66

do_convert(data, dst, src);

sound/core/oss/linear.c

68

dst += dst_step;

sound/core/oss/mulaw.c

143

unsigned char *dst, u16 sample)

sound/core/oss/mulaw.c

149

memset(dst, 0, data->native_bytes);

sound/core/oss/mulaw.c

150

memcpy(dst + data->native_ofs, (char *)&sample + data->copy_ofs,

sound/core/oss/mulaw.c

164

char *dst;

sound/core/oss/mulaw.c

175

dst = dst_channels[channel].area.addr + dst_channels[channel].area.first / 8;

sound/core/oss/mulaw.c

181

cvt_s16_to_native(data, dst, sample);

sound/core/oss/mulaw.c

183

dst += dst_step;

sound/core/oss/mulaw.c

210

char *dst;

sound/core/oss/mulaw.c

221

dst = dst_channels[channel].area.addr + dst_channels[channel].area.first / 8;

sound/core/oss/mulaw.c

227

*dst = linear2ulaw(sample);

sound/core/oss/mulaw.c

229

dst += dst_step;

sound/core/oss/pcm_plugin.c

661

unsigned char *dst;

sound/core/oss/pcm_plugin.c

667

dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8;

sound/core/oss/pcm_plugin.c

672

return snd_pcm_format_set_silence(format, dst, samples);

sound/core/oss/pcm_plugin.c

683

*dst &= 0xf0;

sound/core/oss/pcm_plugin.c

685

*dst &= 0x0f;

sound/core/oss/pcm_plugin.c

686

dst += dst_step;

sound/core/oss/pcm_plugin.c

689

dst++;

sound/core/oss/pcm_plugin.c

696

memcpy(dst, silence, width);

sound/core/oss/pcm_plugin.c

697

dst += dst_step;

sound/core/oss/pcm_plugin.c

708

char *src, *dst;

sound/core/oss/pcm_plugin.c

714

dst = dst_area->addr + (dst_area->first + dst_area->step * dst_offset) / 8;

sound/core/oss/pcm_plugin.c

723

memcpy(dst, src, bytes);

sound/core/oss/pcm_plugin.c

741

*dst = (*dst & 0xf0) | srcval;

sound/core/oss/pcm_plugin.c

743

*dst = (*dst & 0x0f) | (srcval << 4);

sound/core/oss/pcm_plugin.c

750

dst += dst_step;

sound/core/oss/pcm_plugin.c

753

dst++;

sound/core/oss/pcm_plugin.c

760

memcpy(dst, src, width);

sound/core/oss/pcm_plugin.c

762

dst += dst_step;

sound/core/oss/rate.c

116

signed short *src, *dst;

sound/core/oss/rate.c

136

dst = (signed short *)dst_channels[channel].area.addr +

sound/core/oss/rate.c

155

*dst = val;

sound/core/oss/rate.c

156

dst += dst_step;

sound/core/oss/rate.c

57

signed short *src, *dst;

sound/core/oss/rate.c

77

dst = (signed short *)dst_channels[channel].area.addr +

sound/core/oss/rate.c

97

*dst = val;

sound/core/oss/rate.c

98

dst += dst_step;

sound/core/oss/route.c

15

int dst = 0;

sound/core/oss/route.c

16

for (; dst < ndsts; ++dst) {

sound/core/oss/route.c

37

int nsrcs, ndsts, dst;

sound/core/oss/route.c

55

for (dst = 0; dst < ndsts; ++dst) {

sound/core/oss/route.c

62

for (dst = 0; dst < ndsts && dst < nsrcs; ++dst) {

sound/core/oss/route.c

67

if (dst < ndsts)

sound/core/oss/route.c

68

zero_areas(dvp, ndsts - dst, frames, format);

sound/core/pcm_lib.c

2526

unsigned int __user *dst;

sound/core/pcm_lib.c

2536

dst = tlv + 2;

sound/core/pcm_lib.c

2543

if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||

sound/core/pcm_lib.c

2544

put_user(chs_bytes, dst + 1))

sound/core/pcm_lib.c

2546

dst += 2;

sound/core/pcm_lib.c

2554

if (put_user(map->map[c], dst))

sound/core/pcm_lib.c

2556

dst++;

sound/core/pcm_misc.c

412

unsigned char *dst;

sound/core/pcm_misc.c

431

dst = data;

sound/core/pcm_misc.c

434

memcpy(dst, pat, width);

sound/core/pcm_misc.c

435

dst += width;

sound/core/pcm_misc.c

442

memcpy(dst, pat, 2);

sound/core/pcm_misc.c

443

dst += 2;

sound/core/pcm_misc.c

448

memcpy(dst, pat, 3);

sound/core/pcm_misc.c

449

dst += 3;

sound/core/pcm_misc.c

454

memcpy(dst, pat, 4);

sound/core/pcm_misc.c

455

dst += 4;

sound/core/pcm_misc.c

460

memcpy(dst, pat, 8);

sound/core/pcm_misc.c

461

dst += 8;

sound/core/ump.c

61

static void safe_copy_string(void *dst, size_t max_dst_size,

sound/core/ump.c

65

unsigned char *d = dst;

sound/core/ump.c

79

static void safe_append_string(void *dst, size_t max_dst_size,

sound/core/ump.c

82

unsigned char *d = dst;

sound/drivers/aloop.c

537

char *dst = runtime->dma_area;

sound/drivers/aloop.c

549

snd_pcm_format_set_silence(runtime->format, dst + dst_off,

sound/drivers/aloop.c

582

char *dst = capt->substream->runtime->dma_area;

sound/drivers/aloop.c

613

memcpy(dst + dst_off, src + src_off, size);

sound/firewire/amdtp-am824.c

188

u32 *dst;

sound/firewire/amdtp-am824.c

194

dst = (void *)runtime->dma_area +

sound/firewire/amdtp-am824.c

200

*dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8;

sound/firewire/amdtp-am824.c

201

dst++;

sound/firewire/amdtp-am824.c

205

dst = (void *)runtime->dma_area;

sound/firewire/amdtp-stream.c

516

struct seq_desc *dst = cache + cache_pos;

sound/firewire/amdtp-stream.c

519

dst->syt_offset = compute_syt_offset(src->syt, src->cycle, transfer_delay);

sound/firewire/amdtp-stream.c

521

dst->syt_offset = CIP_SYT_NO_INFO;

sound/firewire/amdtp-stream.c

522

dst->data_blocks = src->data_blocks;

sound/firewire/digi00x/amdtp-dot.c

186

u32 *dst;

sound/firewire/digi00x/amdtp-dot.c

192

dst = (void *)runtime->dma_area +

sound/firewire/digi00x/amdtp-dot.c

199

*dst = be32_to_cpu(buffer[c]) << 8;

sound/firewire/digi00x/amdtp-dot.c

200

dst++;

sound/firewire/digi00x/amdtp-dot.c

204

dst = (void *)runtime->dma_area;

sound/firewire/fireface/amdtp-ff.c

69

u32 *dst;

sound/firewire/fireface/amdtp-ff.c

75

dst = (void *)runtime->dma_area +

sound/firewire/fireface/amdtp-ff.c

81

*dst = le32_to_cpu(buffer[c]) & 0xffffff00;

sound/firewire/fireface/amdtp-ff.c

82

dst++;

sound/firewire/fireface/amdtp-ff.c

86

dst = (void *)runtime->dma_area;

sound/firewire/motu/amdtp-motu-trace.h

26

__field(int, dst)

sound/firewire/motu/amdtp-motu-trace.h

33

__entry->dst = fw_parent_device(s->unit)->card->node_id;

sound/firewire/motu/amdtp-motu-trace.h

36

__entry->dst = fw_parent_device(s->unit)->node_id;

sound/firewire/motu/amdtp-motu-trace.h

44

__entry->dst,

sound/firewire/motu/amdtp-motu-trace.h

55

__field(int, dst)

sound/firewire/motu/amdtp-motu-trace.h

62

__entry->dst = fw_parent_device(s->unit)->card->node_id;

sound/firewire/motu/amdtp-motu-trace.h

65

__entry->dst = fw_parent_device(s->unit)->node_id;

sound/firewire/motu/amdtp-motu-trace.h

73

__entry->dst,

sound/firewire/motu/amdtp-motu.c

103

u32 *dst;

sound/firewire/motu/amdtp-motu.c

109

dst = (void *)runtime->dma_area +

sound/firewire/motu/amdtp-motu.c

117

*dst = (byte[0] << 24) |

sound/firewire/motu/amdtp-motu.c

121

dst++;

sound/firewire/motu/amdtp-motu.c

125

dst = (void *)runtime->dma_area;

sound/firewire/tascam/amdtp-tascam.c

74

u32 *dst;

sound/firewire/tascam/amdtp-tascam.c

80

dst = (void *)runtime->dma_area +

sound/firewire/tascam/amdtp-tascam.c

89

*dst = be32_to_cpu(buffer[c]);

sound/firewire/tascam/amdtp-tascam.c

90

dst++;

sound/firewire/tascam/amdtp-tascam.c

94

dst = (void *)runtime->dma_area;

sound/hda/core/hdmi_chmap.c

670

unsigned int __user *dst;

sound/hda/core/hdmi_chmap.c

681

dst = tlv + 2;

sound/hda/core/hdmi_chmap.c

710

if (put_user(type, dst) ||

sound/hda/core/hdmi_chmap.c

711

put_user(chs_bytes, dst + 1))

sound/hda/core/hdmi_chmap.c

714

dst += 2;

sound/hda/core/hdmi_chmap.c

726

if (copy_to_user(dst, tlv_chmap, chs_bytes))

sound/hda/core/hdmi_chmap.c

728

dst += chs;

sound/isa/wavefront/wavefront_synth.c

532

unsigned char *dst,

sound/isa/wavefront/wavefront_synth.c

538

*dst = src & 0x7F; /* Mask high bit of LSB */

sound/isa/wavefront/wavefront_synth.c

542

dst++;

sound/isa/wavefront/wavefront_synth.c

544

return dst;

sound/isa/wavefront/wavefront_synth.c

563

munge_buf (unsigned char *src, unsigned char *dst, unsigned int dst_size)

sound/isa/wavefront/wavefront_synth.c

570

*dst++ = src[i] & 0x7f;

sound/isa/wavefront/wavefront_synth.c

571

*dst++ = src[i] >> 7;

sound/isa/wavefront/wavefront_synth.c

573

return dst;

sound/isa/wavefront/wavefront_synth.c

578

demunge_buf (unsigned char *src, unsigned char *dst, unsigned int src_bytes)

sound/isa/wavefront/wavefront_synth.c

587

dst[i] = *src++;

sound/isa/wavefront/wavefront_synth.c

588

dst[i] |= (*src++)<<7;

sound/isa/wavefront/wavefront_synth.c

591

return dst;

sound/mips/sgio2audio.c

348

s16 *dst;

sound/mips/sgio2audio.c

367

dst = (s16 *)(dst_base + dst_pos);

sound/mips/sgio2audio.c

370

dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff;

sound/mips/sgio2audio.c

371

dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff;

sound/mips/sgio2audio.c

394

u64 *dst;

sound/mips/sgio2audio.c

413

dst = (u64 *)(dst_base + dst_pos);

sound/mips/sgio2audio.c

418

*dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) |

sound/pci/ac97/ac97_codec.c

2645

static void set_ctl_name(char *dst, const char *src, const char *suffix)

sound/pci/ac97/ac97_codec.c

2650

if (snprintf(dst, msize, "%s %s", src, suffix) >= msize)

sound/pci/ac97/ac97_codec.c

2652

src, suffix, dst);

sound/pci/ac97/ac97_codec.c

2654

if (strscpy(dst, src, msize) < 0)

sound/pci/ac97/ac97_codec.c

2656

src, dst);

sound/pci/ac97/ac97_codec.c

2682

const char *dst, const char *suffix)

sound/pci/ac97/ac97_codec.c

2688

set_ctl_name(name, dst, suffix);

sound/pci/ac97/ac97_codec.c

2697

const char *dst)

sound/pci/ac97/ac97_codec.c

2699

snd_ac97_rename_ctl(ac97, src, dst, "Switch");

sound/pci/ac97/ac97_codec.c

2700

snd_ac97_rename_ctl(ac97, src, dst, "Volume");

sound/pci/ac97/ac97_patch.h

66

const char *dst, const char *suffix);

sound/pci/ac97/ac97_patch.h

70

const char *dst);

sound/pci/ca0106/ca0106_mixer.c

709

static int rename_ctl(struct snd_card *card, const char *src, const char *dst)

sound/pci/ca0106/ca0106_mixer.c

713

snd_ctl_rename(card, kctl, dst);

sound/pci/cs46xx/cs46xx_lib.c

309

void __iomem *dst;

sound/pci/cs46xx/cs46xx_lib.c

315

dst = chip->region.idx[bank+1].remap_addr + offset;

sound/pci/cs46xx/cs46xx_lib.c

320

writel(*src++, dst);

sound/pci/cs46xx/cs46xx_lib.c

321

dst += sizeof(u32);

sound/pci/cs46xx/cs46xx_lib.c

326

static inline void memcpy_le32(void *dst, const void *src, unsigned int len)

sound/pci/cs46xx/cs46xx_lib.c

329

memcpy(dst, src, len);

sound/pci/cs46xx/cs46xx_lib.c

331

u32 *_dst = dst;

sound/pci/cs46xx/cs46xx_lib.c

472

void __iomem *dst;

sound/pci/cs46xx/cs46xx_lib.c

478

dst = chip->region.idx[bank+1].remap_addr + offset;

sound/pci/cs46xx/cs46xx_lib.c

483

writel(0, dst);

sound/pci/cs46xx/cs46xx_lib.c

484

dst += sizeof(u32);

sound/pci/cs46xx/dsp_spos.c

546

void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET;

sound/pci/cs46xx/dsp_spos.c

559

val = readl(dst + (ins->tasks[i].address + j) * sizeof(u32));

sound/pci/cs46xx/dsp_spos.c

605

void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET;

sound/pci/cs46xx/dsp_spos.c

624

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

633

void __iomem *dst = chip->region.idx[2].remap_addr;

sound/pci/cs46xx/dsp_spos.c

646

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

662

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

677

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

693

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

709

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

725

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

740

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

755

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos.c

771

snd_iprintf(buffer,"%08X ",readl(dst + i));

sound/pci/cs46xx/dsp_spos_scb_lib.c

150

void __iomem *dst = chip->region.idx[2].remap_addr + sample_buffer_addr;

sound/pci/cs46xx/dsp_spos_scb_lib.c

154

writel(0, dst);

sound/pci/cs46xx/dsp_spos_scb_lib.c

155

dst += 4;

sound/pci/cs46xx/dsp_spos_scb_lib.c

64

void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET;

sound/pci/cs46xx/dsp_spos_scb_lib.c

74

snd_iprintf(buffer,"%08x ",readl(dst + (scb->address + j) * sizeof(u32)));

sound/pci/emu10k1/emufx.c

1531

#define _A_SWITCH(icode, ptr, dst, src, sw) \

sound/pci/emu10k1/emufx.c

1532

A_OP((icode), ptr, iMACINT0, dst, A_C_00000000, src, sw);

sound/pci/emu10k1/emufx.c

1533

#define A_SWITCH(icode, ptr, dst, src, sw) \

sound/pci/emu10k1/emufx.c

1534

_A_SWITCH(icode, ptr, A_GPR(dst), A_GPR(src), A_GPR(sw))

sound/pci/emu10k1/emufx.c

1535

#define _A_SWITCH_NEG(icode, ptr, dst, src) \

sound/pci/emu10k1/emufx.c

1536

A_OP((icode), ptr, iANDXOR, dst, src, A_C_00000001, A_C_00000001);

sound/pci/emu10k1/emufx.c

1537

#define A_SWITCH_NEG(icode, ptr, dst, src) \

sound/pci/emu10k1/emufx.c

1538

_A_SWITCH_NEG(icode, ptr, A_GPR(dst), A_GPR(src))

sound/pci/emu10k1/emufx.c

1760

static void _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)

sound/pci/emu10k1/emufx.c

1762

OP(icode, ptr, iMAC1, dst, C_00000000, src, vol);

sound/pci/emu10k1/emufx.c

1764

static void _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol)

sound/pci/emu10k1/emufx.c

1766

OP(icode, ptr, iMAC1, dst, dst, src, vol);

sound/pci/emu10k1/emufx.c

1769

#define VOLUME(icode, ptr, dst, src, vol) \

sound/pci/emu10k1/emufx.c

1770

_volume(icode, ptr, GPR(dst), GPR(src), GPR(vol))

sound/pci/emu10k1/emufx.c

1771

#define VOLUME_IN(icode, ptr, dst, src, vol) \

sound/pci/emu10k1/emufx.c

1772

_volume(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))

sound/pci/emu10k1/emufx.c

1773

#define VOLUME_ADD(icode, ptr, dst, src, vol) \

sound/pci/emu10k1/emufx.c

1774

_volume_add(icode, ptr, GPR(dst), GPR(src), GPR(vol))

sound/pci/emu10k1/emufx.c

1775

#define VOLUME_ADDIN(icode, ptr, dst, src, vol) \

sound/pci/emu10k1/emufx.c

1776

_volume_add(icode, ptr, GPR(dst), EXTIN(src), GPR(vol))

sound/pci/emu10k1/emufx.c

1777

#define VOLUME_OUT(icode, ptr, dst, src, vol) \

sound/pci/emu10k1/emufx.c

1778

_volume(icode, ptr, EXTOUT(dst), GPR(src), GPR(vol))

sound/pci/emu10k1/emufx.c

1779

#define _SWITCH(icode, ptr, dst, src, sw) \

sound/pci/emu10k1/emufx.c

1780

OP((icode), ptr, iMACINT0, dst, C_00000000, src, sw);

sound/pci/emu10k1/emufx.c

1781

#define SWITCH(icode, ptr, dst, src, sw) \

sound/pci/emu10k1/emufx.c

1782

_SWITCH(icode, ptr, GPR(dst), GPR(src), GPR(sw))

sound/pci/emu10k1/emufx.c

1783

#define SWITCH_IN(icode, ptr, dst, src, sw) \

sound/pci/emu10k1/emufx.c

1784

_SWITCH(icode, ptr, GPR(dst), EXTIN(src), GPR(sw))

sound/pci/emu10k1/emufx.c

1785

#define _SWITCH_NEG(icode, ptr, dst, src) \

sound/pci/emu10k1/emufx.c

1786

OP((icode), ptr, iANDXOR, dst, src, C_00000001, C_00000001);

sound/pci/emu10k1/emufx.c

1787

#define SWITCH_NEG(icode, ptr, dst, src) \

sound/pci/emu10k1/emufx.c

1788

_SWITCH_NEG(icode, ptr, GPR(dst), GPR(src))

sound/pci/emu10k1/emufx.c

2426

static void copy_string(char *dst, const char *src, const char *null, int idx)

sound/pci/emu10k1/emufx.c

2429

sprintf(dst, "%s %02X", null, idx);

sound/pci/emu10k1/emufx.c

2431

strcpy(dst, src);

sound/pci/emu10k1/emufx.c

705

struct snd_emu10k1_fx8010_control_gpr *dst,

sound/pci/emu10k1/emufx.c

716

*dst = src[idx];

sound/pci/emu10k1/emufx.c

717

else if (copy_from_user(dst, &_src[idx], sizeof(*src)))

sound/pci/emu10k1/emufx.c

725

memcpy(dst, &octl[idx], sizeof(*octl));

sound/pci/emu10k1/emufx.c

726

else if (copy_from_user(dst, &_octl[idx], sizeof(*octl)))

sound/pci/emu10k1/emufx.c

728

dst->tlv = NULL;

sound/pci/emu10k1/emufx.c

733

struct snd_emu10k1_fx8010_control_gpr *dst,

sound/pci/emu10k1/emufx.c

740

_dst = (struct snd_emu10k1_fx8010_control_gpr __user *)dst;

sound/pci/emu10k1/emufx.c

744

octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)dst;

sound/pci/emu10k1/emumixer.c

1977

static int rename_ctl(struct snd_card *card, const char *src, const char *dst)

sound/pci/emu10k1/emumixer.c

1981

snd_ctl_rename(card, kctl, dst);

sound/pci/emu10k1/emuproc.c

452

u32 dst)

sound/pci/emu10k1/emuproc.c

454

u32 src = snd_emu1010_fpga_link_dst_src_read(emu, dst);

sound/pci/emu10k1/emuproc.c

455

snd_iprintf(buffer, "%04x: %04x\n", dst, src);

sound/pci/emu10k1/io.c

307

void snd_emu1010_fpga_link_dst_src_write(struct snd_emu10k1 *emu, u32 dst, u32 src)

sound/pci/emu10k1/io.c

309

if (snd_BUG_ON(dst & ~0x71f))

sound/pci/emu10k1/io.c

313

snd_emu1010_fpga_write(emu, EMU_HANA_DESTHI, dst >> 8);

sound/pci/emu10k1/io.c

314

snd_emu1010_fpga_write(emu, EMU_HANA_DESTLO, dst & 0x1f);

sound/pci/emu10k1/io.c

319

u32 snd_emu1010_fpga_link_dst_src_read(struct snd_emu10k1 *emu, u32 dst)

sound/pci/emu10k1/io.c

323

if (snd_BUG_ON(dst & ~0x71f))

sound/pci/emu10k1/io.c

325

snd_emu1010_fpga_write(emu, EMU_HANA_DESTHI, dst >> 8);

sound/pci/emu10k1/io.c

326

snd_emu1010_fpga_write(emu, EMU_HANA_DESTLO, dst & 0x1f);

sound/pci/es1938.c

817

struct iov_iter *dst, unsigned long count)

sound/pci/es1938.c

825

if (copy_to_iter(runtime->dma_area + pos + 1, count, dst) != count)

sound/pci/es1938.c

828

if (copy_to_iter(runtime->dma_area + pos + 1, count - 1, dst) != count - 1)

sound/pci/es1938.c

830

if (copy_to_iter(runtime->dma_area, 1, dst) != 1)

sound/pci/korg1212/korg1212.c

1212

struct KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;

sound/pci/korg1212/korg1212.c

1222

if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||

sound/pci/korg1212/korg1212.c

1223

(void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {

sound/pci/korg1212/korg1212.c

1225

__func__, dst, i);

sound/pci/korg1212/korg1212.c

1229

memset((void*) dst + offset, 0, size);

sound/pci/korg1212/korg1212.c

1230

dst++;

sound/pci/korg1212/korg1212.c

1237

struct iov_iter *dst, int pos, int count)

sound/pci/korg1212/korg1212.c

1258

__func__, src, dst->kvec.iov_base, i);

sound/pci/korg1212/korg1212.c

1262

if (copy_to_iter(src, size, dst) != size)

sound/pci/korg1212/korg1212.c

1275

struct KorgAudioFrame *dst;

sound/pci/korg1212/korg1212.c

1281

dst = korg1212->playDataBufsPtr[0].bufferData + pos;

sound/pci/korg1212/korg1212.c

1291

if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||

sound/pci/korg1212/korg1212.c

1292

(void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {

sound/pci/korg1212/korg1212.c

1294

__func__, src->kvec.iov_base, dst, i);

sound/pci/korg1212/korg1212.c

1298

if (copy_from_iter(dst, size, src) != size)

sound/pci/korg1212/korg1212.c

1300

dst++;

sound/pci/korg1212/korg1212.c

1582

struct iov_iter *dst, unsigned long count)

sound/pci/korg1212/korg1212.c

1584

return snd_korg1212_copy_to(substream, dst, pos, count);

sound/pci/lola/lola_mixer.c

448

int dst = chip->mixer.dest_phys_out_ofs +

sound/pci/lola/lola_mixer.c

450

lola_mixer_set_mapping_gain(chip, src, dst, 336, true);

sound/pci/lola/lola_mixer.c

718

unsigned int dst, mask, i;

sound/pci/lola/lola_mixer.c

720

dst = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + dst_ofs;

sound/pci/lola/lola_mixer.c

721

mask = readl(&chip->mixer.array->dest_mix_gain_enable[dst]);

sound/pci/lola/lola_mixer.c

727

if (mask & (1 << dst))

sound/pci/lola/lola_mixer.c

728

val = readw(&chip->mixer.array->dest_mix_gain[dst][src]) + 1;

sound/pci/lola/lola_mixer.c

743

unsigned int dst, mask;

sound/pci/lola/lola_mixer.c

757

dst = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + dst_ofs;

sound/pci/lola/lola_mixer.c

758

return lola_mixer_set_dest_gains(chip, dst, mask, gains);

sound/pci/nm256/nm256.c

700

struct iov_iter *dst, unsigned long count)

sound/pci/nm256/nm256.c

705

if (copy_to_iter_fromio(s->bufptr + pos, count, dst) != count)

sound/pci/rme32.c

268

struct iov_iter *dst, unsigned long count)

sound/pci/rme32.c

273

count, dst) != count)

sound/pci/rme96.c

334

struct iov_iter *dst, unsigned long count)

sound/pci/rme96.c

339

count, dst) != count)

sound/pci/rme9652/hdsp.c

3942

struct iov_iter *dst, unsigned long count)

sound/pci/rme9652/hdsp.c

3953

if (copy_to_iter(channel_buf + pos, count, dst) != count)

sound/pci/rme9652/rme9652.c

1839

struct iov_iter *dst, unsigned long count)

sound/pci/rme9652/rme9652.c

1852

if (copy_to_iter(channel_buf + pos, count, dst) != count)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

102

static inline void pdacf_transfer_stereo16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

105

*dst++ = swab16(inw(rdp_port) ^ xor);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

106

*dst++ = swab16(inw(rdp_port) ^ xor);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

110

static inline void pdacf_transfer_stereo32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

118

*dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

119

*dst++ = swab32((((u32)val3 << 16) | (val2 & 0xff00)) ^ xor);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

123

static inline void pdacf_transfer_mono24le(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

133

*dst++ = (u8)(xval1 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

134

*dst++ = (u8)(xval1 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

135

*dst++ = (u8)(xval1 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

139

static inline void pdacf_transfer_mono24be(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

149

*dst++ = (u8)(xval1 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

150

*dst++ = (u8)(xval1 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

151

*dst++ = (u8)(xval1 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

155

static inline void pdacf_transfer_stereo24le(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

166

*dst++ = (u8)(xval1 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

167

*dst++ = (u8)(xval1 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

168

*dst++ = (u8)(xval1 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

169

*dst++ = (u8)(xval2 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

170

*dst++ = (u8)(xval2 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

171

*dst++ = (u8)(xval2 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

175

static inline void pdacf_transfer_stereo24be(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

186

*dst++ = (u8)(xval1 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

187

*dst++ = (u8)(xval1 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

188

*dst++ = (u8)(xval1 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

189

*dst++ = (u8)(xval2 >> 24);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

190

*dst++ = (u8)(xval2 >> 16);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

191

*dst++ = (u8)(xval2 >> 8);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

41

static inline void pdacf_transfer_mono16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

44

*dst++ = inw(rdp_port) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

49

static inline void pdacf_transfer_mono32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

57

*dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

61

static inline void pdacf_transfer_stereo16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

64

*dst++ = inw(rdp_port) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

65

*dst++ = inw(rdp_port) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

69

static inline void pdacf_transfer_stereo32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

77

*dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

78

*dst++ = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor;

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

82

static inline void pdacf_transfer_mono16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

85

*dst++ = swab16(inw(rdp_port) ^ xor);

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

90

static inline void pdacf_transfer_mono32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)

sound/pcmcia/pdaudiocf/pdaudiocf_irq.c

98

*dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor);

sound/soc/atmel/mchp-pdmc.c

344

unsigned int __user *dst;

sound/soc/atmel/mchp-pdmc.c

354

dst = tlv + 2;

sound/soc/atmel/mchp-pdmc.c

360

if (put_user(SNDRV_CTL_TLVT_CHMAP_VAR, dst) ||

sound/soc/atmel/mchp-pdmc.c

361

put_user(chs_bytes, dst + 1))

sound/soc/atmel/mchp-pdmc.c

363

dst += 2;

sound/soc/atmel/mchp-pdmc.c

371

if (put_user(map->map[c], dst))

sound/soc/atmel/mchp-pdmc.c

373

dst++;

sound/soc/codecs/rt5677-spi.c

457

static void rt5677_spi_reverse(u8 *dst, u32 dstlen, const u8 *src, u32 srclen)

sound/soc/codecs/rt5677-spi.c

465

dst[w + i] = si < srclen ? src[si] : 0;

sound/soc/codecs/tas2781-i2c.c

251

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

262

dst[i++] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

263

dst[i++] = 'r';

sound/soc/codecs/tas2781-i2c.c

265

dst[i++] = TASDEVICE_BOOK_ID(p->r0_reg);

sound/soc/codecs/tas2781-i2c.c

266

dst[i++] = TASDEVICE_PAGE_ID(p->r0_reg);

sound/soc/codecs/tas2781-i2c.c

267

dst[i++] = TASDEVICE_PAGE_REG(p->r0_reg);

sound/soc/codecs/tas2781-i2c.c

269

dst[i++] = TASDEVICE_BOOK_ID(p->r0_low_reg);

sound/soc/codecs/tas2781-i2c.c

270

dst[i++] = TASDEVICE_PAGE_ID(p->r0_low_reg);

sound/soc/codecs/tas2781-i2c.c

271

dst[i++] = TASDEVICE_PAGE_REG(p->r0_low_reg);

sound/soc/codecs/tas2781-i2c.c

273

dst[i++] = TASDEVICE_BOOK_ID(p->invr0_reg);

sound/soc/codecs/tas2781-i2c.c

274

dst[i++] = TASDEVICE_PAGE_ID(p->invr0_reg);

sound/soc/codecs/tas2781-i2c.c

275

dst[i++] = TASDEVICE_PAGE_REG(p->invr0_reg);

sound/soc/codecs/tas2781-i2c.c

277

dst[i++] = TASDEVICE_BOOK_ID(p->pow_reg);

sound/soc/codecs/tas2781-i2c.c

278

dst[i++] = TASDEVICE_PAGE_ID(p->pow_reg);

sound/soc/codecs/tas2781-i2c.c

279

dst[i++] = TASDEVICE_PAGE_REG(p->pow_reg);

sound/soc/codecs/tas2781-i2c.c

281

dst[i++] = TASDEVICE_BOOK_ID(p->tlimit_reg);

sound/soc/codecs/tas2781-i2c.c

282

dst[i++] = TASDEVICE_PAGE_ID(p->tlimit_reg);

sound/soc/codecs/tas2781-i2c.c

283

dst[i++] = TASDEVICE_PAGE_REG(p->tlimit_reg);

sound/soc/codecs/tas2781-i2c.c

287

dst[i++] = j;

sound/soc/codecs/tas2781-i2c.c

295

rc = tasdevice_dev_bulk_read(priv, j, p->r0_reg, &dst[i], 4);

sound/soc/codecs/tas2781-i2c.c

303

rc = memcmp(&dst[i], &data[k], 4);

sound/soc/codecs/tas2781-i2c.c

309

&dst[i], 4);

sound/soc/codecs/tas2781-i2c.c

317

rc = memcmp(&dst[i], &data[k], 4);

sound/soc/codecs/tas2781-i2c.c

323

&dst[i], 4);

sound/soc/codecs/tas2781-i2c.c

331

rc = memcmp(&dst[i], &data[k], 4);

sound/soc/codecs/tas2781-i2c.c

336

rc = tasdevice_dev_bulk_read(priv, j, p->pow_reg, &dst[i], 4);

sound/soc/codecs/tas2781-i2c.c

344

rc = memcmp(&dst[i], &data[k], 4);

sound/soc/codecs/tas2781-i2c.c

350

&dst[i], 4);

sound/soc/codecs/tas2781-i2c.c

355

rc = memcmp(&dst[i], &data[k], 4);

sound/soc/codecs/tas2781-i2c.c

365

unsigned char *dst)

sound/soc/codecs/tas2781-i2c.c

375

dst[0] = i;

sound/soc/codecs/tas2781-i2c.c

376

rc = tasdevice_dev_bulk_read(tas_priv, i, reg, &dst[1],

sound/soc/codecs/tas2781-i2c.c

639

unsigned char *dst = cali_data->data;

sound/soc/codecs/tas2781-i2c.c

671

memcpy(dst, &src[i], cali_data->total_sz);

sound/soc/codecs/tas2781-i2c.c

684

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

687

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

692

dst[1] = i;

sound/soc/codecs/tas2781-i2c.c

699

dst[2] = val;

sound/soc/codecs/tas2781-i2c.c

715

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

731

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

732

return calib_data_get(tas_priv, reg, &dst[1]);

sound/soc/codecs/tas2781-i2c.c

742

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

757

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

758

return calib_data_get(tas_priv, reg, &dst[1]);

sound/soc/codecs/tas2781-i2c.c

769

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

780

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

781

return calib_data_get(tas_priv, reg, &dst[1]);

sound/soc/codecs/tas2781-i2c.c

793

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

800

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

801

return calib_data_get(tas_priv, reg, &dst[1]);

sound/soc/codecs/tas2781-i2c.c

813

unsigned char *dst = ucontrol->value.bytes.data;

sound/soc/codecs/tas2781-i2c.c

820

dst[0] = bytes_ext->max;

sound/soc/codecs/tas2781-i2c.c

821

return calib_data_get(tas_priv, reg, &dst[1]);

sound/soc/fsl/imx-audio-rpmsg.c

81

rpdev->src, rpdev->dst);

sound/soc/intel/atom/sst-atom-controls.c

1015

SST_FILL_DESTINATION(2, cmd.header.dst,

sound/soc/intel/atom/sst-atom-controls.c

1049

SST_FILL_DESTINATION(2, cmd.header.dst,

sound/soc/intel/atom/sst-atom-controls.c

116

SST_FILL_DEFAULT_DESTINATION(cmd.header.dst);

sound/soc/intel/atom/sst-atom-controls.c

272

len = sizeof(cmd->dst) + sizeof(cmd->command_id) + bc->max;

sound/soc/intel/atom/sst-atom-controls.c

278

SST_FILL_DESTINATION(2, cmd->dst, bc->pipe_id, bc->module_id);

sound/soc/intel/atom/sst-atom-controls.c

415

SST_FILL_DEFAULT_DESTINATION(cmd.header.dst);

sound/soc/intel/atom/sst-atom-controls.c

669

SST_FILL_DEFAULT_DESTINATION(cmd.header.dst);

sound/soc/intel/atom/sst-atom-controls.c

755

SST_FILL_DEFAULT_DESTINATION(cmd.header.dst);

sound/soc/intel/atom/sst-atom-controls.c

959

SST_FILL_DEFAULT_DESTINATION(drv->ssp_cmd.header.dst);

sound/soc/intel/atom/sst-atom-controls.h

313

#define SST_FILL_LOCATION_IDS(dst, cell_idx, pipe_id) do { \

sound/soc/intel/atom/sst-atom-controls.h

314

dst.location_id.p.cell_nbr_idx = (cell_idx); \

sound/soc/intel/atom/sst-atom-controls.h

315

dst.location_id.p.path_id = (pipe_id); \

sound/soc/intel/atom/sst-atom-controls.h

317

#define SST_FILL_LOCATION_ID(dst, loc_id) (\

sound/soc/intel/atom/sst-atom-controls.h

318

dst.location_id.f = (loc_id))

sound/soc/intel/atom/sst-atom-controls.h

319

#define SST_FILL_MODULE_ID(dst, mod_id) (\

sound/soc/intel/atom/sst-atom-controls.h

320

dst.module_id = (mod_id))

sound/soc/intel/atom/sst-atom-controls.h

322

#define SST_FILL_DESTINATION1(dst, id) do { \

sound/soc/intel/atom/sst-atom-controls.h

323

SST_FILL_LOCATION_ID(dst, (id) & 0xFFFF); \

sound/soc/intel/atom/sst-atom-controls.h

324

SST_FILL_MODULE_ID(dst, ((id) & 0xFFFF0000) >> 16); \

sound/soc/intel/atom/sst-atom-controls.h

326

#define SST_FILL_DESTINATION2(dst, loc_id, mod_id) do { \

sound/soc/intel/atom/sst-atom-controls.h

327

SST_FILL_LOCATION_ID(dst, loc_id); \

sound/soc/intel/atom/sst-atom-controls.h

328

SST_FILL_MODULE_ID(dst, mod_id); \

sound/soc/intel/atom/sst-atom-controls.h

330

#define SST_FILL_DESTINATION3(dst, cell_idx, path_id, mod_id) do { \

sound/soc/intel/atom/sst-atom-controls.h

331

SST_FILL_LOCATION_IDS(dst, cell_idx, path_id); \

sound/soc/intel/atom/sst-atom-controls.h

332

SST_FILL_MODULE_ID(dst, mod_id); \

sound/soc/intel/atom/sst-atom-controls.h

335

#define SST_FILL_DESTINATION(level, dst, ...) \

sound/soc/intel/atom/sst-atom-controls.h

336

SST_FILL_DESTINATION##level(dst, __VA_ARGS__)

sound/soc/intel/atom/sst-atom-controls.h

337

#define SST_FILL_DEFAULT_DESTINATION(dst) \

sound/soc/intel/atom/sst-atom-controls.h

338

SST_FILL_DESTINATION(2, dst, SST_DEFAULT_LOCATION_ID, SST_DEFAULT_MODULE_ID)

sound/soc/intel/atom/sst-atom-controls.h

351

struct sst_destination_id dst;

sound/soc/intel/atom/sst-atom-controls.h

411

struct sst_destination_id dst;

sound/soc/intel/atom/sst/sst.c

372

kfree(ctx->fw_sg_list.dst);

sound/soc/intel/atom/sst/sst.h

269

struct scatterlist *dst;

sound/soc/intel/atom/sst/sst.h

521

void memcpy32_toio(void __iomem *dst, const void *src, int count);

sound/soc/intel/atom/sst/sst.h

522

void memcpy32_fromio(void *dst, const void __iomem *src, int count);

sound/soc/intel/atom/sst/sst_loader.c

32

void memcpy32_toio(void __iomem *dst, const void *src, int count)

sound/soc/intel/atom/sst/sst_loader.c

37

__iowrite32_copy(dst, src, count / 4);

sound/soc/intel/atom/sst/sst_loader.c

40

void memcpy32_fromio(void *dst, const void __iomem *src, int count)

sound/soc/intel/atom/sst/sst_loader.c

45

__ioread32_copy(dst, src, count / 4);

sound/soc/mediatek/common/mtk-btcvsd.c

289

u8 *src, u8 *dst,

sound/soc/mediatek/common/mtk-btcvsd.c

297

u32 *dst_32 = (u32 *)dst;

sound/soc/mediatek/common/mtk-btcvsd.c

303

u16 *dst_16 = (u16 *)dst;

sound/soc/mediatek/common/mtk-btcvsd.c

340

void *dst;

sound/soc/mediatek/common/mtk-btcvsd.c

345

dst = (void *)bt->tx->buffer_info.bt_sram_addr[i];

sound/soc/mediatek/common/mtk-btcvsd.c

348

bt->tx->temp_packet_buf, dst,

sound/soc/mediatek/common/mtk-btcvsd.c

418

u8 *dst;

sound/soc/mediatek/common/mtk-btcvsd.c

445

dst = (u8 *)ap_addr_tx;

sound/soc/mediatek/common/mtk-btcvsd.c

449

bt->tx->temp_packet_buf, dst,

sound/soc/mediatek/common/mtk-btcvsd.c

518

u8 *src, *dst;

sound/soc/mediatek/common/mtk-btcvsd.c

539

dst = (u8 *)ap_addr_tx;

sound/soc/mediatek/common/mtk-btcvsd.c

546

bt->tx->temp_packet_buf, dst,

sound/soc/soc-core.c

1889

char *dst = card->dmi_longname;

sound/soc/soc-core.c

1893

len = strlen(dst);

sound/soc/soc-core.c

1894

snprintf(dst + len, dst_len - len, "-%s", str);

sound/soc/soc-core.c

1898

cleanup_dmi_name(dst + len);

sound/soc/sof/amd/acp.c

362

void memcpy_from_scratch(struct snd_sof_dev *sdev, u32 offset, unsigned int *dst, size_t bytes)

sound/soc/sof/amd/acp.c

368

dst[j] = snd_sof_dsp_read(sdev, ACP_DSP_BAR, reg_offset + i);

sound/soc/sof/amd/acp.h

275

void memcpy_from_scratch(struct snd_sof_dev *sdev, u32 offset, unsigned int *dst, size_t bytes);

sound/soc/sof/ipc3.c

419

u8 *src, *dst;

sound/soc/sof/ipc3.c

448

dst = (u8 *)cdata_chunk->chanv;

sound/soc/sof/ipc3.c

451

dst = (u8 *)cdata->chanv;

sound/soc/sof/ipc3.c

459

dst = (u8 *)cdata_chunk->data->data;

sound/soc/sof/ipc3.c

462

dst = (u8 *)cdata->data->data;

sound/soc/sof/ipc3.c

490

memcpy(dst, src + offset, send_bytes);

sound/soc/sof/ipc3.c

499

memcpy(dst + offset, src, send_bytes);

sound/soc/sof/ipc4-topology.c

1752

u32 linktype, u8 dir, u32 **dst, u32 *len)

sound/soc/sof/ipc4-topology.c

1858

*dst = (u32 *)cfg->caps;

sound/soc/sof/ipc4-topology.c

1885

u32 linktype, u8 dir, u32 **dst, u32 *len)

sound/soc/sof/topology.c

370

u8 *dst = (u8 *)object + offset;

sound/soc/sof/topology.c

372

memcpy(dst, velem->uuid, UUID_SIZE);

sound/soc/sof/topology.c

384

char **dst = (char **)((u8 *)object + offset);

sound/soc/sof/topology.c

386

*dst = kstrdup(elem, GFP_KERNEL);

sound/soc/sof/topology.c

387

if (!*dst)

sound/soc/sprd/sprd-pcm-compress.c

536

void *dst;

sound/soc/sprd/sprd-pcm-compress.c

546

dst = stream->iram_buffer.area + stream->received_stage0;

sound/soc/sprd/sprd-pcm-compress.c

553

if (copy_from_user(dst, buf, data_count))

sound/soc/sprd/sprd-pcm-compress.c

566

if (copy_from_user(dst, buf, avail_bytes))

sound/soc/sprd/sprd-pcm-compress.c

580

dst = stream->compr_buffer.area + stream->stage1_pointer;

sound/soc/sprd/sprd-pcm-compress.c

582

if (copy_from_user(dst, buf, data_count))

sound/soc/sprd/sprd-pcm-compress.c

589

if (copy_from_user(dst, buf, avail_bytes))

sound/soc/uniphier/aio-compress.c

286

int src = 0, dst = 0, ret;

sound/soc/uniphier/aio-compress.c

315

dstbuf[dst++] = frm_a;

sound/soc/uniphier/aio-compress.c

316

dstbuf[dst++] = frm_b;

sound/usb/card.c

819

unsigned int src, dst;

sound/usb/card.c

823

sscanf(quirk_alias[i], "%x:%x", &src, &dst) != 2 ||

sound/usb/card.c

829

USB_ID_VENDOR(dst), USB_ID_PRODUCT(dst));

sound/usb/card.c

830

*id = dst;

sound/usb/mixer_scarlett.c

601

static void scarlett_generate_name(int i, char *dst, size_t size, int offsets[])

sound/usb/mixer_scarlett.c

604

scnprintf(dst, size, "Mix %c",

sound/usb/mixer_scarlett.c

607

scnprintf(dst, size, "ADAT %d", i - offsets[SCARLETT_OFFSET_ADAT]);

sound/usb/mixer_scarlett.c

609

scnprintf(dst, size, "SPDIF %d", i - offsets[SCARLETT_OFFSET_SPDIF]);

sound/usb/mixer_scarlett.c

611

scnprintf(dst, size, "Analog %d", i - offsets[SCARLETT_OFFSET_ANALOG]);

sound/usb/mixer_scarlett.c

613

scnprintf(dst, size, "PCM %d", i - offsets[SCARLETT_OFFSET_PCM]);

sound/usb/mixer_scarlett.c

615

scnprintf(dst, size, "Off");

sound/usb/pcm.c

1406

u8 *dst = urb->transfer_buffer;

sound/usb/pcm.c

1430

dst[dst_idx++] = marker[subs->dsd_dop.marker];

sound/usb/pcm.c

1445

dst[dst_idx++] = bitrev8(src[idx]);

sound/usb/pcm.c

1447

dst[dst_idx++] = src[idx];

sound/usb/stream.c

152

unsigned int __user *dst;

sound/usb/stream.c

160

dst = tlv + 2;

sound/usb/stream.c

172

if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) ||

sound/usb/stream.c

173

put_user(ch_bytes, dst + 1))

sound/usb/stream.c

175

dst += 2;

sound/usb/stream.c

176

for (i = 0; i < fp->chmap->channels; i++, dst++) {

sound/usb/stream.c

177

if (put_user(fp->chmap->map[i], dst))

sound/xen/xen_snd_front_alsa.c

615

int channel, unsigned long pos, struct iov_iter *dst,

sound/xen/xen_snd_front_alsa.c

628

if (copy_to_iter(stream->buffer + pos, count, dst) != count)

tools/arch/x86/include/asm/io.h

89

static inline void iosubmit_cmds512(void __iomem *dst, const void *src,

tools/arch/x86/include/asm/io.h

96

movdir64b(dst, from);

tools/arch/x86/include/asm/special_insns.h

6

static inline void movdir64b(void *dst, const void *src)

tools/arch/x86/include/asm/special_insns.h

9

struct { char _[64]; } *__dst = dst;

tools/bpf/bpftool/cfg.c

256

static struct edge_node *new_edge(struct bb_node *src, struct bb_node *dst,

tools/bpf/bpftool/cfg.c

269

if (dst)

tools/bpf/bpftool/cfg.c

270

e->dst = dst;

tools/bpf/bpftool/cfg.c

307

e->dst = bb_next(bb);

tools/bpf/bpftool/cfg.c

312

e->dst = func_search_bb_with_head(func,

tools/bpf/bpftool/cfg.c

319

e->dst = bb_next(bb);

tools/bpf/bpftool/cfg.c

327

e->dst = func_search_bb_with_head(func, insn + insn->off + 1);

tools/bpf/bpftool/cfg.c

41

struct bb_node *dst;

tools/bpf/bpftool/cfg.c

427

func_idx, e->src->idx, func_idx, e->dst->idx,

tools/bpf/bpftool/gen.c

412

char *s, *dst;

tools/bpf/bpftool/gen.c

421

dst = s;

tools/bpf/bpftool/gen.c

451

memcpy(dst, src, n);

tools/bpf/bpftool/gen.c

452

dst += n;

tools/bpf/bpftool/gen.c

454

*dst++ = '\n';

tools/bpf/bpftool/gen.c

457

*dst++ = '\0';

tools/build/feature/test-libelf-getphdrnum.c

6

size_t dst;

tools/build/feature/test-libelf-getphdrnum.c

8

return elf_getphdrnum(0, &dst);

tools/build/feature/test-libelf-getshdrstrndx.c

6

size_t dst;

tools/build/feature/test-libelf-getshdrstrndx.c

8

return elf_getshdrstrndx(0, &dst);

tools/hv/vmbus_bufring.c

215

uint8_t *dst = dst0;

tools/hv/vmbus_bufring.c

221

memcpy(dst, br_data + rindex, fraglen);

tools/hv/vmbus_bufring.c

222

memcpy(dst + fraglen, br_data, cplen - fraglen);

tools/hv/vmbus_bufring.c

224

memcpy(dst, br_data + rindex, cplen);

tools/hv/vmbus_bufring.c

68

rte_atomic32_cmpset(volatile uint32_t *dst, uint32_t exp, uint32_t src)

tools/hv/vmbus_bufring.c

76

[dst] "=m" (*dst)

tools/hv/vmbus_bufring.c

79

"m" (*dst)

tools/include/linux/bitmap.h

137

static inline bool bitmap_and(unsigned long *dst, const unsigned long *src1,

tools/include/linux/bitmap.h

141

return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;

tools/include/linux/bitmap.h

142

return __bitmap_and(dst, src1, src2, nbits);

tools/include/linux/bitmap.h

17

void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,

tools/include/linux/bitmap.h

19

bool __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,

tools/include/linux/bitmap.h

29

bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,

tools/include/linux/bitmap.h

37

static inline void bitmap_zero(unsigned long *dst, unsigned int nbits)

tools/include/linux/bitmap.h

40

*dst = 0UL;

tools/include/linux/bitmap.h

42

memset(dst, 0, bitmap_size(nbits));

tools/include/linux/bitmap.h

46

static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)

tools/include/linux/bitmap.h

51

memset(dst, 0xff, len);

tools/include/linux/bitmap.h

53

dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);

tools/include/linux/bitmap.h

79

static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,

tools/include/linux/bitmap.h

83

*dst = *src1 | *src2;

tools/include/linux/bitmap.h

85

__bitmap_or(dst, src1, src2, nbits);

tools/include/linux/bitmap.h

89

bool bitmap_andnot(unsigned long *dst, const unsigned long *src1,

tools/include/linux/bitmap.h

93

return (*dst = *src1 & ~(*src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;

tools/include/linux/bitmap.h

94

return __bitmap_andnot(dst, src1, src2, nbits);

tools/include/nolibc/arch-x86.h

349

void *memmove(void *dst, const void *src, size_t len);

tools/include/nolibc/arch-x86.h

352

void *memcpy(void *dst, const void *src, size_t len);

tools/include/nolibc/arch-x86.h

355

void *memset(void *dst, int c, size_t len);

tools/include/nolibc/string.h

134

char *strcpy(char *dst, const char *src)

tools/include/nolibc/string.h

136

char *ret = dst;

tools/include/nolibc/string.h

138

while ((*dst++ = *src++));

tools/include/nolibc/string.h

211

size_t strlcat(char *dst, const char *src, size_t size)

tools/include/nolibc/string.h

213

size_t len = strnlen(dst, size);

tools/include/nolibc/string.h

220

dst[len] = *src;

tools/include/nolibc/string.h

228

dst[len] = '\0';

tools/include/nolibc/string.h

237

size_t strlcpy(char *dst, const char *src, size_t size)

tools/include/nolibc/string.h

242

dst[len] = src[len];

tools/include/nolibc/string.h

243

if (!dst[len])

tools/include/nolibc/string.h

247

dst[size-1] = '\0';

tools/include/nolibc/string.h

256

char *strncat(char *dst, const char *src, size_t size)

tools/include/nolibc/string.h

258

char *orig = dst;

tools/include/nolibc/string.h

260

while (*dst)

tools/include/nolibc/string.h

261

dst++;

tools/include/nolibc/string.h

263

while (size && (*dst = *src)) {

tools/include/nolibc/string.h

265

dst++;

tools/include/nolibc/string.h

269

*dst = 0;

tools/include/nolibc/string.h

287

char *strncpy(char *dst, const char *src, size_t size)

tools/include/nolibc/string.h

292

if ((dst[len] = *src))

tools/include/nolibc/string.h

294

return dst;

tools/include/nolibc/string.h

38

void *memmove(void *dst, const void *src, size_t len);

tools/include/nolibc/string.h

40

void *memmove(void *dst, const void *src, size_t len)

tools/include/nolibc/string.h

47

if (dst < src) {

tools/include/nolibc/string.h

54

((char *)dst)[pos] = ((const char *)src)[pos];

tools/include/nolibc/string.h

57

return dst;

tools/include/nolibc/string.h

63

void *memcpy(void *dst, const void *src, size_t len);

tools/include/nolibc/string.h

65

void *memcpy(void *dst, const void *src, size_t len)

tools/include/nolibc/string.h

70

((char *)dst)[pos] = ((const char *)src)[pos];

tools/include/nolibc/string.h

73

return dst;

tools/include/nolibc/string.h

81

void *memset(void *dst, int b, size_t len);

tools/include/nolibc/string.h

83

void *memset(void *dst, int b, size_t len)

tools/include/nolibc/string.h

85

char *p = dst;

tools/include/nolibc/string.h

92

return dst;

tools/include/uapi/linux/userfaultfd.h

276

__u64 dst;

tools/include/uapi/linux/userfaultfd.h

360

__u64 dst;

tools/lib/bitmap.c

144

bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,

tools/lib/bitmap.c

152

result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);

tools/lib/bitmap.c

154

result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &

tools/lib/bitmap.c

21

void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,

tools/lib/bitmap.c

28

dst[k] = bitmap1[k] | bitmap2[k];

tools/lib/bitmap.c

60

bool __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,

tools/lib/bitmap.c

68

result |= (dst[k] = bitmap1[k] & bitmap2[k]);

tools/lib/bitmap.c

70

result |= (dst[k] = bitmap1[k] & bitmap2[k] &

tools/lib/bpf/bpf_core_read.h

311

#define bpf_core_read(dst, sz, src) \

tools/lib/bpf/bpf_core_read.h

312

bpf_probe_read_kernel(dst, sz, (const void *)__builtin_preserve_access_index(src))

tools/lib/bpf/bpf_core_read.h

315

#define bpf_core_read_user(dst, sz, src) \

tools/lib/bpf/bpf_core_read.h

316

bpf_probe_read_user(dst, sz, (const void *)__builtin_preserve_access_index(src))

tools/lib/bpf/bpf_core_read.h

322

#define bpf_core_read_str(dst, sz, src) \

tools/lib/bpf/bpf_core_read.h

323

bpf_probe_read_kernel_str(dst, sz, (const void *)__builtin_preserve_access_index(src))

tools/lib/bpf/bpf_core_read.h

326

#define bpf_core_read_user_str(dst, sz, src) \

tools/lib/bpf/bpf_core_read.h

327

bpf_probe_read_user_str(dst, sz, (const void *)__builtin_preserve_access_index(src))

tools/lib/bpf/bpf_core_read.h

399

#define ___read(read_fn, dst, src_type, src, accessor) \

tools/lib/bpf/bpf_core_read.h

400

read_fn((void *)(dst), sizeof(*(dst)), &((src_type)(src))->accessor)

tools/lib/bpf/bpf_core_read.h

418

#define ___core_read0(fn, fn_ptr, dst, src, a) \

tools/lib/bpf/bpf_core_read.h

419

___read(fn, dst, ___type(src), src, a);

tools/lib/bpf/bpf_core_read.h

420

#define ___core_readN(fn, fn_ptr, dst, src, ...) \

tools/lib/bpf/bpf_core_read.h

422

___read(fn, dst, ___type(src, ___nolast(__VA_ARGS__)), __t, \

tools/lib/bpf/bpf_core_read.h

424

#define ___core_read(fn, fn_ptr, dst, src, a, ...) \

tools/lib/bpf/bpf_core_read.h

425

___apply(___core_read, ___empty(__VA_ARGS__))(fn, fn_ptr, dst, \

tools/lib/bpf/bpf_core_read.h

433

#define BPF_CORE_READ_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

435

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

443

#define BPF_CORE_READ_USER_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

445

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

449

#define BPF_PROBE_READ_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

451

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

459

#define BPF_PROBE_READ_USER_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

461

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

469

#define BPF_CORE_READ_STR_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

47

#define __CORE_BITFIELD_PROBE_READ(dst, src, fld) \

tools/lib/bpf/bpf_core_read.h

471

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

479

#define BPF_CORE_READ_USER_STR_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

481

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

485

#define BPF_PROBE_READ_STR_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

487

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

49

(void *)dst, \

tools/lib/bpf/bpf_core_read.h

496

#define BPF_PROBE_READ_USER_STR_INTO(dst, src, a, ...) ({ \

tools/lib/bpf/bpf_core_read.h

498

dst, (src), a, ##__VA_ARGS__) \

tools/lib/bpf/bpf_core_read.h

57

#define __CORE_BITFIELD_PROBE_READ(dst, src, fld) \

tools/lib/bpf/bpf_core_read.h

59

(void *)dst + (8 - __CORE_RELO(src, fld, BYTE_SIZE)), \

tools/lib/bpf/btf.c

1924

struct btf *dst;

tools/lib/bpf/btf.c

1942

off = btf__add_str(p->dst, btf__str_by_offset(p->src, *str_off));

tools/lib/bpf/btf.c

1971

if (btf_ensure_modifiable(p->dst))

tools/lib/bpf/btf.c

1974

t = btf_add_type_mem(p->dst, sz);

tools/lib/bpf/btf.c

1990

return btf_commit_type(p->dst, sz);

tools/lib/bpf/btf.c

1995

struct btf_pipe p = { .src = src_btf, .dst = btf };

tools/lib/bpf/btf.c

2005

struct btf_pipe p = { .src = src_btf, .dst = btf };

tools/lib/bpf/btf.c

5706

bool adding_to_base = dist->pipe.dst->start_id == 1;

tools/lib/bpf/btf.c

5707

int id = btf__type_cnt(dist->pipe.dst);

tools/lib/bpf/btf.c

5743

err = btf_add_composite(dist->pipe.dst, kind, name, t->size);

tools/lib/bpf/btf.c

5761

err = btf__add_enum(dist->pipe.dst, name, t->size);

tools/lib/bpf/btf.c

5801

struct btf_type *t = btf_type_by_id(dist->pipe.dst, i);

tools/lib/bpf/btf.c

5861

dist.pipe.dst = new_base;

tools/lib/bpf/btf.c

5896

dist.pipe.dst = new_split;

tools/lib/bpf/libbpf_internal.h

229

static inline void libbpf_strlcpy(char *dst, const char *src, size_t sz)

tools/lib/bpf/libbpf_internal.h

238

dst[i] = src[i];

tools/lib/bpf/libbpf_internal.h

239

dst[i] = '\0';

tools/lib/bpf/linker.c

1211

static bool secs_match(struct dst_sec *dst, struct src_sec *src)

tools/lib/bpf/linker.c

1213

if (dst->ephemeral || src->ephemeral)

tools/lib/bpf/linker.c

1216

if (dst->shdr->sh_type != src->shdr->sh_type) {

tools/lib/bpf/linker.c

1217

pr_warn("sec %s types mismatch\n", dst->sec_name);

tools/lib/bpf/linker.c

1220

if (dst->shdr->sh_flags != src->shdr->sh_flags) {

tools/lib/bpf/linker.c

1221

pr_warn("sec %s flags mismatch\n", dst->sec_name);

tools/lib/bpf/linker.c

1224

if (dst->shdr->sh_entsize != src->shdr->sh_entsize) {

tools/lib/bpf/linker.c

1225

pr_warn("sec %s entsize mismatch\n", dst->sec_name);

tools/lib/bpf/linker.c

1259

static int extend_sec(struct bpf_linker *linker, struct dst_sec *dst, struct src_sec *src)

tools/lib/bpf/linker.c

1278

if (dst->ephemeral) {

tools/lib/bpf/linker.c

1279

err = init_sec(linker, dst, src);

tools/lib/bpf/linker.c

1284

dst_align = dst->shdr->sh_addralign;

tools/lib/bpf/linker.c

1291

dst_align_sz = (dst->sec_sz + dst_align - 1) / dst_align * dst_align;

tools/lib/bpf/linker.c

1297

tmp = realloc(dst->raw_data, dst_final_sz);

tools/lib/bpf/linker.c

1312

dst->raw_data = tmp;

tools/lib/bpf/linker.c

1315

memset(dst->raw_data + dst->sec_sz, 0, dst_align_sz - dst->sec_sz);

tools/lib/bpf/linker.c

1317

memcpy(dst->raw_data + dst_align_sz, src->data->d_buf, src->shdr->sh_size);

tools/lib/bpf/linker.c

1320

if (linker->swapped_endian && is_exec_sec(dst))

tools/lib/bpf/linker.c

1321

exec_sec_bswap(dst->raw_data + dst_align_sz, src->shdr->sh_size);

tools/lib/bpf/linker.c

1324

dst->sec_sz = dst_final_sz;

tools/lib/bpf/linker.c

1325

dst->shdr->sh_size = dst_final_sz;

tools/lib/bpf/linker.c

1326

dst->data->d_size = dst_final_sz;

tools/lib/bpf/linker.c

1328

dst->shdr->sh_addralign = dst_align;

tools/lib/bpf/linker.c

1329

dst->data->d_align = dst_align;

tools/lib/perf/mmap.c

233

void *dst = map->event_copy;

tools/lib/perf/mmap.c

236

dst = realloc(map->event_copy, size);

tools/lib/perf/mmap.c

237

if (!dst)

tools/lib/perf/mmap.c

239

map->event_copy = dst;

tools/lib/perf/mmap.c

245

memcpy(dst, &data[offset & map->mask], cpy);

tools/lib/perf/mmap.c

247

dst += cpy;

tools/net/ynl/samples/rt-route.c

29

if (r->_len.dst) {

tools/net/ynl/samples/rt-route.c

30

route = inet_ntop(r->_hdr.rtm_family, r->dst,

tools/objtool/builtin-check.c

210

static int copy_file(const char *src, const char *dst)

tools/objtool/builtin-check.c

223

dst_fd = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0400);

tools/objtool/builtin-check.c

225

ERROR("can't open %s for writing: %s", dst, strerror(errno));

tools/perf/bench/mem-functions.c

197

void *src = NULL, *dst = NULL;

tools/perf/bench/mem-functions.c

201

if (r->fn.init && r->fn.init(info, p, &src, &dst))

tools/perf/bench/mem-functions.c

207

if (info->do_op(r, p, src, dst, &rt))

tools/perf/bench/mem-functions.c

236

if (r->fn.fini) r->fn.fini(info, p, &src, &dst);

tools/perf/bench/mem-functions.c

314

static void memcpy_prefault(memcpy_t fn, size_t size, void *src, void *dst)

tools/perf/bench/mem-functions.c

323

fn(dst, src, size);

tools/perf/bench/mem-functions.c

327

void *src, void *dst, union bench_clock *rt)

tools/perf/bench/mem-functions.c

332

memcpy_prefault(fn, p->size, src, dst);

tools/perf/bench/mem-functions.c

337

fn(dst + off, src + off, min(p->chunk_size, p->size - off));

tools/perf/bench/mem-functions.c

366

void **src, void **dst)

tools/perf/bench/mem-functions.c

370

*dst = bench_mmap(p->size, true, p->page_shift);

tools/perf/bench/mem-functions.c

371

failed = *dst == NULL;

tools/perf/bench/mem-functions.c

383

void **src, void **dst)

tools/perf/bench/mem-functions.c

385

bench_munmap(*dst, p->size);

tools/perf/bench/mem-functions.c

388

*dst = *src = NULL;

tools/perf/bench/mem-functions.c

427

void *src __maybe_unused, void *dst, union bench_clock *rt)

tools/perf/bench/mem-functions.c

436

fn(dst, -1, p->size);

tools/perf/bench/mem-functions.c

441

fn(dst + off, i, min(p->chunk_size, p->size - off));

tools/perf/bench/mem-functions.c

483

static void mmap_page_touch(void *dst, size_t size, unsigned int page_shift, bool random)

tools/perf/bench/mem-functions.c

492

*((char *)dst + offset + r) = *(char *)(dst + offset + r) + i;

tools/perf/bench/mem-functions.c

498

void *src __maybe_unused, void *dst __maybe_unused,

tools/perf/bench/mem-functions.c

510

dst = bench_mmap(p->size, populate, p->page_shift);

tools/perf/bench/mem-functions.c

511

if (!dst)

tools/perf/bench/mem-functions.c

514

fn(dst, p->size, p->page_shift, p->seed);

tools/perf/bench/mem-functions.c

519

bench_munmap(dst, p->size);

tools/perf/bench/mem-functions.c

91

void *src, void *dst, union bench_clock *rt);

tools/perf/builtin-record.c

1610

void *dst, size_t dst_size, void *src, size_t src_size)

tools/perf/builtin-record.c

1619

compressed = zstd_compress_stream_to_records(zstd_data, dst, dst_size, src, src_size,

tools/perf/builtin-record.c

289

void *dst, size_t dst_size, void *src, size_t src_size);

tools/perf/tests/shell/coresight/memcpy_thread/memcpy_thread.c

20

unsigned char *src, *dst;

tools/perf/tests/shell/coresight/memcpy_thread/memcpy_thread.c

23

dst = malloc(a->size * 1024);

tools/perf/tests/shell/coresight/memcpy_thread/memcpy_thread.c

24

if ((!src) || (!dst)) {

tools/perf/tests/shell/coresight/memcpy_thread/memcpy_thread.c

29

memcpy(dst, src, a->size * 1024);

tools/perf/ui/browsers/annotate-data.c

44

static void update_hist_entry(struct type_hist_entry *dst,

tools/perf/ui/browsers/annotate-data.c

47

dst->nr_samples += src->nr_samples;

tools/perf/ui/browsers/annotate-data.c

48

dst->period += src->period;

tools/perf/util/addr_location.c

34

void addr_location__copy(struct addr_location *dst, struct addr_location *src)

tools/perf/util/addr_location.c

36

thread__put(dst->thread);

tools/perf/util/addr_location.c

37

map__put(dst->map);

tools/perf/util/addr_location.c

38

*dst = *src;

tools/perf/util/addr_location.c

39

dst->thread = thread__get(src->thread);

tools/perf/util/addr_location.c

40

dst->map = map__get(src->map);

tools/perf/util/addr_location.h

32

void addr_location__copy(struct addr_location *dst, struct addr_location *src);

tools/perf/util/annotate-arch/annotate-powerpc.c

353

struct annotated_op_loc *dst = &loc.ops[INSN_OP_TARGET];

tools/perf/util/annotate-arch/annotate-powerpc.c

368

src->reg1 = dst->reg1;

tools/perf/util/annotate-arch/annotate-powerpc.c

369

dst->reg1 = src_reg;

tools/perf/util/annotate-arch/annotate-powerpc.c

372

if (!has_reg_type(state, dst->reg1))

tools/perf/util/annotate-arch/annotate-powerpc.c

375

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-powerpc.c

388

insn_offset, src->reg1, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

213

struct annotated_op_loc *dst = &loc.ops[INSN_OP_TARGET];

tools/perf/util/annotate-arch/annotate-x86.c

263

if (!has_reg_type(state, dst->reg1))

tools/perf/util/annotate-arch/annotate-x86.c

266

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-x86.c

294

src->reg1 != DWARF_REG_PC && tsr->kind == TSR_KIND_TYPE && !dst->mem_ref)) {

tools/perf/util/annotate-arch/annotate-x86.c

297

insn_offset, imm_value, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

319

insn_offset, imm_value, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

328

if (!has_reg_type(state, dst->reg1))

tools/perf/util/annotate-arch/annotate-x86.c

331

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-x86.c

342

src->reg1 != DWARF_REG_PC && tsr->kind == TSR_KIND_TYPE && !dst->mem_ref)) {

tools/perf/util/annotate-arch/annotate-x86.c

345

insn_offset, imm_value, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

360

!has_reg_type(state, dst->reg1) ||

tools/perf/util/annotate-arch/annotate-x86.c

365

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-x86.c

386

insn_offset, -src->offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

389

insn_offset, src->offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

418

abs(src->offset), sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

426

if (has_reg_type(state, dst->reg1) && !dst->mem_ref &&

tools/perf/util/annotate-arch/annotate-x86.c

427

dwarf_tag(&state->regs[dst->reg1].type) == DW_TAG_pointer_type) {

tools/perf/util/annotate-arch/annotate-x86.c

435

dl->ins.name, insn_offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

436

state->regs[dst->reg1].ok = false;

tools/perf/util/annotate-arch/annotate-x86.c

437

state->regs[dst->reg1].copied_from = -1;

tools/perf/util/annotate-arch/annotate-x86.c

441

if (!strncmp(dl->ins.name, "xor", 3) && dst->reg1 == src->reg1) {

tools/perf/util/annotate-arch/annotate-x86.c

444

insn_offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

446

state->regs[dst->reg1].kind = TSR_KIND_CONST;

tools/perf/util/annotate-arch/annotate-x86.c

447

state->regs[dst->reg1].imm_value = 0;

tools/perf/util/annotate-arch/annotate-x86.c

448

state->regs[dst->reg1].ok = true;

tools/perf/util/annotate-arch/annotate-x86.c

449

state->regs[dst->reg1].copied_from = -1;

tools/perf/util/annotate-arch/annotate-x86.c

466

if (!src->mem_ref && !dst->mem_ref) {

tools/perf/util/annotate-arch/annotate-x86.c

467

if (!has_reg_type(state, dst->reg1))

tools/perf/util/annotate-arch/annotate-x86.c

470

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-x86.c

492

insn_offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

509

insn_offset, var_addr, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

521

insn_offset, tsr->imm_value, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

542

insn_offset, src->reg1, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

546

if (src->mem_ref && !dst->mem_ref) {

tools/perf/util/annotate-arch/annotate-x86.c

549

if (!has_reg_type(state, dst->reg1))

tools/perf/util/annotate-arch/annotate-x86.c

552

tsr = &state->regs[dst->reg1];

tools/perf/util/annotate-arch/annotate-x86.c

584

insn_offset, -offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

587

insn_offset, offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

602

insn_offset, src->offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

616

insn_offset, src->offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

641

insn_offset, addr, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

675

src->reg2, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

678

insn_offset, src->offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

696

insn_offset, src->offset, sreg, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

719

insn_offset, dst->reg1);

tools/perf/util/annotate-arch/annotate-x86.c

728

if (!src->mem_ref && dst->mem_ref) {

tools/perf/util/annotate-arch/annotate-x86.c

734

if (dst->reg1 == fbreg || dst->reg1 == state->stack_reg) {

tools/perf/util/annotate-arch/annotate-x86.c

736

int offset = dst->offset - fboff;

tools/perf/util/annotate-arch/annotate-x86.c

757

if (dst->reg1 == fbreg) {

tools/perf/util/annotate-arch/annotate-x86.c

762

insn_offset, src->reg1, offset, dst->reg1);

tools/perf/util/annotate.c

3175

int annotate_get_basic_blocks(struct symbol *sym, s64 src, s64 dst,

tools/perf/util/annotate.c

3197

if (process_basic_block(&bb_data, link, sym, dst)) {

tools/perf/util/annotate.h

580

int annotate_get_basic_blocks(struct symbol *sym, s64 src, s64 dst,

tools/perf/util/callchain.c

1035

struct callchain_node *dst, struct callchain_node *src)

tools/perf/util/callchain.c

1059

if (append_chain_children(dst, cursor, src->hit) < 0)

tools/perf/util/callchain.c

1069

err = merge_chain_branch(cursor, dst, child);

tools/perf/util/callchain.c

1083

struct callchain_root *dst, struct callchain_root *src)

tools/perf/util/callchain.c

1085

return merge_chain_branch(cursor, &dst->node, &src->node);

tools/perf/util/callchain.c

1640

int callchain_cursor__copy(struct callchain_cursor *dst,

tools/perf/util/callchain.c

1645

callchain_cursor_reset(dst);

tools/perf/util/callchain.c

1655

rc = callchain_cursor_append(dst, node->ip, &node->ms,

tools/perf/util/callchain.h

200

struct callchain_root *dst, struct callchain_root *src);

tools/perf/util/callchain.h

237

int callchain_cursor__copy(struct callchain_cursor *dst,

tools/perf/util/compress.h

55

ssize_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,

tools/perf/util/compress.h

60

void *dst, size_t dst_size);

tools/perf/util/compress.h

75

void *dst __maybe_unused, size_t dst_size __maybe_unused,

tools/perf/util/compress.h

84

size_t src_size __maybe_unused, void *dst __maybe_unused,

tools/perf/util/disasm.c

1327

size_t i, src, dst, len, new_storage_len, num_tabs;

tools/perf/util/disasm.c

1355

for (i = 0, src = 0, dst = 0; i < line_len && num_tabs; i++) {

tools/perf/util/disasm.c

1358

memcpy(&new_line[dst], &line[src], len);

tools/perf/util/disasm.c

1359

dst += len;

tools/perf/util/disasm.c

1360

new_line[dst++] = ' ';

tools/perf/util/disasm.c

1361

while (dst % 8 != 0)

tools/perf/util/disasm.c

1362

new_line[dst++] = ' ';

tools/perf/util/disasm.c

1370

memcpy(&new_line[dst], &line[src], len);

tools/perf/util/disasm.c

1371

dst += len;

tools/perf/util/disasm.c

1372

new_line[dst] = '\0';

tools/perf/util/evsel.c

438

int copy_config_terms(struct list_head *dst, struct list_head *src)

tools/perf/util/evsel.c

455

list_add_tail(&tmp->list, dst);

tools/perf/util/evsel.c

460

static int evsel__copy_config_terms(struct evsel *dst, struct evsel *src)

tools/perf/util/evsel.c

462

return copy_config_terms(&dst->config_terms, &src->config_terms);

tools/perf/util/evsel.h

263

int copy_config_terms(struct list_head *dst, struct list_head *src);

tools/perf/util/hist.c

362

static void hists__add_mem_stat(struct hists *hists, struct hist_entry *dst,

tools/perf/util/hist.c

370

dst->mem_stat[i].entries[k] += src->mem_stat[i].entries[k];

tools/perf/util/hist.c

374

static int hists__clone_mem_stat(struct hists *hists, struct hist_entry *dst,

tools/perf/util/hist.c

380

dst->mem_stat = calloc(hists->nr_mem_stats, sizeof(*dst->mem_stat));

tools/perf/util/hist.c

381

if (dst->mem_stat == NULL)

tools/perf/util/hist.c

386

dst->mem_stat[i].entries[k] = src->mem_stat[i].entries[k];

tools/perf/util/llvm-c-helpers.cpp

107

llvm_a2l_frame &dst = (*inline_frames)[i];

tools/perf/util/llvm-c-helpers.cpp

110

dst.filename = nullptr;

tools/perf/util/llvm-c-helpers.cpp

112

dst.filename = strdup(src.FileName.c_str());

tools/perf/util/llvm-c-helpers.cpp

113

dst.funcname = strdup(src.FunctionName.c_str());

tools/perf/util/llvm-c-helpers.cpp

114

dst.line = src.Line;

tools/perf/util/llvm-c-helpers.cpp

116

if (dst.filename == nullptr ||

tools/perf/util/llvm-c-helpers.cpp

117

dst.funcname == nullptr) {

tools/perf/util/map_symbol.c

18

void map_symbol__copy(struct map_symbol *dst, struct map_symbol *src)

tools/perf/util/map_symbol.c

20

dst->thread = thread__get(src->thread);

tools/perf/util/map_symbol.c

21

dst->map = map__get(src->map);

tools/perf/util/map_symbol.c

22

dst->sym = src->sym;

tools/perf/util/map_symbol.c

25

void addr_map_symbol__copy(struct addr_map_symbol *dst, struct addr_map_symbol *src)

tools/perf/util/map_symbol.c

27

map_symbol__copy(&dst->ms, &src->ms);

tools/perf/util/map_symbol.c

29

dst->addr = src->addr;

tools/perf/util/map_symbol.c

30

dst->al_addr = src->al_addr;

tools/perf/util/map_symbol.c

31

dst->al_level = src->al_level;

tools/perf/util/map_symbol.c

32

dst->phys_addr = src->phys_addr;

tools/perf/util/map_symbol.c

33

dst->data_page_size = src->data_page_size;

tools/perf/util/map_symbol.h

30

void map_symbol__copy(struct map_symbol *dst, struct map_symbol *src);

tools/perf/util/map_symbol.h

31

void addr_map_symbol__copy(struct addr_map_symbol *dst, struct addr_map_symbol *src);

tools/perf/util/probe-event.c

2428

static int perf_probe_point__copy(struct perf_probe_point *dst,

tools/perf/util/probe-event.c

2431

dst->file = strdup_or_goto(src->file, out_err);

tools/perf/util/probe-event.c

2432

dst->function = strdup_or_goto(src->function, out_err);

tools/perf/util/probe-event.c

2433

dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);

tools/perf/util/probe-event.c

2434

dst->line = src->line;

tools/perf/util/probe-event.c

2435

dst->retprobe = src->retprobe;

tools/perf/util/probe-event.c

2436

dst->offset = src->offset;

tools/perf/util/probe-event.c

2440

clear_perf_probe_point(dst);

tools/perf/util/probe-event.c

2444

static int perf_probe_arg__copy(struct perf_probe_arg *dst,

tools/perf/util/probe-event.c

2449

dst->name = strdup_or_goto(src->name, out_err);

tools/perf/util/probe-event.c

2450

dst->var = strdup_or_goto(src->var, out_err);

tools/perf/util/probe-event.c

2451

dst->type = strdup_or_goto(src->type, out_err);

tools/perf/util/probe-event.c

2454

ppfield = &(dst->field);

tools/perf/util/probe-event.c

2470

int perf_probe_event__copy(struct perf_probe_event *dst,

tools/perf/util/probe-event.c

2475

dst->event = strdup_or_goto(src->event, out_err);

tools/perf/util/probe-event.c

2476

dst->group = strdup_or_goto(src->group, out_err);

tools/perf/util/probe-event.c

2477

dst->target = strdup_or_goto(src->target, out_err);

tools/perf/util/probe-event.c

2478

dst->uprobes = src->uprobes;

tools/perf/util/probe-event.c

2480

if (perf_probe_point__copy(&dst->point, &src->point) < 0)

tools/perf/util/probe-event.c

2483

dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);

tools/perf/util/probe-event.c

2484

if (!dst->args)

tools/perf/util/probe-event.c

2486

dst->nargs = src->nargs;

tools/perf/util/probe-event.c

2489

if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)

tools/perf/util/probe-event.c

2494

clear_perf_probe_event(dst);

tools/perf/util/probe-event.h

142

int perf_probe_event__copy(struct perf_probe_event *dst,

tools/perf/util/symbol-elf.c

2689

Elf_Data dst = {

tools/perf/util/symbol-elf.c

2696

.d_version = EV_CURRENT, .d_size = dst.d_size, .d_off = 0,

tools/perf/util/symbol-elf.c

2708

if (len < dst.d_size + 3)

tools/perf/util/symbol-elf.c

2712

if (gelf_xlatetom(*elf, &dst, &src,

tools/perf/util/symbol-elf.c

2719

provider = data + dst.d_size;

tools/perf/util/symbol-elf.c

54

static int elf_getphdrnum(Elf *elf, size_t *dst)

tools/perf/util/symbol-elf.c

63

*dst = ehdr->e_phnum;

tools/perf/util/symbol-elf.c

70

static int elf_getshdrstrndx(Elf *elf __maybe_unused, size_t *dst __maybe_unused)

tools/perf/util/thread-stack.c

618

struct branch_stack *dst, unsigned int sz)

tools/perf/util/thread-stack.c

626

dst->nr = 0;

tools/perf/util/thread-stack.c

635

dst->nr = min((unsigned int)src->nr, sz);

tools/perf/util/thread-stack.c

637

be = &dst->entries[0];

tools/perf/util/thread-stack.c

638

nr = min(ts->br_stack_sz - ts->br_stack_pos, (unsigned int)dst->nr);

tools/perf/util/thread-stack.c

643

be = &dst->entries[nr];

tools/perf/util/thread-stack.c

679

struct branch_stack *dst, unsigned int sz,

tools/perf/util/thread-stack.c

688

dst->nr = 0;

tools/perf/util/thread-stack.c

700

d = &dst->entries[0];

tools/perf/util/thread-stack.c

750

dst->nr = nr;

tools/perf/util/thread-stack.h

92

struct branch_stack *dst, unsigned int sz);

tools/perf/util/thread-stack.h

94

struct branch_stack *dst, unsigned int sz,

tools/perf/util/tracepoint.c

33

char *dst, *path = malloc(strlen(event_string) + 4); /* Space for "/id\0". */

tools/perf/util/tracepoint.c

41

for (src = event_string, dst = path; *src; src++, dst++)

tools/perf/util/tracepoint.c

42

*dst = (*src == ':') ? '/' : *src;

tools/perf/util/tracepoint.c

44

memcpy(dst, "/id", 4);

tools/perf/util/tracepoint.c

46

dst = get_events_file(path);

tools/perf/util/tracepoint.c

47

if (dst)

tools/perf/util/tracepoint.c

48

have_file = file_available(dst);

tools/perf/util/tracepoint.c

49

free(dst);

tools/perf/util/zstd.c

109

output.dst = dst + output.pos;

tools/perf/util/zstd.c

31

ssize_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,

tools/perf/util/zstd.c

56

record = dst;

tools/perf/util/zstd.c

59

dst += size;

tools/perf/util/zstd.c

61

output = (ZSTD_outBuffer){ dst, (dst_size > max_record_size) ?

tools/perf/util/zstd.c

68

memcpy(dst, src, src_size);

tools/perf/util/zstd.c

74

dst += size;

tools/perf/util/zstd.c

82

void *dst, size_t dst_size)

tools/perf/util/zstd.c

86

ZSTD_outBuffer output = { dst, dst_size, 0 };

tools/power/x86/turbostat/turbostat.c

349

static void bic_clear_bits(cpu_set_t *dst, cpu_set_t *clr)

tools/power/x86/turbostat/turbostat.c

357

CLR_BIC(i, dst);

tools/power/x86/turbostat/turbostat.c

4146

void rapl_counter_accumulate(struct rapl_counter *dst, const struct rapl_counter *src)

tools/power/x86/turbostat/turbostat.c

4149

if (dst->unit == RAPL_UNIT_INVALID) {

tools/power/x86/turbostat/turbostat.c

4150

dst->unit = src->unit;

tools/power/x86/turbostat/turbostat.c

4151

dst->scale = src->scale;

tools/power/x86/turbostat/turbostat.c

4154

assert(dst->unit == src->unit);

tools/power/x86/turbostat/turbostat.c

4155

assert(dst->scale == src->scale);

tools/power/x86/turbostat/turbostat.c

4157

dst->raw_value += src->raw_value;

tools/sched_ext/include/scx/common.bpf.h

365

bool bpf_cpumask_and(struct bpf_cpumask *dst, const struct cpumask *src1,

tools/sched_ext/include/scx/common.bpf.h

367

void bpf_cpumask_or(struct bpf_cpumask *dst, const struct cpumask *src1,

tools/sched_ext/include/scx/common.bpf.h

369

void bpf_cpumask_xor(struct bpf_cpumask *dst, const struct cpumask *src1,

tools/sched_ext/include/scx/common.bpf.h

376

void bpf_cpumask_copy(struct bpf_cpumask *dst, const struct cpumask *src) __ksym;

tools/sched_ext/include/scx/compat.bpf.h

82

int bpf_cpumask_populate(struct cpumask *dst, void *src, size_t src__sz) __ksym __weak;

tools/spi/spidev_test.c

100

char *dst = _dst;

tools/spi/spidev_test.c

110

*dst++ = (unsigned char)ch;

tools/spi/spidev_test.c

112

*dst++ = *src++;

tools/testing/selftests/alsa/conf.c

123

snd_config_t *dst;

tools/testing/selftests/alsa/conf.c

130

err = snd_config_top(&dst);

tools/testing/selftests/alsa/conf.c

133

err = snd_config_load(dst, input);

tools/testing/selftests/alsa/conf.c

137

return dst;

tools/testing/selftests/alsa/conf.c

54

snd_config_t *dst;

tools/testing/selftests/alsa/conf.c

63

err = snd_config_top(&dst);

tools/testing/selftests/alsa/conf.c

68

err = snd_config_load(dst, input);

tools/testing/selftests/alsa/conf.c

71

snd_config_delete(dst);

tools/testing/selftests/alsa/conf.c

74

*config = dst;

tools/testing/selftests/arm64/abi/hwcap.c

195

char dst[1], src[1];

tools/testing/selftests/arm64/abi/hwcap.c

196

register char *dstp asm ("x0") = dst;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

263

char *src, *dst;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

274

dst = (char *)mte_allocate_memory(size, mem_type, 0, true);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

275

if (check_allocated_memory(dst, size, mem_type, true) != KSFT_PASS) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

282

dst = (char *)mte_allocate_memory(size, mem_type, 0, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

283

if (check_allocated_memory(dst, size, mem_type, false) != KSFT_PASS)

tools/testing/selftests/arm64/mte/check_buffer_fill.c

288

mte_free_memory((void *)dst, size, mem_type, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

297

dst = (char *)mte_allocate_memory(size, mem_type, 0, true);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

298

if (check_allocated_memory(dst, size, mem_type, true) != KSFT_PASS) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

309

mte_initialize_current_context(mode, (uintptr_t)dst, size);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

312

memcpy((void *)dst, (void *)src, size);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

320

if (src[j] != dst[j] || src[j] != '1') {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

328

mte_free_memory((void *)dst, size, mem_type,

tools/testing/selftests/arm64/mte/check_buffer_fill.c

329

MT_FETCH_TAG((uintptr_t)dst) ? true : false);

tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

42

args.crypto_len > sizeof(ctx.skel->bss->dst)) {

tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

44

sizeof(ctx.skel->bss->dst));

tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

85

if (!sz || sz > sizeof(ctx.skel->bss->dst)) {

tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

87

sz, sizeof(ctx.skel->bss->dst));

tools/testing/selftests/bpf/bpf_util.h

53

#define __strscpy0(dst, src, ...) \

tools/testing/selftests/bpf/bpf_util.h

54

sized_strscpy(dst, src, sizeof(dst))

tools/testing/selftests/bpf/bpf_util.h

55

#define __strscpy1(dst, src, size) \

tools/testing/selftests/bpf/bpf_util.h

56

sized_strscpy(dst, src, size)

tools/testing/selftests/bpf/bpf_util.h

59

#define strscpy(dst, src, ...) \

tools/testing/selftests/bpf/bpf_util.h

60

CONCATENATE(__strscpy, COUNT_ARGS(__VA_ARGS__))(dst, src, __VA_ARGS__)

tools/testing/selftests/bpf/network_helpers.c

966

const char *src, *dst;

tools/testing/selftests/bpf/network_helpers.c

972

dst = inet_ntop(AF_INET6, &pkt->daddr, dst_buf, sizeof(dst_buf));

tools/testing/selftests/bpf/network_helpers.c

973

if (!dst)

tools/testing/selftests/bpf/network_helpers.c

974

dst = "<invalid>";

tools/testing/selftests/bpf/network_helpers.c

978

ifindex, src, dst, proto, true, pkt_type);

tools/testing/selftests/bpf/network_helpers.c

985

const char *src, *dst;

tools/testing/selftests/bpf/network_helpers.c

991

dst = inet_ntop(AF_INET, &pkt->daddr, dst_buf, sizeof(dst_buf));

tools/testing/selftests/bpf/network_helpers.c

992

if (!dst)

tools/testing/selftests/bpf/network_helpers.c

993

dst = "<invalid>";

tools/testing/selftests/bpf/network_helpers.c

997

ifindex, src, dst, proto, false, pkt_type);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

1467

char *dst = str, *src = str;

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

1473

*(dst++) = *(src++);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

1477

*dst = '\0';

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

203

const struct sockaddr_storage *dst)

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

206

struct sockaddr_in6 *dst_in6 = (struct sockaddr_in6 *)dst;

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

208

struct sockaddr_in *dst_in = (struct sockaddr_in *)dst;

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

29

struct sockaddr_storage *dst)

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

335

struct sockaddr_storage *dst = &dsts[test->type][j];

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

347

tattr.data_size_in = build_input(test, input, src, dst);

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

48

slen = sizeof(*dst);

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

49

if (CHECK_FAIL(getsockname(*conn, (struct sockaddr *)dst, &slen)))

tools/testing/selftests/bpf/prog_tests/crypto_sanity.c

159

if (!ASSERT_STRNEQ(skel->bss->dst, afalg_dst, sizeof(afalg_dst), "encrypt AF_ALG"))

tools/testing/selftests/bpf/prog_tests/crypto_sanity.c

184

if (!ASSERT_STRNEQ(skel->bss->dst, afalg_plain, sizeof(afalg_plain), "decrypt AF_ALG"))

tools/testing/selftests/bpf/prog_tests/crypto_sanity.c

49

static void do_crypt_afalg(const void *src, void *dst, int size, bool encrypt)

tools/testing/selftests/bpf/prog_tests/crypto_sanity.c

72

read(opfd, dst, size);

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

123

uint32_t dst, int payload_len, uint8_t tos)

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

135

iph->daddr = dst;

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

151

const struct sockaddr_in6 *dst, int payload_len,

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

163

memcpy(&ip6h->daddr, &dst->sin6_addr, sizeof(ip6h->daddr));

tools/testing/selftests/bpf/prog_tests/l4lb_all.c

20

__be32 dst;

tools/testing/selftests/bpf/prog_tests/l4lb_all.c

24

} real_def = {.dst = MAGIC_VAL};

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1095

u64 *dst, def;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1162

*f->dst = f->is_32 ? (u64)(u32)val : val;

tools/testing/selftests/bpf/prog_tests/reg_bounds.c

1184

*f->dst = f->def;

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

1163

struct sockaddr_storage dst = {};

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

1201

err = make_sockaddr(AF_INET, EXT_IP4, EXT_PORT, &dst, &len);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

1204

err = connect(client_fd, (void *)&dst, len);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

803

struct sockaddr_storage dst = {};

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

822

err = make_sockaddr(family, t->connect_to.ip, t->connect_to.port, &dst, &len);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

825

err = connect(client_fd, (void *)&dst, len);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

921

struct sockaddr_storage dst = { 0 };

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

950

err = make_sockaddr(family, t->connect_to.ip, t->connect_to.port, &dst, &len);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

953

err = connect(client, (void *)&dst, len);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

362

compare_cookies(src, skel->maps.dst);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

70

static void compare_cookies(struct bpf_map *src, struct bpf_map *dst)

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

76

dst_fd = bpf_map__fd(dst);

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

273

static void run_link(const char *src, const char *dst, int port)

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

278

server = start_server_str(AF_INET, SOCK_STREAM, dst, port, NULL);

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

295

static void block_link(int map_fd, const char *src, const char *dst)

tools/testing/selftests/bpf/prog_tests/test_bpf_smc.c

300

.dip = inet_addr(dst),

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

246

static void vxlan_decap_mod_args_cb(struct subtest_cfg *cfg, char *dst)

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

248

snprintf(dst, TUNNEL_ARGS_MAX_LEN, "id %d dstport %d udp6zerocsumrx",

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

252

static void udp_decap_mod_args_cb(struct subtest_cfg *cfg, char *dst)

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

256

snprintf(dst, TUNNEL_ARGS_MAX_LEN,

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

58

void (*extra_decap_mod_args_cb)(struct subtest_cfg *cfg, char *dst);

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

80

static int build_subtest_name(struct subtest_cfg *cfg, char *dst, size_t size)

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

84

ret = snprintf(dst, size, "%s_%s", cfg->ebpf_tun_type,

tools/testing/selftests/bpf/prog_tests/xdp_noinline.c

22

__be32 dst;

tools/testing/selftests/bpf/prog_tests/xdp_noinline.c

26

} real_def = {.dst = MAGIC_VAL};

tools/testing/selftests/bpf/progs/bpf_iter_sockmap.c

30

} dst SEC(".maps");

tools/testing/selftests/bpf/progs/bpf_iter_sockmap.c

54

return bpf_map_update_elem(&dst, &tmp, sk, 0) != 0;

tools/testing/selftests/bpf/progs/bpf_iter_sockmap.c

57

ret = bpf_map_delete_elem(&dst, &tmp);

tools/testing/selftests/bpf/progs/bpf_mod_race.c

73

char dst;

tools/testing/selftests/bpf/progs/bpf_mod_race.c

79

bpf_copy_from_user(&dst, 1, bpf_mod_race_config.fault_addr);

tools/testing/selftests/bpf/progs/bpf_smc.c

63

static bool smc_check(__u32 src, __u32 dst)

tools/testing/selftests/bpf/progs/bpf_smc.c

68

.dip = dst,

tools/testing/selftests/bpf/progs/cgroup_skb_sk_lookup_kern.c

21

static inline void set_ip(__u32 *dst, const struct in6_addr *src)

tools/testing/selftests/bpf/progs/cgroup_skb_sk_lookup_kern.c

23

dst[0] = src->in6_u.u6_addr32[0];

tools/testing/selftests/bpf/progs/cgroup_skb_sk_lookup_kern.c

24

dst[1] = src->in6_u.u6_addr32[1];

tools/testing/selftests/bpf/progs/cgroup_skb_sk_lookup_kern.c

25

dst[2] = src->in6_u.u6_addr32[2];

tools/testing/selftests/bpf/progs/cgroup_skb_sk_lookup_kern.c

26

dst[3] = src->in6_u.u6_addr32[3];

tools/testing/selftests/bpf/progs/cpumask_common.h

59

void bpf_cpumask_copy(struct bpf_cpumask *dst, const struct cpumask *src) __ksym __weak;

tools/testing/selftests/bpf/progs/crypto_bench.c

16

char dst[256] = {};

tools/testing/selftests/bpf/progs/crypto_bench.c

75

bpf_dynptr_from_mem(dst, len, 0, &pdst);

tools/testing/selftests/bpf/progs/crypto_bench.c

99

bpf_dynptr_from_mem(dst, len, 0, &pdst);

tools/testing/selftests/bpf/progs/crypto_common.h

15

const struct bpf_dynptr *dst, const struct bpf_dynptr *iv) __ksym;

tools/testing/selftests/bpf/progs/crypto_common.h

17

const struct bpf_dynptr *dst, const struct bpf_dynptr *iv) __ksym;

tools/testing/selftests/bpf/progs/crypto_sanity.c

126

bpf_dynptr_from_mem(dst, sizeof(dst), 0, &pdst);

tools/testing/selftests/bpf/progs/crypto_sanity.c

17

char dst[16] = {}, dst_bad[8] = {};

tools/testing/selftests/bpf/progs/crypto_sanity.c

173

bpf_dynptr_from_mem(dst, sizeof(dst), 0, &pdst);

tools/testing/selftests/bpf/progs/dynptr_success.c

644

struct bpf_dynptr src, dst;

tools/testing/selftests/bpf/progs/dynptr_success.c

647

bpf_ringbuf_reserve_dynptr(&ringbuf, sz, 0, &dst);

tools/testing/selftests/bpf/progs/dynptr_success.c

651

err = err ?: bpf_dynptr_copy(&dst, 0, &src, 0, sz);

tools/testing/selftests/bpf/progs/dynptr_success.c

652

err = err ?: bpf_dynptr_read(buf, sz, &dst, 0, 0);

tools/testing/selftests/bpf/progs/dynptr_success.c

656

err = err ?: bpf_dynptr_copy(&dst, 3, &src, 5, sz - 5);

tools/testing/selftests/bpf/progs/dynptr_success.c

657

err = err ?: bpf_dynptr_read(buf, sz - 5, &dst, 3, 0);

tools/testing/selftests/bpf/progs/dynptr_success.c

661

bpf_ringbuf_discard_dynptr(&dst, 0);

tools/testing/selftests/bpf/progs/irq.c

12

extern int bpf_copy_from_user_str(void *dst, u32 dst__sz, const void *unsafe_ptr__ign, u64 flags) __weak __ksym;

tools/testing/selftests/bpf/progs/preempt_lock.c

8

extern int bpf_copy_from_user_str(void *dst, u32 dst__sz, const void *unsafe_ptr__ign, u64 flags) __weak __ksym;

tools/testing/selftests/bpf/progs/profiler.inc.h

153

probe_read_lim(void* dst, void* src, unsigned long len, unsigned long max)

tools/testing/selftests/bpf/progs/profiler.inc.h

157

if (bpf_probe_read_kernel(dst, len, src))

tools/testing/selftests/bpf/progs/profiler.inc.h

160

if (bpf_probe_read_kernel(dst, 1, src))

tools/testing/selftests/bpf/progs/read_vsyscall.c

18

int bpf_copy_from_user_str(void *dst, u32, const void *, u64) __weak __ksym;

tools/testing/selftests/bpf/progs/read_vsyscall.c

19

int bpf_copy_from_user_task_str(void *dst, u32, const void *,

tools/testing/selftests/bpf/progs/test_attach_probe.c

26

int bpf_copy_from_user_str(void *dst, u32, const void *, u64) __weak __ksym;

tools/testing/selftests/bpf/progs/test_bpf_nf.c

194

if (tuple->dst.u3.ip == saddr.ip &&

tools/testing/selftests/bpf/progs/test_bpf_nf.c

195

tuple->dst.u.all == bpf_htons(sport))

tools/testing/selftests/bpf/progs/test_cls_redirect.c

156

static __always_inline bool buf_copy(buf_t *buf, void *dst, size_t len)

tools/testing/selftests/bpf/progs/test_cls_redirect.c

158

if (bpf_skb_load_bytes(buf->skb, buf_off(buf), dst, len)) {

tools/testing/selftests/bpf/progs/test_cls_redirect.c

242

uint16_t dst = ports->src;

tools/testing/selftests/bpf/progs/test_cls_redirect.c

243

ports->src = ports->dst;

tools/testing/selftests/bpf/progs/test_cls_redirect.c

244

ports->dst = dst;

tools/testing/selftests/bpf/progs/test_cls_redirect.c

87

uint16_t src, dst;

tools/testing/selftests/bpf/progs/test_cls_redirect_dynptr.c

152

uint16_t dst = ports->src;

tools/testing/selftests/bpf/progs/test_cls_redirect_dynptr.c

153

ports->src = ports->dst;

tools/testing/selftests/bpf/progs/test_cls_redirect_dynptr.c

154

ports->dst = dst;

tools/testing/selftests/bpf/progs/test_cls_redirect_dynptr.c

83

uint16_t src, dst;

tools/testing/selftests/bpf/progs/test_core_autosize.c

131

#define bpf_core_read_int(dst, sz, src) ({ \

tools/testing/selftests/bpf/progs/test_core_autosize.c

133

volatile long __off = sizeof(*dst) - (sz); \

tools/testing/selftests/bpf/progs/test_core_autosize.c

134

bpf_core_read((char *)(dst) + __off, sz, src); \

tools/testing/selftests/bpf/progs/test_core_reloc_arrays.c

38

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_flavors.c

43

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_ints.c

27

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_kernel.c

43

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_misc.c

36

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_mods.c

46

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_mods.c

48

#define CORE_READ(dst, src) ({ \

tools/testing/selftests/bpf/progs/test_core_reloc_mods.c

49

int __sz = sizeof(*(dst)) < sizeof(*(src)) ? sizeof(*(dst)) : \

tools/testing/selftests/bpf/progs/test_core_reloc_mods.c

51

bpf_core_read((char *)(dst) + sizeof(*(dst)) - __sz, __sz, \

tools/testing/selftests/bpf/progs/test_core_reloc_nesting.c

34

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_primitives.c

29

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_core_reloc_ptr_as_arr.c

20

#define CORE_READ(dst, src) bpf_core_read(dst, sizeof(*(dst)), src)

tools/testing/selftests/bpf/progs/test_l4lb.c

127

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb.c

153

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb.c

277

pckt->dst = iph->saddr;

tools/testing/selftests/bpf/progs/test_l4lb.c

330

struct real_definition *dst;

tools/testing/selftests/bpf/progs/test_l4lb.c

389

pckt.dst = iph->daddr;

tools/testing/selftests/bpf/progs/test_l4lb.c

407

vip.daddr.v4 = pckt.dst;

tools/testing/selftests/bpf/progs/test_l4lb.c

423

if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6))

tools/testing/selftests/bpf/progs/test_l4lb.c

426

if (dst->flags & F_IPV6) {

tools/testing/selftests/bpf/progs/test_l4lb.c

431

memcpy(tkey.remote_ipv6, dst->dstv6, 16);

tools/testing/selftests/bpf/progs/test_l4lb.c

438

tkey.remote_ipv4 = dst->dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

123

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

149

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

276

pckt->dst = iph->saddr;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

329

struct real_definition *dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

388

pckt.dst = iph->daddr;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

406

vip.daddr.v4 = pckt.dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

422

if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6))

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

425

if (dst->flags & F_IPV6) {

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

430

memcpy(tkey.remote_ipv6, dst->dstv6, 16);

tools/testing/selftests/bpf/progs/test_l4lb_noinline.c

437

tkey.remote_ipv4 = dst->dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

125

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

151

__be32 dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

280

pckt->dst = iph->saddr;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

334

struct real_definition *dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

395

pckt.dst = iph->daddr;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

413

vip.daddr.v4 = pckt.dst;

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

429

if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6))

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

432

if (dst->flags & F_IPV6) {

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

437

memcpy(tkey.remote_ipv6, dst->dstv6, 16);

tools/testing/selftests/bpf/progs/test_l4lb_noinline_dynptr.c

444

tkey.remote_ipv4 = dst->dst;

tools/testing/selftests/bpf/progs/test_sock_fields.c

100

dst->rate_delivered = src->rate_delivered;

tools/testing/selftests/bpf/progs/test_sock_fields.c

101

dst->rate_interval_us = src->rate_interval_us;

tools/testing/selftests/bpf/progs/test_sock_fields.c

102

dst->packets_out = src->packets_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

103

dst->retrans_out = src->retrans_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

104

dst->total_retrans = src->total_retrans;

tools/testing/selftests/bpf/progs/test_sock_fields.c

105

dst->segs_in = src->segs_in;

tools/testing/selftests/bpf/progs/test_sock_fields.c

106

dst->data_segs_in = src->data_segs_in;

tools/testing/selftests/bpf/progs/test_sock_fields.c

107

dst->segs_out = src->segs_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

108

dst->data_segs_out = src->data_segs_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

109

dst->lost_out = src->lost_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

110

dst->sacked_out = src->sacked_out;

tools/testing/selftests/bpf/progs/test_sock_fields.c

111

dst->bytes_received = src->bytes_received;

tools/testing/selftests/bpf/progs/test_sock_fields.c

112

dst->bytes_acked = src->bytes_acked;

tools/testing/selftests/bpf/progs/test_sock_fields.c

64

static void skcpy(struct bpf_sock *dst,

tools/testing/selftests/bpf/progs/test_sock_fields.c

67

dst->bound_dev_if = src->bound_dev_if;

tools/testing/selftests/bpf/progs/test_sock_fields.c

68

dst->family = src->family;

tools/testing/selftests/bpf/progs/test_sock_fields.c

69

dst->type = src->type;

tools/testing/selftests/bpf/progs/test_sock_fields.c

70

dst->protocol = src->protocol;

tools/testing/selftests/bpf/progs/test_sock_fields.c

71

dst->mark = src->mark;

tools/testing/selftests/bpf/progs/test_sock_fields.c

72

dst->priority = src->priority;

tools/testing/selftests/bpf/progs/test_sock_fields.c

73

dst->src_ip4 = src->src_ip4;

tools/testing/selftests/bpf/progs/test_sock_fields.c

74

dst->src_ip6[0] = src->src_ip6[0];

tools/testing/selftests/bpf/progs/test_sock_fields.c

75

dst->src_ip6[1] = src->src_ip6[1];

tools/testing/selftests/bpf/progs/test_sock_fields.c

76

dst->src_ip6[2] = src->src_ip6[2];

tools/testing/selftests/bpf/progs/test_sock_fields.c

77

dst->src_ip6[3] = src->src_ip6[3];

tools/testing/selftests/bpf/progs/test_sock_fields.c

78

dst->src_port = src->src_port;

tools/testing/selftests/bpf/progs/test_sock_fields.c

79

dst->dst_ip4 = src->dst_ip4;

tools/testing/selftests/bpf/progs/test_sock_fields.c

80

dst->dst_ip6[0] = src->dst_ip6[0];

tools/testing/selftests/bpf/progs/test_sock_fields.c

81

dst->dst_ip6[1] = src->dst_ip6[1];

tools/testing/selftests/bpf/progs/test_sock_fields.c

82

dst->dst_ip6[2] = src->dst_ip6[2];

tools/testing/selftests/bpf/progs/test_sock_fields.c

83

dst->dst_ip6[3] = src->dst_ip6[3];

tools/testing/selftests/bpf/progs/test_sock_fields.c

84

dst->dst_port = src->dst_port;

tools/testing/selftests/bpf/progs/test_sock_fields.c

85

dst->state = src->state;

tools/testing/selftests/bpf/progs/test_sock_fields.c

88

static void tpcpy(struct bpf_tcp_sock *dst,

tools/testing/selftests/bpf/progs/test_sock_fields.c

91

dst->snd_cwnd = src->snd_cwnd;

tools/testing/selftests/bpf/progs/test_sock_fields.c

92

dst->srtt_us = src->srtt_us;

tools/testing/selftests/bpf/progs/test_sock_fields.c

93

dst->rtt_min = src->rtt_min;

tools/testing/selftests/bpf/progs/test_sock_fields.c

94

dst->snd_ssthresh = src->snd_ssthresh;

tools/testing/selftests/bpf/progs/test_sock_fields.c

95

dst->rcv_nxt = src->rcv_nxt;

tools/testing/selftests/bpf/progs/test_sock_fields.c

96

dst->snd_nxt = src->snd_nxt;

tools/testing/selftests/bpf/progs/test_sock_fields.c

97

dst->snd_una = src->snd_una;

tools/testing/selftests/bpf/progs/test_sock_fields.c

98

dst->mss_cache = src->mss_cache;

tools/testing/selftests/bpf/progs/test_sock_fields.c

99

dst->ecn_flags = src->ecn_flags;

tools/testing/selftests/bpf/progs/test_tc_neigh_fib.c

54

struct in6_addr *dst = (struct in6_addr *)fib_params->ipv6_dst;

tools/testing/selftests/bpf/progs/test_tc_neigh_fib.c

73

*dst = ip6h->daddr;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

145

__u8 *src, *dst;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

153

dst = bpf_dynptr_slice_rdwr(&meta, 0, NULL, META_SIZE);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

154

if (!dst)

tools/testing/selftests/bpf/progs/test_xdp_meta.c

157

__builtin_memcpy(dst, src, META_SIZE);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

169

__u8 *dst, *src;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

171

dst = meta_have;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

175

bpf_dynptr_read(dst, chunk_len, &meta, 0, 0);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

176

dst += chunk_len;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

180

bpf_dynptr_read(dst, chunk_len, &meta, 0, 0);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

181

dst += chunk_len;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

184

bpf_dynptr_read(dst, chunk_len, &meta, chunk_len, 0);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

185

dst += chunk_len;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

191

__builtin_memcpy(dst, src, chunk_len);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

208

__u8 *dst, *src;

tools/testing/selftests/bpf/progs/test_xdp_meta.c

228

dst = bpf_dynptr_slice_rdwr(&meta, 2 * chunk_len, NULL, chunk_len);

tools/testing/selftests/bpf/progs/test_xdp_meta.c

229

if (!dst)

tools/testing/selftests/bpf/progs/test_xdp_meta.c

231

__builtin_memcpy(dst, src, chunk_len);

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

112

__be32 dst;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

157

__be32 dst;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

281

struct real_definition *dst, __u32 pkt_bytes)

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

317

memcpy(ip6h->daddr.in6_u.u6_addr32, dst->dstv6, 16);

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

332

struct real_definition *dst, __u32 pkt_bytes)

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

370

iph->saddr = ((0xFFFF0000 & ip_suffix) | 4268) ^ dst->dst;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

504

pckt->flow.dst = iph->saddr;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

659

pckt->flow.dst = iph->daddr;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

669

struct real_definition *dst = NULL;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

707

vip.vip = pckt.flow.dst;

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

725

if (!dst) {

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

729

connection_table_lookup(&dst, &pckt, lru_map);

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

730

if (dst)

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

743

if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6, lru_map))

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

751

if (dst->flags & (1 << 0)) {

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

752

if (!encap_v6(xdp, cval, &pckt, dst, pkt_bytes))

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

755

if (!encap_v4(xdp, cval, &pckt, dst, pkt_bytes))

tools/testing/selftests/bpf/progs/test_xdp_noinline.c

769

*(u32 *)data = dst->dst;

tools/testing/selftests/bpf/progs/xdp_flowtable.c

110

struct in6_addr *dst = (struct in6_addr *)tuple.ipv6_dst;

tools/testing/selftests/bpf/progs/xdp_flowtable.c

128

*dst = ip6h->daddr;

tools/testing/selftests/bpf/progs/xdping_kern.c

31

unsigned short dst[3];

tools/testing/selftests/bpf/progs/xdping_kern.c

33

dst[0] = p[0];

tools/testing/selftests/bpf/progs/xdping_kern.c

34

dst[1] = p[1];

tools/testing/selftests/bpf/progs/xdping_kern.c

35

dst[2] = p[2];

tools/testing/selftests/bpf/progs/xdping_kern.c

39

p[3] = dst[0];

tools/testing/selftests/bpf/progs/xdping_kern.c

40

p[4] = dst[1];

tools/testing/selftests/bpf/progs/xdping_kern.c

41

p[5] = dst[2];

tools/testing/selftests/bpf/test_sockmap.c

1412

static void append_str(char *dst, const char *src, size_t dst_cap)

tools/testing/selftests/bpf/test_sockmap.c

1414

size_t avail = dst_cap - strlen(dst);

tools/testing/selftests/bpf/test_sockmap.c

1419

strncat(dst, src, avail - 1); /* strncat() adds + 1 for zero byte */

tools/testing/selftests/bpf/test_tag.c

78

static int hex2bin(uint8_t *dst, const char *src, size_t count)

tools/testing/selftests/bpf/test_tag.c

86

*dst++ = (hi << 4) | lo;

tools/testing/selftests/cgroup/test_core.c

579

char *src = NULL, *dst = NULL;

tools/testing/selftests/cgroup/test_core.c

583

dst = cg_name(root, "cg_dst");

tools/testing/selftests/cgroup/test_core.c

584

if (!src || !dst)

tools/testing/selftests/cgroup/test_core.c

589

if (cg_create(dst))

tools/testing/selftests/cgroup/test_core.c

600

cg_enter_current(dst);

tools/testing/selftests/cgroup/test_core.c

601

if (cg_read_lc(dst, CG_THREADS_FILE) != n_threads + 1)

tools/testing/selftests/cgroup/test_core.c

617

if (dst)

tools/testing/selftests/cgroup/test_core.c

618

cg_destroy(dst);

tools/testing/selftests/cgroup/test_core.c

621

free(dst);

tools/testing/selftests/drivers/net/hw/ncdevmem.c

119

void (*memcpy_to_device)(struct memory_buffer *dst, size_t off,

tools/testing/selftests/drivers/net/hw/ncdevmem.c

121

void (*memcpy_from_device)(void *dst, struct memory_buffer *src,

tools/testing/selftests/drivers/net/hw/ncdevmem.c

216

static void udmabuf_memcpy_to_device(struct memory_buffer *dst, size_t off,

tools/testing/selftests/drivers/net/hw/ncdevmem.c

222

ioctl(dst->fd, DMA_BUF_IOCTL_SYNC, &sync);

tools/testing/selftests/drivers/net/hw/ncdevmem.c

224

memcpy(dst->buf_mem + off, src, n);

tools/testing/selftests/drivers/net/hw/ncdevmem.c

227

ioctl(dst->fd, DMA_BUF_IOCTL_SYNC, &sync);

tools/testing/selftests/drivers/net/hw/ncdevmem.c

230

static void udmabuf_memcpy_from_device(void *dst, struct memory_buffer *src,

tools/testing/selftests/drivers/net/hw/ncdevmem.c

238

memcpy(dst, src->buf_mem + off, n);

tools/testing/selftests/kvm/arm64/page_fault_test.c

325

copy.dst = addr;

tools/testing/selftests/kvm/demand_paging_test.c

72

copy.dst = addr;

tools/testing/selftests/kvm/lib/arm64/gic_v3_its.c

178

struct its_cmd_block *dst = cmdq_base + cwriter;

tools/testing/selftests/kvm/lib/arm64/gic_v3_its.c

188

WRITE_ONCE(*dst, *cmd);

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

195

static int __sev_mirror_create(struct kvm_vm *dst, struct kvm_vm *src)

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

197

return __vm_enable_cap(dst, KVM_CAP_VM_COPY_ENC_CONTEXT_FROM, src->fd);

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

201

static void sev_mirror_create(struct kvm_vm *dst, struct kvm_vm *src)

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

205

ret = __sev_mirror_create(dst, src);

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

59

static int __sev_migrate_from(struct kvm_vm *dst, struct kvm_vm *src)

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

61

return __vm_enable_cap(dst, KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM, src->fd);

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

65

static void sev_migrate_from(struct kvm_vm *dst, struct kvm_vm *src)

tools/testing/selftests/kvm/x86/sev_migrate_tests.c

69

ret = __sev_migrate_from(dst, src);

tools/testing/selftests/landlock/audit.h

210

static __maybe_unused char *regex_escape(const char *const src, char *dst,

tools/testing/selftests/landlock/audit.h

213

char *d = dst;

tools/testing/selftests/landlock/audit.h

224

if (d >= dst + dst_size - 2)

tools/testing/selftests/landlock/audit.h

231

if (d >= dst + dst_size - 1)

tools/testing/selftests/landlock/audit.h

237

if (d >= dst + dst_size - 1)

tools/testing/selftests/mm/mkdirty.c

274

char *dst, *src;

tools/testing/selftests/mm/mkdirty.c

281

dst = mmap(NULL, pagesize, PROT_READ, MAP_PRIVATE|MAP_ANON, -1, 0);

tools/testing/selftests/mm/mkdirty.c

282

if (dst == MAP_FAILED) {

tools/testing/selftests/mm/mkdirty.c

301

uffdio_register.range.start = (unsigned long) dst;

tools/testing/selftests/mm/mkdirty.c

310

uffdio_copy.dst = (unsigned long) dst;

tools/testing/selftests/mm/mkdirty.c

319

do_test_write_sigsegv(dst);

tools/testing/selftests/mm/mkdirty.c

323

munmap(dst, pagesize);

tools/testing/selftests/mm/uffd-common.c

601

&uffdio_copy->dst,

tools/testing/selftests/mm/uffd-common.c

633

uffdio_copy.dst = (unsigned long) gopts->area_dst + offset;

tools/testing/selftests/mm/uffd-common.c

646

wake_range(gopts->uffd, uffdio_copy.dst, gopts->page_size);

tools/testing/selftests/mm/uffd-common.c

670

uffdio_move.dst = (unsigned long) gopts->area_dst + offset;

tools/testing/selftests/mm/uffd-common.c

680

wake_range(gopts->uffd, uffdio_move.dst, len);

tools/testing/selftests/net/ioam6_parser.c

1009

struct in6_addr src, dst;

tools/testing/selftests/net/ioam6_parser.c

1023

inet_pton(AF_INET6, argv[4], &dst) != 1 ||

tools/testing/selftests/net/ioam6_parser.c

1062

!ipv6_addr_equal(&ipv6->daddr, &dst) ||

tools/testing/selftests/net/ipsec.c

1012

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

1068

if (xfrm_usersa_found(&answer.info, spi, src, dst, desc))

tools/testing/selftests/net/ipsec.c

1075

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

1081

err = xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc);

tools/testing/selftests/net/ipsec.c

1087

err = xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), dst, src, desc);

tools/testing/selftests/net/ipsec.c

1094

err = xfrm_state_check(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc);

tools/testing/selftests/net/ipsec.c

1095

err |= xfrm_state_check(xfrm_sock, (*seq)++, gen_spi(src), dst, src, desc);

tools/testing/selftests/net/ipsec.c

1105

struct in_addr src, struct in_addr dst, uint8_t dir,

tools/testing/selftests/net/ipsec.c

1123

memcpy(&req.info.sel.daddr, &dst, sizeof(tundst));

tools/testing/selftests/net/ipsec.c

1138

memcpy(&tmpl.id.daddr, &dst, sizeof(dst));

tools/testing/selftests/net/ipsec.c

1161

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

1164

if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst,

tools/testing/selftests/net/ipsec.c

1170

if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), dst, src,

tools/testing/selftests/net/ipsec.c

1180

struct in_addr src, struct in_addr dst, uint8_t dir,

tools/testing/selftests/net/ipsec.c

1196

memcpy(&req.id.sel.daddr, &dst, sizeof(tundst));

tools/testing/selftests/net/ipsec.c

1212

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

1215

if (xfrm_policy_del(xfrm_sock, (*seq)++, src, dst,

tools/testing/selftests/net/ipsec.c

1221

if (xfrm_policy_del(xfrm_sock, (*seq)++, dst, src,

tools/testing/selftests/net/ipsec.c

1231

struct in_addr src, struct in_addr dst, uint8_t proto)

tools/testing/selftests/net/ipsec.c

1246

memcpy(&req.id.daddr, &dst, sizeof(dst));

tools/testing/selftests/net/ipsec.c

1265

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

1268

if (xfrm_state_del(xfrm_sock, (*seq)++, gen_spi(src), src, dst, proto)) {

tools/testing/selftests/net/ipsec.c

1273

if (xfrm_state_del(xfrm_sock, (*seq)++, gen_spi(src), dst, src, proto)) {

tools/testing/selftests/net/ipsec.c

1452

struct in_addr src, dst;

tools/testing/selftests/net/ipsec.c

1457

dst = inet_makeaddr(INADDR_B, grchild_ip(nr));

tools/testing/selftests/net/ipsec.c

1459

if (xfrm_state_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst, desc)) {

tools/testing/selftests/net/ipsec.c

1473

memcpy(&req.expire.state.id.daddr, &dst, sizeof(dst));

tools/testing/selftests/net/ipsec.c

1524

struct in_addr src, dst, tunsrc, tundst;

tools/testing/selftests/net/ipsec.c

1529

dst = inet_makeaddr(INADDR_B, grchild_ip(nr));

tools/testing/selftests/net/ipsec.c

1533

if (xfrm_policy_add(xfrm_sock, (*seq)++, gen_spi(src), src, dst,

tools/testing/selftests/net/ipsec.c

1549

memcpy(&req.expire.pol.sel.daddr, &dst, sizeof(tundst));

tools/testing/selftests/net/ipsec.c

1744

struct in_addr src, dst, tunsrc, tundst;

tools/testing/selftests/net/ipsec.c

1749

dst = inet_makeaddr(INADDR_B, grchild_ip(nr));

tools/testing/selftests/net/ipsec.c

1764

if (xfrm_prepare(xfrm_sock, seq, src, dst, tunsrc, tundst, desc->proto)) {

tools/testing/selftests/net/ipsec.c

1773

if (xfrm_set(xfrm_sock, seq, src, dst, tunsrc, tundst, desc)) {

tools/testing/selftests/net/ipsec.c

1793

if (xfrm_delete(xfrm_sock, seq, src, dst, tunsrc, tundst, desc->proto)) {

tools/testing/selftests/net/ipsec.c

1803

if (xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst)) {

tools/testing/selftests/net/ipsec.c

1885

struct in_addr src, dst, tunsrc, tundst;

tools/testing/selftests/net/ipsec.c

1890

dst = inet_makeaddr(INADDR_B, child_ip(nr));

tools/testing/selftests/net/ipsec.c

1901

tun_reply = memcmp(&dst, &msg->body.ping.reply_ip, sizeof(in_addr_t));

tools/testing/selftests/net/ipsec.c

1910

if (xfrm_prepare(xfrm_sock, seq, src, dst, tunsrc, tundst,

tools/testing/selftests/net/ipsec.c

1912

xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);

tools/testing/selftests/net/ipsec.c

1917

if (xfrm_set(xfrm_sock, seq, src, dst, tunsrc, tundst, desc)) {

tools/testing/selftests/net/ipsec.c

1918

xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);

tools/testing/selftests/net/ipsec.c

1923

if (xfrm_delete(xfrm_sock, seq, src, dst, tunsrc, tundst,

tools/testing/selftests/net/ipsec.c

1925

xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst);

tools/testing/selftests/net/ipsec.c

1930

if (xfrm_cleanup(xfrm_sock, seq, src, dst, tunsrc, tundst)) {

tools/testing/selftests/net/ipsec.c

431

struct in_addr src, struct in_addr dst)

tools/testing/selftests/net/ipsec.c

452

if (rtattr_pack(&req.nh, sizeof(req), RTA_DST, &dst, sizeof(dst)))

tools/testing/selftests/net/ipsec.c

486

static int init_child(int nsfd, char *veth, unsigned int src, unsigned int dst)

tools/testing/selftests/net/ipsec.c

490

struct in_addr tundst = inet_makeaddr(INADDR_A, dst);

tools/testing/selftests/net/ipsec.c

923

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

939

memcpy(&req.info.sel.daddr, &dst, sizeof(dst));

tools/testing/selftests/net/ipsec.c

946

memcpy(&req.info.id.daddr, &dst, sizeof(dst));

tools/testing/selftests/net/ipsec.c

974

struct in_addr src, struct in_addr dst,

tools/testing/selftests/net/ipsec.c

977

if (memcmp(&info->sel.daddr, &dst, sizeof(dst)))

tools/testing/selftests/net/ipsec.c

991

if (memcmp(&info->id.daddr, &dst, sizeof(dst)))

tools/testing/selftests/net/netfilter/connect_close.c

101

do_connect(&dst);

tools/testing/selftests/net/netfilter/connect_close.c

40

static void do_connect(const struct sockaddr_in *dst)

tools/testing/selftests/net/netfilter/connect_close.c

47

connect(s, (struct sockaddr *)dst, sizeof(*dst));

tools/testing/selftests/net/netfilter/connect_close.c

91

struct sockaddr_in dst = {

tools/testing/selftests/net/netfilter/connect_close.c

96

inet_pton(AF_INET, "127.0.0.1", &dst.sin_addr);

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

317

struct in6_addr src, dst;

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

356

dst = (struct in6_addr) {{

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

364

ret = conntrack_data_generate_v6(self->sock, src, dst,

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

375

dst = (struct in6_addr) {{

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

383

ret = conntrack_data_generate_v6(self->sock, src, dst,

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

394

dst = (struct in6_addr) {{

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

402

ret = conntrack_data_generate_v6(self->sock, src, dst,

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

414

dst = (struct in6_addr) {{

tools/testing/selftests/net/netfilter/conntrack_dump_flush.c

422

ret = conntrack_data_generate_v6(self->sock, src, dst,

tools/testing/selftests/net/rxtimestamp.c

304

int src, dst, rcv, port;

tools/testing/selftests/net/rxtimestamp.c

329

dst = socket(addr.addr_un.sa_family, s->type,

tools/testing/selftests/net/rxtimestamp.c

331

if (dst < 0)

tools/testing/selftests/net/rxtimestamp.c

334

if (bind(dst, &addr.addr_un, addr_size) < 0)

tools/testing/selftests/net/rxtimestamp.c

337

if (s->type == SOCK_STREAM && (listen(dst, 1) < 0))

tools/testing/selftests/net/rxtimestamp.c

344

rcv = accept(dst, NULL, NULL);

tools/testing/selftests/net/rxtimestamp.c

347

close(dst);

tools/testing/selftests/net/rxtimestamp.c

349

rcv = dst;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

166

struct sockaddr_in *src, struct sockaddr_in *dst)

tools/testing/selftests/net/tcp_ao/icmps-accept.c

175

iph->daddr = dst->sin_addr.s_addr;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

180

struct sockaddr_in *src, struct sockaddr_in *dst)

tools/testing/selftests/net/tcp_ao/icmps-accept.c

200

set_ip4hdr(&packet.iph, packet_len, IPPROTO_ICMP, src, dst);

tools/testing/selftests/net/tcp_ao/icmps-accept.c

210

set_ip4hdr(&packet.iphe, packet_len, IPPROTO_TCP, dst, src);

tools/testing/selftests/net/tcp_ao/icmps-accept.c

212

packet.tcph.sport = dst->sin_port;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

221

(struct sockaddr *)dst, sizeof(*dst));

tools/testing/selftests/net/tcp_ao/icmps-accept.c

230

struct sockaddr_in6 *src, struct sockaddr_in6 *dst)

tools/testing/selftests/net/tcp_ao/icmps-accept.c

237

iph->daddr = dst->sin6_addr;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

270

struct sockaddr_in6 *dst,

tools/testing/selftests/net/tcp_ao/icmps-accept.c

283

pseudo_header.daddr = dst->sin6_addr;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

294

struct sockaddr_in6 *src, struct sockaddr_in6 *dst)

tools/testing/selftests/net/tcp_ao/icmps-accept.c

297

struct sockaddr_in6 dst_raw = *dst;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

316

set_ip6hdr(&packet.iph, packet_len, IPPROTO_ICMPV6, src, dst);

tools/testing/selftests/net/tcp_ao/icmps-accept.c

322

set_ip6hdr(&packet.iphe, packet_len, IPPROTO_TCP, dst, src);

tools/testing/selftests/net/tcp_ao/icmps-accept.c

324

packet.tcph.sport = dst->sin6_port;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

330

packet.icmph.icmp6_cksum = icmp6_checksum(src, dst,

tools/testing/selftests/net/tcp_ao/icmps-accept.c

362

static void icmp_interfere(const size_t nr, uint32_t rcv_nxt, void *src, void *dst)

tools/testing/selftests/net/tcp_ao/icmps-accept.c

365

struct sockaddr_in *daddr4 = dst;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

367

struct sockaddr_in6 *daddr6 = dst;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

398

struct sockaddr_in6 src, dst;

tools/testing/selftests/net/tcp_ao/icmps-accept.c

404

addr_sz = sizeof(dst);

tools/testing/selftests/net/tcp_ao/icmps-accept.c

405

if (getpeername(sk, &dst, &addr_sz))

tools/testing/selftests/net/tcp_ao/icmps-accept.c

417

icmp_interfere(packets_nr, rcv_nxt, (void *)&src, (void *)&dst);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

166

struct sockaddr_in *src, struct sockaddr_in *dst)

tools/testing/selftests/net/tcp_ao/icmps-discard.c

175

iph->daddr = dst->sin_addr.s_addr;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

180

struct sockaddr_in *src, struct sockaddr_in *dst)

tools/testing/selftests/net/tcp_ao/icmps-discard.c

200

set_ip4hdr(&packet.iph, packet_len, IPPROTO_ICMP, src, dst);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

210

set_ip4hdr(&packet.iphe, packet_len, IPPROTO_TCP, dst, src);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

212

packet.tcph.sport = dst->sin_port;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

221

(struct sockaddr *)dst, sizeof(*dst));

tools/testing/selftests/net/tcp_ao/icmps-discard.c

230

struct sockaddr_in6 *src, struct sockaddr_in6 *dst)

tools/testing/selftests/net/tcp_ao/icmps-discard.c

237

iph->daddr = dst->sin6_addr;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

270

struct sockaddr_in6 *dst,

tools/testing/selftests/net/tcp_ao/icmps-discard.c

283

pseudo_header.daddr = dst->sin6_addr;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

294

struct sockaddr_in6 *src, struct sockaddr_in6 *dst)

tools/testing/selftests/net/tcp_ao/icmps-discard.c

297

struct sockaddr_in6 dst_raw = *dst;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

316

set_ip6hdr(&packet.iph, packet_len, IPPROTO_ICMPV6, src, dst);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

322

set_ip6hdr(&packet.iphe, packet_len, IPPROTO_TCP, dst, src);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

324

packet.tcph.sport = dst->sin6_port;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

330

packet.icmph.icmp6_cksum = icmp6_checksum(src, dst,

tools/testing/selftests/net/tcp_ao/icmps-discard.c

362

static void icmp_interfere(const size_t nr, uint32_t rcv_nxt, void *src, void *dst)

tools/testing/selftests/net/tcp_ao/icmps-discard.c

365

struct sockaddr_in *daddr4 = dst;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

367

struct sockaddr_in6 *daddr6 = dst;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

398

struct sockaddr_in6 src, dst;

tools/testing/selftests/net/tcp_ao/icmps-discard.c

404

addr_sz = sizeof(dst);

tools/testing/selftests/net/tcp_ao/icmps-discard.c

405

if (getpeername(sk, &dst, &addr_sz))

tools/testing/selftests/net/tcp_ao/icmps-discard.c

417

icmp_interfere(packets_nr, rcv_nxt, (void *)&src, (void *)&dst);

tools/testing/selftests/net/tcp_ao/lib/aolib.h

283

union tcp_addr src, union tcp_addr dst);

tools/testing/selftests/net/tcp_ao/lib/aolib.h

285

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

765

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

771

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

777

err = __trace_event_expect(type, TEST_FAMILY, src, dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

786

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

793

err = __trace_event_expect(type, TEST_FAMILY, src, dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

802

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

808

err = __trace_event_expect(type, TEST_FAMILY, src, dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

817

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/aolib.h

822

err = __trace_event_expect(type, TEST_FAMILY, src, dst,

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

121

union tcp_addr dst;

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

157

if (memcmp(&p->dst, &e->dst, sk_size))

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

267

union tcp_addr *dst, unsigned int *port)

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

276

if (inet_pton(family, addr, dst) != 1) {

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

292

char *src = NULL, *dst = NULL, *family = NULL;

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

305

&src, &dst, &out->L3index,

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

31

union tcp_addr dst;

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

319

&src, &dst, &out->L3index,

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

330

&src, &dst, &out->keyid, &out->rnext);

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

340

&src, &dst, &out->sne);

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

386

if (dst && tracer_scan_address(out->family, dst, &out->dst, &out->dst_port)) {

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

399

free(dst);

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

421

char src[INET6_ADDRSTRLEN], dst[INET6_ADDRSTRLEN];

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

425

if (!inet_ntop(e->family, &e->dst, dst, INET6_ADDRSTRLEN))

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

429

src, e->src_port, dst, e->dst_port, e->L3index,

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

58

union tcp_addr src, union tcp_addr dst,

tools/testing/selftests/net/tcp_ao/lib/ftrace-tcp.c

67

.dst = dst,

tools/testing/selftests/net/tcp_ao/lib/netlink.c

246

union tcp_addr src, union tcp_addr dst, uint8_t vrf)

tools/testing/selftests/net/tcp_ao/lib/netlink.c

269

if (rtattr_pack(&req.nh, sizeof(req), RTA_DST, &dst, addr_len))

tools/testing/selftests/net/tcp_ao/lib/netlink.c

287

union tcp_addr src, union tcp_addr dst, uint8_t vrf)

tools/testing/selftests/net/tcp_ao/lib/netlink.c

296

family, src, dst, vrf);

tools/testing/selftests/net/tcp_ao/lib/netlink.c

303

union tcp_addr src, union tcp_addr dst)

tools/testing/selftests/net/tcp_ao/lib/netlink.c

305

return ip_route_add_vrf(intf, family, src, dst, RT_TABLE_MAIN);

tools/testing/selftests/net/tun.c

696

struct sockaddr_storage *dst)

tools/testing/selftests/net/tun.c

699

dst->ss_family = family;

tools/testing/selftests/net/tun.c

703

struct sockaddr_in *d4 = (struct sockaddr_in *)dst;

tools/testing/selftests/net/tun.c

715

struct sockaddr_in6 *d6 = (struct sockaddr_in6 *)dst;

tools/testing/selftests/net/tuntap_helpers.h

122

ip_route_get(const char *dev, int family, int table, void *dst,

tools/testing/selftests/net/tuntap_helpers.h

141

rt_route_getroute_req_set_dst(req, dst, ipalen);

tools/testing/selftests/net/tuntap_helpers.h

261

struct in_addr *dst)

tools/testing/selftests/net/tuntap_helpers.h

272

iph->daddr = dst->s_addr;

tools/testing/selftests/net/tuntap_helpers.h

290

struct in6_addr *src, struct in6_addr *dst)

tools/testing/selftests/net/tuntap_helpers.h

300

memcpy(&ip6h->daddr, dst, sizeof(ip6h->daddr));

tools/testing/selftests/powerpc/alignment/alignment_handler.c

146

void preload_data(void *dst, int offset, int width)

tools/testing/selftests/powerpc/alignment/alignment_handler.c

148

char *c = dst;

tools/testing/selftests/powerpc/alignment/alignment_handler.c

157

int test_memcpy(void *dst, void *src, int size, int offset,

tools/testing/selftests/powerpc/alignment/alignment_handler.c

164

d = dst;

tools/testing/selftests/powerpc/copyloops/exc_validate.c

106

for (dst = 0; dst < MAX_LEN; dst++) {

tools/testing/selftests/powerpc/copyloops/exc_validate.c

109

do_one_test(q+dst, q+src, len);

tools/testing/selftests/powerpc/copyloops/exc_validate.c

83

unsigned long src, dst, len;

tools/testing/selftests/powerpc/copyloops/validate.c

21

static void do_one(char *src, char *dst, unsigned long src_off,

tools/testing/selftests/powerpc/copyloops/validate.c

30

dstp = dst + MIN_REDZONE + dst_off;

tools/testing/selftests/powerpc/copyloops/validate.c

33

memset(dst, POISON, BUFLEN);

tools/testing/selftests/powerpc/copyloops/validate.c

54

if (memcmp(dst, redzone, dstp - dst)) {

tools/testing/selftests/powerpc/copyloops/validate.c

60

if (memcmp(dstp+len, redzone, dst+BUFLEN-(dstp+len))) {

tools/testing/selftests/powerpc/copyloops/validate.c

69

char *src, *dst, *redzone, *fill;

tools/testing/selftests/powerpc/copyloops/validate.c

74

dst = memalign(BUFLEN, BUFLEN);

tools/testing/selftests/powerpc/copyloops/validate.c

78

if (!src || !dst || !redzone || !fill) {

tools/testing/selftests/powerpc/copyloops/validate.c

96

do_one(src, dst, src_off, dst_off, len,

tools/testing/selftests/powerpc/nx-gzip/gunz_test.c

245

static int nx_submit_job(struct nx_dde_t *src, struct nx_dde_t *dst,

tools/testing/selftests/powerpc/nx-gzip/gunz_test.c

253

cmdp->crb.target_dde = *dst;

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

117

put64(cmdp->crb.target_dde, ddead, (uint64_t) dst);

tools/testing/selftests/powerpc/nx-gzip/gzfht_test.c

79

static int compress_fht_sample(char *src, uint32_t srclen, char *dst,

tools/testing/selftests/powerpc/tm/tm-signal-pagefault.c

122

uffdio_copy.dst = msg.arg.pagefault.address & ~(pagesize-1);

tools/testing/selftests/powerpc/tm/tm-signal-pagefault.c

124

offset = (char *) uffdio_copy.dst - uf_mem;

tools/testing/selftests/rseq/rseq-arm-bits.h

378

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-arm-bits.h

469

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-arm64-bits.h

323

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-arm64-bits.h

344

RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len)

tools/testing/selftests/rseq/rseq-arm64-bits.h

360

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-arm64.h

194

#define RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len) \

tools/testing/selftests/rseq/rseq-arm64.h

200

" strb " RSEQ_ASM_TMP_REG32 ", [%[" __rseq_str(dst) "]" \

tools/testing/selftests/rseq/rseq-mips-bits.h

343

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-mips-bits.h

431

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-or1k-bits.h

347

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-or1k-bits.h

366

RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len)

tools/testing/selftests/rseq/rseq-or1k-bits.h

382

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-or1k.h

126

#define RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len) \

tools/testing/selftests/rseq/rseq-or1k.h

132

"l.ori " RSEQ_ASM_TMP_REG_3 ", %[" __rseq_str(dst) "], 0\n" \

tools/testing/selftests/rseq/rseq-ppc-bits.h

370

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-ppc-bits.h

421

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-riscv-bits.h

345

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-riscv-bits.h

364

RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len)

tools/testing/selftests/rseq/rseq-riscv-bits.h

380

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-riscv.h

146

#define RSEQ_ASM_OP_R_BAD_MEMCPY(dst, src, len) \

tools/testing/selftests/rseq/rseq-riscv.h

150

"mv " RSEQ_ASM_TMP_REG_3 ", %[" __rseq_str(dst) "]\n" \

tools/testing/selftests/rseq/rseq-s390-bits.h

358

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-s390-bits.h

438

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-x86-bits.h

408

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-x86-bits.h

487

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq-x86-bits.h

871

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq-x86-bits.h

956

[dst] "r" (dst),

tools/testing/selftests/rseq/rseq.h

367

void *dst, void *src, size_t len,

tools/testing/selftests/rseq/rseq.h

374

return rseq_cmpeqv_trymemcpy_storev_relaxed_cpu_id(v, expect, dst, src, len, newv, cpu);

tools/testing/selftests/rseq/rseq.h

376

return rseq_cmpeqv_trymemcpy_storev_relaxed_mm_cid(v, expect, dst, src, len, newv, cpu);

tools/testing/selftests/rseq/rseq.h

382

return rseq_cmpeqv_trymemcpy_storev_release_cpu_id(v, expect, dst, src, len, newv, cpu);

tools/testing/selftests/rseq/rseq.h

384

return rseq_cmpeqv_trymemcpy_storev_release_mm_cid(v, expect, dst, src, len, newv, cpu);

tools/testing/selftests/timers/set-tz.c

104

set_tz(min, dst);

tools/testing/selftests/timers/set-tz.c

108

set_tz(min, dst);

tools/testing/selftests/timers/set-tz.c

28

int set_tz(int min, int dst)

tools/testing/selftests/timers/set-tz.c

33

tz.tz_dsttime = dst;

tools/testing/selftests/timers/set-tz.c

61

int min, dst;

tools/testing/selftests/timers/set-tz.c

64

dst = get_tz_dst();

tools/testing/selftests/timers/set-tz.c

65

printf("tz_minuteswest started at %i, dst at %i\n", min, dst);

tools/testing/selftests/timers/set-tz.c

70

ret = set_tz(i, dst);

tools/testing/selftests/timers/set-tz.c

82

if (!set_tz(-15*60-1, dst)) {

tools/testing/selftests/timers/set-tz.c

87

if (!set_tz(15*60+1, dst)) {

tools/testing/selftests/timers/set-tz.c

92

if (!set_tz(-24*60, dst)) {

tools/testing/selftests/timers/set-tz.c

97

if (!set_tz(24*60, dst)) {

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

265

iova_t src, iova_t dst, u64 size,

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

281

.dst_addr = dst,

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

311

iova_t src, iova_t dst, u64 size, bool interrupt)

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

317

dsa_copy_desc_init(device, &dsa->copy[0], src, dst, size, interrupt);

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

322

iova_t src, iova_t dst, u64 size, u64 count)

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

332

dsa_copy_desc_init(device, copy_desc, src, dst, size, false);

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

368

iova_t src, iova_t dst, u64 size, u64 count)

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

374

dsa_memcpy_one(device, src, dst, size, false);

tools/testing/selftests/vfio/lib/drivers/dsa/dsa.c

376

dsa_memcpy_batch(device, src, dst, size, count);

tools/testing/selftests/vfio/lib/drivers/ioat/ioat.c

179

iova_t src, iova_t dst, u64 size,

tools/testing/selftests/vfio/lib/drivers/ioat/ioat.c

192

.dst_addr = dst,

tools/testing/selftests/vfio/lib/drivers/ioat/ioat.c

209

iova_t src, iova_t dst, u64 size,

tools/testing/selftests/vfio/lib/drivers/ioat/ioat.c

212

__ioat_memcpy_start(device, src, dst, size, count, false);

tools/testing/selftests/vfio/lib/include/libvfio/vfio_pci_driver.h

44

iova_t src, iova_t dst, u64 size, u64 count);

tools/testing/selftests/vfio/lib/include/libvfio/vfio_pci_driver.h

90

iova_t src, iova_t dst, u64 size);

tools/testing/selftests/vfio/lib/include/libvfio/vfio_pci_driver.h

92

iova_t src, iova_t dst, u64 size,

tools/testing/selftests/vfio/lib/vfio_pci_driver.c

107

iova_t src, iova_t dst, u64 size)

tools/testing/selftests/vfio/lib/vfio_pci_driver.c

109

vfio_pci_driver_memcpy_start(device, src, dst, size, 1);

tools/testing/selftests/vfio/lib/vfio_pci_driver.c

80

iova_t src, iova_t dst, u64 size,

tools/testing/selftests/vfio/lib/vfio_pci_driver.c

89

driver->ops->memcpy_start(device, src, dst, size, count);

tools/testing/selftests/vfio/vfio_pci_driver_test.c

100

self->dst = self->src + self->size;

tools/testing/selftests/vfio/vfio_pci_driver_test.c

103

self->dst_iova = to_iova(self->device, self->dst);

tools/testing/selftests/vfio/vfio_pci_driver_test.c

135

memset(self->dst, 'y', self->size);

tools/testing/selftests/vfio/vfio_pci_driver_test.c

142

ASSERT_EQ(0, memcmp(self->src, self->dst, self->size));

tools/testing/selftests/vfio/vfio_pci_driver_test.c

190

memset(self->dst, 'y', self->size);

tools/testing/selftests/vfio/vfio_pci_driver_test.c

197

ASSERT_EQ(0, memcmp(self->src, self->dst, self->size));

tools/testing/selftests/vfio/vfio_pci_driver_test.c

55

void *dst;

tools/testing/selftests/x86/test_shadow_stack.c

471

req.dst = msg.arg.pagefault.address;

tools/testing/vma/include/custom.h

66

static inline int anon_vma_clone(struct vm_area_struct *dst, struct vm_area_struct *src,

tools/testing/vma/include/custom.h

71

dst->anon_vma = src->anon_vma;

tools/testing/vma/include/custom.h

72

dst->anon_vma->was_cloned = true;

tools/testing/vma/include/stubs.h

416

static inline int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)

virt/kvm/guest_memfd.c

491

struct folio *dst, struct folio *src,