jffs2 파일 시스템 관련 질문

 26 struct jffs2_sb_info {
 27         struct mtd_info *mtd;
 28 
 29         uint32_t highest_ino;
 30         uint32_t checked_ino;
 31 
 32         unsigned int flags;
 33 
 34         struct task_struct *gc_task;    /* GC task struct */
 35         struct completion gc_thread_start; /* GC thread start completion */
 36         struct completion gc_thread_exit; /* GC thread exit completion port */
 37 
 38         struct semaphore alloc_sem;     /* Used to protect all the following
 39                                            fields, and also to protect against
 40                                            out-of-order writing of nodes. And GC. */
 41         uint32_t cleanmarker_size;      /* Size of an _inline_ CLEANMARKER
 42                                          (i.e. zero for OOB CLEANMARKER */
 43 
 44         uint32_t flash_size;
 45         uint32_t used_size;
 46         uint32_t dirty_size;
 47         uint32_t wasted_size;
 48         uint32_t free_size;
 49         uint32_t erasing_size;
 50         uint32_t bad_size;
 51         uint32_t sector_size;
 52         uint32_t unchecked_size;
 53 
 54         uint32_t nr_free_blocks;
 55         uint32_t nr_erasing_blocks;
 56 
 57         /* Number of free blocks there must be before we... */
 58         uint8_t resv_blocks_write;      /* ... allow a normal filesystem write */
 59         uint8_t resv_blocks_deletion;   /* ... allow a normal filesystem deletion */
 60         uint8_t resv_blocks_gctrigger;  /* ... wake up the GC thread */
 61         uint8_t resv_blocks_gcbad;      /* ... pick a block from the bad_list to GC */
 62         uint8_t resv_blocks_gcmerge;    /* ... merge pages when garbage collecting */
 63 
 64         uint32_t nospc_dirty_size;
 65 
 66         uint32_t nr_blocks;
 67         struct jffs2_eraseblock *blocks;        /* The whole array of blocks. Used for getting blocks
 68                                                  * from the offset (blocks[ofs / sector_size]) */
 69         struct jffs2_eraseblock *nextblock;     /* The block we're currently filling */
 70 
 71         struct jffs2_eraseblock *gcblock;       /* The block we're currently garbage-collecting */
 72 
 73         struct list_head clean_list;            /* Blocks 100% full of clean data */
 74         struct list_head very_dirty_list;       /* Blocks with lots of dirty space */
 75         struct list_head dirty_list;            /* Blocks with some dirty space */
 76         struct list_head erasable_list;         /* Blocks which are completely dirty, and need erasing */
 77         struct list_head erasable_pending_wbuf_list;    /* Blocks which need erasing but only after the current wbuf is flushed */
 78         struct list_head erasing_list;          /* Blocks which are currently erasing */
 79         struct list_head erase_pending_list;    /* Blocks which need erasing now */
 80         struct list_head erase_complete_list;   /* Blocks which are erased and need the clean marker written to them */
 81         struct list_head free_list;             /* Blocks which are free and ready to be used */
 82         struct list_head bad_list;              /* Bad blocks. */
 83         struct list_head bad_used_list;         /* Bad blocks with valid data in. */
 84 
 85         spinlock_t erase_completion_lock;       /* Protect free_list and erasing_list
 86                                                    against erase completion handler */
 87         wait_queue_head_t erase_wait;           /* For waiting for erases to complete */
 88 
 89         wait_queue_head_t inocache_wq;
 90         struct jffs2_inode_cache **inocache_list;
 91         spinlock_t inocache_lock;
 92 
 93         /* Sem to allow jffs2_garbage_collect_deletion_dirent to
 94            drop the erase_completion_lock while it's holding a pointer
 95            to an obsoleted node. I don't like this. Alternatives welcomed. */
 96         struct semaphore erase_free_sem;
 97 
 98         uint32_t wbuf_pagesize; /* 0 for NOR and other flashes with no wbuf */
 99 
100 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
101         /* Write-behind buffer for NAND flash */
102         unsigned char *wbuf;
103         uint32_t wbuf_ofs;
104         uint32_t wbuf_len;
105         struct jffs2_inodirty *wbuf_inodes;
106 
107         struct rw_semaphore wbuf_sem;   /* Protects the write buffer */
108 
109         /* Information about out-of-band area usage... */
110         struct nand_oobinfo *oobinfo;
111         uint32_t badblock_pos;
112         uint32_t fsdata_pos;
113         uint32_t fsdata_len;
114 #endif
115 
116         struct jffs2_summary *summary;          /* Summary information */
117 
118         /* OS-private pointer for getting back to master superblock info */
119         void *os_priv;
120 };

 75 struct jffs2_raw_node_ref
 76 {
 77         struct jffs2_raw_node_ref *next_in_ino; /* Points to the next raw_node_ref
 78                 for this inode. If this is the last, it points to the inode_cache
 79                 for this inode instead. The inode_cache will have NULL in the first
 80                 word so you know when you've got there :) */
 81         struct jffs2_raw_node_ref *next_phys;
 82         uint32_t flash_offset;
 83         uint32_t __totlen; /* This may die; use ref_totlen(c, jeb, ) below */
 84 };

183 struct jffs2_eraseblock
184 {
185         struct list_head list;
186         int bad_count;
187         uint32_t offset;                /* of this block in the MTD */
188 
189         uint32_t unchecked_size;
190         uint32_t used_size;
191         uint32_t dirty_size;
192         uint32_t wasted_size;
193         uint32_t free_size;     /* Note that sector_size - free_size
194                                    is the address of the first free space */
195         struct jffs2_raw_node_ref *first_node;
196         struct jffs2_raw_node_ref *last_node;
197 
198         struct jffs2_raw_node_ref *gc_node;     /* Next node to be garbage collected */
199 };