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;
}
