]>
Commit | Line | Data |
---|---|---|
293d7fbd SG |
1 | /* |
2 | * (C) Copyright 2011 - 2012 Samsung Electronics | |
3 | * EXT4 filesystem implementation in Uboot by | |
4 | * Uma Shankar <uma.shankar@samsung.com> | |
5 | * Manjunatha C Achar <a.manjunatha@samsung.com> | |
6 | * | |
7 | * ext4ls and ext4load : Based on ext2 ls and load support in Uboot. | |
8 | * Ext4 read optimization taken from Open-Moko | |
9 | * Qi bootloader | |
10 | * | |
11 | * (C) Copyright 2004 | |
12 | * esd gmbh <www.esd-electronics.com> | |
13 | * Reinhard Arlt <reinhard.arlt@esd-electronics.com> | |
14 | * | |
15 | * based on code from grub2 fs/ext2.c and fs/fshelp.c by | |
16 | * GRUB -- GRand Unified Bootloader | |
17 | * Copyright (C) 2003, 2004 Free Software Foundation, Inc. | |
18 | * | |
19 | * ext4write : Based on generic ext4 protocol. | |
20 | * | |
1a459660 | 21 | * SPDX-License-Identifier: GPL-2.0+ |
293d7fbd SG |
22 | */ |
23 | ||
24 | ||
25 | #include <common.h> | |
cf92e05c | 26 | #include <memalign.h> |
293d7fbd SG |
27 | #include <linux/stat.h> |
28 | #include <div64.h> | |
29 | #include "ext4_common.h" | |
30 | ||
58a9ecba MW |
31 | static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb) |
32 | { | |
33 | sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1); | |
34 | } | |
35 | ||
36 | static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb) | |
37 | { | |
38 | sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1); | |
39 | } | |
40 | ||
749e93ee SB |
41 | static inline void ext4fs_bg_free_inodes_inc |
42 | (struct ext2_block_group *bg, const struct ext_filesystem *fs) | |
58a9ecba | 43 | { |
749e93ee SB |
44 | uint32_t free_inodes = le16_to_cpu(bg->free_inodes); |
45 | if (fs->gdsize == 64) | |
46 | free_inodes += le16_to_cpu(bg->free_inodes_high) << 16; | |
47 | free_inodes++; | |
48 | ||
49 | bg->free_inodes = cpu_to_le16(free_inodes & 0xffff); | |
50 | if (fs->gdsize == 64) | |
51 | bg->free_inodes_high = cpu_to_le16(free_inodes >> 16); | |
58a9ecba MW |
52 | } |
53 | ||
749e93ee SB |
54 | static inline void ext4fs_bg_free_blocks_inc |
55 | (struct ext2_block_group *bg, const struct ext_filesystem *fs) | |
58a9ecba | 56 | { |
749e93ee SB |
57 | uint32_t free_blocks = le16_to_cpu(bg->free_blocks); |
58 | if (fs->gdsize == 64) | |
59 | free_blocks += le16_to_cpu(bg->free_blocks_high) << 16; | |
60 | free_blocks++; | |
61 | ||
62 | bg->free_blocks = cpu_to_le16(free_blocks & 0xffff); | |
63 | if (fs->gdsize == 64) | |
64 | bg->free_blocks_high = cpu_to_le16(free_blocks >> 16); | |
58a9ecba MW |
65 | } |
66 | ||
293d7fbd SG |
67 | static void ext4fs_update(void) |
68 | { | |
69 | short i; | |
70 | ext4fs_update_journal(); | |
71 | struct ext_filesystem *fs = get_fs(); | |
688d0e79 | 72 | struct ext2_block_group *bgd = NULL; |
293d7fbd SG |
73 | |
74 | /* update super block */ | |
75 | put_ext4((uint64_t)(SUPERBLOCK_SIZE), | |
76 | (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); | |
77 | ||
688d0e79 | 78 | /* update block bitmaps */ |
293d7fbd | 79 | for (i = 0; i < fs->no_blkgrp; i++) { |
688d0e79 SB |
80 | bgd = ext4fs_get_group_descriptor(fs, i); |
81 | bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i)); | |
82 | uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); | |
83 | put_ext4(b_bitmap_blk * fs->blksz, | |
293d7fbd SG |
84 | fs->blk_bmaps[i], fs->blksz); |
85 | } | |
86 | ||
688d0e79 | 87 | /* update inode bitmaps */ |
293d7fbd | 88 | for (i = 0; i < fs->no_blkgrp; i++) { |
688d0e79 SB |
89 | bgd = ext4fs_get_group_descriptor(fs, i); |
90 | uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs); | |
91 | put_ext4(i_bitmap_blk * fs->blksz, | |
293d7fbd SG |
92 | fs->inode_bmaps[i], fs->blksz); |
93 | } | |
94 | ||
95 | /* update the block group descriptor table */ | |
0550870b | 96 | put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz), |
293d7fbd SG |
97 | (struct ext2_block_group *)fs->gdtable, |
98 | (fs->blksz * fs->no_blk_pergdt)); | |
99 | ||
100 | ext4fs_dump_metadata(); | |
101 | ||
102 | gindex = 0; | |
103 | gd_index = 0; | |
104 | } | |
105 | ||
106 | int ext4fs_get_bgdtable(void) | |
107 | { | |
108 | int status; | |
293d7fbd | 109 | struct ext_filesystem *fs = get_fs(); |
688d0e79 SB |
110 | int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz); |
111 | fs->no_blk_pergdt = gdsize_total / fs->blksz; | |
293d7fbd SG |
112 | |
113 | /* allocate memory for gdtable */ | |
688d0e79 | 114 | fs->gdtable = zalloc(gdsize_total); |
293d7fbd SG |
115 | if (!fs->gdtable) |
116 | return -ENOMEM; | |
117 | /* read the group descriptor table */ | |
04735e9c FL |
118 | status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk, |
119 | 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable); | |
293d7fbd SG |
120 | if (status == 0) |
121 | goto fail; | |
122 | ||
123 | if (ext4fs_log_gdt(fs->gdtable)) { | |
124 | printf("Error in ext4fs_log_gdt\n"); | |
125 | return -1; | |
126 | } | |
127 | ||
128 | return 0; | |
129 | fail: | |
130 | free(fs->gdtable); | |
131 | fs->gdtable = NULL; | |
132 | ||
133 | return -1; | |
134 | } | |
135 | ||
136 | static void delete_single_indirect_block(struct ext2_inode *inode) | |
137 | { | |
138 | struct ext2_block_group *bgd = NULL; | |
139 | static int prev_bg_bmap_idx = -1; | |
58a9ecba | 140 | uint32_t blknr; |
293d7fbd SG |
141 | int remainder; |
142 | int bg_idx; | |
143 | int status; | |
58a9ecba | 144 | uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); |
293d7fbd SG |
145 | struct ext_filesystem *fs = get_fs(); |
146 | char *journal_buffer = zalloc(fs->blksz); | |
147 | if (!journal_buffer) { | |
148 | printf("No memory\n"); | |
149 | return; | |
150 | } | |
293d7fbd SG |
151 | |
152 | /* deleting the single indirect block associated with inode */ | |
153 | if (inode->b.blocks.indir_block != 0) { | |
58a9ecba MW |
154 | blknr = le32_to_cpu(inode->b.blocks.indir_block); |
155 | debug("SIPB releasing %u\n", blknr); | |
35dd055b ŁM |
156 | bg_idx = blknr / blk_per_grp; |
157 | if (fs->blksz == 1024) { | |
293d7fbd SG |
158 | remainder = blknr % blk_per_grp; |
159 | if (!remainder) | |
160 | bg_idx--; | |
161 | } | |
162 | ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); | |
688d0e79 SB |
163 | /* get block group descriptor table */ |
164 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
749e93ee | 165 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 166 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
167 | /* journal backup */ |
168 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 | 169 | uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); |
58a9ecba | 170 | status = ext4fs_devread( |
688d0e79 SB |
171 | b_bitmap_blk * fs->sect_perblk, |
172 | 0, fs->blksz, journal_buffer); | |
293d7fbd SG |
173 | if (status == 0) |
174 | goto fail; | |
688d0e79 | 175 | if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) |
293d7fbd SG |
176 | goto fail; |
177 | prev_bg_bmap_idx = bg_idx; | |
178 | } | |
179 | } | |
180 | fail: | |
181 | free(journal_buffer); | |
182 | } | |
183 | ||
184 | static void delete_double_indirect_block(struct ext2_inode *inode) | |
185 | { | |
186 | int i; | |
187 | short status; | |
188 | static int prev_bg_bmap_idx = -1; | |
58a9ecba | 189 | uint32_t blknr; |
293d7fbd SG |
190 | int remainder; |
191 | int bg_idx; | |
58a9ecba MW |
192 | uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); |
193 | __le32 *di_buffer = NULL; | |
194 | void *dib_start_addr = NULL; | |
293d7fbd SG |
195 | struct ext2_block_group *bgd = NULL; |
196 | struct ext_filesystem *fs = get_fs(); | |
197 | char *journal_buffer = zalloc(fs->blksz); | |
198 | if (!journal_buffer) { | |
199 | printf("No memory\n"); | |
200 | return; | |
201 | } | |
293d7fbd SG |
202 | |
203 | if (inode->b.blocks.double_indir_block != 0) { | |
204 | di_buffer = zalloc(fs->blksz); | |
205 | if (!di_buffer) { | |
206 | printf("No memory\n"); | |
207 | return; | |
208 | } | |
58a9ecba MW |
209 | dib_start_addr = di_buffer; |
210 | blknr = le32_to_cpu(inode->b.blocks.double_indir_block); | |
04735e9c FL |
211 | status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, |
212 | fs->blksz, (char *)di_buffer); | |
293d7fbd SG |
213 | for (i = 0; i < fs->blksz / sizeof(int); i++) { |
214 | if (*di_buffer == 0) | |
215 | break; | |
216 | ||
217 | debug("DICB releasing %u\n", *di_buffer); | |
58a9ecba | 218 | bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp; |
35dd055b | 219 | if (fs->blksz == 1024) { |
58a9ecba | 220 | remainder = le32_to_cpu(*di_buffer) % blk_per_grp; |
293d7fbd SG |
221 | if (!remainder) |
222 | bg_idx--; | |
223 | } | |
688d0e79 SB |
224 | /* get block group descriptor table */ |
225 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
58a9ecba | 226 | ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer), |
293d7fbd SG |
227 | fs->blk_bmaps[bg_idx], bg_idx); |
228 | di_buffer++; | |
749e93ee | 229 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 230 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
231 | /* journal backup */ |
232 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
233 | uint64_t b_bitmap_blk = |
234 | ext4fs_bg_get_block_id(bgd, fs); | |
235 | status = ext4fs_devread(b_bitmap_blk | |
293d7fbd SG |
236 | * fs->sect_perblk, 0, |
237 | fs->blksz, | |
238 | journal_buffer); | |
239 | if (status == 0) | |
240 | goto fail; | |
241 | ||
242 | if (ext4fs_log_journal(journal_buffer, | |
688d0e79 | 243 | b_bitmap_blk)) |
293d7fbd SG |
244 | goto fail; |
245 | prev_bg_bmap_idx = bg_idx; | |
246 | } | |
247 | } | |
248 | ||
249 | /* removing the parent double indirect block */ | |
58a9ecba | 250 | blknr = le32_to_cpu(inode->b.blocks.double_indir_block); |
35dd055b ŁM |
251 | bg_idx = blknr / blk_per_grp; |
252 | if (fs->blksz == 1024) { | |
293d7fbd SG |
253 | remainder = blknr % blk_per_grp; |
254 | if (!remainder) | |
255 | bg_idx--; | |
256 | } | |
688d0e79 SB |
257 | /* get block group descriptor table */ |
258 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
293d7fbd | 259 | ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); |
749e93ee | 260 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 261 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
262 | /* journal backup */ |
263 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
264 | uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); |
265 | status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
266 | 0, fs->blksz, journal_buffer); | |
293d7fbd SG |
267 | if (status == 0) |
268 | goto fail; | |
269 | ||
688d0e79 | 270 | if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) |
293d7fbd SG |
271 | goto fail; |
272 | prev_bg_bmap_idx = bg_idx; | |
273 | } | |
58a9ecba | 274 | debug("DIPB releasing %d\n", blknr); |
293d7fbd SG |
275 | } |
276 | fail: | |
58a9ecba | 277 | free(dib_start_addr); |
293d7fbd SG |
278 | free(journal_buffer); |
279 | } | |
280 | ||
281 | static void delete_triple_indirect_block(struct ext2_inode *inode) | |
282 | { | |
283 | int i, j; | |
284 | short status; | |
285 | static int prev_bg_bmap_idx = -1; | |
58a9ecba | 286 | uint32_t blknr; |
293d7fbd SG |
287 | int remainder; |
288 | int bg_idx; | |
58a9ecba MW |
289 | uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); |
290 | __le32 *tigp_buffer = NULL; | |
291 | void *tib_start_addr = NULL; | |
292 | __le32 *tip_buffer = NULL; | |
293 | void *tipb_start_addr = NULL; | |
293d7fbd SG |
294 | struct ext2_block_group *bgd = NULL; |
295 | struct ext_filesystem *fs = get_fs(); | |
296 | char *journal_buffer = zalloc(fs->blksz); | |
297 | if (!journal_buffer) { | |
298 | printf("No memory\n"); | |
299 | return; | |
300 | } | |
293d7fbd SG |
301 | |
302 | if (inode->b.blocks.triple_indir_block != 0) { | |
303 | tigp_buffer = zalloc(fs->blksz); | |
304 | if (!tigp_buffer) { | |
305 | printf("No memory\n"); | |
306 | return; | |
307 | } | |
58a9ecba MW |
308 | tib_start_addr = tigp_buffer; |
309 | blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); | |
04735e9c FL |
310 | status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, |
311 | fs->blksz, (char *)tigp_buffer); | |
293d7fbd SG |
312 | for (i = 0; i < fs->blksz / sizeof(int); i++) { |
313 | if (*tigp_buffer == 0) | |
314 | break; | |
315 | debug("tigp buffer releasing %u\n", *tigp_buffer); | |
316 | ||
317 | tip_buffer = zalloc(fs->blksz); | |
318 | if (!tip_buffer) | |
319 | goto fail; | |
58a9ecba MW |
320 | tipb_start_addr = tip_buffer; |
321 | status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) * | |
293d7fbd SG |
322 | fs->sect_perblk, 0, fs->blksz, |
323 | (char *)tip_buffer); | |
324 | for (j = 0; j < fs->blksz / sizeof(int); j++) { | |
58a9ecba | 325 | if (le32_to_cpu(*tip_buffer) == 0) |
293d7fbd | 326 | break; |
58a9ecba | 327 | bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp; |
35dd055b | 328 | if (fs->blksz == 1024) { |
58a9ecba | 329 | remainder = le32_to_cpu(*tip_buffer) % blk_per_grp; |
293d7fbd SG |
330 | if (!remainder) |
331 | bg_idx--; | |
332 | } | |
333 | ||
58a9ecba | 334 | ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer), |
293d7fbd SG |
335 | fs->blk_bmaps[bg_idx], |
336 | bg_idx); | |
337 | ||
338 | tip_buffer++; | |
688d0e79 SB |
339 | /* get block group descriptor table */ |
340 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
749e93ee | 341 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 342 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
343 | /* journal backup */ |
344 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
345 | uint64_t b_bitmap_blk = |
346 | ext4fs_bg_get_block_id(bgd, fs); | |
293d7fbd SG |
347 | status = |
348 | ext4fs_devread( | |
688d0e79 | 349 | b_bitmap_blk * |
293d7fbd SG |
350 | fs->sect_perblk, 0, |
351 | fs->blksz, | |
352 | journal_buffer); | |
353 | if (status == 0) | |
354 | goto fail; | |
355 | ||
356 | if (ext4fs_log_journal(journal_buffer, | |
688d0e79 | 357 | b_bitmap_blk)) |
293d7fbd SG |
358 | goto fail; |
359 | prev_bg_bmap_idx = bg_idx; | |
360 | } | |
361 | } | |
362 | free(tipb_start_addr); | |
363 | tipb_start_addr = NULL; | |
364 | ||
365 | /* | |
366 | * removing the grand parent blocks | |
367 | * which is connected to inode | |
368 | */ | |
58a9ecba | 369 | bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp; |
35dd055b | 370 | if (fs->blksz == 1024) { |
58a9ecba | 371 | remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp; |
293d7fbd SG |
372 | if (!remainder) |
373 | bg_idx--; | |
374 | } | |
58a9ecba | 375 | ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer), |
293d7fbd SG |
376 | fs->blk_bmaps[bg_idx], bg_idx); |
377 | ||
378 | tigp_buffer++; | |
688d0e79 SB |
379 | /* get block group descriptor table */ |
380 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
749e93ee | 381 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 382 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
383 | /* journal backup */ |
384 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
385 | uint64_t b_bitmap_blk = |
386 | ext4fs_bg_get_block_id(bgd, fs); | |
293d7fbd | 387 | memset(journal_buffer, '\0', fs->blksz); |
688d0e79 SB |
388 | status = ext4fs_devread(b_bitmap_blk * |
389 | fs->sect_perblk, 0, | |
390 | fs->blksz, | |
391 | journal_buffer); | |
293d7fbd SG |
392 | if (status == 0) |
393 | goto fail; | |
394 | ||
395 | if (ext4fs_log_journal(journal_buffer, | |
688d0e79 | 396 | b_bitmap_blk)) |
293d7fbd SG |
397 | goto fail; |
398 | prev_bg_bmap_idx = bg_idx; | |
399 | } | |
400 | } | |
401 | ||
402 | /* removing the grand parent triple indirect block */ | |
58a9ecba | 403 | blknr = le32_to_cpu(inode->b.blocks.triple_indir_block); |
35dd055b ŁM |
404 | bg_idx = blknr / blk_per_grp; |
405 | if (fs->blksz == 1024) { | |
293d7fbd SG |
406 | remainder = blknr % blk_per_grp; |
407 | if (!remainder) | |
408 | bg_idx--; | |
409 | } | |
410 | ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); | |
688d0e79 SB |
411 | /* get block group descriptor table */ |
412 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
749e93ee | 413 | ext4fs_bg_free_blocks_inc(bgd, fs); |
58a9ecba | 414 | ext4fs_sb_free_blocks_inc(fs->sb); |
293d7fbd SG |
415 | /* journal backup */ |
416 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
417 | uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); |
418 | status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
419 | 0, fs->blksz, journal_buffer); | |
293d7fbd SG |
420 | if (status == 0) |
421 | goto fail; | |
422 | ||
688d0e79 | 423 | if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) |
293d7fbd SG |
424 | goto fail; |
425 | prev_bg_bmap_idx = bg_idx; | |
426 | } | |
58a9ecba | 427 | debug("tigp buffer itself releasing %d\n", blknr); |
293d7fbd SG |
428 | } |
429 | fail: | |
430 | free(tib_start_addr); | |
431 | free(tipb_start_addr); | |
432 | free(journal_buffer); | |
433 | } | |
434 | ||
435 | static int ext4fs_delete_file(int inodeno) | |
436 | { | |
437 | struct ext2_inode inode; | |
438 | short status; | |
439 | int i; | |
440 | int remainder; | |
441 | long int blknr; | |
442 | int bg_idx; | |
443 | int ibmap_idx; | |
444 | char *read_buffer = NULL; | |
445 | char *start_block_address = NULL; | |
58a9ecba | 446 | uint32_t no_blocks; |
293d7fbd SG |
447 | |
448 | static int prev_bg_bmap_idx = -1; | |
449 | unsigned int inodes_per_block; | |
58a9ecba | 450 | uint32_t blkno; |
293d7fbd | 451 | unsigned int blkoff; |
58a9ecba MW |
452 | uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group); |
453 | uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group); | |
293d7fbd SG |
454 | struct ext2_inode *inode_buffer = NULL; |
455 | struct ext2_block_group *bgd = NULL; | |
456 | struct ext_filesystem *fs = get_fs(); | |
457 | char *journal_buffer = zalloc(fs->blksz); | |
458 | if (!journal_buffer) | |
459 | return -ENOMEM; | |
293d7fbd SG |
460 | status = ext4fs_read_inode(ext4fs_root, inodeno, &inode); |
461 | if (status == 0) | |
462 | goto fail; | |
463 | ||
464 | /* read the block no allocated to a file */ | |
58a9ecba MW |
465 | no_blocks = le32_to_cpu(inode.size) / fs->blksz; |
466 | if (le32_to_cpu(inode.size) % fs->blksz) | |
293d7fbd SG |
467 | no_blocks++; |
468 | ||
469 | if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) { | |
b779e029 SB |
470 | /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */ |
471 | struct ext4_extent_header *eh = | |
472 | (struct ext4_extent_header *) | |
473 | inode.b.blocks.dir_blocks; | |
474 | debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries); | |
293d7fbd | 475 | } else { |
293d7fbd SG |
476 | delete_single_indirect_block(&inode); |
477 | delete_double_indirect_block(&inode); | |
478 | delete_triple_indirect_block(&inode); | |
b779e029 | 479 | } |
293d7fbd | 480 | |
b779e029 SB |
481 | /* release data blocks */ |
482 | for (i = 0; i < no_blocks; i++) { | |
483 | blknr = read_allocated_block(&inode, i); | |
de9e8316 SB |
484 | if (blknr == 0) |
485 | continue; | |
486 | if (blknr < 0) | |
487 | goto fail; | |
b779e029 SB |
488 | bg_idx = blknr / blk_per_grp; |
489 | if (fs->blksz == 1024) { | |
490 | remainder = blknr % blk_per_grp; | |
491 | if (!remainder) | |
492 | bg_idx--; | |
493 | } | |
494 | ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], | |
495 | bg_idx); | |
496 | debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx); | |
293d7fbd | 497 | |
688d0e79 SB |
498 | /* get block group descriptor table */ |
499 | bgd = ext4fs_get_group_descriptor(fs, bg_idx); | |
749e93ee | 500 | ext4fs_bg_free_blocks_inc(bgd, fs); |
b779e029 SB |
501 | ext4fs_sb_free_blocks_inc(fs->sb); |
502 | /* journal backup */ | |
503 | if (prev_bg_bmap_idx != bg_idx) { | |
688d0e79 SB |
504 | uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs); |
505 | status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk, | |
b779e029 SB |
506 | 0, fs->blksz, |
507 | journal_buffer); | |
508 | if (status == 0) | |
509 | goto fail; | |
688d0e79 | 510 | if (ext4fs_log_journal(journal_buffer, b_bitmap_blk)) |
b779e029 SB |
511 | goto fail; |
512 | prev_bg_bmap_idx = bg_idx; | |
293d7fbd SG |
513 | } |
514 | } | |
515 | ||
b779e029 | 516 | /* release inode */ |
293d7fbd SG |
517 | /* from the inode no to blockno */ |
518 | inodes_per_block = fs->blksz / fs->inodesz; | |
519 | ibmap_idx = inodeno / inode_per_grp; | |
520 | ||
521 | /* get the block no */ | |
522 | inodeno--; | |
688d0e79 SB |
523 | /* get block group descriptor table */ |
524 | bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); | |
525 | blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
58a9ecba | 526 | (inodeno % inode_per_grp) / inodes_per_block; |
293d7fbd SG |
527 | |
528 | /* get the offset of the inode */ | |
529 | blkoff = ((inodeno) % inodes_per_block) * fs->inodesz; | |
530 | ||
531 | /* read the block no containing the inode */ | |
532 | read_buffer = zalloc(fs->blksz); | |
533 | if (!read_buffer) | |
534 | goto fail; | |
535 | start_block_address = read_buffer; | |
04735e9c | 536 | status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk, |
293d7fbd SG |
537 | 0, fs->blksz, read_buffer); |
538 | if (status == 0) | |
539 | goto fail; | |
540 | ||
541 | if (ext4fs_log_journal(read_buffer, blkno)) | |
542 | goto fail; | |
543 | ||
544 | read_buffer = read_buffer + blkoff; | |
545 | inode_buffer = (struct ext2_inode *)read_buffer; | |
87f9fdc0 | 546 | memset(inode_buffer, '\0', fs->inodesz); |
293d7fbd SG |
547 | |
548 | /* write the inode to original position in inode table */ | |
549 | if (ext4fs_put_metadata(start_block_address, blkno)) | |
550 | goto fail; | |
551 | ||
552 | /* update the respective inode bitmaps */ | |
553 | inodeno++; | |
554 | ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx); | |
749e93ee | 555 | ext4fs_bg_free_inodes_inc(bgd, fs); |
58a9ecba | 556 | ext4fs_sb_free_inodes_inc(fs->sb); |
293d7fbd SG |
557 | /* journal backup */ |
558 | memset(journal_buffer, '\0', fs->blksz); | |
688d0e79 | 559 | status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * |
293d7fbd SG |
560 | fs->sect_perblk, 0, fs->blksz, journal_buffer); |
561 | if (status == 0) | |
562 | goto fail; | |
688d0e79 | 563 | if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs))) |
293d7fbd SG |
564 | goto fail; |
565 | ||
566 | ext4fs_update(); | |
567 | ext4fs_deinit(); | |
8b454eee | 568 | ext4fs_reinit_global(); |
293d7fbd SG |
569 | |
570 | if (ext4fs_init() != 0) { | |
571 | printf("error in File System init\n"); | |
572 | goto fail; | |
573 | } | |
574 | ||
575 | free(start_block_address); | |
576 | free(journal_buffer); | |
577 | ||
578 | return 0; | |
579 | fail: | |
580 | free(start_block_address); | |
581 | free(journal_buffer); | |
582 | ||
583 | return -1; | |
584 | } | |
585 | ||
586 | int ext4fs_init(void) | |
587 | { | |
588 | short status; | |
589 | int i; | |
58a9ecba | 590 | uint32_t real_free_blocks = 0; |
293d7fbd SG |
591 | struct ext_filesystem *fs = get_fs(); |
592 | ||
593 | /* populate fs */ | |
594 | fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root); | |
50ce4c07 | 595 | fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz; |
293d7fbd SG |
596 | |
597 | /* get the superblock */ | |
598 | fs->sb = zalloc(SUPERBLOCK_SIZE); | |
599 | if (!fs->sb) | |
600 | return -ENOMEM; | |
50ce4c07 | 601 | if (!ext4_read_superblock((char *)fs->sb)) |
293d7fbd SG |
602 | goto fail; |
603 | ||
604 | /* init journal */ | |
605 | if (ext4fs_init_journal()) | |
606 | goto fail; | |
607 | ||
608 | /* get total no of blockgroups */ | |
609 | fs->no_blkgrp = (uint32_t)ext4fs_div_roundup( | |
58a9ecba MW |
610 | le32_to_cpu(ext4fs_root->sblock.total_blocks) |
611 | - le32_to_cpu(ext4fs_root->sblock.first_data_block), | |
612 | le32_to_cpu(ext4fs_root->sblock.blocks_per_group)); | |
293d7fbd SG |
613 | |
614 | /* get the block group descriptor table */ | |
615 | fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1); | |
616 | if (ext4fs_get_bgdtable() == -1) { | |
617 | printf("Error in getting the block group descriptor table\n"); | |
618 | goto fail; | |
619 | } | |
293d7fbd SG |
620 | |
621 | /* load all the available bitmap block of the partition */ | |
622 | fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *)); | |
623 | if (!fs->blk_bmaps) | |
624 | goto fail; | |
625 | for (i = 0; i < fs->no_blkgrp; i++) { | |
626 | fs->blk_bmaps[i] = zalloc(fs->blksz); | |
627 | if (!fs->blk_bmaps[i]) | |
628 | goto fail; | |
629 | } | |
630 | ||
631 | for (i = 0; i < fs->no_blkgrp; i++) { | |
688d0e79 SB |
632 | struct ext2_block_group *bgd = |
633 | ext4fs_get_group_descriptor(fs, i); | |
634 | status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) * | |
04735e9c | 635 | fs->sect_perblk, 0, |
293d7fbd SG |
636 | fs->blksz, (char *)fs->blk_bmaps[i]); |
637 | if (status == 0) | |
638 | goto fail; | |
639 | } | |
640 | ||
641 | /* load all the available inode bitmap of the partition */ | |
642 | fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *)); | |
643 | if (!fs->inode_bmaps) | |
644 | goto fail; | |
645 | for (i = 0; i < fs->no_blkgrp; i++) { | |
646 | fs->inode_bmaps[i] = zalloc(fs->blksz); | |
647 | if (!fs->inode_bmaps[i]) | |
648 | goto fail; | |
649 | } | |
650 | ||
651 | for (i = 0; i < fs->no_blkgrp; i++) { | |
688d0e79 SB |
652 | struct ext2_block_group *bgd = |
653 | ext4fs_get_group_descriptor(fs, i); | |
654 | status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) * | |
04735e9c | 655 | fs->sect_perblk, |
293d7fbd SG |
656 | 0, fs->blksz, |
657 | (char *)fs->inode_bmaps[i]); | |
658 | if (status == 0) | |
659 | goto fail; | |
660 | } | |
661 | ||
662 | /* | |
663 | * check filesystem consistency with free blocks of file system | |
664 | * some time we observed that superblock freeblocks does not match | |
665 | * with the blockgroups freeblocks when improper | |
666 | * reboot of a linux kernel | |
667 | */ | |
688d0e79 SB |
668 | for (i = 0; i < fs->no_blkgrp; i++) { |
669 | struct ext2_block_group *bgd = | |
670 | ext4fs_get_group_descriptor(fs, i); | |
671 | real_free_blocks = real_free_blocks + | |
672 | ext4fs_bg_get_free_blocks(bgd, fs); | |
673 | } | |
674 | if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb)) | |
675 | ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks); | |
293d7fbd SG |
676 | |
677 | return 0; | |
678 | fail: | |
679 | ext4fs_deinit(); | |
680 | ||
681 | return -1; | |
682 | } | |
683 | ||
684 | void ext4fs_deinit(void) | |
685 | { | |
686 | int i; | |
687 | struct ext2_inode inode_journal; | |
688 | struct journal_superblock_t *jsb; | |
58a9ecba | 689 | uint32_t blknr; |
293d7fbd | 690 | struct ext_filesystem *fs = get_fs(); |
58a9ecba | 691 | uint32_t new_feature_incompat; |
293d7fbd SG |
692 | |
693 | /* free journal */ | |
694 | char *temp_buff = zalloc(fs->blksz); | |
695 | if (temp_buff) { | |
696 | ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, | |
697 | &inode_journal); | |
698 | blknr = read_allocated_block(&inode_journal, | |
699 | EXT2_JOURNAL_SUPERBLOCK); | |
04735e9c | 700 | ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz, |
293d7fbd SG |
701 | temp_buff); |
702 | jsb = (struct journal_superblock_t *)temp_buff; | |
58a9ecba | 703 | jsb->s_start = 0; |
0550870b | 704 | put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz), |
293d7fbd SG |
705 | (struct journal_superblock_t *)temp_buff, fs->blksz); |
706 | free(temp_buff); | |
707 | } | |
708 | ext4fs_free_journal(); | |
709 | ||
710 | /* get the superblock */ | |
50ce4c07 | 711 | ext4_read_superblock((char *)fs->sb); |
58a9ecba MW |
712 | new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat); |
713 | new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; | |
714 | fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat); | |
293d7fbd SG |
715 | put_ext4((uint64_t)(SUPERBLOCK_SIZE), |
716 | (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE); | |
717 | free(fs->sb); | |
718 | fs->sb = NULL; | |
719 | ||
720 | if (fs->blk_bmaps) { | |
721 | for (i = 0; i < fs->no_blkgrp; i++) { | |
722 | free(fs->blk_bmaps[i]); | |
723 | fs->blk_bmaps[i] = NULL; | |
724 | } | |
725 | free(fs->blk_bmaps); | |
726 | fs->blk_bmaps = NULL; | |
727 | } | |
728 | ||
729 | if (fs->inode_bmaps) { | |
730 | for (i = 0; i < fs->no_blkgrp; i++) { | |
731 | free(fs->inode_bmaps[i]); | |
732 | fs->inode_bmaps[i] = NULL; | |
733 | } | |
734 | free(fs->inode_bmaps); | |
735 | fs->inode_bmaps = NULL; | |
736 | } | |
737 | ||
738 | ||
739 | free(fs->gdtable); | |
740 | fs->gdtable = NULL; | |
293d7fbd SG |
741 | /* |
742 | * reinitiliazed the global inode and | |
743 | * block bitmap first execution check variables | |
744 | */ | |
745 | fs->first_pass_ibmap = 0; | |
746 | fs->first_pass_bbmap = 0; | |
747 | fs->curr_inode_no = 0; | |
748 | fs->curr_blkno = 0; | |
749 | } | |
750 | ||
de9e8316 SB |
751 | /* |
752 | * Write data to filesystem blocks. Uses same optimization for | |
753 | * contigous sectors as ext4fs_read_file | |
754 | */ | |
293d7fbd SG |
755 | static int ext4fs_write_file(struct ext2_inode *file_inode, |
756 | int pos, unsigned int len, char *buf) | |
757 | { | |
758 | int i; | |
759 | int blockcnt; | |
58a9ecba | 760 | uint32_t filesize = le32_to_cpu(file_inode->size); |
293d7fbd | 761 | struct ext_filesystem *fs = get_fs(); |
50ce4c07 EE |
762 | int log2blksz = fs->dev_desc->log2blksz; |
763 | int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz; | |
293d7fbd SG |
764 | int previous_block_number = -1; |
765 | int delayed_start = 0; | |
766 | int delayed_extent = 0; | |
767 | int delayed_next = 0; | |
768 | char *delayed_buf = NULL; | |
769 | ||
770 | /* Adjust len so it we can't read past the end of the file. */ | |
771 | if (len > filesize) | |
772 | len = filesize; | |
773 | ||
774 | blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz; | |
775 | ||
776 | for (i = pos / fs->blksz; i < blockcnt; i++) { | |
777 | long int blknr; | |
778 | int blockend = fs->blksz; | |
779 | int skipfirst = 0; | |
780 | blknr = read_allocated_block(file_inode, i); | |
de9e8316 | 781 | if (blknr <= 0) |
293d7fbd SG |
782 | return -1; |
783 | ||
50ce4c07 | 784 | blknr = blknr << log2_fs_blocksize; |
293d7fbd SG |
785 | |
786 | if (blknr) { | |
787 | if (previous_block_number != -1) { | |
788 | if (delayed_next == blknr) { | |
789 | delayed_extent += blockend; | |
50ce4c07 | 790 | delayed_next += blockend >> log2blksz; |
293d7fbd | 791 | } else { /* spill */ |
50ce4c07 | 792 | put_ext4((uint64_t) |
0550870b | 793 | ((uint64_t)delayed_start << log2blksz), |
293d7fbd SG |
794 | delayed_buf, |
795 | (uint32_t) delayed_extent); | |
796 | previous_block_number = blknr; | |
797 | delayed_start = blknr; | |
798 | delayed_extent = blockend; | |
799 | delayed_buf = buf; | |
800 | delayed_next = blknr + | |
50ce4c07 | 801 | (blockend >> log2blksz); |
293d7fbd SG |
802 | } |
803 | } else { | |
804 | previous_block_number = blknr; | |
805 | delayed_start = blknr; | |
806 | delayed_extent = blockend; | |
807 | delayed_buf = buf; | |
808 | delayed_next = blknr + | |
50ce4c07 | 809 | (blockend >> log2blksz); |
293d7fbd SG |
810 | } |
811 | } else { | |
812 | if (previous_block_number != -1) { | |
813 | /* spill */ | |
0550870b | 814 | put_ext4((uint64_t) ((uint64_t)delayed_start << |
50ce4c07 EE |
815 | log2blksz), |
816 | delayed_buf, | |
293d7fbd SG |
817 | (uint32_t) delayed_extent); |
818 | previous_block_number = -1; | |
819 | } | |
820 | memset(buf, 0, fs->blksz - skipfirst); | |
821 | } | |
822 | buf += fs->blksz - skipfirst; | |
823 | } | |
824 | if (previous_block_number != -1) { | |
825 | /* spill */ | |
0550870b | 826 | put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz), |
293d7fbd SG |
827 | delayed_buf, (uint32_t) delayed_extent); |
828 | previous_block_number = -1; | |
829 | } | |
830 | ||
831 | return len; | |
832 | } | |
833 | ||
834 | int ext4fs_write(const char *fname, unsigned char *buffer, | |
835 | unsigned long sizebytes) | |
836 | { | |
837 | int ret = 0; | |
838 | struct ext2_inode *file_inode = NULL; | |
839 | unsigned char *inode_buffer = NULL; | |
840 | int parent_inodeno; | |
841 | int inodeno; | |
842 | time_t timestamp = 0; | |
843 | ||
844 | uint64_t bytes_reqd_for_file; | |
845 | unsigned int blks_reqd_for_file; | |
846 | unsigned int blocks_remaining; | |
847 | int existing_file_inodeno; | |
848 | char *temp_ptr = NULL; | |
849 | long int itable_blkno; | |
850 | long int parent_itable_blkno; | |
851 | long int blkoff; | |
852 | struct ext2_sblock *sblock = &(ext4fs_root->sblock); | |
853 | unsigned int inodes_per_block; | |
854 | unsigned int ibmap_idx; | |
688d0e79 | 855 | struct ext2_block_group *bgd = NULL; |
293d7fbd SG |
856 | struct ext_filesystem *fs = get_fs(); |
857 | ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256); | |
46a5707d | 858 | memset(filename, 0x00, 256); |
293d7fbd | 859 | |
87f9fdc0 | 860 | g_parent_inode = zalloc(fs->inodesz); |
293d7fbd SG |
861 | if (!g_parent_inode) |
862 | goto fail; | |
863 | ||
864 | if (ext4fs_init() != 0) { | |
865 | printf("error in File System init\n"); | |
866 | return -1; | |
867 | } | |
868 | inodes_per_block = fs->blksz / fs->inodesz; | |
869 | parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE); | |
870 | if (parent_inodeno == -1) | |
871 | goto fail; | |
872 | if (ext4fs_iget(parent_inodeno, g_parent_inode)) | |
873 | goto fail; | |
10a7a1b8 SB |
874 | /* do not mess up a directory using hash trees */ |
875 | if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) { | |
876 | printf("hash tree directory\n"); | |
877 | goto fail; | |
878 | } | |
293d7fbd | 879 | /* check if the filename is already present in root */ |
76a29519 | 880 | existing_file_inodeno = ext4fs_filename_unlink(filename); |
293d7fbd SG |
881 | if (existing_file_inodeno != -1) { |
882 | ret = ext4fs_delete_file(existing_file_inodeno); | |
883 | fs->first_pass_bbmap = 0; | |
884 | fs->curr_blkno = 0; | |
885 | ||
886 | fs->first_pass_ibmap = 0; | |
887 | fs->curr_inode_no = 0; | |
888 | if (ret) | |
889 | goto fail; | |
890 | } | |
891 | /* calucalate how many blocks required */ | |
892 | bytes_reqd_for_file = sizebytes; | |
893 | blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz); | |
894 | if (do_div(bytes_reqd_for_file, fs->blksz) != 0) { | |
895 | blks_reqd_for_file++; | |
896 | debug("total bytes for a file %u\n", blks_reqd_for_file); | |
897 | } | |
898 | blocks_remaining = blks_reqd_for_file; | |
899 | /* test for available space in partition */ | |
58a9ecba | 900 | if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) { |
293d7fbd SG |
901 | printf("Not enough space on partition !!!\n"); |
902 | goto fail; | |
903 | } | |
904 | ||
a0d767e2 SB |
905 | inodeno = ext4fs_update_parent_dentry(filename, FILETYPE_REG); |
906 | if (inodeno == -1) | |
907 | goto fail; | |
293d7fbd SG |
908 | /* prepare file inode */ |
909 | inode_buffer = zalloc(fs->inodesz); | |
910 | if (!inode_buffer) | |
911 | goto fail; | |
912 | file_inode = (struct ext2_inode *)inode_buffer; | |
58a9ecba MW |
913 | file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | |
914 | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH); | |
293d7fbd | 915 | /* ToDo: Update correct time */ |
58a9ecba MW |
916 | file_inode->mtime = cpu_to_le32(timestamp); |
917 | file_inode->atime = cpu_to_le32(timestamp); | |
918 | file_inode->ctime = cpu_to_le32(timestamp); | |
919 | file_inode->nlinks = cpu_to_le16(1); | |
920 | file_inode->size = cpu_to_le32(sizebytes); | |
293d7fbd SG |
921 | |
922 | /* Allocate data blocks */ | |
923 | ext4fs_allocate_blocks(file_inode, blocks_remaining, | |
924 | &blks_reqd_for_file); | |
58a9ecba MW |
925 | file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >> |
926 | fs->dev_desc->log2blksz); | |
293d7fbd SG |
927 | |
928 | temp_ptr = zalloc(fs->blksz); | |
929 | if (!temp_ptr) | |
930 | goto fail; | |
58a9ecba | 931 | ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); |
293d7fbd | 932 | inodeno--; |
688d0e79 SB |
933 | bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); |
934 | itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
7f101be3 | 935 | (inodeno % le32_to_cpu(sblock->inodes_per_group)) / |
293d7fbd SG |
936 | inodes_per_block; |
937 | blkoff = (inodeno % inodes_per_block) * fs->inodesz; | |
04735e9c FL |
938 | ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz, |
939 | temp_ptr); | |
293d7fbd SG |
940 | if (ext4fs_log_journal(temp_ptr, itable_blkno)) |
941 | goto fail; | |
942 | ||
943 | memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz); | |
944 | if (ext4fs_put_metadata(temp_ptr, itable_blkno)) | |
945 | goto fail; | |
946 | /* copy the file content into data blocks */ | |
947 | if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) { | |
948 | printf("Error in copying content\n"); | |
de9e8316 | 949 | /* FIXME: Deallocate data blocks */ |
293d7fbd SG |
950 | goto fail; |
951 | } | |
58a9ecba | 952 | ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group); |
293d7fbd | 953 | parent_inodeno--; |
688d0e79 SB |
954 | bgd = ext4fs_get_group_descriptor(fs, ibmap_idx); |
955 | parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) + | |
293d7fbd | 956 | (parent_inodeno % |
7f101be3 | 957 | le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block; |
293d7fbd SG |
958 | blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; |
959 | if (parent_itable_blkno != itable_blkno) { | |
960 | memset(temp_ptr, '\0', fs->blksz); | |
04735e9c | 961 | ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk, |
293d7fbd SG |
962 | 0, fs->blksz, temp_ptr); |
963 | if (ext4fs_log_journal(temp_ptr, parent_itable_blkno)) | |
964 | goto fail; | |
965 | ||
87f9fdc0 | 966 | memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); |
293d7fbd SG |
967 | if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno)) |
968 | goto fail; | |
293d7fbd SG |
969 | } else { |
970 | /* | |
971 | * If parent and child fall in same inode table block | |
972 | * both should be kept in 1 buffer | |
973 | */ | |
87f9fdc0 | 974 | memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz); |
293d7fbd SG |
975 | gd_index--; |
976 | if (ext4fs_put_metadata(temp_ptr, itable_blkno)) | |
977 | goto fail; | |
293d7fbd SG |
978 | } |
979 | ext4fs_update(); | |
980 | ext4fs_deinit(); | |
981 | ||
982 | fs->first_pass_bbmap = 0; | |
983 | fs->curr_blkno = 0; | |
984 | fs->first_pass_ibmap = 0; | |
985 | fs->curr_inode_no = 0; | |
986 | free(inode_buffer); | |
987 | free(g_parent_inode); | |
87a40b6e | 988 | free(temp_ptr); |
293d7fbd SG |
989 | g_parent_inode = NULL; |
990 | ||
991 | return 0; | |
992 | fail: | |
993 | ext4fs_deinit(); | |
994 | free(inode_buffer); | |
995 | free(g_parent_inode); | |
87a40b6e | 996 | free(temp_ptr); |
293d7fbd SG |
997 | g_parent_inode = NULL; |
998 | ||
999 | return -1; | |
1000 | } | |
9f12cd0e SR |
1001 | |
1002 | int ext4_write_file(const char *filename, void *buf, loff_t offset, | |
1003 | loff_t len, loff_t *actwrite) | |
1004 | { | |
1005 | int ret; | |
1006 | ||
1007 | if (offset != 0) { | |
1008 | printf("** Cannot support non-zero offset **\n"); | |
1009 | return -1; | |
1010 | } | |
1011 | ||
9f12cd0e | 1012 | ret = ext4fs_write(filename, buf, len); |
9f12cd0e SR |
1013 | if (ret) { |
1014 | printf("** Error ext4fs_write() **\n"); | |
1015 | goto fail; | |
1016 | } | |
9f12cd0e | 1017 | |
22b7509e PM |
1018 | *actwrite = len; |
1019 | ||
9f12cd0e SR |
1020 | return 0; |
1021 | ||
1022 | fail: | |
22b7509e | 1023 | *actwrite = 0; |
9f12cd0e SR |
1024 | |
1025 | return -1; | |
1026 | } |