OSDev.org

Code: Select all

    //! Send SNMP trap
    //! \param[in] addr       Destination for this trap
    //! \param[in] community  Community string, for example "public"
    //! \param[in] enterprise Object ID of the enterprise identifying the event
    //! \param[in] trapcode   Trap code
    //! \param[in] value      Value of the object
    //! \return 0 on success, -1 on fail.
    int	snmp_trap    ( const struct sockaddr *addr, const char * community, const unsigned char* enterprise, int trapcode, int value );

Code: Select all

// Figure this clusterf**k out yourself.

Code: Select all

// tcb_new - allocate a new thread control block
//
// Returns a pointer to a new, initialized TCB on success, NULL on error.
// The TCB will have a locked mutex, and will be in a suspended state.
// This function can fail if there is no memory available for new TCBs or
// if there are no free TCB table slots.
// 
struct tcb *tcb_new(void) {
    struct tcb *tcb = tcb_alloc();
    if (!tcb) {
        return NULL;
    }
    mutex_acquire(&tcb_table_lock);
    for (uint32_t i = 1; i < TCB_LIMIT; i++) {
        if (!tcb_table[i / 512]) {
            struct tcb **subtab = pge_alloc();
            if (!subtab) {
                mutex_release(&tcb_table_lock);
                tcb_free(tcb);
                return NULL;
            }
            tcb_table[i / 512] = subtab;
            for (int j = 0; j < 512; j++) {
                tcb_table[i / 512][j] = NULL;
            }
        }
        if (!tcb_table[i / 512][i % 512]) {
            tcb_table[i / 512][i % 512] = tcb;
            tcb->state = TCB_STATE_SUSPENDED;
            tcb->id = i;
            tcb->pcx_id = 0;
            tcb->xstate = NULL;
            tcb->cs = 0x08;
            tcb->ss = 0x10;
            tcb->rflags = 0x200200;
            mutex_release(&tcb_table_lock);
            return tcb;
        }
    }
    mutex_release(&tcb_table_lock);
    tcb_free(tcb);
    return NULL;
}

Code: Select all

// tcb_new - allocate a new thread control block
//
// Returns a pointer to a new, initialized TCB on success, NULL on error.
// The TCB will have a locked mutex, and will be in a suspended state.
// This function can fail if there is no memory available for new TCBs or
// if there are no free TCB table slots.
// 
struct tcb *tcb_new(void) {

    // try to allocate TCB structure space
    // we want to do this before acquiring the lock for latency reasons
    struct tcb *tcb = tcb_alloc();

    if (!tcb) {

        // allocation failed, error
        return NULL;
    }

    mutex_acquire(&tcb_table_lock);

    // search for empty TCB table slot
    for (uint32_t i = 1; i < TCB_LIMIT; i++) {

        // ensure second-level table exists
        if (!tcb_table[i / 512]) {

            // try to allocate new TCB second-level table
            // XXX should we ever allocate while holding the TCB table lock?
            struct tcb **subtab = pge_alloc();

            if (!subtab) {

                // allocation failed, free TCB and error
                mutex_release(&tcb_table_lock);
                tcb_free(tcb);
                return NULL;
            }

            // initialize second-level table
            tcb_table[i / 512] = subtab;
            for (int j = 0; j < 512; j++) {
                tcb_table[i / 512][j] = NULL;
            }
        }

        if (!tcb_table[i / 512][i % 512]) {
            // empty TCB table slot found

            // fill slot
            tcb_table[i / 512][i % 512] = tcb;

            // initialize new TCB
            tcb->state = TCB_STATE_SUSPENDED;
            tcb->id    = i;

            tcb->pcx_id = 0;
            tcb->xstate = NULL;
            tcb->cs     = 0x08;
            tcb->ss     = 0x10;
            tcb->rflags = 0x200200; // XXX magic numbers

            // return new TCB
            mutex_release(&tcb_table_lock);
            return tcb;
        }
    }

    // no free slots, free TCB and error
    mutex_release(&tcb_table_lock);
    tcb_free(tcb);
    return NULL;
}

Code: Select all

struct tcb *tcb_new(void) {
    // try to allocate TCB structure space
    if (?) {
        // allocation failed, error
    }
    // search for empty TCB table slot
    for (?) {
        // ensure second-level table exists
        if (?) {
            // try to allocate new TCB second-level table
            if (?) {
                // allocation failed, free TCB and error
            }
            // initialize second-level table
        }
        if (?) {
            // empty TCB table slot found
            // fill slot
            // initialize new TCB
            // return new TCB
        }
    }
    // no free slots, free TCB and error
}

Code: Select all

int tcb_new(struct tcb ** des) {
    if ( des==NULL ) return E_INVAL;

    struct tcb *tcb = tcb_alloc();
    if (tcb==NULL) return E_NOMEM;

    // Fill with defaults
    tcb->state = TCB_STATE_SUSPENDED;
    tcb->id = i;
    tcb->pcx_id = 0;
    tcb->xstate = NULL;
    tcb->cs = 0x08;
    tcb->ss = 0x10;
    tcb->rflags = 0x200200;

    mutex_acquire(&tcb_table_lock);
    if ( tcb_table.add ( tab ) < 0 ) {
        mutex_release(&tcb_table_lock);
        tcb_free(tcb);
        return E_INTERNAL;  // internal error
    }
    mutex_release(&tcb_table_lock);
    *des = tcb;
    return E_OK;
}

Code: Select all

/*
 * Returns a newly allocated thread control block or NULL on error.
 * The TCB will have a locked mutex, and will be in a suspended state.
 */
struct tcb *tcb_new(void)
{
    struct tcb *tcb;
    uint32_t i;

    tcb = tcb_alloc();
    if (!tcb) {
        return NULL;
    }

    mutex_acquire(&tcb_table_lock);

    /* Search for free table entry */
    /* XXX Why do we start iterating at 1? */
    for (i = 1; i < TCB_LIMIT; i++) {

        /* Create second-level table if not present */
        if (!tcb_table[i / 512]) {
            struct tcb **subtab = pge_alloc();
            if (!subtab) {
                goto fail;
            }
            tcb_table[i / 512] = subtab;
            for (int j = 0; j < 512; j++) {
                tcb_table[i / 512][j] = NULL;
            }
        }

        /* Second-level table lookup */
        if (!tcb_table[i / 512][i % 512]) {
            goto found;
        }
    }
    goto fail;

found:
    /* Initialise new entry */
    tcb_table[i / 512][i % 512] = tcb;
    *tcb = (struct tcb*) {
        .state  = TCB_STATE_SUSPENDED,
        .id     = i,
        .pcx_id = 0,
        .xstate = NULL,
        .cs     = 0x08,
        .ss     = 0x10,
        .rflags = 0x200200,
    };

    mutex_release(&tcb_table_lock);
    return tcb;

fail:
    mutex_release(&tcb_table_lock);
    tcb_free(tcb);
    return NULL;
}

Code: Select all

// Above: task_t current; task_t tasks;

struct cpu_state* kschedule(struct cpu_state* cpu)
{
        if (current == NULL)
        {
                current = tasks;
        }
        else
        {
                current->cpu = cpu;
                do
                {
                        if (current->next != NULL)
                        {
                                current = current->next;
                        }
                        else
                        {
                                current = tasks;
                        }
                } while (current->blocked);
        }
        cpu = current->cpu;

        return cpu;
}