Nabendu's Blog

Linux process Id's

2014-09-20T14:35:00.000+05:30

Linux process Id's

Scheduler is is the first process to initialize the paging etc..

Process ID Description:
0 The Scheduler
1 The init process
2 kflushd
3 kupdate
4 kpiod
5 kswapd
6 mdrecoveryd

SMD component Cheatsheet by NXP

2014-09-04T19:29:00.000+05:30

How malloc works in userspace

2013-10-31T23:10:00.003+05:30

I was checking how malloc work as compared to kernel kmalloc in term of physical memory allocation.What I found as below..
Glibc/C libary implement the malloc implementation,
For memory less than 128kb use brk()/sbrk
more than that use mmap with MAP_PRIVATE|MAP_ANONYMOUS

for test ran a small program on userspace I wrote
void main()
{
int *a;
a =(int*)malloc(150*1024); /* mmap invocation */
//a =(int*)malloc(10); /* brk invocation */
}

and ran strace on the o/p, there I can see brk and mmap invocation.What I understood from brk call.It increases the data section (Thr Brk limit) and add the memory to malloc.In mmap anonymous private pages are allocated by kernel and added as one vma section of process address space,From there glibc allocate memory and give it to malloc.

more details :
Link1
Link2
Link3
bestone__ Best_link

Process Virtual to Physical Translation

2013-10-31T22:47:00.003+05:30

Allocating aligned address and freeing them

2013-10-31T16:07:00.003+05:30

 uintptr_t mask = ~(uintptr_t)(align - 1);
 void *mem = malloc(1024+align-1);
 void *ptr = (void *)(((uintptr_t)mem+align-1) & ~mask);
ptr is the aligned address.

Some time back I faced an interview ,There I was asked to write a custom malloc using malloc
and free program for a predefined aligned address.Here is the solution.The byte before the 
aligned byte is always empty.We will keep the offset of actual memory allocated by malloc.
But there we have to allocate total memory =(desired+alignment)  instead of  
(desired+alignment-1) downside is that it can store upto 2pow8 offsets.
 mallocX(size_t X,alignment Y)
{
 p= malloc(X+Y);
    ret = (p+Y) & ~(Y-1);
 *(ret-1) = ret - p;
    return ret;
}
similarly for free
freeX(memptr mem)
{
 free (mem - *(mem-1));
}

Tracking Linux kworker threads

2013-10-27T01:14:00.002+05:30

How to find out which part of kernel/module has created this workqueue.How to track a kworker-thread named for example ''kworker/0:3 to its origin in kernel-space?

I found this thread on lkml that answers your question a little. (It seems even Linus himself was puzzled as to how to find out the origin of those threads.)

Basically, there are two ways of doing this:

$ echo workqueue:workqueue_queue_work > /sys/kernel/debug/tracing/set_event
$ cat /sys/kernel/debug/tracing/trace_pipe > out.txt
(wait a few secs)

For this you will need ftrace to be compiled in your kernel, and to enable it with:

mount -t debugfs nodev /sys/kernel/debug

More information on the function tracer facilities of Linux is available in the ftrace.txt documentation.

This will output what threads are all doing, and is useful for tracing multiple small jobs.

cat /proc/THE_OFFENDING_KWORKER/stack

This will output the stack of a single thread doing a lot of work. It may allow you to find out what caused this specific thread to hog the CPU (for example). THE_OFFENDING_KWORKER is the pid of the kworker in the process list. _____ by anarcat

Bit reversing tips

2013-10-26T20:19:00.002+05:30

Reversing bit pairs

unsigned int i, j; // positions of bit sequences to swap

unsigned int n;    // number of consecutive bits in each sequence
unsigned int b;    // bits to swap reside in b
unsigned int r;    // bit-swapped result goes here

unsigned int x = ((b >> i) ^ (b >> j)) & ((1U << n) - 1); // XOR temporary
r = b ^ ((x << i) | (x << j));

-----------------------------------------------------------
Another standard simple method:
unsigned int reverseBits(unsigned int num)
{
    unsigned int count = sizeof(num) * 8 - 1;
    unsigned int reverse_num = num;
    num >>= 1; 

    while(num)
    {
       reverse_num <<= 1;       
       reverse_num |= num & 1;
       num >>= 1;
       count--;
    }
    reverse_num <<= count;
    return reverse_num;
}

