Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 27581e5a authored by NeilBrown's avatar NeilBrown
Browse files

md/bitmap: centralise allocation of bitmap file pages. 



Instead of allocating pages in read_sb_page, read_page and
bitmap_read_sb, allocate them all in bitmap_init_from disk.

Also replace the hack of calling "attach_page_buffers(page, NULL)" to
ensure that free_buffer() won't complain, by putting a test for
PagePrivate in free_buffer().

Signed-off-by: default avatarNeilBrown <neilb@suse.de>
parent ef99bf48

drivers/md/bitmap.c

+68 −81
Original line number Diff line number Diff line
@@ -130,7 +130,7 @@ static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page) 
 */



/* IO operations when bitmap is stored near all superblocks */

static struct page *read_sb_page(struct mddev *mddev, loff_t offset,

static int read_sb_page(struct mddev *mddev, loff_t offset,

			struct page *page,

			unsigned long index, int size)

{
@@ -138,14 +138,6 @@ static struct page *read_sb_page(struct mddev *mddev, loff_t offset, 


	struct md_rdev *rdev;

	sector_t target;

	int did_alloc = 0;



	if (!page) {

		page = alloc_page(GFP_KERNEL);

		if (!page)

			return ERR_PTR(-ENOMEM);

		did_alloc = 1;

	}



	rdev_for_each(rdev, mddev) {

		if (! test_bit(In_sync, &rdev->flags)
@@ -158,15 +150,10 @@ static struct page *read_sb_page(struct mddev *mddev, loff_t offset, 
				 roundup(size, bdev_logical_block_size(rdev->bdev)),

				 page, READ, true)) {

			page->index = index;

			attach_page_buffers(page, NULL); /* so that free_buffer will

							  * quietly no-op */

			return page;

			return 0;

		}

	}

	if (did_alloc)

		put_page(page);

	return ERR_PTR(-EIO);



	return -EIO;

}



static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev)
@@ -325,8 +312,12 @@ __clear_page_buffers(struct page *page) 
}

static void free_buffers(struct page *page)

