crypto/libressl/include/openssl/des.h

181

int DES_enc_read(int fd,void *buf,int len,DES_key_schedule *sched,

crypto/libressl/include/openssl/des.h

183

int DES_enc_write(int fd,const void *buf,int len,DES_key_schedule *sched,

sbin/usched/usched.c

122

if (strlen(sched) != 0) {

sbin/usched/usched.c

126

sched);

sbin/usched/usched.c

129

sched, strlen(sched));

sbin/usched/usched.c

134

pid, sched, (int)strlen(sched));

sbin/usched/usched.c

53

char *sched = NULL;

sbin/usched/usched.c

81

sched = strsep(&sched_cpustr, ":");

sbin/usched/usched.c

82

if (strcmp(sched, "default") == 0)

sbin/usched/usched.c

87

if (strlen(sched) == 0 && cpustr == NULL) {

sys/dev/drm/amd/amdgpu/amdgpu_cs.c

1032

ring = to_amdgpu_ring(entity->rq->sched);

sys/dev/drm/amd/amdgpu/amdgpu_cs.c

1048

ring = to_amdgpu_ring(parser->entity->rq->sched);

sys/dev/drm/amd/amdgpu/amdgpu_cs.c

1256

ring = to_amdgpu_ring(entity->rq->sched);

sys/dev/drm/amd/amdgpu/amdgpu_cs.c

824

struct amdgpu_ring *ring = to_amdgpu_ring(p->entity->rq->sched);

sys/dev/drm/amd/amdgpu/amdgpu_ctx.c

172

rqs[j] = &rings[j]->sched.sched_rq[priority];

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

866

if (!ring || !ring->sched.thread)

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

868

kthread_park(ring->sched.thread);

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

882

if (!ring || !ring->sched.thread)

sys/dev/drm/amd/amdgpu/amdgpu_debugfs.c

884

kthread_unpark(ring->sched.thread);

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3409

if (!ring || !ring->sched.thread)

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3412

kthread_park(ring->sched.thread);

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3414

if (job && job->base.sched != &ring->sched)

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3417

drm_sched_hw_job_reset(&ring->sched, job ? &job->base : NULL);

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3431

if (!ring || !ring->sched.thread)

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3438

if ((!job || job->base.sched == &ring->sched) && !r)

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3439

drm_sched_job_recovery(&ring->sched);

sys/dev/drm/amd/amdgpu/amdgpu_device.c

3441

kthread_unpark(ring->sched.thread);

sys/dev/drm/amd/amdgpu/amdgpu_fence.c

451

r = drm_sched_init(&ring->sched, &amdgpu_sched_ops,

sys/dev/drm/amd/amdgpu/amdgpu_fence.c

509

drm_sched_fini(&ring->sched);

sys/dev/drm/amd/amdgpu/amdgpu_job.c

112

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

152

ring = to_amdgpu_ring(entity->rq->sched);

sys/dev/drm/amd/amdgpu/amdgpu_job.c

163

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

176

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

208

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

33

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

38

s_job->sched->name);

sys/dev/drm/amd/amdgpu/amdgpu_job.c

43

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

sys/dev/drm/amd/amdgpu/amdgpu_job.c

68

(*job)->base.sched = &adev->rings[0]->sched;

sys/dev/drm/amd/amdgpu/amdgpu_job.c

99

struct amdgpu_ring *ring = to_amdgpu_ring(job->base.sched);

sys/dev/drm/amd/amdgpu/amdgpu_ring.h

179

struct drm_gpu_scheduler sched;

sys/dev/drm/amd/amdgpu/amdgpu_ring.h

47

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

sys/dev/drm/amd/amdgpu/amdgpu_sync.c

280

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

sys/dev/drm/amd/amdgpu/amdgpu_sync.c

73

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

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1974

rq = &ring->sched.sched_rq[DRM_SCHED_PRIORITY_KERNEL];

sys/dev/drm/amd/amdgpu/amdgpu_uvd.c

334

rq = &ring->sched.sched_rq[DRM_SCHED_PRIORITY_NORMAL];

sys/dev/drm/amd/amdgpu/amdgpu_vce.c

241

rq = &ring->sched.sched_rq[DRM_SCHED_PRIORITY_NORMAL];

sys/dev/drm/amd/amdgpu/amdgpu_vm.c

1547

ring = container_of(vm->entity.rq->sched, struct amdgpu_ring,

sys/dev/drm/amd/amdgpu/amdgpu_vm.c

1548

sched);

sys/dev/drm/amd/amdgpu/amdgpu_vm.c

1839

ring = container_of(vm->entity.rq->sched, struct amdgpu_ring, sched);

sys/dev/drm/amd/amdgpu/amdgpu_vm.c

841

ring = container_of(vm->entity.rq->sched, struct amdgpu_ring, sched);

sys/dev/drm/amd/amdgpu/cik_sdma.c

1387

struct drm_gpu_scheduler *sched;

sys/dev/drm/amd/amdgpu/cik_sdma.c

1392

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

sys/dev/drm/amd/amdgpu/cik_sdma.c

1394

&sched->sched_rq[DRM_SCHED_PRIORITY_KERNEL];

sys/dev/drm/amd/amdgpu/sdma_v2_4.c

1271

struct drm_gpu_scheduler *sched;

sys/dev/drm/amd/amdgpu/sdma_v2_4.c

1276

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

sys/dev/drm/amd/amdgpu/sdma_v2_4.c

1278

&sched->sched_rq[DRM_SCHED_PRIORITY_KERNEL];

sys/dev/drm/amd/amdgpu/sdma_v3_0.c

1710

struct drm_gpu_scheduler *sched;

sys/dev/drm/amd/amdgpu/sdma_v3_0.c

1715

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

sys/dev/drm/amd/amdgpu/sdma_v3_0.c

1717

&sched->sched_rq[DRM_SCHED_PRIORITY_KERNEL];

sys/dev/drm/amd/amdgpu/sdma_v4_0.c

1834

struct drm_gpu_scheduler *sched;

sys/dev/drm/amd/amdgpu/sdma_v4_0.c

1839

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

sys/dev/drm/amd/amdgpu/sdma_v4_0.c

1841

&sched->sched_rq[DRM_SCHED_PRIORITY_KERNEL];

sys/dev/drm/amd/amdgpu/uvd_v7_0.c

1275

struct amdgpu_ring *ring = to_amdgpu_ring(p->entity->rq->sched);

sys/dev/drm/i915/i915_gem_context.c

340

ctx->sched.priority = I915_PRIORITY_NORMAL;

sys/dev/drm/i915/i915_gem_context.c

507

ctx->sched.priority = prio;

sys/dev/drm/i915/i915_gem_context.c

882

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

sys/dev/drm/i915/i915_gem_context.c

955

ctx->sched.priority = priority;

sys/dev/drm/i915/i915_gem_context.h

161

struct i915_sched_attr sched;

sys/dev/drm/i915/i915_gpu_error.c

1309

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

sys/dev/drm/i915/i915_gpu_error.c

1404

e->sched_attr = ctx->sched;

sys/dev/drm/i915/i915_request.c

1097

__i915_sched_node_add_dependency(&request->sched,

sys/dev/drm/i915/i915_request.c

1098

&prev->sched,

sys/dev/drm/i915/i915_request.c

1131

engine->schedule(request, &request->gem_context->sched);

sys/dev/drm/i915/i915_request.c

467

i915_sched_node_fini(request->i915, &request->sched);

sys/dev/drm/i915/i915_request.c

783

i915_sched_node_init(&rq->sched);

sys/dev/drm/i915/i915_request.c

834

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

sys/dev/drm/i915/i915_request.c

835

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

sys/dev/drm/i915/i915_request.c

858

&to->sched,

sys/dev/drm/i915/i915_request.c

859

&from->sched);

sys/dev/drm/i915/i915_request.h

132

struct i915_sched_node sched;

sys/dev/drm/i915/i915_request.h

339

container_of(node, const struct i915_request, sched);

sys/dev/drm/i915/intel_engine_cs.c

1201

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

sys/dev/drm/i915/intel_engine_cs.c

1543

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

sys/dev/drm/i915/intel_guc_submission.c

705

return rq->sched.attr.priority;

sys/dev/drm/i915/intel_guc_submission.c

750

list_for_each_entry_safe(rq, rn, &p->requests, sched.link) {

sys/dev/drm/i915/intel_guc_submission.c

754

&rq->sched.link);

sys/dev/drm/i915/intel_guc_submission.c

763

INIT_LIST_HEAD(&rq->sched.link);

sys/dev/drm/i915/intel_lrc.c

1141

queue_request(engine, &request->sched, rq_prio(request));

sys/dev/drm/i915/intel_lrc.c

1144

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

sys/dev/drm/i915/intel_lrc.c

1153

return container_of(node, struct i915_request, sched);

sys/dev/drm/i915/intel_lrc.c

1190

if (prio <= READ_ONCE(request->sched.attr.priority))

sys/dev/drm/i915/intel_lrc.c

1196

stack.signaler = &request->sched;

sys/dev/drm/i915/intel_lrc.c

1244

if (request->sched.attr.priority == I915_PRIORITY_INVALID) {

sys/dev/drm/i915/intel_lrc.c

1245

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

sys/dev/drm/i915/intel_lrc.c

1246

request->sched.attr = *attr;

sys/dev/drm/i915/intel_lrc.c

182

return rq->sched.attr.priority;

sys/dev/drm/i915/intel_lrc.c

353

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

sys/dev/drm/i915/intel_lrc.c

694

list_for_each_entry_safe(rq, rn, &p->requests, sched.link) {

sys/dev/drm/i915/intel_lrc.c

715

&rq->sched.link);

sys/dev/drm/i915/intel_lrc.c

729

&rq->sched.link);

sys/dev/drm/i915/intel_lrc.c

742

INIT_LIST_HEAD(&rq->sched.link);

sys/dev/drm/i915/intel_lrc.c

886

list_for_each_entry_safe(rq, rn, &p->requests, sched.link) {

sys/dev/drm/i915/intel_lrc.c

887

INIT_LIST_HEAD(&rq->sched.link);

sys/dev/drm/include/drm/gpu_scheduler.h

113

struct drm_gpu_scheduler *sched;

sys/dev/drm/include/drm/gpu_scheduler.h

154

struct drm_gpu_scheduler *sched;

sys/dev/drm/include/drm/gpu_scheduler.h

191

struct drm_gpu_scheduler *sched;

sys/dev/drm/include/drm/gpu_scheduler.h

288

int drm_sched_init(struct drm_gpu_scheduler *sched,

sys/dev/drm/include/drm/gpu_scheduler.h

292

void drm_sched_fini(struct drm_gpu_scheduler *sched);

sys/dev/drm/include/drm/gpu_scheduler.h

296

void drm_sched_wakeup(struct drm_gpu_scheduler *sched);

sys/dev/drm/include/drm/gpu_scheduler.h

297

void drm_sched_hw_job_reset(struct drm_gpu_scheduler *sched,

sys/dev/drm/include/drm/gpu_scheduler.h

299

void drm_sched_job_recovery(struct drm_gpu_scheduler *sched);

sys/dev/drm/scheduler/sched_entity.c

133

num_jobs = atomic_read(&entity->rq_list[i]->sched->num_jobs);

sys/dev/drm/scheduler/sched_entity.c

157

struct drm_gpu_scheduler *sched;

sys/dev/drm/scheduler/sched_entity.c

163

sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_entity.c

171

sched->job_scheduled,

sys/dev/drm/scheduler/sched_entity.c

175

wait_event_interruptible(sched->job_scheduled,

sys/dev/drm/scheduler/sched_entity.c

212

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

sys/dev/drm/scheduler/sched_entity.c

265

struct drm_gpu_scheduler *sched;

sys/dev/drm/scheduler/sched_entity.c

267

sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_entity.c

277

kthread_park(sched->thread);

sys/dev/drm/scheduler/sched_entity.c

278

kthread_unpark(sched->thread);

sys/dev/drm/scheduler/sched_entity.c

333

drm_sched_wakeup(entity->rq->sched);

sys/dev/drm/scheduler/sched_entity.c

342

*rq = &(*rq)->sched->sched_rq[priority];

sys/dev/drm/scheduler/sched_entity.c

381

struct drm_gpu_scheduler *sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_entity.c

397

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

sys/dev/drm/scheduler/sched_entity.c

432

struct drm_gpu_scheduler *sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_entity.c

440

sched->ops->dependency(sched_job, entity))) {

sys/dev/drm/scheduler/sched_entity.c

506

atomic_inc(&entity->rq->sched->num_jobs);

sys/dev/drm/scheduler/sched_entity.c

524

drm_sched_wakeup(entity->rq->sched);

sys/dev/drm/scheduler/sched_fence.c

164

fence->sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_fence.c

81

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

sys/dev/drm/scheduler/sched_main.c

172

struct drm_gpu_scheduler *sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_main.c

180

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

sys/dev/drm/scheduler/sched_main.c

194

static void drm_sched_start_timeout(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

196

if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&

sys/dev/drm/scheduler/sched_main.c

197

!list_empty(&sched->ring_mirror_list))

sys/dev/drm/scheduler/sched_main.c

198

schedule_delayed_work(&sched->work_tdr, sched->timeout);

sys/dev/drm/scheduler/sched_main.c

207

struct drm_gpu_scheduler *sched = s_job->sched;

sys/dev/drm/scheduler/sched_main.c

216

cancel_delayed_work_sync(&sched->work_tdr);

sys/dev/drm/scheduler/sched_main.c

218

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

222

drm_sched_start_timeout(sched);

sys/dev/drm/scheduler/sched_main.c

223

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

226

sched->ops->free_job(s_job);

sys/dev/drm/scheduler/sched_main.c

239

struct drm_gpu_scheduler *sched = s_job->sched;

sys/dev/drm/scheduler/sched_main.c

244

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

245

list_add_tail(&s_job->node, &sched->ring_mirror_list);

sys/dev/drm/scheduler/sched_main.c

246

drm_sched_start_timeout(sched);

sys/dev/drm/scheduler/sched_main.c

247

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

252

struct drm_gpu_scheduler *sched;

sys/dev/drm/scheduler/sched_main.c

256

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

sys/dev/drm/scheduler/sched_main.c

258

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

259

list_for_each_entry_reverse(job, &sched->ring_mirror_list, node) {

sys/dev/drm/scheduler/sched_main.c

266

job = list_first_entry_or_null(&sched->ring_mirror_list,

sys/dev/drm/scheduler/sched_main.c

268

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

271

sched->ops->timedout_job(job);

sys/dev/drm/scheduler/sched_main.c

273

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

274

list_for_each_entry(job, &sched->ring_mirror_list, node) {

sys/dev/drm/scheduler/sched_main.c

288

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

298

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

sys/dev/drm/scheduler/sched_main.c

304

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

305

list_for_each_entry_reverse(s_job, &sched->ring_mirror_list, node) {

sys/dev/drm/scheduler/sched_main.c

311

atomic_dec(&sched->hw_rq_count);

sys/dev/drm/scheduler/sched_main.c

314

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

323

struct drm_sched_rq *rq = &sched->sched_rq[i];

sys/dev/drm/scheduler/sched_main.c

328

if (atomic_read(&bad->karma) > bad->sched->hang_limit)

sys/dev/drm/scheduler/sched_main.c

348

void drm_sched_job_recovery(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

354

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

355

list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) {

sys/dev/drm/scheduler/sched_main.c

360

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

sys/dev/drm/scheduler/sched_main.c

368

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

369

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

sys/dev/drm/scheduler/sched_main.c

370

atomic_inc(&sched->hw_rq_count);

sys/dev/drm/scheduler/sched_main.c

387

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

389

drm_sched_start_timeout(sched);

sys/dev/drm/scheduler/sched_main.c

390

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

410

struct drm_gpu_scheduler *sched;

sys/dev/drm/scheduler/sched_main.c

413

sched = entity->rq->sched;

sys/dev/drm/scheduler/sched_main.c

415

job->sched = sched;

sys/dev/drm/scheduler/sched_main.c

417

job->s_priority = entity->rq - sched->sched_rq;

sys/dev/drm/scheduler/sched_main.c

421

job->id = atomic64_inc_return(&sched->job_id_count);

sys/dev/drm/scheduler/sched_main.c

437

static bool drm_sched_ready(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

439

return atomic_read(&sched->hw_rq_count) <

sys/dev/drm/scheduler/sched_main.c

440

sched->hw_submission_limit;

sys/dev/drm/scheduler/sched_main.c

449

void drm_sched_wakeup(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

451

if (drm_sched_ready(sched))

sys/dev/drm/scheduler/sched_main.c

452

wake_up_interruptible(&sched->wake_up_worker);

sys/dev/drm/scheduler/sched_main.c

463

drm_sched_select_entity(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

468

if (!drm_sched_ready(sched))

sys/dev/drm/scheduler/sched_main.c

473

entity = drm_sched_rq_select_entity(&sched->sched_rq[i]);

sys/dev/drm/scheduler/sched_main.c

493

struct drm_gpu_scheduler *sched = s_fence->sched;

sys/dev/drm/scheduler/sched_main.c

496

atomic_dec(&sched->hw_rq_count);

sys/dev/drm/scheduler/sched_main.c

497

atomic_dec(&sched->num_jobs);

sys/dev/drm/scheduler/sched_main.c

502

wake_up_interruptible(&sched->wake_up_worker);

sys/dev/drm/scheduler/sched_main.c

512

static bool drm_sched_blocked(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

534

struct drm_gpu_scheduler *sched = (struct drm_gpu_scheduler *)param;

sys/dev/drm/scheduler/sched_main.c

547

wait_event_interruptible(sched->wake_up_worker,

sys/dev/drm/scheduler/sched_main.c

548

(!drm_sched_blocked(sched) &&

sys/dev/drm/scheduler/sched_main.c

549

(entity = drm_sched_select_entity(sched))) ||

sys/dev/drm/scheduler/sched_main.c

561

atomic_inc(&sched->hw_rq_count);

sys/dev/drm/scheduler/sched_main.c

564

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

sys/dev/drm/scheduler/sched_main.c

583

wake_up(&sched->job_scheduled);

sys/dev/drm/scheduler/sched_main.c

590

struct drm_gpu_scheduler *sched = s_job->sched;

sys/dev/drm/scheduler/sched_main.c

592

lockmgr(&sched->job_list_lock, LK_EXCLUSIVE);

sys/dev/drm/scheduler/sched_main.c

594

lockmgr(&sched->job_list_lock, LK_RELEASE);

sys/dev/drm/scheduler/sched_main.c

609

int drm_sched_init(struct drm_gpu_scheduler *sched,

sys/dev/drm/scheduler/sched_main.c

617

sched->ops = ops;

sys/dev/drm/scheduler/sched_main.c

618

sched->hw_submission_limit = hw_submission;

sys/dev/drm/scheduler/sched_main.c

619

sched->name = name;

sys/dev/drm/scheduler/sched_main.c

620

sched->timeout = timeout;

sys/dev/drm/scheduler/sched_main.c

621

sched->hang_limit = hang_limit;

sys/dev/drm/scheduler/sched_main.c

623

drm_sched_rq_init(sched, &sched->sched_rq[i]);

sys/dev/drm/scheduler/sched_main.c

625

init_waitqueue_head(&sched->wake_up_worker);

sys/dev/drm/scheduler/sched_main.c

626

init_waitqueue_head(&sched->job_scheduled);

sys/dev/drm/scheduler/sched_main.c

627

INIT_LIST_HEAD(&sched->ring_mirror_list);

sys/dev/drm/scheduler/sched_main.c

628

lockinit(&sched->job_list_lock, "gssjll", 0, LK_CANRECURSE);

sys/dev/drm/scheduler/sched_main.c

629

atomic_set(&sched->hw_rq_count, 0);

sys/dev/drm/scheduler/sched_main.c

630

INIT_DELAYED_WORK(&sched->work_tdr, drm_sched_job_timedout);

sys/dev/drm/scheduler/sched_main.c

631

atomic_set(&sched->num_jobs, 0);

sys/dev/drm/scheduler/sched_main.c

632

atomic64_set(&sched->job_id_count, 0);

sys/dev/drm/scheduler/sched_main.c

635

sched->thread = kthread_run(drm_sched_main, sched, sched->name);

sys/dev/drm/scheduler/sched_main.c

636

if (IS_ERR(sched->thread)) {

sys/dev/drm/scheduler/sched_main.c

638

return PTR_ERR(sched->thread);

sys/dev/drm/scheduler/sched_main.c

652

void drm_sched_fini(struct drm_gpu_scheduler *sched)

sys/dev/drm/scheduler/sched_main.c

654

if (sched->thread)

sys/dev/drm/scheduler/sched_main.c

655

kthread_stop(sched->thread);

sys/dev/drm/scheduler/sched_main.c

72

static void drm_sched_rq_init(struct drm_gpu_scheduler *sched,

sys/dev/drm/scheduler/sched_main.c

78

rq->sched = sched;

sys/dev/netif/ath/ath/if_ath_tx.c

2868

if (tid->sched)

sys/dev/netif/ath/ath/if_ath_tx.c

2871

tid->sched = 1;

sys/dev/netif/ath/ath/if_ath_tx.c

2913

if (tid->sched == 0)

sys/dev/netif/ath/ath/if_ath_tx.c

2916

tid->sched = 0;

sys/dev/netif/ath/ath/if_ath_tx.c

3257

atid->sched = 0;

sys/dev/netif/ath/ath/if_ath_tx.c

3953

tid->sched, tid->paused,

sys/dev/netif/ath/ath/if_ath_tx.c

3968

tid->sched, tid->paused,

sys/dev/netif/ath/ath/if_ath_tx.c

4101

tid->paused = tid->sched = tid->addba_tx_pending = 0;

sys/dev/netif/ath/ath/if_ath_tx.c

4143

tid->sched = 0;

sys/dev/netif/ath/ath/if_athvar.h

147

int sched;

sys/dev/netif/ath/ath_rate/sample/sample.c

1057

sn->sched = mrr_schedules[sc->sc_curmode];

sys/dev/netif/ath/ath_rate/sample/sample.c

1058

KASSERT(sn->sched != NULL,

sys/dev/netif/ath/ath_rate/sample/sample.c

640

*try0 = mrr ? sn->sched[rix].t0 : ATH_TXMAXTRY;

sys/dev/netif/ath/ath_rate/sample/sample.c

676

const struct txschedule *sched = &sn->sched[rix0];

sys/dev/netif/ath/ath_rate/sample/sample.c

678

KASSERT(rix0 == sched->r0, ("rix0 (%x) != sched->r0 (%x)!\n",

sys/dev/netif/ath/ath_rate/sample/sample.c

679

rix0, sched->r0));

sys/dev/netif/ath/ath_rate/sample/sample.c

683

rc[0].rix = sched->r0;

sys/dev/netif/ath/ath_rate/sample/sample.c

684

rc[1].rix = sched->r1;

sys/dev/netif/ath/ath_rate/sample/sample.c

685

rc[2].rix = sched->r2;

sys/dev/netif/ath/ath_rate/sample/sample.c

686

rc[3].rix = sched->r3;

sys/dev/netif/ath/ath_rate/sample/sample.c

688

rc[0].tries = sched->t0;

sys/dev/netif/ath/ath_rate/sample/sample.c

689

rc[1].tries = sched->t1;

sys/dev/netif/ath/ath_rate/sample/sample.c

690

rc[2].tries = sched->t2;

sys/dev/netif/ath/ath_rate/sample/sample.c

691

rc[3].tries = sched->t3;

sys/dev/netif/ath/ath_rate/sample/sample.c

699

const struct txschedule *sched = &sn->sched[rix];

sys/dev/netif/ath/ath_rate/sample/sample.c

704

rix1 = sched->r1;

sys/dev/netif/ath/ath_rate/sample/sample.c

707

rix2 = sched->r2;

sys/dev/netif/ath/ath_rate/sample/sample.c

710

rix3 = sched->r3;

sys/dev/netif/ath/ath_rate/sample/sample.c

714

s1code, sched->t1, /* series 1 */

sys/dev/netif/ath/ath_rate/sample/sample.c

715

s2code, sched->t2, /* series 2 */

sys/dev/netif/ath/ath_rate/sample/sample.c

716

s3code, sched->t3); /* series 3 */

sys/dev/netif/ath/ath_rate/sample/sample.h

95

const struct txschedule *sched; /* tx schedule table */

sys/dev/netif/iwn/if_iwn.c

1851

return iwn_dma_contig_alloc(sc, &sc->sched_dma, (void **)&sc->sched,

sys/dev/netif/iwn/if_iwn.c

4272

uint16_t *w = &sc->sched[qid * IWN4965_SCHED_COUNT + idx];

sys/dev/netif/iwn/if_iwn.c

4290

uint16_t *w = &sc->sched[qid * IWN5000_SCHED_COUNT + idx];

sys/dev/netif/iwn/if_iwn.c

4308

uint16_t *w = &sc->sched[qid * IWN5000_SCHED_COUNT + idx];

sys/dev/netif/iwn/if_iwnvar.h

281

uint16_t *sched;

sys/net/if.c

218

KTR_INFO(KTR_IF_START, if_start, sched, 1,

tools/regression/p1003_1b/main.c

19

{ "sched", sched, 1 },

tools/regression/p1003_1b/main.c

8

int sched(int argc, char *argv[]);

tools/regression/p1003_1b/sched.c

110

int sched;

tools/regression/p1003_1b/sched.c

235

sched = SCHED_FIFO;

tools/regression/p1003_1b/sched.c

237

q(__LINE__, sched_setscheduler(0, sched, &rt_param),

tools/regression/p1003_1b/sched.c

250

(void)sched_is(__LINE__, 0, sched);

tools/regression/p1003_1b/sched.c

256

q(__LINE__, sched_setscheduler(0, sched, &rt_param),

tools/regression/p1003_1b/sched.c

293

int main(int argc, char *argv[]) { return sched(argc, argv); }

tools/regression/p1003_1b/sched.c

60

checkpris(int sched)

tools/regression/p1003_1b/sched.c

67

if ( (smin = sched_get_priority_min(sched)) == -1 && errno)

tools/regression/p1003_1b/sched.c

70

if ( (smax = sched_get_priority_max(sched)) == -1 && errno)

tools/regression/p1003_1b/sched.c

75

sched_text(sched), smin, smax);

tools/regression/p1003_1b/sched.c

81

sched_text(sched), smin, smax);