fs/gfs2/jdata.c - LeafOS-Devices/android_kernel_realme_mt6785 - Gitiles

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
  * of the GNU General Public License v.2.
  */

 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>

 #include "gfs2.h"
 #include "bmap.h"
 #include "inode.h"
 #include "jdata.h"
 #include "meta_io.h"
 #include "trans.h"

 int gfs2_jdata_get_buffer(struct gfs2_inode *ip, uint64_t block, int new,
 			  struct buffer_head **bhp)
 {
 	struct buffer_head *bh;
 	int error = 0;

 	if (new) {
 		bh = gfs2_meta_new(ip->i_gl, block);
 		gfs2_trans_add_bh(ip->i_gl, bh, 1);
 		gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
 		gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
 	} else {
 		error = gfs2_meta_read(ip->i_gl, block,
 				       DIO_START | DIO_WAIT, &bh);
 		if (error)
 			return error;
 		if (gfs2_metatype_check(ip->i_sbd, bh, GFS2_METATYPE_JD)) {
 			brelse(bh);
 			return -EIO;
 		}
 	}

 	*bhp = bh;

 	return 0;
 }

 /**
  * gfs2_copy2mem - Trivial copy function for gfs2_jdata_read()
  * @bh: The buffer to copy from, or NULL meaning zero the buffer
  * @buf: The buffer to copy/zero
  * @offset: The offset in the buffer to copy from
  * @size: The amount of data to copy/zero
  *
  * Returns: errno
  */

 int gfs2_copy2mem(struct buffer_head *bh, char **buf, unsigned int offset,
 		  unsigned int size)
 {
 	if (bh)
 		memcpy(*buf, bh->b_data + offset, size);
 	else
 		memset(*buf, 0, size);
 	*buf += size;
 	return 0;
 }

 /**
  * gfs2_copy2user - Copy bytes to user space for gfs2_jdata_read()
  * @bh: The buffer
  * @buf: The destination of the data
  * @offset: The offset into the buffer
  * @size: The amount of data to copy
  *
  * Returns: errno
  */

 int gfs2_copy2user(struct buffer_head *bh, char **buf, unsigned int offset,
 		   unsigned int size)
 {
 	int error;

 	if (bh)
 		error = copy_to_user(*buf, bh->b_data + offset, size);
 	else
 		error = clear_user(*buf, size);

 	if (error)
 		error = -EFAULT;
 	else
 		*buf += size;

 	return error;
 }

 static int jdata_read_stuffed(struct gfs2_inode *ip, char *buf,
 			      unsigned int offset, unsigned int size,
 			      read_copy_fn_t copy_fn)
 {
 	struct buffer_head *dibh;
 	int error;

 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (!error) {
 		error = copy_fn(dibh, &buf,
 				offset + sizeof(struct gfs2_dinode), size);
 		brelse(dibh);
 	}

 	return (error) ? error : size;
 }

 /**
  * gfs2_jdata_read - Read a jdata file
  * @ip: The GFS2 Inode
  * @buf: The buffer to place result into
  * @offset: File offset to begin jdata_readng from
  * @size: Amount of data to transfer
  * @copy_fn: Function to actually perform the copy
  *
  * The @copy_fn only copies a maximum of a single block at once so
  * we are safe calling it with int arguments. It is done so that
  * we don't needlessly put 64bit arguments on the stack and it
  * also makes the code in the @copy_fn nicer too.
  *
  * Returns: The amount of data actually copied or the error
  */

 int gfs2_jdata_read(struct gfs2_inode *ip, char __user *buf, uint64_t offset,
 		    unsigned int size, read_copy_fn_t copy_fn)
 {
 	struct gfs2_sbd *sdp = ip->i_sbd;
 	uint64_t lblock, dblock;
 	uint32_t extlen = 0;
 	unsigned int o;
 	int copied = 0;
 	int error = 0;

 	if (offset >= ip->i_di.di_size)
 		return 0;

 	if ((offset + size) > ip->i_di.di_size)
 		size = ip->i_di.di_size - offset;

 	if (!size)
 		return 0;

 	if (gfs2_is_stuffed(ip))
 		return jdata_read_stuffed(ip, buf, (unsigned int)offset, size,
 					  copy_fn);

 	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
 		return -EINVAL;

 	lblock = offset;
 	o = do_div(lblock, sdp->sd_jbsize) +
 		sizeof(struct gfs2_meta_header);

 	while (copied < size) {
 		unsigned int amount;
 		struct buffer_head *bh;
 		int new;

 		amount = size - copied;
 		if (amount > sdp->sd_sb.sb_bsize - o)
 			amount = sdp->sd_sb.sb_bsize - o;

 		if (!extlen) {
 			new = 0;
 			error = gfs2_block_map(ip, lblock, &new,
 					       &dblock, &extlen);
 			if (error)
 				goto fail;
 		}

 		if (extlen > 1)
 			gfs2_meta_ra(ip->i_gl, dblock, extlen);

 		if (dblock) {
 			error = gfs2_jdata_get_buffer(ip, dblock, new, &bh);
 			if (error)
 				goto fail;
 			dblock++;
 			extlen--;
 		} else
 			bh = NULL;

 		error = copy_fn(bh, &buf, o, amount);
 		brelse(bh);
 		if (error)
 			goto fail;

 		copied += amount;
 		lblock++;

 		o = sizeof(struct gfs2_meta_header);
 	}

 	return copied;

  fail:
 	return (copied) ? copied : error;
 }

 /**
  * gfs2_copy_from_mem - Trivial copy function for gfs2_jdata_write()
  * @bh: The buffer to copy to or clear
  * @buf: The buffer to copy from
  * @offset: The offset in the buffer to write to
  * @size: The amount of data to write
  *
  * Returns: errno
  */

 int gfs2_copy_from_mem(struct gfs2_inode *ip, struct buffer_head *bh,
 		       const char **buf, unsigned int offset, unsigned int size)
 {
 	gfs2_trans_add_bh(ip->i_gl, bh, 1);
 	memcpy(bh->b_data + offset, *buf, size);

 	*buf += size;

 	return 0;
 }

 /**
  * gfs2_copy_from_user - Copy bytes from user space for gfs2_jdata_write()
  * @bh: The buffer to copy to or clear
  * @buf: The buffer to copy from
  * @offset: The offset in the buffer to write to
  * @size: The amount of data to write
  *
  * Returns: errno
  */

 int gfs2_copy_from_user(struct gfs2_inode *ip, struct buffer_head *bh,
 			const char __user **buf, unsigned int offset, unsigned int size)
 {
 	int error = 0;

 	gfs2_trans_add_bh(ip->i_gl, bh, 1);
 	if (copy_from_user(bh->b_data + offset, *buf, size))
 		error = -EFAULT;
 	else
 		*buf += size;

 	return error;
 }

 static int jdata_write_stuffed(struct gfs2_inode *ip, char *buf,
 			       unsigned int offset, unsigned int size,
 			       write_copy_fn_t copy_fn)
 {
 	struct buffer_head *dibh;
 	int error;

 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		return error;

 	error = copy_fn(ip,
 			dibh, &buf,
 			offset + sizeof(struct gfs2_dinode), size);
 	if (!error) {
 		if (ip->i_di.di_size < offset + size)
 			ip->i_di.di_size = offset + size;
 		ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
 		gfs2_dinode_out(&ip->i_di, dibh->b_data);
 	}

 	brelse(dibh);

 	return (error) ? error : size;
 }

 /**
  * gfs2_jdata_write - Write bytes to a file
  * @ip: The GFS2 inode
  * @buf: The buffer containing information to be written
  * @offset: The file offset to start writing at
  * @size: The amount of data to write
  * @copy_fn: Function to do the actual copying
  *
  * Returns: The number of bytes correctly written or error code
  */

 int gfs2_jdata_write(struct gfs2_inode *ip, const char __user *buf, uint64_t offset,
 		     unsigned int size, write_copy_fn_t copy_fn)
 {
 	struct gfs2_sbd *sdp = ip->i_sbd;
 	struct buffer_head *dibh;
 	uint64_t lblock, dblock;
 	uint32_t extlen = 0;
 	unsigned int o;
 	int copied = 0;
 	int error = 0;

 	if (!size)
 		return 0;

 	if (gfs2_is_stuffed(ip) &&
 	    offset + size <= sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
 		return jdata_write_stuffed(ip, buf, (unsigned int)offset, size,
 					   copy_fn);

 	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
 		return -EINVAL;

 	if (gfs2_is_stuffed(ip)) {
 		error = gfs2_unstuff_dinode(ip, NULL, NULL);
 		if (error)
 			return error;
 	}

 	lblock = offset;
 	o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);

 	while (copied < size) {
 		unsigned int amount;
 		struct buffer_head *bh;
 		int new;

 		amount = size - copied;
 		if (amount > sdp->sd_sb.sb_bsize - o)
 			amount = sdp->sd_sb.sb_bsize - o;

 		if (!extlen) {
 			new = 1;
 			error = gfs2_block_map(ip, lblock, &new,
 					       &dblock, &extlen);
 			if (error)
 				goto fail;
 			error = -EIO;
 			if (gfs2_assert_withdraw(sdp, dblock))
 				goto fail;
 		}

 		error = gfs2_jdata_get_buffer(ip, dblock,
 				(amount == sdp->sd_jbsize) ? 1 : new,
 				&bh);
 		if (error)
 			goto fail;

 		error = copy_fn(ip, bh, &buf, o, amount);
 		brelse(bh);
 		if (error)
 			goto fail;

 		copied += amount;
 		lblock++;
 		dblock++;
 		extlen--;

 		o = sizeof(struct gfs2_meta_header);
 	}

  out:
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		return error;

 	if (ip->i_di.di_size < offset + copied)
 		ip->i_di.di_size = offset + copied;
 	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();

 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(&ip->i_di, dibh->b_data);
 	brelse(dibh);

 	return copied;

  fail:
 	if (copied)
 		goto out;
 	return error;
 }
	/*
	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
	* Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
	*
	* This copyrighted material is made available to anyone wishing to use,
	* modify, copy, or redistribute it subject to the terms and conditions
	* of the GNU General Public License v.2.
	*/

	#include <linux/sched.h>
	#include <linux/slab.h>
	#include <linux/spinlock.h>
	#include <linux/completion.h>
	#include <linux/buffer_head.h>
	#include <asm/semaphore.h>
	#include <asm/uaccess.h>

	#include "gfs2.h"
	#include "bmap.h"
	#include "inode.h"
	#include "jdata.h"
	#include "meta_io.h"
	#include "trans.h"

	int gfs2_jdata_get_buffer(struct gfs2_inode *ip, uint64_t block, int new,
	struct buffer_head **bhp)
	{
	struct buffer_head *bh;
	int error = 0;

	if (new) {
	bh = gfs2_meta_new(ip->i_gl, block);
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
	} else {
	error = gfs2_meta_read(ip->i_gl, block,
	DIO_START \| DIO_WAIT, &bh);
	if (error)
	return error;
	if (gfs2_metatype_check(ip->i_sbd, bh, GFS2_METATYPE_JD)) {
	brelse(bh);
	return -EIO;
	}
	}

	*bhp = bh;

	return 0;
	}

	/**
	* gfs2_copy2mem - Trivial copy function for gfs2_jdata_read()
	* @bh: The buffer to copy from, or NULL meaning zero the buffer
	* @buf: The buffer to copy/zero
	* @offset: The offset in the buffer to copy from
	* @size: The amount of data to copy/zero
	*
	* Returns: errno
	*/

	int gfs2_copy2mem(struct buffer_head bh, char *buf, unsigned int offset,
	unsigned int size)
	{
	if (bh)
	memcpy(*buf, bh->b_data + offset, size);
	else
	memset(*buf, 0, size);
	*buf += size;
	return 0;
	}

	/**
	* gfs2_copy2user - Copy bytes to user space for gfs2_jdata_read()
	* @bh: The buffer
	* @buf: The destination of the data
	* @offset: The offset into the buffer
	* @size: The amount of data to copy
	*
	* Returns: errno
	*/

	int gfs2_copy2user(struct buffer_head bh, char *buf, unsigned int offset,
	unsigned int size)
	{
	int error;

	if (bh)
	error = copy_to_user(*buf, bh->b_data + offset, size);
	else
	error = clear_user(*buf, size);

	if (error)
	error = -EFAULT;
	else
	*buf += size;

	return error;
	}

	static int jdata_read_stuffed(struct gfs2_inode ip, char buf,
	unsigned int offset, unsigned int size,
	read_copy_fn_t copy_fn)
	{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (!error) {
	error = copy_fn(dibh, &buf,
	offset + sizeof(struct gfs2_dinode), size);
	brelse(dibh);
	}

	return (error) ? error : size;
	}

	/**
	* gfs2_jdata_read - Read a jdata file
	* @ip: The GFS2 Inode
	* @buf: The buffer to place result into
	* @offset: File offset to begin jdata_readng from
	* @size: Amount of data to transfer
	* @copy_fn: Function to actually perform the copy
	*
	* The @copy_fn only copies a maximum of a single block at once so
	* we are safe calling it with int arguments. It is done so that
	* we don't needlessly put 64bit arguments on the stack and it
	* also makes the code in the @copy_fn nicer too.
	*
	* Returns: The amount of data actually copied or the error
	*/

	int gfs2_jdata_read(struct gfs2_inode ip, char __user buf, uint64_t offset,
	unsigned int size, read_copy_fn_t copy_fn)
	{
	struct gfs2_sbd *sdp = ip->i_sbd;
	uint64_t lblock, dblock;
	uint32_t extlen = 0;
	unsigned int o;
	int copied = 0;
	int error = 0;

	if (offset >= ip->i_di.di_size)
	return 0;

	if ((offset + size) > ip->i_di.di_size)
	size = ip->i_di.di_size - offset;

	if (!size)
	return 0;

	if (gfs2_is_stuffed(ip))
	return jdata_read_stuffed(ip, buf, (unsigned int)offset, size,
	copy_fn);

	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
	return -EINVAL;

	lblock = offset;
	o = do_div(lblock, sdp->sd_jbsize) +
	sizeof(struct gfs2_meta_header);

	while (copied < size) {
	unsigned int amount;
	struct buffer_head *bh;
	int new;

	amount = size - copied;
	if (amount > sdp->sd_sb.sb_bsize - o)
	amount = sdp->sd_sb.sb_bsize - o;

	if (!extlen) {
	new = 0;
	error = gfs2_block_map(ip, lblock, &new,
	&dblock, &extlen);
	if (error)
	goto fail;
	}

	if (extlen > 1)
	gfs2_meta_ra(ip->i_gl, dblock, extlen);

	if (dblock) {
	error = gfs2_jdata_get_buffer(ip, dblock, new, &bh);
	if (error)
	goto fail;
	dblock++;
	extlen--;
	} else
	bh = NULL;

	error = copy_fn(bh, &buf, o, amount);
	brelse(bh);
	if (error)
	goto fail;

	copied += amount;
	lblock++;

	o = sizeof(struct gfs2_meta_header);
	}

	return copied;

	fail:
	return (copied) ? copied : error;
	}

	/**
	* gfs2_copy_from_mem - Trivial copy function for gfs2_jdata_write()
	* @bh: The buffer to copy to or clear
	* @buf: The buffer to copy from
	* @offset: The offset in the buffer to write to
	* @size: The amount of data to write
	*
	* Returns: errno
	*/

	int gfs2_copy_from_mem(struct gfs2_inode ip, struct buffer_head bh,
	const char **buf, unsigned int offset, unsigned int size)
	{
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	memcpy(bh->b_data + offset, *buf, size);

	*buf += size;

	return 0;
	}

	/**
	* gfs2_copy_from_user - Copy bytes from user space for gfs2_jdata_write()
	* @bh: The buffer to copy to or clear
	* @buf: The buffer to copy from
	* @offset: The offset in the buffer to write to
	* @size: The amount of data to write
	*
	* Returns: errno
	*/

	int gfs2_copy_from_user(struct gfs2_inode ip, struct buffer_head bh,
	const char __user **buf, unsigned int offset, unsigned int size)
	{
	int error = 0;

	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	if (copy_from_user(bh->b_data + offset, *buf, size))
	error = -EFAULT;
	else
	*buf += size;

	return error;
	}

	static int jdata_write_stuffed(struct gfs2_inode ip, char buf,
	unsigned int offset, unsigned int size,
	write_copy_fn_t copy_fn)
	{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
	return error;

	error = copy_fn(ip,
	dibh, &buf,
	offset + sizeof(struct gfs2_dinode), size);
	if (!error) {
	if (ip->i_di.di_size < offset + size)
	ip->i_di.di_size = offset + size;
	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
	gfs2_dinode_out(&ip->i_di, dibh->b_data);
	}

	brelse(dibh);

	return (error) ? error : size;
	}

	/**
	* gfs2_jdata_write - Write bytes to a file
	* @ip: The GFS2 inode
	* @buf: The buffer containing information to be written
	* @offset: The file offset to start writing at
	* @size: The amount of data to write
	* @copy_fn: Function to do the actual copying
	*
	* Returns: The number of bytes correctly written or error code
	*/

	int gfs2_jdata_write(struct gfs2_inode ip, const char __user buf, uint64_t offset,
	unsigned int size, write_copy_fn_t copy_fn)
	{
	struct gfs2_sbd *sdp = ip->i_sbd;
	struct buffer_head *dibh;
	uint64_t lblock, dblock;
	uint32_t extlen = 0;
	unsigned int o;
	int copied = 0;
	int error = 0;

	if (!size)
	return 0;

	if (gfs2_is_stuffed(ip) &&
	offset + size <= sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
	return jdata_write_stuffed(ip, buf, (unsigned int)offset, size,
	copy_fn);

	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
	return -EINVAL;

	if (gfs2_is_stuffed(ip)) {
	error = gfs2_unstuff_dinode(ip, NULL, NULL);
	if (error)
	return error;
	}

	lblock = offset;
	o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);

	while (copied < size) {
	unsigned int amount;
	struct buffer_head *bh;
	int new;

	amount = size - copied;
	if (amount > sdp->sd_sb.sb_bsize - o)
	amount = sdp->sd_sb.sb_bsize - o;

	if (!extlen) {
	new = 1;
	error = gfs2_block_map(ip, lblock, &new,
	&dblock, &extlen);
	if (error)
	goto fail;
	error = -EIO;
	if (gfs2_assert_withdraw(sdp, dblock))
	goto fail;
	}

	error = gfs2_jdata_get_buffer(ip, dblock,
	(amount == sdp->sd_jbsize) ? 1 : new,
	&bh);
	if (error)
	goto fail;

	error = copy_fn(ip, bh, &buf, o, amount);
	brelse(bh);
	if (error)
	goto fail;

	copied += amount;
	lblock++;
	dblock++;
	extlen--;

	o = sizeof(struct gfs2_meta_header);
	}

	out:
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
	return error;

	if (ip->i_di.di_size < offset + copied)
	ip->i_di.di_size = offset + copied;
	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
	gfs2_dinode_out(&ip->i_di, dibh->b_data);
	brelse(dibh);

	return copied;

	fail:
	if (copied)
	goto out;
	return error;
	}