EmbLogic » deepanshusharma https://www.emblogic.com/blog Embedded System and ARM Training Tue, 03 Mar 2020 13:00:06 +0000 en-US hourly 1 http://wordpress.org/?v=3.9.1 HOW TO USE atoi() function for conversion of strings into integers…….. https://www.emblogic.com/blog/03/how-to-use-atoi-function-for-conversion-of-strings-into-integers/ https://www.emblogic.com/blog/03/how-to-use-atoi-function-for-conversion-of-strings-into-integers/#comments Thu, 13 Mar 2014 06:15:14 +0000 http://www.emblogic.com/blog/?p=9041 Continue reading →]]> RCS file: atoi.c,v

3 Working file: atoi.c

4 head: 1.3

5 branch:

6 locks: strict

7 access list:

8 symbolic names:

9 keyword substitution: kv

10 total revisions: 3; selected revisions: 3

11 description:

12 this program tells the use of atoi() function

13 the atoi function is declared in the header file stdlib.h

14 in this program the string to be converted into integer contains numeric characters in the starting

15 the atoi converts the numeric characters encountered in string before encountering any alphabet or any special symbol into an inte ger

16 the atoi function returns the integer converted from string

17 —————————-

18 revision 1.3

19 date: 2014/03/13 06:00:49; author: root; state: Exp; lines: +1 -1

20 this revision of program uses atoi() functon to convert a string starting with special symbols or characters

21 he function returns 0

22 —————————-

23 revision 1.2

24 date: 2014/03/13 05:58:47; author: root; state: Exp; lines: +1 -1

25 this revision of the program has converted a string which is starting with alphaets

26 in this the atoi function returns 0

27 —————————-

28 revision 1.1

29 date: 2014/03/13 05:54:27; author: root; state: Exp;

30 Initial revision

31 =============================================================================

~ atoi1 atoi2 atoi3

]]> https://www.emblogic.com/blog/03/how-to-use-atoi-function-for-conversion-of-strings-into-integers/feed/ 0 A typical memory representation of C program https://www.emblogic.com/blog/03/a-typical-memory-representation-of-c-program/ https://www.emblogic.com/blog/03/a-typical-memory-representation-of-c-program/#comments Thu, 13 Mar 2014 05:42:29 +0000 http://www.emblogic.com/blog/?p=9039 Continue reading →]]> A typical memory representation of C program consists of following sections.

1. Text segment
2. Initialized data segment
3. Uninitialized data segment
4. Stack
5. Heap


A typical memory layout of a running process

1. Text Segment:
A text segment , also known as a code segment or simply as text, is one of the sections of a program in an object file or in memory, which contains executable instructions.

As a memory region, a text segment may be placed below the heap or stack in order to prevent heaps and stack overflows from overwriting it.

Usually, the text segment is sharable so that only a single copy needs to be in memory for frequently executed programs, such as text editors, the C compiler, the shells, and so on. Also, the text segment is often read-only, to prevent a program from accidentally modifying its instructions.

2. Initialized Data Segment:
Initialized data segment, usually called simply the Data Segment. A data segment is a portion of virtual address space of a program, which contains the global variables and static variables that are initialized by the programmer.

Note that, data segment is not read-only, since the values of the variables can be altered at run time.

This segment can be further classified into initialized read-only area and initialized read-write area.

For instance the global string defined by char s[] = “hello world” in C and a C statement like int debug=1 outside the main (i.e. global) would be stored in initialized read-write area. And a global C statement like const char* string = “hello world” makes the string literal “hello world” to be stored in initialized read-only area and the character pointer variable string in initialized read-write area.

Ex: static int i = 10 will be stored in data segment and global int i = 10 will also be stored in data segment

3. Uninitialized Data Segment:
Uninitialized data segment, often called the “bss” segment, named after an ancient assembler operator that stood for “block started by symbol.” Data in this segment is initialized by the kernel to arithmetic 0 before the program starts executing

uninitialized data starts at the end of the data segment and contains all global variables and static variables that are initialized to zero or do not have explicit initialization in source code.

For instance a variable declared static int i; would be contained in the BSS segment.
For instance a global variable declared int j; would be contained in the BSS segment.

4. Stack:
The stack area traditionally adjoined the heap area and grew the opposite direction; when the stack pointer met the heap pointer, free memory was exhausted. (With modern large address spaces and virtual memory techniques they may be placed almost anywhere, but they still typically grow opposite directions.)

The stack area contains the program stack, a LIFO structure, typically located in the higher parts of memory. On the standard PC x86 computer architecture it grows toward address zero; on some other architectures it grows the opposite direction. A “stack pointer” register tracks the top of the stack; it is adjusted each time a value is “pushed” onto the stack. The set of values pushed for one function call is termed a “stack frame”; A stack frame consists at minimum of a return address.

