Threads and Locking Ioctl operations

Threads Lightweight processes What’s wrong with processes? –fork() is expensive – 10 to 100 times slower –Inter process communication For returning information from child to parent

Threads… Shared components –Global memory –Instructions –Most data –Open descriptors (files, sockets etc) –Signal handlers Not shared… –Thread ID –Registers, Program counter, stack pointer –Stack –Errno –Signal mask –Priority

Creation Thread equivalent of fork() int pthread_create( pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg ); Returns 0 is OK, and non-zero (> 0) if error.

Termination Return from initial fuction. void pthread_exit(void * status) exit() called by any thread main() returns

Waiting for child thread to exit int pthread_join(pthread_t tid, void **status) Equivalent of waitpid()

Detaching a thread The detached thread can act as daemon thread The parent thread doesn’t need to wait int pthread_detach(pthread_t tid) Detaching self : pthread_detach(pthread_self())

Echo client-server Server S1S2 Read Thread Write Thread Read Thread Write Thread listenfd Read Write Read Client1 Client2

Thread-based Echo Server

main() { int listenfd, connfd; int len; /* Start the usual way */ listenfd = Socket(…); Bind(listenfd, …); Listen(listenfd, …) for ( ; ; ) { len = addrlen; connfd = Accept(listenfd, …); /* Create a thread in service_func routine */ Pthread_create(NULL, NULL, service_func, (void *) connfd); }

void * service_func(void *arg) { int local_connfd; /* release parent from waiting */ Pthread_detach(pthread_self()); /* extract connfd from argument */ local_connfd = (int) arg; /* receive and echo client’s message */ str_echo(local_connfd); /* Terminate the connection */ Close(local_connfd); return(NULL); }

Thread-based Echo Client

int sockfd; FILE *fp; main() { pthread_t tid; fp = fopen(…); /* Start the usual way */ sockfd = Socket(…); … Connect(…); /* Create a thread to send data */ Pthread_create(&tid, NULL, write_func, NULL); /* read data from sockfd */ read_func(); /* wait for child thread */ Pthread_join(tid, NULL); }

void * write_func(void *arg) { char sendline[MAXLINE]; while( more data in fp) Read from fp into sendline[]; write sendline[] into sockfd; Shutdown(sockfd, SHUT_WR); return(NULL); } void read_func() { char recvline[MAXLINE]; while ( more data from sockfd) read from sockfd into recvline[]; write from recvline[] to stdout; }

Mutex – for mutual exclusion int counter = 0; void *thread_func(void *arg) { int val; /* unprotected code – why? */ val = counter; counter = val + 1; return NULL; }

Mutex… int counter = 0; ptread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; void *thread_func(void *arg) { int val; /* protected by mutex */ Pthread_mutex_lock( &mutex ); val = counter; counter = val + 1; Pthread_mutex_unlock( &mutex ); return NULL; }

Condition Variable – for signaling Think of Producer – consumer problem Producers and consumers run in separate threads. Producer produces data and consumer consumes data. Consumer has to inform producer when data is available

Without condition variables

/* Globals */ int data_avail = 0; int pthread_mutex_t data_mutex =PTHREAD_MUTEX_INITIALIZER; void *producer(void *) { Pthread_mutex_lock(&data_mutex); Produce data Insert data into queue; data_avail++; Pthread_mutex_unlock(&data_mutex); consume_data(); }

void *consumer(void *) { Pthread_mutex_lock(&data_mutex); while( !data_avail ) /* do nothing – keep looping!!*/; Extract data from queue; if (queue is empty)data_avail = 0; Pthread_mutex_unlock(&data_mutex); consume_data(); }

With condition variables

int data_avail = 0; int pthread_mutex_t data_mutex =PTHREAD_MUTEX_INITIALIZER; int pthread_cont_t data_cond = PTHREAD_COND_INITIALIZER; void *producer(void *) { Pthread_mutex_lock(&data_mutex); Produce data Insert data into queue; data_avail++; Pthread_cond_signal(&data_cond); Pthread_mutex_unlock(&data_mutex); consume_data(); }

void *consumer(void *) { Pthread_mutex_lock(&data_mutex); while( !data_avail ) { /* sleep on condition variable*/ Pthread_cond_wait(&data_cond, &data_mutex); } /*woken up */ Extract data from queue; if (queue is empty)data_avail = 0; Pthread_mutex_unlock(&data_mutex); consume_data(); }

ioctl()

Handles miscellaneous properties of a file/device referenced by a descriptor. –In our case, network interfaces. int ioctl(int fd, int request, void * arg) –Socket operations –File operations –Interface configuration –ARP cache –Routing table

SIOSPGRP/SIOGPGRP –set/get process/group ID of a socket FIONREAD –Return number of bytes in socket buffer SIOCGIFCONF –Get list of all interfaces SIOCGIFBRDADDR/ SIOCSIFBRDADDR –Get/set broadcast address SIOCGARP/SIOCSARP/SIOCDARP –Get/modify/delete ARP cache entry. SIOCADDRT/SIOCDELRT –Add/delete routes