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