vsf_loader.h

Go to the documentation of this file.

/*****************************************************************************
 *   Copyright(C)2009-2022 by VSF Team                                       *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *     http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 ****************************************************************************/
 
#ifndef __VSF_LOADER_H__
#define __VSF_LOADER_H__
 
/*============================ INCLUDES ======================================*/
 
#include "service/vsf_service_cfg.h"
#include "utilities/vsf_utilities.h"
 
#if VSF_USE_LOADER == ENABLED
 
#undef PUBLIC_CONST
#if     defined(__VSF_LOADER_CLASS_IMPLEMENT)
#   define __VSF_CLASS_IMPLEMENT__
#   define PUBLIC_CONST
#elif   defined(__VSF_LOADER_CLASS_INHERIT__)
#   define __VSF_CLASS_INHERIT__
#   define PUBLIC_CONST
#else
#   define PUBLIC_CONST                 const
#endif
 
#include "utilities/ooc_class.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*============================ MACROS ========================================*/
/*============================ MACROFIED FUNCTIONS ===========================*/
 
#define vsf_loader_read(__target, __offset, __ptr, __size)                      \
        (__target)->fn_read((__target), (__offset), (__ptr), (__size))
 
#define vsf_loader_malloc(__loader, __attr, __size, __align)                    \
        (__loader)->heap_op->fn_malloc((vsf_loader_t *)(__loader), (__attr), (__size), (__align))
#define vsf_loader_free(__loader, __attr, __ptr)                                \
        (__loader)->heap_op->fn_free((vsf_loader_t *)(__loader), (__attr), (__ptr))
 
/*============================ TYPES =========================================*/
 
vsf_dcl_class(vsf_loader_t)
 
 
typedef enum vsf_loader_mem_attr_t {
    VSF_LOADER_MEM_R    = 1 << 0,
    VSF_LOADER_MEM_W    = 1 << 1,
    VSF_LOADER_MEM_X    = 1 << 2,
    VSF_LOADER_MEM_RW   = VSF_LOADER_MEM_R | VSF_LOADER_MEM_W,
    VSF_LOADER_MEM_RWX  = VSF_LOADER_MEM_X | VSF_LOADER_MEM_RW,
} vsf_loader_mem_attr_t;
 
typedef struct vsf_loader_heap_op_t {
    void * (*fn_malloc)(vsf_loader_t *loader, vsf_loader_mem_attr_t attr, uint32_t size, uint32_t alignment);
 
    void (*fn_free)(vsf_loader_t *loader, vsf_loader_mem_attr_t attr, void *buffer);
} vsf_loader_heap_op_t;
 
typedef struct vsf_loader_target_t vsf_loader_target_t;
struct vsf_loader_target_t {
    uintptr_t object;
 
    bool support_xip;
 
    uint32_t (*fn_read)(vsf_loader_target_t *target, uint32_t offset, void *buffer, uint32_t size);
};
 
typedef struct vsf_loader_op_t {
    int (*fn_load)(vsf_loader_t *loader, vsf_loader_target_t *target);
    void (*fn_cleanup)(vsf_loader_t *loader);
    int (*fn_call_init_array)(vsf_loader_t *loader);
    void (*fn_call_fini_array)(vsf_loader_t *loader);
    void * (*fn_remap)(vsf_loader_t *loader, void *vaddr);
} vsf_loader_op_t;
 
 
vsf_class(vsf_loader_t) {
    public_member(
        const vsf_loader_heap_op_t *heap_op;
        const vsf_loader_op_t *op;
 
        PUBLIC_CONST void *static_base;
        PUBLIC_CONST void *entry;
        PUBLIC_CONST void *vplt_out;
 
        void *vplt;
        void * (*alloc_vplt)(int num);
        void (*free_vplt)(void *vplt);
    )
    protected_member(
        vsf_loader_target_t *target;
    )
};
 
/*============================ GLOBAL VARIABLES ==============================*/
 
#if VSF_USE_HEAP == ENABLED
extern const vsf_loader_heap_op_t vsf_loader_default_heap_op;
#endif
 
/*============================ PROTOTYPES ====================================*/
 
extern uint32_t vsf_loader_xip_read(vsf_loader_target_t *target, uint32_t offset, void *buffer, uint32_t size);
 
extern uint32_t vsf_loader_stdio_read(vsf_loader_target_t *target, uint32_t offset, void *buffer, uint32_t size);
 
#if defined(__VSF_LOADER_CLASS_IMPLEMENT) || defined(__VSF_LOADER_CLASS_INHERIT__)
extern void * vsf_loader_link(vsf_loader_t *loader, const char *name);
#endif
 
extern int vsf_loader_load(vsf_loader_t *loader, vsf_loader_target_t *target);
extern void vsf_loader_cleanup(vsf_loader_t *loader);
extern int vsf_loader_call_init_array(vsf_loader_t *loader);
extern void vsf_loader_call_fini_array(vsf_loader_t *loader);
extern void * vsf_loader_remap(vsf_loader_t *loader, void *vaddr);
 
#ifdef __cplusplus
}
#endif
 
#undef __VSF_LOADER_CLASS_IMPLEMENT
#undef __VSF_LOADER_CLASS_INHERIT__
 
/*============================ INCLUDES ======================================*/
 
#if VSF_LOADER_USE_ELF == ENABLED
#   include "./elf/vsf_elfloader.h"
#endif
#if VSF_LOADER_USE_PE == ENABLED
#   include "./pe/vsf_peloader.h"
#endif
 
 
#endif      // VSF_USE_LOADER
#endif      // __VSF_LOADER_H__