docs: def _validate_entries(self, processes):
          """
          Verify that the actual file contents match the recorded hashes stored in the manifest files
          """
          errors = list()
  
          # First we'll make sure there's no mismatch between the filesystem
          # and the list of files in the manifest(s)
          only_in_manifests, only_on_fs = self.compare_manifests_with_fs()
          for path in only_in_manifests:
              e = FileMissing(path)
              logger.warning(str(e))
              errors.append(e)
          for path in only_on_fs:
              e = UnexpectedFile(path)
              logger.warning(str(e))
              errors.append(e)
  
          # To avoid the overhead of reading the file more than once or loading
          # potentially massive files into memory we'll create a dictionary of
          # hash objects so we can open a file, read a block and pass it to
          # multiple hash objects
  
          available_hashers = set()
          for alg in self.algs:
              try:
                  hashlib.new(alg)
                  available_hashers.add(alg)
              except ValueError:
                  logger.warning("Unable to validate file contents using unknown %s hash algorithm", alg)
  
          if not available_hashers:
              raise RuntimeError("%s: Unable to validate bag contents: none of the hash algorithms in %s are supported!" % (self, self.algs))
  
          def _init_worker():
              signal.signal(signal.SIGINT, signal.SIG_IGN)
  
          args = ((self.path, rel_path, hashes, available_hashers) for rel_path, hashes in list(self.entries.items()))
  
          try:
              if processes == 1:
                  hash_results = list(map(_calc_hashes, args))
              else:
                  try:
                      pool = multiprocessing.Pool(processes if processes else None, _init_worker)
                      hash_results = pool.map(_calc_hashes, args)
                  finally:
                      try:
                          pool.terminate()
                      except:
                          # we really don't care about any exception in terminate()
                          pass
          # Any unhandled exceptions are probably fatal
          except:
              logger.exception("unable to calculate file hashes for %s", self)
              raise
  
          for rel_path, f_hashes, hashes in hash_results:
              for alg, computed_hash in list(f_hashes.items()):
                  stored_hash = hashes[alg]
                  if stored_hash.lower() != computed_hash:
                      e = ChecksumMismatch(rel_path, alg, stored_hash.lower(), computed_hash)
                      logger.warning(str(e))
                      errors.append(e)
  
          if errors:
              raise BagValidationError("invalid bag", errors)