code: def _fillVolumesAndPaths(self, paths):
          
          with self.btrfs as mount:
              for bv in mount.subvolumes:
                  if not bv.readOnly:
                      continue
  
                  vol = self._btrfsVol2StoreVol(bv)
                  if vol is None:
                      continue
  
                  path = bv.fullPath
  
                  if path is None:
                      logger.info("Skipping deleted volume %s", bv.uuid)
                      continue
  
                  relPath = None
  
                  for path in bv.linuxPaths:
                      path = self._relativePath(path)
  
                      if path is None:
                          continue  # path is outside store scope
  
                      paths[vol].append(path)
  
                      infoPath = self._fullPath(path + Store.theInfoExtension)
                      if os.path.exists(infoPath):
                          logger.debug("Reading %s", infoPath)
                          with open(infoPath) as info:
                              Store.Volume.readInfo(info)
  
                      if not path.startswith("/"):
                          relPath = path
  
                  if vol not in paths:
                      continue
  
                  logger.debug("%s", vol.display(sink=self, detail='phrase'))
  
                  if vol.uuid in self.butterVolumes:
                      logger.warn(
                          "Duplicate effective uuid %s in '%s' and '%s'",
                          vol.uuid, path, self.butterVolumes[vol.uuid].fullPath
                      )
  
                  self.butterVolumes[vol.uuid] = bv
  
                  if relPath is not None:
                      # vol is inside Store directory
                      self.extraVolumes[vol] = relPath
docs: Fill in paths.
  
          :arg paths: = { Store.Volume: ["linux path",]}