检查代码示例

函数枚举参数传入了变量

enum Days { MONDAY = 0, TUESDAY = 1, WEDNESDAY = 2, THURSDAY = 3, FRIDAY = 4, SATURDAY = 5, SUNDAY = 6 };
void func(enum Days day);
int main()
{
    int day = 1;
    func(day);
    return 0;
}

虽然此处day是个合法的枚举值，但违反了禁止枚举类型参数传入变量的规则，因此会报错：ENUM.INVALID。

函数枚举参数传入了非法值

enum Days { MONDAY = 0, TUESDAY = 1, WEDNESDAY = 2, THURSDAY = 3, FRIDAY = 4, SATURDAY = 5, SUNDAY = 6 };
void func(enum Days day1, enum Days day2);
int main()
{
    func(MONDAY, 7);
    return 0;
}

枚举类型Days定义的范围为0~6，传入整数7会报错：ENUM.VALUE。

直接使用u8 *类型变量接收接口函数返回值

typedef struct byte36 {
    u32 byte[9]; 
} byte36_s;
const u8 *const flexda_ucc_get_current_algo_params(){}
int main()
{
    const byte36_s *ret1 = (const byte36_s *) flexda_ucc_get_current_algo_params();
    const u8 *ret2 = (const u8 *) ret1;  // 再次强转成u8 *指针，禁止
    return 0;
}

虽然该接口定义中的返回值类型为const u8 *，但实际指向16Bytes大小的内存空间，因此必须使用大小为16Bytes的结构体类型的指针对返回值进行强转接收，直接使用u8 *会报错：RET.INVALID.TYPE。

使用了大小不符合要求的结构体变量接收函数返回值

typedef struct byte40 {
    u32 byte[10]; 
} byte40_s;
const u8 *const flexda_ucc_get_current_algo_params();
int main()
{
    const byte40_s *ret1 = (const byte40_s *) flexda_ucc_get_current_algo_params(); // 强转为超过内存大小的结构体，禁止
    return 0;
}

返回值大小为16Bytes，使用40Bytes大小的结构体指针接收报错：RET.INVALID.SIZE。

使用memcpy_s函数时从返回值读取超过大小的内存

typedef struct byte16 {
    u32 byte[4];
} byte16_s;
const u8 *const flexda_ucc_get_current_algo_params();
int memcpy_s(void *dest, int size, const void *src, int count);
char *myfunc_str();
int main()
{
    const byte16_s *ret1 = (const byte16_s *) flexda_ucc_get_current_algo_params();
    char *str = myfunc_str();
    memcpy_s(str, 10, ret1, 100);
    return 0;
}

函数返回值大小为16Bytes，使用memcpy_s函数进行内存拷贝时，传入的表示读取字节数的参数为100，超过了限制，报错：RET.INVALID.COPY。

对接收函数返回值的变量进行解引用

const u8 *const flexda_ucc_get_current_algo_params();
int main()
{
    const roce_ucc_ldcp_param_s *ret;
    ret = (const roce_ucc_ldcp_param_s *)flexda_ucc_get_current_algo_params();
    u32 val = (*(ret + 1)).dw0.value;
    return 0;
}

禁止对ret变量使用解引用操作符*，避免结合指针的算术运算造成越界访问，报错：RET.FORBID.DEREF。

通过数组索引形式访问接收函数返回值的变量

const u8 *const flexda_ucc_get_current_algo_params();
int main()
{
    const roce_ucc_ldcp_param_s *ret = (const roce_ucc_ldcp_param_s *)flexda_ucc_get_current_algo_params();
    u32 val = ret[0].rsvd1[0];
    return 0;
}

禁止使用形如ret[0]的形式访问接收函数返回值的指针变量，容易造成访问越界，报错：RET.FORBID.INDEX。

使用大小不符合要求的结构体指针强转接口函数入参

typedef struct mem_byte18 {
    u8 byte[18];
} mem_byte18_s;
void flexda_ucc_user_rp_algo(
    ucc_event_e event_type, ucode_ucc_ext_ctx_s *ucc_ctx, roce_ucc_event_input_s *input, u8 algo_id)
{
    mem_byte18_s *ctx = (mem_byte18_s *)ucc_ctx;
}

ucc_ctx指向大小为32Bytes的内存空间，因此强转时必须使用大小为32Bytes的结构体指针，此处使用了18Bytes大小的结构体，报错：PARAM.INVALID.SIZE。

使用了不符合要求的内存拷贝函数

void *memset_s(void *dest, int size, int c, int count);
 
void flexda_ucc_user_rp_algo(dcc_event_e event_type, ucode_ucc_ext_ctx_s *const ctx, 
    const roce_ucc_event_input_s *const event_input, u8 algo_id)
{
    memset_s(ucc_ctx, sizeof(ucc_ctx), 0, 1);
}

verifier允许使用memset_s/memcpy_s函数对接口函数入参进行赋值/拷贝，且可以是自行实现的，但要求函数原型必须为：

int memset_s(void *dest, int size, int c, int count);
int memcpy_s(void *dest, int size, const void *src, int count);

上面的例子中memset_s返回类型是void *，不符合规则，报错：PARAM.INVALID.COPY。

对接口函数内存入参进行解引用

void flexda_ucc_user_rp_algo(
    ucc_event_e event_type, ucode_ucc_ext_ctx_s *ucc_ctx, roce_ucc_event_input_s *input, u8 algo_id)
{
    ucode_ucc_ext_ctx_s *ucc_ctx2 = (ucode_ucc_ext_ctx_s *)ucc_ctx;
    u32 val = (*(ucc_ctx + 1)).dcc0;
}

与对接收函数返回值的变量进行解引用类似，报错：PARAM.FORBID.DEREF。

通过数组索引形式访问接口函数内存入参

void flexda_ucc_user_rp_algo(
    ucc_event_e event_type, ucode_ucc_ext_ctx_s *ucc_ctx, roce_ucc_event_input_s *input, u8 algo_id)
{
    u32 val = ucc_ctx[1].dcc[0];
 }

与通过数组索引形式访问接收函数返回值的变量类似，报错：PARAM.FORBID.INDEX。

将const类型强转为非const类型

const u8 *const flexda_ucc_get_current_algo_params();
int main()
{
    roce_ucc_ldcp_param_s *ret =
        (roce_ucc_ldcp_param_s *)flexda_ucc_get_current_algo_params();
    return 0;
}

接口的返回值类型是const u8 *const，应强转为const roce_ucc_ldcp_param_s *const，报错：CONST.INVALID.CAST。

代码中使用了内嵌汇编码

int main() {
    int a = 5, b = 3;
    asm volatile ("addl %1, %0" : "+r" (a) : "r" (b));
    printf("result: %d\n", a);
    return 0;
}

禁止在代码中使用内嵌汇编码，报错：INLINE.ASSEMBLY。

函数入参传入不正确的类型

void flexda_ucc_update_cwnd(u32 cwnd_bytes);
int main()
{
    s32 sa = -1;
    flexda_ucc_update_cwnd(sa);
    return 0;
}

函数flexda_ucc_update_cwnd接收的参数类型为u32，传入s32类型时编译器会做隐式类型转换，但verifier会拦截此写法，报错：MISMATCH.INVALID.TYPE。

函数传入规定范围外的值

u32 flexda_ucc_update_packet_source_port();
int main()
{
    flexda_ucc_update_packet_source_port(256);
    return 0;
}

假设规定该函数入参范围为[0, 255]，则此处传入256会报错：MISMATCH.INVALID.VALUE。

父主题： UCC Verifier错误编码