6298213418

Committed 22 Sep 2023 06:47PM UTC coverage: 46.509% (+2.7%) from 43.76%

Build # 6298213418

Build Type

push

github

Committed by

t-8ch

Commit Message

libblkid: (bcachefs) fix size validation

Avoid signed shift out-of-bounds.

Also mark the constants explitly as unsigned instead of casting.

Signed-off-by: Thomas Weißschuh <thomas@t-8ch.de>
(cherry picked from commit befe455f5)

Run Details

24586 of 53862 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

44913 of 95568 relevant lines covered (47.0%)

15851.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.84

/libblkid/src/superblocks/bcache.c

/*
 * Copyright (C) 2013 Rolf Fokkens <rolf@fokkens.nl>
 *
 * This file may be redistributed under the terms of the
 * GNU Lesser General Public License.
 *
 * Based on code fragments from bcache-tools by Kent Overstreet:
 * http://evilpiepirate.org/git/bcache-tools.git
 */

#include <stddef.h>
#include <stdio.h>

#include "superblocks.h"
#include "crc32c.h"
#include "crc64.h"
#include "xxhash.h"

#define SB_LABEL_SIZE      32
#define SB_JOURNAL_BUCKETS 256U

/*
 * The bcache_super_block is adapted from struct cache_sb in kernel.
 * https://github.com/torvalds/linux/blob/master/drivers/md/bcache/bcache_ondisk.h
 */
struct bcache_super_block {
        uint64_t                csum;
        uint64_t                offset;                /* where this super block was written */
        uint64_t                version;
        uint8_t                        magic[16];        /* bcache file system identifier */
        uint8_t                        uuid[16];        /* device identifier */
        uint8_t                        set_info[16];        /* magic or uuid */
        uint8_t                        label[SB_LABEL_SIZE];
        uint64_t                flags;
        uint64_t                seq;

        uint64_t                feature_compat;
        uint64_t                feature_incompat;
        uint64_t                feature_ro_compat;

        uint64_t                pad[5];

        union {
        struct {
                /* Cache devices */
                uint64_t        nbuckets;        /* device size */

                uint16_t        block_size;        /* sectors */
                uint16_t        bucket_size;        /* sectors */

                uint16_t        nr_in_set;
                uint16_t        nr_this_dev;
        };
        struct {
                /* Backing devices */
                uint64_t        data_offset;
        };
        };

        uint32_t                last_mount;

        uint16_t                first_bucket;
        union {
                uint16_t        njournal_buckets;
                uint16_t        keys;
        };
        uint64_t                d[SB_JOURNAL_BUCKETS];        /* journal buckets */
        uint16_t                obso_bucket_size_hi;        /* obsoleted */
} __attribute__((packed));

struct bcachefs_sb_field {
        uint32_t        u64s;
        uint32_t        type;
}  __attribute__((packed));

struct bcachefs_sb_member {
        uint8_t                uuid[16];
        uint64_t        nbuckets;
        uint16_t        first_bucket;
        uint16_t        bucket_size;
        uint32_t        pad;
        uint64_t        last_mount;
        uint64_t        flags[2];
} __attribute__((packed));

struct bcachefs_sb_field_members {
        struct bcachefs_sb_field        field;
        struct bcachefs_sb_member        members[];
}  __attribute__((packed));

enum bcachefs_sb_csum_type {
        BCACHEFS_SB_CSUM_TYPE_NONE = 0,
        BCACHEFS_SB_CSUM_TYPE_CRC32C = 1,
        BCACHEFS_SB_CSUM_TYPE_CRC64 = 2,
        BCACHEFS_SB_CSUM_TYPE_XXHASH = 7,
};

union bcachefs_sb_csum {
        uint32_t crc32c;
        uint64_t crc64;
        XXH64_hash_t xxh64;
        uint8_t raw[16];
} __attribute__((packed));

struct bcachefs_sb_layout {
        uint8_t                magic[16];
        uint8_t                layout_type;
        uint8_t                sb_max_size_bits;
        uint8_t                nr_superblocks;
        uint8_t                pad[5];
        uint64_t        sb_offset[61];
} __attribute__((packed));

