home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / sys / ken / text.c < prev    next >
Encoding:
C/C++ Source or Header  |  1975-07-17  |  3.1 KB  |  157 lines
  1. #
  2. /*
  3.  */
  4.  
  5. #include "../param.h"
  6. #include "../systm.h"
  7. #include "../user.h"
  8. #include "../proc.h"
  9. #include "../text.h"
  10. #include "../inode.h"
  11.  
  12. /*
  13.  * Swap out process p.
  14.  * The ff flag causes its core to be freed--
  15.  * it may be off when called to create an image for a
  16.  * child process in newproc.
  17.  * Os is the old size of the data area of the process,
  18.  * and is supplied during core expansion swaps.
  19.  *
  20.  * panic: out of swap space
  21.  * panic: swap error -- IO error
  22.  */
  23. xswap(p, ff, os)
  24. int *p;
  25. {
  26.     register *rp, a;
  27.  
  28.     rp = p;
  29.     if(os == 0)
  30.         os = rp->p_size;
  31.     a = malloc(swapmap, (rp->p_size+7)/8);
  32.     if(a == NULL)
  33.         panic("out of swap space");
  34.     xccdec(rp->p_textp);
  35.     rp->p_flag =| SLOCK;
  36.     if(swap(a, rp->p_addr, os, 0))
  37.         panic("swap error");
  38.     if(ff)
  39.         mfree(coremap, os, rp->p_addr);
  40.     rp->p_addr = a;
  41.     rp->p_flag =& ~(SLOAD|SLOCK);
  42.     rp->p_time = 0;
  43.     if(runout) {
  44.         runout = 0;
  45.         wakeup(&runout);
  46.     }
  47. }
  48.  
  49. /*
  50.  * relinquish use of the shared text segment
  51.  * of a process.
  52.  */
  53. xfree()
  54. {
  55.     register *xp, *ip;
  56.  
  57.     if((xp=u.u_procp->p_textp) != NULL) {
  58.         u.u_procp->p_textp = NULL;
  59.         xccdec(xp);
  60.         if(--xp->x_count == 0) {
  61.             ip = xp->x_iptr;
  62.             if((ip->i_mode&ISVTX) == 0) {
  63.                 xp->x_iptr = NULL;
  64.                 mfree(swapmap, (xp->x_size+7)/8, xp->x_daddr);
  65.                 ip->i_flag =& ~ITEXT;
  66.                 iput(ip);
  67.             }
  68.         }
  69.     }
  70. }
  71.  
  72. /*
  73.  * Attach to a shared text segment.
  74.  * If there is no shared text, just return.
  75.  * If there is, hook up to it:
  76.  * if it is not currently being used, it has to be read
  77.  * in from the inode (ip) and established in the swap space.
  78.  * If it is being used, but is not currently in core,
  79.  * a swap has to be done to get it back.
  80.  * The full coroutine glory has to be invoked--
  81.  * see slp.c-- because if the calling process
  82.  * is misplaced in core the text image might not fit.
  83.  * Quite possibly the code after "out:" could check to
  84.  * see if the text does fit and simply swap it in.
  85.  *
  86.  * panic: out of swap space
  87.  */
  88. xalloc(ip)
  89. int *ip;
  90. {
  91.     register struct text *xp;
  92.     register *rp, ts;
  93.  
  94.     if(u.u_arg[1] == 0)
  95.         return;
  96.     rp = NULL;
  97.     for(xp = &text[0]; xp < &text[NTEXT]; xp++)
  98.         if(xp->x_iptr == NULL) {
  99.             if(rp == NULL)
  100.                 rp = xp;
  101.         } else
  102.             if(xp->x_iptr == ip) {
  103.                 xp->x_count++;
  104.                 u.u_procp->p_textp = xp;
  105.                 goto out;
  106.             }
  107.     if((xp=rp) == NULL)
  108.         panic("out of text");
  109.     xp->x_count = 1;
  110.     xp->x_ccount = 0;
  111.     xp->x_iptr = ip;
  112.     ts = ((u.u_arg[1]+63)>>6) & 01777;
  113.     xp->x_size = ts;
  114.     if((xp->x_daddr = malloc(swapmap, (ts+7)/8)) == NULL)
  115.         panic("out of swap space");
  116.     expand(USIZE+ts);
  117.     estabur(0, ts, 0, 0);
  118.     u.u_count = u.u_arg[1];
  119.     u.u_offset[1] = 020;
  120.     u.u_base = 0;
  121.     readi(ip);
  122.     rp = u.u_procp;
  123.     rp->p_flag =| SLOCK;
  124.     swap(xp->x_daddr, rp->p_addr+USIZE, ts, 0);
  125.     rp->p_flag =& ~SLOCK;
  126.     rp->p_textp = xp;
  127.     rp = ip;
  128.     rp->i_flag =| ITEXT;
  129.     rp->i_count++;
  130.     expand(USIZE);
  131.  
  132. out:
  133.     if(xp->x_ccount == 0) {
  134.         savu(u.u_rsav);
  135.         savu(u.u_ssav);
  136.         xswap(u.u_procp, 1, 0);
  137.         u.u_procp->p_flag =| SSWAP;
  138.         swtch();
  139.         /* no return */
  140.     }
  141.     xp->x_ccount++;
  142. }
  143.  
  144. /*
  145.  * Decrement the in-core usage count of a shared text segment.
  146.  * When it drops to zero, free the core space.
  147.  */
  148. xccdec(xp)
  149. int *xp;
  150. {
  151.     register *rp;
  152.  
  153.     if((rp=xp)!=NULL && rp->x_ccount!=0)
  154.         if(--rp->x_ccount == 0)
  155.             mfree(coremap, rp->x_size, rp->x_caddr);
  156. }
  157.