Linux Internals Part - 3

© 2012 SysPlay eLearning Academy for You <https://sysplay.in>
All Rights Reserved.
Linux Internals (Day 3)

2
©2012 Pradeep Tewani <pradeep@sysplay.in>
What to Expect?
Debugging with Gdb
Building Statically Linked Modules
Compiling and Building Complex application
using make
Inter Process Communication Mechanisms

Debugging With GDB

Ways of Debugging
Printing
The most basic type of debugging
Using GUI
Various IDEs provide this facility
ddd in Linux, VDD
Text mode debugger
gdb

Debugger: gdb
Text mode debugger
Repetition of previous command
Very powerful
All kind of options: Breakpoint, Watch, ...
Extensive Help
GUI interfaces: ddd, ...

Gdb: Debugging Strategies
Oh no!!! Another tool to learn
Worth learning a new tool
Segmentation faults & Core dumps
Execution intercepted by gdb
Allows examining the state, backtrace, etc
Debugging is Narrowing Down
Reaching close & then stepping

7
'gdb' Usage
Compile with -g option
gcc -g file.c -o file
Run gdb (with desired options)
gdb [options] ./file [core file]
Pass command line arguments by setting args
set args <cmd_line_args>
Run the program by
Typing c, or
run <cmd_line_args>
For debugging: break, watch, backtrace, …
For help: help <command>

8
gdb: Other ways of Running
step [ count ] – step into sub-routines
next – run over sub-routines in a go
finish – run till current function returns
return – make selected stack frame return to its
caller
jump <address> – continue program at specified
line or address

9
gdb: Breakpoints
info break – Show list & status of breakpoints
Setting breakpoints (returns its number)
[t]break <function> [ if <expr> ]
[t]break [<file>:]<line>
Breakpoint Operations
disable <break_no>
enable <break_no>
delete <break_no>
commands <break_no>
Execute gdb commands on reaching <break_no>

10
gdb: Examining Data
print[/xduotcf] <expr>
Evaluate the valid C <expr> within current frame
set <var> = <expr>
Assign <expr> to <var> in the current scope
Variables starting with $ are local to gdb
display <expr>
Print <expr> whenever program stops
undisplay
Cancels all previous display requests

11
gdb: Shortcuts
Just enough of command
To make it unique
Added with tab completion
First letter only for
break, delete, run, continue, step, next, print
Repeat last by <Enter>
Executing the same set of initial commands
Put them in .gdbinit
-x <gdb command file>

12
gdb: Miscellaneous
Set editmode for gdb command line
editmode [ emacs | vi | dumb ]
Execute a shell command
shell <cmd>
Print command history
history
Set logging
set logging <on | off>
set logging file <log_file> (Default: gdb.txt)

13
Statically Linked Modules
Static Modules are simply a collection of ordinary object files
Linked with and becomes the part of the application
Conventionally ends with “.a” suffix
Advantages
Simplifies the reusability
Allows the application vendors a way to simply release an API

14
Compile and get the object codes
gcc -c <file1.o> <file2.o> <file3.o> ...
Create the static library using ar utility
ar rcu libmylib <file1.o> <file2.o> <file3.o> ...
Compile a C program to be linked with Libraries
gcc <filename.c> -L<path> -lmylib -o <executable>

15
Makefile Revisited
Special Variables
$@ - Target
$^ - Dependency
%.o – All the .o files in the directory
%.c – All the .c files in the Directory
%.o: %.c
gcc -c $^ -o $@
Normal Variables
Conventionally declared in Capitals
Functions
Written in Brackets
SRCS:= $(wildcard *.c)

16
Makefile Revisited...
Standard Variables
CC - c
RM – rm -rf
Flags
CFLAGS, LDFLAGS, ASF, ARF
Implicit Commands
%.o: %.c
cc -c $^ -o $@
make looks for Makefiles in this sequence
GNUMakefile, makefile, Makefile
Non Standard Makefile using -f option

Inter Process Communication

18
W's of IPC
Mechanism by which one process communicate
i.e. exchange the data with another process.
Require Special IPC mechanism because
Processes are non-sharing entities
They need to coordinate
They need to exchange data
Separate mechanisms are answers to this

19
Example of IPC
Print the filenames in a directory
'ls' outputs the filenames
'lpr' prints its input
But ls & lpr are separate processes
What are the solutions?
Put into a file -> ls > file; lpr < file
Set up an IPC, say a pipe (I) -> ls | lpr

20
Types of IPC mechanisms
Pipe: Allows the flow of data in one direction only
Name Pipe: Pipe with a specific name
Shared Memory & Semaphore
Allows a interchange of data through a defined area of Memory
Semaphore is use for synchronization
Mapped Memory: Similar to shared memory, but use file
instead of memory
Why so many?
Based on requirements, flexibility & benefits

