1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2000-2001 Christoph Hellwig. 4 */ 5 6 /* 7 * Veritas filesystem driver - shared subroutines. 8 */ 9 #include <linux/fs.h> 10 #include <linux/buffer_head.h> 11 #include <linux/kernel.h> 12 #include <linux/pagemap.h> 13 14 #include "vxfs_extern.h" 15 16 17 static int vxfs_read_folio(struct file *, struct folio *); 18 static sector_t vxfs_bmap(struct address_space *, sector_t); 19 20 const struct address_space_operations vxfs_aops = { 21 .read_folio = vxfs_read_folio, 22 .bmap = vxfs_bmap, 23 }; 24 25 inline void 26 vxfs_put_page(struct page *pp) 27 { 28 kunmap(pp); 29 put_page(pp); 30 } 31 32 /** 33 * vxfs_get_page - read a page into memory. 34 * @mapping: mapping to read from 35 * @n: page number 36 * 37 * Description: 38 * vxfs_get_page reads the @n th page of @ip into the pagecache. 39 * 40 * Returns: 41 * The wanted page on success, else a NULL pointer. 42 */ 43 struct page * 44 vxfs_get_page(struct address_space *mapping, u_long n) 45 { 46 struct page * pp; 47 48 pp = read_mapping_page(mapping, n, NULL); 49 50 if (!IS_ERR(pp)) { 51 kmap(pp); 52 /** if (!PageChecked(pp)) **/ 53 /** vxfs_check_page(pp); **/ 54 } 55 56 return (pp); 57 } 58 59 /** 60 * vxfs_bread - read buffer for a give inode,block tuple 61 * @ip: inode 62 * @block: logical block 63 * 64 * Description: 65 * The vxfs_bread function reads block no @block of 66 * @ip into the buffercache. 67 * 68 * Returns: 69 * The resulting &struct buffer_head. 70 */ 71 struct buffer_head * 72 vxfs_bread(struct inode *ip, int block) 73 { 74 struct buffer_head *bp; 75 daddr_t pblock; 76 77 pblock = vxfs_bmap1(ip, block); 78 bp = sb_bread(ip->i_sb, pblock); 79 80 return (bp); 81 } 82 83 /** 84 * vxfs_getblk - locate buffer for given inode,block tuple 85 * @ip: inode 86 * @iblock: logical block 87 * @bp: buffer skeleton 88 * @create: %TRUE if blocks may be newly allocated. 89 * 90 * Description: 91 * The vxfs_getblk function fills @bp with the right physical 92 * block and device number to perform a lowlevel read/write on 93 * it. 94 * 95 * Returns: 96 * Zero on success, else a negativ error code (-EIO). 97 */ 98 static int 99 vxfs_getblk(struct inode *ip, sector_t iblock, 100 struct buffer_head *bp, int create) 101 { 102 daddr_t pblock; 103 104 pblock = vxfs_bmap1(ip, iblock); 105 if (pblock != 0) { 106 map_bh(bp, ip->i_sb, pblock); 107 return 0; 108 } 109 110 return -EIO; 111 } 112 113 /** 114 * vxfs_read_folio - read one page synchronously into the pagecache 115 * @file: file context (unused) 116 * @folio: folio to fill in. 117 * 118 * Description: 119 * The vxfs_read_folio routine reads @folio synchronously into the 120 * pagecache. 121 * 122 * Returns: 123 * Zero on success, else a negative error code. 124 * 125 * Locking status: 126 * @folio is locked and will be unlocked. 127 */ 128 static int vxfs_read_folio(struct file *file, struct folio *folio) 129 { 130 return block_read_full_folio(folio, vxfs_getblk); 131 } 132 133 /** 134 * vxfs_bmap - perform logical to physical block mapping 135 * @mapping: logical to physical mapping to use 136 * @block: logical block (relative to @mapping). 137 * 138 * Description: 139 * Vxfs_bmap find out the corresponding phsical block to the 140 * @mapping, @block pair. 141 * 142 * Returns: 143 * Physical block number on success, else Zero. 144 * 145 * Locking status: 146 * We are under the bkl. 147 */ 148 static sector_t 149 vxfs_bmap(struct address_space *mapping, sector_t block) 150 { 151 return generic_block_bmap(mapping, block, vxfs_getblk); 152 } 153