Lines Matching defs:size
47 void *buffer, lfs_size_t size) {
49 if (off+size > lfs->cfg->block_size
54 while (size > 0) {
55 lfs_size_t diff = size;
58 off < pcache->off + pcache->size) {
61 diff = lfs_min(diff, pcache->size - (off-pcache->off));
66 size -= diff;
75 off < rcache->off + rcache->size) {
78 diff = lfs_min(diff, rcache->size - (off-rcache->off));
83 size -= diff;
91 if (size >= hint && off % lfs->cfg->read_size == 0 &&
92 size >= lfs->cfg->read_size) {
102 size -= diff;
110 rcache->size = lfs_min(
117 rcache->off, rcache->buffer, rcache->size);
130 const void *buffer, lfs_size_t size) {
134 for (lfs_off_t i = 0; i < size; i += diff) {
137 diff = lfs_min(size-i, sizeof(dat));
156 lfs_block_t block, lfs_off_t off, lfs_size_t size, uint32_t *crc) {
159 for (lfs_off_t i = 0; i < size; i += diff) {
161 diff = lfs_min(size-i, sizeof(dat));
180 lfs_size_t diff = lfs_alignup(pcache->size, lfs->cfg->prog_size);
230 const void *buffer, lfs_size_t size) {
233 LFS_ASSERT(off + size <= lfs->cfg->block_size);
235 while (size > 0) {
240 lfs_size_t diff = lfs_min(size,
246 size -= diff;
248 pcache->size = lfs_max(pcache->size, off - pcache->off);
249 if (pcache->size == lfs->cfg->cache_size) {
267 pcache->size = 0;
326 #define LFS_MKTAG(type, id, size) \
327 (((lfs_tag_t)(type) << 20) | ((lfs_tag_t)(id) << 10) | (lfs_tag_t)(size))
329 #define LFS_MKTAG_IF(cond, type, id, size) \
330 ((cond) ? LFS_MKTAG(type, id, size) : LFS_MKTAG(LFS_FROM_NOOP, 0, 0))
445 lfs_size_t size;
450 fcrc->size = lfs_fromle32(fcrc->size);
456 fcrc->size = lfs_tole32(fcrc->size);
464 ctz->size = lfs_fromle32(ctz->size);
470 ctz->size = lfs_tole32(ctz->size);
552 const void *buffer, lfs_size_t size);
554 const void *buffer, lfs_size_t size);
580 void *buffer, lfs_size_t size);
582 void *buffer, lfs_size_t size);
602 if (off < lfs->free.size) {
620 lfs->free.size = 0;
628 // lfs->free.i is equal lfs->free.size when all blocks are used
630 lfs->free.size = lfs_min(8*lfs->cfg->lookahead_size, lfs->free.ack);
648 while (lfs->free.i != lfs->free.size) {
659 while (lfs->free.i != lfs->free.size &&
758 lfs_off_t off, void *buffer, lfs_size_t size) {
760 if (off+size > lfs->cfg->block_size) {
764 while (size > 0) {
765 lfs_size_t diff = size;
768 off < pcache->off + pcache->size) {
771 diff = lfs_min(diff, pcache->size - (off-pcache->off));
776 size -= diff;
785 off < rcache->off + rcache->size) {
788 diff = lfs_min(diff, rcache->size - (off-rcache->off));
793 size -= diff;
804 rcache->size = lfs_min(lfs_alignup(off+hint, lfs->cfg->read_size),
807 rcache->off, rcache->buffer, rcache->size);
1025 lfs_tag_id(tag) + diff, a[i].size), a[i].buffer);
1312 dir->pair[0], dir->off, fcrc.size, &fcrc_);
1403 info->size = ctz.size;
1405 info->size = lfs_tag_size(tag);
1414 lfs_size_t size;
1424 lfs_size_t diff = lfs_min(name->size, lfs_tag_size(tag));
1432 // only equal if our size is still the same
1433 if (name->size != lfs_tag_size(tag)) {
1434 return (name->size < lfs_tag_size(tag)) ? LFS_CMP_LT : LFS_CMP_GT;
1554 const void *buffer, lfs_size_t size) {
1558 (const uint8_t*)buffer, size);
1563 commit->crc = lfs_crc(commit->crc, buffer, size);
1564 commit->off += size;
1666 .size = lfs->cfg->prog_size,
1671 commit->block, noff, fcrc.size, &fcrc.crc);
1865 lfs_size_t *size = p;
1868 *size += lfs_tag_dsize(tag);
1979 // commit tail, which may be new after last size check
2078 // find size of first split, we do this by halving the split until
2082 // split size. This may result in poorly distributed metadata but isn't
2083 // worth the extra code size or performance hit to fix.
2086 lfs_size_t size = 0;
2092 lfs_dir_commit_size, &size);
2109 && size <= lfs_min(
2149 lfs_ssize_t size = lfs_fs_rawsize(lfs);
2150 if (size < 0) {
2151 return size;
2156 if ((lfs_size_t)size < lfs->block_count/2) {
2357 f->ctz.size > lfs->cfg->cache_size) {
2816 lfs_off_t size = *off;
2818 lfs_off_t i = size / b;
2823 i = (size - 4*(lfs_popc(i-1)+2)) / b;
2824 *off = size - b*i - 4*lfs_popc(i);
2830 lfs_block_t head, lfs_size_t size,
2832 if (size == 0) {
2838 lfs_off_t current = lfs_ctz_index(lfs, &(lfs_off_t){size-1});
2865 lfs_block_t head, lfs_size_t size,
2884 if (size == 0) {
2890 lfs_size_t noff = size - 1;
2964 lfs_block_t head, lfs_size_t size,
2966 if (size == 0) {
2970 lfs_off_t index = lfs_ctz_index(lfs, &(lfs_off_t){size-1});
3104 file->id, file->cfg->attrs[i].size),
3115 if (file->cfg->attrs[i].size > lfs->attr_max) {
3142 file->ctz.size = lfs_tag_size(tag);
3146 file->cache.size = lfs->cfg->cache_size;
3149 if (file->ctz.size > 0) {
3153 lfs_min(file->cache.size, 0x3fe)),
3256 file->cache.size = lfs->pcache.size;
3302 .ctz.size = file->ctz.size,
3309 while (file->pos < file->ctz.size) {
3350 file->pos = lfs_max(file->pos, file->ctz.size);
3355 file->ctz.size = file->pos;
3385 lfs_size_t size;
3391 size = file->ctz.size;
3399 size = sizeof(ctz);
3404 {LFS_MKTAG(type, file->id, size), buffer},
3420 void *buffer, lfs_size_t size) {
3422 lfs_size_t nsize = size;
3424 if (file->pos >= file->ctz.size) {
3429 size = lfs_min(size, file->ctz.size - file->pos);
3430 nsize = size;
3438 file->ctz.head, file->ctz.size,
3477 return size;
3481 void *buffer, lfs_size_t size) {
3494 return lfs_file_flushedread(lfs, file, buffer, size);
3500 const void *buffer, lfs_size_t size) {
3502 lfs_size_t nsize = size;
3505 lfs_max(file->pos+nsize, file->ctz.size) >
3526 file->ctz.head, file->ctz.size,
3584 return size;
3588 const void *buffer, lfs_size_t size) {
3599 if ((file->flags & LFS_O_APPEND) && file->pos < file->ctz.size) {
3600 file->pos = file->ctz.size;
3603 if (file->pos + size > lfs->file_max) {
3608 if (!(file->flags & LFS_F_WRITING) && file->pos > file->ctz.size) {
3611 file->pos = file->ctz.size;
3621 lfs_ssize_t nsize = lfs_file_flushedwrite(lfs, file, buffer, size);
3676 && noff < file->cache.off + file->cache.size) {
3695 static int lfs_file_rawtruncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
3698 if (size > LFS_FILE_MAX) {
3704 if (size < oldsize) {
3706 if (size <= lfs_min(0x3fe, lfs_min(
3719 lfs->rcache.buffer, size);
3725 file->ctz.size = size;
3729 file->cache.size = lfs->cfg->cache_size;
3730 memcpy(file->cache.buffer, lfs->rcache.buffer, size);
3741 file->ctz.head, file->ctz.size,
3742 size-1, &file->block, &(lfs_off_t){0});
3749 file->pos = size;
3751 file->ctz.size = size;
3754 } else if (size > oldsize) {
3762 while (file->pos < size) {
3799 return lfs_max(file->pos, file->ctz.size);
3803 return file->ctz.size;
4034 uint8_t type, void *buffer, lfs_size_t size) {
4053 id, lfs_min(size, lfs->attr_max)),
4068 uint8_t type, const void *buffer, lfs_size_t size) {
4086 {LFS_MKTAG(LFS_TYPE_USERATTR + type, id, size), buffer}));
4092 uint8_t type, const void *buffer, lfs_size_t size) {
4093 if (size > lfs->attr_max) {
4097 return lfs_commitattr(lfs, path, type, buffer, size);
4135 // check that block size is a multiple of cache size is a multiple
4141 // check that the block size is large enough to fit all ctz pointers
4197 // check that the size limits are sane
4270 lfs->free.size = lfs_min(8*lfs->cfg->lookahead_size,
4455 LFS_ERROR("Invalid block size (%"PRIu32" != %"PRIu32")",
4600 ctz.head, ctz.size, cb, data);
4625 f->ctz.head, f->ctz.size, cb, data);
5033 lfs_size_t *size = p;
5034 *size += 1;
5039 lfs_size_t size = 0;
5040 int err = lfs_fs_rawtraverse(lfs, lfs_fs_size_count, &size, false);
5045 return size;
5131 lfs_size_t size;
5148 lfs_size_t size;
5171 static void lfs1_crc(uint32_t *crc, const void *buffer, size_t size) {
5172 *crc = lfs_crc(*crc, buffer, size);
5176 lfs_off_t off, void *buffer, lfs_size_t size) {
5179 return lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, size,
5180 block, off, buffer, size);
5184 lfs_off_t off, lfs_size_t size, uint32_t *crc) {
5185 for (lfs_off_t i = 0; i < size; i++) {
5202 d->size = lfs_fromle32(d->size);
5209 d->size = lfs_tole32(d->size);
5260 if ((0x7fffffff & test.size) < sizeof(test)+4 ||
5261 (0x7fffffff & test.size) > lfs->cfg->block_size) {
5270 (0x7fffffff & test.size) - sizeof(test), &crc);
5301 while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) {
5302 if (!(0x80000000 & dir->d.size)) {
5354 while (dir.off + sizeof(entry.d) <= (0x7fffffff & dir.d.size)-4) {
5365 entry.d.u.file.head, entry.d.u.file.size, cb, data);
5455 lfs->free.size = 0;
5511 // Indeterminate filesystem size not allowed for migration.
5873 uint8_t type, void *buffer, lfs_size_t size) {
5879 (void*)lfs, path, type, buffer, size);
5881 lfs_ssize_t res = lfs_rawgetattr(lfs, path, type, buffer, size);
5890 uint8_t type, const void *buffer, lfs_size_t size) {
5896 (void*)lfs, path, type, buffer, size);
5898 err = lfs_rawsetattr(lfs, path, type, buffer, size);
5993 void *buffer, lfs_size_t size) {
5999 (void*)lfs, (void*)file, buffer, size);
6002 lfs_ssize_t res = lfs_file_rawread(lfs, file, buffer, size);
6011 const void *buffer, lfs_size_t size) {
6017 (void*)lfs, (void*)file, buffer, size);
6020 lfs_ssize_t res = lfs_file_rawwrite(lfs, file, buffer, size);
6046 int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
6052 (void*)lfs, (void*)file, size);
6055 err = lfs_file_rawtruncate(lfs, file, size);