17 files changed, 79 insertions, 48 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 8d941d6818cd..ecc43c255eb8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2210,6 +2210,7 @@ F:	drivers/leds/leds-blinkm.c
 
 BLOCK LAYER
 M:      Jens Axboe <axboe@kernel.dk>
+L:      linux-block@vger.kernel.org
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
 S:      Maintained
 F:      block/
diff --git a/block/blk-core.c b/block/blk-core.c
index 2bbf08cd2900..5131993b23a1 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1575,6 +1575,9 @@ bool bio_attempt_front_merge(struct request_queue *q, struct request *req,
  * @q: request_queue new bio is being queued at
  * @bio: new bio being queued
  * @request_count: out parameter for number of traversed plugged requests
+ * @same_queue_rq: pointer to &struct request that gets filled in when
+ * another request associated with @q is found on the plug list
+ * (optional, may be %NULL)
  *
  * Determine whether @bio being queued on @q can be merged with a request
  * on %current's plugged list.  Returns %true if merge was successful,
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 86bd5b25288e..3ae09de62f19 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -358,7 +358,7 @@ static void blk_mq_ipi_complete_request(struct request *rq)
         put_cpu();
 }
 
-void __blk_mq_complete_request(struct request *rq)
+static void __blk_mq_complete_request(struct request *rq)
 {
         struct request_queue *q = rq->q;
 
diff --git a/block/blk-mq.h b/block/blk-mq.h
index b44dce165761..713820b47b31 100644
--- a/block/blk-mq.h
+++ b/block/blk-mq.h
@@ -25,7 +25,6 @@ struct blk_mq_ctx {
         struct kobject          kobj;
 } ____cacheline_aligned_in_smp;
 
-void __blk_mq_complete_request(struct request *rq);
 void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async);
 void blk_mq_freeze_queue(struct request_queue *q);
 void blk_mq_free_queue(struct request_queue *q);
diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_keys/x509_cert_parser.c
index 3000ea3b6687..021d39c0ba75 100644
--- a/crypto/asymmetric_keys/x509_cert_parser.c
+++ b/crypto/asymmetric_keys/x509_cert_parser.c
@@ -531,7 +531,11 @@ int x509_decode_time(time64_t *_t,  size_t hdrlen,
         if (*p != 'Z')
                 goto unsupported_time;
 
-        mon_len = month_lengths[mon];
+        if (year < 1970 ||
+            mon < 1 || mon > 12)
+                goto invalid_time;
+
+        mon_len = month_lengths[mon - 1];
         if (mon == 2) {
                 if (year % 4 == 0) {
                         mon_len = 29;
@@ -543,14 +547,12 @@ int x509_decode_time(time64_t *_t,  size_t hdrlen,
                 }
         }
 
-        if (year < 1970 ||
-            mon < 1 || mon > 12 ||
-            day < 1 || day > mon_len ||
+        if (day < 1 || day > mon_len ||
             hour > 23 ||
             min > 59 ||
             sec > 59)
                 goto invalid_time;
-        
+
         *_t = mktime64(year, mon, day, hour, min, sec);
         return 0;
 
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index c9f9c30d6467..a5880f4ab40e 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -337,6 +337,9 @@ static blk_qc_t brd_make_request(struct request_queue *q, struct bio *bio)
                 goto io_error;
 
         if (unlikely(bio->bi_rw & REQ_DISCARD)) {
+                if (sector & ((PAGE_SIZE >> SECTOR_SHIFT) - 1) ||
+                    bio->bi_iter.bi_size & PAGE_MASK)
+                        goto io_error;
                 discard_from_brd(brd, sector, bio->bi_iter.bi_size);
                 goto out;
         }
diff --git a/drivers/char/tpm/tpm-chip.c b/drivers/char/tpm/tpm-chip.c
index f26b0ae23bea..45cc39aabeee 100644
--- a/drivers/char/tpm/tpm-chip.c
+++ b/drivers/char/tpm/tpm-chip.c
@@ -226,21 +226,23 @@ int tpm_chip_register(struct tpm_chip *chip)
         if (rc)
                 goto out_err;
 
-        if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) {
-                rc = __compat_only_sysfs_link_entry_to_kobj(&chip->pdev->kobj,
-                                                            &chip->dev.kobj,
-                                                            "ppi");
-                if (rc)
-                        goto out_err;
-        }
-
         /* Make the chip available. */
         spin_lock(&driver_lock);
-        list_add_rcu(&chip->list, &tpm_chip_list);
+        list_add_tail_rcu(&chip->list, &tpm_chip_list);
         spin_unlock(&driver_lock);
 
         chip->flags |= TPM_CHIP_FLAG_REGISTERED;
 
+        if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) {
+                rc = __compat_only_sysfs_link_entry_to_kobj(&chip->pdev->kobj,
+                                                            &chip->dev.kobj,
+                                                            "ppi");
+                if (rc && rc != -ENOENT) {
+                        tpm_chip_unregister(chip);
+                        return rc;
+                }
+        }
+
         return 0;
 out_err:
         tpm1_chip_unregister(chip);
diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c
index bd7039fafa8a..c12130485fc1 100644
--- a/drivers/char/tpm/tpm2-cmd.c
+++ b/drivers/char/tpm/tpm2-cmd.c
@@ -443,12 +443,13 @@ int tpm2_seal_trusted(struct tpm_chip *chip,
                              TPM_DIGEST_SIZE);
 
         /* sensitive */
-        tpm_buf_append_u16(&buf, 4 + TPM_DIGEST_SIZE + payload->key_len);
+        tpm_buf_append_u16(&buf, 4 + TPM_DIGEST_SIZE + payload->key_len + 1);
 
         tpm_buf_append_u16(&buf, TPM_DIGEST_SIZE);
         tpm_buf_append(&buf, options->blobauth, TPM_DIGEST_SIZE);
-        tpm_buf_append_u16(&buf, payload->key_len);
+        tpm_buf_append_u16(&buf, payload->key_len + 1);
         tpm_buf_append(&buf, payload->key, payload->key_len);
+        tpm_buf_append_u8(&buf, payload->migratable);
 
         /* public */
         tpm_buf_append_u16(&buf, 14);
@@ -573,6 +574,8 @@ static int tpm2_unseal(struct tpm_chip *chip,
                        u32 blob_handle)
 {
         struct tpm_buf buf;
+        u16 data_len;
+        u8 *data;
         int rc;
 
         rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_UNSEAL);
@@ -591,11 +594,13 @@ static int tpm2_unseal(struct tpm_chip *chip,
                 rc = -EPERM;
 
         if (!rc) {
-                payload->key_len = be16_to_cpup(
+                data_len = be16_to_cpup(
                         (__be16 *) &buf.data[TPM_HEADER_SIZE + 4]);
+                data = &buf.data[TPM_HEADER_SIZE + 6];
 
-                memcpy(payload->key, &buf.data[TPM_HEADER_SIZE + 6],
-                       payload->key_len);
+                memcpy(payload->key, data, data_len - 1);
+                payload->key_len = data_len - 1;
+                payload->migratable = data[data_len - 1];
         }
 
         tpm_buf_destroy(&buf);
diff --git a/drivers/char/tpm/tpm_of.c b/drivers/char/tpm/tpm_of.c
index 1141456a4b1f..570f30c5c5f4 100644
--- a/drivers/char/tpm/tpm_of.c
+++ b/drivers/char/tpm/tpm_of.c
@@ -53,17 +53,18 @@ int read_log(struct tpm_bios_log *log)
                 goto cleanup_eio;
         }
 
-        of_node_put(np);
         log->bios_event_log = kmalloc(*sizep, GFP_KERNEL);
         if (!log->bios_event_log) {
                 pr_err("%s: ERROR - Not enough memory for BIOS measurements\n",
                        __func__);
+                of_node_put(np);
                 return -ENOMEM;
         }
 
         log->bios_event_log_end = log->bios_event_log + *sizep;
 
         memcpy(log->bios_event_log, __va(*basep), *sizep);
+        of_node_put(np);
 
         return 0;
 
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 696ef1d56b4f..65f7eecc45b0 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -645,6 +645,7 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
 {
         u32 vendor, intfcaps, intmask;
         int rc, i, irq_s, irq_e, probe;
+        int irq_r = -1;
         struct tpm_chip *chip;
         struct priv_data *priv;
 
@@ -751,6 +752,7 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
                 irq_s =
                     ioread8(chip->vendor.iobase +
                             TPM_INT_VECTOR(chip->vendor.locality));
+                irq_r = irq_s;
                 if (irq_s) {
                         irq_e = irq_s;
                 } else {
@@ -805,6 +807,8 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
                         iowrite32(intmask,
                                   chip->vendor.iobase +
                                   TPM_INT_ENABLE(chip->vendor.locality));
+
+                        devm_free_irq(dev, i, chip);
                 }
         }
         if (chip->vendor.irq) {
@@ -831,7 +835,9 @@ static int tpm_tis_init(struct device *dev, struct tpm_info *tpm_info,
                                   chip->vendor.iobase +
                                   TPM_INT_ENABLE(chip->vendor.locality));
                 }
-        }
+        } else if (irq_r != -1)
+                iowrite8(irq_r, chip->vendor.iobase +
+                         TPM_INT_VECTOR(chip->vendor.locality));
 
         if (chip->flags & TPM_CHIP_FLAG_TPM2) {
                 chip->vendor.timeout_a = msecs_to_jiffies(TPM2_TIMEOUT_A);
diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
index 3dfc28875cc3..8187df204695 100644
--- a/drivers/nvme/host/pci.c
+++ b/drivers/nvme/host/pci.c
@@ -1725,7 +1725,7 @@ static int nvme_configure_admin_queue(struct nvme_dev *dev)
 {
         int result;
         u32 aqa;
-        u64 cap = readq(&dev->bar->cap);
+        u64 cap = lo_hi_readq(&dev->bar->cap);
         struct nvme_queue *nvmeq;
         unsigned page_shift = PAGE_SHIFT;
         unsigned dev_page_min = NVME_CAP_MPSMIN(cap) + 12;
@@ -1774,8 +1774,8 @@ static int nvme_configure_admin_queue(struct nvme_dev *dev)
         dev->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES;
 
         writel(aqa, &dev->bar->aqa);
-        writeq(nvmeq->sq_dma_addr, &dev->bar->asq);
-        writeq(nvmeq->cq_dma_addr, &dev->bar->acq);
+        lo_hi_writeq(nvmeq->sq_dma_addr, &dev->bar->asq);
+        lo_hi_writeq(nvmeq->cq_dma_addr, &dev->bar->acq);
 
         result = nvme_enable_ctrl(dev, cap);
         if (result)
@@ -2606,7 +2606,7 @@ static int nvme_dev_add(struct nvme_dev *dev)
         struct pci_dev *pdev = to_pci_dev(dev->dev);
         int res;
         struct nvme_id_ctrl *ctrl;
-        int shift = NVME_CAP_MPSMIN(readq(&dev->bar->cap)) + 12;
+        int shift = NVME_CAP_MPSMIN(lo_hi_readq(&dev->bar->cap)) + 12;
 
         res = nvme_identify_ctrl(dev, &ctrl);
         if (res) {
@@ -2622,6 +2622,8 @@ static int nvme_dev_add(struct nvme_dev *dev)
         memcpy(dev->firmware_rev, ctrl->fr, sizeof(ctrl->fr));
         if (ctrl->mdts)
                 dev->max_hw_sectors = 1 << (ctrl->mdts + shift - 9);
+        else
+                dev->max_hw_sectors = UINT_MAX;
         if ((pdev->vendor == PCI_VENDOR_ID_INTEL) &&
                         (pdev->device == 0x0953) && ctrl->vs[3]) {
                 unsigned int max_hw_sectors;
@@ -2695,7 +2697,7 @@ static int nvme_dev_map(struct nvme_dev *dev)
                         goto unmap;
         }
 
-        cap = readq(&dev->bar->cap);
+        cap = lo_hi_readq(&dev->bar->cap);
         dev->q_depth = min_t(int, NVME_CAP_MQES(cap) + 1, NVME_Q_DEPTH);
         dev->db_stride = 1 << NVME_CAP_STRIDE(cap);
         dev->dbs = ((void __iomem *)dev->bar) + 4096;
@@ -2758,7 +2760,7 @@ static void nvme_wait_dq(struct nvme_delq_ctx *dq, struct nvme_dev *dev)
                          * queues than admin tags.
                          */
                         set_current_state(TASK_RUNNING);
-                        nvme_disable_ctrl(dev, readq(&dev->bar->cap));
+                        nvme_disable_ctrl(dev, lo_hi_readq(&dev->bar->cap));
                         nvme_clear_queue(dev->queues[0]);
                         flush_kthread_worker(dq->worker);
                         nvme_disable_queue(dev, 0);
@@ -3401,6 +3403,7 @@ static const struct pci_error_handlers nvme_err_handler = {
 
 static const struct pci_device_id nvme_id_table[] = {
         { PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_EXPRESS, 0xffffff) },
+        { PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2001) },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, nvme_id_table);
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 0a793c7930eb..bb0dfb1c7af1 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -50,12 +50,21 @@ struct block_device *I_BDEV(struct inode *inode)
 }
 EXPORT_SYMBOL(I_BDEV);
 
-static void bdev_write_inode(struct inode *inode)
+static void bdev_write_inode(struct block_device *bdev)
 {
+        struct inode *inode = bdev->bd_inode;
+        int ret;
+
         spin_lock(&inode->i_lock);
         while (inode->i_state & I_DIRTY) {
                 spin_unlock(&inode->i_lock);
-                WARN_ON_ONCE(write_inode_now(inode, true));
+                ret = write_inode_now(inode, true);
+                if (ret) {
+                        char name[BDEVNAME_SIZE];
+                        pr_warn_ratelimited("VFS: Dirty inode writeback failed "
+                                            "for block device %s (err=%d).\n",
+                                            bdevname(bdev, name), ret);
+                }
                 spin_lock(&inode->i_lock);
         }
         spin_unlock(&inode->i_lock);
@@ -1504,7 +1513,7 @@ static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
                  * ->release can cause the queue to disappear, so flush all
                  * dirty data before.
                  */
-                bdev_write_inode(bdev->bd_inode);
+                bdev_write_inode(bdev);
         }
         if (bdev->bd_contains == bdev) {
                 if (disk->fops->release)
diff --git a/fs/dax.c b/fs/dax.c
index 131fd35ae39d..8e17b371aeb8 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -174,8 +174,10 @@ static ssize_t dax_io(struct inode *inode, struct iov_iter *iter,
                 else
                         len = iov_iter_zero(max - pos, iter);
 
-                if (!len)
+                if (!len) {
+                        retval = -EFAULT;
                         break;
+                }
 
                 pos += len;
                 addr += len;
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 641e5a3ed58c..0fb65843ec1e 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -265,7 +265,7 @@ static inline unsigned int blk_qc_t_to_queue_num(blk_qc_t cookie)
 
 static inline unsigned int blk_qc_t_to_tag(blk_qc_t cookie)
 {
-        return cookie & 0xffff;
+        return cookie & ((1u << BLK_QC_T_SHIFT) - 1);
 }
 
 #endif /* __LINUX_BLK_TYPES_H */
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 2198a630ef58..87fb9801bd9e 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -100,8 +100,6 @@ static DEFINE_PER_CPU(bool, trace_cmdline_save);
  */
 static int tracing_disabled = 1;
 
-DEFINE_PER_CPU(int, ftrace_cpu_disabled);
-
 cpumask_var_t __read_mostly     tracing_buffer_mask;
 
 /*
@@ -1775,10 +1773,6 @@ trace_function(struct trace_array *tr,
         struct ring_buffer_event *event;
         struct ftrace_entry *entry;
 
-        /* If we are reading the ring buffer, don't trace */
-        if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))
-                return;
-
         event = trace_buffer_lock_reserve(buffer, TRACE_FN, sizeof(*entry),
                                           flags, pc);
         if (!event)
@@ -4554,6 +4548,8 @@ out:
         return ret;
 }
 
