home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V6 / usr / sys / ken / sys2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1975-07-18  |  4.0 KB  |  290 lines
  1. #
  2. #include "../param.h"
  3. #include "../systm.h"
  4. #include "../user.h"
  5. #include "../reg.h"
  6. #include "../file.h"
  7. #include "../inode.h"
  8.  
  9. /*
  10.  * read system call
  11.  */
  12. read()
  13. {
  14.     rdwr(FREAD);
  15. }
  16.  
  17. /*
  18.  * write system call
  19.  */
  20. write()
  21. {
  22.     rdwr(FWRITE);
  23. }
  24.  
  25. /*
  26.  * common code for read and write calls:
  27.  * check permissions, set base, count, and offset,
  28.  * and switch out to readi, writei, or pipe code.
  29.  */
  30. rdwr(mode)
  31. {
  32.     register *fp, m;
  33.  
  34.     m = mode;
  35.     fp = getf(u.u_ar0[R0]);
  36.     if(fp == NULL)
  37.         return;
  38.     if((fp->f_flag&m) == 0) {
  39.         u.u_error = EBADF;
  40.         return;
  41.     }
  42.     u.u_base = u.u_arg[0];
  43.     u.u_count = u.u_arg[1];
  44.     u.u_segflg = 0;
  45.     if(fp->f_flag&FPIPE) {
  46.         if(m==FREAD)
  47.             readp(fp); else
  48.             writep(fp);
  49.     } else {
  50.         u.u_offset[1] = fp->f_offset[1];
  51.         u.u_offset[0] = fp->f_offset[0];
  52.         if(m==FREAD)
  53.             readi(fp->f_inode); else
  54.             writei(fp->f_inode);
  55.         dpadd(fp->f_offset, u.u_arg[1]-u.u_count);
  56.     }
  57.     u.u_ar0[R0] = u.u_arg[1]-u.u_count;
  58. }
  59.  
  60. /*
  61.  * open system call
  62.  */
  63. open()
  64. {
  65.     register *ip;
  66.     extern uchar;
  67.  
  68.     ip = namei(&uchar, 0);
  69.     if(ip == NULL)
  70.         return;
  71.     u.u_arg[1]++;
  72.     open1(ip, u.u_arg[1], 0);
  73. }
  74.  
  75. /*
  76.  * creat system call
  77.  */
  78. creat()
  79. {
  80.     register *ip;
  81.     extern uchar;
  82.  
  83.     ip = namei(&uchar, 1);
  84.     if(ip == NULL) {
  85.         if(u.u_error)
  86.             return;
  87.         ip = maknode(u.u_arg[1]&07777&(~ISVTX));
  88.         if (ip==NULL)
  89.             return;
  90.         open1(ip, FWRITE, 2);
  91.     } else
  92.         open1(ip, FWRITE, 1);
  93. }
  94.  
  95. /*
  96.  * common code for open and creat.
  97.  * Check permissions, allocate an open file structure,
  98.  * and call the device open routine if any.
  99.  */
  100. open1(ip, mode, trf)
  101. int *ip;
  102. {
  103.     register struct file *fp;
  104.     register *rip, m;
  105.     int i;
  106.  
  107.     rip = ip;
  108.     m = mode;
  109.     if(trf != 2) {
  110.         if(m&FREAD)
  111.             access(rip, IREAD);
  112.         if(m&FWRITE) {
  113.             access(rip, IWRITE);
  114.             if((rip->i_mode&IFMT) == IFDIR)
  115.                 u.u_error = EISDIR;
  116.         }
  117.     }
  118.     if(u.u_error)
  119.         goto out;
  120.     if(trf)
  121.         itrunc(rip);
  122.     prele(rip);
  123.     if ((fp = falloc()) == NULL)
  124.         goto out;
  125.     fp->f_flag = m&(FREAD|FWRITE);
  126.     fp->f_inode = rip;
  127.     i = u.u_ar0[R0];
  128.     openi(rip, m&FWRITE);
  129.     if(u.u_error == 0)
  130.         return;
  131.     u.u_ofile[i] = NULL;
  132.     fp->f_count--;
  133.  
  134. out:
  135.     iput(rip);
  136. }
  137.  
  138. /*
  139.  * close system call
  140.  */
  141. close()
  142. {
  143.     register *fp;
  144.  
  145.     fp = getf(u.u_ar0[R0]);
  146.     if(fp == NULL)
  147.         return;
  148.     u.u_ofile[u.u_ar0[R0]] = NULL;
  149.     closef(fp);
  150. }
  151.  
  152. /*
  153.  * seek system call
  154.  */
  155. seek()
  156. {
  157.     int n[2];
  158.     register *fp, t;
  159.  
  160.     fp = getf(u.u_ar0[R0]);
  161.     if(fp == NULL)
  162.         return;
  163.     if(fp->f_flag&FPIPE) {
  164.         u.u_error = ESPIPE;
  165.         return;
  166.     }
  167.     t = u.u_arg[1];
  168.     if(t > 2) {
  169.         n[1] = u.u_arg[0]<<9;
  170.         n[0] = u.u_arg[0]>>7;
  171.         if(t == 3)
  172.             n[0] =& 0777;
  173.     } else {
  174.         n[1] = u.u_arg[0];
  175.         n[0] = 0;
  176.         if(t!=0 && n[1]<0)
  177.             n[0] = -1;
  178.     }
  179.     switch(t) {
  180.  
  181.     case 1:
  182.     case 4:
  183.         n[0] =+ fp->f_offset[0];
  184.         dpadd(n, fp->f_offset[1]);
  185.         break;
  186.  
  187.     default:
  188.         n[0] =+ fp->f_inode->i_size0&0377;
  189.         dpadd(n, fp->f_inode->i_size1);
  190.  
  191.     case 0:
  192.     case 3:
  193.         ;
  194.     }
  195.     fp->f_offset[1] = n[1];
  196.     fp->f_offset[0] = n[0];
  197. }
  198.  
  199. /*
  200.  * link system call
  201.  */
  202. link()
  203. {
  204.     register *ip, *xp;
  205.     extern uchar;
  206.  
  207.     ip = namei(&uchar, 0);
  208.     if(ip == NULL)
  209.         return;
  210.     if(ip->i_nlink >= 127) {
  211.         u.u_error = EMLINK;
  212.         goto out;
  213.     }
  214.     if((ip->i_mode&IFMT)==IFDIR && !suser())
  215.         goto out;
  216.     /*
  217.      * unlock to avoid possibly hanging the namei
  218.      */
  219.     ip->i_flag =& ~ILOCK;
  220.     u.u_dirp = u.u_arg[1];
  221.     xp = namei(&uchar, 1);
  222.     if(xp != NULL) {
  223.         u.u_error = EEXIST;
  224.         iput(xp);
  225.     }
  226.     if(u.u_error)
  227.         goto out;
  228.     if(u.u_pdir->i_dev != ip->i_dev) {
  229.         iput(u.u_pdir);
  230.         u.u_error = EXDEV;
  231.         goto out;
  232.     }
  233.     wdir(ip);
  234.     ip->i_nlink++;
  235.     ip->i_flag =| IUPD;
  236.  
  237. out:
  238.     iput(ip);
  239. }
  240.  
  241. /*
  242.  * mknod system call
  243.  */
  244. mknod()
  245. {
  246.     register *ip;
  247.     extern uchar;
  248.  
  249.     if(suser()) {
  250.         ip = namei(&uchar, 1);
  251.         if(ip != NULL) {
  252.             u.u_error = EEXIST;
  253.             goto out;
  254.         }
  255.     }
  256.     if(u.u_error)
  257.         return;
  258.     ip = maknode(u.u_arg[1]);
  259.     if (ip==NULL)
  260.         return;
  261.     ip->i_addr[0] = u.u_arg[2];
  262.  
  263. out:
  264.     iput(ip);
  265. }
  266.  
  267. /*
  268.  * sleep system call
  269.  * not to be confused with the sleep internal routine.
  270.  */
  271. sslep()
  272. {
  273.     char *d[2];
  274.  
  275.     spl7();
  276.     d[0] = time[0];
  277.     d[1] = time[1];
  278.     dpadd(d, u.u_ar0[R0]);
  279.  
  280.     while(dpcmp(d[0], d[1], time[0], time[1]) > 0) {
  281.         if(dpcmp(tout[0], tout[1], time[0], time[1]) <= 0 ||
  282.            dpcmp(tout[0], tout[1], d[0], d[1]) > 0) {
  283.             tout[0] = d[0];
  284.             tout[1] = d[1];
  285.         }
  286.         sleep(tout, PSLEP);
  287.     }
  288.     spl0();
  289. }
  290.