C Questions

All about volatile variable in C

2017-12-18T20:55:00.000-08:00

What is volatile keyword in C?
volatile is a data type qualifier in C.

Role of volatile variable in signal handler?
When a variable is declared as volatile, the C compiler does not optimize the code where this variable involves.

It also means that someone might externally change the value of this variable over time, hence do not cache the value of this variable.

In case of interrupt handlers or signal handlers where the counter is dependent is on the incoming data, this counter variables value changes due to external factors like arrival of new data on the port. Hence even though the program did not modified the data, the value of this counter variable changed. Such variable should be declared as volatile variable, so that the C compiler does not optimize the usage of this variable and hence does not pick up the value from the cache.

Logical & and addition

2017-12-18T18:15:00.001-08:00

What is going to be the output of this code?

1 #include

2 int main(void)

3 {

4 int a=10, b=12;

5 int c;

6 c = a&b + 65;

7 printf("c=%d\n", c);

This code looks simple enough. Guess??

const behavior of a variable in C Programming Language

2017-12-15T08:46:00.001-08:00

When you intend to not change the value of a variable you declare it as a const in C language.

#include <stdio.h>
int c1()
{
  int *a;
  const int b;

  a=&amp;b;

  printf("*a=%d, b=%d\n",*a, b);
  
  *a = *a + 1;
  //b = b + 1; 

  printf("*a=%d, b=%d\n", *a, b);

//return ;
}

main()
{       
        printf("C=%d\n", c1());
}

If you execute

b = b + 1:

then the compiler complains:

c1.c:12:5: error: cannot assign to variable 'b' with const-qualified type 'const int'

b = b + 1;

~ ^

c1.c:5:13: note: variable 'b' declared const here

const int b;

~~~~~~~~~~^

That's what is expected.

But if we declare a pointer variable and that points to the const variable, and you increment the "value" of what the pointer variable is pointing to, then the compiler does not complain. Why?

Using only

*a = *a + 1;

actually increments the value of b because it's same as *a.

Let's change the program slightly:

#include <stdio.h>
int c1()
{
  int *a;
  const int b;

  a=&b;

  printf("*a=%d, b=%d\n",*a, b);
  
  *a = *a + 1;
  //b = b + 1; 

  printf("*a=%d, b=%d\n", *a, b);

//return ;
}

main()
{       
        printf("C=%d\n", c1());

}

This time the compiler gives an error.

s1.c:11:6: error: read-only variable is not assignable

*a = *a + 1;

~~ ^

So, the rational is if you use the const identifier, then you can't update it's value.

Static variable behavior

2017-12-15T07:12:00.002-08:00

How the static variable behaves?

#include

//int s1();

int s1()

{

static int s;

return s++;

}

main()

{

int i=1;

while (i<=2)

{

i++;

printf("S=%d\n", s1());

}

Simple program. But here's the trick.

s is a static variable.

return s++;

the post increment is done as if:

return s;

s = s + 1;

So, when the first time s1() prints, it prints the value of s = 0, s being a static variable it's initialized to 0. But the first time s1() returns before it's being incremented. The next statement of course executes, and s is incremented. Since it's a static variable, it's not in the call stack, hence it's got incremented after the s1() function returns, but before the function actually exits.

As per Wikipedia:

When the program (executable or library) is loaded into memory, static variables are stored in the data segment of the program's address space (if initialized), or the BSS segment (if uninitialized), and are stored in corresponding sections of object files prior to loading.

As per this 1995 Linux Journal article: http://www.linuxjournal.com/article/1059
Executable code is always placed in a section known as .text; all data variables initialized by the user are placed in a section known as .data; and uninitialized data is placed in a section known as .bss.

Hence the static variable actually increments.

New Technology Blog

2016-07-15T12:39:00.002-07:00

http://0x80386.blogspot.com/
-- Introducing my new technology blog on Cloud Computing.

Let's run a c program by hand

2015-08-12T23:32:00.000-07:00

Let’s compile a C program by hand. The aim is to compile the a.c program.

$cat a.h
#define AA 100
$cat a.c
#include “a.h”
main()
{
            printf(“%d apples”, AA);
            exit(19);
}
$

So, this is the program we really wanted to compile.
$gcc a.c –o a.exe
$./a.exe
100 apples$
$

To know what’s happening behind the scene, do this:
[kongkon@cadbury ~]$ gcc -v a.c
Reading specs from /usr/lib/gcc/i386-redhat-linux/3.4.3/specs
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --enable-shared --enable-threads=posix --disable-checking --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-java-awt=gtk --host=i386-redhat-linux
Thread model: posix
gcc version 3.4.3 20050227 (Red Hat 3.4.3-22.1)
/usr/libexec/gcc/i386-redhat-linux/3.4.3/cc1 -quiet -v a.c -quiet -dumpbase a.c -auxbase a -version -o /tmp/ccfWiYm9.s
ignoring nonexistent directory "/usr/lib/gcc/i386-redhat-linux/3.4.3/../../../../i386-redhat-linux/include"
#include "..." search starts here:
#include <...> search starts here:
/usr/local/include
/usr/lib/gcc/i386-redhat-linux/3.4.3/include
/usr/include
End of search list.
GNU C version 3.4.3 20050227 (Red Hat 3.4.3-22.1) (i386-redhat-linux)
compiled by GNU C version 3.4.3 20050227 (Red Hat 3.4.3-22.1).
GGC heuristics: --param ggc-min-expand=98 --param ggc-min-heapsize=128313
as -V -Qy -o /tmp/ccyJwUTb.o /tmp/ccfWiYm9.s
GNU assembler version 2.15.92.0.2 (i386-redhat-linux) using BFD version 2.15.92.0.2 20040927
/usr/libexec/gcc/i386-redhat-linux/3.4.3/collect2 --eh-frame-hdr -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 /usr/lib/gcc/i386-redhat-linux/3.4.3/../../../crt1.o /usr/lib/gcc/i386-redhat-linux/3.4.3/../../../crti.o /usr/lib/gcc/i386-redhat-linux/3.4.3/crtbegin.o -L/usr/lib/gcc/i386-redhat-linux/3.4.3 -L/usr/lib/gcc                                                                /i386-redhat-linux/3.4.3 -L/usr/lib/gcc/i386-redhat-linux/3.4.3/../../.. /tmp/cc yJwUTb.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s                                                                              --no-as-needed /usr/lib/gcc/i386-redhat-linux/3.4.3/crtend.o /usr/lib/gcc/i386-redhat-linux/3.4.3/../../../crtn.o
[kongkon@cadbury ~]$
Understood? It’s really hard to understand. Let me explain a little, and then things will look simpler. The –v switch to gcc explains what gcc has done with the compilation process. Now, first of all what is gcc? gcc is the compiler like everyone would say. Yes, it is the compiler. Actually it is a wrapper, which calls different programs to compile the C program: if you look at the –v output more closely you will see that, gcc calls "cpp", the C preprocessor first, then "cc1", the C compiler, and then "as", the assembler. As an output we get the object file, the same what we get by running “gcc –c a.c”. Here we take help of the linker, "ld", to link a.o with our library for printf, since we have not written code of printf() of our own. We need to link our a.o with libc.so for printf code, as specified by -lc. This outputs a.exe, out executable. Run this, and enjoy 100 apples.

Let’s do every thing by hand. Let’s call all of them one by one. First the C preprocessor, cpp.
[kongkon@cadbury ~]$ cpp a.c
# 1 "a.c"
# 1 ""
# 1 ""
# 1 "a.c"
# 1 "a.h" 1
# 2 "a.c" 2
main()
{
printf("%d apples",100);
exit(19);
}
[kongkon@cadbury ~]$
cpp by default dumps the output in the console, redirect it to a file, call it a.i.
[kongkon@cadbury ~]$ cpp a.c -o a.i
[kongkon@cadbury ~]$
[kongkon@cadbury ~]$ ls a.*
a.c a.h a.i
[kongkon@cadbury ~]$

Next is the C compiler, cc1.
[kongkon@cadbury ~]$ cc1 a.i
-bash: cc1: command not found
[kongkon@cadbury ~]$
Oops! Bash did not find cc1, he does not know where is cc1. Take the help of gcc itself to find where cc1 is. Do this:
[kongkon@cadbury ~]$ gcc -print-prog-name=cc1
/usr/libexec/gcc/i386-redhat-linux/3.4.3/cc1
[kongkon@cadbury ~]$
Next, compile a.i, not a.c.
[kongkon@cadbury ~]$ /usr/libexec/gcc/i386-redhat-linux/3.4.3/cc1 a.i
main

Execution times (seconds)
parser                :   0.01 (100%) usr   0.00 ( 0%) sys   0.00 ( 0%) wall
TOTAL                 :   0.01             0.00             0.01
[kongkon@cadbury ~]$
[kongkon@cadbury ~]$ ls a.*
a.c a.h a.i a.s
This produces a.s.
Now, call the assembler, to create the object file, a.o.
[kongkon@cadbury ~]$ as a.s -o a.o
So, we have the object file here, a.o.
[kongkon@cadbury ~]$ ls a.*
a.c a.h a.i a.o a.s
[kongkon@cadbury ~]$
Now, call the linker program, ld.
[kongkon@cadbury ~]$ ld -o a.exe a.o -e main -lc -dynamic-linker /lib/ld-linux.so.2
[kongkon@cadbury ~]$ ls a.*
a.c a.exe a.h a.i a.o a.s
[kongkon@cadbury ~]$
So, here we have the executable binary a.exe.
Run this and you will see the same output as we did in our first step.
[kongkon@cadbury ~]$ ./a.exe
100 apples[kongkon@cadbury ~]$
Check whether the program exited successfully.
kongkon@cadbury ~]$ echo $?
19
[kongkon@cadbury ~]$

So, we have successfully compiler a C program. Happy programming.

The thread ends here.

rpm spec file magic

2014-12-03T13:01:00.000-08:00

In Unix flavored Operating Systems various software packages are packaged along with the source file in the form of an rpm package. The rpm package contains the source rpm and the binary rpm, along with optional other dependent tools rpm packages that is needed for the main binary rpm to work. In earlier days it was achieved in the form of an tarball, which contains the configure script. The configure scripts calls the Makefile to build the final binary package that's finally ready to installed on that platform.

Here I plan to discuss some of the tricks I have learned in the rpm spec file.
The spec file contains various sections:
a) %description
b) %prep
c) %build
d) %install
e) %files
f) %package ## This is optional section
g) %clean
h) %changelog

