@shijitht

October 20, 2010

Valgrind

Filed under: C, Commands, GNU/Linux, Tools — Tags: , , , , — shijitht @ 1:18 pm

Valgrind is a collection of tools to check the correctness of a program. The main tool in it is memcheck. It reports memory leak, out of bound writes, improperly initialized variables etc. This provides a report which pin points the correct location of the error. So this is a good tool to debug programs with unpredictable behavior and crash.

Using

Inorder to see the exact line number of error, compile the code with -g option and reports could be misleading if optimization above level 1 are used(-O1). The -g option compiles the code with debugging symbols enabled, this helps valgrind to locate line number.
Use this program prog.c

prog.c
-------
void fun()
{
    char *a = (char *)malloc(10 * sizeof(char));
    a[10] = 'a';
}
main()
{
    fun();
    return 0;
}

prog.c has two major errors,
1. a[10]  = ‘a’;
a[10]  is out of the allocated region. Writing to this region could produce mysterious behavior. This is called heap block overrun.
2. 10 byte block pointed by a is never freed. So on return to main, that block remains inaccessible and unusable. This is a serious memory leak.

Lets use valgrind to detect these errors,
Compile the code with -g option

$ cc -g prog.c

Generate report

$ valgrind –leak-check=yes   ./a.out
can use 2>&1 to redirect report to a file( $ valgrind –leak-check=yes  ./a.out > report   2>&1 )

Analyzing report

Various error messages and summaries can be found. error messages are generated in case of out of bound writes, here a[10].
The corresponding report is
==4836== Invalid write of size 4
==4836==    at 0x80483FF: fun(prog.c:6)
==4836==    by 0x8048411: main (prog.c:11)
==4836==  Address 0x419a050 is 0 bytes after a block of size 40 alloc’d
==4836==    at 0x4024F20: malloc (vg_replace_malloc.c:236)
==4836==    by 0x80483F5: fun(prog.c:5)
==4836==    by 0x8048411: main (prog.c:11)
4836 is the process id. First line shows, error is due to an invalid write of size 4. Below it is a complete stack trace. The error happened at line 6 of  prog.c. Read stack trace from bottom to up. Started from main, then a function call to fun, malloc and error at last. Error shows the address we tried to write is beyond the allocated 40 byte block. This information is quite useful to make the code correct.

The Leak summery show the memory leaks.
Here,
==4836== LEAK SUMMARY:
==4836==    definitely lost: 40 bytes in 1 blocks
==4836==    indirectly lost: 0 bytes in 0 blocks
==4836==      possibly lost: 0 bytes in 0 blocks
==4836==    still reachable: 0 bytes in 0 blocks
==4836==         suppressed: 0 bytes in 0 blocks
Second line shows the 40 byte block lost in function fun. Report includes other types of leaks also.

Valgrind checks these errors and leaks in runtime like a virtual machine executing each instruction of a code. So it is time consuming for large code. But the report generated is very much useful and can be used to correct mistakes which are otherwise very difficult to detect.

October 19, 2010

Compiler optimizations

Filed under: C, GNU/Linux — Tags: , , , , — shijitht @ 5:01 pm

To improve the performance, compiler optimizes the code while compilation. Compiler inline optimization and common subexpression elimination are discussed here. The assembly code is given for further clarifications. Compiler does these optimizations on the basis of a cost/benefit calculation.
Compiler used GCC 4.4.3

Code inlining

Code inlining embeds the functions body in the caller. This eliminates call and return steps and helps to put some extra optimization in both codes.
Lets see the difference.
Compile opt1.c with and without optimization to generate assembly code.

opt1.c
-------
int sqr(int x)
{
 return x*x;
}

main()
{
 printf("%d\n", sqr(10));
}

Without optimization
$ cc  -S  opt1.c  -o  wout_opt1.s
With optimization
$ cc  -S  -O3  opt1.c  -o  with_opt1.s

Compare both files. The function call to sqr in wout_opt1.s is replaced with its value in with_opt1.s. The corresponding  lines are darkened.

