others.c

T-kernel 的extension源代码

					MAP_SYS(fsinfo), &mid, fsinfo);
	if ( sh == NULL ) {
		err = (ER)mid;
		goto err_ret;
	}

	/* Obtain the file location information. */
	locat->fs_ctime = (STIME)fmpConvEndianW((UW)sh->ctime, fsinfo);
	tc_strncpy(locat->fs_name, fsinfo->fsName, FsNameLen);
	(void)fmpConvEndianTC(locat->fs_locat, (TC*)sh->devnm, L_DLNM, fsinfo);
	tc_strncpy(locat->fs_dev, fsinfo->devName, DevNameLen);

	fmpUnmapDisk(mid, MD_RDONLY);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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

/*
 * fil_sts: Obtain the file information.
 *	When writing is performed to fh, return MD_WRITE.
 *	Otherwise, return MD_RDONLY.
 */
EXPORT UW fmpGetFileStatusLINK( FmCmdPkt *pkt, FID fid, DfFileHeader *fh,
							FsInfo *fsinfo )
{
	FM_FIL_STS_PARA	*cmdPara = (FM_FIL_STS_PARA*)pkt->cmd.para;
	W		refcnt;
	ER		err;

	/* Parameter check */
	if ( cmdPara->name != NULL ) {
		err = CheckSpaceRW(cmdPara->name, sizeof(FileName)+sizeof(TC));
		if ( err < E_OK ) {
			goto err_ret;
		}
	}
	if ( cmdPara->stat != NULL ) {
		err = CheckSpaceRW(cmdPara->stat, sizeof(F_STATE));
		if ( err < E_OK ) {
			goto err_ret;
		}
	}
	if ( cmdPara->locat != NULL ) {
		err = CheckSpaceRW(cmdPara->locat, sizeof(F_LOCATE));
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	/* Obtain the file name and management information. */
	getFileStateInfo(fh, cmdPara->name, cmdPara->stat, fsinfo);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Obtain the file reference count. */
	refcnt = fmpGetFileReferenceCount(fid, fh, fsinfo);
	if ( refcnt < E_OK ) {
		err = (ER)refcnt;
		goto err_ret;
	}

	/* Obtain the location information. */
	err = getLocateInfo(cmdPara->locat, fsinfo);
	if ( err < E_OK ) {
		goto err_ret;
	}

	pkt->cmd.ret = refcnt;
	return MD_RDONLY;

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

/*
 * ofl_sts: Obtain the file information.
 */
EXPORT void fmpGetFileStatusFD( FmCmdPkt *pkt )
{
	FM_OFL_STS_PARA	*cmdPara = (FM_OFL_STS_PARA*)pkt->cmd.para;
	FD		*fd;
	OFCB		*ofcb;
	FsInfo		*fsinfo;
	W		refcnt;
	DfFileHeader	*fh;
	ID		mid;
	ER		err;

	/* Obtain FD and OFCB. */
	fd = getFDp(cmdPara->fd);
	ofcb = fd->ofcb;
	fsinfo = ofcb->fsinfo;

	/* Parameter check */
	if ( cmdPara->name != NULL ) {
		err = CheckSpaceRW(cmdPara->name, sizeof(FileName)+sizeof(TC));
		if ( err < E_OK ) {
			goto err_ret1;
		}
	}
	if ( cmdPara->stat != NULL ) {
		err = CheckSpaceRW(cmdPara->stat, sizeof(F_STATE));
		if ( err < E_OK ) {
			goto err_ret1;
		}
	}
	if ( cmdPara->locat != NULL ) {
		err = CheckSpaceRW(cmdPara->locat, sizeof(F_LOCATE));
		if ( err < E_OK ) {
			goto err_ret1;
		}
	}

	/* Map the file header. */
	fh = fmpMapDskAdr(ofcb->fhead, sizeof(DfFileHeader),
						ofcb, &mid, fsinfo);
	if ( fh == NULL ) {
		err = (ER)mid;
		goto err_ret1;
	}

	/* Obtain the file name and management information. */
	getFileStateInfo(fh, cmdPara->name, cmdPara->stat, fsinfo);

	/* Obtain the file reference count. */
	refcnt = fmpGetFileReferenceCount(ofcb->fid, fh, fsinfo);
	if ( refcnt < E_OK ) {
		err = (ER)refcnt;
		goto err_ret2;
	}

	fmpUnmapDisk(mid, MD_RDONLY);
	err = fmpCheckDiskError(ofcb, fsinfo);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	/* Obtain the location information. */
	err = getLocateInfo(cmdPara->locat, fsinfo);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	pkt->cmd.ret = refcnt;
	return;

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

/*
 * Obtain the link file information.
 */
LOCAL void getLinkFileInfo( DfFileHeaderBlock *fh, F_LINK *stat,
							FsInfo *fsinfo )
{
	BOOL	big = fsinfo->bigEndian;

	stat->f_ctime = (STIME)fmConvEndianW((UW)fh->head.ctime, big);
	stat->f_atype = fmConvEndianH(fh->head.atype, big);
	(void)fmConvEndianTC(stat->f_name, (TC*)fh->head.name, FileNameLen, big);
	stat->f_id = fmConvEndianH(fh->f.link.fid, big);
	stat->rf_ctime = (STIME)fmConvEndianW(getMisalignW(fh->f.link.ctime), big);
	(void)fmConvEndianTC(stat->fs_name, (TC*)fh->f.link.fsnm, L_FSNM, big);
	(void)fmConvEndianTC(stat->fs_locat, (TC*)fh->f.link.devnm, L_DLNM, big);
}

/*
 * lnk_sts: Obtain the link file information.
 */
EXPORT void fmpGetLinkFileStatus( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FM_LNK_STS_PARA		*cmdPara = (FM_LNK_STS_PARA*)pkt->cmd.para;
	FID			fid = cmdPara->lnk->f_id;
	F_LINK			*stat = cmdPara->stat;
	W			refcnt;
	DfFileHeaderBlock	*fh;
	UH			ftype;
	ID			mid;
	ER			err;

	/* Parameter check */
	if ( stat != NULL ) {
		err = CheckSpaceRW(stat, sizeof(F_LINK));
		if ( err < E_OK ) {
			goto err_ret1;
		}
	}

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

	/* Check the file type. */
	ftype = fmpConvEndianH(fh->head.ftype, fsinfo);
	if ( !isLinkFile(ftype) ) {
		err = E_NOLNK;
		goto err_ret2;
	}

	if ( stat != NULL ) {
		/* Obtain the link file information. */
		getLinkFileInfo(fh, stat, fsinfo);
	}

	/* Obtain the file reference count. */
	refcnt = fmpGetFileReferenceCount(fid, &fh->head, fsinfo);
	if ( refcnt < E_OK ) {
		err = (ER)refcnt;
		goto err_ret2;
	}

	fmpUnmapDisk(mid, MD_RDONLY);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	pkt->cmd.ret = refcnt;
	return;

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

/*
 * syn_lnk: Synchronize the link file.
 */
EXPORT void fmpSyncLinkFile( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FM_SYN_LNK_PARA		*cmdPara = (FM_SYN_LNK_PARA*)pkt->cmd.para;
	DfFileHeaderBlock	*fh;
	ID			mid;
	UW			mflag = MD_RDONLY;
	UH			ftype;
	LINK			ref;
	FileName		name, rname;
	STIME			ctime, rctime;
	W			match = F_SYNC;
	ER			err;

	/* Map the file header. */
	fh = fmpMapFileHeader(cmdPara->lnk->f_id, NULL, &mid, fsinfo);
	if ( fh == NULL ) {
		err = (ER)mid;
		goto err_ret1;
	}

	if ( cmdPara->opt != 0 ) {
		/* Whether it is write protected. */
		if ( isNoWriteFS(fsinfo) != 0 ) {
			err = E_RONLY;
			goto err_ret2;
		}
	}

	/* Check the file type. */
	ftype = fmpConvEndianH(fh->head.ftype, fsinfo);
	if ( !isLinkFile(ftype) ) {
		err = E_NOLNK;
		goto err_ret2;
	}

	/* Obtain the information of the file referred to. */
	(void)fmpConvEndianTC(ref.fs_name, (TC*)fh->f.link.fsnm, FsNameLen, fsinfo);
	ref.f_id = fmpConvEndianH(fh->f.link.fid, fsinfo);
	if ( isSameFS(ref.fs_name, fsinfo) != 0 ) {
		err = E_ILFMT;
		goto err_ret2;
	}
	err = fmIGetFileInfo(&ref, rname, &rctime, NULL);
	if ( err < E_OK ) {
		goto err_ret2;
	}

	/* Whether the file name matches */
	(void)fmpConvEndianTC(name, (TC*)fh->head.name, FileNameLen, fsinfo);
	if ( tc_strncmp(name, rname, FileNameLen) != 0 ) {
		match |= F_DNAME;

		if ( cmdPara->opt != 0 ) {
			/* Update (File name and abbreviated name) */
			err = fmpSetShortFileName(cmdPara->lnk->f_id, rname,
								fsinfo);
			if ( err < E_OK ) {
				goto err_ret2;
			}

			(void)fmpConvEndianTC((TC*)fh->head.name, rname, FileNameLen,
								fsinfo);
			mflag = MD_WRITE;
		}
	}

	/* Whether the date/time of creation matches */
	ctime = (STIME)fmpConvEndianW(getMisalignW(fh->f.link.ctime), fsinfo);
	if ( ctime != rctime ) {
		match |= F_DDATE;

		if ( cmdPara->opt != 0 ) {
			/* Update */
			setMisalignW(fh->f.link.ctime,
					fmpConvEndianW((UW)rctime, fsinfo));
			mflag = MD_WRITE;
		}
	}

	fmpUnmapDisk(mid, mflag);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	pkt->cmd.ret = match;
	setSyncAtExit(SAE_FSTSK, fsinfo);
	return;

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

/* ------------------------------------------------------------------------ */

/*
 * get_nlk: Fetch the links in sequence.
 */
EXPORT void fmpGetNextLink( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FM_GET_NLK_PARA	*cmdPara = (FM_GET_NLK_PARA*)pkt->cmd.para;
	DfFileID	f;
	DfFileID	*p = NULL;
	DskAdrS		fidt;
	W		refcnt;
	W		i, n, sz;
	ID		mid;
	ER		err;

	err = CheckSpaceRW(cmdPara->lnk, sizeof(LINK));
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Retrieve the next file. */
	i = cmdPara->lnk->f_id + 1;
	fidt = (DfFileID*)fsinfo->fidt + i;
	sz = (W)(fsinfo->sblk - ((UW)fidt % fsinfo->sblk));
	n = 0;
	for ( ; i < fsinfo->nfmax; ++i ) {
		if ( --n <= 0 ) {
			if ( p != NULL ) {
				fmpUnmapDisk(mid, MD_RDONLY);
			}

			/* Map the file ID table in one logical block. */
			p = fmpMapDskAdrS(fidt, sz,
					MAP_SYS(fsinfo), &mid, fsinfo);
			if ( p == NULL ) {
				err = (ER)mid;
				goto err_ret;
			}

			fidt = (DskAdrS)((VB*)fidt + sz);
			n = (W)((UW)sz / sizeof(DfFileID));
			sz = (W)fsinfo->sblk;
		}

		if ( p->w != 0U ) {
			/* Found */
			f = fmpConvEndianFileID(*p, fsinfo);
			break;
		}
		p++;
	}

	if ( p != NULL ) {
		fmpUnmapDisk(mid, MD_RDONLY);
	}
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret;
	}

	if ( i >= fsinfo->nfmax ) {
		err = E_NOEXS;
		goto err_ret;
	}

	refcnt = (W)f.s.refcnt;
	if ( (refcnt == TSD_FGN_CNT_255) && (fsinfo->diskform >= DiskForm_B) ) {
		/* STDFS extended format */
		DfFileHeader	*fh;

		/* Map the file header. */
		fh = fmpMapDskAdr(fmpLBlkToDAdr(f.s.blkadr, fsinfo),
				sizeof(DfFileHeader), MAP_FSTSK, &mid, fsinfo);
		if ( fh == NULL ) {
			err = (ER)mid;
			goto err_ret;
		}

		/* File reference count in STDFS extended format (>=255) */
		refcnt = (W)fmpConvEndianW((UW)fh->refcnt, fsinfo);

		fmpUnmapDisk(mid, MD_RDONLY);
		err = fmpCheckDiskError(NULL, fsinfo);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	/* Return the next link. */
	MakeLINK(cmdPara->lnk, (FID)i, fsinfo);

	pkt->cmd.ret = refcnt;
	return;

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

/* ======================================================================== */

/*
 * Obtain the file information. (Service command in the file management)
 */
EXPORT void fmpIGetFileInfo( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FMI_GetFileInfo_PARA	*cmdPara
		= (FMI_GetFileInfo_PARA*)pkt->cmd.para;
	DfFileHeaderBlock	*fh;
	ID			mid;
	ER			err;

	/* Map the file header. */
	fh = fmpMapFileHeader(cmdPara->lnk->f_id, NULL, &mid, fsinfo);
	if ( fh == NULL ) {
		err = (ER)mid;
		goto err_ret1;
	}

	/* Fetch the file name. */
	if ( cmdPara->fname != NULL ) {
		(void)fmpConvEndianTC(cmdPara->fname, (TC*)fh->head.name,
						FileNameLen, fsinfo);
	}

	/* Fetch the time of creation. */
	if ( cmdPara->ctime != NULL ) {
		*cmdPara->ctime = (W)fmpConvEndianW((UW)fh->head.ctime, fsinfo);
	}

	/* Fetch the access mode. */
	if ( cmdPara->amode != NULL ) {
		err = fmpGetFileAccMode(cmdPara->amode, &fh->head, fsinfo);
		if ( err < E_OK ) {
			goto err_ret2;
		}
	}

	fmpUnmapDisk(mid, MD_RDONLY);
	err = fmpCheckDiskError(NULL, fsinfo);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	pkt->cmd.ret = E_OK;
	return;

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

/*
 * Set the work file. (Service command in the file management)
 */
EXPORT void fmpISetWorkFile( FmCmdPkt *pkt, FsInfo *fsinfo )
{
	FMI_SetWorkFile_PARA	*cmdPara
		= (FMI_SetWorkFile_PARA*)pkt->cmd.para;
	ER			err;

	/* Set the work file. */
	err = changeWorkFile(cmdPara->pinfo, cmdPara->lnk, fsinfo);
	if ( err < E_OK ) {
		goto err_ret;
	}

	pkt->cmd.ret = E_OK;
	return;

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