// SPDX-License-Identifier: GPL-2.0
/*
 * linux/fs/befs/datastream.c
 *
 * Copyright (C) 2001 Will Dyson <will_dyson@pobox.com>
 *
 * Based on portions of file.c by Makoto Kato <m_kato@ga2.so-net.ne.jp>
 *
 * Many thanks to Dominic Giampaolo, author of "Practical File System
 * Design with the Be File System", for such a helpful book.
 *
 */

#include <linux/kernel.h>
#include <linux/buffer_head.h>
#include <linux/string.h>

#include "befs.h"
#include "datastream.h"
#include "io.h"

const befs_inode_addr BAD_IADDR = { 0, 0, 0 };

static int befs_find_brun_direct(struct super_block *sb,
				 const befs_data_stream *data,
				 befs_blocknr_t blockno, befs_block_run *run);

static int befs_find_brun_indirect(struct super_block *sb,
				   const befs_data_stream *data,
				   befs_blocknr_t blockno,
				   befs_block_run *run);

static int befs_find_brun_dblindirect(struct super_block *sb,
				      const befs_data_stream *data,
				      befs_blocknr_t blockno,
				      befs_block_run *run);

/**
 * befs_read_datastream - get buffer_head containing data, starting from pos.
 * @sb: Filesystem superblock
 * @ds: datastream to find data with
 * @pos: start of data
 * @off: offset of data in buffer_head->b_data
 *
 * Returns pointer to buffer_head containing data starting with offset @off,
 * if you don't need to know offset just set @off = NULL.
 */
struct buffer_head *
befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
		     befs_off_t pos, uint *off)
{
	struct buffer_head *bh;
	befs_block_run run;
	befs_blocknr_t block;	/* block coresponding to pos */

	befs_debug(sb, "---> %s %llu", __func__, pos);
	block = pos >> BEFS_SB(sb)->block_shift;
	if (off)
		*off = pos - (block << BEFS_SB(sb)->block_shift);

	if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) {
		befs_error(sb, "BeFS: Error finding disk addr of block %lu",
			   (unsigned long)block);
		befs_debug(sb, "<--- %s ERROR", __func__);
		return NULL;
	}
	bh = befs_bread_iaddr(sb, run);
	if (!bh) {
		befs_error(sb, "BeFS: Error reading block %lu from datastream",
			   (unsigned long)block);
		return NULL;
	}

	befs_debug(sb, "<--- %s read data, starting at %llu", __func__, pos);

	return bh;
}

/**
 * befs_fblock2brun - give back block run for fblock
 * @sb: the superblock
 * @data: datastream to read from
 * @fblock: the blocknumber with the file position to find
 * @run: The found run is passed back through this pointer
 *
 * Takes a file position and gives back a brun who's starting block
 * is block number fblock of the file.
 *
 * Returns BEFS_OK or BEFS_ERR.
 *
 * Calls specialized functions for each of the three possible
 * datastream regions.
 */
int
befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
		 befs_blocknr_t fblock, befs_block_run *run)
{
	int err;
	befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;

	if (pos < data->max_direct_range) {
		err = befs_find_brun_direct(sb, data, fblock, run);

	} else if (pos < data->max_indirect_range) {
		err = befs_find_brun_indirect(sb, data, fblock, run);

	} else if (pos < data->max_double_indirect_range) {
		err = befs_find_brun_dblindirect(sb, data, fblock, run);

	} else {
		befs_error(sb,
			   "befs_fblock2brun() was asked to find block %lu, "
			   "which is not mapped by the datastream\n",
			   (unsigned long)fblock);
		err = BEFS_ERR;
	}
	return err;
}

/**
 * befs_read_lsmylink - read long symlink from datastream.
 * @sb: Filesystem superblock
 * @ds: Datastream to read from
 * @buff: Buffer in which to place long symlink data
 * @len: Length of the long symlink in bytes
 *
 * Returns the number of bytes read
 */
