Linux script to create colorful 2013 on the terminal

Here is a script with which you can create the number 2013, on your terminal using any character of your choice. The colors of the numbers will change randomly on every run of hte script.

2013.sh:

#!/bin/bash str_dwn() { rows=$1 s_start=$2 char=$4 str_st_row=$3 rows_end=$((str_st_row+rows)) for((i=str_st_row;i<rows_end;i++)) do tput cup $i $s_start printf "$char " done echo"" } backslash() { b_st_row=$1 b_st_cols=$2 b_char=$3 b_r_end=$((b_st_row + 5 )) for((p=b_st_row;p<b_r_end;p++)) do tput setaf $4 tput cup $p $b_st_cols printf "$b_char " ((b_st_cols++)) done echo"" } forward() { f_st_row=$1 f_st_cols=$2 f_char=$3 f_r_end=$((f_st_row + 5)) for((i=f_st_row;i<f_r_end;i++)) do tput cup $i $f_st_cols printf "$f_char " ((f_st_cols--)) done echo"" } horizontal() { hrow=$2 hstart=$1 hcols=$3 char=$4 end=$((hstart + hcols)) for((i=hstart;i<=end;i++)) do tput cup $hrow $i printf "$char" done echo"" } gen_rand() { num1=$1 if [ $num1 -eq 0 ] then temp=$(($RANDOM % 2)) rand=$((temp + 2)) else temp=$(($RANDOM % 5)) rand=$((temp + num1)) fi } two() { hstart_2=$1 hrow_be=$2 hcols_2=$3 char=$4 color=$5 set_color horizontal $hstart_2 $hrow_be $hcols_2 "$char" st_row_2=$((hrow_be+1)) f_st_cols_2=$((hstart_2+hcols_2)) forward $st_row_2 $f_st_cols_2 "$char" $color hstart_2_lo=$start hrow_2_lo=$((hrow_be+6)) hcols_2_lo=5 horizontal $hstart_2_lo $hrow_2_lo $hcols_2_lo "$char" } zero() { set_color hstart_0=$((f_st_cols_2 +4)) hcols_0=5 horizontal $hstart_0 $hrow_be $hcols_0 "$char" str_dwn_col_0=$hstart_0 str_dwn_row_0=$((hrow_be + 1)) str_dwn 6 $str_dwn_col_0 $str_dwn_row_0 "$char" hstart_0_lo=$((f_st_cols_2 +4)) hcols_0_lo=6 hrow_0_lo=$((hrow_be+6)) horizontal $hstart_0 $hrow_0_lo $hcols_0 "$char" str_dwn_col_rig_0=$((hstart_0 +5)) str_dwn_row_rig_0=$((hrow_be + 1)) str_dwn 6 $str_dwn_col_rig_0 $str_dwn_row_rig_0 "$char" } one() { set_color str_dwn_col_1=$((str_dwn_col_rig_0 + 4)) str_dwn_row_1=$((hrow_be)) str_dwn 7 $str_dwn_col_1 $str_dwn_row_1 "$char" } three() { set_color hstart_3_top=$((str_dwn_col_1 +4)) hcols_3_top=4 hrow_3_top=$((hrow_be)) horizontal $hstart_3_top $hrow_3_top $hcols_3_top "$char" hstart_3_mid=$((str_dwn_col_1 +4)) hcols_3_mid=4 hrow_3_mid=$((hrow_be+3)) horizontal $hstart_3_mid $hrow_3_mid $hcols_3_mid "$char" hstart_3_bt=$((str_dwn_col_1 +4)) hcols_3_bt=4 hrow_3_bt=$((hrow_be+6)) horizontal $hstart_3_bt $hrow_3_bt $hcols_3_bt "$char" str_dwn_col_3=$((hstart_3_bt + 5)) str_dwn_row_3=$((hrow_be)) str_dwn 7 $str_dwn_col_3 $str_dwn_row_3 "$char" } set_color(){ color=$RANDOM color=$((color%6)) tput setaf $color } cols=`tput cols` mid=$((cols/2)) start=$((mid-16)) echo "What character do you want to use" read char tput clear rows=5 begin_row=2 num_cols=6 two $start $begin_row $num_cols "$char" $color;zero;one;three tput setaf 0 tput cup 9 0

Save the script as 2013.sh, give it execute permissions and execute it.

$ chmod 777 2013.sh $ ./2013.sh What character do you want to use *

You sholud see some thing like this on the terminal

Implementing an ioctl call (for kernel versions above 2.6.39)

In the post "Creating an ioctl command in linux " we saw the basics of ioctl, and how we can create our own ioctl commands. The functions used to create ioctls have undergone a change from the kernel version 2.6.39,and the previous functions are no longer valid.

Before 2.6.39, the ioctl calls would lock the BKL (Big kernel lock) and then execute the required functions. This was unnecessary with the new fine grained locking available in the kernel. Thus to improve the implementation of ioctl, a new operation called unlocked_ioctl was introduced and all the existing ioctls were migrated to this new implementation.

Thus stating 2.6.39 the older implementation is no longer available.

The changes required in implementation of the ioctl are.

The function in the driver has changed from

int ioctl_funcs(struct inode *inode, struct file *filp,unsigned int cmd, unsigned long arg)

long ioctl(struct file *filp,unsigned int cmd, unsigned long arg)

The inode is no longer passed as an argument.
The fops uses the name unlocked_ioctl

struct file_operations fops = { open: open, unlocked_ioctl: ioctl_funcs, release: release };

The basic working of ioctl remains same.
Here is a code that implements the above mentioned changes if the kernel version is more than 2.6.39, else uses the older interface.

Module: ioctl_basic.c

#include <linux/module.h> #include <linux/kernel.h> #include <linux/fs.h> // required for various structures related to files liked fops. #include <linux/semaphore.h> #include <linux/cdev.h> #include "ioctl_basic.h" #include <linux/version.h> static int Major; #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36) #define UNLOCKED 1 #endif int open(struct inode *inode, struct file *filp) { printk(KERN_INFO "Inside open \n"); return 0; } int release(struct inode *inode, struct file *filp) { printk (KERN_INFO "Inside close \n"); return 0; } #ifdef UNLOCKED long ioctl_funcs(struct file *filp,unsigned int cmd, unsigned long arg) { int ret=0; switch(cmd) { case IOCTL_HELLO: printk(KERN_INFO "Hello ioctl world"); break; } return ret; } struct file_operations fops = { open: open, unlocked_ioctl: ioctl_funcs, release: release }; #else int ioctl_funcs(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { int data=10,ret; switch(cmd) { case IOCTL_HELLO: printk(KERN_INFO "Hello ioctl world"); break; } return ret; } struct file_operations fops = { open: open, ioctl: ioctl_funcs, release: release }; #endif struct cdev *kernel_cdev; int char_arr_init (void) { int ret; dev_t dev_no,dev; kernel_cdev = cdev_alloc(); kernel_cdev->ops = &fops; kernel_cdev->owner = THIS_MODULE; printk (" Inside init module\n"); ret = alloc_chrdev_region( &dev_no , 0, 1,"char_arr_dev"); if (ret < 0) { printk("Major number allocation is failed\n"); return ret; } Major = MAJOR(dev_no); dev = MKDEV(Major,0); printk (" The major number for your device is %d\n", Major); ret = cdev_add( kernel_cdev,dev,1); if(ret < 0 ) { printk(KERN_INFO "Unable to allocate cdev"); return ret; } return 0; } void char_arr_cleanup(void) { printk(KERN_INFO " Inside cleanup_module\n"); cdev_del(kernel_cdev); unregister_chrdev_region(Major, 1); } MODULE_LICENSE("GPL"); module_init(char_arr_init); module_exit(char_arr_cleanup);

The steps of compiling and testing the module are same as shown in the post "Creating an ioctl command in linux "

colorful Christmas Tree on linux terminal

Here is a version 2 of the Christmas tree creation script. The script will create a colorful Christmas tree on the terminal. The colors of the tree will change on every run.

The script will take as input the character with which the tree has to be drawn, and any two characters that have to be used to decorated the tree.

Christmas_tree:

