fstask.c

T-kernel 的extension源代码

	  case FM_DEL_REC_FN:
		fmpDeleteRecord(pkt);
		break;
	  case FM_TRC_REC_FN:
		fmpTruncateRecord(pkt);
		break;
	  case FM_XCH_FIL_FN:
		fmpExchangeFileContent(pkt);
		break;
	  case FM_LOC_REC_FN:
		fwd = fmpLockRecord(pkt);
		break;
	  case FM_OFL_STS_FN:
		fmpGetFileStatusFD(pkt);
		break;
	  case FM_MAP_REC_FN:
		fmpMapRecord(pkt);
		break;
	  case FM_UMP_REC_FN:
		fmpUnmapRecord(pkt);
		break;
	  case FM_SYN_FIL_FN:
		fmpSyncFileData(pkt);
		break;
	  case FM_GETRECINFO_FN:
		fmpGetRecordInfo(pkt);
		break;

	  default:
		err = E_RSFN;
		goto err_ret1;
	}

	/* Whether the synchronization of the file system is requested. */
	if ( checkSyncAtExit(SAE_OPENF, fsinfo) ) {
		cancelSyncAtExit((UB)SAE_OPENF, fsinfo);

		/* Synchronize the file system only when
		   the file system is connected in synchronous mode.
		   (When asynchronous mode, it is synchronized with cls_fil.) */
		if ( fsinfo->conMode == FS_SYNC ) {
			err = fmpSyncFile(fd->ofcb, fsinfo);
			if ( err < E_OK ) {
				if ( pkt->cmd.ret >= E_OK ) {
					pkt->cmd.ret = err;
				}
				goto err_ret0;
			}
		}
	}

	return fwd;

err_ret1:
	pkt->cmd.ret = err;
err_ret0:
	DEBUG_PRINT(("fdEntry err = %d\n", err));
	return NoForward;
}

/*
 * Request processing entry when the file is specified by LINK.
 */
LOCAL FwdID linkEntry( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	LINK			*lnk = (LINK*)((W*)pkt->cmd.para)[0];
	FID			fid;
	DfFileHeaderBlock	*fhd;
	DskAdr			dadr;
	UH			ftype;
	ID			mid;
	UW			mflag = MD_RDONLY;
	FwdID			fwd;
	ER			err;

	if ( isCmdForward(pkt) != 0 ) {
		/* Reference of the value forwarded with link file */
		fid = pkt->wrk.lnk.f_id;
	} else {
		/* First reference */
		fid = lnk->f_id;
	}

	/* Obtain the file header. */
	fhd = fmpMapFileHeader(fid, &dadr, &mid, fsinfo);
	if ( fhd == NULL ) {
		err = (ER)mid;
		goto err_ret1;
	}

	/* Fetch the file type. */
	ftype = fmpConvEndianH(fhd->head.ftype, fsinfo);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret2;
	}

	/* Judge the file type. */
	if ( isLinkFile(ftype) != 0 ) {

		/* Multiplex indirect link is not permitted. */
		if ( isCmdForward(pkt) != 0 ) {
			err = E_NOEXS;
			goto err_ret2;
		}

		/* Specify the file referred to. */
		pkt->wrk.lnk = *lnk;
		pkt->wrk.lnk.f_id = fmpConvEndianH(fhd->f.link.fid, fsinfo);
		(void)fmpConvEndianTC(pkt->wrk.lnk.fs_name, (TC*)fhd->f.link.fsnm,
							FsNameLen, fsinfo);
		err = fmpCheckDiskError(NULL, fsinfo);
		if ( err < E_OK ) {
			goto err_ret2;
		}

		fwd = ForwardMgr; /* Forward  */
	} else {
		OpenPara	opara;

		opara.fid  = fid;
		opara.fhd  = fhd;
		opara.dadr = dadr;

		/* Processing of each system call */
		switch ( pkt->cmd.fno.w ) {
		  case FM_CRE_FIL_FN:
			mflag = fmpCreateFile(pkt, &opara, fsinfo);
			break;
		  case FM_CRE_LNK_FN:
			mflag = fmpCreateLinkFile(pkt, &opara, fsinfo);
			break;
		  case FM_GEN_FIL_FN:
			mflag = fmpGenerateFile(pkt, &opara, fsinfo);
			break;
		  case FM_OPN_FIL_FN:
			mflag = fmpOpenFile(pkt, &opara, fsinfo);
			break;
		  case FM_DEL_FIL_FN:
			mflag = fmpDeleteFile(pkt, &opara, fsinfo);
			break;
		  case FM_CHK_FIL_FN:
			mflag = fmpCheckFileAccess(pkt, &fhd->head, fsinfo);
			break;
		  case FM_CHG_FMD_FN:
			mflag =
			  fmpChangeFileAccessMode(pkt, &fhd->head, fsinfo);
			break;
		  case FM_CHG_FAT_FN:
			mflag =
			  fmpChangeFileAttribute(pkt, &fhd->head, fsinfo);
			break;
		  case FM_CHG_FNM_FN:
			mflag =
			  fmpChangeFileName(pkt, fid, &fhd->head, fsinfo);
			break;
		  case FM_CHG_FTM_FN:
			mflag = fmpChangeFileTime(pkt, &fhd->head, fsinfo);
			break;
		  case FM_FIL_STS_FN:
			mflag =
			  fmpGetFileStatusLINK(pkt, fid, &fhd->head, fsinfo);
			break;
		  default:
			DEBUG_PRINT(("linkEntry, unknown fno\n"));
			pkt->cmd.ret = E_RSFN;
			break;
		}

		fwd = NoForward;
	}

	fmpUnmapDisk(mid, mflag);

	return fwd;

