lvm2-commits May 2018

lvm2-commits@lists.fedorahosted.org

6 participants
217 discussions

master - Merge branch '2018-05-03-improve-bcache-utils'
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=49db9b5e0b35f6b0a47ad… Commit: 49db9b5e0b35f6b0a47ad10276fb252c09f438ef Parent: 4ebfd8e8eb68442efc334b35bc1f22eda3e4dd3d ac18164a525aedcee9f55deff9a0a77528bfd0e8 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 20:15:13 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 20:15:13 2018 +0100 Merge branch '2018-05-03-improve-bcache-utils' lib/Makefile.in | 1 + lib/device/bcache-utils.c | 229 ++++++++++++++++++++++++++++ lib/device/bcache.c | 150 +------------------ lib/device/bcache.h | 23 ++-- lib/label/label.c | 2 +- test/unit/Makefile.in | 1 + test/unit/bcache_utils_t.c | 352 ++++++++++++++++++++++++++++++++++++++++++++ test/unit/units.h | 2 + 8 files changed, 603 insertions(+), 157 deletions(-)

1 0

master - unit-test: a bunch of tests for bcache-utils
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ac18164a525aedcee9f55… Commit: ac18164a525aedcee9f55deff9a0a77528bfd0e8 Parent: dfc320f5b8c24c1a430b8f044da3ee925815a447 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 20:13:13 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 20:13:13 2018 +0100 unit-test: a bunch of tests for bcache-utils --- test/unit/Makefile.in | 1 + test/unit/bcache_utils_t.c | 352 ++++++++++++++++++++++++++++++++++++++++++++ test/unit/units.h | 2 + 3 files changed, 355 insertions(+), 0 deletions(-) diff --git a/test/unit/Makefile.in b/test/unit/Makefile.in index 63681f3..10ddbe2 100644 --- a/test/unit/Makefile.in +++ b/test/unit/Makefile.in @@ -12,6 +12,7 @@ UNIT_SOURCE=\ test/unit/bcache_t.c \ + test/unit/bcache_utils_t.c \ test/unit/bitset_t.c \ test/unit/config_t.c \ test/unit/dmlist_t.c \ diff --git a/test/unit/bcache_utils_t.c b/test/unit/bcache_utils_t.c new file mode 100644 index 0000000..9c82068 --- /dev/null +++ b/test/unit/bcache_utils_t.c @@ -0,0 +1,352 @@ +/* + * Copyright (C) 2018 Red Hat, Inc. All rights reserved. + * + * This file is part of LVM2. + * + * This copyrighted material is made available to anyone wishing to use, + * modify, copy, or redistribute it subject to the terms and conditions + * of the GNU General Public License v.2. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define _GNU_SOURCE + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +#include "bcache.h" +#include "framework.h" +#include "units.h" + +//---------------------------------------------------------------- + +#define T_BLOCK_SIZE 4096 +#define NR_BLOCKS 64 +#define INIT_PATTERN 123 + +struct fixture { + int fd; + char fname[32]; + struct bcache *cache; +}; + +static inline uint8_t _pattern_at(uint8_t pat, uint8_t byte) +{ + return pat + byte; +} + +static uint64_t byte(block_address b, uint64_t offset) +{ + return b * T_BLOCK_SIZE + offset; +} + +static void *_fix_init(void) +{ + uint8_t buffer[T_BLOCK_SIZE]; + struct io_engine *engine; + struct fixture *f = malloc(sizeof(*f)); + unsigned b, i; + + T_ASSERT(f); + + snprintf(f->fname, sizeof(f->fname), "unit-test-XXXXXX"); + f->fd = mkostemp(f->fname, O_RDWR | O_CREAT | O_EXCL); + T_ASSERT(f->fd >= 0); + + for (b = 0; b < NR_BLOCKS; b++) { + for (i = 0; i < sizeof(buffer); i++) + buffer[i] = _pattern_at(INIT_PATTERN, byte(b, i)); + T_ASSERT(write(f->fd, buffer, T_BLOCK_SIZE) > 0); + } + close(f->fd); + + // reopen with O_DIRECT + f->fd = open(f->fname, O_RDWR | O_DIRECT); + T_ASSERT(f->fd >= 0); + + engine = create_async_io_engine(); + T_ASSERT(engine); + + f->cache = bcache_create(T_BLOCK_SIZE / 512, NR_BLOCKS, engine); + T_ASSERT(f->cache); + + return f; +} + +static void _fix_exit(void *fixture) +{ + struct fixture *f = fixture; + + bcache_destroy(f->cache); + close(f->fd); + unlink(f->fname); + free(f); +} + +//---------------------------------------------------------------- + +static void _verify_bytes(struct block *b, uint64_t base, + uint64_t offset, uint64_t len, uint8_t pat) +{ + unsigned i; + + for (i = 0; i < len; i++) + T_ASSERT_EQUAL(((uint8_t *) b->data)[offset + i], _pattern_at(pat, base + offset + i)); +} + +static void _zero_bytes(struct block *b, uint64_t offset, uint64_t len) +{ + memset(((uint8_t *) b->data) + offset, 0, len); +} + +static uint64_t _min(uint64_t lhs, uint64_t rhs) +{ + return rhs < lhs ? rhs : lhs; +} + +static void _verify(struct fixture *f, uint64_t byte_b, uint64_t byte_e, uint8_t pat) +{ + int err; + struct block *b; + block_address bb = byte_b / T_BLOCK_SIZE; + block_address be = (byte_e + T_BLOCK_SIZE - 1) / T_BLOCK_SIZE; + uint64_t offset = byte_b % T_BLOCK_SIZE; + uint64_t blen, len = byte_e - byte_b; + + // Verify via bcache_read_bytes + { + unsigned i; + size_t len2 = byte_e - byte_b; + uint8_t *buffer = malloc(len2); + T_ASSERT(bcache_read_bytes(f->cache, f->fd, byte_b, len2, buffer)); + for (i = 0; i < len; i++) + T_ASSERT_EQUAL(buffer[i], _pattern_at(pat, byte_b + i)); + } + + // Verify again, driving bcache directly + for (; bb != be; bb++) { + T_ASSERT(bcache_get(f->cache, f->fd, bb, 0, &b, &err)); + + blen = _min(T_BLOCK_SIZE - offset, len); + _verify_bytes(b, bb * T_BLOCK_SIZE, offset, blen, pat); + + offset = 0; + len -= blen; + + bcache_put(b); + } +} + +static void _verify_zeroes(struct fixture *f, uint64_t byte_b, uint64_t byte_e) +{ + int err; + unsigned i; + struct block *b; + block_address bb = byte_b / T_BLOCK_SIZE; + block_address be = (byte_e + T_BLOCK_SIZE - 1) / T_BLOCK_SIZE; + uint64_t offset = byte_b % T_BLOCK_SIZE; + uint64_t blen, len = byte_e - byte_b; + + for (; bb != be; bb++) { + T_ASSERT(bcache_get(f->cache, f->fd, bb, 0, &b, &err)); + + blen = _min(T_BLOCK_SIZE - offset, len); + for (i = 0; i < blen; i++) + T_ASSERT(((uint8_t *) b->data)[offset + i] == 0); + + offset = 0; + len -= blen; + + bcache_put(b); + } +} + +static void _do_write(struct fixture *f, uint64_t byte_b, uint64_t byte_e, uint8_t pat) +{ + unsigned i; + size_t len = byte_e - byte_b; + uint8_t *buffer = malloc(len); + T_ASSERT(buffer); + + for (i = 0; i < len; i++) + buffer[i] = _pattern_at(pat, byte_b + i); + + T_ASSERT(bcache_write_bytes(f->cache, f->fd, byte_b, i, buffer)); + free(buffer); +} + +static void _do_zero(struct fixture *f, uint64_t byte_b, uint64_t byte_e) +{ + int err; + struct block *b; + block_address bb = byte_b / T_BLOCK_SIZE; + block_address be = (byte_e + T_BLOCK_SIZE - 1) / T_BLOCK_SIZE; + uint64_t offset = byte_b % T_BLOCK_SIZE; + uint64_t blen, len = byte_e - byte_b; + + for (; bb != be; bb++) { + T_ASSERT(bcache_get(f->cache, f->fd, bb, GF_DIRTY, &b, &err)); + + blen = _min(T_BLOCK_SIZE - offset, len); + _zero_bytes(b, offset, blen); + + offset = 0; + len -= blen; + + bcache_put(b); + } +} + +static void _reopen(struct fixture *f) +{ + struct io_engine *engine; + + bcache_destroy(f->cache); + engine = create_async_io_engine(); + T_ASSERT(engine); + + f->cache = bcache_create(T_BLOCK_SIZE / 512, NR_BLOCKS, engine); + T_ASSERT(f->cache); +} + +//---------------------------------------------------------------- + +static uint8_t _random_pattern(void) +{ + return random(); +} + +static uint64_t _max_byte(void) +{ + return T_BLOCK_SIZE * NR_BLOCKS; +} + +static void _rwv_cycle(struct fixture *f, uint64_t b, uint64_t e) +{ + uint8_t pat = _random_pattern(); + + _verify(f, b, e, INIT_PATTERN); + _do_write(f, b, e, pat); + _reopen(f); + _verify(f, b < 128 ? 0 : b - 128, b, INIT_PATTERN); + _verify(f, b, e, pat); + _verify(f, e, _min(e + 128, _max_byte()), INIT_PATTERN); +} + +static void _test_rw_first_block(void *fixture) +{ + _rwv_cycle(fixture, byte(0, 0), byte(0, T_BLOCK_SIZE)); +} + +static void _test_rw_last_block(void *fixture) +{ + uint64_t last_block = NR_BLOCKS - 1; + _rwv_cycle(fixture, byte(last_block, 0), + byte(last_block, T_BLOCK_SIZE)); +} + +static void _test_rw_several_whole_blocks(void *fixture) +{ + _rwv_cycle(fixture, byte(5, 0), byte(10, 0)); +} + +static void _test_rw_within_single_block(void *fixture) +{ + _rwv_cycle(fixture, byte(7, 3), byte(7, T_BLOCK_SIZE / 2)); +} + +static void _test_rw_cross_one_boundary(void *fixture) +{ + _rwv_cycle(fixture, byte(13, 43), byte(14, 43)); +} + +static void _test_rw_many_boundaries(void *fixture) +{ + _rwv_cycle(fixture, byte(13, 13), byte(23, 13)); +} + +//---------------------------------------------------------------- + +static void _zero_cycle(struct fixture *f, uint64_t b, uint64_t e) +{ + _verify(f, b, e, INIT_PATTERN); + _do_zero(f, b, e); + _reopen(f); + _verify(f, b < 128 ? 0 : b - 128, b, INIT_PATTERN); + _verify_zeroes(f, b, e); + _verify(f, e, _min(e + 128, _max_byte()), INIT_PATTERN); +} + +static void _test_zero_first_block(void *fixture) +{ + _zero_cycle(fixture, byte(0, 0), byte(0, T_BLOCK_SIZE)); +} + +static void _test_zero_last_block(void *fixture) +{ + uint64_t last_block = NR_BLOCKS - 1; + _zero_cycle(fixture, byte(last_block, 0), byte(last_block, T_BLOCK_SIZE)); +} + +static void _test_zero_several_whole_blocks(void *fixture) +{ + _zero_cycle(fixture, byte(5, 0), byte(10, 0)); +} + +static void _test_zero_within_single_block(void *fixture) +{ + _zero_cycle(fixture, byte(7, 3), byte(7, T_BLOCK_SIZE / 2)); +} + +static void _test_zero_cross_one_boundary(void *fixture) +{ + _zero_cycle(fixture, byte(13, 43), byte(14, 43)); +} + +static void _test_zero_many_boundaries(void *fixture) +{ + _zero_cycle(fixture, byte(13, 13), byte(23, 13)); +} + +//---------------------------------------------------------------- + +#define T(path, desc, fn) register_test(ts, "/base/device/bcache/utils/" path, desc, fn) + +static struct test_suite *_tests(void) +{ + struct test_suite *ts = test_suite_create(_fix_init, _fix_exit); + if (!ts) { + fprintf(stderr, "out of memory\n"); + exit(1); + } + + T("rw-first-block", "read/write/verify the first block", _test_rw_first_block); + T("rw-last-block", "read/write/verify the last block", _test_rw_last_block); + T("rw-several-blocks", "read/write/verify several whole blocks", _test_rw_several_whole_blocks); + T("rw-within-single-block", "read/write/verify within single block", _test_rw_within_single_block); + T("rw-cross-one-boundary", "read/write/verify across one boundary", _test_rw_cross_one_boundary); + T("rw-many-boundaries", "read/write/verify many boundaries", _test_rw_many_boundaries); + + T("zero-first-block", "zero the first block", _test_zero_first_block); + T("zero-last-block", "zero the last block", _test_zero_last_block); + T("zero-several-blocks", "zero several whole blocks", _test_zero_several_whole_blocks); + T("zero-within-single-block", "zero within single block", _test_zero_within_single_block); + T("zero-cross-one-boundary", "zero across one boundary", _test_zero_cross_one_boundary); + T("zero-many-boundaries", "zero many boundaries", _test_zero_many_boundaries); + + return ts; +} + +void bcache_utils_tests(struct dm_list *all_tests) +{ + dm_list_add(all_tests, &_tests()->list); +} + diff --git a/test/unit/units.h b/test/unit/units.h index dbbd41e..c3c0c96 100644 --- a/test/unit/units.h +++ b/test/unit/units.h @@ -21,6 +21,7 @@ // Declare the function that adds tests suites here ... void bcache_tests(struct dm_list *suites); +void bcache_utils_tests(struct dm_list *suites); void bitset_tests(struct dm_list *suites); void config_tests(struct dm_list *suites); void dm_list_tests(struct dm_list *suites); @@ -34,6 +35,7 @@ void string_tests(struct dm_list *suites); static inline void register_all_tests(struct dm_list *suites) { bcache_tests(suites); + bcache_utils_tests(suites); bitset_tests(suites); config_tests(suites); dm_list_tests(suites);

1 0

master - bcache-utils: rewrite
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=dfc320f5b8c24c1a430b8… Commit: dfc320f5b8c24c1a430b8f044da3ee925815a447 Parent: 2688aafefbc937fc319c59ca1c77cdc24bb2c214 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 11:36:15 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 11:36:29 2018 +0100 bcache-utils: rewrite They take care to avoid redundant reads now. --- lib/device/bcache-utils.c | 223 ++++++++++++++++++++++++++------------------- 1 files changed, 131 insertions(+), 92 deletions(-) diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c index d946cc4..92e25c8 100644 --- a/lib/device/bcache-utils.c +++ b/lib/device/bcache-utils.c @@ -29,6 +29,16 @@ static void byte_range_to_block_range(struct bcache *cache, uint64_t start, size *be = (start + len + block_size - 1) / block_size; } +static uint64_t _min(uint64_t lhs, uint64_t rhs) +{ + if (rhs < lhs) + return rhs; + + return lhs; +} + +//---------------------------------------------------------------- + void bcache_prefetch_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) { block_address bb, be; @@ -40,109 +50,149 @@ void bcache_prefetch_bytes(struct bcache *cache, int fd, uint64_t start, size_t } } -static uint64_t _min(uint64_t lhs, uint64_t rhs) -{ - if (rhs < lhs) - return rhs; - - return lhs; -} +//---------------------------------------------------------------- -// FIXME: there's common code that can be factored out of these 3 bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) { struct block *b; - block_address bb, be, i; - unsigned char *udata = data; + block_address bb, be; uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; - int errors = 0; + uint64_t block_offset = start % block_size; + + bcache_prefetch_bytes(cache, fd, start, len); byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, 0, &b, NULL)) { - errors++; - continue; - } - - if (i == bb) { - uint64_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memcpy(udata, ((unsigned char *) b->data) + block_offset, blen); - len -= blen; - udata += blen; - } else { - size_t blen = _min(block_size, len); - memcpy(udata, b->data, blen); - len -= blen; - udata += blen; - } + for (; bb != be; bb++) { + if (!bcache_get(cache, fd, bb, 0, &b, NULL)) + return false; + + size_t blen = _min(block_size - block_offset, len); + memcpy(data, ((unsigned char *) b->data) + block_offset, blen); bcache_put(b); + + block_offset = 0; + len -= blen; + data = ((unsigned char *) data) + blen; } - return errors ? false : true; + return true; } -bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) +//---------------------------------------------------------------- + +// Writing bytes and zeroing bytes are very similar, so we factor out +// this common code. + +struct updater; + +typedef bool (*partial_update_fn)(struct updater *u, int fd, block_address bb, uint64_t offset, size_t len); +typedef bool (*whole_update_fn)(struct updater *u, int fd, block_address bb, block_address be); + +struct updater { + struct bcache *cache; + partial_update_fn partial_fn; + whole_update_fn whole_fn; + void *data; +}; + +static bool _update_bytes(struct updater *u, int fd, uint64_t start, size_t len) { - struct block *b; - block_address bb, be, i; - unsigned char *udata = data; + struct bcache *cache = u->cache; + block_address bb, be; uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; - int errors = 0; + uint64_t block_offset = start % block_size; + uint64_t nr_whole; byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { - errors++; - continue; - } - - if (i == bb) { - uint64_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memcpy(((unsigned char *) b->data) + block_offset, udata, blen); - len -= blen; - udata += blen; - } else { - size_t blen = _min(block_size, len); - memcpy(b->data, udata, blen); - len -= blen; - udata += blen; - } - bcache_put(b); + // If the last block is partial, we will require a read, so let's + // prefetch it. + if ((start + len) % block_size) + bcache_prefetch(cache, fd, (start + len) / block_size); + + // First block may be partial + if (block_offset) { + size_t blen = _min(block_size - block_offset, len); + if (!u->partial_fn(u, fd, bb, block_offset, blen)) + return false; + + len -= blen; + if (!len) + return true; + + bb++; } - return errors ? false : true; + // Now we write out a set of whole blocks + nr_whole = len / block_size; + if (!u->whole_fn(u, fd, bb, bb + nr_whole)) + return false; + + bb += nr_whole; + len -= nr_whole * block_size; + + if (!len) + return true; + + // Finally we write a partial end block + return u->partial_fn(u, fd, bb, 0, len); } //---------------------------------------------------------------- -static bool _zero_whole_blocks(struct bcache *cache, int fd, block_address bb, block_address be) +static bool _write_partial(struct updater *u, int fd, block_address bb, + uint64_t offset, size_t len) +{ + struct block *b; + + if (!bcache_get(u->cache, fd, bb, GF_DIRTY, &b, NULL)) + return false; + + memcpy(((unsigned char *) b->data) + offset, u->data, len); + u->data = ((unsigned char *) u->data) + len; + + bcache_put(b); + return true; +} + +static bool _write_whole(struct updater *u, int fd, block_address bb, block_address be) { struct block *b; + uint64_t block_size = bcache_block_sectors(u->cache) << SECTOR_SHIFT; for (; bb != be; bb++) { - if (!bcache_get(cache, fd, bb, GF_ZERO, &b, NULL)) + // We don't need to read the block since we are overwriting + // it completely. + if (!bcache_get(u->cache, fd, bb, GF_ZERO, &b, NULL)) return false; + memcpy(b->data, u->data, block_size); + u->data = ((unsigned char *) u->data) + block_size; bcache_put(b); } return true; } -static bool _zero_partial(struct bcache *cache, int fd, block_address bb, uint64_t offset, size_t len) +bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) +{ + struct updater u; + + u.cache = cache; + u.partial_fn = _write_partial; + u.whole_fn = _write_whole; + u.data = data; + + return _update_bytes(&u, fd, start, len); +} + +//---------------------------------------------------------------- + +static bool _zero_partial(struct updater *u, int fd, block_address bb, uint64_t offset, size_t len) { struct block *b; - if (!bcache_get(cache, fd, bb, GF_DIRTY, &b, NULL)) + if (!bcache_get(u->cache, fd, bb, GF_DIRTY, &b, NULL)) return false; memset(((unsigned char *) b->data) + offset, 0, len); @@ -151,40 +201,29 @@ static bool _zero_partial(struct bcache *cache, int fd, block_address bb, uint64 return true; } -bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) +static bool _zero_whole(struct updater *u, int fd, block_address bb, block_address be) { - block_address bb, be; - uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; - uint64_t block_offset = start % block_size; - uint64_t nr_whole; - - byte_range_to_block_range(cache, start, len, &bb, &be); + struct block *b; - // First block may be partial - if (block_offset) { - size_t blen = _min(block_size - block_offset, len); - if (!_zero_partial(cache, fd, bb, block_offset, blen)) + for (; bb != be; bb++) { + if (!bcache_get(u->cache, fd, bb, GF_ZERO, &b, NULL)) return false; - - len -= blen; - if (!len) - return true; - - bb++; + bcache_put(b); } - // Now we write out a set of whole blocks - nr_whole = len / block_size; - if (!_zero_whole_blocks(cache, fd, bb, bb + nr_whole)) - return false; - bb += nr_whole; - len -= nr_whole * block_size; + return true; +} - if (!len) - return true; +bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) +{ + struct updater u; - // Finally we write a partial end block - return _zero_partial(cache, fd, bb, 0, len); + u.cache = cache; + u.partial_fn = _zero_partial; + u.whole_fn = _zero_whole; + u.data = NULL; + + return _update_bytes(&u, fd, start, len); } //----------------------------------------------------------------

1 0

master - bcache: rename bcache_write_zeroes() -> bcache_zero_bytes()
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=2688aafefbc937fc319c5… Commit: 2688aafefbc937fc319c59ca1c77cdc24bb2c214 Parent: 8b755f1e042555c5c90cb5766fe90429f143f089 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 10:21:14 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 10:21:14 2018 +0100 bcache: rename bcache_write_zeroes() -> bcache_zero_bytes() Now matches the other util functions: bcache_{prefetch,read,write,zero}_bytes() --- lib/device/bcache-utils.c | 2 +- lib/device/bcache.h | 2 +- lib/label/label.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c index fb02a4b..d946cc4 100644 --- a/lib/device/bcache-utils.c +++ b/lib/device/bcache-utils.c @@ -151,7 +151,7 @@ static bool _zero_partial(struct bcache *cache, int fd, block_address bb, uint64 return true; } -bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len) +bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) { block_address bb, be; uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; diff --git a/lib/device/bcache.h b/lib/device/bcache.h index c6b6fb7..c07f012 100644 --- a/lib/device/bcache.h +++ b/lib/device/bcache.h @@ -161,7 +161,7 @@ void bcache_prefetch_bytes(struct bcache *cache, int fd, uint64_t start, size_t // Reads, writes and zeroes bytes. Returns false if errors occur. bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data); bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data); -bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len); +bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len); //---------------------------------------------------------------- diff --git a/lib/label/label.c b/lib/label/label.c index a981809..d6a5727 100644 --- a/lib/label/label.c +++ b/lib/label/label.c @@ -988,7 +988,7 @@ bool dev_write_zeros(struct device *dev, off_t start, size_t len) } } - if (!bcache_write_zeros(scan_bcache, dev->bcache_fd, start, len)) { + if (!bcache_zero_bytes(scan_bcache, dev->bcache_fd, start, len)) { log_error("dev_write_zeros %s at %u bcache write failed invalidate fd %d", dev_name(dev), (uint32_t)start, dev->bcache_fd); label_scan_invalidate(dev);

1 0

master - bcache: rewrite bcache_write_zeros()
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=8b755f1e042555c5c90cb… Commit: 8b755f1e042555c5c90cb5766fe90429f143f089 Parent: dc30d4b2f2712568f4d7163c790c51655f047ed4 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 10:14:56 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 10:14:56 2018 +0100 bcache: rewrite bcache_write_zeros() It now uses GF_ZERO to avoid reading blocks that are going to be completely zeroed. --- lib/device/bcache-utils.c | 76 ++++++++++++++++++++++++++++++-------------- 1 files changed, 52 insertions(+), 24 deletions(-) diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c index 3a256fc..fb02a4b 100644 --- a/lib/device/bcache-utils.c +++ b/lib/device/bcache-utils.c @@ -48,8 +48,6 @@ static uint64_t _min(uint64_t lhs, uint64_t rhs) return lhs; } -// These functions are all utilities, they should only use the public -// interface to bcache. // FIXME: there's common code that can be factored out of these 3 bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) { @@ -125,38 +123,68 @@ bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len return errors ? false : true; } -bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len) +//---------------------------------------------------------------- + +static bool _zero_whole_blocks(struct bcache *cache, int fd, block_address bb, block_address be) { struct block *b; - block_address bb, be, i; + + for (; bb != be; bb++) { + if (!bcache_get(cache, fd, bb, GF_ZERO, &b, NULL)) + return false; + bcache_put(b); + } + + return true; +} + +static bool _zero_partial(struct bcache *cache, int fd, block_address bb, uint64_t offset, size_t len) +{ + struct block *b; + + if (!bcache_get(cache, fd, bb, GF_DIRTY, &b, NULL)) + return false; + + memset(((unsigned char *) b->data) + offset, 0, len); + bcache_put(b); + + return true; +} + +bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len) +{ + block_address bb, be; uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; - int errors = 0; + uint64_t block_offset = start % block_size; + uint64_t nr_whole; byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { - errors++; - continue; - } + // First block may be partial + if (block_offset) { + size_t blen = _min(block_size - block_offset, len); + if (!_zero_partial(cache, fd, bb, block_offset, blen)) + return false; - if (i == bb) { - uint64_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memset(((unsigned char *) b->data) + block_offset, 0, blen); - len -= blen; - } else { - size_t blen = _min(block_size, len); - memset(b->data, 0, blen); - len -= blen; - } + len -= blen; + if (!len) + return true; - bcache_put(b); + bb++; } - return errors ? false : true; + // Now we write out a set of whole blocks + nr_whole = len / block_size; + if (!_zero_whole_blocks(cache, fd, bb, bb + nr_whole)) + return false; + bb += nr_whole; + len -= nr_whole * block_size; + + if (!len) + return true; + + // Finally we write a partial end block + return _zero_partial(cache, fd, bb, 0, len); } //----------------------------------------------------------------

1 0

master - bcache: switch off_t -> uint64_t
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=dc30d4b2f2712568f4d71… Commit: dc30d4b2f2712568f4d7163c790c51655f047ed4 Parent: efad84ebc297a652a2b88ced57128fc51edcf8ef Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 09:37:43 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 09:37:43 2018 +0100 bcache: switch off_t -> uint64_t We always want it to be 64bit --- lib/device/bcache-utils.c | 24 ++++++++++++------------ lib/device/bcache.h | 8 ++++---- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c index c9a685c..3a256fc 100644 --- a/lib/device/bcache-utils.c +++ b/lib/device/bcache-utils.c @@ -21,7 +21,7 @@ //---------------------------------------------------------------- -static void byte_range_to_block_range(struct bcache *cache, off_t start, size_t len, +static void byte_range_to_block_range(struct bcache *cache, uint64_t start, size_t len, block_address *bb, block_address *be) { block_address block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; @@ -29,7 +29,7 @@ static void byte_range_to_block_range(struct bcache *cache, off_t start, size_t *be = (start + len + block_size - 1) / block_size; } -void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len) +void bcache_prefetch_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) { block_address bb, be; @@ -40,7 +40,7 @@ void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len } } -static off_t _min(off_t lhs, off_t rhs) +static uint64_t _min(uint64_t lhs, uint64_t rhs) { if (rhs < lhs) return rhs; @@ -51,12 +51,12 @@ static off_t _min(off_t lhs, off_t rhs) // These functions are all utilities, they should only use the public // interface to bcache. // FIXME: there's common code that can be factored out of these 3 -bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) +bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) { struct block *b; block_address bb, be, i; unsigned char *udata = data; - off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; int errors = 0; byte_range_to_block_range(cache, start, len, &bb, &be); @@ -70,7 +70,7 @@ bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, vo } if (i == bb) { - off_t block_offset = start % block_size; + uint64_t block_offset = start % block_size; size_t blen = _min(block_size - block_offset, len); memcpy(udata, ((unsigned char *) b->data) + block_offset, blen); len -= blen; @@ -88,12 +88,12 @@ bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, vo return errors ? false : true; } -bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) +bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data) { struct block *b; block_address bb, be, i; unsigned char *udata = data; - off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; int errors = 0; byte_range_to_block_range(cache, start, len, &bb, &be); @@ -107,7 +107,7 @@ bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, v } if (i == bb) { - off_t block_offset = start % block_size; + uint64_t block_offset = start % block_size; size_t blen = _min(block_size - block_offset, len); memcpy(((unsigned char *) b->data) + block_offset, udata, blen); len -= blen; @@ -125,11 +125,11 @@ bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, v return errors ? false : true; } -bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len) +bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len) { struct block *b; block_address bb, be, i; - off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + uint64_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; int errors = 0; byte_range_to_block_range(cache, start, len, &bb, &be); @@ -143,7 +143,7 @@ bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len) } if (i == bb) { - off_t block_offset = start % block_size; + uint64_t block_offset = start % block_size; size_t blen = _min(block_size - block_offset, len); memset(((unsigned char *) b->data) + block_offset, 0, blen); len -= blen; diff --git a/lib/device/bcache.h b/lib/device/bcache.h index db41eeb..c6b6fb7 100644 --- a/lib/device/bcache.h +++ b/lib/device/bcache.h @@ -156,12 +156,12 @@ bool bcache_invalidate_fd(struct bcache *cache, int fd); // The next four functions are utilities written in terms of the above api. // Prefetches the blocks neccessary to satisfy a byte range. -void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len); +void bcache_prefetch_bytes(struct bcache *cache, int fd, uint64_t start, size_t len); // Reads, writes and zeroes bytes. Returns false if errors occur. -bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data); -bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data); -bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len); +bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data); +bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data); +bool bcache_write_zeros(struct bcache *cache, int fd, uint64_t start, size_t len); //----------------------------------------------------------------

1 0

master - bcache: Move the utils to a separate file.
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=efad84ebc297a652a2b88… Commit: efad84ebc297a652a2b88ced57128fc51edcf8ef Parent: b3c41bce3db2124af9296722bd5cda720c943462 Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 09:34:41 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 09:34:41 2018 +0100 bcache: Move the utils to a separate file. This makes it clearer that they don't access the cache internals. --- lib/Makefile.in | 1 + lib/device/bcache-utils.c | 162 +++++++++++++++++++++++++++++++++++++++++++++ lib/device/bcache.c | 145 ---------------------------------------- 3 files changed, 163 insertions(+), 145 deletions(-) diff --git a/lib/Makefile.in b/lib/Makefile.in index dbe7b90..1d42235 100644 --- a/lib/Makefile.in +++ b/lib/Makefile.in @@ -29,6 +29,7 @@ SOURCES =\ datastruct/btree.c \ datastruct/str_list.c \ device/bcache.c \ + device/bcache-utils.c \ device/dev-cache.c \ device/dev-ext.c \ device/dev-io.c \ diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c new file mode 100644 index 0000000..c9a685c --- /dev/null +++ b/lib/device/bcache-utils.c @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2018 Red Hat, Inc. All rights reserved. + * + * This file is part of LVM2. + * + * This copyrighted material is made available to anyone wishing to use, + * modify, copy, or redistribute it subject to the terms and conditions + * of the GNU Lesser General Public License v.2.1. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "bcache.h" + +// FIXME: need to define this in a common place (that doesn't pull in deps) +#ifndef SECTOR_SHIFT +#define SECTOR_SHIFT 9 +#endif + +//---------------------------------------------------------------- + +static void byte_range_to_block_range(struct bcache *cache, off_t start, size_t len, + block_address *bb, block_address *be) +{ + block_address block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + *bb = start / block_size; + *be = (start + len + block_size - 1) / block_size; +} + +void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len) +{ + block_address bb, be; + + byte_range_to_block_range(cache, start, len, &bb, &be); + while (bb < be) { + bcache_prefetch(cache, fd, bb); + bb++; + } +} + +static off_t _min(off_t lhs, off_t rhs) +{ + if (rhs < lhs) + return rhs; + + return lhs; +} + +// These functions are all utilities, they should only use the public +// interface to bcache. +// FIXME: there's common code that can be factored out of these 3 +bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) +{ + struct block *b; + block_address bb, be, i; + unsigned char *udata = data; + off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + int errors = 0; + + byte_range_to_block_range(cache, start, len, &bb, &be); + for (i = bb; i < be; i++) + bcache_prefetch(cache, fd, i); + + for (i = bb; i < be; i++) { + if (!bcache_get(cache, fd, i, 0, &b, NULL)) { + errors++; + continue; + } + + if (i == bb) { + off_t block_offset = start % block_size; + size_t blen = _min(block_size - block_offset, len); + memcpy(udata, ((unsigned char *) b->data) + block_offset, blen); + len -= blen; + udata += blen; + } else { + size_t blen = _min(block_size, len); + memcpy(udata, b->data, blen); + len -= blen; + udata += blen; + } + + bcache_put(b); + } + + return errors ? false : true; +} + +bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) +{ + struct block *b; + block_address bb, be, i; + unsigned char *udata = data; + off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + int errors = 0; + + byte_range_to_block_range(cache, start, len, &bb, &be); + for (i = bb; i < be; i++) + bcache_prefetch(cache, fd, i); + + for (i = bb; i < be; i++) { + if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { + errors++; + continue; + } + + if (i == bb) { + off_t block_offset = start % block_size; + size_t blen = _min(block_size - block_offset, len); + memcpy(((unsigned char *) b->data) + block_offset, udata, blen); + len -= blen; + udata += blen; + } else { + size_t blen = _min(block_size, len); + memcpy(b->data, udata, blen); + len -= blen; + udata += blen; + } + + bcache_put(b); + } + + return errors ? false : true; +} + +bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len) +{ + struct block *b; + block_address bb, be, i; + off_t block_size = bcache_block_sectors(cache) << SECTOR_SHIFT; + int errors = 0; + + byte_range_to_block_range(cache, start, len, &bb, &be); + for (i = bb; i < be; i++) + bcache_prefetch(cache, fd, i); + + for (i = bb; i < be; i++) { + if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { + errors++; + continue; + } + + if (i == bb) { + off_t block_offset = start % block_size; + size_t blen = _min(block_size - block_offset, len); + memset(((unsigned char *) b->data) + block_offset, 0, blen); + len -= blen; + } else { + size_t blen = _min(block_size, len); + memset(b->data, 0, blen); + len -= blen; + } + + bcache_put(b); + } + + return errors ? false : true; +} + +//---------------------------------------------------------------- diff --git a/lib/device/bcache.c b/lib/device/bcache.c index 2b50ae5..6ea0349 100644 --- a/lib/device/bcache.c +++ b/lib/device/bcache.c @@ -1034,150 +1034,5 @@ bool bcache_invalidate_fd(struct bcache *cache, int fd) return r; } -static void byte_range_to_block_range(struct bcache *cache, off_t start, size_t len, - block_address *bb, block_address *be) -{ - block_address block_size = cache->block_sectors << SECTOR_SHIFT; - *bb = start / block_size; - *be = (start + len + block_size - 1) / block_size; -} - -void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len) -{ - block_address bb, be; - - byte_range_to_block_range(cache, start, len, &bb, &be); - while (bb < be) { - bcache_prefetch(cache, fd, bb); - bb++; - } -} - -static off_t _min(off_t lhs, off_t rhs) -{ - if (rhs < lhs) - return rhs; - - return lhs; -} - -// These functions are all utilities, they should only use the public -// interface to bcache. -// FIXME: there's common code that can be factored out of these 3 -bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) -{ - struct block *b; - block_address bb, be, i; - unsigned char *udata = data; - off_t block_size = cache->block_sectors << SECTOR_SHIFT; - int errors = 0; - - byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, 0, &b, NULL)) { - log_error("bcache_read_bytes failed to get block %u fd %d bb %u be %u", - (uint32_t)i, fd, (uint32_t)bb, (uint32_t)be); - errors++; - continue; - } - - if (i == bb) { - off_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memcpy(udata, ((unsigned char *) b->data) + block_offset, blen); - len -= blen; - udata += blen; - } else { - size_t blen = _min(block_size, len); - memcpy(udata, b->data, blen); - len -= blen; - udata += blen; - } - - bcache_put(b); - } - - return errors ? false : true; -} - -bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data) -{ - struct block *b; - block_address bb, be, i; - unsigned char *udata = data; - off_t block_size = cache->block_sectors << SECTOR_SHIFT; - int errors = 0; - - byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { - log_error("bcache_write_bytes failed to get block %u fd %d bb %u be %u", - (uint32_t)i, fd, (uint32_t)bb, (uint32_t)be); - errors++; - continue; - } - - if (i == bb) { - off_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memcpy(((unsigned char *) b->data) + block_offset, udata, blen); - len -= blen; - udata += blen; - } else { - size_t blen = _min(block_size, len); - memcpy(b->data, udata, blen); - len -= blen; - udata += blen; - } - - bcache_put(b); - } - - return errors ? false : true; -} - -bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len) -{ - struct block *b; - block_address bb, be, i; - off_t block_size = cache->block_sectors << SECTOR_SHIFT; - int errors = 0; - - byte_range_to_block_range(cache, start, len, &bb, &be); - for (i = bb; i < be; i++) - bcache_prefetch(cache, fd, i); - - for (i = bb; i < be; i++) { - if (!bcache_get(cache, fd, i, GF_DIRTY, &b, NULL)) { - log_error("bcache_write_bytes failed to get block %u fd %d bb %u be %u", - (uint32_t)i, fd, (uint32_t)bb, (uint32_t)be); - errors++; - continue; - } - - if (i == bb) { - off_t block_offset = start % block_size; - size_t blen = _min(block_size - block_offset, len); - memset(((unsigned char *) b->data) + block_offset, 0, blen); - len -= blen; - } else { - size_t blen = _min(block_size, len); - memset(b->data, 0, blen); - len -= blen; - } - - bcache_put(b); - } - - return errors ? false : true; -} - - //----------------------------------------------------------------

1 0

master - bcache: add bcache_block_sectors() query fn
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=b3c41bce3db2124af9296… Commit: b3c41bce3db2124af9296722bd5cda720c943462 Parent: 65912ce44dcf8d8b3d9d17a88363f913160a338a Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 09:33:55 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 09:33:55 2018 +0100 bcache: add bcache_block_sectors() query fn --- lib/device/bcache.c | 5 +++++ lib/device/bcache.h | 1 + 2 files changed, 6 insertions(+), 0 deletions(-) diff --git a/lib/device/bcache.c b/lib/device/bcache.c index 742b7ee..2b50ae5 100644 --- a/lib/device/bcache.c +++ b/lib/device/bcache.c @@ -863,6 +863,11 @@ void bcache_destroy(struct bcache *cache) dm_free(cache); } +sector_t bcache_block_sectors(struct bcache *cache) +{ + return cache->block_sectors; +} + unsigned bcache_nr_cache_blocks(struct bcache *cache) { return cache->nr_cache_blocks; diff --git a/lib/device/bcache.h b/lib/device/bcache.h index 6a18d33..db41eeb 100644 --- a/lib/device/bcache.h +++ b/lib/device/bcache.h @@ -97,6 +97,7 @@ enum bcache_get_flags { GF_DIRTY = (1 << 1) }; +sector_t bcache_block_sectors(struct bcache *cache); unsigned bcache_nr_cache_blocks(struct bcache *cache); unsigned bcache_max_prefetches(struct bcache *cache);

1 0

master - bcache: add a comment
by Joe Thornber 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=65912ce44dcf8d8b3d9d1… Commit: 65912ce44dcf8d8b3d9d17a88363f913160a338a Parent: 90d0ff66362f3f21f79b5204bcc072c12185883b Author: Joe Thornber <ejt(a)redhat.com> AuthorDate: Thu May 3 09:14:59 2018 +0100 Committer: Joe Thornber <ejt(a)redhat.com> CommitterDate: Thu May 3 09:21:10 2018 +0100 bcache: add a comment --- lib/device/bcache.h | 14 +++++++------- 1 files changed, 7 insertions(+), 7 deletions(-) diff --git a/lib/device/bcache.h b/lib/device/bcache.h index 2b0d965..6a18d33 100644 --- a/lib/device/bcache.h +++ b/lib/device/bcache.h @@ -150,18 +150,18 @@ bool bcache_invalidate(struct bcache *cache, int fd, block_address index); */ bool bcache_invalidate_fd(struct bcache *cache, int fd); -/* - * Prefetches the blocks neccessary to satisfy a byte range. - */ + +//---------------------------------------------------------------- +// The next four functions are utilities written in terms of the above api. + +// Prefetches the blocks neccessary to satisfy a byte range. void bcache_prefetch_bytes(struct bcache *cache, int fd, off_t start, size_t len); -/* - * Reads and writes the bytes. Returns false if errors occur. - */ +// Reads, writes and zeroes bytes. Returns false if errors occur. bool bcache_read_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data); bool bcache_write_bytes(struct bcache *cache, int fd, off_t start, size_t len, void *data); bool bcache_write_zeros(struct bcache *cache, int fd, off_t start, size_t len); -/*----------------------------------------------------------------*/ +//---------------------------------------------------------------- #endif