Some of these sections are self explanatory, like the %description, %clean and %changelog section. The most interesting things happen in the %build, %install and %files section.
In the %build and %install section you can write anything that you can write in a bash script, they understand the bash syntax and executes them.
The %files section however does not understand the bash scripting language, and only understand the rpm macros.
If you want to include addition packages in the same package.spec.in file, then the %package section comes handy, and you include a %package section for each additional rpm package you intend to produce.

The basic structure goes like this:
# This is a comment
Name:          my-package
Version:        1.0
Release:        %RPM_RELTAG%
Summary:     my package update release
Source:         %RPM_SOURCE%
License:        License info
Vendor:         The source code belong to
Packager:      The repackaging is done by
Group:          System Environment/Libraries
Requires:       my-package-tools
BuildRequires: coreutils                  ##dependent packages needed to build this package

%description
This provides the my package which is very important for everyone.

%define debug_package %{nil}
## This is how you define a local variable (called prefix)
%define prefix /lib/firmware/important/

%define MY_FILE_LIST %{expand:%( \
FW="" \
FW+=" a.bin" \    ## a file
FW+=" b.bin" \     ## b file
FW+=" c.bin"        ##c file
##FW+=" c1.bin" \   ##c1 file
FW+=" d.bin"        ##d file
FW+=" e.bin"    ##e file
FW+=" f.bin"    ## f file
echo $FW \
)}

