summaryrefslogtreecommitdiff
path: root/btrfs-sb-mod.c
diff options
context:
space:
mode:
Diffstat (limited to 'btrfs-sb-mod.c')
-rw-r--r--btrfs-sb-mod.c337
1 files changed, 337 insertions, 0 deletions
diff --git a/btrfs-sb-mod.c b/btrfs-sb-mod.c
new file mode 100644
index 00000000..c381fb60
--- /dev/null
+++ b/btrfs-sb-mod.c
@@ -0,0 +1,337 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * 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., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+
+#include "kerncompat.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <inttypes.h>
+#include <string.h>
+#include <limits.h>
+#include <byteswap.h>
+#include <kernel-lib/crc32c.h>
+#include "disk-io.h"
+
+#define BLOCKSIZE (4096)
+static char buf[BLOCKSIZE];
+static int csum_size;
+
+static int check_csum_superblock(void *sb)
+{
+ u8 result[csum_size];
+ u32 crc = ~(u32)0;
+
+ crc = btrfs_csum_data((char *)sb + BTRFS_CSUM_SIZE,
+ crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
+ btrfs_csum_final(crc, result);
+
+ return !memcmp(sb, &result, csum_size);
+}
+
+static void update_block_csum(void *block, int is_sb)
+{
+ u8 result[csum_size];
+ struct btrfs_header *hdr;
+ u32 crc = ~(u32)0;
+
+ if (is_sb) {
+ crc = btrfs_csum_data((char *)block + BTRFS_CSUM_SIZE, crc,
+ BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
+ } else {
+ crc = btrfs_csum_data((char *)block + BTRFS_CSUM_SIZE, crc,
+ BLOCKSIZE - BTRFS_CSUM_SIZE);
+ }
+ btrfs_csum_final(crc, result);
+ memset(block, 0, BTRFS_CSUM_SIZE);
+ hdr = (struct btrfs_header *)block;
+ memcpy(&hdr->csum, result, csum_size);
+}
+
+static u64 arg_strtou64(const char *str)
+{
+ u64 value;
+ char *ptr_parse_end = NULL;
+
+ value = strtoull(str, &ptr_parse_end, 0);
+ if (ptr_parse_end && *ptr_parse_end != '\0') {
+ fprintf(stderr, "ERROR: %s is not a valid numeric value.\n",
+ str);
+ exit(1);
+ }
+
+ /*
+ * if we pass a negative number to strtoull, it will return an
+ * unexpected number to us, so let's do the check ourselves.
+ */
+ if (str[0] == '-') {
+ fprintf(stderr, "ERROR: %s: negative value is invalid.\n",
+ str);
+ exit(1);
+ }
+ if (value == ULLONG_MAX) {
+ fprintf(stderr, "ERROR: %s is too large.\n", str);
+ exit(1);
+ }
+ return value;
+}
+
+
+enum field_op {
+ OP_GET,
+ OP_SET,
+ OP_ADD,
+ OP_SUB,
+ OP_XOR,
+ OP_NAND, /* broken */
+ OP_BSWAP,
+};
+
+struct fspec {
+ const char *name;
+ enum field_op fop;
+ u64 value;
+};
+
+enum field_type {
+ TYPE_UNKNOWN,
+ TYPE_U64,
+ TYPE_U16,
+};
+
+struct sb_field {
+ const char *name;
+ enum field_type type;
+} known_fields[] = {
+ { .name = "total_bytes", .type = TYPE_U64 },
+ { .name = "root", .type = TYPE_U64 },
+ { .name = "generation", .type = TYPE_U64 },
+ { .name = "chunk_root", .type = TYPE_U64 },
+ { .name = "chunk_root_generation", .type = TYPE_U64 },
+ { .name = "cache_generation", .type = TYPE_U64 },
+ { .name = "uuid_tree_generation", .type = TYPE_U64 },
+ { .name = "compat_flags", .type = TYPE_U64 },
+ { .name = "compat_ro_flags", .type = TYPE_U64 },
+ { .name = "incompat_flags", .type = TYPE_U64 },
+ { .name = "csum_type", .type = TYPE_U16 },
+};
+
+#define MOD_FIELD_XX(fname, set, val, bits, f_dec, f_hex, f_type) \
+ else if (strcmp(name, #fname) == 0) { \
+ if (set) { \
+ printf("SET: "#fname" "f_dec" (0x"f_hex")\n", \
+ (f_type)*val, (f_type)*val); \
+ sb->fname = cpu_to_le##bits(*val); \
+ } else { \
+ *val = le##bits##_to_cpu(sb->fname); \
+ printf("GET: "#fname" "f_dec" (0x"f_hex")\n", \
+ (f_type)*val, (f_type)*val); \
+ } \
+ }
+
+#define MOD_FIELD64(fname, set, val) \
+ MOD_FIELD_XX(fname, set, val, 64, "%llu", "%llx", unsigned long long)
+
+/* Alias for u64 */
+#define MOD_FIELD(fname, set, val) MOD_FIELD64(fname, set, val)
+
+/*
+ * Support only GET and SET properly, ADD and SUB may work
+ */
+#define MOD_FIELD32(fname, set, val) \
+ MOD_FIELD_XX(fname, set, val, 32, "%u", "%x", unsigned int)
+
+#define MOD_FIELD16(fname, set, val) \
+ MOD_FIELD_XX(fname, set, val, 16, "%hu", "%hx", unsigned short int)
+
+#define MOD_FIELD8(fname, set, val) \
+ MOD_FIELD_XX(fname, set, val, 8, "%hhu", "%hhx", unsigned char)
+
+static void mod_field_by_name(struct btrfs_super_block *sb, int set, const char *name,
+ u64 *val)
+{
+ if (0) { }
+ MOD_FIELD(total_bytes, set, val)
+ MOD_FIELD(root, set, val)
+ MOD_FIELD(generation, set, val)
+ MOD_FIELD(chunk_root, set, val)
+ MOD_FIELD(chunk_root_generation, set, val)
+ MOD_FIELD(cache_generation, set, val)
+ MOD_FIELD(uuid_tree_generation, set, val)
+ MOD_FIELD(compat_flags, set, val)
+ MOD_FIELD(compat_ro_flags, set, val)
+ MOD_FIELD(incompat_flags, set, val)
+ MOD_FIELD16(csum_type, set, val)
+ else {
+ printf("ERROR: unhandled field: %s\n", name);
+ exit(1);
+ }
+}
+
+static int sb_edit(struct btrfs_super_block *sb, struct fspec *fsp)
+{
+ u64 val;
+ u64 newval;
+
+ mod_field_by_name(sb, 0, fsp->name, &val);
+ switch (fsp->fop) {
+ case OP_GET: newval = val; break;
+ case OP_SET: newval = fsp->value; break;
+ case OP_ADD: newval = val + fsp->value; break;
+ case OP_SUB: newval = val - fsp->value; break;
+ case OP_XOR: newval = val ^ fsp->value; break;
+ case OP_NAND: newval = val & (~fsp->value); break;
+ case OP_BSWAP: newval = bswap_64(val); break;
+ default: printf("ERROR: unhandled operation: %d\n", fsp->fop); exit(1);
+ }
+
+ mod_field_by_name(sb, 1, fsp->name, &newval);
+
+ return 0;
+}
+
+static int is_known_field(const char *f)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(known_fields); i++)
+ if (strcmp(f, known_fields[i].name) == 0)
+ return 1;
+ return 0;
+}
+
+static int arg_to_op_value(const char *arg, enum field_op *op, u64 *val)
+{
+ switch (arg[0]) {
+ case 0: return -1;
+ case '.':
+ case '?': *op = OP_GET; *val = 0; break;
+ case '=': *op = OP_SET; *val = arg_strtou64(arg + 1); break;
+ case '+': *op = OP_ADD; *val = arg_strtou64(arg + 1); break;
+ case '-': *op = OP_SUB; *val = arg_strtou64(arg + 1); break;
+ case '^': *op = OP_XOR; *val = arg_strtou64(arg + 1); break;
+ case '~': *op = OP_NAND; *val = arg_strtou64(arg + 1); break;
+ case '@': *op = OP_BSWAP; *val = arg_strtou64(arg + 1); break;
+ default:
+ printf("ERROR: unknown op: %c\n", arg[0]);
+ return -1;
+ }
+
+ return 0;
+}
+
+int main(int argc, char **argv) {
+ int fd;
+ loff_t off;
+ int ret;
+ struct btrfs_header *hdr;
+ struct btrfs_super_block *sb;
+ int i;
+ struct fspec spec[128];
+ int specidx;
+ int changed;
+
+ memset(spec, 0, sizeof(spec));
+ if (argc <= 2) {
+ printf("Usage: %s image [fieldspec...]\n", argv[0]);
+ exit(1);
+ }
+ fd = open(argv[1], O_RDWR | O_EXCL);
+ if (fd == -1) {
+ perror("open()");
+ exit(1);
+ }
+
+ /* verify superblock */
+ csum_size = btrfs_csum_sizes[BTRFS_CSUM_TYPE_CRC32];
+ off = BTRFS_SUPER_INFO_OFFSET;
+
+ ret = pread(fd, buf, BLOCKSIZE, off);
+ if (ret <= 0) {
+ printf("pread error %d at offset %llu\n",
+ ret, (unsigned long long)off);
+ exit(1);
+ }
+ if (ret != BLOCKSIZE) {
+ printf("pread error at offset %llu: read only %d bytes\n",
+ (unsigned long long)off, ret);
+ exit(1);
+ }
+ hdr = (struct btrfs_header *)buf;
+ /* verify checksum */
+ if (!check_csum_superblock(&hdr->csum)) {
+ printf("super block checksum does not match at offset %llu, will be corrected\n",
+ (unsigned long long)off);
+ } else {
+ printf("super block checksum is ok\n");
+ }
+ sb = (struct btrfs_super_block *)buf;
+ changed = 0;
+
+ specidx = 0;
+ for (i = 2; i < argc; i++) {
+ struct fspec *f;
+
+ if (i + 1 >= argc) {
+ printf("ERROR: bad argument count\n");
+ ret = 1;
+ goto out;
+ }
+
+ if (!is_known_field(argv[i])) {
+ printf("ERROR: unknown filed: %s\n", argv[i]);
+ ret = 1;
+ goto out;
+ }
+ f = &spec[specidx];
+ specidx++;
+ f->name = strdup(argv[i]);
+ i++;
+ if (arg_to_op_value(argv[i], &f->fop, &f->value)) {
+ ret = 1;
+ goto out;
+ }
+ }
+
+ for (i = 0; i < specidx; i++) {
+ sb_edit(sb, &spec[i]);
+ changed = 1;
+ }
+
+ if (changed) {
+ printf("Update csum\n");
+ update_block_csum(buf, 1);
+ ret = pwrite(fd, buf, BLOCKSIZE, off);
+ if (ret <= 0) {
+ printf("pwrite error %d at offset %llu\n",
+ ret, (unsigned long long)off);
+ exit(1);
+ }
+ if (ret != BLOCKSIZE) {
+ printf("pwrite error at offset %llu: written only %d bytes\n",
+ (unsigned long long)off, ret);
+ exit(1);
+ }
+ fsync(fd);
+ } else {
+ printf("Nothing changed\n");
+ }
+ ret = 0;
+out:
+ close(fd);
+ return ret;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-19 23:38:01 +0000