llfio_v2_xxx::algorithm::summarize_visitor Struct Reference

A visitor for the filesystem traversal and summary algorithm. More...

#include "summarize.hpp"

Inheritance diagram for llfio_v2_xxx::algorithm::summarize_visitor:

Public Member Functions
virtual result< directory_handle >	directory_open_failed (void *data, result< void >::error_type &&error, const directory_handle &dirh, path_view leaf, size_t depth) noexcept override
	This override ignores failures to traverse into the directory.
virtual result< void >	post_enumeration (void *data, const directory_handle &dirh, directory_handle::buffers_type &contents, size_t depth) noexcept override
	This override implements the summary.
virtual result< bool >	pre_enumeration (void *data, const directory_handle &dirh, size_t depth) noexcept
	Called to decide whether to enumerate a directory.
virtual result< void >	stack_updated (void *data, size_t dirs_processed, size_t known_dirs_remaining, size_t depth_processed, size_t known_depth_remaining) noexcept
	Called whenever the traversed stack of directory hierarchy is updated. This can act as an estimated progress indicator, or to give an accurate progress indicator by matching it against a previous traversal.
virtual result< size_t >	finished (void *data, result< size_t > result) noexcept
	Called when a traversal finishes, whether due to success or failure. Always called from the original thread.

Static Public Member Functions
static void	accumulate (traversal_summary &acc, traversal_summary *state, const directory_handle *dirh, directory_entry &entry, stat_t::want already_have_metadata)

Detailed Description

A visitor for the filesystem traversal and summary algorithm.

Note that at any time, returning a failure causes summarize() to exit as soon as possible with the same failure.

You can override the members here inherited from traverse_visitor, however note that summarize() is entirely implemented using traverse(), so not calling the implementations here will affect operation.

Member Function Documentation

accumulate()

static void llfio_v2_xxx::algorithm::summarize_visitor::accumulate ( traversal_summary &  acc, traversal_summary *  state, const directory_handle *  dirh, directory_entry &  entry, stat_t::want  already_have_metadata  )

inlinestatic

    {
      if((state->want & already_have_metadata) != state->want)
      {
        // Fetch any missing metadata
        if(entry.stat.st_type == filesystem::file_type::directory)
        {
          if(auto fh = directory_handle::directory(*dirh, entry.leafname, file_handle::mode::attr_read))
          {
            if(!entry.stat.fill(fh.assume_value(), state->want & ~already_have_metadata))
            {
              acc.stats_failed++;
              return;
            }
          }
          else
          {
            acc.stats_failed++;
            return;
          }
        }
        else
        {
          if(auto fh = file_handle::file(*dirh, entry.leafname, file_handle::mode::attr_read))
          {
            if(!entry.stat.fill(fh.assume_value(), state->want & ~already_have_metadata))
            {
              acc.stats_failed++;
              return;
            }
          }
          else
          {
            acc.stats_failed++;
            return;
          }
        }
      }
      if(state->want & stat_t::want::dev)
      {
        acc.devs[entry.stat.st_dev]++;
      }
      if(state->want & stat_t::want::type)
      {
        acc.types[entry.stat.st_type]++;
      }
      if(state->want & stat_t::want::size)
      {
        acc.size += entry.stat.st_size;
      }
      if(state->want & stat_t::want::allocated)
      {
        acc.allocated += entry.stat.st_allocated;
      }
      if(state->want & stat_t::want::blocks)
      {
        if(entry.stat.st_type == filesystem::file_type::directory)
        {
          acc.directory_blocks += entry.stat.st_blocks;
        }
        else
        {
          acc.file_blocks += entry.stat.st_blocks;
        }
      }
    }

directory_open_failed()

virtual result< directory_handle > llfio_v2_xxx::algorithm::summarize_visitor::directory_open_failed ( void *  data, result< void >::error_type &&  error, const directory_handle &  dirh, path_view  leaf, size_t  depth  )

inlineoverridevirtualnoexcept

This override ignores failures to traverse into the directory.

Reimplemented from llfio_v2_xxx::algorithm::traverse_visitor.

    {
      (void) error;
      (void) dirh;
      (void) leaf;
      (void) depth;
      auto *state = (traversal_summary *) data;
      lock_guard<spinlock> g(state->_lock);
      state->directory_opens_failed++;
      return success();  // ignore failure to enter
    }

finished()

virtual result< size_t > llfio_v2_xxx::algorithm::traverse_visitor::finished ( void *  data, result< size_t >  result  )

inlinevirtualnoexceptinherited

Called when a traversal finishes, whether due to success or failure. Always called from the original thread.

Reimplemented in llfio_v2_xxx::algorithm::contents_visitor.

    {
      (void) data;
      return result;
    }

post_enumeration()

virtual result< void > llfio_v2_xxx::algorithm::summarize_visitor::post_enumeration ( void *  data, const directory_handle &  dirh, directory_handle::buffers_type &  contents, size_t  depth  )

inlineoverridevirtualnoexcept

This override implements the summary.

Reimplemented from llfio_v2_xxx::algorithm::traverse_visitor.

Reimplemented in llfio_v2_xxx::algorithm::compare_visitor.

    {
      LLFIO_EXCEPTION_TRY
      {
        auto *state = (traversal_summary *) data;
        traversal_summary acc;
        acc.max_depth = depth;
        for(auto &entry : contents)
        {
          accumulate(acc, state, &dirh, entry, contents.metadata());
        }
        state->operator+=(acc);
        return success();
      }
      LLFIO_EXCEPTION_CATCH_ALL
      {
        return error_from_exception();
      }
    }

pre_enumeration()

virtual result< bool > llfio_v2_xxx::algorithm::traverse_visitor::pre_enumeration ( void *  data, const directory_handle &  dirh, size_t  depth  )

inlinevirtualnoexceptinherited

Called to decide whether to enumerate a directory.

Note that it is more efficient to ignore the directory entry in post_enumeration() than to ignore it here, as a handle is opened for the directory before this callback. Equally, if you need that handle to inspect the directory e.g. to check if one is entering a different filesystem from the root, here is best.

The default returns true.

Note

May be called from multiple kernel threads concurrently.

    {
      (void) data;
      (void) dirh;
      (void) depth;
      return true;
    }

stack_updated()

virtual result< void > llfio_v2_xxx::algorithm::traverse_visitor::stack_updated ( void *  data, size_t  dirs_processed, size_t  known_dirs_remaining, size_t  depth_processed, size_t  known_depth_remaining  )

inlinevirtualnoexceptinherited

Called whenever the traversed stack of directory hierarchy is updated. This can act as an estimated progress indicator, or to give an accurate progress indicator by matching it against a previous traversal.

Parameters

data	The third party data pointer passed to traverse().
dirs_processed	The total number of directories traversed so far.
known_dirs_remaining	The currently known number of directories awaiting traversal.
depth_processed	How many levels deep we have already completely traversed.
known_depth_remaining	The currently known number of levels we shall traverse.

Note

May be called from multiple kernel threads concurrently.

    {
      (void) data;
      (void) dirs_processed;
      (void) known_dirs_remaining;
      (void) depth_processed;
      (void) known_depth_remaining;
      return success();
    }

---

The documentation for this struct was generated from the following file:

• include/llfio/v2.0/algorithm/summarize.hpp