internal.h

/*
 * Copyright (C) 2011 Philippe Gerum <rpm@xenomai.org>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#ifndef _COPPERPLATE_INTERNAL_H
#define _COPPERPLATE_INTERNAL_H

#include <sys/types.h>
#include <stdarg.h>
#include <time.h>
#include <pthread.h>
#include <semaphore.h>
#include <xeno_config.h>
#include <boilerplate/list.h>
#include <boilerplate/ancillaries.h>
#include <boilerplate/limits.h>
#include <boilerplate/sched.h>
#include <boilerplate/setup.h>
#include <copperplate/heapobj.h>
#include <copperplate/tunables.h>

#ifdef CONFIG_XENO_PSHARED

#include <boilerplate/shavl.h>

#define SHEAPMEM_PAGE_SHIFT     9 /* 2^9 => 512 bytes */
#define SHEAPMEM_PAGE_SIZE      (1UL << SHEAPMEM_PAGE_SHIFT)
#define SHEAPMEM_PAGE_MASK      (~(SHEAPMEM_PAGE_SIZE - 1))
#define SHEAPMEM_MIN_LOG2       4 /* 16 bytes */
/*
 * Use bucketed memory for sizes between 2^SHEAPMEM_MIN_LOG2 and
 * 2^(SHEAPMEM_PAGE_SHIFT-1).
 */
#define SHEAPMEM_MAX            (SHEAPMEM_PAGE_SHIFT - SHEAPMEM_MIN_LOG2)
#define SHEAPMEM_MIN_ALIGN      (1U << SHEAPMEM_MIN_LOG2)
/* Max size of an extent (4Gb - SHEAPMEM_PAGE_SIZE). */
#define SHEAPMEM_MAX_EXTSZ      (4294967295U - SHEAPMEM_PAGE_SIZE + 1)
/* Bits we need for encoding a page # */
#define SHEAPMEM_PGENT_BITS      (32 - SHEAPMEM_PAGE_SHIFT)

/* Each page is represented by a page map entry. */
#define SHEAPMEM_PGMAP_BYTES    sizeof(struct sheapmem_pgentry)

struct sheapmem_pgentry {
        /* Linkage in bucket list. */
        unsigned int prev : SHEAPMEM_PGENT_BITS;
        unsigned int next : SHEAPMEM_PGENT_BITS;
        /*  page_list or log2. */
        unsigned int type : 6;
        /*
         * We hold either a spatial map of busy blocks within the page
         * for bucketed memory (up to 32 blocks per page), or the
         * overall size of the multi-page block if entry.type ==
         * page_list.
         */
        union {
                uint32_t map;
                uint32_t bsize;
        };
};

/*
 * A range descriptor is stored at the beginning of the first page of
 * a range of free pages. sheapmem_range.size is nrpages *
 * SHEAPMEM_PAGE_SIZE. Ranges are indexed by address and size in AVL
 * trees.
 */
struct sheapmem_range {
        struct shavlh addr_node;
        struct shavlh size_node;
        size_t size;
};

struct sheapmem_extent {
        struct holder next;
        memoff_t membase;       /* Base offset of page array */
        memoff_t memlim;        /* Offset limit of page array */
        struct shavl addr_tree;
        struct shavl size_tree;
        struct sheapmem_pgentry pagemap[0]; /* Start of page entries[] */
};

#define __SHEAPMEM_MAP_SIZE(__nrpages)                                  \
        ((__nrpages) * SHEAPMEM_PGMAP_BYTES)

#define __SHEAPMEM_ARENA_SIZE(__size)                                   \
        (__size +                                                       \
         __align_to(sizeof(struct sheapmem_extent) +                    \
                    __SHEAPMEM_MAP_SIZE((__size) >> SHEAPMEM_PAGE_SHIFT),       \
                    SHEAPMEM_MIN_ALIGN))

/*
 * Calculate the minimal size of the memory arena needed to contain a
 * heap of __user_size bytes, including our meta data for managing it.
 * Usable at build time if __user_size is constant.
 */
#define SHEAPMEM_ARENA_SIZE(__user_size)                                        \
        __SHEAPMEM_ARENA_SIZE(__align_to(__user_size, SHEAPMEM_PAGE_SIZE))

/*
 * The struct below has to live in shared memory; no direct reference
 * to process local memory in there.
 */
struct shared_heap_memory {
        char name[XNOBJECT_NAME_LEN];
        pthread_mutex_t lock;
        struct listobj extents;
        size_t arena_size;
        size_t usable_size;
        size_t used_size;
        /* Heads of page lists for log2-sized blocks. */
        uint32_t buckets[SHEAPMEM_MAX];
        struct sysgroup_memspec memspec;
};

ssize_t sheapmem_check(struct shared_heap_memory *heap, void *block);

#endif /* CONFIG_XENO_PSHARED */

#ifdef CONFIG_XENO_REGISTRY
#define DEFAULT_REGISTRY_ROOT           CONFIG_XENO_REGISTRY_ROOT
#else
#define DEFAULT_REGISTRY_ROOT           NULL
#endif

struct corethread_attributes {
        size_t stacksize;
        int detachstate;
        int policy;
        struct sched_param_ex param_ex;
        int (*prologue)(void *arg);
        void *(*run)(void *arg);
        void *arg;
        struct {
                int status;
                sem_t warm;
                sem_t *released;
        } __reserved;
};

#ifdef __cplusplus
extern "C" {
#endif

void copperplate_set_current_name(const char *name);

int copperplate_get_current_name(char *name, size_t maxlen);

int copperplate_kill_tid(pid_t tid, int sig);

int copperplate_probe_tid(pid_t tid);
  
int copperplate_create_thread(struct corethread_attributes *cta,
                              pthread_t *ptid);

int copperplate_renice_local_thread(pthread_t ptid, int policy,
                                    const struct sched_param_ex *param_ex);

void copperplate_bootstrap_internal(const char *arg0,
                                    char *mountpt, int regflags);

#ifdef __cplusplus
}
#endif

#endif /* _COPPERPLATE_INTERNAL_H */