PXIXCORE_BUFFER xixcore_call xixcore_AllocateBuffer(xc_uint32 size) { PXIX_BUF xbuf = NULL; struct page * page = NULL; int order = 0; #if LINUX_VERSION_KMEM_CACHE_T_DEPRECATED xbuf= kmem_cache_alloc(xbuf_cachep, GFP_KERNEL); #else xbuf= kmem_cache_alloc(xbuf_cachep, SLAB_KERNEL); #endif if(!xbuf) { xbuf = kmalloc(sizeof(XIX_BUF), GFP_KERNEL); if( !xbuf) { return NULL; } memset(xbuf, 0, sizeof(XIX_BUF)); XIXCORE_SET_FLAGS(xbuf->xixcore_buffer.xcb_flags, XIXCORE_BUFF_ALLOC_F_MEMORY); }else{ memset(xbuf, 0, sizeof(XIX_BUF)); XIXCORE_SET_FLAGS(xbuf->xixcore_buffer.xcb_flags, XIXCORE_BUFF_ALLOC_F_POOL); } order = get_order(size); page = alloc_pages(GFP_KERNEL, order); if(!page) { xixcore_FreeBuffer(&xbuf->xixcore_buffer); return NULL; } xixcore_InitializeBuffer( &xbuf->xixcore_buffer, page_address(page), (PAGE_SIZE << order), 0); xbuf->xix_page = page; xbuf->xix_flags = 0; return &xbuf->xixcore_buffer; }
xixcore_call void xixcore_NotifyChange( PXIXCORE_VCB XixcoreVcb, uint32 VCBMetaFlags ) { PXIXFS_LINUX_VCB pVCB = container_of(XixcoreVcb, XIXFS_LINUX_VCB, XixcoreVcb); spin_lock(&(pVCB->MetaCtx.MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_lock(&(pCtx->MetaLock)) pCtx(%p)\n", &pVCB->MetaCtx )); XIXCORE_SET_FLAGS(pVCB->XixcoreVcb.MetaContext.VCBMetaFlags, VCBMetaFlags); spin_unlock(&(pVCB->MetaCtx.MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", &pVCB->MetaCtx )); wake_up(&(pVCB->MetaCtx.VCBMetaEvent)); }
VOID xixfs_SetFileObject( IN PXIXFS_IRPCONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN TYPE_OF_OPEN TypeOfOpen, IN PXIXFS_FCB pFCB OPTIONAL, IN PXIXFS_CCB pCCB OPTIONAL ) { PAGED_CODE(); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("Enter xixfs_SetFileObject\n")); ASSERT(!XIXCORE_TEST_FLAGS(((ULONG_PTR)pCCB), TYPE_OF_OPEN_MASK)); if(TypeOfOpen == UnopenedFileObject){ DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("xixfs_SetFileObject UnopenedFileObject\n")); FileObject->FsContext = FileObject->FsContext2 = NULL; return; } FileObject->FsContext = pFCB; FileObject->FsContext2 = pCCB; FileObject->CurrentByteOffset.QuadPart = 0; XIXCORE_SET_FLAGS(((ULONG_PTR)FileObject->FsContext2), TypeOfOpen); FileObject->Vpb = pFCB->PtrVCB->PtrVPB; DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("Exit xixfs_SetFileObject\n")); return; }
NTSTATUS xixfs_QueryFsDeviceInfo( IN PXIXFS_IRPCONTEXT pIrpContext, IN PXIXFS_VCB pVcb, IN PFILE_FS_DEVICE_INFORMATION Buffer, IN uint32 Length, IN OUT uint32 *ByteToReturn ) { PAGED_CODE(); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VOLINFO|DEBUG_TARGET_IRPCONTEXT), ("Enter xixfs_QueryFsDeviceInfo \n")); if(Length < sizeof(FILE_FS_DEVICE_INFORMATION)){ *ByteToReturn = 0; return STATUS_INVALID_PARAMETER; } Buffer->DeviceType = FILE_DEVICE_DISK; Buffer->Characteristics = pVcb->TargetDeviceObject->Characteristics; // Added by ILGU HONG for readonly 09052006 if(pVcb->XixcoreVcb.IsVolumeWriteProtected){ XIXCORE_SET_FLAGS(Buffer->Characteristics, FILE_READ_ONLY_DEVICE); }else{ XIXCORE_CLEAR_FLAGS(Buffer->Characteristics, FILE_READ_ONLY_DEVICE); } // Added by ILGU HONG for readonly end *ByteToReturn = sizeof(FILE_FS_DEVICE_INFORMATION); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VOLINFO|DEBUG_TARGET_IRPCONTEXT), ("Exit xixfs_QueryFsDeviceInfo \n")); return STATUS_SUCCESS; }
int xixfs_ResourceThreadFunction( void *lpParameter ) { PXIXFS_LINUX_VCB pVCB = NULL; PXIXFS_LINUX_META_CTX pCtx = NULL; PXIXCORE_META_CTX xixcoreCtx = NULL; int RC =0; #if LINUX_VERSION_25_ABOVE int TimeOut; #endif unsigned long flags; DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO ), ("Enter xixfs_ResourceThreadFunction .\n")); #if defined(NDAS_ORG2423) || defined(NDAS_SIGPENDING_OLD) spin_lock_irqsave(¤t->sigmask_lock, flags); siginitsetinv(¤t->blocked, sigmask(SIGKILL)|sigmask(SIGTERM)); recalc_sigpending(current); spin_unlock_irqrestore(¤t->sigmask_lock, flags); #else spin_lock_irqsave(¤t->sighand->siglock, flags); siginitsetinv(¤t->blocked, sigmask(SIGKILL)|sigmask(SIGTERM)); recalc_sigpending(); spin_unlock_irqrestore(¤t->sighand->siglock, flags); #endif #if LINUX_VERSION_25_ABOVE daemonize("XixMetaThread"); #else daemonize(); #endif pCtx = (PXIXFS_LINUX_META_CTX)lpParameter; XIXCORE_ASSERT(pCtx); pVCB = pCtx->VCBCtx; XIXFS_ASSERT_VCB(pVCB); xixcoreCtx = &pVCB->XixcoreVcb.MetaContext; while(1){ if(signal_pending(current)) { flush_signals(current); } #if LINUX_VERSION_25_ABOVE TimeOut = DEFAULT_XIXFS_UPDATEWAIT; RC = wait_event_timeout(pCtx->VCBMetaEvent, XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_MASK), TimeOut); #else mod_timer(&(pCtx->VCBMetaTimeOut), jiffies+ 180*HZ); wait_event(pCtx->VCBMetaEvent, XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_MASK)); #endif DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO ), ("!!!!! Wake up HELLOE ResourceThreadFunction .\n")); //printk(KERN_DEBUG "!!!!! Wake UP HELLOE ResourceThreadFunction .\n"); spin_lock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_lock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); #if LINUX_VERSION_25_ABOVE if(RC == 0 ) { #else if(XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_TIMEOUT)) { XIXCORE_CLEAR_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_TIMEOUT); #endif DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("Request Call timeout : xixfs_ResourceThreadFunction .\n")); spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); if(XIXCORE_TEST_FLAGS(xixcoreCtx->ResourceFlag, XIXCORE_META_RESOURCE_NEED_UPDATE)){ XIXCORE_CLEAR_FLAGS(xixcoreCtx->ResourceFlag, XIXCORE_META_RESOURCE_NEED_UPDATE); RC = xixfs_UpdateMetaData(pCtx); if( RC <0 ) { DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("fail(0x%x) xixfs_ResourceThreadFunction --> xixfs_UpdateMetaData .\n", RC)); } } #if LINUX_VERSION_25_ABOVE continue; }else if(XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_UPDATE)) { #else } if(XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_UPDATE)) { #endif XIXCORE_CLEAR_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_UPDATE); spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); if(XIXCORE_TEST_FLAGS(xixcoreCtx->ResourceFlag, XIXCORE_META_RESOURCE_NEED_UPDATE)){ XIXCORE_CLEAR_FLAGS(xixcoreCtx->ResourceFlag, XIXCORE_META_RESOURCE_NEED_UPDATE); RC = xixfs_UpdateMetaData(pCtx); if( RC <0 ) { DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("fail(0x%x) xixfs_ResourceThreadFunction --> xixfs_UpdateMetaData .\n", RC)); } } xixfs_wakeup_resource_waiter(pCtx); continue; }else if(XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_KILL_THREAD)) { XIXCORE_CLEAR_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_RECHECK_RESOURCES); XIXCORE_SET_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_INSUFFICIENT_RESOURCES); spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("Stop Thread : xixfs_ResourceThreadFunction .\n")); xixfs_wakeup_resource_waiter(pCtx); #if LINUX_VERSION_25_ABOVE complete_all(&(pCtx->VCBMetaThreadStopCompletion)); #else del_timer(&(pCtx->VCBMetaTimeOut)); xixfs_wakeup_metaThread_stop_waiter(pCtx); #endif break; }else if( XIXCORE_TEST_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_RECHECK_RESOURCES)){ spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("get more resource : xixfs_ResourceThreadFunction .\n")); RC = xixfs_GetMoreCheckOutLotMap(pCtx); DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("End xixfs_GetMoreCheckOutLotMap .\n")); if( RC <0 ) { DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("fail(0x%x) xixfs_ResourceThreadFunction --> xixfs_GetMoreCheckOutLotMap .\n", RC)); }else { spin_lock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_lock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); XIXCORE_CLEAR_FLAGS(xixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_RECHECK_RESOURCES); spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("WAKE UP WAITING THREAD!! .\n")); xixfs_wakeup_resource_waiter(pCtx); } continue; }else { DebugTrace(DEBUG_LEVEL_ALL, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO |DEBUG_TARGET_ALL), ("Request Call Unrecognized : xixfs_ResourceThreadFunction .\n")); spin_unlock(&(pCtx->MetaLock)); //DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, // ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx )); } } DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO ), ("Exit xixfs_ResourceThreadFunction .\n")); return 0; }
static void xixfs_write_super( struct super_block *sb ) { int RC = 0; PXIXFS_LINUX_VCB pVCB = NULL; PXIXFS_LINUX_META_CTX pCtx = NULL; PXIXCORE_META_CTX pXixcoreCtx = NULL; #if LINUX_VERSION_25_ABOVE int TimeOut = 0; #endif XIXFS_WAIT_CTX wait; XIXCORE_ASSERT(sb); pVCB = XIXFS_SB(sb); XIXFS_ASSERT_VCB(pVCB); pCtx = &(pVCB->MetaCtx); XIXCORE_ASSERT(pCtx); pXixcoreCtx = &pVCB->XixcoreVcb.MetaContext; DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VFSAPIT|DEBUG_TARGET_VCB), ("Enter xixfs_write_super\n")); spin_lock(&(pCtx->MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_lock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx)); XIXCORE_SET_FLAGS(pXixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_UPDATE); spin_unlock(&(pCtx->MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx)); xixfs_init_wait_ctx(&wait); xixfs_add_resource_wait_list(&wait, pCtx); wake_up(&(pCtx->VCBMetaEvent)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_THREAD, ("META UPDATE REQ\n")); #if LINUX_VERSION_25_ABOVE TimeOut = DEFAULT_XIXFS_UPDATEWAIT; RC = wait_for_completion_timeout(&(wait.WaitCompletion), TimeOut); #else wait_for_completion(&(wait.WaitCompletion)); RC =1; #endif DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_THREAD, ("END META UPDATE REQ\n")); if(RC<= 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("Fail xixfs_write_super -->wait_event_timeout \n")); return ; } DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VFSAPIT|DEBUG_TARGET_VCB), ("Exit xixfs_write_super\n")); return; }
static void xixfs_put_super( struct super_block *sb ) { int RC = 0; PXIXFS_LINUX_VCB pVCB = NULL; PXIXFS_LINUX_META_CTX pCtx = NULL; PXIXCORE_META_CTX pXixcoreCtx = NULL; #if LINUX_VERSION_25_ABOVE int TimeOut = 0; #endif XIXCORE_ASSERT(sb); pVCB = XIXFS_SB(sb); XIXFS_ASSERT_VCB(pVCB); pCtx = &(pVCB->MetaCtx); pXixcoreCtx = &pVCB->XixcoreVcb.MetaContext; XIXCORE_ASSERT(pCtx); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VFSAPIT|DEBUG_TARGET_VCB), ("Enter xixfs_put_super\n")); xixcore_CleanUpAuxLotLockInfo(&pVCB->XixcoreVcb); if(pVCB->XixcoreVcb.IsVolumeWriteProtected != 1) { #if !LINUX_VERSION_25_ABOVE XIXFS_WAIT_CTX wait; #endif DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_ALL, ("!!request Meta thread stop \n")); spin_lock(&(pCtx->MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_lock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx)); XIXCORE_SET_FLAGS(pXixcoreCtx->VCBMetaFlags, XIXCORE_META_FLAGS_KILL_THREAD); spin_unlock(&(pCtx->MetaLock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_unlock(&(pCtx->MetaLock)) pCtx(%p)\n", pCtx)); #if !LINUX_VERSION_25_ABOVE xixfs_init_wait_ctx(&wait); xixfs_add_metaThread_stop_wait_list(&wait, pCtx); #endif wake_up(&(pCtx->VCBMetaEvent)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_THREAD, ("META THREAD STOP REQ\n")); #if LINUX_VERSION_25_ABOVE TimeOut = DEFAULT_XIXFS_UMOUNTWAIT; RC = wait_for_completion_timeout(&(pCtx->VCBMetaThreadStopCompletion), TimeOut); INIT_COMPLETION(pCtx->VCBMetaThreadStopCompletion); #else wait_for_completion(&(wait.WaitCompletion)); #endif DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_THREAD, ("END META THREAD STOP REQ\n")); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_ALL, ("!!replyed Meta thread stop \n")); RC = xixcore_DeregisterHost(&pVCB->XixcoreVcb); if(pVCB->XixcoreVcb.MetaContext.HostDirtyLotMap) { xixcore_FreeBuffer(pVCB->XixcoreVcb.MetaContext.HostDirtyLotMap->Data); kfree(pVCB->XixcoreVcb.MetaContext.HostDirtyLotMap); pVCB->XixcoreVcb.MetaContext.HostDirtyLotMap = NULL; } if(pVCB->XixcoreVcb.MetaContext.HostFreeLotMap) { xixcore_FreeBuffer(pVCB->XixcoreVcb.MetaContext.HostFreeLotMap->Data); kfree(pVCB->XixcoreVcb.MetaContext.HostFreeLotMap); pVCB->XixcoreVcb.MetaContext.HostFreeLotMap = NULL; } if(pVCB->XixcoreVcb.MetaContext.VolumeFreeMap) { xixcore_FreeBuffer(pVCB->XixcoreVcb.MetaContext.VolumeFreeMap->Data); kfree(pVCB->XixcoreVcb.MetaContext.VolumeFreeMap); pVCB->XixcoreVcb.MetaContext.VolumeFreeMap = NULL; } } xixcore_DeleteALLChildCacheEntry(&pVCB->XixcoreVcb); if(pVCB->XixcoreVcb.VolumeName){ xixcore_FreeMem(pVCB->XixcoreVcb.VolumeName, XCTAG_VOLNAME); } spin_lock(&(xixfs_linux_global.sb_list_lock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_lock(&(xixfs_linux_global.sb_list_lock)) \n" )); list_del(&(pVCB->VCBLink)); spin_unlock(&(xixfs_linux_global.sb_list_lock)); DebugTrace(DEBUG_LEVEL_TRACE, DEBUG_TARGET_CHECK, ("spin_unlock(&(xixfs_linux_global.sb_list_lock)) \n" )); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_VFSAPIT|DEBUG_TARGET_VCB), ("Exit xixfs_put_super\n")); unload_nls(pVCB->nls_map); kfree(pVCB); #if LINUX_VERSION_25_ABOVE sb->s_fs_info = NULL; #else sb->u.generic_sbp = NULL; #endif }
PXIXFS_LCB xixfs_FCBTLBInsertPrefix ( IN PXIXFS_IRPCONTEXT IrpContext, IN PXIXFS_FCB Fcb, IN PUNICODE_STRING Name, IN PXIXFS_FCB ParentFcb ) { PXIXFS_LCB Lcb; PRTL_SPLAY_LINKS *TreeRoot; PLIST_ENTRY ListLinks; PWCHAR NameBuffer; PAGED_CODE(); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CLOSE| DEBUG_TARGET_FCB), ("Enter xixfs_FCBTLBInsertPrefix \n" )); // // Check inputs. // ASSERT_IRPCONTEXT( IrpContext ); ASSERT_FCB( Fcb ); ASSERT_EXCLUSIVE_FCB( Fcb ); ASSERT_EXCLUSIVE_FCB( ParentFcb ); ASSERT( ParentFcb->XixcoreFcb.FCBType == FCB_TYPE_DIR); // // It must be the case that an index Fcb is only referenced by a single index. Now // we walk the child's Lcb queue to insure that if any prefixes have already been // inserted, they all refer to the index Fcb we are linking to. This is the only way // we can detect directory cross-linkage. // if (Fcb->XixcoreFcb.FCBType == FCB_TYPE_DIR) { for (ListLinks = Fcb->ParentLcbQueue.Flink; ListLinks != &Fcb->ParentLcbQueue; ListLinks = ListLinks->Flink) { Lcb = CONTAINING_RECORD( ListLinks, XIXFS_LCB, ChildFcbLinks ); if (Lcb->ParentFcb != ParentFcb) { XifsdRaiseStatus( IrpContext, STATUS_DISK_CORRUPT_ERROR ); } } } // // Allocate space for the Lcb. // Lcb = xixfs_AllocateLCB(Name->Length); // // Initialize the name-based file attributes. // Lcb->FileAttributes = 0; // // Set up the filename in the Lcb. // RtlCopyMemory( Lcb->FileName.Buffer, Name->Buffer, Name->Length ); // // Capture the separate cases. // TreeRoot = &ParentFcb->Root; // // Insert the Lcb into the prefix tree. // if (!xixfs_NLInsertNameLink( IrpContext, TreeRoot, Lcb )) { // // This will very rarely occur. // xixfs_FreeLCB( Lcb ); Lcb = xixfs_NLFindNameLink( IrpContext, TreeRoot, Name ); if (Lcb == NULL) { // // Even worse. // XifsdRaiseStatus( IrpContext, STATUS_DRIVER_INTERNAL_ERROR ); } if(!XIXCORE_TEST_FLAGS(Lcb->LCBFlags, XIFSD_LCB_STATE_IGNORE_CASE_SET)){ XifsdRaiseStatus( IrpContext, STATUS_DRIVER_INTERNAL_ERROR ); } return Lcb; } // // Capture the separate cases. // TreeRoot = &ParentFcb->IgnoreCaseRoot; // // Set up the filename in the Lcb. // RtlDowncaseUnicodeString(&(Lcb->IgnoreCaseFileName), Name, FALSE); if(!xixfs_NLInsertNameLinkIgnoreCase( IrpContext, TreeRoot, Lcb )){ XifsdRaiseStatus( IrpContext, STATUS_DRIVER_INTERNAL_ERROR ); } XIXCORE_SET_FLAGS(Lcb->LCBFlags, XIFSD_LCB_STATE_IGNORE_CASE_SET); // // Link the Fcbs together through the Lcb. // Lcb->ParentFcb = ParentFcb; Lcb->ChildFcb = Fcb; InsertHeadList( &ParentFcb->ChildLcbQueue, &Lcb->ParentFcbLinks ); InsertHeadList( &Fcb->ParentLcbQueue, &Lcb->ChildFcbLinks ); // // Initialize the reference count. // Lcb->Reference = 0; //DbgPrint(" !!!Insert LCB FileName(%wZ) IgnoreFileName(%wZ) .\n", &Lcb->FileName, &Lcb->IgnoreCaseFileName); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_CREATE|DEBUG_TARGET_CLOSE| DEBUG_TARGET_FCB), ("Exit xixfs_FCBTLBInsertPrefix \n" )); return Lcb; }
VOID xixfs_CleanupFlushVCB( IN PXIXFS_IRPCONTEXT pIrpContext, IN PXIXFS_VCB pVCB, IN BOOLEAN DisMountVCB ) { //PAGED_CODE(); ASSERT_IRPCONTEXT( pIrpContext ); ASSERT_VCB( pVCB ); ASSERT_EXCLUSIVE_XIFS_GDATA; ASSERT_EXCLUSIVE_VCB(pVCB); DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT), ("xixfs_CleanupFlushVCB Status(%ld).\n", pVCB->VCBState)); DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT), ("11 Current VCB->PtrVPB->ReferenceCount %d \n", pVCB->PtrVPB->ReferenceCount)); XifsdLockVcb( pIrpContext, pVCB ); XIXCORE_SET_FLAGS(pVCB->VCBFlags, XIFSD_VCB_FLAGS_DEFERED_CLOSE); if(DisMountVCB){ if(pVCB->VolumeDasdFCB != NULL){ pVCB->VolumeDasdFCB->FCBReference -= 1; pVCB->VolumeDasdFCB->FCBUserReference -= 1; } if(pVCB->MetaFCB != NULL){ pVCB->MetaFCB->FCBReference -=1; pVCB->MetaFCB->FCBUserReference -= 1; } if(pVCB->RootDirFCB != NULL){ pVCB->RootDirFCB->FCBReference -=1; pVCB->RootDirFCB->FCBUserReference -= 1; } } XifsdUnlockVcb(pIrpContext, pVCB); xixfs_PurgeVolume(pIrpContext, pVCB, DisMountVCB); DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_PNP| DEBUG_TARGET_VCB| DEBUG_TARGET_IRPCONTEXT), ("22 Current VCB->PtrVPB->ReferenceCount %d \n", pVCB->PtrVPB->ReferenceCount)); if(DisMountVCB){ // Added by ILGU HONG XifsdReleaseVcb(TRUE, pVCB); DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_FSCTL|DEBUG_TARGET_VOLINFO ), ("VCB %d/%d \n", pVCB->VCBReference, pVCB->VCBUserReference)); CcWaitForCurrentLazyWriterActivity(); XifsdAcquireVcbExclusive(TRUE, pVCB, FALSE); xixfs_RealCloseFCB((PVOID)pVCB); } XifsdLockVcb( pIrpContext, pVCB ); XIXCORE_CLEAR_FLAGS(pVCB->VCBFlags, XIFSD_VCB_FLAGS_DEFERED_CLOSE); XifsdUnlockVcb(pIrpContext, pVCB); // Added by ILGU HONG END if(DisMountVCB){ // changed by ILGU HONG for readonly 09052006 if(!pVCB->XixcoreVcb.IsVolumeWriteProtected){ LARGE_INTEGER TimeOut; // // Stop Meta Update process // KeSetEvent(&pVCB->VCBUmountEvent, 0, FALSE); TimeOut.QuadPart = - DEFAULT_XIFS_UMOUNTWAIT; KeWaitForSingleObject(&pVCB->VCBStopOkEvent, Executive, KernelMode, FALSE, &TimeOut); xixcore_DeregisterHost(&pVCB->XixcoreVcb); // Added by ILGU HONG for 08312006 if(pVCB->NdasVolBacl_Id){ xixfs_RemoveUserBacl(pVCB->TargetDeviceObject, pVCB->NdasVolBacl_Id); } // Added by ILGU HONG End } // changed by ILGU HONG for readonly end } return; }
int xixcore_call xixcore_CreateNewFile( PXIXCORE_VCB pVCB, PXIXCORE_FCB pDir, xc_uint32 bIsFile, xc_uint8 * Name, xc_uint32 NameLength, xc_uint32 FileAttribute, PXIXCORE_DIR_EMUL_CONTEXT DirContext, xc_uint64 *NewFileId ) { int RC = 0; PXIXCORE_BUFFER xbuf = NULL; PXIXCORE_BUFFER LotHeader = NULL; xc_int64 BeginingLotIndex = 0; xc_uint32 bLotAlloc = 0; xc_uint32 IsDirSet = 0; xc_uint32 ChildType = 0; xc_uint64 ChildIndex = 0; xc_int32 Reason = 0; PXIDISK_COMMON_LOT_HEADER pLotHeader = NULL; PXIDISK_FILE_INFO pFileInfo = NULL; PXIDISK_DIR_INFO pDirInfo = NULL; PXIDISK_ADDR_MAP pAddressMap = NULL; xc_uint32 AddrStartSectorIndex = 0; xc_uint64 EntryIndex = 0; DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("Enter xixcore_CreateNewFile \n")); XIXCORE_ASSERT_FCB(pDir); XIXCORE_ASSERT_VCB(pVCB); // Changed by ILGU HONG for readonly 09052006 if(pVCB->IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixcore_CreateNewFile : is read only .\n")); RC = XCCODE_EPERM; return RC; } // Changed by ILGU HONG for readonly end ChildType = (bIsFile)?(XIFS_FD_TYPE_FILE):(XIFS_FD_TYPE_DIRECTORY); if(NameLength > (XIFS_MAX_FILE_NAME_LENGTH * sizeof(xc_le16) )){ DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("FileNameLen(%d).\n", NameLength)); NameLength = XIFS_MAX_FILE_NAME_LENGTH * sizeof(xc_le16); } xbuf = xixcore_AllocateBuffer(XIDISK_DUP_FILE_INFO_SIZE); if(xbuf == NULL) { DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixcore_CreateNewFile : can't allocate xbuf .\n")); RC = XCCODE_ENOMEM; return RC; } LotHeader = xixcore_AllocateBuffer(XIDISK_DUP_COMMON_LOT_HEADER_SIZE); if(LotHeader == NULL) { xixcore_FreeBuffer(xbuf); DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixcore_CreateNewFile : can't allocate LotHeader .\n")); RC = XCCODE_ENOMEM; return RC; } RC = xixcore_FindDirEntry ( pVCB, pDir, (xc_uint8 *)Name, NameLength, DirContext, &EntryIndex, 1 ); if(RC >= 0){ RC = XCCODE_EPERM; goto error_out; } BeginingLotIndex = xixcore_AllocVCBLot(pVCB); if(BeginingLotIndex < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixcore_CreateNewFile : can't allocate lot.\n")); RC =XCCODE_ENOSPC; goto error_out; } bLotAlloc = 1; RC = xixcore_AddChildToDir( pVCB, pDir, BeginingLotIndex, ChildType, Name, NameLength, DirContext, &ChildIndex ); if( RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) xixcore_CreateNewFile : xixcore_AddChildToDir.\n", RC)); goto error_out; } IsDirSet =1; xixcore_ZeroBufferOffset(xbuf); memset(xixcore_GetDataBuffer(xbuf), 0,XIDISK_DUP_FILE_INFO_SIZE); xixcore_ZeroBufferOffset(LotHeader); memset(xixcore_GetDataBuffer(LotHeader), 0,XIDISK_DUP_COMMON_LOT_HEADER_SIZE); DebugTrace(DEBUG_LEVEL_INFO, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("Make File Info.\n")); RC = xixcore_RawReadLotHeader( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, LotHeader, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteLotAndFileHeader.\n", RC, Reason)); if(RC == XCCODE_CRCERROR){ xixcore_ZeroBufferOffset(LotHeader); }else{ goto error_out; } } RC = xixcore_RawReadFileHeader( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, xbuf, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteFileHeader.\n", RC, Reason)); if(RC == XCCODE_CRCERROR){ xixcore_ZeroBufferOffset(xbuf); }else{ goto error_out; } } if(ChildType == XIFS_FD_TYPE_FILE){ pFileInfo = (PXIDISK_FILE_INFO)xixcore_GetDataBufferWithOffset(xbuf); pLotHeader = (PXIDISK_COMMON_LOT_HEADER)xixcore_GetDataBufferWithOffset(LotHeader); xixcore_InitializeCommonLotHeader( pLotHeader, pVCB->VolumeLotSignature, LOT_INFO_TYPE_FILE, LOT_FLAG_BEGIN, BeginingLotIndex, BeginingLotIndex, 0, 0, 0, sizeof(XIDISK_FILE_HEADER), pVCB->LotSize - sizeof(XIDISK_FILE_HEADER) ); pLotHeader->Lock.LockState = XIDISK_LOCK_RELEASED; pLotHeader->Lock.LockAcquireTime=0; memcpy(pLotHeader->Lock.LockHostSignature, pVCB->HostId , 16); // Changed by ILGU HONG // chesung suggest //RtlCopyMemory(pLotHeader->Lock.LockHostMacAddress, PtrVCB->HostMac, 6); memcpy(pLotHeader->Lock.LockHostMacAddress, pVCB->HostMac, 32); memset(pFileInfo, 0, (XIDISK_COMMON_LOT_HEADER_SIZE - XIXCORE_MD5DIGEST_AND_SEQSIZE)); pFileInfo->Access_time = xixcore_GetCurrentTime64(); pFileInfo->Change_time = xixcore_GetCurrentTime64(); pFileInfo->Create_time = xixcore_GetCurrentTime64(); pFileInfo->Modified_time = xixcore_GetCurrentTime64(); memcpy(pFileInfo->OwnHostId , pVCB->HostId, 16); pFileInfo->ParentDirLotIndex = pDir->LotNumber; pFileInfo->LotIndex = BeginingLotIndex; pFileInfo->State = XIFS_FD_STATE_CREATE; pFileInfo->ACLState = 0; pFileInfo->FileAttribute = (FileAttribute|FILE_ATTRIBUTE_ARCHIVE); pFileInfo->AccessFlags = FILE_SHARE_READ; pFileInfo->FileSize = 0; pFileInfo->AllocationSize = pVCB->LotSize - XIDISK_FILE_HEADER_SIZE; pFileInfo->AddressMapIndex = 0; pFileInfo->LinkCount = 1; pFileInfo->NameSize = NameLength; pFileInfo->AddressMapIndex = 0; XIXCORE_SET_FLAGS(pFileInfo->Type, XIFS_FD_TYPE_FILE); memcpy(pFileInfo->Name, Name, NameLength); pFileInfo->AddressMapIndex = 0; }else{ pDirInfo = (PXIDISK_DIR_INFO)xixcore_GetDataBufferWithOffset(xbuf); pLotHeader = (PXIDISK_COMMON_LOT_HEADER)xixcore_GetDataBufferWithOffset(LotHeader); xixcore_InitializeCommonLotHeader( pLotHeader, pVCB->VolumeLotSignature, LOT_INFO_TYPE_DIRECTORY, LOT_FLAG_BEGIN, BeginingLotIndex, BeginingLotIndex, 0, 0, 0, sizeof(XIDISK_FILE_HEADER_LOT), pVCB->LotSize - sizeof(XIDISK_DIR_HEADER_LOT) ); pLotHeader->Lock.LockState= XIDISK_LOCK_RELEASED; pLotHeader->Lock.LockAcquireTime= 0;; memcpy(pLotHeader->Lock.LockHostSignature, pVCB->HostId , 16); // Changed by ILGU HONG // chesung suggest //RtlCopyMemory(pLotHeader->Lock.LockHostMacAddress, PtrVCB->HostMac, 6); memcpy(pLotHeader->Lock.LockHostMacAddress, pVCB->HostMac, 32); memset(pDirInfo, 0, (XIDISK_COMMON_LOT_HEADER_SIZE - XIXCORE_MD5DIGEST_AND_SEQSIZE)); pDirInfo->Access_time = xixcore_GetCurrentTime64(); pDirInfo->Change_time = xixcore_GetCurrentTime64(); pDirInfo->Create_time = xixcore_GetCurrentTime64(); pDirInfo->Modified_time = xixcore_GetCurrentTime64(); memcpy(pDirInfo->OwnHostId ,pVCB->HostId, 16); pDirInfo->ParentDirLotIndex = pDir->LotNumber; pDirInfo->LotIndex = BeginingLotIndex; pDirInfo->State = XIFS_FD_STATE_CREATE; pDirInfo->ACLState = 0; pDirInfo->FileAttribute = (FileAttribute | FILE_ATTRIBUTE_DIRECTORY); pDirInfo->AccessFlags = FILE_SHARE_READ; pDirInfo->FileSize = 0; pDirInfo->AllocationSize = pVCB->LotSize - XIDISK_DIR_HEADER_SIZE; pDirInfo->LinkCount = 1; XIXCORE_SET_FLAGS(pDirInfo->Type, XIFS_FD_TYPE_DIRECTORY); pDirInfo->NameSize = NameLength; memcpy(pDirInfo->Name, Name, NameLength); pDirInfo->AddressMapIndex = 0; } RC = xixcore_RawWriteFileHeader( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, xbuf, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteFileHeader.\n", RC, Reason)); goto error_out; } RC = xixcore_RawWriteLotHeader( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, LotHeader, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteLotAndFileHeader.\n", RC, Reason)); goto error_out; } xixcore_ZeroBufferOffset(xbuf); memset(xixcore_GetDataBuffer(xbuf), 0, XIDISK_DUP_FILE_INFO_SIZE); pAddressMap = (PXIDISK_ADDR_MAP)xixcore_GetDataBufferWithOffset(xbuf); pAddressMap->LotNumber[0] = BeginingLotIndex; RC = xixcore_RawWriteAddressOfFile( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, 0, pDir->AddrLotSize, &AddrStartSectorIndex, 0, xbuf, &Reason); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteAddressOfFile.\n", RC, Reason)); goto error_out; } if(ChildType == XIFS_FD_TYPE_DIRECTORY) { PXIDISK_HASH_VALUE_TABLE pTable = NULL; xixcore_ZeroBufferOffset(xbuf); memset(xixcore_GetDataBuffer(xbuf), 0, XIDISK_DUP_FILE_INFO_SIZE); RC = xixcore_RawReadDirEntryHashValueTable( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, xbuf, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteDirEntryHashValueTable.\n", RC, Reason)); if(RC == XCCODE_CRCERROR){ xixcore_ZeroBufferOffset(xbuf); }else{ goto error_out; } } pTable = (PXIDISK_HASH_VALUE_TABLE)xixcore_GetDataBufferWithOffset(xbuf); memset(pTable, 0, (XIDISK_HASH_VALUE_TABLE_SIZE - XIXCORE_MD5DIGEST_AND_SEQSIZE)); RC = xixcore_RawWriteDirEntryHashValueTable( pVCB->XixcoreBlockDevice, pVCB->LotSize, pVCB->SectorSize, pVCB->SectorSizeBit, BeginingLotIndex, xbuf, &Reason ); if(RC < 0 ){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR(0x%x) Reason(0x%x) xixcore_CreateNewFile : xixcore_RawWriteDirEntryHashValueTable.\n", RC, Reason)); goto error_out; } } *NewFileId = BeginingLotIndex; //xixcore_NotifyChange(pVCB, XIXCORE_META_FLAGS_UPDATE); RC = XCCODE_SUCCESS; error_out: if( RC < 0 ) { if(IsDirSet == 1){ xixcore_DeleteChildFromDir( pVCB, pDir, ChildIndex, DirContext ); } if(bLotAlloc == 1) { xixcore_FreeVCBLot(pVCB, BeginingLotIndex); } } if(xbuf) { xixcore_FreeBuffer(xbuf); } if(LotHeader){ xixcore_FreeBuffer(LotHeader); } DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_DIRINFO|DEBUG_TARGET_FCB|DEBUG_TARGET_FILEINFO), ("Exit (0x%x) xixcore_CreateNewFile \n", RC)); return RC; }
void xixfs_truncate ( struct inode * inode ) { struct super_block * sb = NULL; PXIXFS_LINUX_VCB pVCB = NULL; PXIXFS_LINUX_FCB pFCB = NULL; XIXCORE_ASSERT(inode); sb = inode->i_sb; XIXCORE_ASSERT(sb); pVCB = XIXFS_SB(sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_truncate %d(%p).\n", inode->i_ino, inode)); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_truncate : is read only .\n")); return ; } if( pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE) { if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { lock_kernel(); block_truncate_page(inode->i_mapping, inode->i_size, xixfs_get_block); //pFCB->FileSize = 0; //inode->i_size = pFCB->FileSize; //i_size_write(inode, 0); //inode->i_blocks = ((inode->i_size + ((1<<inode->i_blkbits) - 1)) // & ~((loff_t)(1<<inode->i_blkbits)- 1)) >> inode->i_blkbits; #if LINUX_VERSION_25_ABOVE inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC; pFCB->XixcoreFcb.Modified_time = pFCB->XixcoreFcb.Create_time = inode->i_ctime.tv_sec * XIXFS_TIC_P_SEC; #else inode->i_mtime = inode->i_ctime = CURRENT_TIME; pFCB->XixcoreFcb.Modified_time = pFCB->XixcoreFcb.Create_time = inode->i_ctime * XIXFS_TIC_P_SEC; #endif XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, (XIXCORE_FCB_MODIFIED_FILE_TIME| XIXCORE_FCB_MODIFIED_FILE_SIZE) ); unlock_kernel(); return ; } else { DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ERROR: Has no lock. %d($p).\n", inode->i_ino, inode)); } } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_truncate .\n")); return ; }
ssize_t xixfs_file_writev( struct file *file, const struct iovec *iov, unsigned long nr_segs, loff_t *ppos ) { ssize_t RC = 0; int64 index = 0; struct address_space *mapping = file->f_mapping; struct inode *inode = mapping->host; PXIXFS_LINUX_FCB pFCB = NULL; PXIXFS_LINUX_VCB pVCB = NULL; XIXCORE_ASSERT(inode); pVCB = XIXFS_SB(inode->i_sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_file_writev (%s).\n", file->f_dentry->d_name.name)); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_file_writev : is read only .\n")); return -EPERM; } if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR DELETED FILE \n")); return -EPERM; } XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE); if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { index =(int64) (*ppos); RC = generic_file_writev(file, iov, nr_segs, ppos); if(RC > 0 ) { if(pFCB->XixcoreFcb.WriteStartOffset == -1) { pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } if(pFCB->XixcoreFcb.WriteStartOffset > index ){ pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_writev (%d).\n", RC)); return RC; } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_writev ERROR.\n")); return -EPERM; }
int xixfs_sync_inode(struct inode *inode) { struct writeback_control wbc = { .sync_mode = WB_SYNC_ALL, .nr_to_write = 0, /* sys_fsync did this */ }; return sync_inode(inode, &wbc); } #endif int xixfs_sync_file( struct file *file, struct dentry *dentry, int datasync ) { struct inode *inode = dentry->d_inode; PXIXFS_LINUX_FCB pFCB = NULL; PXIXFS_LINUX_VCB pVCB = NULL; int err = 0; int ret = 0; XIXCORE_ASSERT(inode); pVCB = XIXFS_SB(inode->i_sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_sync_file (%s).\n", file->f_dentry->d_name.name)); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_sync_file : is read only .\n")); return -EPERM; } if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR DELETED FILE \n")); return -EPERM; } XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE); if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { #if LINUX_VERSION_25_ABOVE ret = sync_mapping_buffers(inode->i_mapping); if (!(inode->i_state & I_DIRTY)) return ret; if (datasync && !(inode->i_state & I_DIRTY_DATASYNC)) return ret; xixfs_sync_inode(inode); #endif if(XIXCORE_TEST_FLAGS(pFCB->XixcoreFcb.FCBFlags,XIXCORE_FCB_MODIFIED_FILE)){ #if LINUX_VERSION_25_ABOVE err = xixfs_write_inode(inode, 1); #else xixfs_write_inode(inode, 1); #endif if(pFCB->XixcoreFcb.WriteStartOffset != -1){ printk(KERN_DEBUG "Set Update Information!!!\n"); xixfs_SendFileChangeRC( pVCB->XixcoreVcb.HostMac, pFCB->XixcoreFcb.LotNumber, pVCB->XixcoreVcb.VolumeId, i_size_read(inode), pFCB->XixcoreFcb.RealAllocationSize, pFCB->XixcoreFcb.WriteStartOffset ); pFCB->XixcoreFcb.WriteStartOffset = -1; } if (ret == 0) ret = err; return ret; } }else { return -EPERM; } return ret; } #if LINUX_VERSION_25_ABOVE #if LINUX_VERSION_2_6_19_REPLACE_INTERFACE ssize_t xixfs_file_splice_read( struct file *in, loff_t *ppos, struct pipe_inode_info *pipe, size_t len, unsigned int flags ) { return generic_file_splice_read(in, ppos, pipe, len, flags); } ssize_t xixfs_file_splice_write( struct pipe_inode_info *pipe, struct file *out, loff_t *ppos, size_t len, unsigned int flags ) { ssize_t RC = 0; int64 index = 0; struct address_space *mapping = out->f_mapping; struct inode *inode = mapping->host; PXIXFS_LINUX_FCB pFCB = NULL; PXIXFS_LINUX_VCB pVCB = NULL; XIXCORE_ASSERT(inode); pVCB = XIXFS_SB(inode->i_sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_file_splice_write (%s).\n", out->f_dentry->d_name.name)); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_file_splice_write : is read only .\n")); return -EPERM; } if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR DELETED FILE \n")); return -EPERM; } XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE); if(pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { index =(int64) (*ppos); RC = generic_file_splice_write(pipe, out, ppos, len, flags); if(RC > 0 ) { if(pFCB->XixcoreFcb.WriteStartOffset == -1) { pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } if(pFCB->XixcoreFcb.WriteStartOffset > index ){ pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_writev (%d).\n", RC)); return RC; } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_writev ERROR.\n")); return -EPERM; }
ssize_t xixfs_file_aio_write( struct kiocb *iocb, #if LINUX_VERSION_2_6_19_REPLACE_INTERFACE const struct iovec *iov, unsigned long count, #else const char __user *buf, size_t count, #endif loff_t pos ) { ssize_t RC = 0; int64 index = 0; struct address_space *mapping = iocb->ki_filp->f_mapping; struct inode *inode = mapping->host; PXIXFS_LINUX_FCB pFCB = NULL; PXIXFS_LINUX_VCB pVCB = NULL; XIXCORE_ASSERT(inode); pVCB = XIXFS_SB(inode->i_sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_file_aio_write .\n")); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_file_aio_write : is read only .\n")); return -EPERM; } XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE); if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR DELETED FILE \n")); return -EPERM; } if( pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { index =(int64) pos; #if LINUX_VERSION_2_6_19_REPLACE_INTERFACE RC = generic_file_aio_write(iocb, iov, count, pos); #else RC = generic_file_aio_write(iocb, buf, count, pos); #endif if(RC > 0) { if(pFCB->XixcoreFcb.WriteStartOffset == -1) { pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } if(pFCB->XixcoreFcb.WriteStartOffset > index ){ pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } return RC; } } else { return -EPERM; } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_aio_write .\n")); return RC; }
ssize_t xixfs_file_write( struct file *file, const char __user *buf, size_t count, loff_t *ppos ) { ssize_t RC = 0; int64 index = 0; #if LINUX_VERSION_25_ABOVE struct address_space *mapping = file->f_mapping; #else struct address_space *mapping = file->f_dentry->d_inode->i_mapping; #endif struct inode *inode = mapping->host; PXIXFS_LINUX_FCB pFCB = NULL; PXIXFS_LINUX_VCB pVCB = NULL; XIXCORE_ASSERT(inode); pVCB = XIXFS_SB(inode->i_sb); XIXFS_ASSERT_VCB(pVCB); pFCB = XIXFS_I(inode); XIXFS_ASSERT_FCB(pFCB); DebugTrace(DEBUG_LEVEL_TRACE, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("ENTER xixfs_file_write (%s).\n", file->f_dentry->d_name.name)); if(pVCB->XixcoreVcb.IsVolumeWriteProtected){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR xixfs_file_write : is read only .\n")); return -EPERM; } XIXCORE_ASSERT(pFCB->XixcoreFcb.FCBType == FCB_TYPE_FILE); if(XIXCORE_TEST_FLAGS( pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_CHANGE_DELETED )){ DebugTrace(DEBUG_LEVEL_ERROR, DEBUG_TARGET_ALL, ("ERROR DELETED FILE \n")); return -EPERM; } if( pFCB->XixcoreFcb.HasLock == INODE_FILE_LOCK_HAS) { index =(int64) (*ppos); #if LINUX_VERSION_2_6_19_REPLACE_INTERFACE RC = do_sync_write(file, buf, count, ppos); #else RC = generic_file_write(file, buf, count, ppos); #endif if(RC > 0) { if(pFCB->XixcoreFcb.WriteStartOffset == -1) { pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } if(pFCB->XixcoreFcb.WriteStartOffset > index ){ pFCB->XixcoreFcb.WriteStartOffset = index; XIXCORE_SET_FLAGS(pFCB->XixcoreFcb.FCBFlags, XIXCORE_FCB_MODIFIED_FILE_SIZE); } } return RC; } else { return -EPERM; } DebugTrace(DEBUG_LEVEL_ERROR, (DEBUG_TARGET_FCB|DEBUG_TARGET_VFSAPIT), ("EXIT xixfs_file_write .\n")); return RC; }