crypto/dist/ipsec-tools/src/racoon/proposal.c

979

char spc[21];

crypto/dist/ipsec-tools/src/racoon/proposal.c

981

memset(spc, ' ', sizeof(spc));

crypto/dist/ipsec-tools/src/racoon/proposal.c

982

spc[sizeof(spc) - 1] = '\0';

crypto/dist/ipsec-tools/src/racoon/proposal.c

984

spc[level] = '\0';

crypto/dist/ipsec-tools/src/racoon/proposal.c

988

"%s%p: next=%p tnext=%p\n", spc, p, p->next, p->tnext);

distrib/utils/edlabel/edlabel.c

181

int nsect, ntrack, ncyl, spc;

distrib/utils/edlabel/edlabel.c

183

nsect = ntrack = ncyl = spc = 0;

distrib/utils/edlabel/edlabel.c

199

spc = nsect * ntrack;

distrib/utils/edlabel/edlabel.c

200

if (!(ncyl = d->d_secperunit / spc))

distrib/utils/edlabel/edlabel.c

205

d->d_secpercyl = spc;

lib/libcurses/slk.c

733

size_t spc, len, width, x;

lib/libcurses/slk.c

737

spc = screen->slk_label_len;

lib/libcurses/slk.c

756

if (width + w > spc)

lib/libcurses/slk.c

766

if (len > spc)

lib/libcurses/slk.c

767

len = spc;

lib/libcurses/slk.c

776

x = (spc - width) / 2;

lib/libcurses/slk.c

777

if (x + width > spc)

lib/libcurses/slk.c

781

x = spc - width;

lib/libcurses/slk.c

791

spc -= x;

lib/libcurses/slk.c

796

spc -= width;

lib/libcurses/slk.c

798

