source: mainline/uspace/lib/ext4/libext4_directory_index.c@ f577058

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

added (not complete) mechanism for splitting data block in directory index
  • Property mode set to 100644
File size: 18.5 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_directory_index.c
35 * @brief Ext4 directory index operations.
36 */
37
38#include <byteorder.h>
39#include <errno.h>
40#include <malloc.h>
41#include <sort.h>
42#include <string.h>
43#include "libext4.h"
44
45
46uint8_t ext4_directory_dx_root_info_get_hash_version(
47 ext4_directory_dx_root_info_t *root_info)
48{
49 return root_info->hash_version;
50}
51
52void ext4_directory_dx_root_info_set_hash_version(
53 ext4_directory_dx_root_info_t *root_info, uint8_t version)
54{
55 root_info->hash_version = version;
56}
57
58uint8_t ext4_directory_dx_root_info_get_info_length(
59 ext4_directory_dx_root_info_t *root_info)
60{
61 return root_info->info_length;
62}
63
64void ext4_directory_dx_root_info_set_info_length(
65 ext4_directory_dx_root_info_t *root_info, uint8_t info_length)
66{
67 root_info->info_length = info_length;
68}
69
70uint8_t ext4_directory_dx_root_info_get_indirect_levels(
71 ext4_directory_dx_root_info_t *root_info)
72{
73 return root_info->indirect_levels;
74}
75
76void ext4_directory_dx_root_info_set_indirect_levels(
77 ext4_directory_dx_root_info_t *root_info, uint8_t levels)
78{
79 root_info->indirect_levels = levels;
80}
81
82uint16_t ext4_directory_dx_countlimit_get_limit(
83 ext4_directory_dx_countlimit_t *countlimit)
84{
85 return uint16_t_le2host(countlimit->limit);
86}
87
88void ext4_directory_dx_countlimit_set_limit(
89 ext4_directory_dx_countlimit_t *countlimit, uint16_t limit)
90{
91 countlimit->limit = host2uint16_t_le(limit);
92}
93
94uint16_t ext4_directory_dx_countlimit_get_count(
95 ext4_directory_dx_countlimit_t *countlimit)
96{
97 return uint16_t_le2host(countlimit->count);
98}
99
100void ext4_directory_dx_countlimit_set_count(
101 ext4_directory_dx_countlimit_t *countlimit, uint16_t count)
102{
103 countlimit->count = host2uint16_t_le(count);
104}
105
106uint32_t ext4_directory_dx_entry_get_hash(ext4_directory_dx_entry_t *entry)
107{
108 return uint32_t_le2host(entry->hash);
109}
110
111void ext4_directory_dx_entry_set_hash(ext4_directory_dx_entry_t *entry,
112 uint32_t hash)
113{
114 entry->hash = host2uint32_t_le(hash);
115}
116
117uint32_t ext4_directory_dx_entry_get_block(ext4_directory_dx_entry_t *entry)
118{
119 return uint32_t_le2host(entry->block);
120}
121
122void ext4_directory_dx_entry_set_block(ext4_directory_dx_entry_t *entry,
123 uint32_t block)
124{
125 entry->block = host2uint32_t_le(block);
126}
127
128
129/**************************************************************************/
130
131
132static int ext4_directory_hinfo_init(ext4_hash_info_t *hinfo, block_t *root_block,
133 ext4_superblock_t *sb, size_t name_len, const char *name)
134{
135
136 ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data;
137
138 if (root->info.hash_version != EXT4_HASH_VERSION_TEA &&
139 root->info.hash_version != EXT4_HASH_VERSION_HALF_MD4 &&
140 root->info.hash_version != EXT4_HASH_VERSION_LEGACY) {
141 return EXT4_ERR_BAD_DX_DIR;
142 }
143
144 // Check unused flags
145 if (root->info.unused_flags != 0) {
146 EXT4FS_DBG("ERR: unused_flags = \%u", root->info.unused_flags);
147 return EXT4_ERR_BAD_DX_DIR;
148 }
149
150 // Check indirect levels
151 if (root->info.indirect_levels > 1) {
152 EXT4FS_DBG("ERR: indirect_levels = \%u", root->info.indirect_levels);
153 return EXT4_ERR_BAD_DX_DIR;
154 }
155
156 uint32_t block_size = ext4_superblock_get_block_size(sb);
157
158 uint32_t entry_space = block_size;
159 entry_space -= 2 * sizeof(ext4_directory_dx_dot_entry_t);
160 entry_space -= sizeof(ext4_directory_dx_root_info_t);
161 entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
162
163 uint16_t limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)&root->entries);
164 if (limit != entry_space) {
165 return EXT4_ERR_BAD_DX_DIR;
166 }
167
168 hinfo->hash_version = ext4_directory_dx_root_info_get_hash_version(&root->info);
169 if ((hinfo->hash_version <= EXT4_HASH_VERSION_TEA)
170 && (ext4_superblock_has_flag(sb, EXT4_SUPERBLOCK_FLAGS_UNSIGNED_HASH))) {
171 // 3 is magic from ext4 linux implementation
172 hinfo->hash_version += 3;
173 }
174
175 hinfo->seed = ext4_superblock_get_hash_seed(sb);
176
177 if (name) {
178 ext4_hash_string(hinfo, name_len, name);
179 }
180
181 return EOK;
182}
183
184static int ext4_directory_dx_get_leaf(ext4_hash_info_t *hinfo,
185 ext4_filesystem_t *fs, ext4_inode_t *inode, block_t *root_block,
186 ext4_directory_dx_block_t **dx_block, ext4_directory_dx_block_t *dx_blocks)
187{
188 int rc;
189
190 ext4_directory_dx_block_t *tmp_dx_block = dx_blocks;
191
192 ext4_directory_dx_root_t *root = (ext4_directory_dx_root_t *)root_block->data;
193 ext4_directory_dx_entry_t *entries = (ext4_directory_dx_entry_t *)&root->entries;
194
195 uint16_t limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
196 uint8_t indirect_level = ext4_directory_dx_root_info_get_indirect_levels(&root->info);
197
198 block_t *tmp_block = root_block;
199 ext4_directory_dx_entry_t *p, *q, *m, *at;
200 while (true) {
201
202 uint16_t count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)entries);
203 if ((count == 0) || (count > limit)) {
204 return EXT4_ERR_BAD_DX_DIR;
205 }
206
207 p = entries + 1;
208 q = entries + count - 1;
209
210 while (p <= q) {
211 m = p + (q - p) / 2;
212 if (ext4_directory_dx_entry_get_hash(m) > hinfo->hash) {
213 q = m - 1;
214 } else {
215 p = m + 1;
216 }
217 }
218
219 at = p - 1;
220
221 tmp_dx_block->block = tmp_block;
222 tmp_dx_block->entries = entries;
223 tmp_dx_block->position = at;
224
225 if (indirect_level == 0) {
226 *dx_block = tmp_dx_block;
227 return EOK;
228 }
229
230 uint32_t next_block = ext4_directory_dx_entry_get_block(at);
231
232 indirect_level--;
233
234 uint32_t fblock;
235 rc = ext4_filesystem_get_inode_data_block_index(fs, inode, next_block, &fblock);
236 if (rc != EOK) {
237 return rc;
238 }
239
240 rc = block_get(&tmp_block, fs->device, fblock, BLOCK_FLAGS_NONE);
241 if (rc != EOK) {
242 return rc;
243 }
244
245 entries = ((ext4_directory_dx_node_t *) tmp_block->data)->entries;
246 limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
247
248 uint16_t entry_space = ext4_superblock_get_block_size(fs->superblock)
249 - sizeof(ext4_directory_dx_dot_entry_t);
250 entry_space = entry_space / sizeof(ext4_directory_dx_entry_t);
251
252
253 if (limit != entry_space) {
254 block_put(tmp_block);
255 return EXT4_ERR_BAD_DX_DIR;
256 }
257
258 ++tmp_dx_block;
259 }
260
261 // Unreachable
262 return EOK;
263}
264
265
266static int ext4_directory_dx_find_dir_entry(block_t *block,
267 ext4_superblock_t *sb, size_t name_len, const char *name,
268 ext4_directory_entry_ll_t **res_entry, aoff64_t *block_offset)
269{
270
271 aoff64_t offset = 0;
272 ext4_directory_entry_ll_t *dentry = (ext4_directory_entry_ll_t *)block->data;
273 uint8_t *addr_limit = block->data + ext4_superblock_get_block_size(sb);
274
275 while ((uint8_t *)dentry < addr_limit) {
276
277 if ((uint8_t*) dentry + name_len > addr_limit) {
278 break;
279 }
280
281 if (dentry->inode != 0) {
282 if (name_len == ext4_directory_entry_ll_get_name_length(sb, dentry)) {
283 // Compare names
284 if (bcmp((uint8_t *)name, dentry->name, name_len) == 0) {
285 *block_offset = offset;
286 *res_entry = dentry;
287 return 1;
288 }
289 }
290 }
291
292
293 // Goto next entry
294 uint16_t dentry_len = ext4_directory_entry_ll_get_entry_length(dentry);
295
296 if (dentry_len == 0) {
297 // TODO error
298 return -1;
299 }
300
301 offset += dentry_len;
302 dentry = (ext4_directory_entry_ll_t *)((uint8_t *)dentry + dentry_len);
303 }
304
305 return 0;
306}
307
308static int ext4_directory_dx_next_block(ext4_filesystem_t *fs, ext4_inode_t *inode, uint32_t hash,
309 ext4_directory_dx_block_t *handle, ext4_directory_dx_block_t *handles)
310{
311 int rc;
312
313
314 uint32_t num_handles = 0;
315 ext4_directory_dx_block_t *p = handle;
316
317 while (1) {
318
319 p->position++;
320 uint16_t count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)p->entries);
321
322 if (p->position < p->entries + count) {
323 break;
324 }
325
326 if (p == handles) {
327 return 0;
328 }
329
330 num_handles++;
331 p--;
332 }
333
334 uint32_t current_hash = ext4_directory_dx_entry_get_hash(p->position);
335
336 if ((hash & 1) == 0) {
337 if ((current_hash & ~1) != hash) {
338 return 0;
339 }
340 }
341
342
343 while (num_handles--) {
344
345 uint32_t block_idx = ext4_directory_dx_entry_get_block(p->position);
346 uint32_t block_addr;
347 rc = ext4_filesystem_get_inode_data_block_index(fs, inode, block_idx, &block_addr);
348 if (rc != EOK) {
349 return rc;
350 }
351
352 block_t *block;
353 rc = block_get(&block, fs->device, block_addr, BLOCK_FLAGS_NONE);
354 if (rc != EOK) {
355 return rc;
356 }
357
358 p++;
359
360 block_put(p->block);
361 p->block = block;
362 p->entries = ((ext4_directory_dx_node_t *) block->data)->entries;
363 p->position = p->entries;
364 }
365
366 return 1;
367
368}
369
370int ext4_directory_dx_find_entry(ext4_directory_iterator_t *it,
371 ext4_filesystem_t *fs, ext4_inode_ref_t *inode_ref, size_t len, const char *name)
372{
373 int rc;
374
375 // get direct block 0 (index root)
376 uint32_t root_block_addr;
377 rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, 0, &root_block_addr);
378 if (rc != EOK) {
379 return rc;
380 }
381
382 block_t *root_block;
383 rc = block_get(&root_block, fs->device, root_block_addr, BLOCK_FLAGS_NONE);
384 if (rc != EOK) {
385 it->current_block = NULL;
386 return rc;
387 }
388
389 ext4_hash_info_t hinfo;
390 rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, len, name);
391 if (rc != EOK) {
392 block_put(root_block);
393 return EXT4_ERR_BAD_DX_DIR;
394 }
395
396 // Hardcoded number 2 means maximum height of index tree !!!
397 ext4_directory_dx_block_t dx_blocks[2];
398 ext4_directory_dx_block_t *dx_block;
399 rc = ext4_directory_dx_get_leaf(&hinfo, fs, inode_ref->inode, root_block, &dx_block, dx_blocks);
400 if (rc != EOK) {
401 block_put(root_block);
402 return EXT4_ERR_BAD_DX_DIR;
403 }
404
405
406 do {
407
408 uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position);
409 uint32_t leaf_block_addr;
410 rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, leaf_block_idx, &leaf_block_addr);
411 if (rc != EOK) {
412 return EXT4_ERR_BAD_DX_DIR;
413 }
414
415 block_t *leaf_block;
416 rc = block_get(&leaf_block, fs->device, leaf_block_addr, BLOCK_FLAGS_NONE);
417 if (rc != EOK) {
418 return EXT4_ERR_BAD_DX_DIR;
419 }
420
421 aoff64_t block_offset;
422 ext4_directory_entry_ll_t *res_dentry;
423 rc = ext4_directory_dx_find_dir_entry(leaf_block, fs->superblock, len, name,
424 &res_dentry, &block_offset);
425
426 // Found => return it
427 if (rc == 1) {
428 it->fs = fs;
429 it->inode_ref = inode_ref;
430 it->current_block = leaf_block;
431 it->current_offset = block_offset;
432 it->current = res_dentry;
433 return EOK;
434 }
435
436 block_put(leaf_block);
437
438 // ERROR - corrupted index
439 if (rc == -1) {
440 // TODO cleanup
441 return EXT4_ERR_BAD_DX_DIR;
442 }
443
444 rc = ext4_directory_dx_next_block(fs, inode_ref->inode, hinfo.hash, dx_block, &dx_blocks[0]);
445 if (rc < 0) {
446 // TODO cleanup
447 return EXT4_ERR_BAD_DX_DIR;
448 }
449
450 } while (rc == 1);
451
452 return ENOENT;
453}
454
455typedef struct ext4_dx_sort_entry {
456 uint32_t hash;
457 ext4_directory_entry_ll_t *dentry;
458} ext4_dx_sort_entry_t;
459
460static int dx_entry_comparator(void *arg1, void *arg2, void *dummy)
461{
462 ext4_dx_sort_entry_t *entry1 = arg1;
463 ext4_dx_sort_entry_t *entry2 = arg2;
464
465 if (entry1->hash == entry2->hash) {
466 return 0;
467 }
468
469 if (entry1->hash < entry2->hash) {
470 return -1;
471 } else {
472 return 1;
473 }
474
475}
476
477static int ext4_directory_dx_split_data(ext4_filesystem_t *fs,
478 ext4_inode_ref_t *inode_ref, ext4_hash_info_t *hinfo,
479 block_t *data_block, ext4_directory_dx_block_t *index_block)
480{
481 int rc;
482
483 uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
484 void *entry_buffer = malloc(block_size);
485 if (entry_buffer == NULL) {
486 return ENOMEM;
487 }
488
489 // Copy data to buffer
490 memcpy(entry_buffer, index_block->block->data, block_size);
491
492 ext4_directory_dx_countlimit_t *countlimit =
493 (ext4_directory_dx_countlimit_t *)index_block->entries;
494 uint32_t entry_count = ext4_directory_dx_countlimit_get_count(countlimit);
495 ext4_dx_sort_entry_t *sort_array = malloc(entry_count);
496 if (sort_array == NULL) {
497 free(entry_buffer);
498 return ENOMEM;
499 }
500
501 ext4_directory_entry_ll_t *dentry = data_block->data;
502
503 int idx = 0;
504 while ((void *)dentry < data_block->data + block_size) {
505 char *name = (char *)dentry->name;
506 uint8_t len = ext4_directory_entry_ll_get_name_length(fs->superblock, dentry);
507 uint32_t hash = ext4_hash_string(hinfo, len, name);
508
509 sort_array[idx].dentry = dentry;
510 sort_array[idx].hash = hash;
511
512 idx++;
513 dentry = (void *)dentry + ext4_directory_entry_ll_get_entry_length(dentry);
514 }
515
516 qsort(sort_array, entry_count, sizeof(ext4_dx_sort_entry_t), dx_entry_comparator, NULL);
517
518 // TODO split to two groups (by size, NOT by count)
519
520 uint32_t new_fblock;
521 rc = ext4_directory_append_block(fs, inode_ref, &new_fblock);
522 if (rc != EOK) {
523 free(sort_array);
524 free(entry_buffer);
525 return rc;
526 }
527
528 // TODO load new_block
529
530 // TODO write splitted entries to two blocks
531
532 // TODO add new entry to index block
533
534 return EOK;
535}
536
537
538int ext4_directory_dx_add_entry(ext4_filesystem_t *fs,
539 ext4_inode_ref_t *parent, ext4_inode_ref_t *child,
540 size_t name_size, const char *name)
541{
542 int rc;
543
544 // get direct block 0 (index root)
545 uint32_t root_block_addr;
546 rc = ext4_filesystem_get_inode_data_block_index(fs, parent->inode, 0, &root_block_addr);
547 if (rc != EOK) {
548 return rc;
549 }
550
551 block_t *root_block;
552 rc = block_get(&root_block, fs->device, root_block_addr, BLOCK_FLAGS_NONE);
553 if (rc != EOK) {
554 return rc;
555 }
556
557 ext4_hash_info_t hinfo;
558 rc = ext4_directory_hinfo_init(&hinfo, root_block, fs->superblock, name_size, name);
559 if (rc != EOK) {
560 block_put(root_block);
561 return EXT4_ERR_BAD_DX_DIR;
562 }
563
564 // Hardcoded number 2 means maximum height of index tree !!!
565 ext4_directory_dx_block_t dx_blocks[2];
566 ext4_directory_dx_block_t *dx_block;
567 rc = ext4_directory_dx_get_leaf(&hinfo, fs, parent->inode, root_block, &dx_block, dx_blocks);
568 if (rc != EOK) {
569 block_put(root_block);
570 return EXT4_ERR_BAD_DX_DIR;
571 }
572
573
574 // Try to insert to existing data block
575 uint32_t leaf_block_idx = ext4_directory_dx_entry_get_block(dx_block->position);
576 uint32_t leaf_block_addr;
577 rc = ext4_filesystem_get_inode_data_block_index(fs, parent->inode, leaf_block_idx, &leaf_block_addr);
578 if (rc != EOK) {
579 return EXT4_ERR_BAD_DX_DIR;
580 }
581
582
583 block_t *target;
584 rc = block_get(&target, fs->device, leaf_block_addr, BLOCK_FLAGS_NONE);
585 if (rc != EOK) {
586 return EXT4_ERR_BAD_DX_DIR;
587 }
588
589 uint32_t block_size = ext4_superblock_get_block_size(fs->superblock);
590 uint16_t required_len = 8 + name_size + (4 - name_size % 4);
591
592 ext4_directory_entry_ll_t *de = target->data;
593 ext4_directory_entry_ll_t *stop = target->data + block_size;
594
595 while (de < stop) {
596
597 uint32_t de_inode = ext4_directory_entry_ll_get_inode(de);
598 uint16_t de_rec_len = ext4_directory_entry_ll_get_entry_length(de);
599
600 if ((de_inode == 0) && (de_rec_len >= required_len)) {
601 ext4_directory_write_entry(fs->superblock, de, de_rec_len,
602 child, name, name_size);
603 target->dirty = true;
604 rc = block_put(target);
605 if (rc != EOK) {
606 return EXT4_ERR_BAD_DX_DIR;
607 }
608 return EOK;
609 }
610
611 if (de_inode != 0) {
612 uint16_t used_name_len = ext4_directory_entry_ll_get_name_length(
613 fs->superblock, de);
614
615 uint16_t used_space = 8 + used_name_len;
616 if ((used_name_len % 4) != 0) {
617 used_space += 4 - (used_name_len % 4);
618 }
619 uint16_t free_space = de_rec_len - used_space;
620
621 if (free_space >= required_len) {
622
623 EXT4FS_DBG("rec_len = \%u, used_space = \%u, free space = \%u", de_rec_len, used_space, free_space);
624
625 // Cut tail of current entry
626 ext4_directory_entry_ll_set_entry_length(de, used_space);
627 ext4_directory_entry_ll_t *new_entry = (void *)de + used_space;
628 ext4_directory_write_entry(fs->superblock, new_entry,
629 free_space, child, name, name_size);
630 target->dirty = true;
631 rc = block_put(target);
632 if (rc != EOK) {
633 return EXT4_ERR_BAD_DX_DIR;
634 }
635 return EOK;
636
637 }
638
639 }
640
641 de = (void *)de + de_rec_len;
642 }
643
644 EXT4FS_DBG("no free space found");
645
646 ext4_directory_dx_entry_t *entries = ((ext4_directory_dx_node_t *) dx_block->block->data)->entries;
647 uint16_t leaf_limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)entries);
648 uint16_t leaf_count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)entries);
649
650 ext4_directory_dx_entry_t *root_entries = ((ext4_directory_dx_node_t *) dx_blocks[0].block->data)->entries;
651
652 if (leaf_limit == leaf_count) {
653 EXT4FS_DBG("need to split index block !!!");
654
655 unsigned int levels = dx_block - dx_blocks;
656
657 uint16_t root_limit = ext4_directory_dx_countlimit_get_limit((ext4_directory_dx_countlimit_t *)root_entries);
658 uint16_t root_count = ext4_directory_dx_countlimit_get_count((ext4_directory_dx_countlimit_t *)root_entries);
659
660 if ((levels > 0) && (root_limit == root_count)) {
661 EXT4FS_DBG("Directory index is full");
662
663 // ENOSPC - cleanup !!!
664 return ENOSPC;
665 }
666
667 uint32_t fblock;
668 rc = ext4_directory_append_block(fs, parent, &fblock);
669 if (rc != EOK) {
670 // TODO error
671 }
672
673 // New block allocated
674 block_t * new_block;
675 rc = block_get(&new_block, fs->device, fblock, BLOCK_FLAGS_NOREAD);
676 if (rc != EOK) {
677 // TODO error
678 }
679
680 memset(new_block->data, 0, block_size);
681
682 if (levels > 0) {
683 EXT4FS_DBG("split index");
684 } else {
685 EXT4FS_DBG("create second level");
686 }
687 }
688
689 rc = ext4_directory_dx_split_data(fs, parent, &hinfo, target, dx_block);
690 if (rc != EOK) {
691 // TODO error
692 }
693
694
695 // TODO
696 return EOK;
697
698}
699
700
701/**
702 * @}
703 */
Note: See TracBrowser for help on using the repository browser.