dm: Drop the block_dev_desc_t typedef

Use 'struct' instead of a typdef. Also since 'struct block_dev_desc' is long
and causes 80-column violations, rename it to struct blk_desc.

Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Stephen Warren <swarren@nvidia.com>

9 files changed, 66 insertions, 77 deletions

diff --git a/fs/ext4/dev.c b/fs/ext4/dev.c
index 9fd10de077..3eef66f847 100644
--- a/fs/ext4/dev.c
+++ b/fs/ext4/dev.c
@@ -32,13 +32,13 @@
 
 lbaint_t part_offset;
 
-static block_dev_desc_t *ext4fs_block_dev_desc;
+static struct blk_desc *ext4fs_blk_desc;
 static disk_partition_t *part_info;
 
-void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
+void ext4fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 {
 	assert(rbdd->blksz == (1 << rbdd->log2blksz));
-	ext4fs_block_dev_desc = rbdd;
+	ext4fs_blk_desc = rbdd;
 	get_fs()->dev_desc = rbdd;
 	part_info = info;
 	part_offset = info->start;
@@ -49,11 +49,11 @@ void ext4fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
 int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
 {
 	unsigned block_len;
-	int log2blksz = ext4fs_block_dev_desc->log2blksz;
-	ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, (ext4fs_block_dev_desc ?
-						 ext4fs_block_dev_desc->blksz :
+	int log2blksz = ext4fs_blk_desc->log2blksz;
+	ALLOC_CACHE_ALIGN_BUFFER(char, sec_buf, (ext4fs_blk_desc ?
+						 ext4fs_blk_desc->blksz :
 						 0));
-	if (ext4fs_block_dev_desc == NULL) {
+	if (ext4fs_blk_desc == NULL) {
 		printf("** Invalid Block Device Descriptor (NULL)\n");
 		return 0;
 	}
@@ -69,21 +69,20 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
 
 	/* Get the read to the beginning of a partition */
 	sector += byte_offset >> log2blksz;
-	byte_offset &= ext4fs_block_dev_desc->blksz - 1;
+	byte_offset &= ext4fs_blk_desc->blksz - 1;
 
 	debug(" <" LBAFU ", %d, %d>\n", sector, byte_offset, byte_len);
 
 	if (byte_offset != 0) {
 		int readlen;
 		/* read first part which isn't aligned with start of sector */
-		if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
-						      part_info->start + sector,
-						      1, (void *)sec_buf)
-		    != 1) {
+		if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
+						part_info->start + sector,
+						1, (void *)sec_buf) != 1) {
 			printf(" ** ext2fs_devread() read error **\n");
 			return 0;
 		}
-		readlen = min((int)ext4fs_block_dev_desc->blksz - byte_offset,
+		readlen = min((int)ext4fs_blk_desc->blksz - byte_offset,
 			      byte_len);
 		memcpy(buf, sec_buf + byte_offset, readlen);
 		buf += readlen;
@@ -95,38 +94,36 @@ int ext4fs_devread(lbaint_t sector, int byte_offset, int byte_len, char *buf)
 		return 1;
 
 	/* read sector aligned part */
-	block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1);
+	block_len = byte_len & ~(ext4fs_blk_desc->blksz - 1);
 
 	if (block_len == 0) {
-		ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_block_dev_desc->blksz);
+		ALLOC_CACHE_ALIGN_BUFFER(u8, p, ext4fs_blk_desc->blksz);
 
-		block_len = ext4fs_block_dev_desc->blksz;
-		ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
+		block_len = ext4fs_blk_desc->blksz;
+		ext4fs_blk_desc->block_read(ext4fs_blk_desc,
 						  part_info->start + sector,
 						  1, (void *)p);
 		memcpy(buf, p, byte_len);
 		return 1;
 	}
 
-	if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
-					      part_info->start + sector,
-					      block_len >> log2blksz,
-					      (void *)buf) !=
-					      block_len >> log2blksz) {
+	if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
+					part_info->start + sector,
+					block_len >> log2blksz, (void *)buf)
+				!= block_len >> log2blksz) {
 		printf(" ** %s read error - block\n", __func__);
 		return 0;
 	}
-	block_len = byte_len & ~(ext4fs_block_dev_desc->blksz - 1);
+	block_len = byte_len & ~(ext4fs_blk_desc->blksz - 1);
 	buf += block_len;
 	byte_len -= block_len;
