fs/reiser4/init_super.c

   1 /* Copyright by Hans Reiser, 2003 */
   2
   3 #include "super.h"
   4 #include "inode.h"
   5 #include "plugin/plugin_set.h"
   6
   7 #include <linux/swap.h>
   8
   9 /**
  10  * init_fs_info - allocate reiser4 specific super block
  11  * @super: super block of filesystem
  12  *
  13  * Allocates and initialize reiser4_super_info_data, attaches it to
  14  * super->s_fs_info, initializes structures maintaining d_cursor-s.
  15  */
  16 int reiser4_init_fs_info(struct super_block *super)
  17 {
  18         reiser4_super_info_data *sbinfo;
  19
  20         sbinfo = kzalloc(sizeof(reiser4_super_info_data),
  21                          reiser4_ctx_gfp_mask_get());
  22         if (!sbinfo)
  23                 return RETERR(-ENOMEM);
  24
  25         super->s_fs_info = sbinfo;
  26         super->s_op = NULL;
  27
  28         ON_DEBUG(INIT_LIST_HEAD(&sbinfo->all_jnodes));
  29         ON_DEBUG(spin_lock_init(&sbinfo->all_guard));
  30
  31         mutex_init(&sbinfo->delete_mutex);
  32         spin_lock_init(&(sbinfo->guard));
  33
  34         /*  initialize per-super-block d_cursor resources */
  35         reiser4_init_super_d_info(super);
  36
  37         return 0;
  38 }
  39
  40 /**
  41  * reiser4_done_fs_info - free reiser4 specific super block
  42  * @super: super block of filesystem
  43  *
  44  * Performs some sanity checks, releases structures maintaining d_cursor-s,
  45  * frees reiser4_super_info_data.
  46  */
  47 void reiser4_done_fs_info(struct super_block *super)
  48 {
  49         assert("zam-990", super->s_fs_info != NULL);
  50
  51         /* release per-super-block d_cursor resources */
  52         reiser4_done_super_d_info(super);
  53
  54         /* make sure that there are not jnodes already */
  55         assert("", list_empty(&get_super_private(super)->all_jnodes));
  56         assert("", get_current_context()->trans->atom == NULL);
  57         reiser4_check_block_counters(super);
  58         kfree(super->s_fs_info);
  59         super->s_fs_info = NULL;
  60 }
  61
  62 /* type of option parseable by parse_option() */
  63 typedef enum {
  64         /* value of option is arbitrary string */
  65         OPT_STRING,
  66
  67         /*
  68          * option specifies bit in a bitmask. When option is set - bit in
  69          * sbinfo->fs_flags is set. Examples are bsdgroups, 32bittimes, mtflush,
  70          * dont_load_bitmap, atomic_write.
  71          */
  72         OPT_BIT,
  73
  74         /*
  75          * value of option should conform to sprintf() format. Examples are
  76          * tmgr.atom_max_size=N, tmgr.atom_max_age=N
  77          */
  78         OPT_FORMAT,
  79
  80         /*
  81          * option can take one of predefined values. Example is onerror=panic or
  82          * onerror=remount-ro
  83          */
  84         OPT_ONEOF,
  85 } opt_type_t;
  86
  87 #if 0
  88 struct opt_bitmask_bit {
  89         const char *bit_name;
  90         int bit_nr;
  91 };
  92 #endif
  93
  94 /* description of option parseable by parse_option() */
  95 struct opt_desc {
  96         /* option name.
  97
  98            parsed portion of string has a form "name=value".
  99          */
 100         const char *name;
 101         /* type of option */
 102         opt_type_t type;
 103         union {
 104                 /* where to store value of string option (type == OPT_STRING) */
 105                 char **string;
 106                 /* description of bits for bit option (type == OPT_BIT) */
 107                 struct {
 108                         int nr;
 109                         void *addr;
 110                 } bit;
 111                 /* description of format and targets for format option (type
 112                    == OPT_FORMAT) */
 113                 struct {
 114                         const char *format;
 115                         int nr_args;
 116                         void *arg1;
 117                         void *arg2;
 118                         void *arg3;
 119                         void *arg4;
 120                 } f;
 121                 struct {
 122                         int *result;
 123                         const char *list[10];
 124                 } oneof;
 125                 struct {
 126                         void *addr;
 127                         int nr_bits;
 128                         /* struct opt_bitmask_bit *bits; */
 129                 } bitmask;
 130         } u;
 131 };
 132
 133 /**
 134  * parse_option - parse one option
 135  * @opt_strin: starting point of parsing
 136  * @opt: option description
 137  *
 138  * foo=bar,
 139  * ^   ^  ^
 140  * |   |  +-- replaced to '\0'
 141  * |   +-- val_start
 142  * +-- opt_string
 143  * Figures out option type and handles option correspondingly.
 144  */
 145 static int parse_option(char *opt_string, struct opt_desc *opt)
 146 {
 147         char *val_start;
 148         int result;
 149         const char *err_msg;
 150
 151         /* NOTE-NIKITA think about using lib/cmdline.c functions here. */
 152
 153         val_start = strchr(opt_string, '=');
 154         if (val_start != NULL) {
 155                 *val_start = '\0';
 156                 ++val_start;
 157         }
 158
 159         err_msg = NULL;
 160         result = 0;
 161         switch (opt->type) {
 162         case OPT_STRING:
 163                 if (val_start == NULL) {
 164                         err_msg = "String arg missing";
 165                         result = RETERR(-EINVAL);
 166                 } else
 167                         *opt->u.string = val_start;
 168                 break;
 169         case OPT_BIT:
 170                 if (val_start != NULL)
 171                         err_msg = "Value ignored";
 172                 else
 173                         set_bit(opt->u.bit.nr, opt->u.bit.addr);
 174                 break;
 175         case OPT_FORMAT:
 176                 if (val_start == NULL) {
 177                         err_msg = "Formatted arg missing";
 178                         result = RETERR(-EINVAL);
 179                         break;
 180                 }
 181                 if (sscanf(val_start, opt->u.f.format,
 182                            opt->u.f.arg1, opt->u.f.arg2, opt->u.f.arg3,
 183                            opt->u.f.arg4) != opt->u.f.nr_args) {
 184                         err_msg = "Wrong conversion";
 185                         result = RETERR(-EINVAL);
 186                 }
 187                 break;
 188         case OPT_ONEOF:
 189                 {
 190                         int i = 0;
 191
 192                         if (val_start == NULL) {
 193                                 err_msg = "Value is missing";
 194                                 result = RETERR(-EINVAL);
 195                                 break;
 196                         }
 197                         err_msg = "Wrong option value";
 198                         result = RETERR(-EINVAL);
 199                         while (opt->u.oneof.list[i]) {
 200                                 if (!strcmp(opt->u.oneof.list[i], val_start)) {
 201                                         result = 0;
 202                                         err_msg = NULL;
 203                                         *opt->u.oneof.result = i;
 204                                         break;
 205                                 }
 206                                 i++;
 207                         }
 208                         break;
 209                 }
 210         default:
 211                 wrong_return_value("nikita-2100", "opt -> type");
 212                 break;
 213         }
 214         if (err_msg != NULL) {
 215                 warning("nikita-2496", "%s when parsing option \"%s%s%s\"",
 216                         err_msg, opt->name, val_start ? "=" : "",
 217                         val_start ? : "");
 218         }
 219         return result;
 220 }
 221
 222 /**
 223  * parse_options - parse reiser4 mount options
 224  * @opt_string: starting point
 225  * @opts: array of option description
 226  * @nr_opts: number of elements in @opts
 227  *
 228  * Parses comma separated list of reiser4 mount options.
 229  */
 230 static int parse_options(char *opt_string, struct opt_desc *opts, int nr_opts)
 231 {
 232         int result;
 233
 234         result = 0;
 235         while ((result == 0) && opt_string && *opt_string) {
 236                 int j;
 237                 char *next;
 238
 239                 next = strchr(opt_string, ',');
 240                 if (next != NULL) {
 241                         *next = '\0';
 242                         ++next;
 243                 }
 244                 for (j = 0; j < nr_opts; ++j) {
 245                         if (!strncmp(opt_string, opts[j].name,
 246                                      strlen(opts[j].name))) {
 247                                 result = parse_option(opt_string, &opts[j]);
 248                                 break;
 249                         }
 250                 }
 251                 if (j == nr_opts) {
 252                         warning("nikita-2307", "Unrecognized option: \"%s\"",
 253                                 opt_string);
 254                         /* traditionally, -EINVAL is returned on wrong mount
 255                            option */
 256                         result = RETERR(-EINVAL);
 257                 }
 258                 opt_string = next;
 259         }
 260         return result;
 261 }
 262
 263 #define NUM_OPT(label, fmt, addr)                               \
 264                 {                                               \
 265                         .name = (label),                        \
 266                         .type = OPT_FORMAT,                     \
 267                         .u = {                                  \
 268                                 .f = {                          \
 269                                         .format  = (fmt),       \
 270                                         .nr_args = 1,           \
 271                                         .arg1 = (addr),         \
 272                                         .arg2 = NULL,           \
 273                                         .arg3 = NULL,           \
 274                                         .arg4 = NULL            \
 275                                 }                               \
 276                         }                                       \
 277                 }
 278
 279 #define SB_FIELD_OPT(field, fmt) NUM_OPT(#field, fmt, &sbinfo->field)
 280
 281 #define BIT_OPT(label, bitnr)                                   \
 282         {                                                       \
 283                 .name = label,                                  \
 284                 .type = OPT_BIT,                                \
 285                 .u = {                                          \
 286                         .bit = {                                \
 287                                 .nr = bitnr,                    \
 288                                 .addr = &sbinfo->fs_flags       \
 289                         }                                       \
 290                 }                                               \
 291         }
 292
 293 #define MAX_NR_OPTIONS (30)
 294
 295 #if REISER4_DEBUG
 296 #  define OPT_ARRAY_CHECK(opt, array)                                   \
 297         if ((opt) > (array) + MAX_NR_OPTIONS) {                         \
 298                 warning("zam-1046", "opt array is overloaded"); break;  \
 299         }
 300 #else
 301 #   define OPT_ARRAY_CHECK(opt, array) noop
 302 #endif
 303
 304 #define PUSH_OPT(opt, array, ...)               \
 305 do {                                            \
 306         struct opt_desc o = __VA_ARGS__;        \
 307         OPT_ARRAY_CHECK(opt, array);            \
 308         *(opt) ++ = o;                          \
 309 } while (0)
 310
 311 static noinline void push_sb_field_opts(struct opt_desc **p,
 312                                         struct opt_desc *opts,
 313                                         reiser4_super_info_data *sbinfo)
 314 {
 315 #define PUSH_SB_FIELD_OPT(field, format)                \
 316         PUSH_OPT(*p, opts, SB_FIELD_OPT(field, format))
 317         /*
 318          * tmgr.atom_max_size=N
 319          * Atoms containing more than N blocks will be forced to commit. N is
 320          * decimal.
 321          */
 322         PUSH_SB_FIELD_OPT(tmgr.atom_max_size, "%u");
 323         /*
 324          * tmgr.atom_max_age=N
 325          * Atoms older than N seconds will be forced to commit. N is decimal.
 326          */
 327         PUSH_SB_FIELD_OPT(tmgr.atom_max_age, "%u");
 328         /*
 329          * tmgr.atom_min_size=N
 330          * In committing an atom to free dirty pages, force the atom less than
 331          * N in size to fuse with another one.
 332          */
 333         PUSH_SB_FIELD_OPT(tmgr.atom_min_size, "%u");
 334         /*
 335          * tmgr.atom_max_flushers=N
 336          * limit of concurrent flushers for one atom. 0 means no limit.
 337          */
 338         PUSH_SB_FIELD_OPT(tmgr.atom_max_flushers, "%u");
 339         /*
 340          * tree.cbk_cache_slots=N
 341          * Number of slots in the cbk cache.
 342          */
 343         PUSH_SB_FIELD_OPT(tree.cbk_cache.nr_slots, "%u");
 344         /*
 345          * If flush finds more than FLUSH_RELOCATE_THRESHOLD adjacent dirty
 346          * leaf-level blocks it will force them to be relocated.
 347          */
 348         PUSH_SB_FIELD_OPT(flush.relocate_threshold, "%u");
 349         /*
 350          * If flush finds can find a block allocation closer than at most
 351          * FLUSH_RELOCATE_DISTANCE from the preceder it will relocate to that
 352          * position.
 353          */
 354         PUSH_SB_FIELD_OPT(flush.relocate_distance, "%u");
 355         /*
 356          * If we have written this much or more blocks before encountering busy
 357          * jnode in flush list - abort flushing hoping that next time we get
 358          * called this jnode will be clean already, and we will save some
 359          * seeks.
 360          */
 361         PUSH_SB_FIELD_OPT(flush.written_threshold, "%u");
 362         /* The maximum number of nodes to scan left on a level during flush. */
 363         PUSH_SB_FIELD_OPT(flush.scan_maxnodes, "%u");
 364         /* preferred IO size */
 365         PUSH_SB_FIELD_OPT(optimal_io_size, "%u");
 366         /* carry flags used for insertion of new nodes */
 367         PUSH_SB_FIELD_OPT(tree.carry.new_node_flags, "%u");
 368         /* carry flags used for insertion of new extents */
 369         PUSH_SB_FIELD_OPT(tree.carry.new_extent_flags, "%u");
 370         /* carry flags used for paste operations */
 371         PUSH_SB_FIELD_OPT(tree.carry.paste_flags, "%u");
 372         /* carry flags used for insert operations */
 373         PUSH_SB_FIELD_OPT(tree.carry.insert_flags, "%u");
 374
 375 #ifdef CONFIG_REISER4_BADBLOCKS
 376         /*
 377          * Alternative master superblock location in case if it's original
 378          * location is not writeable/accessable. This is offset in BYTES.
 379          */
 380         PUSH_SB_FIELD_OPT(altsuper, "%lu");
 381 #endif
 382 }
 383
 384 /**
 385  * reiser4_init_super_data - initialize reiser4 private super block
 386  * @super: super block to initialize
 387  * @opt_string: list of reiser4 mount options
 388  *
 389  * Sets various reiser4 parameters to default values. Parses mount options and
 390  * overwrites default settings.
 391  */
 392 int reiser4_init_super_data(struct super_block *super, char *opt_string)
 393 {
 394         int result;
 395         struct opt_desc *opts, *p;
 396         reiser4_super_info_data *sbinfo = get_super_private(super);
 397
 398         /* initialize super, export, dentry operations */
 399         sbinfo->ops.super = reiser4_super_operations;
 400         sbinfo->ops.export = reiser4_export_operations;
 401         sbinfo->ops.dentry = reiser4_dentry_operations;
 402         super->s_op = &sbinfo->ops.super;
 403         super->s_export_op = &sbinfo->ops.export;
 404
 405         /* initialize transaction manager parameters to default values */
 406         sbinfo->tmgr.atom_max_size = totalram_pages / 4;
 407         sbinfo->tmgr.atom_max_age = REISER4_ATOM_MAX_AGE / HZ;
 408         sbinfo->tmgr.atom_min_size = 256;
 409         sbinfo->tmgr.atom_max_flushers = ATOM_MAX_FLUSHERS;
 410
 411         /* initialize cbk cache parameter */
 412         sbinfo->tree.cbk_cache.nr_slots = CBK_CACHE_SLOTS;
 413
 414         /* initialize flush parameters */
 415         sbinfo->flush.relocate_threshold = FLUSH_RELOCATE_THRESHOLD;
 416         sbinfo->flush.relocate_distance = FLUSH_RELOCATE_DISTANCE;
 417         sbinfo->flush.written_threshold = FLUSH_WRITTEN_THRESHOLD;
 418         sbinfo->flush.scan_maxnodes = FLUSH_SCAN_MAXNODES;
 419
 420         sbinfo->optimal_io_size = REISER4_OPTIMAL_IO_SIZE;
 421
 422         /* preliminary tree initializations */
 423         sbinfo->tree.super = super;
 424         sbinfo->tree.carry.new_node_flags = REISER4_NEW_NODE_FLAGS;
 425         sbinfo->tree.carry.new_extent_flags = REISER4_NEW_EXTENT_FLAGS;
 426         sbinfo->tree.carry.paste_flags = REISER4_PASTE_FLAGS;
 427         sbinfo->tree.carry.insert_flags = REISER4_INSERT_FLAGS;
 428         rwlock_init(&(sbinfo->tree.tree_lock));
 429         spin_lock_init(&(sbinfo->tree.epoch_lock));
 430
 431         /* initialize default readahead params */
 432         sbinfo->ra_params.max = num_physpages / 4;
 433         sbinfo->ra_params.flags = 0;
 434
 435         /* allocate memory for structure describing reiser4 mount options */
 436         opts = kmalloc(sizeof(struct opt_desc) * MAX_NR_OPTIONS,
 437                        reiser4_ctx_gfp_mask_get());
 438         if (opts == NULL)
 439                 return RETERR(-ENOMEM);
 440
 441         /* initialize structure describing reiser4 mount options */
 442         p = opts;
 443
 444         push_sb_field_opts(&p, opts, sbinfo);
 445         /* turn on BSD-style gid assignment */
 446
 447 #define PUSH_BIT_OPT(name, bit)                 \
 448         PUSH_OPT(p, opts, BIT_OPT(name, bit))
 449
 450         PUSH_BIT_OPT("bsdgroups", REISER4_BSD_GID);
 451         /* turn on 32 bit times */
 452         PUSH_BIT_OPT("32bittimes", REISER4_32_BIT_TIMES);
 453         /*
 454          * Don't load all bitmap blocks at mount time, it is useful for
 455          * machines with tiny RAM and large disks.
 456          */
 457         PUSH_BIT_OPT("dont_load_bitmap", REISER4_DONT_LOAD_BITMAP);
 458         /* disable transaction commits during write() */
 459         PUSH_BIT_OPT("atomic_write", REISER4_ATOMIC_WRITE);
 460         /* disable use of write barriers in the reiser4 log writer. */
 461         PUSH_BIT_OPT("no_write_barrier", REISER4_NO_WRITE_BARRIER);
 462
 463         PUSH_OPT(p, opts,
 464         {
 465                 /*
 466                  * tree traversal readahead parameters:
 467                  * -o readahead:MAXNUM:FLAGS
 468                  * MAXNUM - max number fo nodes to request readahead for: -1UL
 469                  * will set it to max_sane_readahead()
 470                  * FLAGS - combination of bits: RA_ADJCENT_ONLY, RA_ALL_LEVELS,
 471                  * CONTINUE_ON_PRESENT
 472                  */
 473                 .name = "readahead",
 474                 .type = OPT_FORMAT,
 475                 .u = {
 476                         .f = {
 477                                 .format = "%u:%u",
 478                                 .nr_args = 2,
 479                                 .arg1 = &sbinfo->ra_params.max,
 480                                 .arg2 = &sbinfo->ra_params.flags,
 481                                 .arg3 = NULL,
 482                                 .arg4 = NULL
 483                         }
 484                 }
 485         }
 486         );
 487
 488         /* What to do in case of fs error */
 489         PUSH_OPT(p, opts,
 490         {
 491                 .name = "onerror",
 492                 .type = OPT_ONEOF,
 493                 .u = {
 494                         .oneof = {
 495                                 .result = &sbinfo->onerror,
 496                                 .list = {
 497                                         "panic", "remount-ro", NULL
 498                                 },
 499                         }
 500                 }
 501         }
 502         );
 503
 504         /* modify default settings to values set by mount options */
 505         result = parse_options(opt_string, opts, p - opts);
 506         kfree(opts);
 507         if (result != 0)
 508                 return result;
 509
 510         /* correct settings to sanity values */
 511         sbinfo->tmgr.atom_max_age *= HZ;
 512         if (sbinfo->tmgr.atom_max_age <= 0)
 513                 /* overflow */
 514                 sbinfo->tmgr.atom_max_age = REISER4_ATOM_MAX_AGE;
 515
 516         /* round optimal io size up to 512 bytes */
 517         sbinfo->optimal_io_size >>= VFS_BLKSIZE_BITS;
 518         sbinfo->optimal_io_size <<= VFS_BLKSIZE_BITS;
 519         if (sbinfo->optimal_io_size == 0) {
 520                 warning("nikita-2497", "optimal_io_size is too small");
 521                 return RETERR(-EINVAL);
 522         }
 523         return result;
 524 }
 525
 526 /**
 527  * reiser4_init_read_super - read reiser4 master super block
 528  * @super: super block to fill
 529  * @silent: if 0 - print warnings
 530  *
 531  * Reads reiser4 master super block either from predefined location or from
 532  * location specified by altsuper mount option, initializes disk format plugin.
 533  */
 534 int reiser4_init_read_super(struct super_block *super, int silent)
 535 {
 536         struct buffer_head *super_bh;
 537         struct reiser4_master_sb *master_sb;
 538         reiser4_super_info_data *sbinfo = get_super_private(super);
 539         unsigned long blocksize;
 540
 541  read_super_block:
 542 #ifdef CONFIG_REISER4_BADBLOCKS
 543         if (sbinfo->altsuper)
 544                 /*
 545                  * read reiser4 master super block at position specified by
 546                  * mount option
 547                  */
 548                 super_bh = sb_bread(super,
 549                                     (sector_t)(sbinfo->altsuper / super->s_blocksize));
 550         else
 551 #endif
 552                 /* read reiser4 master super block at 16-th 4096 block */
 553                 super_bh = sb_bread(super,
 554                                     (sector_t)(REISER4_MAGIC_OFFSET / super->s_blocksize));
 555         if (!super_bh)
 556                 return RETERR(-EIO);
 557
 558         master_sb = (struct reiser4_master_sb *)super_bh->b_data;
 559         /* check reiser4 magic string */
 560         if (!strncmp(master_sb->magic, REISER4_SUPER_MAGIC_STRING,
 561                      sizeof(REISER4_SUPER_MAGIC_STRING))) {
 562                 /* reiser4 master super block contains filesystem blocksize */
 563                 blocksize = le16_to_cpu(get_unaligned(&master_sb->blocksize));
 564
 565                 if (blocksize != PAGE_CACHE_SIZE) {
 566                         /*
 567                          * currenly reiser4's blocksize must be equal to
 568                          * pagesize
 569                          */
 570                         if (!silent)
 571                                 warning("nikita-2609",
 572                                         "%s: wrong block size %ld\n", super->s_id,
 573                                         blocksize);
 574                         brelse(super_bh);
 575                         return RETERR(-EINVAL);
 576                 }
 577                 if (blocksize != super->s_blocksize) {
 578                         /*
 579                          * filesystem uses different blocksize. Reread master
 580                          * super block with correct blocksize
 581                          */
 582                         brelse(super_bh);
 583                         if (!sb_set_blocksize(super, (int)blocksize))
 584                                 return RETERR(-EINVAL);
 585                         goto read_super_block;
 586                 }
 587
 588                 sbinfo->df_plug =
 589                         disk_format_plugin_by_id(
 590                                 le16_to_cpu(get_unaligned(&master_sb->disk_plugin_id)));
 591                 if (sbinfo->df_plug == NULL) {
 592                         if (!silent)
 593                                 warning("nikita-26091",
 594                                         "%s: unknown disk format plugin %d\n",
 595                                         super->s_id,
 596                                         le16_to_cpu(get_unaligned(&master_sb->disk_plugin_id)));
 597                         brelse(super_bh);
 598                         return RETERR(-EINVAL);
 599                 }
 600                 sbinfo->diskmap_block = le64_to_cpu(get_unaligned(&master_sb->diskmap));
 601                 brelse(super_bh);
 602                 return 0;
 603         }
 604
 605         /* there is no reiser4 on the device */
 606         if (!silent)
 607                 warning("nikita-2608",
 608                         "%s: wrong master super block magic", super->s_id);
 609         brelse(super_bh);
 610         return RETERR(-EINVAL);
 611 }
 612
 613 static struct {
 614         reiser4_plugin_type type;
 615         reiser4_plugin_id id;
 616 } default_plugins[PSET_LAST] = {
 617         [PSET_FILE] = {
 618                 .type = REISER4_FILE_PLUGIN_TYPE,
 619                 .id = UNIX_FILE_PLUGIN_ID
 620         },
 621         [PSET_DIR] = {
 622                 .type = REISER4_DIR_PLUGIN_TYPE,
 623                 .id = HASHED_DIR_PLUGIN_ID
 624         },
 625         [PSET_HASH] = {
 626                 .type = REISER4_HASH_PLUGIN_TYPE,
 627                 .id = R5_HASH_ID
 628         },
 629         [PSET_FIBRATION] = {
 630                 .type = REISER4_FIBRATION_PLUGIN_TYPE,
 631                 .id = FIBRATION_DOT_O
 632         },
 633         [PSET_PERM] = {
 634                 .type = REISER4_PERM_PLUGIN_TYPE,
 635                 .id = NULL_PERM_ID
 636         },
 637         [PSET_FORMATTING] = {
 638                 .type = REISER4_FORMATTING_PLUGIN_TYPE,
 639                 .id = SMALL_FILE_FORMATTING_ID
 640         },
 641         [PSET_SD] = {
 642                 .type = REISER4_ITEM_PLUGIN_TYPE,
 643                 .id = STATIC_STAT_DATA_ID
 644         },
 645         [PSET_DIR_ITEM] = {
 646                 .type = REISER4_ITEM_PLUGIN_TYPE,
 647                 .id = COMPOUND_DIR_ID
 648         },
 649         [PSET_CIPHER] = {
 650                 .type = REISER4_CIPHER_PLUGIN_TYPE,
 651                 .id = NONE_CIPHER_ID
 652         },
 653         [PSET_DIGEST] = {
 654                 .type = REISER4_DIGEST_PLUGIN_TYPE,
 655                 .id = SHA256_32_DIGEST_ID
 656         },
 657         [PSET_COMPRESSION] = {
 658                 .type = REISER4_COMPRESSION_PLUGIN_TYPE,
 659                 .id = LZO1_COMPRESSION_ID
 660         },
 661         [PSET_COMPRESSION_MODE] = {
 662                 .type = REISER4_COMPRESSION_MODE_PLUGIN_TYPE,
 663                 .id = CONVX_COMPRESSION_MODE_ID
 664         },
 665         [PSET_CLUSTER] = {
 666                 .type = REISER4_CLUSTER_PLUGIN_TYPE,
 667                 .id = CLUSTER_64K_ID
 668         },
 669         [PSET_CREATE] = {
 670                 .type = REISER4_FILE_PLUGIN_TYPE,
 671                 .id = UNIX_FILE_PLUGIN_ID
 672         }
 673 };
 674
 675 /* access to default plugin table */
 676 reiser4_plugin *get_default_plugin(pset_member memb)
 677 {
 678         return plugin_by_id(default_plugins[memb].type,
 679                             default_plugins[memb].id);
 680 }
 681
 682 /**
 683  * reiser4_init_root_inode - obtain inode of root directory
 684  * @super: super block of filesystem
 685  *
 686  * Obtains inode of root directory (reading it from disk), initializes plugin
 687  * set it was not initialized.
 688  */
 689 int reiser4_init_root_inode(struct super_block *super)
 690 {
 691         reiser4_super_info_data *sbinfo = get_super_private(super);
 692         struct inode *inode;
 693         int result = 0;
 694
 695         inode = reiser4_iget(super, sbinfo->df_plug->root_dir_key(super), 0);
 696         if (IS_ERR(inode))
 697                 return RETERR(PTR_ERR(inode));
 698
 699         super->s_root = d_alloc_root(inode);
 700         if (!super->s_root) {
 701                 iput(inode);
 702                 return RETERR(-ENOMEM);
 703         }
 704
 705         super->s_root->d_op = &sbinfo->ops.dentry;
 706
 707         if (!is_inode_loaded(inode)) {
 708                 pset_member memb;
 709                 plugin_set *pset;
 710
 711                 pset = reiser4_inode_data(inode)->pset;
 712                 for (memb = 0; memb < PSET_LAST; ++memb) {
 713
 714                         if (aset_get(pset, memb) != NULL)
 715                                 continue;
 716
 717                         result = grab_plugin_pset(inode, NULL, memb);
 718                         if (result != 0)
 719                                 break;
 720
 721                         reiser4_inode_clr_flag(inode, REISER4_SDLEN_KNOWN);
 722                 }
 723
 724                 if (result == 0) {
 725                         if (REISER4_DEBUG) {
 726                                 for (memb = 0; memb < PSET_LAST; ++memb)
 727                                         assert("nikita-3500",
 728                                                aset_get(pset, memb) != NULL);
 729                         }
 730                 } else
 731                         warning("nikita-3448", "Cannot set plugins of root: %i",
 732                                 result);
 733                 reiser4_iget_complete(inode);
 734
 735                 /* As the default pset kept in the root dir may has been changed
 736                    (length is unknown), call update_sd. */
 737                 if (!reiser4_inode_get_flag(inode, REISER4_SDLEN_KNOWN)) {
 738                         result = reiser4_grab_space(
 739                                 inode_file_plugin(inode)->estimate.update(inode),
 740                                 BA_CAN_COMMIT);
 741
 742                         if (result == 0)
 743                                 result = reiser4_update_sd(inode);
 744
 745                         all_grabbed2free();
 746                 }
 747         }
 748
 749         super->s_maxbytes = MAX_LFS_FILESIZE;
 750         return result;
 751 }
 752
 753 /*
 754  * Local variables:
 755  * c-indentation-style: "K&R"
 756  * mode-name: "LC"
 757  * c-basic-offset: 8
 758  * tab-width: 8
 759  * fill-column: 79
 760  * End:
 761  */