size_t
befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
		   void *buff, befs_off_t len)
{
	befs_off_t bytes_read = 0;	/* bytes readed */
	u16 plen;
	struct buffer_head *bh;

	befs_debug(sb, "---> %s length: %llu", __func__, len);

	while (bytes_read < len) {
		bh = befs_read_datastream(sb, ds, bytes_read, NULL);
		if (!bh) {
			befs_error(sb, "BeFS: Error reading datastream block "
				   "starting from %llu", bytes_read);
			befs_debug(sb, "<--- %s ERROR", __func__);
			return bytes_read;

		}
		plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ?
		    BEFS_SB(sb)->block_size : len - bytes_read;
		memcpy(buff + bytes_read, bh->b_data, plen);
		brelse(bh);
		bytes_read += plen;
	}

	befs_debug(sb, "<--- %s read %u bytes", __func__, (unsigned int)
		   bytes_read);
	return bytes_read;
}

/**
 * befs_count_blocks - blocks used by a file
 * @sb: Filesystem superblock
 * @ds: Datastream of the file
 *
 * Counts the number of fs blocks that the file represented by
 * inode occupies on the filesystem, counting both regular file
 * data and filesystem metadata (and eventually attribute data
 * when we support attributes)
*/

befs_blocknr_t
befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
{
	befs_blocknr_t blocks;
	befs_blocknr_t datablocks;	/* File data blocks */
	befs_blocknr_t metablocks;	/* FS metadata blocks */
	struct befs_sb_info *befs_sb = BEFS_SB(sb);

	befs_debug(sb, "---> %s", __func__);

	datablocks = ds->size >> befs_sb->block_shift;
	if (ds->size & (befs_sb->block_size - 1))
		datablocks += 1;

	metablocks = 1;		/* Start with 1 block for inode */

	/* Size of indirect block */
	if (ds->size > ds->max_direct_range)
		metablocks += ds->indirect.len;

	/*
	 * Double indir block, plus all the indirect blocks it maps.
	 * In the double-indirect range, all block runs of data are
	 * BEFS_DBLINDIR_BRUN_LEN blocks long. Therefore, we know
	 * how many data block runs are in the double-indirect region,
	 * and from that we know how many indirect blocks it takes to
	 * map them. We assume that the indirect blocks are also
	 * BEFS_DBLINDIR_BRUN_LEN blocks long.
	 */
	if (ds->size > ds->max_indirect_range && ds->max_indirect_range != 0) {
		uint dbl_bytes;
		uint dbl_bruns;
		uint indirblocks;

		dbl_bytes =
		    ds->max_double_indirect_range - ds->max_indirect_range;
		dbl_bruns =
		    dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN);
		indirblocks = dbl_bruns / befs_iaddrs_per_block(sb);

		metablocks += ds->double_indirect.len;
		metablocks += indirblocks;
	}

	blocks = datablocks + metablocks;
	befs_debug(sb, "<--- %s %u blocks", __func__, (unsigned int)blocks);

	return blocks;
}

/**
 * befs_find_brun_direct - find a direct block run in the datastream
 * @sb: the superblock
 * @data: the datastream
 * @blockno: the blocknumber to find
 * @run: The found run is passed back through this pointer
 *
 * Finds the block run that starts at file block number blockno
 * in the file represented by the datastream data, if that
 * blockno is in the direct region of the datastream.
 *
 * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 * otherwise.
 *
 * Algorithm:
 * Linear search. Checks each element of array[] to see if it
 * contains the blockno-th filesystem block. This is necessary
 * because the block runs map variable amounts of data. Simply
 * keeps a count of the number of blocks searched so far (sum),
 * incrementing this by the length of each block run as we come
 * across it. Adds sum to *count before returning (this is so
 * you can search multiple arrays that are logicaly one array,
 * as in the indirect region code).
 *
 * When/if blockno is found, if blockno is inside of a block
 * run as stored on disk, we offset the start and length members
 * of the block run, so that blockno is the start and len is
 * still valid (the run ends in the same place).
 */
static int
befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
		      befs_blocknr_t blockno, befs_block_run *run)
{
	int i;
	const befs_block_run *array = data->direct;
	befs_blocknr_t sum;

	befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);

	for (i = 0, sum = 0; i < BEFS_NUM_DIRECT_BLOCKS;
	     sum += array[i].len, i++) {
		if (blockno >= sum && blockno < sum + (array[i].len)) {
			int offset = blockno - sum;

			run->allocation_group = array[i].allocation_group;
			run->start = array[i].start + offset;
			run->len = array[i].len - offset;

			befs_debug(sb, "---> %s, "
				   "found %lu at direct[%d]", __func__,
				   (unsigned long)blockno, i);
			return BEFS_OK;
		}
	}

	befs_error(sb, "%s failed to find file block %lu", __func__,
		   (unsigned long)blockno);
	befs_debug(sb, "---> %s ERROR", __func__);
	return BEFS_ERR;
}

