Shulou(Shulou.com)06/01 Report--

Today, I will talk to you about how to analyze thread library initialization and thread management based on linuxthreads2.0.1 thread source code, which may not be well understood by many people. In order to make you understand better, the editor summarizes the following contents. I hope you can get something according to this article.

A preliminary analysis of thread initialization and management.

The initialization code of the thread library is as follows.

/ / execute the main function before the function

Void _ pthread_initialize (void) _ attribute__ ((constructor))

Void _ pthread_initialize (void)

{

Struct sigaction sa

Sigset_t mask

/ * We may be called by others. This may happen if the constructors

Are not called in the order we need. , /

If (_ _ pthread_initial_thread_bos! = NULL)

Return

/ * For the initial stack, reserve at least STACK_SIZE bytes of stack

Below the current stack address, and align that on a

STACK_SIZE boundary. , /

_ _ pthread_initial_thread_bos =

/ / align by STACK_SIZE size

(char *) ((long) CURRENT_STACK_FRAME-2 * STACK_SIZE) & ~ (STACK_SIZE-1))

/ * Update the descriptor for the initial thread. , /

/ / that is, the main process id represented by the main function

_ _ pthread_initial_thread.p_pid = getpid ()

/ * If we have special thread_self processing, initialize that for the

Main thread now. , /

# ifdef INIT_THREAD_SELF

INIT_THREAD_SELF (& _ _ pthread_initial_thread)

# endif

/ * Setup signal handlers for the initial thread.

Since signal handlers are shared between threads, these settings

Will be inherited by all other threads. , /

/ / register processing functions for two signals

Sa.sa_handler = _ _ pthread_sighandler

Sigemptyset & sa.sa_mask)

Sa.sa_flags = SA_RESTART; / * does not matter for regular threads, but

Better for the thread manager * /

Sigaction (PTHREAD_SIG_RESTART, & sa, NULL)

Sa.sa_handler = pthread_handle_sigcancel

Sa.sa_flags = 0

Sigaction (PTHREAD_SIG_CANCEL, & sa, NULL)

/ * Initially, block PTHREAD_SIG_RESTART. Will be unblocked on demand. , /

/ / shielding restart signal

Sigemptyset & mask)

Sigaddset (& mask, PTHREAD_SIG_RESTART)

Sigprocmask (SIG_BLOCK, & mask, NULL)

/ * Register an exit function to kill all other threads. , /

/ * Do it early so that user-registered atexit functions are called

Before pthread_exit_process. , /

/ / register the function executed on exit

_ _ on_exit (pthread_exit_process, NULL)

}

The _ _ pthread_initialize function is executed before executing the main function, and the main things it does are

1 allocate a piece of memory on the stack.

Save the current process and enter the pid of the process corresponding to the main function.

3 register two signal processing functions.

4. Register the function executed when exiting

Next we will call pthread_create to create the thread. Let's see what the function does.

Int pthread_create (pthread_t * thread, const pthread_attr_t * attr

Void * (* start_routine) (void *), void * arg)

{

Pthread_t self = thread_self ()

Struct pthread_request request

/ / execute if pthread_initialize_manager has not been executed, which is used to initialize the manager thread

If (_ _ pthread_manager_request

< 0) { if (pthread_initialize_manager() < 0) return EAGAIN; } // 给manager发一下请求 request.req_thread = self; request.req_kind = REQ_CREATE; request.req_args.create.attr = attr; request.req_args.create.fn = start_routine; request.req_args.create.arg = arg; // 获取当前线程的信号掩码 sigprocmask(SIG_SETMASK, (const sigset_t *) NULL, &request.req_args.create.mask); // 通过管道写入，通知manager线程，新建一个线程 __libc_write(__pthread_manager_request, (char *) &request, sizeof(request)); // 挂起,等待manager唤醒 suspend(self); // 等于0说明创建成功，否则返回失败的错误码,p_retval在pthread_handle_create中设置 if (self->

P_retcode = = 0) * thread = (pthread_t) self- > p_retval

Return self- > p_retcode

}

We found that the function didn't do the actual thing, and it wrote some data to the pipeline. At this point, we should first look at the pthread_initialize_manager function.

Static int pthread_initialize_manager (void)

{

Int manager_pipe [2]

/ * Setup stack for thread manager * /

/ / allocate a piece of memory on the heap for the manager thread's stack

_ _ pthread_manager_thread_bos = malloc (THREAD_MANAGER_STACK_SIZE)

If (_ _ pthread_manager_thread_bos = = NULL) return-1

/ / limit

_ _ pthread_manager_thread_tos =

_ _ pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE

/ * Setup pipe to communicate with thread manager * /

If (pipe (manager_pipe) =-1) {

Free (_ _ pthread_manager_thread_bos)

Return-1

}

_ _ pthread_manager_request = manager_pipe [1]; / * writing end * /

_ _ pthread_manager_reader = manager_pipe [0]; / * reading end * /

/ * Start the thread manager * /

/ / create a new manager thread, and manager_pipe is the input parameter to the _ _ thread_manager function

If (_ clone (_ _ pthread_manager)

_ _ pthread_manager_thread_tos

CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND

(void *) (long) manager_pipe [0]) =-1) {

Free (_ _ pthread_manager_thread_bos)

_ _ libc_close (manager_pipe [0])

_ _ libc_close (manager_pipe [1])

_ _ pthread_manager_request =-1

Return-1

}

Return 0

}

This function does several things

1 apply a piece of memory on the heap to be used as the stack of the manager thread

2 creates a pipe for manager threads to communicate with other threads.

3 then create a new process and execute the _ _ pthread_manager function. (please refer to http://www.man7.org/linux/man-pages/man2/clone.2.html for details)

The manager thread is an important part of the Linux thread library, which manages other threads. Let's move on to the code for the _ pthread_manager function.

/ * The server thread managing requests for thread creation and termination * /

Int _ _ pthread_manager (void * arg)

{

/ / the reader of the pipe

Int reqfd = (long) arg

Sigset_t mask

Fd_set readfds

Struct timeval timeout

Int n

Struct pthread_request request

/ * If we have special thread_self processing, initialize it. , /

# ifdef INIT_THREAD_SELF

INIT_THREAD_SELF (& _ _ pthread_manager_thread)

# endif

/ * Block all signals except PTHREAD_SIG_RESTART * /

/ / initialized to full 1

Sigfillset & mask)

/ / set a bit to 0, where the restart signal can be processed

Sigdelset (& mask, PTHREAD_SIG_RESTART)

/ / set the signal mask of the process

Sigprocmask (SIG_SETMASK, & mask, NULL)

/ * Enter server loop * /

While (1) {

/ / clear 0

FD_ZERO & readfds)

/ / set a bit to 1, and the number of bits is calculated by reqfd. Here is the file descriptor of the pipe reader.

FD_SET (reqfd, & readfds)

/ / timeout for blocking

Timeout.tv_sec = 2

Timeout.tv_usec = 0

/ / scheduled blocking and waiting for the pipeline to have data to read

N = _ _ select (FD_SETSIZE, & readfds, NULL, NULL, & timeout)

/ * Check for termination of the main thread * /

/ / A parent process id of 1 means that the main process (thread) has exited and the child process has been taken over by the init (pid=1) process.

If (getppid ()) = = 1) {

/ / 0 indicates that there is no need to send to the main thread, because he has already quit

Pthread_kill_all_threads (SIGKILL, 0)

Return 0

}

/ * Check for dead children * /

If (terminated_children) {

Terminated_children = 0

Pthread_reap_children ()

}

/ * Read and execute request * /

/ / the pipeline has data to read

If (n = = 1 & & FD_ISSET (reqfd, & readfds)) {

/ / read it out and put it on request

N = _ _ libc_read (reqfd, (char *) & request, sizeof (request))

ASSERT (n = = sizeof (request))

Switch (request.req_kind) {

/ / create thread

Case REQ_CREATE:

Request.req_thread- > p_retcode =

Pthread_handle_create ((pthread_t *) & request.req_thread- > p_retval

Request.req_args.create.attr

Request.req_args.create.fn

Request.req_args.create.arg

Request.req_args.create.mask

Request.req_thread- > p_pid)

/ / Wake up the parent thread

Restart (request.req_thread)

Break

Case REQ_FREE:

Pthread_handle_free (request.req_args.free.thread)

Break

Case REQ_PROCESS_EXIT:

Pthread_handle_exit (request.req_thread

Request.req_args.exit.code)

Break

Case REQ_MAIN_THREAD_EXIT:

/ / Mark the main thread to exit

Main_thread_exiting = 1

/ / other threads have exited, only the main thread. Wake up the main thread, and the main thread also exits. See pthread_exit. If there are child threads that have not exited, the main thread cannot exit.

If (_ _ pthread_main_thread- > p_nextlive = = _ _ pthread_main_thread) {

Restart (_ _ pthread_main_thread)

Return 0

}

Break

}

}

}

}

This function is the main code for the manager thread. He's like a server together. Receive messages from other threads and process them. You can see the specific processing in switch. Here we only look at the logic created by the thread. The function is pthread_handle_create.

/ / pthread_create sends a signal to manager,manager to call this function to create a thread

Static int pthread_handle_create (pthread_t * thread, const pthread_attr_t * attr

Void * (* start_routine) (void *), void * arg

Sigset_t mask, int father_pid)

{

Int sseg

Int pid

Pthread_t new_thread

Int i

/ * Find a free stack segment for the current stack * /

Sseg = 0

While (1) {

While (1) {

If (sseg > = num_stack_segments) {

If (pthread_grow_stack_segments ()) =-1) return EAGAIN

}

If (stack_ segments [sseg] = = 0) break

Sseg++

}

/ / Mark has been used

Stack_ segments [sseg] = 1

/ / where thread metadata is stored

New_thread = THREAD_SEG (sseg)

/ * Allocate space for stack and thread descriptor. , /

/ / assign a stack to a thread

If (mmap ((caddr_t) ((char *) (new_thread+1)-INITIAL_STACK_SIZE))

INITIAL_STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC

MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED | MAP_GROWSDOWN,-1,0)

! = (caddr_t)-1) break

/ * It seems part of this segment is already mapped. Leave it marked

As reserved (to speed up future scans) and try the next. , /

Sseg++

}

/ * Initialize the thread descriptor * /

New_thread- > p_nextwaiting = NULL

New_thread- > p_spinlock = 0

New_thread- > p_signal = 0

New_thread- > p_signal_jmp = NULL

New_thread- > p_cancel_jmp = NULL

New_thread- > p_terminated = 0

New_thread- > p_detached = attr = = NULL? 0: attr- > detachstate

New_thread- > p_exited = 0

New_thread- > p_retval = NULL

New_thread- > p_joining = NULL

New_thread- > p_cleanup = NULL

New_thread- > p_cancelstate = PTHREAD_CANCEL_ENABLE

New_thread- > p_canceltype = PTHREAD_CANCEL_DEFERRED

New_thread- > p_canceled = 0

New_thread- > p_errno = 0

New_thread- > p_h_errno = 0

New_thread- > p_initial_fn = start_routine

New_thread- > p_initial_fn_arg = arg

New_thread- > p_initial_mask = mask

For (I = 0; I)

< PTHREAD_KEYS_MAX; i++) new_thread->

P _ specific [I] = NULL

/ * Do the cloning * /

Pid = _ _ clone (pthread_start_thread, new_thread

(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND

| | PTHREAD_SIG_RESTART) |

New_thread)

/ * Check if cloning succeeded * /

If (pid =-1) {

/ * Free the stack * /

Munmap ((caddr_t) ((char *) (new_thread+1)-INITIAL_STACK_SIZE)

INITIAL_STACK_SIZE)

Stack_ segments [sseg] = 0

Return EAGAIN

}

/ * Set the priority and policy for the new thread, if available. , /

If (attr! = NULL & & attr- > schedpolicy! = SCHED_OTHER) {

Switch (attr- > inheritsched) {

Case PTHREAD_EXPLICIT_SCHED:

Sched_setscheduler (pid, attr- > schedpolicy, & attr- > schedparam)

Break

Case PTHREAD_INHERIT_SCHED:

{struct sched_param father_param

Int father_policy

Father_policy = sched_getscheduler (father_pid)

Sched_getparam (father_pid, & father_param)

Sched_setscheduler (pid, father_policy, & father_param)

}

Break

}

}

/ * Insert new thread in doubly linked list of active threads * /

/ / insert between the main thread and other threads

New_thread- > p_prevlive = _ _ pthread_main_thread

New_thread- > p_nextlive = _ _ pthread_main_thread- > p_nextlive

_ _ pthread_main_thread- > pawnextLive-> p_prevlive = new_thread

_ _ pthread_main_thread- > p_nextlive = new_thread

/ * Set pid field of the new thread, in case we get there before the

Child starts. , /

New_thread- > p_pid = pid

/ * We're all set * /

* thread = new_thread

Return 0

}

This function allocates a tcb structure to represent the new thread. Then assign a thread stack and call clone to create a new process. Finally, link to the thread linked list. Finally, the pthread_start_thread function is executed. The code for the function is as follows.

/ / parameters passed to the clone function

Static int pthread_start_thread (void * arg)

{

/ / newly created thread

Pthread_t self = (pthread_t) arg

Void * outcome

/ * Initialize special thread_self processing, if any. , /

# ifdef INIT_THREAD_SELF

INIT_THREAD_SELF (self)

# endif

/ * Make sure our pid field is initialized, just in case we get there

Before our father has initialized it. , /

/ / record the id of the process corresponding to the thread

Self- > p_pid = getpid ()

/ * Initial signal mask is that of the creating thread. (Otherwise

We'd just inherit the mask of the thread manager.) /

/ / sets the signal mask of the thread. The value is inherited from the parent thread.

Sigprocmask (SIG_SETMASK, & self- > p_initial_mask, NULL)

/ * Run the thread code * /

/ / start executing the thread's main function

Outcome = self- > p_initial_fn (self- > p_initial_fn_arg)

/ * Exit with the given return value * /

/ / exit after execution

Pthread_exit (outcome)

Return 0

}

There is not much logic to execute the functions passed in by the user. Exit after execution.

After reading the above, do you have any further understanding of how to analyze thread library initialization and thread management based on linuxthread 2.0.1 thread source code? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.