pwd
# Output Example: /home/your_username/Documents
2. ls (List) - Seeing What's There 📄
The ls command is used to list the contents of a directory. It's like opening a folder to see its files and subfolders.

Purpose: To display files and directories.

Syntax: ls [OPTIONS] [FILE...]

Basic Examples:

List contents of the current directory:



ls
Example Output:

Documents  Downloads  Music  Public  Templates  Videos
List contents of a specific directory:



ls /home/your_username/Documents
# Or, if you are already in your home directory:
ls Documents
Example Output:

report.txt  presentation.pptx  notes/  project_plan.docx
Common Options & Advanced Examples:

-l (long format): Displays a detailed list including file permissions, number of hard links, owner, group, size, and last modification date.



ls -l
Example Output:

total 20
drwxr-xr-x 2 user user 4096 Jul 23 10:00 notes/
-rw-r--r-- 1 user user 1500 Jul 22 14:30 presentation.pptx
-rw-r--r-- 1 user user  250 Jul 24 11:15 report.txt
-rw-r--r-- 1 user user 3000 Jul 20 09:00 project_plan.docx
-a (all): Shows all files, including hidden files (those starting with a .).



ls -a
Example Output:

.   ..  .rc  Documents  Downloads  .hidden_file.txt  Music
-h (human-readable): Use with -l to show file sizes in a more readable format (e.g., K for kilobytes, M for megabytes, G for gigabytes).



ls -lh
Example Output:

total 20K
drwxr-xr-x 2 user user 4.0K Jul 23 10:00 notes/
-rw-r--r-- 1 user user 1.5K Jul 22 14:30 presentation.pptx
-rw-r--r-- 1 user user  250 Jul 24 11:15 report.txt
-rw-r--r-- 1 user user 3.0K Jul 20 09:00 project_plan.docx
-R (recursive): Lists contents of subdirectories recursively.



ls -R
Example Output:

.:
notes  presentation.pptx  report.txt  project_plan.docx

./notes:
meeting_minutes.txt  todo.txt
Combining options: You can combine multiple options.



ls -lah # Long format, all files, human-readable sizes
3. cd (Change Directory) - Moving Around 🚶‍♂️
The cd command is used to change your current working directory.

Purpose: To navigate between directories.

Syntax: cd [DIRECTORY]

Examples:

Change to your home directory:



cd
# Or explicitly:
cd ~
This is very useful for quickly returning to your starting point.

Change to a subdirectory (relative path):



cd Documents
Change to a parent directory:



cd ..
If you are in /home/user/Documents, cd .. will take you to /home/user.

Change to the root directory:



cd /
Change to the previous directory you were in:



cd -
If you were in /var/log and then went to /home/user, cd - will take you back to /var/log.

Change to an absolute path:



cd /var/log
4. file - What Kind of File Is It? ❓
The file command helps you determine the type of a file. It inspects the file's content, not just its extension.

Purpose: To identify the type of a file.

Syntax: file [OPTIONS] FILE...

Examples:

Check the type of a text file:



file my_document.txt
# Output Example: my_document.txt: ASCII text
Check the type of a directory:



file my_folder
# Output Example: my_folder: directory
Check the type of an executable program:



file /bin/ls
# Output Example: /bin/ls: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=..., stripped
5. mkdir (Make Directory) - Creating Folders 📁
The mkdir command is used to create new directories (folders).

Purpose: To create one or more new directories.

Syntax: mkdir [OPTIONS] DIRECTORY...

Examples:

Create a single directory:



mkdir new_project
Create multiple directories at once:



