Category Archives: Uncategorized

extern in “C”

1. Declaration can be done any number of times but definition only once.
2. “extern” keyword is used to extend the visibility of variables/functions().
3. Since functions are visible through out the program by default. The use of extern is not needed in function declaration/definition. Its use is redundant.
4. When extern is used with a variable, it’s only declared not defined.
5. As an exception, when an extern variable is declared with initialization, it is taken as definition of the variable as well.


Unix signal

kill -STOP pid

kill -CONT pid

Signals are a limited form of inter-process communication used in UnixUnix-like, and other POSIX-compliant operating systems. A signal is an asynchronousnotification sent to a process or to a specific thread within the same process in order to notify it of an event that occurred. Signals have been around since the 1970sBell Labs Unix and have been more recently specified in the POSIX standard.

When a signal is sent, the operating system interrupts the target process’s normal flow of execution to deliver the signal. Execution can be interrupted during any non-atomic instruction. If the process has previously registered a signal handler, that routine is executed. Otherwise, the default signal handler is executed.

Embedded programs may find signals useful for interprocess communications, as the computational and memory footprint for signals is small.

Sending signals[edit]

The kill(2) system call will send a specified signal to a specified process, if permissions allow. Similarly, the kill(1) command allows a user to send signals to processes. The raise(3) library function sends the specified signal to the current process.

Exceptions such as division by zero or a segmentation violation will generate signals (here, SIGFPE and SIGSEGV respectively, which both by default cause a core dump and a program exit).

The kernel can generate signals to notify processes of events. For example, SIGPIPE will be generated when a process writes to a pipe which has been closed by the reader; by default, this causes the process to terminate, which is convenient when constructing shell pipelines.

Typing certain key combinations at the controlling terminal of a running process causes the system to send it certain signals:

  • Ctrl-C (in older Unixes, DEL) sends an INT signal (SIGINT); by default, this causes the process to terminate.
  • Ctrl-Z sends a TSTP signal (SIGTSTP); by default, this causes the process to suspend execution.
  • Ctrl-\ sends a QUIT signal (SIGQUIT); by default, this causes the process to terminate and dump core.
  • Ctrl-T (not supported on all UNIXes) sends an INFO signal (SIGINFO); by default, and if supported by the command, this causes the operating system to show information about the running command.

These default key combinations with modern operating systems can be changed with the stty command.

Handling signals[edit]

Signal handlers can be installed with the signal() system call. If a signal handler is not installed for a particular signal, the default handler is used. Otherwise the signal is intercepted and the signal handler is invoked. The process can also specify two default behaviors, without creating a handler: ignore the signal (SIG_IGN) and use the default signal handler (SIG_DFL). There are two signals which cannot be intercepted and handled: SIGKILL and SIGSTOP.


Signal handling is vulnerable to race conditions. Because signals are asynchronous, another signal (even of the same type) can be delivered to the process during execution of the signal handling routine. The sigprocmask() call can be used to block and unblock delivery of signals.

Signals can cause the interruption of a system call in progress, leaving it to the application to manage a non-transparent restart.

Signal handlers should be written in a way that doesn’t result in any unwanted side-effects, e.g. errno alteration, signal mask alteration, signal disposition change, and other global process attribute changes. Use of non-reentrant functions, e.g., malloc or printf, inside signal handlers is also unsafe.

Signal handlers can instead put the signal into a queue and immediately return. The main thread will then continue “uninterrupted” until signals are taken from the queue, such as in an event loop. “Uninterrupted” here means that operations that block may return prematurely and must be resumed, as mentioned above. Signals should be processed from the queue on the main thread and not by worker pools, as that reintroduces the problem of asynchronicity.

Relationship with hardware exceptions[edit]

process‘s execution may result in the generation of a hardware exception, for instance, if the process attempts to divide by zero or incurs a TLB miss.

In Unix-like operating systems, this event automatically changes the processor context to start executing a kernel exception handler. In case of some exceptions, such as a page fault, the kernel has sufficient information to fully handle the event itself and resume the process’s execution.

Other exceptions, however, the kernel cannot process intelligently and it must instead defer the exception handling operation to the faulting process. This deferral is achieved via the signal mechanism, wherein the kernel sends to the process a signal corresponding to the current exception. For example, if a process attempted integer divide by zero on an x86 CPU, a divide error exception would be generated and cause the kernel to send the SIGFPE signal to the process.

Similarly, if the process attempted to access a memory address outside of its virtual address space, the kernel would notify the process of this violation via aSIGSEGV signal. The exact mapping between signal names and exceptions is obviously dependent upon the CPU, since exception types differ between architectures.

