arch/s390/boot/physmem_info.c

347

range->chain = new_range;

arch/s390/boot/physmem_info.c

383

(unsigned long)range->chain);

arch/s390/include/asm/physmem_info.h

140

range && range->end; range = range->chain ? __va(range->chain) : NULL, \

arch/s390/include/asm/physmem_info.h

151

if (range->chain)

arch/s390/include/asm/physmem_info.h

152

return __va(range->chain);

arch/s390/include/asm/physmem_info.h

37

struct reserved_range *chain;

crypto/acompress.c

167

struct acomp_req_chain *state = &req->chain;

crypto/acompress.c

185

struct acomp_req_chain *state = &req->chain;

crypto/acompress.c

197

struct acomp_req_chain *state = &req->chain;

crypto/acompress.c

257

compl = req->chain.compl;

crypto/acompress.c

258

data = req->chain.data;

crypto/acompress.c

573

if (req->src == &req->chain.ssg)

crypto/acompress.c

574

nreq->src = &nreq->chain.ssg;

crypto/acompress.c

575

if (req->dst == &req->chain.dsg)

crypto/acompress.c

576

nreq->dst = &nreq->chain.dsg;

drivers/accel/amdxdna/aie2_ctx.c

1030

drm_syncobj_add_point(hwctx->priv->syncobj, chain, job->out_fence, *seq);

drivers/accel/amdxdna/aie2_ctx.c

1044

dma_fence_chain_free(chain);

drivers/accel/amdxdna/aie2_ctx.c

958

struct dma_fence_chain *chain;

drivers/accel/amdxdna/aie2_ctx.c

969

chain = dma_fence_chain_alloc();

drivers/accel/amdxdna/aie2_ctx.c

970

if (!chain) {

drivers/bus/mhi/common.h

188

#define MHI_TRE_DATA_DWORD1(bei, ieot, ieob, chain) cpu_to_le32(FIELD_PREP(GENMASK(23, 16), \

drivers/bus/mhi/common.h

193

FIELD_PREP(BIT(0), chain))

drivers/bus/mhi/host/main.c

1179

int eot, eob, chain, bei;

drivers/bus/mhi/host/main.c

1213

chain = !!(flags & MHI_CHAIN);

drivers/bus/mhi/host/main.c

1219

mhi_tre->dword[1] = MHI_TRE_DATA_DWORD1(bei, eot, eob, chain);

drivers/crypto/intel/keembay/ocs-hcu.c

248

u32 *chain;

drivers/crypto/intel/keembay/ocs-hcu.c

256

chain = (u32 *)data->digest;

drivers/crypto/intel/keembay/ocs-hcu.c

270

chain[i] = readl(hcu_dev->io_base + OCS_HCU_CHAIN);

drivers/crypto/intel/keembay/ocs-hcu.c

291

u32 *chain = (u32 *)data->digest;

drivers/crypto/intel/keembay/ocs-hcu.c

301

writel(chain[i], hcu_dev->io_base + OCS_HCU_CHAIN);

drivers/crypto/intel/keembay/ocs-hcu.c

310

u32 *chain;

drivers/crypto/intel/keembay/ocs-hcu.c

326

chain = (u32 *)dgst;

drivers/crypto/intel/keembay/ocs-hcu.c

328

chain[i] = readl(hcu_dev->io_base + OCS_HCU_CHAIN);

drivers/crypto/marvell/cesa/cesa.h

540

struct mv_cesa_tdma_chain chain;

drivers/crypto/marvell/cesa/cesa.h

658

return req->chain.first ? CESA_DMA_REQ : CESA_STD_REQ;

drivers/crypto/marvell/cesa/cesa.h

816