wout_opt1.s
-------------
main:
 pushl   %ebp
 movl    %esp, %ebp
 andl    $-16, %esp
 subl    $16, %esp
 movl    $10, (%esp)
 call    sqrc
 movl    %eax, 4(%esp)
 movl    $.LC0, (%esp)
 call    printf
 leave
 ret

with_opt1.s
-----------
main:
 pushl    %ebp
 movl    %esp, %ebp
 andl    $-16, %esp
 subl    $16, %esp
 movl    $100, 4(%esp)
 movl    $.LC0, (%esp)
 call    printf
 leave
 ret

But the code for sqr remains in both .s file because it could be referenced by some other functions where inline optimization can’t be applied. Only the linker can detect and remove unreferenced functions.
In inlining, the value of the function is found while compilation instead of runtime. Call instruction is replaced by a move instruction which loads the immediate value to the required location. An immediate value($100) equivalent to function sqr can be seen here and the call statement removed.

Common subexpression elimination

Compiler scans the code and finds identical subexpressions. These are evaluated only once and replaced with a single variable holding its value.
For example, take opt2.c

opt2.c
-------
main()
{
 int i, j, k, r;

 scanf("%d%d", &i, &j);

 k = i + j + 10;

 r = i + j + 30;

 printf("%d %d\n", k, r);

}

opt2.c has the subexpression i + j.

Compile opt2.c with and without optimization

Without
$ cc  -S  opt2.c  -o  wout_opt2.s
With
$ cc  -O3  -S  opt2.c  -o  with_opt2.s

wout_opt2.s
------------
main:
 pushl   %ebp
 movl    %esp, %ebp
 andl    $-16, %esp
 subl    $32, %esp
 leal    24(%esp), %eax
 movl    %eax, 8(%esp)
 leal    28(%esp), %eax
 movl    %eax, 4(%esp)
 movl    $.LC0, (%esp)
 call    scanf
 movl    28(%esp), %edx
 movl    24(%esp), %eax
 leal    (%edx,%eax), %eax
 addl    $10, %eax
 movl    %eax, 20(%esp)
 movl    28(%esp), %edx
 movl    24(%esp), %eax
 leal    (%edx,%eax), %eax
 addl    $30, %eax
 movl    %eax, 16(%esp)
 movl    16(%esp), %eax
 movl    %eax, 8(%esp)
 movl    20(%esp), %eax
 movl    %eax, 4(%esp)
 movl    $.LC1, (%esp)
 call    printf
 leave
 ret

with_opt2.s
------------
main:
 same as above
 call    scanf
 movl    24(%esp), %eax
 addl    28(%esp), %eax
 movl    $.LC1, (%esp)
 leal    30(%eax), %edx
 addl    $10, %eax
 movl    %edx, 8(%esp)
 movl    %eax, 4(%esp)
 call    printf
 leave
 ret

In wout_opt2.s, two variables are read as usual. The value i + j is calculated in two places to add with 10 and 30. leal  (%edx,%eax),  %eax is to add i and j. Evaluating the expression twice wastes CPU time.
In optimized with_opt2.s, the first value read is stored in eax. It gets added with the value read next. Now eax the value of i + j. leal adds 30 to it and stores in edx. addl adds 10 and eax.
Common subexpression elimination is a powerful technique to optimize code performance. Programmers can eliminate such subexpressions while coding.  But there will be compiler generated expressions for array index calculation, macro expansion etc. A programmer can’t do optimization in this level. These are the cases where a compiler does its trick to improve performance.

October 14, 2010

Building a GNU/Linux system from scratch and running it with UML

Filed under: GNU/Linux, Projects — Tags: , , , , — shijitht @ 12:23 am

Other than installing the system from the precompiled binaries, we could build it from scratch. The scratch means, building every element that makes our system, entirely from source code !!!. This is a !!! now, but in older days this was a necessary installation routine for linux lovers. Since we are new to this process proper documentation is needed to build the system. A fantastic Linux From Scratch(LFS) project is there to help us. Go to http://www.linuxfromscratch.org/. With proper description of each step, this project is the best to start for a beginner.

