hfs-285/fsck_hfs/cache.c

56 CacheFreeBlock( Cache_t *cache, Tag_t *tag );
64 int CacheLookup (Cache_t *cache, uint64_t off, Tag_t **tag);
122  *        of an actively referenced cache buffer, leaving the tag behind as a
199 	void **		temp;
263 	temp = cache->FreeHead;
265 		*temp = ((char *)temp + cacheBlockSize);
266 		temp  = (void **)((char *)temp + cacheBlockSize);
268 	*temp = NULL;
332 	Tag_t *		tag;
378 	error = CacheLookup (cache, cblk, &tag);
389 		buf->Buffer = tag->Buffer + coff;
392 		tag->Refs++;
395 		LRUHit (&cache->LRU, (LRUNode_t *)tag, 0);
401 		uint32_t	temp;
403 		/* Allocate a temp buffer */
416 		printf("INFO:  memcpy(%p, %p + %u, %u)\n", buf->Buffer, tag->Buffer, coff, boff);
418 		memcpy (buf->Buffer, tag->Buffer + coff, boff);
421 		tag->Refs++;
424 		LRUHit (&cache->LRU, (LRUNode_t *)tag, 0);
432 			error = CacheLookup (cache, cblk, &tag);
441 					if (CacheLookup (cache, cblk, &tag) != EOK) {
445 					tag->Refs--;
448 					LRUHit (&cache->LRU, (LRUNode_t *)tag, 0);
455 			temp = ((blen > cache->BlockSize) ? cache->BlockSize : blen);
457 			printf ("INFO:  memcpy(%p + %u, %p, %u)\n", buf->Buffer, boff, tag->Buffer, temp);
460 			        tag->Buffer,
461 					temp);
464 			boff += temp;
465 			blen -= temp;
466 			tag->Refs++;
472 			LRUHit (&cache->LRU, (LRUNode_t *)tag, 0);
507 	Tag_t *		tag;
513 	error = CacheLookup (cache, cblk, &tag);
521 			/* Copy flags to tag */
522 			tag->Flags |= (writeOptions & (kLazyWrite | kLockWrite));
527 								   tag->Offset,
529 								   tag->Buffer);
535 			tag->Refs--;
538 		LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
544 		uint32_t	temp;
549 		memcpy (tag->Buffer + coff, buf->Buffer, boff);
555 			tag->Flags |= (writeOptions & (kLazyWrite | kLockWrite));
560 								   tag->Offset,
562 								   tag->Buffer);
568 			tag->Refs--;
571 		LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
579 			error = CacheLookup (cache, cblk, &tag);
583 			temp = ((blen > cache->BlockSize) ? cache->BlockSize : blen);
584 			memcpy (tag->Buffer,
586 					temp);
592 				tag->Flags |= (writeOptions & (kLazyWrite | kLockWrite));
597 									   tag->Offset,
599 									   tag->Buffer);
604 			boff += temp;
605 			blen -= temp;
607 				tag->Refs--;
610 			LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
647 	Tag_t *		tag;
653 	error = CacheLookup (cache, cblk, &tag);
664 		if ((tag->Flags & kLockWrite) == 0) {
665 			tag->Refs--;
669 		LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
679 		if ((tag->Flags & kLockWrite) == 0) {
680 			tag->Refs--;
684 		LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
692 			error = CacheLookup (cache, cblk, &tag);
697 			if ((tag->Flags & kLockWrite) == 0)
698 				tag->Refs--;
701 			LRUHit (&cache->LRU, (LRUNode_t *)tag, age);
731 int CacheRemove (Cache_t *cache, Tag_t *tag)
736 	if (tag->Refs) return (EBUSY);
738 	/* Detach the tag */
739 	if (tag->Next != NULL)
740 		tag->Next->Prev = tag->Prev;
741 	if (tag->Prev != NULL)
742 		tag->Prev->Next = tag->Next;
744 		cache->Hash[tag->Offset % cache->HashSize] = tag->Next;
747 	if ((cache->Hash[tag->Offset % cache->HashSize] != NULL) &&
748 	    (cache->Hash[tag->Offset % cache->HashSize]->Prev != NULL)) {
755 	if (tag->Buffer != NULL)
757 		error = CacheFreeBlock (cache, tag);
762 	/* Zero the tag (for easy debugging) */
763 	memset (tag, 0x00, sizeof (Tag_t));
765 	/* Free the tag */
766 	free (tag);
774  *  Only dispose of the buffer, leave the tag intact.
776 int CacheEvict (Cache_t *cache, Tag_t *tag)
781 	if (tag->Refs) return (EBUSY);
784 	if (tag->Buffer != NULL)
786 		error = CacheFreeBlock (cache, tag);
790 	tag->Buffer = NULL;
802 	void *	temp;
809 	temp = cache->FreeHead;
813 	return (temp);
822 CacheFreeBlock( Cache_t *cache, Tag_t *tag )
826 	if ( (tag->Flags & kLazyWrite) != 0 )
830 							   tag->Offset,
832 							   tag->Buffer );
840 		tag->Flags &= ~kLazyWrite;
843 	if ((tag->Flags & kLockWrite) == 0)
845 		*((void **)tag->Buffer) = cache->FreeHead;
846 		cache->FreeHead = (void **)tag->Buffer;
1222 int CacheLookup (Cache_t *cache, uint64_t off, Tag_t **tag)
1224 	Tag_t *		temp;
1228 	*tag = NULL;
1232 	temp = cache->Hash[hash];
1233 	while (temp != NULL) {
1234 		if (temp->Offset == off) break;
1235 		temp = temp->Next;
1239 	if (temp != NULL) {
1241 		if (cache->Hash[hash] != temp) {
1242 			/* Disconnect the tag */
1243 			if (temp->Next != NULL)
1244 				temp->Next->Prev = temp->Prev;
1245 			temp->Prev->Next = temp->Next;
1250 		/* Allocate a new tag */
1251 		temp = (Tag_t *)calloc (sizeof (Tag_t), 1);/* We really only need to zero the
1253 		temp->Offset = off;
1255 		/* Kick the tag onto the LRU */
1256 		//LRUHit (&cache->LRU, (LRUNode_t *)temp, 0);
1260 	if (cache->Hash[hash] != temp) {
1261 		temp->Prev = NULL;
1262 		temp->Next = cache->Hash[hash];
1263 		if (temp->Next != NULL)
1264 			temp->Next->Prev = temp;
1265 		cache->Hash[hash] = temp;
1269 	if (temp->Buffer == NULL) {
1271 		temp->Buffer = CacheAllocBlock (cache);
1272 		if (temp->Buffer == NULL) {
1274 			error = LRUEvict (&cache->LRU, (LRUNode_t *)temp);
1278 			temp->Buffer = CacheAllocBlock (cache);
1279 			if (temp->Buffer == NULL) {
1288 		error = CacheRawRead (cache, off, cache->BlockSize, temp->Buffer);
1293 	if (temp && temp->Flags & kLockWrite) {
1294 		fprintf(stderr, "CacheLookup(%p, %llu, %p):  Found cache-locked block\n", cache, off, tag);
1298 	*tag = temp;
1446  *        of an actively referenced cache buffer, leaving the tag behind as a
1454 	LRUNode_t *	temp;
1459 		temp = lru->Head.Prev;
1462 		if (temp == &lru->Head) {
1470 		temp->Next->Prev = temp->Prev;
1471 		temp->Prev->Next = temp->Next;
1474 		if (!((Tag_t *)temp)->Refs) break;
1477 		temp->Next = lru->Busy.Next;
1478 		temp->Prev = &lru->Busy;
1480 		temp->Next->Prev = temp;
1481 		temp->Prev->Next = temp;
1486 	/* Remove the tag */
1487 	CacheRemove ((Cache_t *)lru, (Tag_t *)temp);
1509 		Tag_t *tag;
1511 		for (tag = cache->Hash[i]; tag; tag = tag->Next) {
1514 			       tag->Offset, tag->Refs, tag->Flags,
1515 			       (tag->Flags & kLazyWrite) ? "" : "no ",
1516 			       (tag->Flags & kLockWrite) ? "" : "no ");