Include/vos_module.h

   1 /******************************************************************************
   2 *
   3 *   Copyright (c) 2020 ICT/CAS.
   4 *
   5 *   Licensed under the O-RAN Software License, Version 1.0 (the "Software License");
   6 *   you may not use this file except in compliance with the License.
   7 *   You may obtain a copy of the License at
   8 *
   9 *       https://www.o-ran.org/software
  10 *
  11 *   Unless required by applicable law or agreed to in writing, software
  12 *   distributed under the License is distributed on an "AS IS" BASIS,
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 *   See the License for the specific language governing permissions and
  15 *   limitations under the License.
  16 *
  17 *******************************************************************************/
  18
  19
  20
  21 #ifndef __VOS_MODULE_H__
  22 #define __VOS_MODULE_H__
  23
  24 #include "vos_types.h"
  25 #include "vos_timer.h"
  26 #include "vos_que.h"
  27 #include "vos_socket.h"
  28
  29
  30
  31 /** 模块名大小 */
  32 #define MODULE_NAME_LEN (48)
  33
  34
  35 /** 模块类型 */
  36 typedef enum module_type_e{
  37     VOS_MOD_T_NORMAL = 0,       ///< 一般模块
  38     VOS_MOD_T_HOST,             ///< host task
  39     VOS_MOD_T_USER,             ///< user task
  40     VOS_MOD_T_EXTERN,           ///< 外部模块 (不是 vos app 中的模块，其他的进程 )
  41     VOS_MOD_T_MAX,              ///<
  42 }module_type_t;
  43
  44 /** 模块通信类型 */
  45 typedef enum module_comm_type_e{
  46     VOS_MOD_COMM_T_VOS              = (1 << 0),     ///< vos 模块间通信
  47     VOS_MOD_COMM_T_UNIX_UDP_C       = (1 << 1),     ///< unix socket udp client
  48     VOS_MOD_COMM_T_UNIX_UDP_S       = (1 << 2),     ///< unix socket udp server
  49     VOS_MOD_COMM_T_UNIX_TCP_C       = (1 << 3),     ///< unix socket tcp client
  50     VOS_MOD_COMM_T_UNIX_TCP_S       = (1 << 4),     ///< unix socket tcp server
  51     VOS_MOD_COMM_T_UDP_C            = (1 << 5),     ///< udp client
  52     VOS_MOD_COMM_T_UDP_S            = (1 << 6),     ///< udp server
  53     VOS_MOD_COMM_T_TCP_C            = (1 << 7),     ///< tcp client
  54     VOS_MOD_COMM_T_TCP_S            = (1 << 8),     ///< tcp server
  55     VOS_MOD_COMM_T_SCTP_ONE2ONE_C   = (1 << 9),     ///< sctp one2one client
  56     VOS_MOD_COMM_T_SCTP_ONE2ONE_S   = (1 << 10),    ///< sctp one2one server
  57     VOS_MOD_COMM_T_SCTP_ONE2MANY_C  = (1 << 11),    ///< sctp one2many client
  58     VOS_MOD_COMM_T_SCTP_ONE2MANY_S  = (1 << 12),    ///< sctp one2many server
  59     VOS_MOD_COMM_T_SOCK_OP          = (1 << 13),    ///< socket
  60     VOS_MOD_COMM_T_MAX,                             ///< max
  61 }module_comm_type_t;
  62
  63
  64 /** 模块管理类型 */
  65 typedef struct vos_module_s{
  66     module_type_t       modType;                      ///< 模块类型
  67     LONG                commType;                     ///< 当前的通信类型
  68     ULONG               moduleID;                     ///< 模块ID
  69     CHAR                name[MODULE_NAME_LEN];        ///< 模块名
  70     ULONG               queueID;                      ///< 模块消息队列，用于接收从其他模块发送过来的消息
  71     LONG                paraCount;                    ///< 无需关心，         （添加的额外参数个数）
  72     void                *pPara;                       ///< 无需关心，         （vos_mod_com_para_cb_t）
  73     LONG                paraLock;                     ///< 无需关心，
  74 }vos_module_t;
  75
  76
  77 /** 采用非VOS通信方式的模块需要提供的handle函数，用于接收数据
  78 *   buf         用于消息接收的缓冲区
  79 *   size        buf 大小
  80 *   opval       额外信息，类型为 vos_mod_com_op_t
  81 *   opvalLen    opval的大小
  82 *
  83 */
  84 typedef LONG (*receive_handler)(VOID *buf,LONG size,VOID *opval,LONG opvalLen);
  85
  86
  87 /**
  88  * 模块注册 API
  89  * 向VOS 模块管理中注册模块 。
  90  * @param[in ]   name         模块名，大小为 MODULE_NAME_LEN
  91  * @param[in]    module       模块管理信息
  92  *                               传入值
  93  *                                      module.queueID  用于模块间通信
  94  *                                      module.mod_type 模块类型
  95  * @param[out]   module       模块管理信息
  96  *                               传出值
  97  *                                      module.name
  98  *                                      module.moduleID
  99  * @return       VOS_OK - 成功，其他 - 失败
 100  */
 101 LONG VOS_module_register(const CHAR *name,vos_module_t *module);
 102
 103
 104 /**
 105  * 模块注销 API
 106  * 向VOS 模块管理中注册模块 。
 107  * @param[in ]   name         模块名，大小为 MODULE_NAME_LEN
 108  * @return       VOS_OK - 成功，其他 - 失败
 109  */
 110 LONG VOS_module_deregister(const CHAR *name);
 111
 112
 113 /**
 114  * 根据模块ID获得模块名
 115  * @param[in ]   id         模块ID
 116  * @param[out]   name       模块名，大小为 MODULE_NAME_LEN
 117  * @return       VOS_OK - 成功，其他 - 失败
 118  */
 119 LONG VOS_module_get_name(ULONG id,CHAR name[MODULE_NAME_LEN]);
 120
 121 /**
 122  * 根据模块名获得模块ID
 123  * @param[in ]   name       模块名，大小为 MODULE_NAME_LEN
 124  * @return       成功返回模块ID，失败返回 0
 125  */
 126 ULONG VOS_module_get_Id(CHAR *name);
 127
 128
 129 /**
 130  * 向某个模块发送异步消息
 131  * @param[in ]   dst_slot           目的槽位号
 132  * @param[in ]   dst_moduleName     目的模块名，大小为 MODULE_NAME_LEN
 133  * @param[in ]   src_moduleName     源模块名，大小为 MODULE_NAME_LEN
 134  * @param[in ]   msgCode            消息码
 135  * @param[in ]   msgData            消息数据
 136  * @param[in ]   msgDataLen         消息数据长度
 137  * @return       成功返回 VOS_OK，失败返回 其他
 138  */
 139 LONG VOS_SendAsynMsg2Module(LONG dst_slot,CHAR dst_moduleName[MODULE_NAME_LEN],CHAR src_moduleName[MODULE_NAME_LEN],
 140                                     LONG msgCode,VOID *msgData,LONG msgDataLen);
 141
 142 /**
 143  * 向某个模块发送同步消息
 144  * @param[in ]   dst_slot           目的槽位号
 145  * @param[in ]   dst_moduleName     目的模块名，大小为 MODULE_NAME_LEN
 146  * @param[in ]   src_moduleName     源模块名，大小为 MODULE_NAME_LEN
 147  * @param[in ]   msgCode            消息码
 148  * @param[in ]   msgData            消息数据，如果没有则填 NULL
 149  * @param[in ]   msgDataLen         消息数据长度，如果msgData 为NULL 填0
 150  * @param[out]   ackData            接收返回数据的buf
 151  * @param[in ]   ackDataLen         输入：接收返回数据buf的长度
 152  * @param[out]   ackDataLen         输出：buf的有效长度
 153  * @param[in ]   timeout            等待接收的时间，单位毫秒,调用者自行判断需要等待时间，一般等待 5秒
 154  * @return       成功返回 VOS_OK，失败返回 其他
 155  */
 156 LONG VOS_SendSynMsg2Module(LONG dst_slot,CHAR dst_moduleName[MODULE_NAME_LEN],CHAR src_moduleName[MODULE_NAME_LEN],
 157                                   LONG msgCode,VOID *msgData,LONG msgDataLen,VOID *ackData,LONG *ackDataLen,LONG timeout);
 158
 159
 160
 161 /**
 162  * 向某个模块发送异步消息，支持非VOS通信方式
 163  * @param[in ]   dst_slot           目的槽位号
 164  * @param[in ]   dst_moduleName     目的模块名，大小为 MODULE_NAME_LEN
 165  * @param[in ]   src_moduleName     源模块名，大小为 MODULE_NAME_LEN
 166  * @param[in ]   msgCode            消息码
 167  * @param[in ]   msgData            消息数据
 168  * @param[in ]   msgDataLen         消息数据长度
 169  * @param[in ]   commType           通信方式
 170  * @param[in ]   optval             可选参数，不需要则填NULL
 171  * @param[in ]   optlen             可选参数长度
 172  * @return       成功返回 VOS_OK，失败返回 其他
 173  */
 174 LONG VOS_SendAsynMsg2ModuleEx(LONG dst_slot,CHAR dst_moduleName[MODULE_NAME_LEN],CHAR src_moduleName[MODULE_NAME_LEN],
 175                                       LONG msgCode,VOID *msgData,LONG msgDataLen,
 176                                       module_comm_type_t commType,VOID *optval,LONG optlen);
 177
 178
 179 /**
 180  * 向某个模块发送同步消息，仅支持VOS通信方式
 181  * @param[in ]   dst_slot           目的槽位号
 182  * @param[in ]   dst_moduleName     目的模块名，大小为 MODULE_NAME_LEN
 183  * @param[in ]   src_moduleName     源模块名，大小为 MODULE_NAME_LEN
 184  * @param[in ]   msgCode            消息码
 185  * @param[in ]   msgData            消息数据，如果没有则填 NULL
 186  * @param[in ]   msgDataLen         消息数据长度，如果msgData 为NULL 填0
 187  * @param[out]   ackData            接收返回数据的buf
 188  * @param[in ]   ackDataLen         输入：接收返回数据buf的长度
 189  * @param[out]   ackDataLen         输出：buf的有效长度
 190  * @param[in ]   timeout            等待接收的时间，单位毫秒,调用者自行判断需要等待时间，一般等待 5秒
 191  * @param[in ]   commType           通信方式
 192  * @param[in ]   optval             可选参数，不需要则填NULL
 193  * @param[in ]   optlen             可选参数长度
 194  * @return       成功返回 VOS_OK，失败返回 其他
 195  */
 196 LONG VOS_SendSynMsg2ModuleEx(LONG dst_slot,CHAR dst_moduleName[MODULE_NAME_LEN],CHAR src_moduleName[MODULE_NAME_LEN],
 197                                     LONG msgCode,VOID *msgData,LONG msgDataLen,VOID *ackData,LONG *ackDataLen,LONG timeout,
 198                                     module_comm_type_t commType,VOID *optval,LONG optlen);
 199
 200 LONG VOS_SendAsynMsg2Module_Raw(LONG dst_slot,CHAR dst_moduleName[MODULE_NAME_LEN],CHAR src_moduleName[MODULE_NAME_LEN],
 201                                     ULONG aulMsg[VOS_QUEUE_MSG_SIZE]);
 202
 203
 204
 205 /**
 206 * 回复同步消息
 207 * @param[in ]   aulMsg             VOS_QueReceive 收到的原始消息
 208 * @param[in ]   ackData            返回数据的buf
 209 * @param[in ]   ackDataLen         返回数据buf的长度
 210 * @return       成功返回 VOS_OK，失败返回 其他
 211 */
 212 LONG VOS_SendSynAckMsg(ULONG aulMsg[VOS_QUEUE_MSG_SIZE],VOID *ackData,LONG ackDataLen);
 213
 214
 215 /**
 216 * 注册timer 消息
 217 * @param[in ]   module_ID        要注册timer msg的模块号
 218 * @param[in ]   msg_code         消息码
 219 * @param[in ]   interval         发送间隔,毫秒
 220 * @param[in ]   type             类型，循环或者只执行一次
 221 * @param[in ]   pArg             附加参数，一般为一个指针
 222 * @return       成功返回 VOS_OK，失败返回 其他
 223 */
 224 LONG VOS_RegTimerMsg(LONG module_ID,LONG msg_code,LONG interval,VOS_TIMER_TYPE_EN type,VOID  *pArg);
 225
 226
 227 /**
 228 * 注销timer 消息
 229 * @param[in ]   module_ID        要注销timer msg的模块号
 230 * @param[in ]   msg_code         消息码
 231 * @return       成功返回 VOS_OK，失败返回 其他
 232 */
 233 LONG VOS_DeregTimerMsg(LONG module_ID,LONG msg_code);
 234
 235
 236 /** 从原始消息中获取消息类型 （同步/异步） */
 237 #define VOS_MOD_MSG_GET_EVENT_TYPE(aulMsg)       aulMsg[0]
 238
 239 /** 从原始消息中获取消息类码 */
 240 #define VOS_MOD_MSG_GET_CODE(aulMsg)         ((SYS_MSG_S *)(aulMsg[3]))->usMsgCode
 241
 242
 243 /** 从原始消息中获取源模块号 */
 244 #define VOS_MOD_MSG_GET_SRC_ID(aulMsg)       ((SYS_MSG_S *)(aulMsg[3]))->ulSrcModuleID
 245
 246
 247 /** 从原始消息中获取目的模块号 */
 248 #define VOS_MOD_MSG_GET_DST_ID(aulMsg)       ((SYS_MSG_S *)(aulMsg[3]))->ulDstModuleID
 249
 250
 251 /** 从原始消息中获取源槽位号 */
 252 #define VOS_MOD_MSG_GET_SRC_SLOT(aulMsg)     ((SYS_MSG_S *)(aulMsg[3]))->ulSrcSlotID
 253
 254
 255 /** 从原始消息中获取目的槽位号 */
 256 #define VOS_MOD_MSG_GET_DST_SLOT(aulMsg)     ((SYS_MSG_S *)(aulMsg[3]))->ulDstSlotID
 257
 258
 259 /** 从原始消息中获取消息长度 */
 260 #define VOS_MOD_MSG_GET_LEN(aulMsg)        ((SYS_MSG_S *)(aulMsg[3]))->usFrameLen
 261
 262 /** 从原始消息中获取消息buf 的指针 */
 263 #define VOS_MOD_MSG_GET_DATAPTR(aulMsg)    ((SYS_MSG_S *)(aulMsg[3]))->ptrMsgBody
 264
 265 /** 从原始消息中拷贝消息到dst中 */
 266 #define VOS_MOD_MSG_GET_DATA(dst,aulMsg)   if( NULL != VOS_MOD_MSG_GET_DATAPTR(aulMsg) )                                                 \
 267                                            {  VOS_MemCpy(dst,VOS_MOD_MSG_GET_DATAPTR(aulMsg),VOS_MOD_MSG_GET_LEN(aulMsg));  }           \
 268                                            else                                                                                         \
 269                                            {  VOS_ASSERT(0);   }
 270
 271 /** 释放原始消息中的sys msg */
 272 #define VOS_MOD_MSG_FREE(aulMsg)           VOS_Free((VOID *)aulMsg[3])
 273
 274
 275 /** msg handler的函数原型 */
 276 typedef LONG(*VOS_msg_code_handler_ptr)(ULONG aulMsg[VOS_QUEUE_MSG_SIZE]);
 277
 278
 279 /** 用于模块间通信的code 和 handler的map */
 280 typedef struct msg_code_handle_map_s
 281 {
 282     LONG                     msg_code;   ///< 消息码
 283     VOS_msg_code_handler_ptr handler;    ///< 消息码的处理函数
 284 }VOS_msg_code_handle_map_t;
 285
 286
 287
 288 #endif /* __VOS_MODULE_H__ */