Pipes

22
W's of Pipe
Two ends – Read & Write to allow the transfer
Unidirectional and serial communication
Limited Capacity
Provides automatic synchronization
Read blocks on no data
Write blocks on full data

23
Pipe Usage
On shell
Using |
In Programming / C
Creation
Using system call pipe()
Communicate as with other fd
Using the system calls read(), write(), ...

24
Creating a Pipe
Invoke the pipe() system call
Supply an integer array of 2
The call to a pipe stores the reading file
descriptor at array index 0 and writing file
descriptor at index 1.
Let's try pipe.c

25
Limitations of Pipe
pipe() call must precede a call to fork()
Pipes are only for related processes
That is processes with related ancestory
What about unrelated processes?
There are special types of pipes called...

FIFO

27
W's of FIFO
A Pipe with a name in the Filesystem
Also called the Named Pipe
Properties identical to those of pipe
including the serial communication
which is now termed as First-In-First-Out
Except that now the processes can be unrelated

28
FIFO Usage
On Shell
Creation: mknod, or mkfifo
Communication: cat, echo..
In programming / C
Creation
System Call: mknod(), open(), close()
Library function: mkfifo(), fopen(), fopen(), fclose()
Communication
System calls : read, write,...
Library Functions: fread(), fwrite(), fputs()

29
Experiments on Shell
Mkfifo /tmp/fifo Open another shell
ls -l /tmp/fifo cat > /tmp/fifo
cat < /temp/fifo type some text
<See the text> rm /tmp/fifo

30
Using System call to create FIFO
mknod(const char *filename, mode_t mode, dev_t dev)
filename – name for the FIFO
Mode
Permission to use and type of node to be created
The node type must be S_IFIFO for FIFO
dev_t
specifies the major and minor number of device special file
Not used for FIFO, so make it 0.
Let's try an example

Shared Memory

32
W's of Shared Memory
Rawest communication mechanism
Piece of Memory which is shared
Between two or more processes
Fastest form of IPC
As no unnecessary copying of data

33
Linux Memory Model
All accesses in Linux are through virtual addresses
Each Process has its “own” virtual address space
which is split into Virtual Pages
Each Process maintains a mapping table
From its Physical pages to these virtual pages
For access to its actual data
And mappings of multiple processes can point to the same
physical page
Enabling the sharing of “actual” memory

34
Shared Memory Usage
Shell Way
Create: ipcmk -M <size> [-p <mode> ]
Get the information: ipcs [-m [ -i -id]]
Remove: ipcrm [-M <shmkey> | -m <shmid>]
Programming way in Linux
Physical Memory Allocation: shmget()
Mapping / Attaching to the Shared Memory: shmat()
Access through usual (Virtual) Address Dereferencing
Unmapping / Detaching from Virtual Memory – shmdt()
Physical Memory Deallocation & other shared memory Control Operations:
Shmctl()

35
Shared Memory Allocation
Done by only one of the sharing process
int shmget(key_t key, size_t size, int shm_flg);
Returns
Shared Memory Id on success
-1 on error
key: System-wide unique id for a shared Memory
Process gets a particular shared memory id using creation key
Size: Number of bytes to allocate or get for the shared memory
shm_flg: operation | permissions
IPC_CREAT, IPC_EXCL

36
Shared Memory Attachment
Done by all the sharing Processes to access the Shared Memory
void *shmat(int shm_id, const void *shm_addr, int shm_flg);
Returns
Virtual start address of the attached shared memory on success
MAP_FAILED i.e (void *)(-1) on error (and sets errno)
shm_id: Shared Memory Id returned by shmget()
shm_addr
Requested process vitual start address
NULL enables the Kernel to choose one
shm_flg
SHM_RND: round down shm_addr to a multiple of the page size
SHM_RDONLY: shared memory will only be read, not written
Children created by fork() inherit attached shared segments

37
Shared Memory Detachment
Done by all the process which did attach or inherit
int shmdt(const void *shm_addr)
Returns : 0 on success; -1 on error (and sets errno)
shm_addr: Process Virtual address map returned by shmat
Call to _exit() or exec*() automatically detaches
Detachment may deallocates
If done by last process
And already marked to deallocate

38
Shared Memory Control Ops
Control Operations on any Shared memory like
Physical Memory Deallocation for Shared Memory
Any other
int shmctl(int shm_id, int cmd, struct shmid_ds *buf)
Retuns 0 on success, -1 on error (and set errno)
shm_id: Shared Memory id returned by shmget()
Cmd
IPC_STAT - Get the shared memory information into buf
IPC_SET - Set the various shared memory info specified by buf
IPC_RMID – (Mark) Deallocate the physical memory (buf is ignored)

