Merge tag 'for-4.19/post-20180822' of git://git.kernel.dk/linux-block
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 22 Aug 2018 20:38:05 +0000 (13:38 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 22 Aug 2018 20:38:05 +0000 (13:38 -0700)
Pull more block updates from Jens Axboe:

 - Set of bcache fixes and changes (Coly)

 - The flush warn fix (me)

 - Small series of BFQ fixes (Paolo)

 - wbt hang fix (Ming)

 - blktrace fix (Steven)

 - blk-mq hardware queue count update fix (Jianchao)

 - Various little fixes

* tag 'for-4.19/post-20180822' of git://git.kernel.dk/linux-block: (31 commits)
  block/DAC960.c: make some arrays static const, shrinks object size
  blk-mq: sync the update nr_hw_queues with blk_mq_queue_tag_busy_iter
  blk-mq: init hctx sched after update ctx and hctx mapping
  block: remove duplicate initialization
  tracing/blktrace: Fix to allow setting same value
  pktcdvd: fix setting of 'ret' error return for a few cases
  block: change return type to bool
  block, bfq: return nbytes and not zero from struct cftype .write() method
  block, bfq: improve code of bfq_bfqq_charge_time
  block, bfq: reduce write overcharge
  block, bfq: always update the budget of an entity when needed
  block, bfq: readd missing reset of parent-entity service
  blk-wbt: fix IO hang in wbt_wait()
  block: don't warn for flush on read-only device
  bcache: add the missing comments for smp_mb()/smp_wmb()
  bcache: remove unnecessary space before ioctl function pointer arguments
  bcache: add missing SPDX header
  bcache: move open brace at end of function definitions to next line
  bcache: add static const prefix to char * array declarations
  bcache: fix code comments style
  ...

1  2 
block/blk-core.c
block/blk-mq-tag.c
block/blk-mq.c
drivers/md/bcache/Kconfig
drivers/md/bcache/util.c
drivers/md/bcache/util.h
kernel/trace/blktrace.c

diff --combined block/blk-core.c
index 12550340418d950dccc3e27b615a6dace19b8b48,5832c4003cfb7d09974acd02c1e7aaf3ac0c52a8..dee56c282efb092196cd9be8400b6bc68c7f7f27
@@@ -1036,7 -1036,6 +1036,6 @@@ struct request_queue *blk_alloc_queue_n
                    laptop_mode_timer_fn, 0);
        timer_setup(&q->timeout, blk_rq_timed_out_timer, 0);
        INIT_WORK(&q->timeout_work, NULL);
-       INIT_LIST_HEAD(&q->queue_head);
        INIT_LIST_HEAD(&q->timeout_list);
        INIT_LIST_HEAD(&q->icq_list);
  #ifdef CONFIG_BLK_CGROUP