struct bcachefs_super_block {
        union bcachefs_sb_csum        csum;
        uint16_t        version;
        uint16_t        version_min;
        uint16_t        pad[2];
        uint8_t                magic[16];
        uint8_t                uuid[16];
        uint8_t                user_uuid[16];
        uint8_t                label[SB_LABEL_SIZE];
        uint64_t        offset;
        uint64_t        seq;
        uint16_t        block_size;
        uint8_t                dev_idx;
        uint8_t                nr_devices;
        uint32_t        u64s;
        uint64_t        time_base_lo;
        uint32_t        time_base_hi;
        uint32_t        time_precision;
        uint64_t        flags[8];
        uint64_t        features[2];
        uint64_t        compat[2];
        struct bcachefs_sb_layout layout;
        struct bcachefs_sb_field _start[];
}  __attribute__((packed));

/* magic string */
#define BCACHE_SB_MAGIC     "\xc6\x85\x73\xf6\x4e\x1a\x45\xca\x82\x65\xf5\x7f\x48\xba\x6d\x81"
#define BCACHEFS_SB_MAGIC   "\xc6\x85\x73\xf6\x66\xce\x90\xa9\xd9\x6a\x60\xcf\x80\x3d\xf7\xef"
/* magic string len */
#define BCACHE_SB_MAGIC_LEN (sizeof(BCACHE_SB_MAGIC) - 1)
/* super block offset */
#define BCACHE_SB_OFF       0x1000U
/* supper block offset in kB */
#define BCACHE_SB_KBOFF     (BCACHE_SB_OFF >> 10)
/* magic string offset within super block */
#define BCACHE_SB_MAGIC_OFF offsetof(struct bcache_super_block, magic)
/* start of checksummed data within superblock */
#define BCACHE_SB_CSUMMED_START 8U
/* granularity of offset and length fields within superblock */
#define BCACHEFS_SECTOR_SIZE   512U
/* maximum superblock size shift */
#define BCACHEFS_SB_MAX_SIZE_SHIFT   0x10U
/* maximum superblock size */
#define BCACHEFS_SB_MAX_SIZE   (1U << BCACHEFS_SB_MAX_SIZE_SHIFT)
/* fields offset within super block */
#define BCACHEFS_SB_FIELDS_OFF offsetof(struct bcachefs_super_block, _start)
/* tag value for members field */
#define BCACHEFS_SB_FIELD_TYPE_MEMBERS 1

#define BYTES(f) ((((uint64_t) le32_to_cpu((f)->u64s)) * 8))

static int bcache_verify_checksum(blkid_probe pr, const struct blkid_idmag *mag,
                const struct bcache_super_block *bcs)
{
        const unsigned char *csummed;
        size_t csummed_size;
        uint64_t csum;

        if (le16_to_cpu(bcs->keys) > ARRAY_SIZE(bcs->d))
                return 0;

        /* up to the end of bcs->d[] */
        csummed_size = offsetof(typeof(*bcs), d) +
                sizeof(bcs->d[0]) * le16_to_cpu(bcs->keys);
        csummed = blkid_probe_get_sb_buffer(pr, mag, csummed_size);
        csum = ul_crc64_we(csummed + BCACHE_SB_CSUMMED_START,
                           csummed_size - BCACHE_SB_CSUMMED_START);
        return blkid_probe_verify_csum(pr, csum, le64_to_cpu(bcs->csum));
}

static int probe_bcache (blkid_probe pr, const struct blkid_idmag *mag)
{
        struct bcache_super_block *bcs;

        bcs = blkid_probe_get_sb(pr, mag, struct bcache_super_block);
        if (!bcs)
                return errno ? -errno : BLKID_PROBE_NONE;

        if (!bcache_verify_checksum(pr, mag, bcs))
                return BLKID_PROBE_NONE;

        if (le64_to_cpu(bcs->offset) != BCACHE_SB_OFF / 512)
                return BLKID_PROBE_NONE;

        if (blkid_probe_set_uuid(pr, bcs->uuid) < 0)
                return BLKID_PROBE_NONE;

        blkid_probe_set_wiper(pr, 0, BCACHE_SB_OFF);

        return BLKID_PROBE_OK;
}