if (spc != 0) {

lib/libcurses/slk.c

799

memset(p, ' ', spc);

lib/libcurses/slk.c

800

p += spc;

lib/librumpclient/rumpclient.c

137

send_with_recon(struct spclient *spc, struct iovec *iov, size_t iovlen)

lib/librumpclient/rumpclient.c

145

rv = dosend(spc, iov, iovlen);

lib/librumpclient/rumpclient.c

220

cliwaitresp(struct spclient *spc, struct respwait *rw, sigset_t *mask,

lib/librumpclient/rumpclient.c

226

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

228

sendunlockl(spc);

lib/librumpclient/rumpclient.c

229

mygen = spc->spc_generation;

lib/librumpclient/rumpclient.c

233

if (__predict_false(spc->spc_generation != mygen || !imalive))

lib/librumpclient/rumpclient.c

237

if (spc->spc_istatus == SPCSTATUS_FREE) {

lib/librumpclient/rumpclient.c

240

spc->spc_istatus = SPCSTATUS_BUSY;

lib/librumpclient/rumpclient.c

241

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

298

switch (readframe(spc)) {

lib/librumpclient/rumpclient.c

309

switch (spc->spc_hdr.rsp_class) {

lib/librumpclient/rumpclient.c

312

kickwaiter(spc);

lib/librumpclient/rumpclient.c

313

gotresp = spc->spc_hdr.rsp_reqno ==

lib/librumpclient/rumpclient.c

317

handlereq(spc);

lib/librumpclient/rumpclient.c

326

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

327

if (spc->spc_istatus == SPCSTATUS_WANTED)

lib/librumpclient/rumpclient.c

328

kickall(spc);

lib/librumpclient/rumpclient.c

329

spc->spc_istatus = SPCSTATUS_FREE;

lib/librumpclient/rumpclient.c

333

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

336

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

339

spc->spc_istatus = SPCSTATUS_WANTED;

lib/librumpclient/rumpclient.c

340

pthread_cond_wait(&rw->rw_cv, &spc->spc_mtx);

lib/librumpclient/rumpclient.c

343

TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);

lib/librumpclient/rumpclient.c

344

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

347

if (spc->spc_generation != mygen || !imalive) {

lib/librumpclient/rumpclient.c

354

syscall_req(struct spclient *spc, sigset_t *omask, int sysnum,

lib/librumpclient/rumpclient.c

371

putwait(spc, &rw, &rhdr);

lib/librumpclient/rumpclient.c

372

if ((rv = send_with_recon(spc, iov, __arraycount(iov))) != 0) {

lib/librumpclient/rumpclient.c

373

unputwait(spc, &rw);

lib/librumpclient/rumpclient.c

377

rv = cliwaitresp(spc, &rw, omask, false);

lib/librumpclient/rumpclient.c

387

handshake_req(struct spclient *spc, int type, void *data,

lib/librumpclient/rumpclient.c

439

putwait_locked(spc, &rw, &rhdr);

lib/librumpclient/rumpclient.c

441

putwait(spc, &rw, &rhdr);

lib/librumpclient/rumpclient.c

449

rv = send_with_recon(spc, iov, __arraycount(iov));

lib/librumpclient/rumpclient.c

452

unputwait_locked(spc, &rw);

lib/librumpclient/rumpclient.c

454

unputwait(spc, &rw);

lib/librumpclient/rumpclient.c

459

rv = cliwaitresp(spc, &rw, &omask, haslock);

lib/librumpclient/rumpclient.c

473

prefork_req(struct spclient *spc, sigset_t *omask, void **resp)

lib/librumpclient/rumpclient.c

488

putwait(spc, &rw, &rhdr);

lib/librumpclient/rumpclient.c

489

rv = send_with_recon(spc, iov, __arraycount(iov));

lib/librumpclient/rumpclient.c

491

unputwait(spc, &rw);

lib/librumpclient/rumpclient.c

495

rv = cliwaitresp(spc, &rw, omask, false);

lib/librumpclient/rumpclient.c

508

resp_sendlock(struct spclient *spc)

lib/librumpclient/rumpclient.c

512

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

513

while (spc->spc_ostatus != SPCSTATUS_FREE) {

lib/librumpclient/rumpclient.c

514

if (__predict_false(spc->spc_reconnecting)) {

lib/librumpclient/rumpclient.c

518

spc->spc_ostatus = SPCSTATUS_WANTED;

lib/librumpclient/rumpclient.c

519

pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);

lib/librumpclient/rumpclient.c

521

spc->spc_ostatus = SPCSTATUS_BUSY;

lib/librumpclient/rumpclient.c

524

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpclient/rumpclient.c

529

send_copyin_resp(struct spclient *spc, uint64_t reqno, void *data, size_t dlen,

lib/librumpclient/rumpclient.c

547

if (resp_sendlock(spc) != 0)

lib/librumpclient/rumpclient.c

549

(void)SENDIOV(spc, iov);

lib/librumpclient/rumpclient.c

550

sendunlock(spc);

lib/librumpclient/rumpclient.c

554

send_anonmmap_resp(struct spclient *spc, uint64_t reqno, void *addr)

lib/librumpclient/rumpclient.c

568

if (resp_sendlock(spc) != 0)

lib/librumpclient/rumpclient.c

570

(void)SENDIOV(spc, iov);

lib/librumpclient/rumpclient.c

571

sendunlock(spc);

lib/librumpclient/rumpclient.c

607

handlereq(struct spclient *spc)

lib/librumpclient/rumpclient.c

610

struct rsp_hdr *rhdr = &spc->spc_hdr;

lib/librumpclient/rumpclient.c

613

int reqtype = spc->spc_hdr.rsp_type;

lib/librumpclient/rumpclient.c

620

copydata = (struct rsp_copydata *)spc->spc_buf;

lib/librumpclient/rumpclient.c

623

send_copyin_resp(spc, spc->spc_hdr.rsp_reqno,

lib/librumpclient/rumpclient.c

630

copydata = (struct rsp_copydata *)spc->spc_buf;

lib/librumpclient/rumpclient.c

639

maplen = *(size_t *)spc->spc_buf;

lib/librumpclient/rumpclient.c

645

send_anonmmap_resp(spc, spc->spc_hdr.rsp_reqno, mapaddr);

lib/librumpclient/rumpclient.c

662

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1003

rfp = (void *)spc->spc_buf;

lib/librumpuser/rumpuser_sp.c

1016

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1019

send_error_resp(spc, reqno,

lib/librumpuser/rumpuser_sp.c

1021

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1030

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1042

if ((error = lwproc_rfork(spc,

lib/librumpuser/rumpuser_sp.c

1044

send_error_resp(spc, reqno,

lib/librumpuser/rumpuser_sp.c

1046

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1050

spc->spc_mainlwp = lwproc_curlwp();

lib/librumpuser/rumpuser_sp.c

1053

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

1055

send_handshake_resp(spc, reqno, 0);

lib/librumpuser/rumpuser_sp.c

1057

send_error_resp(spc, reqno, RUMPSP_ERR_AUTH);

lib/librumpuser/rumpuser_sp.c

1058

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1059

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1063

spc->spc_pid = lwproc_getpid();

lib/librumpuser/rumpuser_sp.c

1066

spc, spc->spc_pid));

lib/librumpuser/rumpuser_sp.c

1069

spc->spc_state = SPCSTATE_RUNNING;

lib/librumpuser/rumpuser_sp.c

1073

if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_PREFORK)) {

lib/librumpuser/rumpuser_sp.c

1079

DPRINTF(("rump_sp: prefork handler executing for %p\n", spc));

lib/librumpuser/rumpuser_sp.c

1080

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1082

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1083

inexec = spc->spc_inexec;

lib/librumpuser/rumpuser_sp.c

1084

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1086

send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);

lib/librumpuser/rumpuser_sp.c

1087

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1093

send_error_resp(spc, reqno, RUMPSP_ERR_NOMEM);

lib/librumpuser/rumpuser_sp.c

1102

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

1103

if ((error = lwproc_rfork(spc, RUMP_RFFD_COPY, NULL)) != 0) {

lib/librumpuser/rumpuser_sp.c

1104

DPRINTF(("rump_sp: fork failed: %d (%p)\n",error, spc));

lib/librumpuser/rumpuser_sp.c

1105

send_error_resp(spc, reqno, RUMPSP_ERR_RFORK_FAILED);

lib/librumpuser/rumpuser_sp.c

1119

LIST_INSERT_HEAD(&spc->spc_pflist, pf, pf_spcentries);

lib/librumpuser/rumpuser_sp.c

1122

DPRINTF(("rump_sp: prefork handler success %p\n", spc));

lib/librumpuser/rumpuser_sp.c

1124

send_prefork_resp(spc, reqno, auth);

lib/librumpuser/rumpuser_sp.c

1128

if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_HANDSHAKE)) {

lib/librumpuser/rumpuser_sp.c

1131

if (spc->spc_hdr.rsp_handshake != HANDSHAKE_EXEC) {

lib/librumpuser/rumpuser_sp.c

1132

send_error_resp(spc, reqno,

lib/librumpuser/rumpuser_sp.c

1134

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1135

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1139

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1140

inexec = spc->spc_inexec;

lib/librumpuser/rumpuser_sp.c

1141

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1143

send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);

lib/librumpuser/rumpuser_sp.c

1144

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

1145

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1149

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1150

spc->spc_inexec = 1;

lib/librumpuser/rumpuser_sp.c

1151

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

1157

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

1165

schedulework(spc, SBA_EXEC);

lib/librumpuser/rumpuser_sp.c

1169

if (__predict_false(spc->spc_hdr.rsp_type != RUMPSP_SYSCALL)) {

lib/librumpuser/rumpuser_sp.c

1170

send_error_resp(spc, reqno, RUMPSP_ERR_MALFORMED_REQUEST);

lib/librumpuser/rumpuser_sp.c

1171

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1175

schedulework(spc, SBA_SYSCALL);

lib/librumpuser/rumpuser_sp.c

1182

struct spclient *spc;

lib/librumpuser/rumpuser_sp.c

1192

spc = &spclist[idx];

lib/librumpuser/rumpuser_sp.c

1193

pthread_mutex_init(&spc->spc_mtx, NULL);

lib/librumpuser/rumpuser_sp.c

1194

pthread_cond_init(&spc->spc_cv, NULL);

lib/librumpuser/rumpuser_sp.c

1195

spc->spc_fd = -1;

lib/librumpuser/rumpuser_sp.c

1253

spc = &spclist[idx];

lib/librumpuser/rumpuser_sp.c

1255

switch (readframe(spc)) {

lib/librumpuser/rumpuser_sp.c

1262

switch (spc->spc_hdr.rsp_class) {

lib/librumpuser/rumpuser_sp.c

1264

kickwaiter(spc);

lib/librumpuser/rumpuser_sp.c

1267

handlereq(spc);

lib/librumpuser/rumpuser_sp.c

1270

send_error_resp(spc,

lib/librumpuser/rumpuser_sp.c

1271

spc->spc_hdr.rsp_reqno,

lib/librumpuser/rumpuser_sp.c

1273

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

1375

struct spclient *spc = arg;

lib/librumpuser/rumpuser_sp.c

1386

if (spc && spc->spc_syscallreq)

lib/librumpuser/rumpuser_sp.c

1387

send_syscall_resp(spc, spc->spc_syscallreq, 0, retval);

lib/librumpuser/rumpuser_sp.c

148

waitresp(struct spclient *spc, struct respwait *rw)

lib/librumpuser/rumpuser_sp.c

153

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

154

sendunlockl(spc);

lib/librumpuser/rumpuser_sp.c

155

while (!rw->rw_done && spc->spc_state != SPCSTATE_DYING) {

lib/librumpuser/rumpuser_sp.c

156

pthread_cond_wait(&rw->rw_cv, &spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

158

TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);

lib/librumpuser/rumpuser_sp.c

159

spcstate = spc->spc_state;

lib/librumpuser/rumpuser_sp.c

160

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

195

lwproc_rfork(struct spclient *spc, int flags, const char *comm)

lib/librumpuser/rumpuser_sp.c

200

rv = rumpuser__hyp.hyp_lwproc_rfork(spc, flags, comm);

lib/librumpuser/rumpuser_sp.c

276

nextreq(struct spclient *spc)

lib/librumpuser/rumpuser_sp.c

280

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

281

nw = spc->spc_nextreq++;

lib/librumpuser/rumpuser_sp.c

282

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

293

send_error_resp(struct spclient *spc, uint64_t reqno, enum rumpsp_err error)

lib/librumpuser/rumpuser_sp.c

306

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

307

(void)SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

308

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

312

send_handshake_resp(struct spclient *spc, uint64_t reqno, int error)

lib/librumpuser/rumpuser_sp.c

327

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

328

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

329

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

335

send_syscall_resp(struct spclient *spc, uint64_t reqno, int error,

lib/librumpuser/rumpuser_sp.c

355

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

356

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

357

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

363

send_prefork_resp(struct spclient *spc, uint64_t reqno, uint32_t *auth)

lib/librumpuser/rumpuser_sp.c

378

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

379

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

380

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

386

copyin_req(struct spclient *spc, const void *remaddr, size_t *dlen,

lib/librumpuser/rumpuser_sp.c

411

putwait(spc, &rw, &rhdr);

lib/librumpuser/rumpuser_sp.c

412

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

414

unputwait(spc, &rw);

lib/librumpuser/rumpuser_sp.c

418

rv = waitresp(spc, &rw);

lib/librumpuser/rumpuser_sp.c

431

send_copyout_req(struct spclient *spc, const void *remaddr,

lib/librumpuser/rumpuser_sp.c

442

rhdr.rsp_reqno = nextreq(spc);

lib/librumpuser/rumpuser_sp.c

454

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

455

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

456

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

462

anonmmap_req(struct spclient *spc, size_t howmuch, void **resp)

lib/librumpuser/rumpuser_sp.c

479

putwait(spc, &rw, &rhdr);

lib/librumpuser/rumpuser_sp.c

480

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

482

unputwait(spc, &rw);

lib/librumpuser/rumpuser_sp.c

486

rv = waitresp(spc, &rw);

lib/librumpuser/rumpuser_sp.c

496

send_raise_req(struct spclient *spc, int signo)

lib/librumpuser/rumpuser_sp.c

509

sendlock(spc);

lib/librumpuser/rumpuser_sp.c

510

rv = SENDIOV(spc, iov);

lib/librumpuser/rumpuser_sp.c

511

sendunlock(spc);

lib/librumpuser/rumpuser_sp.c

517

spcref(struct spclient *spc)

lib/librumpuser/rumpuser_sp.c

520

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

521

spc->spc_refcnt++;

lib/librumpuser/rumpuser_sp.c

522

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

526

spcrelease(struct spclient *spc)

lib/librumpuser/rumpuser_sp.c

530

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

531

ref = --spc->spc_refcnt;

lib/librumpuser/rumpuser_sp.c

532

if (__predict_false(spc->spc_inexec && ref <= 2))

lib/librumpuser/rumpuser_sp.c

533

pthread_cond_broadcast(&spc->spc_cv);

lib/librumpuser/rumpuser_sp.c

534

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

539

DPRINTF(("rump_sp: spcrelease: spc %p fd %d\n", spc, spc->spc_fd));

lib/librumpuser/rumpuser_sp.c

541

_DIAGASSERT(TAILQ_EMPTY(&spc->spc_respwait));

lib/librumpuser/rumpuser_sp.c

542

_DIAGASSERT(spc->spc_buf == NULL);

lib/librumpuser/rumpuser_sp.c

544

if (spc->spc_mainlwp) {

lib/librumpuser/rumpuser_sp.c

545

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

548

spc->spc_mainlwp = NULL;

lib/librumpuser/rumpuser_sp.c

550

close(spc->spc_fd);

lib/librumpuser/rumpuser_sp.c

551

spc->spc_fd = -1;

lib/librumpuser/rumpuser_sp.c

552

spc->spc_state = SPCSTATE_NEW;

lib/librumpuser/rumpuser_sp.c

560

struct spclient *spc = &spclist[idx];

lib/librumpuser/rumpuser_sp.c

567

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

568

spc->spc_state = SPCSTATE_DYING;

lib/librumpuser/rumpuser_sp.c

569

kickall(spc);

lib/librumpuser/rumpuser_sp.c

570

sendunlockl(spc);

lib/librumpuser/rumpuser_sp.c

572

dolwpexit = !spc->spc_inexec;

lib/librumpuser/rumpuser_sp.c

573

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

575

if (dolwpexit && spc->spc_mainlwp) {

lib/librumpuser/rumpuser_sp.c

576

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

586

memset((char *)spc + SPC_ZEROFF, 0, sizeof(*spc) - SPC_ZEROFF);

lib/librumpuser/rumpuser_sp.c

588

spcrelease(spc);

lib/librumpuser/rumpuser_sp.c

594

struct spclient *spc;

lib/librumpuser/rumpuser_sp.c

598

spc = &spclist[i];

lib/librumpuser/rumpuser_sp.c

599

if (spc->spc_fd == -1)

lib/librumpuser/rumpuser_sp.c

602

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

605

spcrelease(spc);

lib/librumpuser/rumpuser_sp.c

675

serv_handlesyscall(struct spclient *spc, struct rsp_hdr *rhdr, uint8_t *data)

lib/librumpuser/rumpuser_sp.c

682

sysnum, spc->spc_pid));

lib/librumpuser/rumpuser_sp.c

684

if (__predict_false((rv = lwproc_newlwp(spc->spc_pid)) != 0)) {

lib/librumpuser/rumpuser_sp.c

686

send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);

lib/librumpuser/rumpuser_sp.c

689

spc->spc_syscallreq = rhdr->rsp_reqno;

lib/librumpuser/rumpuser_sp.c

691

spc->spc_syscallreq = 0;

lib/librumpuser/rumpuser_sp.c

698

send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);

lib/librumpuser/rumpuser_sp.c

702

serv_handleexec(struct spclient *spc, struct rsp_hdr *rhdr, const char *comm)

lib/librumpuser/rumpuser_sp.c

704

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

706

while (spc->spc_refcnt > 2)

lib/librumpuser/rumpuser_sp.c

707

pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

708

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

716

lwproc_switch(spc->spc_mainlwp);

lib/librumpuser/rumpuser_sp.c

720

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

721

spc->spc_inexec = 0;

lib/librumpuser/rumpuser_sp.c

722

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/rumpuser_sp.c

723

send_handshake_resp(spc, rhdr->rsp_reqno, 0);

lib/librumpuser/rumpuser_sp.c

785

struct spclient *spc = arg;

lib/librumpuser/rumpuser_sp.c

791

rv = copyin_req(spc, raddr, len, wantstr, &rdata);

lib/librumpuser/rumpuser_sp.c

826

struct spclient *spc = arg;

lib/librumpuser/rumpuser_sp.c

830

rv = send_copyout_req(spc, raddr, laddr, dlen);

lib/librumpuser/rumpuser_sp.c

859

struct spclient *spc = arg;

lib/librumpuser/rumpuser_sp.c

865

rv = anonmmap_req(spc, howmuch, &rdata);

lib/librumpuser/rumpuser_sp.c

888

struct spclient *spc = arg;

lib/librumpuser/rumpuser_sp.c

892

rv = send_raise_req(spc, signo);

lib/librumpuser/rumpuser_sp.c

900

schedulework(struct spclient *spc, enum sbatype sba_type)

lib/librumpuser/rumpuser_sp.c

907

reqno = spc->spc_hdr.rsp_reqno;

lib/librumpuser/rumpuser_sp.c

910

send_error_resp(spc, reqno, RUMPSP_ERR_TRYAGAIN);

lib/librumpuser/rumpuser_sp.c

911

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

918

sba->sba_spc = spc;

lib/librumpuser/rumpuser_sp.c

920

sba->sba_hdr = spc->spc_hdr;

lib/librumpuser/rumpuser_sp.c

921

sba->sba_data = spc->spc_buf;

lib/librumpuser/rumpuser_sp.c

922

spcresetbuf(spc);

lib/librumpuser/rumpuser_sp.c

924

spcref(spc);

lib/librumpuser/rumpuser_sp.c

958

handlereq(struct spclient *spc)

lib/librumpuser/rumpuser_sp.c

963

reqno = spc->spc_hdr.rsp_reqno;

lib/librumpuser/rumpuser_sp.c

964

if (__predict_false(spc->spc_state == SPCSTATE_NEW)) {

lib/librumpuser/rumpuser_sp.c

965

if (spc->spc_hdr.rsp_type != RUMPSP_HANDSHAKE) {

lib/librumpuser/rumpuser_sp.c

966

send_error_resp(spc, reqno, RUMPSP_ERR_AUTH);

lib/librumpuser/rumpuser_sp.c

967

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

968

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

972

if (spc->spc_hdr.rsp_handshake == HANDSHAKE_GUEST) {

lib/librumpuser/rumpuser_sp.c

976

if ((error = lwproc_rfork(spc, RUMP_RFFD_CLEAR,

lib/librumpuser/rumpuser_sp.c

977

(const char *)spc->spc_buf)) != 0) {

lib/librumpuser/rumpuser_sp.c

978

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

981

spcfreebuf(spc);

lib/librumpuser/rumpuser_sp.c

985

spc->spc_mainlwp = lwproc_curlwp();

lib/librumpuser/rumpuser_sp.c

987

send_handshake_resp(spc, reqno, 0);

lib/librumpuser/rumpuser_sp.c

988

} else if (spc->spc_hdr.rsp_handshake == HANDSHAKE_FORK) {

lib/librumpuser/rumpuser_sp.c

994

if (spc->spc_off-HDRSZ != sizeof(*rfp)) {

lib/librumpuser/rumpuser_sp.c

995

send_error_resp(spc, reqno,

lib/librumpuser/rumpuser_sp.c

997

shutdown(spc->spc_fd, SHUT_RDWR);

lib/librumpuser/rumpuser_sp.c

998

spcfreebuf(spc);

lib/librumpuser/sp_common.c

256

spcresetbuf(struct spclient *spc)

lib/librumpuser/sp_common.c

259

spc->spc_buf = NULL;

lib/librumpuser/sp_common.c

260

spc->spc_off = 0;

lib/librumpuser/sp_common.c

264

spcfreebuf(struct spclient *spc)

lib/librumpuser/sp_common.c

267

free(spc->spc_buf);

lib/librumpuser/sp_common.c

268

spcresetbuf(spc);

lib/librumpuser/sp_common.c

272

sendlockl(struct spclient *spc)

lib/librumpuser/sp_common.c

275

while (spc->spc_ostatus != SPCSTATUS_FREE) {

lib/librumpuser/sp_common.c

276

spc->spc_ostatus = SPCSTATUS_WANTED;

lib/librumpuser/sp_common.c

277

pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);

lib/librumpuser/sp_common.c

279

spc->spc_ostatus = SPCSTATUS_BUSY;

lib/librumpuser/sp_common.c

283

sendlock(struct spclient *spc)

lib/librumpuser/sp_common.c

286

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

287

sendlockl(spc);

lib/librumpuser/sp_common.c

288

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

292

sendunlockl(struct spclient *spc)

lib/librumpuser/sp_common.c

295

if (spc->spc_ostatus == SPCSTATUS_WANTED)

lib/librumpuser/sp_common.c

296

pthread_cond_broadcast(&spc->spc_cv);

lib/librumpuser/sp_common.c

297

spc->spc_ostatus = SPCSTATUS_FREE;

lib/librumpuser/sp_common.c

301

sendunlock(struct spclient *spc)

lib/librumpuser/sp_common.c

304

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

305

sendunlockl(spc);

lib/librumpuser/sp_common.c

306

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

310

dosend(struct spclient *spc, struct iovec *iov, size_t iovlen)

lib/librumpuser/sp_common.c

315

int fd = spc->spc_fd;

lib/librumpuser/sp_common.c

367

doputwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)

lib/librumpuser/sp_common.c

374

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

375

rw->rw_reqno = rhdr->rsp_reqno = spc->spc_nextreq++;

lib/librumpuser/sp_common.c

376

TAILQ_INSERT_TAIL(&spc->spc_respwait, rw, rw_entries);

lib/librumpuser/sp_common.c

380

putwait_locked(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)

lib/librumpuser/sp_common.c

383

doputwait(spc, rw, rhdr);

lib/librumpuser/sp_common.c

384

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

388

putwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)

lib/librumpuser/sp_common.c

391

doputwait(spc, rw, rhdr);

lib/librumpuser/sp_common.c

392

sendlockl(spc);

lib/librumpuser/sp_common.c

393

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

397

dounputwait(struct spclient *spc, struct respwait *rw)

lib/librumpuser/sp_common.c

400

TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);

lib/librumpuser/sp_common.c

401

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

407

unputwait_locked(struct spclient *spc, struct respwait *rw)

lib/librumpuser/sp_common.c

410

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

411

dounputwait(spc, rw);

lib/librumpuser/sp_common.c

415

unputwait(struct spclient *spc, struct respwait *rw)

lib/librumpuser/sp_common.c

418

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

419

sendunlockl(spc);

lib/librumpuser/sp_common.c

421

dounputwait(spc, rw);

lib/librumpuser/sp_common.c

425

kickwaiter(struct spclient *spc)

lib/librumpuser/sp_common.c

430

pthread_mutex_lock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

431

TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) {

lib/librumpuser/sp_common.c

432

if (rw->rw_reqno == spc->spc_hdr.rsp_reqno)

lib/librumpuser/sp_common.c

437

spc->spc_hdr.rsp_reqno));

lib/librumpuser/sp_common.c

438

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

439

spcfreebuf(spc);

lib/librumpuser/sp_common.c

442

DPRINTF(("rump_sp: client %p woke up waiter at %p\n", spc, rw));

lib/librumpuser/sp_common.c

443

rw->rw_data = spc->spc_buf;

lib/librumpuser/sp_common.c

445

rw->rw_dlen = (size_t)(spc->spc_off - HDRSZ);

lib/librumpuser/sp_common.c

446

if (spc->spc_hdr.rsp_class == RUMPSP_ERROR) {

lib/librumpuser/sp_common.c

447

error = rw->rw_error = errmap(spc->spc_hdr.rsp_error);

lib/librumpuser/sp_common.c

450

pthread_mutex_unlock(&spc->spc_mtx);

lib/librumpuser/sp_common.c

453

spcfreebuf(spc);

lib/librumpuser/sp_common.c

455

spcresetbuf(spc);

lib/librumpuser/sp_common.c

459

kickall(struct spclient *spc)

lib/librumpuser/sp_common.c

464

TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries)

lib/librumpuser/sp_common.c

469

readframe(struct spclient *spc)

lib/librumpuser/sp_common.c

471

int fd = spc->spc_fd;

lib/librumpuser/sp_common.c

477

if (spc->spc_off < HDRSZ) {

lib/librumpuser/sp_common.c

479

spc->spc_off));

lib/librumpuser/sp_common.c

481

left = HDRSZ - spc->spc_off;

lib/librumpuser/sp_common.c

483

n = host_read(fd, (uint8_t*)&spc->spc_hdr + spc->spc_off, left);

lib/librumpuser/sp_common.c

493

spc->spc_off += n;

lib/librumpuser/sp_common.c

494

if (spc->spc_off < HDRSZ) {

lib/librumpuser/sp_common.c

499

framelen = spc->spc_hdr.rsp_len;

lib/librumpuser/sp_common.c

508

spc->spc_buf = malloc(framelen - HDRSZ + 1);

lib/librumpuser/sp_common.c

509

if (spc->spc_buf == NULL) {

lib/librumpuser/sp_common.c

512

memset(spc->spc_buf, 0, framelen - HDRSZ + 1);

lib/librumpuser/sp_common.c

517

framelen = spc->spc_hdr.rsp_len;

lib/librumpuser/sp_common.c

520

left = framelen - spc->spc_off;

lib/librumpuser/sp_common.c

523

spc->spc_off, left));

lib/librumpuser/sp_common.c

527

n = host_read(fd, spc->spc_buf + (spc->spc_off - HDRSZ), left);

lib/librumpuser/sp_common.c

536

spc->spc_off += n;

sbin/newfs_msdos/mkfs_msdos.c

120

u_int8_t spc; /* sectors per cluster */

sbin/newfs_msdos/mkfs_msdos.c

164

u_int spc; /* sectors per cluster */

sbin/newfs_msdos/mkfs_msdos.c

182

{ .bps = a, .spc = b, .res = c, .nft = d, .rde = e, \

sbin/newfs_msdos/mkfs_msdos.c

340

if (bpb.spc == 0) { /* set defaults */

sbin/newfs_msdos/mkfs_msdos.c

344

bpb.spc = 1; /* use 512 bytes */

sbin/newfs_msdos/mkfs_msdos.c

348

bpb.spc = 1; /* use 512 bytes */

sbin/newfs_msdos/mkfs_msdos.c

352

bpb.spc = 8; /* use 4k */

sbin/newfs_msdos/mkfs_msdos.c

357

while (bpb.spc < 128 && x < x1) {

sbin/newfs_msdos/mkfs_msdos.c

359

bpb.spc *= 2;

sbin/newfs_msdos/mkfs_msdos.c

424

bpb.spc = o.block_size / bpb.bps;

sbin/newfs_msdos/mkfs_msdos.c

432

bpb.spc = o.sectors_per_cluster;

sbin/newfs_msdos/mkfs_msdos.c

486

howmany((RESFTE + (bpb.spc ? MINCLS16 : MAXCLS12 + 1)) *

sbin/newfs_msdos/mkfs_msdos.c

487

((bpb.spc ? 16 : 12) / BPN), bpb.bps * NPB) *

sbin/newfs_msdos/mkfs_msdos.c

491

(bpb.spc ? MINCLS16 : MAXCLS12 + 1) *

sbin/newfs_msdos/mkfs_msdos.c

492

(bpb.spc ? bpb.spc : howmany(DEFBLK, bpb.bps)))

sbin/newfs_msdos/mkfs_msdos.c

499

(bpb.spc ? bpb.spc : howmany(8192, bpb.bps)))

sbin/newfs_msdos/mkfs_msdos.c

537

if (!bpb.spc)

sbin/newfs_msdos/mkfs_msdos.c

538

for (bpb.spc = howmany(o.fat_type == 16 ? DEFBLK16 : DEFBLK, bpb.bps);

sbin/newfs_msdos/mkfs_msdos.c

539

bpb.spc < MAXSPC &&

sbin/newfs_msdos/mkfs_msdos.c

544

(u_int64_t)(maxcls(o.fat_type) + 1) * bpb.spc <= bpb.bsec;

sbin/newfs_msdos/mkfs_msdos.c

545

bpb.spc <<= 1);

sbin/newfs_msdos/mkfs_msdos.c

558

(bpb.spc * bpb.bps * NPB + o.fat_type / BPN * bpb.nft);

sbin/newfs_msdos/mkfs_msdos.c

566

cls = (bpb.bsec - x1) / bpb.spc;

sbin/newfs_msdos/mkfs_msdos.c

576

if (bspf_is_calculated && o.sectors_per_cluster == 0 && bpb.spc > 2) {

sbin/newfs_msdos/mkfs_msdos.c

587

bpb.bsec = x1 + (cls + 1) * bpb.spc - 1;

sbin/newfs_msdos/mkfs_msdos.c

593

"(%u bytes/cluster)\n", fname, cls * bpb.spc,

sbin/newfs_msdos/mkfs_msdos.c

594

cls * bpb.spc == 1 ? "" : "s", cls, o.fat_type,

sbin/newfs_msdos/mkfs_msdos.c

595

cls == 1 ? "" : "s", bpb.bps * bpb.spc);

sbin/newfs_msdos/mkfs_msdos.c

648

for (lsn = 0; lsn < dir + (o.fat_type == 32 ? bpb.spc : rds); lsn++) {

sbin/newfs_msdos/mkfs_msdos.c

651

fname,lsn,(dir + (o.fat_type == 32 ? bpb.spc : rds)),

sbin/newfs_msdos/mkfs_msdos.c

652

(lsn*100)/(dir + (o.fat_type == 32 ? bpb.spc : rds)));

sbin/newfs_msdos/mkfs_msdos.c

681

mk1(bsbpb->spc, bpb.spc);

sbin/newfs_msdos/mkfs_msdos.c

925

printf("bps=%u spc=%u res=%u nft=%u", bpb->bps, bpb->spc, bpb->res,

sys/arch/aarch64/aarch64/db_interface.c

569

const char *spc = spaces[level];

sys/arch/aarch64/aarch64/db_interface.c

575

pr("%sL%d: pa=%lx pg=NULL\n", spc, level, pa);

sys/arch/aarch64/aarch64/db_interface.c

577

pr("%sL%d: pa=%lx pg=%p\n", spc, level, pa, pg);

sys/arch/aarch64/aarch64/db_interface.c

585

spc, level, i, n, va, pde);

sys/arch/dreamcast/dreamcast/machdep.c

264

intc_intr(int ssr, int spc, int ssp)

sys/arch/dreamcast/dreamcast/machdep.c

283

cf.spc = spc;

sys/arch/evbsh3/evbsh3/machdep.c

530

intc_intr(int ssr, int spc, int ssp)

sys/arch/evbsh3/evbsh3/machdep.c

578

cf.spc = spc;

sys/arch/hp300/dev/spc.c

83

CFATTACH_DECL_NEW(spc, sizeof(struct spc_dio_softc),

sys/arch/hpcsh/hpcsh/machdep.c

588

intc_intr(int ssr, int spc, int ssp)

sys/arch/hpcsh/hpcsh/machdep.c

612

cf.spc = spc;

sys/arch/hppa/dev/gftfb.c

395

struct gftfb_softc *spc = device_private(sc->sc_dev);

sys/arch/hppa/dev/gftfb.c

399

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/arch/hppa/dev/gftfb.c

401

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/arch/hppa/dev/gftfb.c

413

struct gftfb_softc *spc = device_private(sc->sc_dev);

sys/arch/hppa/dev/gftfb.c

417

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/arch/hppa/dev/gftfb.c

419

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/arch/hppa/dev/summitfb.c

377

struct summitfb_softc *spc = device_private(sc->sc_dev);

sys/arch/hppa/dev/summitfb.c

381

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/arch/hppa/dev/summitfb.c

383

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/arch/hppa/dev/summitfb.c

395

struct summitfb_softc *spc = device_private(sc->sc_dev);

sys/arch/hppa/dev/summitfb.c

399

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/arch/hppa/dev/summitfb.c

401

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/arch/i386/stand/lib/biosdisk_ll.c

213

int cyl, head, sec, nsec, spc, dblk32;

sys/arch/i386/stand/lib/biosdisk_ll.c

216

spc = d->head * d->sec;

sys/arch/i386/stand/lib/biosdisk_ll.c

217

cyl = dblk32 / spc;

sys/arch/i386/stand/lib/biosdisk_ll.c

218

head = (dblk32 % spc) / d->sec;

sys/arch/landisk/landisk/intr.c

115

cf.spc = spc;

sys/arch/landisk/landisk/intr.c

74

intc_intr(int ssr, int spc, int ssp)

sys/arch/luna68k/dev/spc.c

60

CFATTACH_DECL_NEW(spc, sizeof(struct spc_softc),

sys/arch/mmeye/mmeye/machdep.c

648

intc_intr(int ssr, int spc, int ssp)

sys/arch/mmeye/mmeye/machdep.c

669

cf.spc = spc;

sys/arch/sh3/include/cpu.h

82

int spc; /* program counter at time of interrupt */

sys/arch/sh3/include/cpu.h

89

#define CLKF_PC(cf) ((cf)->spc)

sys/arch/sh3/include/locore.h

109

stc.l spc, @-r14 /* tf_spc */ ;\

sys/arch/sh3/include/locore.h

138

ldc.l @r14+, spc /* tf_spc */ ;\

sys/arch/sh3/sh3/db_interface.c

634

TF(spc);

sys/arch/x68k/x68k/iodevice.h

320

struct spc io_inspc; /* 0x00e96020 */

sys/arch/x68k/x68k/iodevice.h

327

struct spc io_exspc; /* 0x00ea0000 */

sys/dev/pci/sti_pci.c

102

spc->sc_dev = self;

sys/dev/pci/sti_pci.c

104

spc->sc_pc = paa->pa_pc;

sys/dev/pci/sti_pci.c

105

spc->sc_tag = paa->pa_tag;

sys/dev/pci/sti_pci.c

106

spc->sc_base.sc_dev = self;

sys/dev/pci/sti_pci.c

107

spc->sc_base.sc_enable_rom = sti_pci_enable_rom;

sys/dev/pci/sti_pci.c

108

spc->sc_base.sc_disable_rom = sti_pci_disable_rom;

sys/dev/pci/sti_pci.c

112

if (sti_check_rom(spc, paa) != 0)

sys/dev/pci/sti_pci.c

116

ret = sti_pci_is_console(paa, spc->sc_base. bases);

sys/dev/pci/sti_pci.c

118

spc->sc_base.sc_flags |= STI_CONSOLE;

sys/dev/pci/sti_pci.c

120

ret = sti_attach_common(&spc->sc_base, paa->pa_iot, paa->pa_memt,

sys/dev/pci/sti_pci.c

121

spc->sc_romh, STI_CODEBASE_MAIN);

sys/dev/pci/sti_pci.c

129

struct sti_pci_softc *spc = device_private(dev);

sys/dev/pci/sti_pci.c

130

struct sti_softc *sc = &spc->sc_base;

sys/dev/pci/sti_pci.c

140

sti_check_rom(struct sti_pci_softc *spc, struct pci_attach_args *pa)

sys/dev/pci/sti_pci.c

142

struct sti_softc *sc = &spc->sc_base;

sys/dev/pci/sti_pci.c

174

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

181

sti_pci_enable_rom_internal(spc);

sys/dev/pci/sti_pci.c

188

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

204

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

218

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

221

sti_pci_enable_rom_internal(spc);

sys/dev/pci/sti_pci.c

235

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

248

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

286

sti_pci_enable_rom_internal(spc);

sys/dev/pci/sti_pci.c

305

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

316

stiromsize, 0, &spc->sc_romh);

sys/dev/pci/sti_pci.c

322

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

330

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

382

sti_pci_enable_rom_internal(struct sti_pci_softc *spc)

sys/dev/pci/sti_pci.c

386

KASSERT(spc != NULL);

sys/dev/pci/sti_pci.c

388

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/dev/pci/sti_pci.c

390

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/dev/pci/sti_pci.c

396

struct sti_pci_softc *spc = device_private(sc->sc_dev);

sys/dev/pci/sti_pci.c

399

sti_pci_enable_rom_internal(spc);

sys/dev/pci/sti_pci.c

408

sti_pci_disable_rom_internal(struct sti_pci_softc *spc)

sys/dev/pci/sti_pci.c

412

KASSERT(spc != NULL);

sys/dev/pci/sti_pci.c

414

address = pci_conf_read(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM);

sys/dev/pci/sti_pci.c

416

pci_conf_write(spc->sc_pc, spc->sc_tag, PCI_MAPREG_ROM, address);

sys/dev/pci/sti_pci.c

422

struct sti_pci_softc *spc = device_private(sc->sc_dev);

sys/dev/pci/sti_pci.c

425

sti_pci_disable_rom_internal(spc);

sys/dev/pci/sti_pci.c

98

struct sti_pci_softc *spc = device_private(self);

sys/dev/pcmcia/spc_pcmcia.c

106

struct spc_softc *spc = &sc->sc_spc;

sys/dev/pcmcia/spc_pcmcia.c

112

spc->sc_dev = self;

sys/dev/pcmcia/spc_pcmcia.c

122

spc->sc_iot = cfe->iospace[0].handle.iot;

sys/dev/pcmcia/spc_pcmcia.c

123

spc->sc_ioh = cfe->iospace[0].handle.ioh;

sys/dev/pcmcia/spc_pcmcia.c

129

spc->sc_initiator = 7; /* XXX */

sys/dev/pcmcia/spc_pcmcia.c

130

spc->sc_adapter.adapt_enable = spc_pcmcia_enable;

sys/dev/pcmcia/spc_pcmcia.c

131

spc->sc_adapter.adapt_refcnt = 1;

sys/dev/pcmcia/spc_pcmcia.c

136

spc_attach(spc);

sys/dev/pcmcia/spc_pcmcia.c

137

scsipi_adapter_delref(&spc->sc_adapter);

sys/dev/sbus/tcx.c

969

tcx_clearscreen(struct tcx_softc *sc, int spc)

sys/dev/sbus/tcx.c

976

spc64 = ((spc & 3) << 24);

sys/kern/kern_clock.c

414

struct schedstate_percpu *spc = &ci->ci_schedstate;

sys/kern/kern_clock.c

425

if (spc->spc_psdiv != psdiv) {

sys/kern/kern_clock.c

426

spc->spc_psdiv = psdiv;

sys/kern/kern_clock.c

427

spc->spc_pscnt = psdiv;

sys/kern/kern_clock.c

449

if (--spc->spc_pscnt > 0) {

sys/kern/kern_clock.c

460

spc->spc_cp_time[CP_NICE]++;

sys/kern/kern_clock.c

462

spc->spc_cp_time[CP_USER]++;

sys/kern/kern_clock.c

489

if (--spc->spc_pscnt > 0) {

sys/kern/kern_clock.c

510

spc->spc_cp_time[CP_INTR]++;

sys/kern/kern_clock.c

513

spc->spc_cp_time[CP_SYS]++;

sys/kern/kern_clock.c

515

spc->spc_cp_time[CP_IDLE]++;

sys/kern/kern_clock.c

518

spc->spc_pscnt = psdiv;

sys/kern/kern_cpu.c

315

struct schedstate_percpu *spc, *mspc = NULL;

sys/kern/kern_cpu.c

325

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

327

spc->spc_flags |= SPCF_OFFLINE;

sys/kern/kern_cpu.c

385

spc->spc_flags &= ~SPCF_OFFLINE;

sys/kern/kern_cpu.c

392

struct schedstate_percpu *spc;

sys/kern/kern_cpu.c

397

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

399

spc->spc_flags &= ~SPCF_OFFLINE;

sys/kern/kern_cpu.c

406

struct schedstate_percpu *spc;

sys/kern/kern_cpu.c

413

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

418

if ((spc->spc_flags & SPCF_OFFLINE) == 0)

sys/kern/kern_cpu.c

422

if ((spc->spc_flags & SPCF_OFFLINE) != 0)

sys/kern/kern_cpu.c

432

if (ci2->ci_schedstate.spc_psid != spc->spc_psid)

sys/kern/kern_cpu.c

444

KASSERT((spc->spc_flags & SPCF_OFFLINE) == 0);

sys/kern/kern_cpu.c

447

if ((spc->spc_flags & SPCF_OFFLINE) == 0) {

sys/kern/kern_cpu.c

454

spc->spc_lastmod = time_second;

sys/kern/kern_cpu.c

498

struct schedstate_percpu *spc;

sys/kern/kern_cpu.c

501

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

503

spc->spc_flags &= ~SPCF_NOINTR;

sys/kern/kern_cpu.c

510

struct schedstate_percpu *spc;

sys/kern/kern_cpu.c

513

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

515

spc->spc_flags |= SPCF_NOINTR;

sys/kern/kern_cpu.c

522

struct schedstate_percpu *spc;

sys/kern/kern_cpu.c

529

spc = &ci->ci_schedstate;

sys/kern/kern_cpu.c

534

if ((spc->spc_flags & SPCF_NOINTR) == 0)

sys/kern/kern_cpu.c

540

if ((spc->spc_flags & SPCF_NOINTR) != 0)

sys/kern/kern_cpu.c

562

KASSERT((spc->spc_flags & SPCF_NOINTR) == 0);

sys/kern/kern_cpu.c

563

} else if ((spc->spc_flags & SPCF_NOINTR) == 0) {

sys/kern/kern_cpu.c

570

spc->spc_lastmod = time_second;

sys/kern/kern_idle.c

48

struct schedstate_percpu *spc;

sys/kern/kern_idle.c

54

spc = &ci->ci_schedstate;

sys/kern/kern_idle.c

55

KASSERT(lwp_locked(l, spc->spc_lwplock));

sys/kern/kern_idle.c

59

spc->spc_flags |= SPCF_RUNNING;

sys/kern/kern_idle.c

83

if ((spc->spc_flags & SPCF_OFFLINE) == 0) {

sys/kern/kern_runq.c

1076

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

1085

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

1086

if (__predict_false(spc->spc_migrating != NULL))

sys/kern/kern_runq.c

1090

if (__predict_false(spc->spc_count == 0))

sys/kern/kern_runq.c

1094

KASSERT(spc->spc_bitmap[spc->spc_maxpriority >> BITMAP_SHIFT]);

sys/kern/kern_runq.c

1095

q_head = sched_getrq(spc, spc->spc_maxpriority);

sys/kern/kern_runq.c

1113

const struct schedstate_percpu *spc;

sys/kern/kern_runq.c

1118

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

1119

rv = (spc->spc_count != 0);

sys/kern/kern_runq.c

1188

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

1196

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

1206

spc->spc_count, spc->spc_maxpriority,

sys/kern/kern_runq.c

1207

spc->spc_migrating);

sys/kern/kern_runq.c

1211

q = spc->spc_bitmap[i];

sys/kern/kern_runq.c

138

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

143

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

144

spc->spc_nextpkg = ci;

sys/kern/kern_runq.c

146

if (spc->spc_lwplock == NULL) {

sys/kern/kern_runq.c

147

spc->spc_lwplock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SCHED);

sys/kern/kern_runq.c

151

lwp0.l_mutex = spc->spc_lwplock;

sys/kern/kern_runq.c

153

if (spc->spc_mutex != NULL) {

sys/kern/kern_runq.c

159

size = roundup2(sizeof(spc->spc_queue[0]) * PRI_COUNT, coherency_unit) +

sys/kern/kern_runq.c

162

spc->spc_queue = (void *)roundup2((uintptr_t)p, coherency_unit);

sys/kern/kern_runq.c

165

spc->spc_mutex = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SCHED);

sys/kern/kern_runq.c

167

TAILQ_INIT(&spc->spc_queue[i]);

sys/kern/kern_runq.c

174

sched_getrq(struct schedstate_percpu *spc, const pri_t prio)

sys/kern/kern_runq.c

178

return &spc->spc_queue[prio];

sys/kern/kern_runq.c

188

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

194

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

198

q_head = sched_getrq(spc, eprio);

sys/kern/kern_runq.c

206

KASSERT((spc->spc_bitmap[i] & q) == 0);

sys/kern/kern_runq.c

207

spc->spc_bitmap[i] |= q;

sys/kern/kern_runq.c

237

spc->spc_flags &= ~SPCF_IDLE;

sys/kern/kern_runq.c

238

spc->spc_count++;

sys/kern/kern_runq.c

240

atomic_store_relaxed(&spc->spc_mcount,

sys/kern/kern_runq.c

241

atomic_load_relaxed(&spc->spc_mcount) + 1);

sys/kern/kern_runq.c

248

if (eprio > spc->spc_maxpriority)

sys/kern/kern_runq.c

249

spc->spc_maxpriority = eprio;

sys/kern/kern_runq.c

262

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

265

spc = &l->l_cpu->ci_schedstate;

sys/kern/kern_runq.c

267

KASSERT(lwp_locked(l, spc->spc_mutex));

sys/kern/kern_runq.c

268

KASSERT(eprio <= spc->spc_maxpriority);

sys/kern/kern_runq.c

269

KASSERT(spc->spc_bitmap[eprio >> BITMAP_SHIFT] != 0);

sys/kern/kern_runq.c

270

KASSERT(spc->spc_count > 0);

sys/kern/kern_runq.c

272

if (spc->spc_migrating == l)

sys/kern/kern_runq.c

273

spc->spc_migrating = NULL;

sys/kern/kern_runq.c

275

spc->spc_count--;

sys/kern/kern_runq.c

277

atomic_store_relaxed(&spc->spc_mcount,

sys/kern/kern_runq.c

278

atomic_load_relaxed(&spc->spc_mcount) - 1);

sys/kern/kern_runq.c

281

q_head = sched_getrq(spc, eprio);

sys/kern/kern_runq.c

290

KASSERT((spc->spc_bitmap[i] & q) != 0);

sys/kern/kern_runq.c

291

spc->spc_bitmap[i] &= ~q;

sys/kern/kern_runq.c

297

if (eprio != spc->spc_maxpriority)

sys/kern/kern_runq.c

301

if (spc->spc_bitmap[i] != 0) {

sys/kern/kern_runq.c

302

q = ffs(spc->spc_bitmap[i]);

sys/kern/kern_runq.c

303

spc->spc_maxpriority =

sys/kern/kern_runq.c

310

spc->spc_maxpriority = 0;

sys/kern/kern_runq.c

322

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

326

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

328

KASSERT(mutex_owned(spc->spc_mutex));

sys/kern/kern_runq.c

334

if (pri <= spc->spc_curpriority || !mp_online) {

sys/kern/kern_runq.c

455

const struct schedstate_percpu *spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

459

if (__predict_false(spc->spc_flags & SPCF_OFFLINE))

sys/kern/kern_runq.c

467

return (spc->spc_psid == l->l_psid);

sys/kern/kern_runq.c

476

struct schedstate_percpu *spc = &curcpu()->ci_schedstate;

sys/kern/kern_runq.c

478

spc->spc_nextpkg =

sys/kern/kern_runq.c

479

spc->spc_nextpkg->ci_sibling[CPUREL_PACKAGE1ST];

sys/kern/kern_runq.c

481

return spc->spc_nextpkg;

sys/kern/kern_runq.c

569

struct schedstate_percpu *spc;

sys/kern/kern_runq.c

581

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

622

if (sched_migratable(l, ci) && (eprio > spc->spc_curpriority ||

sys/kern/kern_runq.c

655

struct schedstate_percpu *spc, *curspc;

sys/kern/kern_runq.c

661

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

669

if (atomic_load_relaxed(&spc->spc_mcount) < (gentle ? min_catch : 1) ||

sys/kern/kern_runq.c

670

curspc->spc_psid != spc->spc_psid) {

sys/kern/kern_runq.c

676

q_head = sched_getrq(spc, spc->spc_maxpriority);

sys/kern/kern_runq.c

717

struct schedstate_percpu *spc, *tspc;

sys/kern/kern_runq.c

720

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

725

l = spc->spc_migrating;

sys/kern/kern_runq.c

745

spc->spc_migrating = NULL;

sys/kern/kern_runq.c

770

spc->spc_migrating = NULL;

sys/kern/kern_runq.c

795

struct schedstate_percpu *spc, *tspc;

sys/kern/kern_runq.c

798

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

801

spc->spc_psid == tspc->spc_psid) {

sys/kern/kern_runq.c

819

struct schedstate_percpu *spc, *tspc;

sys/kern/kern_runq.c

823

spc = &ci->ci_schedstate;

sys/kern/kern_runq.c

832

if (spc->spc_migrating != NULL) {

sys/kern/kern_runq.c

837

if ((spc->spc_flags & SPCF_OFFLINE) != 0 || spc->spc_count != 0) {

sys/kern/kern_runq.c

855

if ((spc->spc_flags & SPCF_1STCLASS) == 0 &&

sys/kern/kern_runq.c

856

spc->spc_psid == PS_NONE) {

sys/kern/kern_runq.c

869

if (spc->spc_nextskim > getticks()) {

sys/kern/kern_runq.c

872

spc->spc_nextskim = getticks() + mstohz(skim_interval);

sys/kern/kern_runq.c

884

spc->spc_psid != tspc->spc_psid ||

sys/kern/kern_sleepq.c

123

struct schedstate_percpu *spc;

sys/kern/kern_sleepq.c

141

spc = &ci->ci_schedstate;

sys/kern/kern_sleepq.c

149

lwp_setlock(l, spc->spc_lwplock);

sys/kern/kern_sleepq.c

160

lwp_setlock(l, spc->spc_lwplock);

sys/kern/kern_sleepq.c

171

spc = &ci->ci_schedstate;

sys/kern/kern_sleepq.c

177

lwp_setlock(l, spc->spc_mutex);

sys/kern/kern_synch.c

1057

struct schedstate_percpu *spc;

sys/kern/kern_synch.c

1063

spc = &ci->ci_schedstate;

sys/kern/kern_synch.c

1066

KASSERT(lwp_locked(l, spc->spc_mutex));

sys/kern/kern_synch.c

1073

KASSERT(lwp_locked(l, spc->spc_lwplock));

sys/kern/kern_synch.c

1076

sched_resched_cpu(ci, spc->spc_maxpriority, true);

sys/kern/kern_synch.c

1086

struct schedstate_percpu *spc;

sys/kern/kern_synch.c

1092

spc = &ci->ci_schedstate;

sys/kern/kern_synch.c

1095

KASSERT(lwp_locked(l, spc->spc_mutex));

sys/kern/kern_synch.c

1103

KASSERT(lwp_locked(l, spc->spc_lwplock));

sys/kern/kern_synch.c

1107

sched_resched_cpu(ci, spc->spc_maxpriority, true);

sys/kern/kern_synch.c

549

nextlwp(struct cpu_info *ci, struct schedstate_percpu *spc)

sys/kern/kern_synch.c

565

KASSERT(lwp_locked(newl, spc->spc_mutex));

sys/kern/kern_synch.c

570

spc->spc_curpriority = lwp_eprio(newl);

sys/kern/kern_synch.c

571

spc->spc_flags &= ~(SPCF_SWITCHCLEAR | SPCF_IDLE);

sys/kern/kern_synch.c

572

lwp_setlock(newl, spc->spc_lwplock);

sys/kern/kern_synch.c

580

spc->spc_curpriority = PRI_IDLE;

sys/kern/kern_synch.c

581

spc->spc_flags = (spc->spc_flags & ~SPCF_SWITCHCLEAR) |

sys/kern/kern_synch.c

611

struct schedstate_percpu *spc;

sys/kern/kern_synch.c

631

spc = &ci->ci_schedstate;

sys/kern/kern_synch.c

665

KASSERT(lwp_locked(l, spc->spc_lwplock));

sys/kern/kern_synch.c

668

lwp_setlock(l, spc->spc_mutex);

sys/kern/kern_synch.c

679

spc->spc_migrating = l;

sys/kern/kern_synch.c

685

newl = nextlwp(ci, spc);

sys/kern/kern_synch.c

731

if (l->l_mutex == spc->spc_mutex) {

sys/kern/kern_synch.c

736

mutex_spin_exit(spc->spc_lwplock);

sys/kern/kern_synch.c

742

mutex_spin_exit(spc->spc_mutex);

sys/kern/kern_synch.c

867

mutex_spin_exit(spc->spc_mutex);

sys/kern/kern_tc.c

324

const char *spc;

sys/kern/kern_tc.c

336

spc = "";

sys/kern/kern_tc.c

346

" Hz)", spc, tc->tc_name, tc->tc_quality,

sys/kern/kern_tc.c

357

spc = " ";

sys/kern/sched_4bsd.c

104

struct schedstate_percpu *spc = &ci->ci_schedstate;

sys/kern/sched_4bsd.c

108

spc->spc_ticks = sched_rrticks;

sys/kern/sched_4bsd.c

124

KASSERT(l->l_mutex != spc->spc_mutex);

sys/kern/sched_4bsd.c

134

if (spc->spc_flags & SPCF_SHOULDYIELD) {

sys/kern/sched_4bsd.c

141

} else if (spc->spc_flags & SPCF_SEENRR) {

sys/kern/sched_4bsd.c

148

spc->spc_flags |= SPCF_SHOULDYIELD;

sys/kern/sched_4bsd.c

156

spc->spc_flags |= SPCF_SHOULDYIELD;

sys/kern/sched_4bsd.c

158

spc->spc_flags |= SPCF_SEENRR;

sys/kern/sched_m2.c

281

struct schedstate_percpu *spc = &l->l_cpu->ci_schedstate;

sys/kern/sched_m2.c

286

spc->spc_ticks = l->l_sched.timeslice;

sys/kern/sched_m2.c

299

struct schedstate_percpu *spc = &ci->ci_schedstate;

sys/kern/sched_m2.c

307

KASSERT(l->l_mutex != spc->spc_mutex);

sys/kern/sched_m2.c

315

spc->spc_ticks = l->l_sched.timeslice;

sys/kern/sched_m2.c

340

if (lwp_eprio(l) <= spc->spc_maxpriority || l->l_target_cpu) {

sys/kern/sched_m2.c

341

spc->spc_flags |= SPCF_SHOULDYIELD;

sys/kern/sched_m2.c

346

spc->spc_ticks = l->l_sched.timeslice;

sys/kern/subr_interrupt.c

100

if ((spc->spc_flags & SPCF_NOINTR) == 0)

sys/kern/subr_interrupt.c

103

if ((spc->spc_flags & SPCF_NOINTR) != 0)

sys/kern/subr_interrupt.c

116

spc->spc_lastmod = time_second;

sys/kern/subr_interrupt.c

68

struct schedstate_percpu *spc;

sys/kern/subr_interrupt.c

73

spc = &ci->ci_schedstate;

sys/kern/subr_interrupt.c

77

spc->spc_flags &= ~SPCF_NOINTR;

sys/kern/subr_interrupt.c

79

spc->spc_flags |= SPCF_NOINTR;

sys/kern/subr_interrupt.c

90

struct schedstate_percpu *spc;

sys/kern/subr_interrupt.c

98

spc = &ci->ci_schedstate;

sys/kern/sys_pset.c

222

struct schedstate_percpu *spc;

sys/kern/sys_pset.c

224

spc = &ci->ci_schedstate;

sys/kern/sys_pset.c

225

if (spc->spc_psid != psid)

sys/kern/sys_pset.c

227

spc->spc_psid = PS_NONE;

sys/kern/sys_pset.c

306

struct schedstate_percpu *spc = NULL;

sys/kern/sys_pset.c

325

spc = ispc;

sys/kern/sys_pset.c

338

opsid = spc->spc_psid;

sys/kern/sys_pset.c

350

if (spc->spc_psid == psid)

sys/kern/sys_pset.c

356

if (psid != PS_NONE && ((spc->spc_flags & SPCF_OFFLINE) ||

sys/kern/sys_pset.c

357

(nnone == 1 && spc->spc_psid == PS_NONE))) {

sys/kern/sys_pset.c

387

spc->spc_psid = psid;

sys/lib/libsa/dosfs.c

439

if (!(fs->spc = bs->bpb.bpbSecPerClust) || fs->spc & (fs->spc - 1))

sys/lib/libsa/dosfs.c

441

fs->bsize = secbyt(fs->spc);

sys/lib/libsa/dosfs.c

537

nsec = !clus ? entsec(fs->dirents) : fs->spc;

sys/lib/libsa/dosfs.c

72

u_int spc; /* sectors per cluster */

sys/netinet/sctp_output.c

8488

long spc;

sys/netinet/sctp_output.c

8588

spc = stcb->sctp_socket->so_rcv.sb_hiwat;

sys/netinet/sctp_output.c

8589

if (spc < 0) {

sys/netinet/sctp_output.c

8590

spc = 0;

sys/netinet/sctp_output.c

8592

drp->bottle_bw = htonl(spc);

sys/netinet/sctputil.c

1977

struct sctp_paddr_change *spc;

sys/netinet/sctputil.c

1996

spc = mtod(m_notify, struct sctp_paddr_change *);

sys/netinet/sctputil.c

1997

spc->spc_type = SCTP_PEER_ADDR_CHANGE;

sys/netinet/sctputil.c

1998

spc->spc_flags = 0;

sys/netinet/sctputil.c

1999

spc->spc_length = sizeof(struct sctp_paddr_change);

sys/netinet/sctputil.c

2001

memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in));

sys/netinet/sctputil.c

2003

memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in6));

sys/netinet/sctputil.c

2005

spc->spc_state = state;

sys/netinet/sctputil.c

2006

spc->spc_error = error;

sys/netinet/sctputil.c

2007

spc->spc_assoc_id = sctp_get_associd(stcb);

usr.bin/telnet/telnet.c

1139

struct spc *spcp;

usr.bin/telnet/telnet.c

1238

struct spc *spcp;

usr.bin/telnet/telnet.c

1262

struct spc *spcp;

usr.bin/telnet/telnet.c

1330

struct spc *spcp;

usr.bin/telnet/telnet.c

1395

struct spc *spcp;

usr.bin/tftp/tftp.c

638

const char *spc;

usr.bin/tftp/tftp.c

701

spc = "";

usr.bin/tftp/tftp.c

705

(void)printf("%s%s=%s", spc, opt, cp);

usr.bin/tftp/tftp.c

706

spc = ", ";

usr.sbin/diskpart/diskpart.c

124

int spc, def, part, layout, j, ch;

usr.sbin/diskpart/diskpart.c

176

spc = dp->d_secpercyl;

usr.sbin/diskpart/diskpart.c

188

threshold = howmany(spc, badsecttable);

usr.sbin/diskpart/diskpart.c

199

dp->d_ncylinders = howmany(totsize, spc);

usr.sbin/diskpart/diskpart.c

200

badsecttable = spc * dp->d_ncylinders - totsize;

usr.sbin/diskpart/diskpart.c

212

curcyl += howmany(defpart[def][part], spc);

usr.sbin/diskpart/diskpart.c

231

numcyls[part] = howmany(defpart[def][part], spc);

usr.sbin/diskpart/diskpart.c

239

defpart[def][PART('f')] = numcyls[PART('f')] * spc - badsecttable;

usr.sbin/diskpart/diskpart.c

240

defpart[def][PART('g')] = numcyls[PART('g')] * spc - badsecttable;

usr.sbin/diskpart/diskpart.c

241

defpart[def][PART('c')] = numcyls[PART('c')] * spc;

usr.sbin/diskpart/diskpart.c

278

defpart[def][part], spc * startcyl[part],

usr.sbin/diskpart/diskpart.c

279

'A' + part, spc * startcyl[part],

usr.sbin/diskpart/diskpart.c

280

spc * startcyl[part] + defpart[def][part] - 1);

usr.sbin/diskpart/diskpart.c

324

'a' + part, spc * startcyl[part],

usr.sbin/diskpart/diskpart.c

338

'a' + part, spc * startcyl[part],

usr.sbin/diskpart/diskpart.c

356

defpart[def][part], startcyl[part] * spc,

usr.sbin/diskpart/diskpart.c

358

defpart[def][part] % spc ? "*" : "");

usr.sbin/makefs/ffs.c

330

int32_t spc, nspf, ncyl, fssize;

usr.sbin/sunlabel/sunlabel.c

1031

if (label.spc) {

usr.sbin/sunlabel/sunlabel.c

1032

printf("%u/%u/%u - ", p[i].nblk / label.spc,

usr.sbin/sunlabel/sunlabel.c

1033

(p[i].nblk % label.spc) / label.nsect,

usr.sbin/sunlabel/sunlabel.c

124

uint32_t spc; /* Sectors per cylinder - nhead*nsect */

usr.sbin/sunlabel/sunlabel.c

362

if (label.spc == 0) {

usr.sbin/sunlabel/sunlabel.c

365

p->endcyl = p->startcyl + how_many(p->nblk, label.spc);

usr.sbin/sunlabel/sunlabel.c

412

label.spc = 0;

usr.sbin/sunlabel/sunlabel.c

453

label.spc = label.nhead * label.nsect;

usr.sbin/sunlabel/sunlabel.c

766

* label.spc;

usr.sbin/sunlabel/sunlabel.c

769

* label.spc;

usr.sbin/sunlabel/sunlabel.c

785

* label.spc;

usr.sbin/sunlabel/sunlabel.c

823

if (label.spc && (size % label.spc)) {

usr.sbin/sunlabel/sunlabel.c

825

size / label.spc,

usr.sbin/sunlabel/sunlabel.c

826

(size % label.spc) / label.nsect, size % label.nsect);

usr.sbin/sunlabel/sunlabel.c

831

if ((label.partitions[pno].startcyl * label.spc)

usr.sbin/sunlabel/sunlabel.c

832

+ label.partitions[pno].nblk > label.spc * label.ncyl) {

usr.sbin/sunlabel/sunlabel.c

914

label.spc = label.nhead * label.nsect;