/**
 * befs_find_brun_indirect - find a block run in the datastream
 * @sb: the superblock
 * @data: the datastream
 * @blockno: the blocknumber to find
 * @run: The found run is passed back through this pointer
 *
 * Finds the block run that starts at file block number blockno
 * in the file represented by the datastream data, if that
 * blockno is in the indirect region of the datastream.
 *
 * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 * otherwise.
 *
 * Algorithm:
 * For each block in the indirect run of the datastream, read
 * it in and search through it for search_blk.
 *
 * XXX:
 * Really should check to make sure blockno is inside indirect
 * region.
 */
static int
befs_find_brun_indirect(struct super_block *sb,
			const befs_data_stream *data,
			befs_blocknr_t blockno,
			befs_block_run *run)
{
	int i, j;
	befs_blocknr_t sum = 0;
	befs_blocknr_t indir_start_blk;
	befs_blocknr_t search_blk;
	struct buffer_head *indirblock;
	befs_disk_block_run *array;

	befs_block_run indirect = data->indirect;
	befs_blocknr_t indirblockno = iaddr2blockno(sb, &indirect);
	int arraylen = befs_iaddrs_per_block(sb);

	befs_debug(sb, "---> %s, find %lu", __func__, (unsigned long)blockno);

	indir_start_blk = data->max_direct_range >> BEFS_SB(sb)->block_shift;
	search_blk = blockno - indir_start_blk;

	/* Examine blocks of the indirect run one at a time */
	for (i = 0; i < indirect.len; i++) {
		indirblock = sb_bread(sb, indirblockno + i);
		if (indirblock == NULL) {
			befs_error(sb, "---> %s failed to read "
				   "disk block %lu from the indirect brun",
				   __func__, (unsigned long)indirblockno + i);
			befs_debug(sb, "<--- %s ERROR", __func__);
			return BEFS_ERR;
		}

		array = (befs_disk_block_run *) indirblock->b_data;

		for (j = 0; j < arraylen; ++j) {
			int len = fs16_to_cpu(sb, array[j].len);

			if (search_blk >= sum && search_blk < sum + len) {
				int offset = search_blk - sum;
				run->allocation_group =
				    fs32_to_cpu(sb, array[j].allocation_group);
				run->start =
				    fs16_to_cpu(sb, array[j].start) + offset;
				run->len =
				    fs16_to_cpu(sb, array[j].len) - offset;

				brelse(indirblock);
				befs_debug(sb,
					   "<--- %s found file block "
					   "%lu at indirect[%d]", __func__,
					   (unsigned long)blockno,
					   j + (i * arraylen));
				return BEFS_OK;
			}
			sum += len;
		}

		brelse(indirblock);
	}

	/* Only fallthrough is an error */
	befs_error(sb, "BeFS: %s failed to find "
		   "file block %lu", __func__, (unsigned long)blockno);

	befs_debug(sb, "<--- %s ERROR", __func__);
	return BEFS_ERR;
}

/**
 * befs_find_brun_dblindirect - find a block run in the datastream
 * @sb: the superblock
 * @data: the datastream
 * @blockno: the blocknumber to find
 * @run: The found run is passed back through this pointer
 *
 * Finds the block run that starts at file block number blockno
 * in the file represented by the datastream data, if that
 * blockno is in the double-indirect region of the datastream.
 *
 * Return value is BEFS_OK if the blockrun is found, BEFS_ERR
 * otherwise.
 *
 * Algorithm:
 * The block runs in the double-indirect region are different.
 * They are always allocated 4 fs blocks at a time, so each
 * block run maps a constant amount of file data. This means
 * that we can directly calculate how many block runs into the
 * double-indirect region we need to go to get to the one that
 * maps a particular filesystem block.
 *
 * We do this in two stages. First we calculate which of the
 * inode addresses in the double-indirect block will point us
 * to the indirect block that contains the mapping for the data,
 * then we calculate which of the inode addresses in that
 * indirect block maps the data block we are after.
 *
 * Oh, and once we've done that, we actually read in the blocks
 * that contain the inode addresses we calculated above. Even
 * though the double-indirect run may be several blocks long,
 * we can calculate which of those blocks will contain the index
 * we are after and only read that one. We then follow it to
 * the indirect block and perform a similar process to find
 * the actual block run that maps the data block we are interested
 * in.
 *
 * Then we offset the run as in befs_find_brun_array() and we are
 * done.
 */
