cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

vxfs_subr.c (3329B)

      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
     17static int		vxfs_read_folio(struct file *, struct folio *);
     18static sector_t		vxfs_bmap(struct address_space *, sector_t);
     19
     20const struct address_space_operations vxfs_aops = {
     21	.read_folio =		vxfs_read_folio,
     22	.bmap =			vxfs_bmap,
     23};
     24
     25inline void
     26vxfs_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 * @ip:		inode 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 */
     43struct page *
     44vxfs_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		if (PageError(pp))
     55			goto fail;
     56	}
     57	
     58	return (pp);
     59		 
     60fail:
     61	vxfs_put_page(pp);
     62	return ERR_PTR(-EIO);
     63}
     64
     65/**
     66 * vxfs_bread - read buffer for a give inode,block tuple
     67 * @ip:		inode
     68 * @block:	logical block
     69 *
     70 * Description:
     71 *   The vxfs_bread function reads block no @block  of
     72 *   @ip into the buffercache.
     73 *
     74 * Returns:
     75 *   The resulting &struct buffer_head.
     76 */
     77struct buffer_head *
     78vxfs_bread(struct inode *ip, int block)
     79{
     80	struct buffer_head	*bp;
     81	daddr_t			pblock;
     82
     83	pblock = vxfs_bmap1(ip, block);
     84	bp = sb_bread(ip->i_sb, pblock);
     85
     86	return (bp);
     87}
     88
     89/**
     90 * vxfs_get_block - locate buffer for given inode,block tuple 
     91 * @ip:		inode
     92 * @iblock:	logical block
     93 * @bp:		buffer skeleton
     94 * @create:	%TRUE if blocks may be newly allocated.
     95 *
     96 * Description:
     97 *   The vxfs_get_block function fills @bp with the right physical
     98 *   block and device number to perform a lowlevel read/write on
     99 *   it.
    100 *
    101 * Returns:
    102 *   Zero on success, else a negativ error code (-EIO).
    103 */
    104static int
    105vxfs_getblk(struct inode *ip, sector_t iblock,
    106	    struct buffer_head *bp, int create)
    107{
    108	daddr_t			pblock;
    109
    110	pblock = vxfs_bmap1(ip, iblock);
    111	if (pblock != 0) {
    112		map_bh(bp, ip->i_sb, pblock);
    113		return 0;
    114	}
    115
    116	return -EIO;
    117}
    118
    119/**
    120 * vxfs_read_folio - read one page synchronously into the pagecache
    121 * @file:	file context (unused)
    122 * @folio:	folio to fill in.
    123 *
    124 * Description:
    125 *   The vxfs_read_folio routine reads @folio synchronously into the
    126 *   pagecache.
    127 *
    128 * Returns:
    129 *   Zero on success, else a negative error code.
    130 *
    131 * Locking status:
    132 *   @folio is locked and will be unlocked.
    133 */
    134static int vxfs_read_folio(struct file *file, struct folio *folio)
    135{
    136	return block_read_full_folio(folio, vxfs_getblk);
    137}
    138 
    139/**
    140 * vxfs_bmap - perform logical to physical block mapping
    141 * @mapping:	logical to physical mapping to use
    142 * @block:	logical block (relative to @mapping).
    143 *
    144 * Description:
    145 *   Vxfs_bmap find out the corresponding phsical block to the
    146 *   @mapping, @block pair.
    147 *
    148 * Returns:
    149 *   Physical block number on success, else Zero.
    150 *
    151 * Locking status:
    152 *   We are under the bkl.
    153 */
    154static sector_t
    155vxfs_bmap(struct address_space *mapping, sector_t block)
    156{
    157	return generic_block_bmap(mapping, block, vxfs_getblk);
    158}