Project 2 kthreads, concurrency, shuttle

Highlevel overview User space –program wants to control the shuttle simulation by sending requests. –start_shuttle() –issue_request() –stop_shuttle() Kernel space program wants to simulate the shuttle according those requests. Need to use a thread to simulate the shuttle running.

Kthreads Thread: basic executable unit. Run the shuttle in its own kthread, not the thread that calls the module_init function.

kthreads Kernel Threads Kthread_run(threadfn, data, name,...) –Creates a new thread of execution that starts with the function pointed to by threadfn –threadfn: fuction pointer –data: data passed to threadfn –name: name of the thread

while shuttle_running if users want get off at current terminal Unload (release space) if users want get on at current terminal and have space (..other performance logic) Load (consume space) Move to next desired terminal (*) endwhile

Module (1) Start a new kernel thread, performing a infinite loop. (2) Simulating the shuttle (load, unload, move to next) (3) Finally you may use kthread_stop to stop that thread.

Structure static int yourshuttle_init(void) { //create an proc entry //set function pointers } static void yourshuttle_exit(void) { //reset function pointers to null //remove module data file module_init(yourshuttle_init); module_exit(yourshuttle_exit);

Structure int yourstartshuttle(void) { //initilization //kthread_run } int yourissuerequest(pass_type, initial_terminal, dest_terminal) { //add pass } int yourstopshuttle(void) { //release resources

Add one shuttle

Good shuttle

Remove one shuttle

Good shuttle

Simultaneously shuttle

12345

Bad shuttle

That is correct shuttle

Why Two processes(threads) are accessing the same data. The order of doing things matters. Potential problem, unpredictable.

Concurrency problem? User space: –start_taxi, issue_request, stop_taxi Kernel space: –simulate the shuttle and the queues Bad thing happens if they are accessing the same queue.

Protection There can not be multiple threads accessing the same data, simultaneously. User space –add one passenger to the queue Kernel space –remove one passenger from the queue

"Lock" The solution is to use lock. When a thread wants to access the queue, it first check if it is locked: –if yes, then it waits until it becomes unlocked –if no, then it is fine to move on.

Add one lock before accessing the data; Remove the lock after accessing the data; What is a lock –mutex –semaphore –atom –......

Mutex Semaphone is old... do not use semaphone. Use mutex. Put a pair of mutex lock before and after the critical section.

mutex struct mutex lock; mutex_init(&lock); mutex_lock(&lock); { } mutex_unlock(&lock);

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m)

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m) Requests lock Receives it

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m) Doing stuff

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m) Requests lock Already locked Waits...

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m) Releases lock Notifies threads

Mutex Kernel Module (Prepares Lock) struct mutex m; mutex_init(&m); User-space Code (Adds Alice) Kernel Module (Removes Bob) mutex_lock(&m) list_item->data = Alice list_item->next = NULL list_item->prev = bob_item Queue->last = list_item mutex_unlock(&m); mutex_lock(&m) newlast = list_item->last->prev newlast->next = NULL delete Queue->last Queue->last = newlast mutex_unlock(&m) Wakes up Requests lock Gets lock

Q&A