static int
befs_find_brun_dblindirect(struct super_block *sb,
			   const befs_data_stream *data,
			   befs_blocknr_t blockno,
			   befs_block_run *run)
{
	int dblindir_indx;
	int indir_indx;
	int offset;
	int dbl_which_block;
	int which_block;
	int dbl_block_indx;
	int block_indx;
	off_t dblindir_leftover;
	befs_blocknr_t blockno_at_run_start;
	struct buffer_head *dbl_indir_block;
	struct buffer_head *indir_block;
	befs_block_run indir_run;
	befs_disk_inode_addr *iaddr_array;

	befs_blocknr_t indir_start_blk =
	    data->max_indirect_range >> BEFS_SB(sb)->block_shift;

	off_t dbl_indir_off = blockno - indir_start_blk;

	/* number of data blocks mapped by each of the iaddrs in
	 * the indirect block pointed to by the double indirect block
	 */
	size_t iblklen = BEFS_DBLINDIR_BRUN_LEN;

	/* number of data blocks mapped by each of the iaddrs in
	 * the double indirect block
	 */
	size_t diblklen = iblklen * befs_iaddrs_per_block(sb)
	    * BEFS_DBLINDIR_BRUN_LEN;

	befs_debug(sb, "---> %s find %lu", __func__, (unsigned long)blockno);

	/* First, discover which of the double_indir->indir blocks
	 * contains pos. Then figure out how much of pos that
	 * accounted for. Then discover which of the iaddrs in
	 * the indirect block contains pos.
	 */

	dblindir_indx = dbl_indir_off / diblklen;
	dblindir_leftover = dbl_indir_off % diblklen;
	indir_indx = dblindir_leftover / diblklen;

	/* Read double indirect block */
	dbl_which_block = dblindir_indx / befs_iaddrs_per_block(sb);
	if (dbl_which_block > data->double_indirect.len) {
		befs_error(sb, "The double-indirect index calculated by "
			   "%s, %d, is outside the range "
			   "of the double-indirect block", __func__,
			   dblindir_indx);
		return BEFS_ERR;
	}

	dbl_indir_block =
	    sb_bread(sb, iaddr2blockno(sb, &data->double_indirect) +
					dbl_which_block);
	if (dbl_indir_block == NULL) {
		befs_error(sb, "%s couldn't read the "
			   "double-indirect block at blockno %lu", __func__,
			   (unsigned long)
			   iaddr2blockno(sb, &data->double_indirect) +
			   dbl_which_block);
		return BEFS_ERR;
	}

	dbl_block_indx =
	    dblindir_indx - (dbl_which_block * befs_iaddrs_per_block(sb));
	iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data;
	indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]);
	brelse(dbl_indir_block);

	/* Read indirect block */
	which_block = indir_indx / befs_iaddrs_per_block(sb);
	if (which_block > indir_run.len) {
		befs_error(sb, "The indirect index calculated by "
			   "%s, %d, is outside the range "
			   "of the indirect block", __func__, indir_indx);
		return BEFS_ERR;
	}

	indir_block =
	    sb_bread(sb, iaddr2blockno(sb, &indir_run) + which_block);
	if (indir_block == NULL) {
		befs_error(sb, "%s couldn't read the indirect block "
			   "at blockno %lu", __func__, (unsigned long)
			   iaddr2blockno(sb, &indir_run) + which_block);
		return BEFS_ERR;
	}

	block_indx = indir_indx - (which_block * befs_iaddrs_per_block(sb));
	iaddr_array = (befs_disk_inode_addr *) indir_block->b_data;
	*run = fsrun_to_cpu(sb, iaddr_array[block_indx]);
	brelse(indir_block);

	blockno_at_run_start = indir_start_blk;
	blockno_at_run_start += diblklen * dblindir_indx;
	blockno_at_run_start += iblklen * indir_indx;
	offset = blockno - blockno_at_run_start;

	run->start += offset;
	run->len -= offset;

	befs_debug(sb, "Found file block %lu in double_indirect[%d][%d],"
		   " double_indirect_leftover = %lu", (unsigned long)
		   blockno, dblindir_indx, indir_indx, dblindir_leftover);

	return BEFS_OK;
}