After system build, we can use it on a physical drive as per the documentation. Compile a proper kernel and write it on a drive to boot from it. But this article covers using uml. UML means User Mode Linux. Run linux on top of current linux kernel instead of bare hardware. We can test the new system, above a uml kernel.  While running a uml kernel, we can specify virtual resources such as root file system, swap, hardware etc.

Why build from source ?

You will have a question that, why build from source when a lot distros are available, which could be installed easily with a few mouse clicks ?. The aim of installing from scratch is to make a proper understanding of our system software internals. You can see the use of each package, its contents, size and the commands and scripts to build it. With intelligent package managers, we are unaware of the horrible dependency relations between packages. When you finish compiling the system, you can also get an awareness about the effort people put in making it.

UML

Uml kernel runs on top of system kernel in user space. Being a user process, privileged direct hardware access cant be made in uml kernel. So these are converted to system’s native calls. These calls are usually in arch folder of kernel. This make the creation of UML kernel easier because only the arch section differs. Only that folder needs rewrite. Another simple technique is used to execute processes inside uml system. An executing process is traced using ptrace. On a system call the process is stopped and it’s called address is replaced by the address of system call in real kernel. Then the stopped process is continued.

Building UML kernel

Follow these steps to create a uml kernel binary.
Download a stable kernel source from kernel.org.
Untar and cd to that folder.
Give these commands in the command line.
# make defconfig ARCH=um
will produce a .config file with default configuration for uml.
# make menuconfig
if desired
# make menuconfig ARCH=um
to produce a custom kernel
# make mrproper
# make mrproper ARCH=um
to get rid of all traces of whatever building you did, and start over.
# make ARCH=um
starts build
On completion, you can see a uml binary called “linux” of size ~25M.
Strip off debugging symbols to cut size.
To test this kernel start it with ubda=< FILE SYSTEM > option.

Creating file system

We can use a virtual file system to check the above kernel.
Use dd command to create a file of 6 GB.
# dd if=/dev/zero of=fs bs=1G count=6
will copy 1G from /dev/zero 6 times measuring a total of 6G.
Now create a file system of type ext3 using mkfs.ext3.
# mkfs.ext3 fs
give yes when prompted and it will produce a virtual file system of type ext3.
Use loopback to mount it
# mount -o loop fs /mnt/lfs
will mount fs -> /mnt/lfs
Loop back device /dev/loop0 is used for mounting this file. Through this device we can use the file as we are accessing a block device.
Next step is to make all programs inside fs which will help us use the system.

Creating files(programs)

Our system needs a lot of programs and tools for proper functioning. This include the init process, the first process which loads at boot. Then bash to interact with user and various tools to do tasks like compilation(gcc). The proper documentation for building is given at linuxfromscratch.org. So repeating them again will be a waste of time. Go to LFS site and follow the step by step instructions to build a working system. Do the version check as per the documentation to make sure you meet all the prerequisites. Also some errors might happen if texinfo packages is missing. You can come back, when you finish setting up system boot scripts.

Booting in uml

Make some changes to what you have done.
Edit /etc/fstab
When booting with uml we specify ubda as the root file system device.
So add it to fstab instead of what is there as root device.
/dev/ubda    /    ext3    defaults    1    1
Edit /dev/inittab
Comment all agetty lines and add this line instead
1:2345:respawn:/sbin/agetty tty0 9600
Now you are ready to boot with uml.

Power ON

Unmount the file system
# umount /mnt/lfs
Use the uml kernel produced(“linux”)  to start the system
# ./linux ubda=< PATH TO fs >
This will take you to a new virtual system build with your hands.

Conclusion

