int irodsMkdir (const char *path, mode_t mode) { collInp_t collCreateInp; int status; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsMkdir: %s", path); memset (&collCreateInp, 0, sizeof (collCreateInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, collCreateInp.collName); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMkdir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); status = rcCollCreate (iFuseConn->conn, &collCreateInp); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcCollCreate (iFuseConn->conn, &collCreateInp); } unuseIFuseConn (iFuseConn); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMkdir: rcCollCreate of %s error", path); return -ENOENT; } #ifdef CACHE_FUSE_PATH } else { struct stat stbuf; uint mytime = time (0); bzero (&stbuf, sizeof (struct stat)); fillDirStat (&stbuf, mytime, mytime, mytime); pathExist ((char *) path, NULL, &stbuf, NULL); #endif unuseIFuseConn (iFuseConn); } return (0); }
/* getIFuseConnByPath - try to use the same conn as opened desc of the * same path */ iFuseConn_t *getAndUseConnByPath( char *localPath, int *status ) { iFuseConn_t *iFuseConn; /* make sure iFuseConn is not released after getAndLockIFuseDescByPath finishes */ pathCache_t *tmpPathCache = matchPathCache( pctable, localPath ); if ( tmpPathCache ) { LOCK_STRUCT( *tmpPathCache ); *status = _getAndUseConnForPathCache( &iFuseConn, tmpPathCache ); UNLOCK_STRUCT( *tmpPathCache ); } else { /* no match. just assign one */ pathExist( pctable, localPath, NULL, NULL, NULL ); // need to find a way to clean up *status = getAndUseIFuseConn( &iFuseConn ); } return iFuseConn; }
int irodsOpen (const char *path, struct fuse_file_info *fi) { dataObjInp_t dataObjInp; int status; int fd; iFuseConn_t *iFuseConn = NULL; iFuseDesc_t *desc = NULL; pathCache_t *tmpPathCache = NULL; struct stat stbuf; char cachePath[MAX_NAME_LEN]; char objPath[MAX_NAME_LEN]; int flags = fi->flags; rodsLog (LOG_DEBUG, "irodsOpen: %s, flags = %d", path, fi->flags); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache!= NULL) { if(tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*(tmpPathCache->fileCache)); if (tmpPathCache->fileCache->state != NO_FILE_CACHE) { rodsLog (LOG_DEBUG, "irodsOpen: a match for %s", path); desc = newIFuseDesc(tmpPathCache->fileCache->objPath, (char *) path, tmpPathCache->fileCache, &status); if (status < 0) { UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); rodsLogError (LOG_ERROR, status, "irodsOpen: create descriptor of %s error", dataObjInp.objPath); return status; } fi->fh = desc->index; if(tmpPathCache->fileCache->iFd == 0) { tmpPathCache->fileCache->iFd = open(tmpPathCache->fileCache->fileCachePath, O_RDWR); } UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); return (0); } UNLOCK_STRUCT(*(tmpPathCache->fileCache)); } UNLOCK_STRUCT(*tmpPathCache); } memset (&dataObjInp, 0, sizeof (dataObjInp)); dataObjInp.openFlags = flags; status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, objPath); rstrcpy(dataObjInp.objPath, objPath, MAX_NAME_LEN); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath((char *) path, &MyRodsEnv, &status); /* status = getAndUseIFuseConn(&iFuseConn, &MyRodsEnv); */ if(status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: cannot get connection for %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } /* do only O_RDONLY (0) */ status = _irodsGetattr (iFuseConn, path, &stbuf); if ((flags & (O_WRONLY | O_RDWR)) != 0 || status < 0 || stbuf.st_size > MAX_READ_CACHE_SIZE) { fd = rcDataObjOpen (iFuseConn->conn, &dataObjInp); unuseIFuseConn (iFuseConn); if (fd < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: rcDataObjOpen of %s error, status = %d", path, fd); return -ENOENT; } fileCache_t *fileCache = addFileCache(fd, objPath, (char *) path, NULL, stbuf.st_mode, stbuf.st_size, NO_FILE_CACHE); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache == NULL) { pathExist((char *) path, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc (objPath, (char *) path, fileCache, &status); if (desc == NULL) { rodsLogError (LOG_ERROR, status, "irodsOpen: allocIFuseDesc of %s error", path); return -ENOENT; } } else { rodsLog (LOG_DEBUG, "irodsOpenWithReadCache: caching %s", path); if ((status = getFileCachePath (path, cachePath)) < 0) { unuseIFuseConn(iFuseConn); return status; } /* get the file to local cache */ dataObjInp.dataSize = stbuf.st_size; status = rcDataObjGet (iFuseConn->conn, &dataObjInp, cachePath); unuseIFuseConn(iFuseConn); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpenWithReadCache: rcDataObjGet of %s error", dataObjInp.objPath); return status; } int fd = open(cachePath, O_RDWR); fileCache_t *fileCache = addFileCache(fd, objPath, (char *) path, cachePath, stbuf.st_mode, stbuf.st_size, HAVE_READ_CACHE); matchAndLockPathCache((char *) path, &tmpPathCache); if(tmpPathCache == NULL) { pathExist((char *) path, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc(objPath, (char *) path,fileCache, &status); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsOpen: create descriptor of %s error", dataObjInp.objPath); return status; } } fi->fh = desc->index; return (0); }
int irodsMknod (const char *path, mode_t mode, dev_t rdev) { pathCache_t *tmpPathCache = NULL; struct stat stbuf; int status = -1; char cachePath[MAX_NAME_LEN]; char objPath[MAX_NAME_LEN]; iFuseConn_t *iFuseConn = NULL; fileCache_t *fileCache = NULL; /* iFuseDesc_t *desc = NULL; */ int localFd; rodsLog (LOG_DEBUG, "irodsMknod: %s", path); if (irodsGetattr (path, &stbuf) >= 0) return -EEXIST; status = irodsMknodWithCache ((char *)path, mode, cachePath); localFd = status; status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "dataObjCreateByFusePath: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } getAndUseIFuseConn (&iFuseConn, &MyRodsEnv); if (status < 0) { status = dataObjCreateByFusePath (iFuseConn->conn, (char *) path, mode, objPath); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = dataObjCreateByFusePath (iFuseConn->conn, (char *) path, mode, objPath); } if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMknod: rcDataObjCreate of %s error", path); unuseIFuseConn (iFuseConn); return -ENOENT; } } } fileCache = addFileCache(localFd, objPath, (char *) path, cachePath, mode, 0, HAVE_NEWLY_CREATED_CACHE); stbuf.st_mode = mode; pathExist ((char *) path, fileCache, &stbuf, &tmpPathCache); /* desc = newIFuseDesc (objPath, (char *) path, fileCache, &status); */ if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsMknod: allocIFuseDesc of %s error", path); closeIrodsFd (iFuseConn->conn, status); unuseIFuseConn (iFuseConn); return 0; } /* rodsLog (LOG_ERROR, "irodsMknod: %s conn: %p", path, iFuseConn);*/ unuseIFuseConn (iFuseConn); return (0); }
int _irodsGetattr (iFuseConn_t *iFuseConn, const char *path, struct stat *stbuf) { int status; dataObjInp_t dataObjInp; rodsObjStat_t *rodsObjStatOut = NULL; #ifdef CACHE_FUSE_PATH pathCache_t *tmpPathCache; #endif rodsLog (LOG_DEBUG, "_irodsGetattr: %s", path); #ifdef CACHE_FUSE_PATH /*if (lookupPathNotExist( (char *) path) == 1) { rodsLog (LOG_DEBUG, "irodsGetattr: a match for non existing path %s", path); return -ENOENT; }*/ if (matchAndLockPathCache ((char *) path, &tmpPathCache) == 1) { rodsLog (LOG_DEBUG, "irodsGetattr: a match for path %s", path); if (tmpPathCache->fileCache != NULL) { LOCK_STRUCT(*(tmpPathCache->fileCache)); if(tmpPathCache->fileCache->state == HAVE_NEWLY_CREATED_CACHE) { status = _updatePathCacheStatFromFileCache (tmpPathCache); UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); if (status < 0) { clearPathFromCache ((char *) path); } else { *stbuf = tmpPathCache->stbuf; return (0); } } else { UNLOCK_STRUCT(*(tmpPathCache->fileCache)); UNLOCK_STRUCT(*tmpPathCache); } } else { UNLOCK_STRUCT(*tmpPathCache); } } #endif memset (stbuf, 0, sizeof (struct stat)); memset (&dataObjInp, 0, sizeof (dataObjInp)); status = parseRodsPathStr ((char *) (path + 1) , &MyRodsEnv, dataObjInp.objPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsGetattr: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } status = rcObjStat (iFuseConn->conn, &dataObjInp, &rodsObjStatOut); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rcObjStat (iFuseConn->conn, &dataObjInp, &rodsObjStatOut); } if (status < 0) { if (status != USER_FILE_DOES_NOT_EXIST) { rodsLogError (LOG_ERROR, status, "irodsGetattr: rcObjStat of %s error", path); } #ifdef CACHE_FUSE_PATH pathNotExist ((char *) path); #endif return -ENOENT; } } if (rodsObjStatOut->objType == COLL_OBJ_T) { fillDirStat (stbuf, atoi (rodsObjStatOut->createTime), atoi (rodsObjStatOut->modifyTime), atoi (rodsObjStatOut->modifyTime)); } else if (rodsObjStatOut->objType == UNKNOWN_OBJ_T) { pathNotExist ((char *) path); if (rodsObjStatOut != NULL) freeRodsObjStat (rodsObjStatOut); return -ENOENT; } else { fillFileStat (stbuf, rodsObjStatOut->dataMode, rodsObjStatOut->objSize, atoi (rodsObjStatOut->createTime), atoi (rodsObjStatOut->modifyTime), atoi (rodsObjStatOut->modifyTime)); } if (rodsObjStatOut != NULL) freeRodsObjStat (rodsObjStatOut); /* don't set file cache */ pathExist ((char *) path, NULL, stbuf, &tmpPathCache); return 0; }
int irodsReaddir (const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) { char collPath[MAX_NAME_LEN]; collHandle_t collHandle; collEnt_t collEnt; int status; #ifdef CACHE_FUSE_PATH struct stat stbuf; pathCache_t *tmpPathCache; #endif /* don't know why we need this. the example have them */ (void) offset; (void) fi; iFuseConn_t *iFuseConn = NULL; rodsLog (LOG_DEBUG, "irodsReaddir: %s", path); filler(buf, ".", NULL, 0); filler(buf, "..", NULL, 0); status = parseRodsPathStr ((char *) (path + 1), &MyRodsEnv, collPath); if (status < 0) { rodsLogError (LOG_ERROR, status, "irodsReaddir: parseRodsPathStr of %s error", path); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath ((char *) path, &MyRodsEnv, &status); status = rclOpenCollection (iFuseConn->conn, collPath, 0, &collHandle); if (status < 0) { if (isReadMsgError (status)) { ifuseReconnect (iFuseConn); status = rclOpenCollection (iFuseConn->conn, collPath, 0, &collHandle); } if (status < 0) { rodsLog (LOG_ERROR, "irodsReaddir: rclOpenCollection of %s error. status = %d", collPath, status); unuseIFuseConn (iFuseConn); return -ENOENT; } } while ((status = rclReadCollection (iFuseConn->conn, &collHandle, &collEnt)) >= 0) { char myDir[MAX_NAME_LEN], mySubDir[MAX_NAME_LEN]; #ifdef CACHE_FUSE_PATH char childPath[MAX_NAME_LEN]; bzero (&stbuf, sizeof (struct stat)); #endif if (collEnt.objType == DATA_OBJ_T) { filler (buf, collEnt.dataName, NULL, 0); #ifdef CACHE_FUSE_PATH if (strcmp (path, "/") == 0) { snprintf (childPath, MAX_NAME_LEN, "/%s", collEnt.dataName); } else { snprintf (childPath, MAX_NAME_LEN, "%s/%s", path, collEnt.dataName); } if (lookupPathExist ((char *) childPath, &tmpPathCache) != 1) { fillFileStat (&stbuf, collEnt.dataMode, collEnt.dataSize, atoi (collEnt.createTime), atoi (collEnt.modifyTime), atoi (collEnt.modifyTime)); pathExist (childPath, NULL, &stbuf, &tmpPathCache); } #endif } else if (collEnt.objType == COLL_OBJ_T) { splitPathByKey (collEnt.collName, myDir, mySubDir, '/'); if(mySubDir[0] != '\0') { filler (buf, mySubDir, NULL, 0); #ifdef CACHE_FUSE_PATH if (strcmp (path, "/") == 0) { snprintf (childPath, MAX_NAME_LEN, "/%s", mySubDir); } else { snprintf (childPath, MAX_NAME_LEN, "%s/%s", path, mySubDir); } if (lookupPathExist ((char *) childPath, &tmpPathCache) != 1) { fillDirStat (&stbuf, atoi (collEnt.createTime), atoi (collEnt.modifyTime), atoi (collEnt.modifyTime)); pathExist (childPath, NULL, &stbuf, &tmpPathCache); } #endif } } } rclCloseCollection (&collHandle); unuseIFuseConn (iFuseConn); return (0); }
/************************************************************************** * private functions **************************************************************************/ static int _commitLocalBuffer(const char *iRODSPath, struct fuse_file_info *fi, lazyUploadFileInfo_t *lazyUploadFileInfo) { int status; int desc; char bufferPath[MAX_NAME_LEN]; int descInx; status = _getBufferPath(iRODSPath, bufferPath); if(status < 0) { rodsLog (LOG_DEBUG, "_upload: failed to get Buffered lazy upload file path - %s", iRODSPath); return status; } // close local buffer file handle if(lazyUploadFileInfo->localHandle < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: wrong file descriptor - %s, %d", iRODSPath, lazyUploadFileInfo->localHandle); return -EBADF; } // no write but requested flush if(lazyUploadFileInfo->curOffset == 0) { return 0; } fsync(lazyUploadFileInfo->localHandle); close(lazyUploadFileInfo->localHandle); lazyUploadFileInfo->localHandle = -1; rodsLog (LOG_DEBUG, "_commitLocalBuffer: upload - %s", iRODSPath); if(lazyUploadFileInfo->commitCount == 0) { // put and reopen iRODS file dataObjInp_t dataObjInp; int fd; pathCache_t *tmpPathCache = NULL; iFuseConn_t *iFuseConn = NULL; iFuseDesc_t *desc = NULL; struct stat stbuf; char objPath[MAX_NAME_LEN]; descInx = GET_IFUSE_DESC_INDEX(fi); rodsLog (LOG_DEBUG, "_commitLocalBuffer: closing existing iRODS file handle - %s - %d", iRODSPath, descInx); status = ifuseClose (&IFuseDesc[descInx]); if (status < 0) { int myError; if ((myError = getErrno (status)) > 0) { return (-myError); } else { return -ENOENT; } } // put rodsLog (LOG_DEBUG, "_commitLocalBuffer: uploading buffered file - %s", iRODSPath); status = _upload(iRODSPath); if(status != 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: upload error - %s, %d", iRODSPath, status); return status; } // reopen file rodsLog (LOG_DEBUG, "_commitLocalBuffer: reopening iRODS file handle - %s", iRODSPath); memset (&dataObjInp, 0, sizeof (dataObjInp)); //dataObjInp.openFlags = lazyUploadFileInfo->accmode; dataObjInp.openFlags = O_RDWR | O_APPEND; status = parseRodsPathStr ((char *) iRODSPath, LazyUploadRodsEnv, objPath); rstrcpy(dataObjInp.objPath, objPath, MAX_NAME_LEN); if (status < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: parseRodsPathStr of %s error", iRODSPath); /* use ENOTDIR for this type of error */ return -ENOTDIR; } iFuseConn = getAndUseConnByPath((char *) iRODSPath, &status); /* status = getAndUseIFuseConn(&iFuseConn); */ if(status < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: cannot get connection for %s error", iRODSPath); /* use ENOTDIR for this type of error */ return -ENOTDIR; } status = _irodsGetattr (iFuseConn, iRODSPath, &stbuf); fd = rcDataObjOpen (iFuseConn->conn, &dataObjInp); unuseIFuseConn (iFuseConn); if (fd < 0) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: rcDataObjOpen of %s error, status = %d", iRODSPath, fd); return -ENOENT; } fileCache_t *fileCache = addFileCache(fd, objPath, (char *) iRODSPath, NULL, stbuf.st_mode, stbuf.st_size, NO_FILE_CACHE); matchAndLockPathCache(pctable, (char *) iRODSPath, &tmpPathCache); if(tmpPathCache == NULL) { pathExist(pctable, (char *) iRODSPath, fileCache, &stbuf, NULL); } else { _addFileCacheForPath(tmpPathCache, fileCache); UNLOCK_STRUCT(*tmpPathCache); } desc = newIFuseDesc (objPath, (char *) iRODSPath, fileCache, &status); if (desc == NULL) { rodsLogError (LOG_ERROR, status, "_commitLocalBuffer: allocIFuseDesc of %s error", iRODSPath); return -ENOENT; } SET_IFUSE_DESC_INDEX(fi, desc->index); rodsLog (LOG_DEBUG, "_commitLocalBuffer: created new file handle - %s - %d", iRODSPath, desc->index); } else { // append int localDesc = open (bufferPath, O_RDONLY, 0755); char *buffer = (char*)malloc(FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE); int grandTotalReadLen = 0; if(localDesc < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: file descriptor error - %s, %d", iRODSPath, localDesc); return -ENOENT; } descInx = GET_IFUSE_DESC_INDEX(fi); if (checkFuseDesc (descInx) < 0) { return -EBADF; } status = 0; while(grandTotalReadLen < lazyUploadFileInfo->curOffset) { int totalReadLen = 0; int totalWriteLen = 0; while(totalReadLen < FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE) { int readLen = read(localDesc, buffer + totalReadLen, FUSE_LAZY_UPLOAD_MEM_BUFFER_SIZE - totalReadLen); if(readLen > 0) { totalReadLen += readLen; } else if(readLen == 0) { // EOF break; } else if(readLen < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: buffered file read error - %s, %d", iRODSPath, localDesc); status = getErrno (readLen); break; } } if(status >= 0) { while(totalWriteLen < totalReadLen) { int writeLen = _ifuseWrite (&IFuseDesc[descInx], buffer + totalWriteLen, totalReadLen - totalWriteLen, lazyUploadFileInfo->curLocalOffsetStart + totalWriteLen); if(writeLen > 0) { totalWriteLen += writeLen; } else if(writeLen == 0) { // EOF break; } else if(writeLen < 0) { rodsLog (LOG_DEBUG, "_commitLocalBuffer: iRODS file write error - %s", iRODSPath); status = getErrno (writeLen); break; } } } grandTotalReadLen += totalReadLen; } unlockDesc (descInx); free(buffer); close(localDesc); } rodsLog (LOG_DEBUG, "_commitLocalBuffer: reset local buffered file - %s", iRODSPath); // reset local buffer file desc = open (bufferPath, O_RDWR|O_CREAT|O_TRUNC, 0755); lazyUploadFileInfo->localHandle = desc; lazyUploadFileInfo->commitCount++; lazyUploadFileInfo->curLocalOffsetStart += lazyUploadFileInfo->curOffset; lazyUploadFileInfo->curOffset = 0; return (0); }