table: Refactor __delitem__ in all table types

__delitem__ has some code duplication for the common case. The common
case is to call the low-level bpf_delete_elem function.  Refactor the
code a bit for this case. It avoids duplication of code and will also
make the communication with BPFd simpler as well.

Test: Ran test_tools_smoke tests with all tests passing except for
test_shared_table.py which fails for me with or without this patch.
(Filing separate issue for that).

Signed-off-by: Joel Fernandes <[email protected]>

src/python/bcc/table.py

@@ -205,6 +205,11 @@ def __setitem__(self, key, leaf):
  errstr = os.strerror(ct.get_errno())
  raise Exception("Could not update table: %s" % errstr)
 
+ def __delitem__(self, key):
+ res = lib.bpf_delete_elem(self.map_fd, ct.byref(key))
+ if res < 0:
+ raise KeyError
+
  # override the MutableMapping's implementation of these since they
  # don't handle KeyError nicely
  def itervalues(self):
@@ -391,11 +396,6 @@ def __len__(self):
  for k in self: i += 1
  return i
 
- def __delitem__(self, key):
- res = lib.bpf_delete_elem(self.map_fd, ct.byref(key))
- if res < 0:
- raise KeyError
-
 class LruHash(HashTable):
  def __init__(self, *args, **kwargs):
  super(LruHash, self).__init__(*args, **kwargs)
@@ -430,11 +430,12 @@ def __setitem__(self, key, leaf):
 
  def __delitem__(self, key):
  key = self._normalize_key(key)
- # Deleting from array type maps does not have an effect, so
- # zero out the entry instead.
+ super(ArrayBase, self).__delitem__(key)
+
+ def clearitem(self, key):
+ key = self._normalize_key(key)
  leaf = self.Leaf()
- res = lib.bpf_update_elem(self.map_fd, ct.byref(key), ct.byref(leaf),
- 0)
+ res = lib.bpf_update_elem(self.map_fd, ct.byref(key), ct.byref(leaf), 0)
  if res < 0:
  raise Exception("Could not clear item")
 
@@ -461,6 +462,9 @@ class Array(ArrayBase):
  def __init__(self, *args, **kwargs):
  super(Array, self).__init__(*args, **kwargs)
 
+ def __delitem__(self, key):
+ # Delete in Array type does not have an effect, so zero out instead
+ self.clearitem(key)
 
 class ProgArray(ArrayBase):
  def __init__(self, *args, **kwargs):
@@ -473,12 +477,6 @@ def __setitem__(self, key, leaf):
  leaf = self.Leaf(leaf.fd)
  super(ProgArray, self).__setitem__(key, leaf)
 
- def __delitem__(self, key):
- key = self._normalize_key(key)
- res = lib.bpf_delete_elem(self.map_fd, ct.byref(key))
- if res < 0:
- raise Exception("Could not delete item")
-
 class PerfEventArray(ArrayBase):
 
  def __init__(self, *args, **kwargs):
@@ -494,8 +492,7 @@ def __delitem__(self, key):
  if key not in self._open_key_fds:
  return
  # Delete entry from the array
- c_key = self._normalize_key(key)
- lib.bpf_delete_elem(self.map_fd, ct.byref(c_key))
+ super(PerfEventArray, self).__delitem__(key)
  key_id = (id(self), key)
  if key_id in self.bpf.open_kprobes:
  # The key is opened for perf ring buffer
@@ -665,6 +662,10 @@ def __getitem__(self, key):
  def __setitem__(self, key, leaf):
  super(PerCpuArray, self).__setitem__(key, leaf)
 
+ def __delitem__(self, key):
+ # Delete in this type does not have an effect, so zero out instead
+ self.clearitem(key)
+
  def sum(self, key):
  if isinstance(self.Leaf(), ct.Structure):
  raise IndexError("Leaf must be an integer type for default sum functions")
@@ -728,10 +729,5 @@ def __len__(self):
  for k in self: i += 1
  return i
 
- def __delitem__(self, key):
- res = lib.bpf_delete_elem(self.map_fd, ct.byref(key))
- if res < 0:
- raise KeyError
-
  def clear(self):
  pass