static void probe_bcachefs_sb_members(blkid_probe pr,
                                     const struct bcachefs_super_block *bcs,
                                     const struct bcachefs_sb_field *field,
                                     uint8_t dev_idx)
{
        struct bcachefs_sb_field_members *members =
                        (struct bcachefs_sb_field_members *) field;
        uint64_t sectors = 0;
        uint8_t i;

        if (BYTES(field) != offsetof(typeof(*members), members[bcs->nr_devices]))
                return;

        blkid_probe_set_uuid_as(pr, members->members[dev_idx].uuid, "UUID_SUB");

        for (i = 0; i < bcs->nr_devices; i++) {
                struct bcachefs_sb_member *member = &members->members[i];
                sectors += le64_to_cpu(member->nbuckets) * le16_to_cpu(member->bucket_size);
        }
        blkid_probe_set_fssize(pr, sectors * BCACHEFS_SECTOR_SIZE);
}

static int is_within_range(void *start, uint64_t size, void *end)
{
        ptrdiff_t diff;

        if (start >= end)
                return 0; // should not happen

        diff = (unsigned char *) end - (unsigned char *) start;
        return size <= (uint64_t) diff;
}

static void probe_bcachefs_sb_fields(blkid_probe pr, const struct bcachefs_super_block *bcs,
                                     unsigned char *sb_start, unsigned char *sb_end)
{
        unsigned char *field_addr = sb_start + BCACHEFS_SB_FIELDS_OFF;

        while (1) {
                struct bcachefs_sb_field *field = (struct bcachefs_sb_field *) field_addr;
                uint64_t field_size;
                uint32_t type;

                if (!is_within_range(field, sizeof(*field), sb_end))
                        break;

                field_size = BYTES(field);

                if (field_size < sizeof(*field))
                        break;

                if (!is_within_range(field, field_size, sb_end))
                        break;

                type = le32_to_cpu(field->type);
                if (!type)
                        break;

                if (type == BCACHEFS_SB_FIELD_TYPE_MEMBERS)
                        probe_bcachefs_sb_members(pr, bcs, field, bcs->dev_idx);

                field_addr += BYTES(field);
        }
}

static int bcachefs_validate_checksum(blkid_probe pr, const struct bcachefs_super_block *bcs,
                                      unsigned char *sb, unsigned char *sb_end)
{
        uint8_t checksum_type = be64_to_cpu(bcs->flags[0]) >> 58;
        unsigned char *checksummed_data_start = sb + sizeof(bcs->csum);
        size_t checksummed_data_size = sb_end - checksummed_data_start;

        switch (checksum_type) {
                case BCACHEFS_SB_CSUM_TYPE_NONE:
                        return 1;
                case BCACHEFS_SB_CSUM_TYPE_CRC32C: {
                        uint32_t crc = crc32c(~0LL, checksummed_data_start, checksummed_data_size) ^ ~0LL;
                        return blkid_probe_verify_csum(pr, crc, le32_to_cpu(bcs->csum.crc32c));
                }
                case BCACHEFS_SB_CSUM_TYPE_CRC64: {
                        uint64_t crc = ul_crc64_we(checksummed_data_start, checksummed_data_size);
                        return blkid_probe_verify_csum(pr, crc, le64_to_cpu(bcs->csum.crc64));
                }
                case BCACHEFS_SB_CSUM_TYPE_XXHASH: {
                        XXH64_hash_t xxh64 = XXH64(checksummed_data_start, checksummed_data_size, 0);
                        return blkid_probe_verify_csum(pr, xxh64, le64_to_cpu(bcs->csum.xxh64));
                }
                default:
                        DBG(LOWPROBE, ul_debug("bcachefs: unknown checksum type %d, ignoring.", checksum_type));
                        return 1;
        }
}

