may not offer.

5. The power of community

Unlike closed source software, where development and improvement are limited to a specific team or
company, open source projects benefit from a global community of developers, users, and enthusiasts.
The power of community lies in its ability to harness the collective intelligence of passionate individuals
who share a common goal: creating high-quality software accessible to all.
Cons of open source software
Open source software, despite its many advantages, also has some drawbacks that users should be
aware of:
1. No prompt support
Open source software often relies on community forums and user-driven discussions for
troubleshooting and problem-solving. While these forums can be helpful in many cases, they may not
always provide immediate or timely responses to users’ queries or issues. This can be frustrating for
individuals or businesses requiring urgent technical assistance.
It’s important to consider this aspect before choosing open source software, especially if your
organization requires a high level of technical support and quick resolution for any potential problems
that may arise during usage.
2. Complexity and difficult learning curve
Unlike closed source software, which often comes with user-friendly interfaces and comprehensive
documentation, open source software might require some technical expertise to navigate effectively.
The sheer flexibility and customization options offered by open source software can lead to higher
complexity. Users may need to invest time in understanding the intricacies of the software’s framework
and architecture, configuration settings, and dependencies. This can be daunting for those unfamiliar
with coding or with limited technical knowledge.
3. Limited features
Open source software (OSS) offers numerous benefits, but it’s important to acknowledge that there can
also be limitations. One of these is the potential for limited features in certain OSS projects. This is
because OSS development relies on community contributions and volunteer efforts, which may result in
prioritizing core functionalities over additional features.
4. High maintenance needs
Since these projects rely on community contributions and updates, they require regular upkeep to
ensure compatibility and security. This includes regularly monitoring for updates, bug fixes, and security
patches. Open source applications can become vulnerable to security breaches or compatibility issues
with other software components without proper maintenance.
Additionally, because multiple contributors are involved in the development of open source projects,
coordinating updates can be more complex compared to closed source alternatives, where a single
vendor oversees all aspects of maintenance.
5. Less stable builds
The open nature of OSS means that anyone can modify and update the code, which can lead to
unintended consequences. As a result, users may experience occasional crashes or glitches while using
open source applications. However, passionate developers within the community work diligently to
address these issues and release patches and updates to improve stability over time.
Open Source Software Examples
There are numerous examples of open source software that have made a significant impact in the tech
industry. These include:
 VLC Media Player: VLC Media Player, developed by VideoLAN, is a highly popular open source media
player that supports a wide range of audio and video formats. With its humble beginnings in 1996 as an
academic project at École Centrale Paris, VLC has become one of today’s most widely used media
players.
 GIMP: GIMP, short for GNU Image Manipulation Program, is a powerful open source image editing
software. The history of GIMP dates back to 1995 when Spencer Kimball and Peter Mattis developed the
software as a class project at the University of California, Berkeley. Over the years, it has evolved into a
highly versatile tool used by graphic designers, photographers, and artists worldwide.
 Mozilla Firefox: Mozilla Firefox is a popular web browser that has gained immense popularity among
users worldwide. It was created by the Mozilla Foundation and was initially released in 2004 as an open
source project.
 Linux: Linux is a powerful open source operating system that has revolutionized the computing world.
Developed by Linus Torvalds in 1991, Linux was initially created as an alternative to proprietary
operating systems like Windows and macOS. It is based on the Unix operating system and is designed to
run on a wide range of devices, from servers to Raspberry Pi.
 Apache HTTP Server: The Apache HTTP Server, commonly known as Apache, was created by a group of
developers in 1995 to provide a robust and reliable platform for hosting websites. Since its inception, it
has become one of the most popular web servers globally, commanding over half of the market share.
Takeaway

An Introduction to Linux

Introduction
The Linux operating system is an extremely versatile Unix-like operating system, and has taken a clear
lead in the High Performance Computing (HPC) and scientific computing community. Linux is a multi-
user, preemptive multitasking operating system that provides a number of facilities including
management of hardware resources, directories, and file systems, as well as the loading and execution
of programs. A vast number of utilities and libraries have been developed (mostly free and open source
as well) to accompany or extend Linux.
There are two major components of Linux, the kernel and the shell:
1. The kernel is the core of the Linux operating system that schedules processes and interfaces directly
with the hardware. It manages system and user I/O, processes, devices, files, and memory.
2. The shell is a text-only interface to the kernel. Users input commands through the shell, and the kernel
receives the tasks from the shell and performs them. The shell tends to do four jobs repeatedly: display
a prompt, read a command, process the given command, then execute the command. After which it
starts the process all over again.
It is important to note that users of a Linux system typically do not interact with the kernel directly.
Rather, most user interaction is done through the shell or a desktop environment.

