LXR linux/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 */
  26static 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 */
  72static 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
  89extern void mark_ntfs_record_dirty(struct page *page, const unsigned int ofs);
  90
  91#endif /* NTFS_RW */
  92
  93#endif /* _LINUX_NTFS_AOPS_H */
  94