{

	struct buffer_head *bh = page_buffers(page);

	struct buffer_head *bh;



	if (!PagePrivate(page))

		return;



	bh = page_buffers(page);

	while (bh) {

		struct buffer_head *next = bh->b_this_page;

		free_buffer_head(bh);
@@ -343,11 +334,12 @@ static void free_buffers(struct page *page) 
 * This usage is similar to how swap files are handled, and allows us

 * to write to a file with no concerns of memory allocation failing.

 */

static struct page *read_page(struct file *file, unsigned long index,

static int read_page(struct file *file, unsigned long index,

		     struct bitmap *bitmap,

			      unsigned long count)

		     unsigned long count,

		     struct page *page)

{

	struct page *page = NULL;

	int ret = 0;

	struct inode *inode = file->f_path.dentry->d_inode;

	struct buffer_head *bh;

	sector_t block;
@@ -355,16 +347,9 @@ static struct page *read_page(struct file *file, unsigned long index, 
	pr_debug("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,

		 (unsigned long long)index << PAGE_SHIFT);



	page = alloc_page(GFP_KERNEL);

	if (!page)

		page = ERR_PTR(-ENOMEM);

	if (IS_ERR(page))

		goto out;



	bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);

	if (!bh) {

		put_page(page);

		page = ERR_PTR(-ENOMEM);

		ret = -ENOMEM;

		goto out;

	}

	attach_page_buffers(page, bh);
@@ -376,8 +361,7 @@ static struct page *read_page(struct file *file, unsigned long index, 
			bh->b_blocknr = bmap(inode, block);

			if (bh->b_blocknr == 0) {

				/* Cannot use this file! */

				free_buffers(page);

				page = ERR_PTR(-EINVAL);

				ret = -EINVAL;

				goto out;

			}

			bh->b_bdev = inode->i_sb->s_bdev;
@@ -400,17 +384,15 @@ static struct page *read_page(struct file *file, unsigned long index, 


	wait_event(bitmap->write_wait,

		   atomic_read(&bitmap->pending_writes)==0);

	if (bitmap->flags & BITMAP_WRITE_ERROR) {

		free_buffers(page);

		page = ERR_PTR(-EIO);

	}

	if (bitmap->flags & BITMAP_WRITE_ERROR)

		ret = -EIO;

out:

	if (IS_ERR(page))

		printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %ld\n",

	if (ret)

		printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %d\n",

			(int)PAGE_SIZE,

			(unsigned long long)index << PAGE_SHIFT,

			PTR_ERR(page));

	return page;

			ret);

	return ret;

}



/*
@@ -552,6 +534,7 @@ static int bitmap_read_sb(struct bitmap *bitmap) 
	unsigned long chunksize, daemon_sleep, write_behind;

	unsigned long long events;

	int err = -EINVAL;

	struct page *sb_page;



	if (!bitmap->file && !bitmap->mddev->bitmap_info.offset) {

		chunksize = 128 * 1024 * 1024;
@@ -562,24 +545,27 @@ static int bitmap_read_sb(struct bitmap *bitmap) 
		goto out_no_sb;

	}

	/* page 0 is the superblock, read it... */

	sb_page = alloc_page(GFP_KERNEL);

	if (!sb_page)

		return -ENOMEM;

	bitmap->sb_page = sb_page;



	if (bitmap->file) {

		loff_t isize = i_size_read(bitmap->file->f_mapping->host);

		int bytes = isize > PAGE_SIZE ? PAGE_SIZE : isize;



		bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);

		err = read_page(bitmap->file, 0,

				bitmap, bytes, sb_page);

	} else {

		bitmap->sb_page = read_sb_page(bitmap->mddev,

		err = read_sb_page(bitmap->mddev,

				   bitmap->mddev->bitmap_info.offset,

					       NULL,

				   sb_page,

				   0, sizeof(bitmap_super_t));

	}

	if (IS_ERR(bitmap->sb_page)) {

		err = PTR_ERR(bitmap->sb_page);

		bitmap->sb_page = NULL;

	if (err)

		return err;

	}



	sb = kmap_atomic(bitmap->sb_page);

	sb = kmap_atomic(sb_page);



	chunksize = le32_to_cpu(sb->chunksize);

	daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
@@ -948,7 +934,8 @@ static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int n 
static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)

{

	unsigned long i, chunks, index, oldindex, bit;

	struct page *page = NULL, *oldpage = NULL;

	int pnum;

	struct page *page = NULL;

	unsigned long num_pages, bit_cnt = 0;

	struct file *file;

	unsigned long bytes, offset;
@@ -999,6 +986,22 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
	if (!bitmap->filemap)

		goto err;



	pnum = 0;

	offset = 0;

	if (bitmap->sb_page) {

		bitmap->filemap[0] = bitmap->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;

			goto err;

		}

	}

	bitmap->file_pages = pnum;



	/* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned long) */

	bitmap->filemap_attr = kzalloc(

		roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
@@ -1019,39 +1022,22 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
				count = bytes - index * PAGE_SIZE;

			else

				count = PAGE_SIZE;

			if (index == 0 && bitmap->sb_page) {

				/*

				 * if we're here then the superblock page

				 * contains some bits (PAGE_SIZE != sizeof sb)

				 * we've already read it in, so just use it

				 */

				page = bitmap->sb_page;

				offset = sizeof(bitmap_super_t);

				if (!file)

					page = read_sb_page(

			page = bitmap->filemap[index];

			if (file)

				ret = read_page(file, index, bitmap,

						count, page);

			else

				ret = read_sb_page(

					bitmap->mddev,

					bitmap->mddev->bitmap_info.offset,

					page,

					index, count);

			} else if (file) {

				page = read_page(file, index, bitmap, count);

				offset = 0;

			} else {

				page = read_sb_page(bitmap->mddev,

						    bitmap->mddev->bitmap_info.offset,

						    NULL,

						    index, count);

				offset = 0;

			}

			if (IS_ERR(page)) { /* read error */

				ret = PTR_ERR(page);



			if (ret)

				goto err;

			}



			oldindex = index;

			oldpage = page;



			bitmap->filemap[bitmap->file_pages++] = page;

			bitmap->last_page_size = count;



			if (outofdate) {
@@ -1085,6 +1071,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
					       needed);

			bit_cnt++;

		}

		offset = 0;

	}



	printk(KERN_INFO "%s: bitmap initialized from disk: "