LXR linux/fs/ntfs/index.h

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * index.h - Defines for NTFS kernel index handling.  Part of the Linux-NTFS
   4 *           project.
   5 *
   6 * Copyright (c) 2004 Anton Altaparmakov
   7 */
   8
   9#ifndef _LINUX_NTFS_INDEX_H
  10#define _LINUX_NTFS_INDEX_H
  11
  12#include <linux/fs.h>
  13
  14#include "types.h"
  15#include "layout.h"
  16#include "inode.h"
  17#include "attrib.h"
  18#include "mft.h"
  19#include "aops.h"
  20
  21/**
  22 * @idx_ni:     index inode containing the @entry described by this context
  23 * @entry:      index entry (points into @ir or @ia)
  24 * @data:       index entry data (points into @entry)
  25 * @data_len:   length in bytes of @data
  26 * @is_in_root: 'true' if @entry is in @ir and 'false' if it is in @ia
  27 * @ir:         index root if @is_in_root and NULL otherwise
  28 * @actx:       attribute search context if @is_in_root and NULL otherwise
  29 * @base_ni:    base inode if @is_in_root and NULL otherwise
  30 * @ia:         index block if @is_in_root is 'false' and NULL otherwise
  31 * @page:       page if @is_in_root is 'false' and NULL otherwise
  32 *
  33 * @idx_ni is the index inode this context belongs to.
  34 *
  35 * @entry is the index entry described by this context.  @data and @data_len
  36 * are the index entry data and its length in bytes, respectively.  @data
  37 * simply points into @entry.  This is probably what the user is interested in.
  38 *
  39 * If @is_in_root is 'true', @entry is in the index root attribute @ir described
  40 * by the attribute search context @actx and the base inode @base_ni.  @ia and
  41 * @page are NULL in this case.
  42 *
  43 * If @is_in_root is 'false', @entry is in the index allocation attribute and @ia
  44 * and @page point to the index allocation block and the mapped, locked page it
  45 * is in, respectively.  @ir, @actx and @base_ni are NULL in this case.
  46 *
  47 * To obtain a context call ntfs_index_ctx_get().
  48 *
  49 * We use this context to allow ntfs_index_lookup() to return the found index
  50 * @entry and its @data without having to allocate a buffer and copy the @entry
  51 * and/or its @data into it.
  52 *
  53 * When finished with the @entry and its @data, call ntfs_index_ctx_put() to
  54 * free the context and other associated resources.
  55 *
  56 * If the index entry was modified, call flush_dcache_index_entry_page()
  57 * immediately after the modification and either ntfs_index_entry_mark_dirty()
  58 * or ntfs_index_entry_write() before the call to ntfs_index_ctx_put() to
  59 * ensure that the changes are written to disk.
  60 */
  61typedef struct {
  62        ntfs_inode *idx_ni;
  63        INDEX_ENTRY *entry;
  64        void *data;
  65        u16 data_len;
  66        bool is_in_root;
  67        INDEX_ROOT *ir;
  68        ntfs_attr_search_ctx *actx;
  69        ntfs_inode *base_ni;
  70        INDEX_ALLOCATION *ia;
  71        struct page *page;
  72} ntfs_index_context;
  73
  74extern ntfs_index_context *ntfs_index_ctx_get(ntfs_inode *idx_ni);
  75extern void ntfs_index_ctx_put(ntfs_index_context *ictx);
  76
  77extern int ntfs_index_lookup(const void *key, const int key_len,
  78                ntfs_index_context *ictx);
  79
  80#ifdef NTFS_RW
  81
  82/**
  83 * ntfs_index_entry_flush_dcache_page - flush_dcache_page() for index entries
  84 * @ictx:       ntfs index context describing the index entry
  85 *
  86 * Call flush_dcache_page() for the page in which an index entry resides.
  87 *
  88 * This must be called every time an index entry is modified, just after the
  89 * modification.
  90 *
  91 * If the index entry is in the index root attribute, simply flush the page
  92 * containing the mft record containing the index root attribute.
  93 *
  94 * If the index entry is in an index block belonging to the index allocation
  95 * attribute, simply flush the page cache page containing the index block.
  96 */
  97static inline void ntfs_index_entry_flush_dcache_page(ntfs_index_context *ictx)
  98{
  99        if (ictx->is_in_root)
 100                flush_dcache_mft_record_page(ictx->actx->ntfs_ino);
 101        else
 102                flush_dcache_page(ictx->page);
 103}
 104
 105/**
 106 * ntfs_index_entry_mark_dirty - mark an index entry dirty
 107 * @ictx:       ntfs index context describing the index entry
 108 *
 109 * Mark the index entry described by the index entry context @ictx dirty.
 110 *
 111 * If the index entry is in the index root attribute, simply mark the mft
 112 * record containing the index root attribute dirty.  This ensures the mft
 113 * record, and hence the index root attribute, will be written out to disk
 114 * later.
 115 *
 116 * If the index entry is in an index block belonging to the index allocation
 117 * attribute, mark the buffers belonging to the index record as well as the
 118 * page cache page the index block is in dirty.  This automatically marks the
 119 * VFS inode of the ntfs index inode to which the index entry belongs dirty,
 120 * too (I_DIRTY_PAGES) and this in turn ensures the page buffers, and hence the
 121 * dirty index block, will be written out to disk later.
 122 */
 123static inline void ntfs_index_entry_mark_dirty(ntfs_index_context *ictx)
 124{
 125        if (ictx->is_in_root)
 126                mark_mft_record_dirty(ictx->actx->ntfs_ino);
 127        else
 128                mark_ntfs_record_dirty(ictx->page,
 129                                (u8*)ictx->ia - (u8*)page_address(ictx->page));
 130}
 131
 132#endif /* NTFS_RW */
 133
 134#endif /* _LINUX_NTFS_INDEX_H */
 135