[PATCH 1/3] befs: fix typos in datastream.c

[PATCH 1/3] befs: fix typos in datastream.c

[Luis de Bethencourt]

Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
---

Hi,

This is a series of patches fixing small issues in datastream.c.

On the process of doing the same for the rest of files. To finish cleanup
and start adding documentation and new features.

Thanks,
Luis

 fs/befs/datastream.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index 6889644..b2eb5b5 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -37,7 +37,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
 /**
  * befs_read_datastream - get buffer_head containing data, starting from pos.
  * @sb: Filesystem superblock
- * @ds: datastrem to find data with
+ * @ds: datastream to find data with
  * @pos: start of data
  * @off: offset of data in buffer_head->b_data
  *
@@ -115,7 +115,7 @@ befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
 /**
  * befs_read_lsmylink - read long symlink from datastream.
  * @sb: Filesystem superblock 
- * @ds: Datastrem to read from
+ * @ds: Datastream to read from
  * @buff: Buffer in which to place long symlink data
  * @len: Length of the long symlink in bytes
  *
@@ -183,7 +183,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
 		metablocks += ds->indirect.len;
 
 	/*
-	   Double indir block, plus all the indirect blocks it mapps
+	   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,
@@ -397,7 +397,7 @@ befs_find_brun_indirect(struct super_block *sb,
 	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 indirect block and perform a similar process to find
 	the actual block run that maps the data block we are interested
 	in.
 	
-- 
2.5.1

[PATCH 2/3] befs: improve documentation in datastream.c

[Luis de Bethencourt]

Convert function descriptions to kernel-doc style.

Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
---
 fs/befs/datastream.c | 193 ++++++++++++++++++++++++++-------------------------
 1 file changed, 98 insertions(+), 95 deletions(-)

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index b2eb5b5..5ce85cf 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -75,7 +75,13 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
 	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.
  * 
@@ -212,36 +218,35 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
 	return blocks;
 }
 
-/*
-	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.
-	
-	sb: the superblock
-	data: the datastream
-	blockno: the blocknumber to find
-	run: The found run is passed back through this pointer
-	
-	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).
-	
-	2001-11-15 Will Dyson
-*/
+/**
+ * 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)
@@ -273,29 +278,28 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
 	return BEFS_ERR;
 }
 
-/*
-	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.
-	
-	sb: the superblock
-	data: the datastream
-	blockno: the blocknumber to find
-	run: The found run is passed back through this pointer
-	
-	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.
-	
-	2001-11-15 Will Dyson
-*/
+/**
+ * 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,
@@ -365,47 +369,46 @@ befs_find_brun_indirect(struct super_block *sb,
 	return BEFS_ERR;
 }
 
-/*
-	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.
-	
-	sb: the superblock
-	data: the datastream
-	blockno: the blocknumber to find
-	run: The found run is passed back through this pointer
-	
-	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.
-	
-	2001-11-15 Will Dyson
-*/
+/**
+ * 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,
-- 
2.5.1

[PATCH 3/3] befs: befs: fix style issues in datastream.c

[Luis de Bethencourt]

Fixing the following checkpatch.pl errors:

ERROR: "foo * bar" should be "foo *bar"
+                            befs_blocknr_t blockno, befs_block_run * run);

WARNING: Missing a blank line after declarations
+       struct buffer_head *bh;
+       befs_debug(sb, "---> %s length: %llu", __func__, len);

WARNING: Block comments use * on subsequent lines
+       /*
+          Double indir block, plus all the indirect blocks it maps.

(and other instances of these)

Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
---
 fs/befs/datastream.c | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index 5ce85cf..b4c7ba0 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -22,17 +22,17 @@ 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);
+				 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);
+				   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_block_run *run);
 
 /**
  * befs_read_datastream - get buffer_head containing data, starting from pos.
@@ -46,7 +46,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
  */
 struct buffer_head *
 befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
