def _call_packet_copy(i, **kwargs):
# If you're thinking 'wow, this function looks complicated,' just go
# take a look at kernel/bpf/verifier.c:find_good_pkt_pointers to see
# the hoops that we're jumping through here.
ret = []
fn, skb, dst_ptr, offset, num_bytes = i.src_vars
# TODO: also support ptr to context?
if not isinstance(skb, _mem.ArgVar):
raise TranslationError(
i.starts_line,
'First argument to packet_copy must be SkBuffContext argument')
elif not isinstance(num_bytes, _mem.ConstVar):
raise TranslationError(
i.starts_line,
'Num bytes must not be dynamically defined for packet_copy')
skb_data_mem = bi.Mem(_get_var_reg(skb), skb.var_type.data.offset,
bi.Size.Word)
skb_data_end_mem = bi.Mem(_get_var_reg(skb), skb.var_type.data_end.offset,
bi.Size.Word)
out_of_bounds = _make_tmp_label()
# ret = _mov(dst_ptr, bi.Reg.R1)
dst_ptr = _convert_var(dst_ptr)
# %r2 = skb->data
ret.append(bi.Mov(skb_data_mem, bi.Reg.R2))
# %r2 += offset
if isinstance(offset, _mem.ConstVar):
off_val = offset.val
if hasattr(off_val, 'value'):
off_val = off_val.value
if off_val != 0:
ret.append(bi.Add(bi.Imm(off_val), bi.Reg.R2))
else:
ret.extend(_mov(offset, bi.Reg.R3))
ret.append(bi.Add(bi.Reg.R3, bi.Reg.R2))
# %r3 = %r2
ret.append(bi.Mov(bi.Reg.R2, bi.Reg.R3))
# %r2 += num_bytes
ret.append(bi.Add(bi.Imm(num_bytes.val), bi.Reg.R2))
# %r4 = skb->data_end
ret.append(bi.Mov(skb_data_end_mem, bi.Reg.R4))
# if skb->data + offset + num_bytes > skb->data_end: goto out_of_bounds
ret.append(bi.JumpIfGreaterThan(bi.Reg.R4, bi.Reg.R2, out_of_bounds))
ret.extend(_memcpy_packet(i, dst_ptr, bi.Reg.R3, num_bytes.val))
ret.append(bi.Label(out_of_bounds))
return ret
def _memcpy(i, dst_reg, src_reg, num_bytes):
ret = []
# Unpack ctype
if hasattr(num_bytes, 'value'):
num_bytes = num_bytes.value
for i in range(num_bytes):
sm = bi.Mem(src_reg, i, bi.Size.Byte)
dm = bi.Mem(dst_reg, i, bi.Size.Byte)
ret.extend(_mov(sm, dm))
return ret
def _store_subscr_arr(i):
val, arr, index = i.src_vars
op_sz = _get_cdata_size(arr.var_type._type_)
return (_load_arr_element_addr(i, arr, index, bi.Reg.R0) +
_mov(val, bi.Reg.R1) +
_mov(bi.Reg.R1, bi.Mem(bi.Reg.R0, 0, op_sz)))
def _load_attr_val(i, **kwargs):
sv, dv = i.src_vars[0], i.dst_vars[0]
name = i.argval
if issubclass(sv.var_type, _types.Ptr):
sz = _get_cdata_size(_get_attr_type(sv.var_type.var_type, name))
off = getattr(sv.var_type.var_type, i.argval).offset
return _mov(sv, bi.Reg.R0) + _mov(bi.Mem(bi.Reg.R0, off, sz), dv)
else:
assert isinstance(sv, _stack.StackVar) or isinstance(sv, _mem.ArgVar)
sz = _get_cdata_size(_get_attr_type(sv.var_type, name))
off = getattr(sv.var_type, i.argval).offset
reg = _get_var_reg(sv)
if isinstance(sv, _stack.StackVar):
off += sv.offset
return _mov(bi.Mem(reg, off, sz), dv)
def _call_mem_eq(i, **kwargs):
if (not isinstance(i.src_vars[1], _mem.ConstVar)
or not issubclass(i.src_vars[1].var_type, ctypes.Array)):
raise TranslationError(
i.starts_line, 'first arg to mem_eq must be const ctypes.Array')
ret = []
# stack=None because we shouldn't need to allocate anything
ret.extend(_lea(i, i.src_vars[2], bi.Reg.R2, stack=None))
false, done = _make_tmp_label(), _make_tmp_label()
for off, v in enumerate(i.src_vars[1].val.value):
ret.extend([
bi.Mov(bi.Mem(bi.Reg.R2, off, bi.Size.Byte), bi.Reg.R1),
bi.JumpIfNotEqual(bi.Imm(v), bi.Reg.R1, false)
])
# If we made it here, it's a match
ret.extend(_mov(bi.Imm(1), i.dst_vars[0]))
ret.append(bi.Jump(done))
# if we jumped here, it's not a match
ret.append(bi.Label(false))
ret.extend(_mov(bi.Imm(0), i.dst_vars[0]))
ret.append(bi.Label(done))
return ret
def _memcpy_packet(i, dst_reg, src_reg, num_bytes):
ret = []
# Unpack ctype
if isinstance(dst_reg, bi.Mem):
off = dst_reg.off
d_reg = dst_reg.reg
else:
raise TranslationError(i.starts_line, 'dst_reg must be bi.Mem')
if hasattr(num_bytes, 'value'):
num_bytes = num_bytes.value
for j in range(num_bytes):
dm = bi.Mem(d_reg, off, bi.Size.Byte)
sm = bi.Mem(src_reg, j, bi.Size.Byte)
ret.extend(_mov(sm, dm))
off += 1
return ret
def _binary_subscr_arr(i):
arr, index, dv = i.src_vars[0], i.src_vars[1], i.dst_vars[0]
vt = arr.var_type
if _is_ptr(arr.var_type):
vt = vt.var_type
op_sz = _get_cdata_size(vt._type_)
return (_load_arr_element_addr(i, arr, index, bi.Reg.R0) +
_mov(bi.Mem(bi.Reg.R0, 0, op_sz), bi.Reg.R0) + _mov(bi.Reg.R0, dv))
def _store_attr(i, **kwargs):
val, obj = i.src_vars
reg = _get_var_reg(obj)
off = getattr(obj.var_type, i.argval).offset
if isinstance(obj, _stack.StackVar):
off += obj.offset
for f, t in obj.var_type._fields_:
if f == i.argval:
sz = _get_cdata_size(t)
return _mov(val, bi.Mem(reg, off, sz))
assert False, 'Unreachable. Programmer error?'
def _mov_const(val_type, val, reg, offset):
if issubclass(val_type, FileDescriptorDatastructure):
return (_mov(bi.MapFdImm(val.fd), bi.Reg.R0) +
_mov(bi.Reg.R0, bi.Mem(reg, offset, bi.Size.Quad)))
if issubclass(val_type, _ctypes._SimpleCData):
# They may have passed us a vanilla int here
if hasattr(val, 'value'):
val = val.value
dst_mem = bi.Mem(reg, offset, _get_cdata_size(val_type))
return [bi.Mov(bi.Imm(val), dst_mem)]
ret = []
if issubclass(val_type, ctypes.Array):
for i in range(val_type._length_):
el_off = offset + ctypes.sizeof(val_type._type_) * i
el = val[i] if i < len(val) else val_type._type_()
ret.extend(_mov_const(val_type._type_, el, reg, el_off))
else:
for f, t in val_type._fields_:
f_val = getattr(val, f)
f_off = getattr(val_type, f).offset
ret.extend(_mov_const(t, f_val, reg, offset + f_off))
return ret
def _convert_var(var):
if isinstance(var, _mem.ConstVar):
assert issubclass(var.var_type, _ctypes._SimpleCData)
# TODO: handle non-int types...
return bi.Imm(var.val.value)
elif isinstance(var, _stack.StackVar) or isinstance(var, _mem.ArgVar):
sz = _get_cdata_size(var.var_type)
return bi.Mem(_get_var_reg(var), var.offset, sz)
elif all([
not isinstance(var, t)
for t in [bi.Reg, bi.Mem, bi.Imm, bi.Imm64, bi.MapFdImm]
]):
raise NotImplemented('StackVar, ArgVar, ConstVar, what am I missing?')
return var
def _call_load_xdp_data(i, **kwargs):
ret = []
fn, skb, offset = i.src_vars
data = i.dst_vars[0]
if not isinstance(skb, _mem.ArgVar):
raise TranslationError(
i.starts_line,
'First argument to load_xdp_data must be XdpMetaDataContext argument'
)
if isinstance(offset, _mem.ConstVar):
assert issubclass(offset.var_type, _ctypes._SimpleCData)
offset = offset.val.value
skb_data_mem = bi.Mem(_get_var_reg(skb), offset, bi.Size.Word)
ret.append(bi.Mov(skb_data_mem, bi.Reg.R2))
data = _convert_var(data)
ret.append(bi.Mov(bi.Reg.R2, data))
return ret
def _binary_subscr_map(i, **kwargs):
m, k, dv = i.src_vars[0], i.src_vars[1], i.dst_vars[0]
if not isinstance(m, _mem.ConstVar):
raise TranslationError(i.starts_line,
'Cannot subscript dynamically select map')
found, done = _make_tmp_label(), _make_tmp_label()
ret = []
ret.extend(_mov(bi.MapFdImm(m.val.fd), bi.Reg.R1))
ret.extend(_lea(i, k, bi.Reg.R2, **kwargs))
ret.extend([
bi.Call(bi.Imm(funcs.map_lookup_elem.num)),
])
if _is_ptr(dv.var_type):
sz = _get_cdata_size(dv.var_type)
ret.extend(_mov(bi.Reg.R0, dv))
else:
ret.extend([
bi.JumpIfNotEqual(bi.Imm(0), bi.Reg.R0, found),
])
# Move default value
dr = _get_var_reg(dv)
ret.extend(_mov_const(dv.var_type, m.val.DEFAULT_VALUE, dr, dv.offset))
ret.extend([
bi.Jump(done),
bi.Label(found),
])
# Primitives by value, others by reference
if issubclass(dv.var_type, _ctypes._SimpleCData):
sz = _get_cdata_size(dv.var_type)
ret.extend(_mov(bi.Mem(bi.Reg.R0, 0, sz), dv))
else:
ret.extend(_mov(bi.Reg.R0, dv))
ret.append(bi.Label(done))
return ret
def _call_deref(i, **kwargs):
sz = _get_cdata_size(i.dst_vars[0].var_type)
return (_mov(i.src_vars[1], bi.Reg.R0) +
_mov(bi.Mem(bi.Reg.R0, 0, sz), i.dst_vars[0]))
