fs/ntfs/aops.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /**
   3  * aops.h - Defines for NTFS kernel address space operations and page cache
   4  *          handling.  Part of the Linux-NTFS project.
   5  *
   6  * Copyright (c) 2001-2004 Anton Altaparmakov
   7  * Copyright (c) 2002 Richard Russon
   8  */
   9
  10 #ifndef _LINUX_NTFS_AOPS_H
  11 #define _LINUX_NTFS_AOPS_H
  12
  13 #include <linux/mm.h>
  14 #include <linux/highmem.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/fs.h>
  17
  18 #include "inode.h"
  19
  20 /**
  21  * ntfs_unmap_page - release a page that was mapped using ntfs_map_page()
  22  * @page:       the page to release
  23  *
  24  * Unpin, unmap and release a page that was obtained from ntfs_map_page().
  25  */
  26 static inline void ntfs_unmap_page(struct page *page)
  27 {
  28         kunmap(page);
  29         put_page(page);
  30 }
  31
  32 /**
  33  * ntfs_map_page - map a page into accessible memory, reading it if necessary
  34  * @mapping:    address space for which to obtain the page
  35  * @index:      index into the page cache for @mapping of the page to map
  36  *
  37  * Read a page from the page cache of the address space @mapping at position
  38  * @index, where @index is in units of PAGE_SIZE, and not in bytes.
  39  *
  40  * If the page is not in memory it is loaded from disk first using the readpage
  41  * method defined in the address space operations of @mapping and the page is
  42  * added to the page cache of @mapping in the process.
  43  *
  44  * If the page belongs to an mst protected attribute and it is marked as such
  45  * in its ntfs inode (NInoMstProtected()) the mst fixups are applied but no
  46  * error checking is performed.  This means the caller has to verify whether
  47  * the ntfs record(s) contained in the page are valid or not using one of the
  48  * ntfs_is_XXXX_record{,p}() macros, where XXXX is the record type you are
  49  * expecting to see.  (For details of the macros, see fs/ntfs/layout.h.)
  50  *
  51  * If the page is in high memory it is mapped into memory directly addressible
  52  * by the kernel.
  53  *
  54  * Finally the page count is incremented, thus pinning the page into place.
  55  *
  56  * The above means that page_address(page) can be used on all pages obtained
  57  * with ntfs_map_page() to get the kernel virtual address of the page.
  58  *
  59  * When finished with the page, the caller has to call ntfs_unmap_page() to
  60  * unpin, unmap and release the page.
  61  *
  62  * Note this does not grant exclusive access. If such is desired, the caller
  63  * must provide it independently of the ntfs_{un}map_page() calls by using
  64  * a {rw_}semaphore or other means of serialization. A spin lock cannot be
  65  * used as ntfs_map_page() can block.
  66  *
  67  * The unlocked and uptodate page is returned on success or an encoded error
  68  * on failure. Caller has to test for error using the IS_ERR() macro on the
  69  * return value. If that evaluates to 'true', the negative error code can be
  70  * obtained using PTR_ERR() on the return value of ntfs_map_page().
  71  */
  72 static inline struct page *ntfs_map_page(struct address_space *mapping,
  73                 unsigned long index)
  74 {
  75         struct page *page = read_mapping_page(mapping, index, NULL);
  76
  77         if (!IS_ERR(page)) {
  78                 kmap(page);
  79                 if (!PageError(page))
  80                         return page;
  81                 ntfs_unmap_page(page);
  82                 return ERR_PTR(-EIO);
  83         }
  84         return page;
  85 }
  86
  87 #ifdef NTFS_RW
  88
  89 extern void mark_ntfs_record_dirty(struct page *page, const unsigned int ofs);
  90
  91 #endif /* NTFS_RW */
  92
  93 #endif /* _LINUX_NTFS_AOPS_H */