Unix
The Unix operating system got its start in 1969 at Bell Laboratories and was written in assembly
language. In 1973, Ken Thompson and Dennis Ritchie succeeded in rewriting Unix in their new language
C. This was quite an audacious move; at the time, system programming was done in assembly in order to
extract maximum performance from the hardware. The concept of a portable operating system was
barely a gleam in anyone's eye.
The creation of a portable operating system was very significant in the computing industry, but then
came the problem of licensing each type of Unix. Richard Stallman, an American software freedom
activist and programmer recognized a need for open source solutions and launched the GNU project in
1983, later founding the Free Software Foundation. His goal was to create a completely free and open
source operating system that was Unix-compatible or Unix-like.
Linux
In 1987, the source code to a minimalistic Unix-like operating system called MINIX was released by
Andrew Tanenbaum, a professor at Vrije Universiteit, for academic purposes. Linus Torvalds began
developing a new operating system based on MINIX while a student at the University of Helsinki in 1991.
In September of 1991, Torvalds released the first version (0.1) of the Linux kernel.
Torvalds greatly enhanced the open source community by releasing the Linux kernel under the GNU
General Public License so that everyone has access to the source code and can freely make
modifications to it. Many components from the GNU project, such as the GNU Core Utilities, were then
integrated with the Linux kernel, thus completing the first free and open source operating system.
Linux has been adapted to a variety of computer systems of many sizes and purposes. Furthermore,
different variants of Linux (called Linux distributions) have been developed over time to meet various
 needs. There are now hundreds of different Linux distributions available, with a wide variety of features.
The most popular operating system in the world is actually Android, which is built on the Linux kernel.
Why Linux
Linux has been so heavily utilized in the HPC and scientific computing community that it has become the
standard in many areas of academic and scientific research, particularly those requiring HPC. There have
been over 40 years of development in Unix and Linux, with many academic, scientific, and system tools.
In fact, as of November 2017, all of the TOP500 supercomputers in the world run Linux!
Linux has four essential properties which make it an excellent operating system for the science
community:
 Performance – Performance of the operating system can be optimized for specific tasks such as running
small portable devices or large supercomputers.
 Functionality – A number of community-driven scientific applications and libraries have been developed
under Linux such as molecular dynamics, linear algebra, and fast-Fourier transforms.
 Flexibility – The system is flexible enough to allow users to build applications with a wide array of
support tools such as compilers, scientific libraries, debuggers, and network monitors.
 Portability – The operating system, utilities, and libraries have been ported to a wide variety of devices
including desktops, clusters, supercomputers, mainframes, embedded systems, and smart phones.
Files and Processes
Everything in Linux is considered to be either a file or a process:
 A process is an executing program identified by a unique process identifier, called a PID. Processes may
be short in duration, such as a process that prints a file to the screen, or they may run indefinitely, such
as a monitor program.
 A file is a collection of data, with a location in the file system called a path. Paths will typically be a series
of words (directory names) separated by forward slashes, /. Files are generally created by users via text
editors, compilers, or other means.
 A directory is a special type of file. Linux uses a directory to hold information about other files. You can
think of a directory as a container that holds other files or directories; it is equivalent to a folder in
Windows or macOS.
A file is typically stored on physical storage media such as a disk (hard drive, flash disk, etc.). Every file
must have a name because the operating system identifies files by their name. File names may contain
any characters, although some special characters (such as spaces, quotes, and parenthesis) can make it
difficult to access the file, so you should avoid them in filenames. On most common Linux variants, file
names can be as long as 255 characters, so it is convenient to use descriptive names.
Files can hold any sequence of bytes; it is up to the user to choose the appropriate application to
correctly interpret the file contents. Files can be human readable text organized line by line, a structured
sequence only readable by a specific application, or a machine-readable byte sequence. Many programs
interpret the contents of a file as having some special structure, such as a pdf or postscript file. In
scientific computing, binary files are often used for efficiency storage and data access. Some other
examples include scientific data formats like NetCDF or HDF which have specific formats and provide
application programming interfaces (APIs) for reading and writing.
The Linux kernel is responsible for organizing processes and interacting with files; it allocates time and
memory to each process and handles the file system and communications in response to system calls.
The Linux system uses files to represent everything in the system: devices, internals to the kernel,
configurations, etc.
Shells
A variety of different shells are available for Linux and Unix, each with pros and cons. While bash
(updated version of sh) and tcsh (descended from C-shell/csh) are the most common shells, the choice
of shell is entirely up to user preference and availability on the system. In most Linux distributions, bash
is the default shell.
The purpose of a shell is to interpret commands for the Operating System (OS) to execute. Since bash
and other shells are scripting languages, a shell can also be used for programming via scripts. The shell is
an interactive and customizable environment for the user.
All examples in this tutorial use the bash shell.
Text Editors
A text editor is a tool to assist the user with creating and editing files. There is no "best" text editor; it
depends on personal preferences. Regardless of your typical workflow, you will likely need to be
proficient in using at least one common text editor if you are using Linux for scientific computing or
similar work. Two of the most widely used command-line editors are Vim and Emacs, which are
available via the vim and emacs commands, respectively, in systems where they are installed.
Linux File System

A file system is a structured method of storing and managing data—including files, directories, and
metadata—on your machine. Think of it like a library. If thousands of books were scattered around,
finding one would be hard. But in an organized structure, like labeled shelves, locating a book becomes
easy.
This article aims to simplify the complexities of Linux file systems, guiding beginners through their layers,
characteristics, and implementations. By shedding light on these nuances, we empower users to make
informed choices in navigating the dynamic landscape of Linux operating systems.
What is the Linux File System
A Linux file system is a set of processes that controls how, where, and when data is stored or retrieved
from storage devices. It manages data systematically on disk drives or partitions, and each partition in
Linux has its own file system because Linux treats everything as a file, including devices and
applications.. Like Windows uses C: and D: drives, Linux uses mount points, but everything appears
under the root / directory. In Linux, everything is treated as a file, including devices and applications.
Linux File System Structure
The architecture of a file system comprises three layers mentioned below.
1. Logical File System:
The Logical File System acts as the interface between the user applications and the file system itself. It
facilitates essential operations such as opening, reading, and closing files. Essentially, it serves as the
user-friendly front-end, ensuring that applications can interact with the file system in a way that aligns
with user expectations.
2. Virtual File System:
The Virtual File System (VFS) is a crucial layer that enables the concurrent operation of multiple
instances of physical file systems. It provides a standardized interface, allowing different file systems to
coexist and operate simultaneously. This layer abstracts the underlying complexities, ensuring
compatibility and cohesion between various file system implementations.
3. Physical File System:
The Physical File System is responsible for the tangible management and storage of physical memory
blocks on the disk. It handles the low-level details of storing and retrieving data, interacting directly with
the hardware components. This layer ensures the efficient allocation and utilization of physical storage
resources, contributing to the overall performance and reliability of the file system.
Together, these layers form a cohesive architecture, orchestrating the organized and efficient handling
of data in the Linux operating system.
 Architecture Of
a File System
Characteristics of a File System
A file system defines the rules and structures for how data is organized, stored, accessed, and managed
on a storage device.
 Space Management: How the data is stored on a storage device. Pertaining to the memory blocks and
fragmentation practices applied in it.
 Filename: A file system may have certain restrictions to file names such as the name length, the use of
special characters, and case sensitive-ness.
 Directory: The directories/folders may store files in a linear or hierarchical manner while maintaining an
index table of all the files contained in that directory or subdirectory.
 Metadata: For each file stored, the file system stores various information about that file's existence such
as its data length, its access permissions, device type, modified date-time, and other attributes. This is
called metadata.
 Utilities: File systems provide features for initializing, deleting, renaming, moving, copying, backup,
recovery, and control access of files and folders.
 Design: Due to their implementations, file systems have limitations on the amount of data they can
store.
Linux File Systems:
Here are some linux file systems:
 Types of File