-		     befs_off_t pos, uint * off)
+		     befs_off_t pos, uint *off)
 {
 	struct buffer_head *bh;
 	befs_block_run run;
@@ -94,7 +94,7 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
  */
 int
 befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
-		 befs_blocknr_t fblock, befs_block_run * run)
+		 befs_blocknr_t fblock, befs_block_run *run)
 {
 	int err;
 	befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;
@@ -134,6 +134,7 @@ befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
 	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) {
@@ -189,13 +190,13 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
 		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.
+	 * 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;
@@ -249,7 +250,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
  */
 static int
 befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
-		      befs_blocknr_t blockno, befs_block_run * run)
+		      befs_blocknr_t blockno, befs_block_run *run)
 {
 	int i;
 	const befs_block_run *array = data->direct;
@@ -261,6 +262,7 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
 	     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;
@@ -304,7 +306,7 @@ static int
 befs_find_brun_indirect(struct super_block *sb,
 			const befs_data_stream *data,
 			befs_blocknr_t blockno,
-			befs_block_run * run)
+			befs_block_run *run)
 {
 	int i, j;
 	befs_blocknr_t sum = 0;
@@ -413,7 +415,7 @@ static int
 befs_find_brun_dblindirect(struct super_block *sb,
 			   const befs_data_stream *data,
 			   befs_blocknr_t blockno,
-			   befs_block_run * run)
+			   befs_block_run *run)
 {
 	int dblindir_indx;
 	int indir_indx;
-- 
2.5.1

[PATCH v2 3/3] befs: fix style issues in datastream.c

[Luis de Bethencourt]

Fixing the following checkpatch.pl errors:

ERROR: "foo * bar" should be "foo *bar"
+                            befs_blocknr_t blockno, befs_block_run * run);

WARNING: Missing a blank line after declarations
+       struct buffer_head *bh;
+       befs_debug(sb, "---> %s length: %llu", __func__, len);

WARNING: Block comments use * on subsequent lines
+       /*
+          Double indir block, plus all the indirect blocks it maps.

(and other instances of these)

Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
---

Hi,

Removing the second "befs:" that creeped into the subject line of the patch.

Ironic since it is a patch fixing typos.
Errare humanum est.

Thanks,
Luis

 fs/befs/datastream.c | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index 5ce85cf..b4c7ba0 100644
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -22,17 +22,17 @@ 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);
+				 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);
+				   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_block_run *run);
 
 /**
  * befs_read_datastream - get buffer_head containing data, starting from pos.
@@ -46,7 +46,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
  */
 struct buffer_head *
 befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
