home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume6 / sh.ulimit < prev    next >
Text File  |  1986-11-30  |  12KB  |  478 lines
  1. Subject: v06i049:  Add ksh-style 'ulimit' to 4.2BSD /bin/sh (sh.ulimit)
  2. Newsgroups: mod.sources
  3. Approved: rs@mirror.UUCP
  4.  
  5. Submitted by: seismo!gatech!emory!arnold (Arnold D. Robbins {EUCC})
  6. Mod.sources: Volume 6, Issue 49
  7. Archive-name: sh.ulimit
  8.  
  9. The 4.2 BSD sh does not have any functional equivalent of the csh's 'limit'
  10. built-in command. Below are some patches that provide the "ulimit" builtin,
  11. basically compatible with that implemented in the ksh, which understands the
  12. various BSD resource limits, as well as those available in System V. (Actually,
  13. it is a little different in the output format; but at the time I wrote the code,
  14. I only had ksh doc to go by, and not the ksh to test against. Oh well. 95% now
  15. is better than 100% in two weeks.)
  16.  
  17. *** WARNING: This code has only been minimally tested in the BSD sh!!! ***
  18. It is however, very straightforward, and shouldn't give you too many problems.
  19. I pulled it out of the work I've been doing on the System V Release 2 shell.
  20. (That work is still in progress, and maybe once things settle down with 4.3,
  21. I'll be able to get back to it and post something.) It should be adaptable
  22. to System V shells currently running under 4.2, such as the one in Doug
  23. Gwyn's S5 emulation, and/or the Sun 3.0 shell (if you have source). Sun is
  24. welcome to pick this up and add it in, as it is mostly based on Doug's code,
  25. which is public domain.
  26.  
  27. This posting was motivated by some discussion a while back in net.unix and
  28. net.unix-wizards. I hope it meets a need. (As for those who want job control
  29. for the shell, see the nine part sh posting in volume 1 of mod.sources that I
  30. did last summer. Several parts of that were diffs to the BSD sh, as well as
  31. the S5R2 sh. I am working on that some more too.)
  32.  
  33. Enjoy,
  34.     Arnold Robbins
  35.     CSNET:    arnold@emory    BITNET:    arnold@emoryu1
  36.     ARPA:    arnold%emory.csnet@csnet-relay.arpa
  37.     UUCP:    { akgua, decvax, gatech, sb1, sb6, sunatl }!emory!arnold
  38. -------------------------------------------------------------------------
  39. #! /bin/sh
  40. # This is a shell archive, meaning:
  41. # 1. Remove everything above the #! /bin/sh line.
  42. # 2. Save the resulting text in a file.
  43. # 3. Execute the file with /bin/sh (not csh) to create the files:
  44. #    sh.patch
  45. #    ulimit.c
  46. # This archive created: Mon Jun 30 16:14:11 1986
  47. export PATH; PATH=/bin:$PATH
  48. echo shar: extracting "'sh.patch'" '(6246 characters)'
  49. if test -f 'sh.patch'
  50. then
  51.     echo shar: will not over-write existing file "'sh.patch'"
  52. else
  53. cat << \SHAR_EOF > 'sh.patch'
  54. *** /usr/src/bin/sh/Makefile    Fri Jul  1 06:48:58 1983
  55. --- Makefile    Mon Jun 30 15:47:27 1986
  56. ***************
  57. *** 19,24
  58.   sh:    xec.o service.o error.o io.o
  59.   sh:    print.o macro.o expand.o
  60.   sh:    ctype.o msg.o
  61.   blok.o:        brkincr.h
  62.   fault.o:    brkincr.h
  63.   main.o:        brkincr.h
  64.  
  65. --- 19,25 -----
  66.   sh:    xec.o service.o error.o io.o
  67.   sh:    print.o macro.o expand.o
  68.   sh:    ctype.o msg.o
  69. + sh:    ulimit.o
  70.   blok.o:        brkincr.h
  71.   fault.o:    brkincr.h
  72.   main.o:        brkincr.h
  73. *** /usr/src/bin/sh/defs.h    Sat Jun 11 02:38:06 1983
  74. --- defs.h    Mon Jun 30 15:44:51 1986
  75. ***************
  76. *** 54,59
  77.   #define SYSREAD 17
  78.   #define SYSTST    18
  79.   #define    SYSUMASK    19
  80.   
  81.   /* used for input and output of shell */
  82.   #define INIO 10
  83.  
  84. --- 54,60 -----
  85.   #define SYSREAD 17
  86.   #define SYSTST    18
  87.   #define    SYSUMASK    19
  88. + #define SYSULIMIT    20
  89.   
  90.   /* used for input and output of shell */
  91.   #define INIO 10
  92. ***************
  93. *** 264,269
  94.   MSG        badopt;
  95.   MSG        badparam;
  96.   MSG        badsub;
  97.   MSG        nospace;
  98.   MSG        notfound;
  99.   MSG        badtrap;
  100.  
  101. --- 265,271 -----
  102.   MSG        badopt;
  103.   MSG        badparam;
  104.   MSG        badsub;
  105. + MSG        badulimit;
  106.   MSG        nospace;
  107.   MSG        notfound;
  108.   MSG        badtrap;
  109. *** /usr/src/bin/sh/msg.c    Thu Aug 11 23:21:53 1983
  110. --- msg.c    Mon Jun 30 15:45:24 1986
  111. ***************
  112. *** 26,31
  113.   MSG    badnum        = "bad number";
  114.   MSG    badparam    = "parameter not set";
  115.   MSG    badsub        = "bad substitution";
  116.   MSG    badcreate    = "cannot create";
  117.   MSG    illegal        = "illegal io";
  118.   MSG    restricted    = "restricted";
  119.  
  120. --- 26,32 -----
  121.   MSG    badnum        = "bad number";
  122.   MSG    badparam    = "parameter not set";
  123.   MSG    badsub        = "bad substitution";
  124. + MSG badulimit    = "bad ulimit";
  125.   MSG    badcreate    = "cannot create";
  126.   MSG    illegal        = "illegal io";
  127.   MSG    restricted    = "restricted";
  128. ***************
  129. *** 135,139
  130.           {"exec",    SYSEXEC},
  131.           {"times",    SYSTIMES},
  132.           {"umask",    SYSUMASK},
  133.           {0,    0},
  134.   };
  135.  
  136. --- 136,141 -----
  137.           {"exec",    SYSEXEC},
  138.           {"times",    SYSTIMES},
  139.           {"umask",    SYSUMASK},
  140. +         {"ulimit",    SYSULIMIT},
  141.           {0,    0},
  142.   };
  143. *** /usr/src/bin/sh/xec.c    Thu Aug 11 23:21:56 1983
  144. --- xec.c    Mon Jun 30 16:07:08 1986
  145. ***************
  146. *** 222,227
  147.                                           }
  148.                                           break;
  149.       
  150.                   default:
  151.                       internal=builtin(argn,com);
  152.       
  153.  
  154. --- 222,305 -----
  155.                                           }
  156.                                           break;
  157.       
  158. +                     case SYSULIMIT:    
  159. +                     {    
  160. +                         long int i;    
  161. +                         long ulimit();    
  162. +                         int command = 2;    
  163. +         
  164. +                         if (*a1 == '-')    
  165. +                         {
  166. +                             switch(*(a1+1))    {    
  167. +                             case 'f':    
  168. +                                 command = 2;    
  169. +                                 break;    
  170. +         
  171. + #ifdef rt    
  172. +                             case 'p':    
  173. +                                 command = 5;    
  174. +                                 break;    
  175. +         
  176. + #endif    
  177. +                             case 'c':
  178. +                                 command = 7;
  179. +                                 break;
  180. + 
  181. +                             case 'd':
  182. +                                 command = 9;
  183. +                                 break;
  184. + 
  185. +                             case 'm':
  186. +                                 command = 11;
  187. +                                 break;
  188. + 
  189. +                             case 't':
  190. +                                 command = 13;
  191. +                                 break;
  192. + 
  193. +                             default:    
  194. +                                 error(badopt);    
  195. +                             }    
  196. +                             a1 = com[2];    
  197. +                         }    
  198. +                         if (a1)    
  199. +                         {    
  200. +                             int c;    
  201. + 
  202. +                             i = 0;    
  203. +                             while ((c = *a1++) >= '0' && c <= '9')    
  204. +                             {    
  205. +                                 i = (i * 10) + (long)(c - '0');    
  206. +                                 if (i < 0)    
  207. +                                     error(badulimit);    
  208. +                             }    
  209. +                             if (c || i < 0)    
  210. +                                     error(badulimit);    
  211. +                         }    
  212. +                         else    
  213. +                         {    
  214. +                             i = -1;    
  215. +                             command--;    
  216. +                         }    
  217. +                                     
  218. +                         if ((i = ulimit(command,i)) < 0)    
  219. +                                 error(badulimit);    
  220. +         
  221. +                         switch (command) {    
  222. +                         case 1:
  223. + #ifdef rt
  224. +                         case 4:
  225. + #endif
  226. +                         case 6:
  227. +                         case 8:
  228. +                         case 10:
  229. +                         case 12:
  230. +                             prl(i);    
  231. +                             prc(NL);    
  232. +                         }    
  233. +                         break;    
  234. +                     }                
  235. + 
  236.                   default:
  237.                       internal=builtin(argn,com);
  238.       
  239. ***************
  240. *** 422,425
  241.       FI
  242.       execute(cmd(NL, NLFLG|MTFLG),0);
  243.       pop();
  244.   }
  245.  
  246. --- 500,532 -----
  247.       FI
  248.       execute(cmd(NL, NLFLG|MTFLG),0);
  249.       pop();
  250. + }
  251. + 
  252. + /*
  253. +  * standard itos expects 16 bit ints, so write a prl() routine
  254. +  */
  255. + 
  256. + static int prl (n)
  257. + register long n;
  258. + {
  259. +     register int i, j;
  260. +     char buf[12], c;
  261. + 
  262. +     buf[0] = '0';
  263. +     buf[1] = buf[11] = 0;
  264. +     for (i = 0; n && i < 11; i++)
  265. +     {
  266. +         buf[i] = n % 10 + '0';
  267. +         n /= 10;
  268. +     }
  269. +     buf[i] = 0;
  270. + 
  271. +     for (j = --i, i = 0; i < j ; i++, j--)
  272. +     {
  273. +         c = buf[j];
  274. +         buf[j] = buf[i];
  275. +         buf[i] = c;
  276. +     }
  277. + 
  278. +     prs(buf);
  279.   }
  280. *** /usr/man/man1/sh.1    Thu Jul 28 17:52:12 1983
  281. --- sh.1    Mon Jun 30 15:44:06 1986
  282. ***************
  283. *** 1,6
  284.   .TH SH 1 "7 February 1983"
  285.   .SH NAME
  286. ! sh, for, case, if, while, \fB:\fP, \fB.\fP, break, continue, cd, eval, exec, exit, export, login, read, readonly, set, shift, times, trap, umask, wait \- command language
  287.   .SH SYNOPSIS
  288.   .B sh
  289.   [
  290.  
  291. --- 1,6 -----
  292.   .TH SH 1 "7 February 1983"
  293.   .SH NAME
  294. ! sh, for, case, if, while, \fB:\fP, \fB.\fP, break, continue, cd, eval, exec, exit, export, login, read, readonly, set, shift, times, trap, ulimit, umask, wait \- command language
  295.   .SH SYNOPSIS
  296.   .B sh
  297.   [
  298. ***************
  299. *** 762,767
  300.   .IR sigvec (2).
  301.   .I Trap
  302.   with no arguments prints a list of commands associated with each signal number.
  303.   .TP
  304.   \fBumask \fR[ \fInnn\fR ]
  305.   The user file creation mask is set to the octal value
  306.  
  307. --- 762,813 -----
  308.   .IR sigvec (2).
  309.   .I Trap
  310.   with no arguments prints a list of commands associated with each signal number.
  311. + .TP
  312. + \fBulimit\fP \*(OK \fB\-cdfmpt\fP \*(CK \*(OK \f2n\^\fP \*(CK
  313. + imposes a size limit of
  314. + .IR n\^ .
  315. + .RS
  316. + .TP
  317. + .B \-c
  318. + imposes a size limit of
  319. + .I n\^
  320. + blocks on the size of core dumps.
  321. + .TP
  322. + .B \-d
  323. + imposes a size limit of
  324. + .I n\^
  325. + blocks on the size of the data area.
  326. + .TP
  327. + .B \-f
  328. + imposes a size limit of 
  329. + .I n
  330. + blocks on files written by child processes (files of any size may be read).
  331. + .TP
  332. + .B \-m
  333. + imposes a soft limit of
  334. + .I n\^
  335. + blocks on the size of physical memory.
  336. + .TP
  337. + .B \-p
  338. + changes the pipe size to
  339. + .I n
  340. + (\s-1UNIX\s+1/\s-1RT\s+1 only).
  341. + .TP
  342. + .B \-t
  343. + imposes a time limit of
  344. + .I n\^
  345. + seconds to be used by each process.
  346. + .PP
  347. + If no option is given,
  348. + .B \-f
  349. + is assumed.
  350. + If
  351. + .I n\^
  352. + is not given, the current limit is printed.
  353. + (As far as
  354. + .B ulimit
  355. + is concerned, a block is 512 bytes.)
  356. + .RE
  357.   .TP
  358.   \fBumask \fR[ \fInnn\fR ]
  359.   The user file creation mask is set to the octal value
  360. SHAR_EOF
  361. fi # end of overwriting check
  362. echo shar: extracting "'ulimit.c'" '(2911 characters)'
  363. if test -f 'ulimit.c'
  364. then
  365.     echo shar: will not over-write existing file "'ulimit.c'"
  366. else
  367. cat << \SHAR_EOF > 'ulimit.c'
  368. #ifndef lint
  369. static char RCSid[] = "$Header: ulimit.c,v 1.4 85/12/09 13:02:22 arnold Exp $";
  370. #endif
  371.  
  372. /*
  373.  * $Log:    ulimit.c,v $
  374.  * Revision 1.4  85/12/09  13:02:22  arnold
  375.  * changed the declaration of limit to keep lint happy
  376.  * 
  377.  * Revision 1.3  85/12/03  16:18:42  arnold
  378.  * Fixed original code to use symbolic constants from the header files
  379.  * Added many more commands for use with the ksh style ulimit command,
  380.  * for the BSD limits.
  381.  * 
  382.  * Revision 1.2  85/11/18  10:04:46  arnold
  383.  * Updated from bare S5R2 to my first release
  384.  * 
  385.  * Revision 1.1  85/11/15  12:19:05  arnold
  386.  * Initial revision
  387.  * 
  388.  * 
  389.  */
  390.  
  391. /*
  392.     ulimit -- system call emulation for Bourne shell on 4.2BSD
  393.  
  394.     last edit:    22-Aug-1983    D A Gwyn
  395. */
  396.  
  397. #include    <sys/time.h>
  398. #include    <sys/resource.h>
  399. #include    <errno.h>
  400.  
  401. extern int    getrlimit(), setrlimit();
  402. extern int    errno;
  403.  
  404. #define BLOCK    512L    /* all these things are done in "blocks" */
  405.  
  406. long
  407. ulimit (cmd, newlimit)
  408. int    cmd;            /* subcommand */
  409. long    newlimit;        /* desired new limit */
  410. {
  411.     struct rlimit limit;    /* data being gotten/set */
  412.  
  413.     switch (cmd) {
  414.     case 1:             /* get file size limit */
  415.         if (getrlimit (RLIMIT_FSIZE, &limit) != 0 )
  416.             return -1L;    /* errno is already set */
  417.         return limit.rlim_max / BLOCK;
  418.  
  419.     case 2:             /* set file size limit */
  420.         limit.rlim_cur = limit.rlim_max = newlimit * BLOCK;
  421.         return setrlimit (RLIMIT_FSIZE, &limit);
  422.  
  423.     case 3:             /* get maximum break value */
  424.         if (getrlimit (RLIMIT_DATA, &limit) != 0)
  425.             return -1L;    /* errno is already set */
  426.         return limit.rlim_max;
  427.  
  428.     case 6:        /* get core file size limit */
  429.         if (getrlimit (RLIMIT_CORE, &limit) != 0)
  430.             return -1L;    /* errno already set */
  431.         return limit.rlim_max / BLOCK;
  432.  
  433.     case 7:        /* set core file size limit */
  434.         limit.rlim_cur = limit.rlim_max = newlimit * BLOCK;
  435.         return setrlimit (RLIMIT_CORE, &limit);
  436.  
  437.     case 8:        /* get data segment size limit */
  438.         if (getrlimit (RLIMIT_DATA, &limit) != 0)
  439.             return -1L;    /* errno already set */
  440.         return limit.rlim_max / BLOCK;
  441.  
  442.     case 9:        /* set data segment size limit */
  443.         limit.rlim_cur = limit.rlim_max = newlimit * BLOCK;
  444.         return setrlimit (RLIMIT_DATA, &limit);
  445.  
  446.     case 10:    /* get physical memory limit */
  447.         if (getrlimit (RLIMIT_RSS, &limit) != 0)
  448.             return -1L;    /* errno already set */
  449.         return limit.rlim_max / BLOCK;
  450.  
  451.     case 11:    /* set physical memory limit */
  452.         limit.rlim_cur = newlimit * BLOCK;
  453.         return setrlimit (RLIMIT_RSS, &limit);
  454.  
  455.     case 12:    /* get cpu time limit */
  456.         if (getrlimit (RLIMIT_CPU, &limit) != 0)
  457.             return -1L;    /* errno already set */
  458.         return limit.rlim_max / 1000L;    /* system uses milliseconds */
  459.  
  460.     case 13:    /* set cpu time limit */
  461.         limit.rlim_cur = limit.rlim_max = newlimit * 1000L;
  462.         return setrlimit (RLIMIT_CPU, &limit);
  463.  
  464.     case 4:
  465.     case 5:
  466.         /* These two are for getting and setting the pipe */
  467.         /* size under UNIX/RT -- not applicable here */
  468.         /* so fall thru and complain */
  469.     default:
  470.         errno = EINVAL;
  471.         return -1L;
  472.     }
  473. }
  474. SHAR_EOF
  475. fi # end of overwriting check
  476. #    End of shell archive
  477. exit 0
  478.