static int probe_bcachefs(blkid_probe pr, const struct blkid_idmag *mag)
{
        struct bcachefs_super_block *bcs;
        unsigned char *sb, *sb_end;
        uint64_t sb_size, blocksize;

        bcs = blkid_probe_get_sb(pr, mag, struct bcachefs_super_block);
        if (!bcs)
                return errno ? -errno : BLKID_PROBE_NONE;

        if (le64_to_cpu(bcs->offset) != BCACHE_SB_OFF / BCACHEFS_SECTOR_SIZE)
                return BLKID_PROBE_NONE;

        if (bcs->nr_devices == 0 || bcs->dev_idx >= bcs->nr_devices)
                return BLKID_PROBE_NONE;

        sb_size = BCACHEFS_SB_FIELDS_OFF + BYTES(bcs);

        if (sb_size > BCACHEFS_SB_MAX_SIZE)
                return BLKID_PROBE_NONE;

        if (bcs->layout.sb_max_size_bits > BCACHEFS_SB_MAX_SIZE_SHIFT)
                return BLKID_PROBE_NONE;

        if (sb_size > (BCACHEFS_SECTOR_SIZE << bcs->layout.sb_max_size_bits))
                return BLKID_PROBE_NONE;

        sb = blkid_probe_get_sb_buffer(pr, mag, sb_size);
        if (!sb)
                return BLKID_PROBE_NONE;
        sb_end = sb + sb_size;

        if (!bcachefs_validate_checksum(pr, bcs, sb, sb_end))
                return BLKID_PROBE_NONE;

        blkid_probe_set_uuid(pr, bcs->user_uuid);
        blkid_probe_set_label(pr, bcs->label, sizeof(bcs->label));
        blkid_probe_sprintf_version(pr, "%d", le16_to_cpu(bcs->version));
        blocksize = le16_to_cpu(bcs->block_size);
        blkid_probe_set_block_size(pr, blocksize * BCACHEFS_SECTOR_SIZE);
        blkid_probe_set_fsblocksize(pr, blocksize * BCACHEFS_SECTOR_SIZE);
        blkid_probe_set_wiper(pr, 0, BCACHE_SB_OFF);

        probe_bcachefs_sb_fields(pr, bcs, sb, sb_end);

        return BLKID_PROBE_OK;
}

const struct blkid_idinfo bcache_idinfo =
{
        .name                = "bcache",
        .usage                = BLKID_USAGE_OTHER,
        .probefunc        = probe_bcache,
        .minsz                = 8192,
        .magics                =
        {
                {
                        .magic = BCACHE_SB_MAGIC,
                        .len   = BCACHE_SB_MAGIC_LEN,
                        .kboff = BCACHE_SB_KBOFF,
                        .sboff = BCACHE_SB_MAGIC_OFF
                },
                { NULL }
        }
};

const struct blkid_idinfo bcachefs_idinfo =
{
        .name                = "bcachefs",
        .usage                = BLKID_USAGE_FILESYSTEM,
        .probefunc        = probe_bcachefs,
        .minsz                = 256 * BCACHEFS_SECTOR_SIZE,
        .magics                = {
                {
                        .magic = BCACHE_SB_MAGIC,
                        .len   = BCACHE_SB_MAGIC_LEN,
                        .kboff = BCACHE_SB_KBOFF,
                        .sboff = BCACHE_SB_MAGIC_OFF,
                },
                {
                        .magic = BCACHEFS_SB_MAGIC,
                        .len   = BCACHE_SB_MAGIC_LEN,
                        .kboff = BCACHE_SB_KBOFF,
                        .sboff = BCACHE_SB_MAGIC_OFF,
                },
                { NULL }
        }
};

