2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public
4 * License v2 as published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
9 * General Public License for more details.
11 * You should have received a copy of the GNU General Public
12 * License along with this program; if not, write to the
13 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14 * Boston, MA 021110-1307, USA.
17 #include "kerncompat.h"
21 #include <sys/fcntl.h>
27 #include <kernel-lib/crc32c.h>
30 #define BLOCKSIZE (4096)
31 static char buf[BLOCKSIZE];
34 static int check_csum_superblock(void *sb)
39 crc = btrfs_csum_data((char *)sb + BTRFS_CSUM_SIZE,
40 crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
41 btrfs_csum_final(crc, result);
43 return !memcmp(sb, &result, csum_size);
46 static void update_block_csum(void *block, int is_sb)
49 struct btrfs_header *hdr;
53 crc = btrfs_csum_data((char *)block + BTRFS_CSUM_SIZE, crc,
54 BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
56 crc = btrfs_csum_data((char *)block + BTRFS_CSUM_SIZE, crc,
57 BLOCKSIZE - BTRFS_CSUM_SIZE);
59 btrfs_csum_final(crc, result);
60 memset(block, 0, BTRFS_CSUM_SIZE);
61 hdr = (struct btrfs_header *)block;
62 memcpy(&hdr->csum, result, csum_size);
65 static u64 arg_strtou64(const char *str)
68 char *ptr_parse_end = NULL;
70 value = strtoull(str, &ptr_parse_end, 0);
71 if (ptr_parse_end && *ptr_parse_end != '\0') {
72 fprintf(stderr, "ERROR: %s is not a valid numeric value.\n",
78 * if we pass a negative number to strtoull, it will return an
79 * unexpected number to us, so let's do the check ourselves.
82 fprintf(stderr, "ERROR: %s: negative value is invalid.\n",
86 if (value == ULLONG_MAX) {
87 fprintf(stderr, "ERROR: %s is too large.\n", str);
100 OP_NAND, /* broken */
118 enum field_type type;
120 { .name = "total_bytes", .type = TYPE_U64 },
121 { .name = "root", .type = TYPE_U64 },
122 { .name = "generation", .type = TYPE_U64 },
123 { .name = "chunk_root", .type = TYPE_U64 },
124 { .name = "chunk_root_generation", .type = TYPE_U64 },
125 { .name = "cache_generation", .type = TYPE_U64 },
126 { .name = "uuid_tree_generation", .type = TYPE_U64 },
129 #define MOD_FIELD_XX(fname, set, val, bits, f_dec, f_hex, f_type) \
130 else if (strcmp(name, #fname) == 0) { \
132 printf("SET: "#fname" "f_dec" (0x"f_hex")\n", \
133 (f_type)*val, (f_type)*val); \
134 sb->fname = cpu_to_le##bits(*val); \
136 *val = le##bits##_to_cpu(sb->fname); \
137 printf("GET: "#fname" "f_dec" (0x"f_hex")\n", \
138 (f_type)*val, (f_type)*val); \
142 #define MOD_FIELD64(fname, set, val) \
143 MOD_FIELD_XX(fname, set, val, 64, "%llu", "%llx", unsigned long long)
146 #define MOD_FIELD(fname, set, val) MOD_FIELD64(fname, set, val)
149 * Support only GET and SET properly, ADD and SUB may work
151 #define MOD_FIELD32(fname, set, val) \
152 MOD_FIELD_XX(fname, set, val, 32, "%u", "%x", unsigned int)
154 #define MOD_FIELD16(fname, set, val) \
155 MOD_FIELD_XX(fname, set, val, 16, "%hu", "%hx", unsigned short int)
157 #define MOD_FIELD8(fname, set, val) \
158 MOD_FIELD_XX(fname, set, val, 8, "%hhu", "%hhx", unsigned char)
160 static void mod_field_by_name(struct btrfs_super_block *sb, int set, const char *name,
164 MOD_FIELD(total_bytes, set, val)
165 MOD_FIELD(root, set, val)
166 MOD_FIELD(generation, set, val)
167 MOD_FIELD(chunk_root, set, val)
168 MOD_FIELD(chunk_root_generation, set, val)
169 MOD_FIELD(cache_generation, set, val)
170 MOD_FIELD(uuid_tree_generation, set, val)
172 printf("ERROR: unhandled field: %s\n", name);
177 static int sb_edit(struct btrfs_super_block *sb, struct fspec *fsp)
182 mod_field_by_name(sb, 0, fsp->name, &val);
184 case OP_GET: newval = val; break;
185 case OP_SET: newval = fsp->value; break;
186 case OP_ADD: newval = val + fsp->value; break;
187 case OP_SUB: newval = val - fsp->value; break;
188 case OP_XOR: newval = val ^ fsp->value; break;
189 case OP_NAND: newval = val & (~fsp->value); break;
190 case OP_BSWAP: newval = bswap_64(val); break;
191 default: printf("ERROR: unhandled operation: %d\n", fsp->fop); exit(1);
194 mod_field_by_name(sb, 1, fsp->name, &newval);
199 static int is_known_field(const char *f)
203 for (i = 0; i < ARRAY_SIZE(known_fields); i++)
204 if (strcmp(f, known_fields[i].name) == 0)
209 static int arg_to_op_value(const char *arg, enum field_op *op, u64 *val)
214 case '?': *op = OP_GET; *val = 0; break;
215 case '=': *op = OP_SET; *val = arg_strtou64(arg + 1); break;
216 case '+': *op = OP_ADD; *val = arg_strtou64(arg + 1); break;
217 case '-': *op = OP_SUB; *val = arg_strtou64(arg + 1); break;
218 case '^': *op = OP_XOR; *val = arg_strtou64(arg + 1); break;
219 case '~': *op = OP_NAND; *val = arg_strtou64(arg + 1); break;
220 case '@': *op = OP_BSWAP; *val = arg_strtou64(arg + 1); break;
222 printf("ERROR: unknown op: %c\n", arg[0]);
229 int main(int argc, char **argv) {
233 struct btrfs_header *hdr;
234 struct btrfs_super_block *sb;
236 struct fspec spec[128];
240 memset(spec, 0, sizeof(spec));
242 printf("Usage: %s image [fieldspec...]\n", argv[0]);
245 fd = open(argv[1], O_RDWR | O_EXCL);
251 /* verify superblock */
252 csum_size = btrfs_csum_sizes[BTRFS_CSUM_TYPE_CRC32];
253 off = BTRFS_SUPER_INFO_OFFSET;
255 ret = pread(fd, buf, BLOCKSIZE, off);
257 printf("pread error %d at offset %llu\n",
258 ret, (unsigned long long)off);
261 if (ret != BLOCKSIZE) {
262 printf("pread error at offset %llu: read only %d bytes\n",
263 (unsigned long long)off, ret);
266 hdr = (struct btrfs_header *)buf;
267 /* verify checksum */
268 if (!check_csum_superblock(&hdr->csum)) {
269 printf("super block checksum does not match at offset %llu, will be corrected\n",
270 (unsigned long long)off);
272 printf("super block checksum is ok\n");
274 sb = (struct btrfs_super_block *)buf;
278 for (i = 2; i < argc; i++) {
282 printf("ERROR: bad argument count\n");
287 if (!is_known_field(argv[i])) {
288 printf("ERROR: unknown filed: %s\n", argv[i]);
294 f->name = strdup(argv[i]);
296 if (arg_to_op_value(argv[i], &f->fop, &f->value)) {
302 for (i = 0; i < specidx; i++) {
303 sb_edit(sb, &spec[i]);
308 printf("Update csum\n");
309 update_block_csum(buf, 1);
310 ret = pwrite(fd, buf, BLOCKSIZE, off);
312 printf("pwrite error %d at offset %llu\n",
313 ret, (unsigned long long)off);
316 if (ret != BLOCKSIZE) {
317 printf("pwrite error at offset %llu: written only %d bytes\n",
318 (unsigned long long)off, ret);
323 printf("Nothing changed\n");