fs/proc/vmcore: disallow vmcore modifications while the vmcore is open

The vmcoredd_update_size() call and its effects (size/offset changes) are
currently completely unsynchronized, and will cause trouble when
performed concurrently, or when done while someone is already reading the
vmcore.

Let's protect all vmcore modifications by the vmcore_mutex, disallow vmcore
modifications while the vmcore is open, and warn on vmcore
modifications after the vmcore was already opened once: modifications
while the vmcore is open are unsafe, and modifications after the vmcore
was opened indicates trouble. Properly synchronize against concurrent
opening of the vmcore.

No need to grab the mutex during mmap()/read(): after we opened the
vmcore, modifications are impossible.

It's worth noting that modifications after the vmcore was opened are
completely unexpected, so failing if open, and warning if already opened
(+closed again) is good enough.

This change not only handles concurrent adding of device dumps +
concurrent reading of the vmcore properly, it also prepares for other
mechanisms that will modify the vmcore.

Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20241204125444.1734652-4-david@redhat.com>
Acked-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>

diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 3a7497a3269126ca3aab14b515e3d2bacbc01b8d..4a7bfdf037386e99818383add191d4f1618e7929 100644 (file)
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -68,6 +68,8 @@ DEFINE_STATIC_SRCU(vmcore_cb_srcu);
 static LIST_HEAD(vmcore_cb_list);
 /* Whether the vmcore has been opened once. */
 static bool vmcore_opened;
+/* Whether the vmcore is currently open. */
+static unsigned int vmcore_open;
 
 void register_vmcore_cb(struct vmcore_cb *cb)
 {
@@ -122,6 +124,20 @@ static int open_vmcore(struct inode *inode, struct file *file)
 {
        mutex_lock(&vmcore_mutex);
        vmcore_opened = true;
+       if (vmcore_open + 1 == 0) {
+               mutex_unlock(&vmcore_mutex);
+               return -EBUSY;
+       }
+       vmcore_open++;
+       mutex_unlock(&vmcore_mutex);
+
+       return 0;
+}
+
+static int release_vmcore(struct inode *inode, struct file *file)
+{
+       mutex_lock(&vmcore_mutex);
+       vmcore_open--;
        mutex_unlock(&vmcore_mutex);
 
        return 0;
@@ -243,33 +259,27 @@ static int vmcoredd_copy_dumps(struct iov_iter *iter, u64 start, size_t size)
 {
        struct vmcoredd_node *dump;
        u64 offset = 0;
-       int ret = 0;
        size_t tsz;
        char *buf;
 
-       mutex_lock(&vmcore_mutex);
        list_for_each_entry(dump, &vmcoredd_list, list) {
                if (start < offset + dump->size) {
                        tsz = min(offset + (u64)dump->size - start, (u64)size);
                        buf = dump->buf + start - offset;
-                       if (copy_to_iter(buf, tsz, iter) < tsz) {
-                               ret = -EFAULT;
-                               goto out_unlock;
-                       }
+                       if (copy_to_iter(buf, tsz, iter) < tsz)
+                               return -EFAULT;
 
                        size -= tsz;
                        start += tsz;
 
                        /* Leave now if buffer filled already */
                        if (!size)
-                               goto out_unlock;
+                               return 0;
                }
                offset += dump->size;
        }
 
-out_unlock:
-       mutex_unlock(&vmcore_mutex);
-       return ret;
+       return 0;
 }
 
 #ifdef CONFIG_MMU
@@ -278,20 +288,16 @@ static int vmcoredd_mmap_dumps(struct vm_area_struct *vma, unsigned long dst,
 {
        struct vmcoredd_node *dump;
        u64 offset = 0;
-       int ret = 0;
        size_t tsz;
        char *buf;
 
-       mutex_lock(&vmcore_mutex);
        list_for_each_entry(dump, &vmcoredd_list, list) {
                if (start < offset + dump->size) {
                        tsz = min(offset + (u64)dump->size - start, (u64)size);
                        buf = dump->buf + start - offset;
                        if (remap_vmalloc_range_partial(vma, dst, buf, 0,
-                                                       tsz)) {
-                               ret = -EFAULT;
-                               goto out_unlock;
-                       }
+                                                       tsz))
+                               return -EFAULT;
 
                        size -= tsz;
                        start += tsz;
@@ -299,14 +305,12 @@ static int vmcoredd_mmap_dumps(struct vm_area_struct *vma, unsigned long dst,
 
                        /* Leave now if buffer filled already */
                        if (!size)
-                               goto out_unlock;
+                               return 0;
                }
                offset += dump->size;
        }
 
-out_unlock:
-       mutex_unlock(&vmcore_mutex);
-       return ret;
+       return 0;
 }
 #endif /* CONFIG_MMU */
 #endif /* CONFIG_PROC_VMCORE_DEVICE_DUMP */
@@ -691,6 +695,7 @@ static int mmap_vmcore(struct file *file, struct vm_area_struct *vma)
 
 static const struct proc_ops vmcore_proc_ops = {
        .proc_open      = open_vmcore,
+       .proc_release   = release_vmcore,
        .proc_read_iter = read_vmcore,
        .proc_lseek     = default_llseek,
        .proc_mmap      = mmap_vmcore,
@@ -1516,12 +1521,18 @@ int vmcore_add_device_dump(struct vmcoredd_data *data)
        dump->buf = buf;
        dump->size = data_size;
 
-       /* Add the dump to driver sysfs list */
+       /* Add the dump to driver sysfs list and update the elfcore hdr */
        mutex_lock(&vmcore_mutex);
-       list_add_tail(&dump->list, &vmcoredd_list);
-       mutex_unlock(&vmcore_mutex);
+       if (vmcore_opened)
+               pr_warn_once("Unexpected adding of device dump\n");
+       if (vmcore_open) {
+               ret = -EBUSY;
+               goto out_err;
+       }
 
+       list_add_tail(&dump->list, &vmcoredd_list);
        vmcoredd_update_size(data_size);
+       mutex_unlock(&vmcore_mutex);
        return 0;
 
 out_err: