block: Move SECTOR_SIZE and SECTOR_SHIFT definitions into <linux/blkdev.h>

It happens often while I'm preparing a patch for a block driver that
I'm wondering: is a definition of SECTOR_SIZE and/or SECTOR_SHIFT
available for this driver? Do I have to introduce definitions of these
constants before I can use these constants? To avoid this confusion,
move the existing definitions of SECTOR_SIZE and SECTOR_SHIFT into the
<linux/blkdev.h> header file such that these become available for all
block drivers. Make the SECTOR_SIZE definition in the uapi msdos_fs.h
header file conditional to avoid that including that header file after
<linux/blkdev.h> causes the compiler to complain about a SECTOR_SIZE
redefinition.

Note: the SECTOR_SIZE / SECTOR_SHIFT / SECTOR_BITS definitions have
not been removed from uapi header files nor from NAND drivers in
which these constants are used for another purpose than converting
block layer offsets and sizes into a number of sectors.

Cc: David S. Miller <davem@davemloft.net>
Cc: Mike Snitzer <snitzer@redhat.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Nitin Gupta <ngupta@vflare.org>
Reviewed-by: Sergey Senozhatsky <sergey.senozhatsky@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Bart Van Assche <bart.vanassche@wdc.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 31 insertions, 11 deletions

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 19eaf8d89368..9af3e0f430bc 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1022,6 +1022,19 @@ static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 }
 
 /*
+ * The basic unit of block I/O is a sector. It is used in a number of contexts
+ * in Linux (blk, bio, genhd). The size of one sector is 512 = 2**9
+ * bytes. Variables of type sector_t represent an offset or size that is a
+ * multiple of 512 bytes. Hence these two constants.
+ */
+#ifndef SECTOR_SHIFT
+#define SECTOR_SHIFT 9
+#endif
+#ifndef SECTOR_SIZE
+#define SECTOR_SIZE (1 << SECTOR_SHIFT)
+#endif
+
+/*
  * blk_rq_pos()                 : the current sector
  * blk_rq_bytes()               : bytes left in the entire request
  * blk_rq_cur_bytes()           : bytes left in the current segment
@@ -1048,12 +1061,12 @@ extern unsigned int blk_rq_err_bytes(const struct request *rq);
 
 static inline unsigned int blk_rq_sectors(const struct request *rq)
 {
-        return blk_rq_bytes(rq) >> 9;
+        return blk_rq_bytes(rq) >> SECTOR_SHIFT;
 }
 
 static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
 {
-        return blk_rq_cur_bytes(rq) >> 9;
+        return blk_rq_cur_bytes(rq) >> SECTOR_SHIFT;
 }
 
 static inline unsigned int blk_rq_zone_no(struct request *rq)
@@ -1083,7 +1096,8 @@ static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
                                                      int op)
 {
         if (unlikely(op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE))
-                return min(q->limits.max_discard_sectors, UINT_MAX >> 9);
+                return min(q->limits.max_discard_sectors,
+                           UINT_MAX >> SECTOR_SHIFT);
 
         if (unlikely(op == REQ_OP_WRITE_SAME))
                 return q->limits.max_write_same_sectors;
@@ -1395,16 +1409,21 @@ extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
 static inline int sb_issue_discard(struct super_block *sb, sector_t block,
                 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
 {
-        return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
-                                    nr_blocks << (sb->s_blocksize_bits - 9),
+        return blkdev_issue_discard(sb->s_bdev,
+                                    block << (sb->s_blocksize_bits -
+                                              SECTOR_SHIFT),
+                                    nr_blocks << (sb->s_blocksize_bits -
+                                                  SECTOR_SHIFT),
                                     gfp_mask, flags);
 }
 static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
                 sector_t nr_blocks, gfp_t gfp_mask)
 {
         return blkdev_issue_zeroout(sb->s_bdev,
-                                    block << (sb->s_blocksize_bits - 9),
-                                    nr_blocks << (sb->s_blocksize_bits - 9),
+                                    block << (sb->s_blocksize_bits -
+                                              SECTOR_SHIFT),
+                                    nr_blocks << (sb->s_blocksize_bits -
+                                                  SECTOR_SHIFT),
                                     gfp_mask, 0);
 }
 
@@ -1511,7 +1530,8 @@ static inline int queue_alignment_offset(struct request_queue *q)
 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
 {
         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
-        unsigned int alignment = sector_div(sector, granularity >> 9) << 9;
+        unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT)
+                << SECTOR_SHIFT;
 
         return (granularity + lim->alignment_offset - alignment) % granularity;
 }
@@ -1545,8 +1565,8 @@ static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector
                 return 0;
 
         /* Why are these in bytes, not sectors? */
-        alignment = lim->discard_alignment >> 9;
-        granularity = lim->discard_granularity >> 9;
+        alignment = lim->discard_alignment >> SECTOR_SHIFT;
+        granularity = lim->discard_granularity >> SECTOR_SHIFT;
         if (!granularity)
                 return 0;
 
@@ -1557,7 +1577,7 @@ static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector
         offset = (granularity + alignment - offset) % granularity;
 
         /* Turn it back into bytes, gaah */
-        return offset << 9;
+        return offset << SECTOR_SHIFT;
 }
 
 static inline int bdev_discard_alignment(struct block_device *bdev)