/** * ice_alloc_fd_res_cntr - obtain counter resource for FD type * @hw: pointer to the hardware structure * @cntr_id: returns counter index
*/ int ice_alloc_fd_res_cntr(struct ice_hw *hw, u16 *cntr_id)
{ return ice_alloc_res_cntr(hw, ICE_AQC_RES_TYPE_FDIR_COUNTER_BLOCK,
ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1, cntr_id);
}
/** * ice_free_fd_res_cntr - Free counter resource for FD type * @hw: pointer to the hardware structure * @cntr_id: counter index to be freed
*/ int ice_free_fd_res_cntr(struct ice_hw *hw, u16 cntr_id)
{ return ice_free_res_cntr(hw, ICE_AQC_RES_TYPE_FDIR_COUNTER_BLOCK,
ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1, cntr_id);
}
/** * ice_alloc_fd_guar_item - allocate resource for FD guaranteed entries * @hw: pointer to the hardware structure * @cntr_id: returns counter index * @num_fltr: number of filter entries to be allocated
*/ int ice_alloc_fd_guar_item(struct ice_hw *hw, u16 *cntr_id, u16 num_fltr)
{ return ice_alloc_res_cntr(hw, ICE_AQC_RES_TYPE_FDIR_GUARANTEED_ENTRIES,
ICE_AQC_RES_TYPE_FLAG_DEDICATED, num_fltr,
cntr_id);
}
/** * ice_alloc_fd_shrd_item - allocate resource for flow director shared entries * @hw: pointer to the hardware structure * @cntr_id: returns counter index * @num_fltr: number of filter entries to be allocated
*/ int ice_alloc_fd_shrd_item(struct ice_hw *hw, u16 *cntr_id, u16 num_fltr)
{ return ice_alloc_res_cntr(hw, ICE_AQC_RES_TYPE_FDIR_SHARED_ENTRIES,
ICE_AQC_RES_TYPE_FLAG_DEDICATED, num_fltr,
cntr_id);
}
/** * ice_get_fdir_cnt_all - get the number of Flow Director filters * @hw: hardware data structure * * Returns the number of filters available on device
*/ int ice_get_fdir_cnt_all(struct ice_hw *hw)
{ return hw->func_caps.fd_fltr_guar + hw->func_caps.fd_fltr_best_effort;
}
/** * ice_pkt_insert_ipv6_addr - insert a be32 IPv6 address into a memory buffer * @pkt: packet buffer * @offset: offset into buffer * @addr: IPv6 address to convert and insert into pkt at offset
*/ staticvoid ice_pkt_insert_ipv6_addr(u8 *pkt, int offset, __be32 *addr)
{ int idx;
/** * ice_pkt_insert_u6_qfi - insert a u6 value QFI into a memory buffer for GTPU * @pkt: packet buffer * @offset: offset into buffer * @data: 8 bit value to convert and insert into pkt at offset * * This function is designed for inserting QFI (6 bits) for GTPU.
*/ staticvoid ice_pkt_insert_u6_qfi(u8 *pkt, int offset, u8 data)
{
u8 ret;
/** * ice_pkt_insert_u8 - insert a u8 value into a memory buffer. * @pkt: packet buffer * @offset: offset into buffer * @data: 8 bit value to convert and insert into pkt at offset
*/ staticvoid ice_pkt_insert_u8(u8 *pkt, int offset, u8 data)
{
memcpy(pkt + offset, &data, sizeof(data));
}
/** * ice_pkt_insert_u8_tc - insert a u8 value into a memory buffer for TC ipv6. * @pkt: packet buffer * @offset: offset into buffer * @data: 8 bit value to convert and insert into pkt at offset * * This function is designed for inserting Traffic Class (TC) for IPv6, * since that TC is not aligned in number of bytes. Here we split it out * into two part and fill each byte with data copy from pkt, then insert * the two bytes data one by one.
*/ staticvoid ice_pkt_insert_u8_tc(u8 *pkt, int offset, u8 data)
{
u8 high, low;
/** * ice_pkt_insert_u16 - insert a be16 value into a memory buffer * @pkt: packet buffer * @offset: offset into buffer * @data: 16 bit value to convert and insert into pkt at offset
*/ staticvoid ice_pkt_insert_u16(u8 *pkt, int offset, __be16 data)
{
memcpy(pkt + offset, &data, sizeof(data));
}
/** * ice_pkt_insert_u32 - insert a be32 value into a memory buffer * @pkt: packet buffer * @offset: offset into buffer * @data: 32 bit value to convert and insert into pkt at offset
*/ staticvoid ice_pkt_insert_u32(u8 *pkt, int offset, __be32 data)
{
memcpy(pkt + offset, &data, sizeof(data));
}
/** * ice_pkt_insert_mac_addr - insert a MAC addr into a memory buffer. * @pkt: packet buffer * @addr: MAC address to convert and insert into pkt at offset
*/ staticvoid ice_pkt_insert_mac_addr(u8 *pkt, u8 *addr)
{
ether_addr_copy(pkt, addr);
}
/** * ice_fdir_get_gen_prgm_pkt - generate a training packet * @hw: pointer to the hardware structure * @input: flow director filter data structure * @pkt: pointer to return filter packet * @frag: generate a fragment packet * @tun: true implies generate a tunnel packet
*/ int
ice_fdir_get_gen_prgm_pkt(struct ice_hw *hw, struct ice_fdir_fltr *input,
u8 *pkt, bool frag, bool tun)
{ enum ice_fltr_ptype flow;
u16 tnl_port;
u8 *loc;
u16 idx;
for (idx = 0; idx < ICE_FDIR_NUM_PKT; idx++) if (ice_fdir_pkt[idx].flow == flow) break; if (idx == ICE_FDIR_NUM_PKT) return -EINVAL; if (!tun) {
memcpy(pkt, ice_fdir_pkt[idx].pkt, ice_fdir_pkt[idx].pkt_len);
loc = pkt;
} else { if (!ice_get_open_tunnel_port(hw, &tnl_port, TNL_ALL)) return -ENOENT; if (!ice_fdir_pkt[idx].tun_pkt) return -EINVAL;
memcpy(pkt, ice_fdir_pkt[idx].tun_pkt,
ice_fdir_pkt[idx].tun_pkt_len);
ice_pkt_insert_u16(pkt, ICE_IPV4_UDP_DST_PORT_OFFSET,
htons(tnl_port));
loc = &pkt[ICE_FDIR_TUN_PKT_OFF];
}
/* Reverse the src and dst, since the HW expects them to be from Tx * perspective. The input from user is from Rx filter perspective.
*/ switch (flow) { case ICE_FLTR_PTYPE_NONF_ETH:
ice_pkt_insert_mac_addr(loc, input->eth.h_dest);
ice_pkt_insert_mac_addr(loc + ETH_ALEN, input->eth.h_source); if (input->ext_data.vlan_tag || input->ext_data.vlan_type) {
ice_pkt_insert_u16(loc, ICE_ETH_TYPE_F_OFFSET,
input->ext_data.vlan_type);
ice_pkt_insert_u16(loc, ICE_ETH_VLAN_TCI_OFFSET,
input->ext_data.vlan_tag);
ice_pkt_insert_u16(loc, ICE_ETH_TYPE_VLAN_OFFSET,
input->eth.h_proto);
} else {
ice_pkt_insert_u16(loc, ICE_ETH_TYPE_F_OFFSET,
input->eth.h_proto);
} break; case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_TCP_DST_PORT_OFFSET,
input->ip.v4.src_port);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_TCP_SRC_PORT_OFFSET,
input->ip.v4.dst_port);
ice_pkt_insert_u8(loc, ICE_IPV4_TOS_OFFSET, input->ip.v4.tos);
ice_pkt_insert_u8(loc, ICE_IPV4_TTL_OFFSET, input->ip.v4.ttl);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); if (frag)
loc[20] = ICE_FDIR_IPV4_PKT_FLAG_MF; break; case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_UDP_DST_PORT_OFFSET,
input->ip.v4.src_port);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_UDP_SRC_PORT_OFFSET,
input->ip.v4.dst_port);
ice_pkt_insert_u8(loc, ICE_IPV4_TOS_OFFSET, input->ip.v4.tos);
ice_pkt_insert_u8(loc, ICE_IPV4_TTL_OFFSET, input->ip.v4.ttl);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac);
ice_pkt_insert_mac_addr(loc + ETH_ALEN,
input->ext_data.src_mac); break; case ICE_FLTR_PTYPE_NONF_IPV4_SCTP:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_SCTP_DST_PORT_OFFSET,
input->ip.v4.src_port);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV4_SCTP_SRC_PORT_OFFSET,
input->ip.v4.dst_port);
ice_pkt_insert_u8(loc, ICE_IPV4_TOS_OFFSET, input->ip.v4.tos);
ice_pkt_insert_u8(loc, ICE_IPV4_TTL_OFFSET, input->ip.v4.ttl);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; case ICE_FLTR_PTYPE_NONF_IPV4_OTHER:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u8(loc, ICE_IPV4_TOS_OFFSET, input->ip.v4.tos);
ice_pkt_insert_u8(loc, ICE_IPV4_TTL_OFFSET, input->ip.v4.ttl);
ice_pkt_insert_u8(loc, ICE_IPV4_PROTO_OFFSET,
input->ip.v4.proto);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_UDP: case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_TCP: case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_ICMP: case ICE_FLTR_PTYPE_NONF_IPV4_GTPU_IPV4_OTHER:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u32(loc, ICE_IPV4_GTPU_TEID_OFFSET,
input->gtpu_data.teid);
ice_pkt_insert_u6_qfi(loc, ICE_IPV4_GTPU_QFI_OFFSET,
input->gtpu_data.qfi); break; case ICE_FLTR_PTYPE_NONF_IPV4_L2TPV3:
ice_pkt_insert_u32(loc, ICE_IPV4_L2TPV3_SESS_ID_OFFSET,
input->l2tpv3_data.session_id); break; case ICE_FLTR_PTYPE_NONF_IPV6_L2TPV3:
ice_pkt_insert_u32(loc, ICE_IPV6_L2TPV3_SESS_ID_OFFSET,
input->l2tpv3_data.session_id); break; case ICE_FLTR_PTYPE_NONF_IPV4_ESP:
ice_pkt_insert_u32(loc, ICE_IPV4_ESP_SPI_OFFSET,
input->ip.v4.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV6_ESP:
ice_pkt_insert_u32(loc, ICE_IPV6_ESP_SPI_OFFSET,
input->ip.v6.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV4_AH:
ice_pkt_insert_u32(loc, ICE_IPV4_AH_SPI_OFFSET,
input->ip.v4.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV6_AH:
ice_pkt_insert_u32(loc, ICE_IPV6_AH_SPI_OFFSET,
input->ip.v6.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV4_NAT_T_ESP:
ice_pkt_insert_u32(loc, ICE_IPV4_DST_ADDR_OFFSET,
input->ip.v4.src_ip);
ice_pkt_insert_u32(loc, ICE_IPV4_SRC_ADDR_OFFSET,
input->ip.v4.dst_ip);
ice_pkt_insert_u32(loc, ICE_IPV4_NAT_T_ESP_SPI_OFFSET,
input->ip.v4.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV6_NAT_T_ESP:
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_DST_ADDR_OFFSET,
input->ip.v6.src_ip);
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_SRC_ADDR_OFFSET,
input->ip.v6.dst_ip);
ice_pkt_insert_u32(loc, ICE_IPV6_NAT_T_ESP_SPI_OFFSET,
input->ip.v6.sec_parm_idx); break; case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_NODE: case ICE_FLTR_PTYPE_NONF_IPV4_PFCP_SESSION:
ice_pkt_insert_u16(loc, ICE_IPV4_UDP_SRC_PORT_OFFSET,
input->ip.v4.dst_port); break; case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_NODE: case ICE_FLTR_PTYPE_NONF_IPV6_PFCP_SESSION:
ice_pkt_insert_u16(loc, ICE_IPV6_UDP_SRC_PORT_OFFSET,
input->ip.v6.dst_port); break; case ICE_FLTR_PTYPE_NON_IP_L2:
ice_pkt_insert_u16(loc, ICE_MAC_ETHTYPE_OFFSET,
input->ext_data.ether_type); break; case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_DST_ADDR_OFFSET,
input->ip.v6.src_ip);
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_SRC_ADDR_OFFSET,
input->ip.v6.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV6_TCP_DST_PORT_OFFSET,
input->ip.v6.src_port);
ice_pkt_insert_u16(loc, ICE_IPV6_TCP_SRC_PORT_OFFSET,
input->ip.v6.dst_port);
ice_pkt_insert_u8_tc(loc, ICE_IPV6_TC_OFFSET, input->ip.v6.tc);
ice_pkt_insert_u8(loc, ICE_IPV6_HLIM_OFFSET, input->ip.v6.hlim);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_DST_ADDR_OFFSET,
input->ip.v6.src_ip);
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_SRC_ADDR_OFFSET,
input->ip.v6.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV6_UDP_DST_PORT_OFFSET,
input->ip.v6.src_port);
ice_pkt_insert_u16(loc, ICE_IPV6_UDP_SRC_PORT_OFFSET,
input->ip.v6.dst_port);
ice_pkt_insert_u8_tc(loc, ICE_IPV6_TC_OFFSET, input->ip.v6.tc);
ice_pkt_insert_u8(loc, ICE_IPV6_HLIM_OFFSET, input->ip.v6.hlim);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; case ICE_FLTR_PTYPE_NONF_IPV6_SCTP:
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_DST_ADDR_OFFSET,
input->ip.v6.src_ip);
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_SRC_ADDR_OFFSET,
input->ip.v6.dst_ip);
ice_pkt_insert_u16(loc, ICE_IPV6_SCTP_DST_PORT_OFFSET,
input->ip.v6.src_port);
ice_pkt_insert_u16(loc, ICE_IPV6_SCTP_SRC_PORT_OFFSET,
input->ip.v6.dst_port);
ice_pkt_insert_u8_tc(loc, ICE_IPV6_TC_OFFSET, input->ip.v6.tc);
ice_pkt_insert_u8(loc, ICE_IPV6_HLIM_OFFSET, input->ip.v6.hlim);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; case ICE_FLTR_PTYPE_NONF_IPV6_OTHER:
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_DST_ADDR_OFFSET,
input->ip.v6.src_ip);
ice_pkt_insert_ipv6_addr(loc, ICE_IPV6_SRC_ADDR_OFFSET,
input->ip.v6.dst_ip);
ice_pkt_insert_u8_tc(loc, ICE_IPV6_TC_OFFSET, input->ip.v6.tc);
ice_pkt_insert_u8(loc, ICE_IPV6_HLIM_OFFSET, input->ip.v6.hlim);
ice_pkt_insert_u8(loc, ICE_IPV6_PROTO_OFFSET,
input->ip.v6.proto);
ice_pkt_insert_mac_addr(loc, input->ext_data.dst_mac); break; default: return -EINVAL;
}
if (input->flex_fltr)
ice_pkt_insert_u16(loc, input->flex_offset, input->flex_word);
return 0;
}
/** * ice_fdir_has_frag - does flow type have 2 ptypes * @flow: flow ptype * * returns true is there is a fragment packet for this ptype
*/ bool ice_fdir_has_frag(enum ice_fltr_ptype flow)
{ if (flow == ICE_FLTR_PTYPE_NONF_IPV4_OTHER) returntrue; else returnfalse;
}
/** * ice_fdir_find_fltr_by_idx - find filter with idx * @hw: pointer to hardware structure * @fltr_idx: index to find. * * Returns pointer to filter if found or null
*/ struct ice_fdir_fltr *
ice_fdir_find_fltr_by_idx(struct ice_hw *hw, u32 fltr_idx)
{ struct ice_fdir_fltr *rule;
list_for_each_entry(rule, &hw->fdir_list_head, fltr_node) { /* rule ID found in the list */ if (fltr_idx == rule->fltr_id) return rule; if (fltr_idx < rule->fltr_id) break;
} return NULL;
}
/** * ice_fdir_list_add_fltr - add a new node to the flow director filter list * @hw: hardware structure * @fltr: filter node to add to structure
*/ void ice_fdir_list_add_fltr(struct ice_hw *hw, struct ice_fdir_fltr *fltr)
{ struct ice_fdir_fltr *rule, *parent = NULL;
list_for_each_entry(rule, &hw->fdir_list_head, fltr_node) { /* rule ID found or pass its spot in the list */ if (rule->fltr_id >= fltr->fltr_id) break;
parent = rule;
}
if (parent)
list_add(&fltr->fltr_node, &parent->fltr_node); else
list_add(&fltr->fltr_node, &hw->fdir_list_head);
}
if (flow == ICE_FLTR_PTYPE_NONF_NONE || flow >= ICE_FLTR_PTYPE_MAX)
ice_debug(hw, ICE_DBG_SW, "Unknown filter type %d\n", flow); else
hw->fdir_fltr_cnt[flow] += incr;
}
/** * ice_cmp_ipv6_addr - compare 2 IP v6 addresses * @a: IP v6 address * @b: IP v6 address * * Returns 0 on equal, returns non-0 if different
*/ staticint ice_cmp_ipv6_addr(__be32 *a, __be32 *b)
{ return memcmp(a, b, 4 * sizeof(__be32));
}
/** * ice_fdir_comp_rules - compare 2 filters * @a: a Flow Director filter data structure * @b: a Flow Director filter data structure * * Returns true if the filters match
*/ staticbool
ice_fdir_comp_rules(struct ice_fdir_fltr *a, struct ice_fdir_fltr *b)
{ enum ice_fltr_ptype flow_type = a->flow_type;
/* The calling function already checks that the two filters have the * same flow_type.
*/ switch (flow_type) { case ICE_FLTR_PTYPE_NONF_ETH: if (!memcmp(&a->eth, &b->eth, sizeof(a->eth))) returntrue; break; case ICE_FLTR_PTYPE_NONF_IPV4_TCP: case ICE_FLTR_PTYPE_NONF_IPV4_UDP: case ICE_FLTR_PTYPE_NONF_IPV4_SCTP: if (a->ip.v4.dst_ip == b->ip.v4.dst_ip &&
a->ip.v4.src_ip == b->ip.v4.src_ip &&
a->ip.v4.dst_port == b->ip.v4.dst_port &&
a->ip.v4.src_port == b->ip.v4.src_port) returntrue; break; case ICE_FLTR_PTYPE_NONF_IPV4_OTHER: if (a->ip.v4.dst_ip == b->ip.v4.dst_ip &&
a->ip.v4.src_ip == b->ip.v4.src_ip &&
a->ip.v4.l4_header == b->ip.v4.l4_header &&
a->ip.v4.proto == b->ip.v4.proto &&
a->ip.v4.ip_ver == b->ip.v4.ip_ver &&
a->ip.v4.tos == b->ip.v4.tos) returntrue; break; case ICE_FLTR_PTYPE_NONF_IPV6_UDP: case ICE_FLTR_PTYPE_NONF_IPV6_TCP: case ICE_FLTR_PTYPE_NONF_IPV6_SCTP: if (a->ip.v6.dst_port == b->ip.v6.dst_port &&
a->ip.v6.src_port == b->ip.v6.src_port &&
!ice_cmp_ipv6_addr(a->ip.v6.dst_ip,
b->ip.v6.dst_ip) &&
!ice_cmp_ipv6_addr(a->ip.v6.src_ip,
b->ip.v6.src_ip)) returntrue; break; case ICE_FLTR_PTYPE_NONF_IPV6_OTHER: if (a->ip.v6.dst_port == b->ip.v6.dst_port &&
a->ip.v6.src_port == b->ip.v6.src_port) returntrue; break; default: break;
}
returnfalse;
}
/** * ice_fdir_is_dup_fltr - test if filter is already in list for PF * @hw: hardware data structure * @input: Flow Director filter data structure * * Returns true if the filter is found in the list
*/ bool ice_fdir_is_dup_fltr(struct ice_hw *hw, struct ice_fdir_fltr *input)
{ struct ice_fdir_fltr *rule; bool ret = false;
list_for_each_entry(rule, &hw->fdir_list_head, fltr_node) { if (rule->flow_type != input->flow_type) continue;
ret = ice_fdir_comp_rules(rule, input); if (ret) { if (rule->fltr_id == input->fltr_id &&
rule->q_index != input->q_index)
ret = false; else break;
}
}
return ret;
}
Messung V0.5
¤ Dauer der Verarbeitung: 0.5 Sekunden
(vorverarbeitet)
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