%global flist() %{expand:%( \
files="%*" \
if [ -n "%{?1}" ] ; then \
for pkg in $files \
do \
echo "%%{prefix}/$pkg" \
done \
fi \
)}

%prep
%setup -n src

## The % build section is also common between the base rpm package and additional (tools) rpm package

%build
RM=rm
MD5SUM=/usr/bin/md5sum
## md5sum is part of coreutils, hence it's mentioned in the BuildRequires

cd fw/
${RM} -fr checksum.txt

for FW in %{MY_FILE_LIST}; do \
        echo ${FW}; \
        ${MD5SUM} ${FW} >> checksum.txt; \
done

%install
install -d ${RPM_BUILD_ROOT}%{prefix}/
cd fw/

## This will install all the a.bin, b.bin etc files into the right place, no need list one by one
for FW in %{MY_FILE_LIST}; do \
        install ${FW} ${RPM_BUILD_ROOT}%{prefix};
done
install checksum.txt ${RPM_BUILD_ROOT}%{prefix}

## The tools rpm that this spec file produces installs the my_special_tool as part of it, and
## the % install section is common for both the base package and the addition (tools) package
# Install Tools files
install -d ${RPM_BUILD_ROOT}%{prefix}
cd ../tools
install -m 0755 -D my_special_tool ${RPM_BUILD_ROOT}%{prefix}

%files
%defattr(0664,root,root)
## This is the magic
% flist %MY_FILE_LIST
## Otherwise you have to install each individual file separately like
#% {prefix}/a.bin
#% {prefix}/b.bin
#etc

## Now comes information about the additional package
##
## Tools package
##

%package tools
Summary:        %{name} deployment tools
Group:          System Environment/Base
Requires:       special-tools >= 1.4-5

%description tools
This package provides the special deployment tool for the my software.

%files tools
%defattr(-,root,root,-)
%attr(700,root,root) %{prefix}/my_special_tool
%doc %{_mandir}/man8/my_special_tool.8.gz

%clean
rm -rf ${RPM_BUILD_ROOT}

%changelog
* Wed Dec 03 2014 Kongkon Jyoti Dutta
        - ABC-123 Releasing my special tool to the world

How to update the drive firmware in Linux

2014-06-10T12:40:00.000-07:00

echo "Using firmware file $fwfile for upgrading $product on device $x…"

The process to download in Solid State Drive and Hard Disk Drive is a little different. In case of SDD we can burn the firmware in one command, but in case of HDD we need to write in a loop since there is a limitation of 0x80000 bytes on VFS module system call.

if [ "$rev" != "$target_fw_ver" ]; then

echo "Upgrading $disk_type firmware to version $target_fw_ver on $x i.e.$sg_dev..."

if [ "$disk_type" = "ssd" ]; then

sg_write_buffer --in=${fwfile} --mode=5 --id=0 $sg_dev

if [ $? -ne 0 ]; then

echo "Failed to upgrade SSD firmware on $x i.e.$sg_dev to version $target_fw_ver!" >&2

exit 1

else

# hdd firmware upgrade

bytes=`ls -l $fwfile | awk '{ print $5; }'`

start=0

#length = 0x80000 Bytes

length=524288

while [ $start -lt $bytes ]; do

if let 'start+length>bytes'; then

let 'length=bytes-start'

sg_write_buffer --in=$fwfile --skip=$start --offset=$start --length=$length --mode=0x7 --id=0 $sg_dev

if [ $? -ne 0 ]; then

echo "Failed to upgrade HDD firmware $x i.e.$sg_dev to version $target_fw_ver!" >&2

exit 1

let start+=length

done

Let's see what you installed

2012-10-31T11:42:00.001-07:00

Google+

To install packages in Linux:
Packages can be installed using yum, or rpm. Each one has it's own internal database that list what is already installed into the system.

To install a package using yum:
#yum install

To install a package using rpm:
#rpm -ivh
#rpm -Uvh

To check what is already installed:

To check what is yum installed:
#yum list | grep

To check what is rpm installed:
#rpm -qa | grep

HTH
--kongkon

How to grep in shell script...

