source: trunk/user/ksh/ksh.c @ 407

Last change on this file since 407 was 407, checked in by alain, 5 years ago

First implementation of fork/exec.

File size: 15.2 KB
Line 
1///////////////////////////////////////////////////////////////////////////////
2// File   :  ksh.c
3// Date   :  October 2017
4// Author :  Alain Greiner
5///////////////////////////////////////////////////////////////////////////////
6// This single thread application implement a simple shell for ALMOS-MKH.
7///////////////////////////////////////////////////////////////////////////////
8
9#include <nostdio.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13
14#define CMD_MAX_SIZE   (256)    // max number of characters in one command
15#define LOG_DEPTH      (256)    // max number of registered commands
16#define MAX_ARGS           (32)     // max number of arguments in a command
17#define FIFO_SIZE      (1024)   // FIFO depth for recursive ls
18
19////////////////////////////////////////////////////////////////////////////////
20//         Structures
21////////////////////////////////////////////////////////////////////////////////
22
23// one entry in the registered commands array
24typedef struct log_entry_s
25{
26        char          buf[CMD_MAX_SIZE];
27        unsigned int  count;
28}
29log_entry_t;
30
31// one entry in the supported command types array
32typedef struct ksh_cmd_s
33{
34        char * name;
35        char * desc;
36        void   (*fn)( int , char ** );
37}
38ksh_cmd_t;
39
40
41////////////////////////////////////////////////////////////////////////////////
42//         Global Variables
43////////////////////////////////////////////////////////////////////////////////
44
45ksh_cmd_t       cmd[];                    // array of supported commands
46
47log_entry_t     log_entries[LOG_DEPTH];   // array of registered commands
48
49unsigned int    ptw;                      // write pointer in log_entries[]
50unsigned int    ptr;                      // read pointer in log_entries[]
51
52////////////////////////////////////////////////////////////////////////////////
53//         Shell  Commands
54////////////////////////////////////////////////////////////////////////////////
55
56/////////////////////////////////////////////
57static void cmd_cat( int argc , char **argv )
58{
59        char         * path;
60
61        if (argc != 2) 
62    {
63                printf("usage: cat pathname\n");
64                return;
65        }
66
67        path = argv[1];
68
69    printf("error: not implemented yet\n");
70
71/*
72        // open the file
73        fd = open( path , O_RDONLY , 0 );
74        if (fd < 0)
75    {
76                printf("error: cannot open %s\n", path);
77                goto exit;
78        }
79
80        // get file size
81        if (stat(path, &st) == -1)
82    {
83                printf("error: cannot stat %s\n", path);
84                goto exit;
85        }
86        if (S_ISDIR(st.st_mode)) {
87                printf("error: %s is a directory\n", path);
88                goto exit;
89        }
90        size = st.st_size;
91
92        // mmap the file
93        buf = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
94        if (buf == NULL || buf == (char *)-1) {
95                printf("error: cannot map %s\n", path);
96                goto exit;
97        }
98
99        // set terminating '0' XXX
100        buf[size-1] = 0;
101
102        // display the file content
103        printf("%s", buf);
104
105exit:
106        if (buf != NULL) munmap(buf, size);
107        if (fd >= 0) close(fd);
108*/
109
110}   // end cmd_cat()
111
112////////////////////////////////////////////
113static void cmd_cd( int argc , char **argv )
114{
115        char * path;
116
117        if (argc != 2)
118    {
119                printf("usage: cd pathname\n");
120                return;
121        }
122
123        path = argv[1];
124
125    printf("error: not implemented yet\n");
126/*
127        path = argv[1];
128
129        if (chdir(path) == -1)
130    {
131                printf("error: cannot cd to %s\n", path);
132        }
133*/
134
135}   // end cmd_cd()
136
137/////////////////////////////////////////
138static void cmd_cp(int argc, char **argv)
139{
140//      int src_fd = -1, dst_fd = -1;
141//      char *srcpath, *dstpath;
142//      struct stat st;
143//      size_t size, i;
144//      char buf[1024];
145
146        if (argc != 3) 
147    {
148                printf("usage: cp src_pathname dst_pathname\n");
149                return;
150        }
151
152    printf("error: not implemented yet\n");
153
154/*
155        srcpath = argv[1];
156        dstpath = argv[2];
157
158        // open the src file
159        src_fd = open(srcpath, O_RDONLY, 0);
160        if (src_fd < 0) {
161                printf("error: cannot open %s / err = %d\n", srcpath, errno);
162                goto exit;
163        }
164
165        // get file size
166        if (stat(srcpath, &st) == -1) {
167                printf("error: cannot stat %s\n", srcpath);
168                goto exit;
169        }
170        if (S_ISDIR(st.st_mode)) {
171                printf("error: %s is a directory\n", srcpath);
172                goto exit;
173        }
174        size = st.st_size;
175
176        // open the dst file
177        dst_fd = open(dstpath, O_CREAT|O_TRUNC|O_RDWR, 0);
178        if (dst_fd < 0) {
179                printf("error: cannot open %s / err = %d\n", dstpath, errno);
180                goto exit;
181        }
182        if (stat(dstpath, &st) == -1) {
183                printf("error: cannot stat %s\n", dstpath);
184                goto exit;
185        }
186        if (S_ISDIR(st.st_mode)) {
187                printf("error: %s is a directory\n", dstpath);
188                goto exit;
189        }
190
191        i = 0;
192        while (i < size)
193        {
194                size_t rlen = (size - i < 1024 ? size - i : 1024);
195                size_t wlen;
196                ssize_t ret;
197
198                // read the source
199                ret = read(src_fd, buf, rlen);
200                if (ret == -1) {
201                        printf("error: cannot read from file %s\n", srcpath);
202                        goto exit;
203                }
204                rlen = (size_t)ret;
205
206                // write to the destination
207                ret = write(dst_fd, buf, rlen);
208                if (ret == -1) {
209                        printf("error: cannot write to file %s\n", dstpath);
210                        goto exit;
211                }
212                wlen = (size_t)ret;
213
214                // check
215                if (wlen != rlen) {
216                        printf("error: cannot write on device\n");
217                        goto exit;
218                }
219
220                i += rlen;
221        }
222
223exit:
224        if (src_fd >= 0) close(src_fd);
225        if (dst_fd >= 0) close(dst_fd);
226*/
227
228}   // end cmd_cp()
229
230//////////////////////////////////////////////
231static void cmd_help( int argc , char **argv )
232{
233        unsigned int i;
234
235        if (argc != 1) 
236    {
237                printf("usage: %s\n", argv[0]);
238                return;
239        }
240
241        printf("available commands:\n");
242        for (i = 0 ; cmd[i].name ; i++) 
243    {
244                printf("\t%s\t : %s\n", cmd[i].name , cmd[i].desc);
245        }
246}   // end cmd_help()
247
248//////////////////////////////////////////////
249static void cmd_kill( int argc , char **argv )
250{
251        unsigned int pid;
252
253        if (argc != 2) 
254    {
255                printf("usage: %s pid\n", argv[0]);
256                return;
257        }
258
259        pid = atoi(argv[1]);
260
261        if( kill( pid , 9 ) )   // TODO replace 9 by SIGKILL
262    {
263                printf("error: unable to kill process %x\n", pid );
264        }
265}   // end cmd_kill()
266
267//////////////////////////////////////////////
268static void cmd_load( int argc , char **argv )
269{
270        unsigned int   pid;
271    unsigned int   error;
272        char         * pathname;
273
274        if (argc != 2) 
275    {
276                printf("usage: %s pathname \n", argv[0] );
277                return;
278        }
279
280        pathname = argv[1];
281
282    // fork system call
283        pid = fork();
284
285    if (pid == 0)  // it is the child process
286    {
287
288printf("\n[KSH_DBG] process %x before exec\n", getpid() );
289
290        // exec system call
291        error = exec( pathname , NULL , NULL );
292
293printf("\n[KSH_DBG] process %x after exec / error = %d\n", getpid() , error );
294
295        if( error )
296        {
297            printf("error: new process unable to exec <%s>\n", pathname );
298            // TODO exit();
299        }
300        } 
301    else if ( pid < 0 )  // it is a failure reported to parent
302    {
303        printf("error: unable to fork\n");
304    }
305    else                 // it is a success reported to parent
306    {
307
308printf("\n[KSH_DBG] process %x created for <%s>\n", pid, pathname );
309
310    }
311
312}   // end cmd_load
313
314/////////////////////////////////////////////
315static void cmd_log( int argc , char **argv )
316{
317        unsigned int i;
318
319        printf("--- registered commands ---\n");
320        for (i = 0; i < LOG_DEPTH; i++) 
321    {
322                printf(" - %zu\t: %s\n", i, &log_entries[i].buf);
323        }
324}
325
326////////////////////////////////////////////
327static void cmd_ls( int argc , char **argv )
328{
329        char  * path;
330
331//  struct dirent * file;
332//  DIR *dir;
333
334        if (argc == 1)
335    {
336                path = ".";
337        }
338    else if (argc == 2) 
339    {
340                path = argv[1];
341        } 
342    else 
343    {
344                printf("usage: ls [path]\n");
345                return;
346        }
347
348    printf("error: not implemented yet\n");
349/*
350        dir = opendir( path );
351        while ((file = readdir(dir)) != NULL)
352        {
353                printf(" %s\n", file->d_name);
354        }
355        closedir(dir);
356*/
357}
358
359///////////////////////////////////////////////
360static void cmd_mkdir( int argc , char **argv )
361{
362        char * pathname;
363
364        if (argc != 2)
365    {
366                printf("usage: mkdir pathname\n");
367                return;
368        }
369
370    pathname = argv[1];
371
372    printf("error: not implemented yet\n");
373/*
374        if ( mkdir( path, 0x700) == -1 )
375    {
376                printf("error: cannot create directory %s\n", path);
377        }
378*/
379}
380
381////////////////////////////////////////////
382static void cmd_mv( int argc , char **argv )
383{
384
385        if (argc < 3)
386        {
387                printf("  usage : %s src_pathname dst_pathname\n", argv[0]);
388                return;
389        }
390
391    printf("error: not implemented yet\n");
392   
393/*
394        int ret = giet_fat_rename(argv[1], argv[2]);
395        if (ret < 0)
396        {
397                printf("error : cannot move %s to %s / err = %d\n", argv[1], argv[2], ret );
398        }
399*/
400
401}
402
403/////////////////////////////////////////////
404static void cmd_pwd( int argc , char **argv )
405{
406        char buf[1024];
407
408        if (argc != 1)
409    {
410                printf("usage: pwd\n");
411                return;
412        }
413
414        if ( getcwd( buf , 1024 ) ) 
415    {
416                printf("error: unable to get current directory\n");
417        }
418    else 
419    {
420                printf("%s\n", buf);
421        }
422}
423
424////////////////////////////////////////////
425static void cmd_rm( int argc , char **argv )
426{
427        char * pathname;
428
429        if (argc != 2)
430    {
431                printf("usage: rm pathname\n");
432                return;
433        }
434
435        pathname = argv[1];
436
437    printf("error: not implemented yet\n");
438/*
439        if (remove(path) == -1)
440    {
441                printf("error: cannot remove %s\n", path);
442        }
443*/
444
445}
446
447///////////////////////////////////////////////
448static void cmd_rmdir( int argc , char **argv )
449{
450        cmd_rm(argc, argv);
451}
452
453///////////////////////////////////////////////
454static void cmd_sched( int argc , char **argv )
455{
456    unsigned int cxy;
457    unsigned int lid;
458
459        if (argc != 3)
460    {
461                printf("usage: sched cxy lid\n");
462                return;
463        }
464
465        cxy = atoi(argv[1]);
466        lid = atoi(argv[2]);
467
468    if( get_sched( cxy , lid ) )
469    {
470        printf("error: illegal arguments\n");
471    }
472}
473
474//////////////////////////////////////////////////////////////////
475// Array of commands
476//////////////////////////////////////////////////////////////////
477
478ksh_cmd_t cmd[] =
479{
480        { "cat",    "display file content",                cmd_cat   },
481        { "cd",     "change current directory",            cmd_cd    },
482        { "cp",     "replicate a file in file system",     cmd_cp    },
483        { "load",   "load an user application",            cmd_load  },
484        { "help",   "list available commands",             cmd_help  },
485        { "kill",   "kill an application (all threads)",   cmd_kill  },
486        { "log",    "list registered commands",            cmd_log   },
487        { "ls",     "list directory entries",              cmd_ls    },
488        { "mkdir",  "create a new directory",              cmd_mkdir },
489        { "mv",     "move a file in file system",          cmd_mv    },
490        { "pwd",    "print current working directory",     cmd_pwd   },
491        { "rm",     "remove a file from file system",      cmd_rm    },
492        { "rmdir",  "remove a directory from file system", cmd_rmdir },
493    { "sched",  "display scheduler state",             cmd_sched },
494        { NULL,     NULL,                                                                  NULL      }
495};
496
497////////////////////////////////////////////////////////////////////////////////////
498// This function analyses one command (with arguments), execute it, and return.
499////////////////////////////////////////////////////////////////////////////////////
500static void parse(char *buf)
501{
502        int argc = 0;
503        char *argv[MAX_ARGS];
504        int i;
505        int len = strlen(buf);
506
507        // build argc/argv
508        for (i = 0; i < len; i++) 
509    {
510                if (buf[i] == ' ') 
511        {
512                        buf[i] = '\0';
513                }
514        else if (i == 0 || buf[i - 1] == '\0') 
515        {
516                        if (argc < MAX_ARGS) 
517            {
518                                argv[argc] = &buf[i];
519                                argc++;
520                        }
521                }
522        }
523
524        if (argc > 0)
525    {
526                int found = 0;
527
528                argv[argc] = NULL;
529
530                // try to match typed command
531                for (i = 0; cmd[i].name; i++)
532        {
533                        if (strcmp(argv[0], cmd[i].name) == 0)
534            {
535                                cmd[i].fn(argc, argv);
536                                found = 1;
537                                break;
538                        }
539                }
540
541                if (!found)
542        {
543                        printf("\n  undefined command %s\n", argv[0]);
544                }
545        }
546}
547
548///////////////////////////////////
549int main( int argc , char *argv[] )
550{
551        char         c;                                           // read character
552        char         buf[CMD_MAX_SIZE];           // buffer for one command
553        unsigned int count = 0;                           // pointer in buf
554        unsigned int i;                                           // index for loops
555
556        enum fsm_states
557    {
558                NORMAL,
559                ESCAPE,
560                BRAKET,
561        };
562
563    // log buffer initialisation
564        memset( &log_entries , 0, sizeof(log_entries));
565        ptw   = 0;
566        ptr   = 0;
567
568        printf( "~~~ shell ~~~\n\n" );
569
570        // command buffer initialisation
571        memset( buf, 0x20 , sizeof(buf) );
572        count = 0;
573
574        // display first prompt
575        printf("# ");
576
577        // This lexical analyser writes one command line in the buf buffer.
578        // It is implemented as a 3 states FSM to handle the following sequences:
579        // - ESC [ A : up arrow
580        // - ESC [ B : down arrow
581        // - ESC [ C : right arrow
582        // - ESC [ D : left arrow
583        // The three states have the following semantic:
584        // - NORMAL : no (ESC) character has been found
585        // - ESCAPE : the character (ESC) has been found
586        // - BRAKET : the wo characters (ESC,[) have been found
587        unsigned int state = NORMAL;
588
589// @@@
590parse("load /bin/user/sort.elf");
591// @@@
592   
593        while (1)
594        {
595                c = (char)getchar();
596
597        if( c == 0 ) continue;
598
599                switch (state)
600                {
601                        case NORMAL:
602                        {
603                                if ((c == '\b') || (c == 0x7F))  // backspace => remove one character
604                                {
605                                        if (count > 0) {
606                                                printf("\b \b");
607                                                count--;
608                                        }
609                                }
610                                else if (c == '\n')      // new line => call parser to execute command
611                                {
612                                        if (count > 0)
613                                        {
614                                                // complete command
615                                                buf[count] = '\0';
616
617                                                // register command in log arrays
618                                                strcpy(log_entries[ptw].buf, buf);
619                                                log_entries[ptw].count = count;
620                                                ptw = (ptw + 1) % LOG_DEPTH;
621                                                ptr = ptw;
622
623                                                // execute command
624                                                printf("\n");
625                                                parse((char *)&buf);
626
627                                                // reinitialise buffer and display prompt
628                                                for ( i = 0 ; i < sizeof(buf) ; i++ ) buf[i] = 0x20;
629                                                count = 0;
630                                                printf("# ");
631                                        }
632                                }
633                                else if (c == '\t')     // tabulation => do nothing
634                                {
635                                }
636                                else if (c == 0x1B)     // ESC => start an escape sequence
637                                {
638                                        state = ESCAPE;
639                                }
640                                else if (c == 0x03)     // ^C  => cancel current command
641                                {
642                                        for (i = 0; i < count; i++) printf("\b \b");
643                                        for (i = 0; i < sizeof(buf); i++) buf[i] = 0x20;
644                                        count = 0;
645                                }
646                                else                                     // register character in command buffer
647                                {
648                                        if (count < sizeof(buf) - 1)
649                                        {
650                                                printf("%c", c);
651                                                buf[count] = c;
652                                                count++;
653                                        }
654                                }
655                                break;
656                        }
657                        case ESCAPE:
658                        {
659                                if (c == '[')           //  valid sequence => continue
660                                {
661                                        state = BRAKET;
662                                }
663                                else                               // invalid sequence => do nothing
664                                {
665                                        state = NORMAL;
666                                }
667                                break;
668                        }
669                        case BRAKET:
670                        {
671                                if (c == 'D')   // valid  LEFT sequence => move buf pointer left
672                                {
673                                        if (count > 0)
674                                        {
675                                                printf("\b");
676                                                count--;
677                                        }
678
679                                        // get next user char
680                                        state = NORMAL;
681                                }
682                                else if (c == 'C')   // valid  RIGHT sequence => move buf pointer right
683                                {
684                                        if (count < sizeof(buf) - 1)
685                                        {
686                                                printf("%c", buf[count]);
687                                                count++;
688                                        }
689
690                                        // get next user char
691                                        state = NORMAL;
692                                }
693                                else if (c == 'A')   // valid  UP sequence => move log pointer backward
694                                {
695                                        // cancel current command
696                                        for (i = 0; i < count; i++) printf("\b \b");
697                                        count = 0;
698
699                                        // copy log command into buf
700                                        ptr = (ptr - 1) % LOG_DEPTH;
701                                        strcpy(buf, log_entries[ptr].buf);
702                                        count = log_entries[ptr].count;
703
704                                        // display log command
705                                        printf("%s", buf);
706
707                                        // get next user char
708                                        state = NORMAL;
709                                }
710                                else if (c == 'B')   // valid  DOWN sequence => move log pointer forward
711                                {
712                                        // cancel current command
713                                        for (i = 0 ; i < count; i++) printf("\b \b");
714                                        count = 0;
715
716                                        // copy log command into buf
717                                        ptr = (ptr + 1) % LOG_DEPTH;
718                                        strcpy(buf, log_entries[ptr].buf);
719                                        count = log_entries[ptr].count;
720
721                                        // display log command
722                                        printf("%s", buf);
723
724                                        // get next user char
725                                        state = NORMAL;
726                                }
727                                else                               // other character => do nothing
728                                {
729                                        // get next user char
730                                        state = NORMAL;
731                                }
732                                break;
733                        }
734                }
735        }
736}
737
Note: See TracBrowser for help on using the repository browser.