-		     befs_off_t pos, uint * off)
+		     befs_off_t pos, uint *off)
 {
 	struct buffer_head *bh;
 	befs_block_run run;
@@ -94,7 +94,7 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
  */
 int
 befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
-		 befs_blocknr_t fblock, befs_block_run * run)
+		 befs_blocknr_t fblock, befs_block_run *run)
 {
 	int err;
 	befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;
@@ -134,6 +134,7 @@ befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
 	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) {
@@ -189,13 +190,13 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
 		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.
+	 * 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;
@@ -249,7 +250,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
  */
 static int
 befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
-		      befs_blocknr_t blockno, befs_block_run * run)
+		      befs_blocknr_t blockno, befs_block_run *run)
 {
 	int i;
 	const befs_block_run *array = data->direct;
@@ -261,6 +262,7 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
 	     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;
@@ -304,7 +306,7 @@ static int
 befs_find_brun_indirect(struct super_block *sb,
 			const befs_data_stream *data,
 			befs_blocknr_t blockno,
-			befs_block_run * run)
+			befs_block_run *run)
 {
 	int i, j;
 	befs_blocknr_t sum = 0;
@@ -413,7 +415,7 @@ static int
 befs_find_brun_dblindirect(struct super_block *sb,
 			   const befs_data_stream *data,
 			   befs_blocknr_t blockno,
-			   befs_block_run * run)
+			   befs_block_run *run)
 {
 	int dblindir_indx;
 	int indir_indx;
-- 
2.5.1

Re: [PATCH 1/3] befs: fix typos in datastream.c

[Salah Triki]

On Sat, Aug 13, 2016 at 06:11:19PM +0100, Luis de Bethencourt wrote:
> Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
> ---
> 
> Hi,
> 
> This is a series of patches fixing small issues in datastream.c.
> 
> On the process of doing the same for the rest of files. To finish cleanup
> and start adding documentation and new features.
> 
> Thanks,
> Luis
> 
>  fs/befs/datastream.c | 8 ++++----
>  1 file changed, 4 insertions(+), 4 deletions(-)
> 
> diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
> index 6889644..b2eb5b5 100644
> --- a/fs/befs/datastream.c
> +++ b/fs/befs/datastream.c
> @@ -37,7 +37,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
>  /**
>   * befs_read_datastream - get buffer_head containing data, starting from pos.
>   * @sb: Filesystem superblock
> - * @ds: datastrem to find data with
> + * @ds: datastream to find data with
>   * @pos: start of data
>   * @off: offset of data in buffer_head->b_data
>   *
> @@ -115,7 +115,7 @@ befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
>  /**
>   * befs_read_lsmylink - read long symlink from datastream.
>   * @sb: Filesystem superblock 
> - * @ds: Datastrem to read from
> + * @ds: Datastream to read from
>   * @buff: Buffer in which to place long symlink data
>   * @len: Length of the long symlink in bytes
>   *
> @@ -183,7 +183,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>  		metablocks += ds->indirect.len;
>  
>  	/*
> -	   Double indir block, plus all the indirect blocks it mapps
> +	   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,
> @@ -397,7 +397,7 @@ befs_find_brun_indirect(struct super_block *sb,
>  	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 indirect block and perform a similar process to find
>  	the actual block run that maps the data block we are interested
>  	in.
>  	
> -- 
> 2.5.1
> 

Signed-off-by: Salah Triki <salah.triki@gmail.com>

Thanks,
Salah

Re: [PATCH 2/3] befs: improve documentation in datastream.c

[Salah Triki]

On Sat, Aug 13, 2016 at 06:11:20PM +0100, Luis de Bethencourt wrote:
> Convert function descriptions to kernel-doc style.
> 
> Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
> ---
>  fs/befs/datastream.c | 193 ++++++++++++++++++++++++++-------------------------
>  1 file changed, 98 insertions(+), 95 deletions(-)
> 
> diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
> index b2eb5b5..5ce85cf 100644
> --- a/fs/befs/datastream.c
> +++ b/fs/befs/datastream.c
> @@ -75,7 +75,13 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
>  	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.
>   * 
> @@ -212,36 +218,35 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>  	return blocks;
>  }
>  
> -/*
> -	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.
> -	
> -	sb: the superblock
> -	data: the datastream
> -	blockno: the blocknumber to find
> -	run: The found run is passed back through this pointer
> -	
> -	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).
> -	
> -	2001-11-15 Will Dyson
> -*/
> +/**
> + * 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)
> @@ -273,29 +278,28 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
>  	return BEFS_ERR;
>  }
>  
> -/*
> -	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.
> -	
> -	sb: the superblock
> -	data: the datastream
> -	blockno: the blocknumber to find
> -	run: The found run is passed back through this pointer
> -	
> -	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.
> -	
> -	2001-11-15 Will Dyson
> -*/
> +/**
> + * 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,
> @@ -365,47 +369,46 @@ befs_find_brun_indirect(struct super_block *sb,
>  	return BEFS_ERR;
>  }
>  
> -/*
> -	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.
> -	
> -	sb: the superblock
> -	data: the datastream
> -	blockno: the blocknumber to find
> -	run: The found run is passed back through this pointer
> -	
> -	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.
> -	
> -	2001-11-15 Will Dyson
> -*/
> +/**
> + * 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,
> -- 
> 2.5.1
> 

Signed-off-by: Salah Triki <salah.triki@gmail.com>

Thanks,
Salah

Re: [PATCH v2 3/3] befs: fix style issues in datastream.c

[Salah Triki]

On Sun, Aug 14, 2016 at 06:48:36PM +0100, Luis de Bethencourt wrote:
> Fixing the following checkpatch.pl errors:
> 
> ERROR: "foo * bar" should be "foo *bar"
> +                            befs_blocknr_t blockno, befs_block_run * run);
> 
> WARNING: Missing a blank line after declarations
> +       struct buffer_head *bh;
> +       befs_debug(sb, "---> %s length: %llu", __func__, len);
> 
> WARNING: Block comments use * on subsequent lines
> +       /*
> +          Double indir block, plus all the indirect blocks it maps.
> 
> (and other instances of these)
> 
> Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
> ---
> 
> Hi,
> 
> Removing the second "befs:" that creeped into the subject line of the patch.
> 
> Ironic since it is a patch fixing typos.
> Errare humanum est.
> 
> Thanks,
> Luis
> 
>  fs/befs/datastream.c | 32 +++++++++++++++++---------------
>  1 file changed, 17 insertions(+), 15 deletions(-)
> 
> diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
> index 5ce85cf..b4c7ba0 100644
> --- a/fs/befs/datastream.c
> +++ b/fs/befs/datastream.c
> @@ -22,17 +22,17 @@ 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);
> +				 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);
> +				   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_block_run *run);
>  
>  /**
>   * befs_read_datastream - get buffer_head containing data, starting from pos.
> @@ -46,7 +46,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
>   */
>  struct buffer_head *
>  befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
> -		     befs_off_t pos, uint * off)
> +		     befs_off_t pos, uint *off)
>  {
>  	struct buffer_head *bh;
>  	befs_block_run run;
> @@ -94,7 +94,7 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
>   */
>  int
>  befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
> -		 befs_blocknr_t fblock, befs_block_run * run)
> +		 befs_blocknr_t fblock, befs_block_run *run)
>  {
>  	int err;
>  	befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;
> @@ -134,6 +134,7 @@ befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
>  	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) {
> @@ -189,13 +190,13 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>  		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.
> +	 * 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;
> @@ -249,7 +250,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>   */
>  static int
>  befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
> -		      befs_blocknr_t blockno, befs_block_run * run)
> +		      befs_blocknr_t blockno, befs_block_run *run)
>  {
>  	int i;
>  	const befs_block_run *array = data->direct;
> @@ -261,6 +262,7 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
>  	     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;
> @@ -304,7 +306,7 @@ static int
>  befs_find_brun_indirect(struct super_block *sb,
>  			const befs_data_stream *data,
>  			befs_blocknr_t blockno,
> -			befs_block_run * run)
> +			befs_block_run *run)
>  {
>  	int i, j;
>  	befs_blocknr_t sum = 0;
> @@ -413,7 +415,7 @@ static int
>  befs_find_brun_dblindirect(struct super_block *sb,
>  			   const befs_data_stream *data,
>  			   befs_blocknr_t blockno,
> -			   befs_block_run * run)
> +			   befs_block_run *run)
>  {
>  	int dblindir_indx;
>  	int indir_indx;
> -- 
> 2.5.1
> 

Signed-off-by: Salah Triki <salah.triki@gmail.com>

Thanks,
Salah

Re: [PATCH 3/3] befs: befs: fix style issues in datastream.c

[Salah Triki]

On Sat, Aug 13, 2016 at 06:11:21PM +0100, Luis de Bethencourt wrote:
> Fixing the following checkpatch.pl errors:
> 
> ERROR: "foo * bar" should be "foo *bar"
> +                            befs_blocknr_t blockno, befs_block_run * run);
> 
> WARNING: Missing a blank line after declarations
> +       struct buffer_head *bh;
> +       befs_debug(sb, "---> %s length: %llu", __func__, len);
> 
> WARNING: Block comments use * on subsequent lines
> +       /*
> +          Double indir block, plus all the indirect blocks it maps.
> 
> (and other instances of these)
> 
> Signed-off-by: Luis de Bethencourt <luisbg@osg.samsung.com>
> ---
>  fs/befs/datastream.c | 32 +++++++++++++++++---------------
>  1 file changed, 17 insertions(+), 15 deletions(-)
> 
> diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
> index 5ce85cf..b4c7ba0 100644
> --- a/fs/befs/datastream.c
> +++ b/fs/befs/datastream.c
> @@ -22,17 +22,17 @@ 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);
> +				 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);
> +				   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_block_run *run);
>  
>  /**
>   * befs_read_datastream - get buffer_head containing data, starting from pos.
> @@ -46,7 +46,7 @@ static int befs_find_brun_dblindirect(struct super_block *sb,
>   */
>  struct buffer_head *
>  befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
> -		     befs_off_t pos, uint * off)
> +		     befs_off_t pos, uint *off)
>  {
>  	struct buffer_head *bh;
>  	befs_block_run run;
> @@ -94,7 +94,7 @@ befs_read_datastream(struct super_block *sb, const befs_data_stream *ds,
>   */
>  int
>  befs_fblock2brun(struct super_block *sb, const befs_data_stream *data,
> -		 befs_blocknr_t fblock, befs_block_run * run)
> +		 befs_blocknr_t fblock, befs_block_run *run)
>  {
>  	int err;
>  	befs_off_t pos = fblock << BEFS_SB(sb)->block_shift;
> @@ -134,6 +134,7 @@ befs_read_lsymlink(struct super_block *sb, const befs_data_stream *ds,
>  	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) {
> @@ -189,13 +190,13 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>  		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.
> +	 * 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;
> @@ -249,7 +250,7 @@ befs_count_blocks(struct super_block *sb, const befs_data_stream *ds)
>   */
>  static int
>  befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
> -		      befs_blocknr_t blockno, befs_block_run * run)
> +		      befs_blocknr_t blockno, befs_block_run *run)
>  {
>  	int i;
>  	const befs_block_run *array = data->direct;
> @@ -261,6 +262,7 @@ befs_find_brun_direct(struct super_block *sb, const befs_data_stream *data,
>  	     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;
> @@ -304,7 +306,7 @@ static int
>  befs_find_brun_indirect(struct super_block *sb,
>  			const befs_data_stream *data,
>  			befs_blocknr_t blockno,
> -			befs_block_run * run)
> +			befs_block_run *run)
>  {
>  	int i, j;
>  	befs_blocknr_t sum = 0;
> @@ -413,7 +415,7 @@ static int
>  befs_find_brun_dblindirect(struct super_block *sb,
>  			   const befs_data_stream *data,
>  			   befs_blocknr_t blockno,
> -			   befs_block_run * run)
> +			   befs_block_run *run)
>  {
>  	int dblindir_indx;
>  	int indir_indx;
> -- 
> 2.5.1
> 

Signed-off-by: Salah Triki <salah.triki@gmail.com>

Thanks,
Salah