source: src/libcfa/concurrency/kernel.c @ b69ea6b

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since b69ea6b was b69ea6b, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Updated alarm to use bits/cfatime and fixed preemption for coroutines

  • Property mode set to 100644
File size: 20.5 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// kernel.c --
8//
9// Author           : Thierry Delisle
10// Created On       : Tue Jan 17 12:27:26 2017
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Thu Feb  8 23:52:19 2018
13// Update Count     : 5
14//
15
16//C Includes
17#include <stddef.h>
18extern "C" {
19#include <stdio.h>
20#include <fenv.h>
21#include <sys/resource.h>
22#include <signal.h>
23#include <unistd.h>
24}
25
26//CFA Includes
27#include "kernel_private.h"
28#include "preemption.h"
29#include "startup.h"
30
31//Private includes
32#define __CFA_INVOKE_PRIVATE__
33#include "invoke.h"
34
35//Start and stop routine for the kernel, declared first to make sure they run first
36void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
37void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
38
39//-----------------------------------------------------------------------------
40// Kernel storage
41KERNEL_STORAGE(cluster,           mainCluster);
42KERNEL_STORAGE(processor,         mainProcessor);
43KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
44KERNEL_STORAGE(thread_desc,       mainThread);
45KERNEL_STORAGE(machine_context_t, mainThreadCtx);
46
47cluster *     mainCluster;
48processor *   mainProcessor;
49thread_desc * mainThread;
50
51//-----------------------------------------------------------------------------
52// Global state
53
54thread_local coroutine_desc * volatile this_coroutine;
55thread_local thread_desc *    volatile this_thread;
56thread_local processor *      volatile this_processor;
57
58// volatile thread_local bool preemption_in_progress = 0;
59// volatile thread_local bool preemption_enabled = false;
60// volatile thread_local unsigned short disable_preempt_count = 1;
61
62volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
63
64//-----------------------------------------------------------------------------
65// Main thread construction
66struct current_stack_info_t {
67        machine_context_t ctx;
68        unsigned int size;              // size of stack
69        void *base;                             // base of stack
70        void *storage;                  // pointer to stack
71        void *limit;                    // stack grows towards stack limit
72        void *context;                  // address of cfa_context_t
73        void *top;                              // address of top of storage
74};
75
76void ?{}( current_stack_info_t & this ) {
77        CtxGet( this.ctx );
78        this.base = this.ctx.FP;
79        this.storage = this.ctx.SP;
80
81        rlimit r;
82        getrlimit( RLIMIT_STACK, &r);
83        this.size = r.rlim_cur;
84
85        this.limit = (void *)(((intptr_t)this.base) - this.size);
86        this.context = &storage_mainThreadCtx;
87        this.top = this.base;
88}
89
90void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
91        size      = info->size;
92        storage   = info->storage;
93        limit     = info->limit;
94        base      = info->base;
95        context   = info->context;
96        top       = info->top;
97        userStack = true;
98}
99
100void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
101        stack{ info };
102        name = "Main Thread";
103        errno_ = 0;
104        state = Start;
105        starter = NULL;
106}
107
108void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
109        self_cor{ info };
110        curr_cor = &self_cor;
111        self_mon.owner = &this;
112        self_mon.recursion = 1;
113        self_mon_p = &self_mon;
114        next = NULL;
115        __cfaabi_dbg_debug_do(
116                dbg_next = NULL;
117                dbg_prev = NULL;
118                __cfaabi_dbg_thread_register(&this);
119        )
120
121        monitors{ &self_mon_p, 1, (fptr_t)0 };
122}
123
124//-----------------------------------------------------------------------------
125// Processor coroutine
126
127// Construct the processor context of the main processor
128void ?{}(processorCtx_t & this, processor * proc) {
129        (this.__cor){ "Processor" };
130        this.__cor.starter = NULL;
131        this.proc = proc;
132        proc->runner = &this;
133}
134
135// Construct the processor context of non-main processors
136void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
137        (this.__cor){ info };
138        this.proc = proc;
139        proc->runner = &this;
140}
141
142void ?{}(processor & this) {
143        this{ mainCluster };
144}
145
146void ?{}(processor & this, cluster * cltr) with( this ) {
147        this.cltr = cltr;
148        terminated{ 0 };
149        do_terminate = false;
150        preemption_alarm = NULL;
151        pending_preemption = false;
152
153        start( &this );
154}
155
156void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) with( this ) {
157        this.cltr = cltr;
158        terminated{ 0 };
159        do_terminate = false;
160        preemption_alarm = NULL;
161        pending_preemption = false;
162        kernel_thread = pthread_self();
163
164        this.runner = &runner;
165        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
166        runner{ &this };
167}
168
169void ^?{}(processor & this) with( this ){
170        if( ! do_terminate ) {
171                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
172                terminate(&this);
173                P( terminated );
174                pthread_join( kernel_thread, NULL );
175        }
176}
177
178void ?{}(cluster & this) with( this ) {
179        ready_queue{};
180        ready_queue_lock{};
181
182        preemption = default_preemption();
183}
184
185void ^?{}(cluster & this) {
186
187}
188
189//=============================================================================================
190// Kernel Scheduling logic
191//=============================================================================================
192//Main of the processor contexts
193void main(processorCtx_t & runner) {
194        processor * this = runner.proc;
195
196        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
197
198        {
199                // Setup preemption data
200                preemption_scope scope = { this };
201
202                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
203
204                thread_desc * readyThread = NULL;
205                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
206                {
207                        readyThread = nextThread( this->cltr );
208
209                        if(readyThread)
210                        {
211                                verify( !preemption.enabled );
212
213                                runThread(this, readyThread);
214
215                                verify( !preemption.enabled );
216
217                                //Some actions need to be taken from the kernel
218                                finishRunning(this);
219
220                                spin_count = 0;
221                        }
222                        else
223                        {
224                                spin(this, &spin_count);
225                        }
226                }
227
228                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
229        }
230
231        V( this->terminated );
232
233        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
234}
235
236// runThread runs a thread by context switching
237// from the processor coroutine to the target thread
238void runThread(processor * this, thread_desc * dst) {
239        assert(dst->curr_cor);
240        coroutine_desc * proc_cor = get_coroutine(*this->runner);
241        coroutine_desc * thrd_cor = dst->curr_cor;
242
243        //Reset the terminating actions here
244        this->finish.action_code = No_Action;
245
246        //Update global state
247        this_thread = dst;
248
249        // Context Switch to the thread
250        ThreadCtxSwitch(proc_cor, thrd_cor);
251        // when ThreadCtxSwitch returns we are back in the processor coroutine
252}
253
254void returnToKernel() {
255        coroutine_desc * proc_cor = get_coroutine(*this_processor->runner);
256        coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
257        ThreadCtxSwitch(thrd_cor, proc_cor);
258}
259
260// Once a thread has finished running, some of
261// its final actions must be executed from the kernel
262void finishRunning(processor * this) with( this->finish ) {
263        if( action_code == Release ) {
264                verify( !preemption.enabled );
265                unlock( *lock );
266        }
267        else if( action_code == Schedule ) {
268                ScheduleThread( thrd );
269        }
270        else if( action_code == Release_Schedule ) {
271                verify( !preemption.enabled );
272                unlock( *lock );
273                ScheduleThread( thrd );
274        }
275        else if( action_code == Release_Multi ) {
276                verify( !preemption.enabled );
277                for(int i = 0; i < lock_count; i++) {
278                        unlock( *locks[i] );
279                }
280        }
281        else if( action_code == Release_Multi_Schedule ) {
282                for(int i = 0; i < lock_count; i++) {
283                        unlock( *locks[i] );
284                }
285                for(int i = 0; i < thrd_count; i++) {
286                        ScheduleThread( thrds[i] );
287                }
288        }
289        else {
290                assert(action_code == No_Action);
291        }
292}
293
294// Handles spinning logic
295// TODO : find some strategy to put cores to sleep after some time
296void spin(processor * this, unsigned int * spin_count) {
297        (*spin_count)++;
298}
299
300// Context invoker for processors
301// This is the entry point for processors (kernel threads)
302// It effectively constructs a coroutine by stealing the pthread stack
303void * CtxInvokeProcessor(void * arg) {
304        processor * proc = (processor *) arg;
305        this_processor = proc;
306        this_coroutine = NULL;
307        this_thread = NULL;
308        preemption.enabled = false;
309        preemption.disable_count = 1;
310        // SKULLDUGGERY: We want to create a context for the processor coroutine
311        // which is needed for the 2-step context switch. However, there is no reason
312        // to waste the perfectly valid stack create by pthread.
313        current_stack_info_t info;
314        machine_context_t ctx;
315        info.context = &ctx;
316        processorCtx_t proc_cor_storage = { proc, &info };
317
318        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
319
320        //Set global state
321        this_coroutine = &proc->runner->__cor;
322        this_thread = NULL;
323
324        //We now have a proper context from which to schedule threads
325        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
326
327        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
328        // resume it to start it like it normally would, it will just context switch
329        // back to here. Instead directly call the main since we already are on the
330        // appropriate stack.
331        proc_cor_storage.__cor.state = Active;
332        main( proc_cor_storage );
333        proc_cor_storage.__cor.state = Halted;
334
335        // Main routine of the core returned, the core is now fully terminated
336        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
337
338        return NULL;
339}
340
341void start(processor * this) {
342        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
343
344        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
345
346        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
347}
348
349void kernel_first_resume(processor * this) {
350        coroutine_desc * src = this_coroutine;
351        coroutine_desc * dst = get_coroutine(*this->runner);
352
353        verify( !preemption.enabled );
354
355        create_stack(&dst->stack, dst->stack.size);
356        CtxStart(this->runner, CtxInvokeCoroutine);
357
358        verify( !preemption.enabled );
359
360        dst->last = src;
361        dst->starter = dst->starter ? dst->starter : src;
362
363        // set state of current coroutine to inactive
364        src->state = src->state == Halted ? Halted : Inactive;
365
366        // set new coroutine that task is executing
367        this_coroutine = dst;
368
369        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
370        // Therefore, when first creating a coroutine, interrupts are enable before calling the main.
371        // This is consistent with thread creation. However, when creating the main processor coroutine,
372        // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will
373        // stay disabled.
374        disable_interrupts();
375
376        // context switch to specified coroutine
377        assert( src->stack.context );
378        CtxSwitch( src->stack.context, dst->stack.context );
379        // when CtxSwitch returns we are back in the src coroutine
380
381        // set state of new coroutine to active
382        src->state = Active;
383
384        verify( !preemption.enabled );
385}
386
387//-----------------------------------------------------------------------------
388// Scheduler routines
389void ScheduleThread( thread_desc * thrd ) {
390        // if( !thrd ) return;
391        verify( thrd );
392        verify( thrd->self_cor.state != Halted );
393
394        verify( !preemption.enabled );
395
396        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
397
398        with( *this_processor->cltr ) {
399                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
400                append( ready_queue, thrd );
401                unlock( ready_queue_lock );
402        }
403
404        verify( !preemption.enabled );
405}
406
407thread_desc * nextThread(cluster * this) with( *this ) {
408        verify( !preemption.enabled );
409        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
410        thread_desc * head = pop_head( ready_queue );
411        unlock( ready_queue_lock );
412        verify( !preemption.enabled );
413        return head;
414}
415
416void BlockInternal() {
417        disable_interrupts();
418        verify( !preemption.enabled );
419        returnToKernel();
420        verify( !preemption.enabled );
421        enable_interrupts( __cfaabi_dbg_ctx );
422}
423
424void BlockInternal( __spinlock_t * lock ) {
425        disable_interrupts();
426        this_processor->finish.action_code = Release;
427        this_processor->finish.lock        = lock;
428
429        verify( !preemption.enabled );
430        returnToKernel();
431        verify( !preemption.enabled );
432
433        enable_interrupts( __cfaabi_dbg_ctx );
434}
435
436void BlockInternal( thread_desc * thrd ) {
437        disable_interrupts();
438        this_processor->finish.action_code = Schedule;
439        this_processor->finish.thrd        = thrd;
440
441        verify( !preemption.enabled );
442        returnToKernel();
443        verify( !preemption.enabled );
444
445        enable_interrupts( __cfaabi_dbg_ctx );
446}
447
448void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
449        assert(thrd);
450        disable_interrupts();
451        this_processor->finish.action_code = Release_Schedule;
452        this_processor->finish.lock        = lock;
453        this_processor->finish.thrd        = thrd;
454
455        verify( !preemption.enabled );
456        returnToKernel();
457        verify( !preemption.enabled );
458
459        enable_interrupts( __cfaabi_dbg_ctx );
460}
461
462void BlockInternal(__spinlock_t * locks [], unsigned short count) {
463        disable_interrupts();
464        this_processor->finish.action_code = Release_Multi;
465        this_processor->finish.locks       = locks;
466        this_processor->finish.lock_count  = count;
467
468        verify( !preemption.enabled );
469        returnToKernel();
470        verify( !preemption.enabled );
471
472        enable_interrupts( __cfaabi_dbg_ctx );
473}
474
475void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
476        disable_interrupts();
477        this_processor->finish.action_code = Release_Multi_Schedule;
478        this_processor->finish.locks       = locks;
479        this_processor->finish.lock_count  = lock_count;
480        this_processor->finish.thrds       = thrds;
481        this_processor->finish.thrd_count  = thrd_count;
482
483        verify( !preemption.enabled );
484        returnToKernel();
485        verify( !preemption.enabled );
486
487        enable_interrupts( __cfaabi_dbg_ctx );
488}
489
490void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
491        verify( !preemption.enabled );
492        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
493        this_processor->finish.lock        = lock;
494        this_processor->finish.thrd        = thrd;
495
496        returnToKernel();
497}
498
499//=============================================================================================
500// Kernel Setup logic
501//=============================================================================================
502//-----------------------------------------------------------------------------
503// Kernel boot procedures
504void kernel_startup(void) {
505        verify( !preemption.enabled );
506        __cfaabi_dbg_print_safe("Kernel : Starting\n");
507
508        // Start by initializing the main thread
509        // SKULLDUGGERY: the mainThread steals the process main thread
510        // which will then be scheduled by the mainProcessor normally
511        mainThread = (thread_desc *)&storage_mainThread;
512        current_stack_info_t info;
513        (*mainThread){ &info };
514
515        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
516
517        // Initialize the main cluster
518        mainCluster = (cluster *)&storage_mainCluster;
519        (*mainCluster){};
520
521        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
522
523        // Initialize the main processor and the main processor ctx
524        // (the coroutine that contains the processing control flow)
525        mainProcessor = (processor *)&storage_mainProcessor;
526        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
527
528        //initialize the global state variables
529        this_processor = mainProcessor;
530        this_thread = mainThread;
531        this_coroutine = &mainThread->self_cor;
532
533        // Enable preemption
534        kernel_start_preemption();
535
536        // Add the main thread to the ready queue
537        // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
538        ScheduleThread(mainThread);
539
540        // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
541        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
542        // mainThread is on the ready queue when this call is made.
543        kernel_first_resume( this_processor );
544
545
546
547        // THE SYSTEM IS NOW COMPLETELY RUNNING
548        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
549
550        verify( !preemption.enabled );
551        enable_interrupts( __cfaabi_dbg_ctx );
552        verify( preemption.enabled );
553}
554
555void kernel_shutdown(void) {
556        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
557
558        verify( preemption.enabled );
559        disable_interrupts();
560        verify( !preemption.enabled );
561
562        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
563        // When its coroutine terminates, it return control to the mainThread
564        // which is currently here
565        mainProcessor->do_terminate = true;
566        returnToKernel();
567
568        // THE SYSTEM IS NOW COMPLETELY STOPPED
569
570        // Disable preemption
571        kernel_stop_preemption();
572
573        // Destroy the main processor and its context in reverse order of construction
574        // These were manually constructed so we need manually destroy them
575        ^(*mainProcessor->runner){};
576        ^(mainProcessor){};
577
578        // Final step, destroy the main thread since it is no longer needed
579        // Since we provided a stack to this taxk it will not destroy anything
580        ^(mainThread){};
581
582        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
583}
584
585//=============================================================================================
586// Unexpected Terminating logic
587//=============================================================================================
588
589
590static __spinlock_t kernel_abort_lock;
591static __spinlock_t kernel_debug_lock;
592static bool kernel_abort_called = false;
593
594void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
595        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
596        // the globalAbort flag is true.
597        lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
598
599        // first task to abort ?
600        if ( !kernel_abort_called ) {                   // not first task to abort ?
601                kernel_abort_called = true;
602                unlock( kernel_abort_lock );
603        }
604        else {
605                unlock( kernel_abort_lock );
606
607                sigset_t mask;
608                sigemptyset( &mask );
609                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
610                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
611                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
612                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
613        }
614
615        return this_thread;
616}
617
618void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
619        thread_desc * thrd = kernel_data;
620
621        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
622        __cfaabi_dbg_bits_write( abort_text, len );
623
624        if ( thrd != this_coroutine ) {
625                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
626                __cfaabi_dbg_bits_write( abort_text, len );
627        }
628        else {
629                __cfaabi_dbg_bits_write( ".\n", 2 );
630        }
631}
632
633int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
634        return get_coroutine(this_thread) == get_coroutine(mainThread) ? 4 : 2;
635}
636
637extern "C" {
638        void __cfaabi_dbg_bits_acquire() {
639                lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
640        }
641
642        void __cfaabi_dbg_bits_release() {
643                unlock( kernel_debug_lock );
644        }
645}
646
647//=============================================================================================
648// Kernel Utilities
649//=============================================================================================
650//-----------------------------------------------------------------------------
651// Locks
652void  ?{}( semaphore & this, int count = 1 ) {
653        (this.lock){};
654        this.count = count;
655        (this.waiting){};
656}
657void ^?{}(semaphore & this) {}
658
659void P(semaphore & this) with( this ){
660        lock( lock __cfaabi_dbg_ctx2 );
661        count -= 1;
662        if ( count < 0 ) {
663                // queue current task
664                append( waiting, (thread_desc *)this_thread );
665
666                // atomically release spin lock and block
667                BlockInternal( &lock );
668        }
669        else {
670            unlock( lock );
671        }
672}
673
674void V(semaphore & this) with( this ) {
675        thread_desc * thrd = NULL;
676        lock( lock __cfaabi_dbg_ctx2 );
677        count += 1;
678        if ( count <= 0 ) {
679                // remove task at head of waiting list
680                thrd = pop_head( waiting );
681        }
682
683        unlock( lock );
684
685        // make new owner
686        WakeThread( thrd );
687}
688
689//-----------------------------------------------------------------------------
690// Debug
691__cfaabi_dbg_debug_do(
692        struct {
693                thread_desc * tail;
694        } __cfaabi_dbg_thread_list = { NULL };
695
696        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
697                if( !__cfaabi_dbg_thread_list.tail ) {
698                        __cfaabi_dbg_thread_list.tail = thrd;
699                        return;
700                }
701                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
702                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
703                __cfaabi_dbg_thread_list.tail = thrd;
704        }
705
706        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
707                thread_desc * prev = thrd->dbg_prev;
708                thread_desc * next = thrd->dbg_next;
709
710                if( next ) { next->dbg_prev = prev; }
711                else       {
712                        assert( __cfaabi_dbg_thread_list.tail == thrd );
713                        __cfaabi_dbg_thread_list.tail = prev;
714                }
715
716                if( prev ) { prev->dbg_next = next; }
717
718                thrd->dbg_prev = NULL;
719                thrd->dbg_next = NULL;
720        }
721)
722// Local Variables: //
723// mode: c //
724// tab-width: 4 //
725// End: //
Note: See TracBrowser for help on using the repository browser.