Stack, where automatic variables are stored, along with information that is saved each time a function is called. Each time a function is called, the address of where to return to and certain information about the caller’s environment, such as some of the machine registers, are saved on the stack. The newly called function then allocates room on the stack for its automatic and temporary variables. This is how recursive functions in C can work. Each time a recursive function calls itself, a new stack frame is used, so one set of variables doesn’t interfere with the variables from another instance of the function.

5. Heap:
Heap is the segment where dynamic memory allocation usually takes place.

The heap area begins at the end of the BSS segment and grows to larger addresses from there.The Heap area is managed by malloc, realloc, and free, which may use the brk and sbrk system calls to adjust its size (note that the use of brk/sbrk and a single “heap area” is not required to fulfill the contract of malloc/realloc/free; they may also be implemented using mmap to reserve potentially non-contiguous regions of virtual memory into the process’ virtual address space). The Heap area is shared by all shared libraries and dynamically loaded modules in a process.

]]> https://www.emblogic.com/blog/03/a-typical-memory-representation-of-c-program/feed/ 0 how to give command line arguments to a self defined command created using shell scripting? https://www.emblogic.com/blog/03/how-to-give-command-line-arguments-to-a-self-defined-command-created-using-shell-scripting/ https://www.emblogic.com/blog/03/how-to-give-command-line-arguments-to-a-self-defined-command-created-using-shell-scripting/#comments Sat, 08 Mar 2014 06:24:19 +0000 http://www.emblogic.com/blog/?p=8950

 

this script uses two arguments given while using the command (script name) which it uses to replace $1 (first argument) $2 (second argument).

]]> https://www.emblogic.com/blog/03/how-to-give-command-line-arguments-to-a-self-defined-command-created-using-shell-scripting/feed/ 0 Where Are the Linux Kernel Files? https://www.emblogic.com/blog/03/where-are-the-linux-kernel-files/ https://www.emblogic.com/blog/03/where-are-the-linux-kernel-files/#comments Sat, 08 Mar 2014 05:00:09 +0000 http://www.emblogic.com/blog/?p=8948 Continue reading →]]>

The kernel file, in Ubuntu, is stored in your /boot folder and is called vmlinuz-version. The name vmlinuz comes from the unix world where they used to call their kernels simply “unix” back in the 60?s so Linux started calling their kernel “linux” when it was first developed in the 90?s.

When virtual memory was developed for easier multitasking abilities, “vm” was put at the front of the file to show that the kernel supports virtual memory. For a while the Linux kernel was called vmlinux, but the kernel grew too large to fit in the available boot memory so the kernel image was compressed and the ending x was changed to a z to show it was compressed with zlib compression. This same compression isn’t always used, often replaced with LZMA or BZIP2, and some kernels are simply called zImage.

The version numbering will be in the format A.B.C.D where A.B will probably be 2.6, C will be your version, and D indicates your patches or fixes.

In the /boot folder there will also be other very important files called initrd.img-version, system.map-version, and config-version. The initrd file is used as a small RAM disk that extracts and executes the actual kernel file. The system.map file is used for memory management before the kernel fully loads, and the config file tells the kernel what options and modules to load into the kernel image when the it is being compiled.

]]> https://www.emblogic.com/blog/03/where-are-the-linux-kernel-files/feed/ 0 how to interpret complex declarations in C https://www.emblogic.com/blog/03/how-to-interpret-complex-declarations-in-c/ https://www.emblogic.com/blog/03/how-to-interpret-complex-declarations-in-c/#comments Mon, 03 Mar 2014 05:58:08 +0000 http://www.emblogic.com/blog/?p=8764 Continue reading →]]>

Complicated declarations in C

Most of the times declarations are simple to read, but it is hard to read some declarations which involve pointer to functions. For example, consider the following declaration from “signal.h”.

void (*bsd_signal(int, void (*)(int)))(int);

Let us see the steps to read complicated declarations.

1) Convert C declaration to postfix format and read from left to right.
2) To convert experssion to postfix, start from innermost parenthesis, If innermost parenthesis is not present then start from declarations name and go right first. When first ending parenthesis encounters then go left. Once whole parenthesis is parsed then come out from parenthesis.
3) Continue until complete declaration has been parsed.

Let us start with simple example. Below examples are from “K & R” book.

1)  int (*fp) ();

Let us convert above expression to postfix format. For the above example, there is no innermost parenthesis, that’s why, we will print declaration name i.e. “fp”. Next step is, go to right side of expression, but there is nothing on right side of “fp” to parse, that’s why go to left side. On left side we found “*”, now print “*” and come out of parenthesis. We will get postfix expression as below.

  fp  *  ()  int