Building a Gnu/linux system from scratch is an experience which will take you to each and every corner of your system. Familiarizing with many commands and scripting techniques will increase knowledge. The role of each package is clearly understood while building from source. Now we know, what each package has and depends on. So later a much lighter system can be built with a custom configuration as per demands. Very small(~4M) systems can be built, which could be used in embedded systems. If we use uml, no restart is needed to test or boot a system. Also an exposure to virtualization can be gained with uml. LFS project has a documentation that any beginner can follow. Building a linux system from scratch is something that every linux enthusiast must do.

August 26, 2010

Pidgin invisibility cloak

Filed under: Tools — Tags: , , , , — shijitht @ 1:54 pm

Go Invisible option in pidgin is an option only. It will set status to busy. But there is a solution for it.

Go online.
Enable the XMPP console in Tools > Plugins.
Now select Tools->XMMP Console->XMMP Console.
Check your gmail account is selected in the console.
Put these code in the second box and hit enter.
Don’t mind the trail of code in the monitor, but a hacker could find it pretty useful.

{{{
<presence>
<priority>5</priority>
</presence>
<presence type="unavailable">
<priority>5</priority>
</presence>
}}}

Now go invisible.
To reset change unavailable to available and put it in the console.
For more go to http://www.madhusudancs.info/invisible.

August 22, 2010

Brief note about using Git

Filed under: Commands, Tools — Tags: , , — shijitht @ 7:51 pm

This is a short note including everyday commands. You can find more details like installing git and more commands at http://help.github.com/.
Don’t forget $ man git.

Create a repo graphically and do the following to get started.

The first section is to set up your name and email as a committer.

“git commit” allows to commit locally with  comment specified using -m option.
Here $ git commit -m “first commit” will make your local repo a step ahead of remote repo.
Check status using $ git status .
At first we need to connect to the remote repo. Origin is the remote repo-name used here, I suggest github or whatever name say your real repo name.
Now push using git push. Here master branch pushed to origin(remote repo-name).
To start tracking/add a new file → $ git add <file name> .
To commit to the remote repo → $ git push <repo name>  <branch name>.

Default branch choice is master.
To see branches → $ git branch .
Add -a option if you wish to see remote branches also.
To add a new branch for parallel developing → $ git branch <branch name> .
Move to the new branch → $ git checkout <branch name> .
To push a new branch →
$ git push <remote repo name>  <local branch name> :<remote branch name>.

If you use both branch names same, the ” <local branch name>: ” is optional.
To delete a branch locally → $ git branch -d .
To delete remote branch → $ git push <repo name>   :<remote branch name> .
i.e. nothing pushed( local section blank ).
To add a tag → $ git tag <tag name>
To update remote repo → $ git push   – – tags
To remove tags → $ git push <repo name>  :<tag name> .
Creating a folder demands adding files under it and use git rm in case of file deletion. So better keep file names distinct.
Use git clone/fetch to create a local copy of a repo.
To remove a repo do it graphically.

Useful links :
http://www.gitready.com/
http://scottr.org/presentations/git-in-5-minutes/

August 7, 2010

BloGTK WordPress setup

Filed under: Tools, WordPress — Tags: , , , , , , , — shijitht @ 6:39 pm

BloGTK is an application for blogging. We can use it for posting new articles, instead of browser. It has everything offered by word press editor. Install the software first.
DEB family type “apt-get install blogtk” and RPM group type “yum install blogtk” as root in the terminal. After installing, select it from Application/Internet/BloGTK Webblog Client. If it is not starting, take terminal. Type blogtk to start it. It might show an error like “no module named gtkhtml2”. Then you should install python-gtkhtml2. If apt-get or yum fails to find such a package, you can get it here, python-gtkhtml2. Select appropriate package from the liked site and double-click to install. If installed correctly, blogtk would run.
The settings are, go to Edit/Account and Settings and set

Server URL : http://you.wordpress.com/xmlrpc.php
Username : username
Password : password
Blogging System: Movable type
Press OK and select Connect in File.