#!/bin/bash backslash() { b_st_row=$1 b_st_cols=$2 b_char=$3 deco=$5 b_r_end=$((b_st_row + 5 )) for((p=b_st_row;p<b_r_end;p++)) do tput setaf $4 tput cup $p $b_st_cols printf "$b_char " # sleep 1 if [ $p -eq $deco ] then temp=$((b_st_cols - 1)) tput cup $p $temp printf "$deco_char1" temp=$((temp - 2)) tput cup $p $temp printf "$deco_char2" fi ((b_st_cols++)) done echo"" } forward() { f_st_row=$1 f_st_cols=$2 f_char=$3 deco=$5 f_r_end=$((f_st_row + 5)) for((i=f_st_row;i<f_r_end;i++)) do tput cup $i $f_st_cols tput setaf $4 printf "$f_char " if [ $i -eq $deco ] then temp=$((f_st_cols + 1)) tput cup $i $temp printf "$deco_char1" temp=$((temp + 2)) tput cup $i $temp printf "$deco_char2" fi # sleep 1 ((f_st_cols--)) done echo"" } horizontal() { hrow=$2 hstart=$1 hcols=$3 char=$4 end=$((hstart + hcols)) for((i=hstart;i<=end;i++)) do # sleep 1 tput setaf $5 tput cup $hrow $i printf "$char" done echo"" } base(){ start=$1 tput setaf $4 f_st_cols=$((start - 2)) b_st_cols=$((start + 2)) rows=$2 st_row=$((rows+1)) char=$3 forward $st_row $f_st_cols "$char" $4 1000 backslash $st_row $b_st_cols "$char" $4 1000 hrow=$((st_row + 4)) hcols=12 hstart=$((start - 6)) horizontal $hstart $hrow $hcols "$char" $4 } gen_rand() { num1=$1 #num2=$((num1 + 5)) if [ $num1 -eq 0 ] then temp=$(($RANDOM % 2)) rand=$((temp + 2)) else temp=$(($RANDOM % 5)) rand=$((temp + num1)) fi } cols=`tput cols` start=$((cols/2)) echo "What character do you want to use" read char echo "Enter the first character to be used for decoration" read deco_char1 echo "Enter the second character to be used for decoration" read deco_char2 tput clear rows=5 # char="*" j=1 for((k=0;k<3;k++)) do st_row=$((k*6)) f_st_cols=$((start - k*3)) color=$RANDOM color=$((color % 6)) gen_rand $st_row forward $st_row $f_st_cols "$char" $color $rand b_st_cols=$((start + k*3)) gen_rand $st_row backslash $st_row $b_st_cols "$char" $color $rand hrow=$((j * 5 + k)) hstart=$((5+3*k)) hstart=$((start - hstart)) hcols=$((10 + k*6)) horizontal $hstart $hrow $hcols "$char" $color ((j++)) # deco $st_row $hstart $hcols done base $start $hrow "$char" $color tput setaf 4 tput cup 10 10 printf "**MERRY**" tput cup 10 90 printf "**CHRISTMAS**" tput setaf 0 end=$((hrow + 5)) tput cup $end 0

Save the script as christmas_tree.sh, give it execute permission and execute it.

$ chmod 777 christmas_tree.sh $ ./christmas_tree.sh What character do you want to use * Enter the first character to be used for decoration o Enter the second character to be used for decoration !

You should see the following image on your screen.

Related Posts

Christmas Tree on linux terminal

script to find the mac address using linux

Here is a simple script we can use to find the mac address of the network card in our systems.
We will use the command ifconfig to find the mac address and in some distribution ifconfig is available only to the root hence we make use of "sudo" before ifconfig.

For wired connection

sudo ifconfig | grep eth[0-9] | awk '{ print $NF}'

For wireless connection

sudo ifconfig | grep wlan[0-9] | awk '{print $NF}'

c program in linux to find the maximum length allowed for a host name

The following is a C program to find out the maximum length allowed for a host name in the system We can make use of the function sysconf and pass the argument _SC_HOST_NAME_MAX
We need the header file unistd.h to use sysconf.

#include<stdio.h> #include<unistd.h> #include<stdlib.h> main() { long temp; temp=sysconf(_SC_HOST_NAME_MAX); if(temp==-1) printf("Check the argument passed to sysconf"); printf("\nMaximum length for host name is : %d \n",temp); }

Save the program as get_max_hostname.c. Compile and execute the code.

$ cc get_max_hostname.c -o get_max_hostname $ ./get_max_hostname Maximum length for host name is : 64

c program in linux to find out the number of processors

The following is a C program to find out the number of processors configured on a system.
We can make use of the function sysconf and pass the argument _SC_NPROCESSORS_CONF.
We need the header file unistd.h to use sysconf.

#include<stdio.h> #include<unistd.h> #include<stdlib.h> main() { long temp; temp=sysconf(_SC_NPROCESSORS_CONF); if(temp==-1) printf("Check the argument passed to sysconf"); printf("\nNo of configured processors : %d \n",temp); }

Save the program as get_processors.c. Compile and execute the code.

$ cc get_processors.c -o get_processors $ ./get_processors No of configured processors : 1

C program in linux to find the current working directory

Here are three ways in which we can get the path to the current working directory using a c program,

1. we can make use of the function "getcwd".
Header file required : unistd.h
The syntax of getcwd is

char *getcwd(char *buf,size_t size)

buf: Is the character pointer in which the path of current working directory is stored. size: Is the maximum size of the path in bytes, if the size exceeds this then a NULL is returned

Here is a program that shows the usage of getcwd.

#include<stdio.h> #include<unistd.h> #include<stdlib.h> main() { char *buf; buf=(char *)malloc(100*sizeof(char)); getcwd(buf,100); printf("\n %s \n",buf); }

Save the program is get_cwd.c. Compile and execute it.

$ cc get_cwd.c -o get_cwd $ ./get_cwd /home/user/programs

2.using get_current_dir_name.

Header file required : unistd.h

Syntax:

char *get_current_dir_name(void)

The function returns the absolute path to the current working directory. The function itself mallocs for an array big enough to hold the current directory name, thus we don't need to do malloc in the program. This function returns the value of the environment variable PWD, thus if it is not set the function might fail to return the current value.
Here is a program which uses get_current_dir_name to get the current working directory.

#include<stdio.h> #include<unistd.h> #include<stdlib.h> main() { char *buf; buf=(char *)get_current_dir_name(); printf("\n %s \n",buf); }

Save the file as get_current_dir.c. Compile and execute it.

$ cc get_current_dir.c -o get_current_dir $ ./get_current_dir /home/user/programs

3. The third way of getting the current working directory is using the command "pwd" along with the function "system". The system function executes which ever command is passed to it and prints the result on the screen. Thus we can execute the command system and pass the command "pwd" as the argument, the result of which will be the current working directory being printed on the screen.

The following program shows how the same can be implemented.

#include<stdio.h> #include<unistd.h> #include<stdlib.h> main() { system("pwd"); }

Save the file as get_system_pwd.c. Compile and execute the same.

$ cc get_system_pwd.c -o get_system_pwd $ ./get_sytem_pwd /home/user/programs

C program in linux to find the username of a the currently logged in user

Here are three ways in which we can get the user name of the currently logged in user using a c program.

1. Using getlogin
Header file required : unistd.h
The synatx of getlogin is

char *getlogin()

The function returns a pointer to a character array containing the name of the logged in user.

The following is a program showing the usage of the getlogin

#include<stdio.h> #include<stdlib.h> #include<unistd.h> main() { char *buf; buf=(char *)malloc(10*sizeof(char)); buf=getlogin(); printf("\n %s \n",buf); }

Save the file as get_login.c. Compile and execute it. $ cc get_loing.c -o get_login $ ./get_login user1

The output should be the username with which we have currently logged.

2.Using getlogin_r

Header file required : unistd.h

The syntax of getlogin_r is

int getlogin_r(char *buf,size_t bufsize)

The function returns the login name in the variable buf, as long as the name does not exceed size parameter passed to the function.
The following is an example showing the usage of getlogin_r

#include<stdio.h> #include<stdlib.h> #include<unistd.h> main() { char *buf; buf=(char *)malloc(10*sizeof(char)); getlogin_r(buf,10); printf("\n %s \n",buf); }

Save the file as get_login_r.c. Compile and execute it.

$ cc get_login_r.c -o get_login_r $ ./get_login_r user1

The function returns the login name in the variable buf, as long as the name does not exceed size parameter passed to the function.

3.Using cuserid

Header file required stdio.h

The syntax of userid is

char * cuserid(char *string);

The function returns the user name in the string which is passed as the argument.The string should have enough space to accommodate the name .

Following is an example showing the usage of the function cuserid.

#include<stdio.h> #include<stdlib.h> main() { char *buf; buf=(char *)malloc(10*sizeof(char)); cuserid(buf); printf("\n %s \n",buf); }

Save the file as get_cuserid.c. Compile and execute it.

$ cc get_cuserid.c -o get_cuserid $ ./get_cuserid user1

Linux Script to generate random numbers in a given range

Generating random numbers is common recruitment in number of scripts. bash by default gives a variable $RANDOM which when accessed gives a random number between 0 and 32767.

$ echo $RANDOM 4945 $ echo $RANDOM 15819