POSIX signals[edit]

The list below documents the signals that are specified by the Single Unix Specification.[1] All signals are defined as macro constants in <signal.h> header file. The name of the macro constant consists of a “SIG” prefix and several characters that identify the signal. Each macro constant expands into an integer; these numbers can vary across platforms.

The SIGABRT signal is sent to a process to tell it to abort, i.e. to terminate. The signal is usually initiated by the process itself when it calls abort function of the C Standard Library, but it can be sent to the process from outside as well as any other signal.
The SIGALRM, SIGVTALRM and SIGPROF signal is sent to a process when the time limit specified in a call to a preceding alarm setting function (such assetitimer) elapses. SIGALRM is sent when real or clock time elapses. SIGVTALRM is sent when CPU time used by the process elapses. SIGPROF is sent when CPU time used by the process and by the system on behalf of the process elapses.
The SIGBUS signal is sent to a process when it causes a bus error. The conditions that lead to the signal being raised are, for example, incorrect memory access alignment or non-existent physical address.
The SIGCHLD signal is sent to a process when a child process terminates, is interrupted, or resumes after being interrupted. One common usage of the signal is to instruct the operating system to clean up the resources used by a child process after its termination without an explicit call to the wait system call.
The SIGCONT signal instructs the operating system to continue (restart) a process previously paused by the SIGSTOP or SIGTSTP signal. One important use of this signal is in job control in the Unix shell.
The SIGFPE signal is sent to a process when it executes an erroneous arithmetic operation, such as division by zero (the name “FPE”, standing for floating-point exception, is a misnomer as the signal covers integer-arithmetic errors as well).[2]
The SIGHUP signal is sent to a process when its controlling terminal is closed. It was originally designed to notify the process of a serial line drop (a hangup). In modern systems, this signal usually means that the controlling pseudo or virtual terminal has been closed.[3] Many daemons will reload their configuration files and reopen their logfiles instead of exiting when receiving this signal.[4] nohup is a command to make a command ignore the signal.
The SIGILL signal is sent to a process when it attempts to execute an illegal, malformed, unknown, or privileged instruction.
The SIGINT signal is sent to a process by its controlling terminal when a user wishes to interrupt the process. This is typically initiated by pressing Control-C, but on some systems, the “delete” character or “break” key can be used.[5]
The SIGKILL signal is sent to a process to cause it to terminate immediately (kill). In contrast to SIGTERM and SIGINT, this signal cannot be caught or ignored, and the receiving process cannot perform any clean-up upon receiving this signal.
The SIGPIPE signal is sent to a process when it attempts to write to a pipe without a process connected to the other end.
The SIGQUIT signal is sent to a process by its controlling terminal when the user requests that the process quit and perform a core dump.
The SIGSEGV signal is sent to a process when it makes an invalid virtual memory reference, or segmentation fault, i.e. when it performs a segmentationviolation.[6]
The SIGSTOP signal instructs the operating system to stop a process for later resumption.
The SIGTERM signal is sent to a process to request its termination. Unlike the SIGKILL signal, it can be caught and interpreted or ignored by the process. This allows the process to perform nice termination releasing resources and saving state if appropriate. It should be noted that SIGINT is nearly identical to SIGTERM.
The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop temporarily. It is commonly initiated by the user pressing Control-Z. UnlikeSIGSTOP, the process can register a signal handler for or ignore the signal.
The SIGTTIN and SIGTTOU signals are sent to a process when it attempts to read in or write out respectively from the tty while in the background. Typically, this signal can be received only by processes under job controldaemons do not have controlling terminals and should never receive this signal.
The SIGUSR1 and SIGUSR2 signals are sent to a process to indicate user-defined conditions.
The SIGPOLL signal is sent to a process when an asynchronous I/O event occurs (meaning it has been polled).
The SIGSYS signal is sent to a process when it passes a bad argument to a system call.
The SIGTRAP signal is sent to a process when an exception (or trap) occurs: a condition that a debugger has requested to be informed of — for example, when a particular function is executed, or when a particular variable changes value.
The SIGURG signal is sent to a process when a socket has urgent or out-of-band data available to read.
The SIGXCPU signal is sent to a process when it has used up the CPU for a duration that exceeds a certain predetermined user-settable value.[7] The arrival of a SIGXCPU signal provides the receiving process a chance to quickly save any intermediate results and to exit gracefully, before it is terminated by the operating system using the SIGKILL signal.
The SIGXFSZ signal is sent to a process when it grows a file larger than the maximum allowed size.
The SIGRTMIN to SIGRTMAX signals are intended to be used for user-defined purposes. They are real-time signals.
Signal Code Default Action Description
SIGABRT 6 A Process abort signal
SIGALRM 14 T Alarm clock
SIGBUS 10 A Access to an undefined portion of a memory object
SIGCHLD 18 I – Ignore the Signal Child process terminated, stopped,
SIGCONT 25 C – Continue the process Continue executing, if stopped.
SIGFPE 8 A Erroneous arithmetic operation.
SIGHUP 1 T Hangup.
SIGILL 4 A Illegal instruction.
SIGINT 2 T Terminal interrupt signal.
SIGKILL 9 T Kill (cannot be caught or ignored).
SIGPIPE 13 T – Abnormal termination of the process Write on a pipe with no one to read it.
SIGQUIT 3 A – Abnormal termination of the process Terminal quit signal.
SIGSEGV 11 A Invalid memory reference.
SIGSTOP 23 S – Stop the process Stop executing (cannot be caught or ignored).
SIGTERM 15 T Termination signal.
SIGTSTP 23 S Terminal stop signal.
SIGTTIN 26 S Background process attempting read.
SIGTTOU 27 S Background process attempting write.
SIGUSR1 16 T User-defined signal 1.
SIGUSR2 17 T User-defined signal 2.
SIGPOLL 22 T Pollable event.
SIGPROF 29 T Profiling timer expired.
SIGSYS 12 A Bad system call.
SIGTRAP 5 A Trace/breakpoint trap.
SIGURG 21 I High bandwidth data is available at a socket.
SIGVTALRM 28 T Virtual timer expired.
SIGXCPU 30 A CPU time limit exceeded.
SIGXFSZ 31 A File size limit exceeded
Default Actions:
T – Abnormal termination of the process. The process is terminated with all the consequences of _exit() except that the status made available to wait() and waitpid() indicates abnormal termination by the specified signal.
A – Abnormal termination of the process. Additionally, implementation-defined abnormal termination actions, such as creation of a core file, may occur.
I – Ignore the signal.
S – Stop the process.
C – Continue the process, if it is stopped; otherwise, ignore the signal.

