Advanced Operating Systems: Lecture 8 - Mr. Farhan Zaidi

Advanced Operating Systems - Lecture 8: POSIX threads. This lecture will cover the following: POSIX threads (pthreads) standard interface and calls; simple pthreads hello world program; linux processes and threads; process/threads states and FSM in linux; looking ahead into the next lecture;...

CS703 – Advanced  Operating Systems

By Mr Farhan Zaidi

Lecture No. 8

and calls

 The clone() system call

 Fields in task_struct in Linux

 Looking ahead into the next lecture

 Re-cap of lecture

 Pthreads: Standard interface for ~60 functions that manipulate threads

from C programs.

 Creating and reaping threads.

 pthread_create

 pthread_join

 Determining your thread ID

 pthread_self

 Terminating threads

 pthread_cancel

 pthread_exit

 exit [terminates all threads] , ret [terminates current thread]

 Synchronizing access to shared variables

 pthread_mutex_init

 pthread_mutex_[un]lock

 pthread_cond_init

 pthread_cond_[timed]wait

/*

* hello.c - Pthreads "hello, world" program

*/

#include "csapp.h"

void *thread(void *vargp);

int main() {

pthread_t tid;

Pthread_create(&tid, NULL, thread, NULL);

Pthread_join(tid, NULL);

exit(0);

}

/* thread routine */

void *thread(void *vargp) {

printf("Hello, world!\n");

return NULL;

Thread attributes (usually NULL)

Thread arguments

(void *p)

return value (void **p)

main thread

peer thread

return NULL;

main thread waits for

peer thread to terminate

exit()

terminates main thread and

any peer threads

call Pthread_create()

call Pthread_join()

Pthread_join() returns

printf()

(peer thread terminates) Pthread_create() returns

 Linux uses the same internal representation for processes and threads; a thread is simply a new process that happens to share the same address space as its parent.

 A distinction is only made when a new thread is created by the

clone system call.

 fork creates a new process with its own entirely new process

context

 clone creates a new process with its own identity, but that is

allowed to share the data structures of its parent

 Using clone gives an application fine-grained control over

exactly what is shared between two threads.

 CLONE_CLEARID Clear the task ID.

 CLONE_DETACHED The parent does not want a SIGCHLD signal sent on exit.

 CLONE_FILES Shares the table that identifies the open files.

 CLONE_FS Shares the table that identifies the root directory and the current working

directory, as well as the value of the bit mask used to mask the initial file permissions of a new file.

 CLONE_IDLETASK Set PID to zero, which refers to an idle task The idle task is

employed when all available tasks are blocked waiting for resources.

 CLONE_PARENT Caller and new task share the same parent process.

 CLONE_PTRACE If the parent process is being traced, the child process will also be

traced.

 CLONE_SIGHAND Shares the table that identifies the signal handlers.

 CLONE_THREAD Inserts this process into the same thread group of the parent If this flag

is true, it implicitly enforces CLONE_PARENT.

 CLONE_VFORK If set, the parent does not get scheduled for execution until the child

invokes the execve() system call.

 CLONE_VM Shares the address space (memory descriptor and all page tables).

clone() with specific parameters

 clone(fp, data, flags, stack)

 " " means "don’t call this directly"

 fp is thread start function, data is params

 flags is of CLONE_ flags

 stack is address of user stack

 clone() calls do_fork() to do the work

 Linux has a small number of kernel threads that run

continuously in the kernel (daemons)

 No user address space (only kernel mapped)

 Creating: kernel_thread()

 Process 0: idle process

 Process 1

 Spawns several kernel threads before transitioning to user mode as /sbin/init

 kflushd (bdflush) – Flush dirty buffers to disk under "memory pressure"

 kupdate – Periodically flushes old buffers to disk

 kswapd – Swapping daemon

 In Linux terminology, processes are called tasks

 Linux has a list of process descriptors

 (which are of type task_struct defined in

include/linux/sched.h in Linux source tree)

 The maximum number of threads/processes allowed

is dependent upon the amount of memory in the

system

 Check /proc/sys/kernel/threads_max for the current limit By writing to that file, the limit can be changed

on the fly (by the superuser)

 Users: pid; Kernel: address of descriptor

 Pids dynamically allocated, reused

 16 bits – 32767, avoid immediate reuse

 Pid to address hash

 static task_array

 Statically limited # tasks

 This limitation removed in 2.4

 current->pid (macro)

 Highlights

 alloc_task_struct()

 find_empty_process()

 get_pid()

 Update ancestry

 Copy components based on flags

 copy_thread()

 Link into task list, update nr_tasks

 wake_up_process()

 The process control blocks are called descriptors

 They are kept in circular linked lists

 The linked list implementation in the kernel uses the following structure as a node:

 struct list_head {

struct list_head *next, *prev;

};

 The linked lists are circular, so there is no head or tail node You can start at any node and traverse the whole list

 Scheduling information: Information needed by Linux to schedule

processes A process can be normal or real time and has a priority Real-time processes are scheduled before normal processes, and within each category, relative priorities can be used A counter keeps track of the amount of time a process is allowed to execute.

 Identifiers: Each process has a unique process identifier and also has user

and group identifiers A group identifier is used to assign resource access

privileges to a group of processes.

 Interprocess communication: Linux supports the IPC mechanisms found in

UNIX SVR4

 Links: Each process includes a link to its parent process, links to its siblings

(processes with the same parent), and links to all of its children.

 Times and timers: Includes process creation time and the amount of

processor time so far consumed by the process A process may also have associated one or more interval timers A process defines an interval timer by

the

 current and the root directories for this process.

context of this process

executing or it is ready to execute.

as the end of an I/O operation, the availability of a resource, or a signal from another process.

 Interruptible state is that in an uninterruptible state, a process is waiting directly on

 hardware conditions and therefore will not handle any signals.

another process For example, a process that is being debugged can be put into the

Stopped state.

structure in the process table.

See /include/linux/sched.h for process states in the Linux kernel