@@@ -2162,15 -2161,16 +2161,17 @@@ static inline bool should_fail_request(
  
  static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part)
  {
-       if (part->policy && op_is_write(bio_op(bio))) {
+       const int op = bio_op(bio);
+       if (part->policy && (op_is_write(op) && !op_is_flush(op))) {
                char b[BDEVNAME_SIZE];
  
 -              printk(KERN_ERR
 +              WARN_ONCE(1,
                       "generic_make_request: Trying to write "
                        "to read-only block-device %s (partno %d)\n",
                        bio_devname(bio, b), part->partno);
 -              return true;
 +              /* Older lvm-tools actually trigger this */
 +              return false;
        }
  
        return false;
diff --combined block/blk-mq-tag.c
index 816923bf874d7c8eb55ed640735caab5131022a4,8c5cc115b3f87aeace91469abb7f8d9961bf8d6d..94e1ed667b6ea383a99f1cd76d6917af0d2a1ba6
@@@ -274,7 -274,7 +274,7 @@@ static bool bt_tags_iter(struct sbitma
         * test and set the bit before assining ->rqs[].
         */
        rq = tags->rqs[bitnr];
 -      if (rq && blk_mq_rq_state(rq) == MQ_RQ_IN_FLIGHT)
 +      if (rq && blk_mq_request_started(rq))
                iter_data->fn(rq, iter_data->data, reserved);
  
        return true;
@@@ -320,6 -320,18 +320,18 @@@ void blk_mq_queue_tag_busy_iter(struct 
        struct blk_mq_hw_ctx *hctx;
        int i;
  
+       /*
+        * __blk_mq_update_nr_hw_queues will update the nr_hw_queues and
+        * queue_hw_ctx after freeze the queue. So we could use q_usage_counter
+        * to avoid race with it. __blk_mq_update_nr_hw_queues will users
+        * synchronize_rcu to ensure all of the users go out of the critical
+        * section below and see zeroed q_usage_counter.
+        */
+       rcu_read_lock();
+       if (percpu_ref_is_zero(&q->q_usage_counter)) {
+               rcu_read_unlock();
+               return;
+       }
  
        queue_for_each_hw_ctx(q, hctx, i) {
                struct blk_mq_tags *tags = hctx->tags;
                        bt_for_each(hctx, &tags->breserved_tags, fn, priv, true);
                bt_for_each(hctx, &tags->bitmap_tags, fn, priv, false);
        }
+       rcu_read_unlock();
  }
  
  static int bt_alloc(struct sbitmap_queue *bt, unsigned int depth,
diff --combined block/blk-mq.c
index 72a0033ccee92af029ccc1219fbeb4fc7c127455,81cb84b17b7373d9b4b1170e389bc725490a0d32..85a1c1a59c72716ce2e31c280d7fd43d5c6e61e9
@@@ -560,8 -560,10 +560,8 @@@ static void __blk_mq_complete_request(s
        bool shared = false;
        int cpu;
  
 -      if (cmpxchg(&rq->state, MQ_RQ_IN_FLIGHT, MQ_RQ_COMPLETE) !=
 -                      MQ_RQ_IN_FLIGHT)
 +      if (!blk_mq_mark_complete(rq))
                return;
 -
        if (rq->internal_tag != -1)
                blk_mq_sched_completed_request(rq);
  
@@@ -2145,8 -2147,6 +2145,6 @@@ static void blk_mq_exit_hctx(struct req
        if (set->ops->exit_request)
                set->ops->exit_request(set, hctx->fq->flush_rq, hctx_idx);
  
-       blk_mq_sched_exit_hctx(q, hctx, hctx_idx);
        if (set->ops->exit_hctx)
                set->ops->exit_hctx(hctx, hctx_idx);
  
@@@ -2214,12 -2214,9 +2212,9 @@@ static int blk_mq_init_hctx(struct requ
            set->ops->init_hctx(hctx, set->driver_data, hctx_idx))
                goto free_bitmap;
  
-       if (blk_mq_sched_init_hctx(q, hctx, hctx_idx))
-               goto exit_hctx;
        hctx->fq = blk_alloc_flush_queue(q, hctx->numa_node, set->cmd_size);
        if (!hctx->fq)
-               goto sched_exit_hctx;
+               goto exit_hctx;
  
        if (blk_mq_init_request(set, hctx->fq->flush_rq, hctx_idx, node))
                goto free_fq;
  
   free_fq:
        kfree(hctx->fq);
-  sched_exit_hctx:
-       blk_mq_sched_exit_hctx(q, hctx, hctx_idx);
   exit_hctx:
        if (set->ops->exit_hctx)
                set->ops->exit_hctx(hctx, hctx_idx);
@@@ -2896,10 -2891,81 +2889,81 @@@ int blk_mq_update_nr_requests(struct re
        return ret;
  }
  
+ /*
+  * request_queue and elevator_type pair.
+  * It is just used by __blk_mq_update_nr_hw_queues to cache
+  * the elevator_type associated with a request_queue.
+  */
+ struct blk_mq_qe_pair {
+       struct list_head node;
+       struct request_queue *q;
+       struct elevator_type *type;
+ };
+ /*
+  * Cache the elevator_type in qe pair list and switch the
+  * io scheduler to 'none'
+  */
+ static bool blk_mq_elv_switch_none(struct list_head *head,
+               struct request_queue *q)
+ {
+       struct blk_mq_qe_pair *qe;
+       if (!q->elevator)
+               return true;
+       qe = kmalloc(sizeof(*qe), GFP_NOIO | __GFP_NOWARN | __GFP_NORETRY);
+       if (!qe)
+               return false;
+       INIT_LIST_HEAD(&qe->node);
+       qe->q = q;
+       qe->type = q->elevator->type;
+       list_add(&qe->node, head);
+       mutex_lock(&q->sysfs_lock);
+       /*
+        * After elevator_switch_mq, the previous elevator_queue will be
+        * released by elevator_release. The reference of the io scheduler
+        * module get by elevator_get will also be put. So we need to get
+        * a reference of the io scheduler module here to prevent it to be
+        * removed.
+        */
+       __module_get(qe->type->elevator_owner);
+       elevator_switch_mq(q, NULL);
+       mutex_unlock(&q->sysfs_lock);
+       return true;
+ }
+ static void blk_mq_elv_switch_back(struct list_head *head,
+               struct request_queue *q)
+ {
+       struct blk_mq_qe_pair *qe;
+       struct elevator_type *t = NULL;
+       list_for_each_entry(qe, head, node)
+               if (qe->q == q) {
+                       t = qe->type;
+                       break;
+               }
+       if (!t)
+               return;
+       list_del(&qe->node);
+       kfree(qe);
+       mutex_lock(&q->sysfs_lock);
+       elevator_switch_mq(q, t);
+       mutex_unlock(&q->sysfs_lock);
+ }
  static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
                                                        int nr_hw_queues)
  {
        struct request_queue *q;
+       LIST_HEAD(head);
  
        lockdep_assert_held(&set->tag_list_lock);
  
  
        list_for_each_entry(q, &set->tag_list, tag_set_list)
                blk_mq_freeze_queue(q);
+       /*
+        * Sync with blk_mq_queue_tag_busy_iter.
+        */
+       synchronize_rcu();
+       /*
+        * Switch IO scheduler to 'none', cleaning up the data associated
+        * with the previous scheduler. We will switch back once we are done
+        * updating the new sw to hw queue mappings.
+        */
+       list_for_each_entry(q, &set->tag_list, tag_set_list)
+               if (!blk_mq_elv_switch_none(&head, q))
+                       goto switch_back;
  
        set->nr_hw_queues = nr_hw_queues;
        blk_mq_update_queue_map(set);
                blk_mq_queue_reinit(q);
        }
  
+ switch_back:
+       list_for_each_entry(q, &set->tag_list, tag_set_list)
+               blk_mq_elv_switch_back(&head, q);
        list_for_each_entry(q, &set->tag_list, tag_set_list)
                blk_mq_unfreeze_queue(q);
  }
index af247298409aadc6d7a91d3450f69e545999c73f,817b9fba50db507051dcdaa09307462f445ca50c..f6e0a8b3a61ed34b7b36e02c639c5e7507c23857
@@@ -1,8 -1,7 +1,8 @@@
  
  config BCACHE
        tristate "Block device as cache"
-       ---help---
 +      select CRC64
+       help
        Allows a block device to be used as cache for other devices; uses
        a btree for indexing and the layout is optimized for SSDs.
  
@@@ -11,7 -10,7 +11,7 @@@
  config BCACHE_DEBUG
        bool "Bcache debugging"
        depends on BCACHE
-       ---help---
+       help
        Don't select this option unless you're a developer
  
        Enables extra debugging tools, allows expensive runtime checks to be
@@@ -21,7 -20,7 +21,7 @@@ config BCACHE_CLOSURES_DEBU
        bool "Debug closures"
        depends on BCACHE
        select DEBUG_FS
-       ---help---
+       help
        Keeps all active closures in a linked list and provides a debugfs
        interface to list them, which makes it possible to see asynchronous
        operations that get stuck.
diff --combined drivers/md/bcache/util.c
index c6a99dfa1ad9e80756a5b8ef2982f0cc31d7bf9f,e873b0f7a82a86cba0af47e3be955a5a11ac7261..20eddeac1531a93d4a2bd3077b4645e600e342b1
@@@ -1,3 -1,4 +1,4 @@@
+ // SPDX-License-Identifier: GPL-2.0
  /*
   * random utiility code, for bcache but in theory not specific to bcache
   *
@@@ -133,6 -134,7 +134,7 @@@ bool bch_is_zero(const char *p, size_t 
  int bch_parse_uuid(const char *s, char *uuid)
  {
        size_t i, j, x;
        memset(uuid, 0, 16);
  
        for (i = 0, j = 0;
@@@ -279,3 -281,134 +281,3 @@@ int bch_bio_alloc_pages(struct bio *bio
  
        return 0;
  }
 -
 -/*
 - * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group (Any
 - * use permitted, subject to terms of PostgreSQL license; see.)
 -
 - * If we have a 64-bit integer type, then a 64-bit CRC looks just like the
 - * usual sort of implementation. (See Ross Williams' excellent introduction
 - * A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS, available from
 - * ftp://ftp.rocksoft.com/papers/crc_v3.txt or several other net sites.)
 - * If we have no working 64-bit type, then fake it with two 32-bit registers.
 - *
 - * The present implementation is a normal (not "reflected", in Williams'
 - * terms) 64-bit CRC, using initial all-ones register contents and a final
 - * bit inversion. The chosen polynomial is borrowed from the DLT1 spec
 - * (ECMA-182, available from http://www.ecma.ch/ecma1/STAND/ECMA-182.HTM):
 - *
 - * x^64 + x^62 + x^57 + x^55 + x^54 + x^53 + x^52 + x^47 + x^46 + x^45 +
 - * x^40 + x^39 + x^38 + x^37 + x^35 + x^33 + x^32 + x^31 + x^29 + x^27 +
 - * x^24 + x^23 + x^22 + x^21 + x^19 + x^17 + x^13 + x^12 + x^10 + x^9 +
 - * x^7 + x^4 + x + 1
 -*/
 -
 -static const uint64_t crc_table[256] = {
 -      0x0000000000000000ULL, 0x42F0E1EBA9EA3693ULL, 0x85E1C3D753D46D26ULL,
 -      0xC711223CFA3E5BB5ULL, 0x493366450E42ECDFULL, 0x0BC387AEA7A8DA4CULL,
 -      0xCCD2A5925D9681F9ULL, 0x8E224479F47CB76AULL, 0x9266CC8A1C85D9BEULL,
 -      0xD0962D61B56FEF2DULL, 0x17870F5D4F51B498ULL, 0x5577EEB6E6BB820BULL,
 -      0xDB55AACF12C73561ULL, 0x99A54B24BB2D03F2ULL, 0x5EB4691841135847ULL,
 -      0x1C4488F3E8F96ED4ULL, 0x663D78FF90E185EFULL, 0x24CD9914390BB37CULL,
 -      0xE3DCBB28C335E8C9ULL, 0xA12C5AC36ADFDE5AULL, 0x2F0E1EBA9EA36930ULL,
 -      0x6DFEFF5137495FA3ULL, 0xAAEFDD6DCD770416ULL, 0xE81F3C86649D3285ULL,
 -      0xF45BB4758C645C51ULL, 0xB6AB559E258E6AC2ULL, 0x71BA77A2DFB03177ULL,
 -      0x334A9649765A07E4ULL, 0xBD68D2308226B08EULL, 0xFF9833DB2BCC861DULL,
 -      0x388911E7D1F2DDA8ULL, 0x7A79F00C7818EB3BULL, 0xCC7AF1FF21C30BDEULL,
 -      0x8E8A101488293D4DULL, 0x499B3228721766F8ULL, 0x0B6BD3C3DBFD506BULL,
 -      0x854997BA2F81E701ULL, 0xC7B97651866BD192ULL, 0x00A8546D7C558A27ULL,
 -      0x4258B586D5BFBCB4ULL, 0x5E1C3D753D46D260ULL, 0x1CECDC9E94ACE4F3ULL,
 -      0xDBFDFEA26E92BF46ULL, 0x990D1F49C77889D5ULL, 0x172F5B3033043EBFULL,
 -      0x55DFBADB9AEE082CULL, 0x92CE98E760D05399ULL, 0xD03E790CC93A650AULL,
 -      0xAA478900B1228E31ULL, 0xE8B768EB18C8B8A2ULL, 0x2FA64AD7E2F6E317ULL,
 -      0x6D56AB3C4B1CD584ULL, 0xE374EF45BF6062EEULL, 0xA1840EAE168A547DULL,
 -      0x66952C92ECB40FC8ULL, 0x2465CD79455E395BULL, 0x3821458AADA7578FULL,
 -      0x7AD1A461044D611CULL, 0xBDC0865DFE733AA9ULL, 0xFF3067B657990C3AULL,
 -      0x711223CFA3E5BB50ULL, 0x33E2C2240A0F8DC3ULL, 0xF4F3E018F031D676ULL,
 -      0xB60301F359DBE0E5ULL, 0xDA050215EA6C212FULL, 0x98F5E3FE438617BCULL,
 -      0x5FE4C1C2B9B84C09ULL, 0x1D14202910527A9AULL, 0x93366450E42ECDF0ULL,
 -      0xD1C685BB4DC4FB63ULL, 0x16D7A787B7FAA0D6ULL, 0x5427466C1E109645ULL,
 -      0x4863CE9FF6E9F891ULL, 0x0A932F745F03CE02ULL, 0xCD820D48A53D95B7ULL,
 -      0x8F72ECA30CD7A324ULL, 0x0150A8DAF8AB144EULL, 0x43A04931514122DDULL,
 -      0x84B16B0DAB7F7968ULL, 0xC6418AE602954FFBULL, 0xBC387AEA7A8DA4C0ULL,
 -      0xFEC89B01D3679253ULL, 0x39D9B93D2959C9E6ULL, 0x7B2958D680B3FF75ULL,
 -      0xF50B1CAF74CF481FULL, 0xB7FBFD44DD257E8CULL, 0x70EADF78271B2539ULL,
 -      0x321A3E938EF113AAULL, 0x2E5EB66066087D7EULL, 0x6CAE578BCFE24BEDULL,
 -      0xABBF75B735DC1058ULL, 0xE94F945C9C3626CBULL, 0x676DD025684A91A1ULL,
 -      0x259D31CEC1A0A732ULL, 0xE28C13F23B9EFC87ULL, 0xA07CF2199274CA14ULL,
 -      0x167FF3EACBAF2AF1ULL, 0x548F120162451C62ULL, 0x939E303D987B47D7ULL,
 -      0xD16ED1D631917144ULL, 0x5F4C95AFC5EDC62EULL, 0x1DBC74446C07F0BDULL,
 -      0xDAAD56789639AB08ULL, 0x985DB7933FD39D9BULL, 0x84193F60D72AF34FULL,
 -      0xC6E9DE8B7EC0C5DCULL, 0x01F8FCB784FE9E69ULL, 0x43081D5C2D14A8FAULL,
 -      0xCD2A5925D9681F90ULL, 0x8FDAB8CE70822903ULL, 0x48CB9AF28ABC72B6ULL,
 -      0x0A3B7B1923564425ULL, 0x70428B155B4EAF1EULL, 0x32B26AFEF2A4998DULL,
 -      0xF5A348C2089AC238ULL, 0xB753A929A170F4ABULL, 0x3971ED50550C43C1ULL,
 -      0x7B810CBBFCE67552ULL, 0xBC902E8706D82EE7ULL, 0xFE60CF6CAF321874ULL,
 -      0xE224479F47CB76A0ULL, 0xA0D4A674EE214033ULL, 0x67C58448141F1B86ULL,
 -      0x253565A3BDF52D15ULL, 0xAB1721DA49899A7FULL, 0xE9E7C031E063ACECULL,
 -      0x2EF6E20D1A5DF759ULL, 0x6C0603E6B3B7C1CAULL, 0xF6FAE5C07D3274CDULL,
 -      0xB40A042BD4D8425EULL, 0x731B26172EE619EBULL, 0x31EBC7FC870C2F78ULL,
 -      0xBFC9838573709812ULL, 0xFD39626EDA9AAE81ULL, 0x3A28405220A4F534ULL,
 -      0x78D8A1B9894EC3A7ULL, 0x649C294A61B7AD73ULL, 0x266CC8A1C85D9BE0ULL,
 -      0xE17DEA9D3263C055ULL, 0xA38D0B769B89F6C6ULL, 0x2DAF4F0F6FF541ACULL,
 -      0x6F5FAEE4C61F773FULL, 0xA84E8CD83C212C8AULL, 0xEABE6D3395CB1A19ULL,
 -      0x90C79D3FEDD3F122ULL, 0xD2377CD44439C7B1ULL, 0x15265EE8BE079C04ULL,
 -      0x57D6BF0317EDAA97ULL, 0xD9F4FB7AE3911DFDULL, 0x9B041A914A7B2B6EULL,
 -      0x5C1538ADB04570DBULL, 0x1EE5D94619AF4648ULL, 0x02A151B5F156289CULL,
 -      0x4051B05E58BC1E0FULL, 0x87409262A28245BAULL, 0xC5B073890B687329ULL,
 -      0x4B9237F0FF14C443ULL, 0x0962D61B56FEF2D0ULL, 0xCE73F427ACC0A965ULL,
 -      0x8C8315CC052A9FF6ULL, 0x3A80143F5CF17F13ULL, 0x7870F5D4F51B4980ULL,
 -      0xBF61D7E80F251235ULL, 0xFD913603A6CF24A6ULL, 0x73B3727A52B393CCULL,
 -      0x31439391FB59A55FULL, 0xF652B1AD0167FEEAULL, 0xB4A25046A88DC879ULL,
 -      0xA8E6D8B54074A6ADULL, 0xEA16395EE99E903EULL, 0x2D071B6213A0CB8BULL,
 -      0x6FF7FA89BA4AFD18ULL, 0xE1D5BEF04E364A72ULL, 0xA3255F1BE7DC7CE1ULL,
 -      0x64347D271DE22754ULL, 0x26C49CCCB40811C7ULL, 0x5CBD6CC0CC10FAFCULL,
 -      0x1E4D8D2B65FACC6FULL, 0xD95CAF179FC497DAULL, 0x9BAC4EFC362EA149ULL,
 -      0x158E0A85C2521623ULL, 0x577EEB6E6BB820B0ULL, 0x906FC95291867B05ULL,
 -      0xD29F28B9386C4D96ULL, 0xCEDBA04AD0952342ULL, 0x8C2B41A1797F15D1ULL,
 -      0x4B3A639D83414E64ULL, 0x09CA82762AAB78F7ULL, 0x87E8C60FDED7CF9DULL,
 -      0xC51827E4773DF90EULL, 0x020905D88D03A2BBULL, 0x40F9E43324E99428ULL,
 -      0x2CFFE7D5975E55E2ULL, 0x6E0F063E3EB46371ULL, 0xA91E2402C48A38C4ULL,
 -      0xEBEEC5E96D600E57ULL, 0x65CC8190991CB93DULL, 0x273C607B30F68FAEULL,
 -      0xE02D4247CAC8D41BULL, 0xA2DDA3AC6322E288ULL, 0xBE992B5F8BDB8C5CULL,
 -      0xFC69CAB42231BACFULL, 0x3B78E888D80FE17AULL, 0x7988096371E5D7E9ULL,
 -      0xF7AA4D1A85996083ULL, 0xB55AACF12C735610ULL, 0x724B8ECDD64D0DA5ULL,
 -      0x30BB6F267FA73B36ULL, 0x4AC29F2A07BFD00DULL, 0x08327EC1AE55E69EULL,
 -      0xCF235CFD546BBD2BULL, 0x8DD3BD16FD818BB8ULL, 0x03F1F96F09FD3CD2ULL,
 -      0x41011884A0170A41ULL, 0x86103AB85A2951F4ULL, 0xC4E0DB53F3C36767ULL,
 -      0xD8A453A01B3A09B3ULL, 0x9A54B24BB2D03F20ULL, 0x5D45907748EE6495ULL,
 -      0x1FB5719CE1045206ULL, 0x919735E51578E56CULL, 0xD367D40EBC92D3FFULL,
 -      0x1476F63246AC884AULL, 0x568617D9EF46BED9ULL, 0xE085162AB69D5E3CULL,
 -      0xA275F7C11F7768AFULL, 0x6564D5FDE549331AULL, 0x279434164CA30589ULL,
 -      0xA9B6706FB8DFB2E3ULL, 0xEB46918411358470ULL, 0x2C57B3B8EB0BDFC5ULL,
 -      0x6EA7525342E1E956ULL, 0x72E3DAA0AA188782ULL, 0x30133B4B03F2B111ULL,
 -      0xF7021977F9CCEAA4ULL, 0xB5F2F89C5026DC37ULL, 0x3BD0BCE5A45A6B5DULL,
 -      0x79205D0E0DB05DCEULL, 0xBE317F32F78E067BULL, 0xFCC19ED95E6430E8ULL,
 -      0x86B86ED5267CDBD3ULL, 0xC4488F3E8F96ED40ULL, 0x0359AD0275A8B6F5ULL,
 -      0x41A94CE9DC428066ULL, 0xCF8B0890283E370CULL, 0x8D7BE97B81D4019FULL,
 -      0x4A6ACB477BEA5A2AULL, 0x089A2AACD2006CB9ULL, 0x14DEA25F3AF9026DULL,
 -      0x562E43B4931334FEULL, 0x913F6188692D6F4BULL, 0xD3CF8063C0C759D8ULL,
 -      0x5DEDC41A34BBEEB2ULL, 0x1F1D25F19D51D821ULL, 0xD80C07CD676F8394ULL,
 -      0x9AFCE626CE85B507ULL,
 -};
 -
 -uint64_t bch_crc64_update(uint64_t crc, const void *_data, size_t len)
 -{
 -      const unsigned char *data = _data;
 -
 -      while (len--) {
 -              int i = ((int) (crc >> 56) ^ *data++) & 0xFF;
 -              crc = crc_table[i] ^ (crc << 8);
 -      }
 -
 -      return crc;
 -}
 -
 -uint64_t bch_crc64(const void *data, size_t len)
 -{
 -      uint64_t crc = 0xffffffffffffffffULL;
 -
 -      crc = bch_crc64_update(crc, data, len);
 -
 -      return crc ^ 0xffffffffffffffffULL;
 -}
diff --combined drivers/md/bcache/util.h
index 5ff055f0a653fc384ec621351df906a7a851b9c2,4e0ed19e32d3f5ab68bdee4760c0fffc0c42644f..00aab6abcfe4fd3bb4e625780de0badee109dbf0
@@@ -11,7 -11,6 +11,7 @@@
  #include <linux/ratelimit.h>
  #include <linux/vmalloc.h>
  #include <linux/workqueue.h>
 +#include <linux/crc64.h>
  
  #include "closure.h"
  
@@@ -289,10 -288,10 +289,10 @@@ do {                                                                    
  #define ANYSINT_MAX(t)                                                        \
        ((((t) 1 << (sizeof(t) * 8 - 2)) - (t) 1) * (t) 2 + (t) 1)
  
- int bch_strtoint_h(const char *, int *);
- int bch_strtouint_h(const char *, unsigned int *);
- int bch_strtoll_h(const char *, long long *);
- int bch_strtoull_h(const char *, unsigned long long *);
+ int bch_strtoint_h(const char *cp, int *res);
+ int bch_strtouint_h(const char *cp, unsigned int *res);
+ int bch_strtoll_h(const char *cp, long long *res);
+ int bch_strtoull_h(const char *cp, unsigned long long *res);
  
  static inline int bch_strtol_h(const char *cp, long *res)
  {
@@@ -348,7 -347,7 +348,7 @@@ static inline int bch_strtoul_h(const c
        snprintf(buf, size,                                             \
                __builtin_types_compatible_p(typeof(var), int)          \
                     ? "%i\n" :                                         \
-               __builtin_types_compatible_p(typeof(var), unsigned)     \
+               __builtin_types_compatible_p(typeof(var), unsigned int) \
                     ? "%u\n" :                                         \
                __builtin_types_compatible_p(typeof(var), long)         \
                     ? "%li\n" :                                        \
@@@ -380,7 -379,7 +380,7 @@@ struct time_stats 
  
  void bch_time_stats_update(struct time_stats *stats, uint64_t time);
  
- static inline unsigned local_clock_us(void)
+ static inline unsigned int local_clock_us(void)
  {
        return local_clock() >> 10;
  }
@@@ -403,7 -402,8 +403,8 @@@ do {                                                                       
        __print_time_stat(stats, name,                                  \
                          average_duration,     duration_units);        \
        sysfs_print(name ## _ ##max_duration ## _ ## duration_units,    \
-                       div_u64((stats)->max_duration, NSEC_PER_ ## duration_units));\
+                       div_u64((stats)->max_duration,                  \
+                               NSEC_PER_ ## duration_units));          \
                                                                        \
        sysfs_print(name ## _last_ ## frequency_units, (stats)->last    \
                    ? div_s64(local_clock() - (stats)->last,            \
@@@ -543,26 -543,11 +544,27 @@@ dup:                                                                    
  #define RB_PREV(ptr, member)                                          \
        container_of_or_null(rb_prev(&(ptr)->member), typeof(*ptr), member)
  
 +static inline uint64_t bch_crc64(const void *p, size_t len)
 +{
 +      uint64_t crc = 0xffffffffffffffffULL;
 +
 +      crc = crc64_be(crc, p, len);
 +      return crc ^ 0xffffffffffffffffULL;
 +}
 +
 +static inline uint64_t bch_crc64_update(uint64_t crc,
 +                                      const void *p,
 +                                      size_t len)
 +{
 +      crc = crc64_be(crc, p, len);
 +      return crc;
 +}
 +
  /* Does linear interpolation between powers of two */
- static inline unsigned fract_exp_two(unsigned x, unsigned fract_bits)
+ static inline unsigned int fract_exp_two(unsigned int x,
+                                        unsigned int fract_bits)
  {
-       unsigned fract = x & ~(~0 << fract_bits);
+       unsigned int fract = x & ~(~0 << fract_bits);
  
        x >>= fract_bits;
        x   = 1 << x;
@@@ -578,4 -563,8 +580,4 @@@ static inline sector_t bdev_sectors(str
  {
        return bdev->bd_inode->i_size >> 9;
  }
 -
 -uint64_t bch_crc64_update(uint64_t crc, const void *_data, size_t len);
 -uint64_t bch_crc64(const void *data, size_t len);
 -
  #endif /* _BCACHE_UTIL_H */
diff --combined kernel/trace/blktrace.c
index 2a24a59e99c569bebca133151fb66a4922dabd86,96457ad8d72037aed7983a40cc6820507b364fd8..2868d85f1fb1d3286984c4727f0519957ac069a9
@@@ -1,7 -1,19 +1,7 @@@
 +// SPDX-License-Identifier: GPL-2.0
  /*
   * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk>
   *
 - * This program is free software; you can redistribute it and/or modify
 - * it under the terms of the GNU General Public License version 2 as
 - * published by the Free Software Foundation.
 - *
 - * This program is distributed in the hope that it will be useful,
 - * but WITHOUT ANY WARRANTY; without even the implied warranty of
 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 - * GNU General Public License for more details.
 - *
 - * You should have received a copy of the GNU General Public License
 - * along with this program; if not, write to the Free Software
 - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 - *
   */
  #include <linux/kernel.h>
  #include <linux/blkdev.h>
@@@ -1829,6 -1841,10 +1829,10 @@@ static ssize_t sysfs_blk_trace_attr_sto
        mutex_lock(&q->blk_trace_mutex);
  
        if (attr == &dev_attr_enable) {
+               if (!!value == !!q->blk_trace) {
+                       ret = 0;
+                       goto out_unlock_bdev;
+               }
                if (value)
                        ret = blk_trace_setup_queue(q, bdev);
                else