-	sector += block_len / ext4fs_block_dev_desc->blksz;
+	sector += block_len / ext4fs_blk_desc->blksz;
 
 	if (byte_len != 0) {
 		/* read rest of data which are not in whole sector */
-		if (ext4fs_block_dev_desc->block_read(ext4fs_block_dev_desc,
-						      part_info->start + sector,
-						      1, (void *)sec_buf)
-		    != 1) {
+		if (ext4fs_blk_desc->block_read(ext4fs_blk_desc,
+						part_info->start + sector,
+						1, (void *)sec_buf) != 1) {
 			printf("* %s read error - last part\n", __func__);
 			return 0;
 		}
diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c
index 258b93791b..43c8897793 100644
--- a/fs/ext4/ext4fs.c
+++ b/fs/ext4/ext4fs.c
@@ -198,7 +198,7 @@ int ext4fs_read(char *buf, loff_t len, loff_t *actread)
 	return ext4fs_read_file(ext4fs_file, 0, len, buf, actread);
 }
 
-int ext4fs_probe(block_dev_desc_t *fs_dev_desc,
+int ext4fs_probe(struct blk_desc *fs_dev_desc,
 		 disk_partition_t *fs_partition)
 {
 	ext4fs_set_blk_dev(fs_dev_desc, fs_partition);
diff --git a/fs/fat/fat.c b/fs/fat/fat.c
index 472a63e8bb..2cef3bd22d 100644
--- a/fs/fat/fat.c
+++ b/fs/fat/fat.c
@@ -37,7 +37,7 @@ static void downcase(char *str)
 	}
 }
 
-static block_dev_desc_t *cur_dev;
+static struct blk_desc *cur_dev;
 static disk_partition_t cur_part_info;
 
 #define DOS_BOOT_MAGIC_OFFSET	0x1fe
@@ -60,7 +60,7 @@ static int disk_read(__u32 block, __u32 nr_blocks, void *buf)
 	return ret;
 }
 
-int fat_set_blk_dev(block_dev_desc_t *dev_desc, disk_partition_t *info)
+int fat_set_blk_dev(struct blk_desc *dev_desc, disk_partition_t *info)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, dev_desc->blksz);
 
@@ -89,7 +89,7 @@ int fat_set_blk_dev(block_dev_desc_t *dev_desc, disk_partition_t *info)
 	return -1;
 }
 
-int fat_register_device(block_dev_desc_t *dev_desc, int part_no)
+int fat_register_device(struct blk_desc *dev_desc, int part_no)
 {
 	disk_partition_t info;
 
diff --git a/fs/fs.c b/fs/fs.c
index d123d29a08..8515beabf5 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -20,11 +20,11 @@
 
 DECLARE_GLOBAL_DATA_PTR;
 
-static block_dev_desc_t *fs_dev_desc;
+static struct blk_desc *fs_dev_desc;
 static disk_partition_t fs_partition;
 static int fs_type = FS_TYPE_ANY;
 
-static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
+static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
 				      disk_partition_t *fs_partition)
 {
 	printf("** Unrecognized filesystem type **\n");
@@ -81,7 +81,7 @@ struct fstype_info {
 	 * filesystem.
 	 */
 	bool null_dev_desc_ok;
-	int (*probe)(block_dev_desc_t *fs_dev_desc,
+	int (*probe)(struct blk_desc *fs_dev_desc,
 		     disk_partition_t *fs_partition);
 	int (*ls)(const char *dirname);
 	int (*exists)(const char *filename);
diff --git a/fs/reiserfs/dev.c b/fs/reiserfs/dev.c
index 7b24d6aa71..5a1ab0a364 100644
--- a/fs/reiserfs/dev.c
+++ b/fs/reiserfs/dev.c
@@ -12,13 +12,13 @@
 
 #include "reiserfs_private.h"
 
-static block_dev_desc_t *reiserfs_block_dev_desc;
+static struct blk_desc *reiserfs_blk_desc;
 static disk_partition_t *part_info;
 
 
-void reiserfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
+void reiserfs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 {
-	reiserfs_block_dev_desc = rbdd;
+	reiserfs_blk_desc = rbdd;
 	part_info = info;
 }
 
@@ -53,17 +53,15 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
 #endif
 
 
-	if (reiserfs_block_dev_desc == NULL)
+	if (reiserfs_blk_desc == NULL)
 		return 0;
 
 
 	if (byte_offset != 0) {
 		/* read first part which isn't aligned with start of sector */
-		if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
-							part_info->start +
-								sector,
-							1, (void *)sec_buf)
-		    != 1) {
+		if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
+						  part_info->start + sector,
+						  1, (void *)sec_buf) != 1) {
 			printf (" ** reiserfs_devread() read error\n");
 			return 0;
 		}
@@ -75,11 +73,10 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
 
 	/* read sector aligned part */
 	block_len = byte_len & ~(SECTOR_SIZE-1);
-	if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
-						part_info->start + sector,
-						block_len / SECTOR_SIZE,
-						(void *)buf)
-	    != block_len/SECTOR_SIZE) {
+	if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
+					  part_info->start + sector,
+					  block_len / SECTOR_SIZE, (void *)buf)
+			!= block_len/SECTOR_SIZE) {
 		printf (" ** reiserfs_devread() read error - block\n");
 		return 0;
 	}
