md/bitmap: move some fields of 'struct bitmap' into a 'storage' substruct.

This new 'struct bitmap_storage' reflects the external storage of the
bitmap.
Having this clearly defined will make it easier to change the storage
used while the array is active.

Signed-off-by: NeilBrown <neilb@suse.de>

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 511f0ed..c98f2fe 100644 (file)
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -195,6 +195,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
        struct md_rdev *rdev = NULL;
        struct block_device *bdev;
        struct mddev *mddev = bitmap->mddev;
+       struct bitmap_storage *store = &bitmap->storage;
 
        while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
                int size = PAGE_SIZE;
@@ -202,8 +203,8 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
 
                bdev = (rdev->meta_bdev) ? rdev->meta_bdev : rdev->bdev;
 
-               if (page->index == bitmap->file_pages-1)
-                       size = roundup(bitmap->last_page_size,
+               if (page->index == store->file_pages-1)
+                       size = roundup(store->last_page_size,
                                       bdev_logical_block_size(bdev));
                /* Just make sure we aren't corrupting data or
                 * metadata
@@ -263,7 +264,7 @@ static void write_page(struct bitmap *bitmap, struct page *page, int wait)
 {
        struct buffer_head *bh;
 
-       if (bitmap->file == NULL) {
+       if (bitmap->storage.file == NULL) {
                switch (write_sb_page(bitmap, page, wait)) {
                case -EINVAL:
                        bitmap->flags |= BITMAP_WRITE_ERROR;
@@ -408,9 +409,9 @@ void bitmap_update_sb(struct bitmap *bitmap)
                return;
        if (bitmap->mddev->bitmap_info.external)
                return;
-       if (!bitmap->sb_page) /* no superblock */
+       if (!bitmap->storage.sb_page) /* no superblock */
                return;
-       sb = kmap_atomic(bitmap->sb_page);
+       sb = kmap_atomic(bitmap->storage.sb_page);
        sb->events = cpu_to_le64(bitmap->mddev->events);
        if (bitmap->mddev->events < bitmap->events_cleared)
                /* rocking back to read-only */
@@ -421,7 +422,7 @@ void bitmap_update_sb(struct bitmap *bitmap)
        sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);
        sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);
        kunmap_atomic(sb);
-       write_page(bitmap, bitmap->sb_page, 1);
+       write_page(bitmap, bitmap->storage.sb_page, 1);
 }
 
 /* print out the bitmap file superblock */
