void VA_Resize_IMP(VArray *self, uint32_t size) { if (size < self->size) { VA_Excise(self, size, self->size - size); } else if (size > self->size) { VA_Grow(self, size); } self->size = size; }
static void SI_grow_by(VArray *self, uint32_t add_size) { size_t min_size = self->size + add_size; // Check for overflow. if ((uint32_t)min_size < add_size) { THROW(ERR, "Array grew too large"); } size_t new_size = Memory_oversize(min_size, sizeof(Obj*)); if (new_size > UINT32_MAX) { new_size = UINT32_MAX; } VA_Grow(self, (uint32_t)new_size); }
static void S_add_to_file_list(Folder *self, VArray *list, CharBuf *dir, CharBuf *prefix) { size_t orig_prefix_size = CB_Get_Size(prefix); DirHandle *dh = Folder_Open_Dir(self, dir); CharBuf *entry; if (!dh) { RETHROW(INCREF(Err_get_error())); } entry = DH_Get_Entry(dh); while (DH_Next(dh)) { // Updates entry if (!S_is_updir(entry)) { CharBuf *relpath = CB_newf("%o%o", prefix, entry); if (VA_Get_Size(list) == VA_Get_Capacity(list)) { VA_Grow(list, VA_Get_Size(list) * 2); } VA_Push(list, (Obj*)relpath); if (DH_Entry_Is_Dir(dh) && !DH_Entry_Is_Symlink(dh)) { CharBuf *subdir = CB_Get_Size(dir) ? CB_newf("%o/%o", dir, entry) : CB_Clone(entry); CB_catf(prefix, "%o/", entry); S_add_to_file_list(self, list, subdir, prefix); // recurse CB_Set_Size(prefix, orig_prefix_size); DECREF(subdir); } } } if (!DH_Close(dh)) { RETHROW(INCREF(Err_get_error())); } DECREF(dh); }
static void S_discover_unused(FilePurger *self, VArray **purgables_ptr, VArray **snapshots_ptr) { Folder *folder = self->folder; DirHandle *dh = Folder_Open_Dir(folder, NULL); if (!dh) { RETHROW(INCREF(Err_get_error())); } VArray *spared = VA_new(1); VArray *snapshots = VA_new(1); CharBuf *snapfile = NULL; // Start off with the list of files in the current snapshot. if (self->snapshot) { VArray *entries = Snapshot_List(self->snapshot); VArray *referenced = S_find_all_referenced(folder, entries); VA_Push_VArray(spared, referenced); DECREF(entries); DECREF(referenced); snapfile = Snapshot_Get_Path(self->snapshot); if (snapfile) { VA_Push(spared, INCREF(snapfile)); } } CharBuf *entry = DH_Get_Entry(dh); Hash *candidates = Hash_new(64); while (DH_Next(dh)) { if (!CB_Starts_With_Str(entry, "snapshot_", 9)) { continue; } else if (!CB_Ends_With_Str(entry, ".json", 5)) { continue; } else if (snapfile && CB_Equals(entry, (Obj*)snapfile)) { continue; } else { Snapshot *snapshot = Snapshot_Read_File(Snapshot_new(), folder, entry); Lock *lock = IxManager_Make_Snapshot_Read_Lock(self->manager, entry); VArray *snap_list = Snapshot_List(snapshot); VArray *referenced = S_find_all_referenced(folder, snap_list); // DON'T obtain the lock -- only see whether another // entity holds a lock on the snapshot file. if (lock) { Lock_Clear_Stale(lock); } if (lock && Lock_Is_Locked(lock)) { // The snapshot file is locked, which means someone's using // that version of the index -- protect all of its entries. uint32_t new_size = VA_Get_Size(spared) + VA_Get_Size(referenced) + 1; VA_Grow(spared, new_size); VA_Push(spared, (Obj*)CB_Clone(entry)); VA_Push_VArray(spared, referenced); } else { // No one's using this snapshot, so all of its entries are // candidates for deletion. for (uint32_t i = 0, max = VA_Get_Size(referenced); i < max; i++) { CharBuf *file = (CharBuf*)VA_Fetch(referenced, i); Hash_Store(candidates, (Obj*)file, INCREF(&EMPTY)); } VA_Push(snapshots, INCREF(snapshot)); } DECREF(referenced); DECREF(snap_list); DECREF(snapshot); DECREF(lock); } } DECREF(dh); // Clean up after a dead segment consolidation. S_zap_dead_merge(self, candidates); // Eliminate any current files from the list of files to be purged. for (uint32_t i = 0, max = VA_Get_Size(spared); i < max; i++) { CharBuf *filename = (CharBuf*)VA_Fetch(spared, i); DECREF(Hash_Delete(candidates, (Obj*)filename)); } // Pass back purgables and Snapshots. *purgables_ptr = Hash_Keys(candidates); *snapshots_ptr = snapshots; DECREF(candidates); DECREF(spared); }