/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (c) 2023-2024 Oracle.  All Rights Reserved.
 * Author: Darrick J. Wong <djwong@kernel.org>
 */
#ifndef __XFS_SCRUB_DIRTREE_H__
#define __XFS_SCRUB_DIRTREE_H__

/*
 * Each of these represents one parent pointer path step in a chain going
 * up towards the directory tree root.  These are stored inside an xfarray.
 */
struct xchk_dirpath_step {
 /* Directory entry name associated with this parent link. */
 xfblob_cookie  name_cookie;
 unsigned int  name_len;

 /* Handle of the parent directory. */
 struct xfs_parent_rec pptr_rec;
};

enum xchk_dirpath_outcome {
 XCHK_DIRPATH_SCANNING = 0, /* still being put together */
 XCHK_DIRPATH_DELETE,  /* delete this path */
 XCHK_DIRPATH_CORRUPT,  /* corruption detected in path */
 XCHK_DIRPATH_LOOP,  /* cycle detected further up */
 XCHK_DIRPATH_STALE,  /* path is stale */
 XCHK_DIRPATH_OK,  /* path reaches the root */

 XREP_DIRPATH_DELETING,  /* path is being deleted */
 XREP_DIRPATH_DELETED,  /* path has been deleted */
 XREP_DIRPATH_ADOPTING,  /* path is being adopted */
 XREP_DIRPATH_ADOPTED,  /* path has been adopted */
};

/*
 * Each of these represents one parent pointer path out of the directory being
 * scanned.  These exist in-core, and hopefully there aren't more than a
 * handful of them.
 */
struct xchk_dirpath {
 struct list_head list;

 /* Index of the first step in this path. */
 xfarray_idx_t  first_step;

 /* Index of the second step in this path. */
 xfarray_idx_t  second_step;

 /* Inodes seen while walking this path. */
 struct xino_bitmap seen_inodes;

 /* Number of steps in this path. */
 unsigned int  nr_steps;

 /* Which path is this? */
 unsigned int  path_nr;

 /* What did we conclude from following this path? */
 enum xchk_dirpath_outcome outcome;
};

struct xchk_dirtree_outcomes {
 /* Number of XCHK_DIRPATH_DELETE */
 unsigned int  bad;

 /* Number of XCHK_DIRPATH_CORRUPT or XCHK_DIRPATH_LOOP */
 unsigned int  suspect;

 /* Number of XCHK_DIRPATH_OK */
 unsigned int  good;

 /* Directory needs to be added to lost+found */
 bool   needs_adoption;
};

struct xchk_dirtree {
 struct xfs_scrub *sc;

 /* Root inode that we're looking for. */
 xfs_ino_t  root_ino;

 /*
  * This is the inode that we're scanning.  The live update hook can
  * continue to be called after xchk_teardown drops sc->ip but before
  * it calls buf_cleanup, so we keep a copy.
 */
 xfs_ino_t  scan_ino;

 /*
  * If we start deleting redundant paths to this subdirectory, this is
  * the inode number of the surviving parent and the dotdot entry will
  * be set to this value.  If the value is NULLFSINO, then use @root_ino
  * as a stand-in until the orphanage can adopt the subdirectory.
 */
 xfs_ino_t  parent_ino;

 /* Scratch buffer for scanning pptr xattrs */
 struct xfs_parent_rec pptr_rec;
 struct xfs_da_args pptr_args;

 /* Name buffer */
 struct xfs_name  xname;
 char   namebuf[MAXNAMELEN];

 /* Information for reparenting this directory. */
 struct xrep_adoption adoption;

 /*
  * Hook into directory updates so that we can receive live updates
  * from other writer threads.
 */
 struct xfs_dir_hook dhook;

 /* Parent pointer update arguments. */
 struct xfs_parent_args ppargs;

 /* lock for everything below here */
 struct mutex  lock;

 /* buffer for the live update functions to use for dirent names */
 struct xfs_name  hook_xname;
 unsigned char  hook_namebuf[MAXNAMELEN];

 /*
  * All path steps observed during this scan.  Each of the path
  * steps for a particular pathwalk are recorded in sequential
  * order in the xfarray.  A pathwalk ends either with a step
  * pointing to the root directory (success) or pointing to NULLFSINO
  * (loop detected, empty dir detected, etc).
 */
 struct xfarray  *path_steps;

 /* All names observed during this scan. */
 struct xfblob  *path_names;

 /* All paths being tracked by this scanner. */
 struct list_head path_list;

 /* Number of paths in path_list. */
 unsigned int  nr_paths;

 /* Number of parents found by a pptr scan. */
 unsigned int  parents_found;

 /* Have the path data been invalidated by a concurrent update? */
 bool   stale:1;

 /* Has the scan been aborted? */
 bool   aborted:1;
};

#define xchk_dirtree_for_each_path_safe(dl, path, n) \
 list_for_each_entry_safe((path), (n), &(dl)->path_list, list)

#define xchk_dirtree_for_each_path(dl, path) \
 list_for_each_entry((path), &(dl)->path_list, list)

bool xchk_dirtree_parentless(const struct xchk_dirtree *dl);

int xchk_dirtree_find_paths_to_root(struct xchk_dirtree *dl);
int xchk_dirpath_append(struct xchk_dirtree *dl, struct xfs_inode *ip,
  struct xchk_dirpath *path, const struct xfs_name *name,
  const struct xfs_parent_rec *pptr);
void xchk_dirtree_evaluate(struct xchk_dirtree *dl,
  struct xchk_dirtree_outcomes *oc);

#endif /* __XFS_SCRUB_DIRTREE_H__ */