/* precond: fileCache locked or single thread use */ iFuseDesc_t *newIFuseDesc (char *objPath, char *localPath, fileCache_t *fileCache, int *status) { iFuseDesc_t *desc; LOCK_STRUCT(*IFuseDescFreeList); /* printf("******************************************************\n"); printf("num of desc slots free = %d\n", _listSize(IFuseDescFreeList)); printf("******************************************************\n"); */ if(_listSize(IFuseDescFreeList)!=0) { ListNode *node = IFuseDescFreeList->list->head; desc = (iFuseDesc_t *) node->value; listRemoveNoRegion(IFuseDescFreeList->list, node); UNLOCK_STRUCT(*IFuseDescFreeList); REF_NO_LOCK(desc->fileCache, fileCache); desc->objPath = strdup (objPath); desc->localPath = strdup (localPath); INIT_STRUCT_LOCK(*desc); *status = 0; return desc; } else { UNLOCK_STRUCT(*IFuseDescFreeList); rodsLog (LOG_ERROR, "allocIFuseDesc: Out of iFuseDesc"); *status = SYS_OUT_OF_FILE_DESC; return NULL; } }
fl_concurrentList_t *fl_newConcurrentList() { fl_List *l = fl_newList(); fl_concurrentList_t *cl = (fl_concurrentList_t *) malloc(sizeof (fl_concurrentList_t)); cl->list = l; INIT_STRUCT_LOCK(*cl); return cl; }
concurrentList_t *newConcurrentList() { List *l = newListNoRegion(); concurrentList_t *cl = (concurrentList_t *) malloc(sizeof (concurrentList_t)); cl->list = l; INIT_STRUCT_LOCK(*cl); return cl; }
fileCache_t *newFileCache(int iFd, char *objPath, char *localPath, char *cacheFilePath, time_t cachedTime, int mode, cacheState_t state) { fileCache_t *fileCache = (fileCache_t *) malloc(sizeof(fileCache_t)); if (fileCache == NULL) return NULL; fileCache->fileCachePath = cacheFilePath == NULL?NULL:strdup(cacheFilePath); fileCache->localPath = strdup(localPath); fileCache->objPath = strdup(objPath); fileCache->cachedTime = cachedTime; fileCache->mode = mode; fileCache->fileSize = 0; fileCache->iFd = iFd; fileCache->state = state; fileCache->status = 0; INIT_STRUCT_LOCK(*fileCache); return fileCache; }
iFuseConn_t *newIFuseConn(int *status) { iFuseConn_t *tmpIFuseConn = (iFuseConn_t *) malloc (sizeof (iFuseConn_t)); if (tmpIFuseConn == NULL) { *status = SYS_MALLOC_ERR; return NULL; } bzero (tmpIFuseConn, sizeof (iFuseConn_t)); INIT_STRUCT_LOCK(*tmpIFuseConn); INIT_LOCK(tmpIFuseConn->inuseLock); *status = ifuseConnect (tmpIFuseConn, &MyRodsEnv); /*rodsLog(LOG_ERROR, "[ NEW IFUSE CONN] %s:%d %p", __FILE__, __LINE__, tmpIFuseConn);*/ return tmpIFuseConn; }
int mknodLazyUploadBufferedFile(const char *path) { int status; lazyUploadFileInfo_t *lazyUploadFileInfo = NULL; char iRODSPath[MAX_NAME_LEN]; char bufferPath[MAX_NAME_LEN]; // convert input path to iRODSPath status = _getiRODSPath(path, iRODSPath); if(status < 0) { rodsLog (LOG_DEBUG, "mknodLazyUploadBufferedFile: failed to get iRODS path - %s", path); return status; } status = _getBufferPath(iRODSPath, bufferPath); if(status < 0) { rodsLog (LOG_DEBUG, "mknodLazyUploadBufferedFile: failed to get buffer path - %s", iRODSPath); return status; } LOCK(LazyUploadLock); // make dir makeParentDirs(bufferPath); // create an empty file rodsLog (LOG_DEBUG, "mknodLazyUploadBufferedFile: create a new Buffered file - %s", iRODSPath); int desc = open (bufferPath, O_RDWR|O_CREAT|O_TRUNC, 0755); close (desc); // add to hash table lazyUploadFileInfo = (lazyUploadFileInfo_t *)malloc(sizeof(lazyUploadFileInfo_t)); lazyUploadFileInfo->path = strdup(iRODSPath); lazyUploadFileInfo->accmode = 0; // clear lazyUploadFileInfo->localHandle = -1; // clear lazyUploadFileInfo->commitCount = 0; // clear lazyUploadFileInfo->curLocalOffsetStart = 0; // clear lazyUploadFileInfo->curOffset = 0; // clear INIT_STRUCT_LOCK((*lazyUploadFileInfo)); insertIntoHashTable(LazyUploadBufferedFileTable_Created, iRODSPath, lazyUploadFileInfo); UNLOCK(LazyUploadLock); return status; }
/* precond: fileCache locked or single thread use */ pathCache_t *newPathCache (char *inPath, fileCache_t *fileCache, struct stat *stbuf, time_t cachedTime) { pathCache_t *tmpPathCache; tmpPathCache = (pathCache_t *) malloc (sizeof (pathCache_t)); if (tmpPathCache == NULL) return NULL; tmpPathCache->localPath = strdup (inPath); tmpPathCache->cachedTime = cachedTime; tmpPathCache->expired = 0; REF_NO_LOCK(tmpPathCache->fileCache, fileCache); tmpPathCache->iFuseConn = NULL; INIT_STRUCT_LOCK(*tmpPathCache); if (stbuf != NULL) { tmpPathCache->stbuf = *stbuf; } else { bzero(&(tmpPathCache->stbuf), sizeof(struct stat)); } return tmpPathCache; }
int initIFuseDesc () { #ifndef USE_BOOST pthread_mutex_init (&PathCacheLock, NULL); pthread_mutex_init (&ConnManagerLock, NULL); pthread_cond_init (&ConnManagerCond, NULL); IFuseDescFreeList = newConcurrentList(); int i; for(i=0;i<MAX_IFUSE_DESC;i++) { INIT_STRUCT_LOCK(IFuseDesc[i]); IFuseDesc[i].index = i; if(i>=3) { addToConcurrentList(IFuseDescFreeList, &IFuseDesc[i]); } } #endif // JMC - overwrites objects construction? - memset (IFuseDesc, 0, sizeof (iFuseDesc_t) * MAX_IFUSE_DESC); return (0); }
int openPreloadedFile (const char *path) { int status; char iRODSPath[MAX_NAME_LEN]; char preloadCachePath[MAX_NAME_LEN]; preloadFileHandleInfo_t *preloadFileHandleInfo = NULL; int desc; status = _getiRODSPath(path, iRODSPath); if(status < 0) { rodsLogError(LOG_ERROR, status, "openPreloadedFile: _getiRODSPath error."); rodsLog (LOG_ERROR, "openPreloadedFile: failed to get iRODS path - %s", path); return status; } status = _getCachePath(iRODSPath, preloadCachePath); if(status < 0) { rodsLogError(LOG_ERROR, status, "openPreloadedFile: _getCachePath error."); rodsLog (LOG_ERROR, "openPreloadedFile: failed to get cache path - %s", path); return status; } LOCK(PreloadLock); desc = -1; preloadFileHandleInfo = (preloadFileHandleInfo_t *)lookupFromHashTable(PreloadFileHandleTable, iRODSPath); if(preloadFileHandleInfo != NULL) { // has preload file handle opened if(preloadFileHandleInfo->handle > 0) { // reuse handle desc = preloadFileHandleInfo->handle; rodsLog (LOG_DEBUG, "openPreloadedFile: file is already opened - %s", iRODSPath); } else { // reuse handleinfo if(_hasCache(iRODSPath) >= 0) { desc = open (preloadCachePath, O_RDONLY); if(desc > 0) { preloadFileHandleInfo->handle = desc; rodsLog (LOG_DEBUG, "openPreloadedFile: opens a file handle - %s", iRODSPath); } } } } else { // if preloaded cache file is not opened // open new if(_hasCache(iRODSPath) >= 0) { desc = open (preloadCachePath, O_RDONLY); rodsLog (LOG_DEBUG, "openPreloadedFile: open a preloaded cache path - %s", iRODSPath); if(desc > 0) { preloadFileHandleInfo = (preloadFileHandleInfo_t *)malloc(sizeof(preloadFileHandleInfo_t)); preloadFileHandleInfo->path = strdup(iRODSPath); preloadFileHandleInfo->handle = desc; INIT_STRUCT_LOCK((*preloadFileHandleInfo)); insertIntoHashTable(PreloadFileHandleTable, iRODSPath, preloadFileHandleInfo); } } } UNLOCK(PreloadLock); return desc; }
int preloadFile (const char *path, struct stat *stbuf) { int status; preloadThreadInfo_t *existingThreadInfo = NULL; preloadThreadInfo_t *threadInfo = NULL; preloadThreadData_t *threadData = NULL; char iRODSPath[MAX_NAME_LEN]; off_t cacheSize; // convert input path to iRODSPath status = _getiRODSPath(path, iRODSPath); if(status < 0) { rodsLogError(LOG_ERROR, status, "preloadFile: _getiRODSPath error."); rodsLog (LOG_ERROR, "preloadFile: failed to get iRODS path - %s", path); return status; } // check the given file is already preloaded or preloading LOCK(PreloadLock); // check the given file is preloading existingThreadInfo = (preloadThreadInfo_t *)lookupFromHashTable(PreloadThreadTable, iRODSPath); if(existingThreadInfo != NULL) { rodsLog (LOG_DEBUG, "preloadFile: preloading is already running - %s", iRODSPath); UNLOCK(PreloadLock); return 0; } if(_hasValidCache(iRODSPath, stbuf) != 0) { // invalidate cache - this may fail if cache file does not exists // if old cache exists in local, invalidate it _invalidateCache(iRODSPath); if(stbuf->st_size < PreloadConfig.preloadMinSize) { rodsLog (LOG_DEBUG, "preloadFile: given file is smaller than preloadMinSize, canceling preloading - %s", iRODSPath); UNLOCK(PreloadLock); return (0); } // check whether preload cache exceeds limit if(PreloadConfig.cacheMaxSize > 0) { // cache max size is set if(stbuf->st_size > (off_t)PreloadConfig.cacheMaxSize) { rodsLog (LOG_DEBUG, "preloadFile: given file is bigger than cacheMaxSize, canceling preloading - %s", iRODSPath); UNLOCK(PreloadLock); return (0); } cacheSize = getFileSizeRecursive(PreloadConfig.cachePath); if((cacheSize + stbuf->st_size) > (off_t)PreloadConfig.cacheMaxSize) { // evict? status = _evictOldCache((cacheSize + stbuf->st_size) - (off_t)PreloadConfig.cacheMaxSize); if(status < 0) { rodsLog (LOG_ERROR, "preloadFile: failed to evict old cache"); UNLOCK(PreloadLock); return status; } } } // does not have valid cache. now, start a new preloading // create a new thread to preload threadInfo = (preloadThreadInfo_t *)malloc(sizeof(preloadThreadInfo_t)); threadInfo->path = strdup(iRODSPath); threadInfo->running = PRELOAD_THREAD_RUNNING; INIT_STRUCT_LOCK((*threadInfo)); insertIntoHashTable(PreloadThreadTable, iRODSPath, threadInfo); // prepare thread argument threadData = (preloadThreadData_t *)malloc(sizeof(preloadThreadData_t)); threadData->path = strdup(iRODSPath); memcpy(&threadData->stbuf, stbuf, sizeof(struct stat)); threadData->threadInfo = threadInfo; rodsLog (LOG_DEBUG, "preloadFile: start preloading - %s", iRODSPath); #ifdef USE_BOOST status = threadInfo->thread = new boost::thread(_preloadThread, (void *)threadData); #else status = pthread_create(&threadInfo->thread, NULL, _preloadThread, (void *)threadData); #endif } else { rodsLog (LOG_DEBUG, "preloadFile: given file is already preloaded - %s", iRODSPath); status = 0; } UNLOCK(PreloadLock); return status; }