Monitor and Manage Linux Processes

# Monitor and Manage Linux Processes
      ## Dennis Kibbe
      ### Mesa Community College
      Note: This slide presentation was created using [Reveal.js](https://revealjs.com/). You can access a transcript of this presentation by pressing S for speaker notes. You can access navigation help by pressing the question mark key. Audio for this presentation is artificially generated.
      ---
      # Module Outline
      1. Introduction
      1. Process State and Lifecycle
      1. Graded Quiz
      1. Control Jobs
      1. Guided Exercise
      1. Kill Processes
      1. Guided Exercise
      1. Monitor Process Activity
      1. Guided Exercise
      1. Key Takeaways
      1. Resources
      1. Graded Lab
      Note: 
      ---
      
      # Learning Objectives
      *After completing the work in this module you will be able to:*
      1. Use `ps` and `top` to list running programs.
      1. Use Bash job control to manages processes from the terminal.
      1. Use `kill` and `top` to manage processes.
      1. Determine the system load average.
      Note:  
      ---
      
      # Introduction
      ## Monitor and Manage Linux Processes
      Note: Maintaining peak system performance is an everyday job for a system administrator. A process that unnecessarily hogs resources can lead to unhappy users. In this module you will learn how to monitor processes and terminate a process when necessary.
      ---
      
      # What is a Process?
      - Allocated memory space
      - Ownership and privileges
      - Program code
      - A process state
      Note: A process is a running instance of a program and consists of allocated memory space, an owner and the privileges associated with that owner, program code, and the state the process is in. 
      ---
       
      # Process Environment
      - Local and global variables
      - Scheduling context
      - Allocated system resources
      Note: A process runs in an environment which provides local and global variables, scheduling on the CPU, and system resources. 
      ---
      
      # Process Life Cycle
      ![Diagram of the fork and execution process](../images/process_life_cycle.png)
      Note: This diagram show how a new process is created by forking a parent process. When the child process has finished it is terminated by the parent process. Should the parent process die before the child process has finished the child process becomes a zombie.
      ---
      
      # Process States
      - Running (R)
      - Sleeping (S)
      - Stopped (T)
      - Zombie (Z)
      Note: A process can be in one of four states - Running, Sleeping, Stopped, or in a Zombie state. See the textbook for additional sub-states.
      ---
      
      # Listing Processes
      ## The `ps` command
      ```
      [student@workstation ~]$ ps
      PID       TTY     TIME        CMD
      10430     pts/1   00:00:00    bash
      10458     pts/1   00:00:00    ps
      ```
      Note: The `ps` command without any options lists the processes running in the current shell. Unlike the `top` command the list is static and does not update every few seconds. The `ps` command has many options to customise the listing.
      ---
      
      # Graded Quiz
      ## Process States and Lifecycle
      ![clipboard](../images/clipboard-check.png)
      Note: Complete this short quiz in Canvas.
      ---
      
      # Control Jobs
      Note: It is common to run more than one job in a Bash shell. Additional jobs can be run in the background and then brought to foreground as needed.
      ---
      
      # Run Jobs in the Backgroud
      Note: You can run a job in the backgroup by appending an ampersand (&) to the command. The job will run in the background freeing the terminal so you can do other work. In this demonstration the `sleep` command is started in the background so that the terminal is available to enter the `ps` command.
      ---
      
      # List Jobs
      ```
      [student@workstation ~]$ jobs
      [1]-  Running                 sleep 15 &
      [2]+  Running                 sleep 30 &
      [student@workstation ~]$ jobs
      ```
      Note: The `jobs` command lists jobs running in the background. Each job is assigned a number which is used to bring the job to the foreground when needed.
      ---
      
      # Return a Job to the Foreground
      ```
      [student@workstation ~]$ sleep 15 &
      [1] 27858
      [student@workstation ~]$ sleep 45 &
      [2] 26425
      [student@workstation ~]$ fg %2
      sleep 45
      ```
      Note: The `fg` command is used to return a job running in the background to the foreground. If more than one job is running in the background use the number associated with the job you want to bring forward.
      ---
      # Guided Exercise
      ## Control Jobs
      Note: In this exercise, you use job control to start, suspend, and move multiple processes to the background and foreground.
      ---
      
      # Kill Processes
      <pre>
      []student@workstation ~$] kill -l
      1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
      6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 <strong>9) SIGKILL</strong>	10) SIGUSR1
      11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	<strong>15) SIGTERM</strong>
      16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
      </pre>
      Note: A process can be ended with the `kill` command by sending the process a signal. The main signals are SIGTERM and SIGKILL. 
      ---
      
      # Process Control with Signals (SIGTERM)
      ![Screenshot of the kill -15 command](../images/kill_sigterm.png)
      Note: The SIGTERM signal is what is used if no options are given to the `kill` command. This causes the process to end and release any resources used.
      ---
      
      # Process Control with Signals (SIGKILL)
      ![Screenshot of the kill -9 command](../images/kill_sigkill.png)
      Note: The more drastic SIGKILL should only be used if the process can not be halted using SIGTERM. SIGKILL is a bullet through the head.
      ---
      
      # Guided Exercise
      ## Kill Process
      Note: In this exercise, you use signals to manage and stop processes.
      ---
      
      # The `uptime` Command
      ```
      dennisk@sdf:~$ uptime
      2:48PM  up 10 days, 12:41, 49 users, load averages: 6.57, 6.49, 6.38
      ```
      Note: The `uptime` command shows how long the system has been running since last reboot, the number of users logged into the system, and the load average.
      ---
      
      # How to Interpret Load Average
      ```
      dennisk@sdf.org:~$ uptime
      2:48PM  up 10 days, 12:41, 49 users, load averages: 6.57, 6.49, 6.38
      ```
      ```
      dennisk@sdf:~$ grep "model name" /proc/cpuinfo
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      model name      : Intel(R) Xeon(R) CPU           X5460  @ 3.16GHz
      You have mail in /var/mail/dennisk
      dennisk@sdf:~$
      ```
      Note: The three numbers for load average are from the left, 1 minute ago, 5 minutes ago, and 15 minutes ago. As long as the number is less than the number of processors the system is running normally. If the number is  greater than the number of CPUs then performance will suffer. In this example you can see that the system has eight proceesors and is running without any slowdown.
      ---
      
      # Monitor Process Activity
      Note: Load Average is a measurement that the Linux kernel provides to represent the perceived system load for a period of time. Load average is a moving average over the most recent 1, 5, and 15 minutes. In this section you will use the `top` command to display Load Average and other information about
      ---
      
      # List Processes (Real Time)
      ![Screenshot of the top command](../images/top_sdf.png)
      Note: The `top` command updates every 3 seconds and displays much important information about the system including load averages, number of processes, memory in use, and the most active processes on the system.
      ---
      
      # Guided Exercise
      ## Monitor Process Activity
      ![Lab technicians holding clipboard.](../images/lab_techs.png)
      Note: In this exercise, you use the `top` command to examine running processes and control them dynamically.
      ---
      
      # Key Takeaways
      1. A process is a running instance of a program.
      1. Each process is in a state (running, sleeping, stopped, or zombie).
      1. Each terminal has its own session with foreground and background processes.
      1. The `kill`, `pkill`, and `killall` commands send signals to control a process.
      1. Load Average is a measure of how busy the system is and is displayed with the `top`, `uptime`, or `w` commands.
      ---
      # Resources
      - [2 Minute Linux Tip: ps](https://youtu.be/BRrJEGfUEng)
      - [2 Minute Linux Tip: top](https://youtu.be/1snCKFcZhVE)
      - [2 Minute Linux Tip: kill, pkill, killall](https://youtu.be/Rq6K6vsrmqo)
      - [How to use the uptime command: 2-Minute Linux Tips](https://youtu.be/6uutPhbtB1M)
      - [Uptime Funk - A SUSE Music Parody](https://youtu.be/SYRlTISvjww)
      Note: Here are some resources for the topics covered in this chapter.
      ---
      
      # Graded Lab
      ## Create, View, and Edit Text Files
      ![Screenshot of a sample grading script](../images/lab_techs.png)
      Note: When you complete the lab submit a screenshot of the output of the `lab grade processes-review` command. The screenshot shown here is for reference only.
      ---
      
      
      ![Mesa Community College logo](../images/mcc_logo.png "Mesa Community College")
      Note: This is the end of the slide presentation. I hope you found it useful.