stdfs.c

T-kernel 的extension源代码

	ER		err;

	/* Error designated by root directory */
	if ( inode->nlnk < TSD_STD_NLN_2 ) {
		err = E_PAR;
		goto err_ret;
	}

	/* Link of parent file */
	tc_strncpy(pl.fs_name, inode->link.fs_name, L_FSNM);
	pl.f_id = path[inode->nlnk - TSD_STD_NLN_2];

	/* Parent file access attribute check */
	err = tkse_chk_fil(&pl, F_WRITE, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* File deletion */
	err = tkse_del_fil(&pl, &inode->link, 0);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("sf_unlink err=%#x\n", err));
	return err;
}

/*
 * Creation of directory
 */
EXPORT ER sf_mkdir( INODE *_inode, const char *fname, mode_t mode )
{
	SFNODE		*inode = (SFNODE*)_inode;
	UH		*path = (UH*)inode->c.exinf;
	LINK		lnk;
	TC		tcname[L_FNM + 1];
	W		len;
const	B		*p, *np;
	ER		err;

	/* Nonexistent connection name error*/
	if ( inode->nlnk < TSD_STD_NLN_2) {
		err = E_FACV;
		goto err_ret;
	}

	/* Link of parent file */
	tc_strncpy(lnk.fs_name, inode->link.fs_name, L_FSNM);
	lnk.f_id = path[inode->nlnk - TSD_STD_NLN_2];

	/* Parent file access attribute check */
	err = tkse_chk_fil(&lnk, F_WRITE, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Appearance order location of file name */
	for ( p = np = fname; (np = strchr(np + 1, ':')) != NULL; p = np ) {
		;
	}
	if ( p != fname ) {
		/* Confirmation of appearance order */
		for ( np = p + 1;( *np >= '0' )&&( *np <= '9'); np++ ) {
			;
		}

		/* Keep as it is when it is not in appearance order */
		if (((*np != '\0' )&&( *np != '/' ))||( np == (p + 1))) {
			p = fname;
		}
	}

	/* Check of file name */
	if ( p == fname ) {
		p = strchr(fname, '/');
		if ( p == NULL ) {
			p = strchr(fname, '\0');
		}

		/* File name length */
		len = p - fname;
	} else {
		/* File name length */
		len = p - fname;

		if (((len == 1 )&&( strncmp(fname, ".", (size_t)1) == 0)) ||
		    ((len == TSD_STD_LEN_2 )&&( strncmp(fname, "..", (size_t)TSD_STD_SNC_2) == 0))) {
			err = E_FNAME;
			goto err_ret;
		}
	}

	/* File name conversion */
	err = btConvName_toTC((UB*)fname, len, tcname, L_FNM + 1, TRUE);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Directory creation */
	err = tkse_cre_fil(&lnk, tcname, NULL, ATYPE_DIR, F_FIX);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Close */
	err = tkse_cls_fil(err);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* File access attribute */
	if ( (mode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0 ) {
		err = tkse_chg_fat(&lnk, F_SETRONLY);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("sf_mkdir err=%#x\n", err));
	return err;
}

/*
 * Deletion of directory
 */
EXPORT ER sf_rmdir( INODE *_inode )
{
	SFNODE		*inode = (SFNODE*)_inode;
	UH		*path = (UH*)inode->c.exinf;
	F_STATE		stat;
	LINK		pl;
	ER		err;

	/* Error designated by root directory */
	if ( inode->nlnk < TSD_SRD_VA1_2 ) {
		err = E_FACV;
		goto err_ret;
	}

	/* Link of parent file */
	tc_strncpy(pl.fs_name, inode->link.fs_name, L_FSNM);
	pl.f_id = path[inode->nlnk - TSD_SRD_VA2_2];

	/* Parent file access attribute check */
	err = tkse_chk_fil(&pl, F_WRITE, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Error if it is not empty */
	err = tkse_fil_sts(&inode->link, NULL, &stat, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( stat.f_nlink > 0 ) {
		err = E_OBJ;
		goto err_ret;
	}

	/* Directory deletion */
	err = tkse_del_fil(&pl, &inode->link, 0);
	if ( err == E_REC ) {
		err = E_OBJ;
		goto err_ret;
	}
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("sf_rmdir err=%#x\n", err));
	return err;
}

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

/*
 * Modification of current directory
 */
EXPORT ER sf_chdir( FS *fs, INODE *_inode )
{
	SFNODE		*inode = (SFNODE*)_inode;
	ER		err;

	/* Working file modification */
	if ( fs == (FS*)&STD_FS ) {
		err = tkse_chg_wrk(&inode->link);
		if ( err < E_OK ) {
			goto err_ret;
		}
	} else {
		err = tkse_chg_wrk(NULL);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("sf_chdir err=%#x\n", err));
	return err;
}

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

#define DEFAULT_FILMODE	(S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
#define FILMODE_WRITE	(S_IWUSR|S_IWGRP|S_IWOTH)

/*
 * Acquisition of file information
 */
LOCAL ER btGetAttr( SFNODE *inode, W sffd, struct stat *sb )
{
	F_STATE		stat;
	F_LOCATE	locat;
	FS_STATE	fsstat;
	UB		dn[L_DEVNM + 1];
	W		filsz;
	ER		err;

	/* Initialization */
	memset(sb, 0, (size_t)sizeof(struct stat));

	/* File information */
	err = tkse_ofl_sts(sffd, NULL, &stat, &locat);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Conversion of device name */
	err = tcstoeucs(dn, locat.fs_dev);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Device ID  */
	sb->st_dev = (dev_t)tk_ref_dev(dn, NULL);
	if ( (ID)sb->st_dev < E_OK ) {
		err = E_PAR;
		goto err_ret;
	}

	/* File number */
	sb->st_ino = inode->c.ino;

	/* File mode */
	sb->st_mode = DEFAULT_FILMODE;
	if ( (stat.f_type & F_RONLY) == 0 ) {
		sb->st_mode |= FILMODE_WRITE;
	}

	if ( inode->c.type == DT_REG ) {	/* Regular file */
		/* File type */
		sb->st_mode |= S_IFREG;

		/* File size */
		err = tkse_fnd_rec(sffd, F_TOPEND, TSD_STD_TFR_0X80000000, 0U, NULL);
		if (( err < E_OK )&&( err != E_REC )) {
			goto err_ret;
		}
		if ( err != E_REC ) {
			err = tkse_rea_rec(sffd, 0, NULL, 0, &filsz, NULL);
			if ( err < E_OK ) {
				goto err_ret;
			}
			sb->st_size = filsz;
		} else {
			sb->st_size = 0;
		}
	} else {				/* Directory */
		/* File type */
		sb->st_mode |= S_IFDIR;

		/* File size */
		sb->st_size = stat.f_nlink + TSD_BGA_VA2_2;
	}

	/* The number of links */
	sb->st_nlink	 = (nlink_t)stat.f_nlink;

	/* File time */
	sb->st_atimespec.tv_sec = stat.f_atime;
	sb->st_mtimespec.tv_sec = stat.f_mtime;
	sb->st_ctimespec.tv_sec = stat.f_ctime;

	/* File system information */
	err = tkse_fls_sts(locat.fs_dev , &fsstat);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* The number of blocks */
	if ( fsstat.fs_bsize >= S_BLKSIZE ) {
		sb->st_blocks = (int64_t)(stat.f_nblk * ((W)fsstat.fs_bsize / S_BLKSIZE));
	} else {
		sb->st_blocks = (int64_t)(stat.f_nblk / (S_BLKSIZE / (W)fsstat.fs_bsize));
	}

	/* Block size */
	sb->st_blksize	 = fsstat.fs_bsize;

	/* User definition flag */
	sb->st_flags	 = ((inode->link.atr1 & TSD_GBA_MSK_0X8000) != 0U) ? SF_HIDDEN: 0;

	return E_OK;

err_ret:
	DEBUG_PRINT(("btGetAttr err=%#x\n", err));
	return err;
}

/*
 * Acquisition of file information
 */
EXPORT ER sf_stat( INODE *_inode, struct stat *sb )
{
	SFNODE		*inode = (SFNODE*)_inode;
	W		sffd;
	ER		err;

	/* File open */
	sffd = tkse_opn_fil(&inode->link, F_READ, NULL);
	if ( sffd < E_OK ) {
		err = sffd;
		goto err_ret1;
	}

	/* Acquisition of file information */
	err = btGetAttr(inode, sffd, sb);
	if ( err < E_OK ) {
		goto err_ret2;
	}

	/* File close */
	err = tkse_cls_fil(sffd);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	return E_OK;

err_ret2:
	(void)tkse_cls_fil(sffd);
err_ret1:
	DEBUG_PRINT(("sf_stat err=%#x\n", err));
	return err;
}

EXPORT ER sf_lstat( INODE *_inode, struct stat *sb )
{
	SFNODE		*inode = (SFNODE*)_inode;
	W		sffd;
	ER		err;

	/* File open */
	sffd = tkse_opn_fil(&inode->link, F_READ, NULL);
	if ( sffd < E_OK ) {
		err = sffd;
		goto err_ret1;
	}

	/* Acquisition of file information */
	err = btGetAttr(inode, sffd, sb);
	if ( err < E_OK ) {
		goto err_ret2;
	}

	/* File close */
	err = tkse_cls_fil(sffd);
	if ( err < E_OK ) {
		goto err_ret1;
	}

	return E_OK;

err_ret2:
	(void)tkse_cls_fil(sffd);
err_ret1:
	DEBUG_PRINT(("sf_lstat err=%#x\n", err));
	return err;
}

EXPORT ER sf_fstat( FDPkt *fdp, struct stat *sb )
{
	SFFD		*fd = (SFFD*)fdp->fd;
	SFNODE		*inode = (SFNODE*)fd->c.inode;
	W		sffd = fd->sffd;
	ER		err;

	/* Acquisition of file information */
	err = btGetAttr(inode, sffd, sb);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("sf_fstat err=%#x\n", err));
	return err;
}

/*
 * Acquisition of file system list
 *	Store the file system connected by file management to "buf" to the maximum extent.
 *	When buf != NULL, return the number of stored file systems. 
 *	When buf == NULL, return the number of connected file systems.
 */
EXPORT WER sf_getfsstat( struct statfs *buf, long bufsize, int flags )
{
	F_ATTACH	*bbuf;
	FS_STATE	fss;
	W		cnt, max, i;
	TC		tcdn[L_DEVNM + 1];
	ER		err;

	/* Acquisition of file system buffer */
	max = (buf != NULL )? (W)((UW)bufsize / sizeof(struct statfs)): 1;
	if ( max <= 0 ) {
		return 0;
	}

	bbuf = malloc((size_t)(max * (W)sizeof(F_ATTACH)));
	if ( bbuf == NULL ) {
		err = E_NOMEM;
		goto err_ret1;
	}

	/* Acquisition of file system */
	cnt = tkse_lst_fls(bbuf, max);
	if ( cnt < E_OK ) {
		err = cnt;
		goto err_ret2;
	}
	if ( buf == NULL ) {
		goto finish;
	}
	if ( cnt > max ) {
		cnt = max;
	}

	for ( i = 0; i < cnt; i++ ) {
		/* File system management information */
		err = tkse_fls_sts(bbuf[i].dev, &fss);
		if ( err < E_OK ) {
			goto err_ret2;
		}

		buf[i].f_bsize  = (long)fss.fs_bsize;
		buf[i].f_iosize = (long)fss.fs_bsize;
		buf[i].f_blocks = (long)fss.fs_nblk;
		buf[i].f_bfree  = (long)fss.fs_nfree;
		buf[i].f_bavail = (long)fss.fs_nfree;
		buf[i].f_files  = (long)fss.fs_nfile;
		buf[i].f_ffree  = TSD_SGF_FFR_M1;
		buf[i].f_fsid.val[0] = buf[i].f_fsid.val[1] = 0;
		buf[i].f_owner  = 0;
		buf[i].f_type   = MOUNT_STDFS;
		buf[i].f_flags  = (err > 0)? MNT_RDONLY: 0;

		/* Connection name conversion */
		strncpy(buf[i].f_mntonname, "/", (size_t)1);
		err = btConvName_fromTC(bbuf[i].a_name,
					(UB*)buf[i].f_mntonname + 1, L_CONNM + 1);
		if ( err < E_OK ) {
			goto err_ret2;
		}

		/* Device name conversion */
		(void)tc_strncpy(tcdn, bbuf[i].dev, L_DEVNM);
		tcdn[L_DEVNM] = TNULL;
		strncpy((B*)buf[i].f_mntfromname, "/dev/", (size_t)TSD_SGF_VAL_5);
		err = tcstoeucs((UB*)buf[i].f_mntfromname + TSD_SGF_TTE_5, tcdn);
		if ( err < E_OK ) {
			goto err_ret2;
		}
	}

finish:
	/* File system buffer release */
	free(bbuf);

	return cnt;

err_ret2:
	free(bbuf);
err_ret1:
	DEBUG_PRINT(("sf_getfsstat err=%#x\n", err));
	return err;
}

/*
 * Acquisition of file LINK
 */
EXPORT ER sf_getlink( INODE *_inode, char *buf )
{
	SFNODE		*inode = (SFNODE*)_inode;

	/* Acquired by path name analysis */
	memcpy(buf, &inode->link, (size_t)sizeof(LINK));

	return E_OK;
}

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

/*
 * File reading
 */
EXPORT WER sf_read( FDPkt *fdp, void *buf, size_t nbyte )
{
	SFFD	*fd = (SFFD*)fdp->fd;
	W	r_size, readsz;
	ER	err;

	/* Transfer to reading target record */
	if ( !fd->currec ) {
		err = tkse_fnd_rec(fd->sffd, F_TOPEND, TSD_STD_TFR_0X80000000, 0U, NULL);
		if ( err == E_REC ) {
			return 0;
		}
		if ( err < E_OK ) {
			goto err_ret;
		}

		/* Determination of operation target record  */
		fd->currec = TRUE;
	}

	/* Record size check */
	err = tkse_rea_rec(fd->sffd, 0, NULL, 0, &r_size, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( (W)fd->c.fpos >= r_size ) {
		return 0;
	}

	/* File reading */
	err = tkse_rea_rec(fd->sffd, (W)fd->c.fpos, buf, (W)nbyte, &r_size, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}
	readsz = (r_size < (W)nbyte)? r_size: (W)nbyte;

	/* File pointer transfer */
	fd->c.fpos += (UW)readsz;

	return readsz;

err_ret:
	DEBUG_PRINT(("sf_read err=%#x\n", err));
	return err;
}

/*
 * File writing
 */
EXPORT WER sf_write( FDPkt *fdp, const void *buf, size_t nbyte )
{
	SFFD	*fd = (SFFD*)fdp->fd;
	W	r_size, writesz, recsz = 0;
	ER	err;

	/* Transfer to writing target record */
	if ( !fd->currec ) {
		err = tkse_fnd_rec(fd->sffd, F_TOPEND, TSD_STD_TFR_0X80000000, 0U, NULL);
		if ( (err < E_OK) && (err != E_REC) ) {
			goto err_ret;
		}

		/* Determination of operation target record */
		if ( err != E_REC ) {
			fd->currec = TRUE;
		}
	}

	if ( !fd->currec ) {
		/* File pointer check */
		if (( fd->c.fpos > 0 )&&( (fd->c.omode & O_APPEND) == 0)) {
			err = E_PAR;
			goto err_ret;
		}

		/* Writing into new record */
		err = tkse_apd_rec(fd->sffd, (B*)buf, (W)nbyte, TSD_STD_TAR_31, 0U, 0U);
		if ( err < E_OK ) {
			goto err_ret;
		}
		writesz = (W)nbyte;

		/* Configure to the present record */
		err = tkse_fnd_rec(fd->sffd, F_ENDTOP, TSD_STD_TFR_0X80000000, 0U, NULL);
		if ( err < E_OK ) {
			goto err_ret;
		}

		/* Determination of operation target record determination */
		fd->currec = TRUE;

		/* File pointer transfer */
		fd->c.fpos = nbyte;
	} else {
		/* Writing into present location */