if (ext4_inode_is_type(&mp->fs.sb, child->inode,
EXT4_INODE_MODE_DIRECTORY) &&
!rename) {
- rc = ext4_dir_add_entry(child, ".", strlen("."), child);
- if (rc != EOK) {
- ext4_dir_remove_entry(parent, name, strlen(name));
- return rc;
- }
-
- rc = ext4_dir_add_entry(child, "..", strlen(".."), parent);
- if (rc != EOK) {
- ext4_dir_remove_entry(parent, name, strlen(name));
- ext4_dir_remove_entry(child, ".", strlen("."));
- return rc;
- }
-
- /*New empty directory. Two links (. and ..) */
- ext4_inode_set_links_count(child->inode, 2);
#if CONFIG_DIR_INDEX_ENABLE
/* Initialize directory index if supported */
- if (ext4_sb_has_feature_compatible(
- &mp->fs.sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {
- rc = ext4_dir_dx_init(child);
+ if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_DIR_INDEX)) {
+ rc = ext4_dir_dx_init(child, parent);
if (rc != EOK)
return rc;
ext4_inode_set_flag(child->inode,
EXT4_INODE_FLAG_INDEX);
child->dirty = true;
- }
+ } else
#endif
+ {
+ rc = ext4_dir_add_entry(child, ".", strlen("."), child);
+ if (rc != EOK) {
+ ext4_dir_remove_entry(parent, name, strlen(name));
+ return rc;
+ }
+
+ rc = ext4_dir_add_entry(child, "..", strlen(".."), parent);
+ if (rc != EOK) {
+ ext4_dir_remove_entry(parent, name, strlen(name));
+ ext4_dir_remove_entry(child, ".", strlen("."));
+ return rc;
+ }
+ }
+
+ /*New empty directory. Two links (. and ..) */
+ ext4_inode_set_links_count(child->inode, 2);
ext4_fs_inode_links_count_inc(parent);
child->dirty = true;
int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
{
- uint32_t u;
- uint32_t fblock;
- uint32_t fblock_start;
- uint32_t fblock_cnt;
- uint32_t sblock;
- uint32_t sblock_end;
+ uint32_t unaligned;
+ uint32_t iblock_idx;
+ uint32_t iblock_last;
uint32_t block_size;
+
+ ext4_fsblk_t fblock;
+ ext4_fsblk_t fblock_start;
+ uint32_t fblock_count;
+
uint8_t *u8_buf = buf;
int r;
struct ext4_block b;
block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
size = size > (f->fsize - f->fpos) ? (f->fsize - f->fpos) : size;
- sblock = (f->fpos) / block_size;
- sblock_end = (f->fpos + size) / block_size;
- u = (f->fpos) % block_size;
+
+ iblock_idx = (f->fpos) / block_size;
+ iblock_last = (f->fpos + size) / block_size;
+ unaligned = (f->fpos) % block_size;
/*If the size of symlink is smaller than 60 bytes*/
if (ext4_inode_is_type(&f->mp->fs.sb, ref.inode, EXT4_INODE_MODE_SOFTLINK)
&& !ext4_inode_get_blocks_count(&f->mp->fs.sb, ref.inode)) {
char *content = (char *)ref.inode->blocks;
if (f->fpos < f->fsize) {
- r = (u + size > f->fsize)
- ?(f->fsize - u)
+ r = (unaligned + size > f->fsize)
+ ?(f->fsize - unaligned)
:(size);
- memcpy(buf, content + u, r);
+ memcpy(buf, content + unaligned, r);
if (rcnt)
*rcnt = r;
goto Finish;
}
- if (u) {
-
- uint32_t ll = size > (block_size - u) ? (block_size - u) : size;
-
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ if (unaligned) {
+ uint32_t l = size > (block_size - unaligned) ?
+ (block_size - unaligned) : size;
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx, &fblock,
+ true);
if (r != EOK)
goto Finish;
- r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
- if (r != EOK)
- goto Finish;
+ /* Do we get an unwritten range? */
+ if (fblock != 0) {
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
- memcpy(u8_buf, b.data + u, ll);
+ memcpy(u8_buf, b.data + unaligned, l);
- r = ext4_block_set(f->mp->fs.bdev, &b);
- if (r != EOK)
- goto Finish;
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+ } else {
+ /* Yes, we do. */
+ memset(u8_buf, 0, l);
+ }
- u8_buf += ll;
- size -= ll;
- f->fpos += ll;
+ u8_buf += l;
+ size -= l;
+ f->fpos += l;
if (rcnt)
- *rcnt += ll;
+ *rcnt += l;
- sblock++;
+ iblock_idx++;
}
fblock_start = 0;
- fblock_cnt = 0;
+ fblock_count = 0;
while (size >= block_size) {
- while (sblock < sblock_end) {
- r = ext4_fs_get_inode_data_block_index(&ref, sblock,
- &fblock);
+ while (iblock_idx < iblock_last) {
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx,
+ &fblock, true);
if (r != EOK)
goto Finish;
- sblock++;
+ iblock_idx++;
- if (!fblock_start) {
+ if (!fblock_start)
fblock_start = fblock;
- }
- if ((fblock_start + fblock_cnt) != fblock)
+ if ((fblock_start + fblock_count) != fblock)
break;
- fblock_cnt++;
+ fblock_count++;
}
r = ext4_blocks_get_direct(f->mp->fs.bdev, u8_buf, fblock_start,
- fblock_cnt);
+ fblock_count);
if (r != EOK)
goto Finish;
- size -= block_size * fblock_cnt;
- u8_buf += block_size * fblock_cnt;
- f->fpos += block_size * fblock_cnt;
+ size -= block_size * fblock_count;
+ u8_buf += block_size * fblock_count;
+ f->fpos += block_size * fblock_count;
if (rcnt)
- *rcnt += block_size * fblock_cnt;
+ *rcnt += block_size * fblock_count;
fblock_start = fblock;
- fblock_cnt = 1;
+ fblock_count = 1;
}
if (size) {
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx, &fblock,
+ true);
if (r != EOK)
goto Finish;
int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
{
- uint32_t u;
- uint32_t fblock;
-
- uint32_t sblock;
- uint32_t sblock_end;
- uint32_t file_blocks;
+ uint32_t unaligned;
+ uint32_t iblock_idx;
+ uint32_t iblock_last;
+ uint32_t ifile_blocks;
uint32_t block_size;
- uint32_t fblock_start;
- uint32_t fblock_cnt;
+
+ uint32_t fblock_count;
+ ext4_fsblk_t fblock;
+ ext4_fsblk_t fblock_start;
struct ext4_block b;
struct ext4_inode_ref ref;
const uint8_t *u8_buf = buf;
- int r;
+ int r, rr = EOK;
ext4_assert(f && f->mp);
/*Sync file size*/
f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
-
block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
- sblock_end = (f->fpos + size) > f->fsize ? (f->fpos + size) : f->fsize;
- sblock_end /= block_size;
- file_blocks = (f->fsize / block_size);
-
- if (f->fsize % block_size)
- file_blocks++;
+ iblock_last = (f->fpos + size) / block_size;
+ iblock_idx = (f->fpos) / block_size;
+ ifile_blocks = (f->fsize + block_size - 1) / block_size;
- sblock = (f->fpos) / block_size;
+ unaligned = (f->fpos) % block_size;
- u = (f->fpos) % block_size;
-
- if (u) {
- uint32_t ll = size > (block_size - u) ? (block_size - u) : size;
-
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ if (unaligned) {
+ uint32_t l = size > (block_size - unaligned) ?
+ (block_size - unaligned) : size;
+ r = ext4_fs_init_inode_data_block_index(&ref, iblock_idx, &fblock);
if (r != EOK)
goto Finish;
if (r != EOK)
goto Finish;
- memcpy(b.data + u, u8_buf, ll);
+ memcpy(b.data + unaligned, u8_buf, l);
b.dirty = true;
r = ext4_block_set(f->mp->fs.bdev, &b);
if (r != EOK)
goto Finish;
- u8_buf += ll;
- size -= ll;
- f->fpos += ll;
+ u8_buf += l;
+ size -= l;
+ f->fpos += l;
if (wcnt)
- *wcnt += ll;
+ *wcnt += l;
- sblock++;
+ iblock_idx++;
}
/*Start write back cache mode.*/
goto Finish;
fblock_start = 0;
- fblock_cnt = 0;
+ fblock_count = 0;
while (size >= block_size) {
- while (sblock < sblock_end) {
- if (sblock < file_blocks) {
- r = ext4_fs_get_inode_data_block_index(
- &ref, sblock, &fblock);
+ while (iblock_idx < iblock_last) {
+ if (iblock_idx < ifile_blocks) {
+ r = ext4_fs_init_inode_data_block_index(
+ &ref, iblock_idx, &fblock);
if (r != EOK)
- break;
+ goto Finish;
} else {
- r = ext4_fs_append_inode_block(&ref, &fblock,
- &sblock);
- if (r != EOK)
+ rr = ext4_fs_append_inode_block(&ref, &fblock,
+ &iblock_idx);
+ if (rr != EOK) {
+ /* Unable to append more blocks. But some
+ * block might be allocated already.
+ * */
break;
+ }
}
- sblock++;
+ iblock_idx++;
if (!fblock_start) {
fblock_start = fblock;
}
- if ((fblock_start + fblock_cnt) != fblock)
+ if ((fblock_start + fblock_count) != fblock)
break;
- fblock_cnt++;
+ fblock_count++;
}
r = ext4_blocks_set_direct(f->mp->fs.bdev, u8_buf, fblock_start,
- fblock_cnt);
+ fblock_count);
if (r != EOK)
break;
- size -= block_size * fblock_cnt;
- u8_buf += block_size * fblock_cnt;
- f->fpos += block_size * fblock_cnt;
+ size -= block_size * fblock_count;
+ u8_buf += block_size * fblock_count;
+ f->fpos += block_size * fblock_count;
if (wcnt)
- *wcnt += block_size * fblock_cnt;
+ *wcnt += block_size * fblock_count;
fblock_start = fblock;
- fblock_cnt = 1;
+ fblock_count = 1;
+
+ if (rr != EOK) {
+ /*ext4_fs_append_inode_block has failed and no
+ * more blocks might be written. But node size
+ * should be updated.*/
+ r = rr;
+ goto out_fsize;
+ }
}
/*Stop write back cache mode*/
goto Finish;
if (size) {
- if (sblock < file_blocks) {
- r = ext4_fs_get_inode_data_block_index(&ref, sblock,
+ if (iblock_idx < ifile_blocks) {
+ r = ext4_fs_init_inode_data_block_index(&ref, iblock_idx,
&fblock);
if (r != EOK)
goto Finish;
} else {
- r = ext4_fs_append_inode_block(&ref, &fblock, &sblock);
+ r = ext4_fs_append_inode_block(&ref, &fblock, &iblock_idx);
if (r != EOK)
- goto Finish;
+ /*Node size sholud be updated.*/
+ goto out_fsize;
}
r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
*wcnt += size;
}
+out_fsize:
if (f->fpos > f->fsize) {
f->fsize = f->fpos;
ext4_inode_set_size(ref.inode, f->fsize);
{
struct ext4_block b;
struct ext4_inode_ref ref;
- uint32_t sblock, fblock;
+ uint32_t sblock;
+ ext4_fsblk_t fblock;
uint32_t block_size;
int r;
/*If the size of symlink is smaller than 60 bytes*/
if (size < sizeof(ref.inode->blocks)) {
- char *content = (char *)ref.inode->blocks;
- memset(content, 0, sizeof(ref.inode->blocks));
- memcpy(content, buf, size);
+ memset(ref.inode->blocks, 0, sizeof(ref.inode->blocks));
+ memcpy(ref.inode->blocks, buf, size);
ext4_inode_clear_flag(ref.inode, EXT4_INODE_FLAG_EXTENTS);
} else {
ext4_fs_inode_blocks_init(&f->mp->fs, &ref);
if (!buf)
return EINVAL;
- memset(buf, 0, sizeof(bufsize));
-
filetype = EXT4_DIRENTRY_SYMLINK;
EXT4_MP_LOCK(mp);
projects / lwext4.git / blobdiff