lib/e2p/feature.c

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