/* Ajith - Syntax Higlighter - End ----------------------------------------------- */

## 3.13.2012

### Daemon-izing a Process in Linux

A Linux process works either in foreground or background.

A process running in foreground can interact with the user in front of the terminal. To run a.out in foreground we execute as shown below.
./a.out
When a process runs as background process then it runs by itself without any user interaction. The user can check its status but he doesn't (need to) know what it is doing. To run a.out in background we execute as shown below.
$./a.out & [1] 3665 As shown above when we run a process with & at the end then the process runs in background and returns the process id (3665 in above example). what is a DAEMON Process? A 'daemon' process is a process that runs in background, begins execution at startup (not neccessarily), runs forever, usually do not die or get restarted, waits for requests to arrive and respond to them and frequently spawn other processes to handle these requests. So running a process in BACKGROUND with a while loop logic in code to loop forever makes a Daemon ? Yes and also No. But there are certain things to be considered when we create a daemon process. We follow a step-by-step procedure as shown below to create a daemon process. 1. Create a separate child process - fork() it. Using fork() system call create a copy of our process(child), then let the parent process exit. Once the parent process exits the Orphaned child process will become the child of init process (this is the initial system process, in other words the parent of all processes). As a result our process will be completely detached from its parent and start operating in background. pid=fork(); if (pid<0) exit(1); /* fork error */ if (pid>0) exit(0); /* parent exits */ /* child (daemon) continues */ ## 3.04.2012 ### Memory Layout of a C program - Part 2 Continuation of PART-1 As we have seen so much theory in the PART-1 now let us see a real-time example to understand about these segments. we will use size(1) command to list various section sizes in a C code. A simple C program is given below #include <stdio.h> int main() { return 0; }$ gcc test.c
$size a.out text data bss dec hex filename 836 260 8 1104 450 a.out Now add a global variable as shown below #include <stdio.h> int global; /* Uninitialized variable stored in bss*/ int main() { return 0; }$ gcc test.c
\$ size a.out
text    data     bss     dec     hex filename
836     260      12    1108     454 a.out
As you can see BSS is incremented by 4 bytes.

### Memory Layout of a C program - Part 1

A running program is called a process.

When we run a program, its executable image is loaded into memory area that normally called a process address space in an organized manner. It is organized into following areas of memory, called segments:
• text segment
• data segment
• stack segment
• heap segment
 Figure 1: Memory layout

text segment

It is also called the code segment.

This is the area where the compiled code of the program itself resides. This is the machine language representation of the program steps to be carried out, including all functions making up the program, both user defined and system.

For example, Linux/Unix arranges things so that multiple running instances of the same program share their code if possible. Only one copy of the instructions for the same program resides in memory at any time and also it is often read-only, to prevent a program from accidentally modifying its instructions.

The portion of the executable file containing the text segment is the text section.

## 3.01.2012

### Deletion of a Node from Doubly Linked List

This article is part of article series - "Datastructures".

Previous Article: Inserting a Node in Doubly Linked List.

Deletion of a Node
Let us say our current Doubly Linked List is as shown in Figure-1.
 Figure 1: Current Doubly Linked List

• Deleting First Node of the List
• Now we have to delete First Node from the List shown in Figure-1. Because of this operation HEAD and Node-2 are affected.
In HEAD - FIRST variable should now point to NODE-2 (i.e HEAD->FIRST = HEAD->FIRST->NEXT). If you see HEAD->FIRST->NEXT actually HEAD->FIRST currently points to NODE-1 so HEAD->FIRST->NEXT is equivalent to NODE-1->NEXT which is NODE-2.
In NODE-2 - NEXT variable remains unchanged and PREV variable should now point to NULL since it is the first Node in the List.
Decrement LENGTH variable in HEAD so that it maintains proper count of Nodes in the List.
Pseudocode:
HEAD->FIRST = HEAD->FIRST->NEXT

NODE-2->PREV = NULL

decrement(HEAD->LENGTH)
Output:
 Figure 2: After deleting the First Node in the List.