Subversion Repositories HelenOS

Rev

Rev 508 | Rev 512 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 508 Rev 510
Line 24... Line 24...
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
#include <config.h>
-
 
30
#include <arch.h>
-
 
31
#include <main/kinit.h>
29
#include <main/kinit.h>
-
 
30
#include <main/kconsole.h>
32
#include <main/uinit.h>
31
#include <main/uinit.h>
-
 
32
#include <config.h>
-
 
33
#include <arch.h>
33
#include <proc/scheduler.h>
34
#include <proc/scheduler.h>
34
#include <proc/task.h>
35
#include <proc/task.h>
35
#include <proc/thread.h>
36
#include <proc/thread.h>
36
#include <panic.h>
37
#include <panic.h>
37
#include <func.h>
38
#include <func.h>
Line 80... Line 81...
80
            t->cpu = &cpus[0];
81
            t->cpu = &cpus[0];
81
            spinlock_unlock(&t->lock);
82
            spinlock_unlock(&t->lock);
82
            thread_ready(t);
83
            thread_ready(t);
83
            waitq_sleep(&kmp_completion_wq);
84
            waitq_sleep(&kmp_completion_wq);
84
        }
85
        }
85
        else panic("thread_create/kmp");
86
        else panic("thread_create/kmp\n");
86
    }
87
    }
87
#endif /* CONFIG_SMP */
88
#endif /* CONFIG_SMP */
88
    /*
89
    /*
89
     * Now that all CPUs are up, we can report what we've found.
90
     * Now that all CPUs are up, we can report what we've found.
90
     */
91
     */
Line 107... Line 108...
107
                t->flags |= X_WIRED;
108
                t->flags |= X_WIRED;
108
                t->cpu = &cpus[i];
109
                t->cpu = &cpus[i];
109
                spinlock_unlock(&t->lock);
110
                spinlock_unlock(&t->lock);
110
                thread_ready(t);
111
                thread_ready(t);
111
            }
112
            }
112
            else panic("thread_create/kcpulb");
113
            else panic("thread_create/kcpulb\n");
113
 
114
 
114
        }
115
        }
115
    }
116
    }
116
#endif /* CONFIG_SMP */
117
#endif /* CONFIG_SMP */
117
 
118
 
-
 
119
    /*
-
 
120
     * Create kernel console.
-
 
121
     */
-
 
122
    if (t = thread_create(kconsole, NULL, TASK, 0))
-
 
123
        thread_ready(t);
-
 
124
    else panic("thread_create/kconsole\n");
-
 
125
 
118
    interrupts_enable();
126
    interrupts_enable();
119
 
127
 
120
#ifdef CONFIG_USERSPACE
128
#ifdef CONFIG_USERSPACE
121
    /*
129
    /*
122
     * Create the first user task.
130
     * Create the first user task.
123
     */
131
     */
124
    m = vm_create(NULL);
132
    m = vm_create(NULL);
125
    if (!m)
133
    if (!m)
126
        panic("vm_create");
134
        panic("vm_create\n");
127
    u = task_create(m);
135
    u = task_create(m);
128
    if (!u)
136
    if (!u)
129
        panic("task_create");
137
        panic("task_create\n");
130
    t = thread_create(uinit, NULL, u, THREAD_USER_STACK);
138
    t = thread_create(uinit, NULL, u, THREAD_USER_STACK);
131
    if (!t)
139
    if (!t)
132
        panic("thread_create");
140
        panic("thread_create\n");
133
 
141
 
134
    /*
142
    /*
135
     * Create the text vm_area and copy the userspace code there.
143
     * Create the text vm_area and copy the userspace code there.
136
     */
144
     */
137
    a = vm_area_create(m, VMA_TEXT, 1, UTEXT_ADDRESS);
145
    a = vm_area_create(m, VMA_TEXT, 1, UTEXT_ADDRESS);
138
    if (!a)
146
    if (!a)
139
        panic("vm_area_create: vm_text");
147
        panic("vm_area_create: vm_text\n");
140
    vm_area_map(a, m);
148
    vm_area_map(a, m);
141
    memcpy((void *) PA2KA(a->mapping[0]), (void *) utext, utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);
149
    memcpy((void *) PA2KA(a->mapping[0]), (void *) utext, utext_size < PAGE_SIZE ? utext_size : PAGE_SIZE);
142
 
150
 
143
    /*
151
    /*
144
     * Create the data vm_area.
152
     * Create the data vm_area.
145
     */
153
     */
146
    a = vm_area_create(m, VMA_STACK, 1, USTACK_ADDRESS);
154
    a = vm_area_create(m, VMA_STACK, 1, USTACK_ADDRESS);
147
    if (!a)
155
    if (!a)
148
        panic("vm_area_create: vm_stack");
156
        panic("vm_area_create: vm_stack\n");
149
    vm_area_map(a, m); 
157
    vm_area_map(a, m); 
150
   
158
   
151
    thread_ready(t);
159
    thread_ready(t);
152
#endif /* CONFIG_USERSPACE */
160
#endif /* CONFIG_USERSPACE */
153
 
161
 
154
#ifdef CONFIG_TEST
162
#ifdef CONFIG_TEST
155
    test();
163
    test();
156
#endif /* CONFIG_TEST */
164
#endif /* CONFIG_TEST */
157
 
165
 
158
 
-
 
159
    while (1) {
166
    while (1) {
160
        thread_sleep(60);
167
        thread_sleep(60);
161
        printf("kinit... ");
168
        printf("kinit... ");
162
    }
169
    }
163
 
170