2 * set_fields.c --- set a superblock value
4 * Copyright (C) 2000, 2001, 2002, 2003, 2004 by Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
12 #define _XOPEN_SOURCE 600 /* for inclusion of strptime() and strtoull */
15 #define STRTOULL strtoull
17 #define STRTOULL strtoul
28 #include <sys/types.h>
41 #include "uuid/uuid.h"
43 #include "support/quotaio.h"
45 static struct ext2_super_block set_sb
;
46 static struct ext2_inode_large set_inode
;
47 static struct ext2_group_desc set_gd
;
48 static struct ext4_group_desc set_gd4
;
49 static struct mmp_struct set_mmp
;
51 static ext2_ino_t set_ino
;
54 #define FLAG_ARRAY 0x0001
55 #define FLAG_ALIAS 0x0002 /* Data intersects with other field */
56 #define FLAG_CSUM 0x0004
58 struct field_set_info
{
63 errcode_t (*func
)(struct field_set_info
*info
, char *field
, char *arg
);
68 static errcode_t
parse_uint(struct field_set_info
*info
, char *field
, char *arg
);
69 static errcode_t
parse_int(struct field_set_info
*info
, char *field
, char *arg
);
70 static errcode_t
parse_string(struct field_set_info
*info
, char *field
, char *arg
);
71 static errcode_t
parse_uuid(struct field_set_info
*info
, char *field
, char *arg
);
72 static errcode_t
parse_hashalg(struct field_set_info
*info
, char *field
, char *arg
);
73 static errcode_t
parse_time(struct field_set_info
*info
, char *field
, char *arg
);
74 static errcode_t
parse_bmap(struct field_set_info
*info
, char *field
, char *arg
);
75 static errcode_t
parse_gd_csum(struct field_set_info
*info
, char *field
, char *arg
);
76 static errcode_t
parse_inode_csum(struct field_set_info
*info
, char *field
,
78 static errcode_t
parse_mmp_clear(struct field_set_info
*info
, char *field
,
81 #if __GNUC_PREREQ (4, 6) || defined(__clang__)
82 #pragma GCC diagnostic push
83 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
86 static struct field_set_info super_fields
[] = {
87 { "inodes_count", &set_sb
.s_inodes_count
, NULL
, 4, parse_uint
},
88 { "blocks_count", &set_sb
.s_blocks_count
, &set_sb
.s_blocks_count_hi
,
90 { "r_blocks_count", &set_sb
.s_r_blocks_count
,
91 &set_sb
.s_r_blocks_count_hi
, 4, parse_uint
},
92 { "free_blocks_count", &set_sb
.s_free_blocks_count
,
93 &set_sb
.s_free_blocks_hi
, 4, parse_uint
},
94 { "free_inodes_count", &set_sb
.s_free_inodes_count
, NULL
, 4, parse_uint
},
95 { "first_data_block", &set_sb
.s_first_data_block
, NULL
, 4, parse_uint
},
96 { "log_block_size", &set_sb
.s_log_block_size
, NULL
, 4, parse_uint
},
97 { "log_cluster_size", &set_sb
.s_log_cluster_size
, NULL
, 4, parse_int
},
98 { "blocks_per_group", &set_sb
.s_blocks_per_group
, NULL
, 4, parse_uint
},
99 { "clusters_per_group", &set_sb
.s_clusters_per_group
, NULL
, 4, parse_uint
},
100 { "inodes_per_group", &set_sb
.s_inodes_per_group
, NULL
, 4, parse_uint
},
101 { "mtime", &set_sb
.s_mtime
, NULL
, 4, parse_time
},
102 { "wtime", &set_sb
.s_wtime
, NULL
, 4, parse_time
},
103 { "mnt_count", &set_sb
.s_mnt_count
, NULL
, 2, parse_uint
},
104 { "max_mnt_count", &set_sb
.s_max_mnt_count
, NULL
, 2, parse_int
},
106 { "state", &set_sb
.s_state
, NULL
, 2, parse_uint
},
107 { "errors", &set_sb
.s_errors
, NULL
, 2, parse_uint
},
108 { "minor_rev_level", &set_sb
.s_minor_rev_level
, NULL
, 2, parse_uint
},
109 { "lastcheck", &set_sb
.s_lastcheck
, NULL
, 4, parse_time
},
110 { "checkinterval", &set_sb
.s_checkinterval
, NULL
, 4, parse_uint
},
111 { "creator_os", &set_sb
.s_creator_os
, NULL
, 4, parse_uint
},
112 { "rev_level", &set_sb
.s_rev_level
, NULL
, 4, parse_uint
},
113 { "def_resuid", &set_sb
.s_def_resuid
, NULL
, 2, parse_uint
},
114 { "def_resgid", &set_sb
.s_def_resgid
, NULL
, 2, parse_uint
},
115 { "first_ino", &set_sb
.s_first_ino
, NULL
, 4, parse_uint
},
116 { "inode_size", &set_sb
.s_inode_size
, NULL
, 2, parse_uint
},
117 { "block_group_nr", &set_sb
.s_block_group_nr
, NULL
, 2, parse_uint
},
118 { "feature_compat", &set_sb
.s_feature_compat
, NULL
, 4, parse_uint
},
119 { "feature_incompat", &set_sb
.s_feature_incompat
, NULL
, 4, parse_uint
},
120 { "feature_ro_compat", &set_sb
.s_feature_ro_compat
, NULL
, 4, parse_uint
},
121 { "uuid", &set_sb
.s_uuid
, NULL
, 16, parse_uuid
},
122 { "volume_name", &set_sb
.s_volume_name
, NULL
, 16, parse_string
},
123 { "last_mounted", &set_sb
.s_last_mounted
, NULL
, 64, parse_string
},
124 { "algorithm_usage_bitmap", &set_sb
.s_algorithm_usage_bitmap
, NULL
,
126 { "prealloc_blocks", &set_sb
.s_prealloc_blocks
, NULL
, 1, parse_uint
},
127 { "prealloc_dir_blocks", &set_sb
.s_prealloc_dir_blocks
, NULL
, 1,
129 { "reserved_gdt_blocks", &set_sb
.s_reserved_gdt_blocks
, NULL
, 2,
131 { "journal_uuid", &set_sb
.s_journal_uuid
, NULL
, 16, parse_uuid
},
132 { "journal_inum", &set_sb
.s_journal_inum
, NULL
, 4, parse_uint
},
133 { "journal_dev", &set_sb
.s_journal_dev
, NULL
, 4, parse_uint
},
134 { "last_orphan", &set_sb
.s_last_orphan
, NULL
, 4, parse_uint
},
135 { "hash_seed", &set_sb
.s_hash_seed
, NULL
, 16, parse_uuid
},
136 { "def_hash_version", &set_sb
.s_def_hash_version
, NULL
, 1, parse_hashalg
},
137 { "jnl_backup_type", &set_sb
.s_jnl_backup_type
, NULL
, 1, parse_uint
},
138 { "desc_size", &set_sb
.s_desc_size
, NULL
, 2, parse_uint
},
139 { "default_mount_opts", &set_sb
.s_default_mount_opts
, NULL
, 4, parse_uint
},
140 { "first_meta_bg", &set_sb
.s_first_meta_bg
, NULL
, 4, parse_uint
},
141 { "mkfs_time", &set_sb
.s_mkfs_time
, NULL
, 4, parse_time
},
142 { "jnl_blocks", &set_sb
.s_jnl_blocks
[0], NULL
, 4, parse_uint
, FLAG_ARRAY
,
144 { "min_extra_isize", &set_sb
.s_min_extra_isize
, NULL
, 2, parse_uint
},
145 { "want_extra_isize", &set_sb
.s_want_extra_isize
, NULL
, 2, parse_uint
},
146 { "flags", &set_sb
.s_flags
, NULL
, 4, parse_uint
},
147 { "raid_stride", &set_sb
.s_raid_stride
, NULL
, 2, parse_uint
},
148 { "mmp_interval", &set_sb
.s_mmp_update_interval
, NULL
, 2, parse_uint
},
149 { "mmp_block", &set_sb
.s_mmp_block
, NULL
, 8, parse_uint
},
150 { "raid_stripe_width", &set_sb
.s_raid_stripe_width
, NULL
, 4, parse_uint
},
151 { "log_groups_per_flex", &set_sb
.s_log_groups_per_flex
, NULL
, 1, parse_uint
},
152 { "kbytes_written", &set_sb
.s_kbytes_written
, NULL
, 8, parse_uint
},
153 { "snapshot_inum", &set_sb
.s_snapshot_inum
, NULL
, 4, parse_uint
},
154 { "snapshot_id", &set_sb
.s_snapshot_id
, NULL
, 4, parse_uint
},
155 { "snapshot_r_blocks_count", &set_sb
.s_snapshot_r_blocks_count
,
156 NULL
, 8, parse_uint
},
157 { "snapshot_list", &set_sb
.s_snapshot_list
, NULL
, 4, parse_uint
},
158 { "mount_opts", &set_sb
.s_mount_opts
, NULL
, 64, parse_string
},
159 { "usr_quota_inum", &set_sb
.s_usr_quota_inum
, NULL
, 4, parse_uint
},
160 { "grp_quota_inum", &set_sb
.s_grp_quota_inum
, NULL
, 4, parse_uint
},
161 { "prj_quota_inum", &set_sb
.s_prj_quota_inum
, NULL
, 4, parse_uint
},
162 { "overhead_blocks", &set_sb
.s_overhead_blocks
, NULL
, 4, parse_uint
},
163 { "backup_bgs", &set_sb
.s_backup_bgs
[0], NULL
, 4, parse_uint
,
165 { "checksum", &set_sb
.s_checksum
, NULL
, 4, parse_uint
},
166 { "checksum_type", &set_sb
.s_checksum_type
, NULL
, 1, parse_uint
},
167 { "encryption_level", &set_sb
.s_encryption_level
, NULL
, 1, parse_uint
},
168 { "error_count", &set_sb
.s_error_count
, NULL
, 4, parse_uint
},
169 { "first_error_time", &set_sb
.s_first_error_time
, NULL
, 4, parse_time
},
170 { "first_error_ino", &set_sb
.s_first_error_ino
, NULL
, 4, parse_uint
},
171 { "first_error_block", &set_sb
.s_first_error_block
, NULL
, 8, parse_uint
},
172 { "first_error_func", &set_sb
.s_first_error_func
, NULL
, 32, parse_string
},
173 { "first_error_line", &set_sb
.s_first_error_line
, NULL
, 4, parse_uint
},
174 { "last_error_time", &set_sb
.s_last_error_time
, NULL
, 4, parse_time
},
175 { "last_error_ino", &set_sb
.s_last_error_ino
, NULL
, 4, parse_uint
},
176 { "last_error_block", &set_sb
.s_last_error_block
, NULL
, 8, parse_uint
},
177 { "last_error_func", &set_sb
.s_last_error_func
, NULL
, 32, parse_string
},
178 { "last_error_line", &set_sb
.s_last_error_line
, NULL
, 4, parse_uint
},
179 { "encrypt_algos", &set_sb
.s_encrypt_algos
, NULL
, 1, parse_uint
,
181 { "encrypt_pw_salt", &set_sb
.s_encrypt_pw_salt
, NULL
, 16, parse_uuid
},
182 { "lpf_ino", &set_sb
.s_lpf_ino
, NULL
, 4, parse_uint
},
183 { "checksum_seed", &set_sb
.s_checksum_seed
, NULL
, 4, parse_uint
},
187 static struct field_set_info inode_fields
[] = {
188 { "mode", &set_inode
.i_mode
, NULL
, 2, parse_uint
},
189 { "uid", &set_inode
.i_uid
, &set_inode
.osd2
.linux2
.l_i_uid_high
,
191 { "size", &set_inode
.i_size
, &set_inode
.i_size_high
, 4, parse_uint
},
192 { "atime", &set_inode
.i_atime
, &set_inode
.i_atime_extra
,
194 { "ctime", &set_inode
.i_ctime
, &set_inode
.i_ctime_extra
,
196 { "mtime", &set_inode
.i_mtime
, &set_inode
.i_mtime_extra
,
198 { "dtime", &set_inode
.i_dtime
, NULL
,
200 { "gid", &set_inode
.i_gid
, &set_inode
.osd2
.linux2
.l_i_gid_high
,
202 { "links_count", &set_inode
.i_links_count
, NULL
, 2, parse_uint
},
203 /* Special case: i_blocks is 4 bytes, i_blocks_high is 2 bytes */
204 { "blocks", &set_inode
.i_blocks
, &set_inode
.osd2
.linux2
.l_i_blocks_hi
,
206 { "flags", &set_inode
.i_flags
, NULL
, 4, parse_uint
},
207 { "version", &set_inode
.osd1
.linux1
.l_i_version
,
208 &set_inode
.i_version_hi
, 4, parse_uint
},
209 { "translator", &set_inode
.osd1
.hurd1
.h_i_translator
, NULL
,
210 4, parse_uint
, FLAG_ALIAS
},
211 { "block", &set_inode
.i_block
[0], NULL
, 4, parse_uint
, FLAG_ARRAY
,
213 { "block[IND]", &set_inode
.i_block
[EXT2_IND_BLOCK
], NULL
, 4, parse_uint
},
214 { "block[DIND]", &set_inode
.i_block
[EXT2_DIND_BLOCK
], NULL
, 4, parse_uint
},
215 { "block[TIND]", &set_inode
.i_block
[EXT2_TIND_BLOCK
], NULL
, 4, parse_uint
},
216 { "generation", &set_inode
.i_generation
, NULL
, 4, parse_uint
},
217 /* Special case: i_file_acl_high is 2 bytes */
218 { "file_acl", &set_inode
.i_file_acl
,
219 &set_inode
.osd2
.linux2
.l_i_file_acl_high
, 6, parse_uint
},
220 { "faddr", &set_inode
.i_faddr
, NULL
, 4, parse_uint
},
221 { "frag", &set_inode
.osd2
.hurd2
.h_i_frag
, NULL
, 1, parse_uint
, FLAG_ALIAS
},
222 { "fsize", &set_inode
.osd2
.hurd2
.h_i_fsize
, NULL
, 1, parse_uint
},
223 { "checksum", &set_inode
.osd2
.linux2
.l_i_checksum_lo
,
224 &set_inode
.i_checksum_hi
, 2, parse_inode_csum
, FLAG_CSUM
},
225 { "author", &set_inode
.osd2
.hurd2
.h_i_author
, NULL
,
226 4, parse_uint
, FLAG_ALIAS
},
227 { "extra_isize", &set_inode
.i_extra_isize
, NULL
,
229 { "ctime_extra", &set_inode
.i_ctime_extra
, NULL
,
230 4, parse_uint
, FLAG_ALIAS
},
231 { "mtime_extra", &set_inode
.i_mtime_extra
, NULL
,
232 4, parse_uint
, FLAG_ALIAS
},
233 { "atime_extra", &set_inode
.i_atime_extra
, NULL
,
234 4, parse_uint
, FLAG_ALIAS
},
235 { "crtime", &set_inode
.i_crtime
, &set_inode
.i_crtime_extra
,
237 { "crtime_extra", &set_inode
.i_crtime_extra
, NULL
,
238 4, parse_uint
, FLAG_ALIAS
},
239 { "projid", &set_inode
.i_projid
, NULL
, 4, parse_uint
},
240 { "bmap", NULL
, NULL
, 4, parse_bmap
, FLAG_ARRAY
},
244 static struct field_set_info ext2_bg_fields
[] = {
245 { "block_bitmap", &set_gd
.bg_block_bitmap
, NULL
, 4, parse_uint
},
246 { "inode_bitmap", &set_gd
.bg_inode_bitmap
, NULL
, 4, parse_uint
},
247 { "inode_table", &set_gd
.bg_inode_table
, NULL
, 4, parse_uint
},
248 { "free_blocks_count", &set_gd
.bg_free_blocks_count
, NULL
, 2, parse_uint
},
249 { "free_inodes_count", &set_gd
.bg_free_inodes_count
, NULL
, 2, parse_uint
},
250 { "used_dirs_count", &set_gd
.bg_used_dirs_count
, NULL
, 2, parse_uint
},
251 { "flags", &set_gd
.bg_flags
, NULL
, 2, parse_uint
},
252 { "itable_unused", &set_gd
.bg_itable_unused
, NULL
, 2, parse_uint
},
253 { "checksum", &set_gd
.bg_checksum
, NULL
, 2, parse_gd_csum
},
257 static struct field_set_info ext4_bg_fields
[] = {
258 { "block_bitmap", &set_gd4
.bg_block_bitmap
,
259 &set_gd4
.bg_block_bitmap_hi
, 4, parse_uint
},
260 { "inode_bitmap", &set_gd4
.bg_inode_bitmap
,
261 &set_gd4
.bg_inode_bitmap_hi
, 4, parse_uint
},
262 { "inode_table", &set_gd4
.bg_inode_table
,
263 &set_gd4
.bg_inode_table_hi
, 4, parse_uint
},
264 { "free_blocks_count", &set_gd4
.bg_free_blocks_count
,
265 &set_gd4
.bg_free_blocks_count_hi
, 2, parse_uint
},
266 { "free_inodes_count", &set_gd4
.bg_free_inodes_count
,
267 &set_gd4
.bg_free_inodes_count_hi
, 2, parse_uint
},
268 { "used_dirs_count", &set_gd4
.bg_used_dirs_count
,
269 &set_gd4
.bg_used_dirs_count_hi
, 2, parse_uint
},
270 { "flags", &set_gd4
.bg_flags
, NULL
, 2, parse_uint
},
271 { "exclude_bitmap", &set_gd4
.bg_exclude_bitmap_lo
,
272 &set_gd4
.bg_exclude_bitmap_hi
, 4, parse_uint
},
273 { "block_bitmap_csum", &set_gd4
.bg_block_bitmap_csum_lo
,
274 &set_gd4
.bg_block_bitmap_csum_hi
, 2, parse_uint
},
275 { "inode_bitmap_csum", &set_gd4
.bg_inode_bitmap_csum_lo
,
276 &set_gd4
.bg_inode_bitmap_csum_hi
, 2, parse_uint
},
277 { "itable_unused", &set_gd4
.bg_itable_unused
,
278 &set_gd4
.bg_itable_unused_hi
, 2, parse_uint
},
279 { "checksum", &set_gd4
.bg_checksum
, NULL
, 2, parse_gd_csum
},
283 static struct field_set_info mmp_fields
[] = {
284 { "clear", &set_mmp
.mmp_magic
, NULL
, sizeof(set_mmp
),
285 parse_mmp_clear
, FLAG_ALIAS
},
286 { "magic", &set_mmp
.mmp_magic
, NULL
, 4, parse_uint
},
287 { "seq", &set_mmp
.mmp_seq
, NULL
, 4, parse_uint
},
288 { "time", &set_mmp
.mmp_time
, NULL
, 8, parse_uint
},
289 { "nodename", &set_mmp
.mmp_nodename
, NULL
, sizeof(set_mmp
.mmp_nodename
),
291 { "bdevname", &set_mmp
.mmp_bdevname
, NULL
, sizeof(set_mmp
.mmp_bdevname
),
293 { "check_interval", &set_mmp
.mmp_check_interval
, NULL
, 2, parse_uint
},
294 { "checksum", &set_mmp
.mmp_checksum
, NULL
, 4, parse_uint
},
297 #if __GNUC_PREREQ (4, 6)
298 #pragma GCC diagnostic pop
304 static void do_verify_field_set_info(struct field_set_info
*fields
,
305 const void *data
, size_t size
)
307 struct field_set_info
*ss
, *ss2
;
308 const char *begin
= (char *)data
;
309 const char *end
= begin
+ size
;
311 for (ss
= fields
; ss
->name
; ss
++) {
316 assert(!ptr
|| (ptr
>= begin
&& ptr
< end
));
318 assert(!ptr
|| (ptr
>= begin
&& ptr
< end
));
323 for (ss2
= fields
; ss2
!= ss
; ss2
++) {
324 /* Check duplicate names */
325 assert(strcmp(ss
->name
, ss2
->name
));
327 if (ss
->flags
& FLAG_ALIAS
|| ss2
->flags
& FLAG_ALIAS
)
329 /* Check false aliases, might be copy-n-paste error */
330 assert(!ss
->ptr
|| (ss
->ptr
!= ss2
->ptr
&&
331 ss
->ptr
!= ss2
->ptr2
));
332 assert(!ss
->ptr2
|| (ss
->ptr2
!= ss2
->ptr
&&
333 ss
->ptr2
!= ss2
->ptr2
));
338 int main(int argc
, char **argv
)
340 do_verify_field_set_info(super_fields
, &set_sb
, sizeof(set_sb
));
341 do_verify_field_set_info(inode_fields
, &set_inode
, sizeof(set_inode
));
342 do_verify_field_set_info(ext2_bg_fields
, &set_gd
, sizeof(set_gd
));
343 do_verify_field_set_info(ext4_bg_fields
, &set_gd4
, sizeof(set_gd4
));
344 do_verify_field_set_info(mmp_fields
, &set_mmp
, sizeof(set_mmp
));
348 ext2_filsys current_fs
;
349 ext2_ino_t root
, cwd
;
351 #endif /* UNITTEST */
353 static int check_suffix(const char *field
)
355 int len
= strlen(field
);
360 if (!strcmp(field
, "_lo"))
362 if (!strcmp(field
, "_hi"))
367 static struct field_set_info
*find_field(struct field_set_info
*fields
,
370 struct field_set_info
*ss
;
372 char *arg
, *delim
, *idx
, *tmp
;
373 int suffix
, prefix_len
;
375 if (fields
== super_fields
)
377 else if (fields
== inode_fields
)
381 prefix_len
= strlen(prefix
);
382 if (strncmp(field
, prefix
, prefix_len
) == 0)
385 arg
= malloc(strlen(field
)+1);
390 idx
= strchr(arg
, '[');
393 delim
= idx
+ strlen(idx
) - 1;
394 if (!*idx
|| *delim
!= ']')
400 * Can we parse the number?
403 array_idx
= strtol(idx
, &tmp
, 0);
412 * If there is a valid _hi or a _lo suffix, strip it off
414 suffix
= check_suffix(arg
);
416 arg
[strlen(arg
)-3] = 0;
418 for (ss
= fields
; ss
->name
; ss
++) {
419 if (suffix
&& ss
->ptr2
== 0)
421 if (ss
->flags
& FLAG_ARRAY
) {
422 if (!idx
|| (strcmp(ss
->name
, arg
) != 0))
424 if (ss
->max_idx
> 0 && array_idx
>= ss
->max_idx
)
427 if (strcmp(ss
->name
, arg
) != 0)
438 * Note: info->size == 6 is special; this means a base size 4 bytes,
439 * and secondary (high) size of 2 bytes. This is needed for the
440 * special case of i_blocks_high and i_file_acl_high.
442 static errcode_t
parse_uint(struct field_set_info
*info
, char *field
,
445 unsigned long long n
, num
, mask
, limit
;
446 int suffix
= check_suffix(field
);
448 void *field1
= info
->ptr
, *field2
= info
->ptr2
;
449 int size
= (info
->size
== 6) ? 4 : info
->size
;
464 u
.ptr8
= (__u8
*) field1
;
465 if (info
->flags
& FLAG_ARRAY
)
466 u
.ptr8
+= array_idx
* info
->size
;
469 num
= STRTOULL(arg
, &tmp
, 0);
471 fprintf(stderr
, "Couldn't parse '%s' for field %s.\n",
475 mask
= ~0ULL >> ((8 - size
) * 8);
476 limit
= ~0ULL >> ((8 - info
->size
) * 8);
477 if (field2
&& info
->size
!= 6)
478 limit
= ~0ULL >> ((8 - info
->size
*2) * 8);
481 fprintf(stderr
, "Value '%s' exceeds field %s maximum %llu.\n",
482 arg
, info
->name
, limit
);
488 /* Should never get here */
489 fprintf(stderr
, "64-bit field %s has a second 64-bit field\n"
490 "defined; BUG?!?\n", info
->name
);
505 n
= (size
== 8) ? 0 : (num
>> (size
*8));
506 u
.ptr8
= (__u8
*) field2
;
526 static errcode_t
parse_int(struct field_set_info
*info
,
527 char *field
EXT2FS_ATTR((unused
)), char *arg
)
535 num
= strtol(arg
, &tmp
, 0);
537 fprintf(stderr
, "Couldn't parse '%s' for field %s.\n",
541 switch (info
->size
) {
543 ptr32
= (__s32
*) info
->ptr
;
547 ptr16
= (__s16
*) info
->ptr
;
551 ptr8
= (__s8
*) info
->ptr
;
558 static errcode_t
parse_string(struct field_set_info
*info
,
559 char *field
EXT2FS_ATTR((unused
)), char *arg
)
561 char *cp
= (char *) info
->ptr
;
563 if (strlen(arg
) >= info
->size
) {
564 fprintf(stderr
, "Error maximum size for %s is %d.\n",
565 info
->name
, info
->size
);
572 static errcode_t
parse_time(struct field_set_info
*info
,
573 char *field
, char *arg
)
577 __u32
*ptr_low
, *ptr_high
;
579 if (check_suffix(field
))
580 return parse_uint(info
, field
, arg
);
582 ptr_low
= (__u32
*) info
->ptr
;
583 ptr_high
= (__u32
*) info
->ptr2
;
585 t
= string_to_time(arg
);
588 fprintf(stderr
, "Couldn't parse '%s' for field %s.\n",
593 t_high
= ((t
- (__s32
)t
) >> 32) & EXT4_EPOCH_MASK
;
596 *ptr_high
= (*ptr_high
& ~EXT4_EPOCH_MASK
) | t_high
;
600 static errcode_t
parse_uuid(struct field_set_info
*info
,
601 char *field
EXT2FS_ATTR((unused
)), char *arg
)
603 unsigned char * p
= (unsigned char *) info
->ptr
;
605 if ((strcasecmp(arg
, "null") == 0) ||
606 (strcasecmp(arg
, "clear") == 0)) {
608 } else if (strcasecmp(arg
, "time") == 0) {
609 uuid_generate_time(p
);
610 } else if (strcasecmp(arg
, "random") == 0) {
612 } else if (uuid_parse(arg
, p
)) {
613 fprintf(stderr
, "Invalid UUID format: %s\n", arg
);
619 static errcode_t
parse_hashalg(struct field_set_info
*info
,
620 char *field
EXT2FS_ATTR((unused
)), char *arg
)
623 unsigned char *p
= (unsigned char *) info
->ptr
;
625 hashv
= e2p_string2hash(arg
);
627 fprintf(stderr
, "Invalid hash algorithm: %s\n", arg
);
634 static errcode_t
parse_bmap(struct field_set_info
*info
,
635 char *field
EXT2FS_ATTR((unused
)), char *arg
)
641 blk
= strtoull(arg
, &tmp
, 0);
643 fprintf(stderr
, "Couldn't parse '%s' for field %s.\n",
648 retval
= ext2fs_bmap2(current_fs
, set_ino
,
649 (struct ext2_inode
*) &set_inode
,
650 NULL
, BMAP_ALLOC
| BMAP_SET
, array_idx
, NULL
,
653 com_err("set_inode", retval
, "while setting block map");
658 static errcode_t
parse_gd_csum(struct field_set_info
*info
, char *field
,
661 __u16
*checksum
= info
->ptr
;
663 if (strcmp(arg
, "calc") == 0) {
664 *checksum
= ext2fs_group_desc_csum(current_fs
, set_bg
);
665 printf("Checksum set to 0x%04x\n", *checksum
);
668 return parse_uint(info
, field
, arg
);
671 static errcode_t
parse_inode_csum(struct field_set_info
*info
, char *field
,
674 errcode_t retval
= 0;
676 int is_large_inode
= 0;
677 struct ext2_inode_large
*tmp_inode
;
679 if (strcmp(arg
, "calc") == 0) {
680 size_t sz
= EXT2_INODE_SIZE(current_fs
->super
);
681 struct ext2_inode_large
*tmp_inode
= NULL
;
683 retval
= ext2fs_get_mem(sz
, &tmp_inode
);
687 retval
= ext2fs_read_inode_full(current_fs
, set_ino
,
688 (struct ext2_inode
*) tmp_inode
,
693 #ifdef WORDS_BIGENDIAN
694 ext2fs_swap_inode_full(current_fs
, tmp_inode
,
698 if (sz
> EXT2_GOOD_OLD_INODE_SIZE
)
701 retval
= ext2fs_inode_csum_set(current_fs
, set_ino
,
705 #ifdef WORDS_BIGENDIAN
706 crc
= set_inode
.i_checksum_lo
=
707 ext2fs_swab16(tmp_inode
->i_checksum_lo
);
710 crc
= set_inode
.i_checksum_lo
= tmp_inode
->i_checksum_lo
;
712 if (is_large_inode
&&
713 set_inode
.i_extra_isize
>=
714 (offsetof(struct ext2_inode_large
,
716 EXT2_GOOD_OLD_INODE_SIZE
)) {
717 #ifdef WORDS_BIGENDIAN
718 set_inode
.i_checksum_lo
=
719 ext2fs_swab16(tmp_inode
->i_checksum_lo
);
721 set_inode
.i_checksum_hi
= tmp_inode
->i_checksum_hi
;
723 crc
|= ((__u32
)set_inode
.i_checksum_hi
) << 16;
725 printf("Checksum set to 0x%08x\n", crc
);
727 ext2fs_free_mem(&tmp_inode
);
730 return parse_uint(info
, field
, arg
);
733 static void print_possible_fields(struct field_set_info
*fields
)
735 struct field_set_info
*ss
;
736 const char *type
, *cmd
;
738 char name
[40], idx
[40];
740 if (fields
== super_fields
) {
742 cmd
= "set_super_value";
743 } else if (fields
== inode_fields
) {
746 } else if (fields
== mmp_fields
) {
748 cmd
= "set_mmp_value";
750 type
= "Block group descriptor";
751 cmd
= "set_block_group";
755 fprintf(f
, "%s fields supported by the %s command:\n", type
, cmd
);
757 for (ss
= fields
; ss
->name
; ss
++) {
759 if (ss
->func
== parse_string
)
761 else if (ss
->func
== parse_int
)
763 else if (ss
->func
== parse_uint
)
764 type
= "unsigned integer";
765 else if (ss
->func
== parse_uuid
)
767 else if (ss
->func
== parse_hashalg
)
768 type
= "hash algorithm";
769 else if (ss
->func
== parse_time
)
771 else if (ss
->func
== parse_bmap
)
772 type
= "set physical->logical block map";
773 else if (ss
->func
== parse_gd_csum
)
774 type
= "unsigned integer OR \"calc\"";
775 strcpy(name
, ss
->name
);
776 if (ss
->flags
& FLAG_ARRAY
) {
778 sprintf(idx
, "[%d]", ss
->max_idx
);
784 strcat(name
, "[_hi|_lo]");
785 fprintf(f
, "\t%-25s\t%s\n", name
, type
);
791 void do_set_super(int argc
, char *argv
[], int sci_idx
EXT2FS_ATTR((unused
)),
792 void *infop
EXT2FS_ATTR((unused
)))
794 const char *usage
= "<field> <value>\n"
795 "\t\"set_super_value -l\" will list the names of "
796 "superblock fields\n\twhich can be set.";
797 static struct field_set_info
*ss
;
799 if ((argc
== 2) && !strcmp(argv
[1], "-l")) {
800 print_possible_fields(super_fields
);
804 if (common_args_process(argc
, argv
, 3, 3, "set_super_value",
808 if ((ss
= find_field(super_fields
, argv
[1])) == 0) {
809 com_err(argv
[0], 0, "invalid field specifier: %s", argv
[1]);
812 set_sb
= *current_fs
->super
;
813 if (ss
->func(ss
, argv
[1], argv
[2]) == 0) {
814 *current_fs
->super
= set_sb
;
815 ext2fs_mark_super_dirty(current_fs
);
819 void do_set_inode(int argc
, char *argv
[], int sci_idx
EXT2FS_ATTR((unused
)),
820 void *infop
EXT2FS_ATTR((unused
)))
822 const char *usage
= "<inode> <field> <value>\n"
823 "\t\"set_inode_field -l\" will list the names of "
824 "the fields in an ext2 inode\n\twhich can be set.";
825 static struct field_set_info
*ss
;
827 if ((argc
== 2) && !strcmp(argv
[1], "-l")) {
828 print_possible_fields(inode_fields
);
832 if (common_args_process(argc
, argv
, 4, 4, "set_inode",
836 if ((ss
= find_field(inode_fields
, argv
[2])) == 0) {
837 com_err(argv
[0], 0, "invalid field specifier: %s", argv
[2]);
841 set_ino
= string_to_inode(argv
[1]);
845 if (debugfs_read_inode2(set_ino
,
846 (struct ext2_inode
*) &set_inode
, argv
[1],
848 (ss
->flags
& FLAG_CSUM
) ?
849 READ_INODE_NOCSUM
: 0))
852 if (ss
->func(ss
, argv
[2], argv
[3]) == 0) {
853 debugfs_write_inode2(set_ino
,
854 (struct ext2_inode
*) &set_inode
,
855 argv
[1], sizeof(set_inode
),
856 (ss
->flags
& FLAG_CSUM
) ?
857 WRITE_INODE_NOCSUM
: 0);
861 void do_set_block_group_descriptor(int argc
, char *argv
[],
862 int sci_idx
EXT2FS_ATTR((unused
)),
863 void *infop
EXT2FS_ATTR((unused
)))
865 const char *usage
= "<bg number> <field> <value>\n"
866 "\t\"set_block_group -l\" will list the names of "
867 "the fields in a block group descriptor\n\twhich can be set.";
868 struct field_set_info
*table
;
869 struct field_set_info
*ss
;
875 * Determine whether we are editing an ext2 or ext4 block group
876 * descriptor. Descriptors larger than ext4_group_desc cannot
877 * have their fields edited yet, because they do not have any
878 * names assigned. When that happens, this function needs to
879 * be updated for the new descriptor struct and fields.
882 EXT2_DESC_SIZE(current_fs
->super
) >= EXT2_MIN_DESC_SIZE_64BIT
) {
883 table
= ext4_bg_fields
;
885 size
= sizeof(set_gd4
);
887 table
= ext2_bg_fields
;
889 size
= sizeof(set_gd
);
892 if ((argc
== 2) && !strcmp(argv
[1], "-l")) {
893 print_possible_fields(table
);
897 if (common_args_process(argc
, argv
, 4, 4, "set_block_group",
901 set_bg
= strtoul(argv
[1], &end
, 0);
903 com_err(argv
[0], 0, "invalid block group number: %s", argv
[1]);
907 if (set_bg
>= current_fs
->group_desc_count
) {
908 com_err(argv
[0], 0, "block group number too big: %d", set_bg
);
912 if ((ss
= find_field(table
, argv
[2])) == 0) {
913 com_err(argv
[0], 0, "invalid field specifier: %s", argv
[2]);
917 target
= ext2fs_group_desc(current_fs
, current_fs
->group_desc
, set_bg
);
918 memcpy(edit
, target
, size
);
919 if (ss
->func(ss
, argv
[2], argv
[3]) == 0) {
920 memcpy(target
, edit
, size
);
921 ext2fs_mark_super_dirty(current_fs
);
925 static errcode_t
parse_mmp_clear(struct field_set_info
*info
,
926 char *field
EXT2FS_ATTR((unused
)),
927 char *arg
EXT2FS_ATTR((unused
)))
931 retval
= ext2fs_mmp_clear(current_fs
);
933 com_err("set_mmp_value", retval
, "while clearing MMP block\n");
935 memcpy(info
->ptr
, current_fs
->mmp_buf
, info
->size
);
937 return 1; /* we don't need the MMP block written again */
941 void do_set_mmp_value(int argc
, char *argv
[], int sci_idx
EXT2FS_ATTR((unused
)),
942 void *infop
EXT2FS_ATTR((unused
)))
944 const char *usage
= "<field> <value>\n"
945 "\t\"set_mmp_value -l\" will list the names of "
946 "MMP fields\n\twhich can be set.";
947 static struct field_set_info
*smmp
;
948 struct mmp_struct
*mmp_s
;
951 if (argc
== 2 && strcmp(argv
[1], "-l") == 0) {
952 print_possible_fields(mmp_fields
);
956 if (check_fs_open(argv
[0]))
959 if (current_fs
->super
->s_mmp_block
== 0) {
960 com_err(argv
[0], 0, "no MMP block allocated\n");
964 if (common_args_process(argc
, argv
, 2, 3, "set_mmp_value",
968 mmp_s
= current_fs
->mmp_buf
;
970 retval
= ext2fs_get_mem(current_fs
->blocksize
, &mmp_s
);
972 com_err(argv
[0], retval
, "allocating MMP buffer\n");
975 retval
= ext2fs_mmp_read(current_fs
,
976 current_fs
->super
->s_mmp_block
, mmp_s
);
978 com_err(argv
[0], retval
, "reading MMP block %llu.\n",
979 (long long)current_fs
->super
->s_mmp_block
);
980 ext2fs_free_mem(&mmp_s
);
983 current_fs
->mmp_buf
= mmp_s
;
986 smmp
= find_field(mmp_fields
, argv
[1]);
988 com_err(argv
[0], 0, "invalid field specifier: %s", argv
[1]);
993 if (smmp
->func(smmp
, argv
[1], argv
[2]) == 0) {
994 ext2fs_mmp_write(current_fs
, current_fs
->super
->s_mmp_block
,
1000 void do_set_mmp_value(int argc
EXT2FS_ATTR((unused
)),
1001 char *argv
[] EXT2FS_ATTR((unused
)),
1002 int sci_idx
EXT2FS_ATTR((unused
)),
1003 void *infop
EXT2FS_ATTR((unused
)))
1005 fprintf(stdout
, "MMP is unsupported, please recompile with "