bin/sh/eval.c

423

struct job *jp;

bin/sh/eval.c

564

struct job *jp;

bin/sh/eval.c

639

struct job *jp;

bin/sh/eval.c

824

struct job *jp;

bin/sh/eval.h

45

struct job *jp; /* job structure for command */

bin/sh/jobs.c

1008

vforkexecshell(struct job *jp, char **argv, char **envp, const char *path, int idx, int pip[2])

bin/sh/jobs.c

105

struct job *next; /* job used after this one */

bin/sh/jobs.c

1078

waitforjob(struct job *jp, int *signaled)

bin/sh/jobs.c

110

static struct job *jobtab; /* array of jobs */

bin/sh/jobs.c

113

static struct job *bgjob = NULL; /* last background process */

bin/sh/jobs.c

1142

dowait(int mode, struct job *job)

bin/sh/jobs.c

1149

struct job *jp;

bin/sh/jobs.c

115

static struct job *jobmru; /* most recently used job list */

bin/sh/jobs.c

1150

struct job *thisjob;

bin/sh/jobs.c

1159

TRACE(("dowait(%d, %p) called\n", mode, job));

bin/sh/jobs.c

1196

if (pid == -1 && errno == ECHILD && job != NULL)

bin/sh/jobs.c

1197

job->state = JOBDONE;

bin/sh/jobs.c

1237

