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