os-k/include/kernel/base.h

//----------------------------------------------------------------------------//
//                           GNU GPL OS/K                                     //
//                                                                            //
//  Desc:       Kaleid kernel base include file                               //
//                                                                            //
//                                                                            //
//  Copyright © 2018-2019 The OS/K Team                                       //
//                                                                            //
//  This file is part of OS/K.                                                //
//                                                                            //
//  OS/K is free software: you can redistribute it and/or modify              //
//  it under the terms of the GNU General Public License as published by      //
//  the Free Software Foundation, either version 3 of the License, or         //
//  any later version.                                                        //
//                                                                            //
//  OS/K is distributed in the hope that it will be useful,                   //
//  but WITHOUT ANY WARRANTY//without even the implied warranty of            //
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             //
//  GNU General Public License for more details.                              //
//                                                                            //
//  You should have received a copy of the GNU General Public License         //
//  along with OS/K.  If not, see <https://www.gnu.org/licenses/>.            //
//----------------------------------------------------------------------------//

#ifndef _KALBASE_H
#include <kalbase.h>
#endif

#ifdef __cplusplus
#error "Kaleid's kernel won't compile in C++"
#endif

#ifndef _KALKERN_BASE_H
#define _KALKERN_BASE_H

//------------------------------------------//

typedef struct Lock_t           Lock_t;
typedef struct Buffer_t         Buffer_t;
typedef struct Thread_t         Thread_t;
typedef struct Process_t        Process_t;
typedef struct BootInfo_t       BootInfo_t;
typedef struct ListHead_t       ListHead_t;
typedef struct ListNode_t       ListNode_t;
typedef struct Processor_t      Processor_t;
typedef struct IRQList_t        IRQList_t;

typedef enum ProcState_t        ProcState_t;

//------------------------------------------//

//
// Holds all CPU-local variables
//
struct Processor_t
{
    // CPU number, index in CPU list
    int             index;

    // CPU APIC id
    int             apicId;

    // CPU Vendor String (always 12 characters)
    char            vendorStr[12];

    // CPU Model code (enum in cpu.h)
    int             modelCode;

    // CPU Features flag
    uint            featureFlag;

    // Number of ticks since boot time
    ulong          ticks;

    // Current process & thread
    Process_t      *process;
    Thread_t       *thread;

    // Need re-schedule?
    bool            needReSched;

    // Is preemption ON? ("PREEMPT_ON" in sched.h)
    ulong           preemptCount;

    // List heads for the four priority classes
    ListHead_t     *idlePrioProcs;
    ListHead_t     *reglPrioProcs;
    ListHead_t     *servPrioProcs;
    ListHead_t     *timeCritProcs;
};

//------------------------------------------//

#ifndef NCPUS
#define NCPUS 1
#endif

// Current CPU number
#define _KeCurCPU 0

extern int                      KeCPUCount;
extern volatile Processor_t     *KeCurCPU;
extern Processor_t              _KeCPUTable[NCPUS];

//------------------------------------------//

#define DEC_PER_CPU(pref, name, field, type)                                \
    static inline type pref##Get##name() { return KeGetCurCPU()->field; }   \
    static inline void _##pref##Set##name(type __val)                       \
                        { KeGetCurCPU()->field = __val; }

#define BARRIER()                           \
    do {                                    \
        asm volatile("": : :"memory");      \
        __sync_synchronize();               \
    } while(0)

//------------------------------------------//

error_t KernLog(const char *, ...);

#ifndef _NO_DEBUG
void DebugLog(const char *, ...);
#else
#define DebugLog(fmt, ...) ((void)0)
#endif

//------------------------------------------//

extern volatile bool KeIsPanicking;
noreturn void KeStartPanic(const char *, ...);

//------------------------------------------//

#endif