1	/*
2	* Copyright (C) 2013 Rolf Fokkens <rolf@fokkens.nl>
3	*
4	* This file may be redistributed under the terms of the
5	* GNU Lesser General Public License.
6	*
7	* Based on code fragments from bcache-tools by Kent Overstreet:
8	* http://evilpiepirate.org/git/bcache-tools.git
9	*/
10
11	#include <stddef.h>
12	#include <stdio.h>
13
14	#include "superblocks.h"
15	#include "crc32c.h"
16	#include "crc64.h"
17	#include "xxhash.h"
18
19	#define SB_LABEL_SIZE 32
20	#define SB_JOURNAL_BUCKETS 256U
21
22	/*
23	* The bcache_super_block is adapted from struct cache_sb in kernel.
24	* https://github.com/torvalds/linux/blob/master/drivers/md/bcache/bcache_ondisk.h
25	*/
26	struct bcache_super_block {
27	uint64_t csum;
28	uint64_t offset; /* where this super block was written */
29	uint64_t version;
30	uint8_t magic[16]; /* bcache file system identifier */
31	uint8_t uuid[16]; /* device identifier */
32	uint8_t set_info[16]; /* magic or uuid */
33	uint8_t label[SB_LABEL_SIZE];
34	uint64_t flags;
35	uint64_t seq;
36
37	uint64_t feature_compat;
38	uint64_t feature_incompat;
39	uint64_t feature_ro_compat;
40
41	uint64_t pad[5];
42
43	union {
44	struct {
45	/* Cache devices */
46	uint64_t nbuckets; /* device size */
47
48	uint16_t block_size; /* sectors */
49	uint16_t bucket_size; /* sectors */
50
51	uint16_t nr_in_set;
52	uint16_t nr_this_dev;
53	};
54	struct {
55	/* Backing devices */
56	uint64_t data_offset;
57	};
58	};
59
60	uint32_t last_mount;
61
62	uint16_t first_bucket;
63	union {
64	uint16_t njournal_buckets;
65	uint16_t keys;
66	};
67	uint64_t d[SB_JOURNAL_BUCKETS]; /* journal buckets */
68	uint16_t obso_bucket_size_hi; /* obsoleted */
69	} __attribute__((packed));
70
71	struct bcachefs_sb_field {
72	uint32_t u64s;
73	uint32_t type;
74	} __attribute__((packed));
75
76	struct bcachefs_sb_member {
77	uint8_t uuid[16];
78	uint64_t nbuckets;
79	uint16_t first_bucket;
80	uint16_t bucket_size;
81	uint32_t pad;
82	uint64_t last_mount;
83	uint64_t flags[2];
84	} __attribute__((packed));
85
86	struct bcachefs_sb_field_members {
87	struct bcachefs_sb_field field;
88	struct bcachefs_sb_member members[];
89	} __attribute__((packed));
90
91	enum bcachefs_sb_csum_type {
92	BCACHEFS_SB_CSUM_TYPE_NONE = 0,
93	BCACHEFS_SB_CSUM_TYPE_CRC32C = 1,
94	BCACHEFS_SB_CSUM_TYPE_CRC64 = 2,
95	BCACHEFS_SB_CSUM_TYPE_XXHASH = 7,
96	};
97
98	union bcachefs_sb_csum {
99	uint32_t crc32c;
100	uint64_t crc64;
101	XXH64_hash_t xxh64;
102	uint8_t raw[16];
103	} __attribute__((packed));
104
105	struct bcachefs_sb_layout {
106	uint8_t magic[16];
107	uint8_t layout_type;
108	uint8_t sb_max_size_bits;
109	uint8_t nr_superblocks;
110	uint8_t pad[5];
111	uint64_t sb_offset[61];
112	} __attribute__((packed));
113
114	struct bcachefs_super_block {
115	union bcachefs_sb_csum csum;
116	uint16_t version;
117	uint16_t version_min;
118	uint16_t pad[2];
119	uint8_t magic[16];
120	uint8_t uuid[16];
121	uint8_t user_uuid[16];
122	uint8_t label[SB_LABEL_SIZE];
123	uint64_t offset;
124	uint64_t seq;
125	uint16_t block_size;
126	uint8_t dev_idx;
127	uint8_t nr_devices;
128	uint32_t u64s;
129	uint64_t time_base_lo;
130	uint32_t time_base_hi;
131	uint32_t time_precision;
132	uint64_t flags[8];
133	uint64_t features[2];
134	uint64_t compat[2];
135	struct bcachefs_sb_layout layout;
136	struct bcachefs_sb_field _start[];
137	} __attribute__((packed));
138
139	/* magic string */
140	#define BCACHE_SB_MAGIC "\xc6\x85\x73\xf6\x4e\x1a\x45\xca\x82\x65\xf5\x7f\x48\xba\x6d\x81"
141	#define BCACHEFS_SB_MAGIC "\xc6\x85\x73\xf6\x66\xce\x90\xa9\xd9\x6a\x60\xcf\x80\x3d\xf7\xef"
142	/* magic string len */
143	#define BCACHE_SB_MAGIC_LEN (sizeof(BCACHE_SB_MAGIC) - 1)
144	/* super block offset */
145	#define BCACHE_SB_OFF 0x1000U
146	/* supper block offset in kB */
147	#define BCACHE_SB_KBOFF (BCACHE_SB_OFF >> 10)
148	/* magic string offset within super block */
149	#define BCACHE_SB_MAGIC_OFF offsetof(struct bcache_super_block, magic)
150	/* start of checksummed data within superblock */
151	#define BCACHE_SB_CSUMMED_START 8U
152	/* granularity of offset and length fields within superblock */
153	#define BCACHEFS_SECTOR_SIZE 512U
154	/* maximum superblock size shift */
155	#define BCACHEFS_SB_MAX_SIZE_SHIFT 0x10U
156	/* maximum superblock size */
157	#define BCACHEFS_SB_MAX_SIZE (1U << BCACHEFS_SB_MAX_SIZE_SHIFT)
158	/* fields offset within super block */
159	#define BCACHEFS_SB_FIELDS_OFF offsetof(struct bcachefs_super_block, _start)
160	/* tag value for members field */
161	#define BCACHEFS_SB_FIELD_TYPE_MEMBERS 1
162
163	#define BYTES(f) ((((uint64_t) le32_to_cpu((f)->u64s)) * 8))
164
165	static int bcache_verify_checksum(blkid_probe pr, const struct blkid_idmag *mag,	4✔
166	const struct bcache_super_block *bcs)
167	{
168	const unsigned char *csummed;	4✔
169	size_t csummed_size;	4✔
170	uint64_t csum;	4✔
171
172	if (le16_to_cpu(bcs->keys) > ARRAY_SIZE(bcs->d))	4!
173	return 0;
174
175	/* up to the end of bcs->d[] */
176	csummed_size = offsetof(typeof(*bcs), d) +	4✔
177	sizeof(bcs->d[0]) * le16_to_cpu(bcs->keys);	4✔
178	csummed = blkid_probe_get_sb_buffer(pr, mag, csummed_size);	4✔
179	csum = ul_crc64_we(csummed + BCACHE_SB_CSUMMED_START,	4✔
180	csummed_size - BCACHE_SB_CSUMMED_START);
181	return blkid_probe_verify_csum(pr, csum, le64_to_cpu(bcs->csum));	4✔
182	}
183
184	static int probe_bcache (blkid_probe pr, const struct blkid_idmag *mag)	4✔
185	{
186	struct bcache_super_block *bcs;	4✔
187
188	bcs = blkid_probe_get_sb(pr, mag, struct bcache_super_block);	4✔
189	if (!bcs)	4!
190	return errno ? -errno : BLKID_PROBE_NONE;	×
191
192	if (!bcache_verify_checksum(pr, mag, bcs))	4✔
193	return BLKID_PROBE_NONE;
194
195	if (le64_to_cpu(bcs->offset) != BCACHE_SB_OFF / 512)	3!
196	return BLKID_PROBE_NONE;
197
198	if (blkid_probe_set_uuid(pr, bcs->uuid) < 0)	3!
199	return BLKID_PROBE_NONE;
200
201	blkid_probe_set_wiper(pr, 0, BCACHE_SB_OFF);	3✔
202
203	return BLKID_PROBE_OK;	3✔
204	}
205
206	static void probe_bcachefs_sb_members(blkid_probe pr,	2✔
207	const struct bcachefs_super_block *bcs,
208	const struct bcachefs_sb_field *field,
209	uint8_t dev_idx)
210	{
211	struct bcachefs_sb_field_members *members =	2✔
212	(struct bcachefs_sb_field_members *) field;
213	uint64_t sectors = 0;	2✔
214	uint8_t i;	2✔
215
216	if (BYTES(field) != offsetof(typeof(*members), members[bcs->nr_devices]))	2!
217	return;
218
219	blkid_probe_set_uuid_as(pr, members->members[dev_idx].uuid, "UUID_SUB");	2✔
220
221	for (i = 0; i < bcs->nr_devices; i++) {	6✔
222	struct bcachefs_sb_member *member = &members->members[i];	2✔
223	sectors += le64_to_cpu(member->nbuckets) * le16_to_cpu(member->bucket_size);	2✔
224	}
225	blkid_probe_set_fssize(pr, sectors * BCACHEFS_SECTOR_SIZE);	2✔
226	}
227
228	static int is_within_range(void start, uint64_t size, void end)	7✔
229	{
230	ptrdiff_t diff;	7✔
231
232	if (start >= end)	7✔
233	return 0; // should not happen
234
235	diff = (unsigned char ) end - (unsigned char ) start;	6✔
236	return size <= (uint64_t) diff;	6✔
237	}
238
239	static void probe_bcachefs_sb_fields(blkid_probe pr, const struct bcachefs_super_block *bcs,	2✔
240	unsigned char sb_start, unsigned char sb_end)
241	{
242	unsigned char *field_addr = sb_start + BCACHEFS_SB_FIELDS_OFF;	2✔
243
244	while (1) {	2✔
245	struct bcachefs_sb_field field = (struct bcachefs_sb_field ) field_addr;	4✔
246	uint64_t field_size;	4✔
247	uint32_t type;	4✔
248
249	if (!is_within_range(field, sizeof(*field), sb_end))	4✔
250	break;
251
252	field_size = BYTES(field);	3!
253
254	if (field_size < sizeof(*field))	3!
255	break;
256
257	if (!is_within_range(field, field_size, sb_end))	3!
258	break;
259
260	type = le32_to_cpu(field->type);	3✔
261	if (!type)	3✔
262	break;
263
264	if (type == BCACHEFS_SB_FIELD_TYPE_MEMBERS)	2!
265	probe_bcachefs_sb_members(pr, bcs, field, bcs->dev_idx);	2✔
266
267	field_addr += BYTES(field);	2✔
268	}
269	}	2✔
270
271	static int bcachefs_validate_checksum(blkid_probe pr, const struct bcachefs_super_block *bcs,	2✔
272	unsigned char sb, unsigned char sb_end)
273	{
274	uint8_t checksum_type = be64_to_cpu(bcs->flags[0]) >> 58;	2!
275	unsigned char *checksummed_data_start = sb + sizeof(bcs->csum);	2✔
276	size_t checksummed_data_size = sb_end - checksummed_data_start;	2✔
277
278	switch (checksum_type) {	2!
279	case BCACHEFS_SB_CSUM_TYPE_NONE:
280	return 1;
281	case BCACHEFS_SB_CSUM_TYPE_CRC32C: {	1✔
282	uint32_t crc = crc32c(~0LL, checksummed_data_start, checksummed_data_size) ^ ~0LL;	1✔
283	return blkid_probe_verify_csum(pr, crc, le32_to_cpu(bcs->csum.crc32c));	1✔
284	}
285	case BCACHEFS_SB_CSUM_TYPE_CRC64: {	×
286	uint64_t crc = ul_crc64_we(checksummed_data_start, checksummed_data_size);	×
287	return blkid_probe_verify_csum(pr, crc, le64_to_cpu(bcs->csum.crc64));	×
288	}
289	case BCACHEFS_SB_CSUM_TYPE_XXHASH: {	×
290	XXH64_hash_t xxh64 = XXH64(checksummed_data_start, checksummed_data_size, 0);	×
291	return blkid_probe_verify_csum(pr, xxh64, le64_to_cpu(bcs->csum.xxh64));	×
292	}
293	default:	×
294	DBG(LOWPROBE, ul_debug("bcachefs: unknown checksum type %d, ignoring.", checksum_type));	×
295	return 1;
296	}
297	}
298
299	static int probe_bcachefs(blkid_probe pr, const struct blkid_idmag *mag)	3✔
300	{
301	struct bcachefs_super_block *bcs;	3✔
302	unsigned char sb, sb_end;	3✔
303	uint64_t sb_size, blocksize;	3✔
304
305	bcs = blkid_probe_get_sb(pr, mag, struct bcachefs_super_block);	3✔
306	if (!bcs)	3!
307	return errno ? -errno : BLKID_PROBE_NONE;	×
308
309	if (le64_to_cpu(bcs->offset) != BCACHE_SB_OFF / BCACHEFS_SECTOR_SIZE)	3✔
310	return BLKID_PROBE_NONE;
311
312	if (bcs->nr_devices == 0 \|\| bcs->dev_idx >= bcs->nr_devices)	2!
313	return BLKID_PROBE_NONE;
314
315	sb_size = BCACHEFS_SB_FIELDS_OFF + BYTES(bcs);	2!
316
317	if (sb_size > BCACHEFS_SB_MAX_SIZE)	2!
318	return BLKID_PROBE_NONE;
319
320	if (bcs->layout.sb_max_size_bits > BCACHEFS_SB_MAX_SIZE_SHIFT)	2!
321	return BLKID_PROBE_NONE;
322
323	if (sb_size > (BCACHEFS_SECTOR_SIZE << bcs->layout.sb_max_size_bits))	2!
324	return BLKID_PROBE_NONE;
325
326	sb = blkid_probe_get_sb_buffer(pr, mag, sb_size);	2✔
327	if (!sb)	2!
328	return BLKID_PROBE_NONE;
329	sb_end = sb + sb_size;	2✔
330
331	if (!bcachefs_validate_checksum(pr, bcs, sb, sb_end))	2!
332	return BLKID_PROBE_NONE;
333
334	blkid_probe_set_uuid(pr, bcs->user_uuid);	2✔
335	blkid_probe_set_label(pr, bcs->label, sizeof(bcs->label));	2✔
336	blkid_probe_sprintf_version(pr, "%d", le16_to_cpu(bcs->version));	2✔
337	blocksize = le16_to_cpu(bcs->block_size);	2✔
338	blkid_probe_set_block_size(pr, blocksize * BCACHEFS_SECTOR_SIZE);	2✔
339	blkid_probe_set_fsblocksize(pr, blocksize * BCACHEFS_SECTOR_SIZE);	2✔
340	blkid_probe_set_wiper(pr, 0, BCACHE_SB_OFF);	2✔
341
342	probe_bcachefs_sb_fields(pr, bcs, sb, sb_end);	2✔
343
344	return BLKID_PROBE_OK;	2✔
345	}
346
347	const struct blkid_idinfo bcache_idinfo =
348	{
349	.name = "bcache",
350	.usage = BLKID_USAGE_OTHER,
351	.probefunc = probe_bcache,
352	.minsz = 8192,
353	.magics =
354	{
355	{
356	.magic = BCACHE_SB_MAGIC,
357	.len = BCACHE_SB_MAGIC_LEN,
358	.kboff = BCACHE_SB_KBOFF,
359	.sboff = BCACHE_SB_MAGIC_OFF
360	},
361	{ NULL }
362	}
363	};
364
365	const struct blkid_idinfo bcachefs_idinfo =
366	{
367	.name = "bcachefs",
368	.usage = BLKID_USAGE_FILESYSTEM,
369	.probefunc = probe_bcachefs,
370	.minsz = 256 * BCACHEFS_SECTOR_SIZE,
371	.magics = {
372	{
373	.magic = BCACHE_SB_MAGIC,
374	.len = BCACHE_SB_MAGIC_LEN,
375	.kboff = BCACHE_SB_KBOFF,
376	.sboff = BCACHE_SB_MAGIC_OFF,
377	},
378	{
379	.magic = BCACHEFS_SB_MAGIC,
380	.len = BCACHE_SB_MAGIC_LEN,
381	.kboff = BCACHE_SB_KBOFF,
382	.sboff = BCACHE_SB_MAGIC_OFF,
383	},
384	{ NULL }
385	}
386	};

util-linux / util-linux / 6298213418

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous