chiche.h

Go to the documentation of this file.

/*
** chiche.h for  in /root/research/lseosr2a/programs/chiche
**
** Made Copyright (c)2004 Julien Quintard
** Login   <quinta_j@epita.fr>
**
** Started on  Tue Mar 30 13:19:22 2004 Julien Quintard
** Last update Tue Nov 16 14:07:44 2004 Vianney Rancurel
*/
#ifndef CHICHE_H
#define CHICHE_H        1
#include <libc.h>
#include <libide.h>
#include <libpart.h>
#include <libtimer.h>

#define BLKSZ                   512

/*
 * state entries
 */

#define CHICHE_UNUSED_ENTRIES   2

#define CHICHE_UNUSED           0x00    /* unused entry */
#define CHICHE_EOL              0x01    /* end of list */

/*
 * defines
 */

#define CHICHE_VERSION          1
#define CHICHE_START            2
#define CHICHE_BLKSZ            512
#define CHICHE_BPC              1       /* blocks per cluster */
#define CHICHE_CLUSTERSZ        (CHICHE_BPC * CHICHE_BLKSZ)
#define CHICHE_ENTRYSZ          sizeof(u_int32_t)
#define CHICHE_MAGIC            0xb00ba
#define CHICHE_RESERVED         0x10    /* always up to 1 */
#define CHICHE_CCACHESZ         8
#define CHICHE_MNGBLKS          2       /* unused blk + super blk */
#define CHICHE_SUPERBLK         1       /* superblock block location */
#define CHICHE_FAT              2       /* fat block location */
#define CHICHE_RDENT            0       /* root direntry located
                                           in first data cluster */
#define CHICHE_NAMESZ           31
#define CHICHE_DOTDOT           ".."
#define CHICHE_DOT              "."

#define CHICHE_ACCESS_MODE      0777

#define CHICHE_NOFLAG           0x0
#define CHICHE_FOLLOW_LINK      0x1
#define CHICHE_ACCESS           0x2

/*
 * chiche_write() flags
 */

#define CHICHE_RESTORE          1

/*
 * chiche_new_direntry() flags
 */

#define CHICHE_NOFLAGS          0x0
#define CHICHE_ALLOC_CLUSTER    0x1

/*
 * generic defines
 */

#define CHICHE_SYSCALLS         (1 << 0)
#define CHICHE_MISC             (1 << 1)
#define CHICHE_USH              (1 << 2)
#define CHICHE_RELEASE          (1 << 3)
#define CHICHE_STEP             (1 << 4)
#define CHICHE_DEBUG            (CHICHE_RELEASE)

#define CHICHE_FDTABSZ          1024
#define CHICHE_PSC              "/"     /* path separator character */

/*
 * chiche_poll_directory() return codes
 */

#define CHICHE_POLL_UNUSED      0x00
#define CHICHE_POLL_EOL         0x01
#define CHICHE_POLL_VALID       0x02
#define CHICHE_POLL_ERROR       0x03

/*
 * file system type
 */

#define CHICHE_FSTYPE           0xcd

/*
 * typedef
 */

typedef char **         t_path;

/*
 * link
 */

typedef struct          s_chiche_link
{
  u_int32_t             cluster;
  u_int32_t             no;
}                       t_chiche_link;

/*
 * direntry
 */

typedef struct          s_chiche_direntry
{

  char                  name[CHICHE_NAMESZ + 1];

#define CHICHE_ATTR_FILE        0x00000001
#define CHICHE_ATTR_DIR         0x00000002
#define CHICHE_ATTR_LINK        0x00000004

#define CHICHE_ATTR_ROOT        0x00000010

#define CHICHE_ATTR_SUID        0x00000020
#define CHICHE_ATTR_SGID        0x00000040
#define CHICHE_ATTR_STICKY      0x00000080

#define CHICHE_ATTR_UW          0x00000100
#define CHICHE_ATTR_UR          0x00000200
#define CHICHE_ATTR_UX          0x00000400
#define CHICHE_ATTR_GW          0x00000800
#define CHICHE_ATTR_GR          0x00001000
#define CHICHE_ATTR_GX          0x00002000
#define CHICHE_ATTR_OW          0x00004000
#define CHICHE_ATTR_OR          0x00008000
#define CHICHE_ATTR_OX          0x00001000

#define CHICHE_ROOT_ATTRIBUTES  (CHICHE_ATTR_DIR | CHICHE_ATTR_ROOT |   \
                                 CHICHE_ATTR_UW | CHICHE_ATTR_UR |      \
                                 CHICHE_ATTR_UX | CHICHE_ATTR_GR |      \
                                 CHICHE_ATTR_GX | CHICHE_ATTR_OX)

  u_int32_t             attr;
  u_int32_t             uid;
  u_int32_t             gid;
  u_int32_t             ctime;
  u_int32_t             atime;
  u_int32_t             mtime;
  u_int32_t             data;
  u_int32_t             datasz;
  u_int16_t             nclusters;
}                       t_chiche_direntry;

/*
 * superblock
 */

typedef struct          s_chiche_super
{
  u_int16_t             version;
  u_int16_t             clustersz;
  u_int32_t             magic;
  u_int32_t             fat;
  u_int32_t             fatsz;
  u_int32_t             data;
  u_int32_t             datasz;
  u_int32_t             reserved;
  u_int32_t             reservedsz;
  u_int32_t             rdent;
  u_int32_t             root;
}                       t_chiche_super;

/*
 * cluster cache entry
 */

typedef struct          s_chiche_cce
{
  u_int32_t             addr;
  char                  *data;
}                       t_chiche_cce;

/*
 * useful structure for updating directories
 */

typedef struct          s_chiche_dirupdate
{
  u_int32_t             cluster;
  u_int32_t             no;
}                       t_chiche_dirupdate;

/*
 * chiche core structure
 */

typedef struct          s_chiche
{

  /*
   * superblock image
   */

  t_chiche_super        super;

  /*
   * cache
   */

  t_chiche_cce          cache[CHICHE_CCACHESZ];
  u_int32_t             index;

  /*
   * owner of the mounted partition
   */

  u_int32_t             uid;
  u_int32_t             gid;

  /*
   * device
   */

  u_int32_t             dev;

  /*
   * part
   */

  u_int32_t             pdev;
  u_int32_t             id;
  u_int32_t             unit;

  u_int32_t             start;
  u_int32_t             size;

}                       t_chiche;

typedef struct          s_chiche_fde
{
  u_int8_t              state;
  u_int32_t             ino;
  u_int32_t             cluster;
  u_int32_t             no;
  u_int32_t             data;

  u_int32_t             block;
  off_t                 offset;
}                       t_chiche_fde;

typedef struct          s_chiche_common
{
  __cpu_simple_lock_t   lock;
}                       t_chiche_common;

