ntfs-84/kext/ntfs_index.c

234 		INDEX_ENTRY **entries;
242 		entries = ictx->entries;
244 			entries[u] = (INDEX_ENTRY*)((u8*)entries[u] + delta);
294 	if (ictx->entries)
295 		OSFree(ictx->entries, ictx->max_entries * sizeof(INDEX_ENTRY*),
336  * ntfs_index_get_entries - get the entries for the index node into the context
337  * @ictx:	index context for which to get the entries
339  * Loop through the entries in the index node described by @ictx and gather all
340  * the index entries into the @ictx->entries array which is also allocated by
352 	INDEX_ENTRY *ie, **entries;
366 	entries = OSMalloc(max_entries * sizeof(INDEX_ENTRY*), ntfs_malloc_tag);
367 	if (!entries) {
394 		entries[nr_entries++] = ie;
413 	ictx->entries = entries;
418 	OSFree(entries, max_entries * sizeof(INDEX_ENTRY*), ntfs_malloc_tag);
523 	 * Work out the absolute maximum number of entries there can be in an
532 	 * entries there can be in the index root and if they are more than the
803  * Perform a binary search through the index entries in the index node
827 	INDEX_ENTRY *ie, **entries;
837 	entries = ictx->entries;
848 	 * Now do a binary search through the index entries looking for the
863 		ie = entries[cur_entry];
903 			/* Exclude the wrong half or remaining entries. */
905 			/* Find the middle of the remaining entries. */
926 		/* Exclude the wrong half or remaining entries. */
928 		/* Find the middle of the remaining entries. */
932 	ictx->follow_entry = entries[cur_entry];
1064  * Start searching at the beginning of the B+tree, counting each of the entries
1114 	ictx->entry = ictx->entries[0];
1118 	 * Iterate over the entries in the B+tree counting them up until we
1132 			ictx->entry = ictx->entries[0];
1145 			 * No need to skip any entries if the current entry is
1156 				ictx->entry = ictx->entries[nr];
1165 		 * @ictx->nr_entries - 1 real index entries.
1209 		ictx->entry = ictx->entries[++ictx->entry_nr];
1297 			ictx->entry = ictx->entries[++ictx->entry_nr];
1357 	ictx->entry = ictx->entries[++ictx->entry_nr];
1368 		ictx->entry = ictx->entries[0];
1818 		 * attribute list attribute entries referencing extent mft
1825 		 * If there are other attribute list attribute entries
2273  * Finally all index entries contained in the index root attribute are moved
2277  * so we can move the entries from the index root attribute to the index
2287  * first index block and move the index entries from the index root into it.
2345 	ir_ictx->entries = OSMalloc(ictx->max_entries * sizeof(INDEX_ENTRY*),
2347 	if (!ir_ictx->entries) {
2399 	 * Set up the index block and copy the index entries from the index
2411 	/* Work out the size of the index entries in the index root. */
2417 	 * any space being wasted due to a too long index for its entries.
2452 	 * We have copied the index entries and switched the index context so
2788 	ir_ictx->entries[0] = ir_ictx->entry = ie;
2949 		INDEX_ENTRY **entries;
2963 		entries = ictx->entries;
2964 		delta = (u8*)ictx->entry - (u8*)entries[ictx->entry_nr];
2966 			entries[i] = (INDEX_ENTRY*)((u8*)entries[i] + delta);
2967 		if (ictx->entry != entries[ictx->entry_nr])
2968 			panic("%s(): ictx->entry != entries[ictx->entry_nr]\n",
3221 	ictx->entry = ictx->entries[ictx->entry_nr];
3277  * of entries in the array because on success it means that the index entry
3303 		 * entries within the attribute into a single operation.
3338  * of entries in the array because on success it means that the index entry
3358 		/* Move the index entries to make space for the new entry. */
3379  * of entries in the array because on success it means that the index entry
3426 	INDEX_ENTRY **entries;
3445 	entries = old->entries;
3447 		entries[u] = (INDEX_ENTRY*)((u8*)entries[u] + delta);
3578  * of entries in the array because on success it means that the index node has
3747 		 * entries at 0 and not 1 thus we apply a - 1 for that.  Thus
3760 		 * number of entries is even there are two possible medians.
3809 					entries[median_entry_nr]->length);
3839 		 * entries moved out to an index block.  That is fine as we
3840 		 * have not looked at any of our parent entries yet and the
4015 			entry = insert_ictx->entries[
4228 		 * specified by @promote_entry_nr and move all entries after it
4231 		 * entries after it to the right-hand node (@promote_inserted
4263 		 * First, copy the appropriate entries to the right-hand node
4271 		entry = cur_ictx->entries[u];
4283 			entry = cur_ictx->entries[u];
4285 		end_entry = cur_ictx->entries[cur_ictx->nr_entries - 1];
4300 			entry = cur_ictx->entries[cur_ictx->promote_entry_nr];
4432 			entry = cur_ictx->entries[cur_ictx->promote_entry_nr +
4541  * of entries in the array because on success it means that the index node has
4605 		ictx->follow_entry = ictx->entries[entry_nr];
4614 	ictx->entry = ictx->entries[entry_nr];
4681 		 * attribute and the moving of index entries within the
4970 	 * index is deleted or when the index is filled again with entries.
4988 				"repopulated with entries.", err);
5018 					"deleted or repopulated with entries.",
5031  * ntfs_index_make_empty - make an index empty discarding all entries in it
5156 	 * index is deleted or when the index is filled again with entries.
5163 				"repopulated with entries.");
5176 					"entries.");
5244  * of entries in the array because on success it means that the index entry has
5274 	/* We cannot delete end entries as they do not contain any key/data. */
5395 	 * To do this we ascend the tree looking for a node with entries in it.
5396 	 * The first node containing any entries is the node containing the
5511 		suc_ictx->follow_entry = suc_ictx->entries[0];
5561 	 * Move all the entries out of the way to make space for the
5599 		 * entries back into their old place and resetting the index
5628 	parent_ictx->entry = parent_ictx->entries[pull_down_entry_nr];
5646 	 * entry behind which we need to insert the two predecessor entries.
5662 	parent_ictx->follow_entry = parent_ictx->entries[parent_ictx->entry_nr];
5680 		suc_ictx->follow_entry = suc_ictx->entries[suc_ictx->entry_nr];
5720 	 * the entries.
5825 	 * update it to reflect the addition of the two index entries.
5836 	pred_ictx->entries[pred_ictx->entry_nr] = pred_ictx->entry;
5837 	pred_ictx->entries[pred_ictx->entry_nr + 1] = (INDEX_ENTRY*)(
6151 		suc_ictx->follow_entry = suc_ictx->entries[0];
6196 	 * Move all the entries out of the way to make space for the parent
6207 	pull_down_entry = parent_ictx->entries[pull_down_entry_nr];
6272 			parent_ictx->entries[parent_ictx->entry_nr];
6288 		suc_ictx->follow_entry = suc_ictx->entries[suc_ictx->entry_nr];
6394 	*(leVCN*)((u8*)parent_ictx->entries[old_parent_entry_nr] +
6425 		 * Move the index entries following @ie into @ie's position.
6427 		 * entries and the resizing of the index root attribute into a
6444 		/* Move index entries following @ie into @ie's position. */