There might be situations where we might need random numbers between a range of smaller numbers or between zero and a smaller number than 32767. Here is a script which can be used to generate random numbers between any range of numbers.

It takes as input the lower limit and the upper limit of the random numbers required and then generates the required number of random numbers with in the range.

random_numbers

#!/bin/bash echo "Enter range of numbers between which random numbers is required " echo "lower limit=" read lower echo "upper limit=" read upper echo "How many random numbers do you need" read num diff=$((upper-lower)) echo "Random numbers are " for((i=0;i<num;i++)) do temp=$(($RANDOM % diff)) rand=$((temp + lower)) echo $rand done

save the script as random_numbers.sh,give it execute permissions. chmod 777 random_numbers.sh

Now execute the script to generate the random numbers

$./random_numbers Enter range of numbers between which random numbers is required lower limit= 20 upper limit= 100 How many random numbers do you need 5 Random numbers are 24 37 20 95 62

Thus we can see we can generate any number of random numbers with in any given range, using the script.

Deadlock creation and avoidence in pthreads

In the post we saw how we can use mutex to prevent simultaneous usage of the same resource by multiple threads. But usage of mutexes have to be done very carefully to make sure that the threads don't end up in a dead lock.

A deadlock is a scenario when one thread is waiting for a resource which is held by the second thread, while the second thread is waiting for a resource held by the first thread. Thus causing both the threads to wait for each other infinitely.

To show how this situation might occur, in the following example we have used two mutexes,read_mutex and write_mutex. To gain access to the file both these mutexes have to be locked. In the code, the write thread locks write_mutex and then after a little delay tries to locks read_mutex. The read thread on the other hand locks read_mutex first and then tries to lock write_mutex.

