mptask.h

Go to the documentation of this file.

/****************************************************************************
 * modules/include/asmp/mptask.h
 *
 *   Copyright 2018 Sony Semiconductor Solutions Corporation
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of Sony Semiconductor Solutions Corporation nor
 *    the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/
#ifndef __INCLUDE_ASMP_MPTASK_H
#define __INCLUDE_ASMP_MPTASK_H

#include <sys/types.h>
#include <asmp/types.h>
#include <semaphore.h>
#include <stdbool.h>

#ifndef __DOCUMENT__
#ifndef CONFIG_SMP

/* void CPU_ZERO(FAR cpu_set_t *set); */

#  define CPU_ZERO(s) do { *(s) = 0; } while (0)

/* void CPU_SET(int cpu, FAR cpu_set_t *set); */

#  define CPU_SET(c,s) do { *(s) |= (1 << (c)); } while (0)

/* void CPU_CLR(int cpu, FAR cpu_set_t *set); */

#  define CPU_CLR(c,s) do { *(s) &= ~(1 << (c)); } while (0)

/* int  CPU_ISSET(int cpu, FAR const cpu_set_t *set); */

#  define CPU_ISSET(c,s) ((*(s) & (1 << (c))) != 0)

/* int CPU_COUNT(FAR const cpu_set_t *set); */

#  define CPU_COUNT(s) sched_cpu_count(s)

/* void CPU_AND(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
 *              FAR const cpu_set_t *srcset2);
 */

#  define CPU_AND(d,s1,s2) do { *(d) = *(s1) & *(s2); } while (0)

/* void CPU_OR(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
 *             FAR const cpu_set_t *srcset2);
 */

#  define CPU_OR(d,s1,s2) do { *(d) = *(s1) | *(s2); } while (0)

/* void CPU_XOR(FAR cpu_set_t *destset, FAR const cpu_set_t *srcset1,
 *              FAR const cpu_set_t *srcset2);
 */

#  define CPU_XOR(d,s1,s2) do { *(d) = *(s1) ^ *(s2); } while (0)

/* int CPU_EQUAL(FAR const cpu_set_t *set1, FAR const cpu_set_t *set2); */

#  define CPU_EQUAL(s1,s2) (*(s2) == *(s2))

/* REVISIT: Variably sized CPU sets are not supported */
/* FAR cpu_set_t *CPU_ALLOC(int num_cpus); */

#  define CPU_ALLOC(n) (FAR cpu_set_t *)malloc(sizeof(cpu_set_t));

/* void CPU_FREE(cpu_set_t *set); */

#  define CPU_FREE(s) free(s)

/* size_t CPU_ALLOC_SIZE(int num_cpus); */

#  define CPU_ALLOC_SIZE(n) sizeof(cpu_set_t)

/* void CPU_ZERO_S(size_t setsize, FAR cpu_set_t *set); */

#  define CPU_ZERO_S(n,s) CPU_ZERO_S(s)

/* void CPU_SET_S(int cpu, size_t setsize, FAR cpu_set_t *set); */

#  define CPU_SET_S(c,n,s) CPU_SET(c,s)

/* void CPU_CLR_S(int cpu, size_t setsize, FAR cpu_set_t *set); */

#  define CPU_CLR_S(c,n,s) CPU_CLR(c,s)

/* int CPU_ISSET_S(int cpu, size_t setsize, FAR const cpu_set_t *set); */

#  define CPU_ISSET_S(c,n,s) CPU_ISSET(c,s)

/* int CPU_COUNT_S(size_t setsize, FAR const cpu_set_t *set); */

#  define CPU_COUNT_S(n,s) CPU_COUNT(s)

/* void CPU_AND_S(size_t setsize, FAR cpu_set_t *destset,
 *                FAR const cpu_set_t *srcset1,
 *                FAR const cpu_set_t *srcset2);
 */

#  define CPU_AND_S(n,d,s1,s2) CPU_AND(d,s1,s2)