39
Need for Synchronization
Shared memory has no Access Coordination
It has to be handled by us – the User
Moreover, for communication among the
unrelated processes, you need a synchronization
mechanism
So, now its a time to look into resolving it
That's where we go to the next topic....

Process Semaphores

41
W's of Process Semaphores
First, it isn't any form of IPC
But a mechanism for synchronization used by IPCs
Counter used to provide the synchronized access
To a shared data object for multiple processes
Variable protected by kernel
No direct access by the user
Counter
> 0 -> Resource is available
== 0 -> Resource is busy / in use
< 0 -> Should never happen

42
Semaphore Types
Counting Semaphores
Semaphores controlling a multiple resources availability
Possible Values
>= 1 -> Available
0 -> Unavailable
Binary Semaphores
Semaphores controlling a single resource availability
Possible Values
1 -> Available
0 – Unavailable
Typically initialized to 0

43
Process Semaphore Usage
Shell Way
Create : ipcmk -S <nsems> [-p <mode>]
Get information: ipcs [-s [-i id]]
Remove: ipcrm [-S <semkey> | -s <semid>]
Programming way in C (using sys calls)
Semaphore Allocation/Access: semget()
Semaphore Deallocation & other Semaphore control operations:
semctl()
Semaphore usage Operations: semop()

44
Process Semaphore Allocation
Done by only one of the sharing process
int semget(key_t key, int nsems, int sem_flg);
Returns
Semaphore array Id on success
-1 on error (and sets errno)
key: System-wide unique id for a semaphore array
Process gets a particular semaphore array id using creation key
nsems: Number of semaphores to create or access in the Array
sem_flg: operation | permissions
IPC_CREAT, IPC_EXCL

45
Semaphore Control Ops
Control operations on semaphore like
Deleting a Semaphore Array
And many more
int semctl(int sem_id, int sem_num, int cmd, ...)
Returns 0 on success, -1 on error (set errno)
sem_id: Semaphore array id returned by semget
sem_num: Index of the semaphore in an arry
Cmd
IPC_STAT - Get the semaphore information array into optional arg (sem_num is ignored)
IPC_SET – Set the various semaphore array info specified by optional arg (sem_num is ignored)
IPC_RMID – Remove the semaphore array (sem_num is ignored)
SETVAL – Set sem_num'th semaphore value as specified by optional arg
...

46
The Optional Arg
Union semun
{
int val; //Value for set val
struct semid_ds *buf; //Buffer for IPC_STAT & IPC_SET
unsigned short *array; //Array for GETALL, SETALL
....
}
struct semid_ds
{
struct ipc_perm sem_perm; //Ownership & Permissions
time_t sem_otime; // Time of last semop
time_t sem_ctime; //Time of last change
unsigned short sem_nsems; //No. Of semaphores in the array
}

47
Caution On
Deleting Process Semaphores
Invoking _exit() or exec* doesn't do it
Needs explicit removal
Using IPC_RMID cmd of semctl
Otherwise, may violate the system limit
Of total number of process semaphores

48
Initializing the Process Semaphores
Two ways though both using semctl
Initialize all in the array
cmd = SETALL
arg.array = Array of values to be set
Initializing one at a time
sem_num = Semaphore number to be initialized
cmd = SETVAL
arg.val = Value to be set

49
Semaphore Usage Ops
Usage operations on the Semaphore like
Increment, Decrement, ..
Int semop(sem_id, struct sembuf *sops, unsigned int
nsops)
Returns: 0 on success; -1 on error (and sets errno)
semid: Semaphore array id returned by sem_get
sops: Array of operations to be performed
Nsops: Number of elements n sops

50
Operation Structure Decoded
struct sembuf
{
unsigned short sem_num; // Index of semaphore to be operated on
short sem_op; //Value to added to the current semaphore
short sem_flg; //Operation flags
}
Operation Specifies
sem_op > 0 -> value added & Processes waiting on it are signalled
sem_op < 0 and current semaphore value >= |sem_op| -> value added
sem_op < 0 and current semaphore value < | sem_op|
It would block/wait until the semaphore value becomes >= |sem_op|
Operation Flags
IPC_NOWAIT – Prevents the operation from blocking
Return -1 with EAGAIN in the above blocking case
Kernel automatically undos the semaphore operations on the process exit

51
What all have we learnt?
Debugging with Gdb
Compiling and Building Complex application
using make
Inter Process Communication Mechanisms

52
Any Queries?

Linux Internals Part - 3

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Linux Internals Part - 3

Similar a Linux Internals Part - 3 (20)

Más de SysPlay eLearning Academy for You

Más de SysPlay eLearning Academy for You (10)

Último

Último (20)

Linux Internals Part - 3