int main()
{
    unsigned int x = 1;
    printf("%u", reverseBits(x));
    getchar();
}
----------------------------------------------------------------
Another with n/2 complexity.
 int bitreverse(int x)
{
 unsigned int lmask = 0x80000000;
 int rmask = 0x01;
 while(mask1>mask2)
 {
  if(!(((lmask &x) != 0 && (rmask&x) != 0) || ((lmask &x)==0 && (rmask&x)==0)))
  {
   x=x^lmask;
   x=x^rmask;
  }
  lmask >>=1;
  rmask <<=1;
 }
 return x;
}

----------------------------------------------------------------

Reverse an N-bit quantity in parallel in 5 * lg(N) operations:

unsigned int v; // 32-bit word to reverse bit order

// swap odd and even bits
v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
// swap consecutive pairs
v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
// swap nibbles ... 
v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
// swap bytes
v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
// swap 2-byte long pairs
v = ( v >> 16             ) | ( v               << 16);
The following variation is also O(lg(N)), however it requires more operations to reverse v. Its virtue is in taking less slightly memory by computing the constants on the fly.
unsigned int s = sizeof(v) * CHAR_BIT; // bit size; must be power of 2 
unsigned int mask = ~0;         
while ((s >>= 1) > 0) 
{
  mask ^= (mask << s);
  v = ((v >> s) & mask) | ((v << s) & ~mask);
}

These methods above are best suited to situations where N is large. If you use the above with 64-bit ints (or larger), then you need to add more lines (following the pattern); otherwise only the lower 32 bits will be reversed and the result will be in the lower 32 bits.

Nice value and priority and relations

2013-10-26T17:33:00.000+05:30

The priority of a process in linux is dynamic: The longer it runs, the lower its priority will be. A process runs when its actually using the CPU - most processes on a typical Linux box just wait for I/O and thus do not count as running.

The priority is taken into account when there are more processes running than CPU cores available: Highest priority wins. But as the winning process looses its proirity over time, other processes will take over the CPU at some point.

nice and renice will add/remove some "points" from priority. A process which has a higher nicevalue will get lesser CPU time. Root can also set a negative nice value - the process gets more CPU time.

Example: There are two processes (1 and 2) calculating the halting problem and one CPU core in the system. Default is nice 0, so both processes get about half of the CPU time each. Now lets renice process 1 to value 10. Result: Process 2 gets a significant higher amount of cpu time as process 1.

Note: In modern desktops there is plenty CPU time available - they are fast these days. Unfortunately HDDs are still relativeley slow on random I/O, so even a nice process can generate enough I/O traffic to significantly slow down a system.

Processes have an initial priority specified as the nice value. This value is stored in the static_prio member of the process’s task_struct. The value is called the static priority because it does not change from what the user specifies. The scheduler, in turn, bases its decisions on the dynamic priority that is stored in prio. The dynamic priority is calculated as a function of the static priority and the task’s interactivity.

HIGH PRIORITY – - – - – > – - – - – > – - – - – > – - – - – > – - – – LEAST PRIORITY
……..real time priority (static priority)…….| …. nice value (dynamic priority) …..
99 ……………………….. 50 ……………………… 1 | -20 …….. -10 …….. 0 …….. 10 ……. 19

Forked process, thread and address spaces little deeper

2013-10-23T02:21:00.001+05:30

In Fork()

The child process has a unique process ID.
The child process has a different parent process ID (i.e., the process ID of the parent process).
The child process has its own copy of the parent's descriptors. These descriptors reference the same underlying objects, so that, for instance, file pointers in file objects are shared between the child and the parent, so that an lseek(2) on a descriptor in the child process can affect a subsequent read(2) or write(2) by the parent. This descriptor copying is also used by the shell to establish standard input and output for newly created processes as well as to set up pipes.semaphores if opened it also inherit. Memory mappings created in the parent are retained in the child process,(If MAP_PRIVATE was used in parent,it will be MAP_PRIVATE in child to,after forking if any change in memory mapped area that will be visible to corresponding process only)
The child process' resource utilizations are set to 0; see setrlimit(2).
All interval timers are cleared; see setitimer(2).