Now read postfix expression from left to right. e.g. fp is pointer to function returning int

Let us see some more examples.

2) int (*daytab)[13]

Postfix : daytab * [13] int
Meaning : daytab is pointer to array of 13 integers.

3) void (*f[10]) (int, int)

Postfix : f[10] * (int, int) void
Meaning : f is an array of 10 of pointer to function(which takes 2 arguments of type int) returning void

4) char (*(*x())[]) ()

Postfix : x () * [] * () char
Meaning : x is a function returning pointer to array of pointers to function returnging char

5) char (*(*x[3])())[5]

Postfix : x[3] * () * [5] char
Meaning : x is an array of 3 pointers to function returning pointer to array of 5 char’s

6) int *(*(*arr[5])()) ()

Postfix : arr[5] * () * () * int
Meaning : arr is an array of 5 pointers to functions returning pointer to function returning pointer to integer

7) void (*bsd_signal(int sig, void (*func)(int)))(int);

Postfix : bsd_signal(int sig, void(*func)(int)) * (int) void
Meaning : bsd_signal is a function that takes integer & a pointer to a function(that takes integer as argument and returns void) and returns pointer to a function(that take integer as argument and returns void)

]]> https://www.emblogic.com/blog/03/how-to-interpret-complex-declarations-in-c/feed/ 0 the process of booting in linux https://www.emblogic.com/blog/02/the-process-of-booting-in-linux/ https://www.emblogic.com/blog/02/the-process-of-booting-in-linux/#comments Tue, 25 Feb 2014 07:20:47 +0000 http://www.emblogic.com/blog/?p=8527 Continue reading →]]> The following are the 6 high level stages of a typical Linux boot process.

1. BIOS

BIOS stands for Basic Input/Output System
Performs some system integrity checks
Searches, loads, and executes the boot loader program.
It looks for boot loader in floppy, cd-rom, or hard drive. You can press a key (typically F12 of F2, but it depends on your system) during the BIOS startup to change the boot sequence.
Once the boot loader program is detected and loaded into the memory, BIOS gives the control to it.
So, in simple terms BIOS loads and executes the MBR boot loader.

2. MBR

MBR stands for Master Boot Record.
It is located in the 1st sector of the bootable disk. Typically /dev/hda, or /dev/sda
MBR is less than 512 bytes in size. This has three components 1) primary boot loader info in 1st 446 bytes 2) partition table info in next 64 bytes 3) mbr validation check in last 2 bytes.
It contains information about GRUB (or LILO in old systems).
So, in simple terms MBR loads and executes the GRUB boot loader.

3. GRUB

GRUB stands for Grand Unified Bootloader.
If you have multiple kernel images installed on your system, you can choose which one to be executed.
GRUB displays a splash screen, waits for few seconds, if you don’t enter anything, it loads the default kernel image as specified in the grub configuration file.
GRUB has the knowledge of the filesystem (the older Linux loader LILO didn’t understand filesystem).
Grub configuration file is /boot/grub/grub.conf (/etc/grub.conf is a link to this). The following is sample grub.conf of CentOS.

#boot=/dev/sda
default=0
timeout=5
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
hiddenmenu
title CentOS (2.6.18-194.el5PAE)
root (hd0,0)
kernel /boot/vmlinuz-2.6.18-194.el5PAE ro root=LABEL=/
initrd /boot/initrd-2.6.18-194.el5PAE.img

As you notice from the above info, it contains kernel and initrd image.
So, in simple terms GRUB just loads and executes Kernel and initrd images.

4. Kernel

Mounts the root file system as specified in the “root=” in grub.conf
Kernel executes the /sbin/init program
Since init was the 1st program to be executed by Linux Kernel, it has the process id (PID) of 1. Do a ‘ps -ef | grep init’ and check the pid.
initrd stands for Initial RAM Disk.
initrd is used by kernel as temporary root file system until kernel is booted and the real root file system is mounted. It also contains necessary drivers compiled inside, which helps it to access the hard drive partitions, and other hardware.

5. Init

Looks at the /etc/inittab file to decide the Linux run level.
Following are the available run levels
0 – halt
1 – Single user mode
2 – Multiuser, without NFS
3 – Full multiuser mode
4 – unused
5 – X11
6 – reboot
Init identifies the default initlevel from /etc/inittab and uses that to load all appropriate program.
Execute ‘grep initdefault /etc/inittab’ on your system to identify the default run level
If you want to get into trouble, you can set the default run level to 0 or 6. Since you know what 0 and 6 means, probably you might not do that.
Typically you would set the default run level to either 3 or 5.

6. Runlevel programs