1 0

master - lvconvert: don't return success on degraded -m raid1 conversion
by Heinz Mauelshagen 03 May '18

03 May '18

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=4ebfd8e8eb68442efc334… Commit: 4ebfd8e8eb68442efc334b35bc1f22eda3e4dd3d Parent: b393fbec00bbe1fb8d546ee3f360f8d2eb19540e Author: Heinz Mauelshagen <heinzm(a)redhat.com> AuthorDate: Thu May 3 18:00:21 2018 +0200 Committer: Heinz Mauelshagen <heinzm(a)redhat.com> CommitterDate: Thu May 3 18:48:00 2018 +0200 lvconvert: don't return success on degraded -m raid1 conversion In case "lvconvert -mN RaidLV" was used on a degraded raid1 LV, success was returned instead of an error. Provide message to inform about the need to repair first before changing number of mirrors and exit with error. Add new lvconvert-m-raid1-degraded.sh test. Resolves: rhbz1573960 --- WHATS_NEW | 1 + lib/metadata/raid_manip.c | 36 ++++++++++++++++++++++- test/shell/lvconvert-m-raid1-degraded.sh | 47 ++++++++++++++++++++++++++++++ 3 files changed, 83 insertions(+), 1 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index fbe2418..5b1494b 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.02.178 - ===================================== + lvconvert: don't return success on degraded -m raid1 conversion --enable-testing switch for ./configure has been removed. --with-snapshots switch for ./configure has been removed. --with-mirrors switch for ./configure has been removed. diff --git a/lib/metadata/raid_manip.c b/lib/metadata/raid_manip.c index 7d82a24..1b9ebcf 100644 --- a/lib/metadata/raid_manip.c +++ b/lib/metadata/raid_manip.c @@ -3200,6 +3200,27 @@ static int _raid_remove_images(struct logical_volume *lv, int yes, return 1; } +/* Check if single SubLV @slv is degraded. */ +static int _sublv_is_degraded(const struct logical_volume *slv) +{ + return !slv || lv_is_partial(slv) || lv_is_virtual(slv); +} + +/* Return failed component SubLV count for @lv. */ +static uint32_t _lv_get_nr_failed_components(const struct logical_volume *lv) +{ + uint32_t r = 0, s; + struct lv_segment *seg = first_seg(lv); + + for (s = 0; s < seg->area_count; s++) + if (_sublv_is_degraded(seg_lv(seg, s)) || + (seg->meta_areas && + _sublv_is_degraded(seg_metalv(seg, s)))) + r++; + + return r; +} + /* * _lv_raid_change_image_count * new_count: The absolute count of images (e.g. '2' for a 2-way mirror) @@ -3215,12 +3236,25 @@ static int _lv_raid_change_image_count(struct logical_volume *lv, int yes, uint3 struct dm_list *allocate_pvs, struct dm_list *removal_lvs, int commit, int use_existing_area_len) { + int r; uint32_t old_count = lv_raid_image_count(lv); + /* If there's failed component SubLVs, require repair first! */ + if (lv_is_raid(lv) && + _lv_get_nr_failed_components(lv) && + new_count >= old_count) { + log_error("Can't change number of mirrors of degraded %s.", + display_lvname(lv)); + log_error("Please run \"lvconvert --repair %s\" first.", + display_lvname(lv)); + r = 0; + } else + r = 1; + if (old_count == new_count) { log_warn("WARNING: %s already has image count of %d.", display_lvname(lv), new_count); - return 1; + return r; } /* diff --git a/test/shell/lvconvert-m-raid1-degraded.sh b/test/shell/lvconvert-m-raid1-degraded.sh new file mode 100644 index 0000000..f8a65d9 --- /dev/null +++ b/test/shell/lvconvert-m-raid1-degraded.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +SKIP_WITH_LVMLOCKD=1 +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_raid 1 3 0 || skip + +aux lvmconf 'activation/raid_fault_policy = "warn"' + +aux prepare_vg 3 32 +get_devs + +# Create 2-legged RAID1 and wait for it to complete initial resync +lvcreate --type raid1 -m 1 -l 4 -n $lv $vg "$dev1" "$dev2" +aux wait_for_sync $vg $lv + +# Disable first PV thus erroring first leg +aux disable_dev "$dev1" + +# Reduce VG by missing PV +vgreduce --force --removemissing $vg +check raid_leg_status $vg $lv "DA" + +# Conversion to 2 legs must fail on degraded 2-legged raid1 LV +not lvconvert -y -m1 $vg/$lv +check raid_leg_status $vg $lv "DA" + +# Repair has to succeed +lvconvert -y --repair $vg/$lv +aux wait_for_sync $vg $lv +check raid_leg_status $vg $lv "AA" + +lvremove -ff $vg/$lv + +vgremove -ff $vg

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

lvm2-commits May 2018