process is created with a single thread. If a multi-threaded process calls fork(), the new process contains a replica of the calling thread and its entire address space, possibly including the states of mutexes and other resources. Consequently, to avoid errors, the child process may only execute async-signal safe operations until such time as one of the exec functions is called. Fork handlers may be established by means of the pthread_atfork() function in order to maintain application invariants across fork() calls.

In summery The child gets an exact copy of the parents address space, which in many cases is likely to be laid out in the same format as the parent address space. I have to point out that each one will have it's own virtual address space for it's memory, such that each could have the same data at the same address, yet in different address spaces. Also, linux uses copy on write when creating child processes. This means that the parent and child will share the parent address space until one of them does a write, at which point the memory will be physically copied to the child. This eliminates unneeded copies when execing a new process. Since you're just going to overwrite the memory with a new executable, why bother copying it?

Descriptor copied first, later some elements are intialized. Most of them are intact.
Shared Resources:

In Thread()
Often it is sufficient to run a partial copy of a process with the other parts shared with other processes. Such copies can be realized by a thread (an example of a lightweight process) which has the following properties:

Resources and data can be shared between threads
Each thread has its own stack
Context switching is fast

A fork() induces a parent-child relationship between two processes. Thread creation induces a peer relationship between all the threads of a process.

The main() thread runs first, but has no other priority
The main thread may have some special properties

Processes and threads can

Terminate
Start a new process or thread
Wait for each other to terminate
Terminate each other
Share data and communicate
Run independently

Global variable ,static always initialized but auto is not initialized

2013-10-10T15:26:00.005+05:30

Security: leaving memory alone would leak information from other processes or the kernel.
Efficiency: the values are useless until initialized to something, and it's more efficient to zero them in a block with unrolled loops.
Reproducibility: leaving the values alone would make program behavior non-repeatable, making bugs really hard to find.
Elegance: it's cleaner if programs can start from 0 without having to clutter the code with default initializers.

One might wonder why the auto storage class does start as garbage. The answer is two-fold:

It doesn't, in a sense. The very first stack frame does receive zero values. The "garbage", or "uninitialized" values that subsequent instances at the same stack level see are really the previous values left by the same program.
There might be a runtime performance penalty associated with initializing auto (function locals) to anything. A function might not use any or all of a large array, say, and it could be invoked thousands or millions of times. The initialization of statics and globals, OTOH, only needs to happen once.

Speed of execution in term of code in some cases

2013-10-10T11:53:00.000+05:30

Is “else if” faster than “switch() case”?

For small loops not required,For very big loop hash table is used for switch case so faster execution.

But with good compiler with optimization enabled, it's same.

Why i++ is faster than i=i+1 in c

older compilers used

(1)ADD \\i+1

(2)Assignment operation \i=x

for i=i+1

for i++

(1)INR

but currently good compilers with optimizations enabled creates same assembly code.

ARM Nesting of Interrupts

2013-10-06T23:11:00.002+05:30

NESTING INTERRUPTS

Applies to: RealView C Compiler

Answer

Information in this article applies to:

RealView Compiler Version 3.0 or higher

QUESTION

The classic ARM architecture only provides two interrupts (IRQ and FIQ). The Vectored Interrupt Controller or Advanced Interrupt Controller provides interrupt priorities and interrupt nesting for the standard interrupt, but it requires that you set the I bit in the CPSR.

What is the best method to allow interrupt nesting with the RealView compiler?

ANSWER

It should be noted that good programming technique implies that you keep interrupt functions very short. When you are using short interrupt functions, interrupt nesting becomes unimportant. When you are using an Real-Time Operating System (such as the RTX Kernel), the stack usage of user tasks becomes unpredictable when you allow interrupt nesting.

However, if you still need interrupt nesting in your application, you may implement it using an assembly language wrapper function as described below:

Example:

Within the following __irq function you want to allow interrupt nesting:

void eint1_irq (void)  __irq  {   // C interrupt function
  EXTINT      = 2;                // Clear EINT1 interrupt flag
  delay ();                       // wait a long time
  ++intrp_count;                  // increment interrupt count
  VICVectAddr = 0;                // Acknowledge Interrupt
}

Change the interrupt function as shown below:

extern void eint1_irq (void);     // wrapper ASM interrupt function

