A kernel thread or user process. More...
#include <thread.h>
Data Fields | |
| tid_t | tid |
| Thread identifier. More... | |
| enum thread_status | status |
| Thread state. More... | |
| char | name [16] |
| Name (for debugging purposes). More... | |
| uint8_t * | stack |
| Saved stack pointer. More... | |
| int | priority |
| Priority. More... | |
| struct list_elem | allelem |
| List element for all threads list. More... | |
| struct list_elem | elem |
| List element. More... | |
| unsigned | magic |
| Detects stack overflow. More... | |
Detailed Description
A kernel thread or user process.
Each thread structure is stored in its own 4 kB page. The thread structure itself sits at the very bottom of the page (at offset 0). The rest of the page is reserved for the thread's kernel stack, which grows downward from the top of the page (at offset 4 kB). Here's an illustration:
4 kB +---------------------------------+
| kernel stack |
| | |
| | |
| V |
| grows downward |
| |
| |
| |
| |
| |
| |
| |
| |
+---------------------------------+
| magic |
| : |
| : |
| name |
| status |
0 kB +---------------------------------+
The upshot of this is twofold:
- First, ‘struct thread’ must not be allowed to grow too big. If it does, then there will not be enough room for the kernel stack. Our base ‘struct thread’ is only a few bytes in size. It probably should stay well under 1 kB.
- Second, kernel stacks must not be allowed to grow too large. If a stack overflows, it will corrupt the thread state. Thus, kernel functions should not allocate large structures or arrays as non-static local variables. Use dynamic allocation with malloc() or palloc_get_page() instead.
The first symptom of either of these problems will probably be an assertion failure in thread_current(), which checks that the ‘magic’ member of the running thread's ‘struct thread’ is set to THREAD_MAGIC. Stack overflow will normally change this value, triggering the assertion. The ‘elem’ member has a dual purpose. It can be an element in the run queue (thread.c), or it can be an element in a semaphore wait list (synch.c). It can be used these two ways only because they are mutually exclusive: only a thread in the ready state is on the run queue, whereas only a thread in the blocked state is on a semaphore wait list.
Field Documentation
◆ allelem
| struct list_elem thread::allelem |
List element for all threads list.
Definition at line 91 of file thread.h.
Referenced by init_thread(), thread_exit(), and thread_foreach().
◆ elem
| struct list_elem thread::elem |
List element.
Definition at line 94 of file thread.h.
Referenced by next_thread_to_run(), thread_unblock(), and thread_yield().
◆ magic
| unsigned thread::magic |
◆ name
| char thread::name[16] |
Name (for debugging purposes).
Definition at line 88 of file thread.h.
Referenced by init_thread(), print_stacktrace(), and thread_name().
◆ priority
| int thread::priority |
Priority.
Definition at line 90 of file thread.h.
Referenced by init_thread(), thread_get_priority(), and thread_set_priority().
◆ stack
| uint8_t* thread::stack |
Saved stack pointer.
Definition at line 89 of file thread.h.
Referenced by alloc_frame(), init_thread(), and print_stacktrace().
◆ status
| enum thread_status thread::status |
Thread state.
Definition at line 87 of file thread.h.
Referenced by init_thread(), print_stacktrace(), schedule(), thread_block(), thread_current(), thread_exit(), thread_schedule_tail(), thread_unblock(), and thread_yield().
◆ tid
| tid_t thread::tid |
Thread identifier.
Definition at line 86 of file thread.h.
Referenced by allocate_tid(), thread_create(), and thread_tid().
The documentation for this struct was generated from the following file:
- src/threads/thread.h