/* void CPU_OR_S(size_t setsize, FAR cpu_set_t *destset,
 *              FAR const cpu_set_t *srcset1,
 *              FAR const cpu_set_t *srcset2);
 */

#  define CPU_OR_S(n,d,s1,s2) CPU_OR(d,s1,s2)

/* void CPU_XOR_S(size_t setsize, FAR cpu_set_t *destset,
 *                FAR const cpu_set_t *srcset1,
 *                FAR const cpu_set_t *srcset2);
 */

#  define CPU_XOR_S(n,d,s1,s2) CPU_XOR(d,s1,s2)

/* int CPU_EQUAL_S(size_t setsize, FAR const cpu_set_t *set1,
 *                 FAR const cpu_set_t *set2);
 */

#  define CPU_EQUAL_S(n,s1,s2) CPU_EQUAL(s1,s2)

#endif
#endif

#define NMPBINDS 8

#define mptask_bindobj(t, o) mptask_bind((t), (mpobj_t *)(o))

typedef enum mptask_state
{
  STATE_INIT = 0,               
  STATE_EXEC,                   
  STATE_PAUSED,                 
  STATE_EXIT,                   
} mptask_state_t;

typedef struct mptask_attr
{
  int8_t status;                
  int8_t flags;                 
  cpu_set_t affinity;           
  uint32_t exit_status;         
} mptask_attr_t;

typedef struct mpbindobj
{
  key_t       key;
  mpobjtype_t type;
  uint32_t    value;
} mpbindobj_t;

typedef struct unified_binary
{
  int nr_offs;       /* Number of offsets has been stored */
  uint8_t offset[5]; /* Offset table, except CPU 0 */
  uint8_t size[5];   /* Size table, except CPU 0 */
} unified_binary_t;

typedef struct binary_info
{
  uint32_t loadaddr;
} binary_info_t;

typedef struct mptask
{
  int               fd;
  off_t             filelen;
  uintptr_t         loadaddr;
  size_t            loadsize;
  cpu_set_t         cpuids;
  int               groupid;
  mptask_attr_t     attr;

  /* filename is used when secure loading, and bounds is used for normal binary.
   * So I made them into union for prevent increasing the object size.
   */

  union {
    char              filename[32];
    mpbindobj_t       bounds[NMPBINDS];
  };

  int               nbounds;
  sem_t             wait;

  union {
    unified_binary_t  ubin;     /* Unified binary */
    binary_info_t     bin[5];   /* binary */
  };
} mptask_t;

#ifdef __cplusplus
#define EXTERN extern "C"
extern "C"
{
#else
#define EXTERN extern
#endif

/********************************************************************************
 * Public Function Prototypes
 ********************************************************************************/
int mptask_init(mptask_t *task, const char *filename);

int mptask_init_secure(mptask_t *task, const char *filename);

int mptask_attr_init(mptask_attr_t *attr);

int mptask_destroy(mptask_t *task, bool force, int *exit_status);

int mptask_bind(mptask_t *task, mpobj_t *obj);

int mptask_setattr(mptask_t *task, const mptask_attr_t *attr);

int mptask_getattr(mptask_t *task, mptask_attr_t *attr);

int mptask_assign(mptask_t *task);

int mptask_assign_cpus(mptask_t *task, int ncpus);

cpuid_t mptask_getcpuid(mptask_t *task);

int mptask_getcpuidset(mptask_t *task, cpu_set_t *cpuids);

int mptask_exec(mptask_t *task);

int mptask_join(mptask_t *task, int *exit_status);

#ifdef SDK_EXPERIMENTAL

int mptask_pause(mptask_t *task);

int mptask_restart(mptask_t *task);

#endif /* SDK_EXPERIMENTAL */

#undef EXTERN
#ifdef __cplusplus
}
#endif

#endif /* __INCLUDE_ASMP_MPTASK_H */