  1// Linux port of xv6-riscv shell (no libc)
  2
  3#include "lib.h"
  4#include 
  5
  6// Parsed command representation
  7enum { EXEC = 1, REDIR, PIPE, LIST, BACK };
  8
  9#define MAXARGS 10
 10#define NULL ((void *)0)
 11
 12struct cmd {
 13  int type;
 14};
 15
 16struct execcmd {
 17  int type;
 18  char *argv[MAXARGS], *eargv[MAXARGS];
 19};
 20
 21struct redircmd {
 22  int type, fd, mode;
 23  char *file, *efile;
 24  struct cmd* cmd;
 25};
 26
 27struct pipecmd {
 28  int type;
 29  struct cmd *left, *right;
 30};
 31
 32struct listcmd {
 33  int type;
 34  struct cmd *left, *right;
 35};
 36
 37struct backcmd {
 38  int type;
 39  struct cmd* cmd;
 40};
 41
 42struct cmd* parsecmd(char*);
 43
 44// Execute cmd.  Never returns.
 45void runcmd(struct cmd* cmd) {
 46  int p[2];
 47  struct backcmd* bcmd;
 48  struct execcmd* ecmd;
 49  struct listcmd* lcmd;
 50  struct pipecmd* pcmd;
 51  struct redircmd* rcmd;
 52
 53  if (cmd == 0) syscall(SYS_exit, 1);
 54
 55  switch (cmd->type) {
 56    case EXEC:
 57      ecmd = (struct execcmd*)cmd;
 58      if (ecmd->argv[0] == 0) syscall(SYS_exit, 1);
 59      syscall(SYS_execve, ecmd->argv[0], ecmd->argv, NULL);
 60      print("fail to exec ", ecmd->argv[0], "\n", NULL);
 61      break;
 62
 63    case REDIR:
 64      rcmd = (struct redircmd*)cmd;
 65      syscall(SYS_close, rcmd->fd);
 66      if (syscall(SYS_open, rcmd->file, rcmd->mode, 0644) < 0) {
 67        print("fail to open ", rcmd->file, "\n", NULL);
 68        syscall(SYS_exit, 1);
 69      }
 70      runcmd(rcmd->cmd);
 71      break;
 72
 73    case LIST:
 74      lcmd = (struct listcmd*)cmd;
 75      if (syscall(SYS_fork) == 0) runcmd(lcmd->left);
 76      syscall(SYS_wait4, -1, 0, 0, 0);
 77      runcmd(lcmd->right);
 78      break;
 79
 80    case PIPE:
 81      pcmd = (struct pipecmd*)cmd;
 82      assert(syscall(SYS_pipe, p) >= 0);
 83      if (syscall(SYS_fork) == 0) {
 84        syscall(SYS_close, 1);
 85        syscall(SYS_dup, p[1]);
 86        syscall(SYS_close, p[0]);
 87        syscall(SYS_close, p[1]);
 88        runcmd(pcmd->left);
 89      }
 90      if (syscall(SYS_fork) == 0) {
 91        syscall(SYS_close, 0);
 92        syscall(SYS_dup, p[0]);
 93        syscall(SYS_close, p[0]);
 94        syscall(SYS_close, p[1]);
 95        runcmd(pcmd->right);
 96      }
 97      syscall(SYS_close, p[0]);
 98      syscall(SYS_close, p[1]);
 99      syscall(SYS_wait4, -1, 0, 0, 0);
100      syscall(SYS_wait4, -1, 0, 0, 0);
101      break;
102
103    case BACK:
104      bcmd = (struct backcmd*)cmd;
105      if (syscall(SYS_fork) == 0) runcmd(bcmd->cmd);
106      break;
107
108    default:
109      assert(0);
110  }
111  syscall(SYS_exit, 0);
112}
113
114int getcmd(char* buf, int nbuf) {
115  print("(sh-xv6) > ", NULL);
116  for (int i = 0; i < nbuf; i++) buf[i] = '\0';
117
118  while (nbuf-- > 1) {
119    int nread = syscall(SYS_read, 0, buf, 1);
120    if (nread <= 0) return -1;
121    if (*(buf++) == '\n') break;
122  }
123  return 0;
124}
125
126void _start() {
127  static char buf[100];
128
129  // Read and run input commands.
130  while (getcmd(buf, sizeof(buf)) >= 0) {
131    if (buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' ') {
132      // Chdir must be called by the parent, not the child.
133      buf[strlen(buf) - 1] = 0;  // chop \n
134      if (syscall(SYS_chdir, buf + 3) < 0)
135        print("cannot cd ", buf + 3, "\n", NULL);
136      continue;
137    }
138    if (syscall(SYS_fork) == 0) runcmd(parsecmd(buf));
139    syscall(SYS_wait4, -1, 0, 0, 0);
140  }
141  syscall(SYS_exit, 0);
142}
143
144// Constructors
145
146struct cmd* execcmd(void) {
147  struct execcmd* cmd;
148
149  cmd = zalloc(sizeof(*cmd));
150  cmd->type = EXEC;
151  return (struct cmd*)cmd;
152}
153
154struct cmd* redircmd(struct cmd* subcmd, char* file, char* efile, int mode,
155                     int fd) {
156  struct redircmd* cmd;
157
158  cmd = zalloc(sizeof(*cmd));
159  cmd->type = REDIR;
160  cmd->cmd = subcmd;
161  cmd->file = file;
162  cmd->efile = efile;
163  cmd->mode = mode;
164  cmd->fd = fd;
165  return (struct cmd*)cmd;
166}
167
168struct cmd* pipecmd(struct cmd* left, struct cmd* right) {
169  struct pipecmd* cmd;
170
171  cmd = zalloc(sizeof(*cmd));
172  cmd->type = PIPE;
173  cmd->left = left;
174  cmd->right = right;
175  return (struct cmd*)cmd;
176}
177
178struct cmd* listcmd(struct cmd* left, struct cmd* right) {
179  struct listcmd* cmd;
180
181  cmd = zalloc(sizeof(*cmd));
182  cmd->type = LIST;
183  cmd->left = left;
184  cmd->right = right;
185  return (struct cmd*)cmd;
186}
187
188struct cmd* backcmd(struct cmd* subcmd) {
189  struct backcmd* cmd;
190
191  cmd = zalloc(sizeof(*cmd));
192  cmd->type = BACK;
193  cmd->cmd = subcmd;
194  return (struct cmd*)cmd;
195}
196
197// Parsing
198
199char whitespace[] = " \t\r\n\v";
200char symbols[] = "<|>&;()";
201
202int gettoken(char** ps, char* es, char** q, char** eq) {
203  char* s;
204  int ret;
205
206  s = *ps;
207  while (s < es && strchr(whitespace, *s)) s++;
208  if (q) *q = s;
209  ret = *s;
210  switch (*s) {
211    case 0:
212      break;
213    case '|': case '(': case ')': case ';': case '&': case '<':
214      s++;
215      break;
216    case '>':
217      s++;
218      if (*s == '>') {
219        ret = '+'; s++;
220      }
221      break;
222    default:
223      ret = 'a';
224      while (s < es && !strchr(whitespace, *s) && !strchr(symbols, *s)) s++;
225      break;
226  }
227  if (eq) *eq = s;
228
229  while (s < es && strchr(whitespace, *s)) s++;
230  *ps = s;
231  return ret;
232}
233
234int peek(char** ps, char* es, char* toks) {
235  char* s;
236
237  s = *ps;
238  while (s < es && strchr(whitespace, *s)) s++;
239  *ps = s;
240  return *s && strchr(toks, *s);
241}
242
243struct cmd* parseline(char**, char*);
244struct cmd* parsepipe(char**, char*);
245struct cmd* parseexec(char**, char*);
246struct cmd* nulterminate(struct cmd*);
247
248struct cmd* parsecmd(char* s) {
249  char* es;
250  struct cmd* cmd;
251
252  es = s + strlen(s);
253  cmd = parseline(&s, es);
254  peek(&s, es, "");
255  assert(s == es);
256  nulterminate(cmd);
257  return cmd;
258}
259
260struct cmd* parseline(char** ps, char* es) {
261  struct cmd* cmd;
262
263  cmd = parsepipe(ps, es);
264  while (peek(ps, es, "&")) {
265    gettoken(ps, es, 0, 0);
266    cmd = backcmd(cmd);
267  }
268  if (peek(ps, es, ";")) {
269    gettoken(ps, es, 0, 0);
270    cmd = listcmd(cmd, parseline(ps, es));
271  }
272  return cmd;
273}
274
275struct cmd* parsepipe(char** ps, char* es) {
276  struct cmd* cmd;
277
278  cmd = parseexec(ps, es);
279  if (peek(ps, es, "|")) {
280    gettoken(ps, es, 0, 0);
281    cmd = pipecmd(cmd, parsepipe(ps, es));
282  }
283  return cmd;
284}
285
286struct cmd* parseredirs(struct cmd* cmd, char** ps, char* es) {
287  int tok;
288  char *q, *eq;
289
290  while (peek(ps, es, "<>")) {
291    tok = gettoken(ps, es, 0, 0);
292    assert(gettoken(ps, es, &q, &eq) == 'a');
293    switch (tok) {
294      case '<':
295        cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
296        break;
297      case '>':
298        cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREAT | O_TRUNC, 1);
299        break;
300      case '+':  // >>
301        cmd = redircmd(cmd, q, eq, O_WRONLY | O_CREAT, 1);
302        break;
303    }
304  }
305  return cmd;
306}
307
308struct cmd* parseblock(char** ps, char* es) {
309  struct cmd* cmd;
310
311  assert(peek(ps, es, "("));
312  gettoken(ps, es, 0, 0);
313  cmd = parseline(ps, es);
314  assert(peek(ps, es, ")"));
315  gettoken(ps, es, 0, 0);
316  cmd = parseredirs(cmd, ps, es);
317  return cmd;
318}
319
320struct cmd* parseexec(char** ps, char* es) {
321  char *q, *eq;
322  int tok, argc;
323  struct execcmd* cmd;
324  struct cmd* ret;
325
326  if (peek(ps, es, "(")) return parseblock(ps, es);
327
328  ret = execcmd();
329  cmd = (struct execcmd*)ret;
330
331  argc = 0;
332  ret = parseredirs(ret, ps, es);
333  while (!peek(ps, es, "|)&;")) {
334    if ((tok = gettoken(ps, es, &q, &eq)) == 0) break;
335    assert(tok == 'a');
336    cmd->argv[argc] = q;
337    cmd->eargv[argc] = eq;
338    assert(++argc < MAXARGS);
339    ret = parseredirs(ret, ps, es);
340  }
341  cmd->argv[argc] = 0;
342  cmd->eargv[argc] = 0;
343  return ret;
344}
345
346// NUL-terminate all the counted strings.
347struct cmd* nulterminate(struct cmd* cmd) {
348  int i;
349  struct backcmd* bcmd;
350  struct execcmd* ecmd;
351  struct listcmd* lcmd;
352  struct pipecmd* pcmd;
353  struct redircmd* rcmd;
354
355  if (cmd == 0) return 0;
356
357  switch (cmd->type) {
358    case EXEC:
359      ecmd = (struct execcmd*)cmd;
360      for (i = 0; ecmd->argv[i]; i++) *ecmd->eargv[i] = 0;
361      break;
362
363    case REDIR:
364      rcmd = (struct redircmd*)cmd;
365      nulterminate(rcmd->cmd);
366      *rcmd->efile = 0;
367      break;
368
369    case PIPE:
370      pcmd = (struct pipecmd*)cmd;
371      nulterminate(pcmd->left);
372      nulterminate(pcmd->right);
373      break;
374
375    case LIST:
376      lcmd = (struct listcmd*)cmd;
377      nulterminate(lcmd->left);
378      nulterminate(lcmd->right);
379      break;
380
381    case BACK:
382      bcmd = (struct backcmd*)cmd;
383      nulterminate(bcmd->cmd);
384      break;
385  }
386  return cmd;
387}
19. 系统调用和 UNIX Shell¶

Take-away Messages¶

课后习题/编程作业¶

1. 阅读材料¶

2. 编程实践¶