2012-10-23T18:00:00.000-07:00

The task is there is a file containing one column of entries. Write a script to compare the o/p of one command and check whether the output matches with any row of that file (supported.txt file).

$cat supported.txt
SAS2308_2(C1)
SAS2308_2(D1)

Assume $devInfo gives us a string that contains like the rows of support.txt file. If there is a match between the o/p of $devInfo in that file, then do nothing, else warn.

checkSupportedFwDev() {
local supportedControllerList=`cat supported.txt`
#Get the controller name from $devInfo and compare that with $supportedControllerList
local currentController=`echo "${devInfo}" | grep "Controller" |grep -v Number | awk '{ print $NF }'`
#echo "currentController=[$currentController]"
local supported=`echo "${supportedControllerList}" | grep $currentController`
if [ -z ${supported} ]
then
echo "Warning: This adapter [${currentController}] is not officially supported."
fi
}

Another approach to do the same:

checkSupportedFwDev() {
#Get the controller name from $devInfo and compare that with $supportedControllerList
local currentController=`echo "${devInfo}" | grep "Controller" |grep -v Number | awk '{ print $NF }'`

if ! grep "^${currentController}\$" supported.txt >/dev/null 2>&1;
then
echo "Warning: This adapter [${currentController}] is not officially supported."
fi

}

Which approach you like and why?

Vi tricks

2012-10-12T11:17:00.000-07:00

How to set the line numbers into vi editor?
Everyone knows this:
a) cd
-- go to home directory
b) edit(create if not there) a file called .exrc, and all this line
set nu
or set number
Simple.

But, what I al now looking at is how to set the vi line numbering in only a special work directory, say /home/kdutta/mywork. I do not want to set vi line numbering to all directories, at times this is annoying.
Putting a .exrc file into /home/kdutta/mywork/.exrc does not seem to work, here, even if I source it.

Do you know, how to do that?

Difference between $variable and ${variable} in (bash) shell scripting

2012-09-27T17:28:00.000-07:00

Many often we do shell scripting, but small small ignorance at times cost a lot. Here is an example of what we mean and what it become.
[/tmp]$ cat try.sh #! /bin/sh a=12 b=34 echo $a_$b echo ${a}_$b [vivarkey@/tmp]$ sh try.sh 34 12_34 [/tmp]$

In the above shell script we intended to print "variableA_variableB", in the shell script on last but one line. But since we missed the braces around the variable it actually truncated the previous variable along with the '-' symbol.

NB: This code snippet is tried in bash shell on Linux, on mac it gives different result.

HTH
Kongkon

Playing with RPM

2012-09-27T12:52:00.000-07:00

Ever wondered after running the rpm --install (or rpm -ivh) command what happened, what sort of files created in the file system.

To find out the list of files that an already installed rpm spawned:
rpm -ql
NB: there is no .rpm after the package name here in this command.

[root@localhost release]# rpm -qa|grep lsifw-tools-xrtx
lsifw-tools-xrtx-1-1.xrtx.1872.noarch
[root@localhost release]# rpm -ql lsifw-tools-xrtx-1-1.xrtx.1872.noarch
/lib/firmware/lsi/.NOT_RELEASE_DIR
/lib/firmware/lsi/FirmwareID.sh
/lib/firmware/lsi/xrtx_lsifw.sh
/usr/share/man/man8/xrtx_lsifw.8.gz
[root@localhost release]#

To find out the list of files that an rpm will generate once you install the rpm:
rpm -qlp

[root@localhost tmp]# rpm -qlp /tmp/lsifw-tools-xrtx-1-1.xrtx.1872.src.rpm
lsifw-tools-xrtx-source.spec
lsifw-tools-xrtx.tgz
[root@localhost tmp]#

HTH
Kongkon

C++ Library Problem

2012-06-18T17:40:00.000-07:00

Google+

C++ Library Problem

You have a library provided by the vendor. All you have is header files and library files. Library contains the class "Shape" and there is whole hierarchy tree (I mean classes which derive from this base class).

Now you want to add some function "getArea" (not originally present in the class or any of its derived class) in the class "Shape" , you don't have the source code.
Using this library, you have written a lot of code. Now, you have to make some changes so that, any object of "Shape" class (or its derived class) will be able to call this function.

With your strategy, you should be able to override the definition of this function in the derived class.

http://www.careercup.com/question?id=13872673

A simple C program

2011-12-14T18:11:00.001-08:00

Let's talk about simplicity. And let's look at a simple C program today. Why not, every day we deal with complex problem, so let's talk about a simple C program now. Here is the program;

main()

{

char *p1="name";

char *p2;

p2=(char*)malloc(20);

memset (p2, 0, 20);

while(*p2++ = *p1++);

printf("%s\n", p2);

}

Well, what does this program do. This is the topic of today's blog.

Ans:

Looks like this program output's the string name , but that's not true.

What do you think about this program?

Write your comments about it.

All about C++ templates

2011-11-24T07:12:00.028-08:00

Templates in C++ can be of class template or function template.
A template is used as a mechanism to generalize the parameter type we pass to either the class or function. This extends the function overloading concept of C++. Template takes the C++ concept of polymorphism to the next level.

Here is a example of function templates:
Let's say we have a swap function that swaps two variables of type T.

void f(int a, int b, float m, float n)
{
    swap(a, b);      //swap two integer values
    swap(m, n);      //swaps two float values
}