err_ret2:
	fmpUnmapDisk(mid, mflag);
err_ret1:
	DEBUG_PRINT(("linkEntry err = %d\n", err));
	pkt->cmd.ret = err;
	return NoForward;
}

/*
 * File generation system call entry
 */
LOCAL FwdID createEntry( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	W	opt;
	FwdID	fwd;

	switch ( pkt->cmd.fno.w ) {
	  case FM_CRE_FIL_FN:
		opt = ((FM_CRE_FIL_PARA*)pkt->cmd.para)->opt;
		break;
	  case FM_CRE_LNK_FN:
		opt = ((FM_CRE_LNK_PARA*)pkt->cmd.para)->opt;
		break;
	  case FM_GEN_FIL_FN:
		opt = ((FM_GEN_FIL_PARA*)pkt->cmd.para)->opt;
		break;
	  default:
		DEBUG_PRINT(("createEntry, unknown fno\n"));
		pkt->cmd.ret = E_RSFN;
		return NoForward;
	}

	if ( opt == F_FIX ) {
		/* Forwarding required */
		fwd = linkEntry(pkt, fsinfo);
	} else {
		/* Forwarding not required. */
		switch ( pkt->cmd.fno.w ) {
		  case FM_CRE_FIL_FN:
			(void)fmpCreateFile(pkt, NULL, fsinfo);
			break;
		  case FM_CRE_LNK_FN:
			fmpCreateLinkFile(pkt, NULL, fsinfo);
			break;
		  case FM_GEN_FIL_FN:
			(void)fmpGenerateFile(pkt, NULL, fsinfo);
			break;
		  default:
			/* nothing to do */
			break;
		}
		fwd = NoForward;
	}

	return fwd;
}

/*
 * File deletion system call entry
 */
LOCAL FwdID deleteEntry( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FM_DEL_FIL_PARA	*cmdPara = (FM_DEL_FIL_PARA*)pkt->cmd.para;

	if ( cmdPara->org != NULL ) {
		return linkEntry(pkt, fsinfo);
	}

	fmpDeleteFile(pkt, NULL, fsinfo);

	return NoForward;
}

/*
 * Request processing entry
 */