Now you are ready to post. Select the desired Blog and Category to start writing new posts. You can see 3 tabs. Edit Post for normal editing, Advanced for tags etc and Preview shows preview. The demerits are no text formatting, HTML editor, grammar checking etc. This my first post using BloGTK. I finished it early but I don’t have the usual satisfaction using Word Press. I think you can use it as an offline tool for blogging. It is good tool for a blogger having limited Internet access.
Thanks to this..

August 6, 2010

Malayalam font

Filed under: Tools — Tags: , , — shijitht @ 12:44 am

We could hardly understand words of a Malayalam site. The problem is lack of correct font. For example go to manoramaonline. At the first look, you will close it. As many of our doubts, googling resolves it. But many consider it a huge effort, I don’t know why ?.

You get a Malayalam font, double-click and press install. Manorama.ttf is at the bottom. If fails or something unexpected happens, go ahead with following commands. As root

# mkdir /usr/share/fonts/manorama
# cp  Manorama.ttf /usr/share/fonts/manorama
# fc-cache  -fv

First we created a folder manorama in font directory(/usr/share/fonts/). Then copied Manorama.ttf font to that. The third command updated font information cache files. Restart your browser to start reading in mother-tang.

Click to download Manorama.ttf 

August 3, 2010

IRC > Forms

Filed under: Tools — Tags: , , , — shijitht @ 12:10 pm

Joining an IRC channel can solve doubts more quickly than posting at linux forms. IRC named ##linux would be filled with more than 850 users every time. And I never waited more than 10 sec for a question. At least 3 answer pops up in that time. I have never seen such an active channel elsewhere. If you have any doubts (after googling), I strongly suggest you put that in ##linux. For joining an IRC channel, you should have

* A client say Pidgin

* Add an account specifying IRC as protocol

* On receiving a prompt or chat window type /join ##linux

* Use a nick name,  /nick <name>  is enough. Registering that nick if you are a regular visitor.

* For more details you can google IRC/freenode.

Here is a fine link for clients you might like

August 1, 2010

wvdial.conf

Filed under: GNU/Linux — Tags: , , , , — shijitht @ 6:44 pm

For airtel use

[Dialer Defaults]
Init = AT+CGDCONT=1,”IP”,”airtelgprs.com”,””,0,0
Phone =*99#
Modem Type = USB Modem
Baud = 460800
New PPPD = yes
Modem = /dev/ttyACM0
Stupid Mode = yes
Password =any thing
Username =any thing

————————————————–

For Docomo

[Dialer Defaults]
Init1 = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Phone = *99***1#
Username = Docomo
Password = Docomo
Modem Type = USB Modem
Stupid Mode = yes
Baud = 460800
Dial Command = ATDT
Modem = /dev/ttyACM0
ISDN = 0
Carrier Check = yes
Auto Reconnect = yes
————————————————–

If any problem occurs run #wvdialconf.

In some cases nameserver won’t get updated in /etc/resolv.conf.

That case you need to add it manually.

Format is

nameserver IP

IP -> IP address of DNS server (you can get it while running wvdial).

July 29, 2010

Open System Sounds : Installing and Configuring

Filed under: Tools — Tags: , — shijitht @ 10:01 pm

* install oss from the file obtained from its site

* osstest will test available sound devises in the system.

* /use/lib/oss/ -> a useful folder containing configuration mixer.oss etc.

* oss will add the detected devices in /dev/oss

* when we have configured the device, passed osstest and still having the problem we can configure the softwares(vlc etc).

* we need to select oss instead of alsa or whatever for the audio functioning of the software and this will demand an audio device path.As stated above the device will be in /dev/oss most likely by the name pcm0.

* ossxmix will allow us to adjust volume properties graphically

* ossdetect -v will show the detected devices

* soundon and soundoff could be used to load and unload oss.

* /etc/init.d/oss {start | stop | restart} could be used to manage oss service

* remove /usr/lib/oss/starting if insisted

* vmix is virtual mixing. This will allow us to adjust the volume of each application separate. Vlc would be added to vmix when the above conf done.

Older Posts »

Create a free website or blog at WordPress.com.