int rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit bit) { rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; if (bit >= control->size) return EINVAL; search_map = control->search_bits; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset); bit = index; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset(bit); search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); rtems_rfs_buffer_mark_dirty (control->buffer); control->free++; return 0; }
int rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control) { rtems_rfs_bitmap_map map; size_t elements; int e; int rc; rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; elements = rtems_rfs_bitmap_elements (control->size); control->free = 0; for (e = 0; e < elements; e++) map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; elements = rtems_rfs_bitmap_elements (elements); for (e = 0; e < elements; e++) control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET; rtems_rfs_buffer_mark_dirty (control->buffer); return 0; }
int rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit bit) { rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; if (bit >= control->size) return EINVAL; search_map = control->search_bits; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset); if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET)) { bit = index; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset (bit); search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); control->free--; rtems_rfs_buffer_mark_dirty (control->buffer); } return 0; }
int rtems_rfs_inode_delete (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) { int rc = 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE)) printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n", rtems_rfs_inode_ino (handle), rtems_rfs_inode_is_loaded (handle) ? "yes" : "no"); if (rtems_rfs_inode_is_loaded (handle)) { rtems_rfs_block_map map; /* * Free the ino number. */ rc = rtems_rfs_inode_free (fs, handle->ino); if (rc > 0) return rc; /* * Free the blocks the inode may have attached. */ rc = rtems_rfs_block_map_open (fs, handle, &map); if (rc == 0) { int rrc; rrc = rtems_rfs_block_map_free_all (fs, &map); rc = rtems_rfs_block_map_close (fs, &map); if (rc > 0) rrc = rc; memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE); rtems_rfs_buffer_mark_dirty (&handle->buffer); /* * Do the release here to avoid the ctime field being set on a * close. Also if there loads is greater then one then other loads * active. Forcing the loads count to 0. */ rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer); handle->loads = 0; handle->node = NULL; } } return rc; }
int rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control) { rtems_rfs_bitmap_map map; rtems_rfs_bitmap_bit last_search_bit; size_t elements; int e; int rc; rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; elements = rtems_rfs_bitmap_elements (control->size); control->free = elements; for (e = 0; e < elements; e++) map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; /* * Set the un-mapped bits in the last search element so the available logic * works. */ last_search_bit = rtems_rfs_bitmap_map_offset (elements); if (last_search_bit == 0) last_search_bit = rtems_rfs_bitmap_element_bits (); elements = rtems_rfs_bitmap_elements (elements); for (e = 0; e < (elements - 1); e++) control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; control->search_bits[elements - 1] = rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR, RTEMS_RFS_BITMAP_ELEMENT_SET, rtems_rfs_bitmap_mask (last_search_bit)); rtems_rfs_buffer_mark_dirty (control->buffer); return 0; }
/** * Allocate an indirect block to a map. * * @param fs The file system data. * @param map The map the allocation is for. * @param buffer The buffer the indirect block is accessed by. * @param block The block number of the indirect block allocated. * @param upping True is upping the map to the next indirect level. * @return int The error number (errno). No error if 0. */ static int rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, rtems_rfs_buffer_handle* buffer, rtems_rfs_block_no* block, bool upping) { rtems_rfs_bitmap_bit new_block; int rc; /* * Save the new block locally because upping can have *block pointing to the * slots which are cleared when upping. */ rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block); if (rc > 0) return rc; rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false); if (rc > 0) { rtems_rfs_group_bitmap_free (fs, false, new_block); return rc; } memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs)); if (upping) { int b; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW)) printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n", map->size.count); for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) rtems_rfs_block_set_number (buffer, b, map->blocks[b]); memset (map->blocks, 0, sizeof (map->blocks)); } rtems_rfs_buffer_mark_dirty (buffer); *block = new_block; map->last_map_block = new_block; return 0; }
int rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle, rtems_rfs_buffer_block block, bool read) { int rc; /* * If the handle has a buffer release it. This allows a handle to be reused * without needing to close then open it again. */ if (rtems_rfs_buffer_handle_has_block (handle)) { /* * Treat block 0 as special to handle the loading of the super block. */ if (block && (rtems_rfs_buffer_bnum (handle) == block)) return 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n", rtems_rfs_buffer_bnum (handle)); rc = rtems_rfs_buffer_handle_release (fs, handle); if (rc > 0) return rc; handle->dirty = false; handle->bnum = 0; } if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); /* * First check to see if the buffer has already been requested and is * currently attached to a handle. If it is share the access. A buffer could * be shared where different parts of the block have separate functions. An * example is an inode block and the file system needs to handle 2 inodes in * the same block at the same time. */ if (fs->buffers_count) { /* * Check the active buffer list for shared buffers. */ handle->buffer = rtems_rfs_scan_chain (&fs->buffers, &fs->buffers_count, block); if (rtems_rfs_buffer_handle_has_block (handle) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", rtems_rfs_buffer_refs (handle) + 1); } /* * If the buffer has not been found check the local cache of released * buffers. There are release and released modified lists to preserve the * state. */ if (!rtems_rfs_fs_no_local_cache (fs) && !rtems_rfs_buffer_handle_has_block (handle)) { /* * Check the local cache of released buffers. */ if (fs->release_count) handle->buffer = rtems_rfs_scan_chain (&fs->release, &fs->release_count, block); if (!rtems_rfs_buffer_handle_has_block (handle) && fs->release_modified_count) { handle->buffer = rtems_rfs_scan_chain (&fs->release_modified, &fs->release_modified_count, block); /* * If we found a buffer retain the dirty buffer state. */ if (rtems_rfs_buffer_handle_has_block (handle)) rtems_rfs_buffer_mark_dirty (handle); } } /* * If not located we request the buffer from the I/O layer. */ if (!rtems_rfs_buffer_handle_has_block (handle)) { rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer); if (rc > 0) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", block, read ? "read" : "get", rc, strerror (rc)); return rc; } rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle)); } /* * Increase the reference count of the buffer. */ rtems_rfs_buffer_refs_up (handle); rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++; handle->buffer->user = (void*) ((intptr_t) block); handle->bnum = block; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", block, read ? "read" : "get", handle->buffer->block, handle->buffer->references); return 0; }
static int rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit* bit, bool* found, size_t window, int direction) { rtems_rfs_bitmap_map map; rtems_rfs_bitmap_bit test_bit; rtems_rfs_bitmap_bit end_bit; rtems_rfs_bitmap_element* search_bits; int search_index; int search_offset; rtems_rfs_bitmap_element* map_bits; int map_index; int map_offset; int rc; *found = false; /* * Load the bitmap. */ rc = rtems_rfs_bitmap_load_map (control, &map); if (rc > 0) return rc; /* * Calculate the bit we are testing plus the end point we search over. */ test_bit = *bit; end_bit = test_bit + (window * direction); if (end_bit < 0) end_bit = 0; else if (end_bit >= control->size) end_bit = control->size - 1; map_index = rtems_rfs_bitmap_map_index (test_bit); map_offset = rtems_rfs_bitmap_map_offset (test_bit); search_index = rtems_rfs_bitmap_map_index (map_index); search_offset = rtems_rfs_bitmap_map_offset (map_index); search_bits = &control->search_bits[search_index]; map_bits = &map[map_index]; /* * Check each bit from the search map offset for a clear bit. */ do { /* * If any bit is clear find that bit and then search the map element. If * all bits are set there are no map bits so move to the next search * element. */ if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) { while ((search_offset >= 0) && (search_offset < rtems_rfs_bitmap_element_bits ())) { if (!rtems_rfs_bitmap_test (*search_bits, search_offset)) { /* * Find the clear bit in the map. Update the search map and map if * found. We may find none are spare if searching up from the seed. */ while ((map_offset >= 0) && (map_offset < rtems_rfs_bitmap_element_bits ())) { if (!rtems_rfs_bitmap_test (*map_bits, map_offset)) { *map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset); if (rtems_rfs_bitmap_match(*map_bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) *search_bits = rtems_rfs_bitmap_set (*search_bits, 1 << search_offset); control->free--; *bit = test_bit; *found = true; rtems_rfs_buffer_mark_dirty (control->buffer); return 0; } if (test_bit == end_bit) break; map_offset += direction; test_bit += direction; } } map_bits += direction; map_index += direction; map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1; test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset; search_offset += direction; if (((direction < 0) && (test_bit <= end_bit)) || ((direction > 0) && (test_bit >= end_bit))) break; } } else { /* * Move to the next search element. We need to determine the number of * bits in the search offset that are being skipped so the map bits * pointer can be updated. If we are moving down and we have a search * offset of 0 then the search map adjustment is to the top bit of the * pervious search bit's value. * * Align test_bit either up or down depending on the direction to next 32 * bit boundary. */ rtems_rfs_bitmap_bit bits_skipped; test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1); if (direction > 0) { bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset; test_bit += bits_skipped * rtems_rfs_bitmap_element_bits (); map_offset = 0; } else { bits_skipped = search_offset + 1; /* * Need to remove 1 for the rounding up. The above rounds down and * adds 1. Remember the logic is for subtraction. */ test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1; map_offset = rtems_rfs_bitmap_element_bits () - 1; } map_bits += direction * bits_skipped; map_index += direction * bits_skipped; } search_bits += direction; search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1; } while (((direction < 0) && (test_bit >= end_bit)) || ((direction > 0) && (test_bit <= end_bit))); return 0; }
int rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_ino ino, uint32_t offset) { rtems_rfs_block_map map; rtems_rfs_block_no block; rtems_rfs_buffer_handle buffer; bool search; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", rtems_rfs_inode_ino (dir), ino, offset); rc = rtems_rfs_block_map_open (fs, dir, &map); if (rc > 0) return rc; rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); if (rc > 0) { if (rc == ENXIO) rc = ENOENT; rtems_rfs_block_map_close (fs, &map); return rc; } rc = rtems_rfs_buffer_handle_open (fs, &buffer); if (rc > 0) { rtems_rfs_block_map_close (fs, &map); return rc; } /* * Only search if the offset is 0 else we are at that position. */ search = offset ? false : true; while (rc == 0) { uint8_t* entry; int eoffset; rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); if (rc > 0) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) printf ("rtems-rfs: dir-del-entry: " "block buffer req failed for ino %" PRIu32 ": %d: %s\n", rtems_rfs_inode_ino (dir), rc, strerror (rc)); break; } /* * If we are searching start at the beginning of the block. If not searching * skip to the offset in the block. */ if (search) eoffset = 0; else eoffset = offset % rtems_rfs_fs_block_size (fs); entry = rtems_rfs_buffer_data (&buffer) + eoffset; while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) { rtems_rfs_ino eino; int elength; elength = rtems_rfs_dir_entry_length (entry); eino = rtems_rfs_dir_entry_ino (entry); if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) break; if (rtems_rfs_dir_entry_valid (fs, elength, eino)) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) printf ("rtems-rfs: dir-del-entry: " "bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %" PRIu32 ".%04x\n", rtems_rfs_inode_ino (dir), elength, eino, block, eoffset); rc = EIO; break; } if (ino == rtems_rfs_dir_entry_ino (entry)) { uint32_t remaining; remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength); memmove (entry, entry + elength, remaining); memset (entry + remaining, 0xff, elength); /* * If the remainder of the block is empty and this is the start of the * block and it is the last block in the map shrink the map. * * @note We could check again to see if the new end block in the map is * also empty. This way we could clean up an empty directory. */ elength = rtems_rfs_dir_entry_length (entry); if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) printf ("rtems-rfs: dir-del-entry: " "last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32 " offset=%d last=%s\n", ino, elength, block, eoffset, rtems_rfs_block_map_last (&map) ? "yes" : "no"); if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) && (eoffset == 0) && rtems_rfs_block_map_last (&map)) { rc = rtems_rfs_block_map_shrink (fs, &map, 1); if (rc > 0) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) printf ("rtems-rfs: dir-del-entry: " "block map shrink failed for ino %" PRIu32 ": %d: %s\n", rtems_rfs_inode_ino (dir), rc, strerror (rc)); } } rtems_rfs_buffer_mark_dirty (&buffer); rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return 0; } if (!search) { rc = EIO; break; } entry += elength; eoffset += elength; } if (rc == 0) { rc = rtems_rfs_block_map_next_block (fs, &map, &block); if (rc == ENXIO) rc = ENOENT; } } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; }
int rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, const char* name, size_t length, rtems_rfs_ino ino) { rtems_rfs_block_map map; rtems_rfs_block_pos bpos; rtems_rfs_buffer_handle buffer; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) { int c; printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=", rtems_rfs_inode_ino (dir)); for (c = 0; c < length; c++) printf ("%c", name[c]); printf (", len=%zd\n", length); } rc = rtems_rfs_block_map_open (fs, dir, &map); if (rc > 0) return rc; rc = rtems_rfs_buffer_handle_open (fs, &buffer); if (rc > 0) { rtems_rfs_block_map_close (fs, &map); return rc; } /* * Search the map from the beginning to find any empty space. */ rtems_rfs_block_set_bpos_zero (&bpos); while (true) { rtems_rfs_block_no block; uint8_t* entry; int offset; bool read = true; /* * Locate the first block. If an error the block will be 0. If the map is * empty which happens when creating a directory and adding the first entry * the seek will return ENXIO. In this case we need to grow the directory. */ rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block); if (rc > 0) { if (rc != ENXIO) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) printf ("rtems-rfs: dir-add-entry: " "block map find failed for ino %" PRIu32 ": %d: %s\n", rtems_rfs_inode_ino (dir), rc, strerror (rc)); break; } /* * We have reached the end of the directory so add a block. */ rc = rtems_rfs_block_map_grow (fs, &map, 1, &block); if (rc > 0) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) printf ("rtems-rfs: dir-add-entry: " "block map grow failed for ino %" PRIu32 ": %d: %s\n", rtems_rfs_inode_ino (dir), rc, strerror (rc)); break; } read = false; } bpos.bno++; rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); if (rc > 0) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) printf ("rtems-rfs: dir-add-entry: " "block buffer req failed for ino %" PRIu32 ": %d: %s\n", rtems_rfs_inode_ino (dir), rc, strerror (rc)); break; } entry = rtems_rfs_buffer_data (&buffer); if (!read) memset (entry, 0xff, rtems_rfs_fs_block_size (fs)); offset = 0; while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) { rtems_rfs_ino eino; int elength; elength = rtems_rfs_dir_entry_length (entry); eino = rtems_rfs_dir_entry_ino (entry); if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) { if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < (rtems_rfs_fs_block_size (fs) - offset)) { uint32_t hash; hash = rtems_rfs_dir_hash (name, length); rtems_rfs_dir_set_entry_hash (entry, hash); rtems_rfs_dir_set_entry_ino (entry, ino); rtems_rfs_dir_set_entry_length (entry, RTEMS_RFS_DIR_ENTRY_SIZE + length); memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); rtems_rfs_buffer_mark_dirty (&buffer); rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return 0; } break; } if (rtems_rfs_dir_entry_valid (fs, elength, eino)) { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) printf ("rtems-rfs: dir-add-entry: " "bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n", rtems_rfs_inode_ino (dir), elength, eino, offset); rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return EIO; } entry += elength; offset += elength; } } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; }
int rtems_rfs_file_set_size (rtems_rfs_file_handle* handle, rtems_rfs_pos new_size) { rtems_rfs_block_map* map = rtems_rfs_file_map (handle); rtems_rfs_pos size; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size); size = rtems_rfs_file_size (handle); /* * If the file is same size do nothing else grow or shrink it ? * * If the file does not change size do not update the times. */ if (size != new_size) { /* * Short cut for the common truncate on open call. */ if (new_size == 0) { rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map); if (rc > 0) return rc; } else { if (size < new_size) { /* * Grow. Fill with 0's. */ rtems_rfs_pos count; uint32_t length; bool read_block; count = new_size - size; length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); read_block = false; while (count) { rtems_rfs_buffer_block block; rtems_rfs_block_pos bpos; uint8_t* dst; /* * Get the block position for the current end of the file as seen by * the map. If not found and the EOF grow the map then fill the block * with 0. */ rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos); rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle), map, &bpos, &block); if (rc > 0) { /* * Have we reached the EOF ? */ if (rc != ENXIO) return rc; rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle), map, 1, &block); if (rc > 0) return rc; } if (count < (length - bpos.boff)) { length = count + bpos.boff; read_block = true; rtems_rfs_block_map_set_size_offset (map, length); } else { rtems_rfs_block_map_set_size_offset (map, 0); } /* * Only read the block if the length is not the block size. */ rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), rtems_rfs_file_buffer (handle), block, read_block); if (rc > 0) return rc; dst = rtems_rfs_buffer_data (&handle->buffer); memset (dst + bpos.boff, 0, length - bpos.boff); rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), rtems_rfs_file_buffer (handle)); if (rc > 0) return rc; count -= length - bpos.boff; } } else { /* * Shrink */ rtems_rfs_block_no blocks; uint32_t offset; blocks = rtems_rfs_block_map_count (map) - (((new_size - 1) / rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1); offset = new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); if (blocks) { int rc; rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle), rtems_rfs_file_map (handle), blocks); if (rc > 0) return rc; } rtems_rfs_block_map_set_size_offset (map, offset); if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle), rtems_rfs_block_map_size (map))) rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), rtems_rfs_file_bpos (handle)); } } handle->shared->size.count = rtems_rfs_block_map_count (map); handle->shared->size.offset = rtems_rfs_block_map_size_offset (map); if (rtems_rfs_file_update_mtime (handle)) handle->shared->mtime = time (NULL); } return 0; }
int rtems_rfs_file_io_end (rtems_rfs_file_handle* handle, size_t size, bool read) { bool atime; bool mtime; bool length; int rc = 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) printf ("rtems-rfs: file-io: end: %s size=%zu\n", read ? "read" : "write", size); if (rtems_rfs_buffer_handle_has_block (&handle->buffer)) { if (!read) rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), rtems_rfs_file_buffer (handle)); if (rc > 0) { printf ( "rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n", read ? "read" : "write", size, rc, strerror (rc)); return rc; } } /* * Update the handle's position. Only a block size can be handled at a time * so no special maths is needed. If the offset is bigger than the block size * increase the block number and adjust the offset. * * If we are the last block and the position is past the current size update * the size with the new length. The map holds the block count. */ handle->bpos.boff += size; if (handle->bpos.boff >= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) { handle->bpos.bno++; handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); } length = false; mtime = false; if (!read && rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), rtems_rfs_file_bpos (handle))) { rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle), handle->bpos.boff); length = true; mtime = true; } atime = rtems_rfs_file_update_atime (handle); mtime = rtems_rfs_file_update_mtime (handle) && mtime; length = rtems_rfs_file_update_length (handle) && length; if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n", handle->bpos.bno, handle->bpos.boff, atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-'); if (atime || mtime) { time_t now = time (NULL); if (read && atime) handle->shared->atime = now; if (!read && mtime) handle->shared->mtime = now; } if (length) { handle->shared->size.count = rtems_rfs_block_map_count (rtems_rfs_file_map (handle)); handle->shared->size.offset = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)); } return rc; }
static bool rtems_rfs_write_superblock (rtems_rfs_file_system* fs) { rtems_rfs_buffer_handle handle; uint8_t* sb; int rc; rc = rtems_rfs_buffer_handle_open (fs, &handle); if (rc > 0) { printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n", rc, strerror (rc)); return false; } rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("rtems-rfs: write-superblock: request failed: %d: %s\n", rc, strerror (rc)); return false; } sb = rtems_rfs_buffer_data (&handle); #define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d) memset (sb, 0xff, rtems_rfs_fs_block_size (fs)); write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC); write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION); write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs)); write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs)); write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks); write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length); write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes); write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE); rtems_rfs_buffer_mark_dirty (&handle); rc = rtems_rfs_buffer_handle_release (fs, &handle); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n", rc, strerror (rc)); return false; } rc = rtems_rfs_buffer_handle_close (fs, &handle); if (rc > 0) { printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n", rc, strerror (rc)); return false; } return true; }
static bool rtems_rfs_write_group (rtems_rfs_file_system* fs, int group, bool initialise_inodes, bool verbose) { rtems_rfs_buffer_handle handle; rtems_rfs_bitmap_control bitmap; rtems_rfs_buffer_block group_base; size_t group_size; int blocks; int b; int rc; group_base = rtems_rfs_fs_block (fs, group, 0); if (group_base > rtems_rfs_fs_blocks (fs)) { printf ("rtems-rfs: write-group: group %d base beyond disk limit\n", group); return false; } group_size = fs->group_blocks; /* * Be nice to strange sizes of disks. These are embedded systems after all * and nice numbers do not always work out. Let the last block pick up the * remainder of the blocks. */ if ((group_base + group_size) > rtems_rfs_fs_blocks (fs)) group_size = rtems_rfs_fs_blocks (fs) - group_base; if (verbose) printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd", group, group_base, group_size); /* * Open a handle and request an empty buffer. */ rc = rtems_rfs_buffer_handle_open (fs, &handle); if (rc > 0) { printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n", rc, strerror (rc)); return false; } if (verbose) printf (", blocks"); /* * Open the block bitmap using the new buffer. */ rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size, group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Force the whole buffer to a known state. The bit map may not occupy the * whole block. */ memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs)); /* * Clear the bitmap. */ rc = rtems_rfs_bitmap_map_clear_all (&bitmap); if (rc > 0) { rtems_rfs_bitmap_close (&bitmap); rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Forced allocation of the block bitmap. */ rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK); /* * Forced allocation of the inode bitmap. */ rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK); /* * Determine the number of inodes blocks in the group. */ blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block); /* * Forced allocation of the inode blocks which follow the block bitmap. */ for (b = 0; b < blocks; b++) rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK); /* * Close the block bitmap. */ rc = rtems_rfs_bitmap_close (&bitmap); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } rtems_rfs_buffer_mark_dirty (&handle); if (verbose) printf (", inodes"); /* * Open the inode bitmap using the old buffer. Should release any changes. */ rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size, group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Force the whole buffer to a known state. The bit map may not occupy the * whole block. */ memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs)); /* * Clear the inode bitmap. */ rc = rtems_rfs_bitmap_map_clear_all (&bitmap); if (rc > 0) { rtems_rfs_bitmap_close (&bitmap); rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \ " clear all failed: %d: %s\n", group, rc, strerror (rc)); return false; } /* * Close the inode bitmap. */ rc = rtems_rfs_bitmap_close (&bitmap); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: close inode" \ " bitmap failed: %d: %s\n", group, rc, strerror (rc)); return false; } rtems_rfs_buffer_mark_dirty (&handle); /* * Initialise the inode tables if required to do so. */ if (initialise_inodes) { for (b = 0; b < blocks; b++) { rc = rtems_rfs_buffer_handle_request (fs, &handle, group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK, false); if (rc > 0) { rtems_rfs_buffer_handle_close (fs, &handle); printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n", group, group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK, rc, strerror (rc)); return false; } /* * Force the whole buffer to a known state. The bit map may not occupy the * whole block. */ memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs)); rtems_rfs_buffer_mark_dirty (&handle); } } rc = rtems_rfs_buffer_handle_close (fs, &handle); if (rc > 0) { printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n", rc, strerror (rc)); return false; } return true; }