System in Linux
1) ext (Extended File System):
Implemented in 1992, it is the first file system specifically designed for Linux. It is the first member of the
ext family of file systems.
2) ext2:
The second ext was developed in 1993. It is a non-journaling file system that became known for its
efficient handling of flash drives and SSDs. It solved the problems of separate timestamp for access,
inode modification and data modification. Due to not being journaled, it is slow to load at boot time.
3) Xiafs:
Also developed in 1993, Xiafs was developed as an alternative but lacked the power and functionality of
ext2. Due to limited features and scalability, it is no longer in use.
4) ext3:
Introduced in 1999, ext3 brought in journaling capabilities, offering improved reliability. Unlike ext2, it
avoided long boot-time checks after an improper shutdown. It also supported online file system growth
and HTree indexing, making it efficient for large directories.
5) JFS (Journaled File System):
First created by IBM in 1990, the original JFS was taken to open source to be implemented for Linux in
199 it is Known for its ability to perform well under varied loads JFS performs well under different kinds
of load but is not commonly used anymore due to the release of ext4 in 2006 which gives better
performance.
6) ReiserFS:
It is a journal file system developed in 2001. Despite its earlier issues, it has tail packing as a scheme to
reduce internal fragmentation. It uses a B+ Tree that gives less than linear time in directory lookups and
updates. It was the default file system in SUSE Linux till version 6.4, until switching to ext3 in 2006 for
version 10.2.
7) XFS:
XFS is a 64-bit journaling file system and was ported to Linux in 2001. It now acts as the default file
system for many Linux distributions. It provides features like snapshots, online defragmentation, sparse
files, variable block sizes, and excellent capacity. It also excels at parallel I/O operations.
8) SquashFS:
Developed in 2002, this file system is read-only and is used only with embedded systems where low
overhead is needed.
) Reiser4:
It is an incremental model to ReiserFS. It was developed in 2004. However, it is not widely adapted or
supported on many Linux distributions.
10) ext4:
The fourth ext developed in 2006, is a journaling file system. It has backward compatibility with ext3 and
ext2 and it provides several other features, some of which are persistent pre-allocation, unlimited
number of subdirectories, metadata checksumming and large file size. ext4 is the default file system for
many Linux distributions and also has compatibility with Windows and Macintosh.
11) btrfs (Better/Butter/B-tree FS):
It was developed in 2007. It provides many features such as snapshotting, drive pooling, data scrubbing,
self-healing and online defragmentation. It is the default file system for Fedora Workstation.
12) bcachefs:
This is a copy-on-write file system that was first announced in 2015 with the goal of performing better
than btrfs and ext4. Its features include full filesystem encryption, native compression, snapshots, and
64-bit check summing.
13) Others:
Linux also has support for file systems of operating systems such as NTFS and exFAT, but these do not
support standard Unix permission settings. They are mostly used for interoperability with other
operating systems.
File Systems Comparison:
Please note that there are more criteria than the ones listed in the table. This table is supposed to give
you an idea of how file systems have evolved.

Parameter File Systems

s ext ext2 Xiafs ext3 JFS ReiserFS XFS Reiser4 ext4 btrfs
Max. 4032
filename 255
255 255 248 255 255 255 3976 255 255
length characte
(bytes) rs
Allowable
characters Any
in except except except except Unicode except except except except NUL, except
directory NUL NUL, / NUL NUL or / except NUL or / NUL NUL, / / NUL, /
entries NUL
(Any byte)
Max.
Undefin Undefin Undefin Undefin Undefin Undefin Undefin Undefin Undefin
pathname Undefined
ed ed ed ed ed ed ed ed ed
length
Max. file 16GB - 16GB - 8TB (on 16GB -
2 GB 64MB 4PB 8TB 8EB 16EB
size 2TB 2TB x86) 16TB
Max.
2TB - 2TB -
volume 2 GB 2GB 32PB 16TB 8EB - 1EB 16EB
32TB 32TB
size
Max. no.
- - - - - - - - 2^32 2^64
of files
Metadata
only No No No Yes Yes Yes Yes No Yes No
journaling
Compressi
No No No No No No No Yes No Yes
on
 Parameter File Systems
