stdfs.c

T-kernel 的extension源代码

		err = tkse_wri_rec(fd->sffd,
				((fd->c.omode & O_APPEND) != 0) ? TSD_STD_TWR_M1: (W)fd->c.fpos,
				(B*)buf, (W)nbyte, &r_size, NULL, 0);
		if ( err < E_OK ) {
			goto err_ret;
		}
		writesz = (r_size < (W)nbyte)? r_size: (W)nbyte;

		/* File pointer transfer */
		if ( (fd->c.omode & O_APPEND) != 0U ) {
			/* Record size */
			err = tkse_rea_rec(fd->sffd, 0, NULL, 0, &recsz, NULL);
			if ( err < E_OK ) {
				goto err_ret;
			}
			fd->c.fpos = (UW)recsz;
		} else {
			fd->c.fpos += (UW)writesz;
		}
	}

	return writesz;

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

/*
 * Fetch of directory entry
 */
EXPORT WER sf_getdents( FDPkt *fdp, struct dirent *buf, size_t nbyte )
{
	SFFD		*fd = (SFFD*)fdp->fd;
	SFNODE		*inode = (SFNODE*)fd->c.inode;
	UH		*path = (UH*)inode->c.exinf;
	struct dirent	dent;
	TC		tcname[L_FNM + 1], *order;
	F_STATE		stat;
	LINK		lnk;
	F_LINK		lstat;
	W		len, ordl, ordp, recnum, mode, ord, rdsize = 0;
	UW		fpos = (UW)fd->c.fpos;
	UB		type;
	div_t		d;
	ER		err;

	/* Check of record count and file pointer */
	err = tkse_ofl_sts(fd->sffd, NULL, &stat, NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}
	if ( (W)fpos >= (stat.f_nrec + TSD_STD_FPS_2) ) {
		return rdsize;
	}

	/* SEIO support */
	if ( fpos == 0U ) {		/* Creation of "." */
		dent.d_fileno = SFFS_INO(path[inode->nlnk - 1U]);
		dent.d_type = DT_DIR;
		dent.d_reclen = sizeof(struct dirent) - (MAXNAMLEN + 1);

		dent.d_name[TSD_FDE_POS_0] = '.';
		dent.d_name[TSD_FDE_POS_1] = '\0';

		dent.d_reclen += (TSD_SGF_VAL_5U &~ TSD_FDE_MSK_3);
		dent.d_namlen = 1;

		if ( dent.d_reclen > nbyte ) {
			err = E_PAR;
			goto err_ret;
		}

		/* Writing of buffer record */
		memcpy((UB*)buf, &dent, (size_t)dent.d_reclen);
		rdsize += dent.d_reclen;
		fpos++;
	}
	if ( fpos == 1U ) {		/* Creation of ".." */
		dent.d_fileno = (inode->nlnk < TSD_STD_NLN_2)?
				ROOT_INO: SFFS_INO(path[inode->nlnk - TSD_STD_NLN_2]);
		dent.d_type = DT_DIR;
		dent.d_reclen = sizeof(struct dirent) - (MAXNAMLEN + 1);

		dent.d_name[TSD_FDE_POS_0] = '.';
		dent.d_name[TSD_FDE_POS_1] = '.';
		dent.d_name[TSD_FDE_POS_2] = '\0';

		dent.d_reclen += (TSD_FDE_VAL_6U &~ TSD_FDE_MSK_3);
		dent.d_namlen = TSD_FDE_DNL_2;

		if ( (rdsize + (W)dent.d_reclen) > (W)nbyte ) {
			if ( rdsize > 0 ) {
				fd->c.fpos = fpos;
				return rdsize;
			} else {
				err = E_PAR;
				goto err_ret;
			}
		}

		/* Writing of buffer record */
		memcpy((UB*)buf + rdsize, &dent, (size_t)dent.d_reclen);
		rdsize += dent.d_reclen;
		fpos++;
	}

	/* Stop if there is no link record */
	if ( stat.f_nrec <= 0 ) {
		fd->c.fpos = fpos;
		return rdsize;
	}

	/* Link record search mode */
	if ( fd->nmbuf == NULL ) {
		/* From the top of directory */
		mode = F_TOPEND;
	} else {
		/* From file pointer location */
		err = tkse_see_rec(fd->sffd, (W)(fpos - TSD_FDE_FPO_2), 1, &recnum);
		if ( err < E_OK ) {
			goto err_ret;
		}
		mode = F_FWD;
	}

	/* Transfer to the top of link record */
	err = tkse_fnd_lnk(fd->sffd, mode, NULL, 0, &recnum );
	if ( err == E_REC ) {
		return 0;
	}
	if ( err < E_OK ) {
		goto err_ret;
	}

	for ( ;; ) {
		/* Reading of link record */
		err = tkse_rea_rec(fd->sffd, 0,
				(void *)&lnk, sizeof(LINK), NULL, NULL);
		if ( err < E_OK ) {
			goto err_ret;
		}

		/* File information */
		err = tkse_fil_sts(&lnk, tcname, &stat, NULL);
		if ( err < E_OK ) {
			if ( err != E_NOFS ) {
				goto err_ret;
			}

			/* Link file information */
			err = tkse_lnk_sts(&lnk, &lstat);
			if ( err < E_OK ) {
				goto err_ret;
			}
			tc_strncpy(tcname, lstat.f_name, L_FNM);
			type = DT_REG;
		} else {
			if (( stat.f_atype != ATYPE_DIR )&&( stat.f_nlink <= 0 )) {
				type = DT_REG;	/* Regular file */
			} else {
				type = DT_DIR;	/* Directory */
			}
		}

		/* Registration and acquisition of appearance order */
		order = btGetApprOrder(fd, tcname);
		if ( order == NULL ) {
			err = E_NOMEM;
			goto err_ret;
		}
		ord = *order - 1;

		if ( recnum >= (W)(fpos - TSD_FDE_FPO_2) ) {
			dent.d_fileno = SFFS_INO(lnk.f_id);
			dent.d_type = type;
			dent.d_reclen = sizeof(struct dirent) - (MAXNAMLEN + 1);

			/* File name conversion */
			len = btConvName_fromTC(tcname,
						(UB*)dent.d_name, sizeof(dent.d_name));
			if ( len < E_OK ) {
				(*order)--;
				err = len;
				goto err_ret;
			}

			/* Character string length in appearance order */
			for ( ordl =0, ordp = 1; (ordp <= ord) && (ordl < TSD_FDE_VAL_10) ; ordl++, ordp *= TSD_FDE_VAL_10 ) {
				;
			}

			/* Addition of appearance order */
			if (( ordl > 0 )&&( len < MAXNAMLEN )) {
				dent.d_name[len++] = ':';
			}
			while ( (ordl-- > 0) && (len < MAXNAMLEN) ) {
				d = div(ord, ordp);
				dent.d_name[len++] = (char)('0' + (UB)d.quot);
				ord = d.rem;
			}

			dent.d_name[len] = '\0';
			dent.d_namlen = (UB)len;
			dent.d_reclen += ((unsigned short)(len + 1 + TSD_FDE_VAL_3) &~ TSD_FDE_MSK_3);

			/* Confirmation of buffer size */
			if ( (rdsize + (W)dent.d_reclen) > (W)nbyte ) {
				if ( rdsize > 0 ) {
					(*order)--;
					break;
				} else {
					(*order)--;
					err = E_PAR;
					goto err_ret;
				}
			}

			/* Record writing */
			memcpy((UB*)buf + rdsize, &dent, (size_t)dent.d_reclen);
			rdsize += dent.d_reclen;
		}

		/* Transfer to next link */
		err = tkse_fnd_lnk(fd->sffd, F_NFWD, NULL, 0, &recnum);
		if ( err == E_REC) {
			break;
		}
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	/* Transfer to terminated record */
	err = tkse_see_rec(fd->sffd, 0, TSD_STD_TSR_M1, (err == E_REC)? &recnum: NULL);
	if ( err < E_OK ) {
		goto err_ret;
	}

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

	return rdsize;

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

/*
 * File pointer transfer
 */
EXPORT WER sf_lseek( FDPkt *fdp, long offset, int whence )
{
	SFFD	*fd = (SFFD*)fdp->fd;
	SFNODE	*inode = (SFNODE*)fd->c.inode;
	W	fpos;
	ER	err;

	switch( whence ) {
	  case SEEK_SET: {
		fpos = offset;
		break;
	  }
	  case SEEK_CUR: {
		fpos = (W)(fd->c.fpos + (UW)offset);
		break;
	  }
	  case SEEK_END: {
		W	bfd = fd->sffd, filsz = 0;
		F_STATE	stat;

		if ( inode->c.type == DT_REG ) {	/* Regular file */
			if ( fd->currec != 0 ) {
				/* Record size of the present record */
				err = tkse_rea_rec(bfd, 0, NULL, 0, &filsz, NULL);
				if ( err < E_OK ) {
					goto err_ret;
				}
			}

			/* File pointer (record size) */
			fpos = filsz + offset;
		} else {				/* Directory */
			/* File information */
			err = tkse_ofl_sts(fd->sffd, NULL, &stat, NULL);
			if ( err < E_OK ) {
				goto err_ret;
			}

			/* File pointer (Terminated record number) */
			fpos = stat.f_nrec + TSD_STD_FPS_2 + offset;
		}
		break;
	  }
	  default: {
		err = E_PAR;
		goto err_ret;
	  }
	}
	if ( fpos < 0 ) {
		err = E_PAR;
		goto err_ret;
	}

	/* Clear of an order of appearance buffer */
	if (( fd->c.fpos != (UW)fpos )&&( fd->nmbuf != NULL )) {
		free(fd->nmbuf);
		fd->nmbuf = NULL;
	}

	return (WER)(fd->c.fpos = (UW)fpos);

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

/*
 * Synchronization of file
 */
EXPORT ER sf_fsync( FDPkt *fdp )
{
	SFFD	*fd = (SFFD*)fdp->fd;
	ER	err;

	err = tkse_syn_fil(fd->sffd);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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

/*
 * File close
 */
EXPORT ER sf_close( FDPkt *fdp )
{
	SFFD	*fd = (SFFD*)fdp->fd;
	ER	err;

	/* Release of count buffer in appearance order */
	if ( fd->nmbuf != NULL ) {
		free(fd->nmbuf);
		fd->nmbuf = NULL;
	}

	/* File close */
	err = tkse_cls_fil(fd->sffd);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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

/*
 * File open
 */
EXPORT WER sf_open( FDPkt *fdp, const char *fname, int oflag, mode_t mode )
{
	SFFD		*fd = (SFFD*)fdp->fd;
	SFNODE		*inode = (SFNODE*)fd->c.inode;
	UH		*path = (UH*)inode->c.exinf;
	LINK		lnk, pl;
	W		len, bfd, omode = 0;
	F_STATE 	stat;
	TC		tcname[L_FNM + 1];
const	B		*p, *np;
	ER		err;

	/* Parameter check */
	fd->c.omode = (UB)((UW)oflag & TSD_SOP_MSK_2);
	if ( fd->c.omode == O_RDONLY ) {
		omode = F_READ;
	} else if ( (fd->c.omode & O_WRONLY) != 0 ) {
		/* It is not F_WRITE for file size acquisition */
		omode = F_UPDATE;
	} else if ( (fd->c.omode & O_RDWR) != 0 ) {
		omode = F_UPDATE;
	}
	fd->c.omode |= (UB)((UW)oflag & O_APPEND);

	if ( inode->c.ino == NOEXS_INO ) {	/* File creation open */
		/* Error of nonexistent connection name */
		if ( inode->nlnk < TSD_SOP_VAL_2 ) {
			err = E_FACV;
			goto err_ret1;
		}

		/* 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];

		/* Check of parent file access attribute */
		err = tkse_chk_fil(&pl, F_WRITE, NULL);
		if ( err < E_OK ) {
			goto err_ret1;
		}

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

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

		/* Check of file name */
		if ( p == fname ) {
			if ( strchr(fname, '/') != NULL ) {
				err = E_FNAME;
				goto err_ret1;
			}
			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_ret1;
			}
		}

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

		/* File creation */
		lnk = pl;	/* Parent file designation */
		bfd = tkse_cre_fil(&lnk, tcname, NULL, ATYPE_REG, F_FIX);
		if ( bfd < E_OK ) {
			err = bfd;
			goto err_ret1;
		}

		/* Close once and modify open mode */
		if ( (UW)omode != F_UPDATE ) {
			err = tkse_cls_fil(bfd);
			if ( err < E_OK ) {
				goto err_ret2;
			}

			bfd = tkse_opn_fil(&lnk, omode, NULL);
			if ( bfd < E_OK ) {
				err = bfd;
				goto err_ret2;
			}
		}

		/* 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_ret3;
			}
		}

		/* File reference node */
		inode->c.type = DT_REG;
		inode->c.ino = SFFS_INO(lnk.f_id);
		inode->link = lnk;
		fd->currec = FALSE;
	} else {				/* Existing file open */
		/* File open */
		lnk = inode->link;
		bfd = tkse_opn_fil(&lnk, omode, NULL);
		if ( bfd < E_OK ) {
			err = bfd;
			goto err_ret1;
		}

		/* File informationm */
		err = tkse_ofl_sts(bfd, NULL, &stat, NULL);
		if ( err < E_OK ) {
			goto err_ret3;
		}

		/* File type */
		if ( inode->c.type == DT_REG ) {
			/* Transfer to operation target record */
			err = tkse_fnd_rec(bfd, F_TOPEND, TSD_SFO_VAL_0X80000000, 0U, NULL);
			if (( err < E_OK )&&( err != E_REC )) {
				goto err_ret3;
			}

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

				/* Record content deletion designation */
				if ( (((UW)oflag & O_TRUNC) != 0) && ((UW)omode != F_READ) ) {
					err = tkse_trc_rec(bfd, 0);
					if ( err < E_OK ) {
						goto err_ret3;
					}
				}
			} else {
				/* Undetermination of operation target record */
				fd->currec = FALSE;
			}
		} else {
			/* Transfer to terminated record */
			err = tkse_see_rec(bfd, 0, TSD_STD_TSR_M1, NULL);
			if ( err < E_OK ) {
				goto err_ret3;
			}
			fd->currec = FALSE;
		}
	}

	fd->sffd = bfd;
	fd->nmbuf = NULL;
	fd->bufsz = 0;
	fd->bufend = NULL;
	fd->c.fpos = 0;

	return fdp->fdno;

err_ret3:
	(void)tkse_cls_fil(bfd);
err_ret2:
	if ( inode->c.ino == NOEXS_INO ) {
		tkse_del_fil(&pl, &lnk, TRUE);
	}
err_ret1:
	DEBUG_PRINT(("sf_open err=%#x\n", err));
	return err;
}

/*
 * File system detachment
 */
EXPORT ER sf_detach( const TC *devnm, int eject )
{
	ER	err;

	/* Disk detachment */
	err = tkse_det_fls((TC*)devnm, eject);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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

/*
 * File system connection
 */
EXPORT ER sf_attach( const TC *devnm, const char *connm, int mode )
{
	TC	cn[L_CONNM + 1];
	UW	md;
	W	len;
	ER	err;

	if ( ((UW)mode & (UW)SF_RONLY) != 0 ) {
		md = FS_RONLY;
	} else {
		md = FS_ASYN;
	}

	/* Convert connection name into "TC" */
	for (len = 0; connm[len] != NULL; len++) {
		;
	}
	err = btConvName_toTC((UB*)connm, len, cn, L_CONNM + 1, FALSE);
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Disk connection */
	err = tkse_att_fls((TC*)devnm, cn, NULL, md);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

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