* jset: The checksum is _always_ the first 8 bytes of these structs
*/
#define csum_set(i) \
- crc64(((void *) (i)) + sizeof(uint64_t), \
+ bch_crc64(((void *) (i)) + sizeof(uint64_t), \
((void *) end(i)) - (((void *) (i)) + sizeof(uint64_t)))
/* Error handling macros */
if (!start) {
spin_lock(&b->c->sort_time_lock);
- time_stats_update(&b->c->sort_time, start_time);
+ bch_time_stats_update(&b->c->sort_time, start_time);
spin_unlock(&b->c->sort_time_lock);
}
}
btree_mergesort(b, new->sets->data, &iter, false, true);
spin_lock(&b->c->sort_time_lock);
- time_stats_update(&b->c->sort_time, start_time);
+ bch_time_stats_update(&b->c->sort_time, start_time);
spin_unlock(&b->c->sort_time_lock);
bkey_copy_key(&new->key, &b->key);
uint64_t crc = b->key.ptr[0];
void *data = (void *) i + 8, *end = end(i);
- crc = crc64_update(crc, data, end - data);
+ crc = bch_crc64_update(crc, data, end - data);
return crc ^ 0xffffffffffffffff;
}
mutex_unlock(&b->c->fill_lock);
spin_lock(&b->c->btree_read_time_lock);
- time_stats_update(&b->c->btree_read_time, b->io_start_time);
+ bch_time_stats_update(&b->c->btree_read_time, b->io_start_time);
spin_unlock(&b->c->btree_read_time_lock);
smp_wmb(); /* read_done is our write lock */
b->bio->bi_rw = REQ_META|READ_SYNC;
b->bio->bi_size = KEY_SIZE(&b->key) << 9;
- bio_map(b->bio, b->sets[0].data);
+ bch_bio_map(b->bio, b->sets[0].data);
pr_debug("%s", pbtree(b));
trace_bcache_btree_read(b->bio);
btree_bio_init(b);
b->bio->bi_rw = REQ_META|WRITE_SYNC;
b->bio->bi_size = set_blocks(i, b->c) * block_bytes(b->c);
- bio_map(b->bio, i);
+ bch_bio_map(b->bio, i);
bkey_copy(&k.key, &b->key);
SET_PTR_OFFSET(&k.key, 0, PTR_OFFSET(&k.key, 0) + bset_offset(b, i));
- if (!bio_alloc_pages(b->bio, GFP_NOIO)) {
+ if (!bch_bio_alloc_pages(b->bio, GFP_NOIO)) {
int j;
struct bio_vec *bv;
void *base = (void *) ((unsigned long) i & ~(PAGE_SIZE - 1));
continue_at(cl, btree_write_done, NULL);
} else {
b->bio->bi_vcnt = 0;
- bio_map(b->bio, i);
+ bch_bio_map(b->bio, i);
trace_bcache_btree_write(b->bio);
bch_submit_bbio(b->bio, b->c, &k.key, 0);
void bch_cannibalize_unlock(struct cache_set *c, struct closure *cl)
{
if (c->try_harder == cl) {
- time_stats_update(&c->try_harder_time, c->try_harder_start);
+ bch_time_stats_update(&c->try_harder_time, c->try_harder_start);
c->try_harder = NULL;
__closure_wake_up(&c->try_wait);
}
available = bch_btree_gc_finish(c);
- time_stats_update(&c->btree_gc_time, start_time);
+ bch_time_stats_update(&c->btree_gc_time, start_time);
stats.key_bytes *= sizeof(uint64_t);
stats.dirty <<= 9;
rw_unlock(true, n1);
btree_node_free(b, op);
- time_stats_update(&b->c->btree_split_time, start_time);
+ bch_time_stats_update(&b->c->btree_split_time, start_time);
return 0;
err_free2:
if (!check)
return;
- if (bio_alloc_pages(check, GFP_NOIO))
+ if (bch_bio_alloc_pages(check, GFP_NOIO))
goto out_put;
check->bi_rw = READ_SYNC;
bio->bi_end_io = journal_read_endio;
bio->bi_private = &op->cl;
- bio_map(bio, data);
+ bch_bio_map(bio, data);
closure_bio_submit(bio, &op->cl, ca);
closure_sync(&op->cl);
bio->bi_end_io = journal_write_endio;
bio->bi_private = w;
- bio_map(bio, w->data);
+ bch_bio_map(bio, w->data);
trace_bcache_journal_write(bio);
bio_list_add(&list, bio);
PAGE_SECTORS);
bio->bi_private = &io->s.cl;
bio->bi_io_vec = bio->bi_inline_vecs;
- bio_map(bio, NULL);
+ bch_bio_map(bio, NULL);
}
static void write_moving(struct closure *cl)
bio->bi_rw = READ;
bio->bi_end_io = read_moving_endio;
- if (bio_alloc_pages(bio, GFP_KERNEL))
+ if (bch_bio_alloc_pages(bio, GFP_KERNEL))
goto err;
pr_debug("%s", pkey(&w->key));
char __user *buf, size_t nbytes, loff_t *ppos)
{
char tmp[1024];
- int len = snprint_string_list(tmp, PAGE_SIZE, bch_cache_modes,
- cgroup_to_bcache(cgrp)->cache_mode + 1);
+ int len = bch_snprint_string_list(tmp, PAGE_SIZE, bch_cache_modes,
+ cgroup_to_bcache(cgrp)->cache_mode + 1);
if (len < 0)
return len;
static int cache_mode_write(struct cgroup *cgrp, struct cftype *cft,
const char *buf)
{
- int v = read_string_list(buf, bch_cache_modes);
+ int v = bch_read_string_list(buf, bch_cache_modes);
if (v < 0)
return v;
bio_for_each_segment(bv, bio, i) {
void *d = kmap(bv->bv_page) + bv->bv_offset;
- csum = crc64_update(csum, d, bv->bv_len);
+ csum = bch_crc64_update(csum, d, bv->bv_len);
kunmap(bv->bv_page);
}
s->op.cache_bio->bi_sector = s->cache_miss->bi_sector;
s->op.cache_bio->bi_bdev = s->cache_miss->bi_bdev;
s->op.cache_bio->bi_size = s->cache_bio_sectors << 9;
- bio_map(s->op.cache_bio, NULL);
+ bch_bio_map(s->op.cache_bio, NULL);
src = bio_iovec(s->op.cache_bio);
dst = bio_iovec(s->cache_miss);
if (!bch_btree_insert_check_key(b, &s->op, s->op.cache_bio))
goto out_put;
- bio_map(s->op.cache_bio, NULL);
- if (bio_alloc_pages(s->op.cache_bio, __GFP_NOWARN|GFP_NOIO))
+ bch_bio_map(s->op.cache_bio, NULL);
+ if (bch_bio_alloc_pages(s->op.cache_bio, __GFP_NOWARN|GFP_NOIO))
goto out_put;
s->cache_miss = miss;
goto err;
err = "Bad UUID";
- if (is_zero(sb->uuid, 16))
+ if (bch_is_zero(sb->uuid, 16))
goto err;
err = "Unsupported superblock version";
goto out;
err = "Bad UUID";
- if (is_zero(sb->set_uuid, 16))
+ if (bch_is_zero(sb->set_uuid, 16))
goto err;
err = "Bad cache device number in set";
bio->bi_sector = SB_SECTOR;
bio->bi_rw = REQ_SYNC|REQ_META;
bio->bi_size = SB_SIZE;
- bio_map(bio, NULL);
+ bch_bio_map(bio, NULL);
out->offset = cpu_to_le64(sb->offset);
out->version = cpu_to_le64(sb->version);
bio->bi_end_io = uuid_endio;
bio->bi_private = cl;
- bio_map(bio, c->uuids);
+ bch_bio_map(bio, c->uuids);
bch_submit_bbio(bio, c, k, i);
pkey(&c->uuid_bucket));
for (u = c->uuids; u < c->uuids + c->nr_uuids; u++)
- if (!is_zero(u->uuid, 16))
+ if (!bch_is_zero(u->uuid, 16))
pr_debug("Slot %zi: %pU: %s: 1st: %u last: %u inv: %u",
u - c->uuids, u->uuid, u->label,
u->first_reg, u->last_reg, u->invalidated);
bio->bi_end_io = prio_endio;
bio->bi_private = ca;
- bio_map(bio, ca->disk_buckets);
+ bch_bio_map(bio, ca->disk_buckets);
closure_bio_submit(bio, &ca->prio, ca);
closure_sync(cl);
p->next_bucket = ca->prio_buckets[i + 1];
p->magic = pset_magic(ca);
- p->csum = crc64(&p->magic, bucket_bytes(ca) - 8);
+ p->csum = bch_crc64(&p->magic, bucket_bytes(ca) - 8);
bucket = bch_bucket_alloc(ca, WATERMARK_PRIO, &cl);
BUG_ON(bucket == -1);
prio_io(ca, bucket, READ_SYNC);
- if (p->csum != crc64(&p->magic, bucket_bytes(ca) - 8))
+ if (p->csum != bch_crc64(&p->magic, bucket_bytes(ca) - 8))
pr_warn("bad csum reading priorities");
if (p->magic != pset_magic(ca))
sysfs_remove_file(&dc->kobj, &sysfs_attach);
*/
- if (is_zero(u->uuid, 16)) {
+ if (bch_is_zero(u->uuid, 16)) {
struct closure cl;
closure_init_stack(&cl);
#define var(stat) (dc->stat)
if (attr == &sysfs_cache_mode)
- return snprint_string_list(buf, PAGE_SIZE,
- bch_cache_modes + 1,
- BDEV_CACHE_MODE(&dc->sb));
+ return bch_snprint_string_list(buf, PAGE_SIZE,
+ bch_cache_modes + 1,
+ BDEV_CACHE_MODE(&dc->sb));
sysfs_printf(data_csum, "%i", dc->disk.data_csum);
var_printf(verify, "%i");
char dirty[20];
char derivative[20];
char target[20];
- hprint(dirty,
+ bch_hprint(dirty,
atomic_long_read(&dc->disk.sectors_dirty) << 9);
- hprint(derivative, dc->writeback_rate_derivative << 9);
- hprint(target, dc->writeback_rate_target << 9);
+ bch_hprint(derivative, dc->writeback_rate_derivative << 9);
+ bch_hprint(target, dc->writeback_rate_target << 9);
return sprintf(buf,
"rate:\t\t%u\n"
bch_cached_dev_run(dc);
if (attr == &sysfs_cache_mode) {
- ssize_t v = read_string_list(buf, bch_cache_modes + 1);
+ ssize_t v = bch_read_string_list(buf, bch_cache_modes + 1);
if (v < 0)
return v;
}
if (attr == &sysfs_attach) {
- if (parse_uuid(buf, dc->sb.set_uuid) < 16)
+ if (bch_parse_uuid(buf, dc->sb.set_uuid) < 16)
return -EINVAL;
list_for_each_entry(c, &bch_cache_sets, list) {
((size_t) ca->sb.nbuckets));
if (attr == &sysfs_cache_replacement_policy)
- return snprint_string_list(buf, PAGE_SIZE,
- cache_replacement_policies,
- CACHE_REPLACEMENT(&ca->sb));
+ return bch_snprint_string_list(buf, PAGE_SIZE,
+ cache_replacement_policies,
+ CACHE_REPLACEMENT(&ca->sb));
if (attr == &sysfs_priority_stats) {
int cmp(const void *l, const void *r)
}
if (attr == &sysfs_cache_replacement_policy) {
- ssize_t v = read_string_list(buf, cache_replacement_policies);
+ ssize_t v = bch_read_string_list(buf, cache_replacement_policies);
if (v < 0)
return v;
#define sysfs_hprint(file, val) \
do { \
if (attr == &sysfs_ ## file) { \
- ssize_t ret = hprint(buf, val); \
+ ssize_t ret = bch_hprint(buf, val); \
strcat(buf, "\n"); \
return ret + 1; \
} \
#define simple_strtouint(c, end, base) simple_strtoul(c, end, base)
#define STRTO_H(name, type) \
-int name ## _h(const char *cp, type *res) \
+int bch_ ## name ## _h(const char *cp, type *res) \
{ \
int u = 0; \
char *e; \
*res = i; \
return 0; \
} \
-EXPORT_SYMBOL_GPL(name ## _h);
STRTO_H(strtoint, int)
STRTO_H(strtouint, unsigned int)
STRTO_H(strtoll, long long)
STRTO_H(strtoull, unsigned long long)
-ssize_t hprint(char *buf, int64_t v)
+ssize_t bch_hprint(char *buf, int64_t v)
{
static const char units[] = "?kMGTPEZY";
char dec[3] = "";
return sprintf(buf, "%lli%s%c", v, dec, units[u]);
}
-EXPORT_SYMBOL_GPL(hprint);
-ssize_t snprint_string_list(char *buf, size_t size, const char * const list[],
+ssize_t bch_snprint_string_list(char *buf, size_t size, const char * const list[],
size_t selected)
{
char *out = buf;
out[-1] = '\n';
return out - buf;
}
-EXPORT_SYMBOL_GPL(snprint_string_list);
-ssize_t read_string_list(const char *buf, const char * const list[])
+ssize_t bch_read_string_list(const char *buf, const char * const list[])
{
size_t i;
char *s, *d = kstrndup(buf, PAGE_SIZE - 1, GFP_KERNEL);
return i;
}
-EXPORT_SYMBOL_GPL(read_string_list);
-bool is_zero(const char *p, size_t n)
+bool bch_is_zero(const char *p, size_t n)
{
size_t i;
return false;
return true;
}
-EXPORT_SYMBOL_GPL(is_zero);
-int parse_uuid(const char *s, char *uuid)
+int bch_parse_uuid(const char *s, char *uuid)
{
size_t i, j, x;
memset(uuid, 0, 16);
}
return i;
}
-EXPORT_SYMBOL_GPL(parse_uuid);
-void time_stats_update(struct time_stats *stats, uint64_t start_time)
+void bch_time_stats_update(struct time_stats *stats, uint64_t start_time)
{
uint64_t now = local_clock();
uint64_t duration = time_after64(now, start_time)
stats->last = now ?: 1;
}
-EXPORT_SYMBOL_GPL(time_stats_update);
-unsigned next_delay(struct ratelimit *d, uint64_t done)
+unsigned bch_next_delay(struct ratelimit *d, uint64_t done)
{
uint64_t now = local_clock();
? div_u64(d->next - now, NSEC_PER_SEC / HZ)
: 0;
}
-EXPORT_SYMBOL_GPL(next_delay);
-void bio_map(struct bio *bio, void *base)
+void bch_bio_map(struct bio *bio, void *base)
{
size_t size = bio->bi_size;
struct bio_vec *bv = bio->bi_io_vec;
size -= bv->bv_len;
}
}
-EXPORT_SYMBOL_GPL(bio_map);
-int bio_alloc_pages(struct bio *bio, gfp_t gfp)
+int bch_bio_alloc_pages(struct bio *bio, gfp_t gfp)
{
int i;
struct bio_vec *bv;
return 0;
}
-EXPORT_SYMBOL_GPL(bio_alloc_pages);
/*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group (Any
0x9AFCE626CE85B507
};
-uint64_t crc64_update(uint64_t crc, const void *_data, size_t len)
+uint64_t bch_crc64_update(uint64_t crc, const void *_data, size_t len)
{
const unsigned char *data = _data;
return crc;
}
-EXPORT_SYMBOL(crc64_update);
-uint64_t crc64(const void *data, size_t len)
+uint64_t bch_crc64(const void *data, size_t len)
{
uint64_t crc = 0xffffffffffffffff;
- crc = crc64_update(crc, data, len);
+ crc = bch_crc64_update(crc, data, len);
return crc ^ 0xffffffffffffffff;
}
-EXPORT_SYMBOL(crc64);
#define ANYSINT_MAX(t) \
((((t) 1 << (sizeof(t) * 8 - 2)) - (t) 1) * (t) 2 + (t) 1)
-int strtoint_h(const char *, int *);
-int strtouint_h(const char *, unsigned int *);
-int strtoll_h(const char *, long long *);
-int strtoull_h(const char *, unsigned long long *);
+int bch_strtoint_h(const char *, int *);
+int bch_strtouint_h(const char *, unsigned int *);
+int bch_strtoll_h(const char *, long long *);
+int bch_strtoull_h(const char *, unsigned long long *);
-static inline int strtol_h(const char *cp, long *res)
+static inline int bch_strtol_h(const char *cp, long *res)
{
#if BITS_PER_LONG == 32
- return strtoint_h(cp, (int *) res);
+ return bch_strtoint_h(cp, (int *) res);
#else
- return strtoll_h(cp, (long long *) res);
+ return bch_strtoll_h(cp, (long long *) res);
#endif
}
-static inline int strtoul_h(const char *cp, long *res)
+static inline int bch_strtoul_h(const char *cp, long *res)
{
#if BITS_PER_LONG == 32
- return strtouint_h(cp, (unsigned int *) res);
+ return bch_strtouint_h(cp, (unsigned int *) res);
#else
- return strtoull_h(cp, (unsigned long long *) res);
+ return bch_strtoull_h(cp, (unsigned long long *) res);
#endif
}
#define strtoi_h(cp, res) \
(__builtin_types_compatible_p(typeof(*res), int) \
- ? strtoint_h(cp, (void *) res) \
+ ? bch_strtoint_h(cp, (void *) res) \
: __builtin_types_compatible_p(typeof(*res), long) \
- ? strtol_h(cp, (void *) res) \
+ ? bch_strtol_h(cp, (void *) res) \
: __builtin_types_compatible_p(typeof(*res), long long) \
- ? strtoll_h(cp, (void *) res) \
+ ? bch_strtoll_h(cp, (void *) res) \
: __builtin_types_compatible_p(typeof(*res), unsigned int) \
- ? strtouint_h(cp, (void *) res) \
+ ? bch_strtouint_h(cp, (void *) res) \
: __builtin_types_compatible_p(typeof(*res), unsigned long) \
- ? strtoul_h(cp, (void *) res) \
+ ? bch_strtoul_h(cp, (void *) res) \
: __builtin_types_compatible_p(typeof(*res), unsigned long long)\
- ? strtoull_h(cp, (void *) res) : -EINVAL)
+ ? bch_strtoull_h(cp, (void *) res) : -EINVAL)
#define strtoul_safe(cp, var) \
({ \
__builtin_types_compatible_p(typeof(var), const char *) \
? "%s\n" : "%i\n", var)
-ssize_t hprint(char *buf, int64_t v);
+ssize_t bch_hprint(char *buf, int64_t v);
-bool is_zero(const char *p, size_t n);
-int parse_uuid(const char *s, char *uuid);
+bool bch_is_zero(const char *p, size_t n);
+int bch_parse_uuid(const char *s, char *uuid);
-ssize_t snprint_string_list(char *buf, size_t size, const char * const list[],
+ssize_t bch_snprint_string_list(char *buf, size_t size, const char * const list[],
size_t selected);
-ssize_t read_string_list(const char *buf, const char * const list[]);
+ssize_t bch_read_string_list(const char *buf, const char * const list[]);
struct time_stats {
/*
uint64_t last;
};
-void time_stats_update(struct time_stats *stats, uint64_t time);
+void bch_time_stats_update(struct time_stats *stats, uint64_t time);
#define NSEC_PER_ns 1L
#define NSEC_PER_us NSEC_PER_USEC
d->next = local_clock();
}
-unsigned next_delay(struct ratelimit *d, uint64_t done);
+unsigned bch_next_delay(struct ratelimit *d, uint64_t done);
#define __DIV_SAFE(n, d, zero) \
({ \
#define bio_end(bio) ((bio)->bi_sector + bio_sectors(bio))
-void bio_map(struct bio *bio, void *base);
+void bch_bio_map(struct bio *bio, void *base);
-int bio_alloc_pages(struct bio *bio, gfp_t gfp);
+int bch_bio_alloc_pages(struct bio *bio, gfp_t gfp);
static inline sector_t bdev_sectors(struct block_device *bdev)
{
bch_generic_make_request(bio, &(dev)->bio_split_hook); \
} while (0)
-uint64_t crc64_update(uint64_t, const void *, size_t);
-uint64_t crc64(const void *, size_t);
+uint64_t bch_crc64_update(uint64_t, const void *, size_t);
+uint64_t bch_crc64(const void *, size_t);
#endif /* _BCACHE_UTIL_H */
!dc->writeback_percent)
return 0;
- return next_delay(&dc->writeback_rate, sectors * 10000000ULL);
+ return bch_next_delay(&dc->writeback_rate, sectors * 10000000ULL);
}
/* Background writeback */
bio->bi_max_vecs = DIV_ROUND_UP(KEY_SIZE(&w->key), PAGE_SECTORS);
bio->bi_private = w;
bio->bi_io_vec = bio->bi_inline_vecs;
- bio_map(bio, NULL);
+ bch_bio_map(bio, NULL);
}
static void refill_dirty(struct closure *cl)
io->bio.bi_rw = READ;
io->bio.bi_end_io = read_dirty_endio;
- if (bio_alloc_pages(&io->bio, GFP_KERNEL))
+ if (bch_bio_alloc_pages(&io->bio, GFP_KERNEL))
goto err_free;
pr_debug("%s", pkey(&w->key));
projects / platform / adaptation / renesas_rcar / renesas_kernel.git / commitdiff