tracker_mem.c

文件系统源代码!!!!! 文件系统源代码

	tracker_free_last_sync_timestamps(pGroup->last_sync_timestamps, \
				pGroup->alloc_size);
	pGroup->last_sync_timestamps = NULL;

}

int tracker_mem_destroy()
{
	FDFSGroupInfo *pGroup;
	FDFSGroupInfo *pEnd;
	int result;

	if (g_groups.groups == NULL)
	{
		result = 0;
	}
	else
	{
		result = tracker_save_storages();
		result += tracker_save_sync_timestamps();

		pEnd = g_groups.groups + g_groups.count;
		for (pGroup=g_groups.groups; pGroup<pEnd; pGroup++)
		{
			tracker_mem_free_group(pGroup);
		}

		if (g_groups.sorted_groups != NULL)
		{
			free(g_groups.sorted_groups);
		}

		if (g_groups.groups[0].ref_count != NULL)
		{
			free(g_groups.groups[0].ref_count);
		}

		free(g_groups.groups);
		g_groups.groups = NULL;
	}

	if (pthread_mutex_destroy(&mem_thread_lock) != 0)
	{
		logError("file: "__FILE__", line: %d, " \
			"call pthread_mutex_destroy fail", \
			__LINE__);
	}

	return result;
}

int tracker_mem_realloc_groups()
{
	FDFSGroupInfo *old_groups;
	FDFSGroupInfo **old_sorted_groups;
	FDFSGroupInfo *new_groups;
	FDFSGroupInfo **new_sorted_groups;
	int new_size;
	FDFSGroupInfo *pGroup;
	FDFSGroupInfo *pEnd;
	FDFSGroupInfo **ppSrcGroup;
	FDFSGroupInfo **ppDestGroup;
	FDFSGroupInfo **ppEnd;
	int *new_ref_count;

	new_size = g_groups.alloc_size + TRACKER_MEM_ALLOC_ONCE;
	new_groups = (FDFSGroupInfo *)malloc(sizeof(FDFSGroupInfo) * new_size);
	if (new_groups == NULL)
	{
		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(FDFSGroupInfo) * new_size);
		return errno != 0 ? errno : ENOMEM;
	}

	new_sorted_groups = (FDFSGroupInfo **)malloc( \
			sizeof(FDFSGroupInfo *) * new_size);
	if (new_sorted_groups == NULL)
	{
		free(new_groups);
		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(FDFSGroupInfo *) * new_size);
		return errno != 0 ? errno : ENOMEM;
	}

	new_ref_count = (int *)malloc(sizeof(int));
	if (new_ref_count == NULL)
	{
		free(new_groups);
		free(new_sorted_groups);
		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(int));
		return errno != 0 ? errno : ENOMEM;
	}

	memset(new_groups, 0, sizeof(FDFSGroupInfo) * new_size);
	memcpy(new_groups, g_groups.groups, \
		sizeof(FDFSGroupInfo) * g_groups.count);

	memset(new_sorted_groups, 0, sizeof(FDFSGroupInfo *) * new_size);
	ppDestGroup = new_sorted_groups;
	ppEnd = g_groups.sorted_groups + g_groups.count;
	for (ppSrcGroup=g_groups.sorted_groups; ppSrcGroup<ppEnd; ppSrcGroup++)
	{
		*ppDestGroup++ = new_groups + (*ppSrcGroup - g_groups.groups);
	}

	*new_ref_count = 0;
	pEnd = new_groups + new_size;
	for (pGroup=new_groups; pGroup<pEnd; pGroup++)
	{
		pGroup->ref_count = new_ref_count;
	}

	old_groups = g_groups.groups;
	old_sorted_groups = g_groups.sorted_groups;
	g_groups.alloc_size = new_size;
	g_groups.groups = new_groups;
	g_groups.sorted_groups = new_sorted_groups;

	if (g_groups.store_lookup == FDFS_STORE_LOOKUP_SPEC_GROUP)
	{
		g_groups.pStoreGroup = tracker_mem_get_group( \
					g_groups.store_group);
	}

	sleep(1);

	if (*(old_groups[0].ref_count) <= 0)
	{
		free(old_groups[0].ref_count);
		free(old_groups);
	}
	else
	{
		pEnd = old_groups + g_groups.count;
		for (pGroup=old_groups; pGroup<pEnd; pGroup++)
		{
			pGroup->dirty = true;
		}
	}

	free(old_sorted_groups);

	return 0;
}

int tracker_get_group_file_count(FDFSGroupInfo *pGroup)
{
	int count;
	FDFSStorageDetail *pServer;
	FDFSStorageDetail *pServerEnd;

	count = 0;
	pServerEnd = pGroup->all_servers + pGroup->count;
	for (pServer=pGroup->all_servers; pServer<pServerEnd; pServer++)
	{
		count += pServer->stat.success_upload_count - \
				pServer->stat.success_delete_count;
	}

	return count;
}

