arch/powerpc/include/asm/book3s/64/kup.h

197

#include <linux/sched.h>

arch/x86/events/core.c

1001

return sched.state.unassigned;

arch/x86/events/core.c

838

static void perf_sched_init(struct perf_sched *sched, struct event_constraint **constraints,

arch/x86/events/core.c

843

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

arch/x86/events/core.c

844

sched->max_events = num;

arch/x86/events/core.c

845

sched->max_weight = wmax;

arch/x86/events/core.c

846

sched->max_gp = gpmax;

arch/x86/events/core.c

847

sched->constraints = constraints;

arch/x86/events/core.c

854

sched->state.event = idx; /* start with min weight */

arch/x86/events/core.c

855

sched->state.weight = wmin;

arch/x86/events/core.c

856

sched->state.unassigned = num;

arch/x86/events/core.c

859

static void perf_sched_save_state(struct perf_sched *sched)

arch/x86/events/core.c

861

if (WARN_ON_ONCE(sched->saved_states >= SCHED_STATES_MAX))

arch/x86/events/core.c

864

sched->saved[sched->saved_states] = sched->state;

arch/x86/events/core.c

865

sched->saved_states++;

arch/x86/events/core.c

868

static bool perf_sched_restore_state(struct perf_sched *sched)

arch/x86/events/core.c

870

if (!sched->saved_states)

arch/x86/events/core.c

873

sched->saved_states--;

arch/x86/events/core.c

874

sched->state = sched->saved[sched->saved_states];

arch/x86/events/core.c

878

sched->state.used &= ~BIT_ULL(sched->state.counter);

arch/x86/events/core.c

881

sched->state.counter++;

arch/x86/events/core.c

890

static bool __perf_sched_find_counter(struct perf_sched *sched)

arch/x86/events/core.c

895

if (!sched->state.unassigned)

arch/x86/events/core.c

898

if (sched->state.event >= sched->max_events)

arch/x86/events/core.c

901

c = sched->constraints[sched->state.event];

arch/x86/events/core.c

908

if (sched->state.used & mask)

arch/x86/events/core.c

911

sched->state.used |= mask;

arch/x86/events/core.c

917

idx = sched->state.counter;

arch/x86/events/core.c

924

if (sched->state.used & mask)

arch/x86/events/core.c

927

if (sched->state.nr_gp++ >= sched->max_gp)

arch/x86/events/core.c

930

sched->state.used |= mask;

arch/x86/events/core.c

937

sched->state.counter = idx;

arch/x86/events/core.c

940

perf_sched_save_state(sched);

arch/x86/events/core.c

945

static bool perf_sched_find_counter(struct perf_sched *sched)

arch/x86/events/core.c

947

while (!__perf_sched_find_counter(sched)) {

arch/x86/events/core.c

948

if (!perf_sched_restore_state(sched))

arch/x86/events/core.c

959

static bool perf_sched_next_event(struct perf_sched *sched)

arch/x86/events/core.c

963

if (!sched->state.unassigned || !--sched->state.unassigned)

arch/x86/events/core.c

968

sched->state.event++;

arch/x86/events/core.c

969

if (sched->state.event >= sched->max_events) {

arch/x86/events/core.c

971

sched->state.event = 0;

arch/x86/events/core.c

972

sched->state.weight++;

arch/x86/events/core.c

973

if (sched->state.weight > sched->max_weight)

arch/x86/events/core.c

976

c = sched->constraints[sched->state.event];

arch/x86/events/core.c

977

} while (c->weight != sched->state.weight);

arch/x86/events/core.c

979

sched->state.counter = 0; /* start with first counter */

arch/x86/events/core.c

990

struct perf_sched sched;

arch/x86/events/core.c

992

perf_sched_init(&sched, constraints, n, wmin, wmax, gpmax);

arch/x86/events/core.c

995

if (!perf_sched_find_counter(&sched))

arch/x86/events/core.c

998

assign[sched.state.event] = sched.state.counter;

arch/x86/events/core.c

999

} while (perf_sched_next_event(&sched));

arch/xtensa/include/asm/bitops.h

216

#include <asm-generic/bitops/sched.h>

drivers/accel/amdxdna/aie2_ctx.c

102

drm_sched_stop(&hwctx->priv->sched, bad_job);

drivers/accel/amdxdna/aie2_ctx.c

104

drm_sched_start(&hwctx->priv->sched, 0);

drivers/accel/amdxdna/aie2_ctx.c

675

struct drm_gpu_scheduler *sched;

drivers/accel/amdxdna/aie2_ctx.c

724

sched = &priv->sched;

drivers/accel/amdxdna/aie2_ctx.c

731

ret = drm_sched_init(sched, &args);

drivers/accel/amdxdna/aie2_ctx.c

738

&sched, 1, NULL);

drivers/accel/amdxdna/aie2_ctx.c

796

drm_sched_fini(&priv->sched);

drivers/accel/amdxdna/aie2_ctx.c

822

drm_sched_stop(&hwctx->priv->sched, NULL);

drivers/accel/amdxdna/aie2_ctx.c

824

drm_sched_start(&hwctx->priv->sched, 0);

drivers/accel/amdxdna/aie2_ctx.c

835

drm_sched_fini(&hwctx->priv->sched);

drivers/accel/amdxdna/aie2_pci.h

110

struct drm_gpu_scheduler sched;

drivers/accel/ethosu/ethosu_device.h

182

struct drm_gpu_scheduler sched;

drivers/accel/ethosu/ethosu_job.c

211

drm_sched_fault(&dev->sched);

drivers/accel/ethosu/ethosu_job.c

273

drm_sched_stop(&dev->sched, bad);

drivers/accel/ethosu/ethosu_job.c

283

drm_sched_start(&dev->sched, 0);

drivers/accel/ethosu/ethosu_job.c

330

ret = drm_sched_init(&edev->sched, &args);

drivers/accel/ethosu/ethosu_job.c

339

drm_sched_fini(&edev->sched);

drivers/accel/ethosu/ethosu_job.c

345

drm_sched_fini(&dev->sched);

drivers/accel/ethosu/ethosu_job.c

351

struct drm_gpu_scheduler *sched = &dev->sched;

drivers/accel/ethosu/ethosu_job.c

356

&sched, 1, NULL);

drivers/accel/rocket/rocket_core.h

55

struct drm_gpu_scheduler sched;

drivers/accel/rocket/rocket_job.c

275

struct drm_gpu_scheduler *sched)

drivers/accel/rocket/rocket_job.c

280

if (&rdev->cores[core].sched == sched)

drivers/accel/rocket/rocket_job.c

291

struct rocket_core *core = sched_to_core(rdev, sched_job->sched);

drivers/accel/rocket/rocket_job.c

356

drm_sched_stop(&core->sched, bad);

drivers/accel/rocket/rocket_job.c

379

drm_sched_start(&core->sched, 0);

drivers/accel/rocket/rocket_job.c

386

struct rocket_core *core = sched_to_core(rdev, sched_job->sched);

drivers/accel/rocket/rocket_job.c

472

ret = drm_sched_init(&core->sched, &args);

drivers/accel/rocket/rocket_job.c

481

drm_sched_fini(&core->sched);

drivers/accel/rocket/rocket_job.c

489

drm_sched_fini(&core->sched);

drivers/accel/rocket/rocket_job.c

504

scheds[core] = &rdev->cores[core].sched;

drivers/accel/rocket/rocket_job.c

527

if (atomic_read(&core->sched.credit_count))

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

872

if (!kiq_ring->sched.ready || amdgpu_in_reset(adev))

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

297

drm_sched_stop(&ring->sched, NULL);

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

302

drm_sched_start(&ring->sched, 0);

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

1101

struct drm_gpu_scheduler *sched =

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

1102

container_of(entity->rq, typeof(*sched), rq);

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

1103

struct amdgpu_ring *ring = to_amdgpu_ring(sched);

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

1199

struct drm_gpu_scheduler *sched;

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

1232