We can write a template function to do this as below:

template <class T>
void swap (T &x, T &y)
{
    T temp = x;
    x = y;
    y = T;
}

Similarly we have class template where we can pass any type of parameter using the template T.

template < class T>
class vector
{
     T *v; //type T vector, T can be int, float, anything
     int size;
   public:
     vector (int m)
     {
     v = new T[size = m]; // v is an array of type T
     //initialize the array
       for (int i = 0; i < size; i++)
         v[i] = 0;
    }

}

This is an example of a class vector which initialize an object of type T of array. Invoke it this way:
     vector < int> v1(10);    //a vector class of int
     vector < float> v2(20);    //a vector class of float

Q1. Find the o/p of the code snippet:
template < class T, int l=7> class Foo {
     static const T k = l;
     int q;

   public:
     Foo(int x = l) : q(x)
     { }
     T GetQ() const { return q; }
}

void f() {
     Foo < long, 9> foo(10);
     std :: cout << foo.GetQ();

}

Ans:
Explaination:
Default values for template parameters

Template parameters may have default values, and when instantiating the template these values can be omitted. Here’s an example:

template <typename T=int, int N=10>
class Foo {
};

Foo<float, 42> foo1;
Foo<double> foo2;
Foo<> foo3;

Note specifically the strange syntax for the definition of foo3, which means that it instantiates the Foo template with all parameters assigned their default values. Default values may only be specified for class templates.

Q2. What is STL?
Ans: STL is the C++ Standard Template Library. Instead of writing your own, you can use templates from STL just like other library functions that we use from any other C/C++ library. It is a collections of class templates and function templates. We sahould use template library as it is bug free rather than writing our own like inventing the wheel again.

In tehnical terms:
The Standard Template Libraries (STL's) are a set of C++ template classes to provide common programming data structures and functions such as doubly linked lists (list), paired arrays (map), expandable arrays (vector), large string storage and manipulation (rope), etc. The STL library is available from the STL home page. This is also your best detailed reference for all of the STL class functions available. STL can be categorized into the following groupings:

Here is the greatest post about C++ Templates:
http://eli.thegreenplace.net/2011/04/22/c-template-syntax-patterns/

Q3. What is partial specialization or template specialization?

Q4. How can you force instantiation of a template?

Q5. What is an iterator?

Q6. What is an algorithm (in terms of the STL/C++ standard library)?

2011-10-22T03:23:00.001-07:00

Hello World!

How about compiling a C programming right from the browser itself.
Here it is:

Best C/C++/Data Structure Programming books

2011-10-22T00:35:00.005-07:00

C/C++ Programming Questions This blog is for C/C++ Programming

Here is my collection of some of the best Programming books.

No 1 has to be this:

Then comes the rest of them.
When it comes to data structure there is a book written in simple English, very easy to comprehend the basic fundamentals of computer science.

There are couple of C++ books. But I find this to be the best:

C++
How to Program by Deitel and Deitel

And here a list of best Linux programming books:
a) Linux Kernel

b) Linux Device Driver Programming

Enjoy, happy reading.

Regards,
Kongkon

Free Linux Machine with C compiler

2011-10-21T23:45:00.003-07:00

Hello World!
Many of us wanted their own Linux machine to do some C programming or at least to get a feel of the Linux Operating System.

Here is a Linux machine which can be accessible over the internet free of cost only for you :-).

Just type the following URL in the browser and here you are in your own Linux machine:

http://bellard.org/jslinux/

This is an amaizing work by Bellard. There is also a clipboard facility to copy/paste your work back and forth between your local system and the Linux machine.

Copy your file to the clipboard:

cat myfile > /dev/clipboard

Explore this machine, and I am sure you will have lots of fun. The best part is that there is a C Compiler to test your own C programs.
It's a tiny version of a C compiler called "tcc".

To have a deep dive into the booting process of this OS, look at the booting sequence:

Linux version 2.6.20 (bellard@voyager) (gcc version 3.4.6 20060404 (Red Hat 3.4.6-9)) #2 Mon Aug 8 23:51:02 CEST 2011

BIOS-provided physical RAM map:

sanitize start

sanitize bail 0

 BIOS-e801: 0000000000000000 - 000000000009f000 (usable)

 BIOS-e801: 0000000000100000 - 0000000001000000 (usable)

16MB LOWMEM available.

Entering add_active_range(0, 0, 4096) 0 entries of 256 used

Zone PFN ranges:

  DMA             0 ->     4096

  Normal       4096 ->     4096

early_node_map[1] active PFN ranges

    0:        0 ->     4096

On node 0 totalpages: 4096

  DMA zone: 32 pages used for memmap

  DMA zone: 0 pages reserved

  DMA zone: 4064 pages, LIFO batch:0

  Normal zone: 0 pages used for memmap

DMI not present or invalid.

Allocating PCI resources starting at 10000000 (gap: 01000000:ff000000)

Detected 3.333 MHz processor.

Built 1 zonelists.  Total pages: 4064

Kernel command line: console=ttyS0 root=/dev/ram0 rw init=/sbin/init notsc=1

Initializing CPU#0

Disabling TSC...

PID hash table entries: 64 (order: 6, 256 bytes)

Console: colour dummy device 80x25

Dentry cache hash table entries: 2048 (order: 1, 8192 bytes)

Inode-cache hash table entries: 1024 (order: 0, 4096 bytes)

