// SPDX-License-Identifier: GPL-2.0-only /* * bitmap.c two-level bitmap (C) Peter T. Breuer ([email protected]) 2003 * * bitmap_create - sets up the bitmap structure * bitmap_destroy - destroys the bitmap structure * * additions, Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.: * - added disk storage for bitmap * - changes to allow various bitmap chunk sizes */ /* * Still to do: * * flush after percent set rather than just time based. (maybe both). */ #include <linux/blkdev.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/slab.h> #include <linux/init.h> #include <linux/timer.h> #include <linux/sched.h> #include <linux/list.h> #include <linux/file.h> #include <linux/mount.h> #include <linux/buffer_head.h> #include <linux/seq_file.h> #include <trace/events/block.h> #include "md.h" #include "md-bitmap.h" static inline char *bmname(struct bitmap *bitmap) { … } /* * check a page and, if necessary, allocate it (or hijack it if the alloc fails) * * 1) check to see if this page is allocated, if it's not then try to alloc * 2) if the alloc fails, set the page's hijacked flag so we'll use the * page pointer directly as a counter * * if we find our page, we increment the page's refcount so that it stays * allocated while we're using it */ static int md_bitmap_checkpage(struct bitmap_counts *bitmap, unsigned long page, int create, int no_hijack) __releases(bitmap->lock) __acquires(bitmap->lock) { … } /* if page is completely empty, put it back on the free list, or dealloc it */ /* if page was hijacked, unmark the flag so it might get alloced next time */ /* Note: lock should be held when calling this */ static void md_bitmap_checkfree(struct bitmap_counts *bitmap, unsigned long page) { … } /* * bitmap file handling - read and write the bitmap file and its superblock */ /* * basic page I/O operations */ /* IO operations when bitmap is stored near all superblocks */ /* choose a good rdev and read the page from there */ static int read_sb_page(struct mddev *mddev, loff_t offset, struct page *page, unsigned long index, int size) { … } static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev) { … } static unsigned int optimal_io_size(struct block_device *bdev, unsigned int last_page_size, unsigned int io_size) { … } static unsigned int bitmap_io_size(unsigned int io_size, unsigned int opt_size, loff_t start, loff_t boundary) { … } static int __write_sb_page(struct md_rdev *rdev, struct bitmap *bitmap, unsigned long pg_index, struct page *page) { … } static void write_sb_page(struct bitmap *bitmap, unsigned long pg_index, struct page *page, bool wait) { … } static void md_bitmap_file_kick(struct bitmap *bitmap); #ifdef CONFIG_MD_BITMAP_FILE static void write_file_page(struct bitmap *bitmap, struct page *page, int wait) { … } static void end_bitmap_write(struct buffer_head *bh, int uptodate) { … } static void free_buffers(struct page *page) { … } /* read a page from a file. * We both read the page, and attach buffers to the page to record the * address of each block (using bmap). These addresses will be used * to write the block later, completely bypassing the filesystem. * 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 int read_file_page(struct file *file, unsigned long index, struct bitmap *bitmap, unsigned long count, struct page *page) { … } #else /* CONFIG_MD_BITMAP_FILE */ static void write_file_page(struct bitmap *bitmap, struct page *page, int wait) { } static int read_file_page(struct file *file, unsigned long index, struct bitmap *bitmap, unsigned long count, struct page *page) { return -EIO; } static void free_buffers(struct page *page) { put_page(page); } #endif /* CONFIG_MD_BITMAP_FILE */ /* * bitmap file superblock operations */ /* * write out a page to a file */ static void filemap_write_page(struct bitmap *bitmap, unsigned long pg_index, bool wait) { … } /* * md_bitmap_wait_writes() should be called before writing any bitmap * blocks, to ensure previous writes, particularly from * md_bitmap_daemon_work(), have completed. */ static void md_bitmap_wait_writes(struct bitmap *bitmap) { … } /* update the event counter and sync the superblock to disk */ void md_bitmap_update_sb(struct bitmap *bitmap) { … } EXPORT_SYMBOL(…); /* print out the bitmap file superblock */ void md_bitmap_print_sb(struct bitmap *bitmap) { … } /* * bitmap_new_disk_sb * @bitmap * * This function is somewhat the reverse of bitmap_read_sb. bitmap_read_sb * reads and verifies the on-disk bitmap superblock and populates bitmap_info. * This function verifies 'bitmap_info' and populates the on-disk bitmap * structure, which is to be written to disk. * * Returns: 0 on success, -Exxx on error */ static int md_bitmap_new_disk_sb(struct bitmap *bitmap) { … } /* read the superblock from the bitmap file and initialize some bitmap fields */ static int md_bitmap_read_sb(struct bitmap *bitmap) { … } /* * general bitmap file operations */ /* * on-disk bitmap: * * Use one bit per "chunk" (block set). We do the disk I/O on the bitmap * 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_storage *store, unsigned long chunk) { … } /* calculate the (bit) offset of this bit within a page */ static inline unsigned long file_page_offset(struct bitmap_storage *store, unsigned long chunk) { … } /* * return a pointer to the page in the filemap that contains the given bit * */ static inline struct page *filemap_get_page(struct bitmap_storage *store, unsigned long chunk) { … } static int md_bitmap_storage_alloc(struct bitmap_storage *store, unsigned long chunks, int with_super, int slot_number) { … } static void md_bitmap_file_unmap(struct bitmap_storage *store) { … } /* * bitmap_file_kick - if an error occurs while manipulating the bitmap file * then it is no longer reliable, so we stop using it and we mark the file * as failed in the superblock */ static void md_bitmap_file_kick(struct bitmap *bitmap) { … } enum bitmap_page_attr { … }; static inline void set_page_attr(struct bitmap *bitmap, int pnum, enum bitmap_page_attr attr) { … } static inline void clear_page_attr(struct bitmap *bitmap, int pnum, enum bitmap_page_attr attr) { … } static inline int test_page_attr(struct bitmap *bitmap, int pnum, enum bitmap_page_attr attr) { … } static inline int test_and_clear_page_attr(struct bitmap *bitmap, int pnum, enum bitmap_page_attr attr) { … } /* * bitmap_file_set_bit -- called before performing a write to the md device * to set (and eventually sync) a particular bit in the bitmap file * * we set the bit immediately, then we record the page number so that * when an unplug occurs, we can flush the dirty pages out to disk */ static void md_bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) { … } static void md_bitmap_file_clear_bit(struct bitmap *bitmap, sector_t block) { … } static int md_bitmap_file_test_bit(struct bitmap *bitmap, sector_t block) { … } /* this gets called when the md device is ready to unplug its underlying * (slave) device queues -- before we let any writes go down, we need to * sync the dirty pages of the bitmap file to disk */ void md_bitmap_unplug(struct bitmap *bitmap) { … } EXPORT_SYMBOL(…); struct bitmap_unplug_work { … }; static void md_bitmap_unplug_fn(struct work_struct *work) { … } void md_bitmap_unplug_async(struct bitmap *bitmap) { … } EXPORT_SYMBOL(…); static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed); /* * Initialize the in-memory bitmap from the on-disk bitmap and set up the memory * mapping of the bitmap file. * * Special case: If there's no bitmap file, or if the bitmap file had been * previously kicked from the array, we mark all the bits as 1's in order to * cause a full resync. * * We ignore all bits for sectors that end earlier than 'start'. * This is used when reading an out-of-date bitmap. */ static int md_bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) { … } void md_bitmap_write_all(struct bitmap *bitmap) { … } static void md_bitmap_count_page(struct bitmap_counts *bitmap, sector_t offset, int inc) { … } static void md_bitmap_set_pending(struct bitmap_counts *bitmap, sector_t offset) { … } static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap, sector_t offset, sector_t *blocks, int create); static void mddev_set_timeout(struct mddev *mddev, unsigned long timeout, bool force) { … } /* * bitmap daemon -- periodically wakes up to clean bits and flush pages * out to disk */ void md_bitmap_daemon_work(struct mddev *mddev) { … } static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap, sector_t offset, sector_t *blocks, int create) __releases(bitmap->lock) __acquires(bitmap->lock) { … } int md_bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind) { … } EXPORT_SYMBOL(…); void md_bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int success, int behind) { … } EXPORT_SYMBOL(…); static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded) { … } int md_bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded) { … } EXPORT_SYMBOL(…); void md_bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted) { … } EXPORT_SYMBOL(…); void md_bitmap_close_sync(struct bitmap *bitmap) { … } EXPORT_SYMBOL(…); void md_bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force) { … } EXPORT_SYMBOL(…); void md_bitmap_sync_with_cluster(struct mddev *mddev, sector_t old_lo, sector_t old_hi, sector_t new_lo, sector_t new_hi) { … } EXPORT_SYMBOL(…); static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed) { … } /* dirty the memory and file bits for bitmap chunks "s" to "e" */ void md_bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e) { … } /* * flush out any pending updates */ void md_bitmap_flush(struct mddev *mddev) { … } /* * free memory that was allocated */ void md_bitmap_free(struct bitmap *bitmap) { … } EXPORT_SYMBOL(…); void md_bitmap_wait_behind_writes(struct mddev *mddev) { … } void md_bitmap_destroy(struct mddev *mddev) { … } /* * initialize the bitmap structure * if this returns an error, bitmap_destroy must be called to do clean up * once mddev->bitmap is set */ struct bitmap *md_bitmap_create(struct mddev *mddev, int slot) { … } int md_bitmap_load(struct mddev *mddev) { … } EXPORT_SYMBOL_GPL(…); /* caller need to free returned bitmap with md_bitmap_free() */ struct bitmap *get_bitmap_from_slot(struct mddev *mddev, int slot) { … } EXPORT_SYMBOL(…); /* Loads the bitmap associated with slot and copies the resync information * to our bitmap */ int md_bitmap_copy_from_slot(struct mddev *mddev, int slot, sector_t *low, sector_t *high, bool clear_bits) { … } EXPORT_SYMBOL_GPL(…); void md_bitmap_status(struct seq_file *seq, struct bitmap *bitmap) { … } int md_bitmap_resize(struct bitmap *bitmap, sector_t blocks, int chunksize, int init) { … } EXPORT_SYMBOL_GPL(…); static ssize_t location_show(struct mddev *mddev, char *page) { … } static ssize_t location_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_location = …; /* 'bitmap/space' is the space available at 'location' for the * bitmap. This allows the kernel to know when it is safe to * resize the bitmap to match a resized array. */ static ssize_t space_show(struct mddev *mddev, char *page) { … } static ssize_t space_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_space = …; static ssize_t timeout_show(struct mddev *mddev, char *page) { … } static ssize_t timeout_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_timeout = …; static ssize_t backlog_show(struct mddev *mddev, char *page) { … } static ssize_t backlog_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_backlog = …; static ssize_t chunksize_show(struct mddev *mddev, char *page) { … } static ssize_t chunksize_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_chunksize = …; static ssize_t metadata_show(struct mddev *mddev, char *page) { … } static ssize_t metadata_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_metadata = …; static ssize_t can_clear_show(struct mddev *mddev, char *page) { … } static ssize_t can_clear_store(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry bitmap_can_clear = …; static ssize_t behind_writes_used_show(struct mddev *mddev, char *page) { … } static ssize_t behind_writes_used_reset(struct mddev *mddev, const char *buf, size_t len) { … } static struct md_sysfs_entry max_backlog_used = …; static struct attribute *md_bitmap_attrs[] = …; const struct attribute_group md_bitmap_group = …;
Codebase Browser
linux