Supratim

[heysupratim]

Autojump - The Fastest Way to navigate around in the Terminal

Autojump is by far the coolest terminal utility i have come across . This is fuzzy searching meets the cd command  From the developer himself i quote - 

"autojump is a faster way to navigate your filesystem. It works by maintaining a database of the directories you use the most from the command line. Directories must be visited first before they can be jumped to."

Installing in the popular distros in not an issue as all repositories now house the said utility or otherwise the github repo is always there. 

This Utility changes the way how you use cd in your terminals , imagine traversing from a directory like /docs/ebooks/programming/python/ to another directory like /editing/new/html/intern

This would essentially require you to perform "cd .. " quite a few times and then a few more cd commands , instead autojump lets you do a simple j intern (provided you have once gone to this directory manually in the tiresome manner).

Fuzzy searching for the keywords instead of remembering the entire path is so much cooler and efficient. 

A Note to Ubuntu users : (command j not found issue Ubuntu 13.04/12.10/12.04)

After Installing autojump(sudo apt-get install autojump ) there is a small step you need take before you can use this program 

open up the bashrc file in your text editor of choice - (vim ~/.bashrc) and add this line to rc file : source /usr/share/autojump/autojump.bash

 As a measure i did file a bug for the same , you can check it out here - https://bugs.launchpad.net/ubuntu/+source/autojump/+bug/1200849

[heysupratim]

Upstart and Init - The Services bay

When a linux machine boots up it goes through some distinct phases. but today we are intrested in the phase after the kernel bootup.

Once the Kernel is loaded and has started to run . It calls the init program . This program runs as root and sets the runlevel to that requested at the initial bootime.

A runlevel is simply a number that Linux uses to distinguish different types of states a machine should be booted into.

An example could be Red Hats runlevels:

Runlevel Explanation 0 Halt the system 1 Single user mode (generally only used for administration purposes) 2 Multi-user mode with networking disabled 3 Multi-user mode with networking enabled 4 Unused runlevel 5 Multi-user mode with networking enabled, and X-Windows (graphical login) 6 Reboot

To check the current runlevel of your system . run the command ‘runlevel’.

On Ubuntu . System V init has been replaced by the Upstart daemon and that has a different way of initializing services based on the runlevels.

/etc/init - houses the conf files for all process that are started post the init call . These conf files follow a certain format to tell which script to run , and what command to execute to start and stop the process.

Now as far as ‘services’ are concerned , they are housed in /etc/init.d directory . These processes are called as per runlevel. The ‘rc’ script is the script respnsible to start the services based on the runlevel.

/etc/rc*.d is the format for the directory housing symbolic links to the services to invoke from init.d when the runlevel of the system is the same as the digit mentioned in place of the ‘*’.

to see which all services are enabled and change the runlevel category for the services .

perform a sudo apt-get install sysv-rc-conf

and then execute

sudo sysv-rc-conf

[heysupratim]

My stage act with GRUB 2

Understanding a bootloader has never been easy and the efforts preceeding this article didnt solve the problem either , but anyhow, there are things that i set straight for myself this time. When a computer is turned on, The Computer's BIOS finds the primary bootable device(the HDD) and loads the initial bootstrap program from the MBR The bootstrap program is stored in the ROM in modern day computers in contrast to the manual poking of switches that was needed to be done on older systems. The bootstrap program is stored in the MBR (Master Boot Record) ,first 512 bytes of the Hard Disk . The control is then trasfered to the bootstrap code . MBR usually contains GRUB stage 1 but can contain another bootloader which can chain boot GRUB stage 1 from another boot sector . With GRUB version 2 , boot.img is stored in the MBR , like the Stage 1 however it can load one sector from any LBA48 address (LBA is a logical block addressing for specifying the location of data blocks stored on storage devices. Blocks are located by an integer index -- LBA0 , LBA 1 etc ..) boot.img loads the first sector of the core.img (generated from diskboot.img) which is then used to load the rest of the generated core.img

[heysupratim]

The 'Shift' in shell scripts

Looking through a shell script today i came across a keyword ‘shift’ . The spontaneous attempt at deciphering the keyword led me to the concept of shifting command line arguments.

