2.9BSD - /usr/src/sys/sys/prim.c

   1: #include "param.h"
   2: #include "dh.h"
   3: #include "dz.h"
   4: #include <sys/tty.h>
   5: #include <sys/systm.h>
   6: #include <sys/conf.h>
   7: #include <sys/buf.h>
   8: #include <sys/seg.h>
   9: #include <sys/map.h>
  10: #include <sys/uba.h>
  11: 
  12: /*
  13:  *	SCCS id	@(#)prim.c	2.1 (Berkeley)	8/5/83
  14:  */
  15: 
  16: 
  17: #ifdef UCB_CLIST
  18: /*
  19:  *  Modification to move clists out of kernel data space.
  20:  *  Clist space is allocated by startup.
  21:  */
  22: memaddr clststrt;       /* Physical click address of clist */
  23: extern unsigned clstdesc;   /* PDR for clist segment when mapped */
  24: struct  cblock *cfree = SEG5;   /* Virt. Addr. of clists (0120000 - 0140000) */
  25: 
  26: #else UCB_CLIST
  27: extern  struct cblock cfree[];
  28: #endif	UCB_CLIST
  29: 
  30: struct  cblock  *cfreelist;
  31: int cbad;
  32: 
  33: /*
  34:  * Character list get/put
  35:  */
  36: getc(p)
  37: register struct clist *p;
  38: {
  39:     register struct cblock *bp;
  40:     register int c, s;
  41: #ifdef UCB_CLIST
  42:     segm sav5;
  43: #endif
  44: 
  45:     s = spl6();
  46: #ifdef UCB_CLIST
  47:     saveseg5(sav5);
  48:     mapseg5(clststrt, clstdesc);
  49: #endif
  50:     if (p->c_cc <= 0) {
  51:         c = -1;
  52:         p->c_cc = 0;
  53:         p->c_cf = p->c_cl = NULL;
  54:     } else {
  55:         c = *p->c_cf++ & 0377;
  56:         if (--p->c_cc<=0) {
  57:             bp = (struct cblock *)(p->c_cf-1);
  58:             bp = (struct cblock *) ((int)bp & ~CROUND);
  59:             p->c_cf = NULL;
  60:             p->c_cl = NULL;
  61:             bp->c_next = cfreelist;
  62:             cfreelist = bp;
  63:         } else
  64:             if (((int)p->c_cf & CROUND) == 0){
  65:                 bp = (struct cblock *)(p->c_cf);
  66:                 bp--;
  67:                 p->c_cf = bp->c_next->c_info;
  68:                 bp->c_next = cfreelist;
  69:                 cfreelist = bp;
  70:             }
  71:     }
  72: #ifdef UCB_CLIST
  73:     restorseg5(sav5);
  74: #endif
  75:     splx(s);
  76:     return(c);
  77: }
  78: 
  79: #ifdef  MPX_FILS
  80: /*
  81:  * copy clist to buffer.
  82:  * return number of bytes moved.
  83:  */
  84: q_to_b(q, cp, cc)
  85: register struct clist *q;
  86: register char *cp;
  87: {
  88:     register struct cblock *bp;
  89:     register int s;
  90:     char *acp;
  91: #ifdef UCB_CLIST
  92:     segm sav5;
  93: #endif
  94: 
  95:     if (cc <= 0)
  96:         return(0);
  97:     s = spl6();
  98:     if (q->c_cc <= 0) {
  99:         q->c_cc = 0;
 100:         q->c_cf = q->c_cl = NULL;
 101:         splx(s);
 102:         return(0);
 103:     }
 104:     acp = cp;
 105:     cc++;
 106: 
 107: #ifdef UCB_CLIST
 108:     saveseg5(sav5);
 109:     mapseg5(clststrt, clstdesc);
 110: #endif
 111:     while (--cc) {
 112:         *cp++ = *q->c_cf++;
 113:         if (--q->c_cc <= 0) {
 114:             bp = (struct cblock *)(q->c_cf-1);
 115:             bp = (struct cblock *)((int)bp & ~CROUND);
 116:             q->c_cf = q->c_cl = NULL;
 117:             bp->c_next = cfreelist;
 118:             cfreelist = bp;
 119:             break;
 120:         }
 121:         if (((int)q->c_cf & CROUND) == 0) {
 122:             bp = (struct cblock *)(q->c_cf);
 123:             bp--;
 124:             q->c_cf = bp->c_next->c_info;
 125:             bp->c_next = cfreelist;
 126:             cfreelist = bp;
 127:         }
 128:     }
 129: #ifdef UCB_CLIST
 130:     restorseg5(sav5);
 131: #endif
 132:     splx(s);
 133:     return(cp-acp);
 134: }
 135: #endif	MPX_FILS
 136: 
 137: 
 138: #if NDH > 0 || (NDZ > 0 && defined(DZ_PDMA))
 139: /*
 140:  * Return count of contiguous characters
 141:  * in clist starting at q->c_cf.
 142:  * Stop counting if flag&character is non-null.
 143:  */
 144: ndqb(q, flag)
 145: register struct clist *q;
 146: {
 147:     register cc;
 148:     int s;
 149: #ifdef UCB_CLIST
 150:     segm sav5;
 151: #endif
 152: 
 153:     s = spl6();
 154:     if (q->c_cc <= 0) {
 155:         cc = -q->c_cc;
 156:         goto out;
 157:     }
 158:     cc = ((int)q->c_cf + CBSIZE) & ~CROUND;
 159:     cc -= (int)q->c_cf;
 160:     if (q->c_cc < cc)
 161:         cc = q->c_cc;
 162:     if (flag) {
 163:         register char *p, *end;
 164: 
 165: #ifdef  UCB_CLIST
 166:         saveseg5(sav5);
 167:         mapseg5(clststrt, clstdesc);
 168: #endif
 169:         p = q->c_cf;
 170:         end = p + cc;
 171:         while (p < end) {
 172:             if (*p & flag) {
 173:                 cc = (int)p;
 174:                 cc -= (int)q->c_cf;
 175:                 break;
 176:             }
 177:             p++;
 178:         }
 179: #ifdef  UCB_CLIST
 180:         restorseg5(sav5);
 181: #endif
 182:     }
 183: out:
 184:     splx(s);
 185:     return(cc);
 186: }
 187: 
 188: 
 189: 
 190: /*
 191:  * Update clist to show that cc characters
 192:  * were removed.  It is assumed that cc < CBSIZE.
 193:  */
 194: ndflush(q, cc)
 195: register struct clist *q;
 196: register cc;
 197: {
 198:     register s;
 199: #ifdef UCB_CLIST
 200:     segm sav5;
 201: #endif
 202: 
 203:     s = spl6();
 204:     if (q->c_cc < 0) {
 205:         if (q->c_cf != NULL) {
 206:             q->c_cc += cc;
 207:             q->c_cf += cc;
 208:             goto out;
 209:         }
 210:         q->c_cc = 0;
 211:         goto out;
 212:     }
 213:     if (q->c_cc == 0)
 214:         goto out;
 215:     if (cc > CBSIZE || cc <= 0) {
 216:         cbad++;
 217:         goto out;
 218:     }
 219:     q->c_cc -= cc;
 220:     q->c_cf += cc;
 221:     if (((int)q->c_cf & CROUND) == 0) {
 222:         register struct cblock *bp;
 223: #ifdef UCB_CLIST
 224:         saveseg5(sav5);
 225:         mapseg5(clststrt, clstdesc);
 226: #endif
 227: 
 228:         bp = (struct cblock *)(q->c_cf) -1;
 229:         if (bp->c_next)
 230:             q->c_cf = bp->c_next->c_info;
 231:         else
 232:             q->c_cf = q->c_cl = NULL;
 233:         bp->c_next = cfreelist;
 234:         cfreelist = bp;
 235: #ifdef UCB_CLIST
 236:         restorseg5(sav5);
 237: #endif
 238:     } else
 239:         if (q->c_cc == 0) {
 240:             register struct cblock *bp;
 241: #ifdef UCB_CLIST
 242:             saveseg5(sav5);
 243:             mapseg5(clststrt, clstdesc);
 244: #endif
 245:             q->c_cf = (char *)((int)q->c_cf & ~CROUND);
 246:             bp = (struct cblock *)(q->c_cf);
 247:             bp->c_next = cfreelist;
 248:             cfreelist = bp;
 249:             q->c_cf = q->c_cl = NULL;
 250: #ifdef UCB_CLIST
 251:             restorseg5(sav5);
 252: #endif
 253:         }
 254: out:
 255:     splx(s);
 256: }
 257: #endif	NDH || (NDZ && defined(DZ_PDMA))
 258: 
 259: putc(c, p)
 260: register struct clist *p;
 261: {
 262:     register struct cblock *bp;
 263:     register char *cp;
 264:     int s;
 265: #ifdef UCB_CLIST
 266:     segm sav5;
 267: #endif
 268: 
 269:     s = spl6();
 270: #ifdef UCB_CLIST
 271:     saveseg5(sav5);
 272:     mapseg5(clststrt, clstdesc);
 273: #endif
 274:     if ((cp = p->c_cl) == NULL || p->c_cc < 0 ) {
 275:         if ((bp = cfreelist) == NULL) {
 276: #ifdef UCB_CLIST
 277:             restorseg5(sav5);
 278: #endif
 279:             splx(s);
 280:             return(-1);
 281:         }
 282:         cfreelist = bp->c_next;
 283:         bp->c_next = NULL;
 284:         p->c_cf = cp = bp->c_info;
 285:     } else
 286:         if (((int)cp & CROUND) == 0) {
 287:             bp = (struct cblock *)cp - 1;
 288:             if ((bp->c_next = cfreelist) == NULL) {
 289: #ifdef UCB_CLIST
 290:                 restorseg5(sav5);
 291: #endif
 292:                 splx(s);
 293:                 return(-1);
 294:             }
 295:             bp = bp->c_next;
 296:             cfreelist = bp->c_next;
 297:             bp->c_next = NULL;
 298:             cp = bp->c_info;
 299:         }
 300:     *cp++ = c;
 301:     p->c_cc++;
 302:     p->c_cl = cp;
 303: #ifdef UCB_CLIST
 304:     restorseg5(sav5);
 305: #endif
 306:     splx(s);
 307:     return(0);
 308: }
 309: 
 310: 
 311: 
 312: /*
 313:  * copy buffer to clist.
 314:  * return number of bytes not transfered.
 315:  */
 316: b_to_q(cp, cc, q)
 317: register char *cp;
 318: struct clist *q;
 319: register int cc;
 320: {
 321:     register char *cq;
 322:     struct cblock *bp;
 323:     int s, acc;
 324: #ifdef UCB_CLIST
 325:     segm sav5;
 326: #endif
 327: 
 328:     if (cc <= 0)
 329:         return(0);
 330:     acc = cc;
 331: 
 332: 
 333:     s = spl6();
 334: #ifdef UCB_CLIST
 335:     saveseg5(sav5);
 336:     mapseg5(clststrt, clstdesc);
 337: #endif
 338:     if ((cq = q->c_cl) == NULL || q->c_cc < 0) {
 339:         if ((bp = cfreelist) == NULL)
 340:             goto out;
 341:         cfreelist = bp->c_next;
 342:         bp->c_next = NULL;
 343:         q->c_cf = cq = bp->c_info;
 344:     }
 345: 
 346:     while (cc) {
 347:         if (((int)cq & CROUND) == 0) {
 348:             bp = (struct cblock *) cq - 1;
 349:             if ((bp->c_next = cfreelist) == NULL)
 350:                 goto out;
 351:             bp = bp->c_next;
 352:             cfreelist = bp->c_next;
 353:             bp->c_next = NULL;
 354:             cq = bp->c_info;
 355:         }
 356:         *cq++ = *cp++;
 357:         cc--;
 358:     }
 359: out:
 360:     q->c_cl = cq;
 361:     q->c_cc += acc-cc;
 362: #ifdef UCB_CLIST
 363:     restorseg5(sav5);
 364: #endif
 365:     splx(s);
 366:     return(cc);
 367: }
 368: 
 369: /*
 370:  * Initialize clist by freeing all character blocks.
 371:  */
 372: cinit()
 373: {
 374:     register int ccp;
 375:     register struct cblock *cp;
 376:     register struct cdevsw *cdp;
 377: 
 378:     ccp = (int)cfree;
 379: #ifdef UCB_CLIST
 380:     mapseg5(clststrt, clstdesc);
 381: #else
 382:     ccp = (ccp+CROUND) & ~CROUND;
 383: #endif
 384:     for(cp=(struct cblock *)ccp; cp <= &cfree[nclist-1]; cp++) {
 385:         cp->c_next = cfreelist;
 386:         cfreelist = cp;
 387:     }
 388: #ifdef UCB_CLIST
 389:     normalseg5();
 390: #endif
 391: }
 392: 
 393: #ifdef  unneeded
 394: /*
 395:  * integer (2-byte) get/put
 396:  * using clists
 397:  */
 398: getw(p)
 399: register struct clist *p;
 400: {
 401:     register int s;
 402: 
 403:     if (p->c_cc <= 1)
 404:         return(-1);
 405:     s = getc(p);
 406:     return(s | (getc(p)<<8));
 407: }
 408: #endif	unneeded
 409: 
 410: #ifdef  MPX_FILS
 411: putw(c, p)
 412: register struct clist *p;
 413: {
 414:     register s;
 415: 
 416:     s = spl6();
 417:     if (cfreelist==NULL) {
 418:         splx(s);
 419:         return(-1);
 420:     }
 421:     putc(c, p);
 422:     putc(c>>8, p);
 423:     splx(s);
 424:     return(0);
 425: }
 426: #endif
 427: 
 428: 
 429: #ifdef UCB_NTTY
 430: /*
 431:  * Given a non-NULL pointer into the list (like c_cf which
 432:  * always points to a real character if non-NULL) return the pointer
 433:  * to the next character in the list or return NULL if no more chars.
 434:  *
 435:  * Callers must not allow getc's to happen between nextc's so that the
 436:  * pointer becomes invalid.  Note that interrupts are NOT masked.
 437:  */
 438: char *
 439: nextc(p, cp)
 440: register struct clist *p;
 441: register char *cp;
 442: {
 443:     register char *rcp;
 444: 
 445: #ifdef UCB_CLIST
 446:     segm sav5;
 447: 
 448:     saveseg5(sav5);
 449:     mapseg5(clststrt, clstdesc);
 450: #endif
 451:     if (p->c_cc && ++cp != p->c_cl) {
 452:         if (((int)cp & CROUND) == 0)
 453:             rcp = ((struct cblock *)cp)[-1].c_next->c_info;
 454:         else
 455:             rcp = cp;
 456:     }
 457:     else
 458:         rcp = (char *) NULL;
 459: #ifdef UCB_CLIST
 460:     restorseg5(sav5);
 461: #endif
 462:     return rcp;
 463: }
 464: 
 465: #ifdef  UCB_CLIST
 466: /*
 467:  * Lookc returns the character pointed at by cp, which is a nextc-style
 468:  * (e.g. possibly mapped out) char pointer.
 469:  */
 470: lookc(cp)
 471: register char *cp;
 472: {
 473:     register char rc;
 474:     segm sav5;
 475: 
 476:     saveseg5(sav5);
 477:     mapseg5(clststrt, clstdesc);
 478:     rc = *cp;
 479:     restorseg5(sav5);
 480:     return rc;
 481: }
 482: #endif
 483: 
 484: /*
 485:  * Remove the last character in the list and return it.
 486:  */
 487: unputc(p)
 488: register struct clist *p;
 489: {
 490:     register struct cblock *bp;
 491:     register int c, s;
 492:     struct cblock *obp;
 493: #ifdef UCB_CLIST
 494:     segm sav5;
 495: #endif
 496: 
 497:     s = spl6();
 498: #ifdef UCB_CLIST
 499:     saveseg5(sav5);
 500:     mapseg5(clststrt, clstdesc);
 501: #endif
 502:     if (p->c_cc <= 0)
 503:         c = -1;
 504:     else {
 505:         c = *--p->c_cl;
 506:         if (--p->c_cc <= 0) {
 507:             bp = (struct cblock *)p->c_cl;
 508:             bp = (struct cblock *)((int)bp & ~CROUND);
 509:             p->c_cl = p->c_cf = NULL;
 510:             bp->c_next = cfreelist;
 511:             cfreelist = bp;
 512:         } else
 513:             if (((int)p->c_cl & CROUND) == sizeof(bp->c_next)) {
 514:                 p->c_cl = (char *)((int)p->c_cl & ~CROUND);
 515:                 bp = (struct cblock *)p->c_cf;
 516:                 bp = (struct cblock *)((int)bp & ~CROUND);
 517:                 while (bp->c_next != (struct cblock *)p->c_cl)
 518:                     bp = bp->c_next;
 519:                 obp = bp;
 520:                 p->c_cl = (char *)(bp + 1);
 521:                 bp = bp->c_next;
 522:                 bp->c_next = cfreelist;
 523:                 cfreelist = bp;
 524:                 obp->c_next = NULL;
 525:             }
 526:     }
 527: #ifdef UCB_CLIST
 528:     restorseg5(sav5);
 529: #endif
 530:     splx(s);
 531:     return (c);
 532: }
 533: 
 534: /*
 535:  * Put the chars in the ``from'' queue
 536:  * on the end of the ``to'' queue.
 537:  */
 538: catq(from, to)
 539: struct clist *from, *to;
 540: {
 541:     register c;
 542: 
 543:     while ((c = getc(from)) >= 0)
 544:          putc(c, to);
 545: }
 546: #endif	UCB_NTTY

Defined functions

Defined variables