Memory: 11956k/16384k available (1265k kernel code, 4040k reserved, 324k data, 124k init, 0k highmem)

virtual kernel memory layout:

    fixmap  : 0xffffc000 - 0xfffff000   (  12 kB)

    vmalloc : 0xc1800000 - 0xffffa000   ( 999 MB)

    lowmem  : 0xc0000000 - 0xc1000000   (  16 MB)

      .init : 0xc0290000 - 0xc02af000   ( 124 kB)

      .data : 0xc023c503 - 0xc028d854   ( 324 kB)

      .text : 0xc0100000 - 0xc023c503   (1265 kB)

Checking if this processor honours the WP bit even in supervisor mode... Ok.

Calibrating delay using timer specific routine.. 20.22 BogoMIPS (lpj=101116)

Mount-cache hash table entries: 512

CPU: After generic identify, caps: 00000010 00000000 00000000 00000000 00000000 00000000 00000000

Intel Pentium with F0 0F bug - workaround enabled.

CPU: After all inits, caps: 00000000 00000000 00000000 00000000 00000000 00000000 00000000

Compat vDSO mapped to ffffe000.

CPU: Intel Pentium MMX stepping 03

Checking 'hlt' instruction... OK.

NET: Registered protocol family 16

Setting up standard PCI resources

NET: Registered protocol family 2

IP route cache hash table entries: 1024 (order: 0, 4096 bytes)

TCP established hash table entries: 1024 (order: 0, 4096 bytes)

TCP bind hash table entries: 512 (order: -1, 2048 bytes)

TCP: Hash tables configured (established 1024 bind 512)

TCP reno registered

checking if image is initramfs...it isn't (bad gzip magic numbers); looks like an initrd

Freeing initrd memory: 2048k freed

Total HugeTLB memory allocated, 0

io scheduler noop registered

io scheduler anticipatory registered

io scheduler deadline registered

io scheduler cfq registered (default)

Real Time Clock Driver v1.12ac

JS clipboard: I/O at 0x03c0

Serial: 8250/16550 driver $Revision: 1.90 $ 4 ports, IRQ sharing disabled

serial8250: ttyS0 at I/O 0x3f8 (irq = 4) is a 16450

RAMDISK driver initialized: 16 RAM disks of 4096K size 1024 blocksize

loop: loaded (max 8 devices)

TCP cubic registered

NET: Registered protocol family 1

NET: Registered protocol family 17

Using IPI Shortcut mode

Time: pit clocksource has been installed.

RAMDISK: ext2 filesystem found at block 0

RAMDISK: Loading 2048KiB [1 disk] into ram disk... | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ | / - \ done.

EXT2-fs warning: maximal mount count reached, running e2fsck is recommended

VFS: Mounted root (ext2 filesystem).

Freeing unused kernel memory: 124k freed

Enjoy this. We shall explore more later.

RIP Dennis Ritchie

2011-10-21T21:42:00.001-07:00

Dennis Ritchie

The great Dennis Ritchie, the creator of C Programming Language, the reason behind which this programming blog exist today, died on 12th October 2011, at the age of 70.

Here is a small C program as a tribute to Dennis Ritchie.

main() {

printf("1941: Hello World!\n");

printf("2011: RIP Dennis Ritchie\n");

}

Test your own C Programming skills

2011-05-20T03:30:00.027-07:00

Hello World!

Good morning C programmers. Here is a compilation of couple of C and C++ questions to test your C/C++ programming knowledge. Most of the time you will be facing similar questions in job interviews for Software engineer or programmer not only at the fresher level but also at a very senior level. Many companies expect you to be hands on even at senior level. C is a programming language which is easy and at the same time extremely difficult if asked about complex pointer related questions. So, one has to be extremely careful in answering such questions.

Q1. Find the o/p:
main()
{
char *ptr="hello";
char ary[]="world";

printf("PTR: &ptr=%x, ptr=%x, *ptr=%x, ptr[0]=%x\n", &ptr,ptr, *ptr, ptr[0]);
printf("ARY: &ary=%x,ary=%x, *ary=%x, ary[0]=%x\n", &ary, ary, *ary, ary[0]);
}

Ans:

PTR: &ptr=bfb86990, ptr=8048524, *ptr=68, ptr[0]=68
ARY: &ary=bfb8698a,ary=bfb8698a, *ary=77, ary[0]=77

Q2. Find the o/p:
main()
{
    struct node {
        char a;
        int b;
        short c;
        struct node next;
    }n1;

printf("Ans1:%d\n", sizeof(n1));

return 0;
}

Ans:

This program will not compiler.
Reason: The compiler can't figure out the space needed for the structure n1.
[kongkond@jorhat ~]$ gcc Q2.c
Q2.c: In function ‘main’:
Q2.c:7: error: field ‘next’ has incomplete type

Q3. Find the o/p:
main()
{
    struct node {
        char a;
        int b;
        short c;
        struct node *next;
    }n1;

printf("Ans1:\n\t node=%x\n \t node+2=%x\n", (char *)&n1, (char *)&n1+2);
printf("Ans2:%d\n", sizeof(n1));

return 0;
}
Ans:

Ans1:
node=bfcc5c94
node+2=bfcc5c96
Ans2:16

Q4. What is the difference between fopen() and open()? When do you choose to use one over the other?

Ans:

FILE * fopen(const char *restrict filename, const char *restrict mode);
--Upon successful completion fopen() returns a FILE pointer. Otherwise, NULL is returned and the global variable errno is set to indicate the error.

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
--Given a pathname for a file, open() returns a file descriptor, a small, non-negative integer for use in subsequent system calls (read(2), write(2), lseek(2), fcntl(2), etc.). The file descriptor returned by a successful call will be the lowest-numbered file descriptor not currently open for the process.

Q5. Find the o/p:
main()
{
if(!printf("Hello ")){}
else
printf("World!");
}
Ans:

Hello World!

Q6. Find the o/p:
main()
{
struct i{
int a; //4
double b; //8
char * c; //4
char d[7]; //8
short e; //4
int f; //4
};
printf("sizeof(i)= %d", sizeof(struct i));
}
Ans:

4+8+4+8+4+4=32

Q6.1. Find the o/p:
main()
{
struct i{
int a; //4
double b; //8
char * c; //4
char d[3]; //4
short e; //4
int f; //4
};
printf("sizeof(i)= %d", sizeof(struct i));
}
Ans:

4+8+4+4+4+4=28

Q7. Find the o/p:
# include < stdio.h >
void main()
{
printf(NULL) ;
return ;
}
Ans:

> ./a.out
>

Q8. Find the o/p:
# include < stdio.h >
void main()
{
int i = 0;
printf(i) ;
return ;
}
Ans:

In newer gcc compiler this will not compile. In older ones:
> ./a.out
>

But,
# include < stdio.h >
void main()
{
int i = 0;
printf("%f\n", i) ;
return ;
}

Ans: random number like:
-0.008430

And the result of the following will be like this:
# include < stdio.h >
void main()
{
int i = 0;
printf("%f %d\n", i) ;
return ;
}
Ans:random number like:
-0.008430 134513785

Q9. Find the o/p:
#include <stdio.h>
void main()
{
printf("%s",NULL) ;
return ;
}
Ans:

> ./a.out
(null)

But,
#include <stdio.h>
void main()
{
int i = -10;
printf("%s\n",i) ;
return ;
}
will result in "Segmentation fault" if the value of i is other than zero.

Q10. Find the o/p of this last one:
main()
{
printf("%%",7);
}
Ans:

Try yourself

Q11. How do I declare an array of N pointers to functions returning pointers to functions returning pointers to characters?
Ans:

Well, first you need to know how to declare an array of N items of type T - that's

T foo[N];

Now you need to look at how to declare a pointer to function returning something, say, an object of type S. That's like this:

S (*bar)();

Now assume that S is ``pointer to function returning pointer to char''. We get

(char *) (*)() (*bar)().

So, the whole thing turns out to be (with appropriate parentheses)

(((char)(*))((*)())(((*)((foo)))())([(N)]));

If your compiler complains, break this down into subexpressions.

To call it, just use

foo[i]();

This works because, in C, declaration reflects use, but it's one of those weird distorted mirrors.

Q12. What is asmlinkage and what is it's use?
Ans:

"asmlinkage" is defined, for example, in the header file
"include/asm-i386/linkage.h" as
__attribute__((regparm(0)))
that tells compiler put all function parameters in the stack (i.e.
disables call optimization).
In simple terms, a) you are using assembly code using asmlinkage, and b) all the function parameters are pushed into the stack and optimization is disabled for this purpose.
For more details check this link.

Q13. What is output?
main()
{
printf("%x",-1<<4); }

Ans:

[root@monday kongkon]# gcc 2.c
2.c: In function âmainâ:
2.c:3: warning: incompatible implicit declaration of built-in function âprintfâ
[root@monday kongkon]# ./a.out
fffffff0[root@monday kongkon]#

(1)10=(0000 0000 0000 0001)2
(-1)10=(2's complement of binary 1)=(1's complement of 1 added with 1) =(1111 1111 1111 1110 + 1 )2=(1111 1111 1111 1111)2
Now,
(-1)10 << 4 = (1111 1111 1111 0000)2=(F F F 0)16 Note: In Computer, Negative numbers are represented in 2's complement form, which is 1's complement +1.

Link to the earlier post: Test your programming skills.

Enjoy yourself.
Regards,
Kongkon

Single Linked List using C

2011-03-08T01:43:00.005-08:00

Here is a single linked list data structure using C Language:

#include

struct node {
   int data;
   struct node * next;
};

struct node *first = NULL;

int menu();

struct node * insert_node(int data);
struct node * delete_node(int data);
int count_node(struct node *);
int traverse_list(struct node *);

int menu()
{
int item = 0;

return item;
}

/*
* This routine will insert a new node to the left hand side of a linked list. And make this new node as the first node after insertion.
*/
struct node * insert_node(int data)
{
   struct node * temp = NULL;

   temp = (struct node *)malloc(sizeof(struct node));
   if (!temp)
   printf("Not enough memory in the system\n");

   // insert data;
   temp->data = data;

   if(first == NULL)
   {
   first = temp;
   temp->next = NULL;
   //printf("data=%d\n", temp->data);
   }
   else
   {
   temp->next = first;
   first = temp;
   }

return first;
}
/*
delete_node(int data) deletes the first node from the singly linked list where the data matches, and returns the starting of the list.
*/
struct node * delete_node(int data)
{
struct node * current = first, *prev;
//search the list for the first occurance of "data". If no node with "data" found then the list remains the same.

while(current && current->data!=data)

{

prev = current;

current=current->next;

}

prev->next = current->next;

free(current);

return first;

}

int traverse_list(struct node *list_head)

{

struct node * current, *prev;

if (!first)

printf("Empty list\n");

current = first;

prev = current->next;

printf("\n\nList = ");

#if 1

while(current)

{

printf("\t %d", current->data);

current = current->next;

}

#endif

printf("\n\n");

}

main()

{

insert_node(30);

insert_node(40);

insert_node(50);

insert_node(60);

insert_node(70);

traverse_list(first);

delete_node(50);

traverse_list(first);

return 0;

}

Result of running this program:

kongkon@Linkat-Luidia:~/sea> ./a.out

List = 70 60 50 40 30

List = 70 60 40 30

C

2010-06-07T09:15:00.004-07:00

Today we shall discuss about a simple C program.

I would like to explain the difference between array and &array address.

So, let's start by taking a live question.

Q. Find the o/p:

main()

{

char *ptr="hello";

char ary[]="world";

printf("Ans:\n");

printf("PTR: &ptr=%x, ptr=%x, *ptr=%x, ptr[0]=%x\n", &ptr,ptr, *ptr, ptr[0]);

printf("ARY: &ary=%x,ary=%x, *ary=%x, ary[0]=%x\n", &ary, ary, *ary, ary[0]);

}

Ans:

PTR: &ptr=bfb86990, ptr=8048524, *ptr=68, ptr[0]=68

ARY: &ary=bfb8698a,ary=bfb8698a, *ary=77, ary[0]=77

When you look at the output of array and &array you will find that they both are same. Why? But, whereas in the case of a character pointer (not a character array), they seems to differ. Why again?

We all know that an array is like a constant pointer, and the address of the arrary is also indicated by the name of the array itself. Hence, when we mention arrary and when we mention &array they both mean the same and point to the same location. Memory allocation also happens in the same area as the starting address of the array.

But, but in case of a character pointer, prt and &ptr points to two distinct and different locations. &ptr is the place which is used by the compiler itself to store the actual data string that is pointed by ptr. &ptr points to a .rodata area inside the data segment, accessible and allocated by the compiler itself.

That is the only reason, why you get a segmentation fault while trying to modify the data pointed by the ptr character pointer.

C++ questions: Part 8

2010-05-14T11:15:00.005-07:00

Q. Why the size of empty Class is one byte?
Ans:
Yes, the compiler will generate 1 byte of memory to mark the existence of the class. This doesn't answer WHY though. The reason is the language standard states that all classes must have a memory size of at least 1 byte so that the class doesn't occupy the same memory space with another class. This is to prevent name mangling. i.e., if I declare a class A {};, the compiler will still generate an entry in its table to something called "A". If behind that I declare another class, say class B, if A takes 0 bytes of memory, and B's data gets written in the place where A was declared. In this case, an instantiation of A would take on the properties of B.

Q. What are the default methods of every object?
Ans:
http://qiang-ma.blogspot.com/2007/06/c-default-methods.html
+---------------------------------------------------------+
|What Name |
+---------------------------------------------------------+
|Default Constructor A::A() |
|Copy Constructor A::A(const A &) |
|Assignment [const] A &A::operator=(const A &) |
|Destructor A::~A() |
+---------------------------------------------------------+

Q. Why a constructor can't be virtual?
Ans:

A constructor can not be virtual because at the time when the constructor is invoked the virtual table (vtable) would not be available in the memory.

Virtual allows us to call a function knowing only the interfaces and not the exact type of the object. To create an object you need complete information. In particular, you need to know the what you want to create exactly. Hence call to a constructor can't be virtual.

C++ questions: Part 7

2009-11-13T16:11:00.004-08:00

C++ Q1: What are the steps involved in designing?
Answer: Before getting into the design the designer should go through the SRS prepared by the System Analyst.

The main tasks of design are Architectural Design and Detailed Design.

In Architectural Design we find what are the main modules in the problem domain.

In Detailed Design we find what should be done within each module.

C++ Q2: What are the main underlying concepts of object orientation?
Answer: Objects, messages, class, inheritance and polymorphism are the main concepts of object orientation.

C++ Q3: What do you meant by "SBI" of an object?
Answer: SBI stands for State, Behavior and Identity. Since every object has the above three.

Ø State:

It is just a value to the attribute of an object at a particular time.

Ø Behaviour:

It describes the actions and their reactions of that object.

Ø Identity:

An object has an identity that characterizes its own existence. The identity makes it possible to distinguish any object in an unambiguous way, and independently from its state.

C++ Q4: Differentiate persistent & non-persistent objects?
Answer: Persistent refers to an object's ability to transcend time or space. A persistent object stores/saves its state in a permanent storage system with out losing the information represented by the object.

A non-persistent object is said to be transient or ephemeral. By default objects are considered as non-persistent.

C++ Q5: What do you meant by active and passive objects?
Answer: Active objects are one which instigate an interaction which owns a thread and they are responsible for handling control to other objects. In simple words it can be referred as client.

Passive objects are one, which passively waits for the message to be processed. It waits for another object that requires its services. In simple words it can be referred as server.

C++ Q6: What is meant by software development method?
Answer: Software development method describes how to model and build software systems in a reliable and reproducible way. To put it simple, methods that are used to represent ones' thinking using graphical notations.