When the Linux system is booting up, you might see various services getting started. For example, it might say “starting sendmail …. OK”. Those are the runlevel programs, executed from the run level directory as defined by your run level.
Depending on your default init level setting, the system will execute the programs from one of the following directories.
Run level 0 – /etc/rc.d/rc0.d/
Run level 1 – /etc/rc.d/rc1.d/
Run level 2 – /etc/rc.d/rc2.d/
Run level 3 – /etc/rc.d/rc3.d/
Run level 4 – /etc/rc.d/rc4.d/
Run level 5 – /etc/rc.d/rc5.d/
Run level 6 – /etc/rc.d/rc6.d/
Please note that there are also symbolic links available for these directory under /etc directly. So, /etc/rc0.d is linked to /etc/rc.d/rc0.d.
Under the /etc/rc.d/rc*.d/ directories, you would see programs that start with S and K.
Programs starts with S are used during startup. S for startup.
Programs starts with K are used during shutdown. K for kill.
There are numbers right next to S and K in the program names. Those are the sequence number in which the programs should be started or killed.
For example, S12syslog is to start the syslog deamon, which has the sequence number of 12. S80sendmail is to start the sendmail daemon, which has the sequence number of 80. So, syslog program will be started before sendmail.

]]> https://www.emblogic.com/blog/02/the-process-of-booting-in-linux/feed/ 0 creating linked list using structures and function https://www.emblogic.com/blog/02/creating-linked-list-using-structures-and-function/ https://www.emblogic.com/blog/02/creating-linked-list-using-structures-and-function/#comments Sat, 22 Feb 2014 11:51:42 +0000 http://www.emblogic.com/blog/?p=8480 Continue reading →]]> Screenshot Screenshot-1 Screenshot-2

RCS file: header.h,v
Working file: header.h
head: 1.10
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 10; selected revisions: 10
description:
created a header file including all predefined header files.
learnt that header file “string.h” is required for using memset function
learnt that memset retutrns a void pointer to the memory block which we hav set with a constant character.
—————————-
revision 1.10
date: 2014/02/22 10:38:23; author: root; state: Exp; lines: +8 -10
made changes in the body of function createnode.
—————————-
revision 1.9
date: 2014/02/22 10:27:31; author: root; state: Exp; lines: +2 -2
*** empty log message ***
—————————-
revision 1.8
date: 2014/02/22 10:18:52; author: root; state: Exp; lines: +9 -3
created oother node than the starting node
declared a new pointer in the body of function createnode which will always point to new node.
this new pointer is given the address stored in “next” pointer of the start node.
—————————-
revision 1.7
date: 2014/02/22 09:54:32; author: root; state: Exp; lines: +1 -1
syntax error removed
—————————-
revision 1.6
date: 2014/02/22 09:52:30; author: root; state: Exp; lines: +2 -2
made changes in prototype and definition of the function createnode
—————————-
revision 1.5
date: 2014/02/22 09:43:32; author: root; state: Exp; lines: +3 -3
again changed the parameters passed in the body of the function createnode
learnt we can find out the address of a pointer simply by using &pointer
—————————-
revision 1.4
date: 2014/02/22 09:17:47; author: root; state: Exp; lines: +6 -6
mentioned the type of arguments in the prototype of createnode
passed the arguments using pass by refference
changed the function body
—————————-
revision 1.3
date: 2014/02/22 08:49:00; author: root; state: Exp; lines: +9 -0
created a function for creating start node
declared the prototype of createnode
defined the body of createnode
returned a value flag = 1 if the node is created succesfully
catching of the returned vallue in the main function is necessary
—————————-
revision 1.2
date: 2014/02/22 08:09:18; author: root; state: Exp; lines: +11 -0
declared a structured data type linked.
members of struct link are
int info
a pointer next of structured type linked
—————————-
revision 1.1
date: 2014/02/22 08:04:00; author: root; state: Exp;
Initial revision
=============================================================================
#include

main()
{
struct linked *start;int flag=0,p;
p=createnode(&start,&flag);

if(p)
{ printf(“starting node created successfully\n”);

printf(“%p\n”,start);
printf(“%d”,sizeof(struct linked));

}

}

RCS file: linkedlist.c,v
Working file: linkedlist.c
head: 1.2
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 2; selected revisions: 2
description:
created a pointer of struct linked type
allocated memory to the pointer using malloc
checked if the start pointer is not null
the size of the struct linked printed on the console
the address of the starting node printed on the console
—————————-
revision 1.2
date: 2014/02/22 09:56:31; author: root; state: Exp; lines: +7 -3
first node of linkedlist created using function createnode successfully
pass by referrence method use to pass the addresses of the arguments to the createnode function by main function
—————————-
revision 1.1
date: 2014/02/22 08:21:38; author: root; state: Exp;
Initial revision
=============================================================================

]]> https://www.emblogic.com/blog/02/creating-linked-list-using-structures-and-function/feed/ 0