LOCAL FwdID fmpEntry( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FwdID	fwd = NoForward;
	ER	err;

	switch ( pkt->cmd.fno.w ) {
	  /*
	   * Service request from inside OS
	   */
	  case FM_FINISH_FN:
		fmpFinish(pkt, fsinfo);
		break;
	  case FM_BREAK_FN:
		fmpBreak(pkt, fsinfo);
		break;
	  case FM_INIT_FN:
	  case FM_STARTUP_FN:
	  case FM_CLEANUP_FN:
		/* These services should not be requested. */
		pkt->cmd.ret = E_SYS;
		break;
	  /*
	   * One that specifies the file by path name
	   */
	  case FM_GET_LNK_FN:
		fwd = fmpGetLink(pkt, fsinfo);
		break;
	  /*
	   * One that specifies the file by LINK
	   */
	  case FM_CHG_WRK_FN:
		fmpChangeWorkFile(pkt, fsinfo);
		break;
	  case FM_CRE_FIL_FN:
	  case FM_CRE_LNK_FN:
	  case FM_GEN_FIL_FN:
		fwd = createEntry(pkt, fsinfo);
		break;
	  case FM_DEL_FIL_FN:
		fwd = deleteEntry(pkt, fsinfo);
		break;
	  case FM_OPN_FIL_FN:
	  case FM_CHK_FIL_FN:
	  case FM_CHG_FMD_FN:
	  case FM_CHG_FAT_FN:
	  case FM_CHG_FNM_FN:
	  case FM_CHG_FTM_FN:
	  case FM_FIL_STS_FN:
		fwd = linkEntry(pkt, fsinfo);
		break;
	  case FM_LNK_STS_FN:
		fmpGetLinkFileStatus(pkt, fsinfo);
		break;
	  case FM_SYN_LNK_FN:
		fmpSyncLinkFile(pkt, fsinfo);
		break;
	  case FM_GET_NLK_FN:
		fmpGetNextLink(pkt, fsinfo);
		break;
	  /*
	   * One that specifies the file by file descriptor
	   */
	  case FM_CLS_FIL_FN:
	  case FM_SEE_REC_FN:
	  case FM_FND_REC_FN:
	  case FM_FND_LNK_FN:
	  case FM_REA_REC_FN:
	  case FM_WRI_REC_FN:
	  case FM_INS_REC_FN:
	  case FM_APD_REC_FN:
	  case FM_DEL_REC_FN:
	  case FM_TRC_REC_FN:
	  case FM_XCH_FIL_FN:
	  case FM_LOC_REC_FN:
	  case FM_OFL_STS_FN:
	  case FM_MAP_REC_FN:
	  case FM_UMP_REC_FN:
	  case FM_SYN_FIL_FN:
	  case FM_GETRECINFO_FN:
		fwd = fdEntry(pkt, fsinfo);
		break;
	  /*
	   * One that does not specify the file.
	   */
	  case FM_GET_DFM_FN:
	  case FM_SET_DFM_FN:
		/* These services should not be requested. */
		pkt->cmd.ret = E_SYS;
		break;
	  /*
	   * One relating to the file system
	   */
	  case FM_ATT_FLS_FN:
		fmpAttachFileSystem(pkt, fsinfo);
		break;
	  case FM_CHG_FSM_FN:
		fmpChangeFileSystemMode(pkt, fsinfo);
		break;
	  case FM_DET_FLS_FN:
		fmpDetachFileSystem(pkt, fsinfo);
		break;
	  case FM_SYN_FLS_FN:
	  case FM_FLS_STS_FN:
	  case FM_CHG_FLS_FN:
	  case FM_LST_FLS_FN:
		/* These services should not be requested. */
		pkt->cmd.ret = E_SYS;
		break;
	  /*
	   * Service command for internal use
	   */
	  case FMI_GetFileInfo_FN:
		fmpIGetFileInfo(pkt, fsinfo);
		break;
	  case FMI_ChangeLinkFileName_FN:
		fmpIChangeLinkFileName(pkt, fsinfo);
		break;
	  case FMI_SetWorkFile_FN:
		fmpISetWorkFile(pkt, fsinfo);
		break;

	  case FMI_BreakSysCall_FN:
		/* It just returns. */
		break;

	  default:
		pkt->cmd.ret = E_RSFN;
		break;
	}

	/* Whether the synchronization of the file system is requested. */
	if ( checkSyncAtExit(SAE_FSTSK, fsinfo) ) {
		cancelSyncAtExit((UB)SAE_FSTSK, fsinfo);

		/* Synchronize the file system. */
		err = fmpSyncFile(MAP_FSTSK, fsinfo);
		if ( err < E_OK ) {
			if ( pkt->cmd.ret >= E_OK ) {
				pkt->cmd.ret = err;
			}
			goto err_ret;
		}
	}

	return fwd;

err_ret:
	DEBUG_PRINT(("fmpEntry err = %d\n", err));
	return NoForward;
}

