1 /*
2 * feature.c --- convert between features and strings
3 *
4 * Copyright (C) 1999 Theodore Ts'o <tytso@mit.edu>
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
9 * %End-Header%
10 */
11
12 #include "config.h"
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <ctype.h>
17 #include <errno.h>
18
19 #include "e2p.h"
20 #include <ext2fs/ext2fs.h>
21 #include <ext2fs/kernel-jbd.h>
22
23 struct feature {
24 int compat;
25 unsigned int mask;
26 const char *string;
27 };
28
29 static struct feature feature_list[] = {
30 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_PREALLOC,
31 "dir_prealloc" },
32 { E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL,
33 "has_journal" },
34 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_IMAGIC_INODES,
35 "imagic_inodes" },
36 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_EXT_ATTR,
37 "ext_attr" },
38 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX,
39 "dir_index" },
40 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_RESIZE_INODE,
41 "resize_inode" },
42 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_LAZY_BG,
43 "lazy_bg" },
44 { E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_EXCLUDE_BITMAP,
45 "snapshot_bitmap" },
46 { E2P_FEATURE_COMPAT, EXT4_FEATURE_COMPAT_SPARSE_SUPER2,
47 "sparse_super2" },
48 { E2P_FEATURE_COMPAT, EXT4_FEATURE_COMPAT_FAST_COMMIT,
49 "fast_commit" },
50
51 { E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER,
52 "sparse_super" },
53 { E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_LARGE_FILE,
54 "large_file" },
55 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_HUGE_FILE,
56 "huge_file" },
57 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_GDT_CSUM,
58 "uninit_bg" },
59 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_GDT_CSUM,
60 "uninit_groups" },
61 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_DIR_NLINK,
62 "dir_nlink" },
63 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE,
64 "extra_isize" },
65 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_QUOTA,
66 "quota" },
67 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_BIGALLOC,
68 "bigalloc"},
69 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_METADATA_CSUM,
70 "metadata_csum"},
71 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_REPLICA,
72 "replica" },
73 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_READONLY,
74 "read-only" },
75 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_PROJECT,
76 "project"},
77 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_SHARED_BLOCKS,
78 "shared_blocks"},
79 { E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_VERITY,
80 "verity"},
81
82 { E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_COMPRESSION,
83 "compression" },
84 { E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_FILETYPE,
85 "filetype" },
86 { E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_RECOVER,
87 "needs_recovery" },
88 { E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_JOURNAL_DEV,
89 "journal_dev" },
90 { E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_EXTENTS,
91 "extent" },
92 { E2P_FEATURE_INCOMPAT, EXT3_FEATURE_INCOMPAT_EXTENTS,
93 "extents" },
94 { E2P_FEATURE_INCOMPAT, EXT2_FEATURE_INCOMPAT_META_BG,
95 "meta_bg" },
96 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_64BIT,
97 "64bit" },
98 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_MMP,
99 "mmp" },
100 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_FLEX_BG,
101 "flex_bg"},
102 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_EA_INODE,
103 "ea_inode"},
104 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_DIRDATA,
105 "dirdata"},
106 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CSUM_SEED,
107 "metadata_csum_seed"},
108 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_LARGEDIR,
109 "large_dir"},
110 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_INLINE_DATA,
111 "inline_data"},
112 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_ENCRYPT,
113 "encrypt"},
114 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CASEFOLD,
115 "casefold"},
116 { E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CASEFOLD,
117 "fname_encoding"},
118 { 0, 0, 0 },
119 };
120
121 static struct feature jrnl_feature_list[] = {
122 { E2P_FEATURE_COMPAT, JFS_FEATURE_COMPAT_CHECKSUM,
123 "journal_checksum" },
124
125 { E2P_FEATURE_INCOMPAT, JFS_FEATURE_INCOMPAT_REVOKE,
126 "journal_incompat_revoke" },
127 { E2P_FEATURE_INCOMPAT, JFS_FEATURE_INCOMPAT_64BIT,
128 "journal_64bit" },
129 { E2P_FEATURE_INCOMPAT, JFS_FEATURE_INCOMPAT_ASYNC_COMMIT,
130 "journal_async_commit" },
131 { E2P_FEATURE_INCOMPAT, JFS_FEATURE_INCOMPAT_CSUM_V2,
132 "journal_checksum_v2" },
133 { E2P_FEATURE_INCOMPAT, JFS_FEATURE_INCOMPAT_CSUM_V3,
134 "journal_checksum_v3" },
135 { 0, 0, 0 },
136 };
137
e2p_feature_to_string(int compat,unsigned int mask,char * buf,size_t buf_len)138 void e2p_feature_to_string(int compat, unsigned int mask, char *buf,
139 size_t buf_len)
140 {
141 struct feature *f;
142 char fchar;
143 int fnum;
144
145 for (f = feature_list; f->string; f++) {
146 if ((compat == f->compat) &&
147 (mask == f->mask)) {
148 strncpy(buf, f->string, buf_len);
149 buf[buf_len - 1] = 0;
150 return;
151 }
152 }
153 switch (compat) {
154 case E2P_FEATURE_COMPAT:
155 fchar = 'C';
156 break;
157 case E2P_FEATURE_INCOMPAT:
158 fchar = 'I';
159 break;
160 case E2P_FEATURE_RO_INCOMPAT:
161 fchar = 'R';
162 break;
163 default:
164 fchar = '?';
165 break;
166 }
167 for (fnum = 0; mask >>= 1; fnum++);
168 sprintf(buf, "FEATURE_%c%d", fchar, fnum);
169 }
170
e2p_feature2string(int compat,unsigned int mask)171 const char *e2p_feature2string(int compat, unsigned int mask)
172 {
173 static char buf[20];
174
175 e2p_feature_to_string(compat, mask, buf, sizeof(buf) / sizeof(buf[0]));
176 return buf;
177 }
178
e2p_string2feature(char * string,int * compat_type,unsigned int * mask)179 int e2p_string2feature(char *string, int *compat_type, unsigned int *mask)
180 {
181 struct feature *f;
182 char *eptr;
183 int num;
184
185 for (f = feature_list; f->string; f++) {
186 if (!strcasecmp(string, f->string)) {
187 *compat_type = f->compat;
188 *mask = f->mask;
189 return 0;
190 }
191 }
192 if (strncasecmp(string, "FEATURE_", 8))
193 return 1;
194
195 switch (string[8]) {
196 case 'c':
197 case 'C':
198 *compat_type = E2P_FEATURE_COMPAT;
199 break;
200 case 'i':
201 case 'I':
202 *compat_type = E2P_FEATURE_INCOMPAT;
203 break;
204 case 'r':
205 case 'R':
206 *compat_type = E2P_FEATURE_RO_INCOMPAT;
207 break;
208 default:
209 return 1;
210 }
211 if (string[9] == 0)
212 return 1;
213 num = strtol(string+9, &eptr, 10);
214 if (num > 31 || num < 0)
215 return 1;
216 if (*eptr)
217 return 1;
218 *mask = 1 << num;
219 return 0;
220 }
221
e2p_jrnl_feature2string(int compat,unsigned int mask)222 const char *e2p_jrnl_feature2string(int compat, unsigned int mask)
223 {
224 struct feature *f;
225 static char buf[20];
226 char fchar;
227 int fnum;
228
229 for (f = jrnl_feature_list; f->string; f++) {
230 if ((compat == f->compat) &&
231 (mask == f->mask))
232 return f->string;
233 }
234 switch (compat) {
235 case E2P_FEATURE_COMPAT:
236 fchar = 'C';
237 break;
238 case E2P_FEATURE_INCOMPAT:
239 fchar = 'I';
240 break;
241 case E2P_FEATURE_RO_INCOMPAT:
242 fchar = 'R';
243 break;
244 default:
245 fchar = '?';
246 break;
247 }
248 for (fnum = 0; mask >>= 1; fnum++);
249 sprintf(buf, "FEATURE_%c%d", fchar, fnum);
250 return buf;
251 }
252
e2p_jrnl_string2feature(char * string,int * compat_type,unsigned int * mask)253 int e2p_jrnl_string2feature(char *string, int *compat_type, unsigned int *mask)
254 {
255 struct feature *f;
256 char *eptr;
257 int num;
258
259 for (f = jrnl_feature_list; f->string; f++) {
260 if (!strcasecmp(string, f->string)) {
261 *compat_type = f->compat;
262 *mask = f->mask;
263 return 0;
264 }
265 }
266 if (strncasecmp(string, "FEATURE_", 8))
267 return 1;
268
269 switch (string[8]) {
270 case 'c':
271 case 'C':
272 *compat_type = E2P_FEATURE_COMPAT;
273 break;
274 case 'i':
275 case 'I':
276 *compat_type = E2P_FEATURE_INCOMPAT;
277 break;
278 case 'r':
279 case 'R':
280 *compat_type = E2P_FEATURE_RO_INCOMPAT;
281 break;
282 default:
283 return 1;
284 }
285 if (string[9] == 0)
286 return 1;
287 num = strtol(string+9, &eptr, 10);
288 if (num > 31 || num < 0)
289 return 1;
290 if (*eptr)
291 return 1;
292 *mask = 1 << num;
293 return 0;
294 }
skip_over_blanks(char * cp)295 static char *skip_over_blanks(char *cp)
296 {
297 while (*cp && isspace(*cp))
298 cp++;
299 return cp;
300 }
301
skip_over_word(char * cp)302 static char *skip_over_word(char *cp)
303 {
304 while (*cp && !isspace(*cp) && *cp != ',')
305 cp++;
306 return cp;
307 }
308
309 /*
310 * Edit a feature set array as requested by the user. The ok_array,
311 * if set, allows the application to limit what features the user is
312 * allowed to set or clear using this function. If clear_ok_array is set,
313 * then use it tell whether or not it is OK to clear a filesystem feature.
314 */
e2p_edit_feature2(const char * str,__u32 * compat_array,__u32 * ok_array,__u32 * clear_ok_array,int * type_err,unsigned int * mask_err)315 int e2p_edit_feature2(const char *str, __u32 *compat_array, __u32 *ok_array,
316 __u32 *clear_ok_array, int *type_err,
317 unsigned int *mask_err)
318 {
319 char *cp, *buf, *next;
320 int neg;
321 unsigned int mask;
322 int compat_type;
323 int rc = 0;
324
325 if (!clear_ok_array)
326 clear_ok_array = ok_array;
327
328 if (type_err)
329 *type_err = 0;
330 if (mask_err)
331 *mask_err = 0;
332
333 buf = malloc(strlen(str)+1);
334 if (!buf)
335 return 1;
336 strcpy(buf, str);
337 for (cp = buf; cp && *cp; cp = next ? next+1 : 0) {
338 neg = 0;
339 cp = skip_over_blanks(cp);
340 next = skip_over_word(cp);
341
342 if (*next == 0)
343 next = 0;
344 else
345 *next = 0;
346
347 if ((strcasecmp(cp, "none") == 0) ||
348 (strcasecmp(cp, "clear") == 0)) {
349 compat_array[0] = 0;
350 compat_array[1] = 0;
351 compat_array[2] = 0;
352 continue;
353 }
354
355 switch (*cp) {
356 case '-':
357 case '^':
358 neg++;
359 /* fallthrough */
360 case '+':
361 cp++;
362 break;
363 }
364 if (e2p_string2feature(cp, &compat_type, &mask)) {
365 rc = 1;
366 break;
367 }
368 if (neg) {
369 if (clear_ok_array &&
370 !(clear_ok_array[compat_type] & mask)) {
371 rc = 1;
372 if (type_err)
373 *type_err = (compat_type |
374 E2P_FEATURE_NEGATE_FLAG);
375 if (mask_err)
376 *mask_err = mask;
377 break;
378 }
379 compat_array[compat_type] &= ~mask;
380 } else {
381 if (ok_array && !(ok_array[compat_type] & mask)) {
382 rc = 1;
383 if (type_err)
384 *type_err = compat_type;
385 if (mask_err)
386 *mask_err = mask;
387 break;
388 }
389 compat_array[compat_type] |= mask;
390 }
391 }
392 free(buf);
393 return rc;
394 }
395
e2p_edit_feature(const char * str,__u32 * compat_array,__u32 * ok_array)396 int e2p_edit_feature(const char *str, __u32 *compat_array, __u32 *ok_array)
397 {
398 return e2p_edit_feature2(str, compat_array, ok_array, 0, 0, 0);
399 }
400
401 #ifdef TEST_PROGRAM
main(int argc,char ** argv)402 int main(int argc, char **argv)
403 {
404 int compat, compat2, i;
405 unsigned int mask, mask2;
406 const char *str;
407 struct feature *f;
408
409 for (i = 0; i < 2; i++) {
410 if (i == 0) {
411 f = feature_list;
412 printf("Feature list:\n");
413 } else {
414 printf("\nJournal feature list:\n");
415 f = jrnl_feature_list;
416 }
417 for (; f->string; f++) {
418 if (i == 0) {
419 e2p_string2feature((char *)f->string, &compat,
420 &mask);
421 str = e2p_feature2string(compat, mask);
422 } else {
423 e2p_jrnl_string2feature((char *)f->string,
424 &compat, &mask);
425 str = e2p_jrnl_feature2string(compat, mask);
426 }
427
428 printf("\tCompat = %d, Mask = %u, %s\n",
429 compat, mask, f->string);
430 if (strcmp(f->string, str)) {
431 if (e2p_string2feature((char *) str, &compat2,
432 &mask2) ||
433 (compat2 != compat) ||
434 (mask2 != mask)) {
435 fprintf(stderr, "Failure!\n");
436 exit(1);
437 }
438 }
439 }
440 }
441 exit(0);
442 }
443 #endif
444