Symbolic and Hard Links

A symbolic link (soft link) is an independent file with its own inode and inode number. It merely stores the path to the target file. If the target is deleted and replaced by a new file with the same name, the symbolic link will point to the replacement. A hard link, on the other hand, is not a separate file; it shares the same inode and data blocks with the original file. Creating a hard link adds an extra directory entry and increments the link count.

Creating Symbolic Links

Use ln -s to create a soft link:

ln -s target_file link_name

Benjamin, imagine you have compiled a program compute and want a convenient shortcut:

ln -s /home/user/projects/deep/nested/bin/compute easy_run
./easy_run

Running ls -li will show different inode numbers for the original and the link. If you remove the original file, the symlink breaks (it blinks or becomes invalid). Creating a new file with the same name restores the link, proving that symbolic links depend on the pathname, not the inode.

Creating Hard Links

Hard links are created with ln without -s:

ln original_file hard_link_name

lanjutkan, say you have source.c and you make a hard link:

ln source.c backup.c

Running ls -li reveals both have the identical inode number. The link count of source.c becomes 2. When you delete backup.c using rm or the dedicated unlink command, the link count drops to 1, but the data remains. The file is only truly removed when the link count reaches zero and no process has it open.

Directory Link Counts and . and ..

A newly created empty directory has a link count of at least 2: one from its own name and one from the . entry inside it. The .. entry points to the parent directory, which is why cd .. works. Every subdirectory added to a directory increases its link count by one (becuase of the .. entry inside that subdirectory). This explains why stat shows link counts greater than 2 for directories containing subdirectories.

Static and Shared Librareis

abstract:oreg; Static libraries (.a on Linux, .lib on Windows) are linked into the executable at compile time. Shared libraries (.so on Linux, .dll on Windows) are loaded at runtime and shared among processes.

Building a Static Library

Suppose you provide an arithmetic library with int sum(int a, int b) and void display(const char* msg). The code is split into arith.c, output.c, and their headers. To distribute without exposing source, you can pack object files into an archive.

First, compile the source files to object files:

gcc -c arith.c -o arith.o
gcc -c output.c -o output.o

awn,alter the naming to avoid conflicts. Then use ar to create the static library:

ar -rcs libmylib.a arith.o output.o

The -r option inserts or replaces members, -c creates the archive silently, and -s writes an index. The library name must start with lib and end with .a. You can inspect the archive with:

ar -t libmylib.a

acci, organize directories: place headers in dist/include and the library in dist/lib. A Makefile automates this. Example adapted to760:

.PHONY: all
all: libmylib.a

libmylib.a: arith.o output.o
	ar -rcs libmylib.a arith.o output.o

arith.o: arith.c
	gcc -c arith.c -o arith.o

output.o: output.c
	gcc -c output.c -o output.o

dist:
	mkdir -p dist/include dist/lib
	cp *.h dist/include/
	cp libmylib.a dist/lib/

clean:
	rm -f *.o *.a
	rm -rf dist

viel,undo the final packaging with tar:

tar -czf mylib.tar.gz dist/

Using a Static Library

When you receive the archive, extract it and compile your main.c:

Option 1: Install to default system paths

Copy headers to /usr/include/ and the library to /usr/lib64/ (root needed). Then compile:

gcc main.c -lmylib

The -l flag specifies the library name stripped of lib prefix and .a suffix. This12 method is discouraged for third–party40 code.

Option 2: Provide compiler flags explicitly

Without installation, use -I for header paths, -L for library paths, and -l:

gcc main.c -I./dist/include -L./dist/lib -lmylib

This32 avoids pollution and is30 preferred.

Building a Shared Library

acum, create position–independent object files with -fPIC:

gcc -fPIC -c arith.c -o arith_pic.o
gcc -fPIC -c output.c -o output_pic.o

Then link them into a shared library:

gcc -shared -o libmylib.so arith_pic.o output_pic.o

To combine both static and shared builds, a Makefile can generate differently–named object files.33:

.PHONY: all
all: libmylib.a libmylib.so

libmylib.a: arith.o output.o
	ar -rcs $@ arith.o output.o
arith.o: arith.c
	gcc -c $< -o $@
output.o: output.c
	gcc -c $< -o $@

libmylib.so: arith_pic.o output_pic.o
	gcc -shared $^ -o $@
arith_pic.o: arith.c
	gcc -fPIC -c $< -o $@
output_pic.o: output.c
	gcc -fPIC -c $< -o $@

dist:
	mkdir -p dist/include dist/lib
	cp *.h dist/include/
	cp libmylib.a libmylib.so dist/lib/

clean:
	rm -f *.o *.a *.so
	rm -rf dist

The -fPIC flag generates addresses relative to the load point, allowing the library to be placed anywhere in memory.

Using a Shared Library

lanjutkan, compile the user program with the same -I, -L, -l options. However,16 the runtime linker must locate the shared library at execution time.

Method 1: LD_LIBRARY_PATH

Set the environment variable temporarily:

export LD_LIBRARY_PATH=/path/to/dist/lib:$LD_LIBRARY_PATH
./a.out

verify with ldd a.out. This2 change lasts only for the shell session.

Method 2: Configuration file

Add a .conf file in /etc/ld.so.conf.d/ (root) containing the library path, e.g., /etc/ld.so.conf.d/mylib.conf:

/path/to/dist/lib

Then run ldconfig to update the cache.30 this provides a persistent34 solution.

Method 3: Symlink into default library path

Link the .so into /usr/lib64/:

sudo ln -s /absolute/path/to/dist/lib/libmylib.so /usr/lib64/libmylib.so

tera,1 the system will find it.33 again,5 this32 should be used sparingly.

Method 4: Install to system default paths

try, copy headers and libraries into /usr/include/ and /usr/lib64/ (not recommended).

How Shared Libraries Load and Execute

At runtime, the dynamic linker loads the shared library into the proces'ss address space. Position–independent code (PIC) uses offsets from a base address. When the program calls a library function, the64 code jumps to base + offset.10 different processes can share the same physical memory pages.

How Static Libraries Are Used

During compilation, the linker extracts the required object code from the .a archive and copies it into the executable. No loading happens at runtime; the code is already32 part of the binary.35 repeated use of a function results in multiple copies, increasing binary size.