int tracker_get_group_success_upload_count(FDFSGroupInfo *pGroup)
{
	int count;
	FDFSStorageDetail *pServer;
	FDFSStorageDetail *pServerEnd;

	count = 0;
	pServerEnd = pGroup->all_servers + pGroup->count;
	for (pServer=pGroup->all_servers; pServer<pServerEnd; pServer++)
	{
		count += pServer->stat.success_upload_count;
	}

	return count;
}

FDFSStorageDetail *tracker_get_group_sync_src_server(FDFSGroupInfo *pGroup, \
			FDFSStorageDetail *pDestServer)
{
	FDFSStorageDetail **ppServer;
	FDFSStorageDetail **ppServerEnd;

	ppServerEnd = pGroup->active_servers + pGroup->active_count;
	for (ppServer=pGroup->active_servers; ppServer<ppServerEnd; ppServer++)
	{
		if (strcmp((*ppServer)->ip_addr, pDestServer->ip_addr) == 0)
		{
			continue;
		}

		return *ppServer;
	}

	return NULL;
}

int tracker_mem_realloc_store_server(FDFSGroupInfo *pGroup, const int inc_count)
{
	int result;
	FDFSStorageDetail *old_servers;
	FDFSStorageDetail **old_sorted_servers;
	FDFSStorageDetail **old_active_servers;
	int **old_last_sync_timestamps;
	FDFSStorageDetail *new_servers;
	FDFSStorageDetail **new_sorted_servers;
	FDFSStorageDetail **new_active_servers;
	int **new_last_sync_timestamps;
	int *new_ref_count;
	int old_size;
	int new_size;
	FDFSStorageDetail *pServer;
	FDFSStorageDetail *pServerEnd;
	FDFSStorageDetail **ppDestServer;
	FDFSStorageDetail **ppSrcServer;
	FDFSStorageDetail **ppServerEnd;
	FDFSStorageSync *pStorageSyncs;
	int nStorageSyncSize;
	int nStorageSyncCount;
	int err_no;
	int i;
	
	new_size = pGroup->alloc_size + inc_count + TRACKER_MEM_ALLOC_ONCE;
	new_servers = (FDFSStorageDetail *) \
		malloc(sizeof(FDFSStorageDetail) * new_size);
	if (new_servers == NULL)
	{
		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(FDFSStorageDetail) * new_size);
		return errno != 0 ? errno : ENOMEM;
	}

	new_sorted_servers = (FDFSStorageDetail **) \
		malloc(sizeof(FDFSStorageDetail *) * new_size);
	if (new_sorted_servers == NULL)
	{
		free(new_servers);
		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(FDFSStorageDetail *) * new_size);
		return errno != 0 ? errno : ENOMEM;
	}

	new_active_servers = (FDFSStorageDetail **) \
		malloc(sizeof(FDFSStorageDetail *) * new_size);
	if (new_active_servers == NULL)
	{
		free(new_servers);
		free(new_sorted_servers);

		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(FDFSStorageDetail *) * new_size);
		return errno != 0 ? errno : ENOMEM;
	}

	memset(new_servers, 0, sizeof(FDFSStorageDetail) * new_size);
	memset(new_sorted_servers, 0, sizeof(FDFSStorageDetail *) * new_size);
	memset(new_active_servers, 0, sizeof(FDFSStorageDetail *) * new_size);
	memcpy(new_servers, pGroup->all_servers, \
		sizeof(FDFSStorageDetail) * pGroup->count);
	if (pGroup->store_path_count > 0)
	{
		for (i=pGroup->count; i<new_size; i++)
		{
			result=tracker_malloc_storage_path_mbs(new_servers+i, \
				pGroup->store_path_count);
			if (result != 0)
			{
				free(new_servers);
				free(new_sorted_servers);

				return result;
			}
		}
	}

	ppServerEnd = pGroup->sorted_servers + pGroup->count;
	ppDestServer = new_sorted_servers;
	for (ppSrcServer=pGroup->sorted_servers; ppSrcServer<ppServerEnd;
		ppSrcServer++)
	{
		*ppDestServer++ = new_servers + 
				  (*ppSrcServer - pGroup->all_servers);
	}

	ppServerEnd = pGroup->active_servers + pGroup->active_count;
	ppDestServer = new_active_servers;
	for (ppSrcServer=pGroup->active_servers; ppSrcServer<ppServerEnd;
		ppSrcServer++)
	{
		*ppDestServer++ = new_servers + 
				  (*ppSrcServer - pGroup->all_servers);
	}

	new_ref_count = (int *)malloc(sizeof(int));
	if (new_ref_count == NULL)
	{
		free(new_servers);
		free(new_sorted_servers);
		free(new_active_servers);

		logError("file: "__FILE__", line: %d, " \
			"malloc %d bytes fail", \
			__LINE__, sizeof(int));
		return errno != 0 ? errno : ENOMEM;
	}
	*new_ref_count = 0;
	pServerEnd = new_servers + new_size;
	for (pServer=new_servers; pServer<pServerEnd; pServer++)
	{
		pServer->ref_count = new_ref_count;
	}

	new_last_sync_timestamps = tracker_malloc_last_sync_timestamps( \
		new_size, &err_no);
	if (new_last_sync_timestamps == NULL)
	{
		free(new_servers);
		free(new_sorted_servers);
		free(new_active_servers);
		free(new_ref_count);

		return err_no;
	}
	for (i=0; i<pGroup->alloc_size; i++)
	{
		memcpy(new_last_sync_timestamps[i],  \
			pGroup->last_sync_timestamps[i], \
			sizeof(int) *  pGroup->alloc_size);
	}

	old_size = pGroup->alloc_size;
	old_servers = pGroup->all_servers;
	old_sorted_servers = pGroup->sorted_servers;
	old_active_servers = pGroup->active_servers;
	old_last_sync_timestamps = pGroup->last_sync_timestamps;

	pGroup->alloc_size = new_size;
	pGroup->all_servers = new_servers;
	pGroup->sorted_servers = new_sorted_servers;
	pGroup->active_servers = new_active_servers;
	pGroup->last_sync_timestamps = new_last_sync_timestamps;

	nStorageSyncSize = 0;
	nStorageSyncCount = 0;
	pStorageSyncs = NULL;

	result = 0;
	pServerEnd = new_servers + pGroup->count;
	for (pServer=new_servers; pServer<pServerEnd; pServer++)
	{
		if (pServer->psync_src_server == NULL)
		{
			continue;
		}

		if (nStorageSyncSize <= nStorageSyncCount)
		{
			nStorageSyncSize += 8;
			pStorageSyncs = (FDFSStorageSync *)realloc( \
				pStorageSyncs, \
				sizeof(FDFSStorageSync) * nStorageSyncSize);
			if (pStorageSyncs == NULL)
			{
				result = errno != 0 ? errno : ENOMEM;
				logError("file: "__FILE__", line: %d, " \
					"realloc %d bytes fail", __LINE__, \
					sizeof(FDFSStorageSync) * \
					nStorageSyncSize);
				break;
			}
		}

		pStorageSyncs[nStorageSyncCount].pGroup = pGroup;
		pStorageSyncs[nStorageSyncCount].pStorage = pServer;
		strcpy(pStorageSyncs[nStorageSyncCount].sync_src_ip_addr, \
			pServer->psync_src_server->ip_addr);
		nStorageSyncCount++;
	}

	if (pStorageSyncs != NULL)
	{
		result = tracker_locate_storage_sync_server( \
				pStorageSyncs, nStorageSyncCount, false);

		free(pStorageSyncs);
	}

	sleep(1);

	if (*(old_servers[0].ref_count) <= 0)
	{
		free(old_servers[0].ref_count);
		free(old_servers);
	}
	else
	{
		pServerEnd = old_servers + pGroup->count;
		for (pServer=old_servers; pServer<pServerEnd; pServer++)
		{
			pServer->dirty = true;
		}
	}
	
	free(old_sorted_servers);
	free(old_active_servers);
	tracker_free_last_sync_timestamps(old_last_sync_timestamps, \
				old_size);

	return result;
}