sched = container_of(p->gang_leader->base.entity->rq, typeof(*sched),

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

1243

if (!s_fence || s_fence->sched != sched) {

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

207

struct drm_gpu_scheduler **scheds = NULL, *sched = NULL;

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

229

scheds = adev->gpu_sched[hw_ip][hw_prio].sched;

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

252

sched = drm_sched_pick_best(scheds, num_scheds);

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

253

scheds = &sched;

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

872

scheds = adev->gpu_sched[hw_ip][hw_prio].sched;

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

1776

drm_sched_wqueue_stop(&ring->sched);

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

1792

drm_sched_wqueue_start(&ring->sched);

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

1948

static void amdgpu_ib_preempt_job_recovery(struct drm_gpu_scheduler *sched)

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

1953

spin_lock(&sched->job_list_lock);

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

1954

list_for_each_entry(s_job, &sched->pending_list, list) {

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

1955

fence = sched->ops->run_job(s_job);

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

1958

spin_unlock(&sched->job_list_lock);

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

1968

struct drm_gpu_scheduler *sched = &ring->sched;

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

1985

spin_lock(&sched->job_list_lock);

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

1986

list_for_each_entry_safe(s_job, tmp, &sched->pending_list, list) {

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

1990

sched->ops->free_job(s_job);

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

1998

spin_unlock(&sched->job_list_lock);

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

2032

drm_sched_wqueue_stop(&ring->sched);

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

2055

amdgpu_ib_preempt_job_recovery(&ring->sched);

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

2066

drm_sched_wqueue_start(&ring->sched);

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

582

coredump->ring = to_amdgpu_ring(s_job->sched);

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

2286

r = drm_sched_init(&ring->sched, &args);

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

5643

drm_sched_wqueue_stop(&ring->sched);

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

5646

amdgpu_job_stop_all_jobs_on_sched(&ring->sched);

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

5727

drm_sched_wqueue_start(&ring->sched);

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

2855

if (ring && ring->sched.ready) {

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

596

if (ring->sched.ops)

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

597

drm_sched_fini(&ring->sched);

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

1142

if (adev->mes.ring[0].sched.ready)

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

1218

if (adev->mes.ring[0].sched.ready) {

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

1316

if (adev->enable_mes_kiq && adev->mes.ring[0].sched.ready)

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

1665

struct drm_gpu_scheduler *sched = &ring->sched;

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

1677

&sched, 1, NULL);

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

1735

if ((ring->xcp_id == xcp_id) && ring->sched.ready) {

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

2587

ring->sched.ready = true;

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

2589

ring->sched.ready = false;

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

2607

if (ring->sched.ready)

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

2657

ring->sched.ready = true;

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

2659

ring->sched.ready = false;

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

2678

if (ring->sched.ready)

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

575

if (!kiq_ring->sched.ready || amdgpu_in_reset(adev))

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

627

if (!adev->gfx.kiq[0].ring.sched.ready || amdgpu_in_reset(adev))

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

733

!ring->sched.ready) {

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

802

if (!adev->gmc.flush_pasid_uses_kiq || !ring->sched.ready) {

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

888

if (adev->mes.ring[MES_PIPE_INST(xcc_inst, 0)].sched.ready) {

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

178

if (!ring->sched.ready) {

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

440

if (!ring->sched.ready || !ring->funcs->test_ib)

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

465

ring->sched.ready = false;

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

118

s_job->sched->name);

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

123

job->base.sched->name, atomic_read(&ring->fence_drv.last_seq),

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

137

s_job->sched->name);

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

139

drm_sched_wqueue_stop(&ring->sched);

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

143

drm_sched_wqueue_start(&ring->sched);

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

146

ring->sched.name);

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

151

dev_err(adev->dev, "Ring %s reset failed\n", ring->sched.name);

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

176

drm_sched_suspend_timeout(&ring->sched);

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

377

job->base.sched = &ring->sched;

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

391

struct drm_gpu_scheduler *sched =

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

392

container_of(s_entity->rq, typeof(*sched), rq);

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

393

struct amdgpu_ring *ring = to_amdgpu_ring(sched);

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

430

struct amdgpu_ring *ring = to_amdgpu_ring(sched_job->sched);

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

484

void amdgpu_job_stop_all_jobs_on_sched(struct drm_gpu_scheduler *sched)

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

486

struct drm_sched_rq *rq = &sched->rq;

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

504

list_for_each_entry(s_job, &sched->pending_list, list) {

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

90

struct amdgpu_ring *ring = to_amdgpu_ring(s_job->sched);

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

99

__func__, s_job->sched->name);

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

110

struct drm_gpu_scheduler *sched =

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

111

container_of(job->base.entity->rq, typeof(*sched), rq);

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

113

return to_amdgpu_ring(sched);

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

135

void amdgpu_job_stop_all_jobs_on_sched(struct drm_gpu_scheduler *sched);

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

375

ring->sched.ready = true;

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

377

ring->sched.ready = false;

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

397

if (ring->sched.ready)

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

451

if (adev->gfx.gfx_ring[i].sched.ready &&

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

466

if (adev->gfx.compute_ring[i].sched.ready &&

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

481

if (adev->sdma.instance[i].ring.sched.ready &&

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

499

if (adev->uvd.inst[i].ring.sched.ready &&

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

509

if (adev->vce.ring[i].sched.ready &&

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

522

if (adev->uvd.inst[i].ring_enc[j].sched.ready &&

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

535

if (adev->vcn.inst[i].ring_dec.sched.ready &&

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

549

if (adev->vcn.inst[i].ring_enc[j].sched.ready &&

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

565

if (adev->jpeg.inst[i].ring_dec[j].sched.ready &&

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

574

if (adev->vpe.ring.sched.ready &&

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

327

rst_ctxt->job->base.sched->name);

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

381

adev->gpu_sched[hw_ip][hw_prio].sched[(*num_sched)++] =

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

382

&ring->sched;

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

402

ring->sched.ready = false;

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

818

ring->sched.ready = !r;

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

909

if (ring->no_scheduler || !drm_sched_wqueue_ready(&ring->sched))

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

112

struct drm_gpu_scheduler *sched[AMDGPU_MAX_HWIP_RINGS];

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

309

struct drm_gpu_scheduler sched;

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

69

#define to_amdgpu_ring(s) container_of((s), struct amdgpu_ring, sched)

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

381

ring->sched.ready = true;

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

383

ring->sched.ready = false;

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

387

page->sched.ready = true;

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

389

page->sched.ready = false;

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

420

if (ring->sched.ready)

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

426

if (page->sched.ready)

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

571

drm_sched_wqueue_stop(&gfx_ring->sched);

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

574

drm_sched_wqueue_stop(&page_ring->sched);

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

604

drm_sched_wqueue_start(&gfx_ring->sched);

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

607

drm_sched_wqueue_start(&page_ring->sched);

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

335

if (s_fence->sched == &ring->sched) {

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

73

ring = container_of(s_fence->sched, struct amdgpu_ring, sched);

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

148

__field(struct drm_gpu_scheduler *, sched)

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

156

__entry->sched = container_of(job->base.entity->rq,

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

157

typeof(*__entry->sched),

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

160

__entry->ring = to_amdgpu_ring(__entry->sched)->idx;

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

163

to_amdgpu_ring(__entry->sched));

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

178

__string(ring, to_amdgpu_ring(job->base.sched)->name)

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

201

__string(ring, to_amdgpu_ring(job->base.sched)->name)

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

553

__string(ring, sched_job->base.sched->name)

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

2480

if (!ring->sched.ready) {

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

2663

struct drm_gpu_scheduler *sched;

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

2671

sched = &adev->sdma.instance[i].page.sched;

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

2673

sched = &adev->sdma.instance[i].ring.sched;

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

2675

if (!sched->ready)

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

2678

adev->mman.buffer_funcs_scheds[n++] = sched;

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

413

struct drm_gpu_scheduler *sched = &ring->sched;

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

417

&sched, 1, NULL);

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

281

struct drm_gpu_scheduler *sched = &ring->sched;

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

285

&sched, 1, NULL);

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

1418

ring->sched.ready = true;

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

1420

ring->sched.ready = false;

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

1438

if (ring->sched.ready)

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

1515

drm_sched_wqueue_stop(&vinst->ring_dec.sched);

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

1517

drm_sched_wqueue_stop(&vinst->ring_enc[i].sched);

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

1543

drm_sched_wqueue_start(&vinst->ring_dec.sched);

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

1545

drm_sched_wqueue_start(&vinst->ring_enc[i].sched);

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

1282

adev->mes.ring[0].sched.ready = false;

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

3211

struct drm_gpu_scheduler *sched;

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

3216

sched = &adev->sdma.instance[i].page.sched;

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

3218

sched = &adev->sdma.instance[i].ring.sched;

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

3219

adev->vm_manager.vm_pte_scheds[i] = sched;

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

109

struct drm_gpu_scheduler *sched =

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

110

container_of(p->vm->delayed.rq, typeof(*sched), rq);

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

112

container_of(sched, struct amdgpu_ring, sched);

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

469

struct drm_gpu_scheduler *sched =

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

470

container_of(entity->entity.rq, typeof(*sched), rq);

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

475

if (drm_sched_wqueue_ready(sched)) {

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

476

struct amdgpu_ring *ring = to_amdgpu_ring(sched);

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

512

xcp_mgr->xcp[fpriv->xcp_id].gpu_sched[hw_ip][hw_prio].sched;

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

580

.sched[(*num_gpu_sched)++] = &ring->sched;

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

601

if (!ring || !ring->sched.ready || ring->no_scheduler)

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

1193

drm_sched_fault(&adev->sdma.instance[instance_id].ring.sched);

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

6650

adev->gfx.kiq[0].ring.sched.ready = false;

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

9367

drm_sched_fault(&ring->sched);

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

9376

drm_sched_fault(&ring->sched);

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

439

if (adev->enable_mes && !adev->gfx.kiq[0].ring.sched.ready) {

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

6726

drm_sched_fault(&ring->sched);

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

6735

drm_sched_fault(&ring->sched);

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

2812

adev->gfx.kiq[0].ring.sched.ready = enable;

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

3476

adev->gfx.kiq[0].ring.sched.ready = true;

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

3531

adev->gfx.kiq[0].ring.sched.ready = false;

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

357

if (adev->enable_mes && !adev->gfx.kiq[0].ring.sched.ready) {

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

5043

drm_sched_fault(&ring->sched);

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

5052

drm_sched_fault(&ring->sched);

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

157

if (adev->enable_mes && !adev->gfx.kiq[0].ring.sched.ready) {

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

1965

adev->gfx.kiq[xcc_id].ring.sched.ready = enable;

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

2494

ring->sched.ready = true;

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

2559

adev->gfx.kiq[xcc_id].ring.sched.ready = false;

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

3819

drm_sched_fault(&ring->sched);

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

3424

drm_sched_fault(&ring->sched);

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

4820

drm_sched_fault(&adev->gfx.gfx_ring[0].sched);

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

4827

drm_sched_fault(&ring->sched);

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

1489

if (!ring->sched.ready)

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

4286

adev->gfx.kiq[0].ring.sched.ready = false;

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

6621

drm_sched_fault(&adev->gfx.gfx_ring[0].sched);

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

6629

drm_sched_fault(&ring->sched);

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

3476

adev->gfx.kiq[0].ring.sched.ready = false;

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

4706

if (!ring->sched.ready)

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

6313

drm_sched_fault(&adev->gfx.gfx_ring[0].sched);

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

6321

drm_sched_fault(&ring->sched);

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

501

if (!adev->gfx.compute_ring[0].sched.ready ||

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

502

!adev->gfx.compute_ring[1].sched.ready)

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

645

if (!adev->gfx.compute_ring[0].sched.ready)

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

1747

adev->gfx.kiq[xcc_id].ring.sched.ready = false;

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

3430

drm_sched_fault(&ring->sched);

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

258

if (adev->gfx.kiq[0].ring.sched.ready && !adev->enable_mes &&

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

246

if ((adev->gfx.kiq[0].ring.sched.ready || adev->mes.ring[0].sched.ready) &&

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

317

if ((adev->gfx.kiq[0].ring.sched.ready || adev->mes.ring[0].sched.ready) &&

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

352

if (adev->enable_uni_mes && adev->mes.ring[AMDGPU_MES_SCHED_PIPE].sched.ready &&

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

347

if (((adev->gfx.kiq[inst].ring.sched.ready ||

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

348

adev->mes.ring[MES_PIPE_INST(inst, 0)].sched.ready) &&

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

383

if (adev->enable_uni_mes && adev->mes.ring[0].sched.ready &&

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

800

if (adev->gfx.kiq[inst].ring.sched.ready &&

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

196

ring->sched.ready = true;

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

387

ring->sched.ready = true;

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

266

ring->sched.ready = true;

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

1635

if (adev->mes.ring[0].sched.ready) {

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

1637

adev->mes.ring[0].sched.ready = false;

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

1655

if (adev->mes.ring[0].sched.ready)

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

1704

adev->gfx.kiq[0].ring.sched.ready = false;

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

1705

adev->mes.ring[0].sched.ready = true;

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

1463

kiq_ring->sched.ready = false;

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

1727

adev->mes.ring[0].sched.ready = false;

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

1806

if (adev->mes.ring[0].sched.ready) {

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

1814

adev->mes.ring[0].sched.ready = false;

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

1827

if (adev->mes.ring[0].sched.ready)

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

1883

adev->gfx.kiq[0].ring.sched.ready = false;

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

1884

adev->mes.ring[0].sched.ready = true;

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

1439

kiq_ring->sched.ready = false;

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

1722

adev->mes.ring[MES_PIPE_INST(xcc_id, 0)].sched.ready = false;

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

1814

if (adev->mes.ring[inst].sched.ready) {

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

1822

adev->mes.ring[inst].sched.ready = false;

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

1874

if (adev->mes.ring[MES_PIPE_INST(xcc_id, 0)].sched.ready)

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

1929

adev->gfx.kiq[xcc_id].ring.sched.ready = false;

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

1930

adev->mes.ring[MES_PIPE_INST(xcc_id, 0)].sched.ready = true;

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

1089

drm_sched_fault(&adev->sdma.instance[instance_id].ring.sched);

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

1427

drm_sched_fault(&adev->sdma.instance[instance_id].ring.sched);

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

2155

drm_sched_fault(&adev->sdma.instance[instance].ring.sched);

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

1848

drm_sched_fault(&adev->sdma.instance[instance].ring.sched);

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

610

ring->sched.ready = true;

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

619

ring->sched.ready = false;

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

592

ring->sched.ready = true;

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

601

ring->sched.ready = false;

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

300

ring->sched.ready = false;

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

472

adev->vcn.inst[j].ring_enc[0].sched.ready = true;

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

473

adev->vcn.inst[j].ring_enc[1].sched.ready = false;

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

474

adev->vcn.inst[j].ring_enc[2].sched.ready = false;

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

475

adev->vcn.inst[j].ring_dec.sched.ready = true;

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

1902

[AMDGPU_RING_PRIO_DEFAULT].sched;

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

383

ring->sched.ready = false;

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

390

ring->sched.ready = true;

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

396

ring->sched.ready = false;

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

403

ring->sched.ready = true;

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

1818

[AMDGPU_RING_PRIO_0].sched;

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

337

ring->sched.ready = true;

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

1666

drm_sched_wqueue_stop(&ring->sched);

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

1703

drm_sched_wqueue_start(&ring->sched);

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

358

ring->sched.ready = true;

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

1313

drm_sched_wqueue_stop(&ring->sched);

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

1349

drm_sched_wqueue_start(&ring->sched);

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

313

ring->sched.ready = true;

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

270

vpe->ring.sched.ready = false;

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

304

vpe->ring.sched.ready = false;

drivers/gpu/drm/amd/pm/amdgpu_dpm.c

582

if (ring && ring->sched.ready)

drivers/gpu/drm/etnaviv/etnaviv_drv.c

87

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/etnaviv/etnaviv_drv.c

90

sched = &gpu->sched;

drivers/gpu/drm/etnaviv/etnaviv_drv.c

92

DRM_SCHED_PRIORITY_NORMAL, &sched,

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1597

drm_sched_fault(&gpu->sched);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1990

if (atomic_read(&gpu->sched.credit_count))

drivers/gpu/drm/etnaviv/etnaviv_gpu.h

118

struct drm_gpu_scheduler sched;

drivers/gpu/drm/etnaviv/etnaviv_sched.c

154

return drm_sched_init(&gpu->sched, &args);

drivers/gpu/drm/etnaviv/etnaviv_sched.c

159

drm_sched_fini(&gpu->sched);

drivers/gpu/drm/etnaviv/etnaviv_sched.c

77

drm_sched_stop(&gpu->sched, sched_job);

drivers/gpu/drm/etnaviv/etnaviv_sched.c

86

drm_sched_resubmit_jobs(&gpu->sched);

drivers/gpu/drm/etnaviv/etnaviv_sched.c

88

drm_sched_start(&gpu->sched, 0);

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

1625

ctx->sched = pc->sched;

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

2088

ctx->sched.priority = args->value;

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

2094

if (ctx->sched.priority >= I915_PRIORITY_NORMAL &&

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

2573

args->value = ctx->sched.priority;

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

299

pc->sched.priority = I915_PRIORITY_NORMAL;

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

935

pc->sched.priority = args->value;

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

994

if (ctx->sched.priority >= I915_PRIORITY_NORMAL &&

drivers/gpu/drm/i915/gem/i915_gem_context_types.h

200

struct i915_sched_attr sched;

drivers/gpu/drm/i915/gem/i915_gem_context_types.h

375

struct i915_sched_attr sched;

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

3084

attr = eb->gem_context->sched;

drivers/gpu/drm/i915/gt/intel_context.c

563

sched.link) {

drivers/gpu/drm/i915/gt/intel_engine_cs.c

2324

list_for_each_entry(rq, requests, sched.link) {

drivers/gpu/drm/i915/gt/intel_engine_cs.c

2503

sched.link) {

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

115

rq->sched.attr.priority);

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

190

rq->sched.attr.priority < I915_PRIORITY_BARRIER) {

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

198

if (rq->sched.attr.priority >= attr.priority)

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

200

if (rq->sched.attr.priority >= attr.priority)

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

305

GEM_BUG_ON(rq->sched.attr.priority < I915_PRIORITY_BARRIER);

drivers/gpu/drm/i915/gt/intel_engine_heartbeat.c

44

if (rq && rq->sched.attr.priority >= I915_PRIORITY_BARRIER &&

drivers/gpu/drm/i915/gt/intel_engine_pm.c

222

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/intel_engine_user.c

100

u8 sched;

drivers/gpu/drm/i915/gt/intel_engine_user.c

128

enabled |= BIT(map[i].sched);

drivers/gpu/drm/i915/gt/intel_engine_user.c

130

disabled |= BIT(map[i].sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1087

list_move_tail(&rq->sched.link, pl);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1091

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1113

list_move_tail(&w->sched.link, &list);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1116

rq = list_first_entry_or_null(&list, typeof(*rq), sched.link);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1166

if (!list_is_last_rcu(&rq->sched.link,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

1324

last->sched.attr.priority,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2064

list_move_tail(&rq->sched.link,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2071

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2089

list_move_tail(&w->sched.link, &list);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2092

rq = list_first_entry_or_null(&list, typeof(*rq), sched.link);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2137

container_of(p->signaler, typeof(*s), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2164

list_move_tail(&rq->sched.link,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2172

container_of(p->waiter, typeof(*w), sched);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2187

list_move_tail(&w->sched.link, &list);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2190

rq = list_first_entry_or_null(&list, typeof(*rq), sched.link);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2550

GEM_BUG_ON(!list_empty(&rq->sched.link));

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2551

list_add_tail(&rq->sched.link,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2586

list_add_tail(&request->sched.link,

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

2593

GEM_BUG_ON(list_empty(&request->sched.link));

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

264

return READ_ONCE(rq->sched.attr.priority);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3174

list_for_each_entry(rq, &engine->sched_engine->requests, sched.link)

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3194

list_for_each_entry(rq, &sched_engine->hold, sched.link)

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3280

list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3300

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3350

inflight->sched.attr.priority);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

337

if (!list_is_last(&rq->sched.link, &engine->sched_engine->requests) &&

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

338

rq_prio(list_next_entry(rq, sched.link)) > last_prio)

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

383

sched.link) {

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

385

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

3920

list_move_tail(&rq->sched.link, virtual_queue(ve));

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

399

list_move(&rq->sched.link, pl);

drivers/gpu/drm/i915/gt/intel_execlists_submission.c

4093

list_for_each_entry(rq, &sched_engine->requests, sched.link) {

drivers/gpu/drm/i915/gt/intel_ring_submission.c

1138

list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests);

drivers/gpu/drm/i915/gt/intel_ring_submission.c

1144

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/intel_ring_submission.c

398

list_for_each_entry(pos, &engine->sched_engine->requests, sched.link) {

drivers/gpu/drm/i915/gt/intel_ring_submission.c

468

list_for_each_entry(request, &engine->sched_engine->requests, sched.link)

drivers/gpu/drm/i915/gt/intel_ring_submission.c

655

sched.link)

drivers/gpu/drm/i915/gt/mock_engine.c

259

list_move_tail(&rq->sched.link, &rq->engine->sched_engine->requests);

drivers/gpu/drm/i915/gt/mock_engine.c

280

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/mock_engine.c

305

list_for_each_entry(rq, &engine->sched_engine->requests, sched.link)

drivers/gpu/drm/i915/gt/selftest_context.c

28

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1484

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1548

ctx_hi->sched.priority = I915_CONTEXT_MAX_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1556

ctx_lo->sched.priority = I915_CONTEXT_MIN_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1747

ctx_hi->sched.priority = I915_CONTEXT_MAX_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1752

ctx_lo->sched.priority = I915_CONTEXT_MIN_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1851

ctx_lo->sched.priority = 1;

drivers/gpu/drm/i915/gt/selftest_execlists.c

1973

b.ctx->sched.priority = I915_PRIORITY_MAX;

drivers/gpu/drm/i915/gt/selftest_execlists.c

2843

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_execlists.c

2885

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_execlists.c

3389

ctx_hi->sched.priority = I915_CONTEXT_MAX_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

3394

ctx_lo->sched.priority = I915_CONTEXT_MIN_USER_PRIORITY;

drivers/gpu/drm/i915/gt/selftest_execlists.c

3511

ctx->sched.priority = prio;

drivers/gpu/drm/i915/gt/selftest_execlists.c

393

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_execlists.c

440

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

986

h.ctx->sched.priority = 1024;

drivers/gpu/drm/i915/gt/selftest_lrc.c

104

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_lrc.c

1257

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/selftest_lrc.c

558

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

1835

sched.link) {

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

1839

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

1850

list_add(&rq->sched.link, pl);

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

1968

list_for_each_entry(rq, &ce->guc_state.requests, sched.link)

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

2006

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

2205

GEM_BUG_ON(!list_empty(&rq->sched.link));

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

2206

list_add_tail(&rq->sched.link,

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

3731

list_move_tail(&rq->sched.link, &ce->guc_state.requests);

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

3766

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

3866

prio = ctx->sched.priority;

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

5422

list_for_each_entry(rq, &ce->guc_state.requests, sched.link) {

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

799

return rq->sched.attr.priority;

drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c

961

list_del_init(&rq->sched.link);

drivers/gpu/drm/i915/i915_gpu_error.c

1419

erq->sched_attr = request->sched.attr;

drivers/gpu/drm/i915/i915_gpu_error.c

1470

e->sched_attr = ctx->sched;

drivers/gpu/drm/i915/i915_request.c

1019

GEM_BUG_ON(!list_empty(&rq->sched.signalers_list));

drivers/gpu/drm/i915/i915_request.c

1020

GEM_BUG_ON(!list_empty(&rq->sched.waiters_list));

drivers/gpu/drm/i915/i915_request.c

1141

return rq->sched.semaphores | READ_ONCE(rq->engine->saturated);

drivers/gpu/drm/i915/i915_request.c

1224

if (from->sched.flags & I915_SCHED_HAS_EXTERNAL_CHAIN)

drivers/gpu/drm/i915/i915_request.c

1241

to->sched.semaphores |= mask;

drivers/gpu/drm/i915/i915_request.c

1325

err = i915_sched_node_add_dependency(&to->sched,

drivers/gpu/drm/i915/i915_request.c

1326

&from->sched,

drivers/gpu/drm/i915/i915_request.c

1346

rq->sched.flags |= I915_SCHED_HAS_EXTERNAL_CHAIN;

drivers/gpu/drm/i915/i915_request.c

1482

ret = i915_sched_node_add_dependency(&to->sched,

drivers/gpu/drm/i915/i915_request.c

1483

&from->sched,

drivers/gpu/drm/i915/i915_request.c

1651

__i915_sched_node_add_dependency(&rq->sched,

drivers/gpu/drm/i915/i915_request.c

1652

&prev->sched,

drivers/gpu/drm/i915/i915_request.c

1706

__i915_sched_node_add_dependency(&rq->sched,

drivers/gpu/drm/i915/i915_request.c

1707

&prev->sched,

drivers/gpu/drm/i915/i915_request.c

1861

attr = ctx->sched;

drivers/gpu/drm/i915/i915_request.c

2222

x = print_sched_attr(&rq->sched.attr, buf, x, sizeof(buf));

drivers/gpu/drm/i915/i915_request.c

414

i915_sched_node_fini(&rq->sched);

drivers/gpu/drm/i915/i915_request.c

633

list_del_init(&request->sched.link);

drivers/gpu/drm/i915/i915_request.c

659

if (request->sched.semaphores &&

drivers/gpu/drm/i915/i915_request.c

661

engine->saturated |= request->sched.semaphores;

drivers/gpu/drm/i915/i915_request.c

738

if (request->sched.semaphores && __i915_request_has_started(request))

drivers/gpu/drm/i915/i915_request.c

739

request->sched.semaphores = 0;

drivers/gpu/drm/i915/i915_request.c

879

i915_sched_node_init(&rq->sched);

drivers/gpu/drm/i915/i915_request.c

972

i915_sched_node_reinit(&rq->sched);

drivers/gpu/drm/i915/i915_request.h

270

struct i915_sched_node sched;

drivers/gpu/drm/i915/i915_request.h

604

return !list_empty(&rq->sched.link);

drivers/gpu/drm/i915/i915_scheduler.c

21

return container_of(node, const struct i915_request, sched);

drivers/gpu/drm/i915/i915_scheduler.c

242

sched);

drivers/gpu/drm/i915/i915_scheduler.c

292

__i915_schedule(&rq->sched, attr);

drivers/gpu/drm/i915/i915_scheduler.h

20

list_for_each_entry(it, &(plist)->requests, sched.link)

drivers/gpu/drm/i915/i915_scheduler.h

23

list_for_each_entry_safe(it, n, &(plist)->requests, sched.link)

drivers/gpu/drm/i915/i915_scheduler_types.h

86

&(rq__)->sched.waiters_list, \

drivers/gpu/drm/i915/i915_scheduler_types.h

91

&(rq__)->sched.signalers_list, \

drivers/gpu/drm/i915/i915_trace.h

361

__entry->prio = rq->sched.attr.priority;

drivers/gpu/drm/i915/selftests/i915_request.c

2522

rq->sched.attr.priority = I915_PRIORITY_BARRIER;

drivers/gpu/drm/imagination/pvr_queue.c

1220

struct pvr_queue *queue = container_of(job->base.sched, struct pvr_queue, scheduler);

drivers/gpu/drm/imagination/pvr_queue.c

1292

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/imagination/pvr_queue.c

1330

sched = &queue->scheduler;

drivers/gpu/drm/imagination/pvr_queue.c

1370

&sched, 1, &ctx->faulty);

drivers/gpu/drm/imagination/pvr_queue.c

663

struct pvr_queue *queue = container_of(job->base.sched, struct pvr_queue, scheduler);

drivers/gpu/drm/imagination/pvr_queue.c

806

struct pvr_queue *queue = container_of(job->base.sched,

drivers/gpu/drm/imagination/pvr_queue.c

864

struct drm_gpu_scheduler *sched = s_job->sched;

drivers/gpu/drm/imagination/pvr_queue.c

865

struct pvr_queue *queue = container_of(sched, struct pvr_queue, scheduler);

drivers/gpu/drm/imagination/pvr_queue.c

873

dev_err(sched->dev, "Job timeout\n");

drivers/gpu/drm/imagination/pvr_queue.c

889

drm_sched_stop(sched, s_job);

drivers/gpu/drm/imagination/pvr_queue.c

892

list_for_each_entry(job, &sched->pending_list, base.list) {

drivers/gpu/drm/imagination/pvr_queue.c

911

drm_sched_start(sched, 0);

drivers/gpu/drm/imagination/pvr_queue.c

955

sched_fence->sched->ops == &pvr_queue_sched_ops)

drivers/gpu/drm/lima/lima_sched.c

110

static inline struct lima_sched_pipe *to_lima_pipe(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/lima/lima_sched.c

112

return container_of(sched, struct lima_sched_pipe, base);

drivers/gpu/drm/lima/lima_sched.c

163

struct drm_gpu_scheduler *sched = &pipe->base;

drivers/gpu/drm/lima/lima_sched.c

166

&sched, 1, NULL);

drivers/gpu/drm/lima/lima_sched.c

209

struct lima_sched_pipe *pipe = to_lima_pipe(job->sched);

drivers/gpu/drm/lima/lima_sched.c

276

struct lima_sched_pipe *pipe = to_lima_pipe(task->base.sched);

drivers/gpu/drm/lima/lima_sched.c

405

struct lima_sched_pipe *pipe = to_lima_pipe(job->sched);

drivers/gpu/drm/lima/lima_sched.c

478

struct lima_sched_pipe *pipe = to_lima_pipe(job->sched);

drivers/gpu/drm/lima/lima_trace.h

19

__string(pipe, task->base.sched->name)

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

348

struct drm_gpu_scheduler *sched = &gpu->rb[i]->sched;

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

350

drm_sched_wqueue_stop(sched);

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

359

struct drm_gpu_scheduler *sched = &gpu->rb[i]->sched;

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

361

drm_sched_wqueue_start(sched);

drivers/gpu/drm/msm/msm_gem.h

76

struct drm_gpu_scheduler sched;

drivers/gpu/drm/msm/msm_gem_vma.c

850

ret = drm_sched_init(&vm->sched, &args);

drivers/gpu/drm/msm/msm_gem_vma.c

920

drm_sched_stop(&vm->sched, NULL);

drivers/gpu/drm/msm/msm_gem_vma.c

921

drm_sched_fini(&vm->sched);

drivers/gpu/drm/msm/msm_perfcntr.c

38

queue_work(ring->sched.submit_wq, &stream->sel_work);

drivers/gpu/drm/msm/msm_ringbuffer.c

110

ret = drm_sched_init(&ring->sched, &args);

drivers/gpu/drm/msm/msm_ringbuffer.c

135

drm_sched_fini(&ring->sched);

drivers/gpu/drm/msm/msm_ringbuffer.h

58

struct drm_gpu_scheduler sched;

drivers/gpu/drm/msm/msm_submitqueue.c

152

struct drm_gpu_scheduler *sched = &ring->sched;

drivers/gpu/drm/msm/msm_submitqueue.c

157

ret = drm_sched_entity_init(entity, sched_prio, &sched, 1, NULL);

drivers/gpu/drm/msm/msm_submitqueue.c

221

struct drm_gpu_scheduler *sched = &to_msm_vm(msm_context_vm(drm, ctx))->sched;

drivers/gpu/drm/msm/msm_submitqueue.c

226

&sched, 1, NULL);

drivers/gpu/drm/nouveau/nouveau_abi16.c

178

if (chan->sched)

drivers/gpu/drm/nouveau/nouveau_abi16.c

179

drm_sched_entity_kill(&chan->sched->entity);

drivers/gpu/drm/nouveau/nouveau_abi16.c

184

if (chan->sched)

drivers/gpu/drm/nouveau/nouveau_abi16.c

185

nouveau_sched_destroy(&chan->sched);

drivers/gpu/drm/nouveau/nouveau_abi16.c

447

ret = nouveau_sched_create(&chan->sched, drm, drm->sched_wq,

drivers/gpu/drm/nouveau/nouveau_abi16.h

30

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_drm.c

220

if (cli->sched)

drivers/gpu/drm/nouveau/nouveau_drm.c

221

nouveau_sched_destroy(&cli->sched);

drivers/gpu/drm/nouveau/nouveau_drm.c

317

ret = nouveau_sched_create(&cli->sched, drm, NULL, 1);

drivers/gpu/drm/nouveau/nouveau_drv.h

105

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_exec.c

241

args.sched = __args->sched;

drivers/gpu/drm/nouveau/nouveau_exec.c

396

args.sched = chan16->sched;

drivers/gpu/drm/nouveau/nouveau_exec.h

11

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

120

struct nouveau_sched *sched = job->sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

122

spin_lock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

124

spin_unlock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

126

wake_up(&sched->job.wq);

drivers/gpu/drm/nouveau/nouveau_sched.c

275

struct nouveau_sched *sched = job->sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

29

struct nouveau_sched *sched = args->sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

295

mutex_lock(&sched->mutex);

drivers/gpu/drm/nouveau/nouveau_sched.c

307

spin_lock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

308

list_add(&job->entry, &sched->job.list.head);

drivers/gpu/drm/nouveau/nouveau_sched.c

309

spin_unlock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

328

mutex_unlock(&sched->mutex);

drivers/gpu/drm/nouveau/nouveau_sched.c

338

mutex_unlock(&sched->mutex);

drivers/gpu/drm/nouveau/nouveau_sched.c

36

job->sched = sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

370

struct drm_gpu_scheduler *sched = sched_job->sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

374

drm_sched_stop(sched, sched_job);

drivers/gpu/drm/nouveau/nouveau_sched.c

381

drm_sched_start(sched, 0);

drivers/gpu/drm/nouveau/nouveau_sched.c

401

nouveau_sched_init(struct nouveau_sched *sched, struct nouveau_drm *drm,

drivers/gpu/drm/nouveau/nouveau_sched.c

404

struct drm_gpu_scheduler *drm_sched = &sched->base;

drivers/gpu/drm/nouveau/nouveau_sched.c

405

struct drm_sched_entity *entity = &sched->entity;

drivers/gpu/drm/nouveau/nouveau_sched.c

422

sched->wq = wq;

drivers/gpu/drm/nouveau/nouveau_sched.c

446

mutex_init(&sched->mutex);

drivers/gpu/drm/nouveau/nouveau_sched.c

447

spin_lock_init(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

448

INIT_LIST_HEAD(&sched->job.list.head);

drivers/gpu/drm/nouveau/nouveau_sched.c

449

init_waitqueue_head(&sched->job.wq);

drivers/gpu/drm/nouveau/nouveau_sched.c

456

if (sched->wq)

drivers/gpu/drm/nouveau/nouveau_sched.c

457

destroy_workqueue(sched->wq);

drivers/gpu/drm/nouveau/nouveau_sched.c

465

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

468

sched = kzalloc_obj(*sched);

drivers/gpu/drm/nouveau/nouveau_sched.c

469

if (!sched)

drivers/gpu/drm/nouveau/nouveau_sched.c

472

ret = nouveau_sched_init(sched, drm, wq, credit_limit);

drivers/gpu/drm/nouveau/nouveau_sched.c

474

kfree(sched);

drivers/gpu/drm/nouveau/nouveau_sched.c

478

*psched = sched;

drivers/gpu/drm/nouveau/nouveau_sched.c

484

nouveau_sched_job_list_empty(struct nouveau_sched *sched)

drivers/gpu/drm/nouveau/nouveau_sched.c

488

spin_lock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

489

empty = list_empty(&sched->job.list.head);

drivers/gpu/drm/nouveau/nouveau_sched.c

490

spin_unlock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_sched.c

496

nouveau_sched_fini(struct nouveau_sched *sched)

drivers/gpu/drm/nouveau/nouveau_sched.c

498

struct drm_gpu_scheduler *drm_sched = &sched->base;

drivers/gpu/drm/nouveau/nouveau_sched.c

499

struct drm_sched_entity *entity = &sched->entity;

drivers/gpu/drm/nouveau/nouveau_sched.c

501

wait_event(sched->job.wq, nouveau_sched_job_list_empty(sched));

drivers/gpu/drm/nouveau/nouveau_sched.c

509

if (sched->wq)

drivers/gpu/drm/nouveau/nouveau_sched.c

510

destroy_workqueue(sched->wq);

drivers/gpu/drm/nouveau/nouveau_sched.c

516

struct nouveau_sched *sched = *psched;

drivers/gpu/drm/nouveau/nouveau_sched.c

518

nouveau_sched_fini(sched);

drivers/gpu/drm/nouveau/nouveau_sched.c

519

kfree(sched);

drivers/gpu/drm/nouveau/nouveau_sched.c

87

ret = drm_sched_job_init(&job->base, &sched->entity,

drivers/gpu/drm/nouveau/nouveau_sched.h

29

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_sched.h

53

struct nouveau_sched *sched;

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1084

struct nouveau_sched *sched = job->sched;

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1090

spin_lock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1091

list_for_each_entry(__job, &sched->job.list.head, entry) {

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1101

spin_unlock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1109

spin_unlock(&sched->job.list.lock);

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1686

args.sched = __args->sched;

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1814

args.sched = cli->sched;

drivers/gpu/drm/nouveau/nouveau_uvmm.h

56

struct nouveau_sched *sched;

drivers/gpu/drm/panfrost/panfrost_job.c

1066

struct drm_gpu_scheduler *sched = &pfdev->js->queue[i].sched;

drivers/gpu/drm/panfrost/panfrost_job.c

1069

&sched, 1, NULL);

drivers/gpu/drm/panfrost/panfrost_job.c

36

struct drm_gpu_scheduler sched;

drivers/gpu/drm/panfrost/panfrost_job.c

502

drm_sched_fault(&pfdev->js->queue[js].sched);

drivers/gpu/drm/panfrost/panfrost_job.c

682

drm_sched_stop(&pfdev->js->queue[i].sched, bad);

drivers/gpu/drm/panfrost/panfrost_job.c

747

drm_sched_resubmit_jobs(&pfdev->js->queue[i].sched);

drivers/gpu/drm/panfrost/panfrost_job.c

752

drm_sched_start(&pfdev->js->queue[i].sched, 0);

drivers/gpu/drm/panfrost/panfrost_job.c

900

ret = drm_sched_init(&js->queue[j].sched, &args);

drivers/gpu/drm/panfrost/panfrost_job.c

914

drm_sched_fini(&js->queue[j].sched);

drivers/gpu/drm/panfrost/panfrost_job.c

928

drm_sched_fini(&js->queue[j].sched);

drivers/gpu/drm/panfrost/panfrost_job.c

976

if (atomic_read(&js->queue[i].sched.credit_count))

drivers/gpu/drm/panthor/panthor_mmu.c

1986

drm_sched_fini(&vm->sched);

drivers/gpu/drm/panthor/panthor_mmu.c

246

struct drm_gpu_scheduler sched;

drivers/gpu/drm/panthor/panthor_mmu.c

2731

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/panthor/panthor_mmu.c

2800

ret = drm_sched_init(&vm->sched, &sched_args);

drivers/gpu/drm/panthor/panthor_mmu.c

2804

sched = &vm->sched;

drivers/gpu/drm/panthor/panthor_mmu.c

2805

ret = drm_sched_entity_init(&vm->entity, 0, &sched, 1, NULL);

drivers/gpu/drm/panthor/panthor_mmu.c

2831

drm_sched_fini(&vm->sched);

drivers/gpu/drm/panthor/panthor_mmu.c

856

drm_sched_stop(&vm->sched, NULL);

drivers/gpu/drm/panthor/panthor_mmu.c

861

drm_sched_start(&vm->sched, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1478

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1479

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

1485

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1503

cancel_delayed_work(&sched->tick_work);

drivers/gpu/drm/panthor/panthor_sched.c

1505

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1524

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1525

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

1533

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1575

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1582

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1596

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1626

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1630

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1645

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1681

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1682

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

1685

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1696

if (!queue_work(sched->heap_alloc_wq, &group->tiler_oom_work))

drivers/gpu/drm/panthor/panthor_sched.c

1732

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1734

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1736

sched->might_have_idle_groups = true;

drivers/gpu/drm/panthor/panthor_sched.c

1742

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1762

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1763

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

1766

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1778

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1873

struct panthor_scheduler *sched = container_of(work, struct panthor_scheduler,

drivers/gpu/drm/panthor/panthor_sched.c

1875

u32 events = atomic_xchg(&sched->fw_events, 0);

drivers/gpu/drm/panthor/panthor_sched.c

1876

struct panthor_device *ptdev = sched->ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

1878

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1892

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

1954

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

1957

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2022

tick_ctx_is_full(const struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2025

return ctx->group_count == sched->csg_slot_count;

drivers/gpu/drm/panthor/panthor_sched.c

2029

tick_ctx_pick_groups_from_list(const struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2037

if (tick_ctx_is_full(sched, ctx))

drivers/gpu/drm/panthor/panthor_sched.c

2054

if (i == ctx->as_count && ctx->as_count == sched->as_slot_count)

drivers/gpu/drm/panthor/panthor_sched.c

2075

if (tick_ctx_is_full(sched, ctx))

drivers/gpu/drm/panthor/panthor_sched.c

2081

tick_ctx_insert_old_group(struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2085

struct panthor_csg_slot *csg_slot = &sched->csg_slots[group->csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2092

struct panthor_csg_slot *other_csg_slot = &sched->csg_slots[other_group->csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2107

tick_ctx_init(struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2110

struct panthor_device *ptdev = sched->ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

2124

for (i = 0; i < sched->csg_slot_count; i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2125

struct panthor_csg_slot *csg_slot = &sched->csg_slots[i];

drivers/gpu/drm/panthor/panthor_sched.c

2146

tick_ctx_insert_old_group(sched, ctx, group);

drivers/gpu/drm/panthor/panthor_sched.c

2218

tick_ctx_cleanup(struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2221

struct panthor_device *ptdev = sched->ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

2242

&sched->groups.idle[group->priority] :

drivers/gpu/drm/panthor/panthor_sched.c

2243

&sched->groups.runnable[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

2262

&sched->groups.idle[group->priority] :

drivers/gpu/drm/panthor/panthor_sched.c

2263

&sched->groups.runnable[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

2271

tick_ctx_apply(struct panthor_scheduler *sched, struct panthor_sched_tick_ctx *ctx)

drivers/gpu/drm/panthor/panthor_sched.c

2274

struct panthor_device *ptdev = sched->ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

2292

csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2308

csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2346

for (i = 0; i < sched->csg_slot_count; i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2347

if (!sched->csg_slots[i].group)

drivers/gpu/drm/panthor/panthor_sched.c

2370

csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2421

list_move_tail(&group->run_node, &sched->groups.idle[prio]);

drivers/gpu/drm/panthor/panthor_sched.c

2423

list_move_tail(&group->run_node, &sched->groups.runnable[prio]);

drivers/gpu/drm/panthor/panthor_sched.c

2428

sched->used_csg_slot_count = ctx->group_count;

drivers/gpu/drm/panthor/panthor_sched.c

2429

sched->might_have_idle_groups = ctx->idle_group_count > 0;

drivers/gpu/drm/panthor/panthor_sched.c

2433

tick_ctx_update_resched_target(struct panthor_scheduler *sched,

drivers/gpu/drm/panthor/panthor_sched.c

2441

resched_target = sched->last_tick + sched->tick_period;

drivers/gpu/drm/panthor/panthor_sched.c

2443

if (time_before64(sched->resched_target, sched->last_tick) ||

drivers/gpu/drm/panthor/panthor_sched.c

2444

time_before64(resched_target, sched->resched_target))

drivers/gpu/drm/panthor/panthor_sched.c

2445

sched->resched_target = resched_target;

drivers/gpu/drm/panthor/panthor_sched.c

2447

return sched->resched_target - sched->last_tick;

drivers/gpu/drm/panthor/panthor_sched.c

2450

sched->resched_target = U64_MAX;

drivers/gpu/drm/panthor/panthor_sched.c

2456

struct panthor_scheduler *sched = container_of(work, struct panthor_scheduler,

drivers/gpu/drm/panthor/panthor_sched.c

2458

struct panthor_device *ptdev = sched->ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

2460

u64 resched_target = sched->resched_target;

drivers/gpu/drm/panthor/panthor_sched.c

2475

resched_target = sched->last_tick + sched->tick_period;

drivers/gpu/drm/panthor/panthor_sched.c

2482

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2483

if (panthor_device_reset_is_pending(sched->ptdev))

drivers/gpu/drm/panthor/panthor_sched.c

2486

tick_ctx_init(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2496

prio >= 0 && !tick_ctx_is_full(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2498

tick_ctx_pick_groups_from_list(sched, &ctx, &ctx.old_groups[prio],

drivers/gpu/drm/panthor/panthor_sched.c

2501

tick_ctx_pick_groups_from_list(sched, &ctx,

drivers/gpu/drm/panthor/panthor_sched.c

2502

&sched->groups.runnable[prio],

drivers/gpu/drm/panthor/panthor_sched.c

2510

prio >= 0 && !tick_ctx_is_full(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2521

tick_ctx_pick_groups_from_list(sched, &ctx, &ctx.old_groups[prio], true, true);

drivers/gpu/drm/panthor/panthor_sched.c

2524

tick_ctx_pick_groups_from_list(sched, &ctx, &sched->groups.runnable[prio],

drivers/gpu/drm/panthor/panthor_sched.c

2532

tick_ctx_pick_groups_from_list(sched, &ctx, &ctx.old_groups[prio],

drivers/gpu/drm/panthor/panthor_sched.c

2539

prio >= 0 && !tick_ctx_is_full(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2542

tick_ctx_pick_groups_from_list(sched, &ctx, &ctx.old_groups[prio], false, true);

drivers/gpu/drm/panthor/panthor_sched.c

2543

tick_ctx_pick_groups_from_list(sched, &ctx, &sched->groups.idle[prio],

drivers/gpu/drm/panthor/panthor_sched.c

2547

tick_ctx_apply(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2552

panthor_devfreq_record_idle(sched->ptdev);

drivers/gpu/drm/panthor/panthor_sched.c

2553

if (sched->pm.has_ref) {

drivers/gpu/drm/panthor/panthor_sched.c

2555

sched->pm.has_ref = false;

drivers/gpu/drm/panthor/panthor_sched.c

2558

panthor_devfreq_record_busy(sched->ptdev);

drivers/gpu/drm/panthor/panthor_sched.c

2559

if (!sched->pm.has_ref) {

drivers/gpu/drm/panthor/panthor_sched.c

2561

sched->pm.has_ref = true;

drivers/gpu/drm/panthor/panthor_sched.c

2565

sched->last_tick = now;

drivers/gpu/drm/panthor/panthor_sched.c

2566

resched_delay = tick_ctx_update_resched_target(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2571

sched_queue_delayed_work(sched, tick, resched_delay);

drivers/gpu/drm/panthor/panthor_sched.c

2574

tick_ctx_cleanup(sched, &ctx);

drivers/gpu/drm/panthor/panthor_sched.c

2577

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2616

struct panthor_scheduler *sched = container_of(work,

drivers/gpu/drm/panthor/panthor_sched.c

2622

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2623

list_for_each_entry_safe(group, tmp, &sched->groups.waiting, wait_node) {

drivers/gpu/drm/panthor/panthor_sched.c

2644

&sched->groups.runnable[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

2653

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2656

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

2661

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2664

drm_WARN_ON(&ptdev->base, sched->resched_target != U64_MAX);

drivers/gpu/drm/panthor/panthor_sched.c

2670

sched->resched_target = sched->last_tick + sched->tick_period;

drivers/gpu/drm/panthor/panthor_sched.c

2671

if (sched->used_csg_slot_count == sched->csg_slot_count &&

drivers/gpu/drm/panthor/panthor_sched.c

2672

time_before64(now, sched->resched_target))

drivers/gpu/drm/panthor/panthor_sched.c

2673

delay_jiffies = min_t(unsigned long, sched->resched_target - now, ULONG_MAX);

drivers/gpu/drm/panthor/panthor_sched.c

2683

if (!delayed_work_pending(&sched->tick_work))

drivers/gpu/drm/panthor/panthor_sched.c

2684

sched_queue_delayed_work(sched, tick, delay_jiffies);

drivers/gpu/drm/panthor/panthor_sched.c

2690

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2691

struct list_head *queue = &sched->groups.runnable[group->priority];

drivers/gpu/drm/panthor/panthor_sched.c

2705

if (atomic_read(&sched->reset.in_progress))

drivers/gpu/drm/panthor/panthor_sched.c

2713

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

2720

if (sched->might_have_idle_groups) {

drivers/gpu/drm/panthor/panthor_sched.c

2721

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

2726

if (sched->resched_target != U64_MAX) {

drivers/gpu/drm/panthor/panthor_sched.c

2728

if (sched->used_csg_slot_count < sched->csg_slot_count)

drivers/gpu/drm/panthor/panthor_sched.c

2729

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

2761

struct panthor_scheduler *sched = group->ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2763

lockdep_assert_held(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

2769

list_move_tail(&group->run_node, &sched->reset.stopped_groups);

drivers/gpu/drm/panthor/panthor_sched.c

2774

struct panthor_scheduler *sched = group->ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2784

&sched->groups.idle[group->priority] :

drivers/gpu/drm/panthor/panthor_sched.c

2785

&sched->groups.runnable[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

2828

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2833

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2835

for (i = 0; i < sched->csg_slot_count; i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2836

struct panthor_csg_slot *csg_slot = &sched->csg_slots[i];

drivers/gpu/drm/panthor/panthor_sched.c

2858

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2882

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2916

struct panthor_csg_slot *csg_slot = &sched->csg_slots[csg_id];

drivers/gpu/drm/panthor/panthor_sched.c

2927

for (i = 0; i < sched->csg_slot_count; i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2928

struct panthor_csg_slot *csg_slot = &sched->csg_slots[i];

drivers/gpu/drm/panthor/panthor_sched.c

2945

&sched->groups.idle[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

2955

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

2960

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2964

mutex_lock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

2965

atomic_set(&sched->reset.in_progress, true);

drivers/gpu/drm/panthor/panthor_sched.c

2970

cancel_work_sync(&sched->sync_upd_work);

drivers/gpu/drm/panthor/panthor_sched.c

2971

cancel_delayed_work_sync(&sched->tick_work);

drivers/gpu/drm/panthor/panthor_sched.c

2978

for (i = 0; i < ARRAY_SIZE(sched->groups.runnable); i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2979

list_for_each_entry_safe(group, group_tmp, &sched->groups.runnable[i], run_node)

drivers/gpu/drm/panthor/panthor_sched.c

2983

for (i = 0; i < ARRAY_SIZE(sched->groups.idle); i++) {

drivers/gpu/drm/panthor/panthor_sched.c

2984

list_for_each_entry_safe(group, group_tmp, &sched->groups.idle[i], run_node)

drivers/gpu/drm/panthor/panthor_sched.c

2988

mutex_unlock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

2993

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

2996

mutex_lock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

2998

list_for_each_entry_safe(group, group_tmp, &sched->reset.stopped_groups, run_node) {

drivers/gpu/drm/panthor/panthor_sched.c

3011

atomic_set(&sched->reset.in_progress, false);

drivers/gpu/drm/panthor/panthor_sched.c

3012

mutex_unlock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

3016

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

3017

sched_queue_work(sched, sync_upd);

drivers/gpu/drm/panthor/panthor_sched.c

3189

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3201

params->waitall_mask = GENMASK(sched->sb_slot_count - 1, 0);

drivers/gpu/drm/panthor/panthor_sched.c

3318

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3337

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3380

sched->resched_target == U64_MAX;

drivers/gpu/drm/panthor/panthor_sched.c

3389

if (!sched->pm.has_ref &&

drivers/gpu/drm/panthor/panthor_sched.c

3392

sched->pm.has_ref = true;

drivers/gpu/drm/panthor/panthor_sched.c

3395

panthor_devfreq_record_busy(sched->ptdev);

drivers/gpu/drm/panthor/panthor_sched.c

3405

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3418

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3424

drm_WARN_ON(&ptdev->base, atomic_read(&sched->reset.in_progress));

drivers/gpu/drm/panthor/panthor_sched.c

3428

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3441

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3655

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3761

mutex_lock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

3762

if (atomic_read(&sched->reset.in_progress)) {

drivers/gpu/drm/panthor/panthor_sched.c

3765

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3767

&sched->groups.idle[group->priority]);

drivers/gpu/drm/panthor/panthor_sched.c

3768

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3770

mutex_unlock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

3793

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3803

mutex_lock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

3804

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3807

sched_queue_delayed_work(sched, tick, 0);

drivers/gpu/drm/panthor/panthor_sched.c

3808

} else if (!atomic_read(&sched->reset.in_progress)) {

drivers/gpu/drm/panthor/panthor_sched.c

3816

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3817

mutex_unlock(&sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

3840

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

3852

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

3861

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

4066

struct panthor_scheduler *sched = ptdev->scheduler;

drivers/gpu/drm/panthor/panthor_sched.c

4068

disable_delayed_work_sync(&sched->tick_work);

drivers/gpu/drm/panthor/panthor_sched.c

4069

disable_work_sync(&sched->fw_events_work);

drivers/gpu/drm/panthor/panthor_sched.c

4070

disable_work_sync(&sched->sync_upd_work);

drivers/gpu/drm/panthor/panthor_sched.c

4072

mutex_lock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

4073

if (sched->pm.has_ref) {

drivers/gpu/drm/panthor/panthor_sched.c

4075

sched->pm.has_ref = false;

drivers/gpu/drm/panthor/panthor_sched.c

4077

mutex_unlock(&sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

4082

struct panthor_scheduler *sched = res;

drivers/gpu/drm/panthor/panthor_sched.c

4085

if (!sched || !sched->csg_slot_count)

drivers/gpu/drm/panthor/panthor_sched.c

4088

if (sched->wq)

drivers/gpu/drm/panthor/panthor_sched.c

4089

destroy_workqueue(sched->wq);

drivers/gpu/drm/panthor/panthor_sched.c

4091

if (sched->heap_alloc_wq)

drivers/gpu/drm/panthor/panthor_sched.c

4092

destroy_workqueue(sched->heap_alloc_wq);

drivers/gpu/drm/panthor/panthor_sched.c

4095

drm_WARN_ON(ddev, !list_empty(&sched->groups.runnable[prio]));

drivers/gpu/drm/panthor/panthor_sched.c

4096

drm_WARN_ON(ddev, !list_empty(&sched->groups.idle[prio]));

drivers/gpu/drm/panthor/panthor_sched.c

4099

drm_WARN_ON(ddev, !list_empty(&sched->groups.waiting));

drivers/gpu/drm/panthor/panthor_sched.c

4107

struct panthor_scheduler *sched;

drivers/gpu/drm/panthor/panthor_sched.c

4111

sched = drmm_kzalloc(&ptdev->base, sizeof(*sched), GFP_KERNEL);

drivers/gpu/drm/panthor/panthor_sched.c

4112

if (!sched)

drivers/gpu/drm/panthor/panthor_sched.c

4140

sched->ptdev = ptdev;

drivers/gpu/drm/panthor/panthor_sched.c

4141

sched->sb_slot_count = CS_FEATURES_SCOREBOARDS(cs_iface->control->features);

drivers/gpu/drm/panthor/panthor_sched.c

4142

sched->csg_slot_count = num_groups;

drivers/gpu/drm/panthor/panthor_sched.c

4143

sched->cs_slot_count = csg_iface->control->stream_num;

drivers/gpu/drm/panthor/panthor_sched.c

4144

sched->as_slot_count = gpu_as_count;

drivers/gpu/drm/panthor/panthor_sched.c

4145

ptdev->csif_info.csg_slot_count = sched->csg_slot_count;

drivers/gpu/drm/panthor/panthor_sched.c

4146

ptdev->csif_info.cs_slot_count = sched->cs_slot_count;

drivers/gpu/drm/panthor/panthor_sched.c

4147

ptdev->csif_info.scoreboard_slot_count = sched->sb_slot_count;

drivers/gpu/drm/panthor/panthor_sched.c

4149

sched->last_tick = 0;

drivers/gpu/drm/panthor/panthor_sched.c

4150

sched->resched_target = U64_MAX;

drivers/gpu/drm/panthor/panthor_sched.c

4151

sched->tick_period = msecs_to_jiffies(10);

drivers/gpu/drm/panthor/panthor_sched.c

4152

INIT_DELAYED_WORK(&sched->tick_work, tick_work);

drivers/gpu/drm/panthor/panthor_sched.c

4153

INIT_WORK(&sched->sync_upd_work, sync_upd_work);

drivers/gpu/drm/panthor/panthor_sched.c

4154

INIT_WORK(&sched->fw_events_work, process_fw_events_work);

drivers/gpu/drm/panthor/panthor_sched.c

4156

ret = drmm_mutex_init(&ptdev->base, &sched->lock);

drivers/gpu/drm/panthor/panthor_sched.c

4161

INIT_LIST_HEAD(&sched->groups.runnable[prio]);

drivers/gpu/drm/panthor/panthor_sched.c

4162

INIT_LIST_HEAD(&sched->groups.idle[prio]);

drivers/gpu/drm/panthor/panthor_sched.c

4164

INIT_LIST_HEAD(&sched->groups.waiting);

drivers/gpu/drm/panthor/panthor_sched.c

4166

ret = drmm_mutex_init(&ptdev->base, &sched->reset.lock);

drivers/gpu/drm/panthor/panthor_sched.c

4170

INIT_LIST_HEAD(&sched->reset.stopped_groups);

drivers/gpu/drm/panthor/panthor_sched.c

4187

sched->heap_alloc_wq = alloc_workqueue("panthor-heap-alloc", WQ_UNBOUND, 0);

drivers/gpu/drm/panthor/panthor_sched.c

4188

sched->wq = alloc_workqueue("panthor-csf-sched", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);

drivers/gpu/drm/panthor/panthor_sched.c

4189

if (!sched->wq || !sched->heap_alloc_wq) {

drivers/gpu/drm/panthor/panthor_sched.c

4190

panthor_sched_fini(&ptdev->base, sched);

drivers/gpu/drm/panthor/panthor_sched.c

4195

ret = drmm_add_action_or_reset(&ptdev->base, panthor_sched_fini, sched);

drivers/gpu/drm/panthor/panthor_sched.c

4199

ptdev->scheduler = sched;

drivers/gpu/drm/panthor/panthor_sched.c

746

#define sched_queue_work(sched, wname) \

drivers/gpu/drm/panthor/panthor_sched.c

748

if (!atomic_read(&(sched)->reset.in_progress) && \

drivers/gpu/drm/panthor/panthor_sched.c

749

!panthor_device_reset_is_pending((sched)->ptdev)) \

drivers/gpu/drm/panthor/panthor_sched.c

750

queue_work((sched)->wq, &(sched)->wname ## _work); \

drivers/gpu/drm/panthor/panthor_sched.c

762

#define sched_queue_delayed_work(sched, wname, delay) \

drivers/gpu/drm/panthor/panthor_sched.c

764

if (!atomic_read(&sched->reset.in_progress) && \

drivers/gpu/drm/panthor/panthor_sched.c

765

!panthor_device_reset_is_pending((sched)->ptdev)) \

drivers/gpu/drm/panthor/panthor_sched.c

766

mod_delayed_work((sched)->wq, &(sched)->wname ## _work, delay); \

drivers/gpu/drm/scheduler/gpu_scheduler_trace.h

61

__string(name, sched_job->sched->name)

drivers/gpu/drm/scheduler/gpu_scheduler_trace.h

64

__string(dev, dev_name(sched_job->sched->dev))

drivers/gpu/drm/scheduler/gpu_scheduler_trace.h

74

&sched_job->sched->credit_count);

drivers/gpu/drm/scheduler/sched_entity.c

253

job->sched->ops->free_job(job);

drivers/gpu/drm/scheduler/sched_entity.c

332

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/scheduler/sched_entity.c

339

sched = container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_entity.c

347

sched->job_scheduled,

drivers/gpu/drm/scheduler/sched_entity.c

351

wait_event_killable(sched->job_scheduled,

drivers/gpu/drm/scheduler/sched_entity.c

420

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_entity.c

421

container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_entity.c

425

drm_sched_wakeup(sched);

drivers/gpu/drm/scheduler/sched_entity.c

452

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_entity.c

453

container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_entity.c

469

if (!fence->error && s_fence && s_fence->sched == sched &&

drivers/gpu/drm/scheduler/sched_entity.c

509

if (job->sched->ops->prepare_job)

drivers/gpu/drm/scheduler/sched_entity.c

510

return job->sched->ops->prepare_job(job, entity);

drivers/gpu/drm/scheduler/sched_entity.c

560

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/scheduler/sched_entity.c

586

sched = drm_sched_pick_best(entity->sched_list, entity->num_sched_list);

drivers/gpu/drm/scheduler/sched_entity.c

587

rq = sched ? &sched->rq : NULL;

drivers/gpu/drm/scheduler/sched_entity.c

611

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_entity.c

612

container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_entity.c

624

atomic_inc(sched->score);

drivers/gpu/drm/scheduler/sched_entity.c

635

sched = drm_sched_rq_add_entity(entity);

drivers/gpu/drm/scheduler/sched_entity.c

636

if (sched)

drivers/gpu/drm/scheduler/sched_entity.c

637

drm_sched_wakeup(sched);

drivers/gpu/drm/scheduler/sched_fence.c

118

if (!WARN_ON_ONCE(fence->sched))

drivers/gpu/drm/scheduler/sched_fence.c

230

fence->sched = container_of(entity->rq, typeof(*fence->sched), rq);

drivers/gpu/drm/scheduler/sched_fence.c

95

return (const char *)fence->sched->name;

drivers/gpu/drm/scheduler/sched_internal.h

34

bool drm_sched_can_queue(struct drm_gpu_scheduler *sched,

drivers/gpu/drm/scheduler/sched_internal.h

36

void drm_sched_wakeup(struct drm_gpu_scheduler *sched);

drivers/gpu/drm/scheduler/sched_internal.h

47

drm_sched_select_entity(struct drm_gpu_scheduler *sched);

drivers/gpu/drm/scheduler/sched_main.c

1010

drm_sched_run_job_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

1016

atomic_add(sched_job->credits, &sched->credit_count);

drivers/gpu/drm/scheduler/sched_main.c

1024

fence = sched->ops->run_job(sched_job);

drivers/gpu/drm/scheduler/sched_main.c

1034

DRM_DEV_ERROR(sched->dev, "fence add callback failed (%d)\n", r);

drivers/gpu/drm/scheduler/sched_main.c

1042

wake_up(&sched->job_scheduled);

drivers/gpu/drm/scheduler/sched_main.c

1043

drm_sched_run_job_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

106

bool drm_sched_can_queue(struct drm_gpu_scheduler *sched,

drivers/gpu/drm/scheduler/sched_main.c

1073

int drm_sched_init(struct drm_gpu_scheduler *sched, const struct drm_sched_init_args *args)

drivers/gpu/drm/scheduler/sched_main.c

1075

sched->ops = args->ops;

drivers/gpu/drm/scheduler/sched_main.c

1076

sched->credit_limit = args->credit_limit;

drivers/gpu/drm/scheduler/sched_main.c

1077

sched->name = args->name;

drivers/gpu/drm/scheduler/sched_main.c

1078

sched->timeout = args->timeout;

drivers/gpu/drm/scheduler/sched_main.c

1079

sched->hang_limit = args->hang_limit;

drivers/gpu/drm/scheduler/sched_main.c

1080

sched->timeout_wq = args->timeout_wq ? args->timeout_wq : system_percpu_wq;

drivers/gpu/drm/scheduler/sched_main.c

1081

sched->score = args->score ? args->score : &sched->_score;

drivers/gpu/drm/scheduler/sched_main.c

1082

sched->dev = args->dev;

drivers/gpu/drm/scheduler/sched_main.c

1085

sched->submit_wq = args->submit_wq;

drivers/gpu/drm/scheduler/sched_main.c

1086

sched->own_submit_wq = false;

drivers/gpu/drm/scheduler/sched_main.c

1088

sched->submit_wq = drm_sched_alloc_wq(args->name);

drivers/gpu/drm/scheduler/sched_main.c

1089

if (!sched->submit_wq)

drivers/gpu/drm/scheduler/sched_main.c

1092

sched->own_submit_wq = true;

drivers/gpu/drm/scheduler/sched_main.c

1095

drm_sched_rq_init(&sched->rq);

drivers/gpu/drm/scheduler/sched_main.c

1097

init_waitqueue_head(&sched->job_scheduled);

drivers/gpu/drm/scheduler/sched_main.c

1098

INIT_LIST_HEAD(&sched->pending_list);

drivers/gpu/drm/scheduler/sched_main.c

1099

spin_lock_init(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

1100

atomic_set(&sched->credit_count, 0);

drivers/gpu/drm/scheduler/sched_main.c

1101

INIT_DELAYED_WORK(&sched->work_tdr, drm_sched_job_timedout);

drivers/gpu/drm/scheduler/sched_main.c

1102

INIT_WORK(&sched->work_run_job, drm_sched_run_job_work);

drivers/gpu/drm/scheduler/sched_main.c

1103

INIT_WORK(&sched->work_free_job, drm_sched_free_job_work);

drivers/gpu/drm/scheduler/sched_main.c

1104

atomic_set(&sched->_score, 0);

drivers/gpu/drm/scheduler/sched_main.c

1105

atomic64_set(&sched->job_id_count, 0);

drivers/gpu/drm/scheduler/sched_main.c

1106

sched->pause_submit = false;

drivers/gpu/drm/scheduler/sched_main.c

1107

ewma_drm_sched_avgtime_init(&sched->avg_job_us);

drivers/gpu/drm/scheduler/sched_main.c

1109

sched->ready = true;

drivers/gpu/drm/scheduler/sched_main.c

1114

static void drm_sched_cancel_remaining_jobs(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1119

list_for_each_entry_safe_reverse(job, tmp, &sched->pending_list, list) {

drivers/gpu/drm/scheduler/sched_main.c

1120

sched->ops->cancel_job(job);

drivers/gpu/drm/scheduler/sched_main.c

1122

sched->ops->free_job(job);

drivers/gpu/drm/scheduler/sched_main.c

1139

void drm_sched_fini(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1141

drm_sched_wqueue_stop(sched);

drivers/gpu/drm/scheduler/sched_main.c

1144

wake_up_all(&sched->job_scheduled);

drivers/gpu/drm/scheduler/sched_main.c

1147

cancel_delayed_work_sync(&sched->work_tdr);

drivers/gpu/drm/scheduler/sched_main.c

1150

if (sched->ops->cancel_job)

drivers/gpu/drm/scheduler/sched_main.c

1151

drm_sched_cancel_remaining_jobs(sched);

drivers/gpu/drm/scheduler/sched_main.c

1153

if (sched->own_submit_wq)

drivers/gpu/drm/scheduler/sched_main.c

1154

destroy_workqueue(sched->submit_wq);

drivers/gpu/drm/scheduler/sched_main.c

1155

sched->ready = false;

drivers/gpu/drm/scheduler/sched_main.c

1157

if (!list_empty(&sched->pending_list))

drivers/gpu/drm/scheduler/sched_main.c

1158

dev_warn(sched->dev, "Tearing down scheduler while jobs are pending!\n");

drivers/gpu/drm/scheduler/sched_main.c

1173

struct drm_gpu_scheduler *sched = bad->sched;

drivers/gpu/drm/scheduler/sched_main.c

1175

struct drm_sched_rq *rq = &sched->rq;

drivers/gpu/drm/scheduler/sched_main.c

118

if (s_job->credits > sched->credit_limit) {

drivers/gpu/drm/scheduler/sched_main.c

119

dev_WARN(sched->dev,

drivers/gpu/drm/scheduler/sched_main.c

1205

bool drm_sched_wqueue_ready(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1207

return sched->ready;

drivers/gpu/drm/scheduler/sched_main.c

121

s_job->credits = sched->credit_limit;

drivers/gpu/drm/scheduler/sched_main.c

1218

void drm_sched_wqueue_stop(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1220

WRITE_ONCE(sched->pause_submit, true);

drivers/gpu/drm/scheduler/sched_main.c

1221

cancel_work_sync(&sched->work_run_job);

drivers/gpu/drm/scheduler/sched_main.c

1222

cancel_work_sync(&sched->work_free_job);

drivers/gpu/drm/scheduler/sched_main.c

1235

void drm_sched_wqueue_start(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1237

WRITE_ONCE(sched->pause_submit, false);

drivers/gpu/drm/scheduler/sched_main.c

1238

queue_work(sched->submit_wq, &sched->work_run_job);

drivers/gpu/drm/scheduler/sched_main.c

1239

queue_work(sched->submit_wq, &sched->work_free_job);

drivers/gpu/drm/scheduler/sched_main.c

124

return drm_sched_available_credits(sched) >= s_job->credits;

drivers/gpu/drm/scheduler/sched_main.c

1249

bool drm_sched_is_stopped(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

1251

return READ_ONCE(sched->pause_submit);

drivers/gpu/drm/scheduler/sched_main.c

1269

WARN_ON(!drm_sched_is_stopped(job->sched));

drivers/gpu/drm/scheduler/sched_main.c

131

static void drm_sched_run_job_queue(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

133

if (!drm_sched_is_stopped(sched))

drivers/gpu/drm/scheduler/sched_main.c

134

queue_work(sched->submit_wq, &sched->work_run_job);

drivers/gpu/drm/scheduler/sched_main.c

141

static void drm_sched_run_free_queue(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

143

if (!drm_sched_is_stopped(sched))

drivers/gpu/drm/scheduler/sched_main.c

144

queue_work(sched->submit_wq, &sched->work_free_job);

drivers/gpu/drm/scheduler/sched_main.c

157

struct drm_gpu_scheduler *sched = s_fence->sched;

drivers/gpu/drm/scheduler/sched_main.c

159

atomic_sub(s_job->credits, &sched->credit_count);

drivers/gpu/drm/scheduler/sched_main.c

160

atomic_dec(sched->score);

drivers/gpu/drm/scheduler/sched_main.c

167

drm_sched_run_free_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

189

static void drm_sched_start_timeout(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

191

lockdep_assert_held(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

193

if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&

drivers/gpu/drm/scheduler/sched_main.c

194

!list_empty(&sched->pending_list))

drivers/gpu/drm/scheduler/sched_main.c

195

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

drivers/gpu/drm/scheduler/sched_main.c

198

static void drm_sched_start_timeout_unlocked(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

200

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

201

drm_sched_start_timeout(sched);

drivers/gpu/drm/scheduler/sched_main.c

202

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

212

void drm_sched_tdr_queue_imm(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

214

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

215

sched->timeout = 0;

drivers/gpu/drm/scheduler/sched_main.c

216

drm_sched_start_timeout(sched);

drivers/gpu/drm/scheduler/sched_main.c

217

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

228

void drm_sched_fault(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

230

if (sched->timeout_wq)

drivers/gpu/drm/scheduler/sched_main.c

231

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

drivers/gpu/drm/scheduler/sched_main.c

247

unsigned long drm_sched_suspend_timeout(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

251

sched_timeout = sched->work_tdr.timer.expires;

drivers/gpu/drm/scheduler/sched_main.c

257

if (mod_delayed_work(sched->timeout_wq, &sched->work_tdr, MAX_SCHEDULE_TIMEOUT)

drivers/gpu/drm/scheduler/sched_main.c

261

return sched->timeout;

drivers/gpu/drm/scheduler/sched_main.c

273

void drm_sched_resume_timeout(struct drm_gpu_scheduler *sched,

drivers/gpu/drm/scheduler/sched_main.c

276

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

278

if (list_empty(&sched->pending_list))

drivers/gpu/drm/scheduler/sched_main.c

279

cancel_delayed_work(&sched->work_tdr);

drivers/gpu/drm/scheduler/sched_main.c

281

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

drivers/gpu/drm/scheduler/sched_main.c

283

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

289

struct drm_gpu_scheduler *sched = s_job->sched;

drivers/gpu/drm/scheduler/sched_main.c

291

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

292

list_add_tail(&s_job->list, &sched->pending_list);

drivers/gpu/drm/scheduler/sched_main.c

293

drm_sched_start_timeout(sched);

drivers/gpu/drm/scheduler/sched_main.c

294

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

309

static void drm_sched_job_reinsert_on_false_timeout(struct drm_gpu_scheduler *sched,

drivers/gpu/drm/scheduler/sched_main.c

312

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

313

list_add(&job->list, &sched->pending_list);

drivers/gpu/drm/scheduler/sched_main.c

319

drm_sched_run_free_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

320

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

325

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/scheduler/sched_main.c

329

sched = container_of(work, struct drm_gpu_scheduler, work_tdr.work);

drivers/gpu/drm/scheduler/sched_main.c

332

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

333

job = list_first_entry_or_null(&sched->pending_list,

drivers/gpu/drm/scheduler/sched_main.c

344

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

346

status = job->sched->ops->timedout_job(job);

drivers/gpu/drm/scheduler/sched_main.c

352

if (sched->free_guilty) {

drivers/gpu/drm/scheduler/sched_main.c

353

job->sched->ops->free_job(job);

drivers/gpu/drm/scheduler/sched_main.c

354

sched->free_guilty = false;

drivers/gpu/drm/scheduler/sched_main.c

358

drm_sched_job_reinsert_on_false_timeout(sched, job);

drivers/gpu/drm/scheduler/sched_main.c

360

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

364

drm_sched_start_timeout_unlocked(sched);

drivers/gpu/drm/scheduler/sched_main.c

386

void drm_sched_stop(struct drm_gpu_scheduler *sched, struct drm_sched_job *bad)

drivers/gpu/drm/scheduler/sched_main.c

390

drm_sched_wqueue_stop(sched);

drivers/gpu/drm/scheduler/sched_main.c

399

if (bad && bad->sched == sched)

drivers/gpu/drm/scheduler/sched_main.c

404

list_add(&bad->list, &sched->pending_list);

drivers/gpu/drm/scheduler/sched_main.c

413

list_for_each_entry_safe_reverse(s_job, tmp, &sched->pending_list,

drivers/gpu/drm/scheduler/sched_main.c

420

atomic_sub(s_job->credits, &sched->credit_count);

drivers/gpu/drm/scheduler/sched_main.c

426

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

428

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

444

sched->ops->free_job(s_job);

drivers/gpu/drm/scheduler/sched_main.c

446

sched->free_guilty = true;

drivers/gpu/drm/scheduler/sched_main.c

456

cancel_delayed_work(&sched->work_tdr);

drivers/gpu/drm/scheduler/sched_main.c

475

void drm_sched_start(struct drm_gpu_scheduler *sched, int errno)

drivers/gpu/drm/scheduler/sched_main.c

484

list_for_each_entry_safe(s_job, tmp, &sched->pending_list, list) {

drivers/gpu/drm/scheduler/sched_main.c

487

atomic_add(s_job->credits, &sched->credit_count);

drivers/gpu/drm/scheduler/sched_main.c

499

drm_sched_start_timeout_unlocked(sched);

drivers/gpu/drm/scheduler/sched_main.c

500

drm_sched_wqueue_start(sched);

drivers/gpu/drm/scheduler/sched_main.c

523

void drm_sched_resubmit_jobs(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

530

list_for_each_entry_safe(s_job, tmp, &sched->pending_list, list) {

drivers/gpu/drm/scheduler/sched_main.c

533

if (!found_guilty && atomic_read(&s_job->karma) > sched->hang_limit) {

drivers/gpu/drm/scheduler/sched_main.c

541

fence = sched->ops->run_job(s_job);

drivers/gpu/drm/scheduler/sched_main.c

596

dev_err(job->sched->dev, "%s: entity has no rq!\n", __func__);

drivers/gpu/drm/scheduler/sched_main.c

646

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/scheduler/sched_main.c

651

sched = container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_main.c

653

job->sched = sched;

drivers/gpu/drm/scheduler/sched_main.c

869

void drm_sched_wakeup(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

87

static u32 drm_sched_available_credits(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

871

drm_sched_run_job_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

886

drm_sched_get_finished_job(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_main.c

890

spin_lock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

892

job = list_first_entry_or_null(&sched->pending_list,

drivers/gpu/drm/scheduler/sched_main.c

899

cancel_delayed_work(&sched->work_tdr);

drivers/gpu/drm/scheduler/sched_main.c

901

next = list_first_entry_or_null(&sched->pending_list,

drivers/gpu/drm/scheduler/sched_main.c

91

WARN_ON(check_sub_overflow(sched->credit_limit,

drivers/gpu/drm/scheduler/sched_main.c

911

drm_sched_start_timeout(sched);

drivers/gpu/drm/scheduler/sched_main.c

917

spin_unlock(&sched->job_list_lock);

drivers/gpu/drm/scheduler/sched_main.c

92

atomic_read(&sched->credit_count),

drivers/gpu/drm/scheduler/sched_main.c

934

struct drm_gpu_scheduler *sched, *picked_sched = NULL;

drivers/gpu/drm/scheduler/sched_main.c

939

sched = sched_list[i];

drivers/gpu/drm/scheduler/sched_main.c

941

if (!sched->ready) {

drivers/gpu/drm/scheduler/sched_main.c

943

sched->name);

drivers/gpu/drm/scheduler/sched_main.c

947

num_score = atomic_read(sched->score);

drivers/gpu/drm/scheduler/sched_main.c

950

picked_sched = sched;

drivers/gpu/drm/scheduler/sched_main.c

965

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_main.c

969

while ((job = drm_sched_get_finished_job(sched))) {

drivers/gpu/drm/scheduler/sched_main.c

973

ewma_drm_sched_avgtime_add(&sched->avg_job_us,

drivers/gpu/drm/scheduler/sched_main.c

976

sched->ops->free_job(job);

drivers/gpu/drm/scheduler/sched_main.c

979

drm_sched_run_job_queue(sched);

drivers/gpu/drm/scheduler/sched_main.c

989

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_main.c

998

entity = drm_sched_select_entity(sched);

drivers/gpu/drm/scheduler/sched_rq.c

165

struct drm_gpu_scheduler *sched =

drivers/gpu/drm/scheduler/sched_rq.c

166

container_of(entity->rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_rq.c

180

sched_avg_us = ewma_drm_sched_avgtime_read(&sched->avg_job_us);

drivers/gpu/drm/scheduler/sched_rq.c

252

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/scheduler/sched_rq.c

266

sched = container_of(rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_rq.c

270

atomic_inc(sched->score);

drivers/gpu/drm/scheduler/sched_rq.c

281

return sched;

drivers/gpu/drm/scheduler/sched_rq.c

294

struct drm_gpu_scheduler *sched = container_of(rq, typeof(*sched), rq);

drivers/gpu/drm/scheduler/sched_rq.c

303

atomic_dec(sched->score);

drivers/gpu/drm/scheduler/sched_rq.c

357

drm_sched_select_entity(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/sched_rq.c

359

struct drm_sched_rq *rq = &sched->rq;

drivers/gpu/drm/scheduler/sched_rq.c

371

if (!drm_sched_can_queue(sched, entity)) {

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

145

return (const char *)job->base.sched->name;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

166

struct drm_mock_scheduler *sched =

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

167

drm_sched_to_mock_sched(sched_job->sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

172

&sched->lock,

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

173

sched->hw_timeline.context,

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

174

atomic_inc_return(&sched->hw_timeline.next_seqno));

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

178

spin_lock_irq(&sched->lock);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

182

if (!list_empty(&sched->job_list)) {

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

184

list_last_entry(&sched->job_list, typeof(*prev),

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

195

list_add_tail(&job->link, &sched->job_list);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

198

spin_unlock_irq(&sched->lock);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

217

struct drm_mock_scheduler *sched = drm_sched_to_mock_sched(sched_job->sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

226

spin_lock_irqsave(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

233

spin_unlock_irqrestore(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

25

struct drm_mock_scheduler *sched)

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

254

struct drm_mock_scheduler *sched = drm_sched_to_mock_sched(sched_job->sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

260

spin_lock_irqsave(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

266

spin_unlock_irqrestore(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

298

struct drm_mock_scheduler *sched;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

301

sched = kunit_kzalloc(test, sizeof(*sched), GFP_KERNEL);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

302

KUNIT_ASSERT_NOT_NULL(test, sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

304

ret = drm_sched_init(&sched->base, &args);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

307

sched->test = test;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

308

sched->hw_timeline.context = dma_fence_context_alloc(1);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

309

atomic_set(&sched->hw_timeline.next_seqno, 0);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

310

INIT_LIST_HEAD(&sched->job_list);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

311

spin_lock_init(&sched->lock);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

313

return sched;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

323

void drm_mock_sched_fini(struct drm_mock_scheduler *sched)

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

325

drm_sched_fini(&sched->base);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

34

drm_sched = &sched->base;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

342

unsigned int drm_mock_sched_advance(struct drm_mock_scheduler *sched,

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

350

spin_lock_irqsave(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

351

if (WARN_ON_ONCE(sched->hw_timeline.cur_seqno + num <

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

352

sched->hw_timeline.cur_seqno))

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

354

sched->hw_timeline.cur_seqno += num;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

355

list_for_each_entry_safe(job, next, &sched->job_list, link) {

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

356

if (sched->hw_timeline.cur_seqno < job->hw_fence.seqno)

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

363

spin_unlock_irqrestore(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

60

struct drm_mock_scheduler *sched =

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

61

drm_sched_to_mock_sched(job->base.sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

63

lockdep_assert_held(&sched->lock);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

76

struct drm_mock_scheduler *sched =

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

77

drm_sched_to_mock_sched(job->base.sched);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

83

spin_lock_irqsave(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

84

list_for_each_entry_safe(job, next, &sched->job_list, link) {

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

91

sched->hw_timeline.cur_seqno = job->hw_fence.seqno;

drivers/gpu/drm/scheduler/tests/mock_scheduler.c

94

spin_unlock_irqrestore(&sched->lock, flags);

drivers/gpu/drm/scheduler/tests/sched_tests.h

114

drm_sched_to_mock_sched(struct drm_gpu_scheduler *sched)

drivers/gpu/drm/scheduler/tests/sched_tests.h

116

return container_of(sched, struct drm_mock_scheduler, base);

drivers/gpu/drm/scheduler/tests/sched_tests.h

133

void drm_mock_sched_fini(struct drm_mock_scheduler *sched);

drivers/gpu/drm/scheduler/tests/sched_tests.h

134

unsigned int drm_mock_sched_advance(struct drm_mock_scheduler *sched,

drivers/gpu/drm/scheduler/tests/sched_tests.h

140

struct drm_mock_scheduler *sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

121

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

134

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

157

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

172

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

212

struct drm_mock_scheduler *sched;

drivers/gpu/drm/scheduler/tests/tests_basic.c

221

sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);

drivers/gpu/drm/scheduler/tests/tests_basic.c

223

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

233

drm_mock_sched_fini(sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

252

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

26

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

265

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

28

drm_mock_sched_fini(sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

292

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

306

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

323

i = drm_mock_sched_advance(sched, 1);

drivers/gpu/drm/scheduler/tests/tests_basic.c

348

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

364

entity[p] = drm_mock_sched_entity_new(test, p, sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

383

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

40

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_basic.c

400

entity[p] = drm_mock_sched_entity_new(test, p, sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

439

struct drm_mock_scheduler *sched[3];

drivers/gpu/drm/scheduler/tests/tests_basic.c

456

for (i = 0; i < ARRAY_SIZE(sched); i++)

drivers/gpu/drm/scheduler/tests/tests_basic.c

457

sched[i] = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);

drivers/gpu/drm/scheduler/tests/tests_basic.c

462

sched[i % ARRAY_SIZE(sched)]);

drivers/gpu/drm/scheduler/tests/tests_basic.c

478

cur_sched %= ARRAY_SIZE(sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

479

modify = &sched[cur_sched]->base;

drivers/gpu/drm/scheduler/tests/tests_basic.c

487

for (i = 0; i < ARRAY_SIZE(sched); i++)

drivers/gpu/drm/scheduler/tests/tests_basic.c

488

drm_mock_sched_fini(sched[i]);

drivers/gpu/drm/scheduler/tests/tests_basic.c

504

struct drm_mock_scheduler *sched;

drivers/gpu/drm/scheduler/tests/tests_basic.c

513

sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);

drivers/gpu/drm/scheduler/tests/tests_basic.c

514

sched->base.credit_limit = 1;

drivers/gpu/drm/scheduler/tests/tests_basic.c

518

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

53

sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

532

i = drm_mock_sched_advance(sched, 1);

drivers/gpu/drm/scheduler/tests/tests_basic.c

538

i = drm_mock_sched_advance(sched, 1);

drivers/gpu/drm/scheduler/tests/tests_basic.c

545

drm_mock_sched_fini(sched);

drivers/gpu/drm/scheduler/tests/tests_basic.c

64

i = drm_mock_sched_advance(sched, 1);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

105

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

123

KUNIT_ASSERT_EQ(test, sched->base.credit_limit, 1);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

128

sched);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

147

i = drm_mock_sched_advance(sched, 1); /* Release the queue */

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

18

struct drm_mock_scheduler *sched;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

20

sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

21

sched->base.credit_limit = 1;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

23

test->priv = sched;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

30

struct drm_mock_scheduler *sched;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

32

sched = drm_mock_sched_new(test, MAX_SCHEDULE_TIMEOUT);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

33

sched->base.credit_limit = 2;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

35

test->priv = sched;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

42

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

44

drm_mock_sched_fini(sched);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

49

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

543

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

557

sched);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

67

KUNIT_ASSERT_EQ(test, sched->base.credit_limit, 1);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

71

sched);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

755

struct drm_mock_scheduler *sched = test->priv;

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

779

sched);

drivers/gpu/drm/scheduler/tests/tests_scheduler.c

86

i = drm_mock_sched_advance(sched, 1); /* Release the queue */

drivers/gpu/drm/v3d/v3d_drv.c

139

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/v3d/v3d_drv.c

155

sched = &v3d->queue[i].sched;

drivers/gpu/drm/v3d/v3d_drv.c

157

DRM_SCHED_PRIORITY_NORMAL, &sched,

drivers/gpu/drm/v3d/v3d_drv.h

64

struct drm_gpu_scheduler sched;

drivers/gpu/drm/v3d/v3d_sched.c

707

drm_sched_stop(&v3d->queue[i].sched, sched_job);

drivers/gpu/drm/v3d/v3d_sched.c

719

drm_sched_resubmit_jobs(&v3d->queue[i].sched);

drivers/gpu/drm/v3d/v3d_sched.c

723

drm_sched_start(&v3d->queue[i].sched, 0);

drivers/gpu/drm/v3d/v3d_sched.c

846

return drm_sched_init(&v3d->queue[queue].sched, &args);

drivers/gpu/drm/v3d/v3d_sched.c

896

if (v3d->queue[q].sched.ready)

drivers/gpu/drm/v3d/v3d_sched.c

897

drm_sched_fini(&v3d->queue[q].sched);

drivers/gpu/drm/xe/xe_dep_scheduler.c

106

drm_sched_fini(&dep_scheduler->sched);

drivers/gpu/drm/xe/xe_dep_scheduler.c

123

drm_sched_fini(&dep_scheduler->sched);

drivers/gpu/drm/xe/xe_dep_scheduler.c

31

struct drm_gpu_scheduler sched;

drivers/gpu/drm/xe/xe_dep_scheduler.c

77

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/xe/xe_dep_scheduler.c

92

err = drm_sched_init(&dep_scheduler->sched, &args);

drivers/gpu/drm/xe/xe_dep_scheduler.c

96

sched = &dep_scheduler->sched;

drivers/gpu/drm/xe/xe_dep_scheduler.c

97

err = drm_sched_entity_init(&dep_scheduler->entity, 0, &sched, 1, NULL);

drivers/gpu/drm/xe/xe_execlist.c

328

struct drm_gpu_scheduler *sched;

drivers/gpu/drm/xe/xe_execlist.c

351

err = drm_sched_init(&exl->sched, &args);

drivers/gpu/drm/xe/xe_execlist.c

355

sched = &exl->sched;

drivers/gpu/drm/xe/xe_execlist.c

356

err = drm_sched_entity_init(&exl->entity, 0, &sched, 1, NULL);

drivers/gpu/drm/xe/xe_execlist.c

371

drm_sched_fini(&exl->sched);

drivers/gpu/drm/xe/xe_execlist.c

382

drm_sched_fini(&exl->sched);

drivers/gpu/drm/xe/xe_execlist_types.h

37

struct drm_gpu_scheduler sched;

drivers/gpu/drm/xe/xe_gpu_scheduler.c

10

if (!drm_sched_is_stopped(&sched->base))

drivers/gpu/drm/xe/xe_gpu_scheduler.c

100

drm_sched_wqueue_stop(&sched->base);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

101

cancel_work_sync(&sched->work_process_msg);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

104

void xe_sched_submission_resume_tdr(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

106

drm_sched_resume_timeout(&sched->base, sched->base.timeout);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

109

void xe_sched_add_msg(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.c

11

queue_work(sched->base.submit_wq, &sched->work_process_msg);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

112

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

113

xe_sched_add_msg_locked(sched, msg);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

114

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

117

void xe_sched_add_msg_locked(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.c

120

lockdep_assert_held(&sched->msg_lock);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

122

list_add_tail(&msg->link, &sched->msgs);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

123

xe_sched_process_msg_queue(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

131

void xe_sched_add_msg_head(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.c

134

lockdep_assert_held(&sched->msg_lock);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

136

list_add(&msg->link, &sched->msgs);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

137

xe_sched_process_msg_queue(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

14

static void xe_sched_process_msg_queue_if_ready(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

18

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

19

msg = list_first_entry_or_null(&sched->msgs, struct xe_sched_msg, link);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

21

xe_sched_process_msg_queue(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

22

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

26

xe_sched_get_msg(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

30

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

31

msg = list_first_entry_or_null(&sched->msgs,

drivers/gpu/drm/xe/xe_gpu_scheduler.c

35

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

42

struct xe_gpu_scheduler *sched =

drivers/gpu/drm/xe/xe_gpu_scheduler.c

46

if (drm_sched_is_stopped(&sched->base))

drivers/gpu/drm/xe/xe_gpu_scheduler.c

49

msg = xe_sched_get_msg(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

51

sched->ops->process_msg(msg);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

53

xe_sched_process_msg_queue_if_ready(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

57

int xe_sched_init(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.c

78

sched->ops = xe_ops;

drivers/gpu/drm/xe/xe_gpu_scheduler.c

79

spin_lock_init(&sched->msg_lock);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

8

static void xe_sched_process_msg_queue(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

80

INIT_LIST_HEAD(&sched->msgs);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

81

INIT_WORK(&sched->work_process_msg, xe_sched_process_msg_work);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

83

return drm_sched_init(&sched->base, &args);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

86

void xe_sched_fini(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

88

xe_sched_submission_stop(sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

89

drm_sched_fini(&sched->base);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

92

void xe_sched_submission_start(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.c

94

drm_sched_wqueue_start(&sched->base);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

95

queue_work(sched->base.submit_wq, &sched->work_process_msg);

drivers/gpu/drm/xe/xe_gpu_scheduler.c

98

void xe_sched_submission_stop(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

12

int xe_sched_init(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.h

20

void xe_sched_fini(struct xe_gpu_scheduler *sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

22

void xe_sched_submission_start(struct xe_gpu_scheduler *sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

23

void xe_sched_submission_stop(struct xe_gpu_scheduler *sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

25

void xe_sched_submission_resume_tdr(struct xe_gpu_scheduler *sched);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

27

void xe_sched_add_msg(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.h

29

void xe_sched_add_msg_locked(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.h

31

void xe_sched_add_msg_head(struct xe_gpu_scheduler *sched,

drivers/gpu/drm/xe/xe_gpu_scheduler.h

34

static inline void xe_sched_msg_lock(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

36

spin_lock(&sched->msg_lock);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

39

static inline void xe_sched_msg_unlock(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

41

spin_unlock(&sched->msg_lock);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

44

static inline void xe_sched_stop(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

46

drm_sched_stop(&sched->base, NULL);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

49

static inline void xe_sched_tdr_queue_imm(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

51

drm_sched_tdr_queue_imm(&sched->base);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

54

static inline void xe_sched_resubmit_jobs(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

59

drm_sched_for_each_pending_job(s_job, &sched->base, NULL) {

drivers/gpu/drm/xe/xe_gpu_scheduler.h

62

sched->base.ops->run_job(s_job);

drivers/gpu/drm/xe/xe_gpu_scheduler.h

79

struct xe_sched_job *xe_sched_first_pending_job(struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

83

drm_sched_for_each_pending_job(job, &sched->base, NULL)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

92

struct xe_gpu_scheduler *sched)

drivers/gpu/drm/xe/xe_gpu_scheduler.h

95

(struct drm_gpu_scheduler **)&sched,

drivers/gpu/drm/xe/xe_guc_exec_queue_types.h

27

struct xe_gpu_scheduler sched;

drivers/gpu/drm/xe/xe_guc_submit.c

1266

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

1269

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1271

xe_sched_tdr_queue_imm(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1432

xe_sched_tdr_queue_imm(&q->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1479

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

1505

xe_sched_submission_stop(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1597

xe_sched_tdr_queue_imm(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1639

drm_sched_for_each_pending_job(tmp_job, &sched->base, NULL)

drivers/gpu/drm/xe/xe_guc_submit.c

1646

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1668

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1689

xe_sched_fini(&ge->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1717

cancel_delayed_work_sync(&ge->sched.base.work_tdr);

drivers/gpu/drm/xe/xe_guc_submit.c

1934

struct xe_gpu_scheduler *sched;

drivers/gpu/drm/xe/xe_guc_submit.c

1977

submit_wq = primary->guc->sched.base.submit_wq;

drivers/gpu/drm/xe/xe_guc_submit.c

1980

err = xe_sched_init(&ge->sched, &drm_sched_ops, &xe_sched_ops,

drivers/gpu/drm/xe/xe_guc_submit.c

1987

sched = &ge->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

1988

err = xe_sched_entity_init(&ge->entity, sched);

drivers/gpu/drm/xe/xe_guc_submit.c

1996

xe_sched_stop(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2010

WRITE_ONCE(q->guc->sched.base.pause_submit, true);

drivers/gpu/drm/xe/xe_guc_submit.c

2023

xe_sched_fini(&ge->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2052

xe_sched_add_msg_head(&q->guc->sched, msg);

drivers/gpu/drm/xe/xe_guc_submit.c

2054

xe_sched_add_msg_locked(&q->guc->sched, msg);

drivers/gpu/drm/xe/xe_guc_submit.c

2056

xe_sched_add_msg(&q->guc->sched, msg);

drivers/gpu/drm/xe/xe_guc_submit.c

2180

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2186

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2189

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2239

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2245

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2247

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2291

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2295

xe_sched_submission_stop(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2319

struct xe_sched_job *job = xe_sched_first_pending_job(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2476

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2483

xe_sched_submission_stop(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2484

cancel_delayed_work_sync(&sched->base.work_tdr);

drivers/gpu/drm/xe/xe_guc_submit.c

2502

job = xe_sched_first_pending_job(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2526

xe_sched_submission_stop(&q->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2555

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2558

struct xe_sched_job *job = xe_sched_first_pending_job(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2577

xe_sched_resubmit_jobs(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2580

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2581

xe_sched_submission_resume_tdr(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2610

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2615

drm_sched_for_each_pending_job(s_job, &sched->base, NULL) {

drivers/gpu/drm/xe/xe_guc_submit.c

2656

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2669

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2671

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2684

xe_sched_msg_lock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2686

xe_sched_msg_unlock(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2694

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2699

xe_sched_resubmit_jobs(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2701

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2704

xe_sched_submission_resume_tdr(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2718

xe_sched_submission_start(&q->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

2740

!drm_sched_is_stopped(&q->guc->sched.base))

drivers/gpu/drm/xe/xe_guc_submit.c

2759

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

2765

xe_sched_submission_start(sched);

drivers/gpu/drm/xe/xe_guc_submit.c

3195

struct xe_gpu_scheduler *sched = &q->guc->sched;

drivers/gpu/drm/xe/xe_guc_submit.c

3210

snapshot->sched_timeout = sched->base.timeout;

drivers/gpu/drm/xe/xe_guc_submit.c

558

xe_sched_tdr_queue_imm(&q->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

590

xe_sched_submission_stop(&primary->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

592

xe_sched_submission_stop(&eq->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

618

xe_sched_submission_start(&primary->guc->sched);

drivers/gpu/drm/xe/xe_guc_submit.c

623

xe_sched_submission_start(&eq->guc->sched);

drivers/infiniband/hw/cxgb4/cm.c

145

static int sched(struct c4iw_dev *dev, struct sk_buff *skb);

drivers/infiniband/hw/cxgb4/cm.c

4398

sched(dev, skb);

drivers/infiniband/hw/cxgb4/cm.c

4432

sched(dev, skb);

drivers/infiniband/hw/cxgb4/cm.c

4441

[CPL_ACT_ESTABLISH] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4442

[CPL_ACT_OPEN_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4443

[CPL_RX_DATA] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4444

[CPL_ABORT_RPL_RSS] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4445

[CPL_ABORT_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4446

[CPL_PASS_OPEN_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4447

[CPL_CLOSE_LISTSRV_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4448

[CPL_PASS_ACCEPT_REQ] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4449

[CPL_PASS_ESTABLISH] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4450

[CPL_PEER_CLOSE] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4451

[CPL_CLOSE_CON_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4453

[CPL_RDMA_TERMINATE] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4454

[CPL_FW4_ACK] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4456

[CPL_GET_TCB_RPL] = sched,

drivers/infiniband/hw/cxgb4/cm.c

4458

[CPL_RX_PKT] = sched

drivers/infiniband/hw/cxgb4/cm.c

530

sched(ep->com.dev, skb);

drivers/input/joystick/sidewinder.c

120

int timeout, bitout, sched, i, kick, start, strobe;

drivers/input/joystick/sidewinder.c

130

sched = 0;

drivers/input/joystick/sidewinder.c

150

sched--;

drivers/input/joystick/sidewinder.c

163

sched = kick; /* Schedule second trigger */

drivers/input/joystick/sidewinder.c

168

if (pending && sched < 0 && (i > -SW_END)) { /* Second trigger time */

drivers/input/serio/hil_mlc.c

745

goto sched;

drivers/input/serio/hil_mlc.c

748

goto sched;

drivers/input/serio/hil_mlc.c

751

sched:

drivers/net/ethernet/chelsio/cxgb/sge.c

1308

struct sched *s = from_tasklet(s, t, sched_tsk);

drivers/net/ethernet/chelsio/cxgb/sge.c

264

struct sched *tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

277

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

293

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

338

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

353

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

366

struct sched *s;

drivers/net/ethernet/chelsio/cxgb/sge.c

369

s = kzalloc_obj(struct sched);

drivers/net/ethernet/chelsio/cxgb/sge.c

393

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb/sge.c

428

struct sched *s = sge->tx_sched;

drivers/net/ethernet/chelsio/cxgb3/common.h

731

int t3_config_sched(struct adapter *adap, unsigned int kbps, int sched);

drivers/net/ethernet/chelsio/cxgb3/cxgb3_ioctl.h

101

uint8_t sched;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

798

char *buf, int sched)

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

805

addr = A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

809

if (sched & 1)

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

824

const char *buf, size_t len, int sched)

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

841

ret = t3_config_sched(adap, val, sched);

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

848

#define TM_ATTR(name, sched) \

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

852

return tm_attr_show(d, buf, sched); \

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

857

return tm_attr_store(d, buf, len, sched); \

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

939

static int send_pktsched_cmd(struct adapter *adap, int sched, int qidx, int lo,

drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c

955

req->sched = sched;

drivers/net/ethernet/chelsio/cxgb3/t3_cpl.h

889

__u8 sched;

drivers/net/ethernet/chelsio/cxgb3/t3_hw.c

2972

int t3_config_sched(struct adapter *adap, unsigned int kbps, int sched)

drivers/net/ethernet/chelsio/cxgb3/t3_hw.c

2998

A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2);

drivers/net/ethernet/chelsio/cxgb3/t3_hw.c

3000

if (sched & 1)

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

2063

void t4_get_tx_sched(struct adapter *adap, unsigned int sched,

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10276

void t4_get_tx_sched(struct adapter *adap, unsigned int sched,

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10282

addr = TP_TX_MOD_Q1_Q0_RATE_LIMIT_A - sched / 2;

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10284

if (sched & 1)

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10296

addr = TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR_A - sched / 2;

drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

10298

if (sched & 1)

drivers/net/ethernet/intel/ice/ice_lag.c

1064

pvf_teid = le32_to_cpu(pv_ctx->sched.vsi_node[0]->info.node_teid);

drivers/net/ethernet/intel/ice/ice_lag.c

1068

svf_teid = le32_to_cpu(sv_ctx->sched.vsi_node[0]->info.node_teid);

drivers/net/ethernet/intel/ice/ice_lag.c

1108

q_node = ice_sched_find_node_by_teid(src_ctx->sched.vsi_node[0],

drivers/net/ethernet/intel/ice/ice_lag.c

1249

if (!ctx->sched.vsi_node[tc])

drivers/net/ethernet/intel/ice/ice_lag.c

1253

teid = ctx->sched.vsi_node[tc]->info.node_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

1255

parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

1305

ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]);

drivers/net/ethernet/intel/ice/ice_lag.c

2469

if (!ctx->sched.vsi_node[tc])

drivers/net/ethernet/intel/ice/ice_lag.c

2473

teid = ctx->sched.vsi_node[tc]->info.node_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

2475

parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

2523

ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]);

drivers/net/ethernet/intel/ice/ice_lag.c

651

if (!ctx->sched.vsi_node[tc])

drivers/net/ethernet/intel/ice/ice_lag.c

662

teid = ctx->sched.vsi_node[tc]->info.node_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

664

parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid;

drivers/net/ethernet/intel/ice/ice_lag.c

718

ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]);

drivers/net/ethernet/intel/ice/ice_sched.c

1540

vsi_node = vsi_ctx->sched.vsi_node[tc];

drivers/net/ethernet/intel/ice/ice_sched.c

1923

prev_numqs = vsi_ctx->sched.max_lanq[tc];

drivers/net/ethernet/intel/ice/ice_sched.c

1925

prev_numqs = vsi_ctx->sched.max_rdmaq[tc];

drivers/net/ethernet/intel/ice/ice_sched.c

1963

vsi_ctx->sched.max_lanq[tc] = new_numqs;

drivers/net/ethernet/intel/ice/ice_sched.c

1965

vsi_ctx->sched.max_rdmaq[tc] = new_numqs;

drivers/net/ethernet/intel/ice/ice_sched.c

2024

vsi_ctx->sched.vsi_node[tc] = vsi_node;

drivers/net/ethernet/intel/ice/ice_sched.c

2030

vsi_ctx->sched.max_lanq[tc] = 0;

drivers/net/ethernet/intel/ice/ice_sched.c

2031

vsi_ctx->sched.max_rdmaq[tc] = 0;

drivers/net/ethernet/intel/ice/ice_sched.c

2189

vsi_ctx->sched.vsi_node[i] = NULL;

drivers/net/ethernet/intel/ice/ice_sched.c

2192

vsi_ctx->sched.max_lanq[i] = 0;

drivers/net/ethernet/intel/ice/ice_sched.c

2194

vsi_ctx->sched.max_rdmaq[i] = 0;

drivers/net/ethernet/intel/ice/ice_sched.c

3172

ice_set_clear_cir_bw(&vsi_ctx->sched.bw_t_info[tc], bw);

drivers/net/ethernet/intel/ice/ice_sched.c

3175

ice_set_clear_eir_bw(&vsi_ctx->sched.bw_t_info[tc], bw);

drivers/net/ethernet/intel/ice/ice_sched.c

3178

ice_set_clear_shared_bw(&vsi_ctx->sched.bw_t_info[tc], bw);

drivers/net/ethernet/intel/ice/ice_sched.c

4035

node = vsi_ctx->sched.vsi_node[tc];

drivers/net/ethernet/intel/ice/ice_switch.h

45

struct ice_sched_vsi_info sched;

drivers/net/ethernet/intel/ice/virt/virtchnl.c

459

cfg->shaper.committed = vsi_ctx->sched.bw_t_info[i].cir_bw.bw;

drivers/net/ethernet/intel/ice/virt/virtchnl.c

460

cfg->shaper.peak = vsi_ctx->sched.bw_t_info[i].eir_bw.bw;

drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

3801

u8 sched = *(u8 *)(inbox->buf + 64);

drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

3804

port = (sched >> 6 & 1) + 1;

drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

688

u8 sched = *(u8 *)(inbox->buf + 64);

drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

694

port = (sched >> 6 & 1) + 1;

drivers/net/ethernet/microchip/sparx5/sparx5_calendar.c

262

static u32 sparx5_dsm_cp_cal(u32 *sched)

drivers/net/ethernet/microchip/sparx5/sparx5_calendar.c

267

if (sched[idx] != SPX5_DSM_CAL_EMPTY) {

drivers/net/ethernet/microchip/sparx5/sparx5_calendar.c

268

tmp = sched[idx];

drivers/net/ethernet/microchip/sparx5/sparx5_calendar.c

269

sched[idx] = SPX5_DSM_CAL_EMPTY;

drivers/net/wireless/ath/ath9k/ath9k.h

1009

struct ath_chanctx_sched sched;

drivers/net/wireless/ath/ath9k/channel.c

1043

struct ath_softc *sc = timer_container_of(sc, t, sched.timer);

drivers/net/wireless/ath/ath9k/channel.c

1163

switch (sc->sched.state) {

drivers/net/wireless/ath/ath9k/channel.c

1173

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;

drivers/net/wireless/ath/ath9k/channel.c

1282

if (!sc->sched.offchannel_pending)

drivers/net/wireless/ath/ath9k/channel.c

1283

sc->sched.offchannel_duration = 0;

drivers/net/wireless/ath/ath9k/channel.c

1285

if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)

drivers/net/wireless/ath/ath9k/channel.c

1286

sc->sched.state = ATH_CHANCTX_STATE_IDLE;

drivers/net/wireless/ath/ath9k/channel.c

1298

sc->sched.channel_switch_time =

drivers/net/wireless/ath/ath9k/channel.c

1359

timer_setup(&sc->sched.timer, ath_chanctx_timer, 0);

drivers/net/wireless/ath/ath9k/channel.c

1557

timer_delete_sync(&sc->sched.timer);

drivers/net/wireless/ath/ath9k/channel.c

256

if (likely(sc->sched.channel_switch_time))

drivers/net/wireless/ath/ath9k/channel.c

258

usecs_to_jiffies(sc->sched.channel_switch_time);

drivers/net/wireless/ath/ath9k/channel.c

306

ictx->flush_timeout = usecs_to_jiffies(sc->sched.channel_switch_time);

drivers/net/wireless/ath/ath9k/channel.c

377

mod_timer(&sc->sched.timer, jiffies + timeout);

drivers/net/wireless/ath/ath9k/channel.c

394

if (ctx->active && sc->sched.extend_absence) {

drivers/net/wireless/ath/ath9k/channel.c

396

sc->sched.extend_absence = false;

drivers/net/wireless/ath/ath9k/channel.c

403

if (ctx->active && sc->sched.beacon_miss >= 2) {

drivers/net/wireless/ath/ath9k/channel.c

405

sc->sched.extend_absence = true;

drivers/net/wireless/ath/ath9k/channel.c

418

avp->offchannel_duration = sc->sched.offchannel_duration;

drivers/net/wireless/ath/ath9k/channel.c

446

if (sc->sched.extend_absence)

drivers/net/wireless/ath/ath9k/channel.c

448

sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

452

sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

455

sc->sched.extend_absence)

drivers/net/wireless/ath/ath9k/channel.c

479

avp->noa_duration = duration + sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

508

chanctx_state_string(sc->sched.state),

drivers/net/wireless/ath/ath9k/channel.c

530

if (sc->sched.offchannel_pending && !sc->sched.wait_switch) {

drivers/net/wireless/ath/ath9k/channel.c

531

sc->sched.offchannel_pending = false;

drivers/net/wireless/ath/ath9k/channel.c

533

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;

drivers/net/wireless/ath/ath9k/channel.c

539

if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {

drivers/net/wireless/ath/ath9k/channel.c

541

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;

drivers/net/wireless/ath/ath9k/channel.c

547

if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER) {

drivers/net/wireless/ath/ath9k/channel.c

548

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;

drivers/net/wireless/ath/ath9k/channel.c

553

if (sc->sched.mgd_prepare_tx)

drivers/net/wireless/ath/ath9k/channel.c

554

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;

drivers/net/wireless/ath/ath9k/channel.c

563

sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON) {

drivers/net/wireless/ath/ath9k/channel.c

571

if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)

drivers/net/wireless/ath/ath9k/channel.c

576

sc->sched.beacon_pending = true;

drivers/net/wireless/ath/ath9k/channel.c

577

sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);

drivers/net/wireless/ath/ath9k/channel.c

583

tsf_time = sc->sched.next_tbtt + beacon_int / 4;

drivers/net/wireless/ath/ath9k/channel.c

584

sc->sched.switch_start_time = tsf_time;

drivers/net/wireless/ath/ath9k/channel.c

585

sc->cur_chan->last_beacon = sc->sched.next_tbtt;

drivers/net/wireless/ath/ath9k/channel.c

605

if (sc->sched.mgd_prepare_tx) {

drivers/net/wireless/ath/ath9k/channel.c

621

(!avp->noa_duration || sc->sched.force_noa_update))

drivers/net/wireless/ath/ath9k/channel.c

625

if (ctx->active && sc->sched.force_noa_update)

drivers/net/wireless/ath/ath9k/channel.c

626

sc->sched.force_noa_update = false;

drivers/net/wireless/ath/ath9k/channel.c

630

if (!sc->sched.beacon_pending) {

drivers/net/wireless/ath/ath9k/channel.c

636

sc->sched.beacon_pending = false;

drivers/net/wireless/ath/ath9k/channel.c

638

if (sc->sched.mgd_prepare_tx) {

drivers/net/wireless/ath/ath9k/channel.c

639

sc->sched.mgd_prepare_tx = false;

drivers/net/wireless/ath/ath9k/channel.c

646

if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)

drivers/net/wireless/ath/ath9k/channel.c

652

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;

drivers/net/wireless/ath/ath9k/channel.c

653

ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);

drivers/net/wireless/ath/ath9k/channel.c

656

if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)

drivers/net/wireless/ath/ath9k/channel.c

660

sc->sched.beacon_pending)

drivers/net/wireless/ath/ath9k/channel.c

661

sc->sched.beacon_miss++;

drivers/net/wireless/ath/ath9k/channel.c

666

sc->sched.state = ATH_CHANCTX_STATE_SWITCH;

drivers/net/wireless/ath/ath9k/channel.c

674

sc->sched.beacon_pending = false;

drivers/net/wireless/ath/ath9k/channel.c

675

sc->sched.beacon_miss = 0;

drivers/net/wireless/ath/ath9k/channel.c

677

if (sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||

drivers/net/wireless/ath/ath9k/channel.c

678

!sc->sched.beacon_adjust ||

drivers/net/wireless/ath/ath9k/channel.c

687

tsf_time = sc->sched.switch_start_time;

drivers/net/wireless/ath/ath9k/channel.c

692

sc->sched.beacon_adjust = false;

drivers/net/wireless/ath/ath9k/channel.c

696

if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||

drivers/net/wireless/ath/ath9k/channel.c

703

sc->sched.state = ATH_CHANCTX_STATE_IDLE;

drivers/net/wireless/ath/ath9k/channel.c

707

sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||

drivers/net/wireless/ath/ath9k/channel.c

721

sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;

drivers/net/wireless/ath/ath9k/channel.c

722

sc->sched.wait_switch = false;

drivers/net/wireless/ath/ath9k/channel.c

726

if (sc->sched.extend_absence) {

drivers/net/wireless/ath/ath9k/channel.c

727

sc->sched.beacon_miss = 0;

drivers/net/wireless/ath/ath9k/channel.c

731

tsf_time -= sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

733

sc->sched.switch_start_time = tsf_time;

drivers/net/wireless/ath/ath9k/channel.c

736

sc->sched.beacon_pending = true;

drivers/net/wireless/ath/ath9k/channel.c

737

sc->sched.beacon_adjust = true;

drivers/net/wireless/ath/ath9k/channel.c

751

sc->sched.state = ATH_CHANCTX_STATE_IDLE;

drivers/net/wireless/ath/ath9k/channel.c

756

sc->sched.state = ATH_CHANCTX_STATE_IDLE;

drivers/net/wireless/ath/ath9k/channel.c

775

if (sc->sched.beacon_pending)

drivers/net/wireless/ath/ath9k/channel.c

808

sc->sched.offchannel_pending = true;

drivers/net/wireless/ath/ath9k/channel.c

809

sc->sched.wait_switch = true;

drivers/net/wireless/ath/ath9k/channel.c

810

sc->sched.offchannel_duration =

drivers/net/wireless/ath/ath9k/channel.c

812

sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

828

sc->sched.offchannel_duration =

drivers/net/wireless/ath/ath9k/channel.c

830

sc->sched.channel_switch_time;

drivers/net/wireless/ath/ath9k/channel.c

836

sc->sched.offchannel_duration);

drivers/net/wireless/ath/ath9k/channel.c

922

sc->sched.offchannel_pending = false;

drivers/net/wireless/ath/ath9k/channel.c

923

sc->sched.wait_switch = false;

drivers/net/wireless/ath/ath9k/channel.c

978

sc->sched.force_noa_update = true;

drivers/net/wireless/ath/ath9k/main.c

2716

sc->sched.mgd_prepare_tx = true;

drivers/net/wireless/ath/ath9k/main.c

2732

sc->sched.mgd_prepare_tx = false;

drivers/net/wireless/ath/ath9k/main.c

2745

sc->sched.state = ATH_CHANCTX_STATE_FORCE_ACTIVE;

drivers/net/wireless/ath/ath9k/main.c

511

bool sched = false;

drivers/net/wireless/ath/ath9k/main.c

553

sched = true;

drivers/net/wireless/ath/ath9k/main.c

594

if (sched) {

drivers/net/wireless/intel/iwlwifi/mld/nan.c

920

struct ieee80211_nan_peer_sched *sched = sta->nan_sched;

drivers/net/wireless/intel/iwlwifi/mld/nan.c

926

.sequence_id = sched->seq_id,

drivers/net/wireless/intel/iwlwifi/mld/nan.c

927

.committed_dw_info = cpu_to_le16(sched->committed_dw),

drivers/net/wireless/intel/iwlwifi/mld/nan.c

928

.max_channel_switch_time = cpu_to_le16(sched->max_chan_switch),

drivers/net/wireless/intel/iwlwifi/mld/nan.c

929

.initial_ulw_size = cpu_to_le32(sched->ulw_size),

drivers/net/wireless/intel/iwlwifi/mld/nan.c

941

.data[1] = sched->init_ulw,

drivers/net/wireless/intel/iwlwifi/mld/nan.c

942

.len[1] = sched->ulw_size,

drivers/net/wireless/intel/iwlwifi/mld/nan.c

955

for (int i = 0; i < ARRAY_SIZE(sched->maps); i++) {

drivers/net/wireless/intel/iwlwifi/mld/nan.c

956

if (sched->maps[i].map_id == CFG80211_NAN_INVALID_MAP_ID)

drivers/net/wireless/intel/iwlwifi/mld/nan.c

959

BUILD_BUG_ON(ARRAY_SIZE(sched->maps[i].slots) != 32);

drivers/net/wireless/intel/iwlwifi/mld/nan.c

961

slot < ARRAY_SIZE(sched->maps[i].slots);

drivers/net/wireless/intel/iwlwifi/mld/nan.c

967

chan = sched->maps[i].slots[slot];

drivers/net/wireless/intel/iwlwifi/mld/nan.c

994

cmd.per_phy[phy->fw_id].map_id != sched->maps[i].map_id))

drivers/net/wireless/intel/iwlwifi/mld/nan.c

997

cmd.per_phy[phy->fw_id].map_id = sched->maps[i].map_id;

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

643

struct ieee80211_nan_peer_sched *sched;

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

653

sched = nmi->nan_sched;

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

689

for (int j = 0; j < (sched ? sched->n_channels : 0); j++) {

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

694

if (sched->channels[j].chanctx_conf != chan_ctx)

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

699

width = sched->channels[j].chanreq.oper.width;

drivers/net/wireless/intel/iwlwifi/mld/tlc.c

703

chains = sched->channels[j].needed_rx_chains;

drivers/net/wireless/mediatek/mt76/mt76.h

710

} sched;

drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

540

seq_printf(s, "pse_data_quota\t%d\n", sdio->sched.pse_data_quota);

drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

541

seq_printf(s, "ple_data_quota\t%d\n", sdio->sched.ple_data_quota);

drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

542

seq_printf(s, "pse_mcu_quota\t%d\n", sdio->sched.pse_mcu_quota);

drivers/net/wireless/mediatek/mt76/mt7615/debugfs.c

543

seq_printf(s, "sched_deficit\t%d\n", sdio->sched.deficit);

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c

24

sdio->sched.pse_data_quota = mt76_get_field(dev, MT_PSE_PG_HIF0_GROUP,

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c

26

sdio->sched.pse_mcu_quota = mt76_get_field(dev, MT_PSE_PG_HIF1_GROUP,

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c

28

sdio->sched.ple_data_quota = mt76_get_field(dev, MT_PLE_PG_HIF0_GROUP,

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c

30

sdio->sched.pse_page_size = MT_PSE_PAGE_SZ;

drivers/net/wireless/mediatek/mt76/mt7615/sdio_mcu.c

33

sdio->sched.deficit = txdwcnt << 2;

drivers/net/wireless/mediatek/mt76/mt7915/coredump.c

202

mt7915_memcpy_fromio(dev, dump->sched, base + 0xc + y * 12,

drivers/net/wireless/mediatek/mt76/mt7915/coredump.c

203

sizeof(dump->sched));

drivers/net/wireless/mediatek/mt76/mt7915/coredump.h

45

} sched[60];

drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c

1249

iter->sched ? 's' : 'u',

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2189

if (!iter || !iter->sched || iter->start_tsf > duration) {

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2201

if (!iter_next->sched ||

drivers/net/wireless/mediatek/mt76/mt7915/mac.c

2337

flow->sched = true;

drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h

132

u8 sched:1;

drivers/net/wireless/mediatek/mt76/mt7921/debugfs.c

256

seq_printf(s, "pse_data_quota\t%d\n", sdio->sched.pse_data_quota);

drivers/net/wireless/mediatek/mt76/mt7921/debugfs.c

257

seq_printf(s, "ple_data_quota\t%d\n", sdio->sched.ple_data_quota);

drivers/net/wireless/mediatek/mt76/mt7921/debugfs.c

258

seq_printf(s, "pse_mcu_quota\t%d\n", sdio->sched.pse_mcu_quota);

drivers/net/wireless/mediatek/mt76/mt7921/debugfs.c

259

seq_printf(s, "sched_deficit\t%d\n", sdio->sched.deficit);

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

513

sdio->sched.pse_data_quota = le32_to_cpu(tx_res->pse_data_quota);

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

516

sdio->sched.pse_mcu_quota =

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

517

sdio->sched.pse_mcu_quota ? sdio->pse_mcu_quota_max : sdio->pse_mcu_quota_max - 1;

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

518

sdio->sched.ple_data_quota = le32_to_cpu(tx_res->ple_data_quota);

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

519

sdio->sched.pse_page_size = le16_to_cpu(tx_res->pse_page_size);

drivers/net/wireless/mediatek/mt76/mt7921/mcu.c

520

sdio->sched.deficit = tx_res->pp_padding;

drivers/net/wireless/mediatek/mt76/mt7996/debugfs.c

830

iter->sched ? 's' : 'u',

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3049

if (!iter || !iter->sched || iter->start_tsf > duration) {

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3061

if (!iter_next->sched ||

drivers/net/wireless/mediatek/mt76/mt7996/mac.c

3198

flow->sched = true;

drivers/net/wireless/mediatek/mt76/mt7996/mt7996.h

238

u8 sched:1;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

193

pse_sz = DIV_ROUND_UP(buf_sz + sdio->sched.deficit,

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

194

sdio->sched.pse_page_size);

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

200

if (sdio->sched.pse_mcu_quota < *pse_size + pse_sz)

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

203

if (sdio->sched.pse_data_quota < *pse_size + pse_sz ||

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

204

sdio->sched.ple_data_quota < *ple_size + 1)

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

219

sdio->sched.pse_mcu_quota -= pse_size;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

221

sdio->sched.pse_data_quota -= pse_size;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

222

sdio->sched.ple_data_quota -= ple_size;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

48

sdio->sched.pse_mcu_quota += pse_mcu_quota;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

50

sdio->sched.pse_mcu_quota > sdio->pse_mcu_quota_max) {

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

51

sdio->sched.pse_mcu_quota = sdio->pse_mcu_quota_max;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

53

sdio->sched.pse_data_quota += pse_data_quota;

drivers/net/wireless/mediatek/mt76/sdio_txrx.c

54

sdio->sched.ple_data_quota += ple_data_quota;

drivers/net/wireless/virtual/mac80211_hwsim_nan.c

1305

struct ieee80211_nan_peer_sched *sched = sta->nan_sched;

drivers/net/wireless/virtual/mac80211_hwsim_nan.c

1317

if (!sched)

drivers/net/wireless/virtual/mac80211_hwsim_nan.c

1320

sp->nan_sched.committed_dw = sched->committed_dw;

drivers/net/wireless/virtual/mac80211_hwsim_nan.c

1323

struct ieee80211_nan_peer_map *map = &sched->maps[i];

drivers/slimbus/core.c

268

mutex_init(&ctrl->sched.m_reconf);

drivers/slimbus/core.c

269

init_completion(&ctrl->sched.pause_comp);

drivers/slimbus/core.c

490

if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {

drivers/slimbus/core.c

492

ctrl->sched.clk_state, ret);

drivers/slimbus/messaging.c

121

if (ctrl->sched.clk_state == SLIM_CLK_ENTERING_PAUSE &&

drivers/slimbus/messaging.c

129

if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {

drivers/slimbus/messaging.c

131

ctrl->sched.clk_state, ret);

drivers/slimbus/sched.c

112

sched->clk_state = SLIM_CLK_ACTIVE;

drivers/slimbus/sched.c

114

sched->clk_state = SLIM_CLK_PAUSED;

drivers/slimbus/sched.c

115

complete(&sched->pause_comp);

drivers/slimbus/sched.c

117

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

29

struct slim_sched *sched = &ctrl->sched;

drivers/slimbus/sched.c

38

mutex_lock(&sched->m_reconf);

drivers/slimbus/sched.c

40

if (sched->clk_state == SLIM_CLK_ACTIVE) {

drivers/slimbus/sched.c

41

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

49

ret = wait_for_completion_timeout(&sched->pause_comp,

drivers/slimbus/sched.c

52

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

63

if (sched->clk_state == SLIM_CLK_PAUSED && ctrl->wakeup)

drivers/slimbus/sched.c

66

sched->clk_state = SLIM_CLK_ACTIVE;

drivers/slimbus/sched.c

67

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

73

if (ctrl->sched.clk_state == SLIM_CLK_PAUSED) {

drivers/slimbus/sched.c

74

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

83

mutex_unlock(&sched->m_reconf);

drivers/slimbus/sched.c

89

sched->clk_state = SLIM_CLK_ENTERING_PAUSE;

drivers/slimbus/slimbus.h

413

struct slim_sched sched;

drivers/usb/fotg210/fotg210-hcd.c

4072

struct fotg210_iso_sched *sched;

drivers/usb/fotg210/fotg210-hcd.c

4075

sched = iso_sched_alloc(urb->number_of_packets, mem_flags);

drivers/usb/fotg210/fotg210-hcd.c

4076

if (unlikely(sched == NULL))

drivers/usb/fotg210/fotg210-hcd.c

4079

itd_sched_init(fotg210, sched, stream, urb);

drivers/usb/fotg210/fotg210-hcd.c

4082

num_itds = 1 + (sched->span + 7) / 8;

drivers/usb/fotg210/fotg210-hcd.c

4108

iso_sched_free(stream, sched);

drivers/usb/fotg210/fotg210-hcd.c

4116

list_add(&itd->itd_list, &sched->td_list);

drivers/usb/fotg210/fotg210-hcd.c

4121

urb->hcpriv = sched;

drivers/usb/fotg210/fotg210-hcd.c

4160

struct fotg210_iso_sched *sched = urb->hcpriv;

drivers/usb/fotg210/fotg210-hcd.c

4163

span = sched->span;

drivers/usb/host/ehci-sched.c

1243

struct ehci_iso_sched *sched;

drivers/usb/host/ehci-sched.c

1246

sched = iso_sched_alloc(urb->number_of_packets, mem_flags);

drivers/usb/host/ehci-sched.c

1247

if (unlikely(sched == NULL))

drivers/usb/host/ehci-sched.c

1250

itd_sched_init(ehci, sched, stream, urb);

drivers/usb/host/ehci-sched.c

1253

num_itds = 1 + (sched->span + 7) / 8;

drivers/usb/host/ehci-sched.c

1279

iso_sched_free(stream, sched);

drivers/usb/host/ehci-sched.c

1288

list_add(&itd->itd_list, &sched->td_list);

drivers/usb/host/ehci-sched.c

1293

urb->hcpriv = sched;

drivers/usb/host/ehci-sched.c

1387

struct ehci_iso_sched *sched,

drivers/usb/host/ehci-sched.c

1480

struct ehci_iso_sched *sched = urb->hcpriv;

drivers/usb/host/ehci-sched.c

1485

span = sched->span;

drivers/usb/host/ehci-sched.c

1523

sched, tt))

drivers/usb/host/ehci-sched.c

1624

iso_sched_free(stream, sched);

drivers/usb/host/ehci-sched.c

1625

sched = NULL;

drivers/usb/host/ehci-sched.c

1630

if (sched)

drivers/usb/host/ehci-sched.c

1631

sched->first_packet = urb->error_count;

drivers/usb/host/ehci-sched.c

2153

struct ehci_iso_sched *sched = urb->hcpriv;

drivers/usb/host/ehci-sched.c

2171

for (packet = sched->first_packet, sitd = NULL;

drivers/usb/host/ehci-sched.c

2176

BUG_ON(list_empty(&sched->td_list));

drivers/usb/host/ehci-sched.c

2180

sitd = list_entry(sched->td_list.next,

drivers/usb/host/ehci-sched.c

2186

sitd_patch(ehci, stream, sitd, sched, packet);

drivers/usb/host/ehci-sched.c

2195

iso_sched_free(stream, sched);

include/asm-generic/vmlinux.lds.h

617

*(.sched.text) \

include/drm/gpu_scheduler.h

307

struct drm_gpu_scheduler *sched;

include/drm/gpu_scheduler.h

356

struct drm_gpu_scheduler *sched;

include/drm/gpu_scheduler.h

634

int drm_sched_init(struct drm_gpu_scheduler *sched,

include/drm/gpu_scheduler.h

637

void drm_sched_fini(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

639

unsigned long drm_sched_suspend_timeout(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

640

void drm_sched_resume_timeout(struct drm_gpu_scheduler *sched,

include/drm/gpu_scheduler.h

642

void drm_sched_tdr_queue_imm(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

643

bool drm_sched_wqueue_ready(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

644

void drm_sched_wqueue_stop(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

645

void drm_sched_wqueue_start(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

646

void drm_sched_stop(struct drm_gpu_scheduler *sched, struct drm_sched_job *bad);

include/drm/gpu_scheduler.h

647

void drm_sched_start(struct drm_gpu_scheduler *sched, int errno);

include/drm/gpu_scheduler.h

648

void drm_sched_resubmit_jobs(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

649

void drm_sched_fault(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

650

bool drm_sched_is_stopped(struct drm_gpu_scheduler *sched);

include/drm/gpu_scheduler.h

711

struct drm_gpu_scheduler *sched;

include/drm/gpu_scheduler.h

716

__drm_sched_pending_job_iter_begin(struct drm_gpu_scheduler *sched)

include/drm/gpu_scheduler.h

719

.sched = sched,

include/drm/gpu_scheduler.h

722

WARN_ON(!drm_sched_is_stopped(sched));

include/drm/gpu_scheduler.h

730

WARN_ON(!drm_sched_is_stopped(iter.sched));

include/linux/sched/ext.h

186

struct scx_sched __rcu *sched;

include/linux/sched/ext.h

91

struct scx_sched *sched;

include/net/cfg80211.h

5566

struct cfg80211_nan_local_sched *sched);

include/net/cfg80211.h

5569

struct cfg80211_nan_peer_sched *sched);

include/net/sctp/stream_sched.h

45

enum sctp_sched_type sched);

include/net/sctp/stream_sched.h

57

void sctp_sched_ops_register(enum sctp_sched_type sched,

include/net/sctp/structs.h

1073

const struct sctp_sched_ops *sched;

include/trace/events/sched.h

3

#define TRACE_SYSTEM sched

include/trace/events/xdp.h

175

int sched, struct xdp_cpumap_stats *xdp_stats),

include/trace/events/xdp.h

177

TP_ARGS(map_id, processed, drops, sched, xdp_stats),

include/trace/events/xdp.h

185

__field(int, sched)

include/trace/events/xdp.h

197

__entry->sched = sched;

include/trace/events/xdp.h

211

__entry->sched,

kernel/bpf/cpumap.c

309

unsigned int kmem_alloc_drops = 0, sched = 0;

kernel/bpf/cpumap.c

322

sched = 1;

kernel/bpf/cpumap.c

329

sched = cond_resched();

kernel/bpf/cpumap.c

393

sched, &stats);

kernel/sched/ext/ext.c

320

rcu_assign_pointer(p->scx.sched, sch);

kernel/sched/ext/ext.c

4235

struct scx_sched *sch = dsq->sched;

kernel/sched/ext/ext.c

4674

dsq->sched = sch;

kernel/sched/ext/ext.c

7154

rq->scx.local_dsq.sched = sch;

kernel/sched/ext/ext.c

8852

sch = src_dsq->sched;

kernel/sched/ext/ext.c

9283

dsq->sched = sch;

kernel/sched/ext/internal.h

1680

return rcu_dereference_protected(p->scx.sched,

kernel/sched/ext/internal.h

1693

return rcu_dereference_all(p->scx.sched);

kernel/sched/ext/internal.h

1706

return rcu_access_pointer(p->scx.sched) == sch;

net/ipv6/ip6_flowlabel.c

147

unsigned long sched = 0;

net/ipv6/ip6_flowlabel.c

170

if (!sched || time_before(ttd, sched))

net/ipv6/ip6_flowlabel.c

171

sched = ttd;

net/ipv6/ip6_flowlabel.c

176

if (!sched && fl_size)

net/ipv6/ip6_flowlabel.c

177

sched = now + FL_MAX_LINGER;

net/ipv6/ip6_flowlabel.c

178

if (sched) {

net/ipv6/ip6_flowlabel.c

179

mod_timer(&ip6_fl_gc_timer, sched);

net/mac80211/cfg.c

5970

struct cfg80211_nan_local_sched *sched)

net/mac80211/cfg.c

5976

return ieee80211_nan_set_local_sched(sdata, sched);

net/mac80211/cfg.c

5982

struct cfg80211_nan_peer_sched *sched)

net/mac80211/cfg.c

5988

return ieee80211_nan_set_peer_sched(sdata, sched);

net/mac80211/ieee80211_i.h

2079

struct cfg80211_nan_local_sched *sched);

net/mac80211/ieee80211_i.h

2081

struct cfg80211_nan_peer_sched *sched);

net/mac80211/ieee80211_i.h

2082

void ieee80211_nan_free_peer_sched(struct ieee80211_nan_peer_sched *sched);

net/mac80211/nan.c

252

struct cfg80211_nan_local_sched *sched)

net/mac80211/nan.c

262

if (sched->n_channels > IEEE80211_NAN_MAX_CHANNELS)

net/mac80211/nan.c

265

if (sched->nan_avail_blob_len > IEEE80211_NAN_AVAIL_BLOB_MAX_LEN)

net/mac80211/nan.c

276

if (WARN_ON(sched_cfg->deferred && sched->n_channels))

net/mac80211/nan.c

289

memcpy(sched_cfg->avail_blob, sched->nan_avail_blob,

net/mac80211/nan.c

290

sched->nan_avail_blob_len);

net/mac80211/nan.c

291

sched_cfg->avail_blob_len = sched->nan_avail_blob_len;

net/mac80211/nan.c

305

for (int j = 0; j < sched->n_channels; j++) {

net/mac80211/nan.c

307

&sched->nan_channels[j].chandef)) {

net/mac80211/nan.c

317

if (!sched->deferred)

net/mac80211/nan.c

323

for (int i = 0; i < sched->n_channels; i++) {

net/mac80211/nan.c

328

&sched->nan_channels[i],

net/mac80211/nan.c

329

sched->deferred);

net/mac80211/nan.c

339

&sched->nan_channels[i]);

net/mac80211/nan.c

353

if (sched->schedule[s] < ARRAY_SIZE(sched_idx_to_chan))

net/mac80211/nan.c

355

sched_idx_to_chan[sched->schedule[s]];

net/mac80211/nan.c

360

sched_cfg->deferred = sched->deferred;

net/mac80211/nan.c

402

if (!chan->chanctx_conf || sched->deferred)

net/mac80211/nan.c

488

void ieee80211_nan_free_peer_sched(struct ieee80211_nan_peer_sched *sched)

net/mac80211/nan.c

490

if (!sched)

net/mac80211/nan.c

493

kfree(sched->init_ulw);

net/mac80211/nan.c

494

kfree(sched);

net/mac80211/nan.c

647

struct cfg80211_nan_peer_sched *sched)

net/mac80211/nan.c

658

sta = sta_info_get(sdata, sched->peer_addr);

net/mac80211/nan.c

662

new_sched = kzalloc(struct_size(new_sched, channels, sched->n_channels),

net/mac80211/nan.c

669

new_sched->seq_id = sched->seq_id;

net/mac80211/nan.c

670

new_sched->committed_dw = sched->committed_dw;

net/mac80211/nan.c

671

new_sched->max_chan_switch = sched->max_chan_switch;

net/mac80211/nan.c

672

new_sched->n_channels = sched->n_channels;

net/mac80211/nan.c

674

if (sched->ulw_size && sched->init_ulw) {

net/mac80211/nan.c

675

new_sched->init_ulw = kmemdup(sched->init_ulw, sched->ulw_size,

net/mac80211/nan.c

681

new_sched->ulw_size = sched->ulw_size;

net/mac80211/nan.c

684

for (int i = 0; i < sched->n_channels; i++) {

net/mac80211/nan.c

686

&sched->nan_channels[i],

net/mac80211/nan.c

692

for (int m = 0; m < ARRAY_SIZE(sched->maps); m++)

net/mac80211/nan.c

693

ieee80211_nan_init_peer_map(new_sched, &sched->maps[m],

net/mptcp/ctrl.c

123

struct mptcp_sched_ops *sched;

net/mptcp/ctrl.c

127

sched = mptcp_sched_find(name);

net/mptcp/ctrl.c

128

if (sched)

net/mptcp/protocol.c

3598

mptcp_init_sched(msk, mptcp_sk(sk)->sched);

net/mptcp/protocol.h

350

struct mptcp_sched_ops *sched;

net/mptcp/protocol.h

845

int mptcp_validate_scheduler(struct mptcp_sched_ops *sched);

net/mptcp/protocol.h

846

int mptcp_register_scheduler(struct mptcp_sched_ops *sched);

net/mptcp/protocol.h

847

void mptcp_unregister_scheduler(struct mptcp_sched_ops *sched);

net/mptcp/protocol.h

850

struct mptcp_sched_ops *sched);

net/mptcp/sched.c

104

if (mptcp_sched_find(sched->name)) {

net/mptcp/sched.c

108

list_add_tail_rcu(&sched->list, &mptcp_sched_list);

net/mptcp/sched.c

111

pr_debug("%s registered\n", sched->name);

net/mptcp/sched.c

115

void mptcp_unregister_scheduler(struct mptcp_sched_ops *sched)

net/mptcp/sched.c

117

if (sched == &mptcp_sched_default)

net/mptcp/sched.c

121

list_del_rcu(&sched->list);

net/mptcp/sched.c

131

struct mptcp_sched_ops *sched)

net/mptcp/sched.c

133

if (!sched)

net/mptcp/sched.c

134

sched = &mptcp_sched_default;

net/mptcp/sched.c

136

if (!bpf_try_module_get(sched, sched->owner))

net/mptcp/sched.c

139

msk->sched = sched;

net/mptcp/sched.c

140

if (msk->sched->init)

net/mptcp/sched.c

141

msk->sched->init(msk);

net/mptcp/sched.c

143

pr_debug("sched=%s\n", msk->sched->name);

net/mptcp/sched.c

150

struct mptcp_sched_ops *sched = msk->sched;

net/mptcp/sched.c

152

if (!sched)

net/mptcp/sched.c

155

msk->sched = NULL;

net/mptcp/sched.c

156

if (sched->release)

net/mptcp/sched.c

157

sched->release(msk);

net/mptcp/sched.c

159

bpf_module_put(sched, sched->owner);

net/mptcp/sched.c

190

if (msk->sched == &mptcp_sched_default || !msk->sched)

net/mptcp/sched.c

192

return msk->sched->get_send(msk);

net/mptcp/sched.c

210

if (msk->sched == &mptcp_sched_default || !msk->sched)

net/mptcp/sched.c

212

if (msk->sched->get_retrans)

net/mptcp/sched.c

213

return msk->sched->get_retrans(msk);

net/mptcp/sched.c

214

return msk->sched->get_send(msk);

net/mptcp/sched.c

53

struct mptcp_sched_ops *sched, *ret = NULL;

net/mptcp/sched.c

55

list_for_each_entry_rcu(sched, &mptcp_sched_list, list) {

net/mptcp/sched.c

56

if (!strcmp(sched->name, name)) {

net/mptcp/sched.c

57

ret = sched;

net/mptcp/sched.c

70

struct mptcp_sched_ops *sched;

net/mptcp/sched.c

74

list_for_each_entry_rcu(sched, &mptcp_sched_list, list) {

net/mptcp/sched.c

77

offs == 0 ? "" : " ", sched->name);

net/mptcp/sched.c

85

int mptcp_validate_scheduler(struct mptcp_sched_ops *sched)

net/mptcp/sched.c

87

if (!sched->get_send) {

net/mptcp/sched.c

88

pr_err("%s does not implement required ops\n", sched->name);

net/mptcp/sched.c

95

int mptcp_register_scheduler(struct mptcp_sched_ops *sched)

net/mptcp/sched.c

99

ret = mptcp_validate_scheduler(sched);

net/netfilter/ipvs/ip_vs_core.c

520

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_core.c

527

sched = rcu_dereference(svc->scheduler);

net/netfilter/ipvs/ip_vs_core.c

528

if (sched) {

net/netfilter/ipvs/ip_vs_core.c

531

dest = sched->schedule(svc, skb, iph);

net/netfilter/ipvs/ip_vs_core.c

625

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_core.c

702

sched = rcu_dereference(svc->scheduler);

net/netfilter/ipvs/ip_vs_core.c

703

if (sched) {

net/netfilter/ipvs/ip_vs_core.c

706

dest = sched->schedule(svc, skb, iph);

net/netfilter/ipvs/ip_vs_ctl.c

1316

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_ctl.c

1383

sched = rcu_dereference_protected(svc->scheduler, 1);

net/netfilter/ipvs/ip_vs_ctl.c

1384

if (sched && sched->add_dest)

net/netfilter/ipvs/ip_vs_ctl.c

1385

sched->add_dest(svc, dest);

net/netfilter/ipvs/ip_vs_ctl.c

1391

sched = rcu_dereference_protected(svc->scheduler, 1);

net/netfilter/ipvs/ip_vs_ctl.c

1392

if (sched && sched->upd_dest)

net/netfilter/ipvs/ip_vs_ctl.c

1393

sched->upd_dest(svc, dest);

net/netfilter/ipvs/ip_vs_ctl.c

1632

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_ctl.c

1634

sched = rcu_dereference_protected(svc->scheduler, 1);

net/netfilter/ipvs/ip_vs_ctl.c

1635

if (sched && sched->del_dest)

net/netfilter/ipvs/ip_vs_ctl.c

1636

sched->del_dest(svc, dest);

net/netfilter/ipvs/ip_vs_ctl.c

1712

struct ip_vs_scheduler *sched = NULL;

net/netfilter/ipvs/ip_vs_ctl.c

1728

sched = ip_vs_scheduler_get(u->sched_name);

net/netfilter/ipvs/ip_vs_ctl.c

1729

if (!sched) {

net/netfilter/ipvs/ip_vs_ctl.c

1828

if (sched) {

net/netfilter/ipvs/ip_vs_ctl.c

1829

ret = ip_vs_bind_scheduler(svc, sched);

net/netfilter/ipvs/ip_vs_ctl.c

1904

ip_vs_scheduler_put(sched);

net/netfilter/ipvs/ip_vs_ctl.c

1920

struct ip_vs_scheduler *sched = NULL, *old_sched;

net/netfilter/ipvs/ip_vs_ctl.c

1931

sched = ip_vs_scheduler_get(u->sched_name);

net/netfilter/ipvs/ip_vs_ctl.c

1932

if (!sched) {

net/netfilter/ipvs/ip_vs_ctl.c

1938

old_sched = sched;

net/netfilter/ipvs/ip_vs_ctl.c

1963

if (sched != old_sched) {

net/netfilter/ipvs/ip_vs_ctl.c

1970

if (sched) {

net/netfilter/ipvs/ip_vs_ctl.c

1971

ret = ip_vs_bind_scheduler(svc, sched);

net/netfilter/ipvs/ip_vs_ctl.c

1973

ip_vs_scheduler_put(sched);

net/netfilter/ipvs/ip_vs_ctl.c

2991

struct ip_vs_scheduler *sched = rcu_dereference(svc->scheduler);

net/netfilter/ipvs/ip_vs_ctl.c

2992

char *sched_name = sched ? sched->name : "none";

net/netfilter/ipvs/ip_vs_ctl.c

3576

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_ctl.c

3580

sched = rcu_dereference_protected(src->scheduler, 1);

net/netfilter/ipvs/ip_vs_ctl.c

3581

sched_name = sched ? sched->name : "none";

net/netfilter/ipvs/ip_vs_ctl.c

4052

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_ctl.c

4076

sched = rcu_dereference(svc->scheduler);

net/netfilter/ipvs/ip_vs_ctl.c

4077

sched_name = sched ? sched->name : "none";

net/netfilter/ipvs/ip_vs_sched.c

101

module_put(sched->module);

net/netfilter/ipvs/ip_vs_sched.c

114

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_sched.c

119

sched = ip_vs_sched_getbyname(sched_name);

net/netfilter/ipvs/ip_vs_sched.c

124

if (sched == NULL) {

net/netfilter/ipvs/ip_vs_sched.c

126

sched = ip_vs_sched_getbyname(sched_name);

net/netfilter/ipvs/ip_vs_sched.c

129

return sched;

net/netfilter/ipvs/ip_vs_sched.c

144

struct ip_vs_scheduler *sched = rcu_dereference(svc->scheduler);

net/netfilter/ipvs/ip_vs_sched.c

145

char *sched_name = sched ? sched->name : "none";

net/netfilter/ipvs/ip_vs_sched.c

168

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_sched.c

198

list_for_each_entry(sched, &ip_vs_schedulers, n_list) {

net/netfilter/ipvs/ip_vs_sched.c

199

if (strcmp(scheduler->name, sched->name) == 0) {

net/netfilter/ipvs/ip_vs_sched.c

61

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_sched.c

63

sched = rcu_dereference_protected(svc->scheduler, 1);

net/netfilter/ipvs/ip_vs_sched.c

64

if (!sched)

net/netfilter/ipvs/ip_vs_sched.c

70

if (sched->done_service)

net/netfilter/ipvs/ip_vs_sched.c

71

sched->done_service(svc);

net/netfilter/ipvs/ip_vs_sched.c

80

struct ip_vs_scheduler *sched;

net/netfilter/ipvs/ip_vs_sched.c

86

list_for_each_entry(sched, &ip_vs_schedulers, n_list) {

net/netfilter/ipvs/ip_vs_sched.c

90

if (sched->module && !try_module_get(sched->module)) {

net/netfilter/ipvs/ip_vs_sched.c

96

if (strcmp(sched_name, sched->name)==0) {

net/netfilter/ipvs/ip_vs_sched.c

99

return sched;

net/rxrpc/ar-internal.h

21

__be32 sched[FCRYPT_ROUNDS];

net/rxrpc/fcrypt.c

210

#define F_ENCRYPT(R, L, sched) \

net/rxrpc/fcrypt.c

216

u.l = sched ^ R; \

net/rxrpc/fcrypt.c

227

F_ENCRYPT(X.r, X.l, key->sched[0x0]);

net/rxrpc/fcrypt.c

228

F_ENCRYPT(X.l, X.r, key->sched[0x1]);

net/rxrpc/fcrypt.c

229

F_ENCRYPT(X.r, X.l, key->sched[0x2]);

net/rxrpc/fcrypt.c

230

F_ENCRYPT(X.l, X.r, key->sched[0x3]);

net/rxrpc/fcrypt.c

231

F_ENCRYPT(X.r, X.l, key->sched[0x4]);

net/rxrpc/fcrypt.c

232

F_ENCRYPT(X.l, X.r, key->sched[0x5]);

net/rxrpc/fcrypt.c

233

F_ENCRYPT(X.r, X.l, key->sched[0x6]);

net/rxrpc/fcrypt.c

234

F_ENCRYPT(X.l, X.r, key->sched[0x7]);

net/rxrpc/fcrypt.c

235

F_ENCRYPT(X.r, X.l, key->sched[0x8]);

net/rxrpc/fcrypt.c

236

F_ENCRYPT(X.l, X.r, key->sched[0x9]);

net/rxrpc/fcrypt.c

237

F_ENCRYPT(X.r, X.l, key->sched[0xa]);

net/rxrpc/fcrypt.c

238

F_ENCRYPT(X.l, X.r, key->sched[0xb]);

net/rxrpc/fcrypt.c

239

F_ENCRYPT(X.r, X.l, key->sched[0xc]);

net/rxrpc/fcrypt.c

240

F_ENCRYPT(X.l, X.r, key->sched[0xd]);

net/rxrpc/fcrypt.c

241

F_ENCRYPT(X.r, X.l, key->sched[0xe]);

net/rxrpc/fcrypt.c

242

F_ENCRYPT(X.l, X.r, key->sched[0xf]);

net/rxrpc/fcrypt.c

252

F_ENCRYPT(X.l, X.r, key->sched[0xf]);

net/rxrpc/fcrypt.c

253

F_ENCRYPT(X.r, X.l, key->sched[0xe]);

net/rxrpc/fcrypt.c

254

F_ENCRYPT(X.l, X.r, key->sched[0xd]);

net/rxrpc/fcrypt.c

255

F_ENCRYPT(X.r, X.l, key->sched[0xc]);

net/rxrpc/fcrypt.c

256

F_ENCRYPT(X.l, X.r, key->sched[0xb]);

net/rxrpc/fcrypt.c

257

F_ENCRYPT(X.r, X.l, key->sched[0xa]);

net/rxrpc/fcrypt.c

258

F_ENCRYPT(X.l, X.r, key->sched[0x9]);

net/rxrpc/fcrypt.c

259

F_ENCRYPT(X.r, X.l, key->sched[0x8]);

net/rxrpc/fcrypt.c

260

F_ENCRYPT(X.l, X.r, key->sched[0x7]);

net/rxrpc/fcrypt.c

261

F_ENCRYPT(X.r, X.l, key->sched[0x6]);

net/rxrpc/fcrypt.c

262

F_ENCRYPT(X.l, X.r, key->sched[0x5]);

net/rxrpc/fcrypt.c

263

F_ENCRYPT(X.r, X.l, key->sched[0x4]);

net/rxrpc/fcrypt.c

264

F_ENCRYPT(X.l, X.r, key->sched[0x3]);

net/rxrpc/fcrypt.c

265

F_ENCRYPT(X.r, X.l, key->sched[0x2]);

net/rxrpc/fcrypt.c

266

F_ENCRYPT(X.l, X.r, key->sched[0x1]);

net/rxrpc/fcrypt.c

267

F_ENCRYPT(X.r, X.l, key->sched[0x0]);

net/rxrpc/fcrypt.c

288

key->sched[i] = cpu_to_be32(k);

net/sched/act_gate.c

263

struct tcf_gate_params *sched,

net/sched/act_gate.c

293

list_add_tail(&entry->list, &sched->entries);

net/sched/act_gate.c

297

sched->num_entries = i;

net/sched/act_gate.c

302

release_entry_list(&sched->entries);

net/sched/sch_hfsc.c

1058

cl->sched = q;

net/sched/sch_hfsc.c

121

struct hfsc_sched *sched; /* scheduler data */

net/sched/sch_hfsc.c

1419

q->root.sched = q;

net/sched/sch_hfsc.c

192

struct rb_node **p = &cl->sched->eligible.rb_node;

net/sched/sch_hfsc.c

205

rb_insert_color(&cl->el_node, &cl->sched->eligible);

net/sched/sch_hfsc.c

212

rb_erase(&cl->el_node, &cl->sched->eligible);

net/sched/sch_taprio.c

1089

struct sched_gate_list *sched,

net/sched/sch_taprio.c

1119

list_add_tail(&entry->list, &sched->entries);

net/sched/sch_taprio.c

1123

sched->num_entries = i;

net/sched/sch_taprio.c

120

struct sched_gate_list *sched)

net/sched/sch_taprio.c

1208

struct sched_gate_list *sched,

net/sched/sch_taprio.c

1215

base = sched_base_time(sched);

net/sched/sch_taprio.c

1223

cycle = sched->cycle_time;

net/sched/sch_taprio.c

1242

struct sched_gate_list *sched, ktime_t base)

net/sched/sch_taprio.c

1250

first = list_first_entry(&sched->entries,

net/sched/sch_taprio.c

1253

cycle = sched->cycle_time;

net/sched/sch_taprio.c

1256

sched->cycle_end_time = ktime_add_ns(base, cycle);

net/sched/sch_taprio.c

1259

taprio_set_budgets(q, sched, first);

net/sched/sch_taprio.c

1262

if (first->gate_duration[tc] == sched->cycle_time)

net/sched/sch_taprio.c

127

list_for_each_entry(entry, &sched->entries, list) {

net/sched/sch_taprio.c

1365

struct sched_gate_list *sched, ktime_t base)

net/sched/sch_taprio.c

1370

list_for_each_entry(entry, &sched->entries, list) {

net/sched/sch_taprio.c

1459

struct sched_gate_list *sched,

net/sched/sch_taprio.c

1466

offload->base_time = sched->base_time;

net/sched/sch_taprio.c

1467

offload->cycle_time = sched->cycle_time;

net/sched/sch_taprio.c

1468

offload->cycle_time_extension = sched->cycle_time_extension;

net/sched/sch_taprio.c

1470

list_for_each_entry(entry, &sched->entries, list) {

net/sched/sch_taprio.c

150

cur = list_next_entry_circular(cur, &sched->entries, list);

net/sched/sch_taprio.c

1517

struct sched_gate_list *sched,

net/sched/sch_taprio.c

1544

offload = taprio_offload_alloc(sched->num_entries);

net/sched/sch_taprio.c

1554

taprio_sched_to_offload(dev, sched, offload, &caps);

net/sched/sch_taprio.c

159

sched->max_open_gate_duration[tc] < entry->gate_duration[tc])

net/sched/sch_taprio.c

160

sched->max_open_gate_duration[tc] = entry->gate_duration[tc];

net/sched/sch_taprio.c

170

static ktime_t sched_base_time(const struct sched_gate_list *sched)

net/sched/sch_taprio.c

172

if (!sched)

net/sched/sch_taprio.c

175

return ns_to_ktime(sched->base_time);

net/sched/sch_taprio.c

198

struct sched_gate_list *sched = container_of(head, struct sched_gate_list, rcu);

net/sched/sch_taprio.c

201

list_for_each_entry_safe(entry, n, &sched->entries, list) {

net/sched/sch_taprio.c

206

kfree(sched);

net/sched/sch_taprio.c

224

static s32 get_cycle_time_elapsed(struct sched_gate_list *sched, ktime_t time)

net/sched/sch_taprio.c

229

time_since_sched_start = ktime_sub(time, sched->base_time);

net/sched/sch_taprio.c

2290

const struct sched_gate_list *sched)

net/sched/sch_taprio.c

230

div_s64_rem(time_since_sched_start, sched->cycle_time, &time_elapsed);

net/sched/sch_taprio.c

2304

READ_ONCE(sched->max_sdu[tc])))

net/sched/sch_taprio.c

235

static ktime_t get_interval_end_time(struct sched_gate_list *sched,

net/sched/sch_taprio.c

240

s32 cycle_elapsed = get_cycle_time_elapsed(sched, intv_start);

net/sched/sch_taprio.c

243

cycle_end = ktime_add_ns(intv_start, sched->cycle_time - cycle_elapsed);

net/sched/sch_taprio.c

245

cycle_ext_end = ktime_add(cycle_end, sched->cycle_time_extension);

net/sched/sch_taprio.c

249

else if (admin && admin != sched &&

net/sched/sch_taprio.c

272

struct sched_gate_list *sched,

net/sched/sch_taprio.c

288

if (sched->max_open_gate_duration[tc] == sched->cycle_time) {

net/sched/sch_taprio.c

293

max_frm_len = duration_to_length(q, sched->max_open_gate_duration[tc]);

net/sched/sch_taprio.c

310

sched->max_frm_len[tc] = max_sdu + dev->hard_header_len;

net/sched/sch_taprio.c

311

WRITE_ONCE(sched->max_sdu[tc], max_sdu);

net/sched/sch_taprio.c

313

sched->max_frm_len[tc] = U32_MAX; /* never oversized */

net/sched/sch_taprio.c

314

WRITE_ONCE(sched->max_sdu[tc], 0);

net/sched/sch_taprio.c

325

struct sched_gate_list *sched,

net/sched/sch_taprio.c

347

if (!sched)

net/sched/sch_taprio.c

350

cycle = sched->cycle_time;

net/sched/sch_taprio.c

351

cycle_elapsed = get_cycle_time_elapsed(sched, time);

net/sched/sch_taprio.c

355

list_for_each_entry(entry, &sched->entries, list) {

net/sched/sch_taprio.c

357

curr_intv_end = get_interval_end_time(sched, admin, entry,

net/sched/sch_taprio.c

403

struct sched_gate_list *sched, *admin;

net/sched/sch_taprio.c

408

sched = rcu_dereference(q->oper_sched);

net/sched/sch_taprio.c

411

entry = find_entry_to_transmit(skb, sch, sched, admin, skb->tstamp,

net/sched/sch_taprio.c

472

struct sched_gate_list *sched, *admin;

net/sched/sch_taprio.c

486

sched = rcu_dereference(q->oper_sched);

net/sched/sch_taprio.c

488

switch_schedules(q, &admin, &sched);

net/sched/sch_taprio.c

491

if (!sched || ktime_before(minimum_time, sched->base_time)) {

net/sched/sch_taprio.c

502

entry = find_entry_to_transmit(skb, sch, sched, admin,

net/sched/sch_taprio.c

515

if (admin && admin != sched &&

net/sched/sch_taprio.c

517

sched = admin;

net/sched/sch_taprio.c

529

entry->next_txtime = ktime_add(interval_start, sched->cycle_time);

net/sched/sch_taprio.c

545

struct sched_gate_list *sched;

net/sched/sch_taprio.c

553

sched = rcu_dereference(q->oper_sched);

net/sched/sch_taprio.c

554

if (sched && skb->len > sched->max_frm_len[tc])

net/sched/sch_taprio.c

663

struct sched_gate_list *sched,

net/sched/sch_taprio.c

672

if (entry->gate_duration[tc] == sched->cycle_time)

net/sctp/outqueue.c

389

q->sched->unsched_all(&asoc->stream);

net/sctp/outqueue.c

417

q->sched->sched_all(&asoc->stream);

net/sctp/outqueue.c

76

return q->sched->dequeue(q);

net/sctp/sm_sideeffect.c

1121

asoc->outqueue.sched->enqueue(&asoc->outqueue, msg);

net/sctp/stream.c

1045

const struct sctp_sched_ops *sched;

net/sctp/stream.c

1056

sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream.c

1057

sched->unsched_all(stream);

net/sctp/stream.c

1059

sched->sched_all(stream);

net/sctp/stream.c

133

const struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream.c

145

sched->unsched_all(stream);

net/sctp/stream.c

147

sched->sched_all(stream);

net/sctp/stream.c

185

const struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream.c

188

sched->unsched_all(stream);

net/sctp/stream.c

210

const struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream.c

212

sched->unsched_all(stream);

net/sctp/stream.c

221

sched->sched_all(stream);

net/sctp/stream.c

57

const struct sctp_sched_ops *sched;

net/sctp/stream.c

62

sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream.c

63

sched->free_sid(stream, sid);

net/sctp/stream_sched.c

116

void sctp_sched_ops_register(enum sctp_sched_type sched,

net/sctp/stream_sched.c

119

sctp_sched_ops[sched] = sched_ops;

net/sctp/stream_sched.c

133

const struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream_sched.c

137

sched->unsched_all(stream);

net/sctp/stream_sched.c

142

sched->free_sid(stream, i);

net/sctp/stream_sched.c

149

enum sctp_sched_type sched)

net/sctp/stream_sched.c

151

const struct sctp_sched_ops *old = asoc->outqueue.sched;

net/sctp/stream_sched.c

157

if (sched > SCTP_SS_MAX)

net/sctp/stream_sched.c

160

n = sctp_sched_ops[sched];

net/sctp/stream_sched.c

167

asoc->outqueue.sched = n;

net/sctp/stream_sched.c

190

asoc->outqueue.sched = &sctp_sched_fcfs; /* Always safe */

net/sctp/stream_sched.c

200

if (asoc->outqueue.sched == sctp_sched_ops[i])

net/sctp/stream_sched.c

220

return asoc->outqueue.sched->set(&asoc->stream, sid, value, gfp);

net/sctp/stream_sched.c

232

return asoc->outqueue.sched->get(&asoc->stream, sid, value);

net/sctp/stream_sched.c

253

q->sched->dequeue_done(q, ch);

net/sctp/stream_sched.c

266

const struct sctp_sched_ops *sched = sctp_sched_ops_from_stream(stream);

net/sctp/stream_sched.c

270

return sched->init_sid(stream, sid, gfp);

net/sctp/stream_sched.c

279

return asoc->outqueue.sched;

net/unix/af_unix.c

1609

int sched;

net/unix/af_unix.c

1614

sched = !sock_flag(other, SOCK_DEAD) &&

net/unix/af_unix.c

1620

if (sched)

net/wireless/core.c

286

struct cfg80211_nan_local_sched *sched)

net/wireless/core.c

298

ret = rdev_nan_set_local_sched(rdev, wdev, sched);

net/wireless/core.c

302

wdev->u.nan.sched_update_pending = sched->deferred;

net/wireless/core.c

308

if (!sched->n_channels)

net/wireless/core.c

311

wdev->u.nan.chandefs = kcalloc(sched->n_channels,

net/wireless/core.c

317

for (int i = 0; i < sched->n_channels; i++)

net/wireless/core.c

318

wdev->u.nan.chandefs[i] = sched->nan_channels[i].chandef;

net/wireless/core.c

320

wdev->u.nan.n_channels = sched->n_channels;

net/wireless/core.h

565

struct cfg80211_nan_local_sched *sched);

net/wireless/nl80211.c

17338

struct cfg80211_nan_peer_sched sched = {};

net/wireless/nl80211.c

17413

sched.n_channels = n_channels;

net/wireless/nl80211.c

17414

sched.nan_channels = nan_channels;

net/wireless/nl80211.c

17415

sched.peer_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);

net/wireless/nl80211.c

17416

sched.seq_id = nla_get_u8_default(info->attrs[NL80211_ATTR_NAN_SEQ_ID], 0);

net/wireless/nl80211.c

17417

sched.committed_dw = nla_get_u16(info->attrs[NL80211_ATTR_NAN_COMMITTED_DW]);

net/wireless/nl80211.c

17418

sched.max_chan_switch =

net/wireless/nl80211.c

17422

sched.ulw_size = nla_len(info->attrs[NL80211_ATTR_NAN_ULW]);

net/wireless/nl80211.c

17423

sched.init_ulw = nla_data(info->attrs[NL80211_ATTR_NAN_ULW]);

net/wireless/nl80211.c

17427

for (int j = 0; j < ARRAY_SIZE(sched.maps); j++)

net/wireless/nl80211.c

17428

sched.maps[j].map_id = CFG80211_NAN_INVALID_MAP_ID;

net/wireless/nl80211.c

17434

if (n_maps >= ARRAY_SIZE(sched.maps)) {

net/wireless/nl80211.c

17440

&sched.maps[n_maps],

net/wireless/nl80211.c

17448

&sched.maps[j],

net/wireless/nl80211.c

17449

&sched.maps[n_maps],

net/wireless/nl80211.c

17464

for (int s = 0; s < ARRAY_SIZE(sched.maps[m].schedule); s++) {

net/wireless/nl80211.c

17465

if (sched.maps[m].schedule[s] == ch) {

net/wireless/nl80211.c

17479

return rdev_nan_set_peer_sched(rdev, wdev, &sched);

net/wireless/nl80211.c

17482

static bool nl80211_nan_is_sched_empty(struct cfg80211_nan_local_sched *sched)

net/wireless/nl80211.c

17484

if (!sched->n_channels)

net/wireless/nl80211.c

17487

for (int i = 0; i < ARRAY_SIZE(sched->schedule); i++) {

net/wireless/nl80211.c

17488

if (sched->schedule[i] != NL80211_NAN_SCHED_NOT_AVAIL_SLOT)

net/wireless/nl80211.c

17499

struct cfg80211_nan_local_sched *sched __free(kfree) = NULL;

net/wireless/nl80211.c

17519

sched = kzalloc(struct_size(sched, nan_channels, n_channels),

net/wireless/nl80211.c

17521

if (!sched)

net/wireless/nl80211.c

17524

sched->n_channels = n_channels;

net/wireless/nl80211.c

17529

sched->nan_channels, i, true);

net/wireless/nl80211.c

17539

sched->schedule, sched->n_channels);

net/wireless/nl80211.c

17543

sched_empty = nl80211_nan_is_sched_empty(sched);

net/wireless/nl80211.c

17545

sched->deferred =

net/wireless/nl80211.c

17549

if (sched->deferred) {

net/wireless/nl80211.c

17567

sched->nan_avail_blob =

net/wireless/nl80211.c

17569

sched->nan_avail_blob_len =

net/wireless/nl80211.c

17573

return cfg80211_nan_set_local_schedule(rdev, wdev, sched);

net/wireless/rdev-ops.h

1067

struct cfg80211_nan_local_sched *sched)

net/wireless/rdev-ops.h

1071

trace_rdev_nan_set_local_sched(&rdev->wiphy, wdev, sched);

net/wireless/rdev-ops.h

1073

ret = rdev->ops->nan_set_local_sched(&rdev->wiphy, wdev, sched);

net/wireless/rdev-ops.h

1083

struct cfg80211_nan_peer_sched *sched)

net/wireless/rdev-ops.h

1087

trace_rdev_nan_set_peer_sched(&rdev->wiphy, wdev, sched);

net/wireless/rdev-ops.h

1089

ret = rdev->ops->nan_set_peer_sched(&rdev->wiphy, wdev, sched);

net/wireless/trace.h

2439

struct cfg80211_nan_local_sched *sched),

net/wireless/trace.h

2440

TP_ARGS(wiphy, wdev, sched),

net/wireless/trace.h

2449

memcpy(__entry->schedule, sched->schedule,

net/wireless/trace.h

2460

struct cfg80211_nan_peer_sched *sched),

net/wireless/trace.h

2461

TP_ARGS(wiphy, wdev, sched),

net/wireless/trace.h

2473

memcpy(__entry->peer_addr, sched->peer_addr, ETH_ALEN);

net/wireless/trace.h

2474

__entry->seq_id = sched->seq_id;

net/wireless/trace.h

2475

__entry->committed_dw = sched->committed_dw;

net/wireless/trace.h

2476

__entry->max_chan_switch = sched->max_chan_switch;

samples/bpf/xdp_sample.bpf.c

157

unsigned int drops, int sched, struct xdp_cpumap_stats *xdp_stats)

samples/bpf/xdp_sample.bpf.c

175

if (sched)

tools/perf/builtin-sched.c

1081

static int thread_atoms_insert(struct perf_sched *sched, struct thread *thread)

tools/perf/builtin-sched.c

1091

__thread_latency_insert(&sched->atom_root, atoms, &sched->cmp_pid);

tools/perf/builtin-sched.c

1178

static int latency_switch_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

1198

timestamp0 = sched->cpu_last_switched[cpu];

tools/perf/builtin-sched.c

1199

sched->cpu_last_switched[cpu] = timestamp;

tools/perf/builtin-sched.c

1215

out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);

tools/perf/builtin-sched.c

1217

if (thread_atoms_insert(sched, sched_out))

tools/perf/builtin-sched.c

1219

out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);

tools/perf/builtin-sched.c

1228

in_events = thread_atoms_search(&sched->atom_root, sched_in, &sched->cmp_pid);

tools/perf/builtin-sched.c

1230

if (thread_atoms_insert(sched, sched_in))

tools/perf/builtin-sched.c

1232

in_events = thread_atoms_search(&sched->atom_root, sched_in, &sched->cmp_pid);

tools/perf/builtin-sched.c

1252

static int latency_runtime_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

1266

atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);

tools/perf/builtin-sched.c

1276

if (thread_atoms_insert(sched, thread))

tools/perf/builtin-sched.c

1278

atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);

tools/perf/builtin-sched.c

1294

static int latency_wakeup_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

1308

atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);

tools/perf/builtin-sched.c

1310

if (thread_atoms_insert(sched, wakee))

tools/perf/builtin-sched.c

1312

atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);

tools/perf/builtin-sched.c

1336

if (sched->profile_cpu == -1 && atom->state != THREAD_SLEEPING)

tools/perf/builtin-sched.c

1339

sched->nr_timestamps++;

tools/perf/builtin-sched.c

134

int (*switch_event)(struct perf_sched *sched, struct perf_sample *sample,

tools/perf/builtin-sched.c

1341

sched->nr_unordered_timestamps++;

tools/perf/builtin-sched.c

1354

static int latency_migrate_task_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

1368

if (sched->profile_cpu == -1)

tools/perf/builtin-sched.c

137

int (*runtime_event)(struct perf_sched *sched, struct perf_sample *sample,

tools/perf/builtin-sched.c

1374

atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);

tools/perf/builtin-sched.c

1376

if (thread_atoms_insert(sched, migrant))

tools/perf/builtin-sched.c

1378

register_pid(sched, thread__tid(migrant), thread__comm_str(migrant));

tools/perf/builtin-sched.c

1379

atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);

tools/perf/builtin-sched.c

1393

sched->nr_timestamps++;

tools/perf/builtin-sched.c

1396

sched->nr_unordered_timestamps++;

tools/perf/builtin-sched.c

140

int (*wakeup_event)(struct perf_sched *sched, struct perf_sample *sample,

tools/perf/builtin-sched.c

1403

static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_list)

tools/perf/builtin-sched.c

1418

sched->all_runtime += work_list->total_runtime;

tools/perf/builtin-sched.c

1419

sched->all_count += work_list->nb_atoms;

tools/perf/builtin-sched.c

144

int (*fork_event)(struct perf_sched *sched, union perf_event *event,

tools/perf/builtin-sched.c

147

int (*migrate_task_event)(struct perf_sched *sched,

tools/perf/builtin-sched.c

1551

static void perf_sched__sort_lat(struct perf_sched *sched)

tools/perf/builtin-sched.c

1554

struct rb_root_cached *root = &sched->atom_root;

tools/perf/builtin-sched.c

1564

__thread_latency_insert(&sched->sorted_atom_root, data, &sched->sort_list);

tools/perf/builtin-sched.c

1566

if (root == &sched->atom_root) {

tools/perf/builtin-sched.c

1567

root = &sched->merged_atom_root;

tools/perf/builtin-sched.c

1576

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

1578

if (sched->tp_handler->wakeup_event)

tools/perf/builtin-sched.c

1579

return sched->tp_handler->wakeup_event(sched, sample, machine);

tools/perf/builtin-sched.c

1599

map__findnew_thread(struct perf_sched *sched, struct machine *machine, pid_t pid, pid_t tid)

tools/perf/builtin-sched.c

1603

if (!sched->map.color_pids || !thread)

tools/perf/builtin-sched.c

1613

if (thread_map__has(sched->map.color_pids, tid)) {

tools/perf/builtin-sched.c

1622

static bool sched_match_task(struct perf_sched *sched, const char *comm_str)

tools/perf/builtin-sched.c

1624

bool fuzzy_match = sched->map.fuzzy;

tools/perf/builtin-sched.c

1625

struct strlist *task_names = sched->map.task_names;

tools/perf/builtin-sched.c

1638

static void print_sched_map(struct perf_sched *sched, struct perf_cpu this_cpu, int cpus_nr,

tools/perf/builtin-sched.c

1643

.cpu = sched->map.comp ? sched->map.comp_cpus[i].cpu : i,

tools/perf/builtin-sched.c

1645

struct thread *curr_thread = sched->curr_thread[cpu.cpu];

tools/perf/builtin-sched.c

1646

struct thread *curr_out_thread = sched->curr_out_thread[cpu.cpu];

tools/perf/builtin-sched.c

1656

if (sched->map.color_cpus && perf_cpu_map__has(sched->map.color_cpus, cpu))

tools/perf/builtin-sched.c

1664

thread_to_check = sched_out ? sched->curr_out_thread[cpu.cpu] :

tools/perf/builtin-sched.c

1665

sched->curr_thread[cpu.cpu];

tools/perf/builtin-sched.c

1676

curr_tr = thread__get_runtime(sched->curr_thread[cpu.cpu]);

tools/perf/builtin-sched.c

1688

static int map_switch_event(struct perf_sched *sched, struct perf_sample *sample,

tools/perf/builtin-sched.c

1716

if (this_cpu.cpu > sched->max_cpu.cpu)

tools/perf/builtin-sched.c

1717

sched->max_cpu = this_cpu;

tools/perf/builtin-sched.c

1719

if (sched->map.comp) {

tools/perf/builtin-sched.c

1720

cpus_nr = bitmap_weight(sched->map.comp_cpus_mask, MAX_CPUS);

tools/perf/builtin-sched.c

1721

if (!__test_and_set_bit(this_cpu.cpu, sched->map.comp_cpus_mask)) {

tools/perf/builtin-sched.c

1722

sched->map.comp_cpus[cpus_nr++] = this_cpu;

tools/perf/builtin-sched.c

1726

cpus_nr = sched->max_cpu.cpu + 1;

tools/perf/builtin-sched.c

1728

timestamp0 = sched->cpu_last_switched[this_cpu.cpu];

tools/perf/builtin-sched.c

1729

sched->cpu_last_switched[this_cpu.cpu] = timestamp;

tools/perf/builtin-sched.c

1740

sched_in = map__findnew_thread(sched, machine, -1, next_pid);

tools/perf/builtin-sched.c

1741

sched_out = map__findnew_thread(sched, machine, -1, prev_pid);

tools/perf/builtin-sched.c

1749

thread__put(sched->curr_thread[this_cpu.cpu]);

tools/perf/builtin-sched.c

1750

thread__put(sched->curr_out_thread[this_cpu.cpu]);

tools/perf/builtin-sched.c

1752

sched->curr_thread[this_cpu.cpu] = thread__get(sched_in);

tools/perf/builtin-sched.c

1753

sched->curr_out_thread[this_cpu.cpu] = thread__get(sched_out);

tools/perf/builtin-sched.c

1767

} else if (!sched->map.task_name || sched_match_task(sched, str)) {

tools/perf/builtin-sched.c

1768

tr->shortname[0] = sched->next_shortname1;

tools/perf/builtin-sched.c

1769

tr->shortname[1] = sched->next_shortname2;

tools/perf/builtin-sched.c

1771

if (sched->next_shortname1 < 'Z') {

tools/perf/builtin-sched.c

1772

sched->next_shortname1++;

tools/perf/builtin-sched.c

1774

sched->next_shortname1 = 'A';

tools/perf/builtin-sched.c

1775

if (sched->next_shortname2 < '9')

tools/perf/builtin-sched.c

1776

sched->next_shortname2++;

tools/perf/builtin-sched.c

1778

sched->next_shortname2 = '0';

tools/perf/builtin-sched.c

1787

if (sched->map.cpus && !perf_cpu_map__has(sched->map.cpus, this_cpu))

tools/perf/builtin-sched.c

1796

if (sched->map.task_name && !sched_match_task(sched, str)) {

tools/perf/builtin-sched.c

1797

if (!sched_match_task(sched, thread__comm_str(sched_out)))

tools/perf/builtin-sched.c

1804

if (!(sched->map.task_name && !sched_match_task(sched, str)))

tools/perf/builtin-sched.c

1810

print_sched_map(sched, this_cpu, cpus_nr, color, false);

tools/perf/builtin-sched.c

1825

if (sched->map.comp && new_cpu)

tools/perf/builtin-sched.c

1834

if (sched->map.task_name) {

tools/perf/builtin-sched.c

1835

tr = thread__get_runtime(sched->curr_out_thread[this_cpu.cpu]);

tools/perf/builtin-sched.c

1843

print_sched_map(sched, this_cpu, cpus_nr, color, true);

tools/perf/builtin-sched.c

1861

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

1873

if (sched->curr_pid[this_cpu] != (u32)-1) {

tools/perf/builtin-sched.c

1878

if (sched->curr_pid[this_cpu] != prev_pid)

tools/perf/builtin-sched.c

1879

sched->nr_context_switch_bugs++;

tools/perf/builtin-sched.c

1882

if (sched->tp_handler->switch_event)

tools/perf/builtin-sched.c

1883

err = sched->tp_handler->switch_event(sched, sample, machine);

tools/perf/builtin-sched.c

1885

sched->curr_pid[this_cpu] = next_pid;

tools/perf/builtin-sched.c

1893

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

1902

if (sched->tp_handler->runtime_event)

tools/perf/builtin-sched.c

1903

return sched->tp_handler->runtime_event(sched, sample, machine);

tools/perf/builtin-sched.c

1913

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

1919

if (sched->tp_handler->fork_event)

tools/perf/builtin-sched.c

1920

return sched->tp_handler->fork_event(sched, event, machine);

tools/perf/builtin-sched.c

1929

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

1931

if (sched->tp_handler->migrate_task_event)

tools/perf/builtin-sched.c

1932

return sched->tp_handler->migrate_task_event(sched, sample, machine);

tools/perf/builtin-sched.c

1988

static int perf_sched__read_events(struct perf_sched *sched)

tools/perf/builtin-sched.c

2002

.force = sched->force,

tools/perf/builtin-sched.c

2006

session = perf_session__new(&data, &sched->tool);

tools/perf/builtin-sched.c

2028

sched->nr_events = session->evlist->stats.nr_events[0];

tools/perf/builtin-sched.c

2029

sched->nr_lost_events = session->evlist->stats.total_lost;

tools/perf/builtin-sched.c

2030

sched->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST];

tools/perf/builtin-sched.c

2160

static void timehist_header(struct perf_sched *sched)

tools/perf/builtin-sched.c

2162

u32 ncpus = sched->max_cpu.cpu + 1;

tools/perf/builtin-sched.c

2167

if (sched->show_cpu_visual) {

tools/perf/builtin-sched.c

2179

if (sched->show_prio)

tools/perf/builtin-sched.c

2184

if (sched->pre_migrations)

tools/perf/builtin-sched.c

2187

if (sched->show_state)

tools/perf/builtin-sched.c

2197

if (sched->show_cpu_visual)

tools/perf/builtin-sched.c

2202

if (sched->show_prio)

tools/perf/builtin-sched.c

2207

if (sched->pre_migrations)

tools/perf/builtin-sched.c

2217

if (sched->show_cpu_visual)

tools/perf/builtin-sched.c

2222

if (sched->show_prio)

tools/perf/builtin-sched.c

2227

if (sched->pre_migrations)

tools/perf/builtin-sched.c

2230

if (sched->show_state)

tools/perf/builtin-sched.c

2236

static void timehist_print_sample(struct perf_sched *sched,

tools/perf/builtin-sched.c

2245

u32 max_cpus = sched->max_cpu.cpu + 1;

tools/perf/builtin-sched.c

2257

if (sched->show_cpu_visual) {

tools/perf/builtin-sched.c

2281

if (sched->show_prio)

tools/perf/builtin-sched.c

2289

if (sched->pre_migrations)

tools/perf/builtin-sched.c

2292

if (sched->show_state)

tools/perf/builtin-sched.c

2295

if (sched->show_next) {

tools/perf/builtin-sched.c

2300

if (sched->show_wakeups && !sched->show_next)

tools/perf/builtin-sched.c

2306

if (sched->show_callchain)

tools/perf/builtin-sched.c

2400

static void save_task_callchain(struct perf_sched *sched,

tools/perf/builtin-sched.c

2414

if (!sched->show_callchain || sample->callchain == NULL) {

tools/perf/builtin-sched.c

2422

NULL, NULL, sched->max_stack + 2) != 0) {

tools/perf/builtin-sched.c

2564

static void save_idle_callchain(struct perf_sched *sched,

tools/perf/builtin-sched.c

2570

if (!sched->show_callchain || sample->callchain == NULL)

tools/perf/builtin-sched.c

2580

static struct thread *timehist_get_thread(struct perf_sched *sched,

tools/perf/builtin-sched.c

2600

save_task_callchain(sched, sample, machine);

tools/perf/builtin-sched.c

2601

if (sched->idle_hist) {

tools/perf/builtin-sched.c

2624

save_idle_callchain(sched, itr, sample);

tools/perf/builtin-sched.c

2633

static bool timehist_skip_sample(struct perf_sched *sched,

tools/perf/builtin-sched.c

2643

sched->skipped_samples++;

tools/perf/builtin-sched.c

2646

if (sched->prio_str) {

tools/perf/builtin-sched.c

2661

(prio >= MAX_PRIO || !test_bit(prio, sched->prio_bitmap))) {

tools/perf/builtin-sched.c

2663

sched->skipped_samples++;

tools/perf/builtin-sched.c

2667

if (sched->idle_hist) {

tools/perf/builtin-sched.c

2678

static void timehist_print_wakeup_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

2691

if (timehist_skip_sample(sched, thread, sample) &&

tools/perf/builtin-sched.c

2692

timehist_skip_sample(sched, awakened, sample)) {

tools/perf/builtin-sched.c

2699

if (sched->show_cpu_visual)

tools/perf/builtin-sched.c

2700

printf(" %*s ", sched->max_cpu.cpu + 1, "");

tools/perf/builtin-sched.c

2727

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

2747

if (sched->show_wakeups &&

tools/perf/builtin-sched.c

2748

!perf_time__skip_sample(&sched->ptime, sample->time))

tools/perf/builtin-sched.c

2749

timehist_print_wakeup_event(sched, sample, machine, thread);

tools/perf/builtin-sched.c

2755

static void timehist_print_migration_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

2765

if (sched->summary_only)

tools/perf/builtin-sched.c

2768

max_cpus = sched->max_cpu.cpu + 1;

tools/perf/builtin-sched.c

2776

if (timehist_skip_sample(sched, thread, sample) &&

tools/perf/builtin-sched.c

2777

timehist_skip_sample(sched, migrated, sample)) {

tools/perf/builtin-sched.c

2785

if (sched->show_cpu_visual) {

tools/perf/builtin-sched.c

2814

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

2834

if (sched->show_migrations) {

tools/perf/builtin-sched.c

2835

timehist_print_migration_event(sched, sample, machine, thread);

tools/perf/builtin-sched.c

2870

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

2871

struct perf_time_interval *ptime = &sched->ptime;

tools/perf/builtin-sched.c

2895

if (sched->show_prio || sched->prio_str)

tools/perf/builtin-sched.c

2898

thread = timehist_get_thread(sched, sample, machine);

tools/perf/builtin-sched.c

2904

if (timehist_skip_sample(sched, thread, sample))

tools/perf/builtin-sched.c

2949

if (!sched->idle_hist || is_idle_sample(sample)) {

tools/perf/builtin-sched.c

2954

if (sched->idle_hist) {

tools/perf/builtin-sched.c

2984

if (!sched->summary_only)

tools/perf/builtin-sched.c

2985

timehist_print_sample(sched, sample, &al, thread, t, state);

tools/perf/builtin-sched.c

2989

if (sched->hist_time.start == 0 && t >= ptime->start)

tools/perf/builtin-sched.c

2990

sched->hist_time.start = t;

tools/perf/builtin-sched.c

2992

sched->hist_time.end = t;

tools/perf/builtin-sched.c

3082

struct perf_sched *sched;

tools/perf/builtin-sched.c

309

static void burn_nsecs(struct perf_sched *sched, u64 nsecs)

tools/perf/builtin-sched.c

3102

if (stats->sched->show_state)

tools/perf/builtin-sched.c

315

} while (T1 + sched->run_measurement_overhead < T0 + nsecs);

tools/perf/builtin-sched.c

3166

static void timehist_print_summary(struct perf_sched *sched,

tools/perf/builtin-sched.c

3175

u64 hist_time = sched->hist_time.end - sched->hist_time.start;

tools/perf/builtin-sched.c

3178

totals.sched = sched;

tools/perf/builtin-sched.c

3180

if (sched->idle_hist) {

tools/perf/builtin-sched.c

3184

} else if (sched->show_state) {

tools/perf/builtin-sched.c

3195

sched->show_state ? "(msec)" : "%");

tools/perf/builtin-sched.c

3204

if (sched->skipped_samples && !sched->idle_hist)

tools/perf/builtin-sched.c

3226

if (sched->idle_hist && sched->show_callchain) {

tools/perf/builtin-sched.c

3266

printf(" (x %d)\n", sched->max_cpu.cpu);

tools/perf/builtin-sched.c

3279

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

328

static void calibrate_run_measurement_overhead(struct perf_sched *sched)

tools/perf/builtin-sched.c

3288

this_cpu.cpu > sched->max_cpu.cpu)

tools/perf/builtin-sched.c

3289

sched->max_cpu = this_cpu;

tools/perf/builtin-sched.c

3300

static int timehist_check_attr(struct perf_sched *sched,

tools/perf/builtin-sched.c

3314

if (sched->show_callchain &&

tools/perf/builtin-sched.c

3318

sched->show_callchain = 0;

tools/perf/builtin-sched.c

3326

static int timehist_parse_prio_str(struct perf_sched *sched)

tools/perf/builtin-sched.c

3330

const char *str = sched->prio_str;

tools/perf/builtin-sched.c

335

burn_nsecs(sched, 0);

tools/perf/builtin-sched.c

3356

__set_bit(start_prio, sched->prio_bitmap);

tools/perf/builtin-sched.c

3367

static int perf_sched__timehist(struct perf_sched *sched)

tools/perf/builtin-sched.c

3381

.force = sched->force,

tools/perf/builtin-sched.c

3392

sched->tool.sample = perf_timehist__process_sample;

tools/perf/builtin-sched.c

3393

sched->tool.mmap = perf_event__process_mmap;

tools/perf/builtin-sched.c

3394

sched->tool.mmap2 = perf_event__process_mmap2;

tools/perf/builtin-sched.c

3395

sched->tool.comm = perf_event__process_comm;

tools/perf/builtin-sched.c

3396

sched->tool.exit = perf_event__process_exit;

tools/perf/builtin-sched.c

3397

sched->tool.fork = perf_event__process_fork;

tools/perf/builtin-sched.c

3398

sched->tool.lost = process_lost;

tools/perf/builtin-sched.c

3399

sched->tool.attr = perf_event__process_attr;

tools/perf/builtin-sched.c

340

sched->run_measurement_overhead = min_delta;

tools/perf/builtin-sched.c

3400

sched->tool.tracing_data = perf_event__process_tracing_data;

tools/perf/builtin-sched.c

3401

sched->tool.build_id = perf_event__process_build_id;

tools/perf/builtin-sched.c

3403

sched->tool.ordering_requires_timestamps = true;

tools/perf/builtin-sched.c

3405

symbol_conf.use_callchain = sched->show_callchain;

tools/perf/builtin-sched.c

3407

session = perf_session__new(&data, &sched->tool);

tools/perf/builtin-sched.c

3422

if (perf_time__parse_str(&sched->ptime, sched->time_str) != 0) {

tools/perf/builtin-sched.c

3428

if (timehist_check_attr(sched, evlist) != 0)

tools/perf/builtin-sched.c

3431

if (timehist_parse_prio_str(sched) != 0) {

tools/perf/builtin-sched.c

345

static void calibrate_sleep_measurement_overhead(struct perf_sched *sched)

tools/perf/builtin-sched.c

3454

if ((sched->show_migrations || sched->pre_migrations) &&

tools/perf/builtin-sched.c

3459

sched->max_cpu.cpu = min(env->nr_cpus_online, MAX_CPUS);

tools/perf/builtin-sched.c

3460

if (sched->max_cpu.cpu == 0)

tools/perf/builtin-sched.c

3461

sched->max_cpu.cpu = 4;

tools/perf/builtin-sched.c

3462

if (init_idle_threads(sched->max_cpu.cpu))

tools/perf/builtin-sched.c

3466

if (sched->summary_only)

tools/perf/builtin-sched.c

3467

sched->summary = sched->summary_only;

tools/perf/builtin-sched.c

3469

if (!sched->summary_only)

tools/perf/builtin-sched.c

3470

timehist_header(sched);

tools/perf/builtin-sched.c

3478

sched->nr_events = evlist->stats.nr_events[0];

tools/perf/builtin-sched.c

3479

sched->nr_lost_events = evlist->stats.total_lost;

tools/perf/builtin-sched.c

3480

sched->nr_lost_chunks = evlist->stats.nr_events[PERF_RECORD_LOST];

tools/perf/builtin-sched.c

3482

if (sched->summary)

tools/perf/builtin-sched.c

3483

timehist_print_summary(sched, session);

tools/perf/builtin-sched.c

3493

static void print_bad_events(struct perf_sched *sched)

tools/perf/builtin-sched.c

3495

if (sched->nr_unordered_timestamps && sched->nr_timestamps) {

tools/perf/builtin-sched.c

3497

(double)sched->nr_unordered_timestamps/(double)sched->nr_timestamps*100.0,

tools/perf/builtin-sched.c

3498

sched->nr_unordered_timestamps, sched->nr_timestamps);

tools/perf/builtin-sched.c

3500

if (sched->nr_lost_events && sched->nr_events) {

tools/perf/builtin-sched.c

3502

(double)sched->nr_lost_events/(double)sched->nr_events * 100.0,

tools/perf/builtin-sched.c

3503

sched->nr_lost_events, sched->nr_events, sched->nr_lost_chunks);

tools/perf/builtin-sched.c

3505

if (sched->nr_context_switch_bugs && sched->nr_timestamps) {

tools/perf/builtin-sched.c

3507

(double)sched->nr_context_switch_bugs/(double)sched->nr_timestamps*100.0,

tools/perf/builtin-sched.c

3508

sched->nr_context_switch_bugs, sched->nr_timestamps);

tools/perf/builtin-sched.c

3509

if (sched->nr_lost_events)

tools/perf/builtin-sched.c

3556

static void perf_sched__merge_lat(struct perf_sched *sched)

tools/perf/builtin-sched.c

3561

if (sched->skip_merge)

tools/perf/builtin-sched.c

3564

while ((node = rb_first_cached(&sched->atom_root))) {

tools/perf/builtin-sched.c

3565

rb_erase_cached(node, &sched->atom_root);

tools/perf/builtin-sched.c

3567

__merge_work_atoms(&sched->merged_atom_root, data);

tools/perf/builtin-sched.c

3571

static int setup_cpus_switch_event(struct perf_sched *sched)

tools/perf/builtin-sched.c

3575

sched->cpu_last_switched = calloc(MAX_CPUS, sizeof(*(sched->cpu_last_switched)));

tools/perf/builtin-sched.c

3576

if (!sched->cpu_last_switched)

tools/perf/builtin-sched.c

3579

sched->curr_pid = calloc(MAX_CPUS, sizeof(*(sched->curr_pid)));

tools/perf/builtin-sched.c

358

sched->sleep_measurement_overhead = min_delta;

tools/perf/builtin-sched.c

3580

if (!sched->curr_pid) {

tools/perf/builtin-sched.c

3581

zfree(&sched->cpu_last_switched);

tools/perf/builtin-sched.c

3586

sched->curr_pid[i] = -1;

tools/perf/builtin-sched.c

3591

static void free_cpus_switch_event(struct perf_sched *sched)

tools/perf/builtin-sched.c

3593

zfree(&sched->curr_pid);

tools/perf/builtin-sched.c

3594

zfree(&sched->cpu_last_switched);

tools/perf/builtin-sched.c

3597

static int perf_sched__lat(struct perf_sched *sched)

tools/perf/builtin-sched.c

3604

if (setup_cpus_switch_event(sched))

tools/perf/builtin-sched.c

3607

if (perf_sched__read_events(sched))

tools/perf/builtin-sched.c

3610

perf_sched__merge_lat(sched);

tools/perf/builtin-sched.c

3611

perf_sched__sort_lat(sched);

tools/perf/builtin-sched.c

3617

next = rb_first_cached(&sched->sorted_atom_root);

tools/perf/builtin-sched.c

3623

output_lat_thread(sched, work_list);

tools/perf/builtin-sched.c

3629

(double)sched->all_runtime / NSEC_PER_MSEC, sched->all_count);

tools/perf/builtin-sched.c

3633

print_bad_events(sched);

tools/perf/builtin-sched.c

3638

while ((next = rb_first_cached(&sched->sorted_atom_root))) {

tools/perf/builtin-sched.c

3642

rb_erase_cached(next, &sched->sorted_atom_root);

tools/perf/builtin-sched.c

3646

free_cpus_switch_event(sched);

tools/perf/builtin-sched.c

3650

static int setup_map_cpus(struct perf_sched *sched)

tools/perf/builtin-sched.c

3652

if (sched->map.comp) {

tools/perf/builtin-sched.c

3653

sched->map.comp_cpus = calloc(MAX_CPUS, sizeof(*sched->map.comp_cpus));

tools/perf/builtin-sched.c

3654

if (!sched->map.comp_cpus)

tools/perf/builtin-sched.c

3658

if (sched->map.cpus_str) {

tools/perf/builtin-sched.c

3659

sched->map.cpus = perf_cpu_map__new(sched->map.cpus_str);

tools/perf/builtin-sched.c

3660

if (!sched->map.cpus) {

tools/perf/builtin-sched.c

3661

pr_err("failed to get cpus map from %s\n", sched->map.cpus_str);

tools/perf/builtin-sched.c

3662

zfree(&sched->map.comp_cpus);

tools/perf/builtin-sched.c

3670

static int setup_color_pids(struct perf_sched *sched)

tools/perf/builtin-sched.c

3674

if (!sched->map.color_pids_str)

tools/perf/builtin-sched.c

3677

map = thread_map__new_by_tid_str(sched->map.color_pids_str);

tools/perf/builtin-sched.c

3679

pr_err("failed to get thread map from %s\n", sched->map.color_pids_str);

tools/perf/builtin-sched.c

3683

sched->map.color_pids = map;

tools/perf/builtin-sched.c

3687

static int setup_color_cpus(struct perf_sched *sched)

tools/perf/builtin-sched.c

3691

if (!sched->map.color_cpus_str)

tools/perf/builtin-sched.c

3694

map = perf_cpu_map__new(sched->map.color_cpus_str);

tools/perf/builtin-sched.c

3696

pr_err("failed to get thread map from %s\n", sched->map.color_cpus_str);

tools/perf/builtin-sched.c

3700

sched->map.color_cpus = map;

tools/perf/builtin-sched.c

3704

static int perf_sched__map(struct perf_sched *sched)

tools/perf/builtin-sched.c

3708

sched->curr_thread = calloc(MAX_CPUS, sizeof(*(sched->curr_thread)));

tools/perf/builtin-sched.c

3709

if (!sched->curr_thread)

tools/perf/builtin-sched.c

3712

sched->curr_out_thread = calloc(MAX_CPUS, sizeof(*(sched->curr_out_thread)));

tools/perf/builtin-sched.c

3713

if (!sched->curr_out_thread)

tools/perf/builtin-sched.c

3716

if (setup_cpus_switch_event(sched))

tools/perf/builtin-sched.c

3719

if (setup_map_cpus(sched))

tools/perf/builtin-sched.c

3722

if (setup_color_pids(sched))

tools/perf/builtin-sched.c

3725

if (setup_color_cpus(sched))

tools/perf/builtin-sched.c

3729

if (perf_sched__read_events(sched))

tools/perf/builtin-sched.c

3733

print_bad_events(sched);

tools/perf/builtin-sched.c

3736

perf_cpu_map__put(sched->map.color_cpus);

tools/perf/builtin-sched.c

3739

perf_thread_map__put(sched->map.color_pids);

tools/perf/builtin-sched.c

3742

zfree(&sched->map.comp_cpus);

tools/perf/builtin-sched.c

3743

perf_cpu_map__put(sched->map.cpus);

tools/perf/builtin-sched.c

3746

free_cpus_switch_event(sched);

tools/perf/builtin-sched.c

3750

thread__put(sched->curr_out_thread[i]);

tools/perf/builtin-sched.c

3751

zfree(&sched->curr_out_thread);

tools/perf/builtin-sched.c

3755

thread__put(sched->curr_thread[i]);

tools/perf/builtin-sched.c

3756

zfree(&sched->curr_thread);

tools/perf/builtin-sched.c

3760

static int perf_sched__replay(struct perf_sched *sched)

tools/perf/builtin-sched.c

3765

mutex_init(&sched->start_work_mutex);

tools/perf/builtin-sched.c

3766

mutex_init(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

3768

ret = setup_cpus_switch_event(sched);

tools/perf/builtin-sched.c

3772

calibrate_run_measurement_overhead(sched);

tools/perf/builtin-sched.c

3773

calibrate_sleep_measurement_overhead(sched);

tools/perf/builtin-sched.c

3775

test_calibrations(sched);

tools/perf/builtin-sched.c

3777

ret = perf_sched__read_events(sched);

tools/perf/builtin-sched.c

3781

printf("nr_run_events: %ld\n", sched->nr_run_events);

tools/perf/builtin-sched.c

3782

printf("nr_sleep_events: %ld\n", sched->nr_sleep_events);

tools/perf/builtin-sched.c

3783

printf("nr_wakeup_events: %ld\n", sched->nr_wakeup_events);

tools/perf/builtin-sched.c

3785

if (sched->targetless_wakeups)

tools/perf/builtin-sched.c

3786

printf("target-less wakeups: %ld\n", sched->targetless_wakeups);

tools/perf/builtin-sched.c

3787

if (sched->multitarget_wakeups)

tools/perf/builtin-sched.c

3788

printf("multi-target wakeups: %ld\n", sched->multitarget_wakeups);

tools/perf/builtin-sched.c

3789

if (sched->nr_run_events_optimized)

tools/perf/builtin-sched.c

3791

sched->nr_run_events_optimized);

tools/perf/builtin-sched.c

3793

print_task_traces(sched);

tools/perf/builtin-sched.c

3794

add_cross_task_wakeups(sched);

tools/perf/builtin-sched.c

3796

sched->thread_funcs_exit = false;

tools/perf/builtin-sched.c

3797

create_tasks(sched);

tools/perf/builtin-sched.c

3799

if (sched->replay_repeat == 0)

tools/perf/builtin-sched.c

3800

sched->replay_repeat = UINT_MAX;

tools/perf/builtin-sched.c

3802

for (i = 0; i < sched->replay_repeat; i++)

tools/perf/builtin-sched.c

3803

run_one_test(sched);

tools/perf/builtin-sched.c

3805

sched->thread_funcs_exit = true;

tools/perf/builtin-sched.c

3806

destroy_tasks(sched);

tools/perf/builtin-sched.c

3809

free_cpus_switch_event(sched);

tools/perf/builtin-sched.c

3812

mutex_destroy(&sched->start_work_mutex);

tools/perf/builtin-sched.c

3813

mutex_destroy(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

3817

static void setup_sorting(struct perf_sched *sched, const struct option *options,

tools/perf/builtin-sched.c

3820

char *tmp, *tok, *str = strdup(sched->sort_order);

tools/perf/builtin-sched.c

3824

if (sort_dimension__add(tok, &sched->sort_list) < 0) {

tools/perf/builtin-sched.c

3832

sort_dimension__add("pid", &sched->cmp_pid);

tools/perf/builtin-sched.c

3840

struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

tools/perf/builtin-sched.c

3842

if (perf_data__write(sched->data, event, event->header.size) <= 0) {

tools/perf/builtin-sched.c

3847

sched->session->header.data_size += event->header.size;

tools/perf/builtin-sched.c

3901

static int perf_sched__schedstat_record(struct perf_sched *sched,

tools/perf/builtin-sched.c

3924

session = perf_session__new(&data, &sched->tool);

tools/perf/builtin-sched.c

3933

sched->session = session;

tools/perf/builtin-sched.c

3934

sched->data = &data;

tools/perf/builtin-sched.c

3987

err = perf_event__synthesize_schedstat(&(sched->tool),

tools/perf/builtin-sched.c

4012

err = perf_event__synthesize_schedstat(&(sched->tool),

tools/perf/builtin-sched.c

402

static void add_sched_event_run(struct perf_sched *sched, struct task_desc *task,

tools/perf/builtin-sched.c

412

sched->nr_run_events_optimized++;

tools/perf/builtin-sched.c

424

sched->nr_run_events++;

tools/perf/builtin-sched.c

427

static void add_sched_event_wakeup(struct perf_sched *sched, struct task_desc *task,

tools/perf/builtin-sched.c

440

sched->targetless_wakeups++;

tools/perf/builtin-sched.c

444

sched->multitarget_wakeups++;

tools/perf/builtin-sched.c

456

sched->nr_wakeup_events++;

tools/perf/builtin-sched.c

459

static void add_sched_event_sleep(struct perf_sched *sched, struct task_desc *task,

tools/perf/builtin-sched.c

4673

static int perf_sched__schedstat_report(struct perf_sched *sched)

tools/perf/builtin-sched.c

4684

sched->tool.schedstat_cpu = perf_sched__process_schedstat;

tools/perf/builtin-sched.c

4685

sched->tool.schedstat_domain = perf_sched__process_schedstat;

tools/perf/builtin-sched.c

4687

session = perf_session__new(&data, &sched->tool);

tools/perf/builtin-sched.c

469

sched->nr_sleep_events++;

tools/perf/builtin-sched.c

472

static struct task_desc *register_pid(struct perf_sched *sched,

tools/perf/builtin-sched.c

4727

static int perf_sched__schedstat_diff(struct perf_sched *sched,

tools/perf/builtin-sched.c

4755

sched->tool.schedstat_cpu = perf_sched__process_schedstat;

tools/perf/builtin-sched.c

4756

sched->tool.schedstat_domain = perf_sched__process_schedstat;

tools/perf/builtin-sched.c

4760

session[0] = perf_session__new(&data[0], &sched->tool);

tools/perf/builtin-sched.c

4779

session[1] = perf_session__new(&data[1], &sched->tool);

tools/perf/builtin-sched.c

4836

static int perf_sched__schedstat_live(struct perf_sched *sched,

tools/perf/builtin-sched.c

484

if (sched->pid_to_task == NULL) {

tools/perf/builtin-sched.c

487

sched->pid_to_task = calloc(pid_max, sizeof(struct task_desc *));

tools/perf/builtin-sched.c

488

if (sched->pid_to_task == NULL)

tools/perf/builtin-sched.c

4880

err = perf_event__synthesize_schedstat(&(sched->tool),

tools/perf/builtin-sched.c

4905

err = perf_event__synthesize_schedstat(&(sched->tool),

tools/perf/builtin-sched.c

492

void *p = realloc(sched->pid_to_task, (pid + 1) * sizeof(struct task_desc *));

tools/perf/builtin-sched.c

496

sched->pid_to_task = p;

tools/perf/builtin-sched.c

498

sched->pid_to_task[pid_max++] = NULL;

tools/perf/builtin-sched.c

501

task = sched->pid_to_task[pid];

tools/perf/builtin-sched.c

5025

struct perf_sched sched = {

tools/perf/builtin-sched.c

5026

.cmp_pid = LIST_HEAD_INIT(sched.cmp_pid),

tools/perf/builtin-sched.c

5027

.sort_list = LIST_HEAD_INIT(sched.sort_list),

tools/perf/builtin-sched.c

5044

OPT_BOOLEAN('f', "force", &sched.force, "don't complain, do it"),

tools/perf/builtin-sched.c

5048

OPT_STRING('s', "sort", &sched.sort_order, "key[,key2...]",

tools/perf/builtin-sched.c

5050

OPT_INTEGER('C', "CPU", &sched.profile_cpu,

tools/perf/builtin-sched.c

5052

OPT_BOOLEAN('p', "pids", &sched.skip_merge,

tools/perf/builtin-sched.c

5057

OPT_UINTEGER('r', "repeat", &sched.replay_repeat,

tools/perf/builtin-sched.c

5062

OPT_BOOLEAN(0, "compact", &sched.map.comp,

tools/perf/builtin-sched.c

5064

OPT_STRING(0, "color-pids", &sched.map.color_pids_str, "pids",

tools/perf/builtin-sched.c

5066

OPT_STRING(0, "color-cpus", &sched.map.color_cpus_str, "cpus",

tools/perf/builtin-sched.c

5068

OPT_STRING(0, "cpus", &sched.map.cpus_str, "cpus",

tools/perf/builtin-sched.c

5070

OPT_STRING(0, "task-name", &sched.map.task_name, "task",

tools/perf/builtin-sched.c

5072

OPT_BOOLEAN(0, "fuzzy-name", &sched.map.fuzzy,

tools/perf/builtin-sched.c

5081

OPT_BOOLEAN('g', "call-graph", &sched.show_callchain,

tools/perf/builtin-sched.c

5083

OPT_UINTEGER(0, "max-stack", &sched.max_stack,

tools/perf/builtin-sched.c

5087

OPT_BOOLEAN('s', "summary", &sched.summary_only,

tools/perf/builtin-sched.c

5089

OPT_BOOLEAN('S', "with-summary", &sched.summary,

tools/perf/builtin-sched.c

5091

OPT_BOOLEAN('w', "wakeups", &sched.show_wakeups, "Show wakeup events"),

tools/perf/builtin-sched.c

5092

OPT_BOOLEAN('n', "next", &sched.show_next, "Show next task"),

tools/perf/builtin-sched.c

5093

OPT_BOOLEAN('M', "migrations", &sched.show_migrations, "Show migration events"),

tools/perf/builtin-sched.c

5094

OPT_BOOLEAN('V', "cpu-visual", &sched.show_cpu_visual, "Add CPU visual"),

tools/perf/builtin-sched.c

5095

OPT_BOOLEAN('I', "idle-hist", &sched.idle_hist, "Show idle events only"),

tools/perf/builtin-sched.c

5096

OPT_STRING(0, "time", &sched.time_str, "str",

tools/perf/builtin-sched.c

5098

OPT_BOOLEAN(0, "state", &sched.show_state, "Show task state when sched-out"),

tools/perf/builtin-sched.c

5104

OPT_BOOLEAN(0, "show-prio", &sched.show_prio, "Show task priority"),

tools/perf/builtin-sched.c

5105

OPT_STRING(0, "prio", &sched.prio_str, "prio",

tools/perf/builtin-sched.c

5107

OPT_BOOLEAN('P', "pre-migrations", &sched.pre_migrations, "Show pre-migration wait time"),

tools/perf/builtin-sched.c

516

add_sched_event_sleep(sched, task, 0);

tools/perf/builtin-sched.c

5164

perf_tool__init(&sched.tool, /*ordered_events=*/true);

tools/perf/builtin-sched.c

5165

sched.tool.sample = perf_sched__process_tracepoint_sample;

tools/perf/builtin-sched.c

5166

sched.tool.comm = perf_sched__process_comm;

tools/perf/builtin-sched.c

5167

sched.tool.namespaces = perf_event__process_namespaces;

tools/perf/builtin-sched.c

5168

sched.tool.lost = perf_event__process_lost;

tools/perf/builtin-sched.c

5169

sched.tool.fork = perf_sched__process_fork_event;

tools/perf/builtin-sched.c

518

sched->pid_to_task[pid] = task;

tools/perf/builtin-sched.c

5186

sched.tp_handler = &lat_ops;

tools/perf/builtin-sched.c

519

tasks_p = realloc(sched->tasks, (sched->nr_tasks + 1) * sizeof(struct task_desc *));

tools/perf/builtin-sched.c

5192

setup_sorting(&sched, latency_options, latency_usage);

tools/perf/builtin-sched.c

5193

ret = perf_sched__lat(&sched);

tools/perf/builtin-sched.c

5200

if (sched.map.task_name) {

tools/perf/builtin-sched.c

5201

sched.map.task_names = strlist__new(sched.map.task_name, NULL);

tools/perf/builtin-sched.c

5202

if (sched.map.task_names == NULL) {

tools/perf/builtin-sched.c

5209

sched.tp_handler = &map_ops;

tools/perf/builtin-sched.c

5210

setup_sorting(&sched, latency_options, latency_usage);

tools/perf/builtin-sched.c

5211

ret = perf_sched__map(&sched);

tools/perf/builtin-sched.c

5213

sched.tp_handler = &replay_ops;

tools/perf/builtin-sched.c

5219

ret = perf_sched__replay(&sched);

tools/perf/builtin-sched.c

522

sched->tasks = tasks_p;

tools/perf/builtin-sched.c

5227

if ((sched.show_wakeups || sched.show_next) &&

tools/perf/builtin-sched.c

5228

sched.summary_only) {

tools/perf/builtin-sched.c

523

sched->tasks[sched->nr_tasks] = task;

tools/perf/builtin-sched.c

5231

if (sched.show_wakeups)

tools/perf/builtin-sched.c

5233

if (sched.show_next)

tools/perf/builtin-sched.c

524

task->nr = sched->nr_tasks++;

tools/perf/builtin-sched.c

5240

ret = perf_sched__timehist(&sched);

tools/perf/builtin-sched.c

5244

sched.tp_handler = &stats_ops;

tools/perf/builtin-sched.c

5254

return perf_sched__schedstat_record(&sched, argc, argv);

tools/perf/builtin-sched.c

5259

return perf_sched__schedstat_report(&sched);

tools/perf/builtin-sched.c

5264

return perf_sched__schedstat_diff(&sched, argc, argv);

tools/perf/builtin-sched.c

5266

return perf_sched__schedstat_live(&sched, argc, argv);

tools/perf/builtin-sched.c

527

printf("registered task #%ld, PID %ld (%s)\n", sched->nr_tasks, pid, comm);

tools/perf/builtin-sched.c

533

static void print_task_traces(struct perf_sched *sched)

tools/perf/builtin-sched.c

538

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

539

task = sched->tasks[i];

tools/perf/builtin-sched.c

545

static void add_cross_task_wakeups(struct perf_sched *sched)

tools/perf/builtin-sched.c

550

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

551

task1 = sched->tasks[i];

tools/perf/builtin-sched.c

553

if (j == sched->nr_tasks)

tools/perf/builtin-sched.c

555

task2 = sched->tasks[j];

tools/perf/builtin-sched.c

556

add_sched_event_wakeup(sched, task1, 0, task2);

tools/perf/builtin-sched.c

560

static void perf_sched__process_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

567

burn_nsecs(sched, atom->duration);

tools/perf/builtin-sched.c

599

static int self_open_counters(struct perf_sched *sched, unsigned long cur_task)

tools/perf/builtin-sched.c

618

if (sched->force) {

tools/perf/builtin-sched.c

620

limit.rlim_cur += sched->nr_tasks - cur_task;

tools/perf/builtin-sched.c

654

struct perf_sched *sched;

tools/perf/builtin-sched.c

662

struct perf_sched *sched = parms->sched;

tools/perf/builtin-sched.c

675

while (!sched->thread_funcs_exit) {

tools/perf/builtin-sched.c

678

mutex_lock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

679

mutex_unlock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

685

perf_sched__process_event(sched, this_task->atoms[i]);

tools/perf/builtin-sched.c

693

mutex_lock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

694

mutex_unlock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

699

static void create_tasks(struct perf_sched *sched)

tools/perf/builtin-sched.c

700

EXCLUSIVE_LOCK_FUNCTION(sched->start_work_mutex)

tools/perf/builtin-sched.c

701

EXCLUSIVE_LOCK_FUNCTION(sched->work_done_wait_mutex)

tools/perf/builtin-sched.c

713

mutex_lock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

714

mutex_lock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

715

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

718

parms->task = task = sched->tasks[i];

tools/perf/builtin-sched.c

719

parms->sched = sched;

tools/perf/builtin-sched.c

720

parms->fd = self_open_counters(sched, i);

tools/perf/builtin-sched.c

729

static void destroy_tasks(struct perf_sched *sched)

tools/perf/builtin-sched.c

730

UNLOCK_FUNCTION(sched->start_work_mutex)

tools/perf/builtin-sched.c

731

UNLOCK_FUNCTION(sched->work_done_wait_mutex)

tools/perf/builtin-sched.c

737

mutex_unlock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

738

mutex_unlock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

740

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

741

task = sched->tasks[i];

tools/perf/builtin-sched.c

749

static void wait_for_tasks(struct perf_sched *sched)

tools/perf/builtin-sched.c

750

EXCLUSIVE_LOCKS_REQUIRED(sched->work_done_wait_mutex)

tools/perf/builtin-sched.c

751

EXCLUSIVE_LOCKS_REQUIRED(sched->start_work_mutex)

tools/perf/builtin-sched.c

757

sched->start_time = get_nsecs();

tools/perf/builtin-sched.c

758

sched->cpu_usage = 0;

tools/perf/builtin-sched.c

759

mutex_unlock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

761

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

762

task = sched->tasks[i];

tools/perf/builtin-sched.c

767

mutex_lock(&sched->work_done_wait_mutex);

tools/perf/builtin-sched.c

771

mutex_unlock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

773

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

774

task = sched->tasks[i];

tools/perf/builtin-sched.c

778

sched->cpu_usage += task->cpu_usage;

tools/perf/builtin-sched.c

783

if (!sched->runavg_cpu_usage)

tools/perf/builtin-sched.c

784

sched->runavg_cpu_usage = sched->cpu_usage;

tools/perf/builtin-sched.c

785

sched->runavg_cpu_usage = (sched->runavg_cpu_usage * (sched->replay_repeat - 1) + sched->cpu_usage) / sched->replay_repeat;

tools/perf/builtin-sched.c

787

sched->parent_cpu_usage = cpu_usage_1 - cpu_usage_0;

tools/perf/builtin-sched.c

788

if (!sched->runavg_parent_cpu_usage)

tools/perf/builtin-sched.c

789

sched->runavg_parent_cpu_usage = sched->parent_cpu_usage;

tools/perf/builtin-sched.c

790

sched->runavg_parent_cpu_usage = (sched->runavg_parent_cpu_usage * (sched->replay_repeat - 1) +

tools/perf/builtin-sched.c

791

sched->parent_cpu_usage)/sched->replay_repeat;

tools/perf/builtin-sched.c

793

mutex_lock(&sched->start_work_mutex);

tools/perf/builtin-sched.c

795

for (i = 0; i < sched->nr_tasks; i++) {

tools/perf/builtin-sched.c

796

task = sched->tasks[i];

tools/perf/builtin-sched.c

801

static void run_one_test(struct perf_sched *sched)

tools/perf/builtin-sched.c

802

EXCLUSIVE_LOCKS_REQUIRED(sched->work_done_wait_mutex)

tools/perf/builtin-sched.c

803

EXCLUSIVE_LOCKS_REQUIRED(sched->start_work_mutex)

tools/perf/builtin-sched.c

808

wait_for_tasks(sched);

tools/perf/builtin-sched.c

812

sched->sum_runtime += delta;

tools/perf/builtin-sched.c

813

sched->nr_runs++;

tools/perf/builtin-sched.c

815

avg_delta = sched->sum_runtime / sched->nr_runs;

tools/perf/builtin-sched.c

820

sched->sum_fluct += fluct;

tools/perf/builtin-sched.c

821

if (!sched->run_avg)

tools/perf/builtin-sched.c

822

sched->run_avg = delta;

tools/perf/builtin-sched.c

823

sched->run_avg = (sched->run_avg * (sched->replay_repeat - 1) + delta) / sched->replay_repeat;

tools/perf/builtin-sched.c

825

printf("#%-3ld: %0.3f, ", sched->nr_runs, (double)delta / NSEC_PER_MSEC);

tools/perf/builtin-sched.c

827

printf("ravg: %0.2f, ", (double)sched->run_avg / NSEC_PER_MSEC);

tools/perf/builtin-sched.c

830

(double)sched->cpu_usage / NSEC_PER_MSEC, (double)sched->runavg_cpu_usage / NSEC_PER_MSEC);

tools/perf/builtin-sched.c

838

(double)sched->parent_cpu_usage / NSEC_PER_MSEC,

tools/perf/builtin-sched.c

839

(double)sched->runavg_parent_cpu_usage / NSEC_PER_MSEC);

tools/perf/builtin-sched.c

844

if (sched->nr_sleep_corrections)

tools/perf/builtin-sched.c

845

printf(" (%ld sleep corrections)\n", sched->nr_sleep_corrections);

tools/perf/builtin-sched.c

846

sched->nr_sleep_corrections = 0;

tools/perf/builtin-sched.c

849

static void test_calibrations(struct perf_sched *sched)

tools/perf/builtin-sched.c

854

burn_nsecs(sched, NSEC_PER_MSEC);

tools/perf/builtin-sched.c

867

replay_wakeup_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

881

waker = register_pid(sched, sample->tid, "<unknown>");

tools/perf/builtin-sched.c

882

wakee = register_pid(sched, pid, comm);

tools/perf/builtin-sched.c

886

add_sched_event_wakeup(sched, waker, sample->time, wakee);

tools/perf/builtin-sched.c

890

static int replay_switch_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

909

timestamp0 = sched->cpu_last_switched[cpu];

tools/perf/builtin-sched.c

923

prev = register_pid(sched, prev_pid, prev_comm);

tools/perf/builtin-sched.c

924

next = register_pid(sched, next_pid, next_comm);

tools/perf/builtin-sched.c

928

sched->cpu_last_switched[cpu] = timestamp;

tools/perf/builtin-sched.c

930

add_sched_event_run(sched, prev, timestamp, delta);

tools/perf/builtin-sched.c

931

add_sched_event_sleep(sched, prev, timestamp);

tools/perf/builtin-sched.c

936

static int replay_fork_event(struct perf_sched *sched,

tools/perf/builtin-sched.c

959

register_pid(sched, thread__tid(parent), thread__comm_str(parent));

tools/perf/builtin-sched.c

960

register_pid(sched, thread__tid(child), thread__comm_str(child));

tools/perf/builtin-trace.c

207

bool sched;

tools/perf/builtin-trace.c

4475

if (trace->sched &&

tools/perf/builtin-trace.c

4992

if (trace->sched)

tools/perf/builtin-trace.c

5053

if (trace->sched)

tools/perf/builtin-trace.c

5492

OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),

tools/perf/util/machine.c

3304

if (!machine->sched.text_start) {

tools/perf/util/machine.c

3310

machine->sched.text_start = 1;

tools/perf/util/machine.c

3314

machine->sched.text_start = map__unmap_ip(kmap, sym->start);

tools/perf/util/machine.c

3318

machine->sched.text_end = map__unmap_ip(kmap, sym->start);

tools/perf/util/machine.c

3339

if (machine->sched.text_start == 1)

tools/perf/util/machine.c

3343

if (machine->sched.text_start <= addr && addr < machine->sched.text_end)

tools/perf/util/machine.h

52

} sched, lock, traceiter, trace;

tools/testing/selftests/bpf/progs/xdp_features.c

240

unsigned int drops, int sched, struct xdp_cpumap_stats *xdp_stats)

tools/testing/selftests/x86/fsgsbase.c

599

for (int sched = 0; sched < 2; sched++) {

tools/testing/selftests/x86/fsgsbase.c

600

mov_0_gs(0, !!sched);

tools/testing/selftests/x86/fsgsbase.c

601

mov_0_gs(1, !!sched);

tools/testing/selftests/x86/fsgsbase.c

602

mov_0_gs(0x200000000, !!sched);