So essentially what the shift command does is- It takes the command line arguments and shifts them towrds the left by one place.

So if the command line arguments were :

$1 = -a $2 = foo $3 = bar

writing down shift would lead to the situation where :

$1 = foo $2 == bar

Now taking the live example of the NetBSD shell script . The shift command is written down as such :

case "$1" in "--shelltest") shelltest=true re_exec_allowed=false shift ;; "--no-re-exec") re_exec_allowed=false shift ;; esac

so essentially checking for a no-shell-test and then shifting all the rest of the arguments by one place.

[heysupratim]

So much more to the printf in c we know

I recently came across the concept of printing known bit width quantities in C using inttypes header file.

The idea is to include inttypes.h and use the predefined macros to advantage.

eg:

#include<stdio.h> #include<inttypes.h> int main(int argc,char *argv[]) { uint_32 var = 43434; printf("The value of var is ="PRIu32"\n",var); }

The inttypes.h provides macros like PRId13,PRIu64 ,SCN16 etc.

The general syntax is

PRIz*** SCNz***

PRI stands for printing value , SCN for scanning (duh !!)

z - is the format specifier : ————————————————————————————————

The values could be

1 )d- decimal 2) x - hexadecimal 3) o - octal 4) u - unsigned int 5) i - integer ______________________________________________________

The value of *** is for the bit size support

1) N for N bit size assignment to the data type (eg for for 32 bit size of integers, it would be 32)

2) PTR for pointer

3) MAX for maximum supported bit size

so the use case would be

PRIu64- printing a unsigned int with 64 bit width PRIdMAX- printing a decimal with maximum bit size

[heysupratim]

Diagnostics with C programs

The Best way to log the verification results for an expression in a C program is to use the assert.h header and use the _DIAGASSERT(expression) function to verfiy the passed expression.

Looking it up from NET BSD Documentation

#include<assert.h> .................. _DIAGASSERT(expression)

if the expression is true , the macro does nothing,and if its false-

one or more of the following may occur:

⊕ a diagnostic message may be logged to the system logger with syslog(3). This is default behaviour.

⊕ a diagnostic message may be printed to the stderr stream.

⊕ the calling process will be terminated by calling abort(3).

The macro is not compiled by default and is used is various system libraries such libc( standard C library)

[heysupratim]

NET BSD Source Code style

Having come across various coding style guidelines in different open source projects, I have come to experience that the NET BSD source style suits the best for me. The guidelines can be found here.

The Code style mentions the needed parameters and the rules governing them in a very readable format. They are fairly easy to pick up and dont offer that much of a roadblock when starting off with a project that uses that as their code style. PS: The code style mentioned here is for C language only.

[heysupratim]

Intelligent Branch Prediction for Compilers

GCC version 2.96 and above offers a neat little feature to instruct the compiler to branch to a most probably route in a code /routine/program

if (__builtin_expect (x, 0)) foo (); This tells the compiler that we do not to call `foo' since we expect `x' to be zero.

So lets see an example

int testfunction(int x) { if (_builtin_expect (x,0)) { //we tell the compiler that the else block is more probable x = x+3; } else { x = x+1; } }

So essentially this translates to an intellligent assembly code thats generated for the same.

The  compiler branches the if code block and keeps the else block sequential

The Linux kernel also uses the same , though a little more wisely . It defines cool macros for the same function:

#define likely(x) __builtin_expect((x),1) #define unlikely(x) __builtin_expect((x),0)

[heysupratim]

Guarding Multiple inclusion of header files

Guarding Multiple inclusion of header files requires the usage of a include guard standard developed for C/C++

EXAMPLE HEADER FILE:

A header file which should protect itself against multiple inclusion. would contain something like this:

ifndef SYS_SOCKET_H define SYS_SOCKET_H endif

Contents of #include file go between the #ifndef and the #endif at the end

This Protects any program including this header file from multiple declaration errors and /or multiple inclusion of variable,constants,structures by making sure that the header file is included only once .

The ifndef makes the program using the header file to include the header only the first time its needed , for subsequent calls the define macro comes into picture.