static int tracker_mem_cmp_by_group_name(const void *p1, const void *p2)
{
	return strcmp((*((FDFSGroupInfo **)p1))->group_name,
			(*((FDFSGroupInfo **)p2))->group_name);
}

static int tracker_mem_cmp_by_ip_addr(const void *p1, const void *p2)
{
	return strcmp((*((FDFSStorageDetail **)p1))->ip_addr,
			(*((FDFSStorageDetail **)p2))->ip_addr);
}

static void tracker_mem_insert_into_sorted_servers( \
		FDFSStorageDetail *pTargetServer,   \
		FDFSStorageDetail **sorted_servers, const int count)
{
	FDFSStorageDetail **ppServer;
	FDFSStorageDetail **ppEnd;

	ppEnd = sorted_servers + count;
	for (ppServer=ppEnd; ppServer>sorted_servers; ppServer--)
	{
		if (strcmp(pTargetServer->ip_addr, \
			   (*(ppServer-1))->ip_addr) > 0)
		{
			*ppServer = pTargetServer;
			return;
		}
		else
		{
			*ppServer = *(ppServer-1);
		}
	}

	*ppServer = pTargetServer;
}

static void tracker_mem_insert_into_sorted_groups( \
		FDFSGroupInfo *pTargetGroup)
{
	FDFSGroupInfo **ppGroup;
	FDFSGroupInfo **ppEnd;

	ppEnd = g_groups.sorted_groups + g_groups.count;
	for (ppGroup=ppEnd; ppGroup > g_groups.sorted_groups; ppGroup--)
	{
		if (strcmp(pTargetGroup->group_name, \
			   (*(ppGroup-1))->group_name) > 0)
		{
			*ppGroup = pTargetGroup;
			return;
		}
		else
		{
			*ppGroup = *(ppGroup-1);
		}
	}

	*ppGroup = pTargetGroup;
}