Thus by the time the write tries to access read_mutex, it has already been locked by read thread and by the time read thread tries to lock write_mutex, it has already been locked by the write thread. Thus both the threads end up waiting infinitely for each other to unlock the mutexes and process ends up in a deadlock.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t read_mutex; pthread_mutex_t write_mutex; void * write(void *temp) { char *ret; FILE *file1; char *str; pthread_mutex_lock(&write_mutex); sleep(5); pthread_mutex_lock(&read_mutex); printf("\nFile locked, please enter the message \n"); str=(char *)malloc(10*sizeof(char)); file1=fopen("temp","w"); scanf("%s",str); fprintf(file1,"%s",str); fclose(file1); pthread_mutex_unlock(&read_mutex); pthread_mutex_unlock(&write_mutex); printf("\nUnlocked the file you can read it now \n"); return ret; } void * read(void *temp) { char *ret; FILE *file1; char *str; pthread_mutex_lock(&read_mutex); sleep(5); pthread_mutex_lock(&write_mutex); printf("\n Opening file \n"); file1=fopen("temp","r"); str=(char *)malloc(10*sizeof(char)); fscanf(file1,"%s",str); printf("\n Message from file is %s \n",str); fclose(file1); pthread_mutex_unlock(&write_mutex); pthread_mutex_unlock(&read_mutex); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&write,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created thread"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the file as mutex_deadlock.c, and compile it by passing "-lpthread" flag.

$ cc -lpthread mutex_deadlock.c -o mutex_deadlock $ ./mutex_deadlock

There will be no output as both the threads endup in a deadlock state, to get out of the execution use "cntrl + c".

To avoid such simple deadlocks the easiest method is to make sure that all the threads access the locks in a specific order. In the above example if it is made compulsory that every thread should lock write_mutex first and then try to lock read_mutex, then the deadlock situation will not occur as only one thread will get access to write_mutex first and the same thread will be able to access read_mutex too.

The above code modified to avoid deadlock is shown below. Note that the order of acquiring lock by both the threads is the same, thus able to prevent deadlock.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t read_mutex; pthread_mutex_t write_mutex; void * write(void *temp) { char *ret; FILE *file1; char *str; pthread_mutex_lock(&write_mutex); sleep(5); pthread_mutex_lock(&read_mutex); printf("\nFile locked, please enter the message \n"); str=(char *)malloc(10*sizeof(char)); file1=fopen("temp","w"); scanf("%s",str); fprintf(file1,"%s",str); fclose(file1); pthread_mutex_unlock(&read_mutex); pthread_mutex_unlock(&write_mutex); printf("\nUnlocked the file you can read it now \n"); return ret; } void * read(void *temp) { char *ret; FILE *file1; char *str; pthread_mutex_lock(&write_mutex); sleep(5); pthread_mutex_lock(&read_mutex); printf("\n Opening file \n"); file1=fopen("temp","r"); str=(char *)malloc(10*sizeof(char)); fscanf(file1,"%s",str); printf("\n Message from file is %s \n",str); fclose(file1); pthread_mutex_unlock(&read_mutex); pthread_mutex_unlock(&write_mutex); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&write,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created thread"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the code as mutex_nodeadlock.c, compile it using "-lpthread" flag.

$ cc -lpthread mutex_nodeadlok.c -o create_nodeadlock $ ./create_nodeadlock Created thread File locked, please enter the message Hello Unlocked the file you can read it now Opening file Message from file is Hello

Thus we can successfully avoid a potential deadlock situation, by making use of the rules order of locks.

Using pthread_mutex to lock and synchronize threads

pthreads are used to split a process into multiple threads and execute them concurrently. The threads should be independent of each other as far as possible, but at times the threads could be dependent on each other and they might be working on the same data.

Let us say we want to crate two threads,one to read from a file and the other to write into the same file. It is obvious that we can not read from a file unless we don't write into it, and at any given time the file should be allowed to be accessed by only one of the two threads. That is while it is being written it should not be allowed to be read and while it is being read, it should not be opened for write.

The following program implements the above mentioned two threads, but does not do any thing to synchronize the actions of the two threads.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t rw_mutex; void * write(void *temp) { char *ret; FILE *file1; char *str; printf("\nFile locked, please enter the message \n"); str=(char *)malloc(10*sizeof(char)); file1=fopen("temp","w"); scanf("%s",str); fprintf(file1,"%s",str); fclose(file1); return ret; } void * read(void *temp) { char *ret; FILE *file1; char *str; printf("\n Opening file \n"); file1=fopen("temp","r"); str=(char *)malloc(10*sizeof(char)); fscanf(file1,"%s",str); printf("\n Message from file is %s \n",str); fclose(file1); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&write,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created thread"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the adove file as pthread_file.c. Compile it using "-lpthread" falg

$ cc -lpthread pthread_file.c $./a.out Created thread Opening file Segmentation fault

We get a segmentation fault every time we execute the above program. This is because, the read thread tries to access the file which is being created by thread1 "write" and thus is still not available. When read thread accesses the file it still has not been created and thus we get a segmentation fault.

The part of the program in which multiple threads try to get access to the same resource, in this case the file, is termed as the critical section and ideally a critical section should be executed by only one thread at a any given time.

To prevent the access of the file by multiple threads at the same time we can make use of a mutex. Mutex stands for mutual exclution and as the name implies it keeps the threads mutually exclusive.

Access to the critical section is controlled by locking the mutex. That is whichever process locks the mutex first will be allowed to enter the critical section first and the other process can not enter the critical section unless the mutex is not unlocked by the first process.

Applying this to above example, both read and write threads will have to get a lock on a common mutex before getting access to the file. If we can make sure that the write thread always gets the access to the lock first then, the read thread will have to wait for the write thread to finish its operations on the file and unlock the mutex,before it can read it. Thus making sure that the segmentation fault never ocurrs.

To implement a mutex in pthreads we have to use a datatype of type pthread_mutex_t.
e.g.

pthread_mutex_t rw_mutex;

To lock the mutex we use the function pthread_mutex_lock(Address of mutex variable)
e.g.

pthread_mutex_lock(&rw_mutex)

To unlock the mutex we use the functions pthread_mutex_unlock(address of mutex variable)
e.g.
pthread_mutex_unlock(&rw_mute)

The implementation is shown in the code below.

pthread_mutex.c

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t rw_mutex; void * write(void *temp) { char *ret; FILE *file1; char *str; pthread_mutex_lock(&rw_mutex); printf("\nFile locked, please enter the message \n"); str=(char *)malloc(10*sizeof(char)); file1=fopen("temp","w"); scanf("%s",str); fprintf(file1,"%s",str); fclose(file1); pthread_mutex_unlock(&rw_mutex); printf("\nUnlocked the file you can read it now \n"); return ret; } void * read(void *temp) { char *ret; FILE *file1; char *str; sleep(5); //Adding the delay to give time for write thread to lock the mutex pthread_mutex_lock(&rw_mutex); printf("\nOpening file for reading \n"); file1=fopen("temp","r"); str=(char *)malloc(10*sizeof(char)); fscanf(file1,"%s",str); printf("\nMessage from file is %s \n",str); fclose(file1); pthread_mutex_unlock(&rw_mutex); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&write,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created thread"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

save the code as pthread_mutex.c and compile by passing the "-lpthread" flag and execute it.

$ cc -lpthread pthread_mutex.c -o pthread_mutex $ ./pthread_mutex Created thread File locked, please enter the message Hello Unlocked the file you can read it now Opening file Message from file is Hello

Using pthread_self to find the thread id

Every thread created using pthread_create gets assigned a uniue thread id, with which it is recognized.

Note: Refer to creation of threads using pthreads in the post " "

The parent gets to know the thread id after the pthread_create is executed sucessfully, but while executing the thread if we want to access the thread id we have to use the function pthread_self.

The function pthread_self does not take any arguments, and returns the thread id, which is of kind pthread_t.

In the following program we are creating a thread which executes the function "hello". In the function "hello" we have used pthread_self to find out the thread id and then printed the same. Note that pthread_t is an unsigned long data type and hence we have to use %u while printing using printf.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> void * hello(void *temp) { char *ret; ret="Finished"; pthread_t self_id; self_id=pthread_self(); printf("\nHello from thread %u\n",self_id); return ret; } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&hello,NULL); printf("\nCreated thread %u", thread_id); pthread_join(thread_id,&res); printf("Thread returned: %s \n",(char *)res); }

Save the file as self_pthread.c

Compile it using gcc by passing the "-lpthread" flag.

cc -lpthread self_pthread.c -o self_pthread ./self_ptherad Created thread 3076365168 Hello from thread 3076365168 Thread returned: Finished

We can see that the thread_id printed by the main function, parent, and the thread are the same, indicating that the value returned by pthread_self is the correct value.

pthread error: undefined reference to `pthread_create'

undefined reference to `pthread_create'

The above error is a common error encountered by a number of people who begin writing programs using pthreads. The POSIX libraries required for pthread functions are not linked by the compiler unless we don't ask or it to be linked. Thus we see the above error.

The simple workaround is to pass the option "-lp" to the compiler while compiling the code.
Example:

cc -lp hello_thread.c -o hello_trhread

Now we should not get the above error.

Creating a christmas tree on linux terminal

Here is a script that,when executed, will draw a christmas tree using the characters choosen by the user on the linux terminal.

The script will prompt the user to enter the character using which the tree has to be drawn. Then it will prompt the user to enter two characters that will be used to decorate the tree. The last input it will ask for is the character using which the base of the tree has to be drawn.

chritstmas_tree.sh

#!/bin/bash trapi() { cols=`tput cols` start=$((cols/2)) # char="*" char="$3" rows=$1 rows=$((rows+5)) # tput clear for((i=$1;i<$rows;i++)) do deco1=$(($RANDOM % rows)) deco2=$((RANDOM % rows)) cols=$((start-i-$2)) tput cup $i $cols #printf "$char" for((j=0;j<=(i+$2);j++)) do if [ $i -eq $((rows-1)) ] then printf "$char " elif [ $j -eq 0 ] then printf "$char " else if [ $j -eq $((i+$2)) ] then printf "$char " else if [ $j -eq $deco1 ] then printf "$4 " elif [ $j -eq $deco2 ] then printf "$5 " else printf " " fi fi fi done done echo"" } triangle() { cols=`tput cols` start=$((cols/2)) #echo "How many rows do you want" #read rows #echo "What character do you want to use" #read char rows=5 # char="*" char="$1" tput clear for((i=0;i<rows;i++)) do cols=$((start-i)) tput cup $i $cols deco=$(($RANDOM%rows)) #printf "$char" for((j=0;j<=i;j++)) do if [ $i -eq $((rows-1)) ] then printf "$char " elif [ $j -eq 0 ] then printf "$char " else if [ $j -eq $i ] then printf "$char " else if [ $j -eq $deco ] then printf "$2 " else printf " " fi fi fi done done echo"" # sleep 5 } base() { cols=`tput cols` start=$((cols/2)) #char="*" rows=5 char="$2" # tput clear for((i=0;i<5;i++)) do cols=$((start-i-2)) tput cup $(($1+i)) $cols #printf "$char" for((j=0;j<=(i+2);j++)) do if [ $i -eq $((rows-1)) ] then printf "$char " elif [ $j -eq 0 ] then printf "$char " else if [ $j -eq $((i+2)) ] then printf "$char " else printf " " fi fi done done echo"" } echo "Enter character for the tree" read char echo "Enter first decoration character" read ch_deco1 echo "Enter second decoration character" read ch_deco2 echo "Enter character for base" read base_char triangle "$char" "$ch_deco1" trapi 5 1 "$char" "$ch_deco1" "$ch_deco2" trapi 10 2 "$char" "$ch_deco1" "$ch_deco2" trapi 15 3 "$char" "$ch_deco1" "$ch_deco2" base 20 "$base_char"

Save the script as chritstmas_tree.sh and give it execute permissions

$ chmod 777 chritstmas_tree.sh Execute the script $ ./chritstmas_tree.sh Enter character for the tree * Enter first decoration character o Enter second decoration character ! Enter character for base ^

You should see the following on your screen.

Related Posts

Colorful christmas tree on linux terminal

Creating an outline of triangle shape on linux terminal, using any characeter

This post is in response to the comment #2 in the post Creating a triangle of characters on terminal

The following script will create a blank triangle of characters on the linux terminal, but unlike the script in "" the triangle will be empty, i.e. only the outline has the characters chosen by the user and inside is left blank.

#!/bin/bash cols=`tput cols` start=$((cols/2)) echo "How many rows do you want" read rows echo "What character do you want to use" read char tput clear for((i=0;i<rows;i++)) do cols=$((start-i)) tput cup $i $cols for((j=0;j<=i;j++)) do if [ $i -eq $((rows-1)) ] then printf "$char " elif [ $j -eq 0 ] then printf "$char " else if [ $j -eq $i ] then printf "$char " else printf " " fi fi done done echo""

Save the script as blank_triangle.sh and give it execute permissions

chmod 777 blank_trinale.sh

Now execute it

./blank_triangle.sh How many rows do you want 10 What character do you want to use #

Thus we can see that the script is able to draw the blank triangle of any character user wants and any number of rows (limited by the number of rows in one terminal screen )

Linux script to find prime numbers in a range of numbers

In the post " " we saw how we can use the command factor to find whether a number is prime of not. We can extend the same script further to generate all the prime numbers in a given range of numbers.

To generate a range of numbers we can use the command "seq" . The usage of seq is shown in the post " ".

We can use seq in a for loop to iterate over one number at time.

for mun in `seq 4 10` do echo $mun done

Save the script as seq_for.sh, give it execute permissions and run the script.

$ chmod 777 seq_for.sh $ ./seq_for.sh 4 5 6 7 8 9 10

Thus we can see that using seq along with for loop we can work on a range of numbers, one number at a time.

This script can be combined with the script in " " to generate all the prime numbers in a range of numbers.

We request the user to enter two numbers to indicate the lower and upper limits of the range of numbers between which the user wants to generate the prime numbers. The lower limit can not be 1 because the number 1 does not have any factors and the command "factor" does not return any thing for 1. Thus we need to make sure the user enters a number bigger than 1. If the user enters 1, then we will prompt the user again to enter number greater than 1.

while [ $low -eq 1 ] do echo "Enter the lower limit,greater than 1" read low done echo "Enter the upper limit" read upper

Then we pass these two numbers to seq in a for loop

for mun in `seq $low $upper`

In each iteration of the for loop we use the factor command to find out if a number is prime or not.

do ret=$(factor $mun | grep $mun | cut -d ":" -f 2 | cut -d " " -f 2) if [ "$ret" -eq "$mun" ] then echo "$mun is prime" fi done

The full script looks as below.

#! /bin/bash low=1 count=0 while [ $low -eq 1 ] do echo "Enter the lower limit,greater than 1" read low done echo "Enter the upper limit" read upper for mun in `seq $low $upper` do ret=$(factor $mun | grep $mun | cut -d ":" -f 2 | cut -d " " -f 2) if [ "$ret" -eq "$mun" ] then echo "$mun is prime" ((count++)) fi done echo -e "\n There are $count number of prime numbers"

Save the script as range_prime.sh,give it execute permissions and run it.

$ chmod 777 range_prime.sh $ ./range_prim.sh Enter the lower limit 2 Enter the upper limit 20 2 is prime 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime There are $count number of prime numbers

Thus we can see the script is able to generate a list of all the prime numbers between 2 and 20.

Linux Script to find prime factors using the factor command

The command "factor" takes as input any integer number and returns the prime factors of the that number.

Example :

$ factor 6 6: 2 3 $ factor 131 131: 131

We can use this command to find wheter a given number is prime or not. If we pass a prime number as argument to the command factor, it returns the number itself as its prime factor. As shown above for the number 131.
We can pipe this output to grep,search for the number passed to factor in the output. If the output is comprised only of the input number then the given number is prime.
The following script does the same
#! /bin/bash echo "Please enter a number" read num ret=$(factor $num | grep $num | cut -d ":" -f 2 | cut -d " " -f 2) if [ "$ret" -eq "$num" ] then echo "$num is a prime number" else echo "$ num is not a prime number" fi

Save the above script as prime.sh, and give it execute permissions

chmod 777 prime.sh

Now execute the script and see the output

$ ./prime.sh Please enter a number 5 5 is a prime number $./prime.sh Please enter a number 20 20 is not a prime number

makefiles: Complex conditional execution

While doing the conditional execution in makefiles, using only if and ifneq allows us to check for one condition but to be able to check multiple conditions one after another, we can use either if or ifneq after the else to check for further conditions.
Syntax:

ifneq(<str1>,<str2>) statements else <if or ifneq condition> statements endif

If the ifneq condition fails then the flow will go to the else and check the condition specified after the else. We can use as many else statements as we require.
Let us say we have three "c" programs, hello_1.c, hello_2.c and hello_3.c. We need to compile them depending on which user is running the make command. hello_1.c should be compiled if we are running make as root, hello_2.c if we are running make as "user1" and for any other user hello_3.c. This can be achieved by the following makefile.

CC = cc -o pf=hello user = $(shell whoami) ifeq ($(user),root) targets := $(pf)_1 else ifeq ($(user),user1) targets = $(pf)_2 else targets = $(pf)_3 endif $(targets):$(targets).c $(CC) $(targets) $(targets).c

In the above makefile, first variable "user" is compared with "root" then with "user1". If both the conditions turn out to be false then the statements after the final else gets executed, which sets the targets to hello_3.c as required.

If we run the above makefile as root then we will get the output

cc -o hello_1 hello_1.c

If we run it as "user1" we will get the output

cc -o hello_2 hello_2.c

If we run it as any other user we will get the output

cc -o hello_3 hello_3.c

Conditional execution using ifneq

Conditional execution can also be done using ifneq which is the opposite of ifeq.

The syntax of ifneq is

ifneq(<str1>,<str2>) statements else statement endif

ifneq(,) returns true when and are not equal. If and are equal it jumps to the else statement.

Using the above logic, the example used in the post "Conditional execution using ifeq" can be re written using ifneq as below.

CC = cc -o pf=hello user = $(shell whoami) ifneq ($(user),root) targets := $(pf)_1 else targets = $(pf)_2 endif $(targets):$(targets).c $(CC) $(targets) $(targets).c

Thus ifneq checks if the current user is not root, which if true then sets the target to $(pf)_1, else it sets it to $(pf)_2.

If we execute the make command as root we will get the following output

$ make cc -o hello_2 hello_2.c

If we do the same as any other user other than root, we will get the following output

$ make cc -o hello_2 hello_2.c

Makefies : Conditional execution using ifeq

Conditions can be added in makefiles using "if" conditions, to ensure the commands get executed only under certain conditions.

The syntax of if in a makefile is

ifeq(<str1>,<str2>) statements else statement endif

Let us say we have two files hello1.c and hello2.c which we want to compile using makefile. But the condition for compiling these files is that if the user who is compiling is root then hello_1.c should be compiled,else for any other user hello_2.c should be compiled. We can use the if condition in makefile to achieve this.

This can be done using the following makefile

CC = cc -o pf=hello user = $(shell whoami) ifeq ($(user),root) targets := $(pf)_2 else targets = $(pf)_1 endif $(targets):$(targets).c $(CC) $(targets) $(targets).c

user = $(shell whoami)

Above statement assigns the current user name to the variable "user" using the command "whoami".

Then we use the "if" condition and check the user name and assign the target based on the result of the condition check.

If we execute the make command as root we will get the following output

$ make cc -o hello_2 hello_2.c

If we do the same as any other user other than root, we will get the following output

$ make cc -o hello_2 hello_2.c

seq : To generate a sequence of numbers

seq can be used to generate a sequence of numbers separated by any kind of separator as required.

$ seq 10 1 2 3 4 5 6 7 8 9 10

By default seq generates the range of numbers starting from 1. We can generate the list from any starting number by mentioning the stating number also as an argument.

$ seq 5 10 5 6 7 8 9 10

By default the numbers are generated separated by new lines. We can change the separator by using the option -s

$ seq -s ":" 5 10 5:6:7:8:9:10

We can make the number to be of equal length using the option -w

$ seq -w -s ":" 5 10 05:06:07:08:09:10

The increment by default is by one number,this can be changed by passing the increment number as the second argument.

$ seq -w -s ":" 5 2 20 05:07:09:11:13:15:17:19

The number 2 as the second argument indicates that the increment is to be by two numbers.

We can also generate a reverse seq of numbers

$ seq -w -s ":" 10 -1 5 10:09:08:07:06:05

Makefiles: Using variables

Prev: make is smart We can use variables in makefile to prevent typing the same strings over and over and also make the file more easy to understand.

Defining variables: Let us say we have a makefile to compile three independent executables hello_1, hello_2 and hello_3

all: hello_1 hello_2 hello_3 hello_1:hello_1.c cc -o hello_1 hello_1.c hello_2:hello_2.c cc -o hello_2 hello_2.c hello_3:hello_3.c cc -o hello_3 hello_3.c

In the above makefile we use the string "cc -o" repeatedly. Instead of typing the whole string every time we can create a variable for it.
We can create a variable of any name by using the "=" sign. The left hand would be the name of the variable and the right hand side would be the value of the variable.
Any where in the file if we want to use the value of the variable we just have to use the name of the variable in the format $() and make will automatically replace the variable with its value while executing.

CC = cc -o all: hello_1 hello_2 hello_3 hello_1:hello_1.c $(CC) hello_1 hello_1.c hello_2:hello_2.c $(CC) hello_2 hello_2.c hello_3:hello_3.c $(CC) hello_3 hello_3.c

In the above file have created a variable CC and used it whenever we needed cc -o.
Note that variables are case sensitive thus "cc" "CC" and "Cc" are all different.
We can also use variables for prefixes of various strings. Like in the example above "hello" is like a prefix to a number of strings, thus we can use a variable for it.

CC = cc -o pf=hello all: $(pf)_1 $(pf)_2 $(pf)_3 $(pf)_1:$(pf)_1.c $(CC) $(pf)_1 $(pf)_1.c $(pf)_2:hello_2.c $(CC) $(pf)_2 $(pf)_2.c $(pf)_3:hello_3.c $(CC) $(pf)_3 $(pf)_3.c

Recursive expanded variables : We can create recursive variables by using one variable while declaring another.

CC = cc -o pf=hello targets = $(pf)_1 $(pf)_2 $(pf)_3 all: $(targets) $(pf)_1:$(pf)_1.c $(CC) $(pf)_1 $(pf)_1.c $(pf)_2:hello_2.c $(CC) $(pf)_2 $(pf)_2.c $(pf)_3:hello_3.c $(CC) $(pf)_3 $(pf)_3.c

In the above example "targets" is a variable, which is a list of all the targets. The targets variable uses the variable "pf" , thus to find out what $(targets) refers to make will have to expand pf creating a recursion among variables any depth of such recursion is allowed.
The limitation of defining variables using "=" is that a variable can not refer to itself in recursion.

CC = cc -o pf=hello targets = $(pf)_1 $(pf)_2 targets = $(targets) $(pf)_3 all: $(targets) $(pf)_1:$(pf)_1.c $(CC) $(pf)_1 $(pf)_1.c $(pf)_2:hello_2.c $(CC) $(pf)_2 $(pf)_2.c $(pf)_3:hello_3.c $(CC) $(pf)_3 $(pf)_3.c

In the above example, the second definition of variable "targets" uses the "targets" itself in recursion. Such usage will result in an infinite loop, which make successfully detects and throws the error.

makefile:5: *** Recursive variable `targets' references itself (eventually). Stop.

Simply expanded variables This can be prevented by making use of simply expanded variables which are defined using ":=". The use of ":=" makes the expansion of all the variables in the assignment only once and stop, thus preventing the infinite loop.

Thus in the above example the second definition should be

CC = cc -o pf=hello targets = $(pf)_1 $(pf)_2 targets := $(targets) $(pf)_3 all: $(targets) $(pf)_1:$(pf)_1.c $(CC) $(pf)_1 $(pf)_1.c $(pf)_2:hello_2.c $(CC) $(pf)_2 $(pf)_2.c $(pf)_3:hello_3.c $(CC) $(pf)_3 $(pf)_3.c

Now make will not throw any error and will successfully compile the targets.

Using shell in declaration : We can also execute shell commands while defining variables.

CC = cc -o pf=hello targets = $(pf)_1 $(pf)_2 targets := $(targets) $(pf)_3 opd = $(shell pwd) all: $(targets) $(pf)_1:$(pf)_1.c $(CC) $(opd)/$(pf)_1 $(pf)_1.c $(pf)_2:hello_2.c $(CC) $(pf)_2 $(pf)_2.c $(pf)_3:hello_3.c $(CC) $(pf)_3 $(pf)_3.c

In the above example we executed the command "pwd" and assigned the result to the variable "opd" which we used while compiling to indicate the path where the compiled executable needs to be stored.

Makefiles:make is smart

Prev: Multiple independent targets

Till now to compile a c program we have passed the command to the makefile to compile a given c code. But make has built in intelligence and can work even without the command.

Let us say we have ta file

hello.c

#include<stdio.h> main() { printf("Hello world"); }

To compile this file using make we just need to create the makefile with the contents

makefile

hello:

make looks at the targets and if no dependencies and commands are mentioned in the makefile,it automatically looks for a file with the name .c i.e. in the above example hello.c and compiles it to create the executable.

$ make cc hello.c -o hello

If we want to make sure that the correct files are being compiled before actually generating the executable we can just print the commands that make is going to run by passing the option "--just-print".

$ make --just-print cc hello.c -o hello

In the above case the executable will not get generated, but it only prints the commands that will be executed.

We can also print the folders in which make is running the commands from using the option -w

$ make -w make: Entering directory `/home/user/temp' cc hello.c -o hello make: Leaving directory `/home/user/temp'

Next: Makefiles: Using variables

Makefiles: Multiple independent targets

Prev: Multiple dependent targets

The make command when executed with out any arguments always tries to create the first target. But in one makefile we can specify as many independent targets as we want and then choose to create the specific targets .

Let us say we have two programs

hello_1.c

#include<stdio.h> main() { printf("Hello world"); }

hello_2.c

#include<stdio.h> main() { printf("Hello universe"); }

The above two are independent programs which can be compiled on the command line using

$ cc -o hello_1 hello_1.c $ cc -o hello_2 hello_2.c

The same can be done by creating a makefile with two targets "hello_1" and "hello_2".

makefile:

hello_1: hello_1.c cc -o hello_1 hello_1.c hello_2: hello_2.c cc -o hello_2 hello_2.c

Now if we run the command make

$ make cc -o hello_1 hello_1.c

We can see that if use the command make with no arguments the first target i.e. hello_1 gets crated. Now if we want to create the second target we will have to pass the second target to the make command as an argument.

$ make hello_2 cc hello_2.c -o hello_2

Thus we can specify any specific target we want to create as the argument to the command make.

If we want to option of creating all the independent targets with out specifying every target separately we add a target to the makefile and mention all the targets as the dependencies.

makefile:

all: hello_1 hello_2 hello_1: hello_1.c cc -o hello_1 hello_1.c hello_2: hello_2.c cc -o hello_2 hello_2.c

Now we can create hello_1 and hello_2 by running make with all as the target.

$ make all cc -o hello_1 hello_1.c cc -o hello_2 hello_2.c

Thus we can use makefile with multiple targets and selectively create the required targets or create all of them together.

Next: Makefiles: make is smart

Makefiles: Dependent targets

Prev: Makefiles : Introduction The makefiles can have as many targets as we want, and they could be dependent on another or independent.

Let us say we have the following codes
hello_main.c

#include<stdio.h> main() { print_hello(); }

print_hello.c

print_hello() { printf("Hello world \n"); }

The first program is calling a function declared in the second program. To compile these codes we can run the command

$ cc -o final hello_main.c print_hello.c

This can be broken down into the following steps
Creating the object code

$ cc -c hello_main.c $ cc -c print_hello.c

This will generate the object files "hello_main.o" and "print_hello.o"

Now we can club the object codes into one executable

$ cc -o hello hello_print_main.o print_hello.o

This will generate the final executable hello.

For creating the executable hello, hello_main.o and print_hello.o are the prerequisites.
Thus the makefile entry for target hello is

hello: hello_main.o print_hello.o cc -o hello hello_print_main.o print_hello.o

For creating the object codes, hello_main.o and print_hello.o are the targets and hello_main.c and print_hello.c are the prerequisites

Thus the make file entries for the two object codes is

hello_main.o: hello_main.c cc -c hello_main.c print_main.o: print_main.c cc -c print_main.c

Combining the above two we can create the full makefile

makefile:

hello: hello_main.o print_hello.o cc -o hello hello_main.o print_hello.o hello_main.o: hello_main.c cc -c hello_main.c print_hello.o: print_hello.c cc -c print_hello.c

Note the order in which the entries have been added. The final target is the first entry, the prerequisites for the final target are created by making them as targets in the subsequent entries.

Now run the command make

$ make cc -c -o hello_main.o hello_print.c cc -c print.c cc -o final hello_main.o print.o

We can see that make starts compiling from the first independent target hello_main.o then it compiles print_hello.o then it create the final executable using the two object files.

Now open the program print_hello.c and modify the print statement

print_hello() { printf("Hello world again"); }

Save the program and run the command make again.

$make cc -c hello_print.c cc -o hello hello_main.o hello_print.o

We can see that make compiled only the modified program and did not compile hello_main.c which was not modified after the executable "hello" was created.

The above split was shown just show the concept of dependent targets. We can compile the same code using the shorter makefile

makefie:

hello: hello_print.c print.c cc -o hello_print hello_print.c print.c

If you misspell any of the prerequisite names then make will throw an error and fail. For eg. if we create the above makefile with the file name hell_print.c

hello: hell_print.c print.c cc -o hello_print hello_print.c print.c

On running make we will get the error

make: *** No rule to make target `hell_print.c', needed by `hello'. Stop.

The above error indicates that the problem is with the file name "hell_print.c" as the makefile is unable to find a file with that name. Next: Makefiles :Multiple Independent targets

Makefiles: Introduction

Makefiles: Introduction Makefiles are the files used by the utility make. make helps in compiling a source code into an executable or automate execution of commands listed in the makefile.

Let us say we have a file "hello.c"

hello.c

#include<stdio.h> main() { printf("Hello world"); }

The usual compilation of this in linux using gcc is

$ cc hello.c -o hello

We can use a makefile to do the same compilation
The syntax of writing a makefile is

Target:prerequisite <One tab space> command

A makefile is comprised of

Target : The executable which has to be generated. In the above case the target is the executable hello.

Prerequisite: The source files required to generated the target. In the above example the source is hello.c

Command: If the prerequisite is available which command will convert it into the target ? The command in the above example is "cc -o hello.c -o hello". The command always has to be preceded by a single tab space

Create a file by the name "Makefile" and enter the contents

Makefile

hello:hello.c cc -o hello hello.c

Now open a terminal and cd to the folder where the makefile is stored.
Run the command

$ make cc -o hello hello.c

We can see that make has run the command and generated the executable just as we did from the command line.
You might get the following error if you have omitted the tab space before the command.

Makefile:2: *** missing separator. Stop.

If you name the makefile wrongly You might get the error

make: *** No targets specified and no makefile found. Stop.

The makefile can also be named with any other name we want but in that case we need to use the option "-f" with the command make. If we want to name the above makefile as my_makefile then we need to use the command make as make -f my_makefile

After the makefile has generated the executable if we run the command make again we will get the message

make: `hello' is up to date.

This is a special property of the make utility. It will generated a new executable of the mentioned target only if the target does not exist or the source file has been modified after the target has been generated. Next : Makefiles: Dependent targets

Extracting pages from a pdf file using linux command line

pdftk is a tool which we can use to split or extract pages from a pdf document.

To install pdfktk on debian based systems

sudo apt-get install pdftk

Let us say we have a pdf file,temp.pdf, with 100 pages in it. We want to extranct the pages 20 to 30 and create a new pdf . We can do it using pdftk

$ pdftk temp.pdf cat 20-30 output new.pdf

If the command returns to the prompt with no errors, we will have a new pdf file in the same directory with the name new.pdf.

We can pick specific pages instead of a range by just passing the page numbers.

To create a new pdf by extracting pages 21,25, and 28 we can use.

$ pdftk temp.pdf cat 21 25 28 output new.pdf

We can also select only even/odd pages by passing the option even/odd respectively

To extract all the odd numbered pages we can use the range as 1-end and use the keyword odd.

$pdftk temp.pdf cat 1-endodd

Truncate:Reduce file size from command line in linux

We can change the size of a file from the command line using the command truncate.

For e.g.

$ ls -lh -rw-r--r-- 1 nitin adm 7.3K Apr 5 2012 temp.txt -rw-r--r-- 1 nitin adm 9.4K Apr 5 2012 temp1.txt

We can change the size of temp1.txt to any size we need.

$ truncate -s 4k temp1.txt $ ls -rw-r--r-- 1 nitin adm 7.3K Apr 5 2012 temp.txt -rw-r--r-- 1 nitin adm 4.0K Apr 5 2012 temp1.txt

But be careful as the truncation simply removes the content of the file to reduce its size.

Running .dat files in linux and using vlc

.dat files which are generally vedio files are played easily in windows media player, but in linux not all players support .dat files.

We can use one of the following methods to run a .dat file

1. using vlc
vlc by default throws error when we try to run a .dat file.

File reading failed: VLC could not read the file.

To run a .dat in a vedio cd file using vlc do the following

open vlc media-> open Disc Under Disc Selection : Select the SVCD/VCD Change Disc Device to /dev/sr0 or levae it blank click on play

The file in the cd should start playing automatically.

2. We can use the gxine player to run .dat file

$ sudo apt-get install gxine

Once the installation is done a new player called "gxine" will appear under sound and video menu which will directly play the .dat file with out any problems.

3. We can install windows media player using wine and run the .dat file from the windows media player.

du: Finding the file/folder size from command line in linux

To find the amount of space occupied by any file or folder in the system we can use the command du.

Let us say we have a folder test which contains the files file1,file2,file3,temp

To find the size of the folder test

$ du test 4 test/temp 8 test

The first column Indicates the size of the folder and the second column gives the name of the folder. By default du also lists the sizes of only the sub folders and not of files.
In case we want to have a look at the size of the files too we can use the option "-a"

$ du -a test 0 test/file2 0 test/file3 0 test/file1 4 test/temp 8 test

The size column if displayed with no suffix can be difficult to read for bigger sized files, to make the reading easier we can use the option "-h" which sill convert it into more human readable form

$ du -h test 4.0K test/temp 8.0K test

The suffix K indicating the size is in Kilo bytes. For Mega bytes it will be M for giga G etc.
If we just want the size of the folder and not its sub folders we can use the option "-s"

$ du -s test 8.0K test

We can also pass file names to find the size of a file instead of a folder.

$ du -h test/file1 0 test/file1

Thus we can easily find the space occupied by any file or folder on the system using the du command

Different ways to find the linux kernel version

Here are two ways to find out the currently running kernel version of linux

1. Using uname to find the linux kernel version

$ uname -r 3.2.1

2. Using sysctl to find the linux kernel version

$ sysctl kernel.osrelease kernel.osrelease = 3.2.1

3. Using proc entry to find the linux kernel version

$ cat cat /proc/sys/kernel/osrelease 3.2.1

No manual entry for pthread_create

While learning pthreads, if you try to have look at the man pages of pthread and get the error

$ man pthread_create No manual entry for pthread_create

Then you need to install the package manpages-posix-dev. If you are running debian based systems you can run the command.

$ sudo apt-get install manpages-posix-dev

Once the package is installed you should be able see the man pages for all posix related functions.

Finding the filesystem type of a partition in linux

To find the type of filesystem a partition or a media is of we can use the commands "df" or "mount".

Using df

$ df -T Filesystem Type 1K-blocks Used Available Use% Mounted on /dev/sda1 ext4 53067292 47601336 2770228 95% / tmpfs tmpfs 127140 0 127140 0% /lib/init/rw udev tmpfs 121484 220 121264 1% /dev tmpfs tmpfs 127140 4 127136 1% /dev/shm

The column with the heading "Type" gives the filesystem type. So the partition /dev/sda1 is of type ext4

To find the filesystem type of a specific partition pass the partition as the argument.

$ df -T /dev/sda1 Filesystem Type 1K-blocks Used Available Use% Mounted on /dev/sda1 ext4 53067292 47601332 2770232 95% /

Using mount

$ mount /dev/sda1 on / type ext4 (rw,errors=remount-ro) tmpfs on /lib/init/rw type tmpfs (rw,nosuid,mode=0755) proc on /proc type proc (rw,noexec,nosuid,nodev) sysfs on /sys type sysfs (rw,noexec,nosuid,nodev) udev on /dev type tmpfs (rw,mode=0755) tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev) devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=620) fusectl on /sys/fs/fuse/connections type fusectl (rw) binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,noexec,nosuid,nodev) none on /proc/fs/vmblock/mountPoint type vmblock (rw)

As listed the partition /dev/sda1 is of type ext4.
We can find the specific partition type by combining mount with grep.

$ mount | grep /dev/sda1 /dev/sda1 on / type ext4 (rw,errors=remount-ro)

Finding the current runlevel of linux

To find the current runlevel of the system we can use the following commands

$ who -r run-level 2 2012-08-28 19:43 last=

The output indicates that the current runlevel is "2" , followed by the date and the time. If there was any other runlevel used before it would be listed after "last=".
The second command that can be used is

$ runlevel N 2

The second number is the current runlevel. The first number is the previous runlevel.

readlink: Finding file to which a softlink pointing to

readlink is a command that can be used on a softlink to find out the file to which it is actualy pointing to. For example if we have a file "temp" which is a softlink, we can run readlink of temp as follows

$ readlink temp test

This indicates that readlink is a softlink of the file temp. If we want the full path to the file "test" we can pass the option "-f"

$ readlink -f temp /home/user/Desktop/test

Thus we can find the full path to the file to which the softlink is pointing to .

Creating a soft link.

symbolic links are used in linux to create a link to a folder or a file which is located in a different location, so that the same file or folder can be accessed from both the locations.
Softlinks are created using the command

ln -s original_file link

Example:

If we have a file "temp1" in the path

/home/user1/folder1/temp1

And if we want to create a link to this file in the path

/home/user1/folder2/

We can do it as follows.

$ ln -s /home/user1/folder1/temp1 /home/user1/folder2/link

Now if we do a long listing of the new link that was created we can see that it is a soflink by the way it gets listed

$ ls -l /home/user1/folder2/link lrwxrwxrwx 1 user1 user1 5 Aug 18 15:45 link -> ../folder1/temp1

The first letter, l, in the long listing indicates that the file is a softlink and the last column indicates the file to which it is a softlink

The new link file is just a pointer to the original file and not a new copy of it and hence it occupies just enough space required for a link, which is very very small, rather than for the whole file.
The file can be opened and modified from either of the locations, and the changes will be reflected in files at both the locations.

Removing grub rescue entries from grub menu

The grub2 by default creates an entry for recovery mode in its menu,using which we can log into single user mode and trouble shoot various problems in the system.

But if we do not want this entry we can remove this entry from the grub by changing the grub configuration.

Open the file

/etc/grub/default

Note : Super user privileges are required to modify the file

Edit the line

# GRUB_DISABLE_LINUX_RECOVERY="true"

Uncomment the line by removing the "#" in front of the line.

Now update the grub by running

sudo update-grub

Next time the system is rebooted the grub menu will not have the recovery entries.

Making the grub beep on displaying the menu

In grub2, when the menu is displayed it by default does not make any sound to alert the user about the display.
This behavior can be changed so that the grub creates a beep sound as soon as the grub menu gets displayed, so that the user, if he or she is not looking at the monitor, gets notified about the display.
Open the file

/etc/default/grub

and go to the line

# GRUB_INIT_TUNE="480 440 1"

Uncomment the the line by removing the "#" in the beginning.

Save and quit the file.
Now run the command

$ sudo update-grub

Now reboot the system and we should be able to hear a beep when the grub menu gets displayed.

Pointer to structure from its member pointer: container_of

In c programming, we use structures to store variables of different data types in one kind of variable. Each variable in the structure is termed as a member of the structure. The memory allocation for these members is always sequential.
Example

struct temp { int i; char ch; }

In the above structure the addresses allocated for members "i" and "ch" will be sequential in the memory.

Using this property of the structure, if we know the pointer to a member of the structure we can retrieve the pointer to the structure with the help offsetof function.
In the post "offset of" we saw how we can retrieve the offset of a member with in the structure.

As the size occupied by each data type is fixed once we know the offset of the member and its pointer, we can subtract the offset from the pointer to get a pointer to the structure.

For example in the above structure if the pointer to the "char ch" is 1000. The offset of function will return 4 for "ch" as it is after an integer in the structure.
Thus the pointer to the structure would be "1000-4 = 996".

The same is shown in the example code below.

We allocate memory for one structure,test1, of type "temp" and assign values to "i" and "ch".

test1 = malloc(sizeof(struct temp)); test1->i = 10; test1->ch="h";

Then we assign the pointer of ch to a char pointer. ptr = &(test1->ch);

Then we subtract the offset of "ch" from the pointer and assign the return value to a new pointer to a structure,test2, of type temp.

test2 = (struct temp *) (ptr - offsetof(struct temp,ch));

If the pointer assigned to test2 is the correct , we should be able to access the value of "i" using test2.
Thus we print the value of "i" using test2

printf("%d",test2->i);

Here is the full code

struct_ptr.c

#include<stdio.h> #include<stdlib.h> #include<stddef.h> struct temp { int i; char ch; } ; main() { int size; char *ptr; struct temp *test1; struct temp *test2; test1 = malloc(sizeof(struct temp)); test1->i = 10; test1->ch="h"; ptr = &(test1->ch); test2 = (struct temp *) (ptr - offsetof(struct temp,ch)); printf("Value of integer is %d",test2->i); }

Compile and execute it.

$ cc struct_ptr.c -o struct_ptr $ ./struct_ptr Value of int is 10

Thus we can see that we were able to retrieve the pointer to the parent structure from the pointer to the member.

The same steps are used in the container_of function which is used in the linux kernel code.

/** * container_of - cast a member of a structure out to the containing structure * @ptr: the pointer to the member. * @type: the type of the container struct this is embedded in. * @member: the name of the member within the struct. * */ #define container_of(ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );})

By passing pointer to the member of the structure in ptr and the structure type as argument type and the name of the member of which ptr is the pointer to we can retrieve the pointer to the parent structure just as we did in the example above.

Example usage in kernel code :

File leds.c

struct versatile_led { struct led_classdev cdev; u8 mask; }; static void versatile_led_set(struct led_classdev *cdev, enum led_brightness b) { struct versatile_led *led = container_of(cdev, struct versatile_led, cdev);

By passing a pointer to the cdev structure,the structure type as "versatile_led" and the member of the structure as cdev we are able to get a pointer to the structure that contains the cdev and hence get access to other members of the structure.

unlink: Command to delete files

The command unlink can be used to delete files.

Example : To delete a file called temp

$ unlink temp

But unlink lacks any of the other options that come with the command "rm" which is also meant to delete files and unlink can only delete file and does not work on folders.

offsetof: Using the offsetof funcion in c

The "offsetof" function in c is useful in determining the offset of members with in a structure or union.
It is defined in the header file "stddef.h".
The syntax is

offsetof(TYPE,MEMBER);

Arguments:

TYPE: The type of the structure in which the offset is to be determined MEMBER: The member in the structure TYPE whose offset is required.

Example :

Let say we have a structure foo

struct foo { int i; char ch; };

The structure "foo" has a integer member which generally would of 4 bytes on a 32 bit system and a chat member which would be one byte.
Thus the offset of the member "ch" in the structure "foo" would be the number of bytes occupied by "int" which is "4".

Here is a example code which uses "offsetof" to find the offset of ch in the structre foo.

#include<stdio.h> #include<stdlib.h> #include<stddef.h> struct foo { int i; char ch; } ; main() { int size; size = offsetof(struct foo,ch); printf("offet is = %d",size); }

Compile the code and execute it

$ cc offset.c -o offset $ ./offset offset is = 4

Try changing adding new members to the structure foo and see how the result changes depending on the members added.

Try with the structure :

struct foo { int arr[10]; char ch; };

$ cc offset.c -o offset $ ./offset offset is 40

The offset is the size of the array which is 4 X 10 = 40.

Answers to linux history quiz

1.In which year was the linux kernel released under GNU GPL license for the first time?
Ans.1992

2.The penguin was chosen as the official mascot for linux in
Ans.1996

3. The linux foundation is the merger of
Ans. OSDL and Free standards group

4. Which famous computer scientist said this in 1992 "Linux is obsolete"?
Ans. Andrew S. Tanenbaum

5. Linux 1.0 was released in
Ans. 1994

6. When did microsoft first contribute to linux source code ?
Ans. 2009

7. Which of the following is a linux based company and was started in 1994 ?
Ans. Redhat

8. Which of the following companies invested a billion dollars in to linux in the year 2001 ?
Ans. IBM

9. In which year did Linus Torvalds appear on the cover of Business week ?
Ans. 2005

10. Which of the following Linux Desktop environment (GUI) was started in the year 1997 ?
Ans. GNOME

Linux history quiz

Quiz On history of Linux

A simple quiz on history of Linux

1. In which year was the linux kernel released under GNU GPL license for the first time?

1991
1992
1993
1996


2. The penguin was chosen as the official mascot for linux in

1992
2000
1994
1996


3. "The linux foundation" is the merger of

OSDL and Free standards group
GNU and OSDL
The linux users and unix users group
Many small linux supporting groups


4. Which famous computer scientist said this in 1992 "Linux is obsolete" ?

Andrew S. Tanenbaum
Alan Cox
Ken Thompson
Richard Stallman


5. Linux 1.0 was released in

1999
1994
1996
1992


6. When did microsoft first contribute to linux source code ?

2002
1995
2009
2011


7. Which of the following is a linux based company and was started in 1994 ?

Ubuntu
Redhat
IBM
Apple


8. Which of the following companies invested a billion dollars in to linux in the year 2001 ?

Redhat
Canonical
IBM
Google


9. In which year did Linus Torvalds appear on the cover of Business week ?

2000
2003
2005
1999


10. Which of the following Linux Desktop environment (GUI) was started in the year 1997 ?

GNOME
KDE
Unity
Enlightment

Answers to the uiz are available at : Answers to linux history quiz

expand: To convert a tab space to space characters

expand: Command used to convert the tab space to separate space characters.

Example:

Let us say we we have a file "temp" with the following contents.

temp:

one 1 two 2 three 3 four 4

In each line we have one tab space, which is equivalent to 8 space characters. To convert this one tab space to 8 space characters we can run the command expand on the file.

$ expand temp > temp_1 $ cat temp_1 one 1 two 2 three 3 four 4

The new file "temp_1" looks the same as the file "temp" but if we open the file to edit it, we will encounter 8 space characters instead of tab on every line.

To change the number of space characters from 8 to any number of our choice we can use the option "-t".

$ expand -t 1 temp one 1 two 2 three 3 four 4

We can see that the tab has been replaced by single space. The number that you specify after "-t" will be the number of spaces that will put instead of the tab space.

We can also restrict the command to work only at the beginning of a file by passing the option "-i"

Example :

Let us modify the file temp and add a tab at the beginning of the first line.

temp:

one 1 two 2 three 3 four 4

Now use expand on the file along with option "-i"

$ expand -i -t 1 temp one 1 two 2 three 3 four 4

We can see that only the tab at the beginning of the first line has been removed,but the rest of the tabs are intact.

tr: To translate characters

The command "tr" can be used to translate/change or delete characters from the input.

By default tr takes two arguments, the first one being the set of characters to be searched for and the second argument being the set of characters to be replaced with . The default input is the standard input.

Example:

$ tr x y xyx yyy $

The command waits for user to enter a string and then hit the return key. In the above example on entering "xyx" the character x has been replaced by character y which was what was passed as arguments to the command.

We can also pass multiple characters as arguments and each characters will be considered separately and not as a string and each of the characters in argument1 will be replaced by the corresponding character in the argument2

Example:

$ tr xyz abc xyz abc x a y b z c

If the string length of argument1 is greater than that of argument2 then the last character of argument2 is applied to all the characters of argument1 that are after the string length of argument2.

Example :

$ tr xyz ab xyz abb x a y b z b

As we can see both y and z are replaced by b.

We can change this behavior by passing the option "-t" which will truncate the characters of first argument to the same as the length of argument2.

$ tr -t xyz a xyz ayz x a y y z z

Thus we can see, "y" and "z" both are not replaced by character.

The command can be applied on files by using the input redirection.

Example:

Let say we have a file,temp, with following contents

temp:

one 1 two 2 three 3 four 4

$ tr o O < temp One 1 twO 2 three 3 fOur 4

We can see that all o have been replaced with O.

Instead of translating, we can delete characters too by passing the option "-d" .

Example:

$ tr -d [:digit:] < temp one two three four

Thus we can see that all the digits in the file have been deleted.

Other examples:

We can user "tr" to convert all the characters in a file to upper case too.

$ tr [:lower:] [:upper:] < temp ONE 1 TWO 2 THREE 3 FOUR 4

Using tr over a range of characters

$ tr -d 1-3 < temp one two three four 4

Deleting repetitive characters

$ tr -s e eeee e $