source: mainline/uspace/lib/ext4/libext4_ialloc.c@ a2fa350

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a2fa350 was 1ac1ab4, checked in by Frantisek Princ <frantisek.princ@…>, 13 years ago

simplied headers of more functions, improved bg_ref and inode_ref structures, added block group checksumming and fixed bug in block_group values updating

  • Property mode set to 100644
File size: 6.4 KB
Line 
1/*
2 * Copyright (c) 2011 Frantisek Princ
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libext4
30 * @{
31 */
32
33/**
34 * @file libext4_ialloc.c
35 * @brief Inode (de)allocation operations.
36 */
37
38#include <errno.h>
39#include <time.h>
40#include "libext4.h"
41
42static uint32_t ext4_ialloc_inode2index_in_group(ext4_superblock_t *sb,
43 uint32_t inode)
44{
45 uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
46 return (inode - 1) % inodes_per_group;
47}
48
49static uint32_t ext4_ialloc_index_in_group2inode(ext4_superblock_t *sb,
50 uint32_t index, uint32_t bgid)
51{
52 uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
53 return bgid * inodes_per_group + (index + 1);
54}
55
56static uint32_t ext4_ialloc_get_bgid_of_inode(ext4_superblock_t *sb,
57 uint32_t inode)
58{
59 uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
60 return (inode - 1) / inodes_per_group;
61
62}
63
64
65int ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir)
66{
67 int rc;
68
69 ext4_superblock_t *sb = fs->superblock;
70
71 uint32_t block_group = ext4_ialloc_get_bgid_of_inode(sb, index);
72
73 ext4_block_group_ref_t *bg_ref;
74 rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
75 if (rc != EOK) {
76 return rc;
77 }
78
79 uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
80 bg_ref->block_group, sb);
81 block_t *bitmap_block;
82 rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, BLOCK_FLAGS_NONE);
83 if (rc != EOK) {
84 return rc;
85 }
86
87 uint32_t index_in_group = ext4_ialloc_inode2index_in_group(sb, index);
88 ext4_bitmap_free_bit(bitmap_block->data, index_in_group);
89 bitmap_block->dirty = true;
90
91 rc = block_put(bitmap_block);
92 if (rc != EOK) {
93 // Error in saving bitmap
94 ext4_filesystem_put_block_group_ref(bg_ref);
95 return rc;
96 }
97
98 // if inode is directory, decrement used directories count
99 if (is_dir) {
100 uint32_t bg_used_dirs = ext4_block_group_get_used_dirs_count(
101 bg_ref->block_group, sb);
102 bg_used_dirs--;
103 ext4_block_group_set_used_dirs_count(
104 bg_ref->block_group, sb, bg_used_dirs);
105 }
106
107 // Update block group free inodes count
108 uint32_t free_inodes = ext4_block_group_get_free_inodes_count(
109 bg_ref->block_group, sb);
110 free_inodes++;
111 ext4_block_group_set_free_inodes_count(bg_ref->block_group,
112 sb, free_inodes);
113
114 uint32_t unused_inodes = ext4_block_group_get_itable_unused(
115 bg_ref->block_group, sb);
116 unused_inodes++;
117 ext4_block_group_set_itable_unused(bg_ref->block_group, sb, unused_inodes);
118
119
120 bg_ref->dirty = true;
121
122 rc = ext4_filesystem_put_block_group_ref(bg_ref);
123 if (rc != EOK) {
124 return rc;
125 }
126
127 // Update superblock free inodes count
128 uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb);
129 sb_free_inodes++;
130 ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
131
132 return EOK;
133}
134
135int ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir)
136{
137 int rc;
138
139 ext4_superblock_t *sb = fs->superblock;
140
141 uint32_t bgid = 0;
142 uint32_t bg_count = ext4_superblock_get_block_group_count(sb);
143 uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb);
144 uint32_t avg_free_inodes = sb_free_inodes / bg_count;
145
146 while (bgid < bg_count) {
147
148 ext4_block_group_ref_t *bg_ref;
149 rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref);
150 if (rc != EOK) {
151 return rc;
152 }
153 ext4_block_group_t *bg = bg_ref->block_group;
154
155 uint32_t free_blocks = ext4_block_group_get_free_blocks_count(bg, sb);
156 uint32_t free_inodes = ext4_block_group_get_free_inodes_count(bg, sb);
157 uint32_t used_dirs = ext4_block_group_get_used_dirs_count(bg, sb);
158
159 if ((free_inodes >= avg_free_inodes) && (free_blocks > 0)) {
160
161 uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
162 bg_ref->block_group, sb);
163
164 block_t *bitmap_block;
165 rc = block_get(&bitmap_block, fs->device,
166 bitmap_block_addr, BLOCK_FLAGS_NONE);
167 if (rc != EOK) {
168 return rc;
169 }
170
171 // Alloc bit
172 uint32_t inodes_in_group = ext4_superblock_get_inodes_in_group(sb, bgid);
173 uint32_t index_in_group;
174 rc = ext4_bitmap_find_free_bit_and_set(
175 bitmap_block->data, 0, &index_in_group, inodes_in_group);
176
177 // TODO check
178 if (rc == ENOSPC) {
179 block_put(bitmap_block);
180 ext4_filesystem_put_block_group_ref(bg_ref);
181 continue;
182 }
183
184 bitmap_block->dirty = true;
185
186 rc = block_put(bitmap_block);
187 if (rc != EOK) {
188 return rc;
189 }
190
191 // Modify filesystem counters
192 free_inodes--;
193 ext4_block_group_set_free_inodes_count(bg, sb, free_inodes);
194
195 uint16_t unused_inodes = ext4_block_group_get_itable_unused(bg, sb);
196 unused_inodes--;
197 ext4_block_group_set_itable_unused(bg, sb, unused_inodes);
198
199 if (is_dir) {
200 used_dirs++;
201 ext4_block_group_set_used_dirs_count(bg, sb, used_dirs);
202 }
203
204 bg_ref->dirty = true;
205
206 rc = ext4_filesystem_put_block_group_ref(bg_ref);
207 if (rc != EOK) {
208 // TODO
209 EXT4FS_DBG("ERRRRR");
210 }
211
212 sb_free_inodes--;
213 ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
214
215 *index = ext4_ialloc_index_in_group2inode(sb, index_in_group, bgid);
216
217 return EOK;
218
219 }
220
221 // Not modified
222 ext4_filesystem_put_block_group_ref(bg_ref);
223 ++bgid;
224 }
225
226 return ENOSPC;
227}
228
229/**
230 * @}
231 */
Note: See TracBrowser for help on using the repository browser.