+#ifdef CONFIG_TRACER_MAX_TRACE
+
 static ssize_t
 tracing_max_lat_read(struct file *filp, char __user *ubuf,
                      size_t cnt, loff_t *ppos)
@@ -4568,6 +4564,8 @@ tracing_max_lat_write(struct file *filp, const char __user *ubuf,
         return tracing_nsecs_write(filp->private_data, ubuf, cnt, ppos);
 }
 
+#endif
+
 static int tracing_open_pipe(struct inode *inode, struct file *filp)
 {
         struct trace_array *tr = inode->i_private;
@@ -5469,12 +5467,14 @@ static const struct file_operations tracing_thresh_fops = {
         .llseek         = generic_file_llseek,
 };
 
+#ifdef CONFIG_TRACER_MAX_TRACE
 static const struct file_operations tracing_max_lat_fops = {
         .open           = tracing_open_generic,
         .read           = tracing_max_lat_read,
         .write          = tracing_max_lat_write,
         .llseek         = generic_file_llseek,
 };
+#endif
 
 static const struct file_operations set_tracer_fops = {
         .open           = tracing_open_generic,
@@ -6847,7 +6847,9 @@ struct dentry *tracing_init_dentry(void)
         if (tr->dir)
                 return NULL;
 
-        if (WARN_ON(!debugfs_initialized()))
+        if (WARN_ON(!tracefs_initialized()) ||
+                (IS_ENABLED(CONFIG_DEBUG_FS) &&
+                 WARN_ON(!debugfs_initialized())))
                 return ERR_PTR(-ENODEV);
 
         /*
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index dd7620802e72..919d9d07686f 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -667,7 +667,6 @@ extern int DYN_FTRACE_TEST_NAME2(void);
 
 extern bool ring_buffer_expanded;
 extern bool tracing_selftest_disabled;
-DECLARE_PER_CPU(int, ftrace_cpu_disabled);
 
 #ifdef CONFIG_FTRACE_STARTUP_TEST
 extern int trace_selftest_startup_function(struct tracer *trace,
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 92382af7a213..a663cbb84107 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -288,9 +288,6 @@ int __trace_graph_entry(struct trace_array *tr,
         struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ftrace_graph_ent_entry *entry;
 
-        if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))
-                return 0;
-
         event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_ENT,
                                           sizeof(*entry), flags, pc);
         if (!event)
@@ -403,9 +400,6 @@ void __trace_graph_return(struct trace_array *tr,
         struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ftrace_graph_ret_entry *entry;
 
-        if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))
-                return;
-
         event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_RET,
                                           sizeof(*entry), flags, pc);
         if (!event)