if (jp != job) {

bin/sh/jobs.c

1253

else if ((!rootshell || !iflag || thisjob == job) &&

bin/sh/jobs.c

126

static void restartjob(struct job *);

bin/sh/jobs.c

1274

TRACE(("Not printing status, rootshell=%d, job=%p\n", rootshell, job));

bin/sh/jobs.c

128

static void freejob(struct job *);

bin/sh/jobs.c

129

static int waitcmdloop(struct job *);

bin/sh/jobs.c

1290

struct job *jp;

bin/sh/jobs.c

130

static struct job *getjob_nonotfound(const char *);

bin/sh/jobs.c

131

static struct job *getjob(const char *);

bin/sh/jobs.c

133

static pid_t dowait(int, struct job *);

bin/sh/jobs.c

138

static void setcurjob(struct job *);

bin/sh/jobs.c

139

static void deljob(struct job *);

bin/sh/jobs.c

140

static struct job *getcurjob(struct job *);

bin/sh/jobs.c

142

static int getjobstatus(const struct job *);

bin/sh/jobs.c

143

static void printjobcmd(struct job *);

bin/sh/jobs.c

144

static void showjob(struct job *, int);

bin/sh/jobs.c

245

struct job *jp;

bin/sh/jobs.c

270

struct job *jp;

bin/sh/jobs.c

289

restartjob(struct job *jp)

bin/sh/jobs.c

340

static int getjobstatus(const struct job *jp)

bin/sh/jobs.c

355

printjobcmd(struct job *jp)

bin/sh/jobs.c

369

showjob(struct job *jp, int mode)

bin/sh/jobs.c

375

struct job *j;

bin/sh/jobs.c

477

struct job *jp;

bin/sh/jobs.c

510

freejob(struct job *jp)

bin/sh/jobs.c

536

struct job *job;

bin/sh/jobs.c

544

job = getjob_nonotfound(*argptr);

bin/sh/jobs.c

545

if (job == NULL)

bin/sh/jobs.c

548

retval = waitcmdloop(job);

bin/sh/jobs.c

556

waitcmdloop(struct job *job)

bin/sh/jobs.c

559

struct job *jp;

bin/sh/jobs.c

567

if (job != NULL) {

bin/sh/jobs.c

568

if (job->state == JOBDONE) {

bin/sh/jobs.c

569

status = getjobstatus(job);

bin/sh/jobs.c

574

if (! iflag || ! job->changed)

bin/sh/jobs.c

575

freejob(job);

bin/sh/jobs.c

577

job->remembered = 0;

bin/sh/jobs.c

578

deljob(job);

bin/sh/jobs.c

579

if (job == bgjob)

bin/sh/jobs.c

605

} while (dowait(DOWAIT_BLOCK | DOWAIT_SIG, job) != -1);

bin/sh/jobs.c

617

struct job *jp;

bin/sh/jobs.c

635

static struct job *

bin/sh/jobs.c

639

struct job *found, *jp;

bin/sh/jobs.c

708

static struct job *

bin/sh/jobs.c

711

struct job *jp;

bin/sh/jobs.c

723

struct job *jp;

bin/sh/jobs.c

746

struct job *

bin/sh/jobs.c

750

struct job *jp;

bin/sh/jobs.c

815

setcurjob(struct job *cj)

bin/sh/jobs.c

817

struct job *jp, *prev;

bin/sh/jobs.c

835

deljob(struct job *j)

bin/sh/jobs.c

837

struct job *jp, *prev;

bin/sh/jobs.c

854

static struct job *

bin/sh/jobs.c

855

getcurjob(struct job *nj)

bin/sh/jobs.c

857

struct job *jp;

bin/sh/jobs.c

889

forkshell(struct job *jp, union node *n, int mode)

bin/sh/jobs.c

907

struct job *p;

bin/sh/jobs.h

42

struct job;

bin/sh/jobs.h

55

struct job *makejob(union node *, int);

bin/sh/jobs.h

56

pid_t forkshell(struct job *, union node *, int);

bin/sh/jobs.h

57

pid_t vforkexecshell(struct job *, char **, char **, const char *, int, int [2]);

bin/sh/jobs.h

58

int waitforjob(struct job *, int *);

bin/sh/redir.c

282

if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {

crypto/openssl/crypto/async/async.c

102

ASYNC_JOB *job;

crypto/openssl/crypto/async/async.c

116

job = sk_ASYNC_JOB_pop(pool->jobs);

crypto/openssl/crypto/async/async.c

117

if (job == NULL) {

crypto/openssl/crypto/async/async.c

122

job = async_job_new();

crypto/openssl/crypto/async/async.c

123

if (job != NULL) {

crypto/openssl/crypto/async/async.c

124

if (!async_fibre_makecontext(&job->fibrectx)) {

crypto/openssl/crypto/async/async.c

125

async_job_free(job);

crypto/openssl/crypto/async/async.c

131

return job;

crypto/openssl/crypto/async/async.c

134

static void async_release_job(ASYNC_JOB *job)

crypto/openssl/crypto/async/async.c

143

OPENSSL_free(job->funcargs);

crypto/openssl/crypto/async/async.c

144

job->funcargs = NULL;

crypto/openssl/crypto/async/async.c

145

sk_ASYNC_JOB_push(pool->jobs, job);

crypto/openssl/crypto/async/async.c

150

ASYNC_JOB *job;

crypto/openssl/crypto/async/async.c

159

job = ctx->currjob;

crypto/openssl/crypto/async/async.c

160

job->ret = job->func(job->funcargs);

crypto/openssl/crypto/async/async.c

163

job->status = ASYNC_JOB_STOPPING;

crypto/openssl/crypto/async/async.c

164

if (!async_fibre_swapcontext(&job->fibrectx,

crypto/openssl/crypto/async/async.c

175

int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *wctx, int *ret,

crypto/openssl/crypto/async/async.c

190

if (*job != NULL)

crypto/openssl/crypto/async/async.c

191

ctx->currjob = *job;

crypto/openssl/crypto/async/async.c

200

*job = NULL;

crypto/openssl/crypto/async/async.c

205

*job = ctx->currjob;

crypto/openssl/crypto/async/async.c

212

if (*job == NULL)

crypto/openssl/crypto/async/async.c

214

ctx->currjob = *job;

crypto/openssl/crypto/async/async.c

246

*job = NULL;

crypto/openssl/crypto/async/async.c

285

*job = NULL;

crypto/openssl/crypto/async/async.c

291

ASYNC_JOB *job;

crypto/openssl/crypto/async/async.c

304

job = ctx->currjob;

crypto/openssl/crypto/async/async.c

305

job->status = ASYNC_JOB_PAUSING;

crypto/openssl/crypto/async/async.c

307

if (!async_fibre_swapcontext(&job->fibrectx,

crypto/openssl/crypto/async/async.c

313

async_wait_ctx_reset_counts(job->waitctx);

crypto/openssl/crypto/async/async.c

320

ASYNC_JOB *job;

crypto/openssl/crypto/async/async.c

326

job = sk_ASYNC_JOB_pop(pool->jobs);

crypto/openssl/crypto/async/async.c

327

async_job_free(job);

crypto/openssl/crypto/async/async.c

328

} while (job);

crypto/openssl/crypto/async/async.c

382

ASYNC_JOB *job;

crypto/openssl/crypto/async/async.c

383

job = async_job_new();

crypto/openssl/crypto/async/async.c

384

if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {

crypto/openssl/crypto/async/async.c

389

async_job_free(job);

crypto/openssl/crypto/async/async.c

392

job->funcargs = NULL;

crypto/openssl/crypto/async/async.c

393

sk_ASYNC_JOB_push(pool->jobs, job); /* Cannot fail due to reserve */

crypto/openssl/crypto/async/async.c

446

ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job)

crypto/openssl/crypto/async/async.c

448

return job->waitctx;

crypto/openssl/crypto/async/async.c

80

ASYNC_JOB *job = NULL;

crypto/openssl/crypto/async/async.c

82

job = OPENSSL_zalloc(sizeof(*job));

crypto/openssl/crypto/async/async.c

83

if (job == NULL)

crypto/openssl/crypto/async/async.c

86

job->status = ASYNC_JOB_RUNNING;

crypto/openssl/crypto/async/async.c

88

return job;

crypto/openssl/crypto/async/async.c

91

static void async_job_free(ASYNC_JOB *job)

crypto/openssl/crypto/async/async.c

93

if (job != NULL) {

crypto/openssl/crypto/async/async.c

94

OPENSSL_free(job->funcargs);

crypto/openssl/crypto/async/async.c

95

async_fibre_free(&job->fibrectx);

crypto/openssl/crypto/async/async.c

96

OPENSSL_free(job);

crypto/openssl/engines/e_afalg.c

187

ASYNC_JOB *job;

crypto/openssl/engines/e_afalg.c

192

if ((job = ASYNC_get_current_job()) != NULL) {

crypto/openssl/engines/e_afalg.c

194

waitctx = ASYNC_get_wait_ctx(job);

crypto/openssl/engines/e_dasync.c

518

ASYNC_JOB *job;

crypto/openssl/engines/e_dasync.c

531

if ((job = ASYNC_get_current_job()) == NULL)

crypto/openssl/engines/e_dasync.c

534

waitctx = ASYNC_get_wait_ctx(job);

crypto/openssl/include/openssl/async.h

90

int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,

crypto/openssl/include/openssl/async.h

95

ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);

crypto/openssl/ssl/ssl_lib.c

2099

if (sc->job)

crypto/openssl/ssl/ssl_lib.c

2256

switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args,

crypto/openssl/ssl/ssl_lib.c

2269

sc->job = NULL;

crypto/openssl/ssl/ssl_lib.c

931

s->job = NULL;

crypto/openssl/ssl/ssl_local.h

1809

ASYNC_JOB *job;

crypto/openssl/test/asynctest.c

198

ASYNC_JOB *job = NULL;

crypto/openssl/test/asynctest.c

206

|| ASYNC_start_job(&job, waitctx, &funcret, add_two, NULL, 0)

crypto/openssl/test/asynctest.c

209

|| ASYNC_start_job(&job, waitctx, &funcret, add_two, NULL, 0)

crypto/openssl/test/asynctest.c

226

ASYNC_JOB *job = NULL;

crypto/openssl/test/asynctest.c

234

|| ASYNC_start_job(&job, waitctx, &funcret, save_current, NULL, 0)

crypto/openssl/test/asynctest.c

236

|| currjob != job

crypto/openssl/test/asynctest.c

237

|| ASYNC_start_job(&job, waitctx, &funcret, save_current, NULL, 0)

crypto/openssl/test/asynctest.c

253

ASYNC_JOB *job = NULL;

crypto/openssl/test/asynctest.c

262

|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)

crypto/openssl/test/asynctest.c

271

|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)

crypto/openssl/test/asynctest.c

286

|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)

crypto/openssl/test/asynctest.c

298

|| ASYNC_start_job(&job, waitctx, &funcret, waitfd, NULL, 0)

crypto/openssl/test/asynctest.c

320

ASYNC_JOB *job = NULL;

crypto/openssl/test/asynctest.c

326

|| ASYNC_start_job(&job, waitctx, &funcret, blockpause, NULL, 0)

crypto/openssl/test/asynctest.c

328

|| ASYNC_start_job(&job, waitctx, &funcret, blockpause, NULL, 0)

crypto/openssl/test/asynctest.c

344

ASYNC_JOB *job = NULL;

crypto/openssl/test/asynctest.c

360

|| ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx,

crypto/openssl/test/asynctest.c

377

if (ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx, NULL, 0)

crypto/openssl/test/asynctest.c

392

if (ASYNC_start_job(&job, waitctx, &funcret, change_deflt_libctx, NULL, 0)

crypto/openssl/test/asynctest.c

83

ASYNC_JOB *job;

crypto/openssl/test/asynctest.c

85

job = ASYNC_get_current_job();

crypto/openssl/test/asynctest.c

86

if (job == NULL)

crypto/openssl/test/asynctest.c

88

waitctx = ASYNC_get_wait_ctx(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2387

jobtotid(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_cpl_io.c

2393

so = job->fd_file->f_data;

sys/dev/cxgbe/tom/t4_cpl_io.c

2401

aiotx_free_job(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_cpl_io.c

2406

if (refcount_release(&job->aio_refs) == 0)

sys/dev/cxgbe/tom/t4_cpl_io.c

2409

error = (intptr_t)job->aio_error;

sys/dev/cxgbe/tom/t4_cpl_io.c

2410

status = job->aio_sent;

sys/dev/cxgbe/tom/t4_cpl_io.c

2413

jobtotid(job), job, status, error);

sys/dev/cxgbe/tom/t4_cpl_io.c

2418

aio_cancel(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2420

aio_complete(job, -1, error);

sys/dev/cxgbe/tom/t4_cpl_io.c

2422

job->msgsnd = 1;

sys/dev/cxgbe/tom/t4_cpl_io.c

2423

aio_complete(job, status, 0);

sys/dev/cxgbe/tom/t4_cpl_io.c

2430

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_cpl_io.c

2434

job = m->m_ext.ext_arg1;

sys/dev/cxgbe/tom/t4_cpl_io.c

2437

m->m_len, jobtotid(job));

sys/dev/cxgbe/tom/t4_cpl_io.c

2445

aiotx_free_job(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2453

alloc_aiotx_mbuf(struct kaiocb *job, int len)

sys/dev/cxgbe/tom/t4_cpl_io.c

2462

KASSERT(job->aio_sent + len <= job->uaiocb.aio_nbytes,

sys/dev/cxgbe/tom/t4_cpl_io.c

2464

job, len));

sys/dev/cxgbe/tom/t4_cpl_io.c

2471

vm = job->userproc->p_vmspace;

sys/dev/cxgbe/tom/t4_cpl_io.c

2473

start = (uintptr_t)job->uaiocb.aio_buf + job->aio_sent;

sys/dev/cxgbe/tom/t4_cpl_io.c

2506

m->m_ext.ext_arg1 = job;

sys/dev/cxgbe/tom/t4_cpl_io.c

2507

refcount_acquire(&job->aio_refs);

sys/dev/cxgbe/tom/t4_cpl_io.c

2511

__func__, jobtotid(job), m, job, npages);

sys/dev/cxgbe/tom/t4_cpl_io.c

2529

t4_aiotx_process_job(struct toepcb *toep, struct socket *so, struct kaiocb *job)

sys/dev/cxgbe/tom/t4_cpl_io.c

2544

error = mac_socket_check_send(job->fd_file->f_cred, so);

sys/dev/cxgbe/tom/t4_cpl_io.c

2560

PROC_LOCK(job->userproc);

sys/dev/cxgbe/tom/t4_cpl_io.c

2561

kern_psignal(job->userproc, SIGPIPE);

sys/dev/cxgbe/tom/t4_cpl_io.c

2562

PROC_UNLOCK(job->userproc);

sys/dev/cxgbe/tom/t4_cpl_io.c

2581

MPASS(job->aio_sent == 0 || !(so->so_state & SS_NBIO));

sys/dev/cxgbe/tom/t4_cpl_io.c

2587

if (!aio_set_cancel_function(job, t4_aiotx_cancel)) {

sys/dev/cxgbe/tom/t4_cpl_io.c

2593

TAILQ_INSERT_HEAD(&toep->aiotx_jobq, job, list);

sys/dev/cxgbe/tom/t4_cpl_io.c

2604

if (len > job->uaiocb.aio_nbytes - job->aio_sent) {

sys/dev/cxgbe/tom/t4_cpl_io.c

2605

len = job->uaiocb.aio_nbytes - job->aio_sent;

sys/dev/cxgbe/tom/t4_cpl_io.c

2620

m = alloc_aiotx_mbuf(job, len);

sys/dev/cxgbe/tom/t4_cpl_io.c

2639

job->aio_sent += sent;

sys/dev/cxgbe/tom/t4_cpl_io.c

2673

if (job->aio_sent < job->uaiocb.aio_nbytes &&

sys/dev/cxgbe/tom/t4_cpl_io.c

2676

if (!aio_set_cancel_function(job, t4_aiotx_cancel)) {

sys/dev/cxgbe/tom/t4_cpl_io.c

2681

TAILQ_INSERT_HEAD(&toep->aiotx_jobq, job, list);

sys/dev/cxgbe/tom/t4_cpl_io.c

2692

aiotx_free_job(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2697

job->aio_error = (void *)(intptr_t)error;

sys/dev/cxgbe/tom/t4_cpl_io.c

2698

aiotx_free_job(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2709

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_cpl_io.c

2717

job = TAILQ_FIRST(&toep->aiotx_jobq);

sys/dev/cxgbe/tom/t4_cpl_io.c

2718

TAILQ_REMOVE(&toep->aiotx_jobq, job, list);

sys/dev/cxgbe/tom/t4_cpl_io.c

2719

if (!aio_clear_cancel_function(job))

sys/dev/cxgbe/tom/t4_cpl_io.c

2722

t4_aiotx_process_job(toep, so, job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2751

t4_aiotx_cancel(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_cpl_io.c

2758

so = job->fd_file->f_data;

sys/dev/cxgbe/tom/t4_cpl_io.c

2761

MPASS(job->uaiocb.aio_lio_opcode == LIO_WRITE);

sys/dev/cxgbe/tom/t4_cpl_io.c

2765

if (!aio_cancel_cleared(job))

sys/dev/cxgbe/tom/t4_cpl_io.c

2766

TAILQ_REMOVE(&toep->aiotx_jobq, job, list);

sys/dev/cxgbe/tom/t4_cpl_io.c

2769

job->aio_error = (void *)(intptr_t)ECANCELED;

sys/dev/cxgbe/tom/t4_cpl_io.c

2770

aiotx_free_job(job);

sys/dev/cxgbe/tom/t4_cpl_io.c

2774

t4_aio_queue_aiotx(struct socket *so, struct kaiocb *job)

sys/dev/cxgbe/tom/t4_cpl_io.c

2781

if (job->uaiocb.aio_lio_opcode != LIO_WRITE)

sys/dev/cxgbe/tom/t4_cpl_io.c

2792

CTR3(KTR_CXGBE, "%s: queueing %p for tid %u", __func__, job, toep->tid);

sys/dev/cxgbe/tom/t4_cpl_io.c

2794

if (!aio_set_cancel_function(job, t4_aiotx_cancel))

sys/dev/cxgbe/tom/t4_cpl_io.c

2796

refcount_init(&job->aio_refs, 1);

sys/dev/cxgbe/tom/t4_cpl_io.c

2797

TAILQ_INSERT_TAIL(&toep->aiotx_jobq, job, list);

sys/dev/cxgbe/tom/t4_cpl_io.c

78

static void t4_aiotx_cancel(struct kaiocb *job);

sys/dev/cxgbe/tom/t4_ddp.c

1023

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

1050

MPASS(db->job != NULL);

sys/dev/cxgbe/tom/t4_ddp.c

1063

job = db->job;

sys/dev/cxgbe/tom/t4_ddp.c

1064

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

1066

CTR2(KTR_CXGBE, "%s: cancelling %p", __func__, job);

sys/dev/cxgbe/tom/t4_ddp.c

1067

aio_cancel(job);

sys/dev/cxgbe/tom/t4_ddp.c

1070

__func__, job, copied);

sys/dev/cxgbe/tom/t4_ddp.c

1071

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

1095

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

1137

job = db->job;

sys/dev/cxgbe/tom/t4_ddp.c

1138

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

1140

if (placed > job->uaiocb.aio_nbytes - copied)

sys/dev/cxgbe/tom/t4_ddp.c

1141

placed = job->uaiocb.aio_nbytes - copied;

sys/dev/cxgbe/tom/t4_ddp.c

1143

job->msgrcv = 1;

sys/dev/cxgbe/tom/t4_ddp.c

1147

if (!aio_clear_cancel_function(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

1153

job->aio_received += placed;

sys/dev/cxgbe/tom/t4_ddp.c

1157

aio_complete(job, copied + placed, 0);

sys/dev/cxgbe/tom/t4_ddp.c

164

ddp_complete_one(struct kaiocb *job, int error)

sys/dev/cxgbe/tom/t4_ddp.c

173

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

175

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

177

aio_complete(job, -1, error);

sys/dev/cxgbe/tom/t4_ddp.c

2177

hold_aio(struct toepcb *toep, struct kaiocb *job, struct pageset **pps)

sys/dev/cxgbe/tom/t4_ddp.c

2192

vm = job->userproc->p_vmspace;

sys/dev/cxgbe/tom/t4_ddp.c

2194

start = (uintptr_t)job->uaiocb.aio_buf;

sys/dev/cxgbe/tom/t4_ddp.c

2196

end = round_page(start + job->uaiocb.aio_nbytes);

sys/dev/cxgbe/tom/t4_ddp.c

2211

__func__, toep->tid, (unsigned long)job->uaiocb.aio_nbytes,

sys/dev/cxgbe/tom/t4_ddp.c

2213

job->uaiocb.aio_nbytes = end - (start + pgoff);

sys/dev/cxgbe/tom/t4_ddp.c

2225

job->uaiocb.aio_nbytes) == 0) {

sys/dev/cxgbe/tom/t4_ddp.c

2268

ps->len = job->uaiocb.aio_nbytes;

sys/dev/cxgbe/tom/t4_ddp.c

2274

__func__, toep->tid, ps, job, ps->npages);

sys/dev/cxgbe/tom/t4_ddp.c

2282

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

2287

job = TAILQ_FIRST(&toep->ddp.aiojobq);

sys/dev/cxgbe/tom/t4_ddp.c

2288

TAILQ_REMOVE(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

2290

if (aio_clear_cancel_function(job))

sys/dev/cxgbe/tom/t4_ddp.c

2291

ddp_complete_one(job, error);

sys/dev/cxgbe/tom/t4_ddp.c

2296

aio_ddp_cancel_one(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_ddp.c

2305

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2307

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

2309

aio_cancel(job);

sys/dev/cxgbe/tom/t4_ddp.c

2318

aio_ddp_requeue_one(struct toepcb *toep, struct kaiocb *job)

sys/dev/cxgbe/tom/t4_ddp.c

2323

aio_set_cancel_function(job, t4_aio_cancel_queued)) {

sys/dev/cxgbe/tom/t4_ddp.c

2324

TAILQ_INSERT_HEAD(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

2327

aio_ddp_cancel_one(job);

sys/dev/cxgbe/tom/t4_ddp.c

2337

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

2360

job = TAILQ_FIRST(&toep->ddp.aiojobq);

sys/dev/cxgbe/tom/t4_ddp.c

2361

so = job->fd_file->f_data;

sys/dev/cxgbe/tom/t4_ddp.c

2379

TAILQ_REMOVE(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

2380

if (!aio_clear_cancel_function(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

2390

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2393

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

2399

aio_complete(job, -1, error);

sys/dev/cxgbe/tom/t4_ddp.c

2449

TAILQ_REMOVE(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

2450

if (!aio_clear_cancel_function(job))

sys/dev/cxgbe/tom/t4_ddp.c

2452

toep->ddp.queueing = job;

sys/dev/cxgbe/tom/t4_ddp.c

2455

error = hold_aio(toep, job, &ps);

sys/dev/cxgbe/tom/t4_ddp.c

2457

ddp_complete_one(job, error);

sys/dev/cxgbe/tom/t4_ddp.c

2464

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2468

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

2477

aio_complete(job, -1, error);

sys/dev/cxgbe/tom/t4_ddp.c

2491

aio_ddp_requeue_one(toep, job);

sys/dev/cxgbe/tom/t4_ddp.c

2495

ddp_complete_one(job, 0);

sys/dev/cxgbe/tom/t4_ddp.c

2514

offset = ps->offset + job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2515

MPASS(job->aio_received <= job->uaiocb.aio_nbytes);

sys/dev/cxgbe/tom/t4_ddp.c

2516

resid = job->uaiocb.aio_nbytes - job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2550

job->aio_received += copied;

sys/dev/cxgbe/tom/t4_ddp.c

2551

job->msgrcv = 1;

sys/dev/cxgbe/tom/t4_ddp.c

2552

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

2584

aio_complete(job, copied, 0);

sys/dev/cxgbe/tom/t4_ddp.c

2597

aio_ddp_requeue_one(toep, job);

sys/dev/cxgbe/tom/t4_ddp.c

2614

aio_ddp_requeue_one(toep, job);

sys/dev/cxgbe/tom/t4_ddp.c

2626

if (toep->ddp.db[0].job == NULL) {

sys/dev/cxgbe/tom/t4_ddp.c

2629

MPASS(toep->ddp.db[1].job == NULL);

sys/dev/cxgbe/tom/t4_ddp.c

2669

job->aio_received, ps->len, ddp_flags, ddp_flags_mask);

sys/dev/cxgbe/tom/t4_ddp.c

2672

aio_ddp_requeue_one(toep, job);

sys/dev/cxgbe/tom/t4_ddp.c

2687

if (!aio_set_cancel_function(job, t4_aio_cancel_active)) {

sys/dev/cxgbe/tom/t4_ddp.c

2690

aio_ddp_cancel_one(job);

sys/dev/cxgbe/tom/t4_ddp.c

2698

toep->tid, job, db_idx, ddp_flags, ddp_flags_mask);

sys/dev/cxgbe/tom/t4_ddp.c

2704

db->job = job;

sys/dev/cxgbe/tom/t4_ddp.c

2744

t4_aio_cancel_active(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_ddp.c

2746

struct socket *so = job->fd_file->f_data;

sys/dev/cxgbe/tom/t4_ddp.c

275

if (db->job) {

sys/dev/cxgbe/tom/t4_ddp.c

2754

if (aio_cancel_cleared(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

2756

aio_ddp_cancel_one(job);

sys/dev/cxgbe/tom/t4_ddp.c

2761

if (toep->ddp.db[i].job == job) {

sys/dev/cxgbe/tom/t4_ddp.c

2777

__func__, job);

sys/dev/cxgbe/tom/t4_ddp.c

2785

t4_aio_cancel_queued(struct kaiocb *job)

sys/dev/cxgbe/tom/t4_ddp.c

2787

struct socket *so = job->fd_file->f_data;

sys/dev/cxgbe/tom/t4_ddp.c

2792

if (!aio_cancel_cleared(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

2793

TAILQ_REMOVE(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

2798

CTR2(KTR_CXGBE, "%s: request %p cancelled", __func__, job);

sys/dev/cxgbe/tom/t4_ddp.c

2801

aio_ddp_cancel_one(job);

sys/dev/cxgbe/tom/t4_ddp.c

2805

t4_aio_queue_ddp(struct socket *so, struct kaiocb *job)

sys/dev/cxgbe/tom/t4_ddp.c

2812

if (job->uaiocb.aio_lio_opcode != LIO_READ)

sys/dev/cxgbe/tom/t4_ddp.c

282

if (!aio_clear_cancel_function(db->job))

sys/dev/cxgbe/tom/t4_ddp.c

283

ddp_complete_one(db->job, 0);

sys/dev/cxgbe/tom/t4_ddp.c

285

db->job = NULL;

sys/dev/cxgbe/tom/t4_ddp.c

2850

CTR3(KTR_CXGBE, "%s: queueing %p for tid %u", __func__, job, toep->tid);

sys/dev/cxgbe/tom/t4_ddp.c

2852

if (!aio_set_cancel_function(job, t4_aio_cancel_queued))

sys/dev/cxgbe/tom/t4_ddp.c

2854

TAILQ_INSERT_TAIL(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

356

MPASS(toep->ddp.db[i].job == NULL);

sys/dev/cxgbe/tom/t4_ddp.c

381

KASSERT(toep->ddp.db[db_idx ^ 1].job == NULL,

sys/dev/cxgbe/tom/t4_ddp.c

401

db->job = NULL;

sys/dev/cxgbe/tom/t4_ddp.c

467

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

505

job = db->job;

sys/dev/cxgbe/tom/t4_ddp.c

506

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

508

if (placed > job->uaiocb.aio_nbytes - copied)

sys/dev/cxgbe/tom/t4_ddp.c

509

placed = job->uaiocb.aio_nbytes - copied;

sys/dev/cxgbe/tom/t4_ddp.c

511

job->msgrcv = 1;

sys/dev/cxgbe/tom/t4_ddp.c

515

if (!aio_clear_cancel_function(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

521

job->aio_received += placed;

sys/dev/cxgbe/tom/t4_ddp.c

525

__func__, job, copied, placed);

sys/dev/cxgbe/tom/t4_ddp.c

527

aio_complete(job, copied + placed, 0);

sys/dev/cxgbe/tom/t4_ddp.c

528

} else if (aio_set_cancel_function(job, t4_aio_cancel_queued)) {

sys/dev/cxgbe/tom/t4_ddp.c

529

TAILQ_INSERT_HEAD(&toep->ddp.aiojobq, job, list);

sys/dev/cxgbe/tom/t4_ddp.c

532

aio_cancel(job);

sys/dev/cxgbe/tom/t4_ddp.c

648

struct kaiocb *job;

sys/dev/cxgbe/tom/t4_ddp.c

665

job = db->job;

sys/dev/cxgbe/tom/t4_ddp.c

674

if (aio_clear_cancel_function(job))

sys/dev/cxgbe/tom/t4_ddp.c

675

ddp_complete_one(job, ECONNRESET);

sys/dev/cxgbe/tom/t4_ddp.c

724

job->msgrcv = 1;

sys/dev/cxgbe/tom/t4_ddp.c

732

job->aio_received += len;

sys/dev/cxgbe/tom/t4_ddp.c

734

} else if (!aio_clear_cancel_function(job)) {

sys/dev/cxgbe/tom/t4_ddp.c

739

job->aio_received += len;

sys/dev/cxgbe/tom/t4_ddp.c

741

copied = job->aio_received;

sys/dev/cxgbe/tom/t4_ddp.c

745

__func__, toep->tid, job, copied, len);

sys/dev/cxgbe/tom/t4_ddp.c

747

aio_complete(job, copied + len, 0);

sys/dev/cxgbe/tom/t4_ddp.c

82

static void t4_aio_cancel_active(struct kaiocb *job);

sys/dev/cxgbe/tom/t4_ddp.c

83

static void t4_aio_cancel_queued(struct kaiocb *job);

sys/dev/cxgbe/tom/t4_tom.c

2243

t4_aio_queue_tom(struct socket *so, struct kaiocb *job)

sys/dev/cxgbe/tom/t4_tom.c

2258

error = t4_aio_queue_ddp(so, job);

sys/dev/cxgbe/tom/t4_tom.c

2262

return (soaio_queue_generic(so, job));

sys/dev/cxgbe/tom/t4_tom.c

2265

if (t4_aio_queue_aiotx(so, job) != 0)

sys/dev/cxgbe/tom/t4_tom.c

2266

return (soaio_queue_generic(so, job));

sys/dev/cxgbe/tom/t4_tom.h

180

struct kaiocb *job;

sys/kern/sys_socket.c

619

soaio_process_job(struct socket *so, sb_which which, struct kaiocb *job)

sys/kern/sys_socket.c

625

struct file *fp = job->fd_file;

sys/kern/sys_socket.c

632

aio_switch_vmspace(job);

sys/kern/sys_socket.c

636

td->td_ucred = job->cred;

sys/kern/sys_socket.c

638

job_total_nbytes = job->uiop->uio_resid + job->aio_done;

sys/kern/sys_socket.c

639

done = job->aio_done;

sys/kern/sys_socket.c

640

cnt = job->uiop->uio_resid;

sys/kern/sys_socket.c

641

job->uiop->uio_offset = 0;

sys/kern/sys_socket.c

642

job->uiop->uio_td = td;

sys/kern/sys_socket.c

658

error = soreceive(so, NULL, job->uiop, NULL, NULL,

sys/kern/sys_socket.c

661

job->msgrcv = 1;

sys/kern/sys_socket.c

670

error = sousrsend(so, NULL, job->uiop, NULL, flags,

sys/kern/sys_socket.c

671

job->userproc);

sys/kern/sys_socket.c

673

job->msgsnd = 1;

sys/kern/sys_socket.c

676

done += cnt - job->uiop->uio_resid;

sys/kern/sys_socket.c

677

job->aio_done = done;

sys/kern/sys_socket.c

700

if (!aio_set_cancel_function(job, soo_aio_cancel)) {

sys/kern/sys_socket.c

703

aio_complete(job, done, 0);

sys/kern/sys_socket.c

705

aio_cancel(job);

sys/kern/sys_socket.c

708

TAILQ_INSERT_HEAD(&sb->sb_aiojobq, job, list);

sys/kern/sys_socket.c

718

aio_complete(job, -1, error);

sys/kern/sys_socket.c

720

aio_complete(job, done, 0);

sys/kern/sys_socket.c

727

struct kaiocb *job;

sys/kern/sys_socket.c

733

job = TAILQ_FIRST(&sb->sb_aiojobq);

sys/kern/sys_socket.c

734

TAILQ_REMOVE(&sb->sb_aiojobq, job, list);

sys/kern/sys_socket.c

735

if (!aio_clear_cancel_function(job))

sys/kern/sys_socket.c

738

soaio_process_job(so, which, job);

sys/kern/sys_socket.c

789

soo_aio_cancel(struct kaiocb *job)

sys/kern/sys_socket.c

797

so = job->fd_file->f_data;

sys/kern/sys_socket.c

798

opcode = job->uaiocb.aio_lio_opcode;

sys/kern/sys_socket.c

809

if (!aio_cancel_cleared(job))

sys/kern/sys_socket.c

810

TAILQ_REMOVE(&sb->sb_aiojobq, job, list);

sys/kern/sys_socket.c

815

done = job->aio_done;

sys/kern/sys_socket.c

817

aio_complete(job, done, 0);

sys/kern/sys_socket.c

819

aio_cancel(job);

sys/kern/sys_socket.c

823

soo_aio_queue(struct file *fp, struct kaiocb *job)

sys/kern/sys_socket.c

827

return (so->so_proto->pr_aio_queue(so, job));

sys/kern/sys_socket.c

831

soaio_queue_generic(struct socket *so, struct kaiocb *job)

sys/kern/sys_socket.c

837

switch (job->uaiocb.aio_lio_opcode & (LIO_WRITE | LIO_READ)) {

sys/kern/sys_socket.c

857

if (!aio_set_cancel_function(job, soo_aio_cancel))

sys/kern/sys_socket.c

859

TAILQ_INSERT_TAIL(&sb->sb_aiojobq, job, list);

sys/kern/sys_socket.c

98

static void soo_aio_cancel(struct kaiocb *job);

sys/kern/vfs_aio.c

1003

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

1005

ret = aio_clear_cancel_function_locked(job);

sys/kern/vfs_aio.c

1011

aio_set_cancel_function_locked(struct kaiocb *job, aio_cancel_fn_t *func)

sys/kern/vfs_aio.c

1014

AIO_LOCK_ASSERT(job->userproc->p_aioinfo, MA_OWNED);

sys/kern/vfs_aio.c

1015

if (job->jobflags & KAIOCB_CANCELLED)

sys/kern/vfs_aio.c

1017

job->cancel_fn = func;

sys/kern/vfs_aio.c

1022

aio_set_cancel_function(struct kaiocb *job, aio_cancel_fn_t *func)

sys/kern/vfs_aio.c

1027

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

1029

ret = aio_set_cancel_function_locked(job, func);

sys/kern/vfs_aio.c

1035

aio_complete(struct kaiocb *job, long status, int error)

sys/kern/vfs_aio.c

1040

job->uaiocb._aiocb_private.error = error;

sys/kern/vfs_aio.c

1041

job->uaiocb._aiocb_private.status = status;

sys/kern/vfs_aio.c

1043

userp = job->userproc;

sys/kern/vfs_aio.c

1047

KASSERT(!(job->jobflags & KAIOCB_FINISHED),

sys/kern/vfs_aio.c

1049

job->jobflags |= KAIOCB_FINISHED;

sys/kern/vfs_aio.c

1050

if ((job->jobflags & (KAIOCB_QUEUEING | KAIOCB_CANCELLING)) == 0) {

sys/kern/vfs_aio.c

1051

TAILQ_REMOVE(&ki->kaio_jobqueue, job, plist);

sys/kern/vfs_aio.c

1052

aio_bio_done_notify(userp, job);

sys/kern/vfs_aio.c

1058

aio_cancel(struct kaiocb *job)

sys/kern/vfs_aio.c

1061

aio_complete(job, -1, ECANCELED);

sys/kern/vfs_aio.c

1065

aio_switch_vmspace(struct kaiocb *job)

sys/kern/vfs_aio.c

1068

vmspace_switch_aio(job->userproc->p_vmspace);

sys/kern/vfs_aio.c

1078

struct kaiocb *job;

sys/kern/vfs_aio.c

1123

while ((job = aio_selectjob(aiop)) != NULL) {

sys/kern/vfs_aio.c

1126

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

1127

job->handle_fn(job);

sys/kern/vfs_aio.c

1218

aio_qbio(struct proc *p, struct kaiocb *job)

sys/kern/vfs_aio.c

1233

cb = &job->uaiocb;

sys/kern/vfs_aio.c

1234

fp = job->fd_file;

sys/kern/vfs_aio.c

1250

iovcnt = job->uiop->uio_iovcnt;

sys/kern/vfs_aio.c

1254

if (job->uiop->uio_iov[i].iov_len % vp->v_bufobj.bo_bsize != 0)

sys/kern/vfs_aio.c

1256

if (job->uiop->uio_iov[i].iov_len > maxphys) {

sys/kern/vfs_aio.c

1272

if (job->uiop->uio_resid > dev->si_iosize_max) {

sys/kern/vfs_aio.c

1278

job->error = 0;

sys/kern/vfs_aio.c

1293

refcount_init(&job->nbio, iovcnt);

sys/kern/vfs_aio.c

1301

buf = job->uiop->uio_iov[i].iov_base;

sys/kern/vfs_aio.c

1302

nbytes = job->uiop->uio_iov[i].iov_len;

sys/kern/vfs_aio.c

1324

bp->bio_caller1 = job;

sys/kern/vfs_aio.c

1507

struct kaiocb *job;

sys/kern/vfs_aio.c

1532

job = uma_zalloc(aiocb_zone, M_WAITOK | M_ZERO);

sys/kern/vfs_aio.c

1533

knlist_init_mtx(&job->klist, AIO_MTX(ki));

sys/kern/vfs_aio.c

1535

error = ops->aio_copyin(ujob, job, type);

sys/kern/vfs_aio.c

1539

if (job->uaiocb.aio_nbytes > IOSIZE_MAX) {

sys/kern/vfs_aio.c

1544

if (job->uaiocb.aio_sigevent.sigev_notify != SIGEV_KEVENT &&

sys/kern/vfs_aio.c

1545

job->uaiocb.aio_sigevent.sigev_notify != SIGEV_SIGNAL &&

sys/kern/vfs_aio.c

1546

job->uaiocb.aio_sigevent.sigev_notify != SIGEV_THREAD_ID &&

sys/kern/vfs_aio.c

1547

job->uaiocb.aio_sigevent.sigev_notify != SIGEV_NONE) {

sys/kern/vfs_aio.c

1552

if ((job->uaiocb.aio_sigevent.sigev_notify == SIGEV_SIGNAL ||

sys/kern/vfs_aio.c

1553

job->uaiocb.aio_sigevent.sigev_notify == SIGEV_THREAD_ID) &&

sys/kern/vfs_aio.c

1554

!_SIG_VALID(job->uaiocb.aio_sigevent.sigev_signo)) {

sys/kern/vfs_aio.c

1561

switch (job->uaiocb.aio_lio_opcode & ~LIO_FOFFSET) {

sys/kern/vfs_aio.c

1567

opcode = job->uaiocb.aio_lio_opcode & ~LIO_FOFFSET;

sys/kern/vfs_aio.c

1568

if ((job->uaiocb.aio_lio_opcode & LIO_FOFFSET) != 0)

sys/kern/vfs_aio.c

1569

job->ioflags |= KAIOCB_IO_FOFFSET;

sys/kern/vfs_aio.c

1576

opcode = job->uaiocb.aio_lio_opcode = type;

sys/kern/vfs_aio.c

1578

ksiginfo_init(&job->ksi);

sys/kern/vfs_aio.c

1581

job->ujob = ujob;

sys/kern/vfs_aio.c

1591

fd = job->uaiocb.aio_fildes;

sys/kern/vfs_aio.c

1623

job->uaiocb.aio_offset < 0 &&

sys/kern/vfs_aio.c

1634

job->fd_file = fp;

sys/kern/vfs_aio.c

1637

job->seqno = jobseqno++;

sys/kern/vfs_aio.c

1641

MPASS(job->uiop == &job->uio || job->uiop == NULL);

sys/kern/vfs_aio.c

1642

uma_zfree(aiocb_zone, job);

sys/kern/vfs_aio.c

1646

if (job->uaiocb.aio_sigevent.sigev_notify != SIGEV_KEVENT)

sys/kern/vfs_aio.c

1648

evflags = job->uaiocb.aio_sigevent.sigev_notify_kevent_flags;

sys/kern/vfs_aio.c

1653

kqfd = job->uaiocb.aio_sigevent.sigev_notify_kqueue;

sys/kern/vfs_aio.c

1655

kev.ident = (uintptr_t)job->ujob;

sys/kern/vfs_aio.c

1658

kev.data = (intptr_t)job;

sys/kern/vfs_aio.c

1659

kev.udata = job->uaiocb.aio_sigevent.sigev_value.sival_ptr;

sys/kern/vfs_aio.c

1667

job->uaiocb._aiocb_private.error = EINPROGRESS;

sys/kern/vfs_aio.c

1668

job->userproc = p;

sys/kern/vfs_aio.c

1669

job->cred = crhold(td->td_ucred);

sys/kern/vfs_aio.c

1670

job->jobflags = KAIOCB_QUEUEING;

sys/kern/vfs_aio.c

1671

job->lio = lj;

sys/kern/vfs_aio.c

1675

MPASS(job->uiop != &job->uio && job->uiop != NULL);

sys/kern/vfs_aio.c

1678

job->iov[0].iov_base = (void *)(uintptr_t)job->uaiocb.aio_buf;

sys/kern/vfs_aio.c

1679

job->iov[0].iov_len = job->uaiocb.aio_nbytes;

sys/kern/vfs_aio.c

1680

job->uio.uio_iov = job->iov;

sys/kern/vfs_aio.c

1681

job->uio.uio_iovcnt = 1;

sys/kern/vfs_aio.c

1682

job->uio.uio_resid = job->uaiocb.aio_nbytes;

sys/kern/vfs_aio.c

1683

job->uio.uio_segflg = UIO_USERSPACE;

sys/kern/vfs_aio.c

1684

job->uiop = &job->uio;

sys/kern/vfs_aio.c

1688

job->uiop->uio_rw = UIO_READ;

sys/kern/vfs_aio.c

1691

job->uiop->uio_rw = UIO_WRITE;

sys/kern/vfs_aio.c

1694

job->uiop->uio_offset = job->uaiocb.aio_offset;

sys/kern/vfs_aio.c

1695

job->uiop->uio_td = td;

sys/kern/vfs_aio.c

1698

aio_schedule(job, aio_process_mlock);

sys/kern/vfs_aio.c

1701

error = aio_queue_file(fp, job);

sys/kern/vfs_aio.c

1703

error = fo_aio_queue(fp, job);

sys/kern/vfs_aio.c

1708

job->jobflags &= ~KAIOCB_QUEUEING;

sys/kern/vfs_aio.c

1709

TAILQ_INSERT_TAIL(&ki->kaio_all, job, allist);

sys/kern/vfs_aio.c

1714

if (job->jobflags & KAIOCB_FINISHED) {

sys/kern/vfs_aio.c

1720

aio_bio_done_notify(p, job);

sys/kern/vfs_aio.c

1722

TAILQ_INSERT_TAIL(&ki->kaio_jobqueue, job, plist);

sys/kern/vfs_aio.c

1727

crfree(job->cred);

sys/kern/vfs_aio.c

1731

knlist_delete(&job->klist, curthread, 0);

sys/kern/vfs_aio.c

1733

if (job->uiop != &job->uio)

sys/kern/vfs_aio.c

1734

freeuio(job->uiop);

sys/kern/vfs_aio.c

1735

uma_zfree(aiocb_zone, job);

sys/kern/vfs_aio.c

1742

aio_cancel_daemon_job(struct kaiocb *job)

sys/kern/vfs_aio.c

1746

if (!aio_cancel_cleared(job))

sys/kern/vfs_aio.c

1747

TAILQ_REMOVE(&aio_jobs, job, list);

sys/kern/vfs_aio.c

1749

aio_cancel(job);

sys/kern/vfs_aio.c

1753

aio_schedule(struct kaiocb *job, aio_handle_fn_t *func)

sys/kern/vfs_aio.c

1757

if (!aio_set_cancel_function(job, aio_cancel_daemon_job)) {

sys/kern/vfs_aio.c

1759

aio_cancel(job);

sys/kern/vfs_aio.c

1762

job->handle_fn = func;

sys/kern/vfs_aio.c

1763

TAILQ_INSERT_TAIL(&aio_jobs, job, list);

sys/kern/vfs_aio.c

1764

aio_kick_nowait(job->userproc);

sys/kern/vfs_aio.c

1769

aio_cancel_sync(struct kaiocb *job)

sys/kern/vfs_aio.c

1773

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

1775

if (!aio_cancel_cleared(job))

sys/kern/vfs_aio.c

1776

TAILQ_REMOVE(&ki->kaio_syncqueue, job, list);

sys/kern/vfs_aio.c

1778

aio_cancel(job);

sys/kern/vfs_aio.c

1782

aio_queue_file(struct file *fp, struct kaiocb *job)

sys/kern/vfs_aio.c

1791

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

1792

error = aio_qbio(job->userproc, job);

sys/kern/vfs_aio.c

1810

if (job->uaiocb.aio_lio_opcode & (LIO_WRITE | LIO_READ)) {

sys/kern/vfs_aio.c

1811

aio_schedule(job, aio_process_rw);

sys/kern/vfs_aio.c

1813

} else if (job->uaiocb.aio_lio_opcode & LIO_SYNC) {

sys/kern/vfs_aio.c

1818

if (job2->fd_file == job->fd_file &&

sys/kern/vfs_aio.c

1820

job2->seqno < job->seqno) {

sys/kern/vfs_aio.c

1822

job->pending++;

sys/kern/vfs_aio.c

1825

if (job->pending != 0) {

sys/kern/vfs_aio.c

1826

if (!aio_set_cancel_function_locked(job,

sys/kern/vfs_aio.c

1829

aio_cancel(job);

sys/kern/vfs_aio.c

1832

TAILQ_INSERT_TAIL(&ki->kaio_syncqueue, job, list);

sys/kern/vfs_aio.c

1837

aio_schedule(job, aio_process_sync);

sys/kern/vfs_aio.c

1912

struct kaiocb *job;

sys/kern/vfs_aio.c

1920

TAILQ_FOREACH(job, &ki->kaio_done, plist) {

sys/kern/vfs_aio.c

1921

if (job->ujob == ujob)

sys/kern/vfs_aio.c

1924

if (job != NULL) {

sys/kern/vfs_aio.c

1925

MPASS(job->jobflags & KAIOCB_FINISHED);

sys/kern/vfs_aio.c

1926

status = job->uaiocb._aiocb_private.status;

sys/kern/vfs_aio.c

1927

error = job->uaiocb._aiocb_private.error;

sys/kern/vfs_aio.c

1929

td->td_ru.ru_oublock += job->outblock;

sys/kern/vfs_aio.c

1930

td->td_ru.ru_inblock += job->inblock;

sys/kern/vfs_aio.c

1931

td->td_ru.ru_msgsnd += job->msgsnd;

sys/kern/vfs_aio.c

1932

td->td_ru.ru_msgrcv += job->msgrcv;

sys/kern/vfs_aio.c

1933

aio_free_entry(job);

sys/kern/vfs_aio.c

1961

struct kaiocb *firstjob, *job;

sys/kern/vfs_aio.c

1986

TAILQ_FOREACH(job, &ki->kaio_all, allist) {

sys/kern/vfs_aio.c

1988

if (job->ujob == ujoblist[i]) {

sys/kern/vfs_aio.c

1990

firstjob = job;

sys/kern/vfs_aio.c

1991

if (job->jobflags & KAIOCB_FINISHED)

sys/kern/vfs_aio.c

2047

struct kaiocb *job, *jobn, marker;

sys/kern/vfs_aio.c

2083

TAILQ_FOREACH_SAFE(job, &ki->kaio_jobqueue, plist, jobn) {

sys/kern/vfs_aio.c

2084

if (uap->fd == job->uaiocb.aio_fildes &&

sys/kern/vfs_aio.c

2085

(uap->aiocbp == NULL || uap->aiocbp == job->ujob) &&

sys/kern/vfs_aio.c

2086

(job->jobflags & KAIOCB_MARKER) == 0) {

sys/kern/vfs_aio.c

2087

TAILQ_INSERT_AFTER(&ki->kaio_jobqueue, job, &marker,

sys/kern/vfs_aio.c

2089

if (aio_cancel_job(p, ki, job)) {

sys/kern/vfs_aio.c

2136

struct kaiocb *job;

sys/kern/vfs_aio.c

2147

TAILQ_FOREACH(job, &ki->kaio_all, allist) {

sys/kern/vfs_aio.c

2148

if (job->ujob == ujob) {

sys/kern/vfs_aio.c

2149

if (job->jobflags & KAIOCB_FINISHED)

sys/kern/vfs_aio.c

2151

job->uaiocb._aiocb_private.error;

sys/kern/vfs_aio.c

2243

struct aiocb *job;

sys/kern/vfs_aio.c

2326

job = acb_list[i];

sys/kern/vfs_aio.c

2327

if (job != NULL) {

sys/kern/vfs_aio.c

2328

error = aio_aqueue(td, job, lj, LIO_NOP, ops);

sys/kern/vfs_aio.c

2458

struct kaiocb *job = (struct kaiocb *)bp->bio_caller1;

sys/kern/vfs_aio.c

2469

ki = job->userproc->p_aioinfo;

sys/kern/vfs_aio.c

2485

struct kaiocb *job = (struct kaiocb *)bp->bio_caller1;

sys/kern/vfs_aio.c

2493

opcode = job->uaiocb.aio_lio_opcode;

sys/kern/vfs_aio.c

2498

atomic_add_acq_long(&job->nbytes, nbytes);

sys/kern/vfs_aio.c

2506

atomic_store_int(&job->error, abio_error);

sys/kern/vfs_aio.c

2508

atomic_add_int(&job->outblock, nblks);

sys/kern/vfs_aio.c

2510

atomic_add_int(&job->inblock, nblks);

sys/kern/vfs_aio.c

2512

if (refcount_release(&job->nbio)) {

sys/kern/vfs_aio.c

2513

abio_error = atomic_load_int(&job->error);

sys/kern/vfs_aio.c

2515

aio_complete(job, -1, abio_error);

sys/kern/vfs_aio.c

2517

aio_complete(job, atomic_load_long(&job->nbytes), 0);

sys/kern/vfs_aio.c

2529

struct kaiocb *job;

sys/kern/vfs_aio.c

2558

job = NULL;

sys/kern/vfs_aio.c

2560

while ((job = TAILQ_FIRST(&ki->kaio_done)) == NULL) {

sys/kern/vfs_aio.c

2574

if (job != NULL) {

sys/kern/vfs_aio.c

2575

MPASS(job->jobflags & KAIOCB_FINISHED);

sys/kern/vfs_aio.c

2576

ujob = job->ujob;

sys/kern/vfs_aio.c

2577

status = job->uaiocb._aiocb_private.status;

sys/kern/vfs_aio.c

2578

error = job->uaiocb._aiocb_private.error;

sys/kern/vfs_aio.c

2580

td->td_ru.ru_oublock += job->outblock;

sys/kern/vfs_aio.c

2581

td->td_ru.ru_inblock += job->inblock;

sys/kern/vfs_aio.c

2582

td->td_ru.ru_msgsnd += job->msgsnd;

sys/kern/vfs_aio.c

2583

td->td_ru.ru_msgrcv += job->msgrcv;

sys/kern/vfs_aio.c

2584

aio_free_entry(job);

sys/kern/vfs_aio.c

2644

struct kaiocb *job;

sys/kern/vfs_aio.c

2646

job = (struct kaiocb *)(uintptr_t)kn->kn_sdata;

sys/kern/vfs_aio.c

2655

kn->kn_ptr.p_aio = job;

sys/kern/vfs_aio.c

2658

knlist_add(&job->klist, kn, 0);

sys/kern/vfs_aio.c

2681

struct kaiocb *job = kn->kn_ptr.p_aio;

sys/kern/vfs_aio.c

2683

kn->kn_data = job->uaiocb._aiocb_private.error;

sys/kern/vfs_aio.c

2684

if (!(job->jobflags & KAIOCB_FINISHED))

sys/kern/vfs_aio.c

307

static int aio_free_entry(struct kaiocb *job);

sys/kern/vfs_aio.c

308

static void aio_process_rw(struct kaiocb *job);

sys/kern/vfs_aio.c

309

static void aio_process_sync(struct kaiocb *job);

sys/kern/vfs_aio.c

310

static void aio_process_mlock(struct kaiocb *job);

sys/kern/vfs_aio.c

315

static int aio_queue_file(struct file *fp, struct kaiocb *job);

sys/kern/vfs_aio.c

320

static int aio_qbio(struct proc *p, struct kaiocb *job);

sys/kern/vfs_aio.c

322

static void aio_bio_done_notify(struct proc *userp, struct kaiocb *job);

sys/kern/vfs_aio.c

323

static bool aio_clear_cancel_function_locked(struct kaiocb *job);

sys/kern/vfs_aio.c

499

aio_free_entry(struct kaiocb *job)

sys/kern/vfs_aio.c

505

p = job->userproc;

sys/kern/vfs_aio.c

511

MPASS(job->jobflags & KAIOCB_FINISHED);

sys/kern/vfs_aio.c

518

TAILQ_REMOVE(&ki->kaio_done, job, plist);

sys/kern/vfs_aio.c

519

TAILQ_REMOVE(&ki->kaio_all, job, allist);

sys/kern/vfs_aio.c

521

lj = job->lio;

sys/kern/vfs_aio.c

538

knlist_delete(&job->klist, curthread, 1);

sys/kern/vfs_aio.c

540

sigqueue_take(&job->ksi);

sys/kern/vfs_aio.c

565

if (job->fd_file)

sys/kern/vfs_aio.c

566

fdrop(job->fd_file, curthread);

sys/kern/vfs_aio.c

567

crfree(job->cred);

sys/kern/vfs_aio.c

568

if (job->uiop != &job->uio)

sys/kern/vfs_aio.c

569

freeuio(job->uiop);

sys/kern/vfs_aio.c

570

uma_zfree(aiocb_zone, job);

sys/kern/vfs_aio.c

584

aio_cancel_job(struct proc *p, struct kaioinfo *ki, struct kaiocb *job)

sys/kern/vfs_aio.c

595

MPASS((job->jobflags & KAIOCB_MARKER) == 0);

sys/kern/vfs_aio.c

596

if (job->jobflags & (KAIOCB_CANCELLED | KAIOCB_FINISHED))

sys/kern/vfs_aio.c

598

MPASS((job->jobflags & KAIOCB_CANCELLING) == 0);

sys/kern/vfs_aio.c

599

job->jobflags |= KAIOCB_CANCELLED;

sys/kern/vfs_aio.c

601

func = job->cancel_fn;

sys/kern/vfs_aio.c

619

job->jobflags |= KAIOCB_CANCELLING;

sys/kern/vfs_aio.c

621

func(job);

sys/kern/vfs_aio.c

623

job->jobflags &= ~KAIOCB_CANCELLING;

sys/kern/vfs_aio.c

624

if (job->jobflags & KAIOCB_FINISHED) {

sys/kern/vfs_aio.c

625

cancelled = job->uaiocb._aiocb_private.error == ECANCELED;

sys/kern/vfs_aio.c

626

TAILQ_REMOVE(&ki->kaio_jobqueue, job, plist);

sys/kern/vfs_aio.c

627

aio_bio_done_notify(p, job);

sys/kern/vfs_aio.c

648

struct kaiocb *job, *jobn;

sys/kern/vfs_aio.c

665

TAILQ_FOREACH_SAFE(job, &ki->kaio_jobqueue, plist, jobn) {

sys/kern/vfs_aio.c

666

aio_cancel_job(p, ki, job);

sys/kern/vfs_aio.c

677

while ((job = TAILQ_FIRST(&ki->kaio_done)) != NULL)

sys/kern/vfs_aio.c

678

aio_free_entry(job);

sys/kern/vfs_aio.c

707

struct kaiocb *job;

sys/kern/vfs_aio.c

713

TAILQ_FOREACH(job, &aio_jobs, list) {

sys/kern/vfs_aio.c

714

userp = job->userproc;

sys/kern/vfs_aio.c

718

TAILQ_REMOVE(&aio_jobs, job, list);

sys/kern/vfs_aio.c

719

if (!aio_clear_cancel_function(job))

sys/kern/vfs_aio.c

727

return (job);

sys/kern/vfs_aio.c

768

aio_process_rw(struct kaiocb *job)

sys/kern/vfs_aio.c

780

opcode = job->uaiocb.aio_lio_opcode & ~LIO_FOFFSET;

sys/kern/vfs_aio.c

783

("%s: opcode %d", __func__, job->uaiocb.aio_lio_opcode));

sys/kern/vfs_aio.c

785

aio_switch_vmspace(job);

sys/kern/vfs_aio.c

788

td->td_ucred = job->cred;

sys/kern/vfs_aio.c

789

job->uiop->uio_td = td;

sys/kern/vfs_aio.c

790

fp = job->fd_file;

sys/kern/vfs_aio.c

792

cnt = job->uiop->uio_resid;

sys/kern/vfs_aio.c

804

if (job->uiop->uio_resid == 0)

sys/kern/vfs_aio.c

807

error = fo_read(fp, job->uiop, fp->f_cred,

sys/kern/vfs_aio.c

808

(job->ioflags & KAIOCB_IO_FOFFSET) != 0 ? 0 :

sys/kern/vfs_aio.c

813

error = fo_write(fp, job->uiop, fp->f_cred, (job->ioflags &

sys/kern/vfs_aio.c

821

job->msgrcv = msgrcv_end - msgrcv_st;

sys/kern/vfs_aio.c

822

job->msgsnd = msgsnd_end - msgsnd_st;

sys/kern/vfs_aio.c

823

job->inblock = inblock_end - inblock_st;

sys/kern/vfs_aio.c

824

job->outblock = oublock_end - oublock_st;

sys/kern/vfs_aio.c

826

if (error != 0 && job->uiop->uio_resid != cnt) {

sys/kern/vfs_aio.c

830

PROC_LOCK(job->userproc);

sys/kern/vfs_aio.c

831

kern_psignal(job->userproc, SIGPIPE);

sys/kern/vfs_aio.c

832

PROC_UNLOCK(job->userproc);

sys/kern/vfs_aio.c

836

cnt -= job->uiop->uio_resid;

sys/kern/vfs_aio.c

839

aio_complete(job, -1, error);

sys/kern/vfs_aio.c

841

aio_complete(job, cnt, 0);

sys/kern/vfs_aio.c

845

aio_process_sync(struct kaiocb *job)

sys/kern/vfs_aio.c

849

struct file *fp = job->fd_file;

sys/kern/vfs_aio.c

852

KASSERT(job->uaiocb.aio_lio_opcode & LIO_SYNC,

sys/kern/vfs_aio.c

853

("%s: opcode %d", __func__, job->uaiocb.aio_lio_opcode));

sys/kern/vfs_aio.c

855

td->td_ucred = job->cred;

sys/kern/vfs_aio.c

858

job->uaiocb.aio_lio_opcode);

sys/kern/vfs_aio.c

862

aio_complete(job, -1, error);

sys/kern/vfs_aio.c

864

aio_complete(job, 0, 0);

sys/kern/vfs_aio.c

868

aio_process_mlock(struct kaiocb *job)

sys/kern/vfs_aio.c

870

struct aiocb *cb = &job->uaiocb;

sys/kern/vfs_aio.c

873

KASSERT(job->uaiocb.aio_lio_opcode == LIO_MLOCK,

sys/kern/vfs_aio.c

874

("%s: opcode %d", __func__, job->uaiocb.aio_lio_opcode));

sys/kern/vfs_aio.c

876

aio_switch_vmspace(job);

sys/kern/vfs_aio.c

877

error = kern_mlock(job->userproc, job->cred,

sys/kern/vfs_aio.c

879

aio_complete(job, error != 0 ? -1 : 0, error);

sys/kern/vfs_aio.c

883

aio_bio_done_notify(struct proc *userp, struct kaiocb *job)

sys/kern/vfs_aio.c

893

lj = job->lio;

sys/kern/vfs_aio.c

900

TAILQ_INSERT_TAIL(&ki->kaio_done, job, plist);

sys/kern/vfs_aio.c

901

MPASS(job->jobflags & KAIOCB_FINISHED);

sys/kern/vfs_aio.c

906

if (job->uaiocb.aio_sigevent.sigev_notify == SIGEV_SIGNAL ||

sys/kern/vfs_aio.c

907

job->uaiocb.aio_sigevent.sigev_notify == SIGEV_THREAD_ID)

sys/kern/vfs_aio.c

908

aio_sendsig(userp, &job->uaiocb.aio_sigevent, &job->ksi, true);

sys/kern/vfs_aio.c

910

KNOTE_LOCKED(&job->klist, 1);

sys/kern/vfs_aio.c

928

if (job->jobflags & KAIOCB_CHECKSYNC) {

sys/kern/vfs_aio.c

931

if (job->fd_file != sjob->fd_file ||

sys/kern/vfs_aio.c

932

job->seqno >= sjob->seqno)

sys/kern/vfs_aio.c

956

struct kaiocb *job;

sys/kern/vfs_aio.c

961

job = TAILQ_FIRST(&ki->kaio_syncready);

sys/kern/vfs_aio.c

962

TAILQ_REMOVE(&ki->kaio_syncready, job, list);

sys/kern/vfs_aio.c

964

aio_schedule(job, aio_process_sync);

sys/kern/vfs_aio.c

971

aio_cancel_cleared(struct kaiocb *job)

sys/kern/vfs_aio.c

980

return ((job->jobflags & KAIOCB_CLEARED) != 0);

sys/kern/vfs_aio.c

984

aio_clear_cancel_function_locked(struct kaiocb *job)

sys/kern/vfs_aio.c

987

AIO_LOCK_ASSERT(job->userproc->p_aioinfo, MA_OWNED);

sys/kern/vfs_aio.c

988

MPASS(job->cancel_fn != NULL);

sys/kern/vfs_aio.c

989

if (job->jobflags & KAIOCB_CANCELLING) {

sys/kern/vfs_aio.c

990

job->jobflags |= KAIOCB_CLEARED;

sys/kern/vfs_aio.c

993

job->cancel_fn = NULL;

sys/kern/vfs_aio.c

998

aio_clear_cancel_function(struct kaiocb *job)

sys/netpfil/pf/pf.c

8396

struct pf_sctp_multihome_job *job;

sys/netpfil/pf/pf.c

8439

job = malloc(sizeof(*job), M_PFTEMP, M_NOWAIT | M_ZERO);

sys/netpfil/pf/pf.c

8440

if (! job)

sys/netpfil/pf/pf.c

8445

memcpy(&job->pd, pd, sizeof(*pd));

sys/netpfil/pf/pf.c

8448

memcpy(&job->src, &t, sizeof(t));

sys/netpfil/pf/pf.c

8449

job->pd.src = &job->src;

sys/netpfil/pf/pf.c

8450

memcpy(&job->dst, pd->dst, sizeof(job->dst));

sys/netpfil/pf/pf.c

8451

job->pd.dst = &job->dst;

sys/netpfil/pf/pf.c

8452

job->pd.m = pd->m;

sys/netpfil/pf/pf.c

8453

job->op = op;

sys/netpfil/pf/pf.c

8455

MPASS(job->pd.pcksum);

sys/netpfil/pf/pf.c

8456

TAILQ_INSERT_TAIL(&pd->sctp_multihome_jobs, job, next);

sys/netpfil/pf/pf.c

8475

job = malloc(sizeof(*job), M_PFTEMP, M_NOWAIT | M_ZERO);

sys/netpfil/pf/pf.c

8476

if (! job)

sys/netpfil/pf/pf.c

8481

memcpy(&job->pd, pd, sizeof(*pd));

sys/netpfil/pf/pf.c

8482

memcpy(&job->src, &t, sizeof(t));

sys/netpfil/pf/pf.c

8483

job->pd.src = &job->src;

sys/netpfil/pf/pf.c

8484

memcpy(&job->dst, pd->dst, sizeof(job->dst));

sys/netpfil/pf/pf.c

8485

job->pd.dst = &job->dst;

sys/netpfil/pf/pf.c

8486

job->pd.m = pd->m;

sys/netpfil/pf/pf.c

8487

job->op = op;

sys/netpfil/pf/pf.c

8489

MPASS(job->pd.pcksum);

sys/netpfil/pf/pf.c

8490

TAILQ_INSERT_TAIL(&pd->sctp_multihome_jobs, job, next);

sys/sys/aio.h

214

bool aio_cancel_cleared(struct kaiocb *job);

sys/sys/aio.h

215

void aio_cancel(struct kaiocb *job);

sys/sys/aio.h

216

bool aio_clear_cancel_function(struct kaiocb *job);

sys/sys/aio.h

217

void aio_complete(struct kaiocb *job, long status, int error);

sys/sys/aio.h

218

void aio_schedule(struct kaiocb *job, aio_handle_fn_t *func);

sys/sys/aio.h

219

bool aio_set_cancel_function(struct kaiocb *job, aio_cancel_fn_t *func);

sys/sys/aio.h

220

void aio_switch_vmspace(struct kaiocb *job);

sys/sys/file.h

134

typedef int fo_aio_queue_t(struct file *fp, struct kaiocb *job);

sys/sys/file.h

473

fo_aio_queue(struct file *fp, struct kaiocb *job)

sys/sys/file.h

476

return ((*fp->f_ops->fo_aio_queue)(fp, job));

sys/sys/socketvar.h

531

int soaio_queue_generic(struct socket *so, struct kaiocb *job);

usr.bin/at/at.c

443

in_job_list(long job, long *joblist, int len)

usr.bin/at/at.c

448

if (job == joblist[i])

usr.sbin/cron/cron/job.c

34

static job *jhead = NULL, *jtail = NULL;

usr.sbin/cron/cron/job.c

40

job *j;

usr.sbin/cron/cron/job.c

48

if ((j = (job*)malloc(sizeof(job))) == NULL)

usr.sbin/cron/cron/job.c

50

j->next = (job*) NULL;

usr.sbin/cron/cron/job.c

66

job *j, *jn;

usr.sbin/lpr/lpc/cmds.c

1226

doarg(char *job)

usr.sbin/lpr/lpc/cmds.c

1238

if ((cp = strchr(job, ':')) != NULL) {

usr.sbin/lpr/lpc/cmds.c

1239

machine = job;

usr.sbin/lpr/lpc/cmds.c

1241

job = cp;

usr.sbin/lpr/lpc/cmds.c

1248

if (isdigit(*job)) {

usr.sbin/lpr/lpc/cmds.c

1251

jobnum = jobnum * 10 + (*job++ - '0');

usr.sbin/lpr/lpc/cmds.c

1252

while (isdigit(*job));

usr.sbin/lpr/lpc/cmds.c

1259

if (*job && strcmp(job, cp) != 0)

usr.sbin/lpr/lpc/cmds.c

1283

if (line[0] != 'P' || strcmp(job, line+1) != 0)

usr.sbin/yppush/yppush_main.c

112

struct jobs *job;

usr.sbin/yppush/yppush_main.c

114

job = yppush_joblist;

usr.sbin/yppush/yppush_main.c

116

while (job != NULL) {

usr.sbin/yppush/yppush_main.c

117

if (job->tid == tid)

usr.sbin/yppush/yppush_main.c

119

job = job->next;

usr.sbin/yppush/yppush_main.c

122

if (job == NULL) {

usr.sbin/yppush/yppush_main.c

128

if (job->polled) {

usr.sbin/yppush/yppush_main.c

136

job->tid);

usr.sbin/yppush/yppush_main.c

141

job->map, job->server, status == YPXFR_SUCC ?

usr.sbin/yppush/yppush_main.c

148

job->polled = 1;

usr.sbin/yppush/yppush_main.c

150

svc_unregister(job->prognum, 1);

usr.sbin/yppush/yppush_main.c

279

yppush_send_xfr(struct jobs *job)

usr.sbin/yppush/yppush_main.c

313

req.map_parms.map = job->map;

usr.sbin/yppush/yppush_main.c

314

req.transid = job->tid;

usr.sbin/yppush/yppush_main.c

315

req.prog = job->prognum;

usr.sbin/yppush/yppush_main.c

316

req.port = job->port;

usr.sbin/yppush/yppush_main.c

319

if ((clnt = clnt_create(job->server, YPPROG, YPVERS, "udp")) == NULL) {

usr.sbin/yppush/yppush_main.c

320

yp_error("%s: %s",job->server,clnt_spcreateerror("couldn't \

usr.sbin/yppush/yppush_main.c

324

job->stat = YPPUSH_NOHOST;

usr.sbin/yppush/yppush_main.c

327

job->stat = YPPUSH_PMAP;

usr.sbin/yppush/yppush_main.c

330

job->stat = YPPUSH_RPC;

usr.sbin/yppush/yppush_main.c

348

yp_error("%s: %s", job->server, clnt_sperror(clnt,

usr.sbin/yppush/yppush_main.c

350

job->stat = YPPUSH_YPSERV;

usr.sbin/yppush/yppush_main.c

372

struct jobs *job;

usr.sbin/yppush/yppush_main.c

377

if ((job = (struct jobs *)malloc(sizeof (struct jobs))) == NULL) {

usr.sbin/yppush/yppush_main.c

398

job->stat = 0;

usr.sbin/yppush/yppush_main.c

399

job->tid = tid;

usr.sbin/yppush/yppush_main.c

400

job->port = xprt->xp_port;

usr.sbin/yppush/yppush_main.c

401

job->server = strdup(server);

usr.sbin/yppush/yppush_main.c

402

job->map = strdup(map);

usr.sbin/yppush/yppush_main.c

403

job->prognum = prognum;

usr.sbin/yppush/yppush_main.c

404

job->polled = 0;

usr.sbin/yppush/yppush_main.c

405

job->next = yppush_joblist;

usr.sbin/yppush/yppush_main.c

406

yppush_joblist = job;

usr.sbin/yppush/yppush_main.c

418

if (yppush_send_xfr(job)){

usr.sbin/yppush/yppush_main.c

420

yppush_show_status(job->stat ? job->stat :

usr.sbin/yppush/yppush_main.c

421

YPPUSH_YPSERV,job->tid);