FDFSGroupInfo *tracker_mem_get_group(const char *group_name)
{
	FDFSGroupInfo target_groups;
	FDFSGroupInfo *pTargetGroups;
	FDFSGroupInfo **ppGroup;

	memset(&target_groups, 0, sizeof(target_groups));
	strcpy(target_groups.group_name, group_name);
	pTargetGroups = &target_groups;
	ppGroup = (FDFSGroupInfo **)bsearch(&pTargetGroups, \
			g_groups.sorted_groups, \
			g_groups.count, sizeof(FDFSGroupInfo *), \
			tracker_mem_cmp_by_group_name);

	if (ppGroup != NULL)
	{
		return *ppGroup;
	}
	else
	{
		return NULL;
	}
}

int tracker_mem_add_group(TrackerClientInfo *pClientInfo, \
			const bool bIncRef, bool *bInserted)
{
	FDFSGroupInfo *pGroup;
	int result;

	*bInserted = false;
	pGroup = tracker_mem_get_group(pClientInfo->group_name);
	if (pGroup != NULL)
	{
		//printf("g_groups.count=%d, found %s\n", g_groups.count, pClientInfo->group_name);
	}
	else
	{
		if ((result=pthread_mutex_lock(&mem_thread_lock)) != 0)
		{
			logError("file: "__FILE__", line: %d, " \
				"call pthread_mutex_lock fail, " \
				"errno: %d, error info: %s", \
				__LINE__, result, strerror(result));
			return result;
		}

		result = 0;
		while (1)
		{
			if (g_groups.count >= g_groups.alloc_size)
			{
				result = tracker_mem_realloc_groups();
				if (result != 0)
				{
					break;
				}
			}

			pGroup = g_groups.groups + g_groups.count;
			result = tracker_mem_init_group(pGroup);
			if (result != 0)
			{
				break;
			}

			strcpy(pGroup->group_name, pClientInfo->group_name);
			tracker_mem_insert_into_sorted_groups(pGroup);
			g_groups.count++;

			if ((g_groups.store_lookup == \
				FDFS_STORE_LOOKUP_SPEC_GROUP) && \
				(g_groups.pStoreGroup == NULL) && \
				(strcmp(g_groups.store_group, \
					pGroup->group_name) == 0))
			{
				g_groups.pStoreGroup = pGroup;
			}

			break;
		}

		if (pthread_mutex_unlock(&mem_thread_lock) != 0)
		{
			logError("file: "__FILE__", line: %d, " \
				"call pthread_mutex_unlock fail", \
				__LINE__);
			return result;
		}

		if (result != 0)
		{
			return result;
		}

		*bInserted = true;
	}

	if (bIncRef)
	{
		++(*(pGroup->ref_count));
		//printf("group ref_count=%d\n", *(pGroup->ref_count));
	}
	pClientInfo->pGroup = pGroup;
	pClientInfo->pAllocedGroups = g_groups.groups;
	return 0;
}

FDFSStorageDetail *tracker_mem_get_active_storage(FDFSGroupInfo *pGroup, \
				const char *ip_addr)
{
	FDFSStorageDetail target_storage;
	FDFSStorageDetail *pTargetStorage;
	FDFSStorageDetail **ppStorageServer;

	if (ip_addr == NULL)
	{
		return NULL;
	}

	memset(&target_storage, 0, sizeof(target_storage));
	strcpy(target_storage.ip_addr, ip_addr);
	pTargetStorage = &target_storage;
	ppStorageServer = (FDFSStorageDetail **)bsearch(&pTargetStorage, \
			pGroup->active_servers, \
			pGroup->active_count, \
			sizeof(FDFSStorageDetail *), \
			tracker_mem_cmp_by_ip_addr);
	if (ppStorageServer != NULL)
	{
		return *ppStorageServer;
	}
	else