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