void eint1_srv (void)  {          // C interrupt code
  EXTINT      = 2;                // Clear EINT1 interrupt flag
  delay ();                       // wait a long time
  ++intrp_count;                  // increment interrupt count
//VICVectAddr = 0;                // Acknowledge Interrupt
}

Add the following assembler wrapper (in a separate assembly module) to the interrupt function:

       PRESERVE8
       AREA    NEST_IRQ, CODE, READONLY
       ARM
       IMPORT  eint1_srv
       EXPORT  eint1_irq

eint1_irq

       PUSH    {R0-R3,R12,LR}          ; save register context
       MRS     LR, SPSR                ; Copy SPSR_irq to LR
       PUSH    {LR}                    ; Save SPSR_irq
       MSR     CPSR_c, #0x1F           ; Enable IRQ (Sys Mode)
       PUSH    {LR}                    ; Save LR

       BL      eint1_srv

       POP     {LR}                    ; Restore LR
       MSR     CPSR_c, #0x92           ; Disable IRQ (IRQ Mode)
       POP     {LR}                    ; Restore SPSR_irq to LR
       MSR     SPSR_cxsf, LR           ; Copy LR to SPSR_irq

;      VICVectAddr = 0;                ; Acknowledge Interrupt
       MOV     R0,#0
       STR     R0,[R0,#-0xFD0]

       POP     {R0-R3,R12,LR}          ; restore register context
       SUBS    R15,R14,#0x0004         ; return from interrupt


       END

Note:

The example above shows interrupt nesting with the NXP LPC2000 devices. It is important that you move the interrupt acknowledge sequence VICVectAddr = 0; to the assembly wrapper. Other ARM devices may require a different interrupt acknowledge sequence. Therefore consult the user's manual of the ARM device that you are using.

Source

Another good approach from source:

Many a times it would be handy if we could let the interrupt handling routine decide whether to nest an interrupt or not. Yes this voilates the concept of interrupt prioritization but there might be times say a data frame sync fault has occurred and you would probably need to restart the transfer and which may take a much longer time. In such situations your device driver might decide to allow other interrupts to occur. This can be accomplished in two ways

To raise a Software Interrupt to do this switch
To call an assembly routine that takes care of the context switching

Software Interrupt approach:

This is a very good approach a standardized system routine to take care of this. But is it really necessary to do all this in a simple embedded application. This is a good approach for any high end operating systems. The routine may decide upon whether to allow the driver to nest the interrupt and wait or should it return immediately. I’m not posting more on this here as this not the simplest of approach or easy to give it for free..

A typical Software Interrupt Approach needs to be implemented in the following way or something similar

Create a common IRQ distribution routine

IRQ distribution routine will call the actual interrupt handler

Handler can raise a SWI for allowing interrupt nesting

Handler shall return to the IRQ distribution routine

IRQ distribution routine safely resumes the previous process

Assembly Routine:

By writing an embedded assembler routing supported by ARMGCC compiler the developer has the flexibility to do an interrupt nesting by simple calling this routine(Just like a function call). You would need to create two embedded assembler routines

To Enable the processor interrupt and switch to system mode.
To Disable the processor interrupt and switch back to the original program.

Before we look at the embedded assemblers used to serve this purpose let us see how parameters are passed to embedded assemblers.

__asm void enableIRQ(int dummy_variable)

The dummy variable is available at the register R0. As I mentioned earlier the call to this embedded assembler is just like any function call, on return the old value of the register R0 will be restored. This behavior is opposite to that of a normal function call in which the called function takes care of storing and restoring the registers. This is completely a compiler dependent behavior. If you are interested take a look at the disassemble.

The complete IRQ Nesting code use in SRMSAT-1


__asm void enableIRQ(int dummy)
{
MRS r0, SPSR
STMDB SP!,{r0}
MOV r0,LR
MSR CPSR_c, #0x9F
STMDB SP!,{LR}
MOV LR,r0
MSR CPSR_c,#0x1F
MOV PC,LR
}
__asm void disableIRQ(int dummy)
{
MSR CPSR_c, #0x9F
MOV r0,LR
LDMIA SP!, {LR}
MSR CPSR_c, #0x92
LDMIA SP!, {LR}
MSR SPSR_cxsf, LR
MOV PC,r0
}

I have forced the compiler to free the contents of the register R0 by passing an useless parameter to create an useful slot for swapping the register contents. I’am assuming that the reader is familiar with ARM assembly. If you have more doubts read my other posts on ARM instruction set(At this time i’m still editing my blog on instruction set as it is too big or if I should make it just contain references to someone else blog as there are already a lot of available resources on ARM instruction set and execution). It is a must for the developer to call the “disableIRQ” before returning from the interrupt handler. Else you are going to corrupt the stack and bread the code.

Now before I finish let us see the advantages and drawbacks of both the approaches and which approach you should choose for your application.

Advantages
System IRQ Approach

OS can can decide whether to allow or not.
Switching can be made to “User” mode instead of “System” mode and leading to a
security vulnerability.
OS can consider dynamic system conditions to decide.

Embedded Assembler Approach

Light weight
Easy to use with any Embedded C/C++ projects

Drawbacks
System IRQ Approach

Not all embedded applications have a proper OS.
Adds a lot of procedure to follow in implementing, for instance after the call we need to examine whether the access was granted or not.

Embedded Assembler Approach

Highly vulnerable to security issues due to the switch to privileged system mode.

Choosing the right approach for your application:

Unless you are developing a competing OS for Symbian or Windows do not go for the writing the system IRQ routines(To know about writing System IRQ’s read my post on “Software Interrupts”). If you are assigned a task like designing the On-Board computer system for a satellite like me go for the Embedded Assembler. If you are making an ATM machine then do not go for Embedded Assemblers, in fact for a system like that i prefer to have no nesting.
In lay mans term, If you have a project which involves multiple developers and 3rd party developers write a System IRQ routine (Software Interrupt) else use this simple embedded assembler.

Kashmiri style Tangra Masala

2013-09-29T16:37:00.000+05:30

Sometime I like to cook non-everyday food by myself.Kept my wife aside and cooked the Tangra masala.Pros was that I got appreciation from her,but cons was she want me cook the tangra fish always whenever possible. :(

Recipe is as follows.
Ingredients :
Tangra Fish
Mustard oil
Onions - finely chopped
Green chilies - Slit lengthwise from the middle
Ginger-Garlic paste
Coriander leaves
Tomato - Finely chopped
Cumin, Coriander, Red-chilly and Garam-Masala powder
Posto seed (Poppy Seeds) OR Suji (Semolina) - whole, not paste
Groundnut - paste
Salt and sugar to taste

Method :
Heat mustard oil in a pan, fry the fishes with turmeric powder and salt. Keep aside the fried fishes and add the finely chopped onions, tomatoes, ginger-garlic paste into the heated oil. Mix sugar (optional). Once golden-brown, add to it the green-chillies, cumin-coriander-red chilly powders also salt (save the garam-masala powder till the end) followed by the groundnut paste, coriander leaves. Fry till you get the aroma coming.Add the fish and mix the gravy.add some water.Next sprinkle the posto/suji. Fry a little more and then mix water(very little). Simmer for another 5 mins and add the garam-masala powder before switching off the burner. You are done.

Taken from here.

Airtel Digital tv remote factory reset and reprogram

2013-02-03T01:10:00.001+05:30

Following is the way to reset Airtel Digial tv universal remote reset procedure.

1. Press red button and ok button together untill red light blinks twice.2. Release the buttons and press 980 buttons one by one (not together)
3. Red light will blink again two times, now press ok button.

Reprogramming

There are 5 basic functions which your new Airtel remote needs to learn about your TV
1. TV Power code
2. TV Mute code
3. AV code
4. TV VOL + code
5. TV VOL – code

Steps for Universal remote setup:

Step 1: Bring Airtel digital TV remote in learning mode. Press and hold ‘’OK + Numeric 2” key for 3 seconds. The LED blinks twice to indicate that your Airtel remote is ready to learn.

Step 2 : Hold the source remote and Airtel remote in front of each other ( 3cm-6m apart).

Step 3: Press & release the key (First on Airtel remote and then on Source remote) which needs to be programmed in Airtel remote.
Example: Press and release the TV Power key on both remotes and release. The Airtel remote blinks twice to indicate a successful learning of ‘TV power code’.

Step 4: Now Press & release other keys ( on both remotes simultaneously) : Mute , AV, Vol +/-.

Step 5: Press "OK" on Airtel remote to store the new information about your TV. The LED will blink twice to indicate successful transfer to knowledge from your current TV remote to the new Airtel remote.

If the Airtel remote blinks four times, it means the learning failed. Go to Step 1 again

Priority Inheritance in Linux Kernel

2013-01-23T17:37:00.001+05:30

According to LWN.net

There are a number of approaches to priority inheritance. In effect, the kernel performs a very simple form of it by not allowing kernel code to be preempted while holding a spinlock. In some systems, each lock has a priority associated with it; whenever a process takes a lock, its priority is raised to the lock's priority. In others, a high-priority process will have its priority "inherited" by another process which holds a needed lock. Most priority inheritance schemes have shown a tendency to complicate and slow down the locking code, and they can be used to paper over poor application designs. So they are unpopular in many circles. Linus was reasonably clear about how he felt on the subject last December:

"Friends don't let friends use priority inheritance".

Just don't do it. If you really need it, your system is broken anyway.

Faced with this sort of opposition, many developers would quietly shelve their priority inheritance designs and go back to working on accounting code. The kernel development community, however, happens to have a member who has a track record of getting code merged in spite of this sort of objection: Ingo Molnar. History may well repeat itself, as Ingo (working with Thomas Gleixner) has posted a priority-inheriting futex implementation with a request that it be merged into the mainline. This approach, says Ingo, provides a useful functionality to user space (it is not meant to provide priority-inheriting kernel mutual exclusion primitives) while avoiding the pitfalls which have hit other implementations.

Taken from ..

http://lwn.net/Articles/178253/

BFS vs CFS

2012-10-15T22:41:00.001+05:30

http://forum.cyanogenmod.com/topic/18575-cfs-vs-bfs-kernel-scheduler/

Why Japan attacked Perl harbour

2012-09-18T11:38:00.001+05:30

While reading about Sino-japan war.I found Japan was almost winning.Suddenly it attacked Perl Harbor.I could not find the motive.What Google search gave a result with details explanation.

http://wiki.answers.com/Q/Why_did_the_Japanese_attack_Pearl_Harbor

Linux boot seqence in short

2012-09-15T18:55:00.000+05:30

This the following minimum boot sequence

1) Bootloader loads the Kernel image to Ram
The image may be compressed or uncompressed.Uboot uses a special header in added to the kernel image and make it as uImage. Using mkimage we can make the image zImage/vmLinux

2) Ramdisk loaded in the memory, bootloader do that.