bool mv_cesa_req_dma_iter_next_transfer(struct mv_cesa_dma_iter *chain,

drivers/crypto/marvell/cesa/cesa.h

852

mv_cesa_tdma_desc_iter_init(struct mv_cesa_tdma_chain *chain)

drivers/crypto/marvell/cesa/cesa.h

854

memset(chain, 0, sizeof(*chain));

drivers/crypto/marvell/cesa/cesa.h

857

int mv_cesa_dma_add_result_op(struct mv_cesa_tdma_chain *chain, dma_addr_t src,

drivers/crypto/marvell/cesa/cesa.h

860

struct mv_cesa_op_ctx *mv_cesa_dma_add_op(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/cesa.h

865

int mv_cesa_dma_add_data_transfer(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/cesa.h

869

int mv_cesa_dma_add_dummy_launch(struct mv_cesa_tdma_chain *chain, gfp_t flags);

drivers/crypto/marvell/cesa/cesa.h

870

int mv_cesa_dma_add_dummy_end(struct mv_cesa_tdma_chain *chain, gfp_t flags);

drivers/crypto/marvell/cesa/cesa.h

872

int mv_cesa_dma_add_op_transfers(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/cipher.c

224

memcpy(skreq->iv, basereq->chain.last->op->ctx.skcipher.iv,

drivers/crypto/marvell/cesa/cipher.c

325

basereq->chain.first = NULL;

drivers/crypto/marvell/cesa/cipher.c

326

basereq->chain.last = NULL;

drivers/crypto/marvell/cesa/cipher.c

347

mv_cesa_tdma_desc_iter_init(&basereq->chain);

drivers/crypto/marvell/cesa/cipher.c

353

op = mv_cesa_dma_add_op(&basereq->chain, op_templ, skip_ctx,

drivers/crypto/marvell/cesa/cipher.c

364

ret = mv_cesa_dma_add_op_transfers(&basereq->chain, &iter.base,

drivers/crypto/marvell/cesa/cipher.c

370

ret = mv_cesa_dma_add_dummy_launch(&basereq->chain, flags);

drivers/crypto/marvell/cesa/cipher.c

375

ret = mv_cesa_dma_add_op_transfers(&basereq->chain, &iter.base,

drivers/crypto/marvell/cesa/cipher.c

383

ret = mv_cesa_dma_add_result_op(&basereq->chain,

drivers/crypto/marvell/cesa/cipher.c

391

basereq->chain.last->flags |= CESA_TDMA_END_OF_REQ;

drivers/crypto/marvell/cesa/cipher.c

418

basereq->chain.first = NULL;

drivers/crypto/marvell/cesa/cipher.c

419

basereq->chain.last = NULL;

drivers/crypto/marvell/cesa/hash.c

320

if (base->chain.first->flags & CESA_TDMA_SET_STATE) {

drivers/crypto/marvell/cesa/hash.c

366

(creq->base.chain.last->flags & CESA_TDMA_TYPE_MSK) ==

drivers/crypto/marvell/cesa/hash.c

374

data = creq->base.chain.last->op->ctx.hash.hash;

drivers/crypto/marvell/cesa/hash.c

490

mv_cesa_dma_add_frag(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/hash.c

497

op = mv_cesa_dma_add_op(chain, tmpl, false, flags);

drivers/crypto/marvell/cesa/hash.c

505

ret = mv_cesa_dma_add_dummy_launch(chain, flags);

drivers/crypto/marvell/cesa/hash.c

518

mv_cesa_ahash_dma_add_cache(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/hash.c

534

return mv_cesa_dma_add_data_transfer(chain,

drivers/crypto/marvell/cesa/hash.c

543

mv_cesa_ahash_dma_last_req(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/hash.c

558

op = mv_cesa_dma_add_frag(chain, &creq->op_tmpl, frag_len,

drivers/crypto/marvell/cesa/hash.c

569

ret = mv_cesa_dma_add_result_op(chain,

drivers/crypto/marvell/cesa/hash.c

591

ret = mv_cesa_dma_add_data_transfer(chain,

drivers/crypto/marvell/cesa/hash.c

600

op = mv_cesa_dma_add_frag(chain, &creq->op_tmpl, frag_len + len,

drivers/crypto/marvell/cesa/hash.c

611

ret = mv_cesa_dma_add_data_transfer(chain,

drivers/crypto/marvell/cesa/hash.c

621

return mv_cesa_dma_add_frag(chain, &creq->op_tmpl, trailerlen - padoff,

drivers/crypto/marvell/cesa/hash.c

638

basereq->chain.first = NULL;

drivers/crypto/marvell/cesa/hash.c

639

basereq->chain.last = NULL;

drivers/crypto/marvell/cesa/hash.c

653

mv_cesa_tdma_desc_iter_init(&basereq->chain);

drivers/crypto/marvell/cesa/hash.c

660

ret = mv_cesa_ahash_dma_add_cache(&basereq->chain, creq, flags);

drivers/crypto/marvell/cesa/hash.c

671

ret = mv_cesa_dma_add_op_transfers(&basereq->chain,

drivers/crypto/marvell/cesa/hash.c

682

op = mv_cesa_dma_add_frag(&basereq->chain,

drivers/crypto/marvell/cesa/hash.c

701

op = mv_cesa_ahash_dma_last_req(&basereq->chain, &iter, creq,

drivers/crypto/marvell/cesa/hash.c

704

op = mv_cesa_dma_add_frag(&basereq->chain, &creq->op_tmpl,

drivers/crypto/marvell/cesa/hash.c

718

type = basereq->chain.last->flags & CESA_TDMA_TYPE_MSK;

drivers/crypto/marvell/cesa/hash.c

722

ret = mv_cesa_dma_add_dummy_end(&basereq->chain, flags);

drivers/crypto/marvell/cesa/hash.c

733

basereq->chain.last->flags |= CESA_TDMA_END_OF_REQ;

drivers/crypto/marvell/cesa/hash.c

736

basereq->chain.last->flags |= CESA_TDMA_BREAK_CHAIN;

drivers/crypto/marvell/cesa/hash.c

744

basereq->chain.first->flags |= CESA_TDMA_SET_STATE;

drivers/crypto/marvell/cesa/tdma.c

114

if (!last || dreq->chain.first->flags & CESA_TDMA_SET_STATE)

drivers/crypto/marvell/cesa/tdma.c

115

engine->chain_sw.first = dreq->chain.first;

drivers/crypto/marvell/cesa/tdma.c

117

last->next = dreq->chain.first;

drivers/crypto/marvell/cesa/tdma.c

118

last->next_dma = cpu_to_le32(dreq->chain.first->cur_dma);

drivers/crypto/marvell/cesa/tdma.c

120

last = dreq->chain.last;

drivers/crypto/marvell/cesa/tdma.c

203

mv_cesa_dma_add_desc(struct mv_cesa_tdma_chain *chain, gfp_t flags)

drivers/crypto/marvell/cesa/tdma.c

214

if (chain->last) {

drivers/crypto/marvell/cesa/tdma.c

215

chain->last->next_dma = cpu_to_le32(dma_handle);

drivers/crypto/marvell/cesa/tdma.c

216

chain->last->next = new_tdma;

drivers/crypto/marvell/cesa/tdma.c

218

chain->first = new_tdma;

drivers/crypto/marvell/cesa/tdma.c

221

chain->last = new_tdma;

drivers/crypto/marvell/cesa/tdma.c

226

int mv_cesa_dma_add_result_op(struct mv_cesa_tdma_chain *chain, dma_addr_t src,

drivers/crypto/marvell/cesa/tdma.c

231

tdma = mv_cesa_dma_add_desc(chain, gfp_flags);

drivers/crypto/marvell/cesa/tdma.c

240

for (op_desc = chain->first; op_desc; op_desc = op_desc->next) {

drivers/crypto/marvell/cesa/tdma.c

260

struct mv_cesa_op_ctx *mv_cesa_dma_add_op(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/tdma.c

270

tdma = mv_cesa_dma_add_desc(chain, flags);

drivers/crypto/marvell/cesa/tdma.c

282

tdma = chain->last;

drivers/crypto/marvell/cesa/tdma.c

292

int mv_cesa_dma_add_data_transfer(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/tdma.c

298

tdma = mv_cesa_dma_add_desc(chain, gfp_flags);

drivers/crypto/marvell/cesa/tdma.c

312

int mv_cesa_dma_add_dummy_launch(struct mv_cesa_tdma_chain *chain, gfp_t flags)

drivers/crypto/marvell/cesa/tdma.c

316

tdma = mv_cesa_dma_add_desc(chain, flags);

drivers/crypto/marvell/cesa/tdma.c

320

int mv_cesa_dma_add_dummy_end(struct mv_cesa_tdma_chain *chain, gfp_t flags)

drivers/crypto/marvell/cesa/tdma.c

324

tdma = mv_cesa_dma_add_desc(chain, flags);

drivers/crypto/marvell/cesa/tdma.c

333

int mv_cesa_dma_add_op_transfers(struct mv_cesa_tdma_chain *chain,

drivers/crypto/marvell/cesa/tdma.c

355

ret = mv_cesa_dma_add_data_transfer(chain, dst, src, len,

drivers/crypto/marvell/cesa/tdma.c

42

if (engine->chain_sw.first == dreq->chain.first) {

drivers/crypto/marvell/cesa/tdma.c

46

engine->chain_hw.first = dreq->chain.first;

drivers/crypto/marvell/cesa/tdma.c

47

engine->chain_hw.last = dreq->chain.last;

drivers/crypto/marvell/cesa/tdma.c

60

writel_relaxed(dreq->chain.first->cur_dma,

drivers/crypto/marvell/cesa/tdma.c

71

for (tdma = dreq->chain.first; tdma;) {

drivers/crypto/marvell/cesa/tdma.c

84

dreq->chain.first = NULL;

drivers/crypto/marvell/cesa/tdma.c

85

dreq->chain.last = NULL;

drivers/crypto/marvell/cesa/tdma.c

93

for (tdma = dreq->chain.first; tdma; tdma = tdma->next) {

drivers/dma-buf/dma-fence-chain.c

101

dma_fence_chain_for_each(*pfence, &chain->base) {

drivers/dma-buf/dma-fence-chain.c

102

if ((*pfence)->context != chain->base.context ||

drivers/dma-buf/dma-fence-chain.c

106

dma_fence_put(&chain->base);

drivers/dma-buf/dma-fence-chain.c

124

struct dma_fence_chain *chain;

drivers/dma-buf/dma-fence-chain.c

126

chain = container_of(work, typeof(*chain), work);

drivers/dma-buf/dma-fence-chain.c

129

if (!dma_fence_chain_enable_signaling(&chain->base))

drivers/dma-buf/dma-fence-chain.c

131

dma_fence_signal(&chain->base);

drivers/dma-buf/dma-fence-chain.c

132

dma_fence_put(&chain->base);

drivers/dma-buf/dma-fence-chain.c

137

struct dma_fence_chain *chain;

drivers/dma-buf/dma-fence-chain.c

139

chain = container_of(cb, typeof(*chain), cb);

drivers/dma-buf/dma-fence-chain.c

140

init_irq_work(&chain->work, dma_fence_chain_irq_work);

drivers/dma-buf/dma-fence-chain.c

141

irq_work_queue(&chain->work);

drivers/dma-buf/dma-fence-chain.c

180

struct dma_fence_chain *chain = to_dma_fence_chain(fence);

drivers/dma-buf/dma-fence-chain.c

186

while ((prev = rcu_dereference_protected(chain->prev, true))) {

drivers/dma-buf/dma-fence-chain.c

199

chain->prev = prev_chain->prev;

drivers/dma-buf/dma-fence-chain.c

205

dma_fence_put(chain->fence);

drivers/dma-buf/dma-fence-chain.c

21

static struct dma_fence *dma_fence_chain_get_prev(struct dma_fence_chain *chain)

drivers/dma-buf/dma-fence-chain.c

240

void dma_fence_chain_init(struct dma_fence_chain *chain,

drivers/dma-buf/dma-fence-chain.c

248

spin_lock_init(&chain->lock);

drivers/dma-buf/dma-fence-chain.c

249

rcu_assign_pointer(chain->prev, prev);

drivers/dma-buf/dma-fence-chain.c

250

chain->fence = fence;

drivers/dma-buf/dma-fence-chain.c

251

chain->prev_seqno = 0;

drivers/dma-buf/dma-fence-chain.c

256

chain->prev_seqno = prev->seqno;

drivers/dma-buf/dma-fence-chain.c

26

prev = dma_fence_get_rcu_safe(&chain->prev);

drivers/dma-buf/dma-fence-chain.c

264

dma_fence_init64(&chain->base, &dma_fence_chain_ops, &chain->lock,

drivers/dma-buf/dma-fence-chain.c

41

struct dma_fence_chain *chain, *prev_chain;

drivers/dma-buf/dma-fence-chain.c

44

chain = to_dma_fence_chain(fence);

drivers/dma-buf/dma-fence-chain.c

45

if (!chain) {

drivers/dma-buf/dma-fence-chain.c

50

while ((prev = dma_fence_chain_get_prev(chain))) {

drivers/dma-buf/dma-fence-chain.c

65

tmp = unrcu_pointer(cmpxchg(&chain->prev, RCU_INITIALIZER(prev),

drivers/dma-buf/dma-fence-chain.c

92

struct dma_fence_chain *chain;

drivers/dma-buf/dma-fence-chain.c

97

chain = to_dma_fence_chain(*pfence);

drivers/dma-buf/dma-fence-chain.c

98

if (!chain || chain->base.seqno < seqno)

drivers/dma-buf/dma-fence-unwrap.c

21

cursor->array = dma_fence_chain_contained(cursor->chain);

drivers/dma-buf/dma-fence-unwrap.c

37

cursor->chain = dma_fence_get(head);

drivers/dma-buf/dma-fence-unwrap.c

58

cursor->chain = dma_fence_chain_walk(cursor->chain);

drivers/dma-buf/st-dma-fence-chain.c

79

struct dma_fence *f, *chain;

drivers/dma-buf/st-dma-fence-chain.c

86

chain = mock_chain(NULL, f, 1);

drivers/dma-buf/st-dma-fence-chain.c

87

if (chain)

drivers/dma-buf/st-dma-fence-chain.c

88

dma_fence_enable_sw_signaling(chain);

drivers/dma-buf/st-dma-fence-chain.c

95

dma_fence_put(chain);

drivers/dma-buf/st-dma-fence-unwrap.c

102

struct dma_fence *f, *chain, *array;

drivers/dma-buf/st-dma-fence-unwrap.c

115

chain = mock_chain(NULL, array);

drivers/dma-buf/st-dma-fence-unwrap.c

116

if (!chain)

drivers/dma-buf/st-dma-fence-unwrap.c

119

dma_fence_put(chain);

drivers/dma-buf/st-dma-fence-unwrap.c

169

struct dma_fence *fence, *f1, *f2, *chain;

drivers/dma-buf/st-dma-fence-unwrap.c

187

chain = mock_chain(f1, f2);

drivers/dma-buf/st-dma-fence-unwrap.c

188

if (!chain)

drivers/dma-buf/st-dma-fence-unwrap.c

191

dma_fence_unwrap_for_each(fence, &iter, chain) {

drivers/dma-buf/st-dma-fence-unwrap.c

207

dma_fence_put(chain);

drivers/dma-buf/st-dma-fence-unwrap.c

213

struct dma_fence *fence, *f1, *f2, *array, *chain;

drivers/dma-buf/st-dma-fence-unwrap.c

235

chain = mock_chain(NULL, array);

drivers/dma-buf/st-dma-fence-unwrap.c

236

if (!chain)

drivers/dma-buf/st-dma-fence-unwrap.c

239

dma_fence_unwrap_for_each(fence, &iter, chain) {

drivers/dma-buf/st-dma-fence-unwrap.c

255

dma_fence_put(chain);

drivers/dma/mv_xor.c

1128

INIT_LIST_HEAD(&mv_chan->chain);

drivers/dma/mv_xor.c

280

list_for_each_entry_safe(iter, _iter, &mv_chan->chain,

drivers/dma/mv_xor.c

305

if ((busy == 0) && !list_empty(&mv_chan->chain)) {

drivers/dma/mv_xor.c

311

iter = list_entry(mv_chan->chain.next,

drivers/dma/mv_xor.c

316

if (!list_is_last(&iter->node, &mv_chan->chain)) {

drivers/dma/mv_xor.c

397

if (list_empty(&mv_chan->chain))

drivers/dma/mv_xor.c

398

list_move_tail(&sw_desc->node, &mv_chan->chain);

drivers/dma/mv_xor.c

402

old_chain_tail = list_entry(mv_chan->chain.prev,

drivers/dma/mv_xor.c

405

list_move_tail(&sw_desc->node, &mv_chan->chain);

drivers/dma/mv_xor.c

637

list_for_each_entry_safe(iter, _iter, &mv_chan->chain,

drivers/dma/mv_xor.h

111

struct list_head chain;

drivers/dma/ppc4xx/adma.c

1125

list_for_each_entry_continue(iter, &chan->chain, chain_node) {

drivers/dma/ppc4xx/adma.c

1499

if (list_is_last(&desc->chain_node, &chan->chain) ||

drivers/dma/ppc4xx/adma.c

1554

list_for_each_entry_safe(iter, _iter, &chan->chain,

drivers/dma/ppc4xx/adma.c

1611

&chan->chain, chain_node) {

drivers/dma/ppc4xx/adma.c

1690

LIST_HEAD(chain);

drivers/dma/ppc4xx/adma.c

1730

list_add_tail(&iter->chain_node, &chain);

drivers/dma/ppc4xx/adma.c

1748

list_splice(&chain, &alloc_tail->group_list);

drivers/dma/ppc4xx/adma.c

1912

if (unlikely(list_empty(&chan->chain))) {

drivers/dma/ppc4xx/adma.c

1914

list_splice_init(&sw_desc->group_list, &chan->chain);

drivers/dma/ppc4xx/adma.c

1918

old_chain_tail = list_entry(chan->chain.prev,

drivers/dma/ppc4xx/adma.c

3541

list_for_each_entry_safe(iter, _iter, &ppc440spe_chan->chain,

drivers/dma/ppc4xx/adma.c

3666

list_splice_init(&sw_desc->group_list, &chan->chain);

drivers/dma/ppc4xx/adma.c

4134

INIT_LIST_HEAD(&chan->chain);

drivers/dma/ppc4xx/adma.c

945

list_for_each_entry(iter, &chan->chain,

drivers/dma/ppc4xx/adma.c

954

BUG_ON(&iter->chain_node == &chan->chain);

drivers/dma/ppc4xx/adma.h

93

struct list_head chain;

drivers/dma/txx9dmac.c

538

dma_addr_t chain;

drivers/dma/txx9dmac.c

544

chain = channel64_read_CHAR(dc);

drivers/dma/txx9dmac.c

548

chain = channel32_readl(dc, CHAR);

drivers/dma/txx9dmac.c

559

chain = 0; /* last descriptor of this chain */

drivers/dma/txx9dmac.c

562

(u64)chain);

drivers/dma/txx9dmac.c

565

if (desc_read_CHAR(dc, desc) == chain) {

drivers/dma/txx9dmac.c

573

if (desc_read_CHAR(dc, child) == chain) {

drivers/firmware/arm_scmi/notify.c

1397

blocking_notifier_chain_register(&hndl->chain, nb);

drivers/firmware/arm_scmi/notify.c

1447

blocking_notifier_chain_unregister(&hndl->chain, nb);

drivers/firmware/arm_scmi/notify.c

368

struct blocking_notifier_head chain;

drivers/firmware/arm_scmi/notify.c

406

ret = blocking_notifier_call_chain(&hndl->chain,

drivers/firmware/arm_scmi/notify.c

904

BLOCKING_INIT_NOTIFIER_HEAD(&hndl->chain);

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

1271

if (p->post_deps[i].chain && p->post_deps[i].point) {

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

1273

p->post_deps[i].chain,

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

1275

p->post_deps[i].chain = NULL;

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

1396

kfree(parser->post_deps[i].chain);

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

537

p->post_deps[i].chain = NULL;

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

567

dep->chain = NULL;

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

569

dep->chain = dma_fence_chain_alloc();

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

570

if (!dep->chain)

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

577

dma_fence_chain_free(dep->chain);

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

45

struct dma_fence_chain *chain;

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

106

*chain = dma_fence_chain_alloc();

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

107

if (!*chain) {

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

92

struct dma_fence_chain **chain)

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

149

uint64_t ib, size_t ib_size_in_dwords, bool chain)

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

180

packet->bitfields4.chain = chain ? 1 : 0;

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

182

packet->bitfields4.chained_runlist_idle_disable = chain ? 1 : 0;

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

105

packet->bitfields4.chain = chain ? 1 : 0;

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

77

uint64_t ib, size_t ib_size_in_dwords, bool chain)

drivers/gpu/drm/amd/amdkfd/kfd_pm4_headers_ai.h

123

uint32_t chain:1;

drivers/gpu/drm/amd/amdkfd/kfd_pm4_headers_vi.h

128

uint32_t chain:1;

drivers/gpu/drm/amd/amdkfd/kfd_priv.h

1458

uint64_t ib, size_t ib_size_in_dwords, bool chain);

drivers/gpu/drm/drm_gem_atomic_helper.c

176

struct dma_fence_chain *chain = dma_fence_chain_alloc();

drivers/gpu/drm/drm_gem_atomic_helper.c

178

if (!chain) {

drivers/gpu/drm/drm_gem_atomic_helper.c

183

dma_fence_chain_init(chain, fence, new, 1);

drivers/gpu/drm/drm_gem_atomic_helper.c

184

fence = &chain->base;

drivers/gpu/drm/drm_syncobj.c

1678

struct dma_fence_chain *chain;

drivers/gpu/drm/drm_syncobj.c

1683

chain = to_dma_fence_chain(fence);

drivers/gpu/drm/drm_syncobj.c

1684

if (chain) {

drivers/gpu/drm/drm_syncobj.c

334

struct dma_fence_chain *chain,

drivers/gpu/drm/drm_syncobj.c

350

dma_fence_chain_init(chain, prev, fence, point);

drivers/gpu/drm/drm_syncobj.c

351

rcu_assign_pointer(syncobj->fence, &chain->base);

drivers/gpu/drm/drm_syncobj.c

742

struct dma_fence_chain *chain = dma_fence_chain_alloc();

drivers/gpu/drm/drm_syncobj.c

744

if (!chain)

drivers/gpu/drm/drm_syncobj.c

747

drm_syncobj_add_point(syncobj, chain, fence, point);

drivers/gpu/drm/drm_syncobj.c

924

struct dma_fence_chain *chain;

drivers/gpu/drm/drm_syncobj.c

944

chain = dma_fence_chain_alloc();

drivers/gpu/drm/drm_syncobj.c

945

if (!chain) {

drivers/gpu/drm/drm_syncobj.c

950

drm_syncobj_add_point(timeline_syncobj, chain, fence, args->dst_point);

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

1161

struct dma_fence_chain *chain = dma_fence_chain_alloc();

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

1163

if (!chain) {

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

1168

dma_fence_chain_init(chain, fence, new, 1);

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

1169

fence = &chain->base;

drivers/gpu/drm/i915/gem/i915_gem_clflush.c

114

i915_sw_fence_await_reservation(&clflush->base.chain,

drivers/gpu/drm/i915/i915_request.c

1368

struct dma_fence_chain *chain = to_dma_fence_chain(iter);

drivers/gpu/drm/i915/i915_request.c

1370

if (!dma_fence_is_i915(chain->fence)) {

drivers/gpu/drm/i915/i915_request.c

1375

err = i915_request_await_dma_fence(rq, chain->fence);

drivers/gpu/drm/i915/i915_sw_fence_work.c

29

struct dma_fence_work *f = container_of(fence, typeof(*f), chain);

drivers/gpu/drm/i915/i915_sw_fence_work.c

71

i915_sw_fence_fini(&f->chain);

drivers/gpu/drm/i915/i915_sw_fence_work.c

89

i915_sw_fence_init(&f->chain, fence_notify);

drivers/gpu/drm/i915/i915_sw_fence_work.c

98

return __i915_sw_fence_await_dma_fence(&f->chain, signal, &f->cb);

drivers/gpu/drm/i915/i915_sw_fence_work.h

28

struct i915_sw_fence chain;

drivers/gpu/drm/i915/i915_sw_fence_work.h

45

i915_sw_fence_commit(&f->chain);

drivers/gpu/drm/i915/i915_sw_fence_work.h

61

if (atomic_read(&f->chain.pending) <= 1)

drivers/gpu/drm/i915/i915_vma.c

2178

if (i915_sw_fence_await_active(&vma->resource->chain, &vma->active,

drivers/gpu/drm/i915/i915_vma.c

517

&work->base.chain,

drivers/gpu/drm/i915/i915_vma.c

559

__i915_sw_fence_await_dma_fence(&work->base.chain,

drivers/gpu/drm/i915/i915_vma_resource.c

194

container_of(fence, typeof(*vma_res), chain);

drivers/gpu/drm/i915/i915_vma_resource.c

244

if (atomic_read(&vma_res->chain.pending) <= 1) {

drivers/gpu/drm/i915/i915_vma_resource.c

251

i915_sw_fence_commit(&vma_res->chain);

drivers/gpu/drm/i915/i915_vma_resource.c

268

i915_sw_fence_init(&vma_res->chain, i915_vma_resource_fence_notify);

drivers/gpu/drm/i915/i915_vma_resource.c

92

i915_sw_fence_fini(&vma_res->chain);

drivers/gpu/drm/i915/i915_vma_resource.h

106

struct i915_sw_fence chain;

drivers/gpu/drm/i915/i915_vma_resource.h

240

i915_sw_fence_fini(&vma_res->chain);

drivers/gpu/drm/imagination/pvr_sync.c

195

if (sig_sync->chain) {

drivers/gpu/drm/imagination/pvr_sync.c

196

drm_syncobj_add_point(sig_sync->syncobj, sig_sync->chain,

drivers/gpu/drm/imagination/pvr_sync.c

198

sig_sync->chain = NULL;

drivers/gpu/drm/imagination/pvr_sync.c

42

dma_fence_chain_free(sig_sync->chain);

drivers/gpu/drm/imagination/pvr_sync.c

75

sig_sync->chain = dma_fence_chain_alloc();

drivers/gpu/drm/imagination/pvr_sync.c

76

if (!sig_sync->chain) {

drivers/gpu/drm/imagination/pvr_sync.h

49

struct dma_fence_chain *chain;

drivers/gpu/drm/msm/msm_gem_submit.c

839

kfree(post_deps[i].chain);

drivers/gpu/drm/msm/msm_gem_vma.c

1604

kfree(post_deps[i].chain);

drivers/gpu/drm/msm/msm_syncobj.c

126

post_deps[i].chain = dma_fence_chain_alloc();

drivers/gpu/drm/msm/msm_syncobj.c

127

if (!post_deps[i].chain) {

drivers/gpu/drm/msm/msm_syncobj.c

143

dma_fence_chain_free(post_deps[j].chain);

drivers/gpu/drm/msm/msm_syncobj.c

162

if (post_deps[i].chain) {

drivers/gpu/drm/msm/msm_syncobj.c

164

post_deps[i].chain,

drivers/gpu/drm/msm/msm_syncobj.c

166

post_deps[i].chain = NULL;

drivers/gpu/drm/msm/msm_syncobj.h

14

struct dma_fence_chain *chain;

drivers/gpu/drm/nouveau/nouveau_sched.c

195

struct dma_fence_chain *chain = job->out_sync.chains[i];

drivers/gpu/drm/nouveau/nouveau_sched.c

200

if (chain)

drivers/gpu/drm/nouveau/nouveau_sched.c

201

dma_fence_chain_free(chain);

drivers/gpu/drm/panthor/panthor_drv.c

260

struct dma_fence_chain *chain;

drivers/gpu/drm/panthor/panthor_drv.c

365

dma_fence_chain_free(sig_sync->chain);

drivers/gpu/drm/panthor/panthor_drv.c

393

sig_sync->chain = dma_fence_chain_alloc();

drivers/gpu/drm/panthor/panthor_drv.c

394

if (!sig_sync->chain) {

drivers/gpu/drm/panthor/panthor_drv.c

581

if (sig_sync->chain) {

drivers/gpu/drm/panthor/panthor_drv.c

582

drm_syncobj_add_point(sig_sync->syncobj, sig_sync->chain,

drivers/gpu/drm/panthor/panthor_drv.c

584

sig_sync->chain = NULL;

drivers/gpu/drm/virtio/virtgpu_submit.c

179

kfree(post_deps[i].chain);

drivers/gpu/drm/virtio/virtgpu_submit.c

222

post_deps[i].chain = dma_fence_chain_alloc();

drivers/gpu/drm/virtio/virtgpu_submit.c

223

if (!post_deps[i].chain) {

drivers/gpu/drm/virtio/virtgpu_submit.c

232

kfree(post_deps[i].chain);

drivers/gpu/drm/virtio/virtgpu_submit.c

24

struct dma_fence_chain *chain;

drivers/gpu/drm/virtio/virtgpu_submit.c

259

if (post_deps[i].chain) {

drivers/gpu/drm/virtio/virtgpu_submit.c

261

post_deps[i].chain,

drivers/gpu/drm/virtio/virtgpu_submit.c

263

post_deps[i].chain = NULL;

drivers/gpu/drm/xe/xe_sched_job.c

124

struct dma_fence_chain *chain;

drivers/gpu/drm/xe/xe_sched_job.c

135

chain = dma_fence_chain_alloc();

drivers/gpu/drm/xe/xe_sched_job.c

136

if (!chain) {

drivers/gpu/drm/xe/xe_sched_job.c

140

job->ptrs[i].chain_fence = chain;

drivers/gpu/drm/xe/xe_sched_job.c

271

struct dma_fence_chain *chain;

drivers/gpu/drm/xe/xe_sched_job.c

283

chain = job->ptrs[i - 1].chain_fence;

drivers/gpu/drm/xe/xe_sched_job.c

284

dma_fence_chain_init(chain, prev, fence, seqno++);

drivers/gpu/drm/xe/xe_sched_job.c

286

fence = &chain->base;

drivers/infiniband/core/uverbs_uapi.c

286

rc = uapi_merge_def(uapi, ibdev, def->chain, is_driver);

drivers/media/platform/renesas/vsp1/vsp1_dl.c

202

struct list_head chain;

drivers/media/platform/renesas/vsp1/vsp1_dl.c

628

INIT_LIST_HEAD(&dl->chain);

drivers/media/platform/renesas/vsp1/vsp1_dl.c

652

list_for_each_entry(dl_next, &dl->chain, chain)

drivers/media/platform/renesas/vsp1/vsp1_dl.c

758

list_add_tail(&dl->chain, &head->chain);

drivers/media/platform/renesas/vsp1/vsp1_dl.c

822

struct vsp1_dl_list *next = list_next_entry(dl, chain);

drivers/media/platform/renesas/vsp1/vsp1_dl.c

943

vsp1_dl_list_fill_header(dl, list_empty(&dl->chain));

drivers/media/platform/renesas/vsp1/vsp1_dl.c

945

list_for_each_entry(dl_next, &dl->chain, chain) {

drivers/media/platform/renesas/vsp1/vsp1_dl.c

946

bool last = list_is_last(&dl_next->chain, &dl->chain);

drivers/media/usb/uvc/uvc_ctrl.c

1207

static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1221

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

1229

uvc_dbg(chain->dev, CONTROL, "Control 0x%08x not found\n",

drivers/media/usb/uvc/uvc_ctrl.c

1235

static int uvc_ctrl_populate_cache(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1241

ret = uvc_query_ctrl(chain->dev, UVC_GET_DEF, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

1242

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

1250

ret = uvc_query_ctrl(chain->dev, UVC_GET_MIN, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

1251

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

1258

ret = uvc_query_ctrl(chain->dev, UVC_GET_MAX, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

1259

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

1266

ret = uvc_query_ctrl(chain->dev, UVC_GET_RES, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

1267

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

1280

uvc_warn_once(chain->dev, UVC_WARN_XU_GET_RES,

drivers/media/usb/uvc/uvc_ctrl.c

1292

static int __uvc_ctrl_load_cur(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1311

ret = ctrl->entity->get_cur(chain->dev, ctrl->entity,

drivers/media/usb/uvc/uvc_ctrl.c

1315

ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR,

drivers/media/usb/uvc/uvc_ctrl.c

1316

ctrl->entity->id, chain->dev->intfnum,

drivers/media/usb/uvc/uvc_ctrl.c

1328

static int __uvc_ctrl_get(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1338

ret = __uvc_ctrl_load_cur(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1348

static int __uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,

drivers/media/usb/uvc/uvc_ctrl.c

1358

if (!(chain->ctrl_class_bitmap & BIT(i)))

drivers/media/usb/uvc/uvc_ctrl.c

1373

static int uvc_query_v4l2_class(struct uvc_video_chain *chain, u32 req_id,

drivers/media/usb/uvc/uvc_ctrl.c

1379

idx = __uvc_query_v4l2_class(chain, req_id, found_id);

drivers/media/usb/uvc/uvc_ctrl.c

1434

int uvc_ctrl_is_accessible(struct uvc_video_chain *chain, u32 v4l2_id,

drivers/media/usb/uvc/uvc_ctrl.c

1452

if (__uvc_query_v4l2_class(chain, v4l2_id, 0) >= 0)

drivers/media/usb/uvc/uvc_ctrl.c

1455

ctrl = uvc_find_control(chain, v4l2_id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

1490

ret = __uvc_ctrl_get(chain, master_ctrl, master_map, &val);

drivers/media/usb/uvc/uvc_ctrl.c

1547

static int __uvc_queryctrl_boundaries(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1557

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1646

static int __uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1682

ret = __uvc_ctrl_get(chain, master_ctrl, master_map,

drivers/media/usb/uvc/uvc_ctrl.c

1691

dev_warn_ratelimited(&chain->dev->intf->dev,

drivers/media/usb/uvc/uvc_ctrl.c

1713

ret = __uvc_queryctrl_boundaries(chain, ctrl, mapping, v4l2_ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1715

dev_warn(&chain->dev->intf->dev,

drivers/media/usb/uvc/uvc_ctrl.c

1727

int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1734

ret = mutex_lock_interruptible(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1740

ret = uvc_query_v4l2_class(chain, v4l2_ctrl->id, 0, v4l2_ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1745

ctrl = uvc_find_control(chain, v4l2_ctrl->id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

1757

ret = uvc_query_v4l2_class(chain, v4l2_ctrl->id, mapping->id,

drivers/media/usb/uvc/uvc_ctrl.c

1763

ret = __uvc_query_v4l2_ctrl(chain, ctrl, mapping, v4l2_ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1765

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1778

int uvc_query_v4l2_menu(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1795

ret = mutex_lock_interruptible(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1799

ctrl = uvc_find_control(chain, query_menu->id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

1814

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1840

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1848

static void uvc_ctrl_fill_event(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1856

__uvc_query_v4l2_ctrl(chain, ctrl, mapping, &v4l2_ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

1878

static void uvc_ctrl_send_event(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1889

uvc_ctrl_fill_event(chain, &ev, ctrl, mapping, value, changes);

drivers/media/usb/uvc/uvc_ctrl.c

1904

static void uvc_ctrl_send_slave_event(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1917

__uvc_ctrl_get(chain, ctrl, mapping, &val) == 0)

drivers/media/usb/uvc/uvc_ctrl.c

1920

uvc_ctrl_send_event(chain, handle, ctrl, mapping, val, changes);

drivers/media/usb/uvc/uvc_ctrl.c

1927

lockdep_assert_held(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1944

ret = uvc_pm_get(handle->chain->dev);

drivers/media/usb/uvc/uvc_ctrl.c

1955

lockdep_assert_held(&ctrl->handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

1963

uvc_pm_put(ctrl->handle->chain->dev);

drivers/media/usb/uvc/uvc_ctrl.c

1968

void uvc_ctrl_status_event(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

1975

mutex_lock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2000

uvc_ctrl_send_slave_event(chain, handle, ctrl,

drivers/media/usb/uvc/uvc_ctrl.c

2004

uvc_ctrl_send_event(chain, handle, ctrl, mapping, value,

drivers/media/usb/uvc/uvc_ctrl.c

2008

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2018

uvc_ctrl_status_event(w->chain, w->ctrl, w->data);

drivers/media/usb/uvc/uvc_ctrl.c

2032

bool uvc_ctrl_status_event_async(struct urb *urb, struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2035

struct uvc_device *dev = chain->dev;

drivers/media/usb/uvc/uvc_ctrl.c

2043

w->chain = chain;

drivers/media/usb/uvc/uvc_ctrl.c

2078

ctrl = uvc_find_control(handle->chain, xctrls[i].id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

2100

uvc_ctrl_send_slave_event(handle->chain, handle, ctrl,

drivers/media/usb/uvc/uvc_ctrl.c

2117

uvc_ctrl_send_event(handle->chain, handle, ctrl, mapping,

drivers/media/usb/uvc/uvc_ctrl.c

2129

ret = mutex_lock_interruptible(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2133

if (__uvc_query_v4l2_class(handle->chain, sev->id, 0) >= 0) {

drivers/media/usb/uvc/uvc_ctrl.c

2138

ctrl = uvc_find_control(handle->chain, sev->id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

2149

ret = uvc_pm_get(handle->chain->dev);

drivers/media/usb/uvc/uvc_ctrl.c

2154

__uvc_ctrl_get(handle->chain, ctrl, mapping, &val) == 0)

drivers/media/usb/uvc/uvc_ctrl.c

2157

uvc_ctrl_fill_event(handle->chain, &ev, ctrl, mapping, val,

drivers/media/usb/uvc/uvc_ctrl.c

2160

uvc_pm_put(handle->chain->dev);

drivers/media/usb/uvc/uvc_ctrl.c

2173

mutex_unlock(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2181

mutex_lock(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2182

if (__uvc_query_v4l2_class(handle->chain, sev->id, 0) >= 0)

drivers/media/usb/uvc/uvc_ctrl.c

2186

mutex_unlock(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2220

int uvc_ctrl_begin(struct uvc_video_chain *chain)

drivers/media/usb/uvc/uvc_ctrl.c

2222

return mutex_lock_interruptible(&chain->ctrl_mutex) ? -ERESTARTSYS : 0;

drivers/media/usb/uvc/uvc_ctrl.c

2323

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_ctrl.c

2330

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

2331

ret = uvc_ctrl_commit_entity(chain->dev, handle, entity,

drivers/media/usb/uvc/uvc_ctrl.c

2353

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2357

static int uvc_mapping_get_xctrl_compound(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2401

ret = __uvc_ctrl_load_cur(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2403

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2420

static int uvc_mapping_get_xctrl_std(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2430

return __uvc_ctrl_get(chain, ctrl, mapping, &xctrl->value);

drivers/media/usb/uvc/uvc_ctrl.c

2439

ret = __uvc_queryctrl_boundaries(chain, ctrl, mapping, &qec);

drivers/media/usb/uvc/uvc_ctrl.c

2458

static int uvc_mapping_get_xctrl(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2464

return uvc_mapping_get_xctrl_compound(chain, ctrl, mapping,

drivers/media/usb/uvc/uvc_ctrl.c

2466

return uvc_mapping_get_xctrl_std(chain, ctrl, mapping, which, xctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2469

int uvc_ctrl_get(struct uvc_video_chain *chain, u32 which,

drivers/media/usb/uvc/uvc_ctrl.c

2475

if (__uvc_query_v4l2_class(chain, xctrl->id, 0) >= 0)

drivers/media/usb/uvc/uvc_ctrl.c

2478

ctrl = uvc_find_control(chain, xctrl->id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

2482

return uvc_mapping_get_xctrl(chain, ctrl, mapping, which, xctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2485

static int uvc_ctrl_clamp(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2500

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2538

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2566

ret = uvc_ctrl_populate_cache(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2620

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_ctrl.c

2625

lockdep_assert_held(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

2627

if (__uvc_query_v4l2_class(chain, xctrl->id, 0) >= 0)

drivers/media/usb/uvc/uvc_ctrl.c

2630

ctrl = uvc_find_control(chain, xctrl->id, &mapping);

drivers/media/usb/uvc/uvc_ctrl.c

2636

ret = uvc_ctrl_clamp(chain, ctrl, xctrl->id, mapping, &xctrl->value);

drivers/media/usb/uvc/uvc_ctrl.c

2645

ret = __uvc_ctrl_load_cur(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2830

int uvc_xu_ctrl_query(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

2844

list_for_each_entry(iter, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

2853

uvc_dbg(chain->dev, CONTROL, "Extension unit %u not found\n",

drivers/media/usb/uvc/uvc_ctrl.c

2869

uvc_dbg(chain->dev, CONTROL, "Control %pUl/%u not found\n",

drivers/media/usb/uvc/uvc_ctrl.c

2874

if (mutex_lock_interruptible(&chain->ctrl_mutex))

drivers/media/usb/uvc/uvc_ctrl.c

2877

ret = uvc_ctrl_init_xu_ctrl(chain->dev, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

2939

ret = uvc_query_ctrl(chain->dev, xqry->query, xqry->unit,

drivers/media/usb/uvc/uvc_ctrl.c

2940

chain->dev->intfnum, xqry->selector, data, size);

drivers/media/usb/uvc/uvc_ctrl.c

2949

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

3027

static int __uvc_ctrl_add_mapping(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

3088

chain->ctrl_class_bitmap |= BIT(i);

drivers/media/usb/uvc/uvc_ctrl.c

3094

uvc_dbg(chain->dev, CONTROL, "Adding mapping '%s' to control %pUl/%u\n",

drivers/media/usb/uvc/uvc_ctrl.c

3110

int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

3113

struct uvc_device *dev = chain->dev;

drivers/media/usb/uvc/uvc_ctrl.c

3128

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

3149

if (mutex_lock_interruptible(&chain->ctrl_mutex))

drivers/media/usb/uvc/uvc_ctrl.c

3186

ret = __uvc_ctrl_add_mapping(chain, ctrl, mapping);

drivers/media/usb/uvc/uvc_ctrl.c

3191

mutex_unlock(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

3262

static void uvc_ctrl_init_ctrl(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_ctrl.c

3272

uvc_ctrl_add_info(chain->dev, ctrl, info);

drivers/media/usb/uvc/uvc_ctrl.c

3279

uvc_ctrl_get_flags(chain->dev, ctrl, &ctrl->info);

drivers/media/usb/uvc/uvc_ctrl.c

3297

mapping = mapping->filter_mapping(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

3302

__uvc_ctrl_add_mapping(chain, ctrl, mapping);

drivers/media/usb/uvc/uvc_ctrl.c

3309

static int uvc_ctrl_init_chain(struct uvc_video_chain *chain)

drivers/media/usb/uvc/uvc_ctrl.c

3315

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_ctrl.c

3335

uvc_ctrl_prune_entity(chain->dev, entity);

drivers/media/usb/uvc/uvc_ctrl.c

3356

uvc_ctrl_init_ctrl(chain, ctrl);

drivers/media/usb/uvc/uvc_ctrl.c

3366

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_ctrl.c

3371

list_for_each_entry(chain, &dev->chains, list) {

drivers/media/usb/uvc/uvc_ctrl.c

3372

ret = uvc_ctrl_init_chain(chain);

drivers/media/usb/uvc/uvc_ctrl.c

3384

guard(mutex)(&handle->chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_ctrl.c

3389

list_for_each_entry(entity, &handle->chain->dev->entities, list) {

drivers/media/usb/uvc/uvc_ctrl.c

595

struct uvc_video_chain *chain, struct uvc_control *ctrl)

drivers/media/usb/uvc/uvc_ctrl.c

608

ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

609

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

618

ret = uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

619

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

625

if (chain->dev->uvc_version < 0x150)

drivers/media/usb/uvc/uvc_ctrl.c

630

ret = uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

631

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_ctrl.c

639

uvc_query_ctrl(chain->dev, UVC_SET_CUR, ctrl->entity->id,

drivers/media/usb/uvc/uvc_ctrl.c

640

chain->dev->intfnum, ctrl->info.selector,

drivers/media/usb/uvc/uvc_driver.c

1294

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

1303

chain = list_first_entry(&dev->chains, struct uvc_video_chain, list);

drivers/media/usb/uvc/uvc_driver.c

1304

uvc_ctrl_status_event(chain, unit->controls, &new_val);

drivers/media/usb/uvc/uvc_driver.c

1434

static int uvc_scan_chain_entity(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_driver.c

1442

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1453

if (chain->processing != NULL) {

drivers/media/usb/uvc/uvc_driver.c

1454

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1459

chain->processing = entity;

drivers/media/usb/uvc/uvc_driver.c

1469

if (chain->selector != NULL) {

drivers/media/usb/uvc/uvc_driver.c

1470

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1475

chain->selector = entity;

drivers/media/usb/uvc/uvc_driver.c

1501

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1507

list_add_tail(&entity->chain, &chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1511

static int uvc_scan_chain_forward(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_driver.c

1522

forward = uvc_entity_by_reference(chain->dev, entity->id,

drivers/media/usb/uvc/uvc_driver.c

1528

if (forward->chain.next || forward->chain.prev) {

drivers/media/usb/uvc/uvc_driver.c

1529

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1538

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1557

source = uvc_entity_by_id(chain->dev,

drivers/media/usb/uvc/uvc_driver.c

1560

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1569

list_add_tail(&forward->chain, &chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1582

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1589

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1595

list_add_tail(&forward->chain, &chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1610

static int uvc_scan_chain_backward(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_driver.c

1632

chain->selector = entity;

drivers/media/usb/uvc/uvc_driver.c

1635

term = uvc_entity_by_id(chain->dev, id);

drivers/media/usb/uvc/uvc_driver.c

1637

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1643

if (term->chain.next || term->chain.prev) {

drivers/media/usb/uvc/uvc_driver.c

1644

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1652

list_add_tail(&term->chain, &chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1653

uvc_scan_chain_forward(chain, term, entity);

drivers/media/usb/uvc/uvc_driver.c

1677

entity = uvc_entity_by_id(chain->dev, id);

drivers/media/usb/uvc/uvc_driver.c

1679

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1688

static int uvc_scan_chain(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_driver.c

1693

uvc_dbg(chain->dev, PROBE, "Scanning UVC chain:");

drivers/media/usb/uvc/uvc_driver.c

1700

if (entity->chain.next || entity->chain.prev) {

drivers/media/usb/uvc/uvc_driver.c

1701

uvc_dbg(chain->dev, DESCR,

drivers/media/usb/uvc/uvc_driver.c

1708

if (uvc_scan_chain_entity(chain, entity) < 0)

drivers/media/usb/uvc/uvc_driver.c

1712

if (uvc_scan_chain_forward(chain, entity, prev) < 0)

drivers/media/usb/uvc/uvc_driver.c

1717

if (uvc_scan_chain_backward(chain, &entity) < 0)

drivers/media/usb/uvc/uvc_driver.c

1731

list_for_each_entry(term, terms, chain) {

drivers/media/usb/uvc/uvc_driver.c

1748

static const char *uvc_print_chain(struct uvc_video_chain *chain)

drivers/media/usb/uvc/uvc_driver.c

1753

p += uvc_print_terms(&chain->entities, UVC_TERM_INPUT, p);

drivers/media/usb/uvc/uvc_driver.c

1755

uvc_print_terms(&chain->entities, UVC_TERM_OUTPUT, p);

drivers/media/usb/uvc/uvc_driver.c

1762

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

1764

chain = kzalloc_obj(*chain);

drivers/media/usb/uvc/uvc_driver.c

1765

if (chain == NULL)

drivers/media/usb/uvc/uvc_driver.c

1768

INIT_LIST_HEAD(&chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1769

mutex_init(&chain->ctrl_mutex);

drivers/media/usb/uvc/uvc_driver.c

1770

chain->dev = dev;

drivers/media/usb/uvc/uvc_driver.c

1771

v4l2_prio_init(&chain->prio);

drivers/media/usb/uvc/uvc_driver.c

1773

return chain;

drivers/media/usb/uvc/uvc_driver.c

1791

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

1819

chain = uvc_alloc_chain(dev);

drivers/media/usb/uvc/uvc_driver.c

1820

if (chain == NULL)

drivers/media/usb/uvc/uvc_driver.c

1823

if (uvc_scan_chain_entity(chain, oterm) < 0)

drivers/media/usb/uvc/uvc_driver.c

1843

if (uvc_scan_chain_entity(chain, entity) < 0)

drivers/media/usb/uvc/uvc_driver.c

1850

if (uvc_scan_chain_entity(chain, iterm) < 0)

drivers/media/usb/uvc/uvc_driver.c

1855

list_add_tail(&chain->list, &dev->chains);

drivers/media/usb/uvc/uvc_driver.c

1858

uvc_print_chain(chain));

drivers/media/usb/uvc/uvc_driver.c

1863

kfree(chain);

drivers/media/usb/uvc/uvc_driver.c

1874

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

1887

if (term->chain.next || term->chain.prev)

drivers/media/usb/uvc/uvc_driver.c

1890

chain = uvc_alloc_chain(dev);

drivers/media/usb/uvc/uvc_driver.c

1891

if (chain == NULL)

drivers/media/usb/uvc/uvc_driver.c

1896

if (uvc_scan_chain(chain, term) < 0) {

drivers/media/usb/uvc/uvc_driver.c

1897

kfree(chain);

drivers/media/usb/uvc/uvc_driver.c

1902

uvc_print_chain(chain));

drivers/media/usb/uvc/uvc_driver.c

1904

list_add_tail(&chain->list, &dev->chains);

drivers/media/usb/uvc/uvc_driver.c

1917

chain = list_first_entry(&dev->chains,

drivers/media/usb/uvc/uvc_driver.c

1919

list_add_tail(&dev->gpio_unit->chain, &chain->entities);

drivers/media/usb/uvc/uvc_driver.c

1955

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

1957

chain = list_entry(p, struct uvc_video_chain, list);

drivers/media/usb/uvc/uvc_driver.c

1958

kfree(chain);

drivers/media/usb/uvc/uvc_driver.c

2051

vdev->prio = &stream->chain->prio;

drivers/media/usb/uvc/uvc_driver.c

2106

stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE

drivers/media/usb/uvc/uvc_driver.c

2109

stream->chain->caps |= V4L2_CAP_VIDEO_OUTPUT;

drivers/media/usb/uvc/uvc_driver.c

2123

struct uvc_video_chain *chain)

drivers/media/usb/uvc/uvc_driver.c

2129

list_for_each_entry(term, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_driver.c

2141

stream->chain = chain;

drivers/media/usb/uvc/uvc_driver.c

2160

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_driver.c

2163

list_for_each_entry(chain, &dev->chains, list) {

drivers/media/usb/uvc/uvc_driver.c

2164

ret = uvc_register_terms(dev, chain);

drivers/media/usb/uvc/uvc_driver.c

2169

ret = uvc_mc_register_entities(chain);

drivers/media/usb/uvc/uvc_entity.c

122

ret = v4l2_device_register_subdev(&chain->dev->vdev,

drivers/media/usb/uvc/uvc_entity.c

135

int uvc_mc_register_entities(struct uvc_video_chain *chain)

drivers/media/usb/uvc/uvc_entity.c

140

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_entity.c

141

ret = uvc_mc_init_entity(chain, entity);

drivers/media/usb/uvc/uvc_entity.c

143

dev_info(&chain->dev->intf->dev,

drivers/media/usb/uvc/uvc_entity.c

150

list_for_each_entry(entity, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_entity.c

151

ret = uvc_mc_create_links(chain, entity);

drivers/media/usb/uvc/uvc_entity.c

153

dev_info(&chain->dev->intf->dev,

drivers/media/usb/uvc/uvc_entity.c

17

static int uvc_mc_create_links(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_entity.c

39

remote = uvc_entity_by_id(chain->dev, entity->baSourceID[i]);

drivers/media/usb/uvc/uvc_entity.c

70

static int uvc_mc_init_entity(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_metadata.c

31

struct uvc_video_chain *chain = stream->chain;

drivers/media/usb/uvc/uvc_metadata.c

37

| chain->caps;

drivers/media/usb/uvc/uvc_status.c

145

struct uvc_video_chain **chain)

drivers/media/usb/uvc/uvc_status.c

147

list_for_each_entry((*chain), &dev->chains, list) {

drivers/media/usb/uvc/uvc_status.c

151

list_for_each_entry(entity, &(*chain)->entities, chain) {

drivers/media/usb/uvc/uvc_status.c

170

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvc_status.c

184

ctrl = uvc_event_find_ctrl(dev, status, &chain);

drivers/media/usb/uvc/uvc_status.c

190

return uvc_ctrl_status_event_async(urb, chain, ctrl,

drivers/media/usb/uvc/uvc_status.c

344

uvc_ctrl_status_event(w->chain, w->ctrl, w->data);

drivers/media/usb/uvc/uvc_status.c

356

uvc_ctrl_status_event(w->chain, w->ctrl, w->data);

drivers/media/usb/uvc/uvc_v4l2.c

1044

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

1049

return uvc_ioctl_xu_ctrl_map(chain, arg);

drivers/media/usb/uvc/uvc_v4l2.c

1052

return uvc_xu_ctrl_query(chain, arg);

drivers/media/usb/uvc/uvc_v4l2.c

110

ret = uvc_ctrl_add_mapping(chain, map);

drivers/media/usb/uvc/uvc_v4l2.c

1166

ret = uvc_ioctl_xu_ctrl_map(handle->chain, &karg.xmap);

drivers/media/usb/uvc/uvc_v4l2.c

1178

ret = uvc_xu_ctrl_query(handle->chain, &karg.xqry);

drivers/media/usb/uvc/uvc_v4l2.c

124

static int uvc_ioctl_xu_ctrl_map(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_v4l2.c

131

uvc_dbg(chain->dev, CONTROL,

drivers/media/usb/uvc/uvc_v4l2.c

161

ret = uvc_ctrl_add_mapping(chain, map);

drivers/media/usb/uvc/uvc_v4l2.c

165

ret = uvc_control_add_xu_mapping(chain, map, xmap);

drivers/media/usb/uvc/uvc_v4l2.c

169

uvc_dbg(chain->dev, CONTROL,

drivers/media/usb/uvc/uvc_v4l2.c

50

static int uvc_control_add_xu_mapping(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_v4l2.c

581

handle->chain = stream->chain;

drivers/media/usb/uvc/uvc_v4l2.c

606

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

613

| chain->caps;

drivers/media/usb/uvc/uvc_v4l2.c

656

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

657

const struct uvc_entity *selector = chain->selector;

drivers/media/usb/uvc/uvc_v4l2.c

663

(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {

drivers/media/usb/uvc/uvc_v4l2.c

666

list_for_each_entry(it, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_v4l2.c

673

list_for_each_entry(it, &chain->entities, chain) {

drivers/media/usb/uvc/uvc_v4l2.c

698

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

702

if (chain->selector == NULL ||

drivers/media/usb/uvc/uvc_v4l2.c

703

(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {

drivers/media/usb/uvc/uvc_v4l2.c

712

ret = uvc_query_ctrl(chain->dev, UVC_GET_CUR, chain->selector->id,

drivers/media/usb/uvc/uvc_v4l2.c

713

chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL,

drivers/media/usb/uvc/uvc_v4l2.c

727

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

734

if (chain->selector == NULL ||

drivers/media/usb/uvc/uvc_v4l2.c

735

(chain->dev->quirks & UVC_QUIRK_IGNORE_SELECTOR_UNIT)) {

drivers/media/usb/uvc/uvc_v4l2.c

741

if (input >= chain->selector->bNrInPins)

drivers/media/usb/uvc/uvc_v4l2.c

749

ret = uvc_query_ctrl(chain->dev, UVC_SET_CUR, chain->selector->id,

drivers/media/usb/uvc/uvc_v4l2.c

750

chain->dev->intfnum, UVC_SU_INPUT_SELECT_CONTROL,

drivers/media/usb/uvc/uvc_v4l2.c

761

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

763

return uvc_query_v4l2_ctrl(chain, qec);

drivers/media/usb/uvc/uvc_v4l2.c

766

static int uvc_ctrl_check_access(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvc_v4l2.c

775

ret = uvc_ctrl_is_accessible(chain, ctrl->id, ctrls, which,

drivers/media/usb/uvc/uvc_v4l2.c

790

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

810

ret = uvc_ctrl_check_access(chain, ctrls, which, VIDIOC_G_EXT_CTRLS);

drivers/media/usb/uvc/uvc_v4l2.c

814

ret = uvc_ctrl_begin(chain);

drivers/media/usb/uvc/uvc_v4l2.c

819

ret = uvc_ctrl_get(chain, which, ctrl);

drivers/media/usb/uvc/uvc_v4l2.c

837

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

844

ret = uvc_ctrl_check_access(chain, ctrls, V4L2_CTRL_WHICH_CUR_VAL,

drivers/media/usb/uvc/uvc_v4l2.c

849

ret = uvc_ctrl_begin(chain);

drivers/media/usb/uvc/uvc_v4l2.c

891

struct uvc_video_chain *chain = handle->chain;

drivers/media/usb/uvc/uvc_v4l2.c

893

return uvc_query_v4l2_menu(chain, qm);

drivers/media/usb/uvc/uvcvideo.h

144

(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

188

struct list_head chain; /* Entity as part of a video device chain. */

drivers/media/usb/uvc/uvcvideo.h

457

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvcvideo.h

621

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvcvideo.h

631

struct uvc_video_chain *chain;

drivers/media/usb/uvc/uvcvideo.h

716

int uvc_mc_register_entities(struct uvc_video_chain *chain);

drivers/media/usb/uvc/uvcvideo.h

758

int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

760

int uvc_query_v4l2_menu(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

763

int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

768

bool uvc_ctrl_status_event_async(struct urb *urb, struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

770

void uvc_ctrl_status_event(struct uvc_video_chain *chain,

drivers/media/usb/uvc/uvcvideo.h

773

int uvc_ctrl_begin(struct uvc_video_chain *chain);

drivers/media/usb/uvc/uvcvideo.h

786

int uvc_ctrl_get(struct uvc_video_chain *chain, u32 which,

drivers/media/usb/uvc/uvcvideo.h

789

int uvc_ctrl_is_accessible(struct uvc_video_chain *chain, u32 v4l2_id,

drivers/media/usb/uvc/uvcvideo.h

793

int uvc_xu_ctrl_query(struct uvc_video_chain *chain,

drivers/message/fusion/mptscsih.c

1450

MPT_FRAME_HDR *chain;

drivers/message/fusion/mptscsih.c

1471

chain = (MPT_FRAME_HDR *) (ioc->ChainBuffer

drivers/message/fusion/mptscsih.c

1475

list_add_tail(&chain->u.frame.linkage.list, &ioc->FreeChainQ);

drivers/mtd/inftlcore.c

407

u16 chain, EUN;

drivers/mtd/inftlcore.c

412

for (chain = 0; chain < inftl->nb_blocks; chain++) {

drivers/mtd/inftlcore.c

413

EUN = inftl->VUtable[chain];

drivers/mtd/inftlcore.c

422

chain, EUN);

drivers/mtd/inftlcore.c

434

LongestChain = chain;

drivers/mtd/nftlcore.c

480

u16 chain, EUN;

drivers/mtd/nftlcore.c

482

for (chain = 0; chain < le32_to_cpu(nftl->MediaHdr.FormattedSize) / nftl->EraseSize; chain++) {

drivers/mtd/nftlcore.c

483

EUN = nftl->EUNtable[chain];

drivers/mtd/nftlcore.c

492

chain, EUN);

drivers/mtd/nftlcore.c

505

LongestChain = chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4575

struct hnae3_ring_chain_node *chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4586

chain = devm_kzalloc(&pdev->dev, sizeof(*chain), GFP_KERNEL);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4587

if (!chain)

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4590

cur_chain->next = chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4592

*head = chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4593

chain->tqp_index = ring->tqp->tqp_index;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4594

hnae3_set_bit(chain->flag, HNAE3_RING_TYPE_B,

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4596

hnae3_set_field(chain->int_gl_idx,

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4600

cur_chain = chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4613

struct hnae3_ring_chain_node *chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4625

chain = cur_chain->next;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4627

cur_chain = chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4637

struct hnae3_ring_chain_node *chain_tmp, *chain;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4639

chain = head;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4641

while (chain) {

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4642

chain_tmp = chain->next;

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4643

devm_kfree(&pdev->dev, chain);

drivers/net/ethernet/hisilicon/hns3/hns3_enet.c

4644

chain = chain_tmp;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

159

struct hnae3_ring_chain_node *chain_tmp, *chain;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

161

chain = head->next;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

163

while (chain) {

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

164

chain_tmp = chain->next;

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

165

kfree_sensitive(chain);

drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

166

chain = chain_tmp;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

100

prod_idx |= HINIC_API_CMD_PI_SET(chain->prod_idx, IDX);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

105

static u32 get_hw_cons_idx(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

109

addr = HINIC_CSR_API_CMD_STATUS_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

110

val = hinic_hwif_read_reg(chain->hwif, addr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

115

static void dump_api_chain_reg(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

119

addr = HINIC_CSR_API_CMD_STATUS_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

120

val = hinic_hwif_read_reg(chain->hwif, addr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

122

dev_err(&chain->hwif->pdev->dev, "Chain type: 0x%x, cpld error: 0x%x, check error: 0x%x, current fsm: 0x%x\n",

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

123

chain->chain_type, HINIC_API_CMD_STATUS_GET(val, CPLD_ERR),

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

127

dev_err(&chain->hwif->pdev->dev, "Chain hw current ci: 0x%x\n",

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

130

addr = HINIC_CSR_API_CMD_CHAIN_PI_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

131

val = hinic_hwif_read_reg(chain->hwif, addr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

132

dev_err(&chain->hwif->pdev->dev, "Chain hw current pi: 0x%x\n", val);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

141

static int chain_busy(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

143

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

147

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

149

chain->cons_idx = get_hw_cons_idx(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

150

prod_idx = chain->prod_idx;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

153

if (chain->cons_idx == MASKED_IDX(chain, prod_idx + 1)) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

155

chain->chain_type, chain->cons_idx,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

156

chain->prod_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

157

dump_api_chain_reg(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

222

static void prepare_api_cmd(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

226

struct hinic_api_cmd_cell *cell = chain->curr_node;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

228

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

231

cell_ctxt = &chain->cell_ctxt[chain->prod_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

233

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

266

static void prepare_cell(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

270

struct hinic_api_cmd_cell *curr_node = chain->curr_node;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

271

u16 data_size = get_cell_data_size(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

274

prepare_api_cmd(chain, dest, cmd, cmd_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

277

static inline void cmd_chain_prod_idx_inc(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

279

chain->prod_idx = MASKED_IDX(chain, chain->prod_idx + 1);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

286

static void api_cmd_status_update(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

290

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

295

wb_status = chain->wb_status;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

310

chain->cons_idx = HINIC_API_CMD_STATUS_GET(status, CONS_IDX);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

319

static int wait_for_status_poll(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

326

api_cmd_status_update(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

329

if (chain->cons_idx == chain->prod_idx) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

346

static int wait_for_api_cmd_completion(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

348

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

352

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

354

err = wait_for_status_poll(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

357

dump_api_chain_reg(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

380

static int api_cmd(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

386

down(&chain->sem);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

387

if (chain_busy(chain)) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

388

up(&chain->sem);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

392

prepare_cell(chain, dest, cmd, cmd_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

393

cmd_chain_prod_idx_inc(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

397

set_prod_idx(chain); /* issue the command */

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

399

ctxt = &chain->cell_ctxt[chain->prod_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

401

chain->curr_node = ctxt->cell_vaddr;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

403

err = wait_for_api_cmd_completion(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

405

up(&chain->sem);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

418

int hinic_api_cmd_write(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

422

if (chain->chain_type == HINIC_API_CMD_WRITE_TO_MGMT_CPU)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

423

return api_cmd(chain, dest, cmd, size);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

434

static int api_cmd_hw_restart(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

436

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

442

reg_addr = HINIC_CSR_API_CMD_CHAIN_REQ_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

469

static void api_cmd_ctrl_init(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

471

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

476

addr = HINIC_CSR_API_CMD_CHAIN_CTRL_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

478

cell_size = API_CMD_CELL_SIZE_VAL(chain->cell_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

49

#define MASKED_IDX(chain, idx) ((idx) & ((chain)->num_cells - 1))

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

499

static void api_cmd_set_status_addr(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

501

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

504

addr = HINIC_CSR_API_CMD_STATUS_HI_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

505

val = upper_32_bits(chain->wb_status_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

508

addr = HINIC_CSR_API_CMD_STATUS_LO_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

509

val = lower_32_bits(chain->wb_status_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

517

static void api_cmd_set_num_cells(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

519

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

522

addr = HINIC_CSR_API_CMD_CHAIN_NUM_CELLS_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

523

val = chain->num_cells;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

531

static void api_cmd_head_init(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

533

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

536

addr = HINIC_CSR_API_CMD_CHAIN_HEAD_HI_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

537

val = upper_32_bits(chain->head_cell_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

540

addr = HINIC_CSR_API_CMD_CHAIN_HEAD_LO_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

541

val = lower_32_bits(chain->head_cell_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

549

static void api_cmd_chain_hw_clean(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

551

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

554

addr = HINIC_CSR_API_CMD_CHAIN_CTRL_ADDR(chain->chain_type);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

572

static int api_cmd_chain_hw_init(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

574

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

578

api_cmd_chain_hw_clean(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

580

api_cmd_set_status_addr(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

582

err = api_cmd_hw_restart(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

588

api_cmd_ctrl_init(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

589

api_cmd_set_num_cells(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

590

api_cmd_head_init(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

599

static void free_cmd_buf(struct hinic_api_cmd_chain *chain, int cell_idx)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

602

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

605

cell_ctxt = &chain->cell_ctxt[cell_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

620

static int alloc_cmd_buf(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

624

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

635

cell_ctxt = &chain->cell_ctxt[cell_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

641

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

649

free_cmd_buf(chain, cell_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

666

static int api_cmd_create_cell(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

672

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

678

node = dma_alloc_coherent(&pdev->dev, chain->cell_size, &node_paddr,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

685

cell_ctxt = &chain->cell_ctxt[cell_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

690

chain->head_cell_paddr = node_paddr;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

691

chain->head_node = node;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

697

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

699

err = alloc_cmd_buf(chain, node, cell_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

716

dma_free_coherent(&pdev->dev, chain->cell_size, node, node_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

725

static void api_cmd_destroy_cell(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

729

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

735

cell_ctxt = &chain->cell_ctxt[cell_idx];

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

739

node_size = chain->cell_size;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

742

switch (chain->chain_type) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

744

free_cmd_buf(chain, cell_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

761

static void api_cmd_destroy_cells(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

767

api_cmd_destroy_cell(chain, cell_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

776

static int api_cmd_create_cells(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

779

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

783

for (cell_idx = 0; cell_idx < chain->num_cells; cell_idx++) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

784

err = api_cmd_create_cell(chain, cell_idx, pre_node, &node);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

794

node->next_cell_paddr = cpu_to_be64(chain->head_cell_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

797

chain->curr_node = chain->head_node;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

801

api_cmd_destroy_cells(chain, cell_idx);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

812

static int api_chain_init(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

818

chain->hwif = hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

819

chain->chain_type = attr->chain_type;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

820

chain->num_cells = attr->num_cells;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

821

chain->cell_size = attr->cell_size;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

823

chain->prod_idx = 0;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

824

chain->cons_idx = 0;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

826

sema_init(&chain->sem, 1);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

828

chain->cell_ctxt = devm_kcalloc(&pdev->dev, chain->num_cells,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

829

sizeof(*chain->cell_ctxt), GFP_KERNEL);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

830

if (!chain->cell_ctxt)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

833

chain->wb_status = dma_alloc_coherent(&pdev->dev,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

834

sizeof(*chain->wb_status),

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

835

&chain->wb_status_paddr,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

837

if (!chain->wb_status) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

849

static void api_chain_free(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

851

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

854

dma_free_coherent(&pdev->dev, sizeof(*chain->wb_status),

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

855

chain->wb_status, chain->wb_status_paddr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

869

struct hinic_api_cmd_chain *chain;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

877

chain = devm_kzalloc(&pdev->dev, sizeof(*chain), GFP_KERNEL);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

878

if (!chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

881

err = api_chain_init(chain, attr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

887

err = api_cmd_create_cells(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

89

static void set_prod_idx(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

893

err = api_cmd_chain_hw_init(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

899

return chain;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

902

api_cmd_destroy_cells(chain, chain->num_cells);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

905

api_chain_free(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

91

enum hinic_api_cmd_chain_type chain_type = chain->chain_type;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

913

static void api_cmd_destroy_chain(struct hinic_api_cmd_chain *chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

915

api_cmd_chain_hw_clean(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

916

api_cmd_destroy_cells(chain, chain->num_cells);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

917

api_chain_free(chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

92

struct hinic_hwif *hwif = chain->hwif;

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

927

int hinic_api_cmd_init(struct hinic_api_cmd_chain **chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

949

chain[chain_type] = api_cmd_create_chain(&attr);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

950

if (IS_ERR(chain[chain_type])) {

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

953

err = PTR_ERR(chain[chain_type]);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

966

api_cmd_destroy_chain(chain[type]);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

976

void hinic_api_cmd_free(struct hinic_api_cmd_chain **chain)

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c

985

api_cmd_destroy_chain(chain[chain_type]);

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.h

195

int hinic_api_cmd_write(struct hinic_api_cmd_chain *chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.h

198

int hinic_api_cmd_init(struct hinic_api_cmd_chain **chain,

drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.h

201

void hinic_api_cmd_free(struct hinic_api_cmd_chain **chain);

drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c

207

struct hinic_api_cmd_chain *chain;

drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c

224

chain = pf_to_mgmt->cmd_chain[HINIC_API_CMD_WRITE_TO_MGMT_CPU];

drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c

225

return hinic_api_cmd_write(chain, HINIC_NODE_ID_MGMT,

drivers/net/ethernet/mellanox/mlx5/core/en/tc/act/goto.c

37

dest_chain <= attr->chain) {

drivers/net/ethernet/mellanox/mlx5/core/en/tc/post_act.c

124

post_attr->chain = 0;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/post_meter.c

132

attr->chain = 0;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/sample.c

358

per_vport_tbl_attr.chain = attr->chain;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/sample.c

379

post_attr->chain = 0;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/sample.c

415

tbl_attr.chain = attr->chain;

drivers/net/ethernet/mellanox/mlx5/core/en/tc/sample.c

556

pre_attr->chain = attr->chain;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c

2009

if (!attr->chain) {

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

1312

if (attr->chain || attr->prio)

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

1314

attr->chain, attr->prio,

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

1335

if (attr->chain || attr->prio)

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

1337

attr->chain, attr->prio,

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

1407

if (attr->chain || attr->prio)

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

1408

mlx5_chains_put_table(nic_chains, attr->chain, attr->prio,

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

1526

err = mlx5_chains_get_chain_mapping(esw_chains(esw), flow->attr->chain, &chain_mapping);

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

1927

if (!mlx5e_is_ft_flow(flow) && attr->chain > max_chain) {

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

1947

if (!attr->chain && esw_attr->int_port &&

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

1978

if (attr->chain) {

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

2181

static bool flow_requires_tunnel_mapping(u32 chain, struct flow_cls_offload *f)

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

2188

if (chain)

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

2320

if (attr->chain) {

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

2538

needs_mapping = !!flow->attr->chain;

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

2539

sets_mapping = flow_requires_tunnel_mapping(flow->attr->chain, f);

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

2551

if (!flow->attr->chain) {

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

4493

attr->chain = f->common.chain_index;

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

5699

u32 chain;

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

5701

chain = mapped_obj->type == MLX5_MAPPED_OBJ_CHAIN ? mapped_obj->chain : 0;

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

5704

if (chain || act_miss_cookie) {

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

5718

tc_skb_ext->chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h

373

u32 chain, reg_b;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h

380

chain = reg_b & MLX5E_TC_TABLE_CHAIN_TAG_MASK;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h

381

if (chain)

drivers/net/ethernet/mellanox/mlx5/core/en_tc.h

83

u32 chain;

drivers/net/ethernet/mellanox/mlx5/core/esw/vporttbl.c

10

u32 chain;

drivers/net/ethernet/mellanox/mlx5/core/esw/vporttbl.c

60

key->chain = attr->chain;

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

61

u32 chain;

drivers/net/ethernet/mellanox/mlx5/core/eswitch.h

799

u32 chain;

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

141

if (!attr->chain && esw_attr && esw_attr->int_port)

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

1500

attr.chain = 0;

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

1516

attr.chain = 0;

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

267

u32 chain, u32 prio, u32 level,

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

273

ft = mlx5_chains_get_table(chains, chain, prio, level);

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

421

esw_cleanup_chain_dest(struct mlx5_fs_chains *chains, u32 chain, u32 prio, u32 level)

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

423

mlx5_chains_put_table(chains, chain, prio, level);

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

743

fwd_attr.chain = attr->chain;

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

750

if (attr->chain || attr->prio)

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

751

fdb = mlx5_chains_get_table(chains, attr->chain,

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

787

else if (attr->chain || attr->prio)

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

788

mlx5_chains_put_table(chains, attr->chain, attr->prio, 0);

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

815

fast_fdb = mlx5_chains_get_table(chains, attr->chain, attr->prio, 0);

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

821

fwd_attr.chain = attr->chain;

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

872

mlx5_chains_put_table(chains, attr->chain, attr->prio, 0);

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

903

fwd_attr.chain = attr->chain;

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

911

mlx5_chains_put_table(chains, attr->chain, attr->prio, 0);

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

915

else if (attr->chain || attr->prio)

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

916

mlx5_chains_put_table(chains, attr->chain, attr->prio, 0);

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

3459

int chain = 0;

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

3461

while (steering->fdb_sub_ns[chain])

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

3462

++chain;

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

3464

steering->fdb_sub_ns[chain] = ns;

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

3495

int chain;

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

3505

for (chain = 0; chain < chains; chain++) {

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

153

u32 chain, u32 prio, u32 level)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

164

sz = (chain == mlx5_chains_get_nf_ft_chain(chains)) ?

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

180

(chain == 0 && prio == 1 && level == 0)) {

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

184

mlx5_get_fdb_sub_ns(chains->dev, chain) :

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

210

(int)PTR_ERR(ft), chain, prio, level, sz);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

218

create_chain_restore(struct fs_chain *chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

220

struct mlx5_eswitch *esw = chain->chains->dev->priv.eswitch;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

222

struct mlx5_fs_chains *chains = chain->chains;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

228

if (chain->chain == mlx5_chains_get_nf_ft_chain(chains) ||

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

233

err = mlx5_chains_get_chain_mapping(chains, chain->chain, &index);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

243

err = mlx5_chains_get_chain_mapping(chains, chain->chain, &index);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

249

chain->id = index;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

253

chain->restore_rule = esw_add_restore_rule(esw, chain->id);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

254

if (IS_ERR(chain->restore_rule)) {

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

255

err = PTR_ERR(chain->restore_rule);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

277

MLX5_SET(set_action_in, modact, data, chain->id);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

284

chain->miss_modify_hdr = mod_hdr;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

289

if (!IS_ERR_OR_NULL(chain->restore_rule))

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

290

mlx5_del_flow_rules(chain->restore_rule);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

293

mapping_remove(chains->chains_mapping, chain->id);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

297

static void destroy_chain_restore(struct fs_chain *chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

299

struct mlx5_fs_chains *chains = chain->chains;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

301

if (!chain->miss_modify_hdr)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

304

if (chain->restore_rule)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

305

mlx5_del_flow_rules(chain->restore_rule);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

307

mlx5_modify_header_dealloc(chains->dev, chain->miss_modify_hdr);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

308

mapping_remove(chains->chains_mapping, chain->id);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

312

mlx5_chains_create_chain(struct mlx5_fs_chains *chains, u32 chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

322

chain_s->chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

344

mlx5_chains_destroy_chain(struct fs_chain *chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

346

struct mlx5_fs_chains *chains = chain->chains;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

348

rhashtable_remove_fast(&chains_ht(chains), &chain->node,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

351

destroy_chain_restore(chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

352

kvfree(chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

356

mlx5_chains_get_chain(struct mlx5_fs_chains *chains, u32 chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

360

chain_s = rhashtable_lookup_fast(&chains_ht(chains), &chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

363

chain_s = mlx5_chains_create_chain(chains, chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

374

mlx5_chains_add_miss_rule(struct fs_chain *chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

378

struct mlx5_fs_chains *chains = chain->chains;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

383

if (mlx5_chains_ignore_flow_level_supported(chain->chains))

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

391

chain->chain != mlx5_chains_get_nf_ft_chain(chains) &&

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

393

act.modify_hdr = chain->miss_modify_hdr;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

405

struct fs_chain *chain = prio->chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

418

&chain->prios_list,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

420

miss_rules[n] = mlx5_chains_add_miss_rule(chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

43

u32 chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

437

&chain->prios_list,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

459

mlx5_chains_put_chain(struct fs_chain *chain)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

461

if (--chain->ref == 0)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

462

mlx5_chains_destroy_chain(chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

467

u32 chain, u32 prio, u32 level)

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

480

chain_s = mlx5_chains_get_chain(chains, chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

503

next_ft = (chain == mlx5_chains_get_nf_ft_chain(chains)) ?

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

518

ft = mlx5_chains_create_table(chains, chain, prio, level);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

544

prio_s->chain = chain_s;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

545

prio_s->key.chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

55

u32 chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

587

struct fs_chain *chain = prio->chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

598

mlx5_chains_put_chain(chain);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

603

mlx5_chains_get_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

611

if ((chain > mlx5_chains_get_chain_range(chains) &&

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

612

chain != mlx5_chains_get_nf_ft_chain(chains)) ||

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

621

prev_fts = mlx5_chains_get_table(chains, chain, prio, l);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

628

key.chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

636

prio_s = mlx5_chains_create_prio(chains, chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

651

mlx5_chains_put_table(chains, chain, prio, l);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

656

mlx5_chains_put_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

662

key.chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

677

mlx5_chains_put_table(chains, chain, prio, level);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

68

struct fs_chain *chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

685

chain, prio, level);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

697

u32 chain, prio, level;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

708

chain = mlx5_chains_get_chain_range(chains);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

712

return mlx5_chains_create_table(chains, chain, prio, level);

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

77

.key_offset = offsetof(struct fs_chain, chain),

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

78

.key_len = sizeof_field(struct fs_chain, chain),

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

790

mlx5_chains_get_chain_mapping(struct mlx5_fs_chains *chains, u32 chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.c

797

mapped_obj.chain = chain;

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h

43

mlx5_chains_get_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h

46

mlx5_chains_put_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h

59

mlx5_chains_get_chain_mapping(struct mlx5_fs_chains *chains, u32 chain,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h

82

mlx5_chains_get_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/mellanox/mlx5/core/lib/fs_chains.h

85

mlx5_chains_put_table(struct mlx5_fs_chains *chains, u32 chain, u32 prio,

drivers/net/ethernet/microchip/vcap/vcap_api.c

3007

struct net_device *ndev, int chain)

drivers/net/ethernet/microchip/vcap/vcap_api.c

3009

int next_chain = chain + VCAP_CID_LOOKUP_SIZE;

drivers/net/ethernet/microchip/vcap/vcap_api.c

3015

if (!(chain >= admin->first_cid && chain <= admin->last_cid))

drivers/net/ethernet/microchip/vcap/vcap_api.c

3022

if (!(ri->data.vcap_chain_id >= chain &&

drivers/net/ethernet/microchip/vcap/vcap_api.c

3066

struct net_device *ndev, int chain)

drivers/net/ethernet/microchip/vcap/vcap_api.c

3073

if (!(chain >= admin->first_cid && chain <= admin->last_cid))

drivers/net/ethernet/microchip/vcap/vcap_api.c

3079

if (ri->data.vcap_chain_id != chain)

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2219

int chain;

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2235

chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 0);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2236

KUNIT_EXPECT_EQ(test, 1000000, chain);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2238

chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1000000);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2239

KUNIT_EXPECT_EQ(test, 1100000, chain);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2241

chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1100000);

drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

2242

KUNIT_EXPECT_EQ(test, 8000000, chain);

drivers/net/ethernet/mscc/ocelot_flower.c

102

if (chain == 0)

drivers/net/ethernet/mscc/ocelot_flower.c

111

if (chain == VCAP_IS1_CHAIN(0))

drivers/net/ethernet/mscc/ocelot_flower.c

114

if (chain == VCAP_IS1_CHAIN(1))

drivers/net/ethernet/mscc/ocelot_flower.c

121

if (chain == VCAP_IS1_CHAIN(2)) {

drivers/net/ethernet/mscc/ocelot_flower.c

133

if (chain == VCAP_IS2_CHAIN(0, pag))

drivers/net/ethernet/mscc/ocelot_flower.c

138

if (chain == VCAP_IS2_CHAIN(1, pag))

drivers/net/ethernet/mscc/ocelot_flower.c

145

ocelot_find_vcap_filter_that_points_at(struct ocelot *ocelot, int chain)

drivers/net/ethernet/mscc/ocelot_flower.c

151

block_id = ocelot_chain_to_block(chain, true);

drivers/net/ethernet/mscc/ocelot_flower.c

160

filter->goto_target == chain)

drivers/net/ethernet/mscc/ocelot_flower.c

165

if (filter->goto_target == chain)

drivers/net/ethernet/mscc/ocelot_flower.c

266

int i, chain, egress_port;

drivers/net/ethernet/mscc/ocelot_flower.c

275

chain = f->common.chain_index;

drivers/net/ethernet/mscc/ocelot_flower.c

276

filter->block_id = ocelot_chain_to_block(chain, ingress);

drivers/net/ethernet/mscc/ocelot_flower.c

28

static int ocelot_chain_to_block(int chain, bool ingress)

drivers/net/ethernet/mscc/ocelot_flower.c

282

filter->lookup = ocelot_chain_to_lookup(chain);

drivers/net/ethernet/mscc/ocelot_flower.c

284

filter->pag = ocelot_chain_to_pag(chain);

drivers/net/ethernet/mscc/ocelot_flower.c

33

if (chain == 0)

drivers/net/ethernet/mscc/ocelot_flower.c

41

if (chain == 0)

drivers/net/ethernet/mscc/ocelot_flower.c

45

if (chain == VCAP_IS1_CHAIN(lookup))

drivers/net/ethernet/mscc/ocelot_flower.c

50

if (chain == VCAP_IS2_CHAIN(lookup, pag))

drivers/net/ethernet/mscc/ocelot_flower.c

53

if (chain == OCELOT_PSFP_CHAIN)

drivers/net/ethernet/mscc/ocelot_flower.c

533

chain == 0 || filter->block_id == PSFP_BLOCK_ID) {

drivers/net/ethernet/mscc/ocelot_flower.c

541

if (!ocelot_is_goto_target_valid(filter->goto_target, chain, ingress) &&

drivers/net/ethernet/mscc/ocelot_flower.c

62

static int ocelot_chain_to_lookup(int chain)

drivers/net/ethernet/mscc/ocelot_flower.c

67

if (chain == 0)

drivers/net/ethernet/mscc/ocelot_flower.c

70

return (chain / VCAP_LOOKUP) % 10;

drivers/net/ethernet/mscc/ocelot_flower.c

76

static int ocelot_chain_to_pag(int chain)

drivers/net/ethernet/mscc/ocelot_flower.c

83

if (chain == 0)

drivers/net/ethernet/mscc/ocelot_flower.c

86

lookup = ocelot_chain_to_lookup(chain);

drivers/net/ethernet/mscc/ocelot_flower.c

89

return chain - VCAP_IS2_CHAIN(lookup, 0);

drivers/net/ethernet/mscc/ocelot_flower.c

900

int chain = f->common.chain_index;

drivers/net/ethernet/mscc/ocelot_flower.c

903

if (chain && !ocelot_find_vcap_filter_that_points_at(ocelot, chain)) {

drivers/net/ethernet/mscc/ocelot_flower.c

908

block_id = ocelot_chain_to_block(chain, ingress);

drivers/net/ethernet/mscc/ocelot_flower.c

92

static bool ocelot_is_goto_target_valid(int goto_target, int chain,

drivers/net/ethernet/qlogic/qed/qed_chain.c

10

static void qed_chain_init(struct qed_chain *chain,

drivers/net/ethernet/qlogic/qed/qed_chain.c

101

dma_free_coherent(&cdev->pdev->dev, chain->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

102

chain->p_virt_addr, chain->p_phys_addr);

drivers/net/ethernet/qlogic/qed/qed_chain.c

105

static void qed_chain_free_pbl(struct qed_dev *cdev, struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

111

if (!chain->pbl.pp_addr_tbl)

drivers/net/ethernet/qlogic/qed/qed_chain.c

114

for (i = 0; i < chain->page_cnt; i++) {

drivers/net/ethernet/qlogic/qed/qed_chain.c

115

entry = chain->pbl.pp_addr_tbl + i;

drivers/net/ethernet/qlogic/qed/qed_chain.c

119

dma_free_coherent(dev, chain->page_size, entry->virt_addr,

drivers/net/ethernet/qlogic/qed/qed_chain.c

123

if (!chain->b_external_pbl)

drivers/net/ethernet/qlogic/qed/qed_chain.c

124

dma_free_coherent(dev, chain->pbl_sp.table_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

125

chain->pbl_sp.table_virt,

drivers/net/ethernet/qlogic/qed/qed_chain.c

126

chain->pbl_sp.table_phys);

drivers/net/ethernet/qlogic/qed/qed_chain.c

128

vfree(chain->pbl.pp_addr_tbl);

drivers/net/ethernet/qlogic/qed/qed_chain.c

129

chain->pbl.pp_addr_tbl = NULL;

drivers/net/ethernet/qlogic/qed/qed_chain.c

138

void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

14

memset(chain, 0, sizeof(*chain));

drivers/net/ethernet/qlogic/qed/qed_chain.c

140

switch (chain->mode) {

drivers/net/ethernet/qlogic/qed/qed_chain.c

142

qed_chain_free_next_ptr(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

145

qed_chain_free_single(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

148

qed_chain_free_pbl(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

154

qed_chain_init_mem(chain, NULL, 0);

drivers/net/ethernet/qlogic/qed/qed_chain.c

16

chain->elem_size = params->elem_size;

drivers/net/ethernet/qlogic/qed/qed_chain.c

17

chain->intended_use = params->intended_use;

drivers/net/ethernet/qlogic/qed/qed_chain.c

18

chain->mode = params->mode;

drivers/net/ethernet/qlogic/qed/qed_chain.c

19

chain->cnt_type = params->cnt_type;

drivers/net/ethernet/qlogic/qed/qed_chain.c

199

struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

206

for (i = 0; i < chain->page_cnt; i++) {

drivers/net/ethernet/qlogic/qed/qed_chain.c

207

virt = dma_alloc_coherent(dev, chain->page_size, &phys,

drivers/net/ethernet/qlogic/qed/qed_chain.c

21

chain->elem_per_page = ELEMS_PER_PAGE(params->elem_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

213

qed_chain_init_mem(chain, virt, phys);

drivers/net/ethernet/qlogic/qed/qed_chain.c

214

qed_chain_reset(chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

216

qed_chain_init_next_ptr_elem(chain, virt_prev, virt,

drivers/net/ethernet/qlogic/qed/qed_chain.c

226

qed_chain_init_next_ptr_elem(chain, virt_prev, chain->p_virt_addr,

drivers/net/ethernet/qlogic/qed/qed_chain.c

227

chain->p_phys_addr);

drivers/net/ethernet/qlogic/qed/qed_chain.c

23

chain->usable_per_page = USABLE_ELEMS_PER_PAGE(params->elem_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

233

struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

238

virt = dma_alloc_coherent(&cdev->pdev->dev, chain->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

243

qed_chain_init_mem(chain, virt, phys);

drivers/net/ethernet/qlogic/qed/qed_chain.c

244

qed_chain_reset(chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

249

static int qed_chain_alloc_pbl(struct qed_dev *cdev, struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

259

page_cnt = chain->page_cnt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

26

chain->elem_unusable = UNUSABLE_ELEMS_PER_PAGE(params->elem_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

269

chain->pbl.pp_addr_tbl = addr_tbl;

drivers/net/ethernet/qlogic/qed/qed_chain.c

271

if (chain->b_external_pbl) {

drivers/net/ethernet/qlogic/qed/qed_chain.c

272

pbl_virt = chain->pbl_sp.table_virt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

284

chain->pbl_sp.table_virt = pbl_virt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

285

chain->pbl_sp.table_phys = pbl_phys;

drivers/net/ethernet/qlogic/qed/qed_chain.c

286

chain->pbl_sp.table_size = size;

drivers/net/ethernet/qlogic/qed/qed_chain.c

29

chain->elem_per_page_mask = chain->elem_per_page - 1;

drivers/net/ethernet/qlogic/qed/qed_chain.c

290

virt = dma_alloc_coherent(dev, chain->page_size, &phys,

drivers/net/ethernet/qlogic/qed/qed_chain.c

296

qed_chain_init_mem(chain, virt, phys);

drivers/net/ethernet/qlogic/qed/qed_chain.c

297

qed_chain_reset(chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

30

chain->next_page_mask = chain->usable_per_page &

drivers/net/ethernet/qlogic/qed/qed_chain.c

31

chain->elem_per_page_mask;

drivers/net/ethernet/qlogic/qed/qed_chain.c

320

int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain,

drivers/net/ethernet/qlogic/qed/qed_chain.c

33

chain->page_size = params->page_size;

drivers/net/ethernet/qlogic/qed/qed_chain.c

34

chain->page_cnt = page_cnt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

349

qed_chain_init(chain, params, page_cnt);

drivers/net/ethernet/qlogic/qed/qed_chain.c

35

chain->capacity = chain->usable_per_page * page_cnt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

353

rc = qed_chain_alloc_next_ptr(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

356

rc = qed_chain_alloc_single(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

359

rc = qed_chain_alloc_pbl(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

36

chain->size = chain->elem_per_page * page_cnt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

368

qed_chain_free(cdev, chain);

drivers/net/ethernet/qlogic/qed/qed_chain.c

39

chain->pbl_sp.table_virt = params->ext_pbl_virt;

drivers/net/ethernet/qlogic/qed/qed_chain.c

40

chain->pbl_sp.table_phys = params->ext_pbl_phys;

drivers/net/ethernet/qlogic/qed/qed_chain.c

42

chain->b_external_pbl = true;

drivers/net/ethernet/qlogic/qed/qed_chain.c

46

static void qed_chain_init_next_ptr_elem(const struct qed_chain *chain,

drivers/net/ethernet/qlogic/qed/qed_chain.c

53

size = chain->elem_size * chain->usable_per_page;

drivers/net/ethernet/qlogic/qed/qed_chain.c

60

static void qed_chain_init_mem(struct qed_chain *chain, void *virt_addr,

drivers/net/ethernet/qlogic/qed/qed_chain.c

63

chain->p_virt_addr = virt_addr;

drivers/net/ethernet/qlogic/qed/qed_chain.c

64

chain->p_phys_addr = phys_addr;

drivers/net/ethernet/qlogic/qed/qed_chain.c

68

struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

76

size = chain->elem_size * chain->usable_per_page;

drivers/net/ethernet/qlogic/qed/qed_chain.c

77

virt = chain->p_virt_addr;

drivers/net/ethernet/qlogic/qed/qed_chain.c

78

phys = chain->p_phys_addr;

drivers/net/ethernet/qlogic/qed/qed_chain.c

80

for (i = 0; i < chain->page_cnt; i++) {

drivers/net/ethernet/qlogic/qed/qed_chain.c

88

dma_free_coherent(dev, chain->page_size, virt, phys);

drivers/net/ethernet/qlogic/qed/qed_chain.c

96

struct qed_chain *chain)

drivers/net/ethernet/qlogic/qed/qed_chain.c

98

if (!chain->p_virt_addr)

drivers/net/ethernet/qlogic/qed/qed_dev.c

2239

n_eqes = qed_chain_get_capacity(&p_hwfn->p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_dev_api.h

290

int qed_chain_alloc(struct qed_dev *cdev, struct qed_chain *chain,

drivers/net/ethernet/qlogic/qed/qed_dev_api.h

292

void qed_chain_free(struct qed_dev *cdev, struct qed_chain *chain);

drivers/net/ethernet/qlogic/qed/qed_sp.h

148

struct qed_chain chain;

drivers/net/ethernet/qlogic/qed/qed_sp.h

154

struct qed_chain chain;

drivers/net/ethernet/qlogic/qed/qed_sp.h

178

struct qed_chain chain;

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c

316

qed_chain_get_prod_idx(&p_hwfn->p_eq->chain));

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c

371

qed_chain_get_pbl_phys(&p_hwfn->p_eq->chain));

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c

372

page_cnt = (u8)qed_chain_get_page_cnt(&p_hwfn->p_eq->chain);

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c

377

qed_chain_get_pbl_phys(&p_hwfn->p_consq->chain));

drivers/net/ethernet/qlogic/qed/qed_sp_commands.c

378

page_cnt = (u8)qed_chain_get_page_cnt(&p_hwfn->p_consq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

1021

ret = qed_chain_alloc(p_hwfn->cdev, &p_consq->chain, &params);

drivers/net/ethernet/qlogic/qed/qed_spq.c

1039

qed_chain_reset(&p_hwfn->p_consq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

1047

qed_chain_free(p_hwfn->cdev, &p_hwfn->p_consq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

228

DMA_LO_LE(p_spq->chain.p_phys_addr);

drivers/net/ethernet/qlogic/qed/qed_spq.c

230

DMA_HI_LE(p_spq->chain.p_phys_addr);

drivers/net/ethernet/qlogic/qed/qed_spq.c

236

struct qed_chain *p_chain = &p_hwfn->p_spq->chain;

drivers/net/ethernet/qlogic/qed/qed_spq.c

341

struct qed_chain *p_chain = &p_eq->chain;

drivers/net/ethernet/qlogic/qed/qed_spq.c

414

ret = qed_chain_alloc(p_hwfn->cdev, &p_eq->chain, &params);

drivers/net/ethernet/qlogic/qed/qed_spq.c

435

qed_chain_reset(&p_hwfn->p_eq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

443

qed_chain_free(p_hwfn->cdev, &p_hwfn->p_eq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

503

capacity = qed_chain_get_capacity(&p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

527

qed_chain_reset(&p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

570

ret = qed_chain_alloc(cdev, &p_spq->chain, &params);

drivers/net/ethernet/qlogic/qed/qed_spq.c

577

capacity = qed_chain_get_capacity(&p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

593

qed_chain_free(cdev, &p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

615

capacity = qed_chain_get_capacity(&p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

622

qed_chain_free(p_hwfn->cdev, &p_spq->chain);

drivers/net/ethernet/qlogic/qed/qed_spq.c

759

while (qed_chain_get_elem_left(&p_spq->chain) > keep_reserve &&

drivers/net/ethernet/qlogic/qed/qed_spq.c

826

qed_chain_return_produced(&p_spq->chain);

drivers/net/ethernet/toshiba/ps3_gelic_net.c

1081

chain->tail = descr;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

1082

chain->head = descr->next;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

221

struct gelic_descr_chain *chain,

drivers/net/ethernet/toshiba/ps3_gelic_net.c

232

chain->head = start_descr;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

233

chain->tail = (descr - 1);

drivers/net/ethernet/toshiba/ps3_gelic_net.c

314

struct gelic_descr_chain *chain,

drivers/net/ethernet/toshiba/ps3_gelic_net.c

354

chain->head = start_descr;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

355

chain->tail = start_descr;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

493

struct gelic_descr_chain *chain;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

495

chain = &card->rx_chain;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

497

chain->tail = card->rx_top->prev; /* point to the last */

drivers/net/ethernet/toshiba/ps3_gelic_net.c

988

struct gelic_descr_chain *chain = &card->rx_chain;

drivers/net/ethernet/toshiba/ps3_gelic_net.c

989

struct gelic_descr *descr = chain->head;

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1198

static void ar9003_hw_manual_peak_cal(struct ath_hw *ah, u8 chain, bool is_2g)

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1211

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_GAINSTAGES(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1213

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_GAINSTAGES(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1218

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_GAINSTAGES(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1221

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_GAINSTAGES(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1228

REG_RMW_FIELD(ah, AR_PHY_65NM_RXTX2(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1230

REG_RMW_FIELD(ah, AR_PHY_65NM_RXTX2(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1236

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1238

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1240

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1244

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1248

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1252

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1261

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1265

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1269

agc_out = REG_READ_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1276

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1279

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1285

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_GAINSTAGES(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1290

REG_RMW_FIELD(ah, AR_PHY_65NM_RXTX2(chain),

drivers/net/wireless/ath/ath9k/ar9003_calib.c

1295

REG_RMW_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3638

static u16 ar9003_hw_ant_ctrl_chain_get(struct ath_hw *ah, int chain,

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3641

__le16 val = ar9003_modal_header(ah, is2ghz)->antCtrlChain[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3649

int chain;

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3714

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3715

if ((ah->rxchainmask & BIT(chain)) ||

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3716

(ah->txchainmask & BIT(chain))) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3717

value = ar9003_hw_ant_ctrl_chain_get(ah, chain,

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3719

REG_RMW_FIELD(ah, switch_chain_reg[chain],

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3838

static u16 ar9003_hw_atten_chain_get(struct ath_hw *ah, int chain,

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3845

if (chain >= 0 && chain < 3) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3847

return eep->modalHeader2G.xatten1DB[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3848

else if (eep->base_ext2.xatten1DBLow[chain] != 0) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3849

t[0] = eep->base_ext2.xatten1DBLow[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3851

t[1] = eep->modalHeader5G.xatten1DB[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3853

t[2] = eep->base_ext2.xatten1DBHigh[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3859

return eep->modalHeader5G.xatten1DB[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3866

static u16 ar9003_hw_atten_chain_get_margin(struct ath_hw *ah, int chain,

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3873

if (chain >= 0 && chain < 3) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3875

return eep->modalHeader2G.xatten1Margin[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3876

else if (eep->base_ext2.xatten1MarginLow[chain] != 0) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3877

t[0] = eep->base_ext2.xatten1MarginLow[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3879

t[1] = eep->modalHeader5G.xatten1Margin[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3881

t[2] = eep->base_ext2.xatten1MarginHigh[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

3887

return eep->modalHeader5G.xatten1Margin[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

4213

int chain;

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

4224

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

4225

if (!(ah->caps.tx_chainmask & BIT(chain)))

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

4228

val = ar9003_modal_header(ah, is2ghz)->noiseFloorThreshCh[chain];

drivers/net/wireless/ath/ath9k/ar9003_eeprom.c

4229

REG_RMW_FIELD(ah, cca_ctrl[chain],

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

305

static unsigned int ar9003_get_desired_gain(struct ath_hw *ah, int chain,

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

333

switch (chain) {

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

348

"Invalid chainmask: %d\n", chain);

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

753

int chain)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

755

u32 *paprd_table_val = caldata->pa_table[chain];

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

756

u32 small_signal_gain = caldata->small_signal_gain[chain];

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

761

if (chain == 0)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

763

else if (chain == 1)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

765

else if (chain == 2)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

773

if (chain == 0)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

775

else if (chain == 1)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

799

void ar9003_paprd_setup_gain_table(struct ath_hw *ah, int chain)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

804

desired_gain = ar9003_get_desired_gain(ah, chain, train_power);

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

822

int chain)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

824

u32 *pa_in = caldata->pa_table[chain];

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

917

struct ath9k_hw_cal_data *caldata, int chain)

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

919

u16 *small_signal_gain = &caldata->small_signal_gain[chain];

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

920

u32 *pa_table = caldata->pa_table[chain];

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

926

memset(caldata->pa_table[chain], 0, sizeof(caldata->pa_table[chain]));

drivers/net/wireless/ath/ath9k/ar9003_paprd.c

951

if (ar9003_paprd_retrain_pa_in(ah, caldata, chain))

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

106

int chain, i;

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

108

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

109

if (!(ah->caps.rx_chainmask & (1 << chain)))

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

112

ar9003_hw_rtt_load_hist_entry(ah, chain, i,

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

113

ah->caldata->rtt_table[chain][i]);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

116

i, chain, ah->caldata->rtt_table[chain][i]);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

121

static void ar9003_hw_patch_rtt(struct ath_hw *ah, int index, int chain)

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

128

if ((index != 5) || (chain >= 2))

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

131

agc = REG_READ_FIELD(ah, AR_PHY_65NM_RXRF_AGC(chain),

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

136

caldac = ah->caldata->caldac[chain];

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

137

ah->caldata->rtt_table[chain][index] &= 0xFFFF05FF;

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

139

ah->caldata->rtt_table[chain][index] |= (caldac << 4);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

142

static int ar9003_hw_rtt_fill_hist_entry(struct ath_hw *ah, u8 chain, u32 index)

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

150

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

154

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

157

if (!ath9k_hw_wait(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain),

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

162

val = MS(REG_READ(ah, AR_PHY_RTT_TABLE_SW_INTF_1_B(chain)),

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

171

int chain, i;

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

173

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

174

if (!(ah->caps.rx_chainmask & (1 << chain)))

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

177

ah->caldata->rtt_table[chain][i] =

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

178

ar9003_hw_rtt_fill_hist_entry(ah, chain, i);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

180

ar9003_hw_patch_rtt(ah, i, chain);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

184

i, chain, ah->caldata->rtt_table[chain][i]);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

193

int chain, i;

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

195

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

196

if (!(ah->caps.rx_chainmask & (1 << chain)))

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

199

ar9003_hw_rtt_load_hist_entry(ah, chain, i, 0);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

72

static void ar9003_hw_rtt_load_hist_entry(struct ath_hw *ah, u8 chain,

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

78

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_1_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

83

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

87

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

90

if (!ath9k_hw_wait(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain),

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

96

REG_WRITE(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain), val);

drivers/net/wireless/ath/ath9k/ar9003_rtt.c

99

ath9k_hw_wait(ah, AR_PHY_RTT_TABLE_SW_INTF_B(chain),

drivers/net/wireless/ath/ath9k/calib.c

55

int chain)

drivers/net/wireless/ath/ath9k/calib.c

57

s16 calib_nf = ath9k_hw_get_nf_limits(ah, chan)->cal[chain];

drivers/net/wireless/ath/ath9k/eeprom_9287.c

313

int32_t txPower, u16 chain)

drivers/net/wireless/ath/ath9k/eeprom_9287.c

334

if (chain == 0) {

drivers/net/wireless/ath/ath9k/eeprom_9287.c

344

if (chain == 1) {

drivers/net/wireless/ath/ath9k/hw.h

1125

int chain);

drivers/net/wireless/ath/ath9k/hw.h

1127

struct ath9k_hw_cal_data *caldata, int chain);

drivers/net/wireless/ath/ath9k/hw.h

1128

void ar9003_paprd_setup_gain_table(struct ath_hw *ah, int chain);

drivers/net/wireless/ath/ath9k/link.c

182

int chain;

drivers/net/wireless/ath/ath9k/link.c

190

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/link.c

191

if (!(ah->txchainmask & BIT(chain)))

drivers/net/wireless/ath/ath9k/link.c

194

ar9003_paprd_populate_single_table(ah, caldata, chain);

drivers/net/wireless/ath/ath9k/link.c

201

static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain)

drivers/net/wireless/ath/ath9k/link.c

222

txctl.paprd = BIT(chain);

drivers/net/wireless/ath/ath9k/link.c

236

chain);

drivers/net/wireless/ath/ath9k/link.c

252

int chain;

drivers/net/wireless/ath/ath9k/link.c

282

for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/ath9k/link.c

283

if (!(ah->txchainmask & BIT(chain)))

drivers/net/wireless/ath/ath9k/link.c

287

ar9003_paprd_setup_gain_table(ah, chain);

drivers/net/wireless/ath/ath9k/link.c

290

"Sending PAPRD training frame on chain %d\n", chain);

drivers/net/wireless/ath/ath9k/link.c

291

if (!ath_paprd_send_frame(sc, skb, chain))

drivers/net/wireless/ath/ath9k/link.c

296

"PAPRD not yet done on chain %d\n", chain);

drivers/net/wireless/ath/ath9k/link.c

300

ret = ar9003_paprd_create_curve(ah, caldata, chain);

drivers/net/wireless/ath/ath9k/link.c

304

chain);

drivers/net/wireless/ath/ath9k/link.c

309

chain);

drivers/net/wireless/ath/carl9170/phy.c

1123

int chain, idx, i;

drivers/net/wireless/ath/carl9170/phy.c

1155

for (chain = 0; chain < AR5416_MAX_CHAINS; chain++) {

drivers/net/wireless/ath/carl9170/phy.c

1163

cal_pier_data_2G[chain][idx];

drivers/net/wireless/ath/carl9170/phy.c

1168

cal_pier_data_5G[chain][idx];

drivers/net/wireless/ath/carl9170/phy.c

1202

carl9170_regwrite(0x1c6280 + chain * 0x1000 +

drivers/net/wireless/ath/carl9170/phy.c

1209

carl9170_regwrite(0x1c6280 + chain * 0x1000 + (i << 2),

drivers/net/wireless/broadcom/b43/phy_n.c

3487

u16 chain = 0x33;

drivers/net/wireless/broadcom/b43/phy_n.c

3490

chain = 0x11;

drivers/net/wireless/broadcom/b43/phy_n.c

3493

chain = 0x22;

drivers/net/wireless/broadcom/b43/phy_n.c

3499

chain);

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

506

for (u8 chain = 0; chain < num_chains; chain++) {

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

511

chains[chain].subbands[subband] = 0;

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

516

chains[chain].subbands[subband] =

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

215

struct iwl_per_chain_offset *chain =

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

218

chain->max_tx_power =

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

220

chain->chain_a =

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

222

chain->chain_b =

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

303

static bool iwl_ppag_value_valid(struct iwl_fw_runtime *fwrt, int chain,

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

306

s8 ppag_val = fwrt->ppag_chains[chain].subbands[subband];

drivers/net/wireless/intel/iwlwifi/mld/regulatory.c

178

for (int chain = 0; chain < IWL_NUM_CHAIN_LIMITS; chain++) {

drivers/net/wireless/intel/iwlwifi/mld/regulatory.c

180

cmd.v7.gain[chain][subband] =

drivers/net/wireless/intel/iwlwifi/mld/regulatory.c

181

fwrt->ppag_chains[chain].subbands[subband];

drivers/net/wireless/intel/iwlwifi/mld/regulatory.c

184

chain, subband, cmd.v7.gain[chain][subband]);

drivers/net/wireless/mediatek/mt76/mt7615/init.c

109

mt76_wr(dev, MT_AGG_ARDCR(chain),

drivers/net/wireless/mediatek/mt76/mt7615/init.c

119

mt76_clear(dev, MT_DMA_RCFR0(chain), MT_DMA_RCFR0_MCU_RX_TDLS);

drivers/net/wireless/mediatek/mt76/mt7615/init.c

131

mt76_rmw(dev, MT_DMA_RCFR0(chain), mask, set);

drivers/net/wireless/mediatek/mt76/mt7615/init.c

77

mt7615_init_mac_chain(struct mt7615_dev *dev, int chain)

drivers/net/wireless/mediatek/mt76/mt7615/init.c

81

if (!chain)

drivers/net/wireless/mediatek/mt76/mt7615/init.c

89

mt76_rmw(dev, MT_TMAC_TRCR(chain),

drivers/net/wireless/mediatek/mt76/mt7615/init.c

94

mt76_wr(dev, MT_AGG_ACR(chain),

drivers/net/wireless/mediatek/mt76/mt7615/init.c

99

mt76_wr(dev, MT_AGG_ARUCR(chain),

drivers/net/wireless/mediatek/mt76/mt7615/mac.c

2133

static int mt7615_dfs_start_rdd(struct mt7615_dev *dev, int chain)

drivers/net/wireless/mediatek/mt76/mt7615/mac.c

2137

err = mt76_connac_mcu_rdd_cmd(&dev->mt76, RDD_START, chain,

drivers/net/wireless/mediatek/mt76/mt7615/mac.c

2142

return mt76_connac_mcu_rdd_cmd(&dev->mt76, RDD_DET_MODE, chain,

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c

761

mt76x02_mac_get_rssi(struct mt76x02_dev *dev, s8 rssi, int chain)

drivers/net/wireless/mediatek/mt76/mt76x02_mac.c

765

rssi += cal->rssi_offset[chain];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

198

mt76x2_set_rssi_offset(struct mt76x02_dev *dev, int chain, u8 val)

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

203

dest[chain] = 0;

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

207

dest[chain] = mt76x02_sign_extend_optional(val, 7);

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

347

int chain, int offset)

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

363

t->chain[chain].tssi_slope = data[0];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

364

t->chain[chain].tssi_offset = data[1];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

365

t->chain[chain].target_power = data[2];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

366

t->chain[chain].delta =

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

377

int chain, int offset)

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

415

t->chain[chain].tssi_slope = data[0];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

416

t->chain[chain].tssi_offset = data[1];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

417

t->chain[chain].target_power = data[2];

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

418

t->chain[chain].delta =

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.c

451

t->target_power = t->chain[0].target_power;

drivers/net/wireless/mediatek/mt76/mt76x2/eeprom.h

32

} chain[MT_MAX_CHAINS];

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

160

txp_0 = txp.chain[0].target_power + txp.chain[0].delta + delta;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

161

txp_1 = txp.chain[1].target_power + txp.chain[1].delta + delta;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

176

dev->target_power_delta[0] = txp_0 - txp.chain[0].target_power;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

177

dev->target_power_delta[1] = txp_1 - txp.chain[0].target_power;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

228

t.slope0 = txp.chain[0].tssi_slope;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

229

t.offset0 = txp.chain[0].tssi_offset;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

230

t.slope1 = txp.chain[1].tssi_slope;

drivers/net/wireless/mediatek/mt76/mt76x2/phy.c

231

t.offset1 = txp.chain[1].tssi_offset;

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

4015

u8 chain, reg;

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

4017

for (chain = 0; chain < rt2x00dev->default_ant.rx_chain_num; chain++) {

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

4019

rt2x00_set_field8(&reg, BBP27_RX_CHAIN_SEL, chain);

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

9110

struct rf_reg_pair rf_reg_record[][13], u8 chain)

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

9114

if (chain == CHAIN_0) {

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

9167

} else if (chain == CHAIN_1) {

drivers/net/wireless/ralink/rt2x00/rt2800lib.c

9221

rt2x00_warn(rt2x00dev, "Unknown chain = %u\n", chain);

drivers/s390/cio/crw.c

100

crw[chain].slct, crw[chain].oflw, crw[chain].chn,

drivers/s390/cio/crw.c

101

crw[chain].rsc, crw[chain].anc, crw[chain].erc,

drivers/s390/cio/crw.c

102

crw[chain].rsid);

drivers/s390/cio/crw.c

104

if (crw[chain].oflw) {

drivers/s390/cio/crw.c

114

chain = 0;

drivers/s390/cio/crw.c

117

if (crw[0].chn && !chain) {

drivers/s390/cio/crw.c

118

chain++;

drivers/s390/cio/crw.c

122

handler = crw_handlers[crw[chain].rsc];

drivers/s390/cio/crw.c

124

handler(&crw[0], chain ? &crw[1] : NULL, 0);

drivers/s390/cio/crw.c

127

chain = crw[chain].chn ? chain + 1 : 0;

drivers/s390/cio/crw.c

66

unsigned int chain;

drivers/s390/cio/crw.c

73

chain = 0;

drivers/s390/cio/crw.c

77

if (unlikely(chain > 1)) {

drivers/s390/cio/crw.c

89

"chain\n", __func__, chain);

drivers/s390/cio/crw.c

92

chain = tmp_crw.chn ? chain + 1 : 0;

drivers/s390/cio/crw.c

95

ccode = stcrw(&crw[chain]);

drivers/s390/cio/vfio_ccw_cp.c

320

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

322

chain = kzalloc_obj(*chain);

drivers/s390/cio/vfio_ccw_cp.c

323

if (!chain)

drivers/s390/cio/vfio_ccw_cp.c

326

chain->ch_ccw = kzalloc_objs(*chain->ch_ccw, len, GFP_DMA | GFP_KERNEL);

drivers/s390/cio/vfio_ccw_cp.c

327

if (!chain->ch_ccw)

drivers/s390/cio/vfio_ccw_cp.c

330

chain->ch_pa = kzalloc_objs(*chain->ch_pa, len);

drivers/s390/cio/vfio_ccw_cp.c

331

if (!chain->ch_pa)

drivers/s390/cio/vfio_ccw_cp.c

334

list_add_tail(&chain->next, &cp->ccwchain_list);

drivers/s390/cio/vfio_ccw_cp.c

336

return chain;

drivers/s390/cio/vfio_ccw_cp.c

339

kfree(chain->ch_ccw);

drivers/s390/cio/vfio_ccw_cp.c

340

kfree(chain);

drivers/s390/cio/vfio_ccw_cp.c

344

static void ccwchain_free(struct ccwchain *chain)

drivers/s390/cio/vfio_ccw_cp.c

346

list_del(&chain->next);

drivers/s390/cio/vfio_ccw_cp.c

347

kfree(chain->ch_pa);

drivers/s390/cio/vfio_ccw_cp.c

348

kfree(chain->ch_ccw);

drivers/s390/cio/vfio_ccw_cp.c

349

kfree(chain);

drivers/s390/cio/vfio_ccw_cp.c

353

static void ccwchain_cda_free(struct ccwchain *chain, int idx)

drivers/s390/cio/vfio_ccw_cp.c

355

struct ccw1 *ccw = &chain->ch_ccw[idx];

drivers/s390/cio/vfio_ccw_cp.c

406

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

409

list_for_each_entry(chain, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

410

ccw_head = chain->ch_iova;

drivers/s390/cio/vfio_ccw_cp.c

411

if (is_cpa_within_range(tic->cda, ccw_head, chain->ch_len))

drivers/s390/cio/vfio_ccw_cp.c

418

static int ccwchain_loop_tic(struct ccwchain *chain,

drivers/s390/cio/vfio_ccw_cp.c

425

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

445

chain = ccwchain_alloc(cp, len);

drivers/s390/cio/vfio_ccw_cp.c

446

if (!chain)

drivers/s390/cio/vfio_ccw_cp.c

449

chain->ch_len = len;

drivers/s390/cio/vfio_ccw_cp.c

450

chain->ch_iova = gcda;

drivers/s390/cio/vfio_ccw_cp.c

453

memcpy(chain->ch_ccw, cp->guest_cp, len * sizeof(struct ccw1));

drivers/s390/cio/vfio_ccw_cp.c

456

ret = ccwchain_loop_tic(chain, cp);

drivers/s390/cio/vfio_ccw_cp.c

459

ccwchain_free(chain);

drivers/s390/cio/vfio_ccw_cp.c

465

static int ccwchain_loop_tic(struct ccwchain *chain, struct channel_program *cp)

drivers/s390/cio/vfio_ccw_cp.c

470

for (i = 0; i < chain->ch_len; i++) {

drivers/s390/cio/vfio_ccw_cp.c

471

tic = &chain->ch_ccw[i];

drivers/s390/cio/vfio_ccw_cp.c

759

struct ccwchain *chain, *temp;

drivers/s390/cio/vfio_ccw_cp.c

766

list_for_each_entry_safe(chain, temp, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

767

for (i = 0; i < chain->ch_len; i++) {

drivers/s390/cio/vfio_ccw_cp.c

768

page_array_unpin_free(&chain->ch_pa[i], vdev, idal_is_2k(cp));

drivers/s390/cio/vfio_ccw_cp.c

769

ccwchain_cda_free(chain, i);

drivers/s390/cio/vfio_ccw_cp.c

771

ccwchain_free(chain);

drivers/s390/cio/vfio_ccw_cp.c

814

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

823

list_for_each_entry(chain, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

824

len = chain->ch_len;

drivers/s390/cio/vfio_ccw_cp.c

826

ccw = &chain->ch_ccw[idx];

drivers/s390/cio/vfio_ccw_cp.c

827

pa = &chain->ch_pa[idx];

drivers/s390/cio/vfio_ccw_cp.c

838

chain->ch_len = idx;

drivers/s390/cio/vfio_ccw_cp.c

839

list_for_each_entry_continue(chain, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

840

chain->ch_len = 0;

drivers/s390/cio/vfio_ccw_cp.c

857

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

881

chain = list_first_entry(&cp->ccwchain_list, struct ccwchain, next);

drivers/s390/cio/vfio_ccw_cp.c

882

cpa = chain->ch_ccw;

drivers/s390/cio/vfio_ccw_cp.c

904

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

917

list_for_each_entry(chain, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

918

ccw_head = dma32_to_u32(virt_to_dma32(chain->ch_ccw));

drivers/s390/cio/vfio_ccw_cp.c

923

if (is_cpa_within_range(cpa, ccw_head, chain->ch_len + 1)) {

drivers/s390/cio/vfio_ccw_cp.c

931

cpa = dma32_add(cpa, chain->ch_iova - ccw_head);

drivers/s390/cio/vfio_ccw_cp.c

950

struct ccwchain *chain;

drivers/s390/cio/vfio_ccw_cp.c

956

list_for_each_entry(chain, &cp->ccwchain_list, next) {

drivers/s390/cio/vfio_ccw_cp.c

957

for (i = 0; i < chain->ch_len; i++)

drivers/s390/cio/vfio_ccw_cp.c

958

if (page_array_iova_pinned(&chain->ch_pa[i], iova, length))

drivers/s390/scsi/zfcp_fc.c

813

int chain, max_entries, buf_num, max_bytes;

drivers/s390/scsi/zfcp_fc.c

817

chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;

drivers/s390/scsi/zfcp_fc.c

818

buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;

drivers/s390/scsi/zfcp_fc.c

819

max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;

drivers/s390/scsi/zfcp_fc.c

820

max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE;

drivers/scsi/esas2r/esas2r.h

1193

sgc->sge.a64.chain = NULL;

drivers/scsi/esas2r/esas2r.h

611

struct atto_vda_sge *chain;

drivers/scsi/esas2r/esas2r.h

615

struct atto_physical_region_description *chain;

drivers/scsi/esas2r/esas2r_io.c

268

if (sgc->sge.a64.chain) {

drivers/scsi/esas2r/esas2r_io.c

269

sgc->sge.a64.chain->length |=

drivers/scsi/esas2r/esas2r_io.c

299

sgc->sge.a64.chain = sgc->sge.a64.last;

drivers/scsi/esas2r/esas2r_io.c

334

if (sgc->sge.a64.chain) {

drivers/scsi/esas2r/esas2r_io.c

335

sgc->sge.a64.chain->length |= cpu_to_le32(

drivers/scsi/esas2r/esas2r_io.c

432

if (sgc->sge.prd.chain) {

drivers/scsi/esas2r/esas2r_io.c

439

sgc->sge.prd.chain->ctl_len |= cpu_to_le32(

drivers/scsi/esas2r/esas2r_io.c

467

sgc->sge.prd.chain = sgc->sge.prd.curr;

drivers/scsi/esas2r/esas2r_io.c

469

sgc->sge.prd.chain->ctl_len = cpu_to_le32(PRD_CHAIN);

drivers/scsi/esas2r/esas2r_io.c

470

sgc->sge.prd.chain->address =

drivers/scsi/esas2r/esas2r_io.c

513

if (sgc->sge.prd.chain) {

drivers/scsi/esas2r/esas2r_io.c

514

sgc->sge.prd.chain->ctl_len |=

drivers/scsi/esas2r/esas2r_io.c

624

sgc->sge.prd.chain = NULL;

drivers/scsi/mpi3mr/mpi/mpi30_transport.h

307

struct mpi3_sge_common chain;

drivers/scsi/mpi3mr/mpi3mr_os.c

3691

void *sg_local, *chain;

drivers/scsi/mpi3mr/mpi3mr_os.c

3799

chain = chain_req->addr;

drivers/scsi/mpi3mr/mpi3mr_os.c

3807

sg_local = chain;

drivers/scsi/mpt3sas/mpt3sas_base.c

2722

void *sg_local, *chain;

drivers/scsi/mpt3sas/mpt3sas_base.c

2779

chain = chain_req->chain_buffer;

drivers/scsi/mpt3sas/mpt3sas_base.c

2795

sg_local = chain;

drivers/scsi/mpt3sas/mpt3sas_base.c

2819

chain = chain_req->chain_buffer;

drivers/scsi/mpt3sas/mpt3sas_base.c

2863

void *sg_local, *chain;

drivers/scsi/mpt3sas/mpt3sas_base.c

2918

chain = chain_req->chain_buffer;

drivers/scsi/mpt3sas/mpt3sas_base.c

2932

sg_local = chain;

drivers/scsi/mpt3sas/mpt3sas_base.c

2949

chain = chain_req->chain_buffer;

drivers/usb/cdns3/cdns3-gadget.c

621

u8 chain;

drivers/usb/cdns3/cdns3-gadget.c

624

chain = !!(priv_req->flags & REQUEST_INTERNAL_CH);

drivers/usb/cdns3/cdns3-gadget.c

634

if (!chain)

drivers/usb/cdns3/cdnsp-ring.c

192

u32 chain;

drivers/usb/cdns3/cdnsp-ring.c

194

chain = le32_to_cpu(ring->enqueue->generic.field[3]) & TRB_CHAIN;

drivers/usb/cdns3/cdnsp-ring.c

210

if (!chain && !more_trbs_coming)

drivers/usb/cdns3/cdnsp-ring.c

214

next->link.control |= cpu_to_le32(chain);

drivers/usb/dwc3/ep0.c

37

dma_addr_t buf_dma, u32 len, u32 type, bool chain)

drivers/usb/dwc3/ep0.c

45

if (chain)

drivers/usb/dwc3/ep0.c

56

if (chain)

drivers/usb/dwc3/gadget.c

1277

unsigned int chain, unsigned int node, bool use_bounce_buffer,

drivers/usb/dwc3/gadget.c

1359

if (!no_interrupt && !chain)

drivers/usb/dwc3/gadget.c

1392

if ((!no_interrupt && !chain) || must_interrupt)

drivers/usb/dwc3/gadget.c

1395

if (chain)

drivers/usb/gadget/udc/tegra-xudc.c

359

BUILD_TRB_RW(chain, control, 4, 0x1)

drivers/usb/host/xhci-ring.c

232

static void inc_enq_past_link(struct xhci_hcd *xhci, struct xhci_ring *ring, u32 chain)

drivers/usb/host/xhci-ring.c

249

ring->enqueue->link.control |= cpu_to_le32(chain);

drivers/usb/host/xhci-ring.c

286

u32 chain;

drivers/usb/host/xhci-ring.c

288

chain = le32_to_cpu(ring->enqueue->generic.field[3]) & TRB_CHAIN;

drivers/usb/host/xhci-ring.c

303

if (trb_is_link(ring->enqueue) && (chain || more_trbs_coming))

drivers/usb/host/xhci-ring.c

304

inc_enq_past_link(xhci, ring, chain);

drivers/video/fbdev/via/via_aux.c

47

list_for_each_entry_safe(pos, n, &bus->drivers, chain) {

drivers/video/fbdev/via/via_aux.c

51

list_del(&pos->chain);

drivers/video/fbdev/via/via_aux.c

67

list_for_each_entry(pos, &bus->drivers, chain) {

drivers/video/fbdev/via/via_aux.h

24

struct list_head chain; /* chain to support multiple drivers */

drivers/video/fbdev/via/via_aux.h

51

list_add_tail(&data->chain, &data->bus->drivers);

fs/affs/inode.c

389

__be32 chain;

fs/affs/inode.c

390

chain = AFFS_TAIL(sb, inode_bh)->link_chain;

fs/affs/inode.c

392

AFFS_TAIL(sb, bh)->link_chain = chain;

fs/affs/inode.c

394

affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));

fs/exfat/exfat_fs.h

444

int exfat_chain_cont_cluster(struct super_block *sb, unsigned int chain,

fs/exfat/fatent.c

145

int exfat_chain_cont_cluster(struct super_block *sb, unsigned int chain,

fs/exfat/fatent.c

152

if (exfat_ent_set(sb, chain, chain + 1))

fs/exfat/fatent.c

154

chain++;

fs/exfat/fatent.c

158

if (exfat_ent_set(sb, chain, EXFAT_EOF_CLUSTER))

fs/ext2/inode.c

1040

Indirect chain[4],

fs/ext2/inode.c

1049

partial = ext2_get_branch(inode, k, offsets, chain, &err);

fs/ext2/inode.c

1051

partial = chain + k-1;

fs/ext2/inode.c

1061

for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)

fs/ext2/inode.c

1069

if (p == chain + k - 1 && p > chain) {

fs/ext2/inode.c

1178

Indirect chain[4];

fs/ext2/inode.c

1207

partial = ext2_find_shared(inode, n, offsets, chain, &nr);

fs/ext2/inode.c

1210

if (partial == chain)

fs/ext2/inode.c

1214

ext2_free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);

fs/ext2/inode.c

1217

while (partial > chain) {

fs/ext2/inode.c

1221

(chain+n-1) - partial);

fs/ext2/inode.c

237

Indirect chain[4],

fs/ext2/inode.c

241

Indirect *p = chain;

fs/ext2/inode.c

246

add_chain (chain, NULL, EXT2_I(inode)->i_data + *offsets);

fs/ext2/inode.c

254

if (!verify_chain(chain, p))

fs/ext2/inode.c

631

Indirect chain[4];

fs/ext2/inode.c

648

partial = ext2_get_branch(inode, depth, offsets, chain, &err);

fs/ext2/inode.c

651

first_block = le32_to_cpu(chain[depth - 1].key);

fs/ext2/inode.c

657

if (!verify_chain(chain, chain + depth - 1)) {

fs/ext2/inode.c

666

partial = chain + depth - 1;

fs/ext2/inode.c

669

blk = le32_to_cpu(*(chain[depth-1].p + count));

fs/ext2/inode.c

696

if (err == -EAGAIN || !verify_chain(chain, partial)) {

fs/ext2/inode.c

697

while (partial > chain) {

fs/ext2/inode.c

701

partial = ext2_get_branch(inode, depth, offsets, chain, &err);

fs/ext2/inode.c

724

indirect_blks = (chain + depth) - partial - 1;

fs/ext2/inode.c

735

offsets + (partial - chain), partial);

fs/ext2/inode.c

748

le32_to_cpu(chain[depth-1].key),

fs/ext2/inode.c

756

le32_to_cpu(chain[depth-1].key), count,

fs/ext2/inode.c

772

partial = chain + depth - 1; /* the whole chain */

fs/ext2/inode.c

774

while (partial > chain) {

fs/ext2/inode.c

779

*bno = le32_to_cpu(chain[depth-1].key);

fs/ext4/indirect.c

1118

Indirect chain[4];

fs/ext4/indirect.c

1159

partial = ext4_find_shared(inode, n, offsets, chain, &nr);

fs/ext4/indirect.c

1162

if (partial == chain) {

fs/ext4/indirect.c

1165

&nr, &nr+1, (chain+n-1) - partial);

fs/ext4/indirect.c

1176

partial->p+1, (chain+n-1) - partial);

fs/ext4/indirect.c

1180

while (partial > chain) {

fs/ext4/indirect.c

1183

(chain+n-1) - partial);

fs/ext4/indirect.c

1234

Indirect chain[4], chain2[4];

fs/ext4/indirect.c

1278

partial = p = ext4_find_shared(inode, n, offsets, chain, &nr);

fs/ext4/indirect.c

1280

if (partial == chain) {

fs/ext4/indirect.c

1283

&nr, &nr+1, (chain+n-1) - partial);

fs/ext4/indirect.c

1290

partial->p+1, (chain+n-1) - partial);

fs/ext4/indirect.c

1298

while (partial > chain) {

fs/ext4/indirect.c

1302

(chain+n-1) - partial);

fs/ext4/indirect.c

1343

partial = p = ext4_find_shared(inode, n, offsets, chain, &nr);

fs/ext4/indirect.c

1348

int level = min(partial - chain, partial2 - chain2);

fs/ext4/indirect.c

1360

if (partial == chain) {

fs/ext4/indirect.c

1364

(chain+n-1) - partial);

fs/ext4/indirect.c

1372

(chain+n-1) - partial);

fs/ext4/indirect.c

1387

while (partial > chain || partial2 > chain2) {

fs/ext4/indirect.c

1388

int depth = (chain+n-1) - partial;

fs/ext4/indirect.c

1391

if (partial > chain && partial2 > chain2 &&

fs/ext4/indirect.c

1400

(chain+n-1) - partial);

fs/ext4/indirect.c

1411

if (partial > chain && depth <= depth2) {

fs/ext4/indirect.c

1415

(chain+n-1) - partial);

fs/ext4/indirect.c

1428

while (p && p > chain) {

fs/ext4/indirect.c

146

Indirect chain[4], int *err)

fs/ext4/indirect.c

149

Indirect *p = chain;

fs/ext4/indirect.c

156

add_chain(chain, NULL, EXT4_I(inode)->i_data + *offsets);

fs/ext4/indirect.c

537

Indirect chain[4];

fs/ext4/indirect.c

554

partial = ext4_get_branch(inode, depth, offsets, chain, &err);

fs/ext4/indirect.c

558

first_block = le32_to_cpu(chain[depth - 1].key);

fs/ext4/indirect.c

564

blk = le32_to_cpu(*(chain[depth-1].p + count));

fs/ext4/indirect.c

586

for (i = partial - chain + 1; i < depth; i++)

fs/ext4/indirect.c

623

indirect_blks = (chain + depth) - partial - 1;

fs/ext4/indirect.c

636

offsets + (partial - chain), partial);

fs/ext4/indirect.c

657

map->m_pblk = le32_to_cpu(chain[depth-1].key);

fs/ext4/indirect.c

663

partial = chain + depth - 1; /* the whole chain */

fs/ext4/indirect.c

665

while (partial > chain) {

fs/ext4/indirect.c

798

ext4_lblk_t offsets[4], Indirect chain[4],

fs/ext4/indirect.c

808

partial = ext4_get_branch(inode, k, offsets, chain, &err);

fs/ext4/indirect.c

811

partial = chain + k-1;

fs/ext4/indirect.c

819

for (p = partial; (p > chain) && all_zeroes((__le32 *) p->bh->b_data, p->p); p--)

fs/ext4/indirect.c

827

if (p == chain + k - 1 && p > chain) {

fs/lockd/host.c

236

struct hlist_head *chain;

fs/lockd/host.c

247

chain = &nlm_client_hosts[nlm_hash_address(sap)];

fs/lockd/host.c

248

hlist_for_each_entry(host, chain, h_hash) {

fs/lockd/host.c

273

hlist_add_head(&host->h_hash, chain);

fs/lockd/host.c

331

struct hlist_head *chain;

fs/lockd/host.c

358

chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];

fs/lockd/host.c

359

hlist_for_each_entry(host, chain, h_hash) {

fs/lockd/host.c

37

#define for_each_host(host, chain, table) \

fs/lockd/host.c

378

hlist_add_head(&host->h_hash, chain);

fs/lockd/host.c

38

for ((chain) = (table); \

fs/lockd/host.c

39

(chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \

fs/lockd/host.c

392

hlist_add_head(&host->h_hash, chain);

fs/lockd/host.c

40

hlist_for_each_entry((host), (chain), h_hash)

fs/lockd/host.c

42

#define for_each_host_safe(host, next, chain, table) \

fs/lockd/host.c

43

for ((chain) = (table); \

fs/lockd/host.c

44

(chain) < (table) + NLM_HOST_NRHASH; ++(chain)) \

fs/lockd/host.c

46

(chain), h_hash)

fs/lockd/host.c

529

struct hlist_head *chain;

fs/lockd/host.c

532

for_each_host(host, chain, cache) {

fs/lockd/host.c

584

struct hlist_head *chain;

fs/lockd/host.c

603

for_each_host(host, chain, nlm_server_hosts) {

fs/lockd/host.c

615

struct hlist_head *chain;

fs/lockd/host.c

623

for_each_host(host, chain, nlm_server_hosts) {

fs/lockd/host.c

659

struct hlist_head *chain;

fs/lockd/host.c

665

for_each_host(host, chain, nlm_server_hosts) {

fs/lockd/host.c

674

for_each_host_safe(host, next, chain, nlm_server_hosts) {

fs/minix/itree_common.c

116

Indirect chain[DEPTH],

fs/minix/itree_common.c

125

if (!verify_chain(chain, where-1) || *where->p)

fs/minix/itree_common.c

157

Indirect chain[DEPTH];

fs/minix/itree_common.c

166

partial = get_branch(inode, depth, offsets, chain, &err);

fs/minix/itree_common.c

171

map_bh(bh, inode->i_sb, block_to_cpu(chain[depth-1].key));

fs/minix/itree_common.c

173

partial = chain+depth-1; /* the whole chain */

fs/minix/itree_common.c

180

while (partial > chain) {

fs/minix/itree_common.c

196

left = (chain + depth) - partial;

fs/minix/itree_common.c

197

err = alloc_branch(inode, left, offsets+(partial-chain), partial);

fs/minix/itree_common.c

201

if (splice_branch(inode, chain, partial, left) < 0)

fs/minix/itree_common.c

208

while (partial > chain) {

fs/minix/itree_common.c

226

Indirect chain[DEPTH],

fs/minix/itree_common.c

235

partial = get_branch(inode, k, offsets, chain, &err);

fs/minix/itree_common.c

239

partial = chain + k-1;

fs/minix/itree_common.c

244

for (p=partial;p>chain && all_zeroes((block_t*)p->bh->b_data,p->p);p--)

fs/minix/itree_common.c

246

if (p == chain + k - 1 && p > chain) {

fs/minix/itree_common.c

305

Indirect chain[DEPTH];

fs/minix/itree_common.c

326

partial = find_shared(inode, n, offsets, chain, &nr);

fs/minix/itree_common.c

328

if (partial == chain)

fs/minix/itree_common.c

33

Indirect chain[DEPTH],

fs/minix/itree_common.c

332

free_branches(inode, &nr, &nr+1, (chain+n-1) - partial);

fs/minix/itree_common.c

335

while (partial > chain) {

fs/minix/itree_common.c

337

(chain+n-1) - partial);

fs/minix/itree_common.c

37

Indirect *p = chain;

fs/minix/itree_common.c

42

add_chain (chain, NULL, i_data(inode) + *offsets);

fs/minix/itree_common.c

50

if (!verify_chain(chain, p))

fs/namespace.c

860

struct hlist_head *chain = mp_hash(dentry);

fs/namespace.c

863

hlist_for_each_entry(mp, chain, m_hash) {

fs/ocfs2/ocfs2_ioctl.h

44

__u16 chain; /* Chain for this group */

fs/ocfs2/ocfs2_trace.h

797

TP_PROTO(unsigned long long i_blkno, unsigned int chain,

fs/ocfs2/ocfs2_trace.h

800

TP_ARGS(i_blkno, chain, bg_blkno, prev_blkno),

fs/ocfs2/ocfs2_trace.h

803

__field(unsigned int, chain)

fs/ocfs2/ocfs2_trace.h

809

__entry->chain = chain;

fs/ocfs2/ocfs2_trace.h

814

__entry->i_blkno, __entry->chain, __entry->bg_blkno,

fs/ocfs2/resize.c

142

chain = le16_to_cpu(group->bg_chain);

fs/ocfs2/resize.c

143

cr = (&cl->cl_recs[chain]);

fs/ocfs2/resize.c

392

if (le16_to_cpu(gd->bg_chain) != input->chain)

fs/ocfs2/resize.c

396

le16_to_cpu(gd->bg_chain), input->chain);

fs/ocfs2/resize.c

429

else if (input->chain >= cl_count)

fs/ocfs2/resize.c

431

else if (next_free != cl_count && next_free != input->chain)

fs/ocfs2/resize.c

516

input->chain, input->clusters, input->frees);

fs/ocfs2/resize.c

527

cr = &cl->cl_recs[input->chain];

fs/ocfs2/resize.c

549

if (input->chain == le16_to_cpu(cl->cl_next_free_rec)) {

fs/ocfs2/resize.c

90

u16 chain, num_bits, backups = 0;

fs/ocfs2/suballoc.c

108

u16 chain);

fs/ocfs2/suballoc.c

1531

u16 chain)

fs/ocfs2/suballoc.c

1547

(unsigned long long)le64_to_cpu(fe->i_blkno), chain,

fs/ocfs2/suballoc.c

1568

bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno;

fs/ocfs2/suballoc.c

1576

fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno;

fs/ocfs2/suballoc.c

1704

u16 chain)

fs/ocfs2/suballoc.c

1720

le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits);

fs/ocfs2/suballoc.c

1730

u16 chain)

fs/ocfs2/suballoc.c

1739

le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits);

fs/ocfs2/suballoc.c

1869

u16 chain;

fs/ocfs2/suballoc.c

1879

chain = ac->ac_chain;

fs/ocfs2/suballoc.c

1882

bits_wanted, chain);

fs/ocfs2/suballoc.c

1885

le64_to_cpu(cl->cl_recs[chain].c_blkno),

fs/ocfs2/suballoc.c

1967

prev_group_bh, chain);

fs/ocfs2/suballoc.c

1979

chain);

fs/ocfs2/suballoc.c

1995

ac->ac_bh, res->sr_bits, chain);

fs/ocfs2/suballoc.c

2303

u16 chain;

fs/ocfs2/suballoc.c

2325

chain = le16_to_cpu(bg->bg_chain);

fs/ocfs2/suballoc.c

2329

chain);

fs/ocfs2/suballoc.c

2345

ac->ac_bh, res->sr_bits, chain);

fs/ocfs2/suballoc.h

78

u16 chain);

fs/ocfs2/suballoc.h

82

u16 chain);

fs/ufs/inode.c

132

Indirect chain[4], *q = chain;

fs/ufs/inode.c

150

if (!grow_chain32(ufsi, NULL, &ufsi->i_u1.i_data[*p++], chain, q))

fs/ufs/inode.c

164

if (!grow_chain32(ufsi, bh, ptr, chain, ++q))

fs/ufs/inode.c

173

if (!grow_chain64(ufsi, NULL, &ufsi->i_u1.u2_i_data[*p++], chain, q))

fs/ufs/inode.c

188

if (!grow_chain64(ufsi, bh, ptr, chain, ++q))

fs/ufs/inode.c

197

while (q > chain) {

fs/ufs/inode.c

204

while (q > chain) {

fs/xfs/xfs_hooks.c

18

struct xfs_hooks *chain)

fs/xfs/xfs_hooks.c

20

BLOCKING_INIT_NOTIFIER_HEAD(&chain->head);

fs/xfs/xfs_hooks.c

26

struct xfs_hooks *chain,

fs/xfs/xfs_hooks.c

32

return blocking_notifier_chain_register(&chain->head, &hook->nb);

fs/xfs/xfs_hooks.c

38

struct xfs_hooks *chain,

fs/xfs/xfs_hooks.c

41

blocking_notifier_chain_unregister(&chain->head, &hook->nb);

fs/xfs/xfs_hooks.c

47

struct xfs_hooks *chain,

fs/xfs/xfs_hooks.c

51

return blocking_notifier_call_chain(&chain->head, val, priv);

fs/xfs/xfs_hooks.h

40

void xfs_hooks_init(struct xfs_hooks *chain);

fs/xfs/xfs_hooks.h

41

int xfs_hooks_add(struct xfs_hooks *chain, struct xfs_hook *hook);

fs/xfs/xfs_hooks.h

42

void xfs_hooks_del(struct xfs_hooks *chain, struct xfs_hook *hook);

fs/xfs/xfs_hooks.h

43

int xfs_hooks_call(struct xfs_hooks *chain, unsigned long action,

fs/xfs/xfs_hooks.h

61

# define xfs_hooks_init(chain) ((void)0)

fs/xfs/xfs_hooks.h

62

# define xfs_hooks_call(chain, val, priv) (NOTIFY_DONE)

include/crypto/acompress.h

439

sg_init_table(&req->chain.ssg, 1);

include/crypto/acompress.h

440

sg_set_folio(&req->chain.ssg, folio, len, off);

include/crypto/acompress.h

441

acomp_request_set_src_sg(req, &req->chain.ssg, len);

include/crypto/acompress.h

518

sg_init_table(&req->chain.dsg, 1);

include/crypto/acompress.h

519

sg_set_folio(&req->chain.dsg, folio, len, off);

include/crypto/acompress.h

520

acomp_request_set_dst_sg(req, &req->chain.dsg, len);

include/crypto/acompress.h

98

struct acomp_req_chain chain;

include/drm/drm_syncobj.h

121

struct dma_fence_chain *chain,

include/linux/dma-fence-chain.h

105

static inline void dma_fence_chain_free(struct dma_fence_chain *chain)

include/linux/dma-fence-chain.h

107

kfree(chain);

include/linux/dma-fence-chain.h

126

void dma_fence_chain_init(struct dma_fence_chain *chain,

include/linux/dma-fence-chain.h

79

struct dma_fence_chain *chain = to_dma_fence_chain(fence);

include/linux/dma-fence-chain.h

81

return chain ? chain->fence : fence;

include/linux/dma-fence-unwrap.h

22

struct dma_fence *chain;

include/linux/platform_data/dma-iop32x.h

57

struct list_head chain;

include/linux/qed/qed_chain.h

186

static inline u16 qed_chain_get_prod_idx(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

188

return chain->u.chain16.prod_idx;

include/linux/qed/qed_chain.h

191

static inline u16 qed_chain_get_cons_idx(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

193

return chain->u.chain16.cons_idx;

include/linux/qed/qed_chain.h

196

static inline u32 qed_chain_get_prod_idx_u32(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

198

return chain->u.chain32.prod_idx;

include/linux/qed/qed_chain.h

201

static inline u32 qed_chain_get_cons_idx_u32(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

203

return chain->u.chain32.cons_idx;

include/linux/qed/qed_chain.h

206

static inline u16 qed_chain_get_elem_used(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

208

u32 prod = qed_chain_get_prod_idx(chain);

include/linux/qed/qed_chain.h

209

u32 cons = qed_chain_get_cons_idx(chain);

include/linux/qed/qed_chain.h

210

u16 elem_per_page = chain->elem_per_page;

include/linux/qed/qed_chain.h

217

if (chain->mode == QED_CHAIN_MODE_NEXT_PTR)

include/linux/qed/qed_chain.h

223

static inline u16 qed_chain_get_elem_left(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

225

return (u16)(chain->capacity - qed_chain_get_elem_used(chain));

include/linux/qed/qed_chain.h

228

static inline u32 qed_chain_get_elem_used_u32(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

230

u64 prod = qed_chain_get_prod_idx_u32(chain);

include/linux/qed/qed_chain.h

231

u64 cons = qed_chain_get_cons_idx_u32(chain);

include/linux/qed/qed_chain.h

232

u16 elem_per_page = chain->elem_per_page;

include/linux/qed/qed_chain.h

239

if (chain->mode == QED_CHAIN_MODE_NEXT_PTR)

include/linux/qed/qed_chain.h

245

static inline u32 qed_chain_get_elem_left_u32(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

247

return chain->capacity - qed_chain_get_elem_used_u32(chain);

include/linux/qed/qed_chain.h

250

static inline u16 qed_chain_get_usable_per_page(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

252

return chain->usable_per_page;

include/linux/qed/qed_chain.h

255

static inline u8 qed_chain_get_unusable_per_page(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

257

return chain->elem_unusable;

include/linux/qed/qed_chain.h

260

static inline u32 qed_chain_get_page_cnt(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

262

return chain->page_cnt;

include/linux/qed/qed_chain.h

265

static inline dma_addr_t qed_chain_get_pbl_phys(const struct qed_chain *chain)

include/linux/qed/qed_chain.h

267

return chain->pbl_sp.table_phys;

include/linux/qed/qed_if.h

992

struct qed_chain *chain,

include/linux/skbuff.h

325

__u32 chain;

include/net/inet_hashtables.h

130

struct hlist_head chain;

include/net/inet_hashtables.h

40

struct hlist_nulls_head chain;

include/net/ip6_fib.h

132

struct hlist_head chain;

include/net/ip_fib.h

76

struct fib_nh_exception __rcu *chain;

include/net/netfilter/nf_tables.h

1085

const struct nft_chain *chain; /* for nftables tracing */

include/net/netfilter/nf_tables.h

1163

int nft_chain_validate(const struct nft_ctx *ctx, struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1168

int nf_tables_bind_chain(const struct nft_ctx *ctx, struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1169

void nf_tables_unbind_chain(const struct nft_ctx *ctx, struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1194

int nft_chain_validate_dependency(const struct nft_chain *chain,

include/net/netfilter/nf_tables.h

1196

int nft_chain_validate_hooks(const struct nft_chain *chain,

include/net/netfilter/nf_tables.h

1199

static inline bool nft_chain_binding(const struct nft_chain *chain)

include/net/netfilter/nf_tables.h

1201

return chain->flags & NFT_CHAIN_BINDING;

include/net/netfilter/nf_tables.h

1204

static inline bool nft_chain_is_bound(struct nft_chain *chain)

include/net/netfilter/nf_tables.h

1206

return (chain->flags & NFT_CHAIN_BINDING) && chain->bound;

include/net/netfilter/nf_tables.h

1209

int nft_chain_add(struct nft_table *table, struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1210

void nft_chain_del(struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1211

void nf_tables_chain_destroy(struct nft_chain *chain);

include/net/netfilter/nf_tables.h

1251

struct nft_chain chain;

include/net/netfilter/nf_tables.h

1255

static inline struct nft_base_chain *nft_base_chain(const struct nft_chain *chain)

include/net/netfilter/nf_tables.h

1257

return container_of(chain, struct nft_base_chain, chain);

include/net/netfilter/nf_tables.h

1260

static inline bool nft_is_base_chain(const struct nft_chain *chain)

include/net/netfilter/nf_tables.h

1262

return chain->flags & NFT_CHAIN_BASE;

include/net/netfilter/nf_tables.h

1694

struct nft_chain *chain;

include/net/netfilter/nf_tables.h

1711

nft_trans_container_rule(trans)->chain

include/net/netfilter/nf_tables.h

1744

struct nft_chain *chain;

include/net/netfilter/nf_tables.h

1758

nft_trans_container_chain(trans)->chain

include/net/netfilter/nf_tables.h

1876

ctx->chain = nft_trans_rule_chain(trans);

include/net/netfilter/nf_tables.h

1881

ctx->chain = nft_trans_chain(trans);

include/net/netfilter/nf_tables.h

1884

ctx->chain = NULL;

include/net/netfilter/nf_tables.h

216

struct nft_chain *chain;

include/net/netfilter/nf_tables.h

674

const struct nft_chain *chain;

include/net/netfilter/nf_tables.h

98

struct nft_chain *chain;

include/net/netfilter/nf_tables_offload.h

75

int nft_flow_rule_stats(const struct nft_chain *chain, const struct nft_rule *rule);

include/net/pkt_cls.h

182

struct Qdisc *q = tp->chain->block->q;

include/net/pkt_cls.h

206

struct Qdisc *q = tp->chain->block->q;

include/net/pkt_cls.h

49

void tcf_chain_put_by_act(struct tcf_chain *chain);

include/net/pkt_cls.h

51

struct tcf_chain *chain);

include/net/pkt_cls.h

52

struct tcf_proto *tcf_get_next_proto(struct tcf_chain *chain,

include/net/pkt_cls.h

757

cls_common->chain_index = tp->chain->index;

include/net/sch_generic.h

388

struct tcf_chain *chain,

include/net/sch_generic.h

392

void (*tmplt_reoffload)(struct tcf_chain *chain,

include/net/sch_generic.h

438

struct tcf_chain *chain;

include/net/sch_generic.h

503

struct tcf_chain *chain;

include/net/sch_generic.h

513

static inline bool lockdep_tcf_chain_is_locked(struct tcf_chain *chain)

include/net/sch_generic.h

515

return lockdep_is_held(&chain->filter_chain_lock);

include/net/sch_generic.h

523

#define tcf_chain_dereference(p, chain) \

include/net/sch_generic.h

524

rcu_dereference_protected(p, lockdep_tcf_chain_is_locked(chain))

include/net/sctp/structs.h

100

struct hlist_head chain;

include/net/sctp/structs.h

94

struct hlist_head chain;

include/rdma/uverbs_ioctl.h

351

const struct uapi_definition *chain;

include/rdma/uverbs_ioctl.h

427

.kind = UAPI_DEF_CHAIN, .chain = _def_var, \

include/uapi/linux/virtio_crypto.h

269

struct virtio_crypto_alg_chain_session_req chain;

include/uapi/linux/virtio_crypto.h

446

struct virtio_crypto_alg_chain_data_req chain;

kernel/cpu_pm.c

22

struct raw_notifier_head chain;

kernel/cpu_pm.c

25

.chain = RAW_NOTIFIER_INIT(cpu_pm_notifier.chain),

kernel/cpu_pm.c

34

ret = raw_notifier_call_chain(&cpu_pm_notifier.chain, event, NULL);

kernel/cpu_pm.c

46

ret = raw_notifier_call_chain_robust(&cpu_pm_notifier.chain, event_up, event_down, NULL);

kernel/cpu_pm.c

67

ret = raw_notifier_chain_register(&cpu_pm_notifier.chain, nb);

kernel/cpu_pm.c

87

ret = raw_notifier_chain_unregister(&cpu_pm_notifier.chain, nb);

kernel/futex/core.c

1523

plist_head_init(&fhb->chain);

kernel/futex/core.c

213

plist_for_each_entry_safe(this, tmp, &hb_old->chain, list) {

kernel/futex/core.c

215

plist_del(&this->list, &hb_old->chain);

kernel/futex/core.c

227

plist_add(&this->list, &hb_new->chain);

kernel/futex/core.c

808

plist_for_each_entry(this, &hb->chain, list) {

kernel/futex/core.c

861

plist_del(&q->list, &hb->chain);

kernel/futex/core.c

907

plist_add(&q->list, &hb->chain);

kernel/futex/futex.h

137

struct plist_head chain;

kernel/futex/requeue.c

586

plist_for_each_entry_safe(this, next, &hb1->chain, list) {

kernel/futex/requeue.c

727

plist_del(&q->list, &hb->chain);

kernel/futex/requeue.c

84

if (likely(&hb1->chain != &hb2->chain)) {

kernel/futex/requeue.c

85

plist_del(&q->list, &hb1->chain);

kernel/futex/requeue.c

88

plist_add(&q->list, &hb2->chain);

kernel/futex/waitwake.c

180

plist_for_each_entry_safe(this, next, &hb->chain, list) {

kernel/futex/waitwake.c

299

plist_for_each_entry_safe(this, next, &hb1->chain, list) {

kernel/futex/waitwake.c

313

plist_for_each_entry_safe(this, next, &hb2->chain, list) {

kernel/locking/lockdep.c

1048

static bool check_lock_chain_key(struct lock_chain *chain)

kernel/locking/lockdep.c

1054

for (i = chain->base; i < chain->base + chain->depth; i++)

kernel/locking/lockdep.c

1060

if (chain->chain_key != chain_key) {

kernel/locking/lockdep.c

1062

(unsigned long long)(chain - lock_chains),

kernel/locking/lockdep.c

1063

(unsigned long long)chain->chain_key,

kernel/locking/lockdep.c

1087

struct lock_chain *chain;

kernel/locking/lockdep.c

1116

hlist_for_each_entry_rcu(chain, head, entry) {

kernel/locking/lockdep.c

1117

if (!check_lock_chain_key(chain))

kernel/locking/lockdep.c

3559

struct lock_class *lock_chain_get_class(struct lock_chain *chain, int i)

kernel/locking/lockdep.c

3561

u16 chain_hlock = chain_hlocks[chain->base + i];

kernel/locking/lockdep.c

3621

static void print_chain_keys_chain(struct lock_chain *chain)

kernel/locking/lockdep.c

3627

printk("depth: %u\n", chain->depth);

kernel/locking/lockdep.c

3628

for (i = 0; i < chain->depth; i++) {

kernel/locking/lockdep.c

3629

hlock_id = chain_hlocks[chain->base + i];

kernel/locking/lockdep.c

3639

struct lock_chain *chain)

kernel/locking/lockdep.c

3655

print_chain_keys_chain(chain);

kernel/locking/lockdep.c

3672

struct lock_chain *chain)

kernel/locking/lockdep.c

3679

if (DEBUG_LOCKS_WARN_ON(chain->depth != curr->lockdep_depth - (i - 1))) {

kernel/locking/lockdep.c

3680

print_collision(curr, hlock, chain);

kernel/locking/lockdep.c

3684

for (j = 0; j < chain->depth - 1; j++, i++) {

kernel/locking/lockdep.c

3687

if (DEBUG_LOCKS_WARN_ON(chain_hlocks[chain->base + j] != id)) {

kernel/locking/lockdep.c

3688

print_collision(curr, hlock, chain);

kernel/locking/lockdep.c

3735

struct lock_chain *chain;

kernel/locking/lockdep.c

3746

chain = alloc_lock_chain();

kernel/locking/lockdep.c

3747

if (!chain) {

kernel/locking/lockdep.c

3757

chain->chain_key = chain_key;

kernel/locking/lockdep.c

3758

chain->irq_context = hlock->irq_context;

kernel/locking/lockdep.c

3760

chain->depth = curr->lockdep_depth + 1 - i;

kernel/locking/lockdep.c

3766

j = alloc_chain_hlocks(chain->depth);

kernel/locking/lockdep.c

3778

chain->base = j;

kernel/locking/lockdep.c

3779

for (j = 0; j < chain->depth - 1; j++, i++) {

kernel/locking/lockdep.c

3782

chain_hlocks[chain->base + j] = lock_id;

kernel/locking/lockdep.c

3784

chain_hlocks[chain->base + j] = hlock_id(hlock);

kernel/locking/lockdep.c

3785

hlist_add_head_rcu(&chain->entry, hash_head);

kernel/locking/lockdep.c

3787

inc_chains(chain->irq_context);

kernel/locking/lockdep.c

3799

struct lock_chain *chain;

kernel/locking/lockdep.c

3801

hlist_for_each_entry_rcu(chain, hash_head, entry) {

kernel/locking/lockdep.c

3802

if (READ_ONCE(chain->chain_key) == chain_key) {

kernel/locking/lockdep.c

3804

return chain;

kernel/locking/lockdep.c

3821

struct lock_chain *chain = lookup_chain_cache(chain_key);

kernel/locking/lockdep.c

3823

if (chain) {

kernel/locking/lockdep.c

3825

if (!check_no_collision(curr, hlock, chain))

kernel/locking/lockdep.c

3849

chain = lookup_chain_cache(chain_key);

kernel/locking/lockdep.c

3850

if (chain) {

kernel/locking/lockdep.c

421

#define __chainhashfn(chain) hash_long(chain, CHAINHASH_BITS)

kernel/locking/lockdep.c

422

#define chainhashentry(chain) (chainhash_table + __chainhashfn((chain)))

kernel/locking/lockdep.c

6191

struct lock_chain *chain,

kernel/locking/lockdep.c

6197

for (i = chain->base; i < chain->base + chain->depth; i++) {

kernel/locking/lockdep.c

6210

free_chain_hlocks(chain->base, chain->depth);

kernel/locking/lockdep.c

6212

WRITE_ONCE(chain->chain_key, INITIAL_CHAIN_KEY);

kernel/locking/lockdep.c

6213

dec_chains(chain->irq_context);

kernel/locking/lockdep.c

6219

hlist_del_rcu(&chain->entry);

kernel/locking/lockdep.c

6220

__set_bit(chain - lock_chains, pf->lock_chains_being_freed);

kernel/locking/lockdep.c

6229

struct lock_chain *chain;

kernel/locking/lockdep.c

6235

hlist_for_each_entry_rcu(chain, head, entry) {

kernel/locking/lockdep.c

6236

remove_class_from_lock_chain(pf, chain, class);

kernel/locking/lockdep_internals.h

137

struct lock_class *lock_chain_get_class(struct lock_chain *chain, int i);

kernel/locking/lockdep_proc.c

151

struct lock_chain *chain = v;

kernel/locking/lockdep_proc.c

169

seq_printf(m, "irq_context: %s\n", irq_strs[chain->irq_context]);

kernel/locking/lockdep_proc.c

171

for (i = 0; i < chain->depth; i++) {

kernel/locking/lockdep_proc.c

172

class = lock_chain_get_class(chain, i);

kernel/power/snapshot.c

294

struct linked_page *chain; /* the chain */

kernel/power/snapshot.c

304

ca->chain = NULL;

kernel/power/snapshot.c

322

lp->next = ca->chain;

kernel/power/snapshot.c

323

ca->chain = lp;

kernel/power/snapshot.c

326

ret = ca->chain->data + ca->used_space;

kernel/power/snapshot.c

711

bm->p_list = ca.chain;

kernel/power/snapshot.c

718

bm->p_list = ca.chain;

mm/ksm.c

2062

tree_folio = chain(&stable_node_dup, &stable_node, root);

mm/ksm.c

522

static __always_inline bool is_stable_node_chain(struct ksm_stable_node *chain)

mm/ksm.c

524

return chain->rmap_hlist_len == STABLE_NODE_CHAIN;

mm/ksm.c

533

struct ksm_stable_node *chain)

mm/ksm.c

537

VM_BUG_ON(!is_stable_node_chain(chain));

mm/ksm.c

538

hlist_add_head(&dup->hlist_dup, &chain->hlist);

mm/ksm.c

841

struct ksm_stable_node *chain = alloc_stable_node();

mm/ksm.c

843

if (likely(chain)) {

mm/ksm.c

844

INIT_HLIST_HEAD(&chain->hlist);

mm/ksm.c

845

chain->chain_prune_time = jiffies;

mm/ksm.c

846

chain->rmap_hlist_len = STABLE_NODE_CHAIN;

mm/ksm.c

848

chain->nid = NUMA_NO_NODE; /* debug */

mm/ksm.c

857

rb_replace_node(&dup->node, &chain->node, root);

mm/ksm.c

866

stable_node_chain_add_dup(dup, chain);

mm/ksm.c

868

return chain;

mm/ksm.c

871

static inline void free_stable_node_chain(struct ksm_stable_node *chain,

mm/ksm.c

874

rb_erase(&chain->node, root);

mm/ksm.c

875

free_stable_node(chain);

net/batman-adv/fragmentation.c

106

static bool batadv_frag_init_chain(struct batadv_frag_table_entry *chain,

net/batman-adv/fragmentation.c

109

lockdep_assert_held(&chain->lock);

net/batman-adv/fragmentation.c

111

if (chain->seqno == seqno)

net/batman-adv/fragmentation.c

114

if (!hlist_empty(&chain->fragment_list))

net/batman-adv/fragmentation.c

115

batadv_frag_clear_chain(&chain->fragment_list, true);

net/batman-adv/fragmentation.c

117

chain->size = 0;

net/batman-adv/fragmentation.c

118

chain->seqno = seqno;

net/batman-adv/fragmentation.c

140

struct batadv_frag_table_entry *chain;

net/batman-adv/fragmentation.c

170

chain = &orig_node->fragments[bucket];

net/batman-adv/fragmentation.c

171

spin_lock_bh(&chain->lock);

net/batman-adv/fragmentation.c

172

if (batadv_frag_init_chain(chain, seqno)) {

net/batman-adv/fragmentation.c

173

hlist_add_head(&frag_entry_new->list, &chain->fragment_list);

net/batman-adv/fragmentation.c

174

chain->size = skb->len - hdr_size;

net/batman-adv/fragmentation.c

175

chain->timestamp = jiffies;

net/batman-adv/fragmentation.c

176

chain->total_size = ntohs(frag_packet->total_size);

net/batman-adv/fragmentation.c

182

hlist_for_each_entry(frag_entry_curr, &chain->fragment_list, list) {

net/batman-adv/fragmentation.c

191

chain->size += skb->len - hdr_size;

net/batman-adv/fragmentation.c

192

chain->timestamp = jiffies;

net/batman-adv/fragmentation.c

204

chain->size += skb->len - hdr_size;

net/batman-adv/fragmentation.c

205

chain->timestamp = jiffies;

net/batman-adv/fragmentation.c

210

if (chain->size > batadv_frag_size_limit() ||

net/batman-adv/fragmentation.c

211

chain->total_size != ntohs(frag_packet->total_size) ||

net/batman-adv/fragmentation.c

212

chain->total_size > batadv_frag_size_limit()) {

net/batman-adv/fragmentation.c

217

batadv_frag_clear_chain(&chain->fragment_list, true);

net/batman-adv/fragmentation.c

218

chain->size = 0;

net/batman-adv/fragmentation.c

219

} else if (ntohs(frag_packet->total_size) == chain->size) {

net/batman-adv/fragmentation.c

221

hlist_move_list(&chain->fragment_list, chain_out);

net/batman-adv/fragmentation.c

222

chain->size = 0;

net/batman-adv/fragmentation.c

226

spin_unlock_bh(&chain->lock);

net/batman-adv/fragmentation.c

247

batadv_frag_merge_packets(struct hlist_head *chain)

net/batman-adv/fragmentation.c

258

entry = hlist_entry(chain->first, struct batadv_frag_list_entry, list);

net/batman-adv/fragmentation.c

285

hlist_for_each_entry(entry, chain, list) {

net/batman-adv/fragmentation.c

292

batadv_frag_clear_chain(chain, dropped);

net/batman-adv/fragmentation.c

62

struct batadv_frag_table_entry *chain;

net/batman-adv/fragmentation.c

66

chain = &orig_node->fragments[i];

net/batman-adv/fragmentation.c

67

spin_lock_bh(&chain->lock);

net/batman-adv/fragmentation.c

69

if (!check_cb || check_cb(chain)) {

net/batman-adv/fragmentation.c

70

batadv_frag_clear_chain(&chain->fragment_list, true);

net/batman-adv/fragmentation.c

71

chain->size = 0;

net/batman-adv/fragmentation.c

74

spin_unlock_bh(&chain->lock);

net/bridge/netfilter/ebtables.c

800

static int check_chainloops(const struct ebt_entries *chain, struct ebt_cl_stack *cl_s,

net/bridge/netfilter/ebtables.c

803

int i, chain_nr = -1, pos = 0, nentries = chain->nentries, verdict;

net/bridge/netfilter/ebtables.c

804

const struct ebt_entry *e = (struct ebt_entry *)chain->data;

net/bridge/netfilter/ebtables.c

816

nentries = chain->nentries;

net/bridge/netfilter/nft_meta_bridge.c

195

return nft_chain_validate_hooks(ctx->chain, hooks);

net/bridge/netfilter/nft_reject_bridge.c

175

return nft_chain_validate_hooks(ctx->chain, (1 << NF_BR_PRE_ROUTING) |

net/core/gro.c

338

diffs |= p_ext->chain ^ skb_ext->chain;

net/core/neighbour.c

3154

int chain;

net/core/neighbour.c

3161

for (chain = 0; chain < (1 << nht->hash_shift); chain++) {

net/core/neighbour.c

3164

neigh_for_each_in_bucket(n, &nht->hash_heads[chain])

net/core/neighbour.c

3177

int chain;

net/core/neighbour.c

3181

for (chain = 0; chain < (1 << nht->hash_shift); chain++) {

net/core/neighbour.c

3185

neigh_for_each_in_bucket_safe(n, tmp, &nht->hash_heads[chain]) {

net/ipv4/fib_semantics.c

166

fnhe = rcu_dereference_protected(hash[i].chain, 1);

net/ipv4/fib_semantics.c

1894

for (fnhe = rcu_dereference_protected(bucket[i].chain, 1);

net/ipv4/inet_connection_sock.c

295

inet_bind_bucket_for_each(tb2, &head2->chain) {

net/ipv4/inet_connection_sock.c

373

inet_bind_bucket_for_each(tb, &head->chain)

net/ipv4/inet_connection_sock.c

530

inet_bind_bucket_for_each(tb, &head->chain)

net/ipv4/inet_hashtables.c

1096

hlist_for_each_entry_rcu(tb, &head->chain, node) {

net/ipv4/inet_hashtables.c

1116

inet_bind_bucket_for_each(tb, &head->chain) {

net/ipv4/inet_hashtables.c

1359

INIT_HLIST_NULLS_HEAD(&new_hashinfo->ehash[i].chain, i);

net/ipv4/inet_hashtables.c

147

hlist_add_head(&tb2->node, &head->chain);

net/ipv4/inet_hashtables.c

285

inet_bind_bucket_for_each(tb, &head->chain) {

net/ipv4/inet_hashtables.c

546

sk_nulls_for_each_rcu(sk, node, &head->chain) {

net/ipv4/inet_hashtables.c

597

sk_nulls_for_each(sk2, node, &head->chain) {

net/ipv4/inet_hashtables.c

611

sk_nulls_for_each(sk2, node, &head->chain) {

net/ipv4/inet_hashtables.c

632

__sk_nulls_add_node_rcu(sk, &head->chain);

net/ipv4/inet_hashtables.c

717

list = &head->chain;

net/ipv4/inet_hashtables.c

88

hlist_add_head_rcu(&tb->node, &head->chain);

net/ipv4/inet_hashtables.c

891

inet_bind_bucket_for_each(bhash2, &head->chain)

net/ipv4/inet_timewait_sock.c

314

if (hlist_nulls_empty(&head->chain))

net/ipv4/inet_timewait_sock.c

321

sk_nulls_for_each_rcu(sk, node, &head->chain) {

net/ipv4/route.c

1361

fnhe_p = &hash->chain;

net/ipv4/route.c

1395

for (fnhe = rcu_dereference(hash[hval].chain); fnhe;

net/ipv4/route.c

3095

for (fnhe = rcu_dereference(bucket[i].chain); fnhe;

net/ipv4/route.c

599

for (fnhe_p = &hash->chain; ; fnhe_p = &fnhe->fnhe_next) {

net/ipv4/route.c

671

for (fnhe = rcu_dereference(hash->chain); fnhe;

net/ipv4/route.c

709

fnhe->fnhe_next = hash->chain;

net/ipv4/route.c

718

rcu_assign_pointer(hash->chain, fnhe);

net/ipv4/tcp.c

5313

INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);

net/ipv4/tcp.c

5331

INIT_HLIST_HEAD(&tcp_hashinfo.bhash[i].chain);

net/ipv4/tcp.c

5333

INIT_HLIST_HEAD(&tcp_hashinfo.bhash2[i].chain);

net/ipv4/tcp_diag.c

410

if (hlist_empty(&ibb->chain)) {

net/ipv4/tcp_diag.c

415

inet_bind_bucket_for_each(tb2, &ibb->chain) {

net/ipv4/tcp_diag.c

488

if (hlist_nulls_empty(&head->chain))

net/ipv4/tcp_diag.c

498

sk_nulls_for_each(sk, node, &head->chain) {

net/ipv4/tcp_ipv4.c

2626

return hlist_nulls_empty(&hinfo->ehash[st->bucket].chain);

net/ipv4/tcp_ipv4.c

2651

sk_nulls_for_each(sk, node, &hinfo->ehash[st->bucket].chain) {

net/ipv4/tcp_metrics.c

191

oldest = deref_locked(tcp_metrics_hash[hash].chain);

net/ipv4/tcp_metrics.c

213

tm->tcpm_next = tcp_metrics_hash[hash].chain;

net/ipv4/tcp_metrics.c

214

rcu_assign_pointer(tcp_metrics_hash[hash].chain, tm);

net/ipv4/tcp_metrics.c

238

for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm;

net/ipv4/tcp_metrics.c

280

for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm;

net/ipv4/tcp_metrics.c

781

for (col = 0, tm = rcu_dereference(hb->chain); tm;

net/ipv4/tcp_metrics.c

874

for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm;

net/ipv4/tcp_metrics.c

89

struct tcp_metrics_block __rcu *chain;

net/ipv4/tcp_metrics.c

906

struct tcp_metrics_block __rcu **pp = &hb->chain;

net/ipv4/tcp_metrics.c

953

pp = &hb->chain;

net/ipv6/inet6_hashtables.c

286

sk_nulls_for_each(sk2, node, &head->chain) {

net/ipv6/inet6_hashtables.c

301

sk_nulls_for_each(sk2, node, &head->chain) {

net/ipv6/inet6_hashtables.c

323

__sk_nulls_add_node_rcu(sk, &head->chain);

net/ipv6/inet6_hashtables.c

68

sk_nulls_for_each_rcu(sk, node, &head->chain) {

net/ipv6/route.c

1537

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/ipv6/route.c

1586

hlist_for_each_entry(rt6_ex, &(*bucket)->chain, hlist) {

net/ipv6/route.c

1621

hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) {

net/ipv6/route.c

1770

hlist_add_head_rcu(&rt6_ex->hlist, &bucket->chain);

net/ipv6/route.c

1812

hlist_for_each_entry_safe(rt6_ex, tmp, &bucket->chain, hlist) {

net/ipv6/route.c

2086

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/ipv6/route.c

2119

&bucket->chain, hlist) {

net/ipv6/route.c

2196

&bucket->chain, hlist) {

net/ipv6/route.c

6011

hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {

net/mac80211/rx.c

326

int mpdulen, chain;

net/mac80211/rx.c

377

for_each_set_bit(chain, &chains, IEEE80211_MAX_CHAINS) {

net/mac80211/rx.c

735

for_each_set_bit(chain, &chains, IEEE80211_MAX_CHAINS) {

net/mac80211/rx.c

736

*pos++ = status->chain_signal[chain];

net/mac80211/rx.c

737

*pos++ = chain;

net/netfilter/ipvs/ip_vs_est.c

638

struct hlist_head chain;

net/netfilter/ipvs/ip_vs_est.c

649

INIT_HLIST_HEAD(&chain);

net/netfilter/ipvs/ip_vs_est.c

656

hlist_add_head(&s->est.list, &chain);

net/netfilter/ipvs/ip_vs_est.c

673

ip_vs_chain_estimation(&chain);

net/netfilter/ipvs/ip_vs_est.c

677

ip_vs_chain_estimation(&chain);

net/netfilter/ipvs/ip_vs_est.c

78

static void ip_vs_chain_estimation(struct hlist_head *chain)

net/netfilter/ipvs/ip_vs_est.c

85

hlist_for_each_entry_rcu(e, chain, list) {

net/netfilter/nf_tables_api.c

10041

if (!nft_is_base_chain(trans->chain))

net/netfilter/nf_tables_api.c

10044

basechain = nft_base_chain(trans->chain);

net/netfilter/nf_tables_api.c

10055

&trans->chain->rhlhead,

net/netfilter/nf_tables_api.c

10057

swap(trans->chain->name, trans->name);

net/netfilter/nf_tables_api.c

10059

trans->chain->name,

net/netfilter/nf_tables_api.c

10060

&trans->chain->rhlhead,

net/netfilter/nf_tables_api.c

10064

if (!nft_is_base_chain(trans->chain))

net/netfilter/nf_tables_api.c

10069

basechain = nft_base_chain(trans->chain);

net/netfilter/nf_tables_api.c

10185

static int nf_tables_commit_chain_prepare(struct net *net, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

10195

if (chain->blob_next || !nft_is_active_next(net, chain))

net/netfilter/nf_tables_api.c

10199

list_for_each_entry(rule, &chain->rules, list) {

net/netfilter/nf_tables_api.c

10207

chain->blob_next = nf_tables_chain_alloc_rules(chain, data_size);

net/netfilter/nf_tables_api.c

10208

if (!chain->blob_next)

net/netfilter/nf_tables_api.c

10211

data = (void *)chain->blob_next->data;

net/netfilter/nf_tables_api.c

10215

list_for_each_entry(rule, &chain->rules, list) {

net/netfilter/nf_tables_api.c

10249

chain->blob_next->size += (unsigned long)(data - (void *)prule);

net/netfilter/nf_tables_api.c

10256

nft_last_rule(chain, prule);

net/netfilter/nf_tables_api.c

10269

struct nft_chain *chain = nft_trans_rule_chain(trans);

net/netfilter/nf_tables_api.c

10271

kvfree(chain->blob_next);

net/netfilter/nf_tables_api.c

10272

chain->blob_next = NULL;

net/netfilter/nf_tables_api.c

10295

static void nf_tables_commit_chain(struct net *net, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

10302

g0 = rcu_dereference_protected(chain->blob_gen_0,

net/netfilter/nf_tables_api.c

10304

g1 = rcu_dereference_protected(chain->blob_gen_1,

net/netfilter/nf_tables_api.c

10308

if (chain->blob_next == NULL) {

net/netfilter/nf_tables_api.c

10317

rcu_assign_pointer(chain->blob_gen_1, g0);

net/netfilter/nf_tables_api.c

10320

rcu_assign_pointer(chain->blob_gen_0, g1);

net/netfilter/nf_tables_api.c

10328

rcu_assign_pointer(chain->blob_gen_1, chain->blob_next);

net/netfilter/nf_tables_api.c

10330

rcu_assign_pointer(chain->blob_gen_0, chain->blob_next);

net/netfilter/nf_tables_api.c

10332

chain->blob_next = NULL;

net/netfilter/nf_tables_api.c

10349

void nft_chain_del(struct nft_chain *chain)

net/netfilter/nf_tables_api.c

10351

struct nft_table *table = chain->table;

net/netfilter/nf_tables_api.c

10353

WARN_ON_ONCE(rhltable_remove(&table->chains_ht, &chain->rhlhead,

net/netfilter/nf_tables_api.c

10355

list_del_rcu(&chain->list);

net/netfilter/nf_tables_api.c

10788

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

10849

chain = nft_trans_rule_chain(trans);

net/netfilter/nf_tables_api.c

10851

ret = nf_tables_commit_chain_prepare(net, chain);

net/netfilter/nf_tables_api.c

10862

list_for_each_entry(chain, &table->chains, list)

net/netfilter/nf_tables_api.c

10863

nf_tables_commit_chain(net, chain);

net/netfilter/nf_tables_api.c

11435

int nft_chain_validate_dependency(const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

11440

if (nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

11441

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

11449

int nft_chain_validate_hooks(const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

11454

if (nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

11455

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

11652

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

11677

chain = nft_chain_lookup(ctx->net, ctx->table,

net/netfilter/nf_tables_api.c

11681

chain = nft_chain_lookup_byid(ctx->net, ctx->table,

net/netfilter/nf_tables_api.c

11684

if (IS_ERR(chain))

net/netfilter/nf_tables_api.c

11685

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

11690

if (IS_ERR(chain))

net/netfilter/nf_tables_api.c

11691

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

11692

if (nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

11694

if (nft_chain_is_bound(chain))

net/netfilter/nf_tables_api.c

11697

chain->flags & NFT_CHAIN_BINDING)

net/netfilter/nf_tables_api.c

11699

if (!nft_use_inc(&chain->use))

net/netfilter/nf_tables_api.c

11702

data->verdict.chain = chain;

net/netfilter/nf_tables_api.c

11720

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

11725

chain = data->verdict.chain;

net/netfilter/nf_tables_api.c

11726

nft_use_dec(&chain->use);

net/netfilter/nf_tables_api.c

11746

v->chain->name))

net/netfilter/nf_tables_api.c

11888

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

11890

list_for_each_entry(chain, &table->chains, list)

net/netfilter/nf_tables_api.c

11891

__nf_tables_unregister_hook(net, table, chain, true);

net/netfilter/nf_tables_api.c

11914

struct nft_chain *chain, *nc;

net/netfilter/nf_tables_api.c

11925

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

11926

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

11929

ctx.chain = chain;

net/netfilter/nf_tables_api.c

11930

list_for_each_entry_safe(rule, nr, &chain->rules, list) {

net/netfilter/nf_tables_api.c

11932

nft_use_dec(&chain->use);

net/netfilter/nf_tables_api.c

11954

list_for_each_entry_safe(chain, nc, &table->chains, list) {

net/netfilter/nf_tables_api.c

11955

nft_chain_del(chain);

net/netfilter/nf_tables_api.c

11957

nf_tables_chain_destroy(chain);

net/netfilter/nf_tables_api.c

129

const struct nft_chain *chain)

net/netfilter/nf_tables_api.c

135

if (WARN_ON_ONCE(!nft_is_base_chain(ctx->chain)))

net/netfilter/nf_tables_api.c

1367

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

1370

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

1371

if (!nft_is_active_next(net, chain))

net/netfilter/nf_tables_api.c

1373

if (!nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

1379

nf_tables_unregister_hook(net, table, chain);

net/netfilter/nf_tables_api.c

138

base_chain = nft_base_chain(ctx->chain);

net/netfilter/nf_tables_api.c

1385

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

1388

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

1389

if (!nft_is_active_next(net, chain))

net/netfilter/nf_tables_api.c

1391

if (!nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

1394

err = nf_tables_register_hook(net, table, chain);

net/netfilter/nf_tables_api.c

143

if (chain->vstate.depth >= ctx->level &&

net/netfilter/nf_tables_api.c

144

chain->vstate.hook_mask[type] & BIT(hooknum))

net/netfilter/nf_tables_api.c

1521

const struct nft_chain *chain = data;

net/netfilter/nf_tables_api.c

1523

return nft_chain_hash(chain->name, 0, seed);

net/netfilter/nf_tables_api.c

1529

const struct nft_chain *chain = ptr;

net/netfilter/nf_tables_api.c

1532

return strcmp(chain->name, name);

net/netfilter/nf_tables_api.c

161

struct nft_chain *chain,

net/netfilter/nf_tables_api.c

168

ctx->chain = chain;

net/netfilter/nf_tables_api.c

1684

struct nft_chain *chain, *nc;

net/netfilter/nf_tables_api.c

1689

list_for_each_entry(chain, &ctx->table->chains, list) {

net/netfilter/nf_tables_api.c

1690

if (!nft_is_active_next(ctx->net, chain))

net/netfilter/nf_tables_api.c

1693

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

1696

ctx->chain = chain;

net/netfilter/nf_tables_api.c

1733

list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {

net/netfilter/nf_tables_api.c

1734

if (!nft_is_active_next(ctx->net, chain))

net/netfilter/nf_tables_api.c

1737

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

1740

ctx->chain = chain;

net/netfilter/nf_tables_api.c

1868

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

1870

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

1871

if (chain->handle == handle &&

net/netfilter/nf_tables_api.c

1872

nft_active_genmask(chain, genmask))

net/netfilter/nf_tables_api.c

1873

return chain;

net/netfilter/nf_tables_api.c

1896

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

1906

chain = ERR_PTR(-ENOENT);

net/netfilter/nf_tables_api.c

1912

rhl_for_each_entry_rcu(chain, tmp, list, rhlhead) {

net/netfilter/nf_tables_api.c

1913

if (nft_active_genmask(chain, genmask))

net/netfilter/nf_tables_api.c

1916

chain = ERR_PTR(-ENOENT);

net/netfilter/nf_tables_api.c

1919

return chain;

net/netfilter/nf_tables_api.c

2049

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

2061

nla_put_string(skb, NFTA_CHAIN_NAME, chain->name) ||

net/netfilter/nf_tables_api.c

2062

nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle),

net/netfilter/nf_tables_api.c

2073

if (nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

2074

const struct nft_base_chain *basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

2093

if (chain->flags &&

net/netfilter/nf_tables_api.c

2094

nla_put_be32(skb, NFTA_CHAIN_FLAGS, htonl(chain->flags)))

net/netfilter/nf_tables_api.c

2097

if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))

net/netfilter/nf_tables_api.c

2100

if (chain->udata &&

net/netfilter/nf_tables_api.c

2101

nla_put(skb, NFTA_CHAIN_USERDATA, chain->udlen, chain->udata))

net/netfilter/nf_tables_api.c

2133

ctx->chain, hook_list);

net/netfilter/nf_tables_api.c

2155

const struct nft_chain *chain;

net/netfilter/nf_tables_api.c

2165

list_for_each_entry_rcu(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

2171

if (!nft_is_active(net, chain))

net/netfilter/nf_tables_api.c

2179

chain, NULL) < 0)

net/netfilter/nf_tables_api.c

2200

const struct nft_chain *chain;

net/netfilter/nf_tables_api.c

2221

chain = nft_chain_lookup(net, table, nla[NFTA_CHAIN_NAME], genmask);

net/netfilter/nf_tables_api.c

2222

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

2224

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

2233

0, family, table, chain, NULL);

net/netfilter/nf_tables_api.c

2283

struct nft_base_chain *chain = nft_base_chain(trans->chain);

net/netfilter/nf_tables_api.c

2289

rcu_replace_pointer(chain->stats, trans->stats,

net/netfilter/nf_tables_api.c

2296

static void nf_tables_chain_free_chain_rules(struct nft_chain *chain)

net/netfilter/nf_tables_api.c

2298

struct nft_rule_blob *g0 = rcu_dereference_raw(chain->blob_gen_0);

net/netfilter/nf_tables_api.c

2299

struct nft_rule_blob *g1 = rcu_dereference_raw(chain->blob_gen_1);

net/netfilter/nf_tables_api.c

2306

WARN_ON_ONCE(chain->blob_next);

net/netfilter/nf_tables_api.c

2307

kvfree(chain->blob_next);

net/netfilter/nf_tables_api.c

2310

void nf_tables_chain_destroy(struct nft_chain *chain)

net/netfilter/nf_tables_api.c

2312

const struct nft_table *table = chain->table;

net/netfilter/nf_tables_api.c

2315

if (WARN_ON(chain->use > 0))

net/netfilter/nf_tables_api.c

2319

nf_tables_chain_free_chain_rules(chain);

net/netfilter/nf_tables_api.c

2321

if (nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

2322

struct nft_base_chain *basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

2336

kfree(chain->name);

net/netfilter/nf_tables_api.c

2337

kfree(chain->udata);

net/netfilter/nf_tables_api.c

2340

kfree(chain->name);

net/netfilter/nf_tables_api.c

2341

kfree(chain->udata);

net/netfilter/nf_tables_api.c

2342

kfree(chain);

net/netfilter/nf_tables_api.c

2602

static void nft_last_rule(const struct nft_chain *chain, const void *ptr)

net/netfilter/nf_tables_api.c

2610

lrule->chain = chain;

net/netfilter/nf_tables_api.c

2614

static struct nft_rule_blob *nf_tables_chain_alloc_rules(const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

2629

nft_last_rule(chain, blob->data);

net/netfilter/nf_tables_api.c

263

struct nft_chain *chain, bool bind)

net/netfilter/nf_tables_api.c

2636

struct nft_chain *chain)

net/netfilter/nf_tables_api.c

2641

ops->priv = chain;

net/netfilter/nf_tables_api.c

2649

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

2655

chain = &basechain->chain;

net/netfilter/nf_tables_api.c

2661

nft_basechain_hook_init(ops, family, hook, chain);

net/netfilter/nf_tables_api.c

2664

nft_basechain_hook_init(&basechain->ops, family, hook, chain);

net/netfilter/nf_tables_api.c

2666

chain->flags |= NFT_CHAIN_BASE | flags;

net/netfilter/nf_tables_api.c

2668

if (chain->flags & NFT_CHAIN_HW_OFFLOAD &&

net/netfilter/nf_tables_api.c

2679

int nft_chain_add(struct nft_table *table, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

2683

err = rhltable_insert_key(&table->chains_ht, chain->name,

net/netfilter/nf_tables_api.c

2684

&chain->rhlhead, nft_chain_ht_params);

net/netfilter/nf_tables_api.c

2688

list_add_tail_rcu(&chain->list, &table->chains);

net/netfilter/nf_tables_api.c

269

if (!nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

2705

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

2728

chain = &basechain->chain;

net/netfilter/nf_tables_api.c

2755

chain = kzalloc_obj(*chain, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2756

if (chain == NULL)

net/netfilter/nf_tables_api.c

2759

chain->flags = flags;

net/netfilter/nf_tables_api.c

276

if (nft_trans_chain(trans) == chain)

net/netfilter/nf_tables_api.c

2761

ctx->chain = chain;

net/netfilter/nf_tables_api.c

2763

INIT_LIST_HEAD(&chain->rules);

net/netfilter/nf_tables_api.c

2764

chain->handle = nf_tables_alloc_handle(table);

net/netfilter/nf_tables_api.c

2765

chain->table = table;

net/netfilter/nf_tables_api.c

2768

chain->name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2776

chain->name = kstrdup(name, GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2779

if (!chain->name) {

net/netfilter/nf_tables_api.c

2785

chain->udata = nla_memdup(nla[NFTA_CHAIN_USERDATA], GFP_KERNEL_ACCOUNT);

net/netfilter/nf_tables_api.c

2786

if (chain->udata == NULL) {

net/netfilter/nf_tables_api.c

2790

chain->udlen = nla_len(nla[NFTA_CHAIN_USERDATA]);

net/netfilter/nf_tables_api.c

2793

blob = nf_tables_chain_alloc_rules(chain, 0);

net/netfilter/nf_tables_api.c

2799

RCU_INIT_POINTER(chain->blob_gen_0, blob);

net/netfilter/nf_tables_api.c

280

if (nft_trans_rule_chain(trans) == chain)

net/netfilter/nf_tables_api.c

2800

RCU_INIT_POINTER(chain->blob_gen_1, blob);

net/netfilter/nf_tables_api.c

2814

if (nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

2817

err = nft_chain_add(table, chain);

net/netfilter/nf_tables_api.c

2822

err = nf_tables_register_hook(net, table, chain);

net/netfilter/nf_tables_api.c

2829

nft_chain_del(chain);

net/netfilter/nf_tables_api.c

2836

nf_tables_chain_destroy(chain);

net/netfilter/nf_tables_api.c

2848

struct nft_chain *chain = ctx->chain;

net/netfilter/nf_tables_api.c

2858

if (chain->flags ^ flags)

net/netfilter/nf_tables_api.c

2864

if (!nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

2869

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

288

struct nft_chain *chain)

net/netfilter/nf_tables_api.c

290

__nft_chain_trans_bind(ctx, chain, true);

net/netfilter/nf_tables_api.c

293

int nf_tables_bind_chain(const struct nft_ctx *ctx, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

2942

nft_is_base_chain(chain) &&

net/netfilter/nf_tables_api.c

2944

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

295

if (!nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

2957

if (!nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

298

if (nft_chain_binding(ctx->chain))

net/netfilter/nf_tables_api.c

301

if (chain->bound)

net/netfilter/nf_tables_api.c

304

if (!nft_use_inc(&chain->use))

net/netfilter/nf_tables_api.c

3063

struct nft_chain *chain = NULL;

net/netfilter/nf_tables_api.c

307

chain->bound = true;

net/netfilter/nf_tables_api.c

308

nft_chain_trans_bind(ctx, chain);

net/netfilter/nf_tables_api.c

3081

chain = NULL;

net/netfilter/nf_tables_api.c

3086

chain = nft_chain_lookup_byhandle(table, handle, genmask);

net/netfilter/nf_tables_api.c

3087

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

3089

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

3093

chain = nft_chain_lookup(net, table, attr, genmask);

net/netfilter/nf_tables_api.c

3094

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

3095

if (PTR_ERR(chain) != -ENOENT) {

net/netfilter/nf_tables_api.c

3097

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

3099

chain = NULL;

net/netfilter/nf_tables_api.c

3106

if (chain != NULL &&

net/netfilter/nf_tables_api.c

3107

!nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

3112

if (chain == NULL &&

net/netfilter/nf_tables_api.c

313

void nf_tables_unbind_chain(const struct nft_ctx *ctx, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

3130

else if (chain)

net/netfilter/nf_tables_api.c

3131

flags = chain->flags;

net/netfilter/nf_tables_api.c

3136

nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);

net/netfilter/nf_tables_api.c

3138

if (chain != NULL) {

net/netfilter/nf_tables_api.c

3139

if (chain->flags & NFT_CHAIN_BINDING)

net/netfilter/nf_tables_api.c

3149

flags |= chain->flags & NFT_CHAIN_BASE;

net/netfilter/nf_tables_api.c

315

__nft_chain_trans_bind(ctx, chain, false);

net/netfilter/nf_tables_api.c

3161

const struct nft_chain *chain = &basechain->chain;

net/netfilter/nf_tables_api.c

3173

ctx->family, chain->flags, extack);

net/netfilter/nf_tables_api.c

3218

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

3235

chain = nft_chain_lookup_byhandle(table, handle, genmask);

net/netfilter/nf_tables_api.c

3238

chain = nft_chain_lookup(net, table, attr, genmask);

net/netfilter/nf_tables_api.c

3240

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

3241

if (PTR_ERR(chain) == -ENOENT &&

net/netfilter/nf_tables_api.c

3246

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

3249

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

3252

nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);

net/netfilter/nf_tables_api.c

3256

chain->flags & NFT_CHAIN_HW_OFFLOAD)

net/netfilter/nf_tables_api.c

3259

if (nft_is_base_chain(chain)) {

net/netfilter/nf_tables_api.c

3260

struct nft_base_chain *basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

3268

chain->use > 0)

net/netfilter/nf_tables_api.c

3271

use = chain->use;

net/netfilter/nf_tables_api.c

3272

list_for_each_entry(rule, &chain->rules, list) {

net/netfilter/nf_tables_api.c

3643

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

3649

list_for_each_entry_rcu(rule, &chain->rules, list,

net/netfilter/nf_tables_api.c

3659

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

3665

return __nft_rule_lookup(net, chain, be64_to_cpu(nla_get_be64(nla)));

net/netfilter/nf_tables_api.c

3688

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

3704

if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name))

net/netfilter/nf_tables_api.c

3716

if (chain->flags & NFT_CHAIN_HW_OFFLOAD)

net/netfilter/nf_tables_api.c

3717

nft_flow_rule_stats(chain, rule);

net/netfilter/nf_tables_api.c

3762

!list_is_first(&rule->list, &ctx->chain->rules) &&

net/netfilter/nf_tables_api.c

3763

!list_is_last(&rule->list, &ctx->chain->rules)) {

net/netfilter/nf_tables_api.c

3774

ctx->chain, rule, handle, false);

net/netfilter/nf_tables_api.c

3801

char *chain;

net/netfilter/nf_tables_api.c

3809

const struct nft_chain *chain)

net/netfilter/nf_tables_api.c

3819

list_for_each_entry_rcu(rule, &chain->rules, list) {

net/netfilter/nf_tables_api.c

3834

table, chain, rule, handle, ctx->reset) < 0) {

net/netfilter/nf_tables_api.c

3858

const struct nft_chain *chain;

net/netfilter/nf_tables_api.c

3875

if (ctx->table && ctx->chain) {

net/netfilter/nf_tables_api.c

3878

list = rhltable_lookup(&table->chains_ht, ctx->chain,

net/netfilter/nf_tables_api.c

3883

rhl_for_each_entry_rcu(chain, tmp, list, rhlhead) {

net/netfilter/nf_tables_api.c

3884

if (!nft_is_active(net, chain))

net/netfilter/nf_tables_api.c

3887

cb, table, chain);

net/netfilter/nf_tables_api.c

3893

list_for_each_entry_rcu(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

3895

cb, table, chain))

net/netfilter/nf_tables_api.c

3922

ctx->chain = nla_strdup(nla[NFTA_RULE_CHAIN], GFP_ATOMIC);

net/netfilter/nf_tables_api.c

3923

if (!ctx->chain) {

net/netfilter/nf_tables_api.c

3939

kfree(ctx->chain);

net/netfilter/nf_tables_api.c

3951

const struct nft_chain *chain;

net/netfilter/nf_tables_api.c

396

struct nft_chain *chain)

net/netfilter/nf_tables_api.c

3964

chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN], genmask);

net/netfilter/nf_tables_api.c

3965

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

3967

return ERR_CAST(chain);

net/netfilter/nf_tables_api.c

3970

rule = nft_rule_lookup(net, chain, nla[NFTA_RULE_HANDLE]);

net/netfilter/nf_tables_api.c

3982

family, table, chain, rule, 0, reset);

net/netfilter/nf_tables_api.c

402

!nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

405

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

4059

static void nft_chain_vstate_update(const struct nft_ctx *ctx, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

4066

if (WARN_ON_ONCE(!nft_is_base_chain(ctx->chain))) {

net/netfilter/nf_tables_api.c

4067

memset(&chain->vstate, 0, sizeof(chain->vstate));

net/netfilter/nf_tables_api.c

4071

base_chain = nft_base_chain(ctx->chain);

net/netfilter/nf_tables_api.c

4077

chain->vstate.hook_mask[type] |= BIT(hooknum);

net/netfilter/nf_tables_api.c

4078

if (chain->vstate.depth < ctx->level)

net/netfilter/nf_tables_api.c

4079

chain->vstate.depth = ctx->level;

net/netfilter/nf_tables_api.c

4091

int nft_chain_validate(const struct nft_ctx *ctx, struct nft_chain *chain)

net/netfilter/nf_tables_api.c

4103

if (nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

4106

if (nft_chain_vstate_valid(ctx, chain))

net/netfilter/nf_tables_api.c

4110

list_for_each_entry(rule, &chain->rules, list) {

net/netfilter/nf_tables_api.c

4132

nft_chain_vstate_update(ctx, chain);

net/netfilter/nf_tables_api.c

4139

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

4146

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

4147

if (!nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

4150

ctx.chain = chain;

net/netfilter/nf_tables_api.c

4151

err = nft_chain_validate(&ctx, chain);

net/netfilter/nf_tables_api.c

4157

list_for_each_entry(chain, &table->chains, list)

net/netfilter/nf_tables_api.c

4158

memset(&chain->vstate, 0, sizeof(chain->vstate));

net/netfilter/nf_tables_api.c

4184

err = nft_chain_validate(ctx, data->verdict.chain);

net/netfilter/nf_tables_api.c

419

struct nft_chain *chain,

net/netfilter/nf_tables_api.c

4221

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

4240

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

4258

chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN],

net/netfilter/nf_tables_api.c

426

!nft_is_base_chain(chain))

net/netfilter/nf_tables_api.c

4260

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

4262

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

4266

chain = nft_chain_lookup_byid(net, table, nla[NFTA_RULE_CHAIN_ID],

net/netfilter/nf_tables_api.c

4268

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

4270

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

4276

if (nft_chain_is_bound(chain))

net/netfilter/nf_tables_api.c

428

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_api.c

4281

rule = __nft_rule_lookup(net, chain, handle);

net/netfilter/nf_tables_api.c

4303

old_rule = __nft_rule_lookup(net, chain, pos_handle);

net/netfilter/nf_tables_api.c

4309

old_rule = nft_rule_lookup_byid(net, chain, nla[NFTA_RULE_POSITION_ID]);

net/netfilter/nf_tables_api.c

4317

nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);

net/netfilter/nf_tables_api.c

4385

if (chain->flags & NFT_CHAIN_HW_OFFLOAD) {

net/netfilter/nf_tables_api.c

4393

if (!nft_use_inc(&chain->use)) {

net/netfilter/nf_tables_api.c

4399

if (nft_chain_binding(chain)) {

net/netfilter/nf_tables_api.c

4425

list_add_tail_rcu(&rule->list, &chain->rules);

net/netfilter/nf_tables_api.c

443

struct nft_chain *chain)

net/netfilter/nf_tables_api.c

4430

list_add_rcu(&rule->list, &chain->rules);

net/netfilter/nf_tables_api.c

4444

nft_use_dec_restore(&chain->use);

net/netfilter/nf_tables_api.c

445

return __nf_tables_unregister_hook(net, table, chain, false);

net/netfilter/nf_tables_api.c

4465

const struct nft_chain *chain,

net/netfilter/nf_tables_api.c

4474

nft_trans_rule_chain(trans) == chain &&

net/netfilter/nf_tables_api.c

4487

struct nft_chain *chain = NULL;

net/netfilter/nf_tables_api.c

4502

chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN],

net/netfilter/nf_tables_api.c

4504

if (IS_ERR(chain)) {

net/netfilter/nf_tables_api.c

4505

if (PTR_ERR(chain) == -ENOENT &&

net/netfilter/nf_tables_api.c

4510

return PTR_ERR(chain);

net/netfilter/nf_tables_api.c

4512

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

4516

nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);

net/netfilter/nf_tables_api.c

4518

if (chain) {

net/netfilter/nf_tables_api.c

4520

rule = nft_rule_lookup(info->net, chain, nla[NFTA_RULE_HANDLE]);

net/netfilter/nf_tables_api.c

4532

rule = nft_rule_lookup_byid(net, chain, nla[NFTA_RULE_ID]);

net/netfilter/nf_tables_api.c

4543

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_api.c

4544

if (!nft_is_active_next(net, chain))

net/netfilter/nf_tables_api.c

4546

if (nft_chain_binding(chain))

net/netfilter/nf_tables_api.c

4549

ctx.chain = chain;

net/netfilter/nf_tables_api.c

5803

i->chain == binding->chain)

net/netfilter/nf_tables_api.c

5818

binding->chain = ctx->chain;

net/netfilter/nf_tables_api.c

613

trans_chain->chain = ctx->chain;

net/netfilter/nf_tables_api.c

627

nft_activate_next(ctx->net, ctx->chain);

net/netfilter/nf_tables_api.c

648

nft_deactivate_next(ctx->net, ctx->chain);

net/netfilter/nf_tables_api.c

686

nft_use_dec(&ctx->chain->use);

net/netfilter/nf_tables_api.c

706

nft_trans_rule_chain(trans) = ctx->chain;

net/netfilter/nf_tables_api.c

722

if (ctx->chain->flags & NFT_CHAIN_HW_OFFLOAD) {

net/netfilter/nf_tables_api.c

7395

.chain = (struct nft_chain *)binding->chain,

net/netfilter/nf_tables_api.c

747

list_for_each_entry(rule, &ctx->chain->rules, list) {

net/netfilter/nf_tables_api.c

7636

struct nft_chain *chain;

net/netfilter/nf_tables_api.c

7642

chain = data->verdict.chain;

net/netfilter/nf_tables_api.c

7643

nft_use_inc_restore(&chain->use);

net/netfilter/nf_tables_core.c

178

static noinline void nft_update_chain_stats(const struct nft_chain *chain,

net/netfilter/nf_tables_core.c

185

base_chain = nft_base_chain(chain);

net/netfilter/nf_tables_core.c

252

const struct nft_chain *chain = priv, *basechain = chain;

net/netfilter/nf_tables_core.c

268

blob = rcu_dereference(chain->blob_gen_1);

net/netfilter/nf_tables_core.c

270

blob = rcu_dereference(chain->blob_gen_0);

net/netfilter/nf_tables_core.c

323

chain = regs.verdict.chain;

net/netfilter/nf_tables_offload.c

268

static int nft_flow_offload_cmd(const struct nft_chain *chain,

net/netfilter/nf_tables_offload.c

277

if (!nft_is_base_chain(chain))

net/netfilter/nf_tables_offload.c

280

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_offload.c

288

static int nft_flow_offload_rule(const struct nft_chain *chain,

net/netfilter/nf_tables_offload.c

295

return nft_flow_offload_cmd(chain, rule, flow, command, &cls_flow);

net/netfilter/nf_tables_offload.c

298

int nft_flow_rule_stats(const struct nft_chain *chain,

net/netfilter/nf_tables_offload.c

305

err = nft_flow_offload_cmd(chain, rule, NULL, FLOW_CLS_STATS,

net/netfilter/nf_tables_offload.c

331

struct nft_chain *chain;

net/netfilter/nf_tables_offload.c

334

chain = &basechain->chain;

net/netfilter/nf_tables_offload.c

335

list_for_each_entry(rule, &chain->rules, list) {

net/netfilter/nf_tables_offload.c

387

static int nft_block_offload_cmd(struct nft_base_chain *chain,

net/netfilter/nf_tables_offload.c

395

nft_flow_block_offload_init(&bo, dev_net(dev), cmd, chain, &extack);

net/netfilter/nf_tables_offload.c

401

return nft_block_setup(chain, &bo, cmd);

net/netfilter/nf_tables_offload.c

497

static int nft_flow_offload_chain(struct nft_chain *chain, u8 *ppolicy,

net/netfilter/nf_tables_offload.c

503

if (!nft_is_base_chain(chain))

net/netfilter/nf_tables_offload.c

506

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_offload.c

634

struct nft_chain *chain;

net/netfilter/nf_tables_offload.c

640

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nf_tables_offload.c

641

if (!nft_is_base_chain(chain) ||

net/netfilter/nf_tables_offload.c

642

!(chain->flags & NFT_CHAIN_HW_OFFLOAD))

net/netfilter/nf_tables_offload.c

646

basechain = nft_base_chain(chain);

net/netfilter/nf_tables_offload.c

657

return chain;

net/netfilter/nf_tables_offload.c

670

struct nft_chain *chain;

net/netfilter/nf_tables_offload.c

677

chain = __nft_offload_get_chain(nft_net, dev);

net/netfilter/nf_tables_offload.c

678

if (chain)

net/netfilter/nf_tables_offload.c

679

nft_flow_block_chain(nft_base_chain(chain), dev,

net/netfilter/nf_tables_trace.c

223

return &info->basechain->chain;

net/netfilter/nf_tables_trace.c

230

if (WARN_ON_ONCE(!last->chain))

net/netfilter/nf_tables_trace.c

231

return &info->basechain->chain;

net/netfilter/nf_tables_trace.c

233

return last->chain;

net/netfilter/nf_tables_trace.c

241

const struct nft_chain *chain;

net/netfilter/nf_tables_trace.c

251

chain = nft_trace_get_chain(rule, info);

net/netfilter/nf_tables_trace.c

254

nla_total_size(strlen(chain->table->name)) +

net/netfilter/nf_tables_trace.c

255

nla_total_size(strlen(chain->name)) +

net/netfilter/nf_tables_trace.c

277

size += nla_total_size(strlen(verdict->chain->name)); /* jump target */

net/netfilter/nf_tables_trace.c

298

if (nla_put_string(skb, NFTA_TRACE_CHAIN, chain->name))

net/netfilter/nf_tables_trace.c

301

if (nla_put_string(skb, NFTA_TRACE_TABLE, chain->table->name))

net/netfilter/nf_tables_trace.c

362

const struct nft_chain *chain)

net/netfilter/nf_tables_trace.c

367

info->basechain = nft_base_chain(chain);

net/netfilter/nfnetlink_hook.c

132

struct nft_chain *chain)

net/netfilter/nfnetlink_hook.c

138

if (WARN_ON_ONCE(!chain))

net/netfilter/nfnetlink_hook.c

141

if (!nft_is_active(net, chain))

net/netfilter/nfnetlink_hook.c

148

ret = nfnl_hook_put_nft_info_desc(nlskb, chain->table->name,

net/netfilter/nfnetlink_hook.c

149

chain->name, chain->table->family);

net/netfilter/nft_chain_filter.c

324

struct nft_table *table = basechain->chain.table;

net/netfilter/nft_chain_filter.c

377

struct nft_chain *chain;

net/netfilter/nft_chain_filter.c

386

list_for_each_entry(chain, &table->chains, list) {

net/netfilter/nft_chain_filter.c

387

if (!nft_is_base_chain(chain))

net/netfilter/nft_chain_filter.c

390

basechain = nft_base_chain(chain);

net/netfilter/nft_compat.c

173

if (nft_is_base_chain(ctx->chain)) {

net/netfilter/nft_compat.c

175

nft_base_chain(ctx->chain);

net/netfilter/nft_compat.c

35

const struct nft_chain *chain = ctx->chain;

net/netfilter/nft_compat.c

367

ret = nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_compat.c

376

if (nft_is_base_chain(ctx->chain)) {

net/netfilter/nft_compat.c

378

nft_base_chain(ctx->chain);

net/netfilter/nft_compat.c

39

!nft_is_base_chain(chain))

net/netfilter/nft_compat.c

42

basechain = nft_base_chain(chain);

net/netfilter/nft_compat.c

474

if (nft_is_base_chain(ctx->chain)) {

net/netfilter/nft_compat.c

476

nft_base_chain(ctx->chain);

net/netfilter/nft_compat.c

628

ret = nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_compat.c

637

if (nft_is_base_chain(ctx->chain)) {

net/netfilter/nft_compat.c

639

nft_base_chain(ctx->chain);

net/netfilter/nft_fib.c

62

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_flow_offload.c

148

return nft_chain_validate_hooks(ctx->chain, hook_mask);

net/netfilter/nft_fwd_netdev.c

209

return nft_chain_validate_hooks(ctx->chain, (1 << NF_NETDEV_INGRESS) |

net/netfilter/nft_immediate.c

101

struct nft_chain *chain;

net/netfilter/nft_immediate.c

108

chain = data->verdict.chain;

net/netfilter/nft_immediate.c

109

if (!nft_chain_binding(chain))

net/netfilter/nft_immediate.c

113

chain_ctx.chain = chain;

net/netfilter/nft_immediate.c

115

list_for_each_entry(rule, &chain->rules, list)

net/netfilter/nft_immediate.c

118

nft_clear(ctx->net, chain);

net/netfilter/nft_immediate.c

129

struct nft_chain *chain,

net/netfilter/nft_immediate.c

136

chain_ctx.chain = chain;

net/netfilter/nft_immediate.c

138

list_for_each_entry(rule, &chain->rules, list)

net/netfilter/nft_immediate.c

148

struct nft_chain *chain;

net/netfilter/nft_immediate.c

154

chain = data->verdict.chain;

net/netfilter/nft_immediate.c

155

if (!nft_chain_binding(chain))

net/netfilter/nft_immediate.c

160

nf_tables_unbind_chain(ctx, chain);

net/netfilter/nft_immediate.c

161

nft_deactivate_next(ctx->net, chain);

net/netfilter/nft_immediate.c

164

nft_immediate_chain_deactivate(ctx, chain, phase);

net/netfilter/nft_immediate.c

165

nft_deactivate_next(ctx->net, chain);

net/netfilter/nft_immediate.c

168

nft_immediate_chain_deactivate(ctx, chain, phase);

net/netfilter/nft_immediate.c

169

nft_chain_del(chain);

net/netfilter/nft_immediate.c

170

chain->bound = false;

net/netfilter/nft_immediate.c

171

nft_use_dec(&chain->table->use);

net/netfilter/nft_immediate.c

193

struct nft_chain *chain;

net/netfilter/nft_immediate.c

201

chain = data->verdict.chain;

net/netfilter/nft_immediate.c

203

if (!nft_chain_binding(chain))

net/netfilter/nft_immediate.c

209

if (chain->bound) {

net/netfilter/nft_immediate.c

210

nft_use_dec(&chain->use);

net/netfilter/nft_immediate.c

216

chain_ctx.chain = chain;

net/netfilter/nft_immediate.c

218

nft_use_dec(&chain->use);

net/netfilter/nft_immediate.c

219

list_for_each_entry_safe(rule, n, &chain->rules, list) {

net/netfilter/nft_immediate.c

220

nft_use_dec(&chain->use);

net/netfilter/nft_immediate.c

224

nf_tables_chain_destroy(chain);

net/netfilter/nft_immediate.c

263

err = nft_chain_validate(ctx, data->verdict.chain);

net/netfilter/nft_immediate.c

74

struct nft_chain *chain = priv->data.verdict.chain;

net/netfilter/nft_immediate.c

79

err = nf_tables_bind_chain(ctx, chain);

net/netfilter/nft_masq.c

34

err = nft_chain_validate_dependency(ctx->chain, NFT_CHAIN_T_NAT);

net/netfilter/nft_masq.c

38

return nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_meta.c

554

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_meta.c

577

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_meta.c

626

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_nat.c

150

err = nft_chain_validate_dependency(ctx->chain, NFT_CHAIN_T_NAT);

net/netfilter/nft_nat.c

156

err = nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_nat.c

161

err = nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_objref.c

38

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_osf.c

127

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_queue.c

92

return nft_chain_validate_hooks(ctx->chain, supported_hooks);

net/netfilter/nft_redir.c

34

err = nft_chain_validate_dependency(ctx->chain, NFT_CHAIN_T_NAT);

net/netfilter/nft_redir.c

38

return nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_reject.c

29

return nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_reject_inet.c

66

return nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_reject_netdev.c

150

return nft_chain_validate_hooks(ctx->chain, (1 << NF_NETDEV_INGRESS));

net/netfilter/nft_rt.c

188

return nft_chain_validate_hooks(ctx->chain, hooks);

net/netfilter/nft_socket.c

285

return nft_chain_validate_hooks(ctx->chain,

net/netfilter/nft_synproxy.c

259

return nft_chain_validate_hooks(ctx->chain, (1 << NF_INET_LOCAL_IN) |

net/netfilter/nft_tproxy.c

323

return nft_chain_validate_hooks(ctx->chain, 1 << NF_INET_PRE_ROUTING);

net/netfilter/nft_xfrm.c

259

return nft_chain_validate_hooks(ctx->chain, hooks);

net/openvswitch/flow.c

1042

tc_ext->chain : 0;

net/sched/act_api.c

122

struct tcf_chain *chain = rcu_dereference_protected(p->goto_chain, 1);

net/sched/act_api.c

129

if (chain)

net/sched/act_api.c

130

tcf_chain_put_by_act(chain);

net/sched/act_api.c

47

const struct tcf_chain *chain = rcu_dereference_bh(a->goto_chain);

net/sched/act_api.c

49

res->goto_tp = rcu_dereference_bh(chain->filter_chain);

net/sched/act_api.c

94

*newchain = tcf_chain_get_by_act(tp->chain->block, chain_index);

net/sched/cls_api.c

1065

__tcf_get_next_chain(struct tcf_block *block, struct tcf_chain *chain)

net/sched/cls_api.c

1068

if (chain)

net/sched/cls_api.c

1069

chain = list_is_last(&chain->list, &block->chain_list) ?

net/sched/cls_api.c

1070

NULL : list_next_entry(chain, list);

net/sched/cls_api.c

1072

chain = list_first_entry_or_null(&block->chain_list,

net/sched/cls_api.c

1076

while (chain && tcf_chain_held_by_acts_only(chain))

net/sched/cls_api.c

1077

chain = list_is_last(&chain->list, &block->chain_list) ?

net/sched/cls_api.c

1078

NULL : list_next_entry(chain, list);

net/sched/cls_api.c

1080

if (chain)

net/sched/cls_api.c

1081

tcf_chain_hold(chain);

net/sched/cls_api.c

1084

return chain;

net/sched/cls_api.c

1097

tcf_get_next_chain(struct tcf_block *block, struct tcf_chain *chain)

net/sched/cls_api.c

1099

struct tcf_chain *chain_next = __tcf_get_next_chain(block, chain);

net/sched/cls_api.c

1101

if (chain)

net/sched/cls_api.c

1102

tcf_chain_put(chain);

net/sched/cls_api.c

1109

__tcf_get_next_proto(struct tcf_chain *chain, struct tcf_proto *tp)

net/sched/cls_api.c

1114

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

1117

tp = tcf_chain_dereference(chain->filter_chain, chain);

net/sched/cls_api.c

1124

tp = tcf_chain_dereference(chain->filter_chain, chain);

net/sched/cls_api.c

1126

for (; tp; tp = tcf_chain_dereference(tp->next, chain))

net/sched/cls_api.c

1130

tp = tcf_chain_dereference(tp->next, chain);

net/sched/cls_api.c

1136

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

1150

tcf_get_next_proto(struct tcf_chain *chain, struct tcf_proto *tp)

net/sched/cls_api.c

1152

struct tcf_proto *tp_next = __tcf_get_next_proto(chain, tp);

net/sched/cls_api.c

1163

struct tcf_chain *chain;

net/sched/cls_api.c

1168

for (chain = tcf_get_next_chain(block, NULL);

net/sched/cls_api.c

1169

chain;

net/sched/cls_api.c

1170

chain = tcf_get_next_chain(block, chain)) {

net/sched/cls_api.c

1171

tcf_chain_put_explicitly_created(chain);

net/sched/cls_api.c

1172

tcf_chain_flush(chain, rtnl_held);

net/sched/cls_api.c

1582

struct tcf_chain *chain, *chain_prev;

net/sched/cls_api.c

1588

for (chain = __tcf_get_next_chain(block, NULL);

net/sched/cls_api.c

1589

chain;

net/sched/cls_api.c

1590

chain_prev = chain,

net/sched/cls_api.c

1591

chain = __tcf_get_next_chain(block, chain),

net/sched/cls_api.c

1593

if (chain->tmplt_ops && add)

net/sched/cls_api.c

1594

chain->tmplt_ops->tmplt_reoffload(chain, true, cb,

net/sched/cls_api.c

1596

for (tp = __tcf_get_next_proto(chain, NULL); tp;

net/sched/cls_api.c

1598

tp = __tcf_get_next_proto(chain, tp),

net/sched/cls_api.c

1611

if (chain->tmplt_ops && !add)

net/sched/cls_api.c

1612

chain->tmplt_ops->tmplt_reoffload(chain, false, cb,

net/sched/cls_api.c

1620

tcf_chain_put(chain);

net/sched/cls_api.c

174

return jhash_3words(tp->chain->index, tp->prio,

net/sched/cls_api.c

1743

if (unlikely(n->tp != tp || n->tp->chain != n->chain ||

net/sched/cls_api.c

1769

*last_executed_chain = first_tp->chain->index;

net/sched/cls_api.c

178

static void tcf_proto_signal_destroying(struct tcf_chain *chain,

net/sched/cls_api.c

1792

tp->chain->block->index,

net/sched/cls_api.c

181

struct tcf_block *block = chain->block;

net/sched/cls_api.c

1816

u32 last_executed_chain = tp ? tp->chain->index : 0;

net/sched/cls_api.c

1826

if (ext && (ext->chain || ext->act_miss)) {

net/sched/cls_api.c

1828

u32 chain;

net/sched/cls_api.c

1839

chain = n->chain_index;

net/sched/cls_api.c

1841

chain = ext->chain;

net/sched/cls_api.c

1844

fchain = tcf_chain_lookup_rcu(block, chain);

net/sched/cls_api.c

1873

ext->chain = last_executed_chain;

net/sched/cls_api.c

1892

static struct tcf_proto *tcf_chain_tp_prev(struct tcf_chain *chain,

net/sched/cls_api.c

1895

return tcf_chain_dereference(*chain_info->pprev, chain);

net/sched/cls_api.c

1898

static int tcf_chain_tp_insert(struct tcf_chain *chain,

net/sched/cls_api.c

1902

if (chain->flushing)

net/sched/cls_api.c

1905

RCU_INIT_POINTER(tp->next, tcf_chain_tp_prev(chain, chain_info));

net/sched/cls_api.c

1906

if (*chain_info->pprev == chain->filter_chain)

net/sched/cls_api.c

1907

tcf_chain0_head_change(chain, tp);

net/sched/cls_api.c

1914

static void tcf_chain_tp_remove(struct tcf_chain *chain,

net/sched/cls_api.c

1918

struct tcf_proto *next = tcf_chain_dereference(chain_info->next, chain);

net/sched/cls_api.c

192

return tp1->chain->index == tp2->chain->index &&

net/sched/cls_api.c

1921

if (tp == chain->filter_chain)

net/sched/cls_api.c

1922

tcf_chain0_head_change(chain, next);

net/sched/cls_api.c

1926

static struct tcf_proto *tcf_chain_tp_find(struct tcf_chain *chain,

net/sched/cls_api.c

1937

static struct tcf_proto *tcf_chain_tp_insert_unique(struct tcf_chain *chain,

net/sched/cls_api.c

1946

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

1948

if (tcf_proto_exists_destroying(chain, tp_new)) {

net/sched/cls_api.c

1949

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

1954

tp = tcf_chain_tp_find(chain, &chain_info, protocol, prio, false, NULL);

net/sched/cls_api.c

1956

err = tcf_chain_tp_insert(chain, &chain_info, tp_new);

net/sched/cls_api.c

1957

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

197

static bool tcf_proto_exists_destroying(struct tcf_chain *chain,

net/sched/cls_api.c

1970

static void tcf_chain_tp_delete_empty(struct tcf_chain *chain,

net/sched/cls_api.c

1979

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

1982

for (pprev = &chain->filter_chain;

net/sched/cls_api.c

1983

(tp_iter = tcf_chain_dereference(*pprev, chain));

net/sched/cls_api.c

1997

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2001

tcf_proto_signal_destroying(chain, tp);

net/sched/cls_api.c

2002

next = tcf_chain_dereference(chain_info.next, chain);

net/sched/cls_api.c

2003

if (tp == chain->filter_chain)

net/sched/cls_api.c

2004

tcf_chain0_head_change(chain, next);

net/sched/cls_api.c

2006

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2011

static struct tcf_proto *tcf_chain_tp_find(struct tcf_chain *chain,

net/sched/cls_api.c

2021

for (pprev = &chain->filter_chain;

net/sched/cls_api.c

2022

(tp = tcf_chain_dereference(*pprev, chain));

net/sched/cls_api.c

205

hash_for_each_possible_rcu(chain->block->proto_destroy_ht, iter,

net/sched/cls_api.c

2079

if (nla_put_u32(skb, TCA_CHAIN, tp->chain->index))

net/sched/cls_api.c

218

tcf_proto_signal_destroyed(struct tcf_chain *chain, struct tcf_proto *tp)

net/sched/cls_api.c

220

struct tcf_block *block = chain->block;

net/sched/cls_api.c

2209

struct tcf_chain *chain, int event,

net/sched/cls_api.c

2214

for (tp = tcf_get_next_proto(chain, NULL);

net/sched/cls_api.c

2215

tp; tp = tcf_get_next_proto(chain, tp))

net/sched/cls_api.c

2250

struct tcf_chain *chain;

net/sched/cls_api.c

2277

chain = NULL;

net/sched/cls_api.c

2334

chain = tcf_chain_get(block, chain_index, true);

net/sched/cls_api.c

2335

if (!chain) {

net/sched/cls_api.c

2341

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

2342

tp = tcf_chain_tp_find(chain, &chain_info, protocol,

net/sched/cls_api.c

2352

if (chain->flushing) {

net/sched/cls_api.c

2372

prio = tcf_auto_prio(tcf_chain_tp_prev(chain,

net/sched/cls_api.c

2375

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2376

tp_new = tcf_proto_create(name, protocol, prio, chain,

net/sched/cls_api.c

2384

tp = tcf_chain_tp_insert_unique(chain, tp_new, protocol, prio,

net/sched/cls_api.c

2391

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2415

if (chain->tmplt_ops && chain->tmplt_ops != tp->ops) {

net/sched/cls_api.c

2444

tcf_chain_tp_delete_empty(chain, tp, rtnl_held, NULL);

net/sched/cls_api.c

2446

if (chain) {

net/sched/cls_api.c

2450

tcf_chain_put(chain);

net/sched/cls_api.c

2468

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2485

struct tcf_chain *chain = NULL;

net/sched/cls_api.c

2547

chain = tcf_chain_get(block, chain_index, false);

net/sched/cls_api.c

2548

if (!chain) {

net/sched/cls_api.c

2563

chain, RTM_DELTFILTER, extack);

net/sched/cls_api.c

2564

tcf_chain_flush(chain, rtnl_held);

net/sched/cls_api.c

2569

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

2570

tp = tcf_chain_tp_find(chain, &chain_info, protocol,

net/sched/cls_api.c

2584

tcf_proto_signal_destroying(chain, tp);

net/sched/cls_api.c

2585

tcf_chain_tp_remove(chain, &chain_info, tp);

net/sched/cls_api.c

2586

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2594

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2610

tcf_chain_tp_delete_empty(chain, tp, rtnl_held, extack);

net/sched/cls_api.c

2614

if (chain) {

net/sched/cls_api.c

2617

tcf_chain_put(chain);

net/sched/cls_api.c

2627

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2644

struct tcf_chain *chain = NULL;

net/sched/cls_api.c

2705

chain = tcf_chain_get(block, chain_index, false);

net/sched/cls_api.c

2706

if (!chain) {

net/sched/cls_api.c

2712

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

2713

tp = tcf_chain_tp_find(chain, &chain_info, protocol,

net/sched/cls_api.c

2715

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

2743

if (chain) {

net/sched/cls_api.c

2746

tcf_chain_put(chain);

net/sched/cls_api.c

2777

static bool tcf_chain_dump(struct tcf_chain *chain, struct Qdisc *q, u32 parent,

net/sched/cls_api.c

2782

struct tcf_block *block = chain->block;

net/sched/cls_api.c

2787

for (tp = __tcf_get_next_proto(chain, NULL);

net/sched/cls_api.c

2790

tp = __tcf_get_next_proto(chain, tp),

net/sched/cls_api.c

2846

struct tcf_chain *chain, *chain_prev;

net/sched/cls_api.c

2921

for (chain = __tcf_get_next_chain(block, NULL);

net/sched/cls_api.c

2922

chain;

net/sched/cls_api.c

2923

chain_prev = chain,

net/sched/cls_api.c

2924

chain = __tcf_get_next_chain(block, chain),

net/sched/cls_api.c

2927

nla_get_u32(tca[TCA_CHAIN]) != chain->index)

net/sched/cls_api.c

2929

if (!tcf_chain_dump(chain, q, parent, skb, cb,

net/sched/cls_api.c

2931

tcf_chain_put(chain);

net/sched/cls_api.c

3005

static int tc_chain_notify(struct tcf_chain *chain, struct sk_buff *oskb,

net/sched/cls_api.c

3010

struct tcf_block *block = chain->block;

net/sched/cls_api.c

3022

if (tc_chain_fill_node(chain->tmplt_ops, chain->tmplt_priv,

net/sched/cls_api.c

3023

chain->index, net, skb, block, portid,

net/sched/cls_api.c

3063

static int tc_chain_tmplt_add(struct tcf_chain *chain, struct net *net,

net/sched/cls_api.c

3090

tmplt_priv = ops->tmplt_create(net, chain, tca, extack);

net/sched/cls_api.c

3095

chain->tmplt_ops = ops;

net/sched/cls_api.c

3096

chain->tmplt_priv = tmplt_priv;

net/sched/cls_api.c

3122

struct tcf_chain *chain;

net/sched/cls_api.c

3151

chain = tcf_chain_lookup(block, chain_index);

net/sched/cls_api.c

3153

if (chain) {

net/sched/cls_api.c

3154

if (tcf_chain_held_by_acts_only(chain)) {

net/sched/cls_api.c

3158

tcf_chain_hold(chain);

net/sched/cls_api.c

3170

chain = tcf_chain_create(block, chain_index);

net/sched/cls_api.c

3171

if (!chain) {

net/sched/cls_api.c

3178

if (!chain || tcf_chain_held_by_acts_only(chain)) {

net/sched/cls_api.c

3183

tcf_chain_hold(chain);

net/sched/cls_api.c

3192

tcf_chain_hold(chain);

net/sched/cls_api.c

3193

chain->explicitly_created = true;

net/sched/cls_api.c

3199

err = tc_chain_tmplt_add(chain, net, tca, extack);

net/sched/cls_api.c

3201

tcf_chain_put_explicitly_created(chain);

net/sched/cls_api.c

3205

tc_chain_notify(chain, NULL, 0, NLM_F_CREATE | NLM_F_EXCL,

net/sched/cls_api.c

3210

chain, RTM_DELTFILTER, extack);

net/sched/cls_api.c

3212

tcf_chain_flush(chain, true);

net/sched/cls_api.c

3216

tcf_chain_put_explicitly_created(chain);

net/sched/cls_api.c

3219

err = tc_chain_notify(chain, skb, n->nlmsg_seq,

net/sched/cls_api.c

3231

tcf_chain_put(chain);

net/sched/cls_api.c

3252

struct tcf_chain *chain;

net/sched/cls_api.c

3306

list_for_each_entry(chain, &block->chain_list, list) {

net/sched/cls_api.c

3308

nla_get_u32(tca[TCA_CHAIN]) != chain->index))

net/sched/cls_api.c

3314

if (tcf_chain_held_by_acts_only(chain))

net/sched/cls_api.c

3316

err = tc_chain_fill_node(chain->tmplt_ops, chain->tmplt_priv,

net/sched/cls_api.c

3317

chain->index, net, skb, block,

net/sched/cls_api.c

373

u32 prio, struct tcf_chain *chain,

net/sched/cls_api.c

392

tp->chain = chain;

net/sched/cls_api.c

417

struct tcf_block *block = tp->chain->block;

net/sched/cls_api.c

441

static void tcf_chain_put(struct tcf_chain *chain);

net/sched/cls_api.c

449

tcf_proto_signal_destroyed(tp->chain, tp);

net/sched/cls_api.c

450

tcf_chain_put(tp->chain);

net/sched/cls_api.c

501

struct tcf_chain *chain;

net/sched/cls_api.c

505

chain = kzalloc_obj(*chain);

net/sched/cls_api.c

506

if (!chain)

net/sched/cls_api.c

508

list_add_tail_rcu(&chain->list, &block->chain_list);

net/sched/cls_api.c

509

mutex_init(&chain->filter_chain_lock);

net/sched/cls_api.c

510

chain->block = block;

net/sched/cls_api.c

511

chain->index = chain_index;

net/sched/cls_api.c

512

chain->refcnt = 1;

net/sched/cls_api.c

513

if (!chain->index)

net/sched/cls_api.c

514

block->chain0.chain = chain;

net/sched/cls_api.c

515

return chain;

net/sched/cls_api.c

525

static void tcf_chain0_head_change(struct tcf_chain *chain,

net/sched/cls_api.c

529

struct tcf_block *block = chain->block;

net/sched/cls_api.c

531

if (chain->index)

net/sched/cls_api.c

54

const struct tcf_chain *chain;

net/sched/cls_api.c

542

static bool tcf_chain_detach(struct tcf_chain *chain)

net/sched/cls_api.c

544

struct tcf_block *block = chain->block;

net/sched/cls_api.c

548

list_del_rcu(&chain->list);

net/sched/cls_api.c

549

if (!chain->index)

net/sched/cls_api.c

550

block->chain0.chain = NULL;

net/sched/cls_api.c

567

static void tcf_chain_destroy(struct tcf_chain *chain, bool free_block)

net/sched/cls_api.c

569

struct tcf_block *block = chain->block;

net/sched/cls_api.c

571

mutex_destroy(&chain->filter_chain_lock);

net/sched/cls_api.c

572

kfree_rcu(chain, rcu);

net/sched/cls_api.c

577

static void tcf_chain_hold(struct tcf_chain *chain)

net/sched/cls_api.c

579

ASSERT_BLOCK_LOCKED(chain->block);

net/sched/cls_api.c

581

++chain->refcnt;

net/sched/cls_api.c

584

static bool tcf_chain_held_by_acts_only(struct tcf_chain *chain)

net/sched/cls_api.c

586

ASSERT_BLOCK_LOCKED(chain->block);

net/sched/cls_api.c

591

return chain->refcnt == chain->action_refcnt;

net/sched/cls_api.c

597

struct tcf_chain *chain;

net/sched/cls_api.c

601

list_for_each_entry(chain, &block->chain_list, list) {

net/sched/cls_api.c

602

if (chain->index == chain_index)

net/sched/cls_api.c

603

return chain;

net/sched/cls_api.c

612

struct tcf_chain *chain;

net/sched/cls_api.c

614

list_for_each_entry_rcu(chain, &block->chain_list, list) {

net/sched/cls_api.c

615

if (chain->index == chain_index)

net/sched/cls_api.c

616

return chain;

net/sched/cls_api.c

622

static int tc_chain_notify(struct tcf_chain *chain, struct sk_buff *oskb,

net/sched/cls_api.c

630

struct tcf_chain *chain = NULL;

net/sched/cls_api.c

634

chain = tcf_chain_lookup(block, chain_index);

net/sched/cls_api.c

635

if (chain) {

net/sched/cls_api.c

636

tcf_chain_hold(chain);

net/sched/cls_api.c

640

chain = tcf_chain_create(block, chain_index);

net/sched/cls_api.c

641

if (!chain)

net/sched/cls_api.c

646

++chain->action_refcnt;

net/sched/cls_api.c

647

is_first_reference = chain->refcnt - chain->action_refcnt == 1;

net/sched/cls_api.c

656

tc_chain_notify(chain, NULL, 0, NLM_F_CREATE | NLM_F_EXCL,

net/sched/cls_api.c

659

return chain;

net/sched/cls_api.c

663

return chain;

net/sched/cls_api.c

685

static void __tcf_chain_put(struct tcf_chain *chain, bool by_act,

net/sched/cls_api.c

688

struct tcf_block *block = chain->block;

net/sched/cls_api.c

696

if (!chain->explicitly_created) {

net/sched/cls_api.c

700

chain->explicitly_created = false;

net/sched/cls_api.c

704

chain->action_refcnt--;

net/sched/cls_api.c

710

refcnt = --chain->refcnt;

net/sched/cls_api.c

711

non_act_refcnt = refcnt - chain->action_refcnt;

net/sched/cls_api.c

712

tmplt_ops = chain->tmplt_ops;

net/sched/cls_api.c

713

tmplt_priv = chain->tmplt_priv;

net/sched/cls_api.c

715

if (non_act_refcnt == chain->explicitly_created && !by_act) {

net/sched/cls_api.c

718

chain->index, block, NULL, 0, 0);

net/sched/cls_api.c

720

chain->flushing = false;

net/sched/cls_api.c

724

free_block = tcf_chain_detach(chain);

net/sched/cls_api.c

729

tcf_chain_destroy(chain, free_block);

net/sched/cls_api.c

733

static void tcf_chain_put(struct tcf_chain *chain)

net/sched/cls_api.c

735

__tcf_chain_put(chain, false, false);

net/sched/cls_api.c

738

void tcf_chain_put_by_act(struct tcf_chain *chain)

net/sched/cls_api.c

740

__tcf_chain_put(chain, true, false);

net/sched/cls_api.c

744

static void tcf_chain_put_explicitly_created(struct tcf_chain *chain)

net/sched/cls_api.c

746

__tcf_chain_put(chain, false, true);

net/sched/cls_api.c

749

static void tcf_chain_flush(struct tcf_chain *chain, bool rtnl_held)

net/sched/cls_api.c

753

mutex_lock(&chain->filter_chain_lock);

net/sched/cls_api.c

754

tp = tcf_chain_dereference(chain->filter_chain, chain);

net/sched/cls_api.c

757

tcf_proto_signal_destroying(chain, tp);

net/sched/cls_api.c

760

tp = tcf_chain_dereference(chain->filter_chain, chain);

net/sched/cls_api.c

761

RCU_INIT_POINTER(chain->filter_chain, NULL);

net/sched/cls_api.c

762

tcf_chain0_head_change(chain, NULL);

net/sched/cls_api.c

763

chain->flushing = true;

net/sched/cls_api.c

764

mutex_unlock(&chain->filter_chain_lock);

net/sched/cls_api.c

91

n->chain_index = tp->chain->index;

net/sched/cls_api.c

92

n->chain = tp->chain;

net/sched/cls_api.c

930

chain0 = block->chain0.chain;

net/sched/cls_api.c

968

if (block->chain0.chain)

net/sched/cls_bpf.c

147

struct tcf_block *block = tp->chain->block;

net/sched/cls_bpf.c

228

struct tcf_block *block = tp->chain->block;

net/sched/cls_bpf.c

402

tcf_block_netif_keep_dst(tp->chain->block);

net/sched/cls_bpf.c

654

struct tcf_block *block = tp->chain->block;

net/sched/cls_flow.c

506

struct tcf_block *block = tp->chain->block;

net/sched/cls_flow.c

529

tcf_block_netif_keep_dst(tp->chain->block);

net/sched/cls_flower.c

113

struct tcf_chain *chain;

net/sched/cls_flower.c

2475

if (!fl_mask_fits_tmplt(tp->chain->tmplt_priv, mask)) {

net/sched/cls_flower.c

2684

struct tcf_block *block = tp->chain->block;

net/sched/cls_flower.c

2767

static int fl_hw_create_tmplt(struct tcf_chain *chain,

net/sched/cls_flower.c

2771

struct tcf_block *block = chain->block;

net/sched/cls_flower.c

2777

cls_flower.common.chain_index = chain->index;

net/sched/cls_flower.c

2793

static void fl_hw_destroy_tmplt(struct tcf_chain *chain,

net/sched/cls_flower.c

2797

struct tcf_block *block = chain->block;

net/sched/cls_flower.c

2799

cls_flower.common.chain_index = chain->index;

net/sched/cls_flower.c

2806

static void *fl_tmplt_create(struct net *net, struct tcf_chain *chain,

net/sched/cls_flower.c

2831

tmplt->chain = chain;

net/sched/cls_flower.c

2839

err = fl_hw_create_tmplt(chain, tmplt);

net/sched/cls_flower.c

2857

fl_hw_destroy_tmplt(tmplt->chain, tmplt);

net/sched/cls_flower.c

2861

static void fl_tmplt_reoffload(struct tcf_chain *chain, bool add,

net/sched/cls_flower.c

2864

struct fl_flow_tmplt *tmplt = chain->tmplt_priv;

net/sched/cls_flower.c

2871

cls_flower.common.chain_index = chain->index;

net/sched/cls_flower.c

451

struct tcf_block *block = tp->chain->block;

net/sched/cls_flower.c

467

struct tcf_block *block = tp->chain->block;

net/sched/cls_flower.c

511

struct tcf_block *block = tp->chain->block;

net/sched/cls_fw.c

254

if (tcf_block_shared(tp->chain->block)) {

net/sched/cls_fw.c

77

struct Qdisc *q = tcf_block_q(tp->chain->block);

net/sched/cls_matchall.c

280

struct tcf_block *block = tp->chain->block;

net/sched/cls_matchall.c

317

struct tcf_block *block = tp->chain->block;

net/sched/cls_matchall.c

74

struct tcf_block *block = tp->chain->block;

net/sched/cls_matchall.c

90

struct tcf_block *block = tp->chain->block;

net/sched/cls_route.c

541

tcf_block_netif_keep_dst(tp->chain->block);

net/sched/cls_u32.c

1258

struct tcf_block *block = tp->chain->block;

net/sched/cls_u32.c

332

struct tcf_block *block = tp->chain->block;

net/sched/cls_u32.c

491

struct tcf_block *block = tp->chain->block;

net/sched/cls_u32.c

506

struct tcf_block *block = tp->chain->block;

net/sched/cls_u32.c

535

struct tcf_block *block = tp->chain->block;

net/sched/cls_u32.c

550

struct tcf_block *block = tp->chain->block;

net/sched/ematch.c

177

struct net *net = tp->chain->block->net;

net/sched/sch_api.c

2089

struct Qdisc *q = tcf_block_q(tp->chain->block);

net/sched/sch_api.c

2111

struct tcf_chain *chain;

net/sched/sch_api.c

2116

for (chain = tcf_get_next_chain(block, NULL);

net/sched/sch_api.c

2117

chain;

net/sched/sch_api.c

2118

chain = tcf_get_next_chain(block, chain)) {

net/sched/sch_api.c

2121

for (tp = tcf_get_next_proto(chain, NULL);

net/sched/sch_api.c

2122

tp; tp = tcf_get_next_proto(chain, tp)) {

net/sctp/input.c

755

sctp_for_each_hentry(ep2, &head->chain) {

net/sctp/input.c

782

hlist_add_head(&ep->node, &head->chain);

net/sctp/input.c

856

sctp_for_each_hentry(ep, &head->chain) {

net/sctp/proc.c

173

sctp_for_each_hentry(ep, &head->chain) {

net/sctp/protocol.c

1549

INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);

net/sctp/protocol.c

1583

INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);

net/sctp/socket.c

5371

sctp_for_each_hentry(ep, &head->chain) {

net/sctp/socket.c

8415

sctp_for_each_hentry(pp, &head->chain)

net/sctp/socket.c

8444

sctp_for_each_hentry(pp, &head->chain) {

net/sctp/socket.c

8757

hlist_add_head(&pp->node, &head->chain);

net/switchdev/switchdev.c

521

struct raw_notifier_head *chain = &switchdev_blocking_notif_chain;

net/switchdev/switchdev.c

525

err = raw_notifier_chain_register(chain, nb);

net/switchdev/switchdev.c

534

struct raw_notifier_head *chain = &switchdev_blocking_notif_chain;

net/switchdev/switchdev.c

538

err = raw_notifier_chain_unregister(chain, nb);

net/xfrm/xfrm_policy.c

1243

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

1253

chain = xfrm_policy_inexact_alloc_chain(bin, policy, dir);

net/xfrm/xfrm_policy.c

1254

if (!chain) {

net/xfrm/xfrm_policy.c

1259

delpol = xfrm_policy_insert_list(chain, policy, excl);

net/xfrm/xfrm_policy.c

1288

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

1375

chain = policy_hash_bysel(net, &policy->selector,

net/xfrm/xfrm_policy.c

1378

if (!chain) {

net/xfrm/xfrm_policy.c

1385

hlist_for_each_entry(pol, chain, bydst) {

net/xfrm/xfrm_policy.c

1394

hlist_add_head_rcu(&policy->bydst, chain);

net/xfrm/xfrm_policy.c

1541

static struct xfrm_policy *xfrm_policy_insert_list(struct hlist_head *chain,

net/xfrm/xfrm_policy.c

1547

hlist_for_each_entry(pol, chain, bydst) {

net/xfrm/xfrm_policy.c

1573

hlist_add_head_rcu(&policy->bydst, chain);

net/xfrm/xfrm_policy.c

1582

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

1588

chain = policy_hash_bysel(net, &policy->selector, policy->family, dir);

net/xfrm/xfrm_policy.c

1589

if (chain)

net/xfrm/xfrm_policy.c

1590

delpol = xfrm_policy_insert_list(chain, policy, excl);

net/xfrm/xfrm_policy.c

1629

__xfrm_policy_bysel_ctx(struct hlist_head *chain, const struct xfrm_mark *mark,

net/xfrm/xfrm_policy.c

1635

if (!chain)

net/xfrm/xfrm_policy.c

1638

hlist_for_each_entry(pol, chain, bydst) {

net/xfrm/xfrm_policy.c

1657

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

1661

chain = policy_hash_bysel(net, sel, sel->family, dir);

net/xfrm/xfrm_policy.c

1662

if (!chain) {

net/xfrm/xfrm_policy.c

1694

pol = __xfrm_policy_bysel_ctx(chain, mark, if_id, type, dir,

net/xfrm/xfrm_policy.c

1725

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

1733

chain = net->xfrm.policy_byidx + idx_hash(net, id);

net/xfrm/xfrm_policy.c

1735

hlist_for_each_entry(pol, chain, byidx) {

net/xfrm/xfrm_policy.c

202

xfrm_policy_insert_list(struct hlist_head *chain, struct xfrm_policy *policy,

net/xfrm/xfrm_policy.c

2094

__xfrm_policy_eval_candidates(struct hlist_head *chain,

net/xfrm/xfrm_policy.c

2102

if (!chain)

net/xfrm/xfrm_policy.c

2105

hlist_for_each_entry_rcu(pol, chain, bydst) {

net/xfrm/xfrm_policy.c

2165

struct hlist_head *chain;

net/xfrm/xfrm_policy.c

2178

chain = policy_hash_direct(net, daddr, saddr, family, dir);

net/xfrm/xfrm_policy.c

2182

hlist_for_each_entry_rcu(pol, chain, bydst) {

sound/sound_core.c

350

const int chain = unit % SOUND_STEP;

sound/sound_core.c

355

switch (chain) {

sound/sound_core.c

401

sprintf(_name, "unknown%d", chain);

sound/sound_core.c

408

return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit,

sound/sound_core.c

519

static struct sound_unit *__look_for_unit(int chain, int unit)

sound/sound_core.c

523

s=chains[chain];

sound/sound_core.c

535

int chain;

sound/sound_core.c

540

chain=unit&0x0F;

sound/sound_core.c

541

if(chain==4 || chain==5) /* dsp/audio/dsp16 */

sound/sound_core.c

545

chain=3;

sound/sound_core.c

549

s = __look_for_unit(chain, unit);

sound/sound_core.c

563

request_module("sound-service-%i-%i", unit>>4, chain);

sound/sound_core.c

576

s = __look_for_unit(chain, unit);

tools/net/ynl/samples/tc-filter-add.c

135

req->chain = 0;

tools/net/ynl/samples/tc-filter-add.c

182

req->_present.chain = 1;

tools/net/ynl/samples/tc-filter-add.c

183

req->chain = 0;

tools/perf/arch/powerpc/util/skip-callchain-idx.c

212

int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain)

tools/perf/arch/powerpc/util/skip-callchain-idx.c

220

if (!chain || chain->nr < 3)

tools/perf/arch/powerpc/util/skip-callchain-idx.c

224

ip = chain->ips[1];

tools/perf/builtin-sched.c

3024

struct callchain_list *chain;

tools/perf/builtin-sched.c

3035

list_for_each_entry(chain, &node->val, list) {

tools/perf/builtin-sched.c

3036

if (chain->ip >= PERF_CONTEXT_MAX)

tools/perf/builtin-sched.c

3038

if (chain->ms.sym && chain->ms.sym->ignore)

tools/perf/builtin-sched.c

3041

callchain_list__sym_name(chain, bf, sizeof(bf),

tools/perf/builtin-sched.c

3053

struct callchain_node *chain;

tools/perf/builtin-sched.c

3061

chain = rb_entry(rb_node, struct callchain_node, rb_node);

tools/perf/builtin-sched.c

3065

print_sched_time(chain->hit, 12);

tools/perf/builtin-sched.c

3067

ret += fprintf(fp, " %8d ", chain->count);

tools/perf/builtin-sched.c

3068

ret += callchain__fprintf_folded(fp, chain);

tools/perf/builtin-timechart.c

501

struct ip_callchain *chain = sample->callchain;

tools/perf/builtin-timechart.c

510

if (!chain)

tools/perf/builtin-timechart.c

519

for (i = 0; i < chain->nr; i++) {

tools/perf/builtin-timechart.c

524

ip = chain->ips[i];

tools/perf/builtin-timechart.c

526

ip = chain->ips[chain->nr - i - 1];

tools/perf/ui/browsers/hists.c

1031

struct callchain_list *chain, *first_chain = NULL;

tools/perf/ui/browsers/hists.c

1052

list_for_each_entry(chain, &child->parent_val, list) {

tools/perf/ui/browsers/hists.c

1054

chain, value_str, chain_str);

tools/perf/ui/browsers/hists.c

1057

first_chain = chain;

tools/perf/ui/browsers/hists.c

1068

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

1070

chain, value_str, chain_str);

tools/perf/ui/browsers/hists.c

1073

first_chain = chain;

tools/perf/ui/browsers/hists.c

1120

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

1125

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

1133

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

1136

chain, row, percent_total,

tools/perf/ui/browsers/hists.c

184

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

187

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

191

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

205

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

209

list_for_each_entry(chain, &node->parent_val, list) {

tools/perf/ui/browsers/hists.c

212

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

219

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/browsers/hists.c

222

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

239

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

248

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/browsers/hists.c

251

unfolded = chain->unfolded;

tools/perf/ui/browsers/hists.c

260

static int callchain__count_rows(struct rb_root *chain)

tools/perf/ui/browsers/hists.c

265

for (nd = rb_first(chain); nd; nd = rb_next(nd)) {

tools/perf/ui/browsers/hists.c

335

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

338

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

341

chain->has_children = chain->list.next != &child->val ||

tools/perf/ui/browsers/hists.c

344

chain->has_children = chain->list.next == &child->val &&

tools/perf/ui/browsers/hists.c

355

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

357

chain = list_entry(node->val.next, struct callchain_list, list);

tools/perf/ui/browsers/hists.c

358

chain->has_children = has_sibling;

tools/perf/ui/browsers/hists.c

361

chain = list_entry(node->val.prev, struct callchain_list, list);

tools/perf/ui/browsers/hists.c

362

chain->has_children = !RB_EMPTY_ROOT(&node->rb_root);

tools/perf/ui/browsers/hists.c

518

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

521

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

523

callchain_list__set_folding(chain, unfold);

tools/perf/ui/browsers/hists.c

524

has_children = chain->has_children;

tools/perf/ui/browsers/hists.c

536

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

540

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/browsers/hists.c

542

callchain_list__set_folding(chain, unfold);

tools/perf/ui/browsers/hists.c

543

has_children = chain->has_children;

tools/perf/ui/browsers/hists.c

552

static int callchain__set_folding(struct rb_root *chain, bool unfold)

tools/perf/ui/browsers/hists.c

557

for (nd = rb_first(chain); nd; nd = rb_next(nd)) {

tools/perf/ui/browsers/hists.c

784

struct callchain_list *chain,

tools/perf/ui/browsers/hists.c

790

struct callchain_list *chain,

tools/perf/ui/browsers/hists.c

796

char folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

797

bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;

tools/perf/ui/browsers/hists.c

802

browser->selection = &chain->ms;

tools/perf/ui/browsers/hists.c

816

struct callchain_list *chain,

tools/perf/ui/browsers/hists.c

821

char folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

846

struct callchain_list *chain,

tools/perf/ui/browsers/hists.c

865

str = callchain_list__sym_name(chain, bf, sizeof(bf),

tools/perf/ui/browsers/hists.c

869

callchain_list_counts__printf_value(chain, NULL,

tools/perf/ui/browsers/hists.c

888

print(browser, chain, str, offset, row, arg);

tools/perf/ui/browsers/hists.c

927

struct callchain_list *chain;

tools/perf/ui/browsers/hists.c

932

list_for_each_entry(chain, &child->parent_val, list) {

tools/perf/ui/browsers/hists.c

940

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

943

chain, row, total,

tools/perf/ui/browsers/hists.c

955

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/browsers/hists.c

963

folded_sign = callchain_list__folded(chain);

tools/perf/ui/browsers/hists.c

966

chain, row, total,

tools/perf/ui/browsers/hists.c

988

struct callchain_list *chain,

tools/perf/ui/browsers/hists.c

995

str = callchain_list__sym_name(chain, bf, sizeof(bf),

tools/perf/ui/gtk/hists.c

105

struct callchain_list *chain;

tools/perf/ui/gtk/hists.c

116

list_for_each_entry(chain, &node->parent_val, list) {

tools/perf/ui/gtk/hists.c

124

callchain_list__sym_name(chain, buf, sizeof(buf), false);

tools/perf/ui/gtk/hists.c

137

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/gtk/hists.c

145

callchain_list__sym_name(chain, buf, sizeof(buf), false);

tools/perf/ui/gtk/hists.c

167

struct callchain_list *chain;

tools/perf/ui/gtk/hists.c

177

list_for_each_entry(chain, &node->parent_val, list) {

tools/perf/ui/gtk/hists.c

180

callchain_list__sym_name(chain, name, sizeof(name), false);

tools/perf/ui/gtk/hists.c

193

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/gtk/hists.c

196

callchain_list__sym_name(chain, name, sizeof(name), false);

tools/perf/ui/gtk/hists.c

228

struct callchain_list *chain;

tools/perf/ui/gtk/hists.c

238

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/gtk/hists.c

246

callchain_list__sym_name(chain, buf, sizeof(buf), false);

tools/perf/ui/stdio/hist.c

119

struct callchain_list *chain;

tools/perf/ui/stdio/hist.c

157

list_for_each_entry(chain, &child->val, list) {

tools/perf/ui/stdio/hist.c

158

ret += ipchain__fprintf_graph(fp, child, chain, depth,

tools/perf/ui/stdio/hist.c

226

struct callchain_list *chain;

tools/perf/ui/stdio/hist.c

237

list_for_each_entry(chain, &cnode->val, list) {

tools/perf/ui/stdio/hist.c

258

callchain_list__sym_name(chain, bf,

tools/perf/ui/stdio/hist.c

264

chain, fp, NULL, 0);

tools/perf/ui/stdio/hist.c

289

struct callchain_list *chain;

tools/perf/ui/stdio/hist.c

299

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/stdio/hist.c

300

if (chain->ip >= PERF_CONTEXT_MAX)

tools/perf/ui/stdio/hist.c

302

ret += fprintf(fp, " %s\n", callchain_list__sym_name(chain,

tools/perf/ui/stdio/hist.c

314

struct callchain_node *chain;

tools/perf/ui/stdio/hist.c

318

chain = rb_entry(rb_node, struct callchain_node, rb_node);

tools/perf/ui/stdio/hist.c

321

ret += callchain_node__fprintf_value(chain, fp, total_samples);

tools/perf/ui/stdio/hist.c

323

ret += __callchain__fprintf_flat(fp, chain, total_samples);

tools/perf/ui/stdio/hist.c

337

struct callchain_list *chain;

tools/perf/ui/stdio/hist.c

348

list_for_each_entry(chain, &node->val, list) {

tools/perf/ui/stdio/hist.c

349

if (chain->ip >= PERF_CONTEXT_MAX)

tools/perf/ui/stdio/hist.c

352

callchain_list__sym_name(chain,

tools/perf/ui/stdio/hist.c

365

struct callchain_node *chain;

tools/perf/ui/stdio/hist.c

370

chain = rb_entry(rb_node, struct callchain_node, rb_node);

tools/perf/ui/stdio/hist.c

372

ret += callchain_node__fprintf_value(chain, fp, total_samples);

tools/perf/ui/stdio/hist.c

374

ret += __callchain__fprintf_folded(fp, chain);

tools/perf/ui/stdio/hist.c

55

struct callchain_list *chain,

tools/perf/ui/stdio/hist.c

79

str = callchain_list__sym_name(chain, bf, sizeof(bf), false);

tools/perf/ui/stdio/hist.c

82

callchain_list_counts__printf_value(chain, NULL,

tools/perf/util/callchain.c

1565

struct callchain_list *chain, *new;

tools/perf/util/callchain.c

1569

list_for_each_entry_reverse(chain, &parent->val, list) {

tools/perf/util/callchain.c

1573

*new = *chain;

tools/perf/util/callchain.c

1575

map_symbol__copy(&new->ms, &chain->ms);

tools/perf/util/callchain.c

1581

list_for_each_entry_safe_reverse(chain, new, &head, list)

tools/perf/util/callchain.c

1582

list_move_tail(&chain->list, &node->parent_val);

tools/perf/util/callchain.c

1585

chain = list_first_entry(&node->parent_val, struct callchain_list, list);

tools/perf/util/callchain.c

1586

chain->has_children = rb_prev(&node->rb_node) || rb_next(&node->rb_node);

tools/perf/util/callchain.c

1588

chain = list_first_entry(&node->val, struct callchain_list, list);

tools/perf/util/callchain.c

1589

chain->has_children = false;

tools/perf/util/callchain.c

1594

list_for_each_entry_safe(chain, new, &head, list) {

tools/perf/util/callchain.c

1595

list_del_init(&chain->list);

tools/perf/util/callchain.c

1596

map_symbol__exit(&chain->ms);

tools/perf/util/callchain.c

1597

zfree(&chain->brtype_stat);

tools/perf/util/callchain.c

1598

free(chain);

tools/perf/util/callchain.c

1798

struct callchain_list *chain;

tools/perf/util/callchain.c

1801

list_for_each_entry(chain, &cnode->val, list) {

tools/perf/util/callchain.c

1802

if (chain->srcline && chain->branch_count)

tools/perf/util/callchain.c

1803

cycles += chain->cycles_count / chain->branch_count;

tools/perf/util/callchain.c

390

rb_insert_callchain(struct rb_root *root, struct callchain_node *chain,

tools/perf/util/callchain.c

396

u64 chain_cumul = callchain_cumul_hits(chain);

tools/perf/util/callchain.c

408

if (rnode->hit < chain->hit)

tools/perf/util/callchain.c

426

rb_link_node(&chain->rb_node, parent, p);

tools/perf/util/callchain.c

427

rb_insert_color(&chain->rb_node, root);

tools/perf/util/callchain.h

277

int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain);

tools/perf/util/callchain.h

280

struct ip_callchain *chain __maybe_unused)

tools/perf/util/intel-pt.c

1230

pt->chain = intel_pt_alloc_chain(pt);

tools/perf/util/intel-pt.c

1231

if (!pt->chain)

tools/perf/util/intel-pt.c

1244

thread_stack__sample_late(thread, sample->cpu, pt->chain,

tools/perf/util/intel-pt.c

1248

sample->callchain = pt->chain;

tools/perf/util/intel-pt.c

1305

ptq->chain = intel_pt_alloc_chain(pt);

tools/perf/util/intel-pt.c

1306

if (!ptq->chain)

tools/perf/util/intel-pt.c

1395

zfree(&ptq->chain);

tools/perf/util/intel-pt.c

1412

zfree(&ptq->chain);

tools/perf/util/intel-pt.c

158

struct ip_callchain *chain;

tools/perf/util/intel-pt.c

1827

thread_stack__sample(ptq->thread, ptq->cpu, ptq->chain,

tools/perf/util/intel-pt.c

1830

sample->callchain = ptq->chain;

tools/perf/util/intel-pt.c

189

struct ip_callchain *chain;

tools/perf/util/intel-pt.c

2466

thread_stack__sample(ptq->thread, ptq->cpu, ptq->chain,

tools/perf/util/intel-pt.c

2469

sample.callchain = ptq->chain;

tools/perf/util/intel-pt.c

3835

zfree(&pt->chain);

tools/perf/util/intel-pt.c

4713

zfree(&pt->chain);

tools/perf/util/machine.c

2336

struct ip_callchain *chain = sample->callchain;

tools/perf/util/machine.c

2343

root_al, &cpumode, chain->ips[i],

tools/perf/util/machine.c

2354

root_al, &cpumode, chain->ips[i],

tools/perf/util/machine.c

2671

struct ip_callchain *chain = sample->callchain;

tools/perf/util/machine.c

2672

int chain_nr = min(max_stack, (int)chain->nr), i;

tools/perf/util/machine.c

2679

if (chain->ips[i] == PERF_CONTEXT_USER)

tools/perf/util/machine.c

2749

static int find_prev_cpumode(struct ip_callchain *chain, struct thread *thread,

tools/perf/util/machine.c

2758

u64 ip = chain->ips[ent];

tools/perf/util/machine.c

2790

struct ip_callchain *chain = sample->callchain;

tools/perf/util/machine.c

2798

if (chain)

tools/perf/util/machine.c

2799

chain_nr = chain->nr;

tools/perf/util/machine.c

2816

skip_idx = arch_skip_callchain_idx(thread, chain);

tools/perf/util/machine.c

2844

if (chain == NULL)

tools/perf/util/machine.c

2855

chain->ips[first_call] >= PERF_CONTEXT_MAX)

tools/perf/util/machine.c

2857

else if (be[i].from < chain->ips[first_call] &&

tools/perf/util/machine.c

2858

be[i].from >= chain->ips[first_call] - 8)

tools/perf/util/machine.c

2893

if (chain && callchain_param.order != ORDER_CALLEE) {

tools/perf/util/machine.c

2894

err = find_prev_cpumode(chain, thread, cursor, parent, root_al,

tools/perf/util/machine.c

2895

&cpumode, chain->nr - first_call, symbols);

tools/perf/util/machine.c

2906

j = chain->nr - i - 1;

tools/perf/util/machine.c

2912

ip = chain->ips[j];

tools/perf/util/machine.c

2916

err = find_prev_cpumode(chain, thread, cursor, parent,

tools/perf/util/machine.c

2932

if (usr_idx >= 0 && chain->ips[usr_idx] == PERF_CONTEXT_USER) {

tools/perf/util/session.h

141

struct ip_callchain *chain,

tools/perf/util/stream.c

270

struct callchain_list *chain;

tools/perf/util/stream.c

289

list_for_each_entry(chain, &cnode->val, list) {

tools/perf/util/stream.c

290

s = callchain_list__sym_name(chain, cbuf, sizeof(cbuf), false);

tools/perf/util/thread-stack.c

522

struct ip_callchain *chain,

tools/perf/util/thread-stack.c

531

chain->nr = 0;

tools/perf/util/thread-stack.c

535

chain->ips[0] = context;

tools/perf/util/thread-stack.c

536

chain->ips[1] = ip;

tools/perf/util/thread-stack.c

539

chain->nr = 2;

tools/perf/util/thread-stack.c

551

chain->ips[i++] = context;

tools/perf/util/thread-stack.c

554

chain->ips[i] = ip;

tools/perf/util/thread-stack.c

557

chain->nr = i;

tools/perf/util/thread-stack.c

565

struct ip_callchain *chain, size_t sz,

tools/perf/util/thread-stack.c

574

chain->nr = 0;

tools/perf/util/thread-stack.c

602

chain->ips[nr++] = context;

tools/perf/util/thread-stack.c

605

chain->ips[nr] = ip;

tools/perf/util/thread-stack.c

609

chain->nr = nr;

tools/perf/util/thread-stack.c

611

chain->ips[0] = sample_context;

tools/perf/util/thread-stack.c

612

chain->ips[1] = sample_ip;

tools/perf/util/thread-stack.c

613

chain->nr = 2;

tools/perf/util/thread-stack.h

86

void thread_stack__sample(struct thread *thread, int cpu, struct ip_callchain *chain,

tools/perf/util/thread-stack.h

89

struct ip_callchain *chain, size_t sz, u64 ip,

tools/testing/selftests/vDSO/parse_vdso.c

195

vdso_info.chain = &hash[vdso_info.nbucket + 2];

tools/testing/selftests/vDSO/parse_vdso.c

290

for (; i; i = vdso_info.chain[i]) {

tools/testing/selftests/vDSO/parse_vdso.c

58

ELF_HASH_ENTRY *bucket, *chain;