// 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" #define BITMAP_MAJOR_LO … /* version 4 insists the bitmap is in little-endian order * with version 3, it is host-endian which is non-portable * Version 5 is currently set only for clustered devices */ #define BITMAP_MAJOR_HI … #define BITMAP_MAJOR_CLUSTERED … #define BITMAP_MAJOR_HOSTENDIAN … /* * in-memory bitmap: * * Use 16 bit block counters to track pending writes to each "chunk". * The 2 high order bits are special-purpose, the first is a flag indicating * whether a resync is needed. The second is a flag indicating whether a * resync is active. * This means that the counter is actually 14 bits: * * +--------+--------+------------------------------------------------+ * | resync | resync | counter | * | needed | active | | * | (0-1) | (0-1) | (0-16383) | * +--------+--------+------------------------------------------------+ * * The "resync needed" bit is set when: * a '1' bit is read from storage at startup. * a write request fails on some drives * a resync is aborted on a chunk with 'resync active' set * It is cleared (and resync-active set) when a resync starts across all drives * of the chunk. * * * The "resync active" bit is set when: * a resync is started on all drives, and resync_needed is set. * resync_needed will be cleared (as long as resync_active wasn't already set). * It is cleared when a resync completes. * * The counter counts pending write requests, plus the on-disk bit. * When the counter is '1' and the resync bits are clear, the on-disk * bit can be cleared as well, thus setting the counter to 0. * When we set a bit, or in the counter (to start a write), if the fields is * 0, we first set the disk bit and set the counter to 1. * * If the counter is 0, the on-disk bit is clear and the stripe is clean * Anything that dirties the stripe pushes the counter to 2 (at least) * and sets the on-disk bit (lazily). * If a periodic sweep find the counter at 2, it is decremented to 1. * If the sweep find the counter at 1, the on-disk bit is cleared and the * counter goes to zero. * * Also, we'll hijack the "map" pointer itself and use it as two 16 bit block * counters as a fallback when "page" memory cannot be allocated: * * Normal case (page memory allocated): * * page pointer (32-bit) * * [ ] ------+ * | * +-------> [ ][ ]..[ ] (4096 byte page == 2048 counters) * c1 c2 c2048 * * Hijacked case (page memory allocation failed): * * hijacked page pointer (32-bit) * * [ ][ ] (no page memory allocated) * counter #1 (16-bit) counter #2 (16-bit) * */ #define PAGE_BITS … #define PAGE_BIT_SHIFT … #define NEEDED(x) … #define RESYNC(x) … #define COUNTER(x) … /* how many counters per page? */ #define PAGE_COUNTER_RATIO … /* same, except a shift value for more efficient bitops */ #define PAGE_COUNTER_SHIFT … /* same, except a mask value for more efficient bitops */ #define PAGE_COUNTER_MASK … #define BITMAP_BLOCK_SHIFT … /* * bitmap structures: */ /* the in-memory bitmap is represented by bitmap_pages */ struct bitmap_page { … }; /* the main bitmap structure - one per mddev */ struct bitmap { … }; static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks, int chunksize, bool init); static inline char *bmname(struct bitmap *bitmap) { … } static bool __bitmap_enabled(struct bitmap *bitmap) { … } static bool bitmap_enabled(struct mddev *mddev) { … } /* * 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 */ static void bitmap_update_sb(void *data) { … } static void 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 */ static void __bitmap_unplug(struct bitmap *bitmap) { … } struct bitmap_unplug_work { … }; static void md_bitmap_unplug_fn(struct work_struct *work) { … } static void bitmap_unplug_async(struct bitmap *bitmap) { … } static void bitmap_unplug(struct mddev *mddev, bool sync) { … } 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) { … } /* just flag bitmap pages as needing to be written. */ static void bitmap_write_all(struct mddev *mddev) { … } 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 */ static void 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) { … } static int bitmap_startwrite(struct mddev *mddev, sector_t offset, unsigned long sectors, bool behind) { … } static void bitmap_endwrite(struct mddev *mddev, sector_t offset, unsigned long sectors, bool success, bool behind) { … } static bool __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, bool degraded) { … } static bool bitmap_start_sync(struct mddev *mddev, sector_t offset, sector_t *blocks, bool degraded) { … } static void __bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, bool aborted) { … } static void bitmap_end_sync(struct mddev *mddev, sector_t offset, sector_t *blocks) { … } static void bitmap_close_sync(struct mddev *mddev) { … } static void bitmap_cond_end_sync(struct mddev *mddev, sector_t sector, bool force) { … } static void bitmap_sync_with_cluster(struct mddev *mddev, sector_t old_lo, sector_t old_hi, sector_t new_lo, sector_t new_hi) { … } 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" */ static void bitmap_dirty_bits(struct mddev *mddev, unsigned long s, unsigned long e) { … } static void bitmap_flush(struct mddev *mddev) { … } static void md_bitmap_free(void *data) { … } static void bitmap_wait_behind_writes(struct mddev *mddev) { … } static void 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 */ static struct bitmap *__bitmap_create(struct mddev *mddev, int slot) { … } static int bitmap_create(struct mddev *mddev, int slot) { … } static int bitmap_load(struct mddev *mddev) { … } /* caller need to free returned bitmap with md_bitmap_free() */ static void *bitmap_get_from_slot(struct mddev *mddev, int slot) { … } /* Loads the bitmap associated with slot and copies the resync information * to our bitmap */ static int bitmap_copy_from_slot(struct mddev *mddev, int slot, sector_t *low, sector_t *high, bool clear_bits) { … } static void bitmap_set_pages(void *data, unsigned long pages) { … } static int bitmap_get_stats(void *data, struct md_bitmap_stats *stats) { … } static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks, int chunksize, bool init) { … } static int bitmap_resize(struct mddev *mddev, sector_t blocks, int chunksize, bool init) { … } 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 = …; static struct bitmap_operations bitmap_ops = …; void mddev_set_bitmap_ops(struct mddev *mddev) { … }
Codebase Browser
linux