3) Control is given to kernel ,it also provides kernel arguments/command line options.Also bootlader set ramdisk as rootfs.

Initial Rootfs filesystem may be of ext2 or minix format.

initramfs is the file can be unpacked by kerne l of following formats ..gzip, bzip2, LZMA, XZ and LZO.

3) Then "linuxrc" ran from initial ramdisk.

4) The root device is changed to that specified in the kernel parameter.

5) The init program /etc/init is run which will perform the user configurable boot sequence. if rdinit is used then specified binary is called.

qemu-system-arm -M versatilepb -m 128M -kernel linux-3.5.3/arch/arm/boot/uImage -initrd rootfs3.img.gz -append "rdinit=/sbin/init"

That means roofs is rootfs3.img.gz and run /sbin/init from mounted rootfs.In this command we run the uImage kernel on qemu arm emulator which is emulation versatilepb arm architechture.

Difference of Compilers arm-none-linux-gnueabi and arm-none-eabi

2012-09-11T21:23:00.001+05:30

I was confused between arm-none-linux-gnueabi and arm-none-eabi .I didn't know where to use what.

The gcc naming convention is like as below
arch-vendor-(os-)-eabi

so for arm-none-linux-gnueabi is meant for the compilation to elf which uses linux.
and arm-none-eabi is meant for the compilation of the codes which will run on bare metal arm core.

The difference is that they use library accordingly to compile the source codes.

Oracle Virtual box upgradation issue

2012-09-04T18:25:00.001+05:30

I recently tried to run Xubuntu 12.04 on virtualbox 1.2.0.It was working fine.Then due to some bug in my head :) tried to upgrade virtualbox to VirtualBox-4.2.0_RC3 from here.

Now without uninstalling the previous version I installed it.It created problem.While running any Vms after installing extension pack it gave error [" failed to load vmmr0.r0 (verr_ldr_mismatch_native)"].

This issue is intially I couldn't solve.Later I solved the issue as following.
Remove virtualBox ,remove folders from Program Files then removing "C:\Users\USERNAME\AppData\Local\VirtualStore\Program Files\Oracle\VirtualBox" {Need administrative privilege}

Now install VBox freshly and import the virtual image projects/Disks.

Small Makefile tutorial

2012-09-01T12:41:00.001+05:30

This Makefile tutorial by Alex is small but very useful.

http://www.cprogramming.com/tutorial/makefiles_continued.html

Sysfs or procfs

2012-08-28T22:03:00.001+05:30

I became confused about the utilization of procfs and sysfs.Which one will be used in which place?

What I understand as below.

Procfs is much more generic interface to provide information to user space.All the process related information and some parameters are also passed to user space through profs file system,

Whereas Sysfs is much more modern implementation like procfs.But it is implemented by following Linux driver model and hierarchy.Sysfs stores driver,device information alongside of process information too.As Greg KH told "sysfs is "1 value per file"" . so can be used for full user level driver implementation.

Sysfs can do all the work like procfs ,they normally not used as information interface of process.Procfs will be there holding the process in formations.

Update 23/10/2013: Sysfs is extensively used by udev. Whenever any sysfs file node is created udev get event and creates device files according to major and minor no it revived.I'll discuss it in detail in some later post.

My Comparison of Galaxy S2 and HTC Sensetion

2012-04-13T22:16:00.003+05:30

Suddenly feeling to take one android phone after my tab crashed and bored with my 900rupee samsung guru.Though Guru is very good but feeling calender, camera reminder video calls are very necessary for me. Doing little bit of research about the feature and performances between the HTC sensetion and Samsung Galaxy S2 .Seems like S2 is obvious winner.Though I like HTC outer look very much.The UI is also very good.I used HTC touch phone for very long time so I am very fond of HTC.But as campared by different user HTC has almost double battery life,fron cam is 2.0M ,weight is less and Samsung given S2 to hackers for making custom ROMs.Last thing is very necessary I feel .I like my own ROM don't want to take anything,, though after sometime only I may use it , if and only if I buy S2..

Here are some good comparisons between the smart phones.

HTC Sensation vs Samsung Galaxy S II

HTC Sensation vs Samsung Galaxy S2

My tab is out of service..

2012-04-13T22:04:00.000+05:30

I had rooted my Spice Mi-720 tab long time back.There is no custom rom .But tried to clean up some systems file with root privileged. As usual I crashed it. :( . System is hanging on the splash screen only..
Try myself first else have to go to service center.Probably it's time to hack android in little bit further.

Samsung tab vs IPAD2

2012-04-13T22:00:00.001+05:30

Nabendu's Blog

Linux process Id's

SMD component Cheatsheet by NXP

How malloc works in userspace

Process Virtual to Physical Translation

Allocating aligned address and freeing them

Tracking Linux kworker threads

Bit reversing tips

Nice value and priority and relations

Forked process, thread and address spaces little deeper

Global variable ,static always initialized but auto is not initialized

Speed of execution in term of code in some cases

Is “else if” faster than “switch() case”?

Why i++ is faster than i=i+1 in c

ARM Nesting of Interrupts

NESTING INTERRUPTS

Answer

QUESTION

ANSWER

Software Interrupt approach:

Assembly Routine:

AdvantagesSystem IRQ Approach

Embedded Assembler Approach

DrawbacksSystem IRQ Approach

Embedded Assembler Approach

Choosing the right approach for your application:

Kashmiri style Tangra Masala

Airtel Digital tv remote factory reset and reprogram

Priority Inheritance in Linux Kernel

BFS vs CFS

Why Japan attacked Perl harbour

Linux boot seqence in short

Difference of Compilers arm-none-linux-gnueabi and arm-none-eabi

Oracle Virtual box upgradation issue

Small Makefile tutorial

Sysfs or procfs

My Comparison of Galaxy S2 and HTC Sensetion

My tab is out of service..

Samsung tab vs IPAD2

Advantages
System IRQ Approach

Drawbacks
System IRQ Approach