# Copyright 2017 syzkaller project authors. All rights reserved.
# Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
# Recursive resources.
resource r0[r0] ### recursive resource r0->r0
resource r1[r2] ### recursive resource r1->r2->r1
resource r2[r1] ### recursive resource r2->r1->r2
resource r3[int32] ### unused resource r3
foo$0(a0 ptr[out, r0], a1 ptr[out, r1], a2 ptr[out, r2])
# Recursive structs/unions.
sr1 {
f1 sr1 ### recursive declaration: sr1.f1 -> sr1 (mark some pointers as opt)
}
sr2 {
f1 sr3
f2 sr4
}
sr3 {
f1 ptr[in, sr3] ### recursive declaration: sr3.f1 -> sr3 (mark some pointers as opt)
}
sr4 {
f1 ptr[in, sr3]
f2 array[ptr[in, sr5], 4] ### recursive declaration: sr4.f2 -> sr5.f2 -> sr6.f1 -> sr4 (mark some pointers as opt)
}
sr5 [
f1 int32
f2 sr6
]
sr6 {
f1 sr4
}
sr7 {
f1 ptr[in, sr7, opt]
}
type templ_sr[T] {
f T
}
sr8 {
f templ_sr[sr8] ### recursive declaration: sr8.f -> templ_sr[sr8].f -> sr8 (mark some pointers as opt)
}
sr9 {
f templ_sr[ptr[in, sr9]] ### recursive declaration: sr9.f -> templ_sr[ptr[in, sr9]].f -> sr9 (mark some pointers as opt)
}
use_sr {
u2 u2
u3 u3
s3 s3
s4 s4
s6 s6
sr1 sr1
sr2 sr2
sr5 sr5
sr7 sr7
sr8 sr8
sr9 sr9
s400 s400
s401 s401
u400 u400
u401 u401
s402 s402
s403 s403
} [packed]
foo$sr0(a ptr[in, use_sr])
# Len target tests.
foo$100(a int32, b len[a])
foo$101(a len[a]) ### len target a refer to itself
foo$102(a ptr[in, len[a, int8]]) ### len target a refer to itself
foo$103(a int32, b len[c]) ### len target c does not exist
foo$104(a len[parent]) ### len target parent does not exist
foo$105(a ptr[in, int32], b ptr[in, array[len[a, int32]]])
foo$106(a int32, b ptr[in, csum[a, inet, int32]])
foo$107(a int32, b ptr[in, csum[c, inet, int32]]) ### csum target c does not exist
s1 {
f1 len[s2, int32] ### len target s2 does not exist
}
s2 {
f1 s1
}
s3 {
f1 int8
} [size[0]] ### size attribute has bad value 0, expect [1, 1<<20]
s4 {
f1 int8
} [size[1000000000]] ### size attribute has bad value 1000000000, expect [1, 1<<20]
s6 {
f1 int8
f2 array[int8]
} [size[10]] ### varlen struct s6 has size attribute
u1 [
f1 ptr[in, array[int8]]
f2 len[f1, int32] ### len target f1 does not exist
]
u2 [
f1 int8
] [size[0]] ### size attribute has bad value 0, expect [1, 1<<20]
u3 [
f1 int8
] [varlen, size[8]] ### varlen union u3 has size attribute
foo$200(a ptr[in, s2])
foo$201(a ptr[in, s1])
foo$202(a u1)
# Resource ctor tests.
resource r100[int32] ### resource r100 can't be created (never mentioned as a syscall return value or output argument/field)
resource r101[int32]
resource r102[r101]
resource r103[r102]
resource r104[int8]
resource r105[int8]
resource r106[int8] ### resource r106 can't be created (never mentioned as a syscall return value or output argument/field)
resource r107[int8] ### resource r107 can't be created (never mentioned as a syscall return value or output argument/field)
foo$300(a r100)
foo$301(a ptr[out, array[r103]], b ptr[in, s300], c r107) r104
s300 {
f1 ptr[inout, s301]
f2 r106
}
s301 {
f2 r105
}
# Varlen field tests.
s400 {
f1 int32
f2 array[int8]
}
s401 {
f1 array[int8]
f2 array[int8]
} [packed]
s402 {
f1 array[int8] ### variable size field f1 in the middle of non-packed struct s402
f2 int32
}
u400 [
f1 array[int8]
f2 array[int16]
] [varlen]
u401 [
f1 filename ### variable size field f1 in non-varlen union u401
f2 text[x86_64] ### variable size field f2 in non-varlen union u401
f3 string ### variable size field f3 in non-varlen union u401
f4 string["foo", 10]
f5 string[sf400]
f6 string[sf401] ### variable size field f6 in non-varlen union u401
f7 s401 ### variable size field f7 in non-varlen union u401
]
u402 [
f1 int32
f2 int32
] [varlen]
s403 {
f1 u400 ### variable size field f1 in the middle of non-packed struct s403
f2 u402 ### variable size field f2 in the middle of non-packed struct s403
f3 int32
}
s404 { ### unused struct s404
f1 int8
}
u404 [ ### unused union u404
f1 int8
]
sf400 = "foo", "bar", "baz"
sf401 = "a", "b", "cd"
sf402 = "a", "b" ### unused string flags sf402
# Const argument checks.
foo$500(a int32[3:2]) ### bad int range [3:2]
foo$501(a ptr[in, int32[3:2]]) ### bad int range [3:2]
foo$502(a ptr[in, string["foo", C1]]) ### string value "foo\x00" exceeds buffer length 1
foo$503(a ptr[in, proc[1000, 1, int8]]) ### values starting from 1000 overflow base type
foo$504(a ptr[in, proc[20, 10, int8]]) ### values starting from 20 with step 10 overflow base type for 32 procs
foo$505(a proc[20, 0]) ### proc per-process values must not be 0
foo$506(a ptr[in, array[int32, 0]]) ### arrays of size 0 are not supported
foo$507(a ptr[in, array[int32, 0:0]]) ### arrays of size 0 are not supported
foo$508(a ptr[in, string["foo", 3]]) ### string value "foo\x00" exceeds buffer length 3
foo$509(a int8['b':'a']) ### bad int range [98:97]
foo$510(a type500)
foo$511(a int32[-10:-20]) ### bad int range [18446744073709551606:18446744073709551596]
foo$512(a ptr[in, array[int8, -2:-1]]) ### bad size range [18446744073709551614:18446744073709551615]
foo$513(a ptr[in, array[int8, -2:2]]) ### bad size range [18446744073709551614:2]
foo$514(a vma[-2:2]) ### bad size range [18446744073709551614:2]
foo$515(a ptr[in, proc[1, -10, int64]]) ### values starting from 1 with step 18446744073709551606 overflow base type for 32 procs
type type500 proc[C1, 8, int8] ### values starting from 1 with step 8 overflow base type for 32 procs
type type501 int8 ### unused type type501
type type502[C] const[C, int8] ### unused type type502