LCOV - code coverage report
Current view: top level - block - genhd.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 407 838 48.6 %
Date: 2022-04-01 13:59:58 Functions: 40 79 50.6 %
Branches: 145 482 30.1 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  gendisk handling
       4                 :            :  */
       5                 :            : 
       6                 :            : #include <linux/module.h>
       7                 :            : #include <linux/fs.h>
       8                 :            : #include <linux/genhd.h>
       9                 :            : #include <linux/kdev_t.h>
      10                 :            : #include <linux/kernel.h>
      11                 :            : #include <linux/blkdev.h>
      12                 :            : #include <linux/backing-dev.h>
      13                 :            : #include <linux/init.h>
      14                 :            : #include <linux/spinlock.h>
      15                 :            : #include <linux/proc_fs.h>
      16                 :            : #include <linux/seq_file.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/kmod.h>
      19                 :            : #include <linux/kobj_map.h>
      20                 :            : #include <linux/mutex.h>
      21                 :            : #include <linux/idr.h>
      22                 :            : #include <linux/log2.h>
      23                 :            : #include <linux/pm_runtime.h>
      24                 :            : #include <linux/badblocks.h>
      25                 :            : 
      26                 :            : #include "blk.h"
      27                 :            : 
      28                 :            : static DEFINE_MUTEX(block_class_lock);
      29                 :            : struct kobject *block_depr;
      30                 :            : 
      31                 :            : /* for extended dynamic devt allocation, currently only one major is used */
      32                 :            : #define NR_EXT_DEVT             (1 << MINORBITS)
      33                 :            : 
      34                 :            : /* For extended devt allocation.  ext_devt_lock prevents look up
      35                 :            :  * results from going away underneath its user.
      36                 :            :  */
      37                 :            : static DEFINE_SPINLOCK(ext_devt_lock);
      38                 :            : static DEFINE_IDR(ext_devt_idr);
      39                 :            : 
      40                 :            : static const struct device_type disk_type;
      41                 :            : 
      42                 :            : static void disk_check_events(struct disk_events *ev,
      43                 :            :                               unsigned int *clearing_ptr);
      44                 :            : static void disk_alloc_events(struct gendisk *disk);
      45                 :            : static void disk_add_events(struct gendisk *disk);
      46                 :            : static void disk_del_events(struct gendisk *disk);
      47                 :            : static void disk_release_events(struct gendisk *disk);
      48                 :            : 
      49                 :      77435 : void part_inc_in_flight(struct request_queue *q, struct hd_struct *part, int rw)
      50                 :            : {
      51         [ -  + ]:      77435 :         if (queue_is_mq(q))
      52                 :            :                 return;
      53                 :            : 
      54                 :          0 :         part_stat_local_inc(part, in_flight[rw]);
      55         [ #  # ]:          0 :         if (part->partno)
      56         [ #  # ]:          0 :                 part_stat_local_inc(&part_to_disk(part)->part0, in_flight[rw]);
      57                 :            : }
      58                 :            : 
      59                 :      77435 : void part_dec_in_flight(struct request_queue *q, struct hd_struct *part, int rw)
      60                 :            : {
      61         [ -  + ]:      77435 :         if (queue_is_mq(q))
      62                 :            :                 return;
      63                 :            : 
      64                 :          0 :         part_stat_local_dec(part, in_flight[rw]);
      65         [ #  # ]:          0 :         if (part->partno)
      66         [ #  # ]:          0 :                 part_stat_local_dec(&part_to_disk(part)->part0, in_flight[rw]);
      67                 :            : }
      68                 :            : 
      69                 :          0 : unsigned int part_in_flight(struct request_queue *q, struct hd_struct *part)
      70                 :            : {
      71                 :          0 :         int cpu;
      72                 :          0 :         unsigned int inflight;
      73                 :            : 
      74         [ #  # ]:          0 :         if (queue_is_mq(q)) {
      75                 :          0 :                 return blk_mq_in_flight(q, part);
      76                 :            :         }
      77                 :            : 
      78                 :            :         inflight = 0;
      79         [ #  # ]:          0 :         for_each_possible_cpu(cpu) {
      80                 :          0 :                 inflight += part_stat_local_read_cpu(part, in_flight[0], cpu) +
      81                 :          0 :                             part_stat_local_read_cpu(part, in_flight[1], cpu);
      82                 :            :         }
      83         [ #  # ]:          0 :         if ((int)inflight < 0)
      84                 :          0 :                 inflight = 0;
      85                 :            : 
      86                 :            :         return inflight;
      87                 :            : }
      88                 :            : 
      89                 :          0 : void part_in_flight_rw(struct request_queue *q, struct hd_struct *part,
      90                 :            :                        unsigned int inflight[2])
      91                 :            : {
      92                 :          0 :         int cpu;
      93                 :            : 
      94         [ #  # ]:          0 :         if (queue_is_mq(q)) {
      95                 :          0 :                 blk_mq_in_flight_rw(q, part, inflight);
      96                 :          0 :                 return;
      97                 :            :         }
      98                 :            : 
      99                 :          0 :         inflight[0] = 0;
     100                 :          0 :         inflight[1] = 0;
     101         [ #  # ]:          0 :         for_each_possible_cpu(cpu) {
     102                 :          0 :                 inflight[0] += part_stat_local_read_cpu(part, in_flight[0], cpu);
     103                 :          0 :                 inflight[1] += part_stat_local_read_cpu(part, in_flight[1], cpu);
     104                 :            :         }
     105         [ #  # ]:          0 :         if ((int)inflight[0] < 0)
     106                 :          0 :                 inflight[0] = 0;
     107         [ #  # ]:          0 :         if ((int)inflight[1] < 0)
     108                 :          0 :                 inflight[1] = 0;
     109                 :            : }
     110                 :            : 
     111                 :      69106 : struct hd_struct *__disk_get_part(struct gendisk *disk, int partno)
     112                 :            : {
     113         [ +  - ]:      67390 :         struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl);
     114                 :            : 
     115   [ +  -  +  -  :      69106 :         if (unlikely(partno < 0 || partno >= ptbl->len))
             +  -  +  - ]
     116                 :            :                 return NULL;
     117         [ +  - ]:      69106 :         return rcu_dereference(ptbl->part[partno]);
     118                 :            : }
     119                 :            : 
     120                 :            : /**
     121                 :            :  * disk_get_part - get partition
     122                 :            :  * @disk: disk to look partition from
     123                 :            :  * @partno: partition number
     124                 :            :  *
     125                 :            :  * Look for partition @partno from @disk.  If found, increment
     126                 :            :  * reference count and return it.
     127                 :            :  *
     128                 :            :  * CONTEXT:
     129                 :            :  * Don't care.
     130                 :            :  *
     131                 :            :  * RETURNS:
     132                 :            :  * Pointer to the found partition on success, NULL if not found.
     133                 :            :  */
     134                 :       1716 : struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
     135                 :            : {
     136                 :       1716 :         struct hd_struct *part;
     137                 :            : 
     138                 :       1716 :         rcu_read_lock();
     139         [ +  - ]:       1716 :         part = __disk_get_part(disk, partno);
     140         [ +  - ]:       1716 :         if (part)
     141                 :       1716 :                 get_device(part_to_dev(part));
     142                 :       1716 :         rcu_read_unlock();
     143                 :            : 
     144                 :       1716 :         return part;
     145                 :            : }
     146                 :            : EXPORT_SYMBOL_GPL(disk_get_part);
     147                 :            : 
     148                 :            : /**
     149                 :            :  * disk_part_iter_init - initialize partition iterator
     150                 :            :  * @piter: iterator to initialize
     151                 :            :  * @disk: disk to iterate over
     152                 :            :  * @flags: DISK_PITER_* flags
     153                 :            :  *
     154                 :            :  * Initialize @piter so that it iterates over partitions of @disk.
     155                 :            :  *
     156                 :            :  * CONTEXT:
     157                 :            :  * Don't care.
     158                 :            :  */
     159                 :       2028 : void disk_part_iter_init(struct disk_part_iter *piter, struct gendisk *disk,
     160                 :            :                           unsigned int flags)
     161                 :            : {
     162                 :       2028 :         struct disk_part_tbl *ptbl;
     163                 :            : 
     164                 :        156 :         rcu_read_lock();
     165         [ -  + ]:       2028 :         ptbl = rcu_dereference(disk->part_tbl);
     166                 :            : 
     167                 :       2028 :         piter->disk = disk;
     168                 :       2028 :         piter->part = NULL;
     169                 :            : 
     170         [ -  + ]:        156 :         if (flags & DISK_PITER_REVERSE)
     171                 :          0 :                 piter->idx = ptbl->len - 1;
     172         [ -  + ]:        156 :         else if (flags & (DISK_PITER_INCL_PART0 | DISK_PITER_INCL_EMPTY_PART0))
     173                 :          0 :                 piter->idx = 0;
     174                 :            :         else
     175                 :        156 :                 piter->idx = 1;
     176                 :            : 
     177                 :       2028 :         piter->flags = flags;
     178                 :            : 
     179                 :       2028 :         rcu_read_unlock();
     180                 :       1872 : }
     181                 :            : EXPORT_SYMBOL_GPL(disk_part_iter_init);
     182                 :            : 
     183                 :            : /**
     184                 :            :  * disk_part_iter_next - proceed iterator to the next partition and return it
     185                 :            :  * @piter: iterator of interest
     186                 :            :  *
     187                 :            :  * Proceed @piter to the next partition and return it.
     188                 :            :  *
     189                 :            :  * CONTEXT:
     190                 :            :  * Don't care.
     191                 :            :  */
     192                 :       2028 : struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter)
     193                 :            : {
     194                 :       2028 :         struct disk_part_tbl *ptbl;
     195                 :       2028 :         int inc, end;
     196                 :            : 
     197                 :            :         /* put the last partition */
     198         [ -  + ]:       2028 :         disk_put_part(piter->part);
     199                 :       2028 :         piter->part = NULL;
     200                 :            : 
     201                 :            :         /* get part_tbl */
     202                 :       2028 :         rcu_read_lock();
     203         [ -  + ]:       2028 :         ptbl = rcu_dereference(piter->disk->part_tbl);
     204                 :            : 
     205                 :            :         /* determine iteration parameters */
     206         [ -  + ]:       2028 :         if (piter->flags & DISK_PITER_REVERSE) {
     207                 :          0 :                 inc = -1;
     208         [ #  # ]:          0 :                 if (piter->flags & (DISK_PITER_INCL_PART0 |
     209                 :            :                                     DISK_PITER_INCL_EMPTY_PART0))
     210                 :            :                         end = -1;
     211                 :            :                 else
     212                 :          0 :                         end = 0;
     213                 :            :         } else {
     214                 :       2028 :                 inc = 1;
     215                 :       2028 :                 end = ptbl->len;
     216                 :            :         }
     217                 :            : 
     218                 :            :         /* iterate to the next partition */
     219         [ -  + ]:       2028 :         for (; piter->idx != end; piter->idx += inc) {
     220                 :          0 :                 struct hd_struct *part;
     221                 :            : 
     222         [ #  # ]:          0 :                 part = rcu_dereference(ptbl->part[piter->idx]);
     223         [ #  # ]:          0 :                 if (!part)
     224                 :          0 :                         continue;
     225         [ #  # ]:          0 :                 if (!part_nr_sects_read(part) &&
     226         [ #  # ]:          0 :                     !(piter->flags & DISK_PITER_INCL_EMPTY) &&
     227         [ #  # ]:          0 :                     !(piter->flags & DISK_PITER_INCL_EMPTY_PART0 &&
     228                 :            :                       piter->idx == 0))
     229                 :          0 :                         continue;
     230                 :            : 
     231                 :          0 :                 get_device(part_to_dev(part));
     232                 :          0 :                 piter->part = part;
     233                 :          0 :                 piter->idx += inc;
     234                 :          0 :                 break;
     235                 :            :         }
     236                 :            : 
     237                 :       2028 :         rcu_read_unlock();
     238                 :            : 
     239                 :       2028 :         return piter->part;
     240                 :            : }
     241                 :            : EXPORT_SYMBOL_GPL(disk_part_iter_next);
     242                 :            : 
     243                 :            : /**
     244                 :            :  * disk_part_iter_exit - finish up partition iteration
     245                 :            :  * @piter: iter of interest
     246                 :            :  *
     247                 :            :  * Called when iteration is over.  Cleans up @piter.
     248                 :            :  *
     249                 :            :  * CONTEXT:
     250                 :            :  * Don't care.
     251                 :            :  */
     252                 :       2028 : void disk_part_iter_exit(struct disk_part_iter *piter)
     253                 :            : {
     254         [ -  + ]:        156 :         disk_put_part(piter->part);
     255                 :          0 :         piter->part = NULL;
     256                 :        156 : }
     257                 :            : EXPORT_SYMBOL_GPL(disk_part_iter_exit);
     258                 :            : 
     259                 :          0 : static inline int sector_in_part(struct hd_struct *part, sector_t sector)
     260                 :            : {
     261   [ #  #  #  #  :          0 :         return part->start_sect <= sector &&
             #  #  #  # ]
     262   [ #  #  #  # ]:          0 :                 sector < part->start_sect + part_nr_sects_read(part);
     263                 :            : }
     264                 :            : 
     265                 :            : /**
     266                 :            :  * disk_map_sector_rcu - map sector to partition
     267                 :            :  * @disk: gendisk of interest
     268                 :            :  * @sector: sector to map
     269                 :            :  *
     270                 :            :  * Find out which partition @sector maps to on @disk.  This is
     271                 :            :  * primarily used for stats accounting.
     272                 :            :  *
     273                 :            :  * CONTEXT:
     274                 :            :  * RCU read locked.  The returned partition pointer is valid only
     275                 :            :  * while preemption is disabled.
     276                 :            :  *
     277                 :            :  * RETURNS:
     278                 :            :  * Found partition on success, part0 is returned if no partition matches
     279                 :            :  */
     280                 :      77435 : struct hd_struct *disk_map_sector_rcu(struct gendisk *disk, sector_t sector)
     281                 :            : {
     282                 :      77435 :         struct disk_part_tbl *ptbl;
     283                 :      77435 :         struct hd_struct *part;
     284                 :      77435 :         int i;
     285                 :            : 
     286         [ -  + ]:      77435 :         ptbl = rcu_dereference(disk->part_tbl);
     287                 :            : 
     288                 :      77435 :         part = rcu_dereference(ptbl->last_lookup);
     289         [ -  + ]:      77435 :         if (part && sector_in_part(part, sector))
     290                 :            :                 return part;
     291                 :            : 
     292         [ -  + ]:      77435 :         for (i = 1; i < ptbl->len; i++) {
     293         [ #  # ]:          0 :                 part = rcu_dereference(ptbl->part[i]);
     294                 :            : 
     295         [ #  # ]:          0 :                 if (part && sector_in_part(part, sector)) {
     296                 :          0 :                         rcu_assign_pointer(ptbl->last_lookup, part);
     297                 :          0 :                         return part;
     298                 :            :                 }
     299                 :            :         }
     300                 :      77435 :         return &disk->part0;
     301                 :            : }
     302                 :            : EXPORT_SYMBOL_GPL(disk_map_sector_rcu);
     303                 :            : 
     304                 :            : /**
     305                 :            :  * disk_has_partitions
     306                 :            :  * @disk: gendisk of interest
     307                 :            :  *
     308                 :            :  * Walk through the partition table and check if valid partition exists.
     309                 :            :  *
     310                 :            :  * CONTEXT:
     311                 :            :  * Don't care.
     312                 :            :  *
     313                 :            :  * RETURNS:
     314                 :            :  * True if the gendisk has at least one valid non-zero size partition.
     315                 :            :  * Otherwise false.
     316                 :            :  */
     317                 :          0 : bool disk_has_partitions(struct gendisk *disk)
     318                 :            : {
     319                 :          0 :         struct disk_part_tbl *ptbl;
     320                 :          0 :         int i;
     321                 :          0 :         bool ret = false;
     322                 :            : 
     323                 :          0 :         rcu_read_lock();
     324                 :          0 :         ptbl = rcu_dereference(disk->part_tbl);
     325                 :            : 
     326                 :            :         /* Iterate partitions skipping the whole device at index 0 */
     327         [ #  # ]:          0 :         for (i = 1; i < ptbl->len; i++) {
     328         [ #  # ]:          0 :                 if (rcu_dereference(ptbl->part[i])) {
     329                 :            :                         ret = true;
     330                 :            :                         break;
     331                 :            :                 }
     332                 :            :         }
     333                 :            : 
     334                 :          0 :         rcu_read_unlock();
     335                 :            : 
     336                 :          0 :         return ret;
     337                 :            : }
     338                 :            : EXPORT_SYMBOL_GPL(disk_has_partitions);
     339                 :            : 
     340                 :            : /*
     341                 :            :  * Can be deleted altogether. Later.
     342                 :            :  *
     343                 :            :  */
     344                 :            : #define BLKDEV_MAJOR_HASH_SIZE 255
     345                 :            : static struct blk_major_name {
     346                 :            :         struct blk_major_name *next;
     347                 :            :         int major;
     348                 :            :         char name[16];
     349                 :            : } *major_names[BLKDEV_MAJOR_HASH_SIZE];
     350                 :            : 
     351                 :            : /* index in the above - for now: assume no multimajor ranges */
     352                 :       1794 : static inline int major_to_index(unsigned major)
     353                 :            : {
     354                 :       1794 :         return major % BLKDEV_MAJOR_HASH_SIZE;
     355                 :            : }
     356                 :            : 
     357                 :            : #ifdef CONFIG_PROC_FS
     358                 :          0 : void blkdev_show(struct seq_file *seqf, off_t offset)
     359                 :            : {
     360                 :          0 :         struct blk_major_name *dp;
     361                 :            : 
     362                 :          0 :         mutex_lock(&block_class_lock);
     363         [ #  # ]:          0 :         for (dp = major_names[major_to_index(offset)]; dp; dp = dp->next)
     364         [ #  # ]:          0 :                 if (dp->major == offset)
     365                 :          0 :                         seq_printf(seqf, "%3d %s\n", dp->major, dp->name);
     366                 :          0 :         mutex_unlock(&block_class_lock);
     367                 :          0 : }
     368                 :            : #endif /* CONFIG_PROC_FS */
     369                 :            : 
     370                 :            : /**
     371                 :            :  * register_blkdev - register a new block device
     372                 :            :  *
     373                 :            :  * @major: the requested major device number [1..BLKDEV_MAJOR_MAX-1]. If
     374                 :            :  *         @major = 0, try to allocate any unused major number.
     375                 :            :  * @name: the name of the new block device as a zero terminated string
     376                 :            :  *
     377                 :            :  * The @name must be unique within the system.
     378                 :            :  *
     379                 :            :  * The return value depends on the @major input parameter:
     380                 :            :  *
     381                 :            :  *  - if a major device number was requested in range [1..BLKDEV_MAJOR_MAX-1]
     382                 :            :  *    then the function returns zero on success, or a negative error code
     383                 :            :  *  - if any unused major number was requested with @major = 0 parameter
     384                 :            :  *    then the return value is the allocated major number in range
     385                 :            :  *    [1..BLKDEV_MAJOR_MAX-1] or a negative error code otherwise
     386                 :            :  *
     387                 :            :  * See Documentation/admin-guide/devices.txt for the list of allocated
     388                 :            :  * major numbers.
     389                 :            :  */
     390                 :       1794 : int register_blkdev(unsigned int major, const char *name)
     391                 :            : {
     392                 :       1794 :         struct blk_major_name **n, *p;
     393                 :       1794 :         int index, ret = 0;
     394                 :            : 
     395                 :       1794 :         mutex_lock(&block_class_lock);
     396                 :            : 
     397                 :            :         /* temporary */
     398         [ +  + ]:       1794 :         if (major == 0) {
     399         [ +  - ]:        468 :                 for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
     400         [ +  + ]:        468 :                         if (major_names[index] == NULL)
     401                 :            :                                 break;
     402                 :            :                 }
     403                 :            : 
     404         [ -  + ]:        234 :                 if (index == 0) {
     405                 :          0 :                         printk("%s: failed to get major for %s\n",
     406                 :            :                                __func__, name);
     407                 :          0 :                         ret = -EBUSY;
     408                 :          0 :                         goto out;
     409                 :            :                 }
     410                 :        234 :                 major = index;
     411                 :        234 :                 ret = major;
     412                 :            :         }
     413                 :            : 
     414         [ -  + ]:       1794 :         if (major >= BLKDEV_MAJOR_MAX) {
     415                 :          0 :                 pr_err("%s: major requested (%u) is greater than the maximum (%u) for %s\n",
     416                 :            :                        __func__, major, BLKDEV_MAJOR_MAX-1, name);
     417                 :            : 
     418                 :          0 :                 ret = -EINVAL;
     419                 :          0 :                 goto out;
     420                 :            :         }
     421                 :            : 
     422                 :       1794 :         p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
     423         [ -  + ]:       1794 :         if (p == NULL) {
     424                 :          0 :                 ret = -ENOMEM;
     425                 :          0 :                 goto out;
     426                 :            :         }
     427                 :            : 
     428                 :       1794 :         p->major = major;
     429                 :       1794 :         strlcpy(p->name, name, sizeof(p->name));
     430                 :       1794 :         p->next = NULL;
     431                 :       1794 :         index = major_to_index(major);
     432                 :            : 
     433         [ -  + ]:       1794 :         for (n = &major_names[index]; *n; n = &(*n)->next) {
     434         [ #  # ]:          0 :                 if ((*n)->major == major)
     435                 :            :                         break;
     436                 :            :         }
     437         [ -  + ]:       1794 :         if (!*n)
     438                 :       1794 :                 *n = p;
     439                 :            :         else
     440                 :            :                 ret = -EBUSY;
     441                 :            : 
     442                 :       1794 :         if (ret < 0) {
     443                 :          0 :                 printk("register_blkdev: cannot get major %u for %s\n",
     444                 :            :                        major, name);
     445                 :          0 :                 kfree(p);
     446                 :            :         }
     447                 :       1794 : out:
     448                 :       1794 :         mutex_unlock(&block_class_lock);
     449                 :       1794 :         return ret;
     450                 :            : }
     451                 :            : 
     452                 :            : EXPORT_SYMBOL(register_blkdev);
     453                 :            : 
     454                 :          0 : void unregister_blkdev(unsigned int major, const char *name)
     455                 :            : {
     456                 :          0 :         struct blk_major_name **n;
     457                 :          0 :         struct blk_major_name *p = NULL;
     458                 :          0 :         int index = major_to_index(major);
     459                 :            : 
     460                 :          0 :         mutex_lock(&block_class_lock);
     461         [ #  # ]:          0 :         for (n = &major_names[index]; *n; n = &(*n)->next)
     462         [ #  # ]:          0 :                 if ((*n)->major == major)
     463                 :            :                         break;
     464   [ #  #  #  # ]:          0 :         if (!*n || strcmp((*n)->name, name)) {
     465                 :          0 :                 WARN_ON(1);
     466                 :            :         } else {
     467                 :          0 :                 p = *n;
     468                 :          0 :                 *n = p->next;
     469                 :            :         }
     470                 :          0 :         mutex_unlock(&block_class_lock);
     471                 :          0 :         kfree(p);
     472                 :          0 : }
     473                 :            : 
     474                 :            : EXPORT_SYMBOL(unregister_blkdev);
     475                 :            : 
     476                 :            : static struct kobj_map *bdev_map;
     477                 :            : 
     478                 :            : /**
     479                 :            :  * blk_mangle_minor - scatter minor numbers apart
     480                 :            :  * @minor: minor number to mangle
     481                 :            :  *
     482                 :            :  * Scatter consecutively allocated @minor number apart if MANGLE_DEVT
     483                 :            :  * is enabled.  Mangling twice gives the original value.
     484                 :            :  *
     485                 :            :  * RETURNS:
     486                 :            :  * Mangled value.
     487                 :            :  *
     488                 :            :  * CONTEXT:
     489                 :            :  * Don't care.
     490                 :            :  */
     491                 :          0 : static int blk_mangle_minor(int minor)
     492                 :            : {
     493                 :            : #ifdef CONFIG_DEBUG_BLOCK_EXT_DEVT
     494                 :            :         int i;
     495                 :            : 
     496                 :            :         for (i = 0; i < MINORBITS / 2; i++) {
     497                 :            :                 int low = minor & (1 << i);
     498                 :            :                 int high = minor & (1 << (MINORBITS - 1 - i));
     499                 :            :                 int distance = MINORBITS - 1 - 2 * i;
     500                 :            : 
     501                 :            :                 minor ^= low | high;    /* clear both bits */
     502                 :            :                 low <<= distance; /* swap the positions */
     503                 :            :                 high >>= distance;
     504                 :            :                 minor |= low | high;    /* and set */
     505                 :            :         }
     506                 :            : #endif
     507                 :          0 :         return minor;
     508                 :            : }
     509                 :            : 
     510                 :            : /**
     511                 :            :  * blk_alloc_devt - allocate a dev_t for a partition
     512                 :            :  * @part: partition to allocate dev_t for
     513                 :            :  * @devt: out parameter for resulting dev_t
     514                 :            :  *
     515                 :            :  * Allocate a dev_t for block device.
     516                 :            :  *
     517                 :            :  * RETURNS:
     518                 :            :  * 0 on success, allocated dev_t is returned in *@devt.  -errno on
     519                 :            :  * failure.
     520                 :            :  *
     521                 :            :  * CONTEXT:
     522                 :            :  * Might sleep.
     523                 :            :  */
     524                 :        936 : int blk_alloc_devt(struct hd_struct *part, dev_t *devt)
     525                 :            : {
     526         [ +  - ]:        936 :         struct gendisk *disk = part_to_disk(part);
     527                 :        936 :         int idx;
     528                 :            : 
     529                 :            :         /* in consecutive minor range? */
     530         [ +  - ]:        936 :         if (part->partno < disk->minors) {
     531                 :        936 :                 *devt = MKDEV(disk->major, disk->first_minor + part->partno);
     532                 :        936 :                 return 0;
     533                 :            :         }
     534                 :            : 
     535                 :            :         /* allocate ext devt */
     536                 :          0 :         idr_preload(GFP_KERNEL);
     537                 :            : 
     538                 :          0 :         spin_lock_bh(&ext_devt_lock);
     539                 :          0 :         idx = idr_alloc(&ext_devt_idr, part, 0, NR_EXT_DEVT, GFP_NOWAIT);
     540                 :          0 :         spin_unlock_bh(&ext_devt_lock);
     541                 :            : 
     542                 :          0 :         idr_preload_end();
     543         [ #  # ]:          0 :         if (idx < 0)
     544         [ #  # ]:          0 :                 return idx == -ENOSPC ? -EBUSY : idx;
     545                 :            : 
     546                 :          0 :         *devt = MKDEV(BLOCK_EXT_MAJOR, blk_mangle_minor(idx));
     547                 :          0 :         return 0;
     548                 :            : }
     549                 :            : 
     550                 :            : /**
     551                 :            :  * blk_free_devt - free a dev_t
     552                 :            :  * @devt: dev_t to free
     553                 :            :  *
     554                 :            :  * Free @devt which was allocated using blk_alloc_devt().
     555                 :            :  *
     556                 :            :  * CONTEXT:
     557                 :            :  * Might sleep.
     558                 :            :  */
     559                 :          0 : void blk_free_devt(dev_t devt)
     560                 :            : {
     561         [ #  # ]:          0 :         if (devt == MKDEV(0, 0))
     562                 :            :                 return;
     563                 :            : 
     564         [ #  # ]:          0 :         if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
     565                 :          0 :                 spin_lock_bh(&ext_devt_lock);
     566                 :          0 :                 idr_remove(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
     567                 :          0 :                 spin_unlock_bh(&ext_devt_lock);
     568                 :            :         }
     569                 :            : }
     570                 :            : 
     571                 :            : /*
     572                 :            :  * We invalidate devt by assigning NULL pointer for devt in idr.
     573                 :            :  */
     574                 :          0 : void blk_invalidate_devt(dev_t devt)
     575                 :            : {
     576         [ #  # ]:          0 :         if (MAJOR(devt) == BLOCK_EXT_MAJOR) {
     577                 :          0 :                 spin_lock_bh(&ext_devt_lock);
     578                 :          0 :                 idr_replace(&ext_devt_idr, NULL, blk_mangle_minor(MINOR(devt)));
     579                 :          0 :                 spin_unlock_bh(&ext_devt_lock);
     580                 :            :         }
     581                 :          0 : }
     582                 :            : 
     583                 :          0 : static char *bdevt_str(dev_t devt, char *buf)
     584                 :            : {
     585   [ #  #  #  # ]:          0 :         if (MAJOR(devt) <= 0xff && MINOR(devt) <= 0xff) {
     586                 :          0 :                 char tbuf[BDEVT_SIZE];
     587                 :          0 :                 snprintf(tbuf, BDEVT_SIZE, "%02x%02x", MAJOR(devt), MINOR(devt));
     588                 :          0 :                 snprintf(buf, BDEVT_SIZE, "%-9s", tbuf);
     589                 :            :         } else
     590                 :          0 :                 snprintf(buf, BDEVT_SIZE, "%03x:%05x", MAJOR(devt), MINOR(devt));
     591                 :            : 
     592                 :          0 :         return buf;
     593                 :            : }
     594                 :            : 
     595                 :            : /*
     596                 :            :  * Register device numbers dev..(dev+range-1)
     597                 :            :  * range must be nonzero
     598                 :            :  * The hash chain is sorted on range, so that subranges can override.
     599                 :            :  */
     600                 :       2418 : void blk_register_region(dev_t devt, unsigned long range, struct module *module,
     601                 :            :                          struct kobject *(*probe)(dev_t, int *, void *),
     602                 :            :                          int (*lock)(dev_t, void *), void *data)
     603                 :            : {
     604                 :       2418 :         kobj_map(bdev_map, devt, range, module, probe, lock, data);
     605                 :        936 : }
     606                 :            : 
     607                 :            : EXPORT_SYMBOL(blk_register_region);
     608                 :            : 
     609                 :          0 : void blk_unregister_region(dev_t devt, unsigned long range)
     610                 :            : {
     611                 :          0 :         kobj_unmap(bdev_map, devt, range);
     612                 :          0 : }
     613                 :            : 
     614                 :            : EXPORT_SYMBOL(blk_unregister_region);
     615                 :            : 
     616                 :       2964 : static struct kobject *exact_match(dev_t devt, int *partno, void *data)
     617                 :            : {
     618                 :       2964 :         struct gendisk *p = data;
     619                 :            : 
     620                 :       2964 :         return &disk_to_dev(p)->kobj;
     621                 :            : }
     622                 :            : 
     623                 :       2964 : static int exact_lock(dev_t devt, void *data)
     624                 :            : {
     625                 :       2964 :         struct gendisk *p = data;
     626                 :            : 
     627         [ -  + ]:       2964 :         if (!get_disk_and_module(p))
     628                 :          0 :                 return -1;
     629                 :            :         return 0;
     630                 :            : }
     631                 :            : 
     632                 :        936 : static void register_disk(struct device *parent, struct gendisk *disk,
     633                 :            :                           const struct attribute_group **groups)
     634                 :            : {
     635                 :        936 :         struct device *ddev = disk_to_dev(disk);
     636                 :        936 :         struct block_device *bdev;
     637                 :        936 :         struct disk_part_iter piter;
     638                 :        936 :         struct hd_struct *part;
     639                 :        936 :         int err;
     640                 :            : 
     641                 :        936 :         ddev->parent = parent;
     642                 :            : 
     643                 :        936 :         dev_set_name(ddev, "%s", disk->disk_name);
     644                 :            : 
     645                 :            :         /* delay uevents, until we scanned partition table */
     646         [ -  + ]:        936 :         dev_set_uevent_suppress(ddev, 1);
     647                 :            : 
     648         [ -  + ]:        936 :         if (groups) {
     649         [ #  # ]:          0 :                 WARN_ON(ddev->groups);
     650                 :          0 :                 ddev->groups = groups;
     651                 :            :         }
     652         [ +  - ]:        936 :         if (device_add(ddev))
     653                 :          0 :                 return;
     654                 :        936 :         if (!sysfs_deprecated) {
     655                 :        936 :                 err = sysfs_create_link(block_depr, &ddev->kobj,
     656                 :            :                                         kobject_name(&ddev->kobj));
     657         [ -  + ]:        936 :                 if (err) {
     658                 :          0 :                         device_del(ddev);
     659                 :          0 :                         return;
     660                 :            :                 }
     661                 :            :         }
     662                 :            : 
     663                 :            :         /*
     664                 :            :          * avoid probable deadlock caused by allocating memory with
     665                 :            :          * GFP_KERNEL in runtime_resume callback of its all ancestor
     666                 :            :          * devices
     667                 :            :          */
     668                 :        936 :         pm_runtime_set_memalloc_noio(ddev, true);
     669                 :            : 
     670                 :        936 :         disk->part0.holder_dir = kobject_create_and_add("holders", &ddev->kobj);
     671                 :        936 :         disk->slave_dir = kobject_create_and_add("slaves", &ddev->kobj);
     672                 :            : 
     673         [ -  + ]:        936 :         if (disk->flags & GENHD_FL_HIDDEN) {
     674                 :          0 :                 dev_set_uevent_suppress(ddev, 0);
     675                 :          0 :                 return;
     676                 :            :         }
     677                 :            : 
     678                 :            :         /* No minors to use for partitions */
     679   [ +  +  +  + ]:       1872 :         if (!disk_part_scan_enabled(disk))
     680                 :        702 :                 goto exit;
     681                 :            : 
     682                 :            :         /* No such device (e.g., media were just removed) */
     683         [ +  + ]:        234 :         if (!get_capacity(disk))
     684                 :         78 :                 goto exit;
     685                 :            : 
     686                 :        156 :         bdev = bdget_disk(disk, 0);
     687         [ -  + ]:        156 :         if (!bdev)
     688                 :          0 :                 goto exit;
     689                 :            : 
     690                 :        156 :         bdev->bd_invalidated = 1;
     691                 :        156 :         err = blkdev_get(bdev, FMODE_READ, NULL);
     692         [ -  + ]:        156 :         if (err < 0)
     693                 :          0 :                 goto exit;
     694                 :        156 :         blkdev_put(bdev, FMODE_READ);
     695                 :            : 
     696                 :        936 : exit:
     697                 :            :         /* announce disk after possible partitions are created */
     698                 :        936 :         dev_set_uevent_suppress(ddev, 0);
     699                 :        936 :         kobject_uevent(&ddev->kobj, KOBJ_ADD);
     700                 :            : 
     701                 :            :         /* announce possible partitions */
     702                 :        936 :         disk_part_iter_init(&piter, disk, 0);
     703         [ -  + ]:        936 :         while ((part = disk_part_iter_next(&piter)))
     704                 :          0 :                 kobject_uevent(&part_to_dev(part)->kobj, KOBJ_ADD);
     705         [ -  + ]:        936 :         disk_part_iter_exit(&piter);
     706                 :            : 
     707         [ +  - ]:        936 :         if (disk->queue->backing_dev_info->dev) {
     708                 :        936 :                 err = sysfs_create_link(&ddev->kobj,
     709                 :            :                           &disk->queue->backing_dev_info->dev->kobj,
     710                 :            :                           "bdi");
     711         [ -  + ]:        936 :                 WARN_ON(err);
     712                 :            :         }
     713                 :            : }
     714                 :            : 
     715                 :            : /**
     716                 :            :  * __device_add_disk - add disk information to kernel list
     717                 :            :  * @parent: parent device for the disk
     718                 :            :  * @disk: per-device partitioning information
     719                 :            :  * @groups: Additional per-device sysfs groups
     720                 :            :  * @register_queue: register the queue if set to true
     721                 :            :  *
     722                 :            :  * This function registers the partitioning information in @disk
     723                 :            :  * with the kernel.
     724                 :            :  *
     725                 :            :  * FIXME: error handling
     726                 :            :  */
     727                 :        936 : static void __device_add_disk(struct device *parent, struct gendisk *disk,
     728                 :            :                               const struct attribute_group **groups,
     729                 :            :                               bool register_queue)
     730                 :            : {
     731                 :        936 :         dev_t devt;
     732                 :        936 :         int retval;
     733                 :            : 
     734                 :            :         /*
     735                 :            :          * The disk queue should now be all set with enough information about
     736                 :            :          * the device for the elevator code to pick an adequate default
     737                 :            :          * elevator if one is needed, that is, for devices requesting queue
     738                 :            :          * registration.
     739                 :            :          */
     740         [ +  - ]:        936 :         if (register_queue)
     741                 :        936 :                 elevator_init_mq(disk->queue);
     742                 :            : 
     743                 :            :         /* minors == 0 indicates to use ext devt from part0 and should
     744                 :            :          * be accompanied with EXT_DEVT flag.  Make sure all
     745                 :            :          * parameters make sense.
     746                 :            :          */
     747   [ +  -  +  -  :       1872 :         WARN_ON(disk->minors && !(disk->major || disk->first_minor));
                   -  + ]
     748   [ -  +  -  -  :       1872 :         WARN_ON(!disk->minors &&
                   -  + ]
     749                 :            :                 !(disk->flags & (GENHD_FL_EXT_DEVT | GENHD_FL_HIDDEN)));
     750                 :            : 
     751                 :        936 :         disk->flags |= GENHD_FL_UP;
     752                 :            : 
     753                 :        936 :         retval = blk_alloc_devt(&disk->part0, &devt);
     754         [ -  + ]:        936 :         if (retval) {
     755                 :          0 :                 WARN_ON(1);
     756                 :          0 :                 return;
     757                 :            :         }
     758                 :        936 :         disk->major = MAJOR(devt);
     759                 :        936 :         disk->first_minor = MINOR(devt);
     760                 :            : 
     761                 :        936 :         disk_alloc_events(disk);
     762                 :            : 
     763         [ -  + ]:        936 :         if (disk->flags & GENHD_FL_HIDDEN) {
     764                 :            :                 /*
     765                 :            :                  * Don't let hidden disks show up in /proc/partitions,
     766                 :            :                  * and don't bother scanning for partitions either.
     767                 :            :                  */
     768                 :          0 :                 disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
     769                 :          0 :                 disk->flags |= GENHD_FL_NO_PART_SCAN;
     770                 :            :         } else {
     771                 :        936 :                 int ret;
     772                 :            : 
     773                 :            :                 /* Register BDI before referencing it from bdev */
     774                 :        936 :                 disk_to_dev(disk)->devt = devt;
     775                 :        936 :                 ret = bdi_register_owner(disk->queue->backing_dev_info,
     776                 :            :                                                 disk_to_dev(disk));
     777         [ -  + ]:        936 :                 WARN_ON(ret);
     778                 :        936 :                 blk_register_region(disk_devt(disk), disk->minors, NULL,
     779                 :            :                                     exact_match, exact_lock, disk);
     780                 :            :         }
     781                 :        936 :         register_disk(parent, disk, groups);
     782         [ +  - ]:        936 :         if (register_queue)
     783                 :        936 :                 blk_register_queue(disk);
     784                 :            : 
     785                 :            :         /*
     786                 :            :          * Take an extra ref on queue which will be put on disk_release()
     787                 :            :          * so that it sticks around as long as @disk is there.
     788                 :            :          */
     789         [ -  + ]:        936 :         WARN_ON_ONCE(!blk_get_queue(disk->queue));
     790                 :            : 
     791                 :        936 :         disk_add_events(disk);
     792                 :        936 :         blk_integrity_add(disk);
     793                 :            : }
     794                 :            : 
     795                 :        936 : void device_add_disk(struct device *parent, struct gendisk *disk,
     796                 :            :                      const struct attribute_group **groups)
     797                 :            : 
     798                 :            : {
     799                 :        936 :         __device_add_disk(parent, disk, groups, true);
     800                 :        936 : }
     801                 :            : EXPORT_SYMBOL(device_add_disk);
     802                 :            : 
     803                 :          0 : void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk)
     804                 :            : {
     805                 :          0 :         __device_add_disk(parent, disk, NULL, false);
     806                 :          0 : }
     807                 :            : EXPORT_SYMBOL(device_add_disk_no_queue_reg);
     808                 :            : 
     809                 :          0 : void del_gendisk(struct gendisk *disk)
     810                 :            : {
     811                 :          0 :         struct disk_part_iter piter;
     812                 :          0 :         struct hd_struct *part;
     813                 :            : 
     814                 :          0 :         blk_integrity_del(disk);
     815                 :          0 :         disk_del_events(disk);
     816                 :            : 
     817                 :            :         /*
     818                 :            :          * Block lookups of the disk until all bdevs are unhashed and the
     819                 :            :          * disk is marked as dead (GENHD_FL_UP cleared).
     820                 :            :          */
     821                 :          0 :         down_write(&disk->lookup_sem);
     822                 :            :         /* invalidate stuff */
     823                 :          0 :         disk_part_iter_init(&piter, disk,
     824                 :            :                              DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
     825         [ #  # ]:          0 :         while ((part = disk_part_iter_next(&piter))) {
     826                 :          0 :                 invalidate_partition(disk, part->partno);
     827                 :          0 :                 bdev_unhash_inode(part_devt(part));
     828                 :          0 :                 delete_partition(disk, part->partno);
     829                 :            :         }
     830         [ #  # ]:          0 :         disk_part_iter_exit(&piter);
     831                 :            : 
     832                 :          0 :         invalidate_partition(disk, 0);
     833                 :          0 :         bdev_unhash_inode(disk_devt(disk));
     834                 :          0 :         set_capacity(disk, 0);
     835                 :          0 :         disk->flags &= ~GENHD_FL_UP;
     836                 :          0 :         up_write(&disk->lookup_sem);
     837                 :            : 
     838         [ #  # ]:          0 :         if (!(disk->flags & GENHD_FL_HIDDEN))
     839                 :          0 :                 sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
     840         [ #  # ]:          0 :         if (disk->queue) {
     841                 :            :                 /*
     842                 :            :                  * Unregister bdi before releasing device numbers (as they can
     843                 :            :                  * get reused and we'd get clashes in sysfs).
     844                 :            :                  */
     845         [ #  # ]:          0 :                 if (!(disk->flags & GENHD_FL_HIDDEN))
     846                 :          0 :                         bdi_unregister(disk->queue->backing_dev_info);
     847                 :          0 :                 blk_unregister_queue(disk);
     848                 :            :         } else {
     849                 :          0 :                 WARN_ON(1);
     850                 :            :         }
     851                 :            : 
     852         [ #  # ]:          0 :         if (!(disk->flags & GENHD_FL_HIDDEN))
     853                 :          0 :                 blk_unregister_region(disk_devt(disk), disk->minors);
     854                 :            :         /*
     855                 :            :          * Remove gendisk pointer from idr so that it cannot be looked up
     856                 :            :          * while RCU period before freeing gendisk is running to prevent
     857                 :            :          * use-after-free issues. Note that the device number stays
     858                 :            :          * "in-use" until we really free the gendisk.
     859                 :            :          */
     860                 :          0 :         blk_invalidate_devt(disk_devt(disk));
     861                 :            : 
     862                 :          0 :         kobject_put(disk->part0.holder_dir);
     863                 :          0 :         kobject_put(disk->slave_dir);
     864                 :            : 
     865                 :          0 :         part_stat_set_all(&disk->part0, 0);
     866                 :          0 :         disk->part0.stamp = 0;
     867                 :          0 :         if (!sysfs_deprecated)
     868         [ #  # ]:          0 :                 sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
     869                 :          0 :         pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
     870                 :          0 :         device_del(disk_to_dev(disk));
     871                 :          0 : }
     872                 :            : EXPORT_SYMBOL(del_gendisk);
     873                 :            : 
     874                 :            : /* sysfs access to bad-blocks list. */
     875                 :          0 : static ssize_t disk_badblocks_show(struct device *dev,
     876                 :            :                                         struct device_attribute *attr,
     877                 :            :                                         char *page)
     878                 :            : {
     879                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
     880                 :            : 
     881         [ #  # ]:          0 :         if (!disk->bb)
     882                 :          0 :                 return sprintf(page, "\n");
     883                 :            : 
     884                 :          0 :         return badblocks_show(disk->bb, page, 0);
     885                 :            : }
     886                 :            : 
     887                 :          0 : static ssize_t disk_badblocks_store(struct device *dev,
     888                 :            :                                         struct device_attribute *attr,
     889                 :            :                                         const char *page, size_t len)
     890                 :            : {
     891                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
     892                 :            : 
     893         [ #  # ]:          0 :         if (!disk->bb)
     894                 :            :                 return -ENXIO;
     895                 :            : 
     896                 :          0 :         return badblocks_store(disk->bb, page, len, 0);
     897                 :            : }
     898                 :            : 
     899                 :            : /**
     900                 :            :  * get_gendisk - get partitioning information for a given device
     901                 :            :  * @devt: device to get partitioning information for
     902                 :            :  * @partno: returned partition index
     903                 :            :  *
     904                 :            :  * This function gets the structure containing partitioning
     905                 :            :  * information for the given device @devt.
     906                 :            :  */
     907                 :       2964 : struct gendisk *get_gendisk(dev_t devt, int *partno)
     908                 :            : {
     909                 :       2964 :         struct gendisk *disk = NULL;
     910                 :            : 
     911         [ +  - ]:       2964 :         if (MAJOR(devt) != BLOCK_EXT_MAJOR) {
     912                 :       2964 :                 struct kobject *kobj;
     913                 :            : 
     914                 :       2964 :                 kobj = kobj_lookup(bdev_map, devt, partno);
     915         [ +  - ]:       2964 :                 if (kobj)
     916                 :       2964 :                         disk = dev_to_disk(kobj_to_dev(kobj));
     917                 :            :         } else {
     918                 :          0 :                 struct hd_struct *part;
     919                 :            : 
     920                 :          0 :                 spin_lock_bh(&ext_devt_lock);
     921                 :          0 :                 part = idr_find(&ext_devt_idr, blk_mangle_minor(MINOR(devt)));
     922   [ #  #  #  # ]:          0 :                 if (part && get_disk_and_module(part_to_disk(part))) {
     923                 :          0 :                         *partno = part->partno;
     924         [ #  # ]:          0 :                         disk = part_to_disk(part);
     925                 :            :                 }
     926                 :          0 :                 spin_unlock_bh(&ext_devt_lock);
     927                 :            :         }
     928                 :            : 
     929         [ -  + ]:       2964 :         if (!disk)
     930                 :          0 :                 return NULL;
     931                 :            : 
     932                 :            :         /*
     933                 :            :          * Synchronize with del_gendisk() to not return disk that is being
     934                 :            :          * destroyed.
     935                 :            :          */
     936                 :       2964 :         down_read(&disk->lookup_sem);
     937         [ -  + ]:       2964 :         if (unlikely((disk->flags & GENHD_FL_HIDDEN) ||
     938                 :            :                      !(disk->flags & GENHD_FL_UP))) {
     939                 :          0 :                 up_read(&disk->lookup_sem);
     940                 :          0 :                 put_disk_and_module(disk);
     941                 :          0 :                 disk = NULL;
     942                 :            :         } else {
     943                 :       2964 :                 up_read(&disk->lookup_sem);
     944                 :            :         }
     945                 :            :         return disk;
     946                 :            : }
     947                 :            : EXPORT_SYMBOL(get_gendisk);
     948                 :            : 
     949                 :            : /**
     950                 :            :  * bdget_disk - do bdget() by gendisk and partition number
     951                 :            :  * @disk: gendisk of interest
     952                 :            :  * @partno: partition number
     953                 :            :  *
     954                 :            :  * Find partition @partno from @disk, do bdget() on it.
     955                 :            :  *
     956                 :            :  * CONTEXT:
     957                 :            :  * Don't care.
     958                 :            :  *
     959                 :            :  * RETURNS:
     960                 :            :  * Resulting block_device on success, NULL on failure.
     961                 :            :  */
     962                 :        312 : struct block_device *bdget_disk(struct gendisk *disk, int partno)
     963                 :            : {
     964                 :        312 :         struct hd_struct *part;
     965                 :        312 :         struct block_device *bdev = NULL;
     966                 :            : 
     967                 :        312 :         part = disk_get_part(disk, partno);
     968         [ +  - ]:        312 :         if (part)
     969                 :        312 :                 bdev = bdget(part_devt(part));
     970         [ +  - ]:        312 :         disk_put_part(part);
     971                 :            : 
     972                 :        312 :         return bdev;
     973                 :            : }
     974                 :            : EXPORT_SYMBOL(bdget_disk);
     975                 :            : 
     976                 :            : /*
     977                 :            :  * print a full list of all partitions - intended for places where the root
     978                 :            :  * filesystem can't be mounted and thus to give the victim some idea of what
     979                 :            :  * went wrong
     980                 :            :  */
     981                 :          0 : void __init printk_all_partitions(void)
     982                 :            : {
     983                 :          0 :         struct class_dev_iter iter;
     984                 :          0 :         struct device *dev;
     985                 :            : 
     986                 :          0 :         class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
     987         [ #  # ]:          0 :         while ((dev = class_dev_iter_next(&iter))) {
     988                 :          0 :                 struct gendisk *disk = dev_to_disk(dev);
     989                 :          0 :                 struct disk_part_iter piter;
     990                 :          0 :                 struct hd_struct *part;
     991                 :          0 :                 char name_buf[BDEVNAME_SIZE];
     992                 :          0 :                 char devt_buf[BDEVT_SIZE];
     993                 :            : 
     994                 :            :                 /*
     995                 :            :                  * Don't show empty devices or things that have been
     996                 :            :                  * suppressed
     997                 :            :                  */
     998         [ #  # ]:          0 :                 if (get_capacity(disk) == 0 ||
     999         [ #  # ]:          0 :                     (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
    1000                 :          0 :                         continue;
    1001                 :            : 
    1002                 :            :                 /*
    1003                 :            :                  * Note, unlike /proc/partitions, I am showing the
    1004                 :            :                  * numbers in hex - the same format as the root=
    1005                 :            :                  * option takes.
    1006                 :            :                  */
    1007                 :          0 :                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
    1008         [ #  # ]:          0 :                 while ((part = disk_part_iter_next(&piter))) {
    1009                 :          0 :                         bool is_part0 = part == &disk->part0;
    1010                 :            : 
    1011         [ #  # ]:          0 :                         printk("%s%s %10llu %s %s", is_part0 ? "" : "  ",
    1012                 :            :                                bdevt_str(part_devt(part), devt_buf),
    1013                 :          0 :                                (unsigned long long)part_nr_sects_read(part) >> 1
    1014                 :            :                                , disk_name(disk, part->partno, name_buf),
    1015         [ #  # ]:          0 :                                part->info ? part->info->uuid : "");
    1016         [ #  # ]:          0 :                         if (is_part0) {
    1017   [ #  #  #  # ]:          0 :                                 if (dev->parent && dev->parent->driver)
    1018                 :          0 :                                         printk(" driver: %s\n",
    1019                 :            :                                               dev->parent->driver->name);
    1020                 :            :                                 else
    1021                 :          0 :                                         printk(" (driver?)\n");
    1022                 :            :                         } else
    1023                 :          0 :                                 printk("\n");
    1024                 :            :                 }
    1025         [ #  # ]:          0 :                 disk_part_iter_exit(&piter);
    1026                 :            :         }
    1027                 :          0 :         class_dev_iter_exit(&iter);
    1028                 :          0 : }
    1029                 :            : 
    1030                 :            : #ifdef CONFIG_PROC_FS
    1031                 :            : /* iterator */
    1032                 :          0 : static void *disk_seqf_start(struct seq_file *seqf, loff_t *pos)
    1033                 :            : {
    1034                 :          0 :         loff_t skip = *pos;
    1035                 :          0 :         struct class_dev_iter *iter;
    1036                 :          0 :         struct device *dev;
    1037                 :            : 
    1038                 :          0 :         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
    1039         [ #  # ]:          0 :         if (!iter)
    1040                 :            :                 return ERR_PTR(-ENOMEM);
    1041                 :            : 
    1042                 :          0 :         seqf->private = iter;
    1043                 :          0 :         class_dev_iter_init(iter, &block_class, NULL, &disk_type);
    1044                 :          0 :         do {
    1045                 :          0 :                 dev = class_dev_iter_next(iter);
    1046         [ #  # ]:          0 :                 if (!dev)
    1047                 :            :                         return NULL;
    1048         [ #  # ]:          0 :         } while (skip--);
    1049                 :            : 
    1050                 :          0 :         return dev_to_disk(dev);
    1051                 :            : }
    1052                 :            : 
    1053                 :          0 : static void *disk_seqf_next(struct seq_file *seqf, void *v, loff_t *pos)
    1054                 :            : {
    1055                 :          0 :         struct device *dev;
    1056                 :            : 
    1057                 :          0 :         (*pos)++;
    1058                 :          0 :         dev = class_dev_iter_next(seqf->private);
    1059         [ #  # ]:          0 :         if (dev)
    1060                 :          0 :                 return dev_to_disk(dev);
    1061                 :            : 
    1062                 :            :         return NULL;
    1063                 :            : }
    1064                 :            : 
    1065                 :          0 : static void disk_seqf_stop(struct seq_file *seqf, void *v)
    1066                 :            : {
    1067                 :          0 :         struct class_dev_iter *iter = seqf->private;
    1068                 :            : 
    1069                 :            :         /* stop is called even after start failed :-( */
    1070         [ #  # ]:          0 :         if (iter) {
    1071                 :          0 :                 class_dev_iter_exit(iter);
    1072                 :          0 :                 kfree(iter);
    1073                 :          0 :                 seqf->private = NULL;
    1074                 :            :         }
    1075                 :          0 : }
    1076                 :            : 
    1077                 :          0 : static void *show_partition_start(struct seq_file *seqf, loff_t *pos)
    1078                 :            : {
    1079                 :          0 :         void *p;
    1080                 :            : 
    1081                 :          0 :         p = disk_seqf_start(seqf, pos);
    1082   [ #  #  #  #  :          0 :         if (!IS_ERR_OR_NULL(p) && !*pos)
                   #  # ]
    1083                 :          0 :                 seq_puts(seqf, "major minor  #blocks  name\n\n");
    1084                 :          0 :         return p;
    1085                 :            : }
    1086                 :            : 
    1087                 :          0 : static int show_partition(struct seq_file *seqf, void *v)
    1088                 :            : {
    1089                 :          0 :         struct gendisk *sgp = v;
    1090                 :          0 :         struct disk_part_iter piter;
    1091                 :          0 :         struct hd_struct *part;
    1092                 :          0 :         char buf[BDEVNAME_SIZE];
    1093                 :            : 
    1094                 :            :         /* Don't show non-partitionable removeable devices or empty devices */
    1095   [ #  #  #  #  :          0 :         if (!get_capacity(sgp) || (!disk_max_parts(sgp) &&
                   #  # ]
    1096         [ #  # ]:          0 :                                    (sgp->flags & GENHD_FL_REMOVABLE)))
    1097                 :            :                 return 0;
    1098         [ #  # ]:          0 :         if (sgp->flags & GENHD_FL_SUPPRESS_PARTITION_INFO)
    1099                 :            :                 return 0;
    1100                 :            : 
    1101                 :            :         /* show the full disk and all non-0 size partitions of it */
    1102                 :          0 :         disk_part_iter_init(&piter, sgp, DISK_PITER_INCL_PART0);
    1103         [ #  # ]:          0 :         while ((part = disk_part_iter_next(&piter)))
    1104                 :          0 :                 seq_printf(seqf, "%4d  %7d %10llu %s\n",
    1105                 :          0 :                            MAJOR(part_devt(part)), MINOR(part_devt(part)),
    1106                 :          0 :                            (unsigned long long)part_nr_sects_read(part) >> 1,
    1107                 :            :                            disk_name(sgp, part->partno, buf));
    1108         [ #  # ]:          0 :         disk_part_iter_exit(&piter);
    1109                 :            : 
    1110                 :          0 :         return 0;
    1111                 :            : }
    1112                 :            : 
    1113                 :            : static const struct seq_operations partitions_op = {
    1114                 :            :         .start  = show_partition_start,
    1115                 :            :         .next   = disk_seqf_next,
    1116                 :            :         .stop   = disk_seqf_stop,
    1117                 :            :         .show   = show_partition
    1118                 :            : };
    1119                 :            : #endif
    1120                 :            : 
    1121                 :            : 
    1122                 :          0 : static struct kobject *base_probe(dev_t devt, int *partno, void *data)
    1123                 :            : {
    1124         [ #  # ]:          0 :         if (request_module("block-major-%d-%d", MAJOR(devt), MINOR(devt)) > 0)
    1125                 :            :                 /* Make old-style 2.4 aliases work */
    1126                 :          0 :                 request_module("block-major-%d", MAJOR(devt));
    1127                 :          0 :         return NULL;
    1128                 :            : }
    1129                 :            : 
    1130                 :         78 : static int __init genhd_device_init(void)
    1131                 :            : {
    1132                 :         78 :         int error;
    1133                 :            : 
    1134                 :         78 :         block_class.dev_kobj = sysfs_dev_block_kobj;
    1135                 :         78 :         error = class_register(&block_class);
    1136         [ +  - ]:         78 :         if (unlikely(error))
    1137                 :            :                 return error;
    1138                 :         78 :         bdev_map = kobj_map_init(base_probe, &block_class_lock);
    1139                 :         78 :         blk_dev_init();
    1140                 :            : 
    1141                 :         78 :         register_blkdev(BLOCK_EXT_MAJOR, "blkext");
    1142                 :            : 
    1143                 :            :         /* create top-level block dir */
    1144                 :         78 :         if (!sysfs_deprecated)
    1145                 :         78 :                 block_depr = kobject_create_and_add("block", NULL);
    1146                 :         78 :         return 0;
    1147                 :            : }
    1148                 :            : 
    1149                 :            : subsys_initcall(genhd_device_init);
    1150                 :            : 
    1151                 :          0 : static ssize_t disk_range_show(struct device *dev,
    1152                 :            :                                struct device_attribute *attr, char *buf)
    1153                 :            : {
    1154                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1155                 :            : 
    1156                 :          0 :         return sprintf(buf, "%d\n", disk->minors);
    1157                 :            : }
    1158                 :            : 
    1159                 :          0 : static ssize_t disk_ext_range_show(struct device *dev,
    1160                 :            :                                    struct device_attribute *attr, char *buf)
    1161                 :            : {
    1162                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1163                 :            : 
    1164         [ #  # ]:          0 :         return sprintf(buf, "%d\n", disk_max_parts(disk));
    1165                 :            : }
    1166                 :            : 
    1167                 :          0 : static ssize_t disk_removable_show(struct device *dev,
    1168                 :            :                                    struct device_attribute *attr, char *buf)
    1169                 :            : {
    1170                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1171                 :            : 
    1172                 :          0 :         return sprintf(buf, "%d\n",
    1173                 :          0 :                        (disk->flags & GENHD_FL_REMOVABLE ? 1 : 0));
    1174                 :            : }
    1175                 :            : 
    1176                 :          0 : static ssize_t disk_hidden_show(struct device *dev,
    1177                 :            :                                    struct device_attribute *attr, char *buf)
    1178                 :            : {
    1179                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1180                 :            : 
    1181                 :          0 :         return sprintf(buf, "%d\n",
    1182                 :          0 :                        (disk->flags & GENHD_FL_HIDDEN ? 1 : 0));
    1183                 :            : }
    1184                 :            : 
    1185                 :          0 : static ssize_t disk_ro_show(struct device *dev,
    1186                 :            :                                    struct device_attribute *attr, char *buf)
    1187                 :            : {
    1188                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1189                 :            : 
    1190                 :          0 :         return sprintf(buf, "%d\n", get_disk_ro(disk) ? 1 : 0);
    1191                 :            : }
    1192                 :            : 
    1193                 :          0 : static ssize_t disk_capability_show(struct device *dev,
    1194                 :            :                                     struct device_attribute *attr, char *buf)
    1195                 :            : {
    1196                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1197                 :            : 
    1198                 :          0 :         return sprintf(buf, "%x\n", disk->flags);
    1199                 :            : }
    1200                 :            : 
    1201                 :          0 : static ssize_t disk_alignment_offset_show(struct device *dev,
    1202                 :            :                                           struct device_attribute *attr,
    1203                 :            :                                           char *buf)
    1204                 :            : {
    1205                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1206                 :            : 
    1207         [ #  # ]:          0 :         return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
    1208                 :            : }
    1209                 :            : 
    1210                 :          0 : static ssize_t disk_discard_alignment_show(struct device *dev,
    1211                 :            :                                            struct device_attribute *attr,
    1212                 :            :                                            char *buf)
    1213                 :            : {
    1214                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1215                 :            : 
    1216         [ #  # ]:          0 :         return sprintf(buf, "%d\n", queue_discard_alignment(disk->queue));
    1217                 :            : }
    1218                 :            : 
    1219                 :            : static DEVICE_ATTR(range, 0444, disk_range_show, NULL);
    1220                 :            : static DEVICE_ATTR(ext_range, 0444, disk_ext_range_show, NULL);
    1221                 :            : static DEVICE_ATTR(removable, 0444, disk_removable_show, NULL);
    1222                 :            : static DEVICE_ATTR(hidden, 0444, disk_hidden_show, NULL);
    1223                 :            : static DEVICE_ATTR(ro, 0444, disk_ro_show, NULL);
    1224                 :            : static DEVICE_ATTR(size, 0444, part_size_show, NULL);
    1225                 :            : static DEVICE_ATTR(alignment_offset, 0444, disk_alignment_offset_show, NULL);
    1226                 :            : static DEVICE_ATTR(discard_alignment, 0444, disk_discard_alignment_show, NULL);
    1227                 :            : static DEVICE_ATTR(capability, 0444, disk_capability_show, NULL);
    1228                 :            : static DEVICE_ATTR(stat, 0444, part_stat_show, NULL);
    1229                 :            : static DEVICE_ATTR(inflight, 0444, part_inflight_show, NULL);
    1230                 :            : static DEVICE_ATTR(badblocks, 0644, disk_badblocks_show, disk_badblocks_store);
    1231                 :            : #ifdef CONFIG_FAIL_MAKE_REQUEST
    1232                 :            : static struct device_attribute dev_attr_fail =
    1233                 :            :         __ATTR(make-it-fail, 0644, part_fail_show, part_fail_store);
    1234                 :            : #endif
    1235                 :            : #ifdef CONFIG_FAIL_IO_TIMEOUT
    1236                 :            : static struct device_attribute dev_attr_fail_timeout =
    1237                 :            :         __ATTR(io-timeout-fail, 0644, part_timeout_show, part_timeout_store);
    1238                 :            : #endif
    1239                 :            : 
    1240                 :            : static struct attribute *disk_attrs[] = {
    1241                 :            :         &dev_attr_range.attr,
    1242                 :            :         &dev_attr_ext_range.attr,
    1243                 :            :         &dev_attr_removable.attr,
    1244                 :            :         &dev_attr_hidden.attr,
    1245                 :            :         &dev_attr_ro.attr,
    1246                 :            :         &dev_attr_size.attr,
    1247                 :            :         &dev_attr_alignment_offset.attr,
    1248                 :            :         &dev_attr_discard_alignment.attr,
    1249                 :            :         &dev_attr_capability.attr,
    1250                 :            :         &dev_attr_stat.attr,
    1251                 :            :         &dev_attr_inflight.attr,
    1252                 :            :         &dev_attr_badblocks.attr,
    1253                 :            : #ifdef CONFIG_FAIL_MAKE_REQUEST
    1254                 :            :         &dev_attr_fail.attr,
    1255                 :            : #endif
    1256                 :            : #ifdef CONFIG_FAIL_IO_TIMEOUT
    1257                 :            :         &dev_attr_fail_timeout.attr,
    1258                 :            : #endif
    1259                 :            :         NULL
    1260                 :            : };
    1261                 :            : 
    1262                 :      11232 : static umode_t disk_visible(struct kobject *kobj, struct attribute *a, int n)
    1263                 :            : {
    1264                 :      11232 :         struct device *dev = container_of(kobj, typeof(*dev), kobj);
    1265                 :      11232 :         struct gendisk *disk = dev_to_disk(dev);
    1266                 :            : 
    1267   [ +  +  -  + ]:      11232 :         if (a == &dev_attr_badblocks.attr && !disk->bb)
    1268                 :            :                 return 0;
    1269                 :      10296 :         return a->mode;
    1270                 :            : }
    1271                 :            : 
    1272                 :            : static struct attribute_group disk_attr_group = {
    1273                 :            :         .attrs = disk_attrs,
    1274                 :            :         .is_visible = disk_visible,
    1275                 :            : };
    1276                 :            : 
    1277                 :            : static const struct attribute_group *disk_attr_groups[] = {
    1278                 :            :         &disk_attr_group,
    1279                 :            :         NULL
    1280                 :            : };
    1281                 :            : 
    1282                 :            : /**
    1283                 :            :  * disk_replace_part_tbl - replace disk->part_tbl in RCU-safe way
    1284                 :            :  * @disk: disk to replace part_tbl for
    1285                 :            :  * @new_ptbl: new part_tbl to install
    1286                 :            :  *
    1287                 :            :  * Replace disk->part_tbl with @new_ptbl in RCU-safe way.  The
    1288                 :            :  * original ptbl is freed using RCU callback.
    1289                 :            :  *
    1290                 :            :  * LOCKING:
    1291                 :            :  * Matching bd_mutex locked or the caller is the only user of @disk.
    1292                 :            :  */
    1293                 :       1170 : static void disk_replace_part_tbl(struct gendisk *disk,
    1294                 :            :                                   struct disk_part_tbl *new_ptbl)
    1295                 :            : {
    1296                 :       1170 :         struct disk_part_tbl *old_ptbl =
    1297                 :       1170 :                 rcu_dereference_protected(disk->part_tbl, 1);
    1298                 :            : 
    1299   [ -  -  -  + ]:       1170 :         rcu_assign_pointer(disk->part_tbl, new_ptbl);
    1300                 :            : 
    1301   [ -  -  -  + ]:       1170 :         if (old_ptbl) {
    1302                 :          0 :                 rcu_assign_pointer(old_ptbl->last_lookup, NULL);
    1303                 :          0 :                 kfree_rcu(old_ptbl, rcu_head);
    1304                 :            :         }
    1305                 :            : }
    1306                 :            : 
    1307                 :            : /**
    1308                 :            :  * disk_expand_part_tbl - expand disk->part_tbl
    1309                 :            :  * @disk: disk to expand part_tbl for
    1310                 :            :  * @partno: expand such that this partno can fit in
    1311                 :            :  *
    1312                 :            :  * Expand disk->part_tbl such that @partno can fit in.  disk->part_tbl
    1313                 :            :  * uses RCU to allow unlocked dereferencing for stats and other stuff.
    1314                 :            :  *
    1315                 :            :  * LOCKING:
    1316                 :            :  * Matching bd_mutex locked or the caller is the only user of @disk.
    1317                 :            :  * Might sleep.
    1318                 :            :  *
    1319                 :            :  * RETURNS:
    1320                 :            :  * 0 on success, -errno on failure.
    1321                 :            :  */
    1322                 :       1170 : int disk_expand_part_tbl(struct gendisk *disk, int partno)
    1323                 :            : {
    1324                 :       1170 :         struct disk_part_tbl *old_ptbl =
    1325                 :       1170 :                 rcu_dereference_protected(disk->part_tbl, 1);
    1326                 :       1170 :         struct disk_part_tbl *new_ptbl;
    1327         [ -  + ]:       1170 :         int len = old_ptbl ? old_ptbl->len : 0;
    1328                 :       1170 :         int i, target;
    1329                 :            : 
    1330                 :            :         /*
    1331                 :            :          * check for int overflow, since we can get here from blkpg_ioctl()
    1332                 :            :          * with a user passed 'partno'.
    1333                 :            :          */
    1334                 :       1170 :         target = partno + 1;
    1335         [ +  - ]:       1170 :         if (target < 0)
    1336                 :            :                 return -EINVAL;
    1337                 :            : 
    1338                 :            :         /* disk_max_parts() is zero during initialization, ignore if so */
    1339   [ +  -  -  +  :       1170 :         if (disk_max_parts(disk) && target > disk_max_parts(disk))
                   -  - ]
    1340                 :            :                 return -EINVAL;
    1341                 :            : 
    1342         [ +  - ]:       1170 :         if (target <= len)
    1343                 :            :                 return 0;
    1344                 :            : 
    1345         [ -  + ]:       1170 :         new_ptbl = kzalloc_node(struct_size(new_ptbl, part, target), GFP_KERNEL,
    1346                 :            :                                 disk->node_id);
    1347         [ +  - ]:       1170 :         if (!new_ptbl)
    1348                 :            :                 return -ENOMEM;
    1349                 :            : 
    1350                 :       1170 :         new_ptbl->len = target;
    1351                 :            : 
    1352         [ -  + ]:       1170 :         for (i = 0; i < len; i++)
    1353                 :          0 :                 rcu_assign_pointer(new_ptbl->part[i], old_ptbl->part[i]);
    1354                 :            : 
    1355                 :       1170 :         disk_replace_part_tbl(disk, new_ptbl);
    1356                 :            :         return 0;
    1357                 :            : }
    1358                 :            : 
    1359                 :          0 : static void disk_release(struct device *dev)
    1360                 :            : {
    1361                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1362                 :            : 
    1363                 :          0 :         blk_free_devt(dev->devt);
    1364                 :          0 :         disk_release_events(disk);
    1365                 :          0 :         kfree(disk->random);
    1366                 :          0 :         disk_replace_part_tbl(disk, NULL);
    1367                 :          0 :         hd_free_part(&disk->part0);
    1368         [ #  # ]:          0 :         if (disk->queue)
    1369                 :          0 :                 blk_put_queue(disk->queue);
    1370                 :          0 :         kfree(disk);
    1371                 :          0 : }
    1372                 :            : struct class block_class = {
    1373                 :            :         .name           = "block",
    1374                 :            : };
    1375                 :            : 
    1376                 :       5304 : static char *block_devnode(struct device *dev, umode_t *mode,
    1377                 :            :                            kuid_t *uid, kgid_t *gid)
    1378                 :            : {
    1379                 :       5304 :         struct gendisk *disk = dev_to_disk(dev);
    1380                 :            : 
    1381         [ -  + ]:       5304 :         if (disk->devnode)
    1382                 :          0 :                 return disk->devnode(disk, mode);
    1383                 :            :         return NULL;
    1384                 :            : }
    1385                 :            : 
    1386                 :            : static const struct device_type disk_type = {
    1387                 :            :         .name           = "disk",
    1388                 :            :         .groups         = disk_attr_groups,
    1389                 :            :         .release        = disk_release,
    1390                 :            :         .devnode        = block_devnode,
    1391                 :            : };
    1392                 :            : 
    1393                 :            : #ifdef CONFIG_PROC_FS
    1394                 :            : /*
    1395                 :            :  * aggregate disk stat collector.  Uses the same stats that the sysfs
    1396                 :            :  * entries do, above, but makes them available through one seq_file.
    1397                 :            :  *
    1398                 :            :  * The output looks suspiciously like /proc/partitions with a bunch of
    1399                 :            :  * extra fields.
    1400                 :            :  */
    1401                 :          0 : static int diskstats_show(struct seq_file *seqf, void *v)
    1402                 :            : {
    1403                 :          0 :         struct gendisk *gp = v;
    1404                 :          0 :         struct disk_part_iter piter;
    1405                 :          0 :         struct hd_struct *hd;
    1406                 :          0 :         char buf[BDEVNAME_SIZE];
    1407                 :          0 :         unsigned int inflight;
    1408                 :            : 
    1409                 :            :         /*
    1410                 :            :         if (&disk_to_dev(gp)->kobj.entry == block_class.devices.next)
    1411                 :            :                 seq_puts(seqf,  "major minor name"
    1412                 :            :                                 "     rio rmerge rsect ruse wio wmerge "
    1413                 :            :                                 "wsect wuse running use aveq"
    1414                 :            :                                 "\n\n");
    1415                 :            :         */
    1416                 :            : 
    1417                 :          0 :         disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0);
    1418         [ #  # ]:          0 :         while ((hd = disk_part_iter_next(&piter))) {
    1419                 :          0 :                 inflight = part_in_flight(gp->queue, hd);
    1420                 :          0 :                 seq_printf(seqf, "%4d %7d %s "
    1421                 :            :                            "%lu %lu %lu %u "
    1422                 :            :                            "%lu %lu %lu %u "
    1423                 :            :                            "%u %u %u "
    1424                 :            :                            "%lu %lu %lu %u "
    1425                 :            :                            "%lu %u"
    1426                 :            :                            "\n",
    1427                 :          0 :                            MAJOR(part_devt(hd)), MINOR(part_devt(hd)),
    1428                 :            :                            disk_name(gp, hd->partno, buf),
    1429         [ #  # ]:          0 :                            part_stat_read(hd, ios[STAT_READ]),
    1430         [ #  # ]:          0 :                            part_stat_read(hd, merges[STAT_READ]),
    1431         [ #  # ]:          0 :                            part_stat_read(hd, sectors[STAT_READ]),
    1432         [ #  # ]:          0 :                            (unsigned int)part_stat_read_msecs(hd, STAT_READ),
    1433         [ #  # ]:          0 :                            part_stat_read(hd, ios[STAT_WRITE]),
    1434         [ #  # ]:          0 :                            part_stat_read(hd, merges[STAT_WRITE]),
    1435         [ #  # ]:          0 :                            part_stat_read(hd, sectors[STAT_WRITE]),
    1436         [ #  # ]:          0 :                            (unsigned int)part_stat_read_msecs(hd, STAT_WRITE),
    1437                 :            :                            inflight,
    1438         [ #  # ]:          0 :                            jiffies_to_msecs(part_stat_read(hd, io_ticks)),
    1439         [ #  # ]:          0 :                            jiffies_to_msecs(part_stat_read(hd, time_in_queue)),
    1440         [ #  # ]:          0 :                            part_stat_read(hd, ios[STAT_DISCARD]),
    1441         [ #  # ]:          0 :                            part_stat_read(hd, merges[STAT_DISCARD]),
    1442         [ #  # ]:          0 :                            part_stat_read(hd, sectors[STAT_DISCARD]),
    1443         [ #  # ]:          0 :                            (unsigned int)part_stat_read_msecs(hd, STAT_DISCARD),
    1444         [ #  # ]:          0 :                            part_stat_read(hd, ios[STAT_FLUSH]),
    1445         [ #  # ]:          0 :                            (unsigned int)part_stat_read_msecs(hd, STAT_FLUSH)
    1446                 :            :                         );
    1447                 :            :         }
    1448         [ #  # ]:          0 :         disk_part_iter_exit(&piter);
    1449                 :            : 
    1450                 :          0 :         return 0;
    1451                 :            : }
    1452                 :            : 
    1453                 :            : static const struct seq_operations diskstats_op = {
    1454                 :            :         .start  = disk_seqf_start,
    1455                 :            :         .next   = disk_seqf_next,
    1456                 :            :         .stop   = disk_seqf_stop,
    1457                 :            :         .show   = diskstats_show
    1458                 :            : };
    1459                 :            : 
    1460                 :         78 : static int __init proc_genhd_init(void)
    1461                 :            : {
    1462                 :         78 :         proc_create_seq("diskstats", 0, NULL, &diskstats_op);
    1463                 :         78 :         proc_create_seq("partitions", 0, NULL, &partitions_op);
    1464                 :         78 :         return 0;
    1465                 :            : }
    1466                 :            : module_init(proc_genhd_init);
    1467                 :            : #endif /* CONFIG_PROC_FS */
    1468                 :            : 
    1469                 :         78 : dev_t blk_lookup_devt(const char *name, int partno)
    1470                 :            : {
    1471                 :         78 :         dev_t devt = MKDEV(0, 0);
    1472                 :         78 :         struct class_dev_iter iter;
    1473                 :         78 :         struct device *dev;
    1474                 :            : 
    1475                 :         78 :         class_dev_iter_init(&iter, &block_class, NULL, &disk_type);
    1476         [ +  - ]:        702 :         while ((dev = class_dev_iter_next(&iter))) {
    1477                 :        702 :                 struct gendisk *disk = dev_to_disk(dev);
    1478                 :        702 :                 struct hd_struct *part;
    1479                 :            : 
    1480   [ +  -  +  + ]:       1404 :                 if (strcmp(dev_name(dev), name))
    1481                 :        624 :                         continue;
    1482                 :            : 
    1483         [ +  - ]:         78 :                 if (partno < disk->minors) {
    1484                 :            :                         /* We need to return the right devno, even
    1485                 :            :                          * if the partition doesn't exist yet.
    1486                 :            :                          */
    1487                 :         78 :                         devt = MKDEV(MAJOR(dev->devt),
    1488                 :            :                                      MINOR(dev->devt) + partno);
    1489                 :         78 :                         break;
    1490                 :            :                 }
    1491                 :          0 :                 part = disk_get_part(disk, partno);
    1492         [ #  # ]:          0 :                 if (part) {
    1493                 :          0 :                         devt = part_devt(part);
    1494                 :          0 :                         disk_put_part(part);
    1495                 :            :                         break;
    1496                 :            :                 }
    1497                 :            :                 disk_put_part(part);
    1498                 :            :         }
    1499                 :         78 :         class_dev_iter_exit(&iter);
    1500                 :         78 :         return devt;
    1501                 :            : }
    1502                 :            : EXPORT_SYMBOL(blk_lookup_devt);
    1503                 :            : 
    1504                 :       1170 : struct gendisk *__alloc_disk_node(int minors, int node_id)
    1505                 :            : {
    1506                 :       1170 :         struct gendisk *disk;
    1507                 :       1170 :         struct disk_part_tbl *ptbl;
    1508                 :            : 
    1509         [ -  + ]:       1170 :         if (minors > DISK_MAX_PARTS) {
    1510                 :          0 :                 printk(KERN_ERR
    1511                 :            :                         "block: can't allocate more than %d partitions\n",
    1512                 :            :                         DISK_MAX_PARTS);
    1513                 :          0 :                 minors = DISK_MAX_PARTS;
    1514                 :            :         }
    1515                 :            : 
    1516                 :       1170 :         disk = kzalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);
    1517         [ +  - ]:       1170 :         if (disk) {
    1518                 :       1170 :                 if (!init_part_stats(&disk->part0)) {
    1519                 :          0 :                         kfree(disk);
    1520                 :          0 :                         return NULL;
    1521                 :            :                 }
    1522                 :       1170 :                 init_rwsem(&disk->lookup_sem);
    1523                 :       1170 :                 disk->node_id = node_id;
    1524         [ -  + ]:       1170 :                 if (disk_expand_part_tbl(disk, 0)) {
    1525                 :          0 :                         free_part_stats(&disk->part0);
    1526                 :          0 :                         kfree(disk);
    1527                 :          0 :                         return NULL;
    1528                 :            :                 }
    1529                 :       1170 :                 ptbl = rcu_dereference_protected(disk->part_tbl, 1);
    1530                 :       1170 :                 rcu_assign_pointer(ptbl->part[0], &disk->part0);
    1531                 :            : 
    1532                 :            :                 /*
    1533                 :            :                  * set_capacity() and get_capacity() currently don't use
    1534                 :            :                  * seqcounter to read/update the part0->nr_sects. Still init
    1535                 :            :                  * the counter as we can read the sectors in IO submission
    1536                 :            :                  * patch using seqence counters.
    1537                 :            :                  *
    1538                 :            :                  * TODO: Ideally set_capacity() and get_capacity() should be
    1539                 :            :                  * converted to make use of bd_mutex and sequence counters.
    1540                 :            :                  */
    1541                 :       1170 :                 seqcount_init(&disk->part0.nr_sects_seq);
    1542                 :       1170 :                 if (hd_ref_init(&disk->part0)) {
    1543                 :          0 :                         hd_free_part(&disk->part0);
    1544                 :          0 :                         kfree(disk);
    1545                 :          0 :                         return NULL;
    1546                 :            :                 }
    1547                 :            : 
    1548                 :       1170 :                 disk->minors = minors;
    1549                 :       1170 :                 rand_initialize_disk(disk);
    1550                 :       1170 :                 disk_to_dev(disk)->class = &block_class;
    1551                 :       1170 :                 disk_to_dev(disk)->type = &disk_type;
    1552                 :       1170 :                 device_initialize(disk_to_dev(disk));
    1553                 :            :         }
    1554                 :            :         return disk;
    1555                 :            : }
    1556                 :            : EXPORT_SYMBOL(__alloc_disk_node);
    1557                 :            : 
    1558                 :       2964 : struct kobject *get_disk_and_module(struct gendisk *disk)
    1559                 :            : {
    1560                 :       2964 :         struct module *owner;
    1561                 :       2964 :         struct kobject *kobj;
    1562                 :            : 
    1563         [ +  - ]:       2964 :         if (!disk->fops)
    1564                 :            :                 return NULL;
    1565                 :       2964 :         owner = disk->fops->owner;
    1566   [ -  +  -  - ]:       2964 :         if (owner && !try_module_get(owner))
    1567                 :            :                 return NULL;
    1568                 :       2964 :         kobj = kobject_get_unless_zero(&disk_to_dev(disk)->kobj);
    1569         [ -  + ]:       2964 :         if (kobj == NULL) {
    1570                 :          0 :                 module_put(owner);
    1571                 :          0 :                 return NULL;
    1572                 :            :         }
    1573                 :            :         return kobj;
    1574                 :            : 
    1575                 :            : }
    1576                 :            : EXPORT_SYMBOL(get_disk_and_module);
    1577                 :            : 
    1578                 :       2808 : void put_disk(struct gendisk *disk)
    1579                 :            : {
    1580         [ #  # ]:          0 :         if (disk)
    1581                 :          0 :                 kobject_put(&disk_to_dev(disk)->kobj);
    1582                 :          0 : }
    1583                 :            : EXPORT_SYMBOL(put_disk);
    1584                 :            : 
    1585                 :            : /*
    1586                 :            :  * This is a counterpart of get_disk_and_module() and thus also of
    1587                 :            :  * get_gendisk().
    1588                 :            :  */
    1589                 :       2808 : void put_disk_and_module(struct gendisk *disk)
    1590                 :            : {
    1591         [ +  - ]:       2808 :         if (disk) {
    1592                 :       2808 :                 struct module *owner = disk->fops->owner;
    1593                 :            : 
    1594                 :       2808 :                 put_disk(disk);
    1595                 :       2808 :                 module_put(owner);
    1596                 :            :         }
    1597                 :       2808 : }
    1598                 :            : EXPORT_SYMBOL(put_disk_and_module);
    1599                 :            : 
    1600                 :          0 : static void set_disk_ro_uevent(struct gendisk *gd, int ro)
    1601                 :            : {
    1602                 :          0 :         char event[] = "DISK_RO=1";
    1603                 :          0 :         char *envp[] = { event, NULL };
    1604                 :            : 
    1605         [ #  # ]:          0 :         if (!ro)
    1606                 :          0 :                 event[8] = '0';
    1607                 :          0 :         kobject_uevent_env(&disk_to_dev(gd)->kobj, KOBJ_CHANGE, envp);
    1608                 :          0 : }
    1609                 :            : 
    1610                 :          0 : void set_device_ro(struct block_device *bdev, int flag)
    1611                 :            : {
    1612                 :          0 :         bdev->bd_part->policy = flag;
    1613                 :          0 : }
    1614                 :            : 
    1615                 :            : EXPORT_SYMBOL(set_device_ro);
    1616                 :            : 
    1617                 :        936 : void set_disk_ro(struct gendisk *disk, int flag)
    1618                 :            : {
    1619                 :        936 :         struct disk_part_iter piter;
    1620                 :        936 :         struct hd_struct *part;
    1621                 :            : 
    1622         [ -  + ]:        936 :         if (disk->part0.policy != flag) {
    1623                 :          0 :                 set_disk_ro_uevent(disk, flag);
    1624                 :          0 :                 disk->part0.policy = flag;
    1625                 :            :         }
    1626                 :            : 
    1627                 :        936 :         disk_part_iter_init(&piter, disk, DISK_PITER_INCL_EMPTY);
    1628         [ -  + ]:        936 :         while ((part = disk_part_iter_next(&piter)))
    1629                 :          0 :                 part->policy = flag;
    1630         [ -  + ]:        936 :         disk_part_iter_exit(&piter);
    1631                 :        936 : }
    1632                 :            : 
    1633                 :            : EXPORT_SYMBOL(set_disk_ro);
    1634                 :            : 
    1635                 :        468 : int bdev_read_only(struct block_device *bdev)
    1636                 :            : {
    1637         [ +  + ]:        468 :         if (!bdev)
    1638                 :            :                 return 0;
    1639                 :        312 :         return bdev->bd_part->policy;
    1640                 :            : }
    1641                 :            : 
    1642                 :            : EXPORT_SYMBOL(bdev_read_only);
    1643                 :            : 
    1644                 :        156 : int invalidate_partition(struct gendisk *disk, int partno)
    1645                 :            : {
    1646                 :        156 :         int res = 0;
    1647                 :        156 :         struct block_device *bdev = bdget_disk(disk, partno);
    1648         [ +  - ]:        156 :         if (bdev) {
    1649                 :        156 :                 fsync_bdev(bdev);
    1650                 :        156 :                 res = __invalidate_device(bdev, true);
    1651                 :        156 :                 bdput(bdev);
    1652                 :            :         }
    1653                 :        156 :         return res;
    1654                 :            : }
    1655                 :            : 
    1656                 :            : EXPORT_SYMBOL(invalidate_partition);
    1657                 :            : 
    1658                 :            : /*
    1659                 :            :  * Disk events - monitor disk events like media change and eject request.
    1660                 :            :  */
    1661                 :            : struct disk_events {
    1662                 :            :         struct list_head        node;           /* all disk_event's */
    1663                 :            :         struct gendisk          *disk;          /* the associated disk */
    1664                 :            :         spinlock_t              lock;
    1665                 :            : 
    1666                 :            :         struct mutex            block_mutex;    /* protects blocking */
    1667                 :            :         int                     block;          /* event blocking depth */
    1668                 :            :         unsigned int            pending;        /* events already sent out */
    1669                 :            :         unsigned int            clearing;       /* events being cleared */
    1670                 :            : 
    1671                 :            :         long                    poll_msecs;     /* interval, -1 for default */
    1672                 :            :         struct delayed_work     dwork;
    1673                 :            : };
    1674                 :            : 
    1675                 :            : static const char *disk_events_strs[] = {
    1676                 :            :         [ilog2(DISK_EVENT_MEDIA_CHANGE)]        = "media_change",
    1677                 :            :         [ilog2(DISK_EVENT_EJECT_REQUEST)]       = "eject_request",
    1678                 :            : };
    1679                 :            : 
    1680                 :            : static char *disk_uevents[] = {
    1681                 :            :         [ilog2(DISK_EVENT_MEDIA_CHANGE)]        = "DISK_MEDIA_CHANGE=1",
    1682                 :            :         [ilog2(DISK_EVENT_EJECT_REQUEST)]       = "DISK_EJECT_REQUEST=1",
    1683                 :            : };
    1684                 :            : 
    1685                 :            : /* list of all disk_events */
    1686                 :            : static DEFINE_MUTEX(disk_events_mutex);
    1687                 :            : static LIST_HEAD(disk_events);
    1688                 :            : 
    1689                 :            : /* disable in-kernel polling by default */
    1690                 :            : static unsigned long disk_events_dfl_poll_msecs;
    1691                 :            : 
    1692                 :            : static unsigned long disk_events_poll_jiffies(struct gendisk *disk)
    1693                 :            : {
    1694                 :            :         struct disk_events *ev = disk->ev;
    1695                 :            :         long intv_msecs = 0;
    1696                 :            : 
    1697                 :            :         /*
    1698                 :            :          * If device-specific poll interval is set, always use it.  If
    1699                 :            :          * the default is being used, poll if the POLL flag is set.
    1700                 :            :          */
    1701                 :            :         if (ev->poll_msecs >= 0)
    1702                 :            :                 intv_msecs = ev->poll_msecs;
    1703                 :            :         else if (disk->event_flags & DISK_EVENT_FLAG_POLL)
    1704                 :            :                 intv_msecs = disk_events_dfl_poll_msecs;
    1705                 :            : 
    1706                 :            :         return msecs_to_jiffies(intv_msecs);
    1707                 :            : }
    1708                 :            : 
    1709                 :            : /**
    1710                 :            :  * disk_block_events - block and flush disk event checking
    1711                 :            :  * @disk: disk to block events for
    1712                 :            :  *
    1713                 :            :  * On return from this function, it is guaranteed that event checking
    1714                 :            :  * isn't in progress and won't happen until unblocked by
    1715                 :            :  * disk_unblock_events().  Events blocking is counted and the actual
    1716                 :            :  * unblocking happens after the matching number of unblocks are done.
    1717                 :            :  *
    1718                 :            :  * Note that this intentionally does not block event checking from
    1719                 :            :  * disk_clear_events().
    1720                 :            :  *
    1721                 :            :  * CONTEXT:
    1722                 :            :  * Might sleep.
    1723                 :            :  */
    1724                 :       2808 : void disk_block_events(struct gendisk *disk)
    1725                 :            : {
    1726                 :       2808 :         struct disk_events *ev = disk->ev;
    1727                 :       2808 :         unsigned long flags;
    1728                 :       2808 :         bool cancel;
    1729                 :            : 
    1730         [ +  + ]:       2808 :         if (!ev)
    1731                 :            :                 return;
    1732                 :            : 
    1733                 :            :         /*
    1734                 :            :          * Outer mutex ensures that the first blocker completes canceling
    1735                 :            :          * the event work before further blockers are allowed to finish.
    1736                 :            :          */
    1737                 :        468 :         mutex_lock(&ev->block_mutex);
    1738                 :            : 
    1739                 :        468 :         spin_lock_irqsave(&ev->lock, flags);
    1740                 :        468 :         cancel = !ev->block++;
    1741                 :        468 :         spin_unlock_irqrestore(&ev->lock, flags);
    1742                 :            : 
    1743         [ +  + ]:        468 :         if (cancel)
    1744                 :        234 :                 cancel_delayed_work_sync(&disk->ev->dwork);
    1745                 :            : 
    1746                 :        468 :         mutex_unlock(&ev->block_mutex);
    1747                 :            : }
    1748                 :            : 
    1749                 :        546 : static void __disk_unblock_events(struct gendisk *disk, bool check_now)
    1750                 :            : {
    1751                 :        546 :         struct disk_events *ev = disk->ev;
    1752                 :        546 :         unsigned long intv;
    1753                 :        546 :         unsigned long flags;
    1754                 :            : 
    1755                 :        546 :         spin_lock_irqsave(&ev->lock, flags);
    1756                 :            : 
    1757   [ -  +  -  + ]:        546 :         if (WARN_ON_ONCE(ev->block <= 0))
    1758                 :          0 :                 goto out_unlock;
    1759                 :            : 
    1760         [ +  + ]:        546 :         if (--ev->block)
    1761                 :        234 :                 goto out_unlock;
    1762                 :            : 
    1763                 :        312 :         intv = disk_events_poll_jiffies(disk);
    1764         [ +  + ]:        312 :         if (check_now)
    1765                 :         78 :                 queue_delayed_work(system_freezable_power_efficient_wq,
    1766                 :            :                                 &ev->dwork, 0);
    1767         [ -  + ]:        234 :         else if (intv)
    1768                 :        234 :                 queue_delayed_work(system_freezable_power_efficient_wq,
    1769                 :            :                                 &ev->dwork, intv);
    1770                 :          0 : out_unlock:
    1771                 :        546 :         spin_unlock_irqrestore(&ev->lock, flags);
    1772                 :        546 : }
    1773                 :            : 
    1774                 :            : /**
    1775                 :            :  * disk_unblock_events - unblock disk event checking
    1776                 :            :  * @disk: disk to unblock events for
    1777                 :            :  *
    1778                 :            :  * Undo disk_block_events().  When the block count reaches zero, it
    1779                 :            :  * starts events polling if configured.
    1780                 :            :  *
    1781                 :            :  * CONTEXT:
    1782                 :            :  * Don't care.  Safe to call from irq context.
    1783                 :            :  */
    1784                 :       2574 : void disk_unblock_events(struct gendisk *disk)
    1785                 :            : {
    1786         [ +  + ]:       2574 :         if (disk->ev)
    1787                 :        234 :                 __disk_unblock_events(disk, false);
    1788                 :       2574 : }
    1789                 :            : 
    1790                 :            : /**
    1791                 :            :  * disk_flush_events - schedule immediate event checking and flushing
    1792                 :            :  * @disk: disk to check and flush events for
    1793                 :            :  * @mask: events to flush
    1794                 :            :  *
    1795                 :            :  * Schedule immediate event checking on @disk if not blocked.  Events in
    1796                 :            :  * @mask are scheduled to be cleared from the driver.  Note that this
    1797                 :            :  * doesn't clear the events from @disk->ev.
    1798                 :            :  *
    1799                 :            :  * CONTEXT:
    1800                 :            :  * If @mask is non-zero must be called with bdev->bd_mutex held.
    1801                 :            :  */
    1802                 :       2496 : void disk_flush_events(struct gendisk *disk, unsigned int mask)
    1803                 :            : {
    1804                 :       2496 :         struct disk_events *ev = disk->ev;
    1805                 :            : 
    1806         [ +  + ]:       2496 :         if (!ev)
    1807                 :            :                 return;
    1808                 :            : 
    1809                 :        312 :         spin_lock_irq(&ev->lock);
    1810                 :        312 :         ev->clearing |= mask;
    1811         [ +  - ]:        312 :         if (!ev->block)
    1812                 :        312 :                 mod_delayed_work(system_freezable_power_efficient_wq,
    1813                 :            :                                 &ev->dwork, 0);
    1814                 :        312 :         spin_unlock_irq(&ev->lock);
    1815                 :            : }
    1816                 :            : 
    1817                 :            : /**
    1818                 :            :  * disk_clear_events - synchronously check, clear and return pending events
    1819                 :            :  * @disk: disk to fetch and clear events from
    1820                 :            :  * @mask: mask of events to be fetched and cleared
    1821                 :            :  *
    1822                 :            :  * Disk events are synchronously checked and pending events in @mask
    1823                 :            :  * are cleared and returned.  This ignores the block count.
    1824                 :            :  *
    1825                 :            :  * CONTEXT:
    1826                 :            :  * Might sleep.
    1827                 :            :  */
    1828                 :        312 : unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask)
    1829                 :            : {
    1830                 :        312 :         const struct block_device_operations *bdops = disk->fops;
    1831                 :        312 :         struct disk_events *ev = disk->ev;
    1832                 :        312 :         unsigned int pending;
    1833                 :        312 :         unsigned int clearing = mask;
    1834                 :            : 
    1835         [ +  + ]:        312 :         if (!ev) {
    1836                 :            :                 /* for drivers still using the old ->media_changed method */
    1837         [ +  - ]:         78 :                 if ((mask & DISK_EVENT_MEDIA_CHANGE) &&
    1838   [ +  -  +  - ]:         78 :                     bdops->media_changed && bdops->media_changed(disk))
    1839                 :            :                         return DISK_EVENT_MEDIA_CHANGE;
    1840                 :         78 :                 return 0;
    1841                 :            :         }
    1842                 :            : 
    1843                 :        234 :         disk_block_events(disk);
    1844                 :            : 
    1845                 :            :         /*
    1846                 :            :          * store the union of mask and ev->clearing on the stack so that the
    1847                 :            :          * race with disk_flush_events does not cause ambiguity (ev->clearing
    1848                 :            :          * can still be modified even if events are blocked).
    1849                 :            :          */
    1850                 :        234 :         spin_lock_irq(&ev->lock);
    1851                 :        234 :         clearing |= ev->clearing;
    1852                 :        234 :         ev->clearing = 0;
    1853                 :        234 :         spin_unlock_irq(&ev->lock);
    1854                 :            : 
    1855                 :        234 :         disk_check_events(ev, &clearing);
    1856                 :            :         /*
    1857                 :            :          * if ev->clearing is not 0, the disk_flush_events got called in the
    1858                 :            :          * middle of this function, so we want to run the workfn without delay.
    1859                 :            :          */
    1860                 :        234 :         __disk_unblock_events(disk, ev->clearing ? true : false);
    1861                 :            : 
    1862                 :            :         /* then, fetch and clear pending events */
    1863                 :        234 :         spin_lock_irq(&ev->lock);
    1864                 :        234 :         pending = ev->pending & mask;
    1865                 :        234 :         ev->pending &= ~mask;
    1866                 :        234 :         spin_unlock_irq(&ev->lock);
    1867         [ -  + ]:        234 :         WARN_ON_ONCE(clearing & mask);
    1868                 :            : 
    1869                 :            :         return pending;
    1870                 :            : }
    1871                 :            : 
    1872                 :            : /*
    1873                 :            :  * Separate this part out so that a different pointer for clearing_ptr can be
    1874                 :            :  * passed in for disk_clear_events.
    1875                 :            :  */
    1876                 :        468 : static void disk_events_workfn(struct work_struct *work)
    1877                 :            : {
    1878                 :        468 :         struct delayed_work *dwork = to_delayed_work(work);
    1879                 :        468 :         struct disk_events *ev = container_of(dwork, struct disk_events, dwork);
    1880                 :            : 
    1881                 :        468 :         disk_check_events(ev, &ev->clearing);
    1882                 :        468 : }
    1883                 :            : 
    1884                 :        702 : static void disk_check_events(struct disk_events *ev,
    1885                 :            :                               unsigned int *clearing_ptr)
    1886                 :            : {
    1887                 :        702 :         struct gendisk *disk = ev->disk;
    1888                 :        702 :         char *envp[ARRAY_SIZE(disk_uevents) + 1] = { };
    1889                 :        702 :         unsigned int clearing = *clearing_ptr;
    1890                 :        702 :         unsigned int events;
    1891                 :        702 :         unsigned long intv;
    1892                 :        702 :         int nr_events = 0, i;
    1893                 :            : 
    1894                 :            :         /* check events */
    1895                 :        702 :         events = disk->fops->check_events(disk, clearing);
    1896                 :            : 
    1897                 :            :         /* accumulate pending events and schedule next poll if necessary */
    1898                 :        702 :         spin_lock_irq(&ev->lock);
    1899                 :            : 
    1900                 :        702 :         events &= ~ev->pending;
    1901                 :        702 :         ev->pending |= events;
    1902                 :        702 :         *clearing_ptr &= ~clearing;
    1903                 :            : 
    1904                 :        702 :         intv = disk_events_poll_jiffies(disk);
    1905   [ +  +  +  + ]:        702 :         if (!ev->block && intv)
    1906                 :        376 :                 queue_delayed_work(system_freezable_power_efficient_wq,
    1907                 :            :                                 &ev->dwork, intv);
    1908                 :            : 
    1909                 :        702 :         spin_unlock_irq(&ev->lock);
    1910                 :            : 
    1911                 :            :         /*
    1912                 :            :          * Tell userland about new events.  Only the events listed in
    1913                 :            :          * @disk->events are reported, and only if DISK_EVENT_FLAG_UEVENT
    1914                 :            :          * is set. Otherwise, events are processed internally but never
    1915                 :            :          * get reported to userland.
    1916                 :            :          */
    1917         [ +  + ]:       2808 :         for (i = 0; i < ARRAY_SIZE(disk_uevents); i++)
    1918         [ +  + ]:       1404 :                 if ((events & disk->events & (1 << i)) &&
    1919         [ +  - ]:         78 :                     (disk->event_flags & DISK_EVENT_FLAG_UEVENT))
    1920                 :         78 :                         envp[nr_events++] = disk_uevents[i];
    1921                 :            : 
    1922         [ +  + ]:        702 :         if (nr_events)
    1923                 :         78 :                 kobject_uevent_env(&disk_to_dev(disk)->kobj, KOBJ_CHANGE, envp);
    1924                 :        702 : }
    1925                 :            : 
    1926                 :            : /*
    1927                 :            :  * A disk events enabled device has the following sysfs nodes under
    1928                 :            :  * its /sys/block/X/ directory.
    1929                 :            :  *
    1930                 :            :  * events               : list of all supported events
    1931                 :            :  * events_async         : list of events which can be detected w/o polling
    1932                 :            :  *                        (always empty, only for backwards compatibility)
    1933                 :            :  * events_poll_msecs    : polling interval, 0: disable, -1: system default
    1934                 :            :  */
    1935                 :          0 : static ssize_t __disk_events_show(unsigned int events, char *buf)
    1936                 :            : {
    1937                 :          0 :         const char *delim = "";
    1938                 :          0 :         ssize_t pos = 0;
    1939                 :          0 :         int i;
    1940                 :            : 
    1941         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(disk_events_strs); i++)
    1942         [ #  # ]:          0 :                 if (events & (1 << i)) {
    1943                 :          0 :                         pos += sprintf(buf + pos, "%s%s",
    1944                 :            :                                        delim, disk_events_strs[i]);
    1945                 :          0 :                         delim = " ";
    1946                 :            :                 }
    1947         [ #  # ]:          0 :         if (pos)
    1948                 :          0 :                 pos += sprintf(buf + pos, "\n");
    1949                 :          0 :         return pos;
    1950                 :            : }
    1951                 :            : 
    1952                 :          0 : static ssize_t disk_events_show(struct device *dev,
    1953                 :            :                                 struct device_attribute *attr, char *buf)
    1954                 :            : {
    1955                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1956                 :            : 
    1957         [ #  # ]:          0 :         if (!(disk->event_flags & DISK_EVENT_FLAG_UEVENT))
    1958                 :            :                 return 0;
    1959                 :            : 
    1960                 :          0 :         return __disk_events_show(disk->events, buf);
    1961                 :            : }
    1962                 :            : 
    1963                 :          0 : static ssize_t disk_events_async_show(struct device *dev,
    1964                 :            :                                       struct device_attribute *attr, char *buf)
    1965                 :            : {
    1966                 :          0 :         return 0;
    1967                 :            : }
    1968                 :            : 
    1969                 :          0 : static ssize_t disk_events_poll_msecs_show(struct device *dev,
    1970                 :            :                                            struct device_attribute *attr,
    1971                 :            :                                            char *buf)
    1972                 :            : {
    1973                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1974                 :            : 
    1975         [ #  # ]:          0 :         if (!disk->ev)
    1976                 :          0 :                 return sprintf(buf, "-1\n");
    1977                 :            : 
    1978                 :          0 :         return sprintf(buf, "%ld\n", disk->ev->poll_msecs);
    1979                 :            : }
    1980                 :            : 
    1981                 :          0 : static ssize_t disk_events_poll_msecs_store(struct device *dev,
    1982                 :            :                                             struct device_attribute *attr,
    1983                 :            :                                             const char *buf, size_t count)
    1984                 :            : {
    1985                 :          0 :         struct gendisk *disk = dev_to_disk(dev);
    1986                 :          0 :         long intv;
    1987                 :            : 
    1988   [ #  #  #  # ]:          0 :         if (!count || !sscanf(buf, "%ld", &intv))
    1989                 :          0 :                 return -EINVAL;
    1990                 :            : 
    1991         [ #  # ]:          0 :         if (intv < 0 && intv != -1)
    1992                 :            :                 return -EINVAL;
    1993                 :            : 
    1994         [ #  # ]:          0 :         if (!disk->ev)
    1995                 :            :                 return -ENODEV;
    1996                 :            : 
    1997                 :          0 :         disk_block_events(disk);
    1998                 :          0 :         disk->ev->poll_msecs = intv;
    1999                 :          0 :         __disk_unblock_events(disk, true);
    2000                 :            : 
    2001                 :          0 :         return count;
    2002                 :            : }
    2003                 :            : 
    2004                 :            : static const DEVICE_ATTR(events, 0444, disk_events_show, NULL);
    2005                 :            : static const DEVICE_ATTR(events_async, 0444, disk_events_async_show, NULL);
    2006                 :            : static const DEVICE_ATTR(events_poll_msecs, 0644,
    2007                 :            :                          disk_events_poll_msecs_show,
    2008                 :            :                          disk_events_poll_msecs_store);
    2009                 :            : 
    2010                 :            : static const struct attribute *disk_events_attrs[] = {
    2011                 :            :         &dev_attr_events.attr,
    2012                 :            :         &dev_attr_events_async.attr,
    2013                 :            :         &dev_attr_events_poll_msecs.attr,
    2014                 :            :         NULL,
    2015                 :            : };
    2016                 :            : 
    2017                 :            : /*
    2018                 :            :  * The default polling interval can be specified by the kernel
    2019                 :            :  * parameter block.events_dfl_poll_msecs which defaults to 0
    2020                 :            :  * (disable).  This can also be modified runtime by writing to
    2021                 :            :  * /sys/module/block/parameters/events_dfl_poll_msecs.
    2022                 :            :  */
    2023                 :         78 : static int disk_events_set_dfl_poll_msecs(const char *val,
    2024                 :            :                                           const struct kernel_param *kp)
    2025                 :            : {
    2026                 :         78 :         struct disk_events *ev;
    2027                 :         78 :         int ret;
    2028                 :            : 
    2029                 :         78 :         ret = param_set_ulong(val, kp);
    2030         [ +  - ]:         78 :         if (ret < 0)
    2031                 :            :                 return ret;
    2032                 :            : 
    2033                 :         78 :         mutex_lock(&disk_events_mutex);
    2034                 :            : 
    2035         [ +  + ]:        156 :         list_for_each_entry(ev, &disk_events, node)
    2036                 :         78 :                 disk_flush_events(ev->disk, 0);
    2037                 :            : 
    2038                 :         78 :         mutex_unlock(&disk_events_mutex);
    2039                 :            : 
    2040                 :         78 :         return 0;
    2041                 :            : }
    2042                 :            : 
    2043                 :            : static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
    2044                 :            :         .set    = disk_events_set_dfl_poll_msecs,
    2045                 :            :         .get    = param_get_ulong,
    2046                 :            : };
    2047                 :            : 
    2048                 :            : #undef MODULE_PARAM_PREFIX
    2049                 :            : #define MODULE_PARAM_PREFIX     "block."
    2050                 :            : 
    2051                 :            : module_param_cb(events_dfl_poll_msecs, &disk_events_dfl_poll_msecs_param_ops,
    2052                 :            :                 &disk_events_dfl_poll_msecs, 0644);
    2053                 :            : 
    2054                 :            : /*
    2055                 :            :  * disk_{alloc|add|del|release}_events - initialize and destroy disk_events.
    2056                 :            :  */
    2057                 :        936 : static void disk_alloc_events(struct gendisk *disk)
    2058                 :            : {
    2059                 :        936 :         struct disk_events *ev;
    2060                 :            : 
    2061   [ +  +  +  + ]:        936 :         if (!disk->fops->check_events || !disk->events)
    2062                 :            :                 return;
    2063                 :            : 
    2064                 :         78 :         ev = kzalloc(sizeof(*ev), GFP_KERNEL);
    2065         [ -  + ]:         78 :         if (!ev) {
    2066                 :          0 :                 pr_warn("%s: failed to initialize events\n", disk->disk_name);
    2067                 :          0 :                 return;
    2068                 :            :         }
    2069                 :            : 
    2070                 :         78 :         INIT_LIST_HEAD(&ev->node);
    2071                 :         78 :         ev->disk = disk;
    2072                 :         78 :         spin_lock_init(&ev->lock);
    2073                 :         78 :         mutex_init(&ev->block_mutex);
    2074                 :         78 :         ev->block = 1;
    2075                 :         78 :         ev->poll_msecs = -1;
    2076                 :         78 :         INIT_DELAYED_WORK(&ev->dwork, disk_events_workfn);
    2077                 :            : 
    2078                 :         78 :         disk->ev = ev;
    2079                 :            : }
    2080                 :            : 
    2081                 :        936 : static void disk_add_events(struct gendisk *disk)
    2082                 :            : {
    2083                 :            :         /* FIXME: error handling */
    2084         [ -  + ]:        936 :         if (sysfs_create_files(&disk_to_dev(disk)->kobj, disk_events_attrs) < 0)
    2085                 :          0 :                 pr_warn("%s: failed to create sysfs files for events\n",
    2086                 :            :                         disk->disk_name);
    2087                 :            : 
    2088         [ +  + ]:        936 :         if (!disk->ev)
    2089                 :            :                 return;
    2090                 :            : 
    2091                 :         78 :         mutex_lock(&disk_events_mutex);
    2092                 :         78 :         list_add_tail(&disk->ev->node, &disk_events);
    2093                 :         78 :         mutex_unlock(&disk_events_mutex);
    2094                 :            : 
    2095                 :            :         /*
    2096                 :            :          * Block count is initialized to 1 and the following initial
    2097                 :            :          * unblock kicks it into action.
    2098                 :            :          */
    2099                 :         78 :         __disk_unblock_events(disk, true);
    2100                 :            : }
    2101                 :            : 
    2102                 :          0 : static void disk_del_events(struct gendisk *disk)
    2103                 :            : {
    2104         [ #  # ]:          0 :         if (disk->ev) {
    2105                 :          0 :                 disk_block_events(disk);
    2106                 :            : 
    2107                 :          0 :                 mutex_lock(&disk_events_mutex);
    2108                 :          0 :                 list_del_init(&disk->ev->node);
    2109                 :          0 :                 mutex_unlock(&disk_events_mutex);
    2110                 :            :         }
    2111                 :            : 
    2112                 :          0 :         sysfs_remove_files(&disk_to_dev(disk)->kobj, disk_events_attrs);
    2113                 :          0 : }
    2114                 :            : 
    2115                 :            : static void disk_release_events(struct gendisk *disk)
    2116                 :            : {
    2117                 :            :         /* the block count should be 1 from disk_del_events() */
    2118                 :            :         WARN_ON_ONCE(disk->ev && disk->ev->block != 1);
    2119                 :            :         kfree(disk->ev);
    2120                 :            : }

Generated by: LCOV version 1.14