Miscellaneous signals[edit]

The following signals are not specified in the POSIX specification. They are, however, sometimes used on various systems.

The SIGEMT signal is sent to a process when an emulator trap occurs.
The SIGINFO signal is sent to a process when a status (info) request is received from the controlling terminal.
The SIGPWR signal is sent to a process when the system experiences a power failure.
The SIGLOST signal is sent to a process when a file lock is lost.
The SIGWINCH signal is sent to a process when its controlling terminal changes its size (a window change).

Network socket


network socket is an endpoint of an inter-process communication flow across a computer network. Today, most communication between computers is based on the Internet Protocol; therefore most network sockets areInternet sockets.

socket API is an application programming interface (API), usually provided by the operating system, that allows application programs to control and use network sockets. Internet socket APIs are usually based on theBerkeley sockets standard.

socket address is the combination of an IP address and a port number, much like one end of a telephone connection is the combination of a phone number and a particular extension. Based on this address, internet sockets deliver incoming data packets to the appropriate application process or thread.



An Internet socket is characterized by a unique combination of the following:

  • Local socket address: Local IP address and port number
  • Remote socket address: Only for established TCP sockets. As discussed in the client-server section below, this is necessary since a TCP server may serve several clients concurrently. The server creates one socket for each client, and these sockets share the same local socket address from the point of view of the TCP server.
  • Protocol: A transport protocol (e.g., TCPUDPraw IP, or others). TCP port 53 and UDP port 53 are consequently different, distinct sockets.

Within the operating system and the application that created a socket, a socket is referred to by a unique integer value called a socket descriptor. The operating system forwards the payload of incoming IP packets to the corresponding application by extracting the socket address information from the IP and transport protocol headers and stripping the headers from the application data.

In IETF Request for CommentsInternet Standards, in many textbooks, as well as in this article, the term socket refers to an entity that is uniquely identified by the socket number. In other textbooks,[1] the socket term refers to a local socket address, i.e. a “combination of an IP address and a port number”. In the original definition of socket given in RFC 147, as it was related to the ARPA network in 1971, “the socket is specified as a 32 bit number with even sockets identifying receiving sockets and odd sockets identifying sending sockets.” Today, however, socket communications are bidirectional.

On Unix-like and Microsoft Windows based operating systems the netstat command line tool may be used to list all currently established sockets and related information.

Socket types[edit]

There are several Internet socket types available:

There are also non-Internet sockets, implemented over other transport protocols, such as Systems Network Architecture (SNA).[2] See also Unix domain sockets (UDS), for internal inter-process communication.