@@ -429,9 +430,9 @@ void bitmap_print_sb(struct bitmap *bitmap)
 {
        bitmap_super_t *sb;
 
-       if (!bitmap || !bitmap->sb_page)
+       if (!bitmap || !bitmap->storage.sb_page)
                return;
-       sb = kmap_atomic(bitmap->sb_page);
+       sb = kmap_atomic(bitmap->storage.sb_page);
        printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
        printk(KERN_DEBUG "         magic: %08x\n", le32_to_cpu(sb->magic));
        printk(KERN_DEBUG "       version: %d\n", le32_to_cpu(sb->version));
@@ -470,15 +471,15 @@ static int bitmap_new_disk_sb(struct bitmap *bitmap)
        unsigned long chunksize, daemon_sleep, write_behind;
        int err = -EINVAL;
 
-       bitmap->sb_page = alloc_page(GFP_KERNEL);
-       if (IS_ERR(bitmap->sb_page)) {
-               err = PTR_ERR(bitmap->sb_page);
-               bitmap->sb_page = NULL;
+       bitmap->storage.sb_page = alloc_page(GFP_KERNEL);
+       if (IS_ERR(bitmap->storage.sb_page)) {
+               err = PTR_ERR(bitmap->storage.sb_page);
+               bitmap->storage.sb_page = NULL;
                return err;
        }
-       bitmap->sb_page->index = 0;
+       bitmap->storage.sb_page->index = 0;
 
-       sb = kmap_atomic(bitmap->sb_page);
+       sb = kmap_atomic(bitmap->storage.sb_page);
 
        sb->magic = cpu_to_le32(BITMAP_MAGIC);
        sb->version = cpu_to_le32(BITMAP_MAJOR_HI);
@@ -536,7 +537,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
        int err = -EINVAL;
        struct page *sb_page;
 
-       if (!bitmap->file && !bitmap->mddev->bitmap_info.offset) {
+       if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {
                chunksize = 128 * 1024 * 1024;
                daemon_sleep = 5 * HZ;
                write_behind = 0;
@@ -548,13 +549,13 @@ static int bitmap_read_sb(struct bitmap *bitmap)
        sb_page = alloc_page(GFP_KERNEL);
        if (!sb_page)
                return -ENOMEM;
-       bitmap->sb_page = sb_page;
+       bitmap->storage.sb_page = sb_page;
 
-       if (bitmap->file) {
-               loff_t isize = i_size_read(bitmap->file->f_mapping->host);
+       if (bitmap->storage.file) {
+               loff_t isize = i_size_read(bitmap->storage.file->f_mapping->host);
                int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;
 
-               err = read_page(bitmap->file, 0,
+               err = read_page(bitmap->storage.file, 0,
                                bitmap, bytes, sb_page);
        } else {
                err = read_sb_page(bitmap->mddev,
@@ -647,9 +648,9 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
        bitmap_super_t *sb;
        int old;
 
-       if (!bitmap->sb_page) /* can't set the state */
+       if (!bitmap->storage.sb_page) /* can't set the state */
                return 0;
-       sb = kmap_atomic(bitmap->sb_page);
+       sb = kmap_atomic(bitmap->storage.sb_page);
        old = le32_to_cpu(sb->state) & bits;
        switch (op) {
        case MASK_SET:
@@ -678,17 +679,19 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
  * file a page at a time. There's a superblock at the start of the file.
  */
 /* calculate the index of the page that contains this bit */
-static inline unsigned long file_page_index(struct bitmap *bitmap, unsigned long chunk)
+static inline unsigned long file_page_index(struct bitmap_storage *store,
+                                           unsigned long chunk)
 {
-       if (!bitmap->mddev->bitmap_info.external)
+       if (store->sb_page)
                chunk += sizeof(bitmap_super_t) << 3;
        return chunk >> PAGE_BIT_SHIFT;
 }
 
 /* calculate the (bit) offset of this bit within a page */
-static inline unsigned long file_page_offset(struct bitmap *bitmap, unsigned long chunk)
+static inline unsigned long file_page_offset(struct bitmap_storage *store,
+                                            unsigned long chunk)
 {
-       if (!bitmap->mddev->bitmap_info.external)
+       if (store->sb_page)
                chunk += sizeof(bitmap_super_t) << 3;
        return chunk & (PAGE_BITS - 1);
 }
@@ -700,13 +703,13 @@ static inline unsigned long file_page_offset(struct bitmap *bitmap, unsigned lon
  * 1 page (e.g., x86) or less than 1 page -- so the bitmap might start on page
  * 0 or page 1
  */
-static inline struct page *filemap_get_page(struct bitmap *bitmap,
+static inline struct page *filemap_get_page(struct bitmap_storage *store,
                                            unsigned long chunk)
 {
-       if (file_page_index(bitmap, chunk) >= bitmap->file_pages)
+       if (file_page_index(store, chunk) >= store->file_pages)
                return NULL;
-       return bitmap->filemap[file_page_index(bitmap, chunk)
-                              - file_page_index(bitmap, 0)];
+       return store->filemap[file_page_index(store, chunk)
+                             - file_page_index(store, 0)];
 }
 
 static void bitmap_file_unmap(struct bitmap *bitmap)
@@ -715,16 +718,17 @@ static void bitmap_file_unmap(struct bitmap *bitmap)
        unsigned long *attr;
        int pages;
        unsigned long flags;
+       struct bitmap_storage *store = &bitmap->storage;
 
        spin_lock_irqsave(&bitmap->lock, flags);
-       map = bitmap->filemap;
-       bitmap->filemap = NULL;
-       attr = bitmap->filemap_attr;
-       bitmap->filemap_attr = NULL;
-       pages = bitmap->file_pages;
-       bitmap->file_pages = 0;
-       sb_page = bitmap->sb_page;
-       bitmap->sb_page = NULL;
+       map = store->filemap;
+       store->filemap = NULL;
+       attr = store->filemap_attr;
+       store->filemap_attr = NULL;
+       pages = store->file_pages;
+       store->file_pages = 0;
+       sb_page = store->sb_page;
+       store->sb_page = NULL;
        spin_unlock_irqrestore(&bitmap->lock, flags);
 
        while (pages--)
@@ -743,8 +747,8 @@ static void bitmap_file_put(struct bitmap *bitmap)
        unsigned long flags;
 
        spin_lock_irqsave(&bitmap->lock, flags);
-       file = bitmap->file;
-       bitmap->file = NULL;
+       file = bitmap->storage.file;
+       bitmap->storage.file = NULL;
        spin_unlock_irqrestore(&bitmap->lock, flags);
 
        if (file)
@@ -771,11 +775,11 @@ static void bitmap_file_kick(struct bitmap *bitmap)
        if (bitmap_mask_state(bitmap, BITMAP_STALE, MASK_SET) == 0) {
                bitmap_update_sb(bitmap);
 
-               if (bitmap->file) {
+               if (bitmap->storage.file) {
                        path = kmalloc(PAGE_SIZE, GFP_KERNEL);
                        if (path)
-                               ptr = d_path(&bitmap->file->f_path, path,
-                                            PAGE_SIZE);
+                               ptr = d_path(&bitmap->storage.file->f_path,
+                                            path, PAGE_SIZE);
 
                        printk(KERN_ALERT
                              "%s: kicking failed bitmap file %s from array!\n",
@@ -803,19 +807,19 @@ enum bitmap_page_attr {
 static inline void set_page_attr(struct bitmap *bitmap, int pnum,
                                 enum bitmap_page_attr attr)
 {
-       __set_bit((pnum<<2) + attr, bitmap->filemap_attr);
+       __set_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
 }
 
 static inline void clear_page_attr(struct bitmap *bitmap, int pnum,
                                   enum bitmap_page_attr attr)
 {
-       __clear_bit((pnum<<2) + attr, bitmap->filemap_attr);
+       __clear_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
 }
 
 static inline unsigned long test_page_attr(struct bitmap *bitmap, int pnum,
                                           enum bitmap_page_attr attr)
 {
-       return test_bit((pnum<<2) + attr, bitmap->filemap_attr);
+       return test_bit((pnum<<2) + attr, bitmap->storage.filemap_attr);
 }
 
 /*
@@ -832,10 +836,10 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
        void *kaddr;
        unsigned long chunk = block >> bitmap->chunkshift;
 
-       page = filemap_get_page(bitmap, chunk);
+       page = filemap_get_page(&bitmap->storage, chunk);
        if (!page)
                return;
-       bit = file_page_offset(bitmap, chunk);
+       bit = file_page_offset(&bitmap->storage, chunk);
 
        /* set the bit */
        kaddr = kmap_atomic(page);
@@ -856,10 +860,10 @@ static void bitmap_file_clear_bit(struct bitmap *bitmap, sector_t block)
        void *paddr;
        unsigned long chunk = block >> bitmap->chunkshift;
 
-       page = filemap_get_page(bitmap, chunk);
+       page = filemap_get_page(&bitmap->storage, chunk);
        if (!page)
                return;
-       bit = file_page_offset(bitmap, chunk);
+       bit = file_page_offset(&bitmap->storage, chunk);
        paddr = kmap_atomic(page);
        if (bitmap->flags & BITMAP_HOSTENDIAN)
                clear_bit(bit, paddr);
@@ -881,14 +885,14 @@ void bitmap_unplug(struct bitmap *bitmap)
        int dirty, need_write;
        int wait = 0;
 
-       if (!bitmap || !bitmap->filemap)
+       if (!bitmap || !bitmap->storage.filemap)
                return;
 
        /* look at each page to see if there are any set bits that need to be
         * flushed out to disk */
-       for (i = 0; i < bitmap->file_pages; i++) {
+       for (i = 0; i < bitmap->storage.file_pages; i++) {
                spin_lock_irqsave(&bitmap->lock, flags);
-               if (!bitmap->filemap) {
+               if (!bitmap->storage.filemap) {
                        spin_unlock_irqrestore(&bitmap->lock, flags);
                        return;
                }
@@ -903,10 +907,10 @@ void bitmap_unplug(struct bitmap *bitmap)
                spin_unlock_irqrestore(&bitmap->lock, flags);
 
                if (dirty || need_write)
-                       write_page(bitmap, bitmap->filemap[i], 0);
+                       write_page(bitmap, bitmap->storage.filemap[i], 0);
        }
        if (wait) { /* if any writes were performed, we need to wait on them */
-               if (bitmap->file)
+               if (bitmap->storage.file)
                        wait_event(bitmap->write_wait,
                                   atomic_read(&bitmap->pending_writes)==0);
                else
@@ -940,14 +944,15 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
        int outofdate;
        int ret = -ENOSPC;
        void *paddr;
+       struct bitmap_storage *store = &bitmap->storage;
 
        chunks = bitmap->chunks;
-       file = bitmap->file;
+       file = store->file;
 
        if (!file && !bitmap->mddev->bitmap_info.offset) {
                /* No permanent bitmap - fill with '1s'. */
-               bitmap->filemap = NULL;
-               bitmap->file_pages = 0;
+               store->filemap = NULL;
+               store->file_pages = 0;
                for (i = 0; i < chunks ; i++) {
                        /* if the disk bit is set, set the memory bit */
                        int needed = ((sector_t)(i+1) << (bitmap->chunkshift)
@@ -980,39 +985,40 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
 
        ret = -ENOMEM;
 
-       bitmap->filemap = kmalloc(sizeof(struct page *) * num_pages, GFP_KERNEL);
-       if (!bitmap->filemap)
+       store->filemap = kmalloc(sizeof(struct page *)
+                                         * num_pages, GFP_KERNEL);
+       if (!store->filemap)
                goto err;
 
        pnum = 0;
        offset = 0;
-       if (bitmap->sb_page) {
-               bitmap->filemap[0] = bitmap->sb_page;
+       if (store->sb_page) {
+               store->filemap[0] = store->sb_page;
                pnum = 1;
                offset = sizeof(bitmap_super_t);
        }
        for ( ; pnum < num_pages; pnum++) {
-               bitmap->filemap[pnum] = alloc_page(GFP_KERNEL);
-               if (!bitmap->filemap[pnum]) {
-                       bitmap->file_pages = pnum;
+               store->filemap[pnum] = alloc_page(GFP_KERNEL);
+               if (!store->filemap[pnum]) {
+                       store->file_pages = pnum;
                        goto err;
                }
        }
-       bitmap->file_pages = pnum;
+       store->file_pages = pnum;
 
        /* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned long) */
-       bitmap->filemap_attr = kzalloc(
+       store->filemap_attr = kzalloc(
                roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
                GFP_KERNEL);
-       if (!bitmap->filemap_attr)
+       if (!store->filemap_attr)
                goto err;
 
        oldindex = ~0L;
 
        for (i = 0; i < chunks; i++) {
                int b;
-               index = file_page_index(bitmap, i);
-               bit = file_page_offset(bitmap, i);
+               index = file_page_index(&bitmap->storage, i);
+               bit = file_page_offset(&bitmap->storage, i);
                if (index != oldindex) { /* this is a new page, read it in */
                        int count;
                        /* unmap the old page, we're done with it */
@@ -1020,7 +1026,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                                count = bytes - index * PAGE_SIZE;
                        else
                                count = PAGE_SIZE;
-                       page = bitmap->filemap[index];
+                       page = store->filemap[index];
                        if (file)
                                ret = read_page(file, index, bitmap,
                                                count, page);
@@ -1036,7 +1042,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
 
                        oldindex = index;
 
-                       bitmap->last_page_size = count;
+                       store->last_page_size = count;
 
                        if (outofdate) {
                                /*
@@ -1074,7 +1080,8 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
 
        printk(KERN_INFO "%s: bitmap initialized from disk: "
               "read %lu/%lu pages, set %lu of %lu bits\n",
-              bmname(bitmap), bitmap->file_pages, num_pages, bit_cnt, chunks);
+              bmname(bitmap), store->file_pages,
+              num_pages, bit_cnt, chunks);
 
        return 0;
 
@@ -1091,14 +1098,14 @@ void bitmap_write_all(struct bitmap *bitmap)
         */
        int i;
 
-       if (!bitmap || !bitmap->filemap)
+       if (!bitmap || !bitmap->storage.filemap)
                return;
-       if (bitmap->file)
+       if (bitmap->storage.file)
                /* Only one copy, so nothing needed */
                return;
 
        spin_lock_irq(&bitmap->lock);
-       for (i = 0; i < bitmap->file_pages; i++)
+       for (i = 0; i < bitmap->storage.file_pages; i++)
                set_page_attr(bitmap, i,
                              BITMAP_PAGE_NEEDWRITE);
        bitmap->allclean = 0;
@@ -1165,7 +1172,7 @@ void bitmap_daemon_work(struct mddev *mddev)
         * we will write it.
         */
        spin_lock_irqsave(&bitmap->lock, flags);
-       for (j = 0; j < bitmap->file_pages; j++)
+       for (j = 0; j < bitmap->storage.file_pages; j++)
                if (test_page_attr(bitmap, j,
                                   BITMAP_PAGE_PENDING)) {
                        set_page_attr(bitmap, j,
@@ -1180,8 +1187,8 @@ void bitmap_daemon_work(struct mddev *mddev)
                 * other changes */
                bitmap_super_t *sb;
                bitmap->need_sync = 0;
-               if (bitmap->filemap) {
-                       sb = kmap_atomic(bitmap->sb_page);
+               if (bitmap->storage.filemap) {
+                       sb = kmap_atomic(bitmap->storage.sb_page);
                        sb->events_cleared =
                                cpu_to_le64(bitmap->events_cleared);
                        kunmap_atomic(sb);
@@ -1233,7 +1240,7 @@ void bitmap_daemon_work(struct mddev *mddev)
         * the first blocking holds the superblock and it has been updated.
         * We mustn't write any other blocks before the superblock.
         */
-       for (j = 0; j < bitmap->file_pages; j++) {
+       for (j = 0; j < bitmap->storage.file_pages; j++) {
 
                if (test_page_attr(bitmap, j,
                                   BITMAP_PAGE_DIRTY))
@@ -1244,9 +1251,9 @@ void bitmap_daemon_work(struct mddev *mddev)
                        clear_page_attr(bitmap, j,
                                        BITMAP_PAGE_NEEDWRITE);
                        spin_unlock_irqrestore(&bitmap->lock, flags);
-                       write_page(bitmap, bitmap->filemap[j], 0);
+                       write_page(bitmap, bitmap->storage.filemap[j], 0);
                        spin_lock_irqsave(&bitmap->lock, flags);
-                       if (!bitmap->filemap)
+                       if (!bitmap->storage.filemap)
                                break;
                }
        }
@@ -1700,7 +1707,7 @@ int bitmap_create(struct mddev *mddev)
        } else
                bitmap->sysfs_can_clear = NULL;
 
-       bitmap->file = file;
+       bitmap->storage.file = file;
        if (file) {
                get_file(file);
                /* As future accesses to this file will use bmap,
@@ -1832,9 +1839,9 @@ void bitmap_status(struct seq_file *seq, struct bitmap *bitmap)
                   << (PAGE_SHIFT - 10),
                   chunk_kb ? chunk_kb : bitmap->mddev->bitmap_info.chunksize,
                   chunk_kb ? "KB" : "B");
-       if (bitmap->file) {
+       if (bitmap->storage.file) {
                seq_printf(seq, ", file: ");
-               seq_path(seq, &bitmap->file->f_path, " \t\n");
+               seq_path(seq, &bitmap->storage.file->f_path, " \t\n");
        }
 
        seq_printf(seq, "\n");
@@ -1958,8 +1965,9 @@ space_store(struct mddev *mddev, const char *buf, size_t len)
                return -EINVAL;
 
        if (mddev->bitmap &&
-           sectors  < ((mddev->bitmap->file_pages - 1) * PAGE_SIZE
-                       + mddev->bitmap->last_page_size + 511) >> 9)
+           sectors  < ((mddev->bitmap->storage.file_pages - 1)
+                             * PAGE_SIZE
+                       + mddev->bitmap->storage.last_page_size + 511) >> 9)
                return -EFBIG; /* Bitmap is too big for this small space */
 
        /* could make sure it isn't too big, but that isn't really

diff --git a/drivers/md/bitmap.h b/drivers/md/bitmap.h
index 79e1798..162ab09 100644 (file)
--- a/drivers/md/bitmap.h
+++ b/drivers/md/bitmap.h
@@ -188,12 +188,17 @@ struct bitmap {
        /* bitmap spinlock */
        spinlock_t lock;
 
-       struct file *file; /* backing disk file */
-       struct page *sb_page; /* cached copy of the bitmap file superblock */
-       struct page **filemap; /* list of cache pages for the file */
-       unsigned long *filemap_attr; /* attributes associated w/ filemap pages */
-       unsigned long file_pages; /* number of pages in the file */
-       int last_page_size; /* bytes in the last page */
+       struct bitmap_storage {
+               struct file *file;              /* backing disk file */
+               struct page *sb_page;           /* cached copy of the bitmap
+                                                * file superblock */
+               struct page **filemap;          /* list of cache pages for
+                                                * the file */
+               unsigned long *filemap_attr;    /* attributes associated
+                                                * w/ filemap pages */
+               unsigned long file_pages;       /* number of pages in the file*/
+               int last_page_size;             /* bytes in the last page */
+       } storage;
 
        unsigned long flags;
 

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 607771b..9e2336f 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1989,7 +1989,7 @@ super_1_allow_new_offset(struct md_rdev *rdev,
        bitmap = rdev->mddev->bitmap;
        if (bitmap && !rdev->mddev->bitmap_info.file &&
            rdev->sb_start + rdev->mddev->bitmap_info.offset +
-           bitmap->file_pages * (PAGE_SIZE>>9) > new_offset)
+           bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
                return 0;
        if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
                return 0;
@@ -5649,7 +5649,7 @@ static int get_bitmap_file(struct mddev * mddev, void __user * arg)
                goto out;
 
        /* bitmap disabled, zero the first byte and copy out */
-       if (!mddev->bitmap || !mddev->bitmap->file) {
+       if (!mddev->bitmap || !mddev->bitmap->storage.file) {
                file->pathname[0] = '\0';
                goto copy_out;
        }
@@ -5658,7 +5658,8 @@ static int get_bitmap_file(struct mddev * mddev, void __user * arg)
        if (!buf)
                goto out;
 
-       ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
+       ptr = d_path(&mddev->bitmap->storage.file->f_path,
+                    buf, sizeof(file->pathname));
        if (IS_ERR(ptr))
                goto out;
 
@@ -6299,7 +6300,7 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
                        /* remove the bitmap */
                        if (!mddev->bitmap)
                                return -ENOENT;
-                       if (mddev->bitmap->file)
+                       if (mddev->bitmap->storage.file)
                                return -EINVAL;
                        mddev->pers->quiesce(mddev, 1);
                        bitmap_destroy(mddev);