/*
 * File system task entry
 */
EXPORT void fmpFsTask( ID port, VP exinf )
{
	FsInfo		*fsinfo = exinf;
	FmCmdPkt	*pkt;
	FwdID		fwd;
	TMO		tmo = TMO_FEVR;
	ER		err;

	/*
	 * Lock it always except when the file system task goes into waiting.
	 */
	Lock(&fsinfo->lock);

	QueInit(&fsinfo->resumeReq);

	for ( ;; ) {	/* It does not end by itself. */

		/* Fetch a request waiting for resumption. */
		pkt = (FmCmdPkt*)QueRemoveNext(&fsinfo->resumeReq);
		if ( pkt == NULL ) {
			RNO		rdvno;
			INT		cmsgsz;

			/* Receive a request. */
			Unlock(&fsinfo->lock);
			cmsgsz = tk_acp_por(port, (~0U), &rdvno, &pkt, tmo);
			Lock(&fsinfo->lock);
			if ( cmsgsz == E_TMOUT ) {
				(void)SyncFS(fsinfo->dskid, 0);
				tmo = TMO_FEVR;
				continue;
			}
			if ( cmsgsz < E_OK ) {
				DEBUG_PRINT(("acp_por er = %d\n", cmsgsz));
				continue;
			}
			tmo = fmInfo.syncTimeOut;

			pkt->wrk.rdvno = rdvno;
			pkt->cmd.ret = E_OK;
		}

		/* Conform the task address space to the processing request task. */
		err = SetTaskSpace(pkt->cmd.tid);
		if ( err != E_OK ) {
			goto err_ret;
		}

		/* Request processing */
		fwd = fmpEntry(pkt, fsinfo);

		if ( pkt->cmd.ret == EFM_RETRY ) {
			/* Reexecution reservation */
			err = fmForwardFsTask(fsinfo->port,
						pkt->wrk.rdvno, pkt);
			if ( err < E_OK ) {
				goto err_ret;
			}
			continue;
		}

		if ( fwd == WaitRequest ) {
			/* Go into indeterminate waiting. */
			continue;
		}

		if ( fwd == ForwardMgr ) {
			if ( !isCmdForward(pkt) ) {
				err = E_ILFMT;
				goto err_ret;
			}

			/* Forward to the manager task (Common section task) */
			err = fmForwardMgrTask(pkt->wrk.rdvno, pkt);
			if ( err == E_OK ) {
				continue;
			}

	err_ret:
			pkt->cmd.ret = err;
			DEBUG_PRINT(("fmpFsTask err = %d\n", err));
		}

		/* Result response */
		err = tk_rpl_rdv(pkt->wrk.rdvno, &pkt, sizeof(VP));
		if ( err != E_OK ) {
			DEBUG_PRINT(("tk_rpl_rdv er = %d\n", err));
		}
	}

	tk_exd_tsk(); /* It should not come here. */
}