mkdir dir1 dir2 dir3
Create a directory with parent directories (if they don't exist):
The -p (parents) option is very useful for creating nested directory structures in one go.



mkdir -p my_app/src/main/java
This will create my_app, then my_app/src, then my_app/src/main, and finally my_app/src/main/java.

6. touch - Creating Empty Files or Updating Timestamps 📝
The touch command is primarily used to create empty new files or to update the access and modification times of existing files.

Purpose: To create empty files or change file timestamps.

Syntax: touch [OPTIONS] FILE...

Examples:

Create an empty new file:



touch my_new_file.txt
If my_new_file.txt doesn't exist, it will be created empty.

Update the timestamp of an existing file:



touch existing_document.txt
If existing_document.txt exists, its "last modified" and "last accessed" timestamps will be updated to the current time, without changing its content.

7. cp () - Duplicating Files and Directories 📋
The cp command is used to  files and directories.

Purpose: To make copies of files or directories.

Syntax: cp [OPTIONS] SOURCE DESTINATION

Examples:

 a file to the same directory with a new name (effectively renaming a ):



cp report.txt report_backup.txt
 a file to a different directory:



cp document.pdf /home/your_username/Documents/archives/
# Or to a relative path:
cp document.pdf ../backups/
 a directory (and its contents):
The -r (recursive) option is mandatory when ing directories, as cp by default only copies files.



cp -r my_folder new_folder_
Common Options:

-r (recursive): Required for ing directories.

-i (interactive): Prompts you before overwriting an existing file. Highly recommended for safety.



cp -i file1.txt file1_.txt
-v (verbose): Shows what's being copied.



cp -v file1.txt /tmp/
# Output: 'file1.txt' -> '/tmp/file1.txt'
8. mv (Move / Rename) - Moving or Renaming Files and Directories ➡️
The mv command is used to move files or directories from one location to another, or to rename them.

Purpose: To move or rename files and directories.

Syntax: mv [OPTIONS] SOURCE DESTINATION

Examples:

Rename a file (same directory, new name):



mv old_name.txt new_name.txt
Move a file to a different directory:



mv document.odt /home/your_username/Downloads/
# Or to a relative path:
mv my_image.jpg ../archive/images/
Move a directory:



mv project_old project_archive/
This moves the entire project_old directory and its contents into the project_archive directory.

Common Options:

-i (interactive): Prompts before overwriting an existing file. Recommended.

-v (verbose): Shows what's being moved/renamed.

9. rm (Remove) - Deleting Files and Directories 🗑️
The rm command is used to remove (delete) files or directories. Use rm with extreme caution, as deleted files are generally not recoverable, especially on Linux where there's no "Recycle Bin" equivalent for command-line deletions.

Purpose: To delete files or directories.

Syntax: rm [OPTIONS] FILE...

Examples:

Remove a single file:



rm unwanted_file.txt
Remove multiple files:



rm file1.txt file2.txt temp_data.csv
Remove a directory and its contents (recursive):
*The -r (recursive) option is mandatory for deleting non-empty directories. Be very, very careful with this!



rm -r old_project_files/
Common Options (Use with Caution!):

-i (interactive): Prompts before every deletion. Highly recommended to prevent accidental deletion.



rm -i my_file_to_delete.txt
# Output: rm: remove regular file 'my_file_to_delete.txt'? (y/n)
-f (force): Forces deletion, ignoring non-existent files and never prompting. Extremely dangerous! Only use if you are absolutely sure. Often combined with -r as rm -rf.



rm -rf /path/to/directory_to_delete # AVOID THIS UNLESS YOU ARE 100% CERTAIN
10. find - Locating Files and Directories 🔍
The find command is a powerful tool for searching for files and directories based on various criteria (name, type, size, modification time, permissions, etc.).

Purpose: To search for files and directories in a directory hierarchy.

Syntax: find [PATH...] [EXPRESSION]

PATH: The starting directory for the search (e.g., . for current, / for root).

EXPRESSION: Consists of options, tests, actions, and operators.

Examples:

Find a file by name (case-sensitive) in the current directory and its subdirectories:



find . -name "report.txt"
Find a file by name (case-insensitive):



find . -iname "Report.txt"
Find all .log files in /var/log:



find /var/log -name "*.log"
Find directories only:



find . -type d -name "my_project*"
Find files only:



find . -type f -name "config.*"
Find files larger than 1 Megabyte:



find . -type f -size +1M
Size units: b (512-byte blocks), c (bytes), k (kilobytes), M (megabytes), G (gigabytes).

Find files modified in the last 7 days:



find . -type f -mtime -7
+7 for older than 7 days, 7 for exactly 7 days old.

Find files by owner:



find . -user john -name "*.log"
Find and execute a command on found files (e.g., delete backup files):

The -exec option runs a command for each found item.

{} is a placeholder for the found filename.

\; marks the end of the -exec command.



find . -name "*.bak" -exec rm {} \;
Use -exec rm {} \; with extreme caution! Always test find without -exec first to ensure it's selecting the correct files.

Find files and pipe them to another command (using xargs for efficiency):



find . -name "*.tmp" -print0 | xargs -0 rm
-print0 and xargs -0 handle filenames with spaces or special characters correctly.


---

### Tutorial 2: Wildcards (`*`, `?`), Relative vs. Absolute Paths

Here's a detailed tutorial on wildcards and paths.

```markdown
# Linux Wildcards and Paths Tutorial

This tutorial explains the use of wildcards for pattern matching and the fundamental concepts of relative and absolute paths in the Linux filesystem.

## 1. Wildcards (Globbing) - Pattern Matching for Files

Wildcards are special characters that allow you to specify patterns to match multiple filenames with a single expression. This is incredibly useful for selecting groups of files for commands like `ls`, `cp`, `mv`, `rm`, etc.

### a. The `*` Wildcard (Asterisk) - Matches Any Sequence of Characters

* **Meaning:** Matches any sequence of zero or more characters.
* **Use Case:** Ideal for matching parts of filenames.

**Examples:**

1.  **Match all files ending with `.txt`:**
    ```
    ls *.txt
    ```
    *If you have `document.txt`, `notes.txt`, `report.pdf`, `image.png`*
    *Output:*
    ```
    document.txt  notes.txt
    ```

2.  **Match all files starting with `report`:**
    ```
    ls report*
    ```
    *If you have `report.txt`, `report_final.pdf`, `archive_report.zip`*
    *Output:*
    ```
    report.txt  report_final.pdf
    ```

3.  **Match all files containing `data`:**
    ```
    ls *data*
    ```
    *If you have `raw_data.csv`, `processed_data.json`, `my_document.txt`*
    *Output:*
    ```
    processed_data.json  raw_data.csv
    ```

4.  **Match all files (effectively `ls -a` if no other options are used):**
    ```
    ls *
    ```
    *This will list all non-hidden files and directories.*

### b. The `?` Wildcard (Question Mark) - Matches Any Single Character

* **Meaning:** Matches any single character.
* **Use Case:** Useful when you know the number of characters but not their exact value.

**Examples:**

1.  **Match `file1.txt`, `file2.txt`, but not `file10.txt`:**
    ```
    ls file?.txt
    ```
    *If you have `file1.txt`, `fileA.txt`, `file_new.txt`, `file10.txt`*
    *Output:*
    ```
    file1.txt  fileA.txt
    ```

2.  **Match files like `doc-A.txt`, `doc-B.txt`:**
    ```
    ls doc-?.txt
    ```

3.  **Match files with exactly 3 characters before the extension:**
    ```
    ls ???.log
    ```
    *Matches `abc.log`, `123.log`, but not `abcd.log` or `ab.log`.*

### c. Character Sets `[ ]` - Matches Any Character Within the Brackets

* **Meaning:** Matches any single character that is part of the specified set.
* **Use Case:** When you need to match specific characters at a position.

**Examples:**

1.  **Match files ending in `.txt` or `.log`:**
    ```
    ls *.[tl]xt
    ```
    *This is a bit simplified; better to use `ls *.txt *.log` for OR conditions across extensions.*

2.  **Match `file1.txt` or `file2.txt` (but not `file3.txt`):**
    ```
    ls file[12].txt
    ```

3.  **Match filenames with a digit (0-9):**
    ```
    ls *[0-9]*
    ```

## 2. Paths: Relative vs. Absolute

Understanding how to refer to files and directories using paths is fundamental to navigating and managing your Linux system.

### a. Absolute Paths (Full Paths)

* **Definition:** An absolute path is the **complete path from the root directory (`/`)** to the file or directory you are referencing.
* **Characteristics:**
    * Always start with a forward slash (`/`).
    * Uniquely identifies the location of a file or directory regardless of your current working directory.
* **Analogy:** Like giving someone full directions from a well-known landmark (e.g., "From the Empire State Building, go north 5 blocks...").

**Examples:**

* `/home/your_username/Documents/report.txt`
    * Starts from the root (`/`), goes into `home`, then `your_username`, then `Documents`, then `report.txt`.
* `/etc/passwd`
* `/var/log/syslog`
* `/usr/bin/ls`

**When to use Absolute Paths:**

* When you need to refer to a file or directory from *any* location in the filesystem.
* In scripts, configuration files, or cron jobs where the current working directory is unpredictable.
* When you want to be explicit and avoid ambiguity.

### b. Relative Paths

* **Definition:** A relative path specifies the location of a file or directory **in relation to your current working directory**.
* **Characteristics:**
    * Does *not* start with a forward slash (`/`).
    * Depends on where you currently are in the filesystem.
* **Analogy:** Like giving directions from your current location ("Go left, then straight two blocks").

**Key Relative Path Notations:**

* `.` (single dot): Represents the **current directory**.
* `..` (double dot): Represents the **parent directory** (one level up).

**Examples:**

Let's assume your current working directory is `/home/your_username/Documents/`:

1.  **Referring to a file in the current directory:**
    ```
    ls report.txt      # Lists report.txt within /home/your_username/Documents/
    ls ./report.txt    # Same as above, explicitly using '.'
    ```

2.  **Referring to a directory in the current directory:**
    ```
    cd notes/          # Changes to /home/your_username/Documents/notes/
    ```

3.  **Referring to a file in a subdirectory:**
    ```
    cat notes/meeting_minutes.txt # Displays content of file in the 'notes' subdirectory
    ```

4.  **Referring to a file in the parent directory:**
    ```
    ls ../Downloads/my_download.zip # Lists a file in /home/your_username/Downloads/
    ```

5.  **Referring to a file two directories up:**
    ```
    cp ../../another_file.txt . # Copies another_file.txt from /home/your_username/ to current directory
    ```

**When to use Relative Paths:**

* When navigating within a specific project structure.
* When the exact absolute path might change (e.g., if you move a project folder).
* For shorter, more convenient typing in the command line.

**Comparison:**

| Feature            | Absolute Path                       | Relative Path                                |
| :----------------- | :---------------------------------- | :------------------------------------------- |
| **Starting Point** | Always from the root (`/`)          | From the current working directory           |
| **Ambiguity** | No ambiguity, always the same path  | Can be ambiguous if current directory changes |
| **Typing Effort** | Generally longer                    | Generally shorter                            |
| **Use Case** | Scripts, configuration, cross-system | Interactive shell, within project structures |

**Practice:**
Navigate to `/var/log`. Now, try to `ls` the contents of `/home/your_username/Documents` using both an absolute path and a relative path. (Hint for relative: you'll need `../` multiple times to get up to the root or `home` from `/var/log`).

# Day 3: Permissions and Essential Commands

---

## Permissions: `rwx`, `chmod`, `chown` (RHCSA 4.14)

### File Permission Basics (`rwx`)

Linux file permissions are displayed as:
-rwxr-xr--





| Symbol | Meaning       |
|--------|----------------|
| `r`    | Read           |
| `w`    | Write          |
| `x`    | Execute        |
| `-`    | No permission  |

### Permission Sections:

| Section     | Who it applies to |
|-------------|-------------------|
| First char  | File type (`-`=file, `d`=directory) |
| 1–3         | Owner permissions |
| 4–6         | Group permissions |
| 7–9         | Others' permissions |

---

### `chmod` – Change permissions

Markdown

## 1. top: The Classic Process Monitor 

`top` (table of processes) is a traditional, powerful, and real-time command-line utility that provides a dynamic view of running processes. It displays information about CPU and memory usage, process ID (PID), user, and much more.

### 1.1 Basic Usage and Output Explained
Just type `top` in your terminal and press Enter.

top - 09:30:01 up 2 days, 16:30,  1 user,  load average: 0.00, 0.01, 0.05
Tasks: 200 total,    1 running, 199 sleeping,    0 stopped,    0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   7987.9 total,   7000.0 free,    500.0 used,    487.9 buff/cache
MiB Swap:   4096.0 total,   4096.0 free,      0.0 used.   7200.0 avail Mem

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM    TIME+ COMMAND
  1 root      20   0  169420   9980   6720 S   0.0   0.1   0:15.23 systemd
  2 root      20   0       0      0      0 S   0.0   0.0   0:00.04 kthreadd
... (more processes)

Understanding the Output Sections:

Header (First 5 lines):

* **Line 1 (System Summary):**
    * `top - HH:MM:SS`: Current system time.
    * `up X days, Y hours/minutes`: System uptime.
    * `Z users`: Number of users currently logged in.
    * `load average: L1, L5, L15`: Average number of processes waiting to run over the last 1, 5, and 15 minutes. High numbers indicate a busy system.

* **Line 2 (Tasks/Processes):**
    * `total`: Total number of processes.
    * `running`: Number of processes currently executing.
    * `sleeping`: Processes waiting for an event (e.g., I/O).
    * `stopped`: Processes that have been stopped (e.g., by Ctrl+Z).
    * `zombie`: Zombie processes (terminated but parent hasn't reaped them; indicates a problem).

* **Line 3 (CPU Usage):** Percentages of CPU time spent in various states.
    * `us`: User CPU time (processes running in user space).
    * `sy`: System CPU time (kernel operations).
    * `ni`: Nice CPU time (user processes with modified priority).
    * `id`: Idle CPU time.
    * `wa`: I/O Wait time (CPU waiting for disk or network I/O).
    * `hi`: Hardware Interrupts.
    * `si`: Software Interrupts.
    * `st`: Steal time (relevant in virtualized environments where CPU is "stolen" by the hypervisor).

* **Line 4 (Memory Usage - Physical RAM):**
    * `total`: Total physical memory.
    * `free`: Unused memory.
    * `used`: Memory actively used by processes.
    * `buff/cache`: Memory used by kernel buffers and page cache (can be freed if needed).

* **Line 5 (Swap Usage):**
    * `total`: Total swap space.
    * `free`: Unused swap space.
    * `used`: Used swap space.
    * `avail Mem`: Estimated available memory for new applications (free + reclaimable buff/cache).

**Process List (Table):**

* `PID`: Process ID.
* `USER`: User who owns the process.
* `PR`: Priority (kernel-assigned).
* `NI`: Nice value (user-assigned priority; lower is higher priority).
* `VIRT`: Virtual memory used by the process (including swap and shared libraries).
* `RES`: Resident Set Size (physical memory actually used by the process, not swapped out). This is a key metric for memory usage.
* `SHR`: Shared memory (memory shared with other processes).
* `S`: Process Status (S=sleeping, R=running, Z=zombie, T=stopped).
* `%CPU`: Percentage of CPU time used since the last update.
* `%MEM`: Percentage of total physical memory used.
* `TIME+`: Total CPU time used by the task since it started.
* `COMMAND`: The command name or command line of the process.

### 1.2 Interactive Commands within top
While `top` is running, you can press several keys to interact with it:

* `q`: Quit `top`.
* `k`: Kill a process (prompts for PID, then signal, e.g., 9 for KILL).
* `r`: Renice a process (change its nice value/priority).
* `d` or `s`: Change the update delay (in seconds).
* `z`: Toggle color/bold mode.
* `b`: Toggle bold highlighting of running processes.
* `x`: Highlight sort column.
* `y`: Highlight running tasks.
* `1`: Toggle display of individual CPU cores.
* `m`: Toggle memory display modes (percent, absolute, etc.).
* `P`: Sort by %CPU (default).
* `M`: Sort by %MEM.
* `T`: Sort by TIME+.
* `u`: Filter by user (prompts for username).
* `h` or `?`: Display help screen.

### 1.3 Running top with Options
You can also start `top` with command-line options:

* `top -d 2`: Update every 2 seconds.
* `top -u username`: Show processes for a specific user.
* `top -p PID`: Monitor a specific process by PID.
* `top -n 1`: Run once and exit (useful in scripts).

**Example: Monitor the httpd process (assuming its PID is 12345):**

PID USER      PRI NI VIRT  RES  SHR S CPU% MEM%  TIME+ Command

#Day 4