docs: def interfaces(root):
      '''
      Generate a dictionary with all available interfaces relative to root.
      Symlinks are not followed.
  
      CLI example:
       .. code-block:: bash
  
          salt '*' sysfs.interfaces block/bcache0/bcache
  
      Output example:
       .. code-block:: json
  
         {
            "r": [
              "state",
              "partial_stripes_expensive",
              "writeback_rate_debug",
              "stripe_size",
              "dirty_data",
              "stats_total/cache_hits",
              "stats_total/cache_bypass_misses",
              "stats_total/bypassed",
              "stats_total/cache_readaheads",
              "stats_total/cache_hit_ratio",
              "stats_total/cache_miss_collisions",
              "stats_total/cache_misses",
              "stats_total/cache_bypass_hits",
            ],
            "rw": [
              "writeback_rate",
              "writeback_rate_update_seconds",
              "cache_mode",
              "writeback_delay",
              "label",
              "writeback_running",
              "writeback_metadata",
              "running",
              "writeback_rate_p_term_inverse",
              "sequential_cutoff",
              "writeback_percent",
              "writeback_rate_d_term",
              "readahead"
            ],
            "w": [
              "stop",
              "clear_stats",
              "attach",
              "detach"
            ]
         }
  
      .. note::
        * 'r' interfaces are read-only
        * 'w' interfaces are write-only (e.g. actions)
        * 'rw' are interfaces that can both be read or written
      '''
  
      root = target(root)
      if root is False or not os.path.isdir(root):
          log.error('SysFS %s not a dir', root)
          return False
  
      readwrites = []
      reads = []
      writes = []
  
      for path, _, files in salt.utils.path.os_walk(root, followlinks=False):
          for afile in files:
              canpath = os.path.join(path, afile)
  
              if not os.path.isfile(canpath):
                  continue
  
              stat_mode = os.stat(canpath).st_mode
              is_r = bool(stat.S_IRUSR & stat_mode)
              is_w = bool(stat.S_IWUSR & stat_mode)
  
              relpath = os.path.relpath(canpath, root)
              if is_w:
                  if is_r:
                      readwrites.append(relpath)
                  else:
                      writes.append(relpath)
              elif is_r:
                  reads.append(relpath)
              else:
                  log.warning('Unable to find any interfaces in %s', canpath)
  
      return {
          'r': reads,
          'w': writes,
          'rw': readwrites
      }