Named pipe


In computing, a named pipe (also known as a FIFO for its behavior) is an extension to the traditional pipe concept on Unix and Unix-like systems, and is one of the methods ofinter-process communication (IPC). The concept is also found in Microsoft Windows, although the semantics differ substantially. A traditional pipe is “unnamed” because it exists anonymously and persists only for as long as the process is running. A named pipe is system-persistent and exists beyond the life of the process and must be deleted once it is no longer being used. Processes generally attach to the named pipes (usually appearing as a file) to perform inter-process communication.



In Unix[edit]

Instead of a conventional, unnamed, shell pipeline, a named pipeline makes use of the filesystem. It is explicitly created using mkfifo() or mknod(), and two separate processes can access the pipe by name — one process can open it as a reader, and the other as a writer.

For example, one can create a pipe and set up gzip to compress things piped to it:

 mkfifo my_pipe
 gzip -9 -c < my_pipe > out.gz &

In a separate process shell, independently, one could send the data to be compressed:

cat file > my_pipe

The named pipe can be deleted just like any file:

rm my_pipe

A named pipe can be used to transfer information from one application to another without the use of an intermediate temporary file. For example, you can pipe the output of gzip into a named pipe like so:

 mkfifo --mode=0666 /tmp/namedPipe
 gzip --stdout -d file.gz > /tmp/namedPipe

Then load the uncompressed data into a MySQL table[1] like so:

 LOAD DATA INFILE '/tmp/namedPipe' INTO TABLE tableName;

Without this named pipe one would need to write out the entire uncompressed version of file.gz before loading it into MySQL. Writing the temporary file is both time consuming and results in more I/O and less free space on the hard drive.

PostgreSQL‘s command line terminal, psql, also supports loading data from named pipes.[2]



In a Unix-style file system, an index node, informally referred to as an i-node, is a data structure used to represent a filesystem object, which can be one of various things including a file or a directory. Each i-node stores the attributes and disk block location(s) of the filesystem object’s data.[1] Filesystem object attributes may include manipulationmetadata (e.g. creation, access, modify time), as well as owner and permission data (e.g. group-iduser-idpermissions).[2]

Linux directory lists other filesystem objects by name, normally identifying the listed object by referring to its inode. The directory contains an entry for itself, its parent, and each of its children.

UNIX / Linux: Explains setuid File Permission


What does it mean for a file to be “setuid?” How do keep track of all setuid enabled file?

setuid means set user ID upon execution. If setuid bit turned on a file, user executing that executable file gets the permissions of the individual or group that owns the file. You need to use the ls -l or find command to see setuid programs. All setuid programs displays S or s in the permission bit (owner-execute) of the ls command. Type the following command:

ls -l /usr/bin/passwd

Sample outputs:

-rwsr-xr-x 1 root root 42856 2009-07-31 19:29 /usr/bin/passwd

Ubuntu 12.04 LTS Kernel Compile Guide


Important Note:

Whether it’s for educational purposes, tweaking or curiosity, compiling a Kernel in Ubuntu 12.04 LTS is generally a straight forward exercise. However, it can be a little more complex depending on what sources are used, for example GIT or a vanilla kernel from

This guide goes for the easiest method and demonstrates how to compile the Ubuntu 12.04 LTS Kernel using apt-get sources.

It is not intended to be a comprehensive guide to kernel compiling, just something to get you started and as a quick reference for Ubuntu 12.04 LTS users.

Before you attempt using this guide please make sure your Ubuntu installation is fully up to date. Use the ‘Update Manager’ program and if you need to reboot after the update please do.

The Kernel Compile Guide

Install required packages

sudo apt-get install libncurses5-dev kernel-package

Create a source directory

mkdir ~/src

cd ~/src

Download the kernel source into your source directory

apt-get source linux-image-$(uname -r)

Configure your Kernel 

cd linux-3.2.0

make menuconfig

Speed up the build


General rule is CONCURRENCY_LEVEL = number of processor cores + 1

Compile the Kernel

time fakeroot make-kpkg –initrd –append-to-version=-tweak kernel-image kernel-headers

You can change -tweak to anything you wish

Install your compiled Kernel

cd ~/src

sudo dpkg -i linux-image-3.2.24-tweak_3.2.24-tweak-10.00.Custom_amd64.deb

sudo dpkg -i linux-headers-3.2.24-tweak_3.2.24-tweak-10.00.Custom_amd64.deb


Ubuntu should boot with your new Kernel by default, if not you may have to edit Grub or enable the Grub menu to be displayed during boot.

Enjoy tweaking!