LCOV - code coverage report
Current view: top level - block - blk-sysfs.c (source / functions) Hit Total Coverage
Test: Real Lines: 43 297 14.5 %
Date: 2020-10-17 15:46:16 Functions: 0 57 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Functions related to sysfs handling
       4                 :            :  */
       5                 :            : #include <linux/kernel.h>
       6                 :            : #include <linux/slab.h>
       7                 :            : #include <linux/module.h>
       8                 :            : #include <linux/bio.h>
       9                 :            : #include <linux/blkdev.h>
      10                 :            : #include <linux/backing-dev.h>
      11                 :            : #include <linux/blktrace_api.h>
      12                 :            : #include <linux/blk-mq.h>
      13                 :            : #include <linux/blk-cgroup.h>
      14                 :            : 
      15                 :            : #include "blk.h"
      16                 :            : #include "blk-mq.h"
      17                 :            : #include "blk-mq-debugfs.h"
      18                 :            : #include "blk-wbt.h"
      19                 :            : 
      20                 :            : struct queue_sysfs_entry {
      21                 :            :         struct attribute attr;
      22                 :            :         ssize_t (*show)(struct request_queue *, char *);
      23                 :            :         ssize_t (*store)(struct request_queue *, const char *, size_t);
      24                 :            : };
      25                 :            : 
      26                 :            : static ssize_t
      27                 :            : queue_var_show(unsigned long var, char *page)
      28                 :            : {
      29                 :          3 :         return sprintf(page, "%lu\n", var);
      30                 :            : }
      31                 :            : 
      32                 :            : static ssize_t
      33                 :            : queue_var_store(unsigned long *var, const char *page, size_t count)
      34                 :            : {
      35                 :            :         int err;
      36                 :            :         unsigned long v;
      37                 :            : 
      38                 :            :         err = kstrtoul(page, 10, &v);
      39                 :          0 :         if (err || v > UINT_MAX)
      40                 :            :                 return -EINVAL;
      41                 :            : 
      42                 :          0 :         *var = v;
      43                 :            : 
      44                 :          0 :         return count;
      45                 :            : }
      46                 :            : 
      47                 :          0 : static ssize_t queue_var_store64(s64 *var, const char *page)
      48                 :            : {
      49                 :            :         int err;
      50                 :            :         s64 v;
      51                 :            : 
      52                 :            :         err = kstrtos64(page, 10, &v);
      53                 :          0 :         if (err < 0)
      54                 :            :                 return err;
      55                 :            : 
      56                 :          0 :         *var = v;
      57                 :          0 :         return 0;
      58                 :            : }
      59                 :            : 
      60                 :          0 : static ssize_t queue_requests_show(struct request_queue *q, char *page)
      61                 :            : {
      62                 :          0 :         return queue_var_show(q->nr_requests, (page));
      63                 :            : }
      64                 :            : 
      65                 :            : static ssize_t
      66                 :          0 : queue_requests_store(struct request_queue *q, const char *page, size_t count)
      67                 :            : {
      68                 :            :         unsigned long nr;
      69                 :            :         int ret, err;
      70                 :            : 
      71                 :          0 :         if (!queue_is_mq(q))
      72                 :            :                 return -EINVAL;
      73                 :            : 
      74                 :            :         ret = queue_var_store(&nr, page, count);
      75                 :          0 :         if (ret < 0)
      76                 :            :                 return ret;
      77                 :            : 
      78                 :          0 :         if (nr < BLKDEV_MIN_RQ)
      79                 :            :                 nr = BLKDEV_MIN_RQ;
      80                 :            : 
      81                 :          0 :         err = blk_mq_update_nr_requests(q, nr);
      82                 :          0 :         if (err)
      83                 :            :                 return err;
      84                 :            : 
      85                 :          0 :         return ret;
      86                 :            : }
      87                 :            : 
      88                 :          0 : static ssize_t queue_ra_show(struct request_queue *q, char *page)
      89                 :            : {
      90                 :          0 :         unsigned long ra_kb = q->backing_dev_info->ra_pages <<
      91                 :            :                                         (PAGE_SHIFT - 10);
      92                 :            : 
      93                 :          0 :         return queue_var_show(ra_kb, (page));
      94                 :            : }
      95                 :            : 
      96                 :            : static ssize_t
      97                 :          0 : queue_ra_store(struct request_queue *q, const char *page, size_t count)
      98                 :            : {
      99                 :            :         unsigned long ra_kb;
     100                 :            :         ssize_t ret = queue_var_store(&ra_kb, page, count);
     101                 :            : 
     102                 :          0 :         if (ret < 0)
     103                 :            :                 return ret;
     104                 :            : 
     105                 :          0 :         q->backing_dev_info->ra_pages = ra_kb >> (PAGE_SHIFT - 10);
     106                 :            : 
     107                 :          0 :         return ret;
     108                 :            : }
     109                 :            : 
     110                 :          0 : static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
     111                 :            : {
     112                 :          0 :         int max_sectors_kb = queue_max_sectors(q) >> 1;
     113                 :            : 
     114                 :          0 :         return queue_var_show(max_sectors_kb, (page));
     115                 :            : }
     116                 :            : 
     117                 :          0 : static ssize_t queue_max_segments_show(struct request_queue *q, char *page)
     118                 :            : {
     119                 :          0 :         return queue_var_show(queue_max_segments(q), (page));
     120                 :            : }
     121                 :            : 
     122                 :          0 : static ssize_t queue_max_discard_segments_show(struct request_queue *q,
     123                 :            :                 char *page)
     124                 :            : {
     125                 :          0 :         return queue_var_show(queue_max_discard_segments(q), (page));
     126                 :            : }
     127                 :            : 
     128                 :          0 : static ssize_t queue_max_integrity_segments_show(struct request_queue *q, char *page)
     129                 :            : {
     130                 :          0 :         return queue_var_show(q->limits.max_integrity_segments, (page));
     131                 :            : }
     132                 :            : 
     133                 :          0 : static ssize_t queue_max_segment_size_show(struct request_queue *q, char *page)
     134                 :            : {
     135                 :          0 :         return queue_var_show(queue_max_segment_size(q), (page));
     136                 :            : }
     137                 :            : 
     138                 :          0 : static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
     139                 :            : {
     140                 :          0 :         return queue_var_show(queue_logical_block_size(q), page);
     141                 :            : }
     142                 :            : 
     143                 :          0 : static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
     144                 :            : {
     145                 :          0 :         return queue_var_show(queue_physical_block_size(q), page);
     146                 :            : }
     147                 :            : 
     148                 :          0 : static ssize_t queue_chunk_sectors_show(struct request_queue *q, char *page)
     149                 :            : {
     150                 :          0 :         return queue_var_show(q->limits.chunk_sectors, page);
     151                 :            : }
     152                 :            : 
     153                 :          0 : static ssize_t queue_io_min_show(struct request_queue *q, char *page)
     154                 :            : {
     155                 :          0 :         return queue_var_show(queue_io_min(q), page);
     156                 :            : }
     157                 :            : 
     158                 :          0 : static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
     159                 :            : {
     160                 :          0 :         return queue_var_show(queue_io_opt(q), page);
     161                 :            : }
     162                 :            : 
     163                 :          0 : static ssize_t queue_discard_granularity_show(struct request_queue *q, char *page)
     164                 :            : {
     165                 :          0 :         return queue_var_show(q->limits.discard_granularity, page);
     166                 :            : }
     167                 :            : 
     168                 :          0 : static ssize_t queue_discard_max_hw_show(struct request_queue *q, char *page)
     169                 :            : {
     170                 :            : 
     171                 :          0 :         return sprintf(page, "%llu\n",
     172                 :          0 :                 (unsigned long long)q->limits.max_hw_discard_sectors << 9);
     173                 :            : }
     174                 :            : 
     175                 :          0 : static ssize_t queue_discard_max_show(struct request_queue *q, char *page)
     176                 :            : {
     177                 :          0 :         return sprintf(page, "%llu\n",
     178                 :          0 :                        (unsigned long long)q->limits.max_discard_sectors << 9);
     179                 :            : }
     180                 :            : 
     181                 :          0 : static ssize_t queue_discard_max_store(struct request_queue *q,
     182                 :            :                                        const char *page, size_t count)
     183                 :            : {
     184                 :            :         unsigned long max_discard;
     185                 :            :         ssize_t ret = queue_var_store(&max_discard, page, count);
     186                 :            : 
     187                 :          0 :         if (ret < 0)
     188                 :            :                 return ret;
     189                 :            : 
     190                 :          0 :         if (max_discard & (q->limits.discard_granularity - 1))
     191                 :            :                 return -EINVAL;
     192                 :            : 
     193                 :          0 :         max_discard >>= 9;
     194                 :            :         if (max_discard > UINT_MAX)
     195                 :            :                 return -EINVAL;
     196                 :            : 
     197                 :          0 :         if (max_discard > q->limits.max_hw_discard_sectors)
     198                 :            :                 max_discard = q->limits.max_hw_discard_sectors;
     199                 :            : 
     200                 :          0 :         q->limits.max_discard_sectors = max_discard;
     201                 :          0 :         return ret;
     202                 :            : }
     203                 :            : 
     204                 :          0 : static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
     205                 :            : {
     206                 :          0 :         return queue_var_show(0, page);
     207                 :            : }
     208                 :            : 
     209                 :          0 : static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)
     210                 :            : {
     211                 :          0 :         return sprintf(page, "%llu\n",
     212                 :          0 :                 (unsigned long long)q->limits.max_write_same_sectors << 9);
     213                 :            : }
     214                 :            : 
     215                 :          0 : static ssize_t queue_write_zeroes_max_show(struct request_queue *q, char *page)
     216                 :            : {
     217                 :          0 :         return sprintf(page, "%llu\n",
     218                 :          0 :                 (unsigned long long)q->limits.max_write_zeroes_sectors << 9);
     219                 :            : }
     220                 :            : 
     221                 :            : static ssize_t
     222                 :          0 : queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
     223                 :            : {
     224                 :            :         unsigned long max_sectors_kb,
     225                 :          0 :                 max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
     226                 :            :                         page_kb = 1 << (PAGE_SHIFT - 10);
     227                 :            :         ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
     228                 :            : 
     229                 :          0 :         if (ret < 0)
     230                 :            :                 return ret;
     231                 :            : 
     232                 :          0 :         max_hw_sectors_kb = min_not_zero(max_hw_sectors_kb, (unsigned long)
     233                 :            :                                          q->limits.max_dev_sectors >> 1);
     234                 :            : 
     235                 :          0 :         if (max_sectors_kb > max_hw_sectors_kb || max_sectors_kb < page_kb)
     236                 :            :                 return -EINVAL;
     237                 :            : 
     238                 :            :         spin_lock_irq(&q->queue_lock);
     239                 :          0 :         q->limits.max_sectors = max_sectors_kb << 1;
     240                 :          0 :         q->backing_dev_info->io_pages = max_sectors_kb >> (PAGE_SHIFT - 10);
     241                 :            :         spin_unlock_irq(&q->queue_lock);
     242                 :            : 
     243                 :          0 :         return ret;
     244                 :            : }
     245                 :            : 
     246                 :          0 : static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
     247                 :            : {
     248                 :          0 :         int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
     249                 :            : 
     250                 :          0 :         return queue_var_show(max_hw_sectors_kb, (page));
     251                 :            : }
     252                 :            : 
     253                 :            : #define QUEUE_SYSFS_BIT_FNS(name, flag, neg)                            \
     254                 :            : static ssize_t                                                          \
     255                 :            : queue_show_##name(struct request_queue *q, char *page)                  \
     256                 :            : {                                                                       \
     257                 :            :         int bit;                                                        \
     258                 :            :         bit = test_bit(QUEUE_FLAG_##flag, &q->queue_flags);              \
     259                 :            :         return queue_var_show(neg ? !bit : bit, page);                  \
     260                 :            : }                                                                       \
     261                 :            : static ssize_t                                                          \
     262                 :            : queue_store_##name(struct request_queue *q, const char *page, size_t count) \
     263                 :            : {                                                                       \
     264                 :            :         unsigned long val;                                              \
     265                 :            :         ssize_t ret;                                                    \
     266                 :            :         ret = queue_var_store(&val, page, count);                   \
     267                 :            :         if (ret < 0)                                                 \
     268                 :            :                  return ret;                                            \
     269                 :            :         if (neg)                                                        \
     270                 :            :                 val = !val;                                             \
     271                 :            :                                                                         \
     272                 :            :         if (val)                                                        \
     273                 :            :                 blk_queue_flag_set(QUEUE_FLAG_##flag, q);               \
     274                 :            :         else                                                            \
     275                 :            :                 blk_queue_flag_clear(QUEUE_FLAG_##flag, q);             \
     276                 :            :         return ret;                                                     \
     277                 :            : }
     278                 :            : 
     279                 :          3 : QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
     280                 :          0 : QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
     281                 :          0 : QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
     282                 :            : #undef QUEUE_SYSFS_BIT_FNS
     283                 :            : 
     284                 :          0 : static ssize_t queue_zoned_show(struct request_queue *q, char *page)
     285                 :            : {
     286                 :          0 :         switch (blk_queue_zoned_model(q)) {
     287                 :            :         case BLK_ZONED_HA:
     288                 :          0 :                 return sprintf(page, "host-aware\n");
     289                 :            :         case BLK_ZONED_HM:
     290                 :          0 :                 return sprintf(page, "host-managed\n");
     291                 :            :         default:
     292                 :          0 :                 return sprintf(page, "none\n");
     293                 :            :         }
     294                 :            : }
     295                 :            : 
     296                 :          0 : static ssize_t queue_nr_zones_show(struct request_queue *q, char *page)
     297                 :            : {
     298                 :          0 :         return queue_var_show(blk_queue_nr_zones(q), page);
     299                 :            : }
     300                 :            : 
     301                 :          0 : static ssize_t queue_nomerges_show(struct request_queue *q, char *page)
     302                 :            : {
     303                 :          0 :         return queue_var_show((blk_queue_nomerges(q) << 1) |
     304                 :            :                                blk_queue_noxmerges(q), page);
     305                 :            : }
     306                 :            : 
     307                 :          0 : static ssize_t queue_nomerges_store(struct request_queue *q, const char *page,
     308                 :            :                                     size_t count)
     309                 :            : {
     310                 :            :         unsigned long nm;
     311                 :            :         ssize_t ret = queue_var_store(&nm, page, count);
     312                 :            : 
     313                 :          0 :         if (ret < 0)
     314                 :            :                 return ret;
     315                 :            : 
     316                 :          0 :         blk_queue_flag_clear(QUEUE_FLAG_NOMERGES, q);
     317                 :          0 :         blk_queue_flag_clear(QUEUE_FLAG_NOXMERGES, q);
     318                 :          0 :         if (nm == 2)
     319                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q);
     320                 :          0 :         else if (nm)
     321                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_NOXMERGES, q);
     322                 :            : 
     323                 :            :         return ret;
     324                 :            : }
     325                 :            : 
     326                 :          0 : static ssize_t queue_rq_affinity_show(struct request_queue *q, char *page)
     327                 :            : {
     328                 :          0 :         bool set = test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags);
     329                 :          0 :         bool force = test_bit(QUEUE_FLAG_SAME_FORCE, &q->queue_flags);
     330                 :            : 
     331                 :          0 :         return queue_var_show(set << force, page);
     332                 :            : }
     333                 :            : 
     334                 :            : static ssize_t
     335                 :          0 : queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count)
     336                 :            : {
     337                 :            :         ssize_t ret = -EINVAL;
     338                 :            : #ifdef CONFIG_SMP
     339                 :            :         unsigned long val;
     340                 :            : 
     341                 :            :         ret = queue_var_store(&val, page, count);
     342                 :          0 :         if (ret < 0)
     343                 :            :                 return ret;
     344                 :            : 
     345                 :          0 :         if (val == 2) {
     346                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
     347                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_SAME_FORCE, q);
     348                 :          0 :         } else if (val == 1) {
     349                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_SAME_COMP, q);
     350                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
     351                 :          0 :         } else if (val == 0) {
     352                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_SAME_COMP, q);
     353                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_SAME_FORCE, q);
     354                 :            :         }
     355                 :            : #endif
     356                 :            :         return ret;
     357                 :            : }
     358                 :            : 
     359                 :          0 : static ssize_t queue_poll_delay_show(struct request_queue *q, char *page)
     360                 :            : {
     361                 :            :         int val;
     362                 :            : 
     363                 :          0 :         if (q->poll_nsec == BLK_MQ_POLL_CLASSIC)
     364                 :            :                 val = BLK_MQ_POLL_CLASSIC;
     365                 :            :         else
     366                 :          0 :                 val = q->poll_nsec / 1000;
     367                 :            : 
     368                 :          0 :         return sprintf(page, "%d\n", val);
     369                 :            : }
     370                 :            : 
     371                 :          0 : static ssize_t queue_poll_delay_store(struct request_queue *q, const char *page,
     372                 :            :                                 size_t count)
     373                 :            : {
     374                 :            :         int err, val;
     375                 :            : 
     376                 :          0 :         if (!q->mq_ops || !q->mq_ops->poll)
     377                 :            :                 return -EINVAL;
     378                 :            : 
     379                 :          0 :         err = kstrtoint(page, 10, &val);
     380                 :          0 :         if (err < 0)
     381                 :            :                 return err;
     382                 :            : 
     383                 :          0 :         if (val == BLK_MQ_POLL_CLASSIC)
     384                 :          0 :                 q->poll_nsec = BLK_MQ_POLL_CLASSIC;
     385                 :          0 :         else if (val >= 0)
     386                 :          0 :                 q->poll_nsec = val * 1000;
     387                 :            :         else
     388                 :            :                 return -EINVAL;
     389                 :            : 
     390                 :          0 :         return count;
     391                 :            : }
     392                 :            : 
     393                 :          0 : static ssize_t queue_poll_show(struct request_queue *q, char *page)
     394                 :            : {
     395                 :          0 :         return queue_var_show(test_bit(QUEUE_FLAG_POLL, &q->queue_flags), page);
     396                 :            : }
     397                 :            : 
     398                 :          0 : static ssize_t queue_poll_store(struct request_queue *q, const char *page,
     399                 :            :                                 size_t count)
     400                 :            : {
     401                 :            :         unsigned long poll_on;
     402                 :            :         ssize_t ret;
     403                 :            : 
     404                 :          0 :         if (!q->tag_set || q->tag_set->nr_maps <= HCTX_TYPE_POLL ||
     405                 :          0 :             !q->tag_set->map[HCTX_TYPE_POLL].nr_queues)
     406                 :            :                 return -EINVAL;
     407                 :            : 
     408                 :            :         ret = queue_var_store(&poll_on, page, count);
     409                 :          0 :         if (ret < 0)
     410                 :            :                 return ret;
     411                 :            : 
     412                 :          0 :         if (poll_on)
     413                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_POLL, q);
     414                 :            :         else
     415                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_POLL, q);
     416                 :            : 
     417                 :          0 :         return ret;
     418                 :            : }
     419                 :            : 
     420                 :          0 : static ssize_t queue_io_timeout_show(struct request_queue *q, char *page)
     421                 :            : {
     422                 :          0 :         return sprintf(page, "%u\n", jiffies_to_msecs(q->rq_timeout));
     423                 :            : }
     424                 :            : 
     425                 :          0 : static ssize_t queue_io_timeout_store(struct request_queue *q, const char *page,
     426                 :            :                                   size_t count)
     427                 :            : {
     428                 :            :         unsigned int val;
     429                 :            :         int err;
     430                 :            : 
     431                 :            :         err = kstrtou32(page, 10, &val);
     432                 :          0 :         if (err || val == 0)
     433                 :            :                 return -EINVAL;
     434                 :            : 
     435                 :          0 :         blk_queue_rq_timeout(q, msecs_to_jiffies(val));
     436                 :            : 
     437                 :          0 :         return count;
     438                 :            : }
     439                 :            : 
     440                 :          0 : static ssize_t queue_wb_lat_show(struct request_queue *q, char *page)
     441                 :            : {
     442                 :          0 :         if (!wbt_rq_qos(q))
     443                 :            :                 return -EINVAL;
     444                 :            : 
     445                 :          0 :         return sprintf(page, "%llu\n", div_u64(wbt_get_min_lat(q), 1000));
     446                 :            : }
     447                 :            : 
     448                 :          0 : static ssize_t queue_wb_lat_store(struct request_queue *q, const char *page,
     449                 :            :                                   size_t count)
     450                 :            : {
     451                 :            :         struct rq_qos *rqos;
     452                 :            :         ssize_t ret;
     453                 :            :         s64 val;
     454                 :            : 
     455                 :          0 :         ret = queue_var_store64(&val, page);
     456                 :          0 :         if (ret < 0)
     457                 :            :                 return ret;
     458                 :          0 :         if (val < -1)
     459                 :            :                 return -EINVAL;
     460                 :            : 
     461                 :            :         rqos = wbt_rq_qos(q);
     462                 :          0 :         if (!rqos) {
     463                 :            :                 ret = wbt_init(q);
     464                 :            :                 if (ret)
     465                 :            :                         return ret;
     466                 :            :         }
     467                 :            : 
     468                 :          0 :         if (val == -1)
     469                 :          0 :                 val = wbt_default_latency_nsec(q);
     470                 :          0 :         else if (val >= 0)
     471                 :          0 :                 val *= 1000ULL;
     472                 :            : 
     473                 :          0 :         if (wbt_get_min_lat(q) == val)
     474                 :          0 :                 return count;
     475                 :            : 
     476                 :            :         /*
     477                 :            :          * Ensure that the queue is idled, in case the latency update
     478                 :            :          * ends up either enabling or disabling wbt completely. We can't
     479                 :            :          * have IO inflight if that happens.
     480                 :            :          */
     481                 :          0 :         blk_mq_freeze_queue(q);
     482                 :          0 :         blk_mq_quiesce_queue(q);
     483                 :            : 
     484                 :            :         wbt_set_min_lat(q, val);
     485                 :            : 
     486                 :          0 :         blk_mq_unquiesce_queue(q);
     487                 :          0 :         blk_mq_unfreeze_queue(q);
     488                 :            : 
     489                 :          0 :         return count;
     490                 :            : }
     491                 :            : 
     492                 :          0 : static ssize_t queue_wc_show(struct request_queue *q, char *page)
     493                 :            : {
     494                 :          0 :         if (test_bit(QUEUE_FLAG_WC, &q->queue_flags))
     495                 :          0 :                 return sprintf(page, "write back\n");
     496                 :            : 
     497                 :          0 :         return sprintf(page, "write through\n");
     498                 :            : }
     499                 :            : 
     500                 :          0 : static ssize_t queue_wc_store(struct request_queue *q, const char *page,
     501                 :            :                               size_t count)
     502                 :            : {
     503                 :            :         int set = -1;
     504                 :            : 
     505                 :          0 :         if (!strncmp(page, "write back", 10))
     506                 :            :                 set = 1;
     507                 :          0 :         else if (!strncmp(page, "write through", 13) ||
     508                 :          0 :                  !strncmp(page, "none", 4))
     509                 :            :                 set = 0;
     510                 :            : 
     511                 :          0 :         if (set == -1)
     512                 :            :                 return -EINVAL;
     513                 :            : 
     514                 :          0 :         if (set)
     515                 :          0 :                 blk_queue_flag_set(QUEUE_FLAG_WC, q);
     516                 :            :         else
     517                 :          0 :                 blk_queue_flag_clear(QUEUE_FLAG_WC, q);
     518                 :            : 
     519                 :          0 :         return count;
     520                 :            : }
     521                 :            : 
     522                 :          0 : static ssize_t queue_fua_show(struct request_queue *q, char *page)
     523                 :            : {
     524                 :          0 :         return sprintf(page, "%u\n", test_bit(QUEUE_FLAG_FUA, &q->queue_flags));
     525                 :            : }
     526                 :            : 
     527                 :          0 : static ssize_t queue_dax_show(struct request_queue *q, char *page)
     528                 :            : {
     529                 :          0 :         return queue_var_show(blk_queue_dax(q), page);
     530                 :            : }
     531                 :            : 
     532                 :            : static struct queue_sysfs_entry queue_requests_entry = {
     533                 :            :         .attr = {.name = "nr_requests", .mode = 0644 },
     534                 :            :         .show = queue_requests_show,
     535                 :            :         .store = queue_requests_store,
     536                 :            : };
     537                 :            : 
     538                 :            : static struct queue_sysfs_entry queue_ra_entry = {
     539                 :            :         .attr = {.name = "read_ahead_kb", .mode = 0644 },
     540                 :            :         .show = queue_ra_show,
     541                 :            :         .store = queue_ra_store,
     542                 :            : };
     543                 :            : 
     544                 :            : static struct queue_sysfs_entry queue_max_sectors_entry = {
     545                 :            :         .attr = {.name = "max_sectors_kb", .mode = 0644 },
     546                 :            :         .show = queue_max_sectors_show,
     547                 :            :         .store = queue_max_sectors_store,
     548                 :            : };
     549                 :            : 
     550                 :            : static struct queue_sysfs_entry queue_max_hw_sectors_entry = {
     551                 :            :         .attr = {.name = "max_hw_sectors_kb", .mode = 0444 },
     552                 :            :         .show = queue_max_hw_sectors_show,
     553                 :            : };
     554                 :            : 
     555                 :            : static struct queue_sysfs_entry queue_max_segments_entry = {
     556                 :            :         .attr = {.name = "max_segments", .mode = 0444 },
     557                 :            :         .show = queue_max_segments_show,
     558                 :            : };
     559                 :            : 
     560                 :            : static struct queue_sysfs_entry queue_max_discard_segments_entry = {
     561                 :            :         .attr = {.name = "max_discard_segments", .mode = 0444 },
     562                 :            :         .show = queue_max_discard_segments_show,
     563                 :            : };
     564                 :            : 
     565                 :            : static struct queue_sysfs_entry queue_max_integrity_segments_entry = {
     566                 :            :         .attr = {.name = "max_integrity_segments", .mode = 0444 },
     567                 :            :         .show = queue_max_integrity_segments_show,
     568                 :            : };
     569                 :            : 
     570                 :            : static struct queue_sysfs_entry queue_max_segment_size_entry = {
     571                 :            :         .attr = {.name = "max_segment_size", .mode = 0444 },
     572                 :            :         .show = queue_max_segment_size_show,
     573                 :            : };
     574                 :            : 
     575                 :            : static struct queue_sysfs_entry queue_iosched_entry = {
     576                 :            :         .attr = {.name = "scheduler", .mode = 0644 },
     577                 :            :         .show = elv_iosched_show,
     578                 :            :         .store = elv_iosched_store,
     579                 :            : };
     580                 :            : 
     581                 :            : static struct queue_sysfs_entry queue_hw_sector_size_entry = {
     582                 :            :         .attr = {.name = "hw_sector_size", .mode = 0444 },
     583                 :            :         .show = queue_logical_block_size_show,
     584                 :            : };
     585                 :            : 
     586                 :            : static struct queue_sysfs_entry queue_logical_block_size_entry = {
     587                 :            :         .attr = {.name = "logical_block_size", .mode = 0444 },
     588                 :            :         .show = queue_logical_block_size_show,
     589                 :            : };
     590                 :            : 
     591                 :            : static struct queue_sysfs_entry queue_physical_block_size_entry = {
     592                 :            :         .attr = {.name = "physical_block_size", .mode = 0444 },
     593                 :            :         .show = queue_physical_block_size_show,
     594                 :            : };
     595                 :            : 
     596                 :            : static struct queue_sysfs_entry queue_chunk_sectors_entry = {
     597                 :            :         .attr = {.name = "chunk_sectors", .mode = 0444 },
     598                 :            :         .show = queue_chunk_sectors_show,
     599                 :            : };
     600                 :            : 
     601                 :            : static struct queue_sysfs_entry queue_io_min_entry = {
     602                 :            :         .attr = {.name = "minimum_io_size", .mode = 0444 },
     603                 :            :         .show = queue_io_min_show,
     604                 :            : };
     605                 :            : 
     606                 :            : static struct queue_sysfs_entry queue_io_opt_entry = {
     607                 :            :         .attr = {.name = "optimal_io_size", .mode = 0444 },
     608                 :            :         .show = queue_io_opt_show,
     609                 :            : };
     610                 :            : 
     611                 :            : static struct queue_sysfs_entry queue_discard_granularity_entry = {
     612                 :            :         .attr = {.name = "discard_granularity", .mode = 0444 },
     613                 :            :         .show = queue_discard_granularity_show,
     614                 :            : };
     615                 :            : 
     616                 :            : static struct queue_sysfs_entry queue_discard_max_hw_entry = {
     617                 :            :         .attr = {.name = "discard_max_hw_bytes", .mode = 0444 },
     618                 :            :         .show = queue_discard_max_hw_show,
     619                 :            : };
     620                 :            : 
     621                 :            : static struct queue_sysfs_entry queue_discard_max_entry = {
     622                 :            :         .attr = {.name = "discard_max_bytes", .mode = 0644 },
     623                 :            :         .show = queue_discard_max_show,
     624                 :            :         .store = queue_discard_max_store,
     625                 :            : };
     626                 :            : 
     627                 :            : static struct queue_sysfs_entry queue_discard_zeroes_data_entry = {
     628                 :            :         .attr = {.name = "discard_zeroes_data", .mode = 0444 },
     629                 :            :         .show = queue_discard_zeroes_data_show,
     630                 :            : };
     631                 :            : 
     632                 :            : static struct queue_sysfs_entry queue_write_same_max_entry = {
     633                 :            :         .attr = {.name = "write_same_max_bytes", .mode = 0444 },
     634                 :            :         .show = queue_write_same_max_show,
     635                 :            : };
     636                 :            : 
     637                 :            : static struct queue_sysfs_entry queue_write_zeroes_max_entry = {
     638                 :            :         .attr = {.name = "write_zeroes_max_bytes", .mode = 0444 },
     639                 :            :         .show = queue_write_zeroes_max_show,
     640                 :            : };
     641                 :            : 
     642                 :            : static struct queue_sysfs_entry queue_nonrot_entry = {
     643                 :            :         .attr = {.name = "rotational", .mode = 0644 },
     644                 :            :         .show = queue_show_nonrot,
     645                 :            :         .store = queue_store_nonrot,
     646                 :            : };
     647                 :            : 
     648                 :            : static struct queue_sysfs_entry queue_zoned_entry = {
     649                 :            :         .attr = {.name = "zoned", .mode = 0444 },
     650                 :            :         .show = queue_zoned_show,
     651                 :            : };
     652                 :            : 
     653                 :            : static struct queue_sysfs_entry queue_nr_zones_entry = {
     654                 :            :         .attr = {.name = "nr_zones", .mode = 0444 },
     655                 :            :         .show = queue_nr_zones_show,
     656                 :            : };
     657                 :            : 
     658                 :            : static struct queue_sysfs_entry queue_nomerges_entry = {
     659                 :            :         .attr = {.name = "nomerges", .mode = 0644 },
     660                 :            :         .show = queue_nomerges_show,
     661                 :            :         .store = queue_nomerges_store,
     662                 :            : };
     663                 :            : 
     664                 :            : static struct queue_sysfs_entry queue_rq_affinity_entry = {
     665                 :            :         .attr = {.name = "rq_affinity", .mode = 0644 },
     666                 :            :         .show = queue_rq_affinity_show,
     667                 :            :         .store = queue_rq_affinity_store,
     668                 :            : };
     669                 :            : 
     670                 :            : static struct queue_sysfs_entry queue_iostats_entry = {
     671                 :            :         .attr = {.name = "iostats", .mode = 0644 },
     672                 :            :         .show = queue_show_iostats,
     673                 :            :         .store = queue_store_iostats,
     674                 :            : };
     675                 :            : 
     676                 :            : static struct queue_sysfs_entry queue_random_entry = {
     677                 :            :         .attr = {.name = "add_random", .mode = 0644 },
     678                 :            :         .show = queue_show_random,
     679                 :            :         .store = queue_store_random,
     680                 :            : };
     681                 :            : 
     682                 :            : static struct queue_sysfs_entry queue_poll_entry = {
     683                 :            :         .attr = {.name = "io_poll", .mode = 0644 },
     684                 :            :         .show = queue_poll_show,
     685                 :            :         .store = queue_poll_store,
     686                 :            : };
     687                 :            : 
     688                 :            : static struct queue_sysfs_entry queue_poll_delay_entry = {
     689                 :            :         .attr = {.name = "io_poll_delay", .mode = 0644 },
     690                 :            :         .show = queue_poll_delay_show,
     691                 :            :         .store = queue_poll_delay_store,
     692                 :            : };
     693                 :            : 
     694                 :            : static struct queue_sysfs_entry queue_wc_entry = {
     695                 :            :         .attr = {.name = "write_cache", .mode = 0644 },
     696                 :            :         .show = queue_wc_show,
     697                 :            :         .store = queue_wc_store,
     698                 :            : };
     699                 :            : 
     700                 :            : static struct queue_sysfs_entry queue_fua_entry = {
     701                 :            :         .attr = {.name = "fua", .mode = 0444 },
     702                 :            :         .show = queue_fua_show,
     703                 :            : };
     704                 :            : 
     705                 :            : static struct queue_sysfs_entry queue_dax_entry = {
     706                 :            :         .attr = {.name = "dax", .mode = 0444 },
     707                 :            :         .show = queue_dax_show,
     708                 :            : };
     709                 :            : 
     710                 :            : static struct queue_sysfs_entry queue_io_timeout_entry = {
     711                 :            :         .attr = {.name = "io_timeout", .mode = 0644 },
     712                 :            :         .show = queue_io_timeout_show,
     713                 :            :         .store = queue_io_timeout_store,
     714                 :            : };
     715                 :            : 
     716                 :            : static struct queue_sysfs_entry queue_wb_lat_entry = {
     717                 :            :         .attr = {.name = "wbt_lat_usec", .mode = 0644 },
     718                 :            :         .show = queue_wb_lat_show,
     719                 :            :         .store = queue_wb_lat_store,
     720                 :            : };
     721                 :            : 
     722                 :            : #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
     723                 :            : static struct queue_sysfs_entry throtl_sample_time_entry = {
     724                 :            :         .attr = {.name = "throttle_sample_time", .mode = 0644 },
     725                 :            :         .show = blk_throtl_sample_time_show,
     726                 :            :         .store = blk_throtl_sample_time_store,
     727                 :            : };
     728                 :            : #endif
     729                 :            : 
     730                 :            : static struct attribute *queue_attrs[] = {
     731                 :            :         &queue_requests_entry.attr,
     732                 :            :         &queue_ra_entry.attr,
     733                 :            :         &queue_max_hw_sectors_entry.attr,
     734                 :            :         &queue_max_sectors_entry.attr,
     735                 :            :         &queue_max_segments_entry.attr,
     736                 :            :         &queue_max_discard_segments_entry.attr,
     737                 :            :         &queue_max_integrity_segments_entry.attr,
     738                 :            :         &queue_max_segment_size_entry.attr,
     739                 :            :         &queue_iosched_entry.attr,
     740                 :            :         &queue_hw_sector_size_entry.attr,
     741                 :            :         &queue_logical_block_size_entry.attr,
     742                 :            :         &queue_physical_block_size_entry.attr,
     743                 :            :         &queue_chunk_sectors_entry.attr,
     744                 :            :         &queue_io_min_entry.attr,
     745                 :            :         &queue_io_opt_entry.attr,
     746                 :            :         &queue_discard_granularity_entry.attr,
     747                 :            :         &queue_discard_max_entry.attr,
     748                 :            :         &queue_discard_max_hw_entry.attr,
     749                 :            :         &queue_discard_zeroes_data_entry.attr,
     750                 :            :         &queue_write_same_max_entry.attr,
     751                 :            :         &queue_write_zeroes_max_entry.attr,
     752                 :            :         &queue_nonrot_entry.attr,
     753                 :            :         &queue_zoned_entry.attr,
     754                 :            :         &queue_nr_zones_entry.attr,
     755                 :            :         &queue_nomerges_entry.attr,
     756                 :            :         &queue_rq_affinity_entry.attr,
     757                 :            :         &queue_iostats_entry.attr,
     758                 :            :         &queue_random_entry.attr,
     759                 :            :         &queue_poll_entry.attr,
     760                 :            :         &queue_wc_entry.attr,
     761                 :            :         &queue_fua_entry.attr,
     762                 :            :         &queue_dax_entry.attr,
     763                 :            :         &queue_wb_lat_entry.attr,
     764                 :            :         &queue_poll_delay_entry.attr,
     765                 :            :         &queue_io_timeout_entry.attr,
     766                 :            : #ifdef CONFIG_BLK_DEV_THROTTLING_LOW
     767                 :            :         &throtl_sample_time_entry.attr,
     768                 :            : #endif
     769                 :            :         NULL,
     770                 :            : };
     771                 :            : 
     772                 :          3 : static umode_t queue_attr_visible(struct kobject *kobj, struct attribute *attr,
     773                 :            :                                 int n)
     774                 :            : {
     775                 :            :         struct request_queue *q =
     776                 :            :                 container_of(kobj, struct request_queue, kobj);
     777                 :            : 
     778                 :          3 :         if (attr == &queue_io_timeout_entry.attr &&
     779                 :          3 :                 (!q->mq_ops || !q->mq_ops->timeout))
     780                 :            :                         return 0;
     781                 :            : 
     782                 :          3 :         return attr->mode;
     783                 :            : }
     784                 :            : 
     785                 :            : static struct attribute_group queue_attr_group = {
     786                 :            :         .attrs = queue_attrs,
     787                 :            :         .is_visible = queue_attr_visible,
     788                 :            : };
     789                 :            : 
     790                 :            : 
     791                 :            : #define to_queue(atr) container_of((atr), struct queue_sysfs_entry, attr)
     792                 :            : 
     793                 :            : static ssize_t
     794                 :          3 : queue_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
     795                 :            : {
     796                 :            :         struct queue_sysfs_entry *entry = to_queue(attr);
     797                 :            :         struct request_queue *q =
     798                 :          3 :                 container_of(kobj, struct request_queue, kobj);
     799                 :            :         ssize_t res;
     800                 :            : 
     801                 :          3 :         if (!entry->show)
     802                 :            :                 return -EIO;
     803                 :          3 :         mutex_lock(&q->sysfs_lock);
     804                 :          3 :         if (blk_queue_dying(q)) {
     805                 :          0 :                 mutex_unlock(&q->sysfs_lock);
     806                 :          0 :                 return -ENOENT;
     807                 :            :         }
     808                 :          3 :         res = entry->show(q, page);
     809                 :          3 :         mutex_unlock(&q->sysfs_lock);
     810                 :          3 :         return res;
     811                 :            : }
     812                 :            : 
     813                 :            : static ssize_t
     814                 :          0 : queue_attr_store(struct kobject *kobj, struct attribute *attr,
     815                 :            :                     const char *page, size_t length)
     816                 :            : {
     817                 :            :         struct queue_sysfs_entry *entry = to_queue(attr);
     818                 :            :         struct request_queue *q;
     819                 :            :         ssize_t res;
     820                 :            : 
     821                 :          0 :         if (!entry->store)
     822                 :            :                 return -EIO;
     823                 :            : 
     824                 :          0 :         q = container_of(kobj, struct request_queue, kobj);
     825                 :          0 :         mutex_lock(&q->sysfs_lock);
     826                 :          0 :         if (blk_queue_dying(q)) {
     827                 :          0 :                 mutex_unlock(&q->sysfs_lock);
     828                 :          0 :                 return -ENOENT;
     829                 :            :         }
     830                 :          0 :         res = entry->store(q, page, length);
     831                 :          0 :         mutex_unlock(&q->sysfs_lock);
     832                 :          0 :         return res;
     833                 :            : }
     834                 :            : 
     835                 :          0 : static void blk_free_queue_rcu(struct rcu_head *rcu_head)
     836                 :            : {
     837                 :          0 :         struct request_queue *q = container_of(rcu_head, struct request_queue,
     838                 :            :                                                rcu_head);
     839                 :          0 :         kmem_cache_free(blk_requestq_cachep, q);
     840                 :          0 : }
     841                 :            : 
     842                 :            : /* Unconfigure the I/O scheduler and dissociate from the cgroup controller. */
     843                 :          0 : static void blk_exit_queue(struct request_queue *q)
     844                 :            : {
     845                 :            :         /*
     846                 :            :          * Since the I/O scheduler exit code may access cgroup information,
     847                 :            :          * perform I/O scheduler exit before disassociating from the block
     848                 :            :          * cgroup controller.
     849                 :            :          */
     850                 :          0 :         if (q->elevator) {
     851                 :          0 :                 ioc_clear_queue(q);
     852                 :          0 :                 __elevator_exit(q, q->elevator);
     853                 :          0 :                 q->elevator = NULL;
     854                 :            :         }
     855                 :            : 
     856                 :            :         /*
     857                 :            :          * Remove all references to @q from the block cgroup controller before
     858                 :            :          * restoring @q->queue_lock to avoid that restoring this pointer causes
     859                 :            :          * e.g. blkcg_print_blkgs() to crash.
     860                 :            :          */
     861                 :          0 :         blkcg_exit_queue(q);
     862                 :            : 
     863                 :            :         /*
     864                 :            :          * Since the cgroup code may dereference the @q->backing_dev_info
     865                 :            :          * pointer, only decrease its reference count after having removed the
     866                 :            :          * association with the block cgroup controller.
     867                 :            :          */
     868                 :          0 :         bdi_put(q->backing_dev_info);
     869                 :          0 : }
     870                 :            : 
     871                 :            : 
     872                 :            : /**
     873                 :            :  * __blk_release_queue - release a request queue
     874                 :            :  * @work: pointer to the release_work member of the request queue to be released
     875                 :            :  *
     876                 :            :  * Description:
     877                 :            :  *     This function is called when a block device is being unregistered. The
     878                 :            :  *     process of releasing a request queue starts with blk_cleanup_queue, which
     879                 :            :  *     set the appropriate flags and then calls blk_put_queue, that decrements
     880                 :            :  *     the reference counter of the request queue. Once the reference counter
     881                 :            :  *     of the request queue reaches zero, blk_release_queue is called to release
     882                 :            :  *     all allocated resources of the request queue.
     883                 :            :  */
     884                 :          0 : static void __blk_release_queue(struct work_struct *work)
     885                 :            : {
     886                 :          0 :         struct request_queue *q = container_of(work, typeof(*q), release_work);
     887                 :            : 
     888                 :          0 :         if (test_bit(QUEUE_FLAG_POLL_STATS, &q->queue_flags))
     889                 :          0 :                 blk_stat_remove_callback(q, q->poll_cb);
     890                 :          0 :         blk_stat_free_callback(q->poll_cb);
     891                 :            : 
     892                 :          0 :         blk_free_queue_stats(q->stats);
     893                 :            : 
     894                 :          0 :         if (queue_is_mq(q))
     895                 :          0 :                 cancel_delayed_work_sync(&q->requeue_work);
     896                 :            : 
     897                 :          0 :         blk_exit_queue(q);
     898                 :            : 
     899                 :            :         blk_queue_free_zone_bitmaps(q);
     900                 :            : 
     901                 :          0 :         if (queue_is_mq(q))
     902                 :          0 :                 blk_mq_release(q);
     903                 :            : 
     904                 :          0 :         blk_trace_shutdown(q);
     905                 :            : 
     906                 :          0 :         if (queue_is_mq(q))
     907                 :          0 :                 blk_mq_debugfs_unregister(q);
     908                 :            : 
     909                 :          0 :         bioset_exit(&q->bio_split);
     910                 :            : 
     911                 :          0 :         ida_simple_remove(&blk_queue_ida, q->id);
     912                 :          0 :         call_rcu(&q->rcu_head, blk_free_queue_rcu);
     913                 :          0 : }
     914                 :            : 
     915                 :          0 : static void blk_release_queue(struct kobject *kobj)
     916                 :            : {
     917                 :            :         struct request_queue *q =
     918                 :            :                 container_of(kobj, struct request_queue, kobj);
     919                 :            : 
     920                 :          0 :         INIT_WORK(&q->release_work, __blk_release_queue);
     921                 :          0 :         schedule_work(&q->release_work);
     922                 :          0 : }
     923                 :            : 
     924                 :            : static const struct sysfs_ops queue_sysfs_ops = {
     925                 :            :         .show   = queue_attr_show,
     926                 :            :         .store  = queue_attr_store,
     927                 :            : };
     928                 :            : 
     929                 :            : struct kobj_type blk_queue_ktype = {
     930                 :            :         .sysfs_ops      = &queue_sysfs_ops,
     931                 :            :         .release        = blk_release_queue,
     932                 :            : };
     933                 :            : 
     934                 :            : /**
     935                 :            :  * blk_register_queue - register a block layer queue with sysfs
     936                 :            :  * @disk: Disk of which the request queue should be registered with sysfs.
     937                 :            :  */
     938                 :          3 : int blk_register_queue(struct gendisk *disk)
     939                 :            : {
     940                 :            :         int ret;
     941                 :          3 :         struct device *dev = disk_to_dev(disk);
     942                 :          3 :         struct request_queue *q = disk->queue;
     943                 :            :         bool has_elevator = false;
     944                 :            : 
     945                 :          3 :         if (WARN_ON(!q))
     946                 :            :                 return -ENXIO;
     947                 :            : 
     948                 :          3 :         WARN_ONCE(blk_queue_registered(q),
     949                 :            :                   "%s is registering an already registered queue\n",
     950                 :            :                   kobject_name(&dev->kobj));
     951                 :            : 
     952                 :            :         /*
     953                 :            :          * SCSI probing may synchronously create and destroy a lot of
     954                 :            :          * request_queues for non-existent devices.  Shutting down a fully
     955                 :            :          * functional queue takes measureable wallclock time as RCU grace
     956                 :            :          * periods are involved.  To avoid excessive latency in these
     957                 :            :          * cases, a request_queue starts out in a degraded mode which is
     958                 :            :          * faster to shut down and is made fully functional here as
     959                 :            :          * request_queues for non-existent devices never get registered.
     960                 :            :          */
     961                 :          3 :         if (!blk_queue_init_done(q)) {
     962                 :          3 :                 blk_queue_flag_set(QUEUE_FLAG_INIT_DONE, q);
     963                 :          3 :                 percpu_ref_switch_to_percpu(&q->q_usage_counter);
     964                 :            :         }
     965                 :            : 
     966                 :          3 :         ret = blk_trace_init_sysfs(dev);
     967                 :          3 :         if (ret)
     968                 :            :                 return ret;
     969                 :            : 
     970                 :          3 :         mutex_lock(&q->sysfs_dir_lock);
     971                 :            : 
     972                 :          3 :         ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
     973                 :          3 :         if (ret < 0) {
     974                 :          0 :                 blk_trace_remove_sysfs(dev);
     975                 :          0 :                 goto unlock;
     976                 :            :         }
     977                 :            : 
     978                 :          3 :         ret = sysfs_create_group(&q->kobj, &queue_attr_group);
     979                 :          3 :         if (ret) {
     980                 :          0 :                 blk_trace_remove_sysfs(dev);
     981                 :          0 :                 kobject_del(&q->kobj);
     982                 :          0 :                 kobject_put(&dev->kobj);
     983                 :          0 :                 goto unlock;
     984                 :            :         }
     985                 :            : 
     986                 :          3 :         if (queue_is_mq(q)) {
     987                 :          3 :                 __blk_mq_register_dev(dev, q);
     988                 :          3 :                 blk_mq_debugfs_register(q);
     989                 :            :         }
     990                 :            : 
     991                 :          3 :         mutex_lock(&q->sysfs_lock);
     992                 :          3 :         if (q->elevator) {
     993                 :          3 :                 ret = elv_register_queue(q, false);
     994                 :          3 :                 if (ret) {
     995                 :          0 :                         mutex_unlock(&q->sysfs_lock);
     996                 :          0 :                         mutex_unlock(&q->sysfs_dir_lock);
     997                 :          0 :                         kobject_del(&q->kobj);
     998                 :          0 :                         blk_trace_remove_sysfs(dev);
     999                 :          0 :                         kobject_put(&dev->kobj);
    1000                 :          0 :                         return ret;
    1001                 :            :                 }
    1002                 :            :                 has_elevator = true;
    1003                 :            :         }
    1004                 :            : 
    1005                 :          3 :         blk_queue_flag_set(QUEUE_FLAG_REGISTERED, q);
    1006                 :            :         wbt_enable_default(q);
    1007                 :            :         blk_throtl_register_queue(q);
    1008                 :            : 
    1009                 :            :         /* Now everything is ready and send out KOBJ_ADD uevent */
    1010                 :          3 :         kobject_uevent(&q->kobj, KOBJ_ADD);
    1011                 :          3 :         if (has_elevator)
    1012                 :          3 :                 kobject_uevent(&q->elevator->kobj, KOBJ_ADD);
    1013                 :          3 :         mutex_unlock(&q->sysfs_lock);
    1014                 :            : 
    1015                 :            :         ret = 0;
    1016                 :            : unlock:
    1017                 :          3 :         mutex_unlock(&q->sysfs_dir_lock);
    1018                 :          3 :         return ret;
    1019                 :            : }
    1020                 :            : EXPORT_SYMBOL_GPL(blk_register_queue);
    1021                 :            : 
    1022                 :            : /**
    1023                 :            :  * blk_unregister_queue - counterpart of blk_register_queue()
    1024                 :            :  * @disk: Disk of which the request queue should be unregistered from sysfs.
    1025                 :            :  *
    1026                 :            :  * Note: the caller is responsible for guaranteeing that this function is called
    1027                 :            :  * after blk_register_queue() has finished.
    1028                 :            :  */
    1029                 :          0 : void blk_unregister_queue(struct gendisk *disk)
    1030                 :            : {
    1031                 :          0 :         struct request_queue *q = disk->queue;
    1032                 :            : 
    1033                 :          0 :         if (WARN_ON(!q))
    1034                 :            :                 return;
    1035                 :            : 
    1036                 :            :         /* Return early if disk->queue was never registered. */
    1037                 :          0 :         if (!blk_queue_registered(q))
    1038                 :            :                 return;
    1039                 :            : 
    1040                 :            :         /*
    1041                 :            :          * Since sysfs_remove_dir() prevents adding new directory entries
    1042                 :            :          * before removal of existing entries starts, protect against
    1043                 :            :          * concurrent elv_iosched_store() calls.
    1044                 :            :          */
    1045                 :          0 :         mutex_lock(&q->sysfs_lock);
    1046                 :          0 :         blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q);
    1047                 :          0 :         mutex_unlock(&q->sysfs_lock);
    1048                 :            : 
    1049                 :          0 :         mutex_lock(&q->sysfs_dir_lock);
    1050                 :            :         /*
    1051                 :            :          * Remove the sysfs attributes before unregistering the queue data
    1052                 :            :          * structures that can be modified through sysfs.
    1053                 :            :          */
    1054                 :          0 :         if (queue_is_mq(q))
    1055                 :          0 :                 blk_mq_unregister_dev(disk_to_dev(disk), q);
    1056                 :            : 
    1057                 :          0 :         kobject_uevent(&q->kobj, KOBJ_REMOVE);
    1058                 :          0 :         kobject_del(&q->kobj);
    1059                 :          0 :         blk_trace_remove_sysfs(disk_to_dev(disk));
    1060                 :            : 
    1061                 :          0 :         mutex_lock(&q->sysfs_lock);
    1062                 :          0 :         if (q->elevator)
    1063                 :          0 :                 elv_unregister_queue(q);
    1064                 :          0 :         mutex_unlock(&q->sysfs_lock);
    1065                 :          0 :         mutex_unlock(&q->sysfs_dir_lock);
    1066                 :            : 
    1067                 :          0 :         kobject_put(&disk_to_dev(disk)->kobj);
    1068                 :            : }
    

Generated by: LCOV version 1.14