source: trunk/kernel/syscalls/sys_thread_create.c

Last change on this file was 651, checked in by alain, 13 months ago

1) Improve the VMM MMAP allocator: implement the "buddy" algorithm
to allocate only aligned blocks.
2) fix a bug in the pthread_join() / pthread_exit() mmechanism.

File size: 7.0 KB
Line 
1/*
2 * sys_thread_create.c - creates a new user thread
3 *
4 * Author     Alain Greiner (2016,2017,2018,2019)
5 *
6 * Copyright (c) UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <kernel_config.h>
25#include <hal_kernel_types.h>
26#include <hal_uspace.h>
27#include <hal_vmm.h>
28#include <printk.h>
29#include <errno.h>
30#include <core.h>
31#include <cluster.h>
32#include <list.h>
33#include <xlist.h>
34#include <thread.h>
35#include <scheduler.h>
36#include <kmem.h>
37#include <process.h>
38#include <dqdt.h>
39#include <rpc.h>
40
41#include <syscalls.h>
42
43/////////////////////////////////////////////////////////
44int sys_thread_create( trdid_t               * trdid_ptr,
45                       struct pthread_attr_s * user_attr,
46                       void                  * start_func,
47                       void                  * start_args )
48{
49    pthread_attr_t   kern_attr;        // copy of pthread attributes in kernel space
50    thread_t       * parent;           // pointer on thread executing the pthread_create
51    cxy_t            child_cxy;        // created child thread cluster identifier
52    thread_t       * child_ptr;        // pointer on created child thread
53    xptr_t           child_xp;         // extended pointer on created thread
54    trdid_t          trdid;            // created thread identifier
55    process_t      * process;          // pointer on local process descriptor
56    vseg_t         * vseg;             // required for user space checking
57    error_t          error;
58
59    // get parent thead pointer, extended pointer, and process
60    parent     = CURRENT_THREAD;
61    process    = parent->process;
62
63#if (DEBUG_SYS_THREAD_CREATE || CONFIG_INSTRUMENTATION_SYSCALLS)
64uint64_t     tm_start = hal_get_cycles();
65#endif
66
67#if DEBUG_SYS_THREAD_CREATE
68if( DEBUG_SYS_THREAD_CREATE < tm_start )
69printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
70__FUNCTION__, process->pid, parent->trdid, (uint32_t)tm_start );
71#endif
72
73    // check trdid buffer in user space
74    if( vmm_get_vseg( process , (intptr_t)trdid_ptr , &vseg ) )
75    {
76
77#if DEBUG_SYSCALLS_ERROR
78printk("\n[ERROR] in %s : thread[%x,%x] / trdid buffer %x unmapped %x\n",
79__FUNCTION__, process->pid, parent->trdid, (intptr_t)trdid_ptr );
80#endif
81                parent->errno = EINVAL;
82                return -1;
83    }
84
85        // check user_attr buffer in user space & copy to kernel space
86    if( user_attr != NULL )
87    {
88            if( vmm_get_vseg( process , (intptr_t)user_attr , &vseg ) )
89            {
90
91#if DEBUG_SYSCALLS_ERROR
92printk("\n[ERROR] in %s : thread[%x,%x] / user_attr buffer unmapped %x\n",
93__FUNCTION__, process->pid, parent->trdid, (intptr_t)user_attr );
94#endif
95                    parent->errno = EINVAL;
96                    return -1;
97            }
98       
99            hal_copy_from_uspace( XPTR( local_cxy , &kern_attr ),
100                              user_attr,
101                              sizeof(pthread_attr_t) );
102    }
103
104        // check start_func in user space
105        if( vmm_get_vseg( process , (intptr_t)start_func , &vseg ) )
106    {
107
108#if DEBUG_SYSCALLS_ERROR
109printk("\n[ERROR] in %s : thread[%x,%x] / start_func unmapped %x\n",
110__FUNCTION__, process->pid, parent->trdid, (intptr_t)start_func );
111#endif
112        parent->errno = EINVAL;
113            return -1;
114        }
115
116        // check start_args buffer in user space
117        if( start_args != NULL )
118    {
119        if( vmm_get_vseg( process , (intptr_t)start_args , &vseg ) )
120            {
121
122#if DEBUG_SYSCALLS_ERROR
123printk("\n[ERROR] in %s : thread[%x,%x] / start_args buffer unmapped %x\n",
124__FUNCTION__, process->pid, parent->trdid, (intptr_t)start_args );
125#endif
126                    parent->errno = EINVAL;
127                    return -1;
128        }
129        }
130
131    // define attributes and child_cxy
132    if( user_attr != NULL )                      // user defined attributes
133    {
134            // check / get child_cxy
135            if( kern_attr.attributes & PT_ATTR_CLUSTER_DEFINED )
136            {
137                    if( cluster_is_active( kern_attr.cxy ) == false )
138                    {
139
140#if DEBUG_SYSCALLS_ERROR
141printk("\n[ERROR] in %s : thread[%x,%x] / illegal target cluster %x\n",
142__FUNCTION__, process->pid, parent->trdid, kern_attr.cxy );
143#endif
144                            parent->errno = EINVAL;
145                            return -1;
146            }
147            child_cxy = kern_attr.cxy;
148                }
149        else
150        {
151            child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
152        }
153        }
154        else                                        // set default attributes
155        {
156        kern_attr.attributes = PT_ATTR_CLUSTER_DEFINED;
157        child_cxy = dqdt_get_cluster_for_thread( LOCAL_CLUSTER->dqdt_root_xp );
158        }
159
160        // create the thread, using a RPC if required
161        // this returns "error", "child_ptr", and "child_xp"
162
163        if( child_cxy == local_cxy )                         // target cluster is local
164        {
165                // create thread in local cluster
166                error = thread_user_create( process->pid,
167                                            start_func,
168                                            start_args,
169                                            &kern_attr,
170                                            &child_ptr );
171
172                child_xp = XPTR( local_cxy , child_ptr );
173        }
174        else                                                 // target cluster is remote
175        {
176                rpc_thread_user_create_client( child_cxy,
177                                               process->pid,
178                                               start_func,
179                                               start_args,
180                                               &kern_attr,
181                                               &child_xp,
182                                               &error );
183
184                child_ptr = (thread_t *)GET_PTR( child_xp );
185        }
186
187        // check successful thread creation
188        if( error )
189        {
190
191#if DEBUG_SYSCALLS_ERROR
192printk("\n[ERROR] in %s : thread[%x,%x] cannot create new thread\n",
193__FUNCTION__ , process->pid, parent->trdid );
194#endif
195                parent->errno = ENOMEM;
196                return -1;
197        }
198
199        // returns trdid to user space
200        trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
201        hal_copy_to_uspace( trdid_ptr,
202                        XPTR( local_cxy , &trdid ),
203                        sizeof(pthread_t) );
204
205    // activate new thread
206        thread_unblock( child_xp , THREAD_BLOCKED_GLOBAL );
207
208    hal_fence();
209
210#if (DEBUG_SYS_THREAD_CREATE || CONFIG_INSTRUMENTATION_SYSCALLS)
211uint64_t     tm_end = hal_get_cycles();
212#endif
213
214#if DEBUG_SYS_THREAD_CREATE
215if( DEBUG_SYS_THREAD_CREATE < tm_end )
216printk("\n[%s] thread[%x,%x] created thread %x / cycle %d\n",
217__FUNCTION__, process->pid, parent->trdid, child_ptr->trdid, (uint32_t)tm_end );
218#endif
219
220#if CONFIG_INSTRUMENTATION_SYSCALLS
221hal_atomic_add( &syscalls_cumul_cost[SYS_THREAD_CREATE] , tm_end - tm_start );
222hal_atomic_add( &syscalls_occurences[SYS_THREAD_CREATE] , 1 );
223#endif
224
225        return 0;
226
227}  // end sys_thread_create()
228
Note: See TracBrowser for help on using the repository browser.