Nothing Special   »   [go: up one dir, main page]
Scribd Logo
Upload

Welcome to Scribd!

  • 185 views

    Activity Jobs and Processes

    Uploaded by

    ErwinMacaraig
    1. The document discusses Linux jobs, processes, and commands used to monitor and manage them. A job is any command executed, while a process is a program running on the system identified by its process ID. 2. It describes process types like interactive, automatic, and daemon processes. Interactive processes run in the foreground and occupy the terminal, while automatic and daemon processes run independently without a terminal. 3. Commands like ps, pstree, and top are used to view and monitor active processes. Ps provides snapshots of running processes, pstree shows them in a tree format, and top continuously updates process activity.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd

    Activity Jobs and Processes

    Uploaded by

    ErwinMacaraig
    185 views8 pages
    1. The document discusses Linux jobs, processes, and commands used to monitor and manage them. A job is any command executed, while a process is a program running on the system identified by its process ID. 2. It describes process types like interactive, automatic, and daemon processes. Interactive processes run in the foreground and occupy the terminal, while automatic and daemon processes run independently without a terminal. 3. Commands like ps, pstree, and top are used to view and monitor active processes. Ps provides snapshots of running processes, pstree shows them in a tree format, and top continuously updates process activity.

    Original Description:

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    1. The document discusses Linux jobs, processes, and commands used to monitor and manage them. A job is any command executed, while a process is a program running on the system identified by its process ID. 2. It describes process types like interactive, automatic, and daemon processes. Interactive processes run in the foreground and occupy the terminal, while automatic and daemon processes run independently without a terminal. 3. Commands like ps, pstree, and top are used to view and monitor active processes. Ps provides snapshots of running processes, pstree shows them in a tree format, and top continuously updates process activity.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    185 views8 pages

    Activity Jobs and Processes

    Uploaded by

    ErwinMacaraig
    1. The document discusses Linux jobs, processes, and commands used to monitor and manage them. A job is any command executed, while a process is a program running on the system identified by its process ID. 2. It describes process types like interactive, automatic, and daemon processes. Interactive processes run in the foreground and occupy the terminal, while automatic and daemon processes run independently without a terminal. 3. Commands like ps, pstree, and top are used to view and monitor active processes. Ps provides snapshots of running processes, pstree shows them in a tree format, and top continuously updates process activity.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 8

    SysAd323: Activity 1: Jobs and Processes

    Name:_______________________ Lab Section:___ Lec Sec: ___ CAC: _________

    Objectives:
    1. Define how jobs and processes works in Linux.
    2. List and identify the processes running in the Linux operating system.
    3. Select the most important processes in Linux.
    4. Apply the Linux commands as well as Bash commands to monitor, and manage Linux processes
    and jobs.

    Concepts

    Job
    Every command you give is a job that is executed. A job can be suspended, placed in the
    background, moved back to the foreground or terminated.
    Most of the commands that we encountered such as pwd is executed fast but when you are
    for example dealing with copying large amount of data, it will take a little while finish the job thus
    occupying your terminal (your terminal will be unaccessible unless you put the job in the
    background). In these cases, the job can be placed in the background, allowing you to execute other
    commands in the meantime.

    Job Control
    • Most shells offer job control
    ◦ The ability to stop, restart and background a running process
    • The shell lets you put '&' on the end of a command line to start it in the background
    • You can hit ' Ctrl + Z ' to suspend a running foreground job.
    • Suspended and backgrounded jobs are given numbers by the shell.
    • These numbers can be given to shell job-control built-in commands
    • These are jobs, fg, and bg

    jobs
    • The jobs built-in prints a listing of active jobs and their job numbers

    $jobs
    [1] - Stopped vim index.html
    [2] Running netscape &
    [3] + Stopped man ls

    • Job numbers are given in square brackets


    ◦ But when you use them with other job-control built-ins, you need to write them with
    percent signs, for example %1
    • The jobs marked + and – may be accessed as %+ or %- as well as by number
    ◦ %+ is the shell's idea of the current job – the most recently active job
    ◦ %- is the previous current job
    fg
    • Brings a backgrounded job into the foreground
    • Re-starts a suspended job, running in the foreground
    • fg %1 will foreground job number 1
    • fg with no arguments will operate on the current job

    bg
    • Re-starts a suspended job, running it in the background
    • bg %1 will background job number 1
    • bg with no arguments will operate on the current job
    Example: after running gv and suspending it with Ctrl+Z, use bg to start it running again in
    the background.

    Process

    In our previous lessons last semester we were able to talk or communicate with the operating
    system through the shell. Now, we need to study the processes that runs in Linux in more detail.

    • The kernel considers each program running on the system to be a process


    • A process lives as it executes with a lifetime that may be short or long.
    • A process is said to die when it terminates
    • The kernel identifies each process by a number known as process id or pid
    • The kernel keeps track of various properties of each process.

    Process Types: Interactive Processes


    • Initialize and controlled through a terminal session
    • They are not started automatically as part of the system functions.
    • These processes run in the foreground, occupying the terminal that started the program and
    you can't other applications as long as this process is running in the foreground.
    • Using job control we are able to able to handle multiple process
    ◦ This will allow us to switch processes between the foreground and the background
    ◦ When a process runs in the background, the use is not prevented from doing other things
    in the terminal in which he started the program, while it is running
    • Running a process in the background is only useful for programs that don't need user input

    Process Types: Automatic Processes


    • Processes that are not connected to a terminal.
    • These are tasks that can be queued into a spooler area, where they can be executed on a
    FIFO basis.
    • Such tasks can be executed using one of the following criteria:
    ◦ At a certain date and time: done with the at command
    ◦ At times when the total system load is low enough to accept extra job: done with the
    batch command
    Process Types: Daemons
    • Daemons are server processes that run continuously
    • Most of the time they are initialized at system startup and then wait in the background until
    the service is required

    Process Properties
    • A process has a user id (uid) and a group id (gid) which together specify what permissions
    it has
    • A process has a parent process id (ppid) – the pid of the process which created it
    ◦ The kernel starts an init process with pid 1 at boot-up
    ◦ Every other process is a descendant of pid 1
    • Each process has its own working directory, initially inherited from its parent process
    • There is an environment for each process - a collection of named environment variables and
    their associated values.
    ◦ A process's environment is normally inherited from its parent process

    Parent and Child Processes


    • The init process is the ancestor if all other processes:
    init

    bash

    bash vi

    apache

    apache

    apache

    apache

    • (Apache starts many child processes so that they can serve HTTP requests at the same time)

    ps: process monitoring


    • The ps command gives a snapshot if the processes on a system at a given moment in time
    • Very flexible in what it shows and how:
    ◦ Normally shows a fairly brief summary of each process
    ◦ Normally shows only processes which are both owned by the current user and attached
    to a terminal
    • Unfortunately, it doesn't use standard option syntax
    • Instead it uses a mixture of options with one of three syntaxes
    ◦ Traditional BSD ps: a single letter with no hyphen
    ◦ Unix98 ps: a single letter preceded by a hyphen
    ◦ GNU: a word or phrase preceded by two hyphens

    ps Options
    Option Description
    a Show processes owned by other users
    f Display process ancestors in a tree-like format
    u Use the 'user' output format, showing user names and process start times
    w Use a wider output format. Normally each line of output is truncated; each use
    the w option makes the window wider
    x Include processes which have no controlling terminal
    -e Show information in all processes
    -l Use a long output format
    -f Use a full output format
    -C cmd Show only processes named cmd
    -U user Show only processes owned by user

    pstree: Process Monitoring


    • Displays a snapshot of running processes
    • Always uses a tree-like display like ps f
    ◦ But by default shows only the name of each command
    • Normally shows all processes
    ◦ Specify a pid as an argument to show a specific process and its descendants
    ◦ Specify a user as an argument to show process trees owned by that user

    pstree Options
    Option Description
    -a Display commands' arguments
    -c Don't compact identical subtrees
    -G Attempt to use terminal-specific line-drawing characters
    -h Highlight the ancestors of the current process
    -n Sort processes numerically by pid, rather than alphanumeric by name
    -p Include pids in the output

    top: Process Monitoring


    • Shows full-screen, continuously-updated snapshots of process activity
    ◦ Waits a short period of time between each snapshot to give the illusion of real-time
    monitoring
    ◦ Processes are displayed in descending order of how much processor time they're using
    ◦ Also displays system uptime, load average, CPU status and memory information

    top Command Line Options


    Option Description
    -b Batch mode – send snapshots to standard output
    -n num Exit after displaying num snapshots
    -d delay Wait delay seconds between each snapshots
    -i Ignore idle processes
    -s Disable interactive commands which could be dangerous if run by the
    superuser
    -u username Displays process owned by the username

    top Interactive Commands


    Key Behavior
    q Quit the program
    Ctrl + L Repaint the screen
    h Show a help screen
    k Prompts for a pid and a signal and sends that signal to that process
    n Prompts for the number of processes to show information; 0 (the default) means
    to show as many as will fit
    r Change the priority (niceness) of a process
    s Change the number of seconds to delay between updates. The number may
    include fractions of a second(0.5, for example)
    M Sort by memory usage
    P Sort by CPU usage

    Examples:

    1. Running a job in the background:

    $ cp file backup/file
    Ctrl + Z
    $ bg

    • Using Crl + Z, we are able to put the job in the background and make the terminal available
    for other tasks
    2. Alternately you can do this
    $ cp file backup/file &

    3. To see your running jobs you can use jobs


    $ jobs
    4. To resume the process in the background, we use the bg job control command (short for
    background)
    $ xload
    Ctrl + Z

    $ jobs

    $ bg

    • We use Ctrl + Z to suspend the process


    • We then resume the suspended process using bg

    5. To list the running processes


    $ jobs

    $ ps

    • Immediately following example number 4, we execute the jobs command to display the
    processes that you (the user) have run.
    • Alternately we can use the ps command.

    6. To foreground a suspended job


    $ man sleep

    Ctrl + Z

    $ fg %1

    • We consulted the manual page for the sleep command using the man command
    • Executing Ctrl + Z suspends the less pager for the sleep manual
    • To foreground the less pager we give the shell a fg %1 command

    7. Show all the processes running on your machine in a hierarchical format starting from upper
    parent process, init
    skx@taltos:~$ pstree
    init-+-apache2---10*[apache2]
    |-atd
    |-clamd
    |-cron
    |-events/0
    |-exim4---exim4
    |-freshclam
    |-getty
    |-gpg-agent
    |-khelper
    |-ksoftirqd/0
    |-kthread-+-aio/0
    | |-ata/0
    | |-ata_aux
    | |-kblockd/0
    | |-khubd
    | |-kjournald
    | |-kmirrord
    | |-kseriod
    | |-kswapd0
    | |-2*[pdflush]
    | |-xenbus
    | `-xenwatch
    |-memcached
    |-migration/0
    |-monit---{monit}
    |-munin-node
    |-mysqld_safe-+-logger
    | `-mysqld---16*[{mysqld}]
    |-pdnsd---4*[{pdnsd}]
    |-python
    |-qpsmtpd-forkser
    |-roundup-server---roundup-server
    |-screen---bash---irssi
    |-ssh-agent
    |-sshd-+-sshd---sshd---bash
    | `-sshd---sshd---bash---pstree
    |-syslog-ng
    `-watchdog/0

    Exercises:
    1.
    Execute the command:
    $ sleep 100

    Ctrl + Z

    Specify the output. What does the sleep command do? How does Ctrl + Z affects the previous
    command - sleep command?

    2. How would you move the stoped job in number 1 to the background? (Specify the exact
    command)

    3. Execute the command exactly as specified here:


    $ sleep 150
    Ctrl + Z

    $ sleep 140
    Ctrl + Z

    $ sleep 130
    Ctrl + Z

    $ jobs

    Specify the output of the last command entered (jobs)

    4. How would you move the second active job to the background? (Specify the exact command)

    5.How would you run xclock in the background using &. (Specify the exact command)

    6. Can command(s) will you use to bring xclock into the foreground? (Specify the exact command)
    7. Run
    $ gedit
    This should run gedit in the foreground. You will not be able to use the shell.
    Try suspending gedit with Ctrl + Z.
    What happened when you executed Ctrl + Z?
    How would you put gedit into the background?

    8. Use the top command to show the processes running on your machine. (Specify at least 5 lines of
    ouput).

    9. Make top sort by memory usage, so that the most memroy-hungry processes appear on top.

    10. Restrict the display to show only processes owned by you.

    You might also like