s ext ext2 Xiafs ext3 JFS ReiserFS XFS Reiser4 ext4 btrfs
Block sub-
No No No No Yes Yes No Yes No Yes
allocation
Online
No No - Yes No Yes Yes Yes Yes Yes
grow
Yes
Encryption No No No No No No No Yes (experimen No
tal)
Checksum No No No No No No Partial No Partial Yes
Observations:
We see that XFS, ext4 and btrfs perform the best of all the other file systems. In fact, btrfs looks as if it's
almost the best. Despite that, the ext family of file systems has been the default for most Linux
distributions for a long time. So, what is it that made the developers choose ext4 as the default rather
than btrfs or XFS? Since ext4 is so important for this discussion, let's describe it a bit more.
ext4 in Linux File System
Ext4 was designed to be backward compatible with ext3 and ext2, its previous generations. It's better
than the previous generations in the following ways:
 It provides a large file system as described in the table above.
 Utilizes extents that improve large file performance and reduces fragmentation.
 Provides persistent pre-allocation which guarantees space allocation and contiguous memory.
 Delayed allocation improves performance and reduces fragmentation by effectively allocating larger
amounts of data at a time.
 It uses HTree indices to allow unlimited number of subdirectories.
 Performs journal checksumming which allows the file system to realize that some of its entries are
invalid or out of order after a crash.
 Support for time-of-creation timestamps and improved timestamps to induce granularity.
 Transparent encryption.
 Allows cleaning of inode tables in background which in turn speeds initialization. The process is called
lazy initialization.
 Enables writing barriers by default. Which ensures that file system metadata is correctly written and
ordered on disk, even when write caches lose power.
There are still some features in the process of developing like metadata checksumming, first-class quota
supports, and large allocation blocks.
However, ext4 has some limitations. Ext4 does not guarantee the integrity of your data, if the data is
corrupted while already on disk then it has no way of detecting or repairing such corruption. The ext4
file system cannot secure deletion of files, which is supposed to cause overwriting of files upon deletion.
It results in sensitive data ending up in the file-system journal.
XFS performs highly well for large filesystems and high degrees of concurrency. So XFS is stable, yet
there's not a solid borderline that would make you choose it over ext4 since both work about the same.
Unless you want a file system that directly solves a problem of ext4 like having capacity > 50TiB.
Btrfs on the other hand, despite offering features like multiple device management, per-block
checksumming, asynchronous replication and inline compression, does not perform the best in many
common use cases as compared to ext4 and XFS. Several of its features can be buggy and result in
reduced performance and data loss.
Some Hands On Example on Linux File System
For example, if our use_case is to set up a server that will first store and serve large multimedia files
(videos and audios). In that case we have to prioritize efficient speed and use of storage space.
According to this requirement the XFS file system would be a better choice. Because we know that XFS is
optimized for large files and can work on high volumes of data transfer which in general makes it ideal
for media servers.
Following steps to use it:
 Step 1: Installing XFS utilities package on Linux system.
sudo apt-get install xfsprogs
Installing xfsprogs
Step 2: Create a partition to format as XFS.
For example: `/dev/sda1`
This can be done using tool like `fdisk`.
Step 3: Format the partition as XFS.
sudo [Link] /dev/sda1 -f
Format the partition
We have formatted partition using XFS filesystem. (Used -f for forcefully to avoid error or warning) .
Step 4: Mount the XFS partition to a directory we want.
sudo mount /dev/sda1 /mnt/jayesh_xfs_partition
mounting of XFS partition
We have mounted XFS partition to a directory `/mnt/jayesh_xfs_partition`, (you can create your own
directory.)
Step 5: To verify the mount.
df -h
Successful mount
Linux File Hierarchy Structure
The Linux File Hierarchy Structure or the Filesystem Hierarchy Standard (FHS) defines the directory
structure and directory contents in Unix-like operating systems. It is maintained by the Linux
Foundation.
 In the FHS, all files and directories appear under the root directory /, even if they are stored on different
physical or virtual devices.
 Some of these directories only exist on a particular system if certain subsystems, such as the X Window
System, are installed.
 Most of these directories exist in all UNIX operating systems and are generally used in much the same
way; however, the descriptions here are those used specifically for the FHS and are not considered
authoritative for platforms other than Linux.
linux-directory
1. / (Root):
At the top of every Linux file system is the root directory represented by a forward slash /. It’s the base
point, and no directory exists above it. If you look at the file system graphically, you’ll see all other
directories branching from this root directory.
 Every single file and directory start from the root directory.
 The only root user has the right to write under this directory.
 /root is the root user’s home directory, which is not the same as /
