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