md/bcache/super.c

64 static unsigned int get_bucket_size(struct cache_sb *sb, struct cache_sb_disk *s)
68 	if (sb->version >= BCACHE_SB_VERSION_CDEV_WITH_FEATURES) {
69 		if (bch_has_feature_large_bucket(sb)) {
82 		} else if (bch_has_feature_obso_large_bucket(sb)) {
91 static const char *read_super_common(struct cache_sb *sb,  struct block_device *bdev,
97 	sb->first_bucket= le16_to_cpu(s->first_bucket);
98 	sb->nbuckets	= le64_to_cpu(s->nbuckets);
99 	sb->bucket_size	= get_bucket_size(sb, s);
101 	sb->nr_in_set	= le16_to_cpu(s->nr_in_set);
102 	sb->nr_this_dev	= le16_to_cpu(s->nr_this_dev);
105 	if (sb->keys > SB_JOURNAL_BUCKETS)
109 	if (sb->nbuckets > LONG_MAX)
113 	if (sb->nbuckets < 1 << 7)
117 	if (!is_power_of_2(sb->block_size))
121 	if (sb->block_size > PAGE_SECTORS)
125 	if (!is_power_of_2(sb->bucket_size))
129 	if (sb->bucket_size < PAGE_SECTORS)
134 	    sb->bucket_size * sb->nbuckets)
138 	if (bch_is_zero(sb->set_uuid, 16))
142 	if (!sb->nr_in_set ||
143 	    sb->nr_in_set <= sb->nr_this_dev ||
144 	    sb->nr_in_set > MAX_CACHES_PER_SET)
148 	for (i = 0; i < sb->keys; i++)
149 		if (sb->d[i] != sb->first_bucket + i)
153 	if (sb->first_bucket + sb->keys > sb->nbuckets)
157 	if (sb->first_bucket * sb->bucket_size < 16)
166 static const char *read_super(struct cache_sb *sb, struct block_device *bdev,
180 	sb->offset		= le64_to_cpu(s->offset);
181 	sb->version		= le64_to_cpu(s->version);
183 	memcpy(sb->magic,	s->magic, 16);
184 	memcpy(sb->uuid,	s->uuid, 16);
185 	memcpy(sb->set_uuid,	s->set_uuid, 16);
186 	memcpy(sb->label,	s->label, SB_LABEL_SIZE);
188 	sb->flags		= le64_to_cpu(s->flags);
189 	sb->seq			= le64_to_cpu(s->seq);
190 	sb->last_mount		= le32_to_cpu(s->last_mount);
191 	sb->keys		= le16_to_cpu(s->keys);
194 		sb->d[i] = le64_to_cpu(s->d[i]);
196 	pr_debug("read sb version %llu, flags %llu, seq %llu, journal size %u\n",
197 		 sb->version, sb->flags, sb->seq, sb->keys);
200 	if (sb->offset != SB_SECTOR)
204 	if (memcmp(sb->magic, bcache_magic, 16))
212 	if (bch_is_zero(sb->uuid, 16))
215 	sb->block_size	= le16_to_cpu(s->block_size);
218 	if (sb->block_size << 9 < bdev_logical_block_size(bdev))
221 	switch (sb->version) {
223 		sb->data_offset	= BDEV_DATA_START_DEFAULT;
227 		sb->data_offset	= le64_to_cpu(s->data_offset);
230 		if (sb->data_offset < BDEV_DATA_START_DEFAULT)
236 		err = read_super_common(sb, bdev, s);
245 		sb->feature_compat = le64_to_cpu(s->feature_compat);
246 		sb->feature_incompat = le64_to_cpu(s->feature_incompat);
247 		sb->feature_ro_compat = le64_to_cpu(s->feature_ro_compat);
251 		if (bch_has_unknown_compat_features(sb))
255 		if (bch_has_unknown_ro_compat_features(sb))
259 		if (bch_has_unknown_incompat_features(sb))
262 		err = read_super_common(sb, bdev, s);
271 	sb->last_mount = (u32)ktime_get_real_seconds();
289 static void __write_super(struct cache_sb *sb, struct cache_sb_disk *out,
299 	out->offset		= cpu_to_le64(sb->offset);
301 	memcpy(out->uuid,	sb->uuid, 16);
302 	memcpy(out->set_uuid,	sb->set_uuid, 16);
303 	memcpy(out->label,	sb->label, SB_LABEL_SIZE);
305 	out->flags		= cpu_to_le64(sb->flags);
306 	out->seq		= cpu_to_le64(sb->seq);
308 	out->last_mount		= cpu_to_le32(sb->last_mount);
309 	out->first_bucket	= cpu_to_le16(sb->first_bucket);
310 	out->keys		= cpu_to_le16(sb->keys);
312 	for (i = 0; i < sb->keys; i++)
313 		out->d[i] = cpu_to_le64(sb->d[i]);
315 	if (sb->version >= BCACHE_SB_VERSION_CDEV_WITH_FEATURES) {
316 		out->feature_compat    = cpu_to_le64(sb->feature_compat);
317 		out->feature_incompat  = cpu_to_le64(sb->feature_incompat);
318 		out->feature_ro_compat = cpu_to_le64(sb->feature_ro_compat);
321 	out->version		= cpu_to_le64(sb->version);
325 		 sb->version, sb->flags, sb->seq);
351 	__write_super(&dc->sb, dc->sb_disk, bio);
383 	ca->sb.seq++;
385 	if (ca->sb.version < version)
386 		ca->sb.version = version;
393 	__write_super(&ca->sb, ca->sb_disk, bio);
512 	size =  meta_bucket_pages(&ca->sb) * PAGE_SECTORS;
518 	atomic_long_add(ca->sb.bucket_size, &ca->meta_sectors_written);
597 	bio->bi_iter.bi_sector	= bucket * ca->sb.bucket_size;
599 	bio->bi_iter.bi_size	= meta_bucket_bytes(&ca->sb);
639 	atomic_long_add(ca->sb.bucket_size * prio_buckets(ca),
649 		     b < ca->buckets + ca->sb.nbuckets && d < end;
656 		p->magic	= pset_magic(&ca->sb);
657 		p->csum		= bch_crc64(&p->magic, meta_bucket_bytes(&ca->sb) - 8);
700 	     b < ca->buckets + ca->sb.nbuckets;
710 			    bch_crc64(&p->magic, meta_bucket_bytes(&ca->sb) - 8)) {
715 			if (p->magic != pset_magic(&ca->sb)) {
957 		pr_info("bcache%i: sb/logical block size (%u) greater than page size (%lu) falling back to device logical block size (%u)\n",
1053 	char *buf = kmemdup_nul(dc->sb.label, SB_LABEL_SIZE, GFP_KERNEL);
1056 		kasprintf(GFP_KERNEL, "CACHED_UUID=%pU", dc->sb.uuid),
1074 	    BDEV_STATE(&dc->sb) != BDEV_STATE_NONE) {
1079 		SET_BDEV_STATE(&dc->sb, BDEV_STATE_STALE);
1204 	    (!set_uuid && memcmp(dc->sb.set_uuid, c->set_uuid, 16)))
1217 	if (dc->sb.block_size < c->cache->sb.block_size) {
1226 		if (!memcmp(dc->sb.uuid, exist_dc->sb.uuid, 16)) {
1234 	u = uuid_find(c, dc->sb.uuid);
1237 	    (BDEV_STATE(&dc->sb) == BDEV_STATE_STALE ||
1238 	     BDEV_STATE(&dc->sb) == BDEV_STATE_NONE)) {
1245 		if (BDEV_STATE(&dc->sb) == BDEV_STATE_DIRTY) {
1267 		memcpy(u->uuid, dc->sb.uuid, 16);
1268 		memcpy(u->label, dc->sb.label, SB_LABEL_SIZE);
1272 		memcpy(dc->sb.set_uuid, c->set_uuid, 16);
1273 		SET_BDEV_STATE(&dc->sb, BDEV_STATE_CLEAN);
1302 	if (BDEV_STATE(&dc->sb) == BDEV_STATE_DIRTY) {
1327 	if (bch_has_feature_obso_large_bucket(&(c->cache->sb))) {
1430 			 bdev_nr_sectors(dc->bdev) - dc->sb.data_offset,
1448 static int register_bdev(struct cache_sb *sb, struct cache_sb_disk *sb_disk,
1456 	memcpy(&dc->sb, sb, sizeof(struct cache_sb));
1461 	if (cached_dev_init(dc, sb->block_size << 9))
1477 	if (BDEV_STATE(&dc->sb) == BDEV_STATE_NONE ||
1478 	    BDEV_STATE(&dc->sb) == BDEV_STATE_STALE) {
1556 	if (bch_has_feature_obso_large_bucket(&c->cache->sb)) {
1686 	free_pages((unsigned long) c->uuids, ilog2(meta_bucket_pages(&c->cache->sb)));
1854 #define alloc_meta_bucket_pages(gfp, sb)		\
1855 	((void *) __get_free_pages(__GFP_ZERO|__GFP_COMP|gfp, ilog2(meta_bucket_pages(sb))))
1857 struct cache_set *bch_cache_set_alloc(struct cache_sb *sb)
1860 	struct cache *ca = container_of(sb, struct cache, sb);
1882 	memcpy(c->set_uuid, sb->set_uuid, 16);
1886 	c->bucket_bits		= ilog2(sb->bucket_size);
1887 	c->block_bits		= ilog2(sb->block_size);
1888 	c->nr_uuids		= meta_bucket_bytes(sb) / sizeof(struct uuid_entry);
1891 	c->btree_pages		= meta_bucket_pages(sb);
1918 		    ((meta_bucket_pages(sb) * PAGE_SECTORS) / sb->block_size) *
1930 			sizeof(struct bio_vec) * meta_bucket_pages(sb)))
1940 	c->uuids = alloc_meta_bucket_pages(GFP_KERNEL, sb);
1983 	c->nbuckets = ca->sb.nbuckets;
1986 	if (CACHE_SYNC(&c->cache->sb)) {
2003 		if (prio_read(ca, j->prio_bucket[ca->sb.nr_this_dev]))
2071 		ca->sb.keys = clamp_t(int, ca->sb.nbuckets >> 7,
2074 		for (j = 0; j < ca->sb.keys; j++)
2075 			ca->sb.d[j] = ca->sb.first_bucket + j;
2109 		SET_CACHE_SYNC(&c->cache->sb, true);
2120 	c->cache->sb.last_mount = (u32)ktime_get_real_seconds();
2123 	if (bch_has_feature_obso_large_bucket(&c->cache->sb))
2155 		if (!memcmp(c->set_uuid, ca->sb.set_uuid, 16)) {
2162 	c = bch_cache_set_alloc(&ca->sb);
2178 	sprintf(buf, "cache%i", ca->sb.nr_this_dev);
2210 	free_pages((unsigned long) ca->disk_buckets, ilog2(meta_bucket_pages(&ca->sb)));
2244 	 * when ca->sb.njournal_buckets is not zero, journal exists,
2252 	btree_buckets = ca->sb.njournal_buckets ?: 8;
2253 	free = roundup_pow_of_two(ca->sb.nbuckets) >> 10;
2256 		err = "ca->sb.nbuckets is too small";
2293 			      ca->sb.nbuckets));
2307 	ca->disk_buckets = alloc_meta_bucket_pages(GFP_KERNEL, &ca->sb);
2343 static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk,
2350 	memcpy(&ca->sb, sb, sizeof(struct cache_sb));
2356 		ca->discard = CACHE_DISCARD(&ca->sb);
2449 	struct cache_sb *sb;
2462 	if (register_bdev(args->sb, args->sb_disk, args->bdev_file,
2470 	kfree(args->sb);
2483 	if (register_cache(args->sb, args->sb_disk, args->bdev_file,
2490 	kfree(args->sb);
2498 	if (SB_IS_BDEV(args->sb))
2507 static void *alloc_holder_object(struct cache_sb *sb)
2509 	if (SB_IS_BDEV(sb))
2519 	struct cache_sb *sb;
2548 	sb = kmalloc(sizeof(struct cache_sb), GFP_KERNEL);
2549 	if (!sb)
2562 	err = read_super(sb, file_bdev(bdev_file), &sb_disk);
2566 	holder = alloc_holder_object(sb);
2613 		args->sb	= sb;
2622 	if (SB_IS_BDEV(sb)) {
2624 		ret = register_bdev(sb, sb_disk, bdev_file, holder);
2631 		ret = register_cache(sb, sb_disk, bdev_file, holder);
2636 	kfree(sb);
2650 	kfree(sb);
2689 		char *pdev_set_uuid = pdev->dc->sb.set_uuid;