LinnCreate.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 Niek Linnenbank
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef __FILESYSTEM_LINN_CREATE_H
#define __FILESYSTEM_LINN_CREATE_H
 
#include <BitArray.h>
#include <List.h>
#include <String.h>
#include <FileSystem.h>
#include "LinnSuperBlock.h"
#include "LinnInode.h"
 
#define LINN_CREATE_BLOCK_SIZE          2048
 
#define LINN_CREATE_BLOCK_NUM           8192
 
#define LINN_CREATE_BLOCKS_PER_GROUP    8192
 
#define LINN_CREATE_INODE_NUM           1024
 
#define LINN_CREATE_INODES_PER_GROUP    1024
 
#define BLOCKPTR(type,nr) (type *)(blocks + (super->blockSize * (nr)))
 
#define BLOCKS(sb,count) \
    ({ \
        if ((sb)->freeBlocksCount < (count)) \
        { \
            printf("%s: not enough free blocks remaining (%lu needed)\n", \
                    prog, (ulong)(count)); \
            exit(EXIT_FAILURE); \
        } \
        (sb)->freeBlocksCount -= (count); \
        ((sb)->blocksCount - (sb)->freeBlocksCount - (count)); \
     })
 
#define BLOCK(sb) \
    BLOCKS(sb, (ulong)1)
 
#define FILETYPE_FROM_ST(st) \
({ \
    FileSystem::FileType t = FileSystem::UnknownFile; \
    \
    switch ((st)->st_mode & S_IFMT) \
    { \
        case S_IFBLK:  t = FileSystem::BlockDeviceFile; break; \
        case S_IFCHR:  t = FileSystem::CharacterDeviceFile; break; \
        case S_IFIFO:  t = FileSystem::FIFOFile; break; \
        case S_IFREG:  t = FileSystem::RegularFile; break; \
        case S_IFDIR:  t = FileSystem::DirectoryFile; break; \
        case S_IFLNK:  t = FileSystem::SymlinkFile; break; \
        case S_IFSOCK: t = FileSystem::SocketFile; break; \
        default: break; \
    } \
    t; \
})
 
#define FILEMODE_FROM_ST(st) \
    (FileSystem::FileMode)((st)->st_mode & 0777)
 
class LinnCreate
{
  public:
 
    LinnCreate();
 
    int create(Size blockSize, Size blockNum, Size inodeNum);
 
    void setProgram(char *progName);
 
    void setImage(char *imageName);
 
    void setInput(char *inputName);
 
    void setExclude(char *pattern);
 
    void setVerbose(bool newVerbose);
 
  private:
 
    LinnInode * createInode(le32 inodeNum, FileSystem::FileType type, FileSystem::FileModes mode,
                            UserID uid = ZERO, GroupID gid = ZERO);
 
    le32 createInode(char *inputFile, struct stat *st);
 
    void insertEntry(le32 dirInode, le32 entryInode,
                     const char *name, FileSystem::FileType type);
 
    void insertDirectory(char *inputFile, le32 inodeNum, le32 parentNum);
 
    void insertFile(char *inputFile, LinnInode *inode,
                    struct stat *st);
 
    le32 insertIndirect(le32 *ptr, const le32 blockIndexNumber, const Size depth);
 
    int writeImage();
 
  private:
 
    char *prog;
 
    char *image;
 
    char *input;
 
    bool verbose;
 
    List<String *> excludes;
 
    LinnSuperBlock *super;
 
    u8 *blocks;
};
 
#endif /* __FILESYSTEM_LINN_CREATE_H */