Only the root user has permission to modify contents inside this directory. Regular users cannot make
changes here. For example, if you attempt to create a file in / as a non-root user, you’ll encounter a
"Permission Denied" error.
root-linux-directory
2. /bin :
The /bin directory contains essential commands and binaries needed by all users, including cp, ls, ssh,
and kill. These commands are universally available across user types.
 Contains binary executables.
 Common linux commands you need to use in single-user modes are located under this directory.
 Commands used by all the users of the system are located here e.g. ps, ls, ping, grep, cp
bin-linux-directory
3. /boot :
This directory stores all files required for booting the system. It includes the GRUB bootloader
configuration and essential kernel files that are loaded during startup.
 Kernel initrd, vmlinux, grub files are located under /boot
 Example: [Link]-2.6.32-24-generic, vmlinuz-2.6.32-24-generic
 boot-linux-directory
4. /dev :
Device files in Linux are stored in the /dev directory. These are special files that act as interfaces
between hardware and software. Device files are of two types: block devices (e.g., hard drives) and
character devices (e.g., microphones and speakers). Examples include /dev/sda1 for disk partitions.
 These include terminal devices, usb, or any device attached to the system.
 Example: /dev/tty1, /dev/usbmon0
dev-linux-directory

5. /etc :
Short for "Editable Text Configuration," /etc contains configuration files for system applications, users,
services, and tools or it contains the Host-specific system-wide configuration files. For example, user
details like UID and local addresses are defined here.
 This also contains startup and shutdown shell scripts used to start/stop individual programs.
 Example: /etc/[Link], /etc/[Link].
etc-linux-directory
Applications require shared libraries to run, which are stored in /lib. These include dynamic libraries
needed during runtime. For example, Apache server libraries are available here.
 Library filenames are either ld* or lib*.so.*
 Example: [Link], [Link].5.7
lib-linux-directory
8. /media:
Devices like USBs, CDs, and pen drives are mounted under /media. For example, when a CD-ROM is
inserted (appeared in FHS-2.3), its details will appear here.
 Temporary mount directory for removable devices.
 Examples, /media/cdrom for CD-ROM; /media/floppy for floppy drives; /media/cdrecorder for CD writer
media-linux-directory

9. /mnt :
When external drives are connected, they are temporarily mounted in /mnt. This is where their contents
become accessible to the system.
 Temporary mount directory where sysadmins can mount filesystems.
mnt-linux-directory
10. /opt :
Third-party software and packages not part of the default system installation are stored in /opt. It
includes their configuration and data files.
 Contains add-on applications from individual vendors.
 Add-on applications should be installed under either /opt/ or /opt/ sub-directory.
opt-linux-directory.
11. /sbin :
Essential system binaries, e.g.,
This directory holds administrative binaries like iptables, firewall management tools, fsck, init, route etc.
These binaries are primarily for system administrators and typically require root privileges to execute.
 Just like /bin, /sbin also contains binary executables.
 The linux commands located under this directory are used typically by system administrators, for system
maintenance purposes.
 Example: iptables, reboot, fdisk, ifconfig, swapon
sbin-linux-directory

12. /srv :
Site- specific data served by this system, such as data and scripts for web servers, data offered by FTP
servers, and repositories for version control systems.
 srv stands for service.
 Contains server specific services related data.
 Example, /srv/cvs contains CVS related data.
srv-linux-directory
13. /tmp :
Programs create temporary files during execution, and these are stored in /tmp. These files are deleted
automatically after the program finishes or when the system is restarted.
 Directory that contains temporary files created by system and users.
 Files under this directory are deleted when the system is rebooted.
tmp-linux-directory
14. /usr :
Secondary hierarchy for read-only user data; contains the majority of (multi-)user utilities and
applications.
 Contains binaries, libraries, documentation, and source-code for second level programs.
 / usr/bin contains binary files for user programs. If you can’t find a user binary under /bin, look under
/usr/bin. For example: at, awk, cc, less, scp
 /usr/sbin contains binary files for system administrators. If you can’t find a system binary under /sbin,
look under /usr/sbin. For example: atd, cron, sshd, useradd, userdel
 /usr/lib contains libraries for /usr/bin and /usr/sbin
 / usr/local contains user's programs that you install from source. For example, when you install apache
from source, it goes under /usr/local/apache2
 /usr/src holds the Linux kernel sources, header-files and documentation.
usr_bin-linux-directoryusr_sbin-linux-directoryusr_lib-linux-dirctoryusr_local-linux-directory