@@ -89,11 +86,9 @@ int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf)
 
 	if ( byte_len != 0 ) {
 		/* read rest of data which are not in whole sector */
-		if (reiserfs_block_dev_desc->block_read(reiserfs_block_dev_desc,
-							part_info->start +
-							    sector,
-							1, (void *)sec_buf)
-		    != 1) {
+		if (reiserfs_blk_desc->block_read(reiserfs_blk_desc,
+						  part_info->start + sector,
+						  1, (void *)sec_buf) != 1) {
 			printf (" ** reiserfs_devread() read error - last part\n");
 			return 0;
 		}
diff --git a/fs/sandbox/sandboxfs.c b/fs/sandbox/sandboxfs.c
index 5acfc03704..2703eed208 100644
--- a/fs/sandbox/sandboxfs.c
+++ b/fs/sandbox/sandboxfs.c
@@ -8,10 +8,10 @@
 #include <fs.h>
 #include <os.h>
 
-int sandbox_fs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
+int sandbox_fs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 {
 	/*
-	 * Only accept a NULL block_dev_desc_t for the sandbox, which is when
+	 * Only accept a NULL struct blk_desc for the sandbox, which is when
 	 * hostfs interface is used
 	 */
 	return rbdd != NULL;
diff --git a/fs/ubifs/ubifs.c b/fs/ubifs/ubifs.c
index a992a00c8f..168ae2b697 100644
--- a/fs/ubifs/ubifs.c
+++ b/fs/ubifs/ubifs.c
@@ -561,7 +561,7 @@ static unsigned long ubifs_findfile(struct super_block *sb, char *filename)
 	return 0;
 }
 
-int ubifs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
+int ubifs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 {
 	if (rbdd) {
 		debug("UBIFS cannot be used with normal block devices\n");
diff --git a/fs/zfs/dev.c b/fs/zfs/dev.c
index 67d12652b0..2f409e66cd 100644
--- a/fs/zfs/dev.c
+++ b/fs/zfs/dev.c
@@ -13,12 +13,12 @@
 #include <config.h>
 #include <zfs_common.h>
 
-static block_dev_desc_t *zfs_block_dev_desc;
+static struct blk_desc *zfs_blk_desc;
 static disk_partition_t *part_info;
 
-void zfs_set_blk_dev(block_dev_desc_t *rbdd, disk_partition_t *info)
+void zfs_set_blk_dev(struct blk_desc *rbdd, disk_partition_t *info)
 {
-	zfs_block_dev_desc = rbdd;
+	zfs_blk_desc = rbdd;
 	part_info = info;
 }
 
@@ -48,17 +48,16 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
 
 	debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len);
 
-	if (zfs_block_dev_desc == NULL) {
+	if (zfs_blk_desc == NULL) {
 		printf("** Invalid Block Device Descriptor (NULL)\n");
 		return 1;
 	}
 
 	if (byte_offset != 0) {
 		/* read first part which isn't aligned with start of sector */
-		if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
-						   part_info->start + sector, 1,
-						   (void *)sec_buf)
-		    != 1) {
+		if (zfs_blk_desc->block_read(zfs_blk_desc,
+					     part_info->start + sector, 1,
+					     (void *)sec_buf) != 1) {
 			printf(" ** zfs_devread() read error **\n");
 			return 1;
 		}
@@ -79,18 +78,16 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
 		u8 p[SECTOR_SIZE];
 
 		block_len = SECTOR_SIZE;
-		zfs_block_dev_desc->block_read(zfs_block_dev_desc,
-					       part_info->start + sector,
-					       1, (void *)p);
+		zfs_blk_desc->block_read(zfs_blk_desc,
+					 part_info->start + sector,
+					 1, (void *)p);
 		memcpy(buf, p, byte_len);
 		return 0;
 	}
 
-	if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
-					   part_info->start + sector,
-					   block_len / SECTOR_SIZE,
-					   (void *)buf)
-	    != block_len / SECTOR_SIZE) {
+	if (zfs_blk_desc->block_read(zfs_blk_desc, part_info->start + sector,
+				     block_len / SECTOR_SIZE,
+				     (void *)buf) != block_len / SECTOR_SIZE) {
 		printf(" ** zfs_devread() read error - block\n");
 		return 1;
 	}
@@ -102,9 +99,9 @@ int zfs_devread(int sector, int byte_offset, int byte_len, char *buf)
 
 	if (byte_len != 0) {
 		/* read rest of data which are not in whole sector */
-		if (zfs_block_dev_desc->block_read(zfs_block_dev_desc,
-						   part_info->start + sector,
-						   1, (void *)sec_buf) != 1) {
+		if (zfs_blk_desc->block_read(zfs_blk_desc,
+					     part_info->start + sector,
+					     1, (void *)sec_buf) != 1) {
 			printf(" ** zfs_devread() read error - last part\n");
 			return 1;
 		}
diff --git a/fs/zfs/zfs.c b/fs/zfs/zfs.c
index fb2b3ee089..ca67afbb2e 100644
--- a/fs/zfs/zfs.c
+++ b/fs/zfs/zfs.c
@@ -20,7 +20,7 @@
 #include "zfs_common.h"
 #include "div64.h"
 
-block_dev_desc_t *zfs_dev_desc;
+struct blk_desc *zfs_dev_desc;
 
 /*
  * The zfs plug-in routines for GRUB are: