CS计算机代考程序代写 chain c++ Shell

Reading in Commands

The shell will read in a command from
stdin

(https://linux.die.net/man/3/stdin) (or a file if -f was specified).

Command Types and Formats
Shell supports two types of commands: built-in and external (i.e. non-built-in).
Built-in commands are part of the shell s̓ code, and are executed without
creating a new process. External commands must be executed by a new
process, forked from your shell. If a command is not one of the built-in
commands listed, it is an external command.

Command arguments will be space-separated without trailing whitespace. Your
shell does not need to support quotes (for example, echo “hello there” ).

Running the Commands
The shell should run the command that was read in previously.

If the command is run by a new process, the PID of the process should be
printed like this:

Command executed by pid=

https://linux.die.net/man/3/getopt
https://linux.die.net/man/3/stdin

Built-in Commands

This should be printed by the process that will run the command, before any of
the output of the command is printed (prints to be used are in format.h ).

Keeping History
Your shell should store the command that the user entered, so the user can
repeat it later if they wish. Every command should be stored unless otherwise
noted. A vector may be useful here.

exit
(https://linux.die.net/man/3/exit)

The shell will exit once it receives the
exit

(https://linux.die.net/man/3/exit) command or once it receives an
EOF at the beginning of the line. An EOF is sent by typing Ctrl-D from your
terminal. It is also sent automatically from a script file (as used with the -f
flag) once the end of the file is reached. This should cause your shell to exit
with exit status 0.

If there are currently stopped or running background processes when your shell

receives
exit

(https://linux.die.net/man/3/exit) or Control-D (EOF), you should kill and cleanup each of those
children before your shell exits. You do not need to worry about SIGTERM.

If you donʼt handle EOF or
exit

(https://linux.die.net/man/3/exit) to exit, you will fail many of our test cases!

Do not store
exit

(https://linux.die.net/man/3/exit) in history!

Catching Ctrl+C
Usually when we do Ctrl+C , the current running program will exit. However,
we want the shell itself to ignore the Ctrl+C signal ( SIGINT ) – instead, it
should kill the currently running foreground process (if one exists) using

SIGINT . One way to do this is to use the
kill

(https://linux.die.net/man/3/kill) function on the foreground
process PID when SIGINT is caught in your shell. However, when a signal is
sent to a process, it is sent to all processes in its process group. In this
assignment, the shell process is the leader of a process group consisting of all

processes that are
fork

(https://linux.die.net/man/3/fork)‘d from it. So another way to properly handle Ctrl+C
is to simply do nothing inside the handler for SIGINT if it is caught in the shell –
your shell will continue running, but SIGINT will automatically propagate to the
foreground process and kill it.

However, since we want this signal to be sent to only the foreground process,

but not to any backgrounded processes, you will want to use
setpgid

(https://linux.die.net/man/3/ to
assign each background process to its own process group after forking. (Note:

think about who should be making the
setpgid

(https://linux.die.net/man/3/setpgid) call and why).

There are several built-in commands your shell is expected to support.

cd Changes the current working directory of the shell to . Paths not
starting with / should be followed relative to the current directory. If the
directory does not exist, then print the appropriate error. Unlike your regular

https://linux.die.net/man/3/exit
https://linux.die.net/man/3/exit
https://linux.die.net/man/3/exit
https://linux.die.net/man/3/exit
https://linux.die.net/man/3/exit
https://linux.die.net/man/3/kill
https://linux.die.net/man/3/fork
https://linux.die.net/man/3/setpgid
https://linux.die.net/man/3/setpgid

shell, the argument is mandatory here. A missing path should be
treated as a nonexistent directory.

(pid=1234)/home/user$ cd code
(pid=1234)/home/user/code$ cd imaginary_directory
imaginary_directory: No such file or directory
(pid=1234)/home/user/code$

There is a system call that may be helpful here.

!history
Prints out each command in the history, in order.

(pid=1234)/home/user$ !history
0 ls -l
1 pwd
2 ps
(pid=1234)/home/user$

This command is not stored in history.

#
Prints and executes the -th command in history (in chronological order, from
earliest to most recent), where is a non-negative integer. Other values of
will not be tested. The command executed should be stored in the history. If is
not a valid index, then print the appropriate error and do not store anything in
the history.

The following example assumes a fresh history:

(pid=1234)/home/user$ echo Echo This!
Command executed by pid=1235
Echo This!
(pid=1234)/home/user$ echo Another echo
Command executed by pid=1236
Another echo
(pid=1234)/home/user$ !history
0 echo Echo This!
1 echo Another echo
(pid=1234)/home/user$ #1
echo Another echo
Command executed by pid=1237
Another echo
(pid=1234)/home/user$ #9001
Invalid Index
(pid=1234)/home/user$ !history
0 echo Echo This!
1 echo Another echo
2 echo Another echo
(pid=1234)/home/user$

Print out the command before executing if there is a match.

The # command itself is not stored in history, but the command being
executed (if any) is.

!

n

n n

n

External Commands

Prints and executes the last command that has the specified prefix. If no match
is found, print the appropriate error and do not store anything in the history. The
prefix may be empty. The following example assumes a fresh history:

(pid=1234)/home/user$ echo Echo This!
Command executed by pid=1235
Echo This!
(pid=1234)/home/user$ echo Another echo
Command executed by pid=1236
Another echo
(pid=1234)/home/user$ !e
echo Another echo
Command executed by pid=1237
Another echo
(pid=1234)/home/user$ !echo E
echo Echo This!
Command executed by pid=1238
Echo This!
(pid=1234)/home/user$ !d
No Match
(pid=1234)/home/user$ !
echo Echo This!
Command executed by pid=1239
Echo This!
(pid=1234)/home/user$ !history
0 echo Echo This!
1 echo Another echo
2 echo Another echo
3 echo Echo This!
4 echo Echo This!
(pid=1234)/home/user$

Print out the command before executing if there is a match.

The ! command itself is not stored in history, but the command
being executed (if any) is.

Invalid Built-in Commands
You should be printing appropriate errors in cases where built-in commands

fail; for example, if the user tries to
cd
(https://linux.die.net/man/1/cd) into a nonexistent directory.

(pid=1234)/home/user$ cd /imaginary_directory
/imaginary_directory: No such file or directory
(pid=1234)/home/user$

For commands that are not built-in, the shell should consider the command
name to be the name of a file that contains executable binary code. Such a
code must be executed in a process different from the one executing the shell.

You must use
fork

(https://linux.die.net/man/3/fork),
exec

(https://linux.die.net/man/3/exec), and
wait

(https://linux.die.net/man/3/wait)/
waitpid

(https://linux.die.net/man/3/waitpid).

The fork/exec/wait paradigm is as follows:
fork

(https://linux.die.net/man/3/fork) a child process. The child

process must execute the command with exec* , while the parent must
wait

(https://linux.die.ne
for the child to terminate before printing the next prompt.

https://linux.die.net/man/1/cd
https://linux.die.net/man/3/fork
https://linux.die.net/man/3/exec
https://linux.die.net/man/3/wait
https://linux.die.net/man/3/waitpid
https://linux.die.net/man/3/fork
https://linux.die.net/man/3/wait

Logical Operators

You are responsible of cleaning up all the child processes upon termination of
your program. It is important to note that, upon a successful execution of the

command,
exec

(https://linux.die.net/man/3/exec) never returns to the child process.
exec

(https://linux.die.net/man/3/exec) only returns to the

child process when the command fails to execute successfully. If any of
fork

(https://linux.die.ne,
exec

(https://linux.die.net/man/3/exec), or
wait

(https://linux.die.net/man/3/wait) fail, the appropriate error messages should be printed. The

child should
exit

(https://linux.die.net/man/3/exit) with exit status 1 if it fails to execute a command.

Some external commands you may test to see whether your shell works are:

/bin/ls
echo hello

Tip: It is good practice to flush the standard output stream before the fork to be
able to correctly display the output. This will also prevent duplicate printing
from the child process.

Please read the disclaimer at the top of the page! We donʼt want to have to
give any failing grades.

Like
bash

(https://linux.die.net/man/1/bash), your shell should support && , || , and ; in between two
commands. This will require only a minimal amount of string parsing that you
have to do yourself.

Important: each input can have at most one of && , || , or ; . You do not have
to support chaining (e.g. x && y || z; w ).

Important: you should not try to handle the combination of the !history , #

, ! , or
exit

(https://linux.die.net/man/3/exit) commands with any logical operators. Rather, you
can assume these commands will always be run on a line by themselves.

AND
&& is the AND operator. Usage:

x && y

The shell first runs x , then checks the exit status.
If x exited successfully (status = 0), run y .
If x did not exit successfully (status ≠ 0), do not run y . This is also

known as

short-circuiting
(https://en.wikipedia.org/wiki/Short-
circuit_evaluation).

(pid=27853)/home/user/semester/shell$ echo hi && echo bye
Command executed by pid=27854
hi
Command executed by pid=27855
bye

(pid=27879)/home/mkrzys2/fa19/shell$ cd /asdf && echo short-circuit
/asdf: No such file or directory!

https://linux.die.net/man/3/exec
https://linux.die.net/man/3/exec
https://linux.die.net/man/3/fork
https://linux.die.net/man/3/exec
https://linux.die.net/man/3/wait
https://linux.die.net/man/3/exit
https://linux.die.net/man/1/bash
https://linux.die.net/man/3/exit
https://en.wikipedia.org/wiki/Short-circuit_evaluation

This mimics short-circuiting AND in boolean algebra: if x is false, we know the
result will be false without having to run y .

This is often used to run multiple commands in a sequence and stop early if

one fails. For example, make && ./shell will run your shell only if
make

(https://linux.die.net/ma
succeeds.

Tip: You may want to look into the provided macros to read the status of an
exited child.

OR
|| is the OR operator. Usage:

x || y

The shell first runs x , then checks the exit status.
If x exited successfully, the shell does not run y . This is short-circuiting.
If x did not exit successfully, run y .

(pid=27853)/home/user/semester/shell$ echo hi || echo bye
Command executed by pid=27854
hi

(pid=1234)/home/user$ cd /asdf || echo runMe
/asdf: No such file or directory
runMe

Boolean algebra: if x is true, we can return true right away without having to
run y .

This is often used to recover after errors. For example, make || echo

‘Make failed!’ will run
echo

(https://linux.die.net/man/3/echo) only if
make

(https://linux.die.net/man/3/make) does not succeed.

Separator
; is the command separator. Usage:

x; y

The shell first runs x .
The shell then runs y .

(pid=27879)/home/user/semester/shell$ echo hi; echo bye
Command executed by pid=27883
hi
Command executed by pid=27884
bye

(pid=27879)/home/user/semester/shell$ cd /asdf; echo runMe
/asdf: No such file or directory
Command executed by pid=27884
runMe

https://linux.die.net/man/3/make
https://linux.die.net/man/3/echo
https://linux.die.net/man/3/make

Memory

Background Processes

ps
(https://linux.die.net/man/1/ps)

The two commands are run regardless of whether the first one succeeds.

As usual, you may not have any memory leaks or errors. Note that still
reachable memory blocks do not count as memory leaks.

An external command suffixed with & should be run in the background. In
other words, the shell should be ready to take the next command before the
given command has finished running. There is no limit on the number of
background processes you can have running at one time (aside from any limits
set by the system).

There will be a single space between the rest of the command and & . For
example, pwd & is valid while you need not worry about pwd& .

Since spawning a background process introduces a race condition, it is okay if
the prompt gets misaligned as in the following example:

(pid=1873)/home/user$ pwd &
Command executed by pid=1874
(pid=1873)/home/user$
/home/user
When I type, it shows up on this line

Note this is not the only way your shell may misalign.

While the shell should be usable after calling the command, after the process
finishes, the parent is still responsible for waiting on the child. Avoid creating
zombies! Do not catch SIGCHLD , as catching SIGCHLD comes with all sorts of
caveats and subtleties that are hard to work around. Instead regularly check to
see if your children need reaping (think about placement of this piece of code:
where should you put this, and why). Think about what happens when multiple
children finish around the same time, and what happens if a
foreground/background process finish around the same time.

Backgrounding will not be chained with the logical operators nor with
redirection operators.

Like our good old
ps
(https://linux.die.net/man/1/ps), your shell should print out information about all currently

executing processes. You should include the shell and its immediate children,
but donʼt worry about grandchildren or other processes. Make sure you use
print_process_info_header() and print_process_info() (and maybe
some other helper functions)!

Note: while
ps
(https://linux.die.net/man/1/ps) is normally a separate binary, it is a built-in command for your

shell. (This is not “execing
ps
(https://linux.die.net/man/1/ps)”, this is you implementing it in the code. Thus

you may have to keep track of some information for each process.)

Your version of the
ps
(https://linux.die.net/man/1/ps) should print the following information for each process:

PID: The pid of the process

https://linux.die.net/man/1/ps
https://linux.die.net/man/1/ps
https://linux.die.net/man/1/ps
https://linux.die.net/man/1/ps
https://linux.die.net/man/1/ps

Redirection Operators

NLWP: The number of threads currently being used in the process
VSZ: The program size (virtual memory size) of the process, in kilobytes
(1 kilobyte = 1024 bytes)
STAT: The state of the process
START: The start time of the process. You will want to add the boot time
of the computer, and start time of the process to calculate this. Make sure
you are careful while converting from various formats – the man pages for
procfs have helpful tips.
TIME: The amount of cpu time that the process has been executed for.

This includes time the process has been scheduled in user mode (
utime

(https://linux.die.ne)

and kernel mode (
stime

(https://linux.die.net/man/2/stime)).
COMMAND: The command that executed the process

Some things to keep in mind:

The order in which you print the processes does not matter.
The ‘commandʼ for print_process_info should be the full command
you executed. The & for background processes is optional. For the main
shell process only, you do not need to include the command-line flags.
Ensure that the ‘commandʼ does not have trailing whitespace at the end of
it.

You may not exec the
ps
(https://linux.die.net/man/1/ps) binary to complete this part of the assignment.

Example output of this command:

(pid=25497)/home/user$ ps
PID NLWP VSZ STAT START TIME COMMAND
25498 1 7328 R 14:03 0:08 dd if=/dev/zero bs=1M c
ount=123456 of=/dev/null &
25501 1 7288 S 14:04 0:00 sleep 1000 &
25497 1 7484 R 14:03 0:00 ./shell

Hint: You may find the /proc filesystem to be useful, as well as the man pages
for it.

Your boss wants some way for your shell commands to be able to link together.
You decide to implement >> , > , and < . This will require only a minimal amount of string parsing that you have to do yourself. Important: each input can have at most one of >> , > or < . You do not have to support chaining (e.g. x >> y < z > w ).

Important: you should not try to handle the combination of the
cd
(https://linux.die.net/man/1/, !history ,

# , ! , or
exit

(https://linux.die.net/man/3/exit) commands with any redirection operators. Rather,
you can assume these commands will always be run on a line by themselves.

Note: Assume that the redirection operator commands will be formatted
correctly. Any incorrectly formatted redirection commands is considered
undefined behavior.

OUTPUT
> places the output of a command into a file. Usage:

[args …] >

https://linux.die.net/man/3/utime
https://linux.die.net/man/2/stime
https://linux.die.net/man/1/ps
https://linux.die.net/man/1/cd
https://linux.die.net/man/3/exit

Signal Commands

If the file exists, overwrite the contents of the file with the output of the current
command. Example usage:

(pid=2777)/home/usr$ echo hello > hey.txt
Command executed by pid=3750
(pid=2777)/home/usr$ cat hey.txt
Command executed by pid=3751
hello
(pid=2777)/home/usr$ echo welcome to cs241 > hey.txt
Command executed by pid=3752
(pid=2777)/home/usr$ cat hey.txt
Command executed by pid=3754
welcome to cs241

APPEND
>> appends the output of a command into a file. Usage:

[args …] >>

If the file does not exist, assume that it is an empty file. Example usage
( hi.txt does not exist in the directory before these commands are executed):

(pid=2777)/home/usr$ echo a >> hi.txt
Command executed by pid=2780
(pid=2777)/home/usr$ cat hi.txt
Command executed by pid=2781
a
(pid=2777)/home/usr$ echo wheeee >> hi.txt
Command executed by pid=2782
(pid=2777)/home/usr$ cat hi.txt
Command executed by pid=2783
a
wheeee

INPUT
< pipes the contents of a file into a command as its input. Usage: [args …] <

If the file does not exist, it is undefined behavior. Example usage: hello.txt
contains:

welcome to cs241

(pid=3771)/home/usr$ wc < hello.txt Command executed by pid=3772 1 3 17 Hint: dup (https://linux.die.net/man/3/dup) will be useful for all the redirection commands https://linux.die.net/man/3/dup Grading Like bash, your shell will support sending signals to its child processes. We require you to implement the 3 signals listed below. kill The ever-useful panic button. Sends SIGKILL to the specified process.

Use the appropriate prints from format.h for:

Successfully sending SIGKILL to process
No process with pid exists
kill

(https://linux.die.net/man/3/kill) was ran without a pid

stop This command will allow your shell to stop a currently executing process by
sending it the SIGSTOP signal. It may be resumed by using the command
cont .

Use the appropriate prints from format.h for:

Process was successfully sent SIGSTOP
No process with pid exists
stop was ran without a pid

cont This command resumes the specified process by sending it SIGCONT .

Use the appropriate prints from format.h for:

Process was successfully sent SIGCONT
No such process exists
cont was ran without a pid

Note: Any used in
kill

(https://linux.die.net/man/3/kill), stop , or, cont will either be a process that is
a direct child of your shell or a non-existent process. You do not have to worry
about killing other processes.

Note that Week 1 and Week 2 count as one week of MP grades respectively.
See the overview for a list of features required for each week.

https://linux.die.net/man/3/kill
https://linux.die.net/man/3/kill