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