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]))