/* PROTO chiche.c */
/* chiche.c */
int chiche_init_srv(void);
void chiche_waitfor_service(int gate);
int main(int argc, char **argv);
int chiche_cache_read(t_chiche *chiche, u_int32_t dev, u_int32_t addr, void *buffer, u_int32_t nblocks);
void chiche_cache_write(t_chiche *chiche, u_int32_t addr, void *buffer, u_int32_t nblocks);
int chiche_read(t_chiche *chiche, u_int32_t dev, u_int32_t block, u_int32_t off, void *data, u_int32_t bytes);
int chiche_write(t_chiche *chiche, u_int32_t dev, u_int32_t block, u_int32_t off, void *data, u_int32_t bytes, int restore);
int chiche_write_super(t_chiche *chiche);
int chiche_read_super(t_chiche *chiche);
u_int32_t chiche_nxt_cluster(t_chiche *chiche, u_int32_t cluster);
int chiche_poll_directory(t_chiche *chiche, t_chiche_direntry *direntry, u_int32_t *root, int *no);
int chiche_mkfs(t_chiche *chiche);
void chiche_dump_superblock(t_chiche_super *super);
u_int32_t chiche_pathsz(t_path path);
t_path chiche_reserve_path(t_chiche *chiche, char *upath, char *psc);
void chiche_release_path(t_chiche *chiche, t_path path);
void chiche_dump_path(t_chiche *chiche, t_path path);
void chiche_dump_cce(t_chiche *chiche, t_chiche_cce *cce);
int chiche_mount(t_chiche *chiche);
u_int32_t chiche_find_free_cluster(t_chiche *chiche);
int chiche_set_fat_entry(t_chiche *chiche, u_int32_t cluster, u_int32_t set);
void chiche_dump_direntry(t_chiche *chiche, t_chiche_direntry *direntry);
int chiche_fill_root_direntry(t_chiche *chiche, t_chiche_direntry *direntry);
int chiche_dir_from_path(t_chiche *chiche, t_path path, t_chiche_direntry *dir, t_chiche_dirupdate *du);
void chiche_set_mode(t_chiche *chiche, u_int32_t *attr, mode_t mode, u_int32_t more);
u_int32_t chiche_dirsz(t_chiche *chiche, int fd);
int chiche_new_direntry(t_chiche *chiche, t_path path, mode_t mode, u_int32_t attr, int flags);
int chiche_mkfile(t_chiche *chiche, char *upath, mode_t mode, int flags);
int chiche_mkdir(t_chiche *chiche, char *upath, mode_t mode);
int chiche_mksymlink(t_chiche *chiche, char *upath, mode_t mode);
int chiche_is_fde_valid(t_chiche *chiche, int fd);
void chiche_fill_fde(t_chiche *chiche, t_chiche_direntry *direntry, u_int32_t root, u_int32_t no, int fd);
int chiche_open(t_chiche *chiche, int fd, char *upath, int flags, int chflags);
int chiche_reserve_fde(t_chiche *chiche);
void chiche_release_fde(t_chiche *chiche, int fd);
int chiche_fstat(t_chiche *chiche, int fd, struct stat *stat);
int chiche_getdents(t_chiche *chiche, int fd, void *data, u_int32_t *nbytes);
int chiche_fchmod(t_chiche *chiche, int fd, mode_t mode);
int chiche_resize_dir(t_chiche *chiche, t_chiche_direntry *dir);
int chiche_clean_direntry(t_chiche *chiche, t_chiche_direntry *direntry);
int chiche_rename(t_chiche *chiche, char *uoldpath, int fd, char *unewpath);
int chiche_unlink(t_chiche *chiche, char *upath, int fd);
int chiche_rmdir(t_chiche *chiche, char *upath, int fd);
int chiche_exists(t_chiche *chiche, char *upath);
int chiche_append(t_chiche *chiche, int fd);
void sys_chiche_rename(t_tcb *caller_tcb);
void sys_chiche_fchmod(t_tcb *caller_tcb);
void sys_chiche_chmod(t_tcb *caller_tcb);
void sys_chiche_getdents(t_tcb *caller_tcb);
void sys_chiche_stat(t_tcb *caller_tcb);
void sys_chiche_fstat(t_tcb *caller_tcb);
void sys_chiche_close(t_tcb *caller_tcb);
void sys_chiche_open(t_tcb *caller_tcb);
void sys_chiche_unlink(t_tcb *caller_tcb);
void sys_chiche_rmdir(t_tcb *caller_tcb);
void sys_chiche_mkdir(t_tcb *caller_tcb);
void sys_chiche_umount(t_tcb *caller_tcb);
void sys_chiche_mount(t_tcb *caller_tcb);
void sys_chiche_mkfs(t_tcb *caller_tcb);
void sys_chiche_init(t_tcb *caller_tcb);
void do_sys_chiche(void);
void sys_chiche(void);
#endif

---