prototypes.h File Reference

関数のプロトタイプ宣言を集約したヘッダ More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	htonl(x)
#define	htons(x)   ((0xff & ((x) >> 8)) | ((0xff & (x)) << 8))
#define	ntohl(x)
#define	ntohs(x)   ((0xff & ((x) >> 8)) | ((0xff & (x)) << 8))

Functions
void	_mkinit (void)
void	_ptclear (struct ptentry *, uint16, int32(*)(int32))
	ポートを用いたメッセージと待機中プロセスを解放する。 More...
status	addargs (pid32, int32, int32[], int32, char *, void *)
	XINUシェルが作成したコマンドプロセスのスタックに引数argv（任意個）のローカルコピーを追加する。 More...
int32	am335x_eth_init (struct ethcblk *)
int32	arp_alloc (void)
void	arp_hton (struct arppacket *)
void	arp_in (struct arppacket *)
void	arp_init (void)
void	arp_ntoh (struct arppacket *)
status	arp_resolve (uint32, byte[])
status	ascdate (uint32, char *)
status	bufinit (void)
	バッファプールデータ構造を初期化する。 More...
pri16	chprio (pid32, pri16)
	プロセスのスケジューリング優先度を変更する。 More...
uint32	clkcount (void)
interrupt	clkhandler (void)
void	clkinit (void)
void	clkint (void)
syscall	close (did32)
syscall	control (did32, int32, int32, int32)
pid32	create (void *, uint32, pri16, char *, uint32,...)
	関数の実行を開始するプロセスを作成する。 More...
void	ctxsw (void *, void *)
	コンテキストスイッチを行う（ctxsw.S に定義がある） More...
pid32	dequeue (qid16)
	プロセスキューテーブルからキューを削除し、リスト先頭のプロセスIDを返す。 More...
intmask	disable (void)
	割り込み禁止（intr.Sに定義がある） More...
uint32	dnslookup (char *)
uint32	dot2ip (char *, uint32 *)
void	enable (void)
	割り込み許可（intr.Sに定義がある） More...
pid32	enqueue (pid32, qid16)
	プロセスをプロセスキューテーブルの末尾に挿入する。 More...
void	eth_hton (struct netpacket *)
void	eth_ntoh (struct netpacket *)
int32	ethcontrol (struct dentry *, int32, int32, int32)
interrupt	ethhandler (uint32)
int32	ethinit (struct dentry *)
int32	ethread (struct dentry *, void *, uint32)
int32	ethwrite (struct dentry *, void *, uint32)
void	exception (int32, int32 *)
syscall	freebuf (char *)
	バッファプールから取得したバッファを解放する。 More...
syscall	freemem (char *, uint32)
	メモリブロックを解放し、ブロックを空きリストに戻す。 More...
char *	getbuf (bpid32)
	事前に確保されたバッファプールからバッファを取得する。 More...
syscall	getc (did32)
pid32	getfirst (qid16)
	キューの先頭からプロセスを取り出す。 More...
pid32	getitem (pid32)
	キューの任意の位置からプロセスを取り出す。 More...
pid32	getlast (qid16)
	キューの末尾からプロセスを取り出す。 More...
uint32	getlocalip (void)
char *	getmem (uint32)
	ヒープ領域を割り当て、最下位のワードアドレスを返す。 More...
pid32	getpid (void)
	現在実行中のプロセスIDを返す。 More...
uint16	getport (void)
syscall	getprio (pid32)
	プロセスのスケジューリング優先度を取得する。 More...
char *	getstk (uint32)
	スタックメモリを割り当て、最上位のワードアドレスを返す。 More...
uint32	getticks (void)
	CPUリセット以降のclock tick数を取得する。 More...
status	gettime (uint32 *)
	1970年1月1日からの経過時間（秒単位）にロケーション（時差）を反映した時間を返す。 More...
status	getutime (uint32 *)
devcall	gpiocontrol (struct dentry *, int32, int32, int32)
void	gpiohandler (uint32)
devcall	gpioinit (struct dentry *)
devcall	gpioread (struct dentry *, char *, int32)
devcall	gpioselect (uint32, uint32, uint32)
devcall	gpiowrite (struct dentry *, char *, int32)
void	halt (void)
	システムを停止させる（intr.Sに定義がある） More...
uint16	icmp_cksum (char *, int32)
void	icmp_hton (struct netpacket *)
void	icmp_in (struct netpacket *)
void	icmp_init (void)
struct netpacket *	icmp_mkpkt (uint32, uint16, uint16, uint16, char *, int32)
void	icmp_ntoh (struct netpacket *)
int32	icmp_recv (int32, char *, int32, uint32)
int32	icmp_register (uint32)
status	icmp_release (int32)
status	icmp_send (uint32, uint16, uint16, uint16, char *, int32)
int32	inb (int32)
syscall	init (did32)
	デバイスとデバイスドライバを初期化する。 More...
int32	initevec (void)
int32	initintc (void)
int32	inl (int32)
status	insert (pid32, qid16, int32)
	優先度に基づいて、キューにプロセスを挿入する。 More...
status	insertd (pid32, qid16, int32)
int32	insw (int32, int32, int32)
int32	inw (int32)
devcall	ioerr (void)
	ステータスとしてエラーを返す（デバイステーブルの"error"エントリに対して使用する）。 More...
devcall	ionull (void)
	何もしない（デバイステーブルの"don't care"エントリに使用する） More...
status	ip_enqueue (struct netpacket *)
void	ip_hton (struct netpacket *)
void	ip_in (struct netpacket *)
void	ip_local (struct netpacket *)
void	ip_ntoh (struct netpacket *)
status	ip_out (struct netpacket *)
int32	ip_route (uint32)
status	ip_send (struct netpacket *)
uint16	ipcksum (struct netpacket *)
process	ipout (void)
syscall	kill (pid32)
	指定のプロセスを終了させ、システムから終了させたプロセス情報を取り除く。 More...
int32	lexan (char *, int32, char *, int32 *, int32[], int32[])
dbid32	lfdballoc (struct lfdbfree *)
status	lfdbfree (did32, dbid32)
status	lfflush (struct lflcblk *)
int32	lfgetmode (char *)
ibid32	lfiballoc (void)
void	lfibclear (struct lfiblk *, int32)
void	lfibget (did32, ibid32, struct lfiblk *)
status	lfibput (did32, ibid32, struct lfiblk *)
devcall	lflclose (struct dentry *)
devcall	lflcontrol (struct dentry *, int32, int32, int32)
devcall	lflgetc (struct dentry *)
devcall	lflinit (struct dentry *)
devcall	lflputc (struct dentry *, char)
devcall	lflread (struct dentry *, char *, int32)
devcall	lflseek (struct dentry *, uint32)
devcall	lflwrite (struct dentry *, char *, int32)
status	lfscheck (struct lfdir *)
status	lfscreate (did32, ibid32, uint32)
status	lfsetup (struct lflcblk *)
devcall	lfsinit (struct dentry *)
devcall	lfsopen (struct dentry *, char *, char *)
status	lftruncate (struct lflcblk *)
devcall	lpgetc (struct dentry *)
devcall	lpinit (struct dentry *)
devcall	lpopen (struct dentry *, char *, char *)
devcall	lpputc (struct dentry *, char)
devcall	lpread (struct dentry *, char *, int32)
devcall	lpwrite (struct dentry *, char *, int32)
int32 *	memcmp (void *, const void *, int32)
void *	memcpy (void *, const void *, int32)
	メモリAの領域（source）からメモリBの領域（Destination）にN Byteコピーする。 More...
void *	memset (void *, const int, int32)
	指定のByteブロックに対して、同じ値をNバイト分書き込む。 More...
bpid32	mkbufpool (int32, int32)
	バッファプール用のメモリを割り当て、バッファ同士をリンクする。 More...
syscall	mount (char *, char *, did32)
status	namcpy (char *, char *, int32)
status	naminit (void)
int32	namlen (char *, int32)
devcall	nammap (char *, char[], did32)
devcall	namopen (struct dentry *, char *, char *)
did32	namrepl (char *, char[])
void	net_init (void)
process	netin (void)
process	netout (void)
qid16	newqueue (void)
	グローバルキューテーブルにキューを割り当て、テーブルを初期化する。 More...
syscall	open (did32, char *, char *)
int32	outb (int32, int32)
int32	outl (int32, int32)
int32	outsw (int32, int32, int32)
int32	outw (int32, int32)
void	panic (char *)
	Panic状態に陥った旨のメッセージを表示し、全てのプロセスを停止させる。 More...
int32	pci_init (void)
void	pdump (struct netpacket *)
void	pdumph (struct netpacket *)
void	platinit (void)
int32	ptcount (int32)
	ポートを用いたメッセージ送受信において、メッセージ数を数える。 More...
syscall	ptcreate (int32)
	未処理のメッセージを「カウント」できるポートを作成する。 More...
syscall	ptdelete (int32, int32(*)(int32))
	ポートを削除し、待機中のプロセスとメッセージを解放する。 More...
syscall	ptinit (int32)
	全てのポートを初期化する。 More...
uint32	ptrecv (int32)
	ポートからメッセージを受信する。受信前にメッセージが空の場合はブロッキングする。 More...
syscall	ptreset (int32, int32(*)(int32))
	ポートをリセットを行う。 More...
syscall	ptsend (int32, umsg32)
	メッセージをキューに追加する事によってポートへメッセージを送信する。 More...
syscall	putc (did32, char)
	デバイスへ文字１Byteを送信する。 More...
devcall	ramclose (struct dentry *)
devcall	raminit (struct dentry *)
devcall	ramopen (struct dentry *, char *, char *)
devcall	ramread (struct dentry *, char *, int32)
devcall	ramwrite (struct dentry *, char *, int32)
process	rawin (void)
struct rdbuff *	rdsbufalloc (struct rdscblk *)
devcall	rdsclose (struct dentry *)
status	rdscomm (struct rd_msg_hdr *, int32, struct rd_msg_hdr *, int32, struct rdscblk *)
devcall	rdscontrol (struct dentry *, int32, int32, int32)
devcall	rdsinit (struct dentry *)
devcall	rdsopen (struct dentry *, char *, char *)
void	rdsprocess (struct rdscblk *)
devcall	rdsread (struct dentry *, char *, int32)
devcall	rdswrite (struct dentry *, char *, int32)
syscall	read (did32, char *, uint32)
status	ready (pid32)
	プロセスをCPUサービスの対象にする。 More...
umsg32	receive (void)
	メッセージの受信を待ち、受信後にreceive()の呼び出し者にメッセージを返す。 More...
umsg32	recvclr (void)
	受信メッセージをクリアし、待機している場合はメッセージを返す。 More...
umsg32	recvtime (int32)
void	resched (void)
	最優先の適切なプロセスにCPU実行権を渡す。 More...
status	resched_cntl (int32)
	再スケジューリングを延期させるか、もしくは許可させるかを制御する。 More...
void	restore (intmask)
pri16	resume (pid32)
	プロセスを休止状態（サスペンド）からREADY状態に遷移させる。 More...
devcall	rflclose (struct dentry *)
devcall	rflgetc (struct dentry *)
devcall	rflinit (struct dentry *)
devcall	rflputc (struct dentry *, char)
devcall	rflread (struct dentry *, char *, int32)
devcall	rflseek (struct dentry *, uint32)
devcall	rflwrite (struct dentry *, char *, int32)
int32	rfscomm (struct rf_msg_hdr *, int32, struct rf_msg_hdr *, int32)
devcall	rfscontrol (struct dentry *, int32, int32, int32)
int32	rfsgetmode (char *)
devcall	rfsinit (struct dentry *)
status	rfsndmsg (uint16, char *)
devcall	rfsopen (struct dentry *devptr, char *, char *)
syscall	seek (did32, uint32)
syscall	semcount (sid32)
	セマフォのカウント値を返す。 More...
sid32	semcreate (int32)
	未使用セマフォを割り当て、そのセマフォへのインデックス（セマフォID）を返す。 More...
syscall	semdelete (sid32)
	セマフォテーブルエントリを解放し、セマフォを削除する。 More...
syscall	semreset (sid32, int32)
	セマフォカウントをリセットし、待機中のプロセスを全て解放する。 More...
syscall	send (pid32, umsg32)
	プロセスにメッセージを送信し、受信側が待機状態の場合はREADY状態にする。 More...
int32	set_evec (uint32, uint32)
process	shell (did32)
syscall	signal (sid32)
	セマフォにシグナルを送り、待機プロセスがある場合は解除する。 More...
syscall	signaln (sid32, int32)
	セマフォにシグナルをN回送り、N個の待機プロセスがある場合はそれらをREADY状態にする。 More...
syscall	sleep (int32)
syscall	sleepms (int32)
devcall	spicontrol (struct dentry *, int32, int32, int32)
int32	spiinit (struct dentry *)
syscall	suspend (pid32)
	プロセスを一時停止し、休止状態（サスペンド）に遷移させる。 More...
void	trap (int32)
devcall	ttycontrol (struct dentry *, int32, int32, int32)
devcall	ttygetc (struct dentry *)
void	ttyhandle_in (struct ttycblk *, struct uart_csreg *)
void	ttyhandle_out (struct ttycblk *, struct uart_csreg *)
void	ttyhandler (uint32)
devcall	ttyinit (struct dentry *)
void	ttykickout (struct uart_csreg *)
devcall	ttyputc (struct dentry *, char)
devcall	ttyread (struct dentry *, char *, int32)
devcall	ttywrite (struct dentry *, char *, int32)
void	udp_hton (struct netpacket *)
void	udp_in (struct netpacket *)
void	udp_init (void)
void	udp_ntoh (struct netpacket *)
int32	udp_recv (uid32, char *, int32, uint32)
int32	udp_recvaddr (uid32, uint32 *, uint16 *, char *, int32, uint32)
uid32	udp_register (uint32, uint16, uint16)
status	udp_release (uid32)
status	udp_send (uid32, char *, int32)
status	udp_sendto (uid32, uint32, uint16, char *, int32)
syscall	unsleep (pid32)
void	userret (void)
	プロセスが最上位の関数に戻る時に呼ばれる。現在のプロセスを終了させる。 More...
syscall	wait (sid32)
void	wakeup (void)
syscall	write (did32, char *, uint32)
void	xdone (void)
	最終プロセスの終了時、システム終了メッセージを表示する。 More...
syscall	yield (void)
	CPU実行権を自発的に放棄する（タイムスライスを終了する）。 More...

Detailed Description

関数のプロトタイプ宣言を集約したヘッダ

Definition in file prototypes.h.

Macro Definition Documentation

htonl

#define htonl

(

x

)

Value:

((((x) >> 24) & 0x000000ff) | (((x) >> 8) & 0x0000ff00) | \
                  (((x) << 8) & 0x00ff0000) | (((x) << 24) & 0xff000000))

Definition at line 620 of file prototypes.h.

Referenced by arp_hton(), dhcp_bld_bootp_msg(), ip_hton(), rdscomm(), rflread(), rflwrite(), rfscomm(), and rfsopen().

htons

#define htons

(

x

)

((0xff & ((x) >> 8)) | ((0xff & (x)) << 8))

Definition at line 619 of file prototypes.h.

Referenced by arp_hton(), dns_bldq(), dnslookup(), eth_hton(), icmp_hton(), ip_hton(), ip_out(), ipcksum(), rdscontrol(), rdsopen(), rdsprocess(), rflread(), rflwrite(), rfscontrol(), rfsndmsg(), rfsopen(), tftpget_mb(), and udp_hton().

ntohl

#define ntohl

(

x

)

Value:

((((x) >> 24) & 0x000000ff) | (((x) >> 8) & 0x0000ff00) | \
                  (((x) << 8) & 0x00ff0000) | (((x) << 24) & 0xff000000))

Definition at line 623 of file prototypes.h.

Referenced by arp_ntoh(), dns_geta(), dnslookup(), getlocalip(), getutime(), ip_ntoh(), pdump(), rdscomm(), rflread(), rflwrite(), rfscomm(), rfscontrol(), and rfsndmsg().

ntohs

#define ntohs

(

x

)

((0xff & ((x) >> 8)) | ((0xff & (x)) << 8))

Definition at line 622 of file prototypes.h.

Referenced by arp_ntoh(), dns_geta(), dns_getrname(), eth_ntoh(), icmp_cksum(), icmp_ntoh(), ip_ntoh(), pdump(), pdumph(), rdscomm(), rdscontrol(), rdsopen(), rdsprocess(), rflread(), rflwrite(), rfscomm(), rfsopen(), tftp_send1(), and udp_ntoh().

Function Documentation

_mkinit()

void _mkinit

(

void

)

_ptclear()

void _ptclear	(	struct ptentry *	ptptr,
		uint16	newstate,
		int32(*)(int32)	dispose
	)

ポートを用いたメッセージと待機中プロセスを解放する。

Step1. ポートの状態をLIMBOとし、他のプロセスからポート使用不可とする。
Step2. ポートシーケンス番号をリセットする。
Step3. メッセージリストが空になるまで、各メッセージを処分する。
Step4. メッセージリスト全体をフリーリストとする。
Step5. 引数で指定されたポートクリア後の状態に応じて、処理を切り替える。
　・PT_ALLOCの場合：ポートテーブルエントリの先頭と末尾をNULLを指す状態とし、送受信用セマフォをリセットする。
　・上記以外の場合：送受信用セマフォを削除する。
Step6. ポート状態を引数で指定された状態に変更する。

Parameters

[in]	ptptr	クリア対象のポートテーブルエントリ
[in]	newstate	ポートをクリアした後の新しい状態
[in]	dispose	メッセージ処分用の関数ポインタ

Note

ポート内部の関数をクリアまたはリセットするために、ptdeleteおよびreset経由で_ptclear()は使用される。
_ptclear()の呼び出しは、割り込みが無効であり、引数の有効性がチェックされている事を前提としている。

Definition at line 24 of file ptclear.c.

References NULL, PT_ALLOC, PT_LIMBO, ptfree, ptentry::pthead, ptentry::ptmaxcnt, ptnode::ptmsg, ptnode::ptnext, ptentry::ptrsem, ptentry::ptseq, ptentry::ptssem, ptentry::ptstate, ptentry::pttail, semdelete(), and semreset().

Referenced by ptdelete(), and ptreset().

{
    struct ptnode *walk; /* Pointer to walk message list    */

    /* Place port in limbo state while waiting processes are freed */

    ptptr->ptstate = PT_LIMBO;

    ptptr->ptseq++;       /* Reset accession number */
    walk = ptptr->pthead; /* First item on msg list */

    if (walk != NULL)
    { /* If message list nonempty   */

        /* Walk message list and dispose of each message */

        for (; walk != NULL; walk = walk->ptnext)
        {
            (*dispose)(walk->ptmsg);
        }

        /* Link entire message list into the free list */

        (ptptr->pttail)->ptnext = ptfree;
        ptfree = ptptr->pthead;
    }

    if (newstate == PT_ALLOC)
    {
        ptptr->pttail = ptptr->pthead = NULL;
        semreset(ptptr->ptssem, ptptr->ptmaxcnt);
        semreset(ptptr->ptrsem, 0);
    }
    else
    {
        semdelete(ptptr->ptssem);
        semdelete(ptptr->ptrsem);
    }
    ptptr->ptstate = newstate;
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

addargs()

status addargs	(	pid32	pid,
		int32	ntok,
		int32	tok[],
		int32	tlen,
		char *	tokbuf,
		void *	dummy
	)

XINUシェルが作成したコマンドプロセスのスタックに引数argv（任意個）のローカルコピーを追加する。

Step1. 割り込みを禁止する。
Step2. 「引数の数が0以下」もしくは「トークンバッファの中にあるデータの長さが0以下」であれば、
割り込み状態を復元し、処理を修正する。
Step3. args配列と引数文字列（トークンバッファ）を続けて格納するために、プロセススタックの最下位の場所を計算する。
4Byte単位での丸め計算も行うため、args配列はユーザスタック最下位かその次の4byteの倍数アドレスから始まる。
最下位アドレス：[トークン1へのポインタ][トークン2へのポインタ][NULL][トークン1][NULL][トークン2]...：最上位アドレス
Step4. 文字列は可変長のため、args配列を超えた最初の位置を計算する。
Step5. args配列に格納されたポインタ（各引数へのポインタ）に対して、文字列領域開始アドレスをオフセットとして加え、
スタック最下位から順に格納する。 Step6. args配列に格納されたポインタの後に、区切りとしてNULLを付与する。
Step7. 引数文字列をargs配列（+ NULL）を超えた位置にコピーする。
Step8. プロセススタック中の第2引数（XINUシェルがプロセスをcreate()した際にスタックに追加した引数であり、
引数dummyと同じアドレスを持つ）を探し、第2引数の内容をプロセススタック中のargs配列アドレスに置換する。
Step9. 割り込みを許可状態に復元する。

Parameters

[in]	pid	使用するプロセスID
[in]	ntok	引数の数
[in]	tok	トークンバッファの中にあるトークンのインデックス
[in]	tlen	トークンバッファの中にあるデータの長さ
[in]	tokbuf	NULLで終わるトークン配列
[in,out]	dummy	生成時に使用されるダミー引数。引数の配列へのポインタで置き換える必要がある。

Returns

Definition at line 33 of file addargs.c.

References disable(), memcpy(), NULL, OK, proctab, procent::prstkbase, procent::prstklen, procent::prstkptr, restore(), and SYSERR.

Referenced by shell().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process' table entry   */
    uint32 aloc;           /* Argument location in process stack as an integer  */
    uint32 *argloc;        /* Location in process's stack to place args vector  */
    char *argstr;          /* Location in process's stack to place arg strings  */
    uint32 *search;        /* pointer that searches for dummy argument on stack */
    uint32 *aptr;          /* Walks through args array  */
    int32 i;               /* Index into tok array      */

    mask = disable();

    /* Check argument count and data length */

    if ((ntok <= 0) || (tlen < 0))
    {
        restore(mask);
        return SYSERR;
    }

    prptr = &proctab[pid];

    /* Compute lowest location in the process stack where the   */
    /*  args array will be stored followed by the argument  */
    /*  strings                         */

    aloc = (uint32)(prptr->prstkbase - prptr->prstklen + sizeof(uint32));
    argloc = (uint32 *)((aloc + 3) & ~0x3); /* round multiple of 4  */

    /* Compute the first location beyond args array for the strings */

    argstr = (char *)(argloc + (ntok + 1)); /* +1 for a null ptr    */

    /* Set each location in the args vector to be the address of    */
    /*  string area plus the offset of this argument        */

    for (aptr = argloc, i = 0; i < ntok; i++)
    {
        *aptr++ = (uint32)(argstr + tok[i]);
    }

    /* Add a null pointer to the args array */

    *aptr++ = (uint32)NULL;

    /* Copy the argument strings from tokbuf into process's stack   */
    /*  just beyond the args vector             */

    memcpy(aptr, tokbuf, tlen);

    /* Find the second argument in process's stack */

    for (search = (uint32 *)prptr->prstkptr;
         search < (uint32 *)prptr->prstkbase; search++)
    {

        /* If found, replace with the address of the args vector*/

        if (*search == (uint32)dummy)
        {
            *search = (uint32)argloc;
            restore(mask);
            return OK;
        }
    }

    /* Argument value not found on the stack - report an error */

    restore(mask);
    return SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

am335x_eth_init()

int32 am335x_eth_init

(

struct ethcblk *

)

arp_alloc()

int32 arp_alloc

(

void

)

Definition at line 298 of file arp.c.

References AR_FREE, AR_RESOLVED, ARP_SIZ, arpcache, arpentry::arstate, kprintf(), memset(), NULLCH, and SYSERR.

Referenced by arp_in(), and arp_resolve().

{
    int32   slot;           /* Slot in ARP cache        */

    /* Search for a free slot */

    for (slot=0; slot < ARP_SIZ; slot++) {
        if (arpcache[slot].arstate == AR_FREE) {
            memset((char *)&arpcache[slot],
                    NULLCH, sizeof(struct arpentry));
            return slot;
        }
    }

    /* Search for a resolved entry */

    for (slot=0; slot < ARP_SIZ; slot++) {
        if (arpcache[slot].arstate == AR_RESOLVED) {
            memset((char *)&arpcache[slot],
                    NULLCH, sizeof(struct arpentry));
            return slot;
        }
    }

    /* At this point, all slots are pending (should not happen) */

    kprintf("ARP cache size exceeded\n");

    return SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

arp_hton()

void arp_hton

(

struct arppacket *

)

Definition at line 348 of file arp.c.

References arppacket::arp_htype, arppacket::arp_op, arppacket::arp_ptype, arppacket::arp_sndpa, arppacket::arp_tarpa, htonl, and htons.

Referenced by arp_in(), and arp_resolve().

{
    pktptr->arp_htype = htons(pktptr->arp_htype);
    pktptr->arp_ptype = htons(pktptr->arp_ptype);
    pktptr->arp_op    = htons(pktptr->arp_op);
    pktptr->arp_sndpa = htonl(pktptr->arp_sndpa);
    pktptr->arp_tarpa = htonl(pktptr->arp_tarpa);
}

Here is the caller graph for this function:

arp_in()

void arp_in

(

struct arppacket *

)

Definition at line 158 of file arp.c.

References AR_FREE, AR_PENDING, AR_RESOLVED, arpentry::arhaddr, arp_alloc(), arppacket::arp_ethdst, arppacket::arp_ethsrc, arppacket::arp_ethtype, ARP_HALEN, arppacket::arp_hlen, arp_hton(), ARP_HTYPE, arppacket::arp_htype, arp_ntoh(), arppacket::arp_op, ARP_OP_RPLY, ARP_PALEN, arppacket::arp_plen, ARP_PTYPE, arppacket::arp_ptype, ARP_SIZ, arppacket::arp_sndha, arppacket::arp_sndpa, arppacket::arp_tarha, arppacket::arp_tarpa, arpentry::arpaddr, arpcache, arpentry::arpid, arpentry::arstate, disable(), ETH_ARP, eth_hton(), ETHER0, network::ethucast, FALSE, freebuf(), network::ipucast, network::ipvalid, kprintf(), memcpy(), NetData, OK, restore(), send(), SYSERR, TRUE, and write().

Referenced by netin().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  arppacket apkt;     /* Local packet buffer      */
    int32   slot;           /* Slot in cache        */
    struct  arpentry  *arptr;   /* Ptr to ARP cache entry   */
    bool8   found;          /* Is the sender's address in   */
                    /*   the cache?         */

    /* Convert packet from network order to host order */

    arp_ntoh(pktptr);

    /* Verify ARP is for IPv4 and Ethernet */

    if ( (pktptr->arp_htype != ARP_HTYPE) ||
         (pktptr->arp_ptype != ARP_PTYPE) ) {
        freebuf((char *)pktptr);
        return;
    }

    /* Ensure only one process uses ARP at a time */

    mask = disable();

    /* Search cache for sender's IP address */

    found = FALSE;

    for (slot=0; slot < ARP_SIZ; slot++) {
        arptr = &arpcache[slot];

        /* Skip table entries that are unused */

        if (arptr->arstate == AR_FREE) {
            continue;
        }

        /* If sender's address matches, we've found it */

        if (arptr->arpaddr == pktptr->arp_sndpa) {
            found = TRUE;
            break;
        }
    }

    if (found) {

        /* Update sender's hardware address */

        memcpy(arptr->arhaddr, pktptr->arp_sndha, ARP_HALEN);

        /* If a process was waiting, inform the process */

        if (arptr->arstate == AR_PENDING) {
            /* Mark resolved and notify waiting process */
            arptr->arstate = AR_RESOLVED;
            send(arptr->arpid, OK);
        }
    }

    /* For an ARP reply, processing is complete */

    if (pktptr->arp_op == ARP_OP_RPLY) {
        freebuf((char *)pktptr);
        restore(mask);
        return;
    }

    /* The following is for an ARP request packet: if the local */
    /*  machine is not the target or the local IP address is not    */
    /*  yet known, ignore the request (i.e., processing is complete)*/

    if ((!NetData.ipvalid) ||
            (pktptr->arp_tarpa != NetData.ipucast)) {
        freebuf((char *)pktptr);
        restore(mask);
        return;
    }

    /* Request has been sent to the local machine's address.  So,   */
    /*   add sender's info to cache, if not already present     */

    if (!found) {
        slot = arp_alloc();
        if (slot == SYSERR) {   /* Cache is full */
            kprintf("ARP cache overflow on interface\n");
            freebuf((char *)pktptr);
            restore(mask);
            return;
        }
        arptr = &arpcache[slot];
        arptr->arpaddr = pktptr->arp_sndpa;
        memcpy(arptr->arhaddr, pktptr->arp_sndha, ARP_HALEN);
        arptr->arstate = AR_RESOLVED;
    }

    /* Hand-craft an ARP reply packet and send back to requester    */

    memcpy(apkt.arp_ethdst, pktptr->arp_sndha, ARP_HALEN);
    memcpy(apkt.arp_ethsrc, NetData.ethucast, ARP_HALEN);
    apkt.arp_ethtype= ETH_ARP;      /* Frame carries ARP    */
    apkt.arp_htype  = ARP_HTYPE;        /* Hardware is Ethernet */
    apkt.arp_ptype  = ARP_PTYPE;        /* Protocol is IP   */
    apkt.arp_hlen   = ARP_HALEN;        /* Ethernet address size*/
    apkt.arp_plen   = ARP_PALEN;        /* IP address size  */
    apkt.arp_op = ARP_OP_RPLY;      /* Type is Reply    */

    /* Insert local Ethernet and IP address in sender fields    */

    memcpy(apkt.arp_sndha, NetData.ethucast, ARP_HALEN);
    apkt.arp_sndpa = NetData.ipucast;

    /* Copy target Ethernet and IP addresses from request packet */

    memcpy(apkt.arp_tarha, pktptr->arp_sndha, ARP_HALEN);
    apkt.arp_tarpa = pktptr->arp_sndpa;

    /* Convert ARP packet from host to network byte order */

    arp_hton(&apkt);

    /* Convert the Ethernet header to network byte order */

    eth_hton((struct netpacket *)&apkt);

    /* Send the reply */

    write(ETHER0, (char *)&apkt, sizeof(struct arppacket));
    freebuf((char *)pktptr);
    restore(mask);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

arp_init()

void arp_init

(

void

)

Definition at line 11 of file arp.c.

References AR_FREE, ARP_SIZ, arpcache, and arpentry::arstate.

Referenced by net_init().

{
    int32   i;          /* ARP cache index      */

    for (i=1; i<ARP_SIZ; i++) { /* Initialize cache to empty    */
        arpcache[i].arstate = AR_FREE;
    }
}

Here is the caller graph for this function:

arp_ntoh()

void arp_ntoh

(

struct arppacket *

)

Definition at line 333 of file arp.c.

References arppacket::arp_htype, arppacket::arp_op, arppacket::arp_ptype, arppacket::arp_sndpa, arppacket::arp_tarpa, ntohl, and ntohs.

Referenced by arp_in().

{
    pktptr->arp_htype = ntohs(pktptr->arp_htype);
    pktptr->arp_ptype = ntohs(pktptr->arp_ptype);
    pktptr->arp_op    = ntohs(pktptr->arp_op);
    pktptr->arp_sndpa = ntohl(pktptr->arp_sndpa);
    pktptr->arp_tarpa = ntohl(pktptr->arp_tarpa);
}

Here is the caller graph for this function:

arp_resolve()

status arp_resolve	(	uint32	,
		byte	[]
	)

Referenced by ip_send(), and ipout().

Here is the caller graph for this function:

ascdate()

status ascdate	(	uint32	,
		char *
	)

Definition at line 16 of file ascdate.c.

References DATE_DST_AUTO, DATE_DST_ON, dateinfo::dt_daylight, dateinfo::dt_dnam, dateinfo::dt_mnam, dateinfo::dt_msize, FALSE, isleap, OK, SECPERDY, SECPERHR, SECPERMN, sprintf(), TIMEZONE, and TRUE.

Referenced by xsh_date().

{
    uint32  tmp;            /* Counts remaining seconds */
                    /*   during computations    */
    int32   year, month, day,   /* Values for various parts of  */
        hour, minute, second;   /*   the date           */
    uint32  days;           /* Number of days in a year */
    uint32  leapyrs;        /* Number of leap years between */
                    /*   1970 and now       */
    uint32  shift;          /* Number of times the calendar */
                    /*   shifted by a day       */
    uint32  dayofweek;      /* Day of the week (0 - 6)  */
                    /* For DST, day of the week for:*/
    int32   jan1;           /*   January 1 this year    */
    int32   mar1;           /*   March 1 this year      */
    int32   nov1;           /*   November 1 this year   */
    int32   marss;          /* Day of second sunday in march*/
    int32   novfs;          /* Day of second sunday in march*/
    bool8   dst;            /* Should we adjust for DST?    */
    int32   i;          /* Indexes through months   */

    char    *zones[]  = {"EST", "CST", "MST", "PST"};
    char    *dzones[] = {"EDT", "CDT", "MDT", "PDT"};

    /* Compute the year (1970-2099) */

    for (year=1970 ; TRUE ; year++) {
        days = isleap(year) ? 366 : 365;
        tmp = days * SECPERDY;
        if (tmp > now)
            break;
        now -= tmp;
    }

    /* Compute the number of whole days that have already passed    */
    /*   during the current year (0 through 365)            */

    days = now / SECPERDY;

    /* Compute the month (0-11) */

    for (month=0 ; month<12 ; month++) {
        tmp = Date.dt_msize[month] * SECPERDY;
        if ((month == 1) && isleap(year)) {
            tmp += SECPERDY;
        }
        if (tmp > now)
            break;
        now -= tmp;
    }

    /* Compute the day of month (1-31) */

    day = (int32)( now/SECPERDY ) + 1;
    now %= SECPERDY;

    /* Compute the hour (0-23) */

    hour = (int32) ( now/SECPERHR );
    now %= SECPERHR;

    /* Compute the minutes (0-59) */

    minute = now / SECPERMN;
    now %= SECPERMN;

    /* Compute the seconds (0-59) */
    second = (int32) now;

    /* Compute the day of the week (0-6)                */
    /*                              */
    /*   Note: Jan 1, 1970 was a Thursday (4 on a 0 to 6 range) */
    /* Add one day of the week each full year (365%7 == 1) plus */
    /*    one extra day for each leap year              */

    /* Compute number of leap years prior to current year */

    leapyrs = (year-1969)/4;

    /* Compute shift for all previous years (i.e., day of week of   */
    /* Jan 1 of the current year)                   */

    shift = 4 + (year - 1970) + leapyrs;

    /* Remember day of the week for Jan 1 this year (for DST)   */

    jan1 = shift % 7;

    /* Add the number of days so far this year */

    shift += days;

    /* Convert to integer from 0 through 6 */

    dayofweek = shift % 7;

    /*                              */
    /*      Handle daylight savings time            */
    /*                              */
    /*   Date.dt_daylight specifies whether to set it on, off,  */
    /*      or automatically compute the setting        */
    /*                              */

    dst = FALSE;
    if (Date.dt_daylight == DATE_DST_ON) {
        dst = TRUE;
    } else if (Date.dt_daylight == DATE_DST_AUTO) {
        
        /* Automatic DST calculation: DST is on between 2:00 AM */
        /*   the second Sunday of March and 2:00 AM the first   */
        /*   sunday in November                 */

        /* Calculate day of the week for March 1        */

        mar1 = (jan1 + Date.dt_msize[0] + Date.dt_msize[1] +
                            isleap(year)) % 7;

        /* Caculate day (1-31) of the second sunday in March    */

        if (mar1 == 0) {    /* Mar. 1 is a Sunday       */
            marss = 8;
        } else {        /* Mar. 1 is Monday - Saturday  */
            marss = 15 - mar1;
        }

        /* Calculate day of the week for November 1     */

        nov1 = jan1;
        for (i=0; i<10; i++) {
            nov1 += Date.dt_msize[i];
        }
        if (isleap(year)) {
            nov1++;
        }
        nov1 = nov1 % 7;
        if (nov1 == 0) {    /* Nov. 1 is a Sunday       */
            novfs = 1;
        } else {        /* Nov. 1 is Monday - Saturday  */
            novfs = 8 - nov1;
        }

        /* Set dst based on time of the year */

        /* DST is off during December, January, and Feburary */

        if ( (month == 11) || (month == 0) || (month == 1) ) {
            dst = FALSE;

        /* DST is on from April through October */

        } else if ( (month>2) && (month<10) ) {
            dst = TRUE;

        /* DST is on in March past 2 AM on the second Sunday    */

        } else if (month == 2) {

            dst = FALSE;
            if (day > marss) {
                dst = TRUE;
            } else if ( (day == marss) && (hour >= 2) ) {
                dst = TRUE;
            }

        /* DST is on in November until 2 am on first Sunday */


        } else if (month == 10) {

            dst = TRUE;
            if (day > novfs) {
                dst = FALSE;
            } else if ( (day == novfs) && (hour >= 1) ) {
                dst = FALSE;
            }
        }
    }

    /* If we are doing DST, move ahead one hour and handle the  */
    /*   case where we move to the next day or the next month   */

    if (dst) {
        hour++;

        /* If day exceeded, move to next day */

        if (hour > 23) {
            hour = 0;
            day++;

            /* If month exceeded, move to next month */

            if (day > Date.dt_msize[month]) {
                day = 1;
                month++;

                /* Stop here because DST does not occur */
                /*  during the year boundary        */
            }
        }
    }

    sprintf(str, "%3s  %3s %2d  %2d:%02d:%02d %s %d",
        Date.dt_dnam[dayofweek], Date.dt_mnam[month],
        day, hour, minute, second, dst? dzones[TIMEZONE-5]:
            zones[TIMEZONE-5], year);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bufinit()

status bufinit

(

void

)

バッファプールデータ構造を初期化する。

現在のバッファプール数を0にする。

Returns

OKを返す。

Definition at line 17 of file bufinit.c.

References nbpools, and OK.

Referenced by sysinit().

{
    nbpools = 0;
    return OK;
}

Here is the caller graph for this function:

chprio()

pri16 chprio	(	pid32	pid,
		pri16	newprio
	)

プロセスのスケジューリング優先度を変更する。

Step1. 割り込みを禁止する。
Step2. 不正なPIDの場合は割り込み許可状態に戻し、処理を終了する。
Step3. 引数で指定されたPIDからプロセス情報を取得し、新しい優先度に変更する。
Step4. 割り込み許可状態に戻し、処理を終了する。

Parameters

[in]	pid	優先度を変更したいプロセスのID
[in]	newprio	新しい優先度

Returns

優先度が変更できた場合は古い優先度、PIDが不正な場合はSYSERRを返す。

Definition at line 18 of file chprio.c.

References disable(), isbadpid, proctab, procent::prprio, restore(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    pri16 oldprio;         /* Priority to return        */

    mask = disable();
    if (isbadpid(pid))
    {
        restore(mask);
        return (pri16)SYSERR;
    }
    prptr = &proctab[pid];
    oldprio = prptr->prprio;
    prptr->prprio = newprio;
    restore(mask);
    return oldprio;
}

Here is the call graph for this function:

clkcount()

uint32 clkcount

(

void

)

clkhandler()

interrupt clkhandler

(

void

)

Definition at line 9 of file clkhandler.c.

References AM335X_TIMER1MS_TISR_OVF_IT_FLAG, clktime, count1000, firstid, isempty, preempt, QUANTUM, queuetab, resched(), sleepq, am335x_timer1ms::tisr, and wakeup().

Referenced by clkinit().

{

    
    volatile struct am335x_timer1ms *csrptr =
            (struct am335x_timer1ms *)0x44E31000;
            /* Set csrptr to address of timer CSR       */

    /* If there is no interrupt, return */

    if((csrptr->tisr & AM335X_TIMER1MS_TISR_OVF_IT_FLAG) == 0) {
        return;
    }

    /* Acknowledge the interrupt */

    csrptr->tisr = AM335X_TIMER1MS_TISR_OVF_IT_FLAG;

    /* Increment 1000ms counter */

    count1000++;

    /* After 1 sec, increment clktime */

    if(count1000 >= 1000) {
        clktime++;
        count1000 = 0;
    }

    /* check if sleep queue is empty */

    if(!isempty(sleepq)) {

        /* sleepq nonempty, decrement the key of */
        /* topmost process on sleepq         */

        if((--queuetab[firstid(sleepq)].qkey) == 0) {

            wakeup();
        }
    }

    /* Decrement the preemption counter */
    /* Reschedule if necessary      */

    if((--preempt) == 0) {
        preempt = QUANTUM;
        resched();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

clkinit()

void clkinit

(

void

)

Definition at line 15 of file clkinit.c.

References AM335X_TIMER1MS_ADDR, AM335X_TIMER1MS_CLKCTRL_ADDR, AM335X_TIMER1MS_CLKCTRL_EN, AM335X_TIMER1MS_IRQ, AM335X_TIMER1MS_TCLR_AR, AM335X_TIMER1MS_TCLR_ST, AM335X_TIMER1MS_TIER_OVF_IT_ENA, AM335X_TIMER1MS_TIOCP_CFG_SOFTRESET, AM335X_TIMER1MS_TISTAT_RESETDONE, clkhandler(), clktime, count1000, newqueue(), preempt, QUANTUM, set_evec(), sleepq, am335x_timer1ms::tclr, am335x_timer1ms::tier, am335x_timer1ms::tiocp_cfg, am335x_timer1ms::tistat, am335x_timer1ms::tldr, am335x_timer1ms::tnir, am335x_timer1ms::tpir, and am335x_timer1ms::ttgr.

Referenced by sysinit().

{
    volatile struct am335x_timer1ms *csrptr =
        (volatile struct am335x_timer1ms *)AM335X_TIMER1MS_ADDR;
    /* Pointer to timer CSR in BBoneBlack   */
    volatile uint32 *clkctrl =
        (volatile uint32 *)AM335X_TIMER1MS_CLKCTRL_ADDR;

    *clkctrl = AM335X_TIMER1MS_CLKCTRL_EN;
    while ((*clkctrl) != 0x2) /* Do nothing */
        ;

    /* Reset the timer module */

    csrptr->tiocp_cfg |= AM335X_TIMER1MS_TIOCP_CFG_SOFTRESET;

    /* Wait until the reset is complete */

    while ((csrptr->tistat & AM335X_TIMER1MS_TISTAT_RESETDONE) == 0)
        /* Do nothing */;

    /* Set interrupt vector for clock to invoke clkint */

    set_evec(AM335X_TIMER1MS_IRQ, (uint32)clkhandler);

    sleepq = newqueue(); /* Allocate a queue to hold the delta  */
                         /*   list of sleeping processes        */

    preempt = QUANTUM; /* Set the preemption time       */

    clktime = 0; /* Start counting seconds      */
    count1000 = 0;
    /* The following values are calculated for a    */
    /*   timer that generates 1ms tick rate     */

    csrptr->tpir = 1000000;
    csrptr->tnir = 0;
    csrptr->tldr = 0xFFFFFFFF - 26000;

    /* Set the timer to auto reload */

    csrptr->tclr = AM335X_TIMER1MS_TCLR_AR;

    /* Start the timer */

    csrptr->tclr |= AM335X_TIMER1MS_TCLR_ST;

    /* Enable overflow interrupt which will generate */
    /*   an interrupt every 1 ms             */

    csrptr->tier = AM335X_TIMER1MS_TIER_OVF_IT_ENA;

    /* Kickstart the timer */

    csrptr->ttgr = 1;

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

clkint()

void clkint

(

void

)

close()

syscall close

(

did32

)

Definition at line 9 of file close.c.

References devtab, disable(), dentry::dvclose, isbaddev, restore(), and SYSERR.

Referenced by kill(), lfscreate(), xsh_cat(), and xsh_rdstest().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct  dentry  *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvclose) (devptr);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

control()

syscall control	(	did32	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file control.c.

References devtab, disable(), dentry::dvcntl, isbaddev, restore(), and SYSERR.

Referenced by net_init(), and shell().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvcntl) (devptr, func, arg1, arg2);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create()

pid32 create	(	void *	procaddr,
		uint32	ssize,
		pri16	priority,
		char *	name,
		uint32	nargs,
			...
	)

関数の実行を開始するプロセスを作成する。

Step1. 割り込みを禁止する。
Step2. スタックサイズがMINSTKを下回っていた場合、サイズをMINSTKまで引き上げ、丸めを行う。
Step3. 以下のいずれかを満たした場合は、割り込み許可状態に復元し、SYSERRを返す。
　・スタックが確保できなかった場合
　・全てのプロセスがFREE状態ではなかった場合（使用中だった場合）
　・引数のプロセス優先度が1より小さかった場合
Step4. アクティブプロセス数を１増やす。 Step5. プロセステーブルエントリを以下の状態で初期化する。
　・プロセス状態 = サスペンド
　・プロセス優先度 = 引数で指定した優先度
　・スタックアドレス = getstk()で取得したスタックアドレス（ プロセススタックの最上位にオーバフロー検知マーカを付与）
　・スタックサイズ = 引数で指定されたスタックサイズ（MINSTK以上のサイズ）
　・プロセス名 = 引数で指定した名前（15文字 + NULL終端）
　・セマフォとメッセージ = 未使用状態
　・デバイスディスクリプタ = XINU Shell用に0:STDIN(標準入力)、1:STDOUT(標準出力)、2:STDERR(標準エラー)を設定
Step6. 可変長引数と関数ポインタをスタックに積む。前提として、ARMはr0〜r3レジスタが引数渡しに使用される。
可変長引数の5個目〜N個目をスタックに積んだ後、関数ポインタをスタックに積む。
引数をレジスタ渡しするためにスタックにr4〜r11用の情報（=0）を積み、r3〜r0用の情報（引数次第で変化）を積む。
Step7. 関数のリターンアドレス（INITRET = userret()であり、kill()を呼び出す）をスタックに積む。
Step8. CPSR F bitを有効化し、スーパバイザモードに移行するためのビットマスクをスタックに積む。
このビットマスクは、コンテキストスイッチ中のリストア時に使用される。
Step9. 新しいスタックアドレスをプロセステーブルにセットする。
Step10. 割り込み許可状態に復元する。

Parameters

[in]	procaddr	関数ポインタ（プロセスのエントリポイント）
[in]	ssize	スタックサイズ（Byte）
[in]	priority	プロセスの優先度（> 0）
[in]	name	プロセス名（デバッグ用）
[in]	nargs	本引数より後にある引数の総数
[in]	...	可変長引数

Returns

成功時は作成したプロセスのID、以下の場合はSYSERRを返す。
　・スタックが確保できなかった場合
　・全てのプロセスがFREE状態ではなかった場合（使用中だった場合）
　・引数のプロセス優先度が1より小さかった場合

Definition at line 55 of file create.c.

References CONSOLE, disable(), FALSE, getpid(), getstk(), INITRET, MINSTK, newpid(), NULLCH, PNMLEN, PR_SUSP, prcount, procent::prdesc, procent::prhasmsg, procent::prname, proctab, procent::prparent, procent::prprio, procent::prsem, procent::prstate, procent::prstkbase, procent::prstklen, procent::prstkptr, restore(), roundew, STACKMAGIC, and SYSERR.

Referenced by main(), net_init(), nulluser(), rdsinit(), shell(), and startup().

{
    intmask mask;          /* interrupt mask        */
    pid32 pid;             /* stores new process id */
    struct procent *prptr; /* pointer to proc. table entry */
    int32 i;
    uint32 *a;     /* points to list of args    */
    uint32 *saddr; /* stack address     */

    mask = disable();
    if (ssize < MINSTK)
        ssize = MINSTK;
    ssize = (uint32)roundew(ssize);
    if (((saddr = (uint32 *)getstk(ssize)) ==
         (uint32 *)SYSERR) ||
        (pid = newpid()) == SYSERR || priority < 1)
    {
        restore(mask);
        return SYSERR;
    }

    prcount++;
    prptr = &proctab[pid];

    /* initialize process table entry for new process */
    prptr->prstate = PR_SUSP; /* initial state is suspended */
    prptr->prprio = priority;
    prptr->prstkbase = (char *)saddr;
    prptr->prstklen = ssize;
    prptr->prname[PNMLEN - 1] = NULLCH;
    for (i = 0; i < PNMLEN - 1 && (prptr->prname[i] = name[i]) != NULLCH; i++)
        ;
    prptr->prsem = -1;
    prptr->prparent = (pid32)getpid();
    prptr->prhasmsg = FALSE;

    /* set up initial device descriptors for the shell      */
    prptr->prdesc[0] = CONSOLE; /* stdin  is CONSOLE device */
    prptr->prdesc[1] = CONSOLE; /* stdout is CONSOLE device */
    prptr->prdesc[2] = CONSOLE; /* stderr is CONSOLE device */

    /* Initialize stack as if the process was called        */

    *saddr = STACKMAGIC;

    /* push arguments */
    a = (uint32 *)(&nargs + 1); /* start of args        */
    a += nargs - 1;             /* last argument        */
    for (; nargs > 4; nargs--)  /* machine dependent; copy args */
        *--saddr = *a--;        /* onto created process's stack */
    *--saddr = (long)procaddr;
    for (i = 11; i >= 4; i--)
        *--saddr = 0;
    for (i = 4; i > 0; i--)
    {
        if (i <= nargs)
            *--saddr = *a--;
        else
            *--saddr = 0;
    }
    *--saddr = (long)INITRET;    /* push on return address  */
    *--saddr = (long)0x00000053; /* CPSR F bit set,     */
    /* Supervisor mode      */
    prptr->prstkptr = (char *)saddr;
    restore(mask);
    return pid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ctxsw()

void ctxsw	(	void *	,
		void *
	)

コンテキストスイッチを行う（ctxsw.S に定義がある）

Referenced by resched().

Here is the caller graph for this function:

dequeue()

pid32 dequeue

(

qid16

q

)

プロセスキューテーブルからキューを削除し、リスト先頭のプロセスIDを返す。

Parameters

[in]

q

使用するキューID

Returns

キューを削除した場合はリスト先頭のプロセスID、キューIDが不正の場合はSYSERR、
キューが空の場合はEMPTYを返す。

Definition at line 78 of file queue.c.

References EMPTY, getfirst(), isbadqid, isempty, qentry::qnext, qentry::qprev, queuetab, and SYSERR.

Referenced by resched(), signal(), signaln(), and wakeup().

{
    pid32 pid; /* ID of process removed */

    if (isbadqid(q))
    {
        return SYSERR;
    }
    else if (isempty(q))
    {
        return EMPTY;
    }

    pid = getfirst(q);
    queuetab[pid].qprev = EMPTY;
    queuetab[pid].qnext = EMPTY;
    return pid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

disable()

intmask disable

(

void

)

割り込み禁止（intr.Sに定義がある）

Referenced by addargs(), arp_in(), arp_resolve(), chprio(), close(), control(), create(), freebuf(), freemem(), getbuf(), getc(), getdev(), getmem(), getprio(), getstk(), icmp_in(), icmp_recv(), icmp_register(), icmp_release(), icmp_send(), init(), ip_enqueue(), ip_send(), irq_dispatch(), kgetc(), kill(), kputc(), mkbufpool(), mount(), open(), panic(), ptcount(), ptcreate(), ptdelete(), ptrecv(), ptreset(), ptsend(), putc(), rdscomm(), read(), receive(), recvclr(), recvtime(), resume(), seek(), semcount(), semcreate(), semdelete(), semreset(), send(), signal(), signaln(), sleepms(), suspend(), udp_in(), udp_recv(), udp_recvaddr(), udp_register(), udp_release(), udp_send(), udp_sendto(), unsleep(), wait(), write(), and yield().

dnslookup()

uint32 dnslookup

(

char *

)

Definition at line 15 of file dns.c.

References currpid, dns_bldq(), dns_geta(), DNSLPORT, DNSPORT, DNSRETRY, network::dnsserver, DNSTIMEOUT, getlocalip(), htons, kprintf(), memset(), NetData, ntohl, NULL, SYSERR, TIMEOUT, udp_recv(), udp_register(), udp_release(), and udp_send().

Referenced by xsh_ping().

{
    struct  dnspkt  qpkt;       /* Query Packet buffer      */
    struct  dnspkt  rpkt;       /* Response Packet buffer   */
    uint32  nsaddr;         /* Name server IP address   */
    uint32  qlen;           /* Query length         */
    uid32   slot;           /* UDP Slot         */
    int32   rlen;           /* Response length      */
    uint32  ipaddr;         /* IP address from response */
    int32   retval;         /* Return value         */
    int32   i;          /* Loop index           */

    /* Check if we have a valid name pointer */

    if(dname == NULL) {
        return (uint32)SYSERR;
    }

    /* Obtain the IP address of a DNS server */

    retval = getlocalip();
    nsaddr = NetData.dnsserver;
    if ( (retval == SYSERR) || (NetData.dnsserver == 0) ) {
            kprintf("Cannot find a DNS server\n");
            return (uint32)SYSERR;
    }

    /* Register a UDP Slot */

    slot = udp_register(nsaddr, DNSPORT, DNSLPORT);
    if(slot == SYSERR) {
        return (uint32)SYSERR;
    }

    /* Build the Query message */

    memset((char *)&qpkt, 0, sizeof(struct dnspkt));

    qpkt.id = currpid;
    qpkt.rd = 1;
    qpkt.qucount = htons(1);

    qlen = dns_bldq(dname, qpkt.data);

    ipaddr = (uint32)SYSERR;
    for(i = 0; (ipaddr==(uint32)SYSERR) && (i < DNSRETRY); i++) {

        /* Send the Query message */

        udp_send(slot, (char*)&qpkt, qlen);

        /* Wait for the response */

        rlen = udp_recv(slot, (char*)&rpkt, sizeof(struct dnspkt),
                        DNSTIMEOUT);
        if ( (rlen == SYSERR) || (rlen == TIMEOUT) ) {
            continue;
        }
        ipaddr = dns_geta(dname, &rpkt);
    }
    udp_release(slot);
    return ntohl(ipaddr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

dot2ip()

uint32 dot2ip	(	char *	,
		uint32 *
	)

Definition at line 9 of file dot2ip.c.

References NULLCH, OK, and SYSERR.

Referenced by getlocalip(), getutime(), rdsinit(), rfsinit(), xsh_ping(), and xsh_udpecho().

{
    int32   seg;            /* Counts segments      */
    int32   nch;            /* Counts chars within segment  */
    char    ch;         /* Next character       */
    uint32  ipaddr;         /* IP address in binary     */
    int32   val;            /* Binary value of one segment  */

    /* Input must have the form  X.X.X.X, where X is 1 to 3 digits  */

    ipaddr = 0;
    for (seg=0 ; seg<4 ; seg++) {    /* For each segment        */
        val = 0;
        for (nch=0 ; nch<4; nch++) { /* Up to four chars per segment*/
        ch = *dotted++;
        if ( (ch==NULLCH) || (ch == '.') ) {
            if (nch == 0) {
                return SYSERR;
            } else {
                break;
            }
        }

        /*  Non-digit is an error */

        if ( (ch<'0') || (ch>'9') ) {
            return SYSERR;
        }

        val = 10*val + (ch-'0');
        }

        if (val > 255) {    /* Out of valid range */
        return SYSERR;
        }
        ipaddr = (ipaddr << 8) | val;

        if (ch == NULLCH) {
        break;
        }
    }
    if ( (seg != 3) || (ch != NULLCH) ) {
        return SYSERR;
    }
    *result = ipaddr;
    return OK;
}

Here is the caller graph for this function:

enable()

void enable

(

void

)

割り込み許可（intr.Sに定義がある）

Referenced by nulluser().

Here is the caller graph for this function:

enqueue()

pid32 enqueue	(	pid32	pid,
		qid16	q
	)

プロセスをプロセスキューテーブルの末尾に挿入する。

Parameters

[in]	pid	挿入するプロセスID
[in]	q	使用するキューID

Returns

成功時はキューに挿入したプロセスID、引数不正時はSYSERRを返す。

Definition at line 53 of file queue.c.

References isbadpid, isbadqid, qentry::qnext, qentry::qprev, queuetab, queuetail, and SYSERR.

Referenced by wait().

{
    qid16 tail, prev; /* Tail & previous node indexes   */

    if (isbadqid(q) || isbadpid(pid))
    {
        return SYSERR;
    }

    tail = queuetail(q);
    prev = queuetab[tail].qprev;

    queuetab[pid].qnext = tail; /* Insert just before tail node */
    queuetab[pid].qprev = prev;
    queuetab[prev].qnext = pid;
    queuetab[tail].qprev = pid;
    return pid;
}

Here is the caller graph for this function:

eth_hton()

void eth_hton

(

struct netpacket *

)

Definition at line 127 of file net.c.

References htons, and netpacket::net_ethtype.

Referenced by arp_in(), arp_resolve(), and ip_out().

{
    pktptr->net_ethtype = htons(pktptr->net_ethtype);
}

Here is the caller graph for this function:

eth_ntoh()

void eth_ntoh

(

struct netpacket *

)

Definition at line 139 of file net.c.

References netpacket::net_ethtype, and ntohs.

Referenced by netin().

{
    pktptr->net_ethtype = ntohs(pktptr->net_ethtype);
}

Here is the caller graph for this function:

ethcontrol()

int32 ethcontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 18 of file ethcontrol.c.

References ethcblk::devAddress, dentry::dvminor, ETH_ADDR_LEN, ETH_CTRL_GET_MAC, ethertab, memcpy(), OK, and SYSERR.

{
    struct ethcblk *ethptr; /* Ethertab entry pointer   */
    int32 retval = OK;      /* Return value of cntl function*/

    ethptr = &ethertab[devptr->dvminor];

    switch (func)
    {

        /* Get MAC address */

    case ETH_CTRL_GET_MAC:
        memcpy((byte *)arg1, ethptr->devAddress,
               ETH_ADDR_LEN);
        break;

    default:
        return SYSERR;
    }

    return retval;
}

Here is the call graph for this function:

ethhandler()

interrupt ethhandler

(

uint32

)

Definition at line 9 of file ethhandler.c.

References eth_a_csreg::cpdma, ethcblk::csr, DEFER_START, DEFER_STOP, eth_a_cpdma::eoi_vector, ETH_AM335X_RDS_OWN, ETH_AM335X_RXINT, ETH_AM335X_TDS_OWN, ETH_AM335X_TXINT, ethertab, ethcblk::isem, ethcblk::osem, resched_cntl(), eth_a_stateram::rx_cp, eth_a_stateram::rx_hdp, ethcblk::rxRing, ethcblk::rxRingSize, ethcblk::rxTail, semcount(), signal(), eth_a_rx_desc::stat, eth_a_tx_desc::stat, eth_a_csreg::stateram, eth_a_stateram::tx_cp, eth_a_stateram::tx_hdp, ethcblk::txHead, ethcblk::txRing, and ethcblk::txRingSize.

{
    struct  eth_a_csreg *csrptr;        /* Ethernet CSR pointer */
    struct  eth_a_tx_desc *tdescptr;    /* Tx desc pointer  */
    struct  eth_a_rx_desc *rdescptr;    /* Rx desc pointer  */
    struct  ethcblk *ethptr = &ethertab[0]; /* Ethernet ctl blk ptr */

    csrptr = (struct eth_a_csreg *)ethptr->csr;

    if(xnum == ETH_AM335X_TXINT) {  /* Transmit interrupt */

        /* Get pointer to first desc in queue   */

        tdescptr = (struct eth_a_tx_desc *)ethptr->txRing +
                            ethptr->txHead;

        /* Defer scheduling until all descs are processed */

        resched_cntl(DEFER_START);

        while(semcount(ethptr->osem) < (int32)ethptr->txRingSize) {

            /* If desc owned by DMA, check if we need to    */
            /* Restart the transmission         */

            if(tdescptr->stat & ETH_AM335X_TDS_OWN) {
                if(csrptr->stateram->tx_hdp[0] == 0) {
                    csrptr->stateram->tx_hdp[0] =
                            (uint32)tdescptr;
                }
                break;
            }

            /* Acknowledge the interrupt    */

            csrptr->stateram->tx_cp[0] = (uint32)tdescptr;

            /* Increment the head index of the queue    */
            /* And go to the next descriptor in queue   */

            ethptr->txHead++;
            tdescptr++;
            if(ethptr->txHead >= ethptr->txRingSize) {
                ethptr->txHead = 0;
                tdescptr = (struct eth_a_tx_desc *)
                            ethptr->txRing;
            }

            /* Signal the output semaphore */

            signal(ethptr->osem);
        }

        /* Acknowledge the transmit interrupt */

        csrptr->cpdma->eoi_vector = 0x2;

        /* Resume rescheduling  */

        resched_cntl(DEFER_STOP);
    }
    else if(xnum == ETH_AM335X_RXINT) { /* Receive interrupt */

        /* Get the pointer to last desc in the queue    */

        rdescptr = (struct eth_a_rx_desc *)ethptr->rxRing +
                            ethptr->rxTail;

        /* Defer scheduling until all descriptors are processed */

        resched_cntl(DEFER_START);

        while(semcount(ethptr->isem) < (int32)ethptr->rxRingSize) {

            /* Check if we need to restart the DMA  */

            if(rdescptr->stat & ETH_AM335X_RDS_OWN) {
                if(csrptr->stateram->rx_hdp[0] == 0) {
                    csrptr->stateram->rx_hdp[0] =
                            (uint32)rdescptr;
                }
                break;
            }

            /* Acknowledge the interrupt    */

            csrptr->stateram->rx_cp[0] = (uint32)rdescptr;

            /* Increment the tail index of the queue    */
            /* And go to the next descriptor in the queue   */

            ethptr->rxTail++;
            rdescptr++;
            if(ethptr->rxTail >= ethptr->rxRingSize) {
                ethptr->rxTail = 0;
                rdescptr = (struct eth_a_rx_desc *)
                            ethptr->rxRing;
            }

            /* Signal the input semaphore   */

            signal(ethptr->isem);
        }

        /* Acknowledge the receive interrupt */

        csrptr->cpdma->eoi_vector = 0x1;

        /* Resume rescheduling  */

        resched_cntl(DEFER_STOP);
    }
}

Here is the call graph for this function:

ethinit()

int32 ethinit

(

struct dentry *

)

Definition at line 173 of file ethinit.c.

References eth_a_csreg::ale, eth_a_rx_desc::buffer, eth_a_tx_desc::buffer, eth_a_rx_desc::buflen, eth_a_tx_desc::buflen, eth_a_rx_desc::bufoff, eth_a_tx_desc::bufoff, eth_a_wr::c0_rx_en, eth_a_wr::c0_tx_en, eth_a_csreg::cpdma, ethcblk::csr, eth_a_ale::ctrl, eth_a_mdio::ctrl, ethcblk::devAddress, dentry::dvintr, dentry::dvminor, eth_a_regs, ETH_AM335X_ALE_ADDR, ETH_AM335X_ALECTL_BY, ETH_AM335X_ALECTL_EN, ETH_AM335X_ALEPCTL_FWD, ETH_AM335X_CPDMA_ADDR, ETH_AM335X_MDIO_ADDR, ETH_AM335X_MDIOCTL_EN, ETH_AM335X_RDS_OWN, ETH_AM335X_RX_RING_SIZE, ETH_AM335X_RXINT, ETH_AM335X_SL1_ADDR, ETH_AM335X_SLCTL_EN, ETH_AM335X_SLCTL_FD, ETH_AM335X_SS_ADDR, ETH_AM335X_STATERAM_ADDR, ETH_AM335X_TDS_DIR, ETH_AM335X_TDS_EOP, ETH_AM335X_TDS_P1, ETH_AM335X_TDS_SOP, ETH_AM335X_TX_RING_SIZE, ETH_AM335X_TXINT, ETH_AM335X_WR_ADDR, ETH_BUF_SIZE, ETH_PHY_1000M, ETH_PHY_100M, ETH_PHY_10M, ETH_PHY_CTLREG, ETH_PHY_CTLREG_FD, ETH_PHY_CTLREG_SM, eth_phy_read(), eth_phy_reset(), ethertab, getmem(), ethcblk::isem, kprintf(), eth_a_sl::macctrl, eth_a_csreg::mdio, memset(), netpacket::net_ethdst, eth_a_rx_desc::next, eth_a_tx_desc::next, NULL, NULLCH, OK, ethcblk::osem, eth_a_ale::portctl, eth_a_cpdma::reset, eth_a_sl::reset, eth_a_ss::reset, eth_a_wr::reset, eth_a_cpdma::rx_ctrl, eth_a_stateram::rx_hdp, eth_a_cpdma::rx_intmask_set, ethcblk::rxBufs, ethcblk::rxHead, ethcblk::rxRing, ethcblk::rxRingSize, ethcblk::rxTail, semcreate(), set_evec(), eth_a_csreg::sl, eth_a_csreg::ss, eth_a_rx_desc::stat, eth_a_tx_desc::stat, eth_a_csreg::stateram, SYSERR, eth_a_cpdma::tx_ctrl, eth_a_stateram::tx_hdp, eth_a_cpdma::tx_intmask_set, ethcblk::txBufs, ethcblk::txHead, ethcblk::txRing, ethcblk::txRingSize, ethcblk::txTail, and eth_a_csreg::wr.

{
    struct  ethcblk *ethptr;        /* Ethernet control blk pointer */
    struct  eth_a_tx_desc *tdescptr;/* Tx descriptor pointer    */
    struct  eth_a_rx_desc *rdescptr;/* Rx descriptor pointer    */
    struct  netpacket *pktptr;  /* Packet pointer       */
    struct  eth_a_csreg *csrptr;    /* Ethernet CSR pointer     */
    uint32  phyreg;         /* Variable to store PHY reg val*/
    int32   retval;         /* Return value         */
    int32   i;          /* Index variable       */

    /* Get the Ethernet control block address   */
    /* from the device table entry          */

    ethptr = &ethertab[devptr->dvminor];

    /* Store the address of CSRs in the Ethernet control block  */

    csrptr = &eth_a_regs;
    ethptr->csr = csrptr;

    /* Initialize the addresses of all the submodules   */

    csrptr->ale = (struct eth_a_ale *)ETH_AM335X_ALE_ADDR;
    csrptr->cpdma = (struct eth_a_cpdma *)ETH_AM335X_CPDMA_ADDR;
    csrptr->sl = (struct eth_a_sl *)ETH_AM335X_SL1_ADDR;
    csrptr->stateram = (struct eth_a_stateram *)
                    ETH_AM335X_STATERAM_ADDR;
    csrptr->ss = (struct eth_a_ss *)ETH_AM335X_SS_ADDR;
    csrptr->wr = (struct eth_a_wr *)ETH_AM335X_WR_ADDR;
    csrptr->mdio = (struct eth_a_mdio *)ETH_AM335X_MDIO_ADDR;

    /* Reset all the submodules */

    csrptr->cpdma->reset = 1;
    while(csrptr->cpdma->reset == 1);

    csrptr->sl->reset = 1;
    while(csrptr->sl->reset == 1);

    csrptr->wr->reset = 1;
    while(csrptr->wr->reset == 1) ;

    csrptr->ss->reset = 1;
    while(csrptr->ss->reset == 1) ;

    /* Enable MDIO  */

    csrptr->mdio->ctrl |= ETH_AM335X_MDIOCTL_EN;

    /* Reset the PHY */

    retval = eth_phy_reset(csrptr->mdio, 0);
    if(retval == SYSERR) {
        kprintf("Cannot reset Ethernet PHY\n");
        return SYSERR;
    }

    retval = eth_phy_read(csrptr->mdio, ETH_PHY_CTLREG, 0, &phyreg);
    if(retval == SYSERR) {
        return SYSERR;
    }

    if( (phyreg & ETH_PHY_CTLREG_SM) == ETH_PHY_10M ) {
        kprintf("Ethernet Link is Up. Speed is 10Mbps\n");
    }
    else if( (phyreg & ETH_PHY_CTLREG_SM) == ETH_PHY_100M ) {
        kprintf("Ethernet Link is Up. Speed is 100Mbps\n");
    }
    else if( (phyreg & ETH_PHY_CTLREG_SM) == ETH_PHY_1000M ) {
        kprintf("Ethernet Link is Up. Speed is 1000Mbps\n");
    }
    else {
        return SYSERR;
    }

    if(phyreg & ETH_PHY_CTLREG_FD) {
        kprintf("Link is Full Duplex\n");
        csrptr->sl->macctrl |= ETH_AM335X_SLCTL_FD;
    }
    else {
        kprintf("Link is Half Duplex\n");
    }

    /* Read the device MAC address */
    for(i = 0; i < 2; i++) {
        ethptr->devAddress[4+i] = *((byte *)(0x44e10630+i));
    }
    for(i = 0; i < 4; i++) {
        ethptr->devAddress[i] = *((byte *)(0x44e10634+i));
    }

    kprintf("MAC Address is: ");
    for(i = 0; i < 5; i++) {
        kprintf("%02X:", ethptr->devAddress[i]);
    }
    kprintf("%02X\n", ethptr->devAddress[5]);

    /* Initialize the rx ring size field */
    ethptr->rxRingSize = ETH_AM335X_RX_RING_SIZE;

    /* Allocate memory for the rx ring */
    ethptr->rxRing = (void*)getmem(sizeof(struct eth_a_rx_desc)*
                    ethptr->rxRingSize);
    if((int32)ethptr->rxRing == SYSERR) {
        return SYSERR;
    }

    /* Zero out the rx ring */
    memset((char*)ethptr->rxRing, NULLCH,
        sizeof(struct eth_a_rx_desc)*ethptr->rxRingSize);

    /* Allocate memory for rx buffers */
    ethptr->rxBufs = (void*)getmem(ETH_BUF_SIZE *
                    ethptr->rxRingSize);
    if((int32)ethptr->rxBufs == SYSERR) {
        return SYSERR;
    }

    /* Zero out the rx buffers */
    memset((char *)ethptr->rxBufs, NULLCH, ETH_BUF_SIZE *
                        ethptr->rxRingSize);

    /* Initialize the rx ring */

    rdescptr = (struct eth_a_rx_desc *)ethptr->rxRing;
    pktptr = (struct netpacket *)ethptr->rxBufs;

    for(i = 0; i < ethptr->rxRingSize; i++) {
        rdescptr->next = rdescptr + 1;
        rdescptr->buffer = (uint32)pktptr->net_ethdst;
        rdescptr->buflen = ETH_BUF_SIZE;
        rdescptr->bufoff = 0;
        rdescptr->stat = ETH_AM335X_RDS_OWN;
        rdescptr++;
        pktptr++;
    }
    (--rdescptr)->next = NULL;

    ethptr->rxHead = 0;
    ethptr->rxTail = 0;
    ethptr->isem = semcreate(0);
    if((int32)ethptr->isem == SYSERR) {
        return SYSERR;
    }

    /* initialize the tx ring size */
    ethptr->txRingSize = ETH_AM335X_TX_RING_SIZE;

    /* Allocate memory for tx ring */
    ethptr->txRing = (void*)getmem(sizeof(struct eth_a_tx_desc)*
                    ethptr->txRingSize);
    if((int32)ethptr->txRing == SYSERR) {
        return SYSERR;
    }

    /* Zero out the tx ring */
    memset((char*)ethptr->txRing, NULLCH,
        sizeof(struct eth_a_tx_desc)*ethptr->txRingSize);

    /* Allocate memory for tx buffers */
    ethptr->txBufs = (void*)getmem(ETH_BUF_SIZE *
                    ethptr->txRingSize);
    if((int32)ethptr->txBufs == SYSERR) {
        return SYSERR;
    }

    /* Zero out the tx buffers */
    memset((char*)ethptr->txBufs, NULLCH, ETH_BUF_SIZE *
                        ethptr->txRingSize);

    /* Initialize the tx ring */

    tdescptr = (struct eth_a_tx_desc *)ethptr->txRing;
    pktptr = (struct netpacket *)ethptr->txBufs;

    for(i = 0; i < ethptr->txRingSize; i++) {
        tdescptr->next = NULL;
        tdescptr->buffer = (uint32)pktptr->net_ethdst;
        tdescptr->buflen = ETH_BUF_SIZE;
        tdescptr->bufoff = 0;
        tdescptr->stat = (ETH_AM335X_TDS_SOP |
                  ETH_AM335X_TDS_EOP |
                  ETH_AM335X_TDS_DIR |
                  ETH_AM335X_TDS_P1);
        tdescptr++;
        pktptr++;
    }

    ethptr->txHead = 0;
    ethptr->txTail = 0;
    ethptr->osem = semcreate(ethptr->txRingSize);
    if((int32)ethptr->osem == SYSERR) {
        return SYSERR;
    }

    /* Enable the ALE and put it into bypass mode */
    csrptr->ale->ctrl = (ETH_AM335X_ALECTL_EN |
                 ETH_AM335X_ALECTL_BY);

    /* Put the ports 0, 1 in forwarding state */
    csrptr->ale->portctl[0] = ETH_AM335X_ALEPCTL_FWD;
    csrptr->ale->portctl[1] = ETH_AM335X_ALEPCTL_FWD;

    /* Start the rx and tx processes in DMA */
    csrptr->cpdma->tx_ctrl = 1;
    csrptr->cpdma->rx_ctrl = 1;

    /* Initialize the head desc pointers for tx and rx */
    csrptr->stateram->tx_hdp[0] = 0;
    csrptr->stateram->rx_hdp[0] = (uint32)ethptr->rxRing;

    /* Enable Rx and Tx in MAC */
    csrptr->sl->macctrl |= ETH_AM335X_SLCTL_EN;

    /* Set interrupt vectors */
    set_evec(ETH_AM335X_TXINT, (uint32)devptr->dvintr);
    set_evec(ETH_AM335X_RXINT, (uint32)devptr->dvintr);

    /* Enable the CPDMA interrupts */
    csrptr->cpdma->tx_intmask_set = 0x1;
    csrptr->cpdma->rx_intmask_set = 0x1;

    /* Route the interrupts to core 0 */
    csrptr->wr->c0_tx_en = 0x1;
    csrptr->wr->c0_rx_en = 0x1;

    return OK;
}

Here is the call graph for this function:

ethread()

int32 ethread	(	struct dentry *	,
		void *	,
		uint32
	)

Definition at line 9 of file ethread.c.

References eth_a_rx_desc::buffer, eth_a_rx_desc::buflen, eth_a_rx_desc::bufoff, ethcblk::csr, dentry::dvminor, ETH_AM335X_RDS_OWN, ETH_BUF_SIZE, ethertab, ethcblk::isem, kprintf(), memcpy(), eth_a_rx_desc::next, NULL, eth_a_rx_desc::packlen, eth_a_stateram::rx_hdp, ethcblk::rxHead, ethcblk::rxRing, ethcblk::rxRingSize, eth_a_rx_desc::stat, eth_a_csreg::stateram, and wait().

{
    struct  ethcblk *ethptr;    /* Ethernet ctl blk ptr */
    struct  eth_a_csreg *csrptr;    /* Ethernet CSR pointer */
    struct  eth_a_rx_desc *rdescptr;/* Rx Desc. pointer */
    struct  eth_a_rx_desc *prev;    /* Prev Rx desc pointer */
    uint32  retval;         /* Num of bytes returned*/

    ethptr = &ethertab[devptr->dvminor];

    /* Get the pointer to Ethernet CSR */
    csrptr = (struct eth_a_csreg *)ethptr->csr;

    /* Wait for a packet */
    wait(ethptr->isem);

    /* Get pointer to the descriptor */
    rdescptr = (struct eth_a_rx_desc *)ethptr->rxRing +
                        ethptr->rxHead;

    /* Read the packet length */
    retval = rdescptr->packlen;
    if(retval > count) {
        retval = count;
    }

    /* Copy the packet into user provided buffer */
    memcpy((char *)buf, (char *)rdescptr->buffer, retval);

    /* Initialize the descriptor for next packet */
    rdescptr->stat = ETH_AM335X_RDS_OWN;
    rdescptr->bufoff = 0;
    rdescptr->buflen = ETH_BUF_SIZE;
    rdescptr->packlen = 0;
    rdescptr->next = NULL;

    /* Insert the descriptor into Rx queue */
    prev = (struct eth_a_rx_desc *)csrptr->stateram->rx_hdp[0];
    if(prev == NULL) {
        kprintf("hdp 0, adding %x\n", rdescptr);
        csrptr->stateram->rx_hdp[0] = (uint32)rdescptr;
    }
    else {
        while(prev->next != NULL) {
            prev = prev->next;
        }
        prev->next = rdescptr;
    }

    /* Increment the head index of rx ring */
    ethptr->rxHead++;
    if(ethptr->rxHead >= ethptr->rxRingSize) {
        ethptr->rxHead = 0;
    }

    return retval;
}

Here is the call graph for this function:

ethwrite()

int32 ethwrite	(	struct dentry *	,
		void *	,
		uint32
	)

Definition at line 9 of file ethwrite.c.

References eth_a_tx_desc::buffer, eth_a_tx_desc::buflen, eth_a_tx_desc::bufoff, ethcblk::csr, dentry::dvminor, ETH_AM335X_TDS_DIR, ETH_AM335X_TDS_EOP, ETH_AM335X_TDS_OWN, ETH_AM335X_TDS_P1, ETH_AM335X_TDS_SOP, ethertab, memcpy(), memset(), eth_a_tx_desc::next, NULL, ethcblk::osem, PACKLEN, eth_a_tx_desc::packlen, eth_a_tx_desc::stat, eth_a_csreg::stateram, eth_a_stateram::tx_hdp, ethcblk::txRing, ethcblk::txRingSize, ethcblk::txTail, and wait().

{
    struct  ethcblk *ethptr;    /* Ether entry pointer  */
    struct  eth_a_csreg *csrptr;    /* Ethernet CSR pointer */
    struct  eth_a_tx_desc *tdescptr;/* Tx Desc. pointer */
    struct  eth_a_tx_desc *prev;    /* Prev. Desc. pointer  */

    ethptr = &ethertab[devptr->dvminor];

    /* Get the pointer to the Ethernet CSR */
    csrptr = (struct eth_a_csreg *)ethptr->csr;

    /* Wait for an empty slot in the queue */
    wait(ethptr->osem);

    /* Get the pointer to the next descriptor */
    tdescptr = (struct eth_a_tx_desc *)ethptr->txRing +
                            ethptr->txTail;

    /* Adjust count if greater than max. possible packet size */
    if(count > PACKLEN) {
        count = PACKLEN;
    }

    /* Initialize the descriptor */
    tdescptr->next = NULL;
    tdescptr->buflen = count;
    tdescptr->bufoff = 0;
    tdescptr->packlen = count;
    tdescptr->stat = (ETH_AM335X_TDS_SOP |  /* Start of packet  */
              ETH_AM335X_TDS_EOP |  /* End of packet    */
              ETH_AM335X_TDS_OWN |  /* Own flag set for DMA */
              ETH_AM335X_TDS_DIR |  /* Directed packet  */
              ETH_AM335X_TDS_P1);   /* Output port is port1 */

    /* Copy the packet into the Tx buffer */
    memcpy((char *)tdescptr->buffer, buf, count);

    /* TODO Figure out why we need this hack    */
    /* This ethernet device does not send packets smaller than 60   */
    /* bytes; So pad a small packet to make it 60 bytes long    */

    if(count < 60) {
        memset((char *)tdescptr->buffer+count, 0, 60-count);
        tdescptr->buflen = 60;
        tdescptr->packlen = 60;
    }

    /* Insert the descriptor into Tx queue */

    if(csrptr->stateram->tx_hdp[0] == 0) {
        /* Tx queue is empty, this desc. will be the first */
        csrptr->stateram->tx_hdp[0] = (uint32)tdescptr;
    }
    else {
        /* Tx queue not empty, insert at end */
        prev = (struct eth_a_tx_desc *)
                csrptr->stateram->tx_hdp[0];
        while(prev->next != NULL) {
            prev = prev->next;
        }
        prev->next = tdescptr;
    }

    /* Increment the tail index of the Tx ring */
    ethptr->txTail++;
    if(ethptr->txTail >= ethptr->txRingSize) {
        ethptr->txTail = 0;
    }

    return count;
}

Here is the call graph for this function:

exception()

void exception	(	int32	,
		int32 *
	)

freebuf()

syscall freebuf

(

char *

bufaddr

)

バッファプールから取得したバッファを解放する。

Step1. 割り込みを禁止する。
Step2. 解放対象バッファアドレスの4Byte前に埋め込んだバッファプールIDが不正値かどうかを確認し、
不正値であれば割り込み状態を復元し、処理を終了する。
Step3. 解放対象バッファをバッファプールに戻す。
Step4. セマフォにシグナルを送り、待機プロセスがいれば待機解除とする。
Step5. 割り込み状態を復元する。

Parameters

[in]

bufaddr

getbuf()で取得したバッファアドレス

Returns

バッファを解放した場合はOK、バッファプールIDが不正値の場合はSYSERRを返す。

Definition at line 19 of file freebuf.c.

References bpentry::bpnext, bpentry::bpsem, buftab, disable(), nbpools, OK, restore(), signal(), and SYSERR.

Referenced by arp_in(), icmp_in(), icmp_recv(), icmp_release(), ip_enqueue(), ip_in(), ip_local(), ip_out(), ip_send(), ipout(), netin(), udp_in(), udp_recv(), udp_recvaddr(), and udp_release().

{
    intmask mask;          /* Saved interrupt mask      */
    struct bpentry *bpptr; /* Pointer to entry in buftab    */
    bpid32 poolid;         /* ID of buffer's pool       */

    mask = disable();

    /* Extract pool ID from integer prior to buffer address */

    bufaddr -= sizeof(bpid32);
    poolid = *(bpid32 *)bufaddr;
    if (poolid < 0 || poolid >= nbpools)
    {
        restore(mask);
        return SYSERR;
    }

    /* Get address of correct pool entry in table */

    bpptr = &buftab[poolid];

    /* Insert buffer into list and signal semaphore */

    ((struct bpentry *)bufaddr)->bpnext = bpptr->bpnext;
    bpptr->bpnext = (struct bpentry *)bufaddr;
    signal(bpptr->bpsem);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

freemem()

syscall freemem	(	char *	blkaddr,
		uint32	nbytes
	)

メモリブロックを解放し、ブロックを空きリストに戻す。

Step1. 割り込みを禁止する。
Step2. 以下のいずれかの場合は、割り込み状態を復元し、処理を終了する。
・メモリブロックのサイズが0の場合
・メモリブロックのポインタがヒープ開始アドレスより小さい場合
・メモリブロックのポインタがヒープ終了アドレスより大きい場合
Step4. メモリブロックのサイズを8の倍数で丸める。
Step5. フリーメモリリストから空きメモリブロックの位置を探す。
Step6. 「一つ前のメモリブロック」と「解放対象メモリブロック」の結合を試みるため、
一つ前のメモリブロックの最終アドレスを算出する（このアドレスはTOPとして扱う）。
Step7. 解放対象メモリブロックが前後のメモリブロックと重なっていた場合は、
割り込み状態を復元し、処理を終了する。
Step8. フリーメモリリストの使用可能メモリサイズに対して、今回解放するメモリブロックのサイズを加算する。
Step9. 解放対象のメモリブロックを一つ前のメモリブロックと結合するか、フリーメモリリストに追加する。
Step10. 解放対象のメモリブロックが次のメモリブロックと隣接している場合は、結合する。
Step11. 割り込み状態を復元する。

Parameters

[in]	blkaddr	メモリブロックのポインタ
[in]	nbytes	メモリブロックのサイズ（Byte）

Returns

メモリ解放時はOKを返し、以下のいずれかの場合はSYSERRを返す。
・メモリブロックのサイズが0の場合
・メモリブロックのポインタがヒープ開始アドレスより小さい場合
・メモリブロックのポインタがヒープ終了アドレスより大きい場合
・解放対象メモリブロックが前後のメモリブロックと重なっていた場合

Definition at line 33 of file freemem.c.

References disable(), maxheap, memlist, minheap, memblk::mlength, memblk::mnext, NULL, OK, restore(), roundmb, and SYSERR.

Referenced by mkbufpool().

{
    intmask mask; /* Saved interrupt mask       */
    struct memblk *next, *prev, *block;
    uint32 top;

    mask = disable();
    if ((nbytes == 0) || ((uint32)blkaddr < (uint32)minheap) || ((uint32)blkaddr > (uint32)maxheap))
    {
        restore(mask);
        return SYSERR;
    }

    nbytes = (uint32)roundmb(nbytes); /* Use memblk multiples   */
    block = (struct memblk *)blkaddr;

    prev = &memlist; /* Walk along free list    */
    next = memlist.mnext;
    while ((next != NULL) && (next < block))
    {
        prev = next;
        next = next->mnext;
    }

    if (prev == &memlist)
    { /* Compute top of previous block*/
        top = (uint32)NULL;
    }
    else
    {
        top = (uint32)prev + prev->mlength;
    }

    /* Ensure new block does not overlap previous or next blocks    */

    if (((prev != &memlist) && (uint32)block < top) || ((next != NULL) && (uint32)block + nbytes > (uint32)next))
    {
        restore(mask);
        return SYSERR;
    }

    memlist.mlength += nbytes;

    /* Either coalesce with previous block or add to free list */

    if (top == (uint32)block)
    { /* Coalesce with previous block   */
        prev->mlength += nbytes;
        block = prev;
    }
    else
    { /* Link into list as new node */
        block->mnext = next;
        block->mlength = nbytes;
        prev->mnext = block;
    }

    /* Coalesce with next block if adjacent */

    if (((uint32)block + block->mlength) == (uint32)next)
    {
        block->mlength += next->mlength;
        block->mnext = next->mnext;
    }
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getbuf()

char* getbuf

(

bpid32

poolid

)

事前に確保されたバッファプールからバッファを取得する。

Step1. 割り込みを禁止する。
Step2. バッファプールIDが不正値の場合は、割り込み状態を復元し、処理を終了する。
Step3. バッファプールに使用できるバッファが用意されるまで、待機する。
Step4. 提供するバッファをプール（リスト）から切り離す。
Step5. 提供するバッファの先頭4byteにバッファプールIDを記録し、4Byte分だけバッファのポインタを進める。
Step6. 割り込み状態を復元する。

Parameters

[in]

poolid

バッファテーブル中のバッファプールID

Returns

成功時はバッファへのポインタ、バッファプールIDが不正の場合はSYSERRを返す。

Definition at line 19 of file getbuf.c.

References bpentry::bpnext, bpentry::bpsem, buftab, disable(), nbpools, restore(), SYSERR, and wait().

Referenced by icmp_mkpkt(), netin(), udp_send(), and udp_sendto().

{
    intmask mask;           /* Saved interrupt mask     */
    struct bpentry *bpptr;  /* Pointer to entry in buftab   */
    struct bpentry *bufptr; /* Pointer to a buffer      */

    mask = disable();

    /* Check arguments */

    if ((poolid < 0 || poolid >= nbpools))
    {
        restore(mask);
        return (char *)SYSERR;
    }
    bpptr = &buftab[poolid];

    /* Wait for pool to have > 0 buffers and allocate a buffer */

    wait(bpptr->bpsem);
    bufptr = bpptr->bpnext;

    /* Unlink buffer from pool */

    bpptr->bpnext = bufptr->bpnext;

    /* Record pool ID in first four bytes of buffer and skip */

    *(bpid32 *)bufptr = poolid;
    bufptr = (struct bpentry *)(sizeof(bpid32) + (char *)bufptr);
    restore(mask);
    return (char *)bufptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getc()

syscall getc

(

did32

)

Definition at line 9 of file getc.c.

Referenced by xsh_cat().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvgetc) (devptr);
    restore(mask);
    return retval;
}

Here is the caller graph for this function:

getfirst()

pid32 getfirst

(

qid16

q

)

キューの先頭からプロセスを取り出す。

Parameters

[in]

q

プロセスを取り出すためのキューID（チェックなしで有効）

Returns

キューにプロセスがある場合はキューの先頭にあるプロセスID、
キューが空の場合はEMPTYを返す。

Definition at line 13 of file getitem.c.

References EMPTY, getitem(), isempty, queuehead, and queuetab.

Referenced by dequeue(), semdelete(), and semreset().

{
    pid32 head;

    if (isempty(q))
    {
        return EMPTY;
    }

    head = queuehead(q);
    return getitem(queuetab[head].qnext);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getitem()

pid32 getitem

(

pid32

pid

)

キューの任意の位置からプロセスを取り出す。

Parameters

[in]

pid

取り出すプロセスID

Returns

キューにプロセスがある場合はキューの末尾にあるプロセスID、
キューが空の場合はEMPTYを返す。

Definition at line 51 of file getitem.c.

References qentry::qnext, qentry::qprev, and queuetab.

Referenced by getfirst(), getlast(), kill(), suspend(), and unsleep().

{
    pid32 prev, next;

    next = queuetab[pid].qnext; /* Following node in list   */
    prev = queuetab[pid].qprev; /* Previous node in list    */
    queuetab[prev].qnext = next;
    queuetab[next].qprev = prev;
    return pid;
}

Here is the caller graph for this function:

getlast()

pid32 getlast

(

qid16

q

)

キューの末尾からプロセスを取り出す。

Parameters

[in]

q

プロセスを取り出すためのキューID（チェックなしで有効）

Returns

キューにプロセスがある場合はキューの末尾にあるプロセスID、
キューが空の場合はEMPTYを返す。

Definition at line 32 of file getitem.c.

References EMPTY, getitem(), isempty, queuetab, and queuetail.

{
    pid32 tail;

    if (isempty(q))
    {
        return EMPTY;
    }

    tail = queuetail(q);
    return getitem(queuetab[tail].qprev);
}

Here is the call graph for this function:

getlocalip()

uint32 getlocalip

(

void

)

Definition at line 142 of file dhcp.c.

References network::bootfile, network::bootserver, dhcp_bld_disc(), dhcp_bld_req(), dhcp_get_opt_val(), DHCP_RETRY, DHCP_SERVER_ID, network::dnsserver, dot2ip(), IP_BCAST, network::ipbcast, network::ipmask, network::ipprefix, network::iprouter, network::ipucast, network::ipvalid, kprintf(), memcpy(), NetData, ntohl, network::ntpserver, OK, SYSERR, TIMEOUT, TRUE, UDP_DHCP_CPORT, UDP_DHCP_SPORT, udp_recv(), udp_register(), udp_release(), and udp_sendto().

Referenced by dnslookup(), getutime(), rdscomm(), startup(), xsh_netinfo(), and xsh_udpeserver().

{
    int32   slot;           /* UDP slot to use      */
    struct  dhcpmsg dmsg_snd;   /* Holds outgoing DHCP messages */
    struct  dhcpmsg dmsg_rvc;   /* Holds incoming DHCP messages */

    int32   i, j;           /* Retry counters       */
    int32   len;            /* Length of data sent      */
    int32   inlen;          /* Length of data received  */
    char    *optptr;        /* Pointer to options area  */
    char    *eop;           /* Address of end of packet */
    int32   msgtype;        /* Type of DCHP message     */
    uint32  addrmask;       /* Address mask for network */
    uint32  routeraddr;     /* Default router address   */
    uint32  dnsaddr;        /* DNS server address       */
    uint32  ntpaddr;        /* NTP server address       */
    uint32  tmp;            /* Used for byte conversion */
    uint32* tmp_server_ip;      /* Temporary DHCP server pointer*/

    slot = udp_register(0, UDP_DHCP_SPORT, UDP_DHCP_CPORT);
    if (slot == SYSERR) {
        kprintf("getlocalip: cannot register with UDP\n");
        return SYSERR;
    }

    len = dhcp_bld_disc(&dmsg_snd);
    if(len == SYSERR) {
        kprintf("getlocalip: Unable to build DHCP discover\n");
        return SYSERR;
    }

    for (i = 0; i < DHCP_RETRY; i++) {
        udp_sendto(slot, IP_BCAST, UDP_DHCP_SPORT,
                        (char *)&dmsg_snd, len);

        /* Read 3 incoming DHCP messages and check for an offer */
        /*  or wait for three timeout periods if no message */
        /*  arrives.                    */

        for (j=0; j<3; j++) {
        inlen = udp_recv(slot, (char *)&dmsg_rvc,
                    sizeof(struct dhcpmsg), 2000);
        if (inlen == TIMEOUT) {
            continue;
        } else if (inlen == SYSERR) {
            return SYSERR;
        }
        /* Check that incoming message is a valid   */
        /*   response (ID matches our request)      */

        if (dmsg_rvc.dc_xid != dmsg_snd.dc_xid) {
            continue;
        }

        eop = (char *)&dmsg_rvc + inlen - 1;
        optptr = (char *)&dmsg_rvc.dc_opt;
        msgtype = addrmask = routeraddr = dnsaddr = ntpaddr = 0;

        while (optptr < eop) {

            switch (*optptr) {
            case 53:    /* Message type */
                msgtype = 0xff & *(optptr+2);
                break;

            case 1:     /* Subnet mask */
                memcpy((void *)&tmp, optptr+2, 4);
                addrmask = ntohl(tmp);
                break;

            case 3:     /* Router address */
                memcpy((void *)&tmp, optptr+2, 4);
                routeraddr = ntohl(tmp);
                break;

            case 6:     /* DNS server address */
                memcpy((void *)&tmp, optptr+2, 4);
                dnsaddr = ntohl(tmp);
                break;

            case 42:    /* NTP server address */
                memcpy((void *)&tmp, optptr+2, 4);
                ntpaddr = ntohl(tmp);
                break;

            }
            optptr++;   /* Move to length octet */
            optptr += (0xff & *optptr) + 1;
        }

        if (msgtype == 0x02) {  /* Offer - send request */
            len = dhcp_bld_req(&dmsg_snd, &dmsg_rvc, inlen);
            if(len == SYSERR) {
                kprintf("getlocalip: %s\n",
                  "Unable to build DHCP request");
                return SYSERR;
            }
            udp_sendto(slot, IP_BCAST, UDP_DHCP_SPORT,
                    (char *)&dmsg_snd, len);
            continue;

        } else if (dmsg_rvc.dc_opt[2] != 0x05) {
            /* If not an ack skip it */
            continue;
        }
        if (addrmask != 0) {
            NetData.ipmask = addrmask;
        }
        if (routeraddr != 0) {
            NetData.iprouter = routeraddr;
        }
        if (dnsaddr != 0) {
            NetData.dnsserver = dnsaddr;
        }
        if (ntpaddr != 0) {
            NetData.ntpserver = ntpaddr;
        }

        NetData.ipucast = ntohl(dmsg_rvc.dc_yip);
        NetData.ipprefix = NetData.ipucast & NetData.ipmask;
        NetData.ipbcast = NetData.ipprefix | ~NetData.ipmask;
        NetData.ipvalid = TRUE;
        udp_release(slot);

        /* Retrieve the boot server IP */
        if (dot2ip((char*)dmsg_rvc.sname,
                        &NetData.bootserver) != OK) {
            /* Could not retrieve the boot server from  */
            /*  the  BOOTP fields, so use the DHCP server   */
            /*  address                 */
            tmp_server_ip = (uint32*)dhcp_get_opt_val(
                    &dmsg_rvc, len, DHCP_SERVER_ID);
            memcpy((char *)&tmp, tmp_server_ip, 4);
            NetData.bootserver = ntohl(tmp);
        }
        memcpy(NetData.bootfile, dmsg_rvc.bootfile,
                         sizeof(dmsg_rvc.bootfile));
        return NetData.ipucast;
        }
    }

    kprintf("DHCP failed to get a response\n");
    udp_release(slot);
    return (uint32)SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getmem()

char* getmem

(

uint32

nbytes

)

ヒープ領域を割り当て、最下位のワードアドレスを返す。

Step1. 割り込みを禁止する。
Step2. 要求されたメモリのByte数が0の場合は、割り込み状態を復元し、処理を終了する。
Step3. 要求されたメモリのByte数を8の倍数で丸める。
Step4. フリーメモリリスト先頭の次のブロックから順番に、最適なメモリブロック探索を始める。
メモリブロック探索では、以下の3通りいずれかを行う。
・現在のメモリブロックがユーザの要求サイズと一致する場合、そのメモリブロックを返す。
・ユーザの要求よりメモリブロックサイズが大きい場合、必要なメモリブロックサイズ分だけを返す。
・ユーザの要求よりメモリブロックサイズが小さい場合、次のメモリブロックを探索対象とする。
メモリブロック提供時は、フリーメモリリストを連結し直し、メモリブロック合計サイズから提供サイズ分を引く。
また、割り込み状態を許可状態に復元する。

Parameters

[in]

nbytes

必要なメモリサイズ（Byte）

Returns

成功時はユーザ要求サイズ分のメモリへのアドレスを返し、「要求されたメモリのByte数が0の場合」や
「メモリに空きがない場合」はSYSERRを返す。

Note

フリーメモリブロックはリンクリストで保持され、各ブロックはアドレスの昇順で管理されている。

Definition at line 25 of file getmem.c.

References disable(), memlist, memblk::mlength, memblk::mnext, NULL, restore(), roundmb, and SYSERR.

Referenced by ethinit(), mkbufpool(), ptinit(), and rdsinit().

{
    intmask mask; /* Saved interrupt mask       */
    struct memblk *prev, *curr, *leftover;

    mask = disable();
    if (nbytes == 0)
    {
        restore(mask);
        return (char *)SYSERR;
    }

    nbytes = (uint32)roundmb(nbytes); /* Use memblk multiples   */

    prev = &memlist;
    curr = memlist.mnext;
    while (curr != NULL)
    { /* Search free list   */

        if (curr->mlength == nbytes)
        { /* Block is exact match   */
            prev->mnext = curr->mnext;
            memlist.mlength -= nbytes;
            restore(mask);
            return (char *)(curr);
        }
        else if (curr->mlength > nbytes)
        { /* Split big block    */
            leftover = (struct memblk *)((uint32)curr +
                                         nbytes);
            prev->mnext = leftover;
            leftover->mnext = curr->mnext;
            leftover->mlength = curr->mlength - nbytes;
            memlist.mlength -= nbytes;
            restore(mask);
            return (char *)(curr);
        }
        else
        { /* Move to next block */
            prev = curr;
            curr = curr->mnext;
        }
    }
    restore(mask);
    return (char *)SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getpid()

pid32 getpid

(

void

)

現在実行中のプロセスIDを返す。

Returns

現在実行中のプロセスIDを返す（グローバル変数currpidをそのまま返す）

Definition at line 11 of file getpid.c.

References currpid.

Referenced by create(), exit(), rdscontrol(), rdsread(), rdswrite(), and userret().

{
    return (currpid);
}

Here is the caller graph for this function:

getport()

uint16 getport

(

void

)

Definition at line 150 of file net.c.

References netportseed.

Referenced by tftpget_mb().

{
    netportseed = 1103515245 * netportseed + 12345;
    return 50000 + ((uint16)((netportseed >> 16)) % 15535);
}

Here is the caller graph for this function:

getprio()

syscall getprio

(

pid32

pid

)

プロセスのスケジューリング優先度を取得する。

Step1. 割り込みを禁止する。
Step2. 不正なPIDの場合は割り込み許可状態に戻し、処理を終了する。
Step3. 引数で指定されたPIDからプロセス情報を取得し、そこから優先度を取得する。
Step4. 割り込み許可状態に戻し、処理を終了する。

Parameters

[in]

pid

優先度を取得したいプロセスのID

Returns

処理が成功した場合は引数で指定したPIDの優先度、PIDが不正な場合はSYSERRを返す。

Definition at line 17 of file getprio.c.

References disable(), isbadpid, proctab, procent::prprio, restore(), and SYSERR.

{
    intmask mask; /* Saved interrupt mask       */
    uint32 prio;  /* Priority to return     */

    mask = disable();
    if (isbadpid(pid))
    {
        restore(mask);
        return SYSERR;
    }
    prio = proctab[pid].prprio;
    restore(mask);
    return prio;
}

Here is the call graph for this function:

getstk()

char* getstk

(

uint32

nbytes

)

スタックメモリを割り当て、最上位のワードアドレスを返す。

Step1. 割り込みを禁止する。
Step2. 要求メモリサイズが0の場合は、割り込み状態を復元し、処理を終了する。
Step3. 要求メモリサイズを8の倍数で丸める。
Step4. フリーメモリリストの先頭から、要求メモリサイズ以上のメモリブロックを探索する。
Step5. 要求メモリサイズを満たすメモリブロックがない場合は、割り込み状態を復元し、処理を終了する。
Step6. 要求メモリサイズとメモリブロックサイズが一致する場合は、そのブロックをメモリフリーリストから除く
Step7.要求メモリサイズよりメモリブロックサイズが大きい場合は、2つに分割し、
要求サイズと一致するブロックをスタックとし、残りをメモリフリーリストに残す。
Step8. 割り込み状態を復元する。
Step9. スタック（メモリブロックの最上位アドレス）を返す。

Parameters

[in]

nbytes

要求メモリサイズ（byte）

Returns

成功時はスタック（メモリブロックの最上位アドレス）を返し、以下の場合はSYSERRを返す。
　・要求メモリサイズが0の場合
　・要求メモリサイズを確保できなかった場合

Definition at line 25 of file getstk.c.

References disable(), memlist, memblk::mlength, memblk::mnext, NULL, restore(), roundmb, and SYSERR.

Referenced by create(), and sysinit().

{
    intmask mask;                   /* Saved interrupt mask     */
    struct memblk *prev, *curr;     /* Walk through memory list */
    struct memblk *fits, *fitsprev; /* Record block that fits   */

    mask = disable();
    if (nbytes == 0)
    {
        restore(mask);
        return (char *)SYSERR;
    }

    nbytes = (uint32)roundmb(nbytes); /* Use mblock multiples   */

    prev = &memlist;
    curr = memlist.mnext;
    fits = NULL;
    fitsprev = NULL; /* Just to avoid a compiler warning */

    while (curr != NULL)
    { /* Scan entire list   */
        if (curr->mlength >= nbytes)
        {                /* Record block address    */
            fits = curr; /*   when request fits */
            fitsprev = prev;
        }
        prev = curr;
        curr = curr->mnext;
    }

    if (fits == NULL)
    { /* No block was found */
        restore(mask);
        return (char *)SYSERR;
    }
    if (nbytes == fits->mlength)
    { /* Block is exact match   */
        fitsprev->mnext = fits->mnext;
    }
    else
    { /* Remove top section */
        fits->mlength -= nbytes;
        fits = (struct memblk *)((uint32)fits + fits->mlength);
    }
    memlist.mlength -= nbytes;
    restore(mask);
    return (char *)((uint32)fits + nbytes - sizeof(uint32));
}

Here is the call graph for this function:

Here is the caller graph for this function:

getticks()

uint32 getticks

(

void

)

CPUリセット以降のclock tick数を取得する。

Returns

CPUリセット以降のclock tick

Note

インラインアセンブラ部分はPMCNT0〜PMCNT3レジスタを読み込んでいる。
なお、CP15（コプロセッサ15、p15）は、システム制御機能を提供する。
c9はパフォーマンスモニターカウントレジスタ、c13はサイクルカウントレジスタである。

Definition at line 14 of file getticks.c.

Referenced by net_init().

{
    uint32 ret;
    asm volatile("MRC p15, 0, %0, c9, c13, 0\t\n"
                 : "=r"(ret));
    return ret;
}

Here is the caller graph for this function:

gettime()

status gettime

(

uint32 *

timvar

)

1970年1月1日からの経過時間（秒単位）にロケーション（時差）を反映した時間を返す。

UCT（協定世界時）からの経過時刻に対してロケーション（時差）を反映する。

Parameters

[in,out]

timvar

XINU時刻の取得結果の保存先

Returns

XINU時間を取得できた場合はOK、UCTからの経過時間が取得できなかった場合はSYSERRを返す。

Definition at line 13 of file gettime.c.

References getutime(), OK, SYSERR, and utim2ltim.

Referenced by xsh_date().

{
    uint32 now;   /* Current time (UCT)     */
    int32 retval; /* Return value from call */

    /* Get current time in UCT representation (GMT) */

    retval = getutime(&now);
    if (retval == SYSERR)
    {
        return SYSERR;
    }

    /* Adjust to xinu time and store result */

    *timvar = utim2ltim(now);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getutime()

status getutime

(

uint32 *

)

Definition at line 10 of file getutime.c.

References clktime, Date, dot2ip(), dateinfo::dt_boot, dateinfo::dt_bootvalid, fprintf(), getlocalip(), memset(), NetData, ntim2xtim, ntohl, network::ntpserver, OK, stderr, SYSERR, TIMELPORT, TIMEOUT, TIMERPORT, TIMESERVER, TIMETIMEOUT, TRUE, udp_recv(), udp_register(), udp_release(), and udp_send().

Referenced by gettime().

{
    uint32  now;            /* Current time in xinu format  */
    int32   retval;         /* Return value from call   */
    uid32   slot;           /* Slot in UDP table        */
    struct  ntp {           /* Format of an NTP message */
        byte    livn;       /* LI:2 VN:3 and mode:3 fields  */
        byte    strat;      /* Stratum          */
        byte    poll;       /* Poll interval        */
        byte    precision;  /* Precision            */
        uint32  rootdelay;  /* Root delay           */
        uint32  rootdisp;   /* Root dispersion      */
        uint32  refid;      /* Reference identifier     */
        uint32  reftimestamp[2];/* Reference timestamp      */
        uint32  oritimestamp[2];/* Originate timestamp      */
        uint32  rectimestamp[2];/* Receive timestamp        */
        uint32  trntimestamp[2];/* Transmit timestamp       */
    } ntpmsg;

    if (Date.dt_bootvalid) {    /* Return time from local info  */
        *timvar = Date.dt_boot + clktime;
        return OK;
    }

    /* Verify that we have obtained an IP address */

    if (getlocalip() == SYSERR) {
        return SYSERR;
    }

    /* If the DHCP response did not contain an NTP server address   */
    /*  use the default server                  */

    if (NetData.ntpserver == 0) {
        if (dot2ip(TIMESERVER, &NetData.ntpserver) == SYSERR) {
            return SYSERR;
        }
    }

    /* Contact the time server to get the date and time */

    slot = udp_register(NetData.ntpserver, TIMERPORT, TIMELPORT);
    if (slot == SYSERR) {
        fprintf(stderr,"getutime: cannot register a udp port %d\n",
                    TIMERPORT);
        return SYSERR;
    }

    /* Send a request message to the NTP server */

    memset((char *)&ntpmsg, 0x00, sizeof(ntpmsg));
    ntpmsg.livn = 0x1b; /* Client request, protocol version 3 */
    retval = udp_send(slot, (char *)&ntpmsg, sizeof(ntpmsg));
    if (retval == SYSERR) {
        fprintf(stderr,"getutime: cannot send to the server\n");
        udp_release(slot);
        return SYSERR;
    }

    /* Read the response from the NTP server */

    retval = udp_recv(slot, (char *) &ntpmsg, sizeof(ntpmsg),
                             TIMETIMEOUT);
    if ( (retval == SYSERR) || (retval == TIMEOUT) ) {
        udp_release(slot);
        return SYSERR;
    }
    udp_release(slot);

    /* Extract the seconds since Jan 1900 and convert */

    now = ntim2xtim( ntohl(ntpmsg.trntimestamp[0]) );
    Date.dt_boot = now - clktime;
    Date.dt_bootvalid = TRUE;
    *timvar = now;
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gpiocontrol()

devcall gpiocontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 14 of file gpiocontrol.c.

References gpio_csreg::clear_data, gpio_csreg::datain, gpio_csreg::deb_ena, gpio_csreg::deb_time, dentry::dvcsr, dentry::dvminor, gpio_csreg::falling, gpiocblk::gphookfn, GPIO_DEB_SET_TIME, GPIO_INT_ALL_LINES, GPIO_INT_ALL_TRIG, GPIO_INT_FALL_TRIG, GPIO_INT_LINE0_EN, GPIO_INT_LINE1_EN, GPIO_INT_LVL0_TRIG, GPIO_INT_LVL1_TRIG, GPIO_INT_RISE_TRIG, GPIO_INTERRUPT_CTL, GPIO_OUTPUT_DISABLE, GPIO_OUTPUT_ENABLE, GPIO_READ_PIN, GPIO_REG_INT_HANDLER, GPIO_WRITE_PIN, gpiotab, gpio_csreg::irqclear0, gpio_csreg::irqclear1, gpio_csreg::irqset0, gpio_csreg::irqset1, gpio_csreg::level0, gpio_csreg::level1, gpio_csreg::oe, OK, PIN_MASK, gpio_csreg::rising, gpio_csreg::set_data, and SYSERR.

{
    struct gpio_csreg *csrptr; /* Pointer ot the CSR for GPIO   */
    struct gpiocblk *gpioptr;  /* Pointer to the control block  */

    csrptr = (struct gpio_csreg *)(devptr->dvcsr);
    gpioptr = &gpiotab[devptr->dvminor];

    /* Process the request */

    switch (func)
    {

        /* Enable output capability for pins in arg1 */

    case GPIO_OUTPUT_ENABLE:
        csrptr->oe &= (~arg1);
        return (devcall)OK;

        /* Disable output capability for pins in arg1 */

    case GPIO_OUTPUT_DISABLE:
        csrptr->oe |= arg1;
        return (devcall)OK;

        /* Register arg1 function pointer to be called from interrupt */

    case GPIO_REG_INT_HANDLER:
        gpioptr->gphookfn = (gpiointhook)arg1;
        return (devcall)OK;

        /* Configure debounce capability for pins in arg2 */

    case GPIO_DEB_SET_TIME:
        if (arg1 > 0)
        {
            csrptr->deb_time = (arg1 - 1) & 0xFF;
            csrptr->deb_ena |= arg2;
        }
        else
        {
            csrptr->deb_ena &= (~arg2);
        }
        return (devcall)OK;

        /* Configure interrupt capability for pins in arg2 */

    case GPIO_INTERRUPT_CTL:

        /* No lines affected */

        if ((arg1 & GPIO_INT_ALL_LINES) == 0)
        {
            return (devcall)SYSERR;
        }

        /* Disable lines and triggers */

        if ((arg1 & GPIO_INT_ALL_TRIG) == 0)
        {

            /* Flags affect line 0 */

            if ((arg1 & GPIO_INT_LINE0_EN) != 0)
            {
                csrptr->irqclear0 = arg2;
            }

            /* Flags affect line 1 */

            if ((arg1 & GPIO_INT_LINE1_EN) != 0)
            {
                csrptr->irqclear1 = arg2;
            }

            /* Disable all triggers */

            csrptr->rising &= (~arg2);
            csrptr->falling &= (~arg2);
            csrptr->level0 &= (~arg2);
            csrptr->level1 &= (~arg2);

            return (devcall)OK;
        }

        /* Enable lines and triggers */

        if ((arg1 & GPIO_INT_LINE0_EN) != 0)
        {
            csrptr->irqset0 = arg2;
        }
        if ((arg1 & GPIO_INT_LINE1_EN) != 0)
        {
            csrptr->irqset1 = arg2;
        }
        if ((arg1 & GPIO_INT_RISE_TRIG) != 0)
        {
            csrptr->rising |= arg2;
        }
        if ((arg1 & GPIO_INT_FALL_TRIG) != 0)
        {
            csrptr->falling |= arg2;
        }
        if ((arg1 & GPIO_INT_LVL0_TRIG) != 0)
        {
            csrptr->level0 |= arg2;
        }
        if ((arg1 & GPIO_INT_LVL1_TRIG) != 0)
        {
            csrptr->level1 |= arg2;
        }

        return (devcall)OK;

        /* Read input from a single pin arg1 */

    case GPIO_READ_PIN:
        arg2 = csrptr->datain & PIN_MASK(arg1);
        return (arg2 > 0);

        /* Write value arg2 to a single output pin arg1 */

    case GPIO_WRITE_PIN:
        if (arg2)
        {
            csrptr->set_data = PIN_MASK(arg1);
        }
        else
        {
            csrptr->clear_data = PIN_MASK(arg1);
        }
        return (devcall)OK;

    default:
        return (devcall)SYSERR;
    }
}

gpiohandler()

void gpiohandler

(

uint32

)

Definition at line 9 of file gpiohandler.c.

References gpiocblk::gphookfn, GPIO0_BASE, GPIO0_INT_A, GPIO0_INT_B, GPIO1_BASE, GPIO1_INT_A, GPIO1_INT_B, GPIO2_BASE, GPIO2_INT_A, GPIO2_INT_B, GPIO3_BASE, GPIO3_INT_A, GPIO3_INT_B, gpiotab, gpio_csreg::irqstatus0, gpio_csreg::irqstatus1, and NULL.

{
    struct gpio_csreg *csrptr;  /* GPIO CSR pointer     */
    gpiointhook gphookfn;       /* The inerrupt function    */

    /* Clear all interrupts */

    if(xnum == GPIO0_INT_A) {
        csrptr = (struct gpio_csreg *)(GPIO0_BASE);
        gphookfn = gpiotab[0].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus0);
        csrptr->irqstatus0 = 0xFFFFFFFF;
        return;
    }
    if(xnum == GPIO0_INT_B) {
        csrptr = (struct gpio_csreg *)(GPIO0_BASE);
        gphookfn = gpiotab[0].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus1);
        csrptr->irqstatus1 = 0xFFFFFFFF;
        return;
    }

    if(xnum == GPIO1_INT_A) {
        csrptr = (struct gpio_csreg *)(GPIO1_BASE);
        gphookfn = gpiotab[1].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus0);
        csrptr->irqstatus0 = 0xFFFFFFFF;
        return;
    }
    if(xnum == GPIO1_INT_B) {
        csrptr = (struct gpio_csreg *)(GPIO1_BASE);
        gphookfn = gpiotab[1].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus1);
        csrptr->irqstatus1 = 0xFFFFFFFF;
        return;
    }

    if(xnum == GPIO2_INT_A) {
        csrptr = (struct gpio_csreg *)(GPIO2_BASE);
        gphookfn = gpiotab[2].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus0);
        csrptr->irqstatus0 = 0xFFFFFFFF;
        return;
    }
    if(xnum == GPIO2_INT_B) {
        csrptr = (struct gpio_csreg *)(GPIO2_BASE);
        gphookfn = gpiotab[2].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus1);
        csrptr->irqstatus1 = 0xFFFFFFFF;
        return;
    }

    if(xnum == GPIO3_INT_A) {
        csrptr = (struct gpio_csreg *)(GPIO3_BASE);
        gphookfn = gpiotab[3].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus0);
        csrptr->irqstatus0 = 0xFFFFFFFF;
        return;
    }
    if(xnum == GPIO3_INT_B) {
        csrptr = (struct gpio_csreg *)(GPIO3_BASE);
        gphookfn = gpiotab[3].gphookfn;
        if(gphookfn != NULL)
            gphookfn(xnum, csrptr->irqstatus1);
        csrptr->irqstatus1 = 0xFFFFFFFF;
        return;
    }
}

gpioinit()

devcall gpioinit

(

struct dentry *

)

Definition at line 11 of file gpioinit.c.

References gpio_csreg::clear_data, gpio_csreg::deb_ena, dentry::dvcsr, dentry::dvintr, dentry::dvirq, dentry::dvminor, gpio_csreg::falling, gpiocblk::gphookfn, GPIO1_BASE, GPIO2_BASE, GPIO3_BASE, gpiotab, gpio_csreg::irqclear0, gpio_csreg::irqclear1, gpio_csreg::irqstatus0, gpio_csreg::irqstatus1, gpio_csreg::irqwaken0, gpio_csreg::irqwaken1, gpio_csreg::level0, gpio_csreg::level1, NULL, gpio_csreg::oe, OK, PRCM_FCLK_BIT, PRCM_FCLK_GPIO1, PRCM_FCLK_GPIO2, PRCM_FCLK_GPIO3, gpio_csreg::rising, set_evec(), and gpio_csreg::sysconfig.

{
    struct gpio_csreg *csrptr;  /* Pointer ot GPIO CSRs     */
    struct gpiocblk *gpioptr;   /* Pointer ot GPIO Control block*/
    uint32 *fclkreg;        /* FCLK Register for debounce   */

    csrptr = (struct gpio_csreg *)(devptr->dvcsr);
    gpioptr = &gpiotab[devptr->dvminor];

    /* Get the FCLK Register for the corresponding GPIO module */

    if(csrptr == GPIO1_BASE)    {
        fclkreg = PRCM_FCLK_GPIO1;
    } else if(csrptr == GPIO2_BASE) {
        fclkreg = PRCM_FCLK_GPIO2;
    } else if(csrptr == GPIO3_BASE) {
        fclkreg = PRCM_FCLK_GPIO3;
    } else {
        /* GPIO0 FCLK is ON by default */
        fclkreg = NULL;
    }

    /* Initialize register values */

    csrptr->sysconfig = 0x0;
    
    /* Disable output for all pins */

    csrptr->oe = 0xFFFFFFFF;

    /* Clear all pending interrupts */

    csrptr->irqstatus0 = 0xFFFFFFFF;
    csrptr->irqstatus1 = 0xFFFFFFFF;

    /* Disable all interrupts */

    csrptr->irqclear0 = 0xFFFFFFFF;
    csrptr->irqclear1 = 0xFFFFFFFF;
    
    /* Clear all pins */

    csrptr->clear_data = 0xFFFFFFFF;
    
    /* Clear wakeup settings */

    csrptr->irqwaken0 = 0x0;
    csrptr->irqwaken1 = 0x0;

    /* Clear all interrupt trigger settings */

    csrptr->rising  = 0x0;
    csrptr->falling = 0x0;
    csrptr->level0  = 0x0;
    csrptr->level1  = 0x0;

    /* Disable debouncing */

    csrptr->deb_ena = 0x0;

    /* Setup debouncing clock */

    if(fclkreg != NULL) {
        *fclkreg |= PRCM_FCLK_BIT;
    }

    /* Interrupt A */

    set_evec( devptr->dvirq, (uint32)devptr->dvintr );

    /* Interrupt B is the next interrupt line */

    set_evec( (devptr->dvirq)+1, (uint32)devptr->dvintr );

    gpioptr->gphookfn = NULL;

    return OK;
}

Here is the call graph for this function:

gpioread()

devcall gpioread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file gpioread.c.

References gpio_csreg::datain, dentry::dvcsr, and OK.

{
    struct gpio_csreg *csrptr;  /* Pointer to GPIO CSRs     */

    /* Obtain the address of the CSR from the device switch table   */

    csrptr = (struct gpio_csreg *)(devptr->dvcsr);
    
    /* Access the GPIO pins, use the mask to select a subset, and   */
    /*  store the result in the specified buffer        */

    *((uint32 *)value) = csrptr->datain & pinmask;

    return OK;
}

gpioselect()

devcall gpioselect	(	uint32	,
		uint32	,
		uint32
	)

Definition at line 8 of file gpioselect.c.

References OK, and PINMUXBASE.

{
    volatile uint32* confreg; /* Pin configuration register */

    /* Pick up the pin configuration register address */

    confreg = &(((uint32*)PINMUXBASE)[pinreg]);

    /* Apply the specified settings to the pin */

    *confreg = pinmode|pinsettings;

    return OK;
}

gpiowrite()

devcall gpiowrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file gpiowrite.c.

References gpio_csreg::clear_data, dentry::dvcsr, OK, and gpio_csreg::set_data.

{
    struct gpio_csreg *csrptr;  /* Pointer to GPIO CSRs     */
    uint32 val;         /* Value to be written      */

    csrptr = (struct gpio_csreg *)(devptr->dvcsr);
    val = * (uint32 *)value;

    /* Set bits that should become one */

    csrptr->set_data = pinmask & val;   

    /* Clear bits that should become zero */

    csrptr->clear_data = pinmask & ~val;

    return OK;
}

halt()

void halt

(

void

)

システムを停止させる（intr.Sに定義がある）

Referenced by xdone().

Here is the caller graph for this function:

icmp_cksum()

uint16 icmp_cksum	(	char *	,
		int32
	)

Definition at line 359 of file icmp.c.

References ntohs.

Referenced by ip_in(), ip_out(), and pdumph().

{
    int32   scount;         /* Number of 16-bit values buf  */
    uint32  cksum;          /* Checksum being computed  */
    uint16  *sptr;          /* Walks along buffer       */
    uint16  word;           /* One 16-bit word      */

    /* Walk along buffer and sum all 16-bit values */

    scount = buflen >> 1;       /* Divide by 2 and round down   */
    sptr = (uint16 *)buf;
    cksum = 0;
    for (; scount > 0; scount--) {
        word = (uint32) *sptr++;
        cksum += ntohs(word);
    }

    /* If buffer lenght is odd, add last byte */

    if ( (buflen & 0x01) !=0 ) {
        cksum += 0xFFFF & ((uint32) (*((byte *) sptr) << 8));
    }
    cksum += (cksum >> 16);
        cksum = 0xffff & ~cksum;
        return (uint16) (0xffff & cksum);
}

Here is the caller graph for this function:

icmp_hton()

void icmp_hton

(

struct netpacket *

)

Definition at line 394 of file icmp.c.

References htons, netpacket::net_iccksum, netpacket::net_icident, and netpacket::net_icseq.

Referenced by ip_out().

{
    pktptr->net_iccksum = htons(pktptr->net_iccksum);
    pktptr->net_icident = htons(pktptr->net_icident);
    pktptr->net_icseq = htons(pktptr->net_icseq);
}

Here is the caller graph for this function:

icmp_in()

void icmp_in

(

struct netpacket *

)

Definition at line 26 of file icmp.c.

References disable(), freebuf(), icmpentry::iccount, ICMP_ECHOREPLY, ICMP_ECHOREQST, ICMP_FREE, ICMP_HDR_LEN, icmp_mkpkt(), ICMP_QSIZ, ICMP_RECV, ICMP_SLOTS, ICMP_USED, icmptab, icmpentry::icpid, icmpentry::icqueue, icmpentry::icremip, icmpentry::icstate, icmpentry::ictail, ip_enqueue(), IP_HDR_LEN, netpacket::net_icdata, netpacket::net_icident, netpacket::net_icseq, netpacket::net_ictype, netpacket::net_iplen, netpacket::net_ipsrc, OK, restore(), send(), and SYSERR.

Referenced by ip_local().

{
    intmask mask;           /* Saved interrupt mask     */
    int32   slot;           /* Slot in ICMP table       */
    struct  icmpentry *icmptr;  /* Pointer to icmptab entry */
    struct  netpacket *replypkt;    /* Pointer to reply packet  */

    mask = disable();

    /* Discard all ICMP messages except ping */

    if ( (pkt->net_ictype != ICMP_ECHOREPLY) &&
         (pkt->net_ictype != ICMP_ECHOREQST)  ) {
        freebuf((char *)pkt);
        restore(mask);
        return;
    }

    /* Handle Echo Request message */

    if (pkt->net_ictype == ICMP_ECHOREQST) {

        /* Send echo reply message */

        replypkt = icmp_mkpkt(pkt->net_ipsrc,ICMP_ECHOREPLY,
                pkt->net_icident, pkt->net_icseq,
                (char *) &pkt->net_icdata,
                pkt->net_iplen-IP_HDR_LEN-ICMP_HDR_LEN);
        if ((int32)replypkt != SYSERR) {
            ip_enqueue(replypkt);
        }
        freebuf((char *)pkt);
        restore(mask);
        return;
    }

    /* Handle Echo Reply message: verify that ID is valid */

    slot = pkt->net_icident;
    if ( (slot < 0) || (slot >= ICMP_SLOTS) ) {
        freebuf((char *)pkt);
        restore(mask);
        return;
    }

    /* Verify that slot in table is in use and IP address   */
    /*    in incomming packet matches IP address in table   */

    icmptr = &icmptab[slot];
    if ( (icmptr->icstate == ICMP_FREE) ||
         (pkt->net_ipsrc != icmptr->icremip) ) {
        freebuf((char *)pkt);   /* discard packet */
        restore(mask);
        return;
    }

    /* Add packet to queue */

    icmptr->iccount++;
    icmptr->icqueue[icmptr->ictail++] = pkt;
    if (icmptr->ictail >= ICMP_QSIZ) {
        icmptr->ictail = 0;
    }
    if (icmptr->icstate == ICMP_RECV) {
        icmptr->icstate = ICMP_USED;
        send (icmptr->icpid, OK);
    }
    restore(mask);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_init()

void icmp_init

(

void

)

Definition at line 12 of file icmp.c.

References ICMP_FREE, ICMP_SLOTS, icmptab, and icmpentry::icstate.

Referenced by net_init().

                        {

    int32   i;          /* table index */

    for(i=0; i<ICMP_SLOTS; i++) {
        icmptab[i].icstate = ICMP_FREE;
    }
    return;
}

Here is the caller graph for this function:

icmp_mkpkt()

struct netpacket* icmp_mkpkt	(	uint32	,
		uint16	,
		uint16	,
		uint16	,
		char *	,
		int32
	)

Definition at line 259 of file icmp.c.

References ETH_ADDR_LEN, network::ethucast, getbuf(), ICMP_HDR_LEN, IP_HDR_LEN, IP_ICMP, network::ipucast, memcpy(), netpacket::net_ethsrc, netpacket::net_ethtype, netpacket::net_iccksum, netpacket::net_iccode, netpacket::net_icdata, netpacket::net_icident, netpacket::net_icseq, netpacket::net_ictype, netpacket::net_ipcksum, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipsrc, netpacket::net_iptos, netpacket::net_ipttl, netpacket::net_ipvh, netbufpool, NetData, panic(), and SYSERR.

Referenced by icmp_in(), and icmp_send().

{
    struct  netpacket *pkt;     /* pointer to packet buffer */
    static  uint32  ipident=32767;  /* IP ident field       */

    /* Allocate packet */

    pkt = (struct netpacket *)getbuf(netbufpool);

    if ((int32)pkt == SYSERR) {
        panic("icmp_mkpkt: cannot get a network buffer\n");
    }

    /* Create icmp packet in pkt */

    memcpy(pkt->net_ethsrc, NetData.ethucast, ETH_ADDR_LEN);
        pkt->net_ethtype = 0x800;   /* Type is IP */
    pkt->net_ipvh = 0x45;       /* IP version and hdr length    */
    pkt->net_iptos = 0x00;      /* Type of service      */
    pkt->net_iplen= IP_HDR_LEN+ICMP_HDR_LEN+len;/* datagram length  */
    pkt->net_ipid = ipident++;  /* Datagram gets next IDENT */
    pkt->net_ipfrag = 0x0000;   /* IP flags & fragment offset   */
    pkt->net_ipttl = 0xff;      /* IP time-to-live      */
    pkt->net_ipproto = IP_ICMP; /* Datagram carries icmp    */
    pkt->net_ipcksum = 0x0000;  /* Initial checksum     */
    pkt->net_ipsrc = NetData.ipucast; /* IP source address  */
    pkt->net_ipdst = remip;     /* IP destination address   */


    pkt->net_ictype = type;     /* ICMP type            */
    pkt->net_iccode = 0;        /* Code is zero for ping    */
    pkt->net_iccksum = 0x0000;  /* Temporarily zero the cksum   */
    pkt->net_icident = ident;   /* ICMP identification      */
    pkt->net_icseq = seq;       /* ICMP sequence number     */
    memcpy(pkt->net_icdata, buf, len);

    /* Return packet to caller */

    return pkt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_ntoh()

void icmp_ntoh

(

struct netpacket *

)

Definition at line 408 of file icmp.c.

References netpacket::net_iccksum, netpacket::net_icident, netpacket::net_icseq, and ntohs.

Referenced by ip_in().

{
    pktptr->net_iccksum = ntohs(pktptr->net_iccksum);
    pktptr->net_icident = ntohs(pktptr->net_icident);
    pktptr->net_icseq = ntohs(pktptr->net_icseq);
}

Here is the caller graph for this function:

icmp_recv()

int32 icmp_recv	(	int32	,
		char *	,
		int32	,
		uint32
	)

Definition at line 150 of file icmp.c.

References currpid, disable(), freebuf(), icmpentry::iccount, icmpentry::ichead, ICMP_HDR_LEN, ICMP_RECV, ICMP_SLOTS, ICMP_USED, icmptab, icmpentry::icpid, icmpentry::icqueue, icmpentry::icstate, IP_HDR_LEN, netpacket::net_icdata, netpacket::net_iplen, OK, recvclr(), recvtime(), restore(), SYSERR, and TIMEOUT.

Referenced by xsh_ping().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  icmpentry *icmptr;  /* Pointer to icmptab entry */
    umsg32  msg;            /* Message from recvtime()  */
    struct  netpacket *pkt;     /* Pointer to packet being read */
    int32   datalen;        /* Length of ICMP data area */
    char    *icdataptr;     /* Pointer to icmp data     */
    int32   i;          /* Counter for data copy    */

    /* Verify that the ID is valid */

    if ( (icmpid < 0) || (icmpid >= ICMP_SLOTS) ) {
        return SYSERR;
    }

    /* Insure only one process touches the table at a time */

    mask = disable();

    /* Verify that the ID has been registered and is idle */

    icmptr = &icmptab[icmpid];
    if (icmptr->icstate != ICMP_USED) {
        restore(mask);
        return SYSERR;
    }

    if (icmptr->iccount == 0) {     /* No packet is waiting */
        icmptr->icstate = ICMP_RECV;
        icmptr->icpid = currpid;
        msg = recvclr();
        msg = recvtime(timeout);    /* Wait for a reply */
        icmptr->icstate = ICMP_USED;
        if (msg == TIMEOUT) {
            restore(mask);
            return TIMEOUT;
        } else if (msg != OK) {
            restore(mask);
            return SYSERR;
        }
    }

    /* Packet has arrived -- dequeue it */

    pkt = icmptr->icqueue[icmptr->ichead++];
    if (icmptr->ichead >= ICMP_SLOTS) {
        icmptr->ichead = 0;
    }
    icmptr->iccount--;

    /* Copy data from ICMP message into caller's buffer */

    datalen = pkt->net_iplen - IP_HDR_LEN - ICMP_HDR_LEN;
    icdataptr = (char *) &pkt->net_icdata;
    for (i=0; i<datalen; i++) {
        if (i >= len) {
            break;
        }
        *buff++ = *icdataptr++;
    }
    freebuf((char *)pkt);
    restore(mask);
    return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_register()

int32 icmp_register

(

uint32

)

Definition at line 103 of file icmp.c.

References disable(), icmpentry::iccount, icmpentry::ichead, ICMP_FREE, ICMP_SLOTS, ICMP_USED, icmptab, icmpentry::icpid, icmpentry::icremip, icmpentry::icstate, icmpentry::ictail, restore(), and SYSERR.

Referenced by xsh_ping().

{
    intmask mask;           /* Saved interrupt mask     */
    int32   i;          /* Index into icmptab       */
    int32   freeslot;       /* Index of slot to use     */
    struct  icmpentry *icmptr;  /* Pointer to icmptab entry */

    mask = disable();

    /* Find a free slot in the table */

    freeslot = -1;
    for (i=0; i<ICMP_SLOTS; i++) {
        icmptr = &icmptab[i];
        if (icmptr->icstate == ICMP_FREE) {
            if (freeslot == -1) {
                freeslot = i;
            }
        } else if (icmptr->icremip == remip) {
            restore(mask);
            return SYSERR;  /* Already registered */
        }
    }
    if (freeslot == -1) {  /* No free entries in table */

        restore(mask);
        return SYSERR;
    }

    /* Fill in table entry */

    icmptr = &icmptab[freeslot];
    icmptr->icstate = ICMP_USED;
    icmptr->icremip = remip;
    icmptr->iccount = 0;
    icmptr->ichead = icmptr->ictail = 0;
    icmptr->icpid = -1;
    restore(mask);
    return freeslot;
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_release()

status icmp_release

(

int32

)

Definition at line 312 of file icmp.c.

References DEFER_START, DEFER_STOP, disable(), freebuf(), icmpentry::iccount, icmpentry::ichead, ICMP_FREE, ICMP_SLOTS, ICMP_USED, icmptab, icmpentry::icqueue, icmpentry::icstate, OK, resched_cntl(), restore(), and SYSERR.

Referenced by xsh_ping().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  icmpentry *icmptr;  /* Pointer to icmptab entry */
    struct  netpacket *pkt;     /* Pointer to packet        */

    mask = disable();

    /* Check arg and insure entry in table is in use */

    if ( (icmpid < 0) || (icmpid >= ICMP_SLOTS) ) {
        restore(mask);
        return SYSERR;
    }
    icmptr = &icmptab[icmpid];
    if (icmptr->icstate != ICMP_USED) {
        restore(mask);
        return SYSERR;
    }

    /* Remove each packet from the queue and free the buffer */

    resched_cntl(DEFER_START);
    while (icmptr->iccount > 0) {
        pkt = icmptr->icqueue[icmptr->ichead++];
        if (icmptr->ichead >= ICMP_SLOTS) {
            icmptr->ichead = 0;

        }
        freebuf((char *)pkt);
        icmptr->iccount--;
    }

    /* Mark the entry free */

    icmptr->icstate = ICMP_FREE;
    resched_cntl(DEFER_STOP);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

icmp_send()

status icmp_send	(	uint32	,
		uint16	,
		uint16	,
		uint16	,
		char *	,
		int32
	)

Definition at line 225 of file icmp.c.

References disable(), icmp_mkpkt(), ip_send(), restore(), and SYSERR.

Referenced by xsh_ping().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  netpacket *pkt;     /* Packet returned by icmp_mkpkt*/
    int32   retval;         /* Value returned by ip_send    */

    mask = disable();

    /* Form a packet to send */

    pkt = icmp_mkpkt(remip, type, ident, seq, buf, len);
    if ((int32)pkt == SYSERR) {
        return SYSERR;
    }

    /* Send the packet */

    retval = ip_send(pkt);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

inb()

int32 inb

(

int32

)

init()

syscall init

(

did32

descrp

)

デバイスとデバイスドライバを初期化する。

Step1. 割り込みを禁止する。
Step2. デバイスディスクリプタが不正値の場合は、割り込み状態を復元し、処理を終了する。
Step3. デバイス固有の初期化処理を実施する。
Step4. 割り込み許可状態に復元する。

Parameters

[in]

descrp

デバイスディスクリプタ

Returns

成功時はデバイスに応じた返り値、デバイスディスクリプタが不正値の場合はSYSERRを返す。

Definition at line 17 of file init.c.

References devtab, disable(), dentry::dvinit, isbaddev, restore(), and SYSERR.

Referenced by sysinit().

{
    intmask mask;          /* Saved interrupt mask      */
    struct dentry *devptr; /* Entry in device switch table  */
    int32 retval;          /* Value to return to caller */

    mask = disable();
    if (isbaddev(descrp))
    {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *)&devtab[descrp];
    retval = (*devptr->dvinit)(devptr);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

initevec()

int32 initevec

(

void

)

Referenced by sysinit().

Here is the caller graph for this function:

initintc()

int32 initintc

(

void

)

Definition at line 18 of file evec.c.

References INTC_SYSCONFIG_SOFTRESET, INTC_SYSSTATUS_RESETDONE, OK, intc_csreg::sysconfig, and intc_csreg::sysstatus.

Referenced by platinit().

{
    struct  intc_csreg *csrptr = (struct intc_csreg *)0x48200000;

    /* Reset the interrupt controller */

    csrptr->sysconfig |= (INTC_SYSCONFIG_SOFTRESET);

    /* Wait until reset is complete */

    while((csrptr->sysstatus & INTC_SYSSTATUS_RESETDONE) == 0);

    return OK;
}

Here is the caller graph for this function:

inl()

int32 inl

(

int32

)

insert()

status insert	(	pid32	pid,
		qid16	q,
		int32	key
	)

優先度に基づいて、キューにプロセスを挿入する。

優先度の降順に並べたキューに対して、以下を行う。 Step1. キューを先頭から走査（whileループ部）
Step2. 挿入しようとしているプロセスIDの優先度より低い優先度を持つプロセスを探す。
Step3.「より低優先度なプロセスノード（Step2で見つけたノード）」と「その前にあるノード」との間に、 挿入したいプロセスを配置する。 なお、キューの末尾は有効な最小キーを下回るため、ループは必ず停止する。

Parameters

[in]	pid	挿入するプロセスID
[in]	q	使用するキューID
[in]	key	挿入するプロセスの優先度（キー）

Returns

成功時はOK、キューIDもしくはプロセスIDが不正の場合はSYSERRを返す。

Definition at line 20 of file insert.c.

References firstid, isbadpid, isbadqid, OK, qentry::qkey, qentry::qnext, qentry::qprev, queuetab, and SYSERR.

Referenced by ready(), and resched().

{
    qid16 curr; /* Runs through items in a queue*/
    qid16 prev; /* Holds previous node index    */

    if (isbadqid(q) || isbadpid(pid))
    {
        return SYSERR;
    }

    curr = firstid(q);
    while (queuetab[curr].qkey >= key)
    {
        curr = queuetab[curr].qnext;
    }

    /* Insert process between curr node and previous node */

    prev = queuetab[curr].qprev; /* Get index of previous node  */
    queuetab[pid].qnext = curr;
    queuetab[pid].qprev = prev;
    queuetab[pid].qkey = key;
    queuetab[prev].qnext = pid;
    queuetab[curr].qprev = pid;
    return OK;
}

Here is the caller graph for this function:

insertd()

status insertd	(	pid32	,
		qid16	,
		int32
	)

Definition at line 9 of file insertd.c.

References isbadpid, isbadqid, OK, qentry::qkey, qentry::qnext, qentry::qprev, queuehead, queuetab, queuetail, and SYSERR.

Referenced by recvtime(), and sleepms().

{
    int32   next;           /* Runs through the delta list  */
    int32   prev;           /* Follows next through the list*/

    if (isbadqid(q) || isbadpid(pid)) {
        return SYSERR;
    }

    prev = queuehead(q);
    next = queuetab[queuehead(q)].qnext;
    while ((next != queuetail(q)) && (queuetab[next].qkey <= key)) {
        key -= queuetab[next].qkey;
        prev = next;
        next = queuetab[next].qnext;
    }

    /* Insert new node between prev and next nodes */

    queuetab[pid].qnext = next;
    queuetab[pid].qprev = prev;
    queuetab[pid].qkey = key;
    queuetab[prev].qnext = pid;
    queuetab[next].qprev = pid;
    if (next != queuetail(q)) {
        queuetab[next].qkey -= key;
    }

    return OK;
}

Here is the caller graph for this function:

insw()

int32 insw	(	int32	,
		int32	,
		int32
	)

inw()

int32 inw

(

int32

)

ioerr()

devcall ioerr

(

void

)

ステータスとしてエラーを返す（デバイステーブルの"error"エントリに対して使用する）。

Returns

SYSERRを返す。

Definition at line 12 of file ioerr.c.

{
    return SYSERR;
}

ionull()

devcall ionull

(

void

)

何もしない（デバイステーブルの"don't care"エントリに使用する）

Returns

必ずOKを返す。

Definition at line 11 of file ionull.c.

{
    return OK;
}

ip_enqueue()

status ip_enqueue

(

struct netpacket *

)

Definition at line 439 of file ip.c.

References disable(), freebuf(), IP_OQSIZ, ipoqueue, iqentry::iqbuf, iqentry::iqsem, iqentry::iqtail, kprintf(), OK, restore(), semcount(), signal(), and SYSERR.

Referenced by icmp_in().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  iqentry *iptr;      /* Ptr. to network output queue */

    /* Ensure only one process accesses output queue at a time */

    mask = disable();

    /* Enqueue packet on network output queue */

    iptr = &ipoqueue;
    if (semcount(iptr->iqsem) >= IP_OQSIZ) {
        kprintf("ipout: output queue overflow\n");
        freebuf((char *)pktptr);
        restore(mask);
        return SYSERR;
    }
    iptr->iqbuf[iptr->iqtail++] = pktptr;
    if (iptr->iqtail >= IP_OQSIZ) {
        iptr->iqtail = 0;
    }
    signal(iptr->iqsem);
    restore(mask);
    return OK;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_hton()

void ip_hton

(

struct netpacket *

)

Definition at line 338 of file ip.c.

References htonl, htons, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, and netpacket::net_ipsrc.

Referenced by ip_out().

{
    pktptr->net_iplen = htons(pktptr->net_iplen);
    pktptr->net_ipid = htons(pktptr->net_ipid);
    pktptr->net_ipfrag = htons(pktptr->net_ipfrag);
    pktptr->net_ipsrc = htonl(pktptr->net_ipsrc);
    pktptr->net_ipdst = htonl(pktptr->net_ipdst);
}

Here is the caller graph for this function:

ip_in()

void ip_in

(

struct netpacket *

)

Definition at line 13 of file ip.c.

References freebuf(), icmp_cksum(), icmp_ntoh(), IP_BCAST, IP_HDR_LEN, IP_ICMP, ip_local(), ip_ntoh(), IP_UDP, network::ipbcast, ipcksum(), network::ipucast, network::ipvalid, kprintf(), netpacket::net_ictype, netpacket::net_ipdst, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipvh, NetData, and udp_ntoh().

Referenced by netin().

{
    int32   icmplen;        /* Length of ICMP message   */

    /* Verify checksum */

    if (ipcksum(pktptr) != 0) {
        kprintf("IP header checksum failed\n\r");
        freebuf((char *)pktptr);
        return;
    }

    /* Convert IP header fields to host order */

    ip_ntoh(pktptr);

    /* Ensure version and length are valid */

    if (pktptr->net_ipvh != 0x45) {
        kprintf("IP version failed\n\r");
        freebuf((char *)pktptr);
        return;
    }

    /* Verify encapsulated prototcol checksums and then convert */
    /*  the encapsulated headers to host byte order     */

    switch (pktptr->net_ipproto) {

        case IP_UDP:
        /* Skipping UDP checksum for now */
        udp_ntoh(pktptr);
        break;

        case IP_ICMP:
        icmplen = pktptr->net_iplen - IP_HDR_LEN;
        if (icmp_cksum((char *)&pktptr->net_ictype,icmplen) != 0){
            freebuf((char *)pktptr);
            return;
        }
        icmp_ntoh(pktptr);
        break;

        default:
        break;
    }

    /* Deliver 255.255.255.255 to local stack */

    if (pktptr->net_ipdst == IP_BCAST) {
        ip_local(pktptr);
        return;
    }

    /* If we do not yet have a valid address, accept UDP packets    */
    /*  (to get DHCP replies) and drop others           */

    if (!NetData.ipvalid) {
        if (pktptr->net_ipproto == IP_UDP) {
            ip_local(pktptr);
            return;
        } else {
            freebuf((char *)pktptr);
            return;
        }
    }

    /* If packet is destined for us, accept it; otherwise, drop it  */

    if ( (pktptr->net_ipdst == NetData.ipucast) ||
         (pktptr->net_ipdst == NetData.ipbcast) ||
         (pktptr->net_ipdst == IP_BCAST)  ) {
        ip_local(pktptr);
        return;
    } else {

        /* Drop the packet */
        freebuf((char *)pktptr);
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_local()

void ip_local

(

struct netpacket *

)

Definition at line 186 of file ip.c.

References freebuf(), icmp_in(), IP_ICMP, IP_UDP, netpacket::net_ipproto, and udp_in().

Referenced by ip_in(), ip_send(), and ipout().

{
    /* Use datagram contents to determine how to process */

    switch (pktptr->net_ipproto) {

        case IP_UDP:
        udp_in(pktptr);
        return;

        case IP_ICMP:
        icmp_in(pktptr);
        return;

        default:
        freebuf((char *)pktptr);
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_ntoh()

void ip_ntoh

(

struct netpacket *

)

Definition at line 323 of file ip.c.

References netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipsrc, ntohl, and ntohs.

Referenced by ip_in().

{
    pktptr->net_iplen = ntohs(pktptr->net_iplen);
    pktptr->net_ipid = ntohs(pktptr->net_ipid);
    pktptr->net_ipfrag = ntohs(pktptr->net_ipfrag);
    pktptr->net_ipsrc = ntohl(pktptr->net_ipsrc);
    pktptr->net_ipdst = ntohl(pktptr->net_ipdst);
}

Here is the caller graph for this function:

ip_out()

status ip_out

(

struct netpacket *

)

Definition at line 213 of file ip.c.

References ETH_HDR_LEN, eth_hton(), ETHER0, freebuf(), htons, icmp_cksum(), icmp_hton(), IP_HDR_LEN, ip_hton(), IP_ICMP, IP_UDP, ipcksum(), netpacket::net_iccksum, netpacket::net_ictype, netpacket::net_ipcksum, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_udpcksum, OK, SYSERR, udp_hton(), and write().

Referenced by ip_send(), and ipout().

{
    uint16  cksum;          /* Checksum in host byte order  */
    int32   len;            /* Length of ICMP message   */  
    int32   pktlen;         /* Length of entire packet  */
    int32   retval;         /* Value returned by write  */

    /* Compute total packet length */

    pktlen = pktptr->net_iplen + ETH_HDR_LEN;

    /* Convert encapsulated protocol to network byte order */

    switch (pktptr->net_ipproto) {

        case IP_UDP:

            pktptr->net_udpcksum = 0;
            udp_hton(pktptr);

            /* ...skipping UDP checksum computation */

            break;

        case IP_ICMP:
            icmp_hton(pktptr);

            /* Compute ICMP checksum */

            pktptr->net_iccksum = 0;
            len = pktptr->net_iplen-IP_HDR_LEN;
            cksum = icmp_cksum((char *)&pktptr->net_ictype,
                                len);
            pktptr->net_iccksum = 0xffff & htons(cksum);
            break;

        default:
            break;
    }

    /* Convert IP fields to network byte order */

    ip_hton(pktptr);

    /* Compute IP header checksum */

    pktptr->net_ipcksum = 0;
    cksum = ipcksum(pktptr);
    pktptr->net_ipcksum = 0xffff & htons(cksum);

    /* Convert Ethernet fields to network byte order */

    eth_hton(pktptr);

    /* Send packet over the Ethernet */

    retval = write(ETHER0, (char*)pktptr, pktlen);
    freebuf((char *)pktptr);

    if (retval == SYSERR) {
        return SYSERR;
    } else {
        return OK;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_route()

int32 ip_route

(

uint32

)

ip_send()

status ip_send

(

struct netpacket *

)

Definition at line 103 of file ip.c.

References arp_resolve(), disable(), ETH_ADDR_LEN, network::ethbcast, freebuf(), IP_BCAST, ip_local(), ip_out(), network::ipbcast, network::ipmask, network::ipprefix, network::iprouter, network::ipucast, memcpy(), netpacket::net_ethdst, netpacket::net_ipdst, NetData, OK, restore(), and SYSERR.

Referenced by icmp_send(), udp_send(), and udp_sendto().

{
    intmask mask;           /* Saved interrupt mask     */
    uint32  dest;           /* Destination of the datagram  */
    int32   retval;         /* Return value from functions  */
    uint32  nxthop;         /* Next-hop address     */

    mask = disable();

    /* Pick up the IP destination address from the packet */

    dest = pktptr->net_ipdst;

    /* Loop back to local stack if destination 127.0.0.0/8 */

    if ((dest&0xff000000) == 0x7f000000) {
        ip_local(pktptr);
        restore(mask);
        return OK;
    }

    /* Loop back if the destination matches our IP unicast address  */

    if (dest == NetData.ipucast) {
        ip_local(pktptr);
        restore(mask);
        return OK;
    }

    /* Broadcast if destination is 255.255.255.255 */

    if ( (dest == IP_BCAST) ||
         (dest == NetData.ipbcast) ) {
        memcpy(pktptr->net_ethdst, NetData.ethbcast,
                            ETH_ADDR_LEN);
        retval = ip_out(pktptr);
        restore(mask);
        return retval;
    }

    /* If destination is on the local network, next hop is the  */
    /*  destination; otherwise, next hop is default router  */


    if ( (dest & NetData.ipmask) == NetData.ipprefix) {

        /* Next hop is the destination itself */
        nxthop = dest;

    } else {

        /* Next hop is default router on the network */
        nxthop = NetData.iprouter;

    }

    if (nxthop == 0) {  /* Dest. invalid or no default route    */
        freebuf((char *)pktptr);
        return SYSERR;
    }

    /* Resolve the next-hop address to get a MAC address */

    retval = arp_resolve(nxthop, pktptr->net_ethdst);
    if (retval != OK) {
        freebuf((char *)pktptr);
        return SYSERR;
    }

    /* Send the packet */

    retval = ip_out(pktptr);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ipcksum()

uint16 ipcksum

(

struct netpacket *

)

Definition at line 286 of file ip.c.

References htons, and netpacket::net_ipvh.

Referenced by ip_in(), ip_out(), pdump(), and pdumph().

{
    uint16  *hptr;          /* Ptr to 16-bit header values  */
    int32   i;          /* Counts 16-bit values in hdr  */
    uint16  word;           /* One 16-bit word      */
    uint32  cksum;          /* Computed value of checksum   */

    hptr= (uint16 *) &pkt->net_ipvh;

    /* Sum 16-bit words in the packet */

    cksum = 0;
    for (i=0; i<10; i++) {
        word = *hptr++;
        cksum += (uint32) htons(word);
    }

    /* Add in carry, and take the ones-complement */

    cksum += (cksum >> 16);
    cksum = 0xffff & ~cksum;

    /* Use all-1s for zero */

    if (cksum == 0xffff) {
        cksum = 0;
    }
    return (uint16) (0xffff & cksum);
}

Here is the caller graph for this function:

ipout()

process ipout

(

void

)

Definition at line 356 of file ip.c.

References arp_resolve(), ETH_ADDR_LEN, network::ethucast, freebuf(), IP_BCAST, ip_local(), IP_OQSIZ, ip_out(), network::ipbcast, network::ipmask, ipoqueue, network::ipprefix, network::iprouter, network::ipucast, iqentry::iqbuf, iqentry::iqhead, iqentry::iqsem, kprintf(), memcpy(), netpacket::net_ethdst, netpacket::net_ethsrc, netpacket::net_ipdst, NetData, OK, and wait().

Referenced by net_init().

{
    struct  netpacket *pktptr;  /* Pointer to next the packet   */
    struct  iqentry   *ipqptr;  /* Pointer to IP output queue   */
    uint32  destip;         /* Destination IP address   */
    uint32  nxthop;         /* Next hop IP address      */
    int32   retval;         /* Value returned by functions  */

    ipqptr = &ipoqueue;

    while(1) {

        /* Obtain next packet from the IP output queue */

        wait(ipqptr->iqsem);
        pktptr = ipqptr->iqbuf[ipqptr->iqhead++];
        if (ipqptr->iqhead >= IP_OQSIZ) {
            ipqptr->iqhead= 0;
        }

        /* Fill in the MAC source address */

        memcpy(pktptr->net_ethsrc, NetData.ethucast, ETH_ADDR_LEN);

        /* Extract destination address from packet */

        destip = pktptr->net_ipdst;


        /* Sanity check: packets sent to ipout should *not* */
        /*  contain a broadcast address.            */

        if ((destip == IP_BCAST)||(destip == NetData.ipbcast)) {
            kprintf("ipout: encountered a broadcast\n");
            freebuf((char *)pktptr);
            continue;
        }

        /* Check whether destination is the local computer */

        if (destip == NetData.ipucast) {
            ip_local(pktptr);
            continue;
        }

        /* Check whether destination is on the local net */

        if ( (destip & NetData.ipmask) == NetData.ipprefix) {

            /* Next hop is the destination itself */

            nxthop = destip;
        } else {

            /* Next hop is default router on the network */

            nxthop = NetData.iprouter;
        }

        if (nxthop == 0) {  /* Dest. invalid or no default route*/
            freebuf((char *)pktptr);
            continue;
        }

        /* Use ARP to resolve next-hop address */

        retval = arp_resolve(nxthop, pktptr->net_ethdst);
        if (retval != OK) {
            freebuf((char *)pktptr);
            continue;
        }

        /* Use ipout to Convert byte order and send */

        ip_out(pktptr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kill()

syscall kill

(

pid32

pid

)

指定のプロセスを終了させ、システムから終了させたプロセス情報を取り除く。

Step1. 割り込み禁止状態に移行する。
Step2. プロセスが以下の状態であれば、割り込み許可状態に復元してから処理を終了する。
　・引数のPIDが不正
　・引数のPIDがNULLプロセス
　・引数のPIDで指定されるプロセスがFREE状態
Step3. 現在アクティブのプロセス数が1以下（NULLプロセスのみ動作中）の場合、
　　　 全ユーザプロセスが終了したため、システム終了メッセージを表示する。
Step4. 親プロセスに終了させるプロセスのIDを通知する。
Step5. XINU Shell用に確保したSTDIN(標準入力)／STDOUT(標準出力)／STDERR(標準エラー)用のディスクリプタを閉じる。
Step6. 終了させるプロセスが使用していたスタックメモリを解放する。
Step7. 終了させるプロセスの状態に応じて、以下の処理を行う。
　・実行中の場合、FREE状態に移行し、再スケジューリングを行う（二度と戻ってこない）。
　・SLEEP状態やタイムアウト／メッセージ到着待ちの場合、休眠キューから終了させるプロセスを取り除く。
　・WAIT状態の場合、終了させるプロセス分（1個分）だけセマフォカウンタを増やす。次に、READY状態用の処理を行う。
　・READY状態の場合、終了させるプロセスをキューから取り出し、終了させるプロセス状態のをFREE状態に遷移する。
Step8. 割り込み許可状態に復元してから、OKを返す。

Parameters

[in]

pid

終了させたいプロセスのID

Returns

プロセスを終了させた場合はOKを返す。以下の場合はSYSERRを返す。
・引数のPIDが不正
・引数のPIDがNULLプロセスbr> ・引数のPIDで指定されるプロセスがFREE状態

Definition at line 31 of file kill.c.

References close(), disable(), freestk, getitem(), isbadpid, NULLPROC, OK, PR_CURR, PR_FREE, PR_READY, PR_RECTIM, PR_SLEEP, PR_WAIT, prcount, procent::prdesc, proctab, procent::prparent, procent::prsem, procent::prstate, procent::prstkbase, procent::prstklen, resched(), restore(), sentry::scount, semtab, send(), SYSERR, unsleep(), and xdone().

Referenced by exit(), userret(), and xsh_kill().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    int32 i;               /* Index into descriptors    */

    mask = disable();
    if (isbadpid(pid) || (pid == NULLPROC) || ((prptr = &proctab[pid])->prstate) == PR_FREE)
    {
        restore(mask);
        return SYSERR;
    }

    if (--prcount <= 1)
    { /* Last user process completes    */
        xdone();
    }

    send(prptr->prparent, pid);
    for (i = 0; i < 3; i++)
    {
        close(prptr->prdesc[i]);
    }
    freestk(prptr->prstkbase, prptr->prstklen);

    switch (prptr->prstate)
    {
    case PR_CURR:
        prptr->prstate = PR_FREE; /* Suicide */
        resched();

    case PR_SLEEP:
    case PR_RECTIM:
        unsleep(pid);
        prptr->prstate = PR_FREE;
        break;

    case PR_WAIT:
        semtab[prptr->prsem].scount++;
        /* Fall through */

    case PR_READY:
        getitem(pid); /* Remove from queue */
                      /* Fall through */

    default:
        prptr->prstate = PR_FREE;
    }

    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lexan()

int32 lexan	(	char *	,
		int32	,
		char *	,
		int32 *	,
		int32	[],
		int32	[]
	)

Definition at line 10 of file lexan.c.

References NULLCH, SH_AMPER, SH_BLANK, SH_DQUOTE, SH_GREATER, SH_LESS, SH_NEWLINE, SH_SQUOTE, SH_TAB, SH_TOK_AMPER, SH_TOK_GREATER, SH_TOK_LESS, SH_TOK_OTHER, SHELL_MAXTOK, and SYSERR.

Referenced by shell().

{
    char    quote;          /* Character for quoted string  */
    uint32  ntok;           /* Number of tokens found   */
    char    *p;         /* Pointer that walks along the */
                    /*   input line         */
    int32   tbindex;        /* Index into tokbuf        */
    char    ch;         /* Next char from input line    */

    /* Start at the beginning of the line with no tokens */

    ntok = 0;
    p = line;
    tbindex = 0;

    /* While not yet at end of line, get next token */

    while ( (*p != NULLCH) && (*p != SH_NEWLINE) ) {

        /* If too many tokens, return error */

        if (ntok >= SHELL_MAXTOK) {
            return SYSERR;
        }

        /* Skip whitespace before token */

        while ( (*p == SH_BLANK) || (*p == SH_TAB) ) {
            p++;
        }

        /* Stop parsing at end of line (or end of string) */

        ch = *p;
        if ( (ch==SH_NEWLINE) || (ch==NULLCH) ) {
            *tlen = tbindex;
            return ntok;
        }

        /* Set next entry in tok array to be an index to the    */
        /*   current location in the token buffer       */

        tok[ntok] = tbindex;    /* the start of the token   */

        /* Set the token type */

        switch (ch) {

            case SH_AMPER:  toktyp[ntok] = SH_TOK_AMPER;
                    tokbuf[tbindex++] = ch;
                    tokbuf[tbindex++] = NULLCH;
                    ntok++;
                    p++;
                    continue;

            case SH_LESS:   toktyp[ntok] = SH_TOK_LESS;
                    tokbuf[tbindex++] = ch;
                    tokbuf[tbindex++] = NULLCH;
                    ntok++;
                    p++;
                    continue;

            case SH_GREATER:    toktyp[ntok] = SH_TOK_GREATER;
                    tokbuf[tbindex++] = ch;
                    tokbuf[tbindex++] = NULLCH;
                    ntok++;
                    p++;
                    continue;

            default:        toktyp[ntok] = SH_TOK_OTHER;
        };

        /* Handle quoted string (single or double quote) */

        if ( (ch==SH_SQUOTE) || (ch==SH_DQUOTE) ) {
            quote = ch; /* remember opening quote */

            /* Copy quoted string to arg area */

            p++;    /* Move past starting quote */

            while ( ((ch=*p++) != quote) && (ch != SH_NEWLINE)
                    && (ch != NULLCH) ) {
                tokbuf[tbindex++] = ch;
            }
            if (ch != quote) {  /* string missing end quote */
                return SYSERR;
            }

            /* Finished string - count token and go on  */

            tokbuf[tbindex++] = NULLCH; /* terminate token  */
            ntok++;     /* count string as one token    */
            continue;   /* go to next token     */
        }

        /* Handle a token other than a quoted string        */

        tokbuf[tbindex++] = ch; /* put first character in buffer*/
        p++;

        while ( ((ch = *p) != SH_NEWLINE) && (ch != NULLCH)
            && (ch != SH_LESS)  && (ch != SH_GREATER)
            && (ch != SH_BLANK) && (ch != SH_TAB)
            && (ch != SH_AMPER) && (ch != SH_SQUOTE)
            && (ch != SH_DQUOTE) )  {
                tokbuf[tbindex++] = ch;
                p++;
        }

        /* Report error if other token is appended */

        if (       (ch == SH_SQUOTE) || (ch == SH_DQUOTE)
            || (ch == SH_LESS)   || (ch == SH_GREATER) ) {
            return SYSERR;
        }

        tokbuf[tbindex++] = NULLCH; /* terminate the token  */

                ntok++;             /* count valid token    */

    }
    *tlen = tbindex;
    return ntok;
}

Here is the caller graph for this function:

lfdballoc()

dbid32 lfdballoc

(

struct lfdbfree *

)

Definition at line 19 of file lfdballoc.c.

References DFILL, FALSE, LF_AREA_DIR, LF_BLKSIZ, Lf_data, lfdata::lf_dir, lfdata::lf_dirdirty, LF_DNULL, lfdata::lf_dskdev, lfdir::lfd_dfree, memset(), panic(), read(), SYSERR, and write().

Referenced by lfsetup().

{
    dbid32 dnum;  /* ID of next d-block on the free list    */
    int32 retval; /* Return value               */

    /* Get the ID of first data block on the free list */

    dnum = Lf_data.lf_dir.lfd_dfree;
    if (dnum == LF_DNULL)
    { /* Ran out of free data blocks */
        panic("out of data blocks");
    }
    retval = read(Lf_data.lf_dskdev, (char *)dbuff, dnum);
    if (retval == SYSERR)
    {
        panic("lfdballoc cannot read disk block\n\r");
    }

    /* Unlink d-block from in-memory directory */

    Lf_data.lf_dir.lfd_dfree = dbuff->lf_nextdb;
    write(Lf_data.lf_dskdev, (char *)&Lf_data.lf_dir, LF_AREA_DIR);
    Lf_data.lf_dirdirty = FALSE;

    /* Fill data block to erase old data */

    memset((char *)dbuff, DFILL, LF_BLKSIZ);
    return dnum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfdbfree()

status lfdbfree	(	did32	,
		dbid32
	)

Definition at line 10 of file lfdbfree.c.

References LF_AREA_DIR, Lf_data, lfdata::lf_dir, lfdbfree::lf_nextdb, OK, and write().

Referenced by lftruncate().

{
    struct  lfdir   *dirptr;    /* Pointer to directory     */
    struct  lfdbfree buf;       /* Buffer to hold data block    */

    dirptr = &Lf_data.lf_dir;
    buf.lf_nextdb = dirptr->lfd_dfree;
    dirptr->lfd_dfree = dnum;
    write(diskdev, (char *)&buf,   dnum);
    write(diskdev, (char *)dirptr, LF_AREA_DIR);

    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfflush()

status lfflush

(

struct lflcblk *

)

Definition at line 10 of file lfflush.c.

References FALSE, LF_AREA_DIR, Lf_data, lfdata::lf_dir, lfdata::lf_dirdirty, lfdata::lf_dskdev, LF_FREE, lflcblk::lfdbdirty, lflcblk::lfdblock, lflcblk::lfdnum, lflcblk::lfibdirty, lflcblk::lfiblock, lfibput(), lflcblk::lfinum, lflcblk::lfstate, OK, SYSERR, and write().

Referenced by lflclose(), lfsetup(), and lftruncate().

{

    if (lfptr->lfstate == LF_FREE) {
        return SYSERR;
    }

    /* Write the directory if it has changed */

    if (Lf_data.lf_dirdirty) {
        write(Lf_data.lf_dskdev, (char *)&Lf_data.lf_dir,
                            LF_AREA_DIR);
        Lf_data.lf_dirdirty = FALSE;
    }

    /* Write data block if it has changed */

    if (lfptr->lfdbdirty) {
        write(Lf_data.lf_dskdev, lfptr->lfdblock, lfptr->lfdnum);
        lfptr->lfdbdirty = FALSE;
    }

    /* Write i-block if it has changed */

    if (lfptr->lfibdirty) {
        lfibput(Lf_data.lf_dskdev, lfptr->lfinum, &lfptr->lfiblock);
        lfptr->lfibdirty = FALSE;
    }
    
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfgetmode()

int32 lfgetmode

(

char *

)

Definition at line 9 of file lfgetmode.c.

References LF_MODE_N, LF_MODE_O, LF_MODE_R, LF_MODE_RW, LF_MODE_W, NULLCH, and SYSERR.

Referenced by lfsopen().

{
    int32   mbits;          /* Mode bits to return      */
    char    ch;         /* Next char in mode string */

    mbits = 0;

    /* Mode string specifies:                   */
    /*  r - read                        */
    /*  w - write                       */
    /*  o - old (file must exist)               */
    /*  n - new (create a new file)             */

    while ( (ch = *mode++) != NULLCH) {
        switch (ch) {

            case 'r':   if (mbits&LF_MODE_R) {
                    return SYSERR;
                }
                mbits |= LF_MODE_R;
                continue;

            case 'w':   if (mbits&LF_MODE_W) {
                    return SYSERR;
                }
                mbits |= LF_MODE_W;
                continue;

            case 'o':   if (mbits&LF_MODE_O || mbits&LF_MODE_N) {
                    return SYSERR;
                }
                mbits |= LF_MODE_O;
                break;

            case 'n':   if (mbits&LF_MODE_O || mbits&LF_MODE_N) {
                    return SYSERR;
                }
                mbits |= LF_MODE_N;
                break;

            default:    return SYSERR;
        }
    }

    /* If neither read nor write specified, allow both */

    if ( (mbits&LF_MODE_RW) == 0 ) {
        mbits |= LF_MODE_RW;
    }
    return mbits;
}

Here is the caller graph for this function:

lfiballoc()

ibid32 lfiballoc

(

void

)

Definition at line 10 of file lfiballoc.c.

References FALSE, lfiblk::ib_next, LF_AREA_DIR, Lf_data, lfdata::lf_dir, lfdata::lf_dirdirty, lfdata::lf_dskdev, LF_INULL, lfdir::lfd_ifree, lfibget(), panic(), and write().

Referenced by lfsetup().

{
    ibid32  ibnum;      /* ID of next block on the free list    */
    struct  lfiblk  iblock; /* Buffer to hold an index block    */

    /* Get ID of first index block on free list */

    ibnum = Lf_data.lf_dir.lfd_ifree;
    if (ibnum == LF_INULL) {    /* Ran out of free index blocks */
        panic("out of index blocks");
    }
    lfibget(Lf_data.lf_dskdev, ibnum, &iblock);

    /* Unlink index block from the directory free list */

    Lf_data.lf_dir.lfd_ifree = iblock.ib_next;

    /* Write a copy of the directory to disk after the change */

    write(Lf_data.lf_dskdev, (char *) &Lf_data.lf_dir, LF_AREA_DIR);
    Lf_data.lf_dirdirty = FALSE;

    return ibnum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfibclear()

void lfibclear	(	struct lfiblk *	,
		int32
	)

Definition at line 9 of file lfibclear.c.

References lfiblk::ib_dba, lfiblk::ib_next, lfiblk::ib_offset, LF_DNULL, LF_IBLEN, and LF_INULL.

Referenced by lfscreate(), and lfsetup().

{
    int32   i;          /* Index for data block array   */

    ibptr->ib_offset = offset;  /* Assign specified file offset */
    for (i=0 ; i<LF_IBLEN ; i++) {  /* Clear each data block pointer*/
        ibptr->ib_dba[i] = LF_DNULL;
    }
    ibptr->ib_next = LF_INULL;  /* Set next ptr to null     */
    return;
}

Here is the caller graph for this function:

lfibget()

void lfibget	(	did32	,
		ibid32	,
		struct lfiblk *
	)

Definition at line 10 of file lfibget.c.

References ib2disp, ib2sect, LF_BLKSIZ, and read().

Referenced by lfiballoc(), lfsckfmt(), lfsetup(), and lftruncate().

{
    char    *from, *to;     /* Pointers used in copying */
    int32   i;          /* Loop index used during copy  */
    char    dbuff[LF_BLKSIZ];   /* Buffer to hold disk block    */

    /* Read disk block that contains the specified index block */

    read(diskdev, dbuff, ib2sect(inum));

    /* Copy specified index block to caller's ibuff */

    from = dbuff + ib2disp(inum);
    to = (char *)ibuff;
    for (i=0 ; i<sizeof(struct lfiblk) ; i++)
        *to++ = *from++;
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfibput()

status lfibput	(	did32	,
		ibid32	,
		struct lfiblk *
	)

Definition at line 10 of file lfibput.c.

References ib2disp, ib2sect, LF_BLKSIZ, OK, read(), SYSERR, and write().

Referenced by lfflush(), lfscreate(), lfsetup(), and lftruncate().

{
    dbid32  diskblock;      /* ID of disk sector (block)    */
    char    *from, *to;     /* Pointers used in copying */
    int32   i;          /* Loop index used during copy  */
    char    dbuff[LF_BLKSIZ];   /* Temp. buffer to hold d-block */

    /* Compute disk block number and offset of index block */

    diskblock = ib2sect(inum);
    to = dbuff + ib2disp(inum);
    from = (char *)ibuff;

    /* Read disk block */

    if (read(diskdev, dbuff, diskblock) == SYSERR) {
        return SYSERR;
    }

    /* Copy index block into place */

    for (i=0 ; i<sizeof(struct lfiblk) ; i++) {
        *to++ = *from++;
    }

    /* Write the block back to disk */

    write(diskdev, dbuff, diskblock);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lflclose()

devcall lflclose

(

struct dentry *

)

Definition at line 9 of file lflclose.c.

References dentry::dvminor, Lf_data, lfdata::lf_dirdirty, LF_FREE, LF_USED, lflcblk::lfdbdirty, lfflush(), lflcblk::lfibdirty, lfltab, lflcblk::lfmutex, lflcblk::lfstate, OK, signal(), SYSERR, and wait().

{
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */

    /* Obtain exclusive use of the file */

    lfptr = &lfltab[devptr->dvminor];
    wait(lfptr->lfmutex);

    /* If file is not open, return an error */

    if (lfptr->lfstate != LF_USED) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* Write index or data blocks to disk if they have changed */

    if (Lf_data.lf_dirdirty || lfptr->lfdbdirty || lfptr->lfibdirty) {
        lfflush(lfptr);
    }

    /* Set device state to FREE and return to caller */

    lfptr->lfstate = LF_FREE;
    signal(lfptr->lfmutex);
    return OK;
}

Here is the call graph for this function:

lflcontrol()

devcall lflcontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file lflcontrol.c.

References dentry::dvminor, kprintf(), LF_CTL_TRUNC, Lf_data, lfdata::lf_mutex, LF_USED, lfltab, lflcblk::lfmutex, lflcblk::lfstate, lftruncate(), signal(), SYSERR, and wait().

{
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */
    int32   retval;         /* Return value from func. call */

    /* Obtain exclusive use of the file */

    lfptr = &lfltab[devptr->dvminor];
    wait(lfptr->lfmutex);

    /* If file is not open, return an error */

    if (lfptr->lfstate != LF_USED) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    switch (func) {

    /* Truncate a file */

    case LF_CTL_TRUNC:
        wait(Lf_data.lf_mutex);
        retval = lftruncate(lfptr);
        signal(Lf_data.lf_mutex);
        signal(lfptr->lfmutex);
        return retval;  

    default:
        kprintf("lfcontrol: function %d not valid\n\r", func);
        signal(lfptr->lfmutex);
        return SYSERR;
    }
}

Here is the call graph for this function:

lflgetc()

devcall lflgetc

(

struct dentry *

)

Definition at line 9 of file lflgetc.c.

References dentry::dvminor, EOF, ldentry::ld_size, LF_BLKSIZ, LF_USED, lflcblk::lfbyte, lflcblk::lfdblock, lflcblk::lfdirptr, lfltab, lflcblk::lfmutex, lflcblk::lfpos, lfsetup(), lflcblk::lfstate, signal(), SYSERR, and wait().

Referenced by lflread().

{
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */
    struct  ldentry *ldptr;     /* Ptr to file's entry in the   */
                    /*   in-memory directory    */
    int32   onebyte;        /* Next data byte in the file   */

    /* Obtain exclusive use of the file */

    lfptr = &lfltab[devptr->dvminor];
    wait(lfptr->lfmutex);

    /* If file is not open, return an error */

    if (lfptr->lfstate != LF_USED) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* Return EOF for any attempt to read beyond the end-of-file */

    ldptr = lfptr->lfdirptr;
    if (lfptr->lfpos >= ldptr->ld_size) {
        signal(lfptr->lfmutex);
        return EOF;
    }

    /* If byte pointer is beyond the current data block, set up */
    /*  a new data block                    */

    if (lfptr->lfbyte >= &lfptr->lfdblock[LF_BLKSIZ]) {
        lfsetup(lfptr);
    }

    /* Extract the next byte from block, update file position, and  */
    /*  return the byte to the caller               */

    onebyte = 0xff & *lfptr->lfbyte++;
    lfptr->lfpos++;
    signal(lfptr->lfmutex);
    return onebyte;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lflinit()

devcall lflinit

(

struct dentry *

)

Definition at line 11 of file lflinit.c.

References dentry::dvminor, dentry::dvnum, FALSE, LF_BLKSIZ, LF_FREE, LF_INULL, LF_NAME_LEN, lflcblk::lfbyte, lflcblk::lfdbdirty, lflcblk::lfdblock, lflcblk::lfdev, lflcblk::lfdirptr, lflcblk::lfdnum, lflcblk::lfibdirty, lflcblk::lfiblock, lflcblk::lfinum, lfltab, lflcblk::lfmutex, lflcblk::lfname, lflcblk::lfpos, lflcblk::lfstate, memset(), NULL, NULLCH, OK, and semcreate().

{
    struct  lflcblk *lfptr;     /* Ptr. to control block entry  */
    int32   i;          /* Walks through name array */

    lfptr = &lfltab[ devptr->dvminor ];

    /* Initialize control block entry */

    lfptr->lfstate = LF_FREE;   /* Device is currently unused   */
    lfptr->lfdev = devptr->dvnum;   /* Set device ID        */
    lfptr->lfmutex = semcreate(1);  /* Create the mutex semaphore   */

    /* Initialize the directory and file position */

    lfptr->lfdirptr = (struct  ldentry *) NULL;
    lfptr->lfpos = 0;
    for (i=0; i<LF_NAME_LEN; i++) {
        lfptr->lfname[i] = NULLCH;
    }

    /* Zero the in-memory index block and data block */

    lfptr->lfinum = LF_INULL;
    memset((char *) &lfptr->lfiblock, NULLCH, sizeof(struct lfiblk));
    lfptr->lfdnum = 0;
    memset((char *) &lfptr->lfdblock, NULLCH, LF_BLKSIZ);

    /* Start with the byte beyond the current data block */

    lfptr->lfbyte = &lfptr->lfdblock[LF_BLKSIZ];
    lfptr->lfibdirty = lfptr->lfdbdirty = FALSE;
    return OK;
}

Here is the call graph for this function:

lflputc()

devcall lflputc	(	struct dentry *	,
		char
	)

Definition at line 9 of file lflputc.c.

References dentry::dvminor, ldentry::ld_size, LF_BLKSIZ, Lf_data, lfdata::lf_dirdirty, LF_USED, lflcblk::lfbyte, lflcblk::lfdbdirty, lflcblk::lfdblock, lflcblk::lfdirptr, lfltab, lflcblk::lfmutex, lflcblk::lfpos, lfsetup(), lflcblk::lfstate, OK, signal(), SYSERR, TRUE, and wait().

Referenced by lflwrite().

{
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */
    struct  ldentry *ldptr;     /* Ptr to file's entry in the   */
                    /*  in-memory directory     */

    /* Obtain exclusive use of the file */

    lfptr = &lfltab[devptr->dvminor];
    wait(lfptr->lfmutex);

    /* If file is not open, return an error */

    if (lfptr->lfstate != LF_USED) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* Return SYSERR for an attempt to skip bytes beyond the byte   */
    /*  that is currently the end of the file           */

    ldptr = lfptr->lfdirptr;
    if (lfptr->lfpos > ldptr->ld_size) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* If pointer is outside current block, set up new block */

    if (lfptr->lfbyte >= &lfptr->lfdblock[LF_BLKSIZ]) {

        /* Set up block for current file position */

        lfsetup(lfptr);
    }

    /* If appending a byte to the file, increment the file size.    */
    /*   Note: comparison might be equal, but should not be greater.*/

    if (lfptr->lfpos >= ldptr->ld_size) {
        ldptr->ld_size++;
        Lf_data.lf_dirdirty = TRUE;
    }

    /* Place byte in buffer and mark buffer "dirty" */

    *lfptr->lfbyte++ = ch;
    lfptr->lfpos++;
    lfptr->lfdbdirty = TRUE;

    signal(lfptr->lfmutex);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lflread()

devcall lflread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file lflread.c.

References EOF, lflgetc(), and SYSERR.

{
    uint32  numread;        /* Number of bytes read     */
    int32   nxtbyte;        /* Character or SYSERR/EOF  */

    if (count < 0) {
        return SYSERR;
    }

    /* Iterate and use lflgetc to read individual bytes */

    for (numread=0 ; numread < count ; numread++) {
        nxtbyte = lflgetc(devptr);
        if (nxtbyte == SYSERR) {
            return SYSERR;
        } else if (nxtbyte == EOF) {    /* EOF before finished */
            if (numread == 0) {
            return EOF;
            } else {
            return numread;
            }
        } else {
            *buff++ = (char) (0xff & nxtbyte);
        }
    }
    return numread;
}

Here is the call graph for this function:

lflseek()

devcall lflseek	(	struct dentry *	,
		uint32
	)

Definition at line 9 of file lflseek.c.

References dentry::dvminor, ldentry::ld_size, LF_BLKSIZ, LF_USED, lflcblk::lfbyte, lflcblk::lfdblock, lflcblk::lfdirptr, lfltab, lflcblk::lfmutex, lflcblk::lfpos, lflcblk::lfstate, OK, signal(), SYSERR, and wait().

{
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */

    /* If file is not open, return an error */

    lfptr = &lfltab[devptr->dvminor];
    wait(lfptr->lfmutex);
    if (lfptr->lfstate != LF_USED) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* Verify offset is within current file size */

    if (offset > lfptr->lfdirptr->ld_size) {
        signal(lfptr->lfmutex);
        return SYSERR;
    }

    /* Record new offset and invalidate byte pointer (i.e., force   */
    /*   the index and data blocks to be replaced if a successive   */
    /*   call is made to read or write)             */

    lfptr->lfpos = offset;
    lfptr->lfbyte = &lfptr->lfdblock[LF_BLKSIZ];

    signal(lfptr->lfmutex);
    return OK;
}

Here is the call graph for this function:

lflwrite()

devcall lflwrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file lflwrite.c.

References lflputc(), and SYSERR.

{
    int32       i;      /* Number of bytes written  */

    if (count < 0) {
        return SYSERR;
    }

    /* Iteratate and write one byte at a time */

    for (i=0; i<count; i++) {
        if (lflputc(devptr, *buff++) == SYSERR) {
            return SYSERR;
        }
    }
    return count;
}

Here is the call graph for this function:

lfscheck()

status lfscheck

(

struct lfdir *

)

Definition at line 10 of file lfscheck.c.

References lfdir::lfd_allones, lfdir::lfd_allzeros, lfdir::lfd_fsysid, lfdir::lfd_nfiles, lfdir::lfd_revid, LFS_ID, OK, and SYSERR.

Referenced by lfsckfmt(), lfsopen(), and xsh_ls().

{
    uint32  reverse;        /* LFS_ID in reverse byte order */

    /* Verify the File System ID, all 0's and all 1's fields */

    if ( (dirptr->lfd_fsysid != LFS_ID)       ||
         (dirptr->lfd_allzeros != 0x00000000) ||
         (dirptr->lfd_allones  != 0xffffffff) ) {
        return SYSERR;
    }

    /* Check the reverse-order File System ID field */

    reverse = ((LFS_ID>>24) & 0x000000ff) | 
          ((LFS_ID>> 8) & 0x0000ff00) |
          ((LFS_ID<< 8) & 0x00ff0000) |
          ((LFS_ID<<24) & 0xff000000) ;

    if (dirptr->lfd_revid != reverse) {
        return SYSERR;
    }

    /* Extra sanity check - verify file count is positive */
    if (dirptr->lfd_nfiles < 0){
        return SYSERR;
    }
    return OK;
}

Here is the caller graph for this function:

lfscreate()

status lfscreate	(	did32	,
		ibid32	,
		uint32
	)

Definition at line 10 of file lfscreate.c.

References close(), lfiblk::ib_next, LF_AREA_DIR, LF_BLKSIZ, LF_DNULL, LF_INULL, lfibclear(), lfibput(), LFS_ID, memset(), NULLCH, OK, SYSERR, and write().

{
    uint32  sectors;        /* Number of sectors to use */
    uint32  ibsectors;      /* Number of sectors of i-blocks*/
    uint32  ibpersector;        /* Number of i-blocks per sector*/
    struct  lfdir   dir;        /* Buffer to hold the directory */
    uint32  dblks;          /* Total free data blocks   */
    struct  lfiblk  iblock;     /* Space for one i-block    */
    struct  lfdbfree dblock;    /* Data block on the free list  */
    dbid32  dbindex;        /* Index for data blocks    */
    int32   retval;         /* Return value from func call  */
    int32   i;          /* Loop index           */

    /* Compute total sectors on disk */

    sectors = dsiz  / LF_BLKSIZ;    /* Truncate to full sector */

    /* Compute number of sectors comprising i-blocks */

    ibpersector = LF_BLKSIZ / sizeof(struct lfiblk);
    ibsectors = (lfiblks+(ibpersector-1)) / ibpersector;/* Round up */
    lfiblks = ibsectors * ibpersector;
    if (ibsectors > sectors/2) {    /* Invalid arguments */
        return SYSERR;
    }

    /* Create an initial directory */

    memset((char *)&dir, NULLCH, sizeof(struct lfdir));
    dir.lfd_fsysid = LFS_ID;
    dir.lfd_nfiles = 0;
    dir.lfd_allzeros = 0;
    dir.lfd_allones = 0xffffffff;
    dir.lfd_revid = ((LFS_ID>>24) & 0x000000ff) | 
                  ((LFS_ID>> 8) & 0x0000ff00) |
                  ((LFS_ID<< 8) & 0x00ff0000) |
                  ((LFS_ID<<24) & 0xff000000) ;
    dbindex= (dbid32)(ibsectors + 1);
    dir.lfd_dfree = dbindex;
    dblks = sectors - ibsectors - 1;
    retval = write(disk,(char *)&dir, LF_AREA_DIR);
    if (retval == SYSERR) {
        return SYSERR;
    }

    /* Create list of free i-blocks on disk */

    lfibclear(&iblock, 0);
    for (i=0; i<lfiblks-1; i++) {
        iblock.ib_next = (ibid32)(i + 1);
        lfibput(disk, i, &iblock);
    }
    iblock.ib_next = LF_INULL;
    lfibput(disk, i, &iblock);

    /* Create list of free data blocks on disk */

    memset((char*)&dblock, NULLCH, LF_BLKSIZ);
    for (i=0; i<dblks-1; i++) {
        dblock.lf_nextdb = dbindex + 1;
        write(disk, (char *)&dblock, dbindex);
        dbindex++;
    }
    dblock.lf_nextdb = LF_DNULL;
    write(disk, (char *)&dblock, dbindex);
    close(disk);
    return OK;
}

Here is the call graph for this function:

lfsetup()

status lfsetup

(

struct lflcblk *

)

Definition at line 10 of file lfsetup.c.

References FALSE, lfiblk::ib_dba, lfiblk::ib_next, lfiblk::ib_offset, ldentry::ld_ilist, Lf_data, LF_DMASK, LF_DNULL, lfdata::lf_dskdev, LF_IDATA, LF_IMASK, LF_INULL, lfdata::lf_mutex, lflcblk::lfbyte, lfdballoc(), lflcblk::lfdbdirty, lflcblk::lfdblock, lflcblk::lfdirptr, lflcblk::lfdnum, lfflush(), lfiballoc(), lfibclear(), lflcblk::lfibdirty, lfibget(), lflcblk::lfiblock, lfibput(), lflcblk::lfinum, lflcblk::lfpos, OK, read(), signal(), TRUE, and wait().

Referenced by lflgetc(), and lflputc().

{
    dbid32  dnum;           /* Data block to fetch      */
    ibid32  ibnum;          /* I-block number during search */
    struct  ldentry *ldptr;     /* Ptr to file entry in dir.    */
    struct  lfiblk  *ibptr;     /* Ptr to in-memory index block */
    uint32  newoffset;      /* Computed data offset for */
                    /*   next index block       */
    int32   dindex;         /* Index into array in an index */
                    /*   block          */


    /* Obtain exclusive access to the directory */

    wait(Lf_data.lf_mutex);

    /* Get pointers to in-memory directory, file's entry in the */
    /*  directory, and the in-memory index block        */

    ldptr = lfptr->lfdirptr;
    ibptr = &lfptr->lfiblock;

    /* If existing index block or data block changed, write to disk */

    if (lfptr->lfibdirty || lfptr->lfdbdirty) {
        lfflush(lfptr);
    }
    ibnum = lfptr->lfinum;      /* Get ID of curr. index block  */

    /* If there is no index block in memory (e.g., because the file */
    /*  was just opened), either load the first index block of  */
    /*  the file or allocate a new first index block        */

    if (ibnum == LF_INULL) {

        /* Check directory entry to see if index block exists   */

        ibnum = ldptr->ld_ilist;
        if (ibnum == LF_INULL) { /* Empty file - get new i-block*/
            ibnum = lfiballoc();
            lfibclear(ibptr, 0);
            ldptr->ld_ilist = ibnum;
            lfptr->lfibdirty = TRUE;
        } else {        /* Nonempty - read first i-block*/
            lfibget(Lf_data.lf_dskdev, ibnum, ibptr);
        }
        lfptr->lfinum = ibnum;

    /* Otherwise, if current file position has been moved to an */
    /*   offset before the current index block, start at the    */
    /*   beginning of the index list for the file           */

    } else if (lfptr->lfpos < ibptr->ib_offset) {

        /* Load initial index block for the file (we know that  */
        /*  at least one index block exists)        */
    
        ibnum = ldptr->ld_ilist;
        lfibget(Lf_data.lf_dskdev, ibnum, ibptr);
        lfptr->lfinum = ibnum;
    }

    /* At this point, an index block is in memory, but may cover    */
    /*  an offset less than the current file position.  Loop until  */
    /*  the index block covers the current file position.       */

    while ((lfptr->lfpos & ~LF_IMASK) > ibptr->ib_offset ) {
        ibnum = ibptr->ib_next;
        if (ibnum == LF_INULL) {
            /* Allocate new index block to extend file */
            ibnum = lfiballoc();
            ibptr->ib_next = ibnum;
            lfibput(Lf_data.lf_dskdev, lfptr->lfinum, ibptr);
            lfptr->lfinum = ibnum;
            newoffset = ibptr->ib_offset + LF_IDATA;
            lfibclear(ibptr, newoffset);
            lfptr->lfibdirty = TRUE;
        } else {
            lfibget(Lf_data.lf_dskdev, ibnum, ibptr);
            lfptr->lfinum = ibnum;
        }
        lfptr->lfdnum = LF_DNULL; /* Invalidate old data block */
    }

    /* At this point, the index block in lfiblock covers the    */
    /*  current file position (i.e., position lfptr->lfpos).  The   */
    /*  next step consists of loading the correct data block.   */

    dindex = (lfptr->lfpos & LF_IMASK) >> 9;

    /* If data block index does not match current data block, read  */
    /*   the correct data block from disk               */

    dnum = lfptr->lfiblock.ib_dba[dindex];
    if (dnum == LF_DNULL) {     /* Allocate new data block */
        dnum = lfdballoc((struct lfdbfree *)&lfptr->lfdblock);
        lfptr->lfiblock.ib_dba[dindex] = dnum;
        lfptr->lfibdirty = TRUE;
    } else if ( dnum != lfptr->lfdnum) {
        read(Lf_data.lf_dskdev, (char *)lfptr->lfdblock, dnum);
        lfptr->lfdbdirty = FALSE;
    }
    lfptr->lfdnum = dnum;

    /* Use current file offset to set the pointer to the next byte  */
    /*   within the data block                  */

    lfptr->lfbyte = &lfptr->lfdblock[lfptr->lfpos & LF_DMASK];
    signal(Lf_data.lf_mutex);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lfsinit()

devcall lfsinit

(

struct dentry *

)

Definition at line 11 of file lfsinit.c.

References FALSE, Lf_data, lfdata::lf_dir, lfdata::lf_dirdirty, lfdata::lf_dirpresent, LF_DISK_DEV, lfdata::lf_dskdev, lfdata::lf_mutex, memset(), NULLCH, OK, and semcreate().

{
    /* Assign ID of disk device that will be used */

    Lf_data.lf_dskdev = LF_DISK_DEV;

    /* Create a mutual exclusion semaphore */

    Lf_data.lf_mutex = semcreate(1);

    /* Zero directory area (for debugging) */

    memset((char *)&Lf_data.lf_dir, NULLCH, sizeof(struct lfdir));

    /* Initialize directory to "not present" in memory */

    Lf_data.lf_dirpresent = Lf_data.lf_dirdirty = FALSE;

    return OK;
}

Here is the call graph for this function:

lfsopen()

devcall lfsopen	(	struct dentry *	,
		char *	,
		char *
	)

Definition at line 9 of file lfsopen.c.

References FALSE, kprintf(), ldentry::ld_ilist, ldentry::ld_name, ldentry::ld_size, LF_AREA_DIR, LF_BLKSIZ, Lf_data, lfdata::lf_dir, lfdata::lf_dirpresent, LF_DNULL, lfdata::lf_dskdev, LF_FREE, LF_INULL, LF_MODE_N, LF_MODE_O, LF_MODE_RW, lfdata::lf_mutex, LF_NAME_LEN, LF_NUM_DIR_ENT, LF_USED, lflcblk::lfbyte, lfdir::lfd_files, lfdir::lfd_nfiles, lflcblk::lfdbdirty, lflcblk::lfdblock, lflcblk::lfdev, lflcblk::lfdirptr, lflcblk::lfdnum, lfgetmode(), lflcblk::lfibdirty, lflcblk::lfinum, lfltab, lflcblk::lfmode, lflcblk::lfname, lflcblk::lfpos, lfscheck(), lflcblk::lfstate, Nlfl, NULLCH, read(), signal(), SYSERR, TRUE, and wait().

{
    struct  lfdir   *dirptr;    /* Ptr to in-memory directory   */
    char        *from, *to; /* Ptrs used during copy    */
    char        *nam, *cmp; /* Ptrs used during comparison  */
    int32       i;      /* General loop index       */
    did32       lfnext;     /* Minor number of an unused    */
                    /*    file pseudo-device    */
    struct  ldentry *ldptr;     /* Ptr to an entry in directory */
    struct  lflcblk *lfptr;     /* Ptr to open file table entry */
    bool8       found;      /* Was the name found?      */
    int32   retval;         /* Value returned from function */
    int32   mbits;          /* Mode bits            */

    /* Check length of name file (leaving space for NULLCH */

    from = name;
    for (i=0; i< LF_NAME_LEN; i++) {
        if (*from++ == NULLCH) {
            break;
        }
    }
    if (i >= LF_NAME_LEN) {     /* Name is too long */
        return SYSERR;
    }

    /* Parse mode argument and convert to binary */

    mbits = lfgetmode(mode);
    if (mbits == SYSERR) {
        return SYSERR;
    }

    /* If named file is already open, return SYSERR */

    lfnext = SYSERR;
    for (i=0; i<Nlfl; i++) {    /* Search file pseudo-devices   */
        lfptr = &lfltab[i];
        if (lfptr->lfstate == LF_FREE) {
            if (lfnext == SYSERR) {
                lfnext = i; /* Record index */
            }
            continue;
        }

        /* Compare requested name to name of open file */

        nam = name;
        cmp = lfptr->lfname;
        while(*nam != NULLCH) {
            if (*nam != *cmp) {
                break;
            }
            nam++;
            cmp++;
        }

        /* See if comparison succeeded */

        if ( (*nam==NULLCH) && (*cmp == NULLCH) ) {
            return SYSERR;
        }
    }
    if (lfnext == SYSERR) { /* No slave file devices are available  */
        return SYSERR;
    }

    /* Obtain copy of directory if not already present in memory    */

    dirptr = &Lf_data.lf_dir;
    wait(Lf_data.lf_mutex);
    if (! Lf_data.lf_dirpresent) {
        retval = read(Lf_data.lf_dskdev,(char *)dirptr,LF_AREA_DIR);
        if (retval == SYSERR ) {
        signal(Lf_data.lf_mutex);
        return SYSERR;
        }
        if (lfscheck(dirptr) == SYSERR ) {
        kprintf("Disk does not contain a Xinu file system\n");
        signal(Lf_data.lf_mutex);
        return SYSERR;
        }
        Lf_data.lf_dirpresent = TRUE;
    }

    /* Search directory to see if file exists */

    found = FALSE;
    for (i=0; i<dirptr->lfd_nfiles; i++) {
        ldptr = &dirptr->lfd_files[i];
        nam = name;
        cmp = ldptr->ld_name;
        while(*nam != NULLCH) {
            if (*nam != *cmp) {
                break;
            }
            nam++;
            cmp++;
        }
        if ( (*nam==NULLCH) && (*cmp==NULLCH) ) { /* Name found */
            found = TRUE;
            break;
        }
    }

    /* Case #1 - file is not in directory (i.e., does not exist)    */

    if (! found) {
        if (mbits & LF_MODE_O) {    /* File *must* exist    */
            signal(Lf_data.lf_mutex);
            return SYSERR;
        }

        /* Take steps to create new file and add to directory   */

        /* Verify that space remains in the directory */

        if (dirptr->lfd_nfiles >= LF_NUM_DIR_ENT) {
            signal(Lf_data.lf_mutex);
            return SYSERR;
        }

        /* Allocate next dir. entry & initialize to empty file  */

        ldptr = &dirptr->lfd_files[dirptr->lfd_nfiles++];
        ldptr->ld_size = 0;
        from = name;
        to = ldptr->ld_name;
        while ( (*to++ = *from++) != NULLCH ) {
            ;
        }
        ldptr->ld_ilist = LF_INULL;

    /* Case #2 - file is in directory (i.e., already exists)    */

    } else if (mbits & LF_MODE_N) {     /* File must not exist  */
            signal(Lf_data.lf_mutex);
            return SYSERR;
    }

    /* Initialize the local file pseudo-device */

    lfptr = &lfltab[lfnext];
    lfptr->lfstate = LF_USED;
    lfptr->lfdirptr = ldptr;    /* Point to directory entry */
    lfptr->lfmode = mbits & LF_MODE_RW;

    /* File starts at position 0 */

    lfptr->lfpos     = 0;

    to = lfptr->lfname;
    from = name;
    while ( (*to++ = *from++) != NULLCH ) {
        ;
    }

    /* Neither index block nor data block are initially valid   */

    lfptr->lfinum    = LF_INULL;
    lfptr->lfdnum    = LF_DNULL;

    /* Initialize byte pointer to address beyond the end of the */
    /*  buffer (i.e., invalid pointer triggers setup)       */

    lfptr->lfbyte = &lfptr->lfdblock[LF_BLKSIZ];
    lfptr->lfibdirty = FALSE;
    lfptr->lfdbdirty = FALSE;

    signal(Lf_data.lf_mutex);

    return lfptr->lfdev;
}

Here is the call graph for this function:

lftruncate()

status lftruncate

(

struct lflcblk *

)

Definition at line 10 of file lftruncate.c.

References lfiblk::ib_dba, lfiblk::ib_next, lfiblk::ib_offset, ldentry::ld_ilist, ldentry::ld_size, LF_BLKSIZ, Lf_data, lfdata::lf_dir, lfdata::lf_dirdirty, LF_DNULL, lfdata::lf_dskdev, LF_IBLEN, LF_INULL, lflcblk::lfbyte, lfdir::lfd_ifree, lflcblk::lfdbdirty, lfdbfree(), lflcblk::lfdblock, lflcblk::lfdirptr, lflcblk::lfdnum, lfflush(), lflcblk::lfibdirty, lfibget(), lfibput(), lflcblk::lfinum, lflcblk::lfpos, OK, and TRUE.

Referenced by lflcontrol().

{
    struct  ldentry *ldptr;     /* Pointer to file's dir. entry */
    struct  lfiblk  iblock;     /* Buffer for one index block   */
    ibid32  ifree;          /* Start of index blk free list */
    ibid32  firstib;        /* First index blk of the file  */
    ibid32  nextib;         /* Walks down list of the   */
                    /*   file's index blocks    */
    dbid32  nextdb;         /* Next data block to free  */
    int32   i;          /* Moves through data blocks in */
                    /*   a given index block    */

    ldptr = lfptr->lfdirptr;    /* Get pointer to dir. entry    */
    if (ldptr->ld_size == 0) {  /* File is already empty */
        return OK;
    }

    /* Clean up the open local file first */

    if ( (lfptr->lfibdirty) || (lfptr->lfdbdirty) ) {
        lfflush(lfptr);
    }
    lfptr->lfpos = 0;
    lfptr->lfinum = LF_INULL;
    lfptr->lfdnum = LF_DNULL;
    lfptr->lfbyte = &lfptr->lfdblock[LF_BLKSIZ];

    /* Obtain ID of first index block on free list */

    ifree = Lf_data.lf_dir.lfd_ifree;

    /* Record file's first i-block and clear directory entry */

    firstib = ldptr->ld_ilist;
    ldptr->ld_ilist = LF_INULL;
    ldptr->ld_size = 0;
    Lf_data.lf_dirdirty = TRUE;

    /* Walk along index block list, disposing of each data block    */
    /*   and clearing the corresponding pointer.  A note on loop    */
    /*   termination: last pointer is set to ifree below.       */

    for (nextib=firstib; nextib!=ifree; nextib=iblock.ib_next) {

        /* Obtain a copy of current index block from disk   */

        lfibget(Lf_data.lf_dskdev, nextib, &iblock);

        /* Free each data block in the index block      */

        for (i=0; i<LF_IBLEN; i++) {    /* For each d-block */

            /* Free the data block */

            nextdb = iblock.ib_dba[i];
            if (nextdb != LF_DNULL) {
                lfdbfree(Lf_data.lf_dskdev, nextdb);
            }

            /* Clear entry in i-block for this d-block  */

                iblock.ib_dba[i] = LF_DNULL;
        }

        /* Clear offset (just to make debugging easier)     */

        iblock.ib_offset = 0;

        /* For the last index block on the list, make it point  */
        /*  to the current free list            */

        if (iblock.ib_next == LF_INULL) {
            iblock.ib_next = ifree;
        }

        /* Write cleared i-block back to disk */

        lfibput(Lf_data.lf_dskdev, nextib, &iblock);
    }

    /* Last index block on the file list now points to first node   */
    /*   on the current free list.  Once we make the free list  */
    /*   point to the first index block on the file list, the   */
    /*   entire set of index blocks will be on the free list    */

    Lf_data.lf_dir.lfd_ifree = firstib;

    /* Indicate that directory has changed and return */

    Lf_data.lf_dirdirty = TRUE;
    
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lpgetc()

devcall lpgetc

(

struct dentry *

)

lpinit()

devcall lpinit

(

struct dentry *

)

lpopen()

devcall lpopen	(	struct dentry *	,
		char *	,
		char *
	)

lpputc()

devcall lpputc	(	struct dentry *	,
		char
	)

lpread()

devcall lpread	(	struct dentry *	,
		char *	,
		int32
	)

lpwrite()

devcall lpwrite	(	struct dentry *	,
		char *	,
		int32
	)

memcmp()

int32* memcmp	(	void *	,
		const void *	,
		int32
	)

memcpy()

void* memcpy	(	void *	s,
		const void *	ct,
		int	n
	)

メモリAの領域（source）からメモリBの領域（Destination）にN Byteコピーする。

Parameters

[in,out]	s	コピー先のアドレス（Destination address）
[in]	ct	コピー元のアドレス（Source address）
[in]	n	コピーサイズ（Byte）

Returns

コピー完了後のコピー先アドレス

Definition at line 13 of file memcpy.c.

Referenced by addargs(), arp_in(), arp_resolve(), dhcp_bld_bootp_msg(), dhcp_bld_req(), dns_bldq(), dns_geta(), dns_getrname(), ethcontrol(), ethread(), ethwrite(), getlocalip(), icmp_mkpkt(), ip_send(), ipout(), raminit(), ramread(), ramwrite(), rdsread(), rdswrite(), udp_send(), and udp_sendto().

{
    register int i;
    char *dst = (char *)s;
    char *src = (char *)ct;

    for (i = 0; i < n; i++)
    {
        *dst++ = *src++;
    }
    return s;
}

Here is the caller graph for this function:

memset()

void* memset	(	void *	s,
		int	c,
		int	n
	)

指定のByteブロックに対して、同じ値をNバイト分書き込む。

Parameters

[in,out]	s	Byteブロックへのポインタ（例：文字列）
[in]	c	書き込む値（1Byte）
[in]	n	書き込むサイズ（Byte）

Returns

書き込み完了後のByteブロックへのポインタ

Definition at line 13 of file memset.c.

Referenced by arp_alloc(), arp_resolve(), dhcp_bld_bootp_msg(), dnslookup(), ethinit(), ethwrite(), getutime(), if(), lfdballoc(), lflinit(), lfscreate(), lfsinit(), net_init(), rdscontrol(), rdsopen(), rdsprocess(), rflread(), rflwrite(), rfscontrol(), rfsopen(), tftpget_mb(), and xsh_rdstest().

{
    register int i;
    char *cp = (char *)s;

    for (i = 0; i < n; i++)
    {
        *cp = (unsigned char)c;
        cp++;
    }
    return s;
}

Here is the caller graph for this function:

mkbufpool()

bpid32 mkbufpool	(	int32	bufsiz,
		int32	numbufs
	)

バッファプール用のメモリを割り当て、バッファ同士をリンクする。

Step1. 割り込みを禁止する。
Step2. 以下のいずれかの場合は、割り込み状態を復元し、処理を終了する。
　・バッファサイズがバッファ最小値を下回る場合
　・バッファサイズがバッファ最大値を超えた場合
　・バッファ数が0以下の場合
　・バッファ数がバッファ最大数を超えた場合
　・割り当て済みのバッファプール数が最大数を超えた場合
Step3. 要求されたバッファサイズを4の倍数で丸める。
Step4. 要求されたバッファサイズ + バッファプールID分のメモリをバッファ数分、割り当てる。
メモリ確保に失敗した場合は割り込み状態を復元し、処理を終了する。 Step5. 新しいバッファプールIDを割り当て、バッファプールの総数を1増加させる。
Step6. 割り当てたバッファとバッファプールをリンクする。
Step7. 割り当てたバッファにセマフォを割り当てる。
セマフォ割り当てに失敗した場合は割り当てたバッファを解放し、バッファプール総数を元に戻し、
割り込み状態を復元し、処理を終了する。
Step8. 割り当てたバッファ同士をリンクする。
Step9. 割り込み状態を復元する。

Parameters

[in]	bufsiz	バッファプール中のバッファサイズ
[in]	numbufs	バッファプール中のバッファ数

Returns

バッファプールを割り当てた場合はバッファプールIDを返し、以下の場合はSYSERRを返す。
　・バッファサイズがバッファ最小値を下回る場合
　・バッファサイズがバッファ最大値を超えた場合
　・バッファ数が0以下の場合
　・バッファ数がバッファ最大数を超えた場合
　・割り当て済みのバッファプール数が最大数を超えた場合
　・バッファを確保できなかった場合
　・セマフォを作成できなかった場合

Definition at line 38 of file mkbufpool.c.

References BP_MAXB, BP_MAXN, bpentry::bpnext, bpentry::bpsem, bpentry::bpsize, buftab, disable(), freemem(), getmem(), NBPOOLS, nbpools, NULL, restore(), semcreate(), and SYSERR.

Referenced by net_init().

{
    intmask mask;          /* Saved interrupt mask      */
    bpid32 poolid;         /* ID of pool that is created    */
    struct bpentry *bpptr; /* Pointer to entry in buftab    */
    char *buf;             /* Pointer to memory for buffer  */

    mask = disable();
    if (bufsiz < BP_MINB || bufsiz > BP_MAXB || numbufs < 1 || numbufs > BP_MAXN || nbpools >= NBPOOLS)
    {
        restore(mask);
        return (bpid32)SYSERR;
    }
    /* Round request to a multiple of 4 bytes */

    bufsiz = ((bufsiz + 3) & (~3));

    buf = (char *)getmem(numbufs * (bufsiz + sizeof(bpid32)));
    if ((int32)buf == SYSERR)
    {
        restore(mask);
        return (bpid32)SYSERR;
    }
    poolid = nbpools++;
    bpptr = &buftab[poolid];
    bpptr->bpnext = (struct bpentry *)buf;
    bpptr->bpsize = bufsiz;
    if ((bpptr->bpsem = semcreate(numbufs)) == SYSERR)
    {
        freemem(buf, numbufs * (bufsiz + sizeof(bpid32)));
        nbpools--;
        restore(mask);
        return (bpid32)SYSERR;
    }
    bufsiz += sizeof(bpid32);
    for (numbufs--; numbufs > 0; numbufs--)
    {
        bpptr = (struct bpentry *)buf;
        buf += bufsiz;
        bpptr->bpnext = (struct bpentry *)buf;
    }
    bpptr = (struct bpentry *)buf;
    bpptr->bpnext = (struct bpentry *)NULL;
    restore(mask);
    return poolid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mount()

syscall mount	(	char *	,
		char *	,
		did32
	)

Definition at line 9 of file mount.c.

References disable(), isbaddev, nametab, namlen(), nmentry::ndevice, NM_PRELEN, NM_REPLLEN, NNAMES, nnames, nmentry::nprefix, nmentry::nreplace, OK, restore(), and SYSERR.

Referenced by naminit().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  nmentry *namptr;    /* Pointer to unused table entry*/
    int32   psiz, rsiz;     /* Sizes of prefix & replacement*/
    int32   i;          /* Counter for copy loop    */

        mask = disable();

    psiz = namlen(prefix, NM_PRELEN);
    rsiz = namlen(replace, NM_REPLLEN);

    /* If arguments are invalid or table is full, return error */

    if ( (psiz == SYSERR)   || (rsiz == SYSERR) ||
         (isbaddev(device)) || (nnames >= NNAMES) ) {
        restore(mask);
        return SYSERR;
    }

    /* Allocate a slot in the table */

    namptr = &nametab[nnames];  /* Next unused entry in table   */

    /* copy prefix and replacement strings and record device ID */
    
    for (i=0; i<psiz; i++) {    /* Copy prefix into table entry */
        namptr->nprefix[i] = *prefix++;
    }

    for (i=0; i<rsiz; i++) {    /* Copy replacement into entry  */
        namptr->nreplace[i] = *replace++;
    }

    namptr->ndevice = device;   /* Record the device ID     */

        nnames++;           /* Increment number of names    */

    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

namcpy()

status namcpy	(	char *	newname,
		char *	oldname,
		int32	buflen
	)

Definition at line 116 of file nammap.c.

References NULLCH, OK, and SYSERR.

Referenced by nammap().

{
        char    *nptr;                  /* Point to new name            */
        char    *optr;                  /* Point to old name            */
    int32   cnt;            /* Count of characters copied   */

        nptr = newname;
        optr = oldname;

    for (cnt=0; cnt<buflen; cnt++) {
        if ( (*nptr++ = *optr++) == NULLCH) {
            return OK;
        }
    }
    return SYSERR;      /* Buffer filled before copy completed  */
}

Here is the caller graph for this function:

naminit()

status naminit

(

void

)

Definition at line 29 of file naminit.c.

References devtab, dentry::dvname, dentry::dvnum, kprintf(), LFILESYS, mount(), NDEVS, NM_MAXLEN, nnames, NULLCH, NULLDEV, NULLSTR, OK, RFILESYS, and SYSERR.

{
    did32 i;                    /* Index into devtab        */
    struct dentry *devptr;      /* Pointer to device table entry*/
    char tmpstr[NM_MAXLEN];     /* String to hold a name    */
    status retval;              /* Return value         */
    char *tptr;                 /* Pointer into tempstring  */
    char *nptr;                 /* Pointer to device name   */
    char devprefix[] = "/dev/"; /* Prefix to use for devices    */
    int32 len;                  /* Length of created name   */
    char ch;                    /* Storage for a character  */

    /* Set prefix table to empty */

    nnames = 0;

    for (i = 0; i < NDEVS; i++)
    {
        tptr = tmpstr;
        nptr = devprefix;

        /* Copy prefix into tmpstr */

        len = 0;
        while ((*tptr++ = *nptr++) != NULLCH)
        {
            len++;
        }
        tptr--; /* Move pointer to position before NULLCH */
        devptr = &devtab[i];
        nptr = devptr->dvname; /* Move to device name */

        /* Map device name to lower case and append */

        while (++len < NM_MAXLEN)
        {
            ch = *nptr++;
            if ((ch >= 'A') && (ch <= 'Z'))
            {
                ch += 'a' - 'A';
            }
            if ((*tptr++ = ch) == NULLCH)
            {
                break;
            }
        }

        if (len > NM_MAXLEN)
        {
            kprintf("namespace: device name %s too long\r\n",
                    devptr->dvname);
            continue;
        }

        retval = mount(tmpstr, NULLSTR, devptr->dvnum);
        if (retval == SYSERR)
        {
            kprintf("namespace: cannot mount device %d\r\n",
                    devptr->dvname);
            continue;
        }
    }

    /* Add other prefixes (longest prefix first) */

    mount("/dev/null", "", NULLDEV);
    mount("/remote/", "remote:", RFILESYS);
    mount("/local/", NULLSTR, LFILESYS);
    mount("/dev/", NULLSTR, SYSERR);
    mount("~/", NULLSTR, LFILESYS);
    mount("/", "root:", RFILESYS);
    mount("", "", LFILESYS);

    return OK;
}

Here is the call graph for this function:

namlen()

int32 namlen	(	char *	,
		int32
	)

Definition at line 60 of file mount.c.

References NULLCH, and SYSERR.

Referenced by dns_geta(), mount(), and namrepl().

{
    int32   i;          /* Count of characters found    */

    /* Search until a null terminator or length reaches max */

    for (i=0; i < maxlen; i++) {
        if (*name++ == NULLCH) {
            return i+1; /* Include NULLCH in length */
        }
    }
    return SYSERR;
}

Here is the caller graph for this function:

nammap()

devcall nammap	(	char *	,
		char	[],
		did32
	)

Referenced by namopen().

Here is the caller graph for this function:

namopen()

devcall namopen	(	struct dentry *	,
		char *	,
		char *
	)

Definition at line 9 of file namopen.c.

References dentry::dvnum, nammap(), newdev(), NM_MAXLEN, open(), and SYSERR.

{
    char    newname[NM_MAXLEN]; /* Name with prefix replaced    */
    did32   newdev;         /* Device ID after mapping  */

    /* Use namespace to map name to a new name and new descriptor */

    newdev = nammap(name, newname, devptr->dvnum);
    
    if (newdev == SYSERR) {
        return SYSERR;
    }

    /* Open underlying device and return status */

    return  open(newdev, newname, mode);
}

Here is the call graph for this function:

namrepl()

did32 namrepl	(	char *	,
		char	[]
	)

net_init()

void net_init

(

void

)

Definition at line 15 of file net.c.

References arp_init(), control(), create(), ETH_ADDR_LEN, ETH_CTRL_GET_MAC, ETHER0, getticks(), icmp_init(), ICMP_QSIZ, ICMP_SLOTS, ipoqueue, ipout(), iqentry::iqhead, iqentry::iqsem, iqentry::iqtail, memset(), mkbufpool(), netbufpool, NetData, netin(), netportseed, NETPRIO, NETSTK, NULL, NULLCH, PACKLEN, panic(), resume(), semcreate(), SYSERR, udp_init(), UDP_QSIZ, and UDP_SLOTS.

Referenced by nulluser().

{
    int32   nbufs;          /* Total no of buffers      */

    /* Initialize the network data structure */

    memset((char *)&NetData, NULLCH, sizeof(struct network));

    /* Obtain the Ethernet MAC address */

    control(ETHER0, ETH_CTRL_GET_MAC, (int32)NetData.ethucast, 0);

    memset((char *)NetData.ethbcast, 0xFF, ETH_ADDR_LEN);

    /* Initialize the random port seed */

    netportseed = getticks();

    /* Create the network buffer pool */

    nbufs = UDP_SLOTS * UDP_QSIZ + ICMP_SLOTS * ICMP_QSIZ + 1;

    netbufpool = mkbufpool(PACKLEN, nbufs);

    /* Initialize the ARP cache */

    arp_init();

    /* Initialize UDP */

    udp_init();

    /* Initialize ICMP */

    icmp_init();

    /* Initialize the IP output queue */

    ipoqueue.iqhead = 0;
    ipoqueue.iqtail = 0;
    ipoqueue.iqsem = semcreate(0);
    if((int32)ipoqueue.iqsem == SYSERR) {
        panic("Cannot create ip output queue semaphore");
        return;
    }

    /* Create the IP output process */

    resume(create(ipout, NETSTK, NETPRIO, "ipout", 0, NULL));

    /* Create a network input process */

    resume(create(netin, NETSTK, NETPRIO, "netin", 0, NULL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

netin()

process netin

(

void

)

Definition at line 76 of file net.c.

References arp_in(), ETH_ARP, ETH_IP, ETH_IPv6, eth_ntoh(), ETHER0, freebuf(), getbuf(), ip_in(), netbufpool, PACKLEN, panic(), read(), and SYSERR.

Referenced by net_init().

{
    struct  netpacket *pkt;     /* Ptr to current packet    */
    int32   retval;         /* Return value from read   */

    /* Do forever: read a packet from the network and process */

    while(1) {

        /* Allocate a buffer */

        pkt = (struct netpacket *)getbuf(netbufpool);

        /* Obtain next packet that arrives */

        retval = read(ETHER0, (char *)pkt, PACKLEN);
        if(retval == SYSERR) {
            panic("Cannot read from Ethernet\n");
        }

        /* Convert Ethernet Type to host order */

        eth_ntoh(pkt);

        /* Demultiplex on Ethernet type */

        switch (pkt->net_ethtype) {

            case ETH_ARP:           /* Handle ARP   */
            arp_in((struct arppacket *)pkt);
            continue;

            case ETH_IP:            /* Handle IP    */
            ip_in(pkt);
            continue;
    
            case ETH_IPv6:          /* Handle IPv6  */
            freebuf((char *)pkt);
            continue;

            default:    /* Ignore all other incoming packets    */
            freebuf((char *)pkt);
            continue;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

netout()

process netout

(

void

)

newqueue()

qid16 newqueue

(

void

)

グローバルキューテーブルにキューを割り当て、テーブルを初期化する。

newqueue()は、キューテーブルのインデックスNPROC以降にリストの先頭／末尾を作成し、
そのリストに要素を追加できる状態にする。
次にnewqueue()を呼び出された時、キューテーブルの位置に新しいリストの先頭／末尾を配置すべきかは、
newqueue()内のstatic変数nextqidを参照すれば判断できる。

Returns

成功時はリストの先頭ノードインデックス、キューテーブルがオーバフローした場合はSYSERRを返す。

Definition at line 15 of file newqueue.c.

References EMPTY, MAXKEY, MINKEY, NPROC, NQENT, qentry::qkey, qentry::qnext, qentry::qprev, queuehead, queuetab, queuetail, and SYSERR.

Referenced by clkinit(), and sysinit().

{
    static qid16 nextqid = NPROC; /* Next list in queuetab to use   */
    qid16 q;                      /* ID of allocated queue  */

    q = nextqid;
    if (q >= NQENT)
    { /* Check for table overflow   */
        return SYSERR;
    }

    nextqid += 2; /* Increment index for next call*/

    /* Initialize head and tail nodes to form an empty queue */

    queuetab[queuehead(q)].qnext = queuetail(q);
    queuetab[queuehead(q)].qprev = EMPTY;
    queuetab[queuehead(q)].qkey = MAXKEY;
    queuetab[queuetail(q)].qnext = EMPTY;
    queuetab[queuetail(q)].qprev = queuehead(q);
    queuetab[queuetail(q)].qkey = MINKEY;
    return q;
}

Here is the caller graph for this function:

open()

syscall open	(	did32	,
		char *	,
		char *
	)

Definition at line 9 of file open.c.

References devtab, disable(), dentry::dvopen, isbaddev, restore(), and SYSERR.

Referenced by namopen(), shell(), xsh_cat(), and xsh_rdstest().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvopen) (devptr, name, mode);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

outb()

int32 outb	(	int32	,
		int32
	)

outl()

int32 outl	(	int32	,
		int32
	)

outsw()

int32 outsw	(	int32	,
		int32	,
		int32
	)

outw()

int32 outw	(	int32	,
		int32
	)

panic()

void panic

(

char *

msg

)

Panic状態に陥った旨のメッセージを表示し、全てのプロセスを停止させる。

割り込み禁止後にPanicメッセージを表示し、無限ループを行う。

Parameters

[in]

msg

表示するメッセージ

Definition at line 12 of file panic.c.

References disable(), kprintf(), and TRUE.

Referenced by icmp_mkpkt(), irq_dispatch(), lfdballoc(), lfiballoc(), lfsckfmt(), net_init(), netin(), ptinit(), ptsend(), rdsbufalloc(), rdsinit(), rdsprocess(), and rfsinit().

{
    disable(); /* Disable interrupts        */
    kprintf("\n\n\rpanic: %s\n\n", msg);
    while (TRUE)
    {
        ;
    } /* Busy loop forever      */
}

Here is the call graph for this function:

Here is the caller graph for this function:

pci_init()

int32 pci_init

(

void

)

pdump()

void pdump

(

struct netpacket *

)

Definition at line 9 of file pdump.c.

References arppacket::arp_hlen, ARP_HTYPE, arppacket::arp_htype, arppacket::arp_op, ARP_OP_REQ, ARP_OP_RPLY, arppacket::arp_plen, ARP_PTYPE, arppacket::arp_ptype, arppacket::arp_sndha, arppacket::arp_sndpa, arppacket::arp_tarpa, ETH_HDR_LEN, ICMP_ECHOREPLY, ICMP_ECHOREQST, IP_ICMP, IP_UDP, ipcksum(), kprintf(), netpacket::net_ethdst, netpacket::net_ethsrc, netpacket::net_ethtype, netpacket::net_icident, netpacket::net_icseq, netpacket::net_ictype, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipsrc, netpacket::net_iptos, netpacket::net_ipttl, netpacket::net_udpdport, netpacket::net_udplen, netpacket::net_udpsport, ntohl, ntohs, and UDP_HDR_LEN.

{
    struct  arppacket *aptr;

    kprintf("%02x:%02x:%02x:%02x:%02x:%02x >",
            pptr->net_ethsrc[0],
            pptr->net_ethsrc[1],
            pptr->net_ethsrc[2],
            pptr->net_ethsrc[3],
            pptr->net_ethsrc[4],
            pptr->net_ethsrc[5]
           );
    kprintf(" %02x:%02x:%02x:%02x:%02x:%02x, ",
            pptr->net_ethdst[0],
            pptr->net_ethdst[1],
            pptr->net_ethdst[2],
            pptr->net_ethdst[3],
            pptr->net_ethdst[4],
            pptr->net_ethdst[5]
           );

    kprintf("ethertype ");

    switch (ntohs(pptr->net_ethtype)) {

        case 0x0806:
            kprintf("ARP (0x%04x), length %d: ",
                    ntohs(pptr->net_ethtype),
                    sizeof(struct arppacket));
            aptr = (struct arppacket *)pptr;
            
            if ( (ntohs(aptr->arp_htype) != ARP_HTYPE) ||
                 (ntohs(aptr->arp_ptype) != ARP_PTYPE) ) {
                break;
            }

            kprintf("hard addr len=%d), proto addr len=%d), ",
                    aptr->arp_hlen,
                    aptr->arp_plen);

            if (ntohs(aptr->arp_op) == ARP_OP_REQ) {
                kprintf("Request who-has %d.%d.%d.%d tell %d.%d.%d.%d, ",
                        (ntohl(aptr->arp_tarpa)>>24)&0xff,
                        (ntohl(aptr->arp_tarpa)>>16)&0xff,
                        (ntohl(aptr->arp_tarpa)>>8)&0xff,
                        ntohl(aptr->arp_tarpa)&0xff,
                        (ntohl(aptr->arp_sndpa)>>24)&0xff,
                        (ntohl(aptr->arp_sndpa)>>16)&0xff,
                        (ntohl(aptr->arp_sndpa)>>8)&0xff,
                        ntohl(aptr->arp_sndpa)&0xff);
            } else if (ntohs(aptr->arp_op) == ARP_OP_RPLY) {
                kprintf("Reply %d.%d.%d.%d is-at %02x:%02x:%02x:%02x:%02x:%02x, ",
                        (ntohl(aptr->arp_sndpa)>>24)&0xff,
                        (ntohl(aptr->arp_sndpa)>>16)&0xff,
                        (ntohl(aptr->arp_sndpa)>>8)&0xff,
                        ntohl(aptr->arp_sndpa)&0xff,
                        aptr->arp_sndha[0],
                        aptr->arp_sndha[1],
                        aptr->arp_sndha[2],
                        aptr->arp_sndha[3],
                        aptr->arp_sndha[4],
                        aptr->arp_sndha[5]);
            } else {
                break;
            }

            kprintf("length %d\n", sizeof(struct arppacket) - ETH_HDR_LEN);
            break;

        case 0x0800:
            kprintf("IPv4 (0x%04x), length %d: ",
                    ntohs(pptr->net_ethtype),
                    ntohs(pptr->net_iplen) + ETH_HDR_LEN);
            
            kprintf("(");
            kprintf("tos 0x%01x, ttl %d, id %d, offset %d ",
                    pptr->net_iptos,
                    pptr->net_ipttl,
                    ntohs(pptr->net_ipid),
                    (ntohs(pptr->net_ipfrag) & 0x1fff));

            kprintf("flags ");
            if (ntohs(pptr->net_ipfrag) & 0x4000)
                kprintf("[DF], ");
            else if (ntohs(pptr->net_ipfrag) & 0x2000)
                kprintf("[MF], " );
            else
                kprintf("[none], ");

            kprintf("[ip checksum %s], ",
                    ipcksum(pptr) == 0 ? "ok" : "fail");

            if (pptr->net_ipproto == IP_UDP) {
                kprintf("proto UDP (%d), length %d",
                        pptr->net_ipproto, ntohs(pptr->net_iplen));
                kprintf(")\n");
                kprintf("\t%d.%d.%d.%d > ",
                        (ntohl(pptr->net_ipsrc)>>24)&0xff,
                        (ntohl(pptr->net_ipsrc)>>16)&0xff,
                        (ntohl(pptr->net_ipsrc)>>8)&0xff,
                        (ntohl(pptr->net_ipsrc)&0xff));
                kprintf("%d.%d.%d.%d: ",
                        (ntohl(pptr->net_ipdst)>>24)&0xff,
                        (ntohl(pptr->net_ipdst)>>16)&0xff,
                        (ntohl(pptr->net_ipdst)>>8)&0xff,
                        (ntohl(pptr->net_ipdst)&0xff));
                kprintf("[udp checksum none] ");
                kprintf("UDP, src port %d, dst port %d, length %d\n",
                        ntohs(pptr->net_udpsport),
                        ntohs(pptr->net_udpdport),
                        ntohs(pptr->net_udplen) - UDP_HDR_LEN);
                break;
            } else if (pptr->net_ipproto == IP_ICMP) {
                kprintf("proto ICMP (%d), length %d",
                        pptr->net_ipproto, ntohs(pptr->net_iplen));
                kprintf(")\n");
                kprintf("\t%d.%d.%d.%d > ",
                        (ntohl(pptr->net_ipsrc)>>24)&0xff,
                        (ntohl(pptr->net_ipsrc)>>16)&0xff,
                        (ntohl(pptr->net_ipsrc)>>8)&0xff,
                        (ntohl(pptr->net_ipsrc)&0xff));
                kprintf("%d.%d.%d.%d: ",
                        (ntohl(pptr->net_ipdst)>>24)&0xff,
                        (ntohl(pptr->net_ipdst)>>16)&0xff,
                        (ntohl(pptr->net_ipdst)>>8)&0xff,
                        (ntohl(pptr->net_ipdst)&0xff));

                if (pptr->net_ictype == ICMP_ECHOREQST)
                    kprintf("ICMP echo request, ");
                else if (pptr->net_ictype == ICMP_ECHOREPLY)
                    kprintf("ICMP echo reply, ");
                else
                    break;

                kprintf("id %d, seq %d\n",
                        ntohs(pptr->net_icident),
                        ntohs(pptr->net_icseq));
                
                break;
            }
            else
                break;
        default:
            kprintf("unknown\n");
            break;

    }

    return;
}

Here is the call graph for this function:

pdumph()

void pdumph

(

struct netpacket *

)

Definition at line 164 of file pdump.c.

References arppacket::arp_hlen, ARP_HTYPE, arppacket::arp_htype, arppacket::arp_op, ARP_OP_REQ, ARP_OP_RPLY, arppacket::arp_plen, ARP_PTYPE, arppacket::arp_ptype, arppacket::arp_sndha, arppacket::arp_sndpa, arppacket::arp_tarpa, ETH_HDR_LEN, icmp_cksum(), ICMP_ECHOREPLY, ICMP_ECHOREQST, IP_HDR_LEN, IP_ICMP, IP_UDP, ipcksum(), kprintf(), netpacket::net_ethdst, netpacket::net_ethsrc, netpacket::net_ethtype, netpacket::net_icident, netpacket::net_icseq, netpacket::net_ictype, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipsrc, netpacket::net_iptos, netpacket::net_ipttl, netpacket::net_udpdport, netpacket::net_udplen, netpacket::net_udpsport, ntohs, and UDP_HDR_LEN.

{
    struct  arppacket *aptr;

    kprintf("%02x:%02x:%02x:%02x:%02x:%02x >",
            pptr->net_ethsrc[0],
            pptr->net_ethsrc[1],
            pptr->net_ethsrc[2],
            pptr->net_ethsrc[3],
            pptr->net_ethsrc[4],
            pptr->net_ethsrc[5]
           );
    kprintf(" %02x:%02x:%02x:%02x:%02x:%02x, ",
            pptr->net_ethdst[0],
            pptr->net_ethdst[1],
            pptr->net_ethdst[2],
            pptr->net_ethdst[3],
            pptr->net_ethdst[4],
            pptr->net_ethdst[5]
           );

    kprintf("ethertype ");

    switch (pptr->net_ethtype) {

        case 0x0806:
            kprintf("ARP (0x%04x), length %d: ",
                    pptr->net_ethtype,
                    sizeof(struct arppacket));
            aptr = (struct arppacket *)pptr;
            
            if ( (aptr->arp_htype != ARP_HTYPE) ||
                 (aptr->arp_ptype != ARP_PTYPE) ) {
                break;
            }

            kprintf("hard addr len=%d), proto addr len=%d), ",
                    aptr->arp_hlen,
                    aptr->arp_plen);

            if (aptr->arp_op == ARP_OP_REQ) {
                kprintf("Request who-has %d.%d.%d.%d tell %d.%d.%d.%d, ",
                        (aptr->arp_tarpa>>24)&0xff,
                        (aptr->arp_tarpa>>16)&0xff,
                        (aptr->arp_tarpa>>8)&0xff,
                        aptr->arp_tarpa&0xff,
                        (aptr->arp_sndpa>>24)&0xff,
                        (aptr->arp_sndpa>>16)&0xff,
                        (aptr->arp_sndpa>>8)&0xff,
                        aptr->arp_sndpa&0xff);
            } else if (aptr->arp_op == ARP_OP_RPLY) {
                kprintf("Reply %d.%d.%d.%d is-at %02x:%02x:%02x:%02x:%02x:%02x, ",
                        (aptr->arp_sndpa>>24)&0xff,
                        (aptr->arp_sndpa>>16)&0xff,
                        (aptr->arp_sndpa>>8)&0xff,
                        aptr->arp_sndpa&0xff,
                        aptr->arp_sndha[0],
                        aptr->arp_sndha[1],
                        aptr->arp_sndha[2],
                        aptr->arp_sndha[3],
                        aptr->arp_sndha[4],
                        aptr->arp_sndha[5]);
            } else {
                break;
            }

            kprintf("length %d\n", sizeof(struct arppacket) - ETH_HDR_LEN);
            break;

        case 0x0800:
            kprintf("IPv4 (0x%04x), length %d: ",
                    pptr->net_ethtype,
                    pptr->net_iplen + ETH_HDR_LEN);
            
            kprintf("(");
            kprintf("tos 0x%01x, ttl %d, id %d, offset %d ",
                    pptr->net_iptos,
                    pptr->net_ipttl,
                    pptr->net_ipid,
                    pptr->net_ipfrag & 0x1fff);

            kprintf("flags ");
            if (pptr->net_ipfrag & 0x4000)
                kprintf("[DF], ");
            else if (pptr->net_ipfrag & 0x2000)
                kprintf("[MF], " );
            else
                kprintf("[none], ");

            kprintf("[ip checksum %s], ",
                    ipcksum(pptr) == 0 ? "ok" : "fail");

            if (pptr->net_ipproto == IP_UDP) {
                kprintf("proto UDP (%d), length %d",
                        pptr->net_ipproto, pptr->net_iplen);
                kprintf(")\n");
                kprintf("\t%d.%d.%d.%d > ",
                        (pptr->net_ipsrc>>24)&0xff,
                        (pptr->net_ipsrc>>16)&0xff,
                        (pptr->net_ipsrc>>8)&0xff,
                        (pptr->net_ipsrc&0xff));
                kprintf("%d.%d.%d.%d: ",
                        (pptr->net_ipdst>>24)&0xff,
                        (pptr->net_ipdst>>16)&0xff,
                        (pptr->net_ipdst>>8)&0xff,
                        (pptr->net_ipdst&0xff));
                kprintf("[udp checksum none] ");
                kprintf("UDP, src port %d, dst port %d, length %d\n",
                        pptr->net_udpsport,
                        pptr->net_udpdport,
                        pptr->net_udplen - UDP_HDR_LEN);
                break;
            } else if (pptr->net_ipproto == IP_ICMP) {
                kprintf("proto ICMP (%d), length %d",
                        pptr->net_ipproto, pptr->net_iplen);
                kprintf(")\n");
                kprintf("\t%d.%d.%d.%d > ",
                        (pptr->net_ipsrc>>24)&0xff,
                        (pptr->net_ipsrc>>16)&0xff,
                        (pptr->net_ipsrc>>8)&0xff,
                        (pptr->net_ipsrc&0xff));
                kprintf("%d.%d.%d.%d: ",
                        (pptr->net_ipsrc>>24)&0xff,
                        (pptr->net_ipsrc>>16)&0xff,
                        (pptr->net_ipsrc>>8)&0xff,
                        (pptr->net_ipsrc&0xff));

                if (pptr->net_ictype == ICMP_ECHOREQST)
                    kprintf("ICMP echo request, ");
                else if (pptr->net_ictype == ICMP_ECHOREPLY)
                    kprintf("ICMP echo reply, ");
                else
                    break;

                kprintf("id %d, seq %d\n",
                        pptr->net_icident,
                        pptr->net_icseq);
                kprintf("icmp ckeckcum %s\n",
                    icmp_cksum((char *)&pptr->net_ictype,
                    ntohs(pptr->net_iplen)-IP_HDR_LEN)==0?
                    "OK":"failed");
                break;
            }
            else
                break;
        default:
            kprintf("unknown\n");
            break;

    }

    return;
}

Here is the call graph for this function:

platinit()

void platinit

(

void

)

Definition at line 31 of file platinit.c.

References am335x_padctl, AM335X_PADCTL_RXTX, AM335X_PADCTL_TX, CONSOLE, counterinit(), devtab, initintc(), uart_csreg::sysc, uart_csreg::syss, UART0_PADRX_ADDR, UART0_PADRX_MODE, UART0_PADTX_ADDR, UART0_PADTX_MODE, UART_SYSC_SOFTRESET, UART_SYSS_RESETDONE, WDTADDR, watchdog_csreg::wspr, and watchdog_csreg::wwps.

Referenced by sysinit().

{

    struct  uart_csreg *uptr;   /* Address of UART's CSRs   */
    struct  watchdog_csreg *wdtptr; /* Watchdog registers       */

    /* Disable the watchdog timer */

    wdtptr = (struct watchdog_csreg *)WDTADDR;
    wdtptr->wspr = 0x0000aaaa;
    while(wdtptr->wwps & 0x00000010);
    wdtptr->wspr = 0x00005555;
    while(wdtptr->wwps & 0x00000010);

    /* Initialize the Interrupt Controller */

    initintc();

    /* Initialize the Performance Counters */

    counterinit();

    /* Pad control for CONSOLE */

    am335x_padctl(UART0_PADRX_ADDR,
            AM335X_PADCTL_RXTX | UART0_PADRX_MODE);
    am335x_padctl(UART0_PADTX_ADDR,
            AM335X_PADCTL_TX | UART0_PADTX_MODE);

    /* Reset the UART device */

    uptr = (struct uart_csreg *)devtab[CONSOLE].dvcsr;
    uptr->sysc |= UART_SYSC_SOFTRESET;
    while((uptr->syss & UART_SYSS_RESETDONE) == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ptcount()

int32 ptcount

(

int32

portid

)

ポートを用いたメッセージ送受信において、メッセージ数を数える。

Step1. 割り込みを禁止する。
Step2. ポートIDが不正値もしくはポートが未割り当ての場合は、割り込み状態を復元し、
処理を終了する。 Step3. 受信メッセージ数（受信用セマフォ数）を数える。
Step4. 受信メッセージ数が0以上の場合は、送信メッセージ数（送信用セマフォ数）を数える。
Step5. 送信メッセージが0以下の場合は、受信メッセージ数にその数（送信者がブロックされた数）を
加算する。
Step6. 割り込み状態を復元する。

Parameters

[in]

portid

ポートID

Returns

成功時は現在ポートで待機中のメッセージ数を返し、ポートIDが不正値もしくは
ポートが未割り当ての場合はSYSERRを返す。

Note

正の値Kは、ポートにK個のメッセージ（送信者がブロックされて送信待機中のメッセージ含む）が
ある事を意味する。負の値Kはポートが空であり、K個のプロセスがメッセージ受信のために
大気中である事を意味する。

Definition at line 25 of file ptcount.c.

References disable(), isbadport, porttab, PT_ALLOC, ptentry::ptrsem, ptentry::ptssem, ptentry::ptstate, restore(), semcount(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    int32 count;           /* Count of messages available   */
    int32 sndcnt;          /* Count of sender semaphore */
    struct ptentry *ptptr; /* Pointer to port table entry   */

    mask = disable();
    if (isbadport(portid) ||
        (ptptr = &porttab[portid])->ptstate != PT_ALLOC)
    {
        restore(mask);
        return SYSERR;
    }

    /* Get count of messages available */

    count = semcount(ptptr->ptrsem);

    /* If messages are waiting, check for blocked senders */

    if (count >= 0)
    {
        sndcnt = semcount(ptptr->ptssem);
        if (sndcnt < 0)
        { /* -sndcnt senders blocked */
            count += -sndcnt;
        }
    }
    restore(mask);
    return count;
}

Here is the call graph for this function:

ptcreate()

syscall ptcreate

(

int32

count

)

未処理のメッセージを「カウント」できるポートを作成する。

Step1. 割り込みを禁止する。
Step2. ポートサイズが0より小さい場合は割り込み状態を復元し、処理を終了する。
Step3. 0〜NPORTS(30)の中で、空きポートIDを探す。
Step4. 空きポートに以下の対応を行う。
　・状態をALLOCに変更
　・送受信セマフォを作成
　・メッセージリストを初期化（先頭と末尾をNULLとする）
　・シーケンス番号を1増加
　・最大待機メッセージ数を設定
Step5. 割り込み状態を復元する。

Parameters

[in]

count

ポートサイズ（未処理メッセージの最大数）

Returns

成功時は割り当てたポートID、ポートサイズが不正な場合はSYSERRを返す。

Definition at line 23 of file ptcreate.c.

References disable(), NPORTS, NULL, porttab, PT_ALLOC, PT_FREE, ptentry::pthead, ptentry::ptmaxcnt, ptnextid, ptentry::ptrsem, ptentry::ptseq, ptentry::ptssem, ptentry::ptstate, ptentry::pttail, restore(), semcreate(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    int32 i;               /* Counts all possible ports */
    int32 ptnum;           /* Candidate port number to try  */
    struct ptentry *ptptr; /* Pointer to port table entry   */

    mask = disable();
    if (count < 0)
    {
        restore(mask);
        return SYSERR;
    }

    for (i = 0; i < NPORTS; i++)
    {                     /* Count all table entries    */
        ptnum = ptnextid; /* Get an entry to check  */
        if (++ptnextid >= NPORTS)
        {
            ptnextid = 0; /* Reset for next iteration   */
        }

        /* Check table entry that corresponds to ID ptnum */

        ptptr = &porttab[ptnum];
        if (ptptr->ptstate == PT_FREE)
        {
            ptptr->ptstate = PT_ALLOC;
            ptptr->ptssem = semcreate(count);
            ptptr->ptrsem = semcreate(0);
            ptptr->pthead = ptptr->pttail = NULL;
            ptptr->ptseq++;
            ptptr->ptmaxcnt = count;
            restore(mask);
            return ptnum;
        }
    }
    restore(mask);
    return SYSERR;
}

Here is the call graph for this function:

ptdelete()

syscall ptdelete	(	int32	portid,
		int32(*)(int32)	disp
	)

ポートを削除し、待機中のプロセスとメッセージを解放する。

Step1. 割り込みを禁止する。
Step2. ポートIDが不正、もしくはポートがALLOC状態でなければ割り込み状態を復元し、処理を終了する。
Step3. ポートを用いたメッセージと待機中プロセスを解放し、セマフォを削除する。
Step4. 次回のポート作成時には、今回削除したポートIDを使用するように設定する。
Step5. 割り込み状態を復元する。

Parameters

[in]	portid	削除対象のポート
[in]	disp	待機メッセージ処分用の関数ポインタ

Returns

成功時はOK、ポートIDが不正もしくはポートがALLOC状態以外の場合はSYSERRを返す。

Definition at line 19 of file ptdelete.c.

References _ptclear(), disable(), isbadport, OK, porttab, PT_ALLOC, PT_FREE, ptnextid, ptentry::ptstate, restore(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    struct ptentry *ptptr; /* Pointer to port table entry   */

    mask = disable();
    if (isbadport(portid) ||
        (ptptr = &porttab[portid])->ptstate != PT_ALLOC)
    {
        restore(mask);
        return SYSERR;
    }
    _ptclear(ptptr, PT_FREE, disp);
    ptnextid = portid;
    restore(mask);
    return OK;
}

Here is the call graph for this function:

ptinit()

syscall ptinit

(

int32

maxmsgs

)

全てのポートを初期化する。

Step1. 全てのポート中の最大メッセージ数分だけメモリを確保する。
メモリが確保できなかった場合はpanic状態となり、再起動が必要となる。
Step2. 全てのポートテーブルエントリをFREE状態として初期化する。
Step3. フリーメッセージリストをリンクさせる。

Parameters

[in]

maxmsgs

全てのポート中の最大メッセージ数

Returns

初期化成功時はOK、メモリ確保失敗時はpanic状態となって再起動が必須となる。

Definition at line 24 of file ptinit.c.

References getmem(), NPORTS, NULL, OK, panic(), porttab, PT_FREE, ptnode::ptnext, ptnextid, ptentry::ptseq, ptentry::ptstate, and SYSERR.

{
    int32 i;                    /* Runs through the port table  */
    struct ptnode *next, *curr; /* Used to build a free list    */

    /* Allocate memory for all messages on all ports */

    ptfree = (struct ptnode *)getmem(maxmsgs * sizeof(struct ptnode));
    if (ptfree == (struct ptnode *)SYSERR)
    {
        panic("ptinit - insufficient memory");
    }

    /* Initialize all port table entries to free */

    for (i = 0; i < NPORTS; i++)
    {
        porttab[i].ptstate = PT_FREE;
        porttab[i].ptseq = 0;
    }
    ptnextid = 0;

    /* Create a free list of message nodes linked together */

    for (curr = next = ptfree; --maxmsgs > 0; curr = next)
    {
        curr->ptnext = ++next;
    }

    /* Set the pointer in the final node to NULL */

    curr->ptnext = NULL;
    return OK;
}

Here is the call graph for this function:

ptrecv()

uint32 ptrecv

(

int32

portid

)

ポートからメッセージを受信する。受信前にメッセージが空の場合はブロッキングする。

Step1. 割り込みを禁止する。
Step2. ポートIDが不正、もしくはポートがALLOC状態でなければ割り込み状態を復元し、処理を終了する。
Step3. 送信側セマフォに空きが出るまで待機する。
セマフォ待機後、以下の状態のいずれかであれば割り込み状態を復元し、処理を終了する。
　・セマフォ待機結果がエラー
　・ポートがALLOC状態以外
　・シーケンス番号が変化した場合
Step4. ポートフリーノードがNULL状態であれば（メッセージを使い果たした場合）、Panic状態とする。
Step5. ポートフリーノードからメッセージノード1個を切り出し、メッセージノードにメッセージを追加する。
Step6. メッセージノードをメッセージリストの末尾に追加する。
Step7. 受信セマフォにシグナルを送る。
Step8. 割り込み状態を復元する。

Parameters

[in]

portid

使用するポートのID

Returns

メッセージ送信時はOKを返し、以下の場合はSYSERRを返す。
　・引数のポートIDが不正
・セマフォ待機結果がエラー
　・ポートがALLOC状態以外
　・シーケンス番号が変化した場合

Definition at line 29 of file ptrecv.c.

References disable(), isbadport, NULL, porttab, PT_ALLOC, ptfree, ptentry::pthead, ptnode::ptmsg, ptnode::ptnext, ptentry::ptrsem, ptentry::ptseq, ptentry::ptssem, ptentry::ptstate, ptentry::pttail, restore(), signal(), SYSERR, and wait().

{
    intmask mask;           /* Saved interrupt mask     */
    struct ptentry *ptptr;  /* Pointer to table entry   */
    int32 seq;              /* Local copy of sequence num.  */
    umsg32 msg;             /* Message to return        */
    struct ptnode *msgnode; /* First node on message list   */

    mask = disable();
    if (isbadport(portid) ||
        (ptptr = &porttab[portid])->ptstate != PT_ALLOC)
    {
        restore(mask);
        return (uint32)SYSERR;
    }

    /* Wait for message and verify that the port is still allocated */

    seq = ptptr->ptseq; /* Record orignal sequence  */
    if (wait(ptptr->ptrsem) == SYSERR || ptptr->ptstate != PT_ALLOC || ptptr->ptseq != seq)
    {
        restore(mask);
        return (uint32)SYSERR;
    }

    /* Dequeue first message that is waiting in the port */

    msgnode = ptptr->pthead;
    msg = msgnode->ptmsg;
    if (ptptr->pthead == ptptr->pttail) /* Delete last item */
        ptptr->pthead = ptptr->pttail = NULL;
    else
        ptptr->pthead = msgnode->ptnext;
    msgnode->ptnext = ptfree; /* Return to free list    */
    ptfree = msgnode;
    signal(ptptr->ptssem);
    restore(mask);
    return msg;
}

Here is the call graph for this function:

ptreset()

syscall ptreset	(	int32	portid,
		int32(*)(int32)	disp
	)

ポートをリセットを行う。

待機中のプロセスとメッセージを解放した後、ポートを再利用できるようにする。
Step1. 割り込みを禁止する。
Step2. ポートIDが不正、もしくはポートがALLOC状態でなければ割り込み状態を復元し、処理を終了する。
Step3. ポートを用いたメッセージと待機中プロセスを解放し、セマフォはリセットする。
Step4. 割り込み状態を復元する。

Parameters

[in]	portid	削除対象のポート
[in]	disp	待機メッセージ処分用の関数ポインタ

Returns

成功時はOK、ポートIDが不正もしくはポートがALLOC状態以外の場合はSYSERRを返す。

Definition at line 21 of file ptreset.c.

References _ptclear(), disable(), isbadport, OK, porttab, PT_ALLOC, ptentry::ptstate, restore(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    struct ptentry *ptptr; /* Pointer to port table entry   */

    mask = disable();
    if (isbadport(portid) ||
        (ptptr = &porttab[portid])->ptstate != PT_ALLOC)
    {
        restore(mask);
        return SYSERR;
    }
    _ptclear(ptptr, PT_ALLOC, disp);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

ptsend()

syscall ptsend	(	int32	portid,
		umsg32	msg
	)

メッセージをキューに追加する事によってポートへメッセージを送信する。

Step1. 割り込みを禁止する。
Step2. ポートIDが不正、もしくはポートがALLOC状態でなければ割り込み状態を復元し、処理を終了する。
Step3. 送信側セマフォに空きが出るまで待機する。
セマフォ待機後、以下の状態のいずれかであれば割り込み状態を復元し、処理を終了する。
　・セマフォ待機結果がエラー
　・ポートがALLOC状態以外
　・シーケンス番号が変化した場合
Step4. ポートフリーノードがNULL状態であれば（メッセージを使い果たした場合）、Panic状態とする。
Step5. ポートフリーノードからメッセージノード1個を切り出し、メッセージノードにメッセージを追加する。
Step6. メッセージノードをメッセージリストの末尾に追加する。
Step7. 受信セマフォにシグナルを送る。
Step8. 割り込み状態を復元する。

Parameters

[in]	portid	使用するポートのID
[in]	msg	送信するメッセージ

Returns

メッセージ送信時はOKを返し、以下の場合はSYSERRを返す。
　・引数のポートIDが不正
・セマフォ待機結果がエラー
　・ポートがALLOC状態以外
　・シーケンス番号が変化した場合

Note

ポートのメッセージノードが枯渇した場合は、システム再起動が必要となる。

Definition at line 31 of file ptsend.c.

References disable(), isbadport, NULL, OK, panic(), porttab, PT_ALLOC, ptfree, ptentry::pthead, ptnode::ptmsg, ptnode::ptnext, ptentry::ptrsem, ptentry::ptseq, ptentry::ptssem, ptentry::ptstate, ptentry::pttail, restore(), signal(), SYSERR, and wait().

{
    intmask mask;            /* Saved interrupt mask        */
    struct ptentry *ptptr;   /* Pointer to table entry  */
    int32 seq;               /* Local copy of sequence num. */
    struct ptnode *msgnode;  /* Allocated message node  */
    struct ptnode *tailnode; /* Last node in port or NULL   */

    mask = disable();
    if (isbadport(portid) ||
        (ptptr = &porttab[portid])->ptstate != PT_ALLOC)
    {
        restore(mask);
        return SYSERR;
    }

    /* Wait for space and verify port has not been reset */
    seq = ptptr->ptseq; /* Record original sequence */
    if (wait(ptptr->ptssem) == SYSERR || ptptr->ptstate != PT_ALLOC || ptptr->ptseq != seq)
    {
        restore(mask);
        return SYSERR;
    }
    if (ptfree == NULL)
    {
        panic("Port system ran out of message nodes");
    }

    /* Obtain node from free list by unlinking */

    msgnode = ptfree;         /* Point to first free node   */
    ptfree = msgnode->ptnext; /* Unlink from the free list  */
    msgnode->ptnext = NULL;   /* Set fields in the node */
    msgnode->ptmsg = msg;

    /* Link into queue for the specified port */

    tailnode = ptptr->pttail;
    if (tailnode == NULL)
    { /* Queue for port was empty   */
        ptptr->pttail = ptptr->pthead = msgnode;
    }
    else
    { /* Insert new node at tail    */
        tailnode->ptnext = msgnode;
        ptptr->pttail = msgnode;
    }
    signal(ptptr->ptrsem);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

putc()

syscall putc	(	did32	descrp,
		char	ch
	)

デバイスへ文字１Byteを送信する。

Step1. 割り込みを禁止する。
Step2. デバイスディスクリプタが不正値の場合は、割り込み状態を復元し、処理を終了する。
Step3. デバイスに応じたputc()処理を行う。
Step4. 割り込み状態を復元する。

Parameters

[in]	descrp	デバイスディスクリプタ
[in]	ch	送信したい文字

Returns

成功時はデバイスに応じた返り値、デバイスディスクリプタが不正値の場合はSYSERRを返す。

Definition at line 18 of file putc.c.

Referenced by fprintf(), printf(), and xsh_cat().

{
    intmask mask;          /* Saved interrupt mask      */
    struct dentry *devptr; /* Entry in device switch table  */
    int32 retval;          /* Value to return to caller */

    mask = disable();
    if (isbaddev(descrp))
    {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *)&devtab[descrp];
    retval = (*devptr->dvputc)(devptr, ch);
    restore(mask);
    return retval;
}

Here is the caller graph for this function:

ramclose()

devcall ramclose

(

struct dentry *

)

Definition at line 9 of file ramclose.c.

References OK.

{
    return OK;
}

raminit()

devcall raminit

(

struct dentry *

)

Definition at line 17 of file raminit.c.

References ramdisk::disk, memcpy(), OK, Ram, RM_BLKS, and RM_BLKSIZ.

{
    memcpy(Ram.disk, "hopeless", 8);
    memcpy(&Ram.disk[8], Ram.disk, RM_BLKSIZ * RM_BLKS - 8);
    return OK;
}

Here is the call graph for this function:

ramopen()

devcall ramopen	(	struct dentry *	,
		char *	,
		char *
	)

Definition at line 10 of file ramopen.c.

References dentry::dvnum.

{
    /* No action -- just return the device descriptor */

    return devptr->dvnum;
}

ramread()

devcall ramread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 10 of file ramread.c.

References ramdisk::disk, memcpy(), OK, Ram, and RM_BLKSIZ.

{
    int32   bpos;           /* Byte position of blk     */

    bpos = RM_BLKSIZ * blk;
    memcpy(buff, &Ram.disk[bpos], RM_BLKSIZ);
    return OK;
}

Here is the call graph for this function:

ramwrite()

devcall ramwrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 10 of file ramwrite.c.

References ramdisk::disk, memcpy(), OK, Ram, and RM_BLKSIZ.

{
    int32   bpos;           /* Byte position of blk     */

    bpos = RM_BLKSIZ * blk;
    memcpy(&Ram.disk[bpos], buff, RM_BLKSIZ);
    return OK;
}

Here is the call graph for this function:

rawin()

process rawin

(

void

)

rdsbufalloc()

struct rdbuff * rdsbufalloc

(

struct rdscblk *

)

Definition at line 9 of file rdsbufalloc.c.

References NULL, panic(), rdscblk::rd_availsem, rdscblk::rd_chnext, rdscblk::rd_ctprev, rdscblk::rd_free, rdbuff::rd_next, rdbuff::rd_prev, rdbuff::rd_refcnt, SYSERR, and wait().

Referenced by rdscontrol(), rdsread(), and rdswrite().

{
    struct  rdbuff  *bptr;      /* Pointer to a buffer      */
    struct  rdbuff  *pptr;      /* Pointer to previous buffer   */
    struct  rdbuff  *nptr;      /* Pointer to next buffer   */

    /* Wait for an available buffer */

    wait(rdptr->rd_availsem);

    /* If free list contains a buffer, extract it */

    bptr = rdptr->rd_free;

    if ( bptr != (struct rdbuff *)NULL ) {
        rdptr->rd_free = bptr->rd_next;
        return bptr;
    }

    /* Extract oldest item in cache that has ref count zero (at */
    /*   least one such entry must exist because the semaphore  */
    /*   had a nonzero count)                   */

    bptr = rdptr->rd_ctprev;
    while (bptr != (struct rdbuff *) &rdptr->rd_chnext) {
        if (bptr->rd_refcnt <= 0) {

            /* Remove from cache and return to caller */

            pptr = bptr->rd_prev;
            nptr = bptr->rd_next;
            pptr->rd_next = nptr;
            nptr->rd_prev = pptr;
            return bptr;
        }
        bptr = bptr->rd_prev;
    }
    panic("Remote disk cannot find an available buffer");
    return (struct rdbuff *)SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rdsclose()

devcall rdsclose

(

struct dentry *

)

Definition at line 9 of file rdsclose.c.

References dentry::dvminor, OK, rdscblk::rd_chnext, rdscblk::rd_ctnext, RD_FREE, rdscblk::rd_free, RD_INVALID, rdbuff::rd_next, RD_OPEN, rdbuff::rd_prev, rdscblk::rd_rhnext, rdscblk::rd_rtnext, rdscblk::rd_state, rdbuff::rd_status, rdstab, and SYSERR.

Referenced by rdscontrol().

{
    struct  rdscblk *rdptr;     /* Ptr to control block entry   */
    struct  rdbuff  *bptr;      /* Ptr to buffer on a list  */
    struct  rdbuff  *nptr;      /* Ptr to next buff on the list */
    int32   nmoved;         /* Number of buffers moved  */

    /* Device must be open */

    rdptr = &rdstab[devptr->dvminor];
    if (rdptr->rd_state != RD_OPEN) {
        return SYSERR;
    }

    /* Request queue must be empty */

    if (rdptr->rd_rhnext != (struct rdbuff *)&rdptr->rd_rtnext) {
        return SYSERR;
    }

    /* Move all buffers from the cache to the free list */

    bptr = rdptr->rd_chnext;
    nmoved = 0;
    while (bptr != (struct rdbuff *)&rdptr->rd_ctnext) {
        nmoved++;

        /* Unlink buffer from cache */

        nptr = bptr->rd_next;
        (bptr->rd_prev)->rd_next = nptr;
        nptr->rd_prev = bptr->rd_prev;

        /* Insert buffer into free list */

        bptr->rd_next = rdptr->rd_free;
    
        rdptr->rd_free = bptr;
        bptr->rd_status = RD_INVALID;

        /* Move to next buffer in the cache */

        bptr = nptr;
    }

    /* Set the state to indicate the device is closed */

    rdptr->rd_state = RD_FREE;
    return OK;
}

Here is the caller graph for this function:

rdscomm()

status rdscomm	(	struct rd_msg_hdr *	,
		int32	,
		struct rd_msg_hdr *	,
		int32	,
		struct rdscblk *
	)

Definition at line 11 of file rdscomm.c.

References disable(), FALSE, getlocalip(), htonl, network::ipvalid, kprintf(), NetData, ntohl, ntohs, OK, rdscblk::rd_loc_port, RD_MSG_RESPONSE, rdscblk::rd_registered, RD_RETRIES, rdscblk::rd_seq, rdscblk::rd_ser_ip, rdscblk::rd_ser_port, RD_TIMEOUT, rdscblk::rd_udpslot, restore(), SYSERR, TIMEOUT, TRUE, udp_recv(), udp_register(), and udp_sendto().

Referenced by rdscontrol(), rdsopen(), and rdsprocess().

{
    intmask     mask;       /* Saved interrupt mask     */
    int32       i;      /* Counts retries       */
    int32       retval;     /* Return value         */
    int32       seq;        /* Sequence for this exchange   */
    uint32      localip;    /* Local IP address     */
    int16       rtype;      /* Reply type in host byte order*/
    bool8       xmit;       /* Should we transmit again?    */
    int32       slot;       /* UDP slot         */

    /* Disable interrupts while testing status */

    mask = disable();

    /* Register the server port, if not registered */

    if ( ! rdptr->rd_registered ) {
        slot = udp_register(0, rdptr->rd_ser_port,
                        rdptr->rd_loc_port);
        if(slot == SYSERR) {
            restore(mask);
            return SYSERR;
        }
        rdptr->rd_udpslot = slot;
        rdptr->rd_registered = TRUE;
    }

    /* Get the local IP address */

    if ( NetData.ipvalid == FALSE ) {
        localip = getlocalip();
        if((int32)localip == SYSERR) {
            restore(mask);
            return SYSERR;
        }
    }
    restore(mask);

    /* Retrieve the saved UDP slot number  */

    slot = rdptr->rd_udpslot;

    /* Assign message next sequence number */

    seq = rdptr->rd_seq++;
    msg->rd_seq = htonl(seq);

    /* Repeat RD_RETRIES times: send message and receive reply */

    xmit = TRUE;
    for (i=0; i<RD_RETRIES; i++) {
        if (xmit) {

        /* Send a copy of the message */

        retval = udp_sendto(slot, rdptr->rd_ser_ip, rdptr->rd_ser_port,
                    (char *)msg, mlen);
        if (retval == SYSERR) {
            kprintf("Cannot send to remote disk server\n\r");
            return SYSERR;
        }
        } else {
        xmit = TRUE;
        }

        /* Receive a reply */

        retval = udp_recv(slot, (char *)reply, rlen,
                        RD_TIMEOUT);

        if (retval == TIMEOUT) {
        continue;
        } else if (retval == SYSERR) {
        kprintf("Error reading remote disk reply\n\r");
        return SYSERR;
        }

        /* Verify that sequence in reply matches request */

        
        if (ntohl(reply->rd_seq) < seq) {
        xmit = FALSE;
        } else if (ntohl(reply->rd_seq) != seq) {
            continue;
        }

        /* Verify the type in the reply matches the request */

        rtype = ntohs(reply->rd_type);
        if (rtype != ( ntohs(msg->rd_type) | RD_MSG_RESPONSE) ) {
        continue;
        }

        /* Check the status */

        if (ntohs(reply->rd_status) != 0) {
        return SYSERR;
        }

        return OK;
    }

    /* Retries exhausted without success */

    kprintf("Timeout on exchange with remote disk server\n\r");
    return TIMEOUT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rdscontrol()

devcall rdscontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file rdscontrol.c.

References dentry::dvminor, getpid(), htons, kprintf(), memset(), ntohs, NULLCH, OK, rdbuff::rd_blknum, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_id, RD_IDLEN, RD_INVALID, RD_MSG_DREQ, rdbuff::rd_next, rdbuff::rd_op, RD_OP_SYNC, RD_OPEN, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rtprev, rdscblk::rd_state, rdbuff::rd_status, RDS_CTL_DEL, RDS_CTL_SYNC, rdsbufalloc(), rdsclose(), rdscomm(), rdstab, receive(), recvclr(), resume(), signal(), SYSERR, TIMEOUT, and TRUE.

{
    struct  rdscblk *rdptr;     /* Pointer to control block */
    struct  rdbuff  *bptr;      /* Ptr to buffer that will be   */
                    /*   placed on the req. queue   */
    struct  rdbuff  *pptr;      /* Ptr to "previous" node on    */
                    /*   a list         */
    struct  rd_msg_dreq msg;    /* Buffer for delete request    */
    struct  rd_msg_dres resp;   /* Buffer for delete response   */
    char    *to, *from;     /* Used during name copy    */
    int32   retval;         /* Return value         */

    /* Verify that device is currently open */

    rdptr = &rdstab[devptr->dvminor];
    if (rdptr->rd_state != RD_OPEN) {
        return SYSERR;
    }

    /* Ensure rdsprocess is runnning */

    if ( ! rdptr->rd_comruns ) {
        rdptr->rd_comruns = TRUE;
        resume(rdptr->rd_comproc);
    }

    switch (func) {

    /* Synchronize writes */

    case RDS_CTL_SYNC:

        /* Allocate a buffer to use for the request list */

        bptr = rdsbufalloc(rdptr);
        if (bptr == (struct rdbuff *)SYSERR) {
            return SYSERR;
        }

        /* Form a sync request */

        bptr->rd_op = RD_OP_SYNC;
        bptr->rd_refcnt = 1;
        bptr->rd_blknum = 0;        /* Unused */
        bptr->rd_status = RD_INVALID;
        bptr->rd_pid = getpid();

        /* Insert new request into list just before tail */

        pptr = rdptr->rd_rtprev;
        rdptr->rd_rtprev = bptr;
        bptr->rd_next = pptr->rd_next;
        bptr->rd_prev = pptr;
        pptr->rd_next = bptr;

        /* Prepare to wait until item is processed */

        recvclr();

        /* Signal then semaphore to start communication */

        signal(rdptr->rd_reqsem);

        /* Block to wait for a message */

        bptr = (struct rdbuff *)receive();
        if (bptr == (struct rdbuff *)SYSERR) {  
            return SYSERR;
        }
        break;

    /* Delete the remote disk (entirely remove it) */

    case RDS_CTL_DEL:

        /* Handcraft a message for the server that requests */
        /*  deleting the disk with the specified ID     */

        msg.rd_type = htons(RD_MSG_DREQ);/* Request deletion    */
        msg.rd_status = htons(0);
        msg.rd_seq = 0; /* rdscomm will insert sequence # later */
        to = msg.rd_id;
        memset(to, NULLCH, RD_IDLEN);   /* Initialize to zeroes */
        from = rdptr->rd_id;
        while ( (*to++ = *from++) != NULLCH ) { /* copy ID  */
            ;
        }

        /* Send message and receive response */

        retval = rdscomm((struct rd_msg_hdr *)&msg,
                    sizeof(struct rd_msg_dreq),
             (struct rd_msg_hdr *)&resp,
                    sizeof(struct rd_msg_dres),
                    rdptr);

        /* Check response */

        if (retval == SYSERR) {
            return SYSERR;
        } else if (retval == TIMEOUT) {
            kprintf("Timeout during remote file delete\n\r");
            return SYSERR;
        } else if (ntohs(resp.rd_status) != 0) {
            return SYSERR;
        }

        /* Close local device */

        return rdsclose(devptr);

    default:
        kprintf("rfsControl: function %d not valid\n\r", func);
        return SYSERR;
    }

    return OK;
}

Here is the call graph for this function:

rdsinit()

devcall rdsinit

(

struct dentry *

)

Definition at line 17 of file rdsinit.c.

References create(), dot2ip(), dentry::dvminor, FALSE, getmem(), NULL, NULLCH, OK, panic(), rdscblk::rd_availsem, RD_BUFFS, rdscblk::rd_chnext, rdscblk::rd_chprev, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_ctnext, rdscblk::rd_ctprev, RD_FREE, rdscblk::rd_free, rdscblk::rd_id, RD_INVALID, RD_LOC_PORT, rdscblk::rd_loc_port, rdbuff::rd_next, RD_PRIO, rdscblk::rd_registered, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rhprev, rdscblk::rd_rtnext, rdscblk::rd_rtprev, rdscblk::rd_seq, rdscblk::rd_ser_ip, rdscblk::rd_ser_port, RD_SERVER_IP, RD_SERVER_PORT, RD_STACK, rdscblk::rd_state, rdbuff::rd_status, rdsprocess(), rdstab, semcreate(), and SYSERR.

{
    struct rdscblk *rdptr; /* Ptr to device contol block    */
    struct rdbuff *bptr;   /* Ptr to buffer in memory   */
    /*   used to form linked list   */
    struct rdbuff *pptr;    /* Ptr to previous buff on list */
    struct rdbuff *buffend; /* Last address in buffer memory*/
    uint32 size;            /* Total size of memory needed  */
    /*   buffers            */

    /* Obtain address of control block */

    rdptr = &rdstab[devptr->dvminor];

    /* Set control block to unused */

    rdptr->rd_state = RD_FREE;

    /* Create the resprocess and leave it suspended.    */
    /*  Note: the process cannot be resumed because */
    /*  device initialization occurs before interrupts  */
    /*  are enabled.                    */

    rdptr->rd_comproc = create(rdsprocess, RD_STACK, RD_PRIO,
                               "rdsproc", 1, rdptr);
    if (rdptr->rd_comproc == SYSERR)
    {
        panic("Cannot create remote disk process");
    }
    rdptr->rd_comruns = FALSE;

    rdptr->rd_id[0] = NULLCH;

    /* Set initial message sequence number */

    rdptr->rd_seq = 1;

    /* Initialize request queue and cache to empty */

    rdptr->rd_rhnext = (struct rdbuff *)&rdptr->rd_rtnext;
    rdptr->rd_rhprev = (struct rdbuff *)NULL;

    rdptr->rd_rtnext = (struct rdbuff *)NULL;
    rdptr->rd_rtprev = (struct rdbuff *)&rdptr->rd_rhnext;

    rdptr->rd_chnext = (struct rdbuff *)&rdptr->rd_ctnext;
    rdptr->rd_chprev = (struct rdbuff *)NULL;

    rdptr->rd_ctnext = (struct rdbuff *)NULL;
    rdptr->rd_ctprev = (struct rdbuff *)&rdptr->rd_chnext;

    /* Allocate memory for a set of buffers (actually request   */
    /*    blocks and link them to form the initial free list    */

    size = sizeof(struct rdbuff) * RD_BUFFS;

    bptr = (struct rdbuff *)getmem(size);
    rdptr->rd_free = bptr;

    if ((int32)bptr == SYSERR)
    {
        panic("Cannot allocate memory for remote disk buffers");
    }

    pptr = (struct rdbuff *)NULL; /* To avoid a compiler warning    */
    buffend = (struct rdbuff *)((char *)bptr + size);
    while (bptr < buffend)
    { /* walk through memory */
        pptr = bptr;
        bptr = (struct rdbuff *)(sizeof(struct rdbuff) + (char *)bptr);
        pptr->rd_status = RD_INVALID; /* Buffer is empty    */
        pptr->rd_next = bptr;         /* Point to next buffer */
    }
    pptr->rd_next = (struct rdbuff *)NULL; /* Last buffer on list   */

    /* Create the request list and available buffer semaphores */

    rdptr->rd_availsem = semcreate(RD_BUFFS);
    rdptr->rd_reqsem = semcreate(0);

    /* Set the server IP address, server port, and local port */

    if (dot2ip(RD_SERVER_IP, &rdptr->rd_ser_ip) == SYSERR)
    {
        panic("invalid IP address for remote disk server");
    }

    /* Set the port numbers */

    rdptr->rd_ser_port = RD_SERVER_PORT;
    rdptr->rd_loc_port = RD_LOC_PORT + devptr->dvminor;

    /* Specify that the server port is not yet registered */

    rdptr->rd_registered = FALSE;

    return OK;
}

Here is the call graph for this function:

rdsopen()

devcall rdsopen	(	struct dentry *	,
		char *	,
		char *
	)

Definition at line 10 of file rdsopen.c.

References dentry::dvminor, dentry::dvnum, htons, kprintf(), memset(), ntohs, NULLCH, RD_FREE, rdscblk::rd_id, RD_IDLEN, RD_MSG_OREQ, RD_OPEN, RD_PEND, rdscblk::rd_state, rdscomm(), rdstab, SYSERR, and TIMEOUT.

{
    struct  rdscblk *rdptr;     /* Ptr to control block entry   */
    struct  rd_msg_oreq msg;    /* Message to be sent       */
    struct  rd_msg_ores resp;   /* Buffer to hold response  */
    int32   retval;         /* Return value from rdscomm    */
    int32   len;            /* Counts chars in diskid   */
    char    *idto;          /* Ptr to ID string copy    */
    char    *idfrom;        /* Pointer into ID string   */

    rdptr = &rdstab[devptr->dvminor];

    /* Reject if device is already open */

    if (rdptr->rd_state != RD_FREE) {
        return SYSERR;
    }
    rdptr->rd_state = RD_PEND;

    /* Copy disk ID into free table slot */

    idto = rdptr->rd_id;
    idfrom = diskid;
    len = 0;
    while ( (*idto++ = *idfrom++) != NULLCH) {
        len++;
        if (len >= RD_IDLEN) {  /* ID string is too long */
            return SYSERR;
        }
    }

    /* Verify that name is non-null */

    if (len == 0) {
        return SYSERR;
    }

    /* Hand-craft an open request message to be sent to the server */

    msg.rd_type = htons(RD_MSG_OREQ);/* Request an open     */
    msg.rd_status = htons(0);
    msg.rd_seq = 0;         /* Rdscomm fills in an entry    */
    idto = msg.rd_id;
    memset(idto, NULLCH, RD_IDLEN);/* initialize ID to zero bytes   */

    idfrom = diskid;
    while ( (*idto++ = *idfrom++) != NULLCH ) { /* Copy ID to req.  */
        ;
    }

    /* Send message and receive response */

    retval = rdscomm((struct rd_msg_hdr *)&msg,
                    sizeof(struct rd_msg_oreq),
             (struct rd_msg_hdr *)&resp,
                    sizeof(struct rd_msg_ores),
                rdptr );

    /* Check response */

    if (retval == SYSERR) {
        rdptr->rd_state = RD_FREE;
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file open\n\r");
        rdptr->rd_state = RD_FREE;
        return SYSERR;
    } else if (ntohs(resp.rd_status) != 0) {
        rdptr->rd_state = RD_FREE;
        return SYSERR;
    }

    /* Change state of device to indicate currently open */

    rdptr->rd_state = RD_OPEN;

    /* Return device descriptor */

    return devptr->dvnum;
}

Here is the call graph for this function:

rdsprocess()

void rdsprocess

(

struct rdscblk *

)

Definition at line 12 of file rdsprocess.c.

References htons, memset(), ntohs, NULLCH, OK, panic(), rdscblk::rd_availsem, rdbuff::rd_blknum, RD_BLKSIZ, rdbuff::rd_block, rdscblk::rd_chnext, rdscblk::rd_free, rdscblk::rd_id, RD_IDLEN, RD_MSG_RREQ, RD_MSG_WREQ, rdbuff::rd_next, rdbuff::rd_op, RD_OP_READ, RD_OP_SYNC, RD_OP_WRITE, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rtnext, rdscomm(), send(), signal(), SYSERR, TIMEOUT, TRUE, and wait().

Referenced by rdsinit().

{
    struct  rd_msg_wreq msg;    /* Message to be sent       */
                    /*   (includes data area)   */
    struct  rd_msg_rres resp;   /* Buffer to hold response  */
                    /*   (includes data area)   */
    int32   retval;         /* Return value from rdscomm    */
    char    *idto;          /* Ptr to ID string copy    */
    char    *idfrom;        /* Ptr into ID string       */
    struct  rdbuff  *bptr;      /* Ptr to buffer at the head of */
                    /*   the request queue      */
    struct  rdbuff  *nptr;      /* Ptr to next buffer on the    */
                    /*   request queue      */
    struct  rdbuff  *pptr;      /* Ptr to previous buffer   */
    struct  rdbuff  *qptr;      /* Ptr that runs along the  */
                    /*   request queue      */
    int32   i;          /* Loop index           */

    while (TRUE) {          /* Do forever */

        /* Wait until the request queue contains a node */
        wait(rdptr->rd_reqsem);
        bptr = rdptr->rd_rhnext;

        /* Use operation in request to determine action */

       switch (bptr->rd_op) {

       case RD_OP_READ:

        /* Build a read request message for the server */

        msg.rd_type = htons(RD_MSG_RREQ);   /* Read request */
        msg.rd_status = htons(0);
        msg.rd_seq = 0;     /* Rdscomm fills in an entry    */
        idto = msg.rd_id;
        memset(idto, NULLCH, RD_IDLEN);/* Initialize ID to zero */
        idfrom = rdptr->rd_id;
        while ( (*idto++ = *idfrom++) != NULLCH ) { /* Copy ID  */
            ;
        }

        /* Send the message and receive a response */

        retval = rdscomm((struct rd_msg_hdr *)&msg,
                    sizeof(struct rd_msg_rreq),
                 (struct rd_msg_hdr *)&resp,
                    sizeof(struct rd_msg_rres),
                  rdptr );

        /* Check response */

        if ( (retval == SYSERR) || (retval == TIMEOUT) ||
                (ntohs(resp.rd_status) != 0) ) {
            panic("Failed to contact remote disk server");
        }

        /* Copy data from the reply into the buffer */

        for (i=0; i<RD_BLKSIZ; i++) {
            bptr->rd_block[i] = resp.rd_data[i];
        }

        /* Unlink buffer from the request queue */

        nptr = bptr->rd_next;
        pptr = bptr->rd_prev;
        nptr->rd_prev = bptr->rd_prev;
        pptr->rd_next = bptr->rd_next;

        /* Insert buffer in the cache */

        pptr = (struct rdbuff *) &rdptr->rd_chnext;
        nptr = pptr->rd_next;
        bptr->rd_next = nptr;
        bptr->rd_prev = pptr;
        pptr->rd_next = bptr;
        nptr->rd_prev = bptr;

        /* Initialize reference count */

        bptr->rd_refcnt = 1;

        /* Signal the available semaphore */

        signal(rdptr->rd_availsem);

        /* Send a message to waiting process */

        send(bptr->rd_pid, (uint32)bptr);

        /* If other processes are waiting to read the  */
        /*   block, notify them and remove the request */

        qptr = rdptr->rd_rhnext;
        while (qptr != (struct rdbuff *)&rdptr->rd_rtnext) {
            if (qptr->rd_blknum == bptr->rd_blknum) {
                bptr->rd_refcnt++;
                send(qptr->rd_pid,(uint32)bptr);

                /* Unlink request from queue    */

                pptr = qptr->rd_prev;
                nptr = qptr->rd_next;
                pptr->rd_next = bptr->rd_next;
                nptr->rd_prev = bptr->rd_prev;

                /* Move buffer to the free list */

                qptr->rd_next = rdptr->rd_free;
                rdptr->rd_free = qptr;
                signal(rdptr->rd_availsem);
                break;
            }
            qptr = qptr->rd_next;
        }
        break;

        case RD_OP_WRITE:

        /* Build a write request message for the server */

        msg.rd_type = htons(RD_MSG_WREQ);   /* Write request*/
        msg.rd_blk = bptr->rd_blknum;
        msg.rd_status = htons(0);
        msg.rd_seq = 0;     /* Rdscomb fills in an entry    */
        idto = msg.rd_id;
        memset(idto, NULLCH, RD_IDLEN);/* Initialize ID to zero */
        idfrom = rdptr->rd_id;
        while ( (*idto++ = *idfrom++) != NULLCH ) { /* Copy ID  */
            ;
        }
        for (i=0; i<RD_BLKSIZ; i++) {
            msg.rd_data[i] = bptr->rd_block[i];
        }

        /* Unlink buffer from request queue */

        nptr = bptr->rd_next;
        pptr = bptr->rd_prev;
        pptr->rd_next = nptr;
        nptr->rd_prev = pptr;

        /* Insert buffer in the cache */

        pptr = (struct rdbuff *) &rdptr->rd_chnext;
        nptr = pptr->rd_next;
        bptr->rd_next = nptr;
        bptr->rd_prev = pptr;
        pptr->rd_next = bptr;
        nptr->rd_prev = bptr;

        /* Declare that buffer is eligible for reuse */

        bptr->rd_refcnt = 0;
        signal(rdptr->rd_availsem);

        /* Send the message and receive a response */

        retval = rdscomm((struct rd_msg_hdr *)&msg,
                    sizeof(struct rd_msg_wreq),
                 (struct rd_msg_hdr *)&resp,
                    sizeof(struct rd_msg_wres),
                  rdptr );

        /* Check response */

        if ( (retval == SYSERR) || (retval == TIMEOUT) ||
                (ntohs(resp.rd_status) != 0) ) {
            panic("failed to contact remote disk server");
        }
        break;

        case RD_OP_SYNC:

        /* Send a message to the waiting process */

        send(bptr->rd_pid, OK);

        /* Unlink buffer from the request queue */

        nptr = bptr->rd_next;
        pptr = bptr->rd_prev;
        nptr->rd_prev = bptr->rd_prev;
        pptr->rd_next = bptr->rd_next;

        /* Insert buffer into the free list */

        bptr->rd_next = rdptr->rd_free;
        rdptr->rd_free = bptr;
        signal(rdptr->rd_availsem);
        break;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rdsread()

devcall rdsread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file rdsread.c.

References dentry::dvminor, getpid(), memcpy(), OK, rdbuff::rd_blknum, RD_BLKSIZ, rdbuff::rd_block, rdscblk::rd_chnext, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_ctnext, rdscblk::rd_free, RD_INVALID, rdbuff::rd_next, rdbuff::rd_op, RD_OP_READ, RD_OP_WRITE, RD_OPEN, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rtprev, rdscblk::rd_state, rdbuff::rd_status, rdsbufalloc(), rdstab, receive(), recvclr(), resume(), signal(), SYSERR, and TRUE.

{
    struct  rdscblk *rdptr;     /* Pointer to control block */
    struct  rdbuff  *bptr;      /* Pointer to buffer possibly   */
                    /*   in the request list    */
    struct  rdbuff  *nptr;      /* Pointer to "next" node on a  */
                    /*   list           */
    struct  rdbuff  *pptr;      /* Pointer to "previous" node   */
                    /*   on a list          */
    struct  rdbuff  *cptr;      /* Pointer that walks the cache */

    /* If device not currently in use, report an error */

    rdptr = &rdstab[devptr->dvminor];
    if (rdptr->rd_state != RD_OPEN) {
        return SYSERR;
    }

    /* Ensure rdsprocess is runnning */

    if ( ! rdptr->rd_comruns ) {
        rdptr->rd_comruns = TRUE;
        resume(rdptr->rd_comproc);
    }

    /* Search the cache for specified block */

    bptr = rdptr->rd_chnext;
    while (bptr != (struct rdbuff *)&rdptr->rd_ctnext) {
        if (bptr->rd_blknum == blk) {
            if (bptr->rd_status == RD_INVALID) {
                break;
            }
            memcpy(buff, bptr->rd_block, RD_BLKSIZ);
            return OK;
        }
        bptr = bptr->rd_next;
    }

    /* Search the request list for most recent occurrence of block */

    bptr = rdptr->rd_rtprev;  /* Start at tail of list */

    while (bptr != (struct rdbuff *)&rdptr->rd_rhnext) {
        if (bptr->rd_blknum == blk)  {

        /* If most recent request for block is write, copy data */

        if (bptr->rd_op == RD_OP_WRITE) {
            memcpy(buff, bptr->rd_block, RD_BLKSIZ);
            return OK;
        }
        break;
        }
        bptr = bptr->rd_prev;
    }

    /* Allocate a buffer and add read request to tail of req. queue */

    bptr = rdsbufalloc(rdptr);  
    bptr->rd_op = RD_OP_READ;
    bptr->rd_refcnt = 1;
    bptr->rd_blknum = blk;
    bptr->rd_status = RD_INVALID;
    bptr->rd_pid = getpid();

    /* Insert new request into list just before tail */

    pptr = rdptr->rd_rtprev;
    rdptr->rd_rtprev = bptr;
    bptr->rd_next = pptr->rd_next;
    bptr->rd_prev = pptr;
    pptr->rd_next = bptr;

    /* Prepare to receive message when read completes */

    recvclr();

    /* Signal the semaphore to start communication */

    signal(rdptr->rd_reqsem);

    /* Block to wait for a message */

    bptr = (struct rdbuff *)receive();
    if (bptr == (struct rdbuff *)SYSERR) {  
        return SYSERR;
    }
    memcpy(buff, bptr->rd_block, RD_BLKSIZ);
    bptr->rd_refcnt--;
    if (bptr->rd_refcnt <= 0) {

        /* Look for previous item in cache with the same block  */
        /*    number to see if this item was only being kept    */
        /*    until pending read completed          */
                
        cptr = rdptr->rd_chnext;
        while (cptr != bptr) {
            if (cptr->rd_blknum == blk) {

                /* Unlink from cache */

                pptr = bptr->rd_prev;
                nptr = bptr->rd_next;
                pptr->rd_next = nptr;
                nptr->rd_prev = pptr;

                /* Add to the free list */

                bptr->rd_next = rdptr->rd_free;
                rdptr->rd_free = bptr;
                break;
            }
            cptr = cptr->rd_next;
        }
    }
    return OK;
}

Here is the call graph for this function:

rdswrite()

devcall rdswrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file rdswrite.c.

References dentry::dvminor, FALSE, getpid(), memcpy(), OK, rdscblk::rd_availsem, rdbuff::rd_blknum, RD_BLKSIZ, rdbuff::rd_block, rdscblk::rd_chnext, rdscblk::rd_comproc, rdscblk::rd_comruns, rdscblk::rd_ctnext, rdbuff::rd_next, rdbuff::rd_op, RD_OP_WRITE, RD_OPEN, rdbuff::rd_pid, rdbuff::rd_prev, rdbuff::rd_refcnt, rdscblk::rd_reqsem, rdscblk::rd_rhnext, rdscblk::rd_rtnext, rdscblk::rd_rtprev, rdscblk::rd_state, rdbuff::rd_status, RD_VALID, rdsbufalloc(), rdstab, resume(), semcount(), semreset(), signal(), SYSERR, and TRUE.

{
    struct  rdscblk *rdptr;     /* Pointer to control block */
    struct  rdbuff  *bptr;      /* Pointer to buffer on a list  */
    struct  rdbuff  *pptr;      /* Ptr to previous buff on list */
    struct  rdbuff  *nptr;      /* Ptr to next buffer on list   */
    bool8   found;          /* Was buff found during search?*/

    /* If device not currently in use, report an error */

    rdptr = &rdstab[devptr->dvminor];
    if (rdptr->rd_state != RD_OPEN) {
        return SYSERR;
    }

    /* Ensure rdsprocess is runnning */

    if ( ! rdptr->rd_comruns ) {
        rdptr->rd_comruns = TRUE;
        resume(rdptr->rd_comproc);
    }

    /* If request queue already contains a write request */
    /*    for the block, replace the contents        */

    bptr = rdptr->rd_rhnext;
    while (bptr != (struct rdbuff *)&rdptr->rd_rtnext) {
        if ( (bptr->rd_blknum == blk) &&
            (bptr->rd_op == RD_OP_WRITE) ) {
            memcpy(bptr->rd_block, buff, RD_BLKSIZ);
            return OK;
        }
        bptr = bptr->rd_next;
    }

    /* Search cache for cached copy of block */

    bptr = rdptr->rd_chnext;
    found = FALSE;
    while (bptr != (struct rdbuff *)&rdptr->rd_ctnext) {
        if (bptr->rd_blknum == blk) {
            if (bptr->rd_refcnt <= 0) {
                pptr = bptr->rd_prev;
                nptr = bptr->rd_next;

                /* Unlink node from cache list and reset*/
                /*   the available semaphore accordingly*/

                pptr->rd_next = bptr->rd_next;
                nptr->rd_prev = bptr->rd_prev;
                semreset(rdptr->rd_availsem,
                    semcount(rdptr->rd_availsem) - 1);
                found = TRUE;
            }
            break;
        }
        bptr = bptr->rd_next;
    }

    if ( !found ) {
        bptr = rdsbufalloc(rdptr);
    }

    /* Create a write request */

    memcpy(bptr->rd_block, buff, RD_BLKSIZ);
    bptr->rd_op = RD_OP_WRITE;
    bptr->rd_refcnt = 0;
    bptr->rd_blknum = blk;
    bptr->rd_status = RD_VALID;
    bptr->rd_pid = getpid();

    /* Insert new request into list just before tail */

    pptr = rdptr->rd_rtprev;
    rdptr->rd_rtprev = bptr;
    bptr->rd_next = pptr->rd_next;
    bptr->rd_prev = pptr;
    pptr->rd_next = bptr;

    /* Signal semaphore to start communication process */

    signal(rdptr->rd_reqsem);
    return OK;
}

Here is the call graph for this function:

read()

syscall read	(	did32	,
		char *	,
		uint32
	)

Definition at line 9 of file read.c.

References devtab, disable(), dentry::dvread, isbaddev, restore(), and SYSERR.

Referenced by lfdballoc(), lfibget(), lfibput(), lfsckfmt(), lfsetup(), lfsopen(), netin(), shell(), xsh_ls(), and xsh_rdstest().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvread) (devptr, buffer, count);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ready()

status ready

(

pid32

pid

)

プロセスをCPUサービスの対象にする。

Step1. PIDが正常値かどうかを確認する。
Step2. プロセス情報を取得し、ステータスをREADY状態に移行する。
Step3. プロセスをREADYリストに挿入する。
Step4. 再スケジューリングを行う。

Parameters

[in]

pid

READY状態に遷移させるプロセスのID

Returns

プロセスがREADY状態となった場合はOK、引数が不正なPIDの場合はSYSERRを返す。

Definition at line 21 of file ready.c.

References insert(), isbadpid, OK, PR_READY, proctab, procent::prprio, procent::prstate, readylist, resched(), and SYSERR.

Referenced by resume(), semdelete(), semreset(), send(), signal(), signaln(), and wakeup().

{
    register struct procent *prptr;

    if (isbadpid(pid))
    {
        return SYSERR;
    }

    /* Set process state to indicate ready and add to ready list */

    prptr = &proctab[pid];
    prptr->prstate = PR_READY;
    insert(pid, readylist, prptr->prprio);
    resched();

    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

receive()

umsg32 receive

(

void

)

メッセージの受信を待ち、受信後にreceive()の呼び出し者にメッセージを返す。

Step1. 割り込みを禁止する。
Step2. 現在のプロセスが有効なメッセージを受信していない場合は受信待ち状態に移行し、
再スケジューリングを行う。
Step3. プロセスが復帰後、メッセージを取得し、メッセージフラグをリセットする。
Step4. 割り込み状態を復元する。

Returns

取得したメッセージを返す。

Definition at line 17 of file receive.c.

References currpid, disable(), FALSE, PR_RECV, procent::prhasmsg, procent::prmsg, proctab, procent::prstate, resched(), and restore().

Referenced by main(), rdscontrol(), rdsread(), and shell().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    umsg32 msg;            /* Message to return     */

    mask = disable();
    prptr = &proctab[currpid];
    if (prptr->prhasmsg == FALSE)
    {
        prptr->prstate = PR_RECV;
        resched(); /* Block until message arrives   */
    }
    msg = prptr->prmsg;      /* Retrieve message        */
    prptr->prhasmsg = FALSE; /* Reset message flag      */
    restore(mask);
    return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recvclr()

umsg32 recvclr

(

void

)

受信メッセージをクリアし、待機している場合はメッセージを返す。

Returns

現在のプロセスが有効なメッセージを持っている場合はその内容を返し、
現在のプロセスが有効なメッセージを持っていない場合はOKを返す。

Note

receive()と異なり、メッセージ受信を待ち続けず、即座にリターンする。

Definition at line 14 of file recvclr.c.

References currpid, disable(), FALSE, OK, procent::prhasmsg, procent::prmsg, proctab, restore(), and TRUE.

Referenced by arp_resolve(), icmp_recv(), main(), rdscontrol(), rdsread(), shell(), udp_recv(), and udp_recvaddr().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    umsg32 msg;            /* Message to return     */

    mask = disable();
    prptr = &proctab[currpid];
    if (prptr->prhasmsg == TRUE)
    {
        msg = prptr->prmsg;      /* Retrieve message        */
        prptr->prhasmsg = FALSE; /* Reset message flag      */
    }
    else
    {
        msg = OK;
    }
    restore(mask);
    return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recvtime()

umsg32 recvtime

(

int32

maxwait

)

Parameters

[in]

maxwait

Returns

Definition at line 17 of file recvtime.c.

References currpid, disable(), FALSE, insertd(), PR_RECTIM, procent::prhasmsg, procent::prmsg, proctab, procent::prstate, resched(), restore(), sleepq, SYSERR, and TIMEOUT.

Referenced by arp_resolve(), icmp_recv(), udp_recv(), and udp_recvaddr().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Tbl entry of current process  */
    umsg32 msg;            /* Message to return     */

    if (maxwait < 0)
    {
        return SYSERR;
    }
    mask = disable();

    /* Schedule wakeup and place process in timed-receive state */

    prptr = &proctab[currpid];
    if (prptr->prhasmsg == FALSE)
    { /* Delay if no message waiting    */
        if (insertd(currpid, sleepq, maxwait) == SYSERR)
        {
            restore(mask);
            return SYSERR;
        }
        prptr->prstate = PR_RECTIM;
        resched();
    }

    /* Either message arrived or timer expired */

    if (prptr->prhasmsg)
    {
        msg = prptr->prmsg;      /* Retrieve message        */
        prptr->prhasmsg = FALSE; /* Reset message indicator */
    }
    else
    {
        msg = TIMEOUT;
    }
    restore(mask);
    return msg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resched()

void resched

(

void

)

最優先の適切なプロセスにCPU実行権を渡す。

resched()は、割り込みが禁止された区間で使用される事を想定している。
Step1. 再スケジューリングを遅延させられている場合、再スケジュールを試みた事を記録して終了する。
Step2. カレント（古い）プロセスのプロセステーブルを取得する
Step3. 「カレントプロセスが現在動作中」かつ「READYリスト先頭プロセスより高優先度」の場合は終了する。
Step4. カレントプロセスの状態を実行中からREADY状態に遷移させ、READYリストに挿入する。
Step5. カレントPIDをREADYリストの先頭プロセスとし、そのプロセスをREADY状態から実行状態に遷移させる。
Step6. プリエンプション（実行中のタスクを一時的に中断する動作）のためのタイムスライスを設定する。
Step7. 古いプロセスから新しいプロセスへコンテキストスイッチを行う。
Step8. 古いプロセスはresume()後に、resched()を即座にリターンする。

Definition at line 22 of file resched.c.

References defer::attempt, ctxsw(), currpid, Defer, dequeue(), firstkey, insert(), defer::ndefers, PR_CURR, PR_READY, preempt, proctab, procent::prprio, procent::prstate, procent::prstkptr, QUANTUM, readylist, and TRUE.

Referenced by clkhandler(), kill(), ready(), receive(), recvtime(), resched_cntl(), sleepms(), suspend(), wait(), and yield().

{
    struct procent *ptold; /* Ptr to table entry for old process    */
    struct procent *ptnew; /* Ptr to table entry for new process    */

    /* If rescheduling is deferred, record attempt and return */

    if (Defer.ndefers > 0)
    {
        Defer.attempt = TRUE;
        return;
    }

    /* Point to process table entry for the current (old) process */

    ptold = &proctab[currpid];

    if (ptold->prstate == PR_CURR)
    { /* Process remains eligible */
        if (ptold->prprio > firstkey(readylist))
        {
            return;
        }

        /* Old process will no longer remain current */

        ptold->prstate = PR_READY;
        insert(currpid, readylist, ptold->prprio);
    }

    /* Force context switch to highest priority ready process */

    currpid = dequeue(readylist);
    ptnew = &proctab[currpid];
    ptnew->prstate = PR_CURR;
    preempt = QUANTUM; /* Reset time slice for process  */
    ctxsw(&ptold->prstkptr, &ptnew->prstkptr);

    /* Old process returns here when resumed */

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resched_cntl()

status resched_cntl

(

int32

defer

)

再スケジューリングを延期させるか、もしくは許可させるかを制御する。

Parameters

[in]

defer

DEFER_START（延期開始）か、DEFER_STOP（延期終了）を指定する。

resched_cntl()は、割り込みが禁止された区間で使用される事を想定している。
引数がDEFER_STARTの場合、以下を実行後にOKを返して終了する。
　・延期されたプロセス数が0の場合は、その数を1に変更
　・延期されたプロセス数が0の場合は、延期中の再スケジューリングは未実施に変更
引数がDEFER_STOPの場合、以下を実行する。
　・延期されたプロセス数が負の値の場合は、SYSERRを返す。
　・「延期されたプロセスが1の場合」かつ「延期中に再スケジューリング実施済み」の場合は再スケジューリングを実施し、OKを返す。 引数が不正な値の場合は、SYSERRを返す。

Definition at line 81 of file resched.c.

References defer::attempt, Defer, DEFER_START, DEFER_STOP, FALSE, defer::ndefers, OK, resched(), and SYSERR.

Referenced by ethhandler(), icmp_release(), irq_dispatch(), semdelete(), semreset(), signaln(), ttyhandler(), udp_release(), and wakeup().

{
    switch (defer)
    {

    case DEFER_START: /* Handle a deferral request */

        if (Defer.ndefers++ == 0)
        {
            Defer.attempt = FALSE;
        }
        return OK;

    case DEFER_STOP: /* Handle end of deferral */
        if (Defer.ndefers <= 0)
        {
            return SYSERR;
        }
        if ((--Defer.ndefers == 0) && Defer.attempt)
        {
            resched();
        }
        return OK;

    default:
        return SYSERR;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

restore()

void restore

(

intmask

)

Referenced by addargs(), arp_in(), arp_resolve(), chprio(), close(), control(), create(), freebuf(), freemem(), getbuf(), getc(), getdev(), getmem(), getprio(), getstk(), icmp_in(), icmp_recv(), icmp_register(), icmp_release(), icmp_send(), init(), ip_enqueue(), ip_send(), kgetc(), kill(), kputc(), mkbufpool(), mount(), open(), ptcount(), ptcreate(), ptdelete(), ptrecv(), ptreset(), ptsend(), putc(), rdscomm(), read(), receive(), recvclr(), recvtime(), resume(), seek(), semcount(), semcreate(), semdelete(), semreset(), send(), signal(), signaln(), sleepms(), suspend(), udp_in(), udp_recv(), udp_recvaddr(), udp_register(), udp_release(), udp_send(), udp_sendto(), unsleep(), wait(), write(), and yield().

resume()

pri16 resume

(

pid32

pid

)

プロセスを休止状態（サスペンド）からREADY状態に遷移させる。

Step1. 割り込み禁止状態とし、割り込みマスクを保持する。
Step2. PIDが正常値かどうかを確認する。
Step3. レジューム対象プロセス情報を取得する。
Step4. レジューム対象プロセス情報は、休止状態（サスペンド状態）かどうかを確認する。
Step5. 現在の優先度を取得する。
Step6. プロセスをREADY状態（CPUサービス対象）にする。
Step7. 割り込み状態（割り込みマスク）を元に戻す。

Parameters

[in]

pid

休止状態からREADY状態に遷移させるプロセスのID

Returns

READY状態となったプロセスの優先度

Definition at line 20 of file resume.c.

References disable(), isbadpid, PR_SUSP, proctab, procent::prprio, procent::prstate, ready(), restore(), and SYSERR.

Referenced by main(), net_init(), nulluser(), rdscontrol(), rdsread(), rdswrite(), shell(), and startup().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    pri16 prio;            /* Priority to return        */

    mask = disable();
    if (isbadpid(pid))
    {
        restore(mask);
        return (pri16)SYSERR;
    }
    prptr = &proctab[pid];
    if (prptr->prstate != PR_SUSP)
    {
        restore(mask);
        return (pri16)SYSERR;
    }
    prio = prptr->prprio; /* Record priority to return  */
    ready(pid);
    restore(mask);
    return prio;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rflclose()

devcall rflclose

(

struct dentry *

)

Definition at line 9 of file rflclose.c.

References dentry::dvminor, OK, Rf_data, RF_FREE, rfdata::rf_mutex, rfltab, rflcblk::rfstate, signal(), SYSERR, and wait().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Verify remote file device is open */

    rfptr = &rfltab[devptr->dvminor];
    if (rfptr->rfstate == RF_FREE) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Mark device closed */

    rfptr->rfstate = RF_FREE;
    signal(Rf_data.rf_mutex);
    return OK;
}

Here is the call graph for this function:

rflgetc()

devcall rflgetc

(

struct dentry *

)

Definition at line 9 of file rflgetc.c.

References rflread(), and SYSERR.

{
    char    ch;         /* Character to read        */
    int32   retval;         /* Return value         */

    retval = rflread(devptr, &ch, 1);

    if (retval != 1) {
        return SYSERR;
    }

    return (devcall)ch;
}

Here is the call graph for this function:

rflinit()

devcall rflinit

(

struct dentry *

)

Definition at line 11 of file rflinit.c.

References dentry::dvminor, dentry::dvnum, NULLCH, OK, RF_FREE, RF_NAMLEN, rflcblk::rfdev, rfltab, rflcblk::rfmode, rflcblk::rfname, rflcblk::rfpos, and rflcblk::rfstate.

{
    struct  rflcblk *rflptr;    /* Ptr. to control block entry  */
    int32   i;          /* Walks through name arrary    */

    rflptr = &rfltab[ devptr->dvminor ];

    /* Initialize entry to unused */

    rflptr->rfstate = RF_FREE;
    rflptr->rfdev = devptr->dvnum;
    for (i=0; i<RF_NAMLEN; i++) {
        rflptr->rfname[i] = NULLCH;
    }
    rflptr->rfpos = rflptr->rfmode = 0;
    return OK;
}

rflputc()

devcall rflputc	(	struct dentry *	,
		char
	)

Definition at line 9 of file rflputc.c.

References OK, rflwrite(), and SYSERR.

{
    if (rflwrite(devptr, &ch, 1) != 1) {
        return SYSERR;
    }

    return OK;
}

Here is the call graph for this function:

rflread()

devcall rflread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file rflread.c.

References dentry::dvminor, htonl, htons, kprintf(), memset(), ntohl, ntohs, NULLCH, Rf_data, RF_DATALEN, RF_FREE, rf_msg_rreq::rf_len, RF_MODE_R, RF_MSG_RREQ, rfdata::rf_mutex, RF_NAMLEN, rf_msg_rreq::rf_pos, rfltab, rflcblk::rfmode, rflcblk::rfname, rflcblk::rfpos, rfscomm(), rflcblk::rfstate, signal(), SYSERR, TIMEOUT, and wait().

Referenced by rflgetc().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */
    int32   retval;         /* Return value         */
    struct  rf_msg_rreq  msg;   /* Request message to send  */
    struct  rf_msg_rres resp;   /* Buffer for response      */
    int32   i;          /* Counts bytes copied      */
    char    *from, *to;     /* Used during name copy    */
    int32   len;            /* Length of name       */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Verify count is legitimate */

    if ( (count <= 0) || (count > RF_DATALEN) ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Verify pseudo-device is in use */

    rfptr = &rfltab[devptr->dvminor];

    /* If device not currently in use, report an error */

    if (rfptr->rfstate == RF_FREE) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Verify pseudo-device allows reading */

    if ((rfptr->rfmode & RF_MODE_R) == 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Form read request */

    msg.rf_type = htons(RF_MSG_RREQ);
    msg.rf_status = htons(0);
    msg.rf_seq = 0;         /* Rfscomm will set sequence    */
    from = rfptr->rfname;
    to = msg.rf_name;
    memset(to, NULLCH, RF_NAMLEN);  /* Start name as all zero bytes */
    len = 0;
    while ( (*to++ = *from++) ) {   /* Copy name to request     */
        if (++len >= RF_NAMLEN) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
    }
    msg.rf_pos = htonl(rfptr->rfpos);/* Set file position       */
    msg.rf_len = htonl(count);  /* Set count of bytes to read   */

    /* Send message and receive response */

    retval = rfscomm((struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_rreq),
             (struct rf_msg_hdr *)&resp,
                    sizeof(struct rf_msg_rres) );

    /* Check response */

    if (retval == SYSERR) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file read\n");
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (ntohs(resp.rf_status) != 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Copy data to application buffer and update file position */

    for (i=0; i<ntohl(resp.rf_len); i++) {
        *buff++ = resp.rf_data[i];
    }
    rfptr->rfpos += ntohl(resp.rf_len);

    signal(Rf_data.rf_mutex);
    return ntohl(resp.rf_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rflseek()

devcall rflseek	(	struct dentry *	,
		uint32
	)

Definition at line 9 of file rflseek.c.

References dentry::dvminor, OK, Rf_data, RF_FREE, rfdata::rf_mutex, rfltab, rflcblk::rfpos, rflcblk::rfstate, signal(), SYSERR, and wait().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Verify remote file device is open */

    rfptr = &rfltab[devptr->dvminor];
    if (rfptr->rfstate == RF_FREE) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Set the new position */

    rfptr->rfpos = pos;
    signal(Rf_data.rf_mutex);
    return OK;
}

Here is the call graph for this function:

rflwrite()

devcall rflwrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file rflwrite.c.

References dentry::dvminor, htonl, htons, kprintf(), memset(), ntohl, ntohs, NULLCH, Rf_data, rf_msg_wreq::rf_data, RF_DATALEN, RF_FREE, rf_msg_wreq::rf_len, RF_MODE_W, RF_MSG_WREQ, rfdata::rf_mutex, RF_NAMLEN, rf_msg_wreq::rf_pos, rfltab, rflcblk::rfmode, rflcblk::rfname, rflcblk::rfpos, rfscomm(), rflcblk::rfstate, signal(), SYSERR, TIMEOUT, and wait().

Referenced by rflputc().

{
    struct  rflcblk *rfptr;     /* Pointer to control block */
    int32   retval;         /* Return value         */
    struct  rf_msg_wreq  msg;   /* Request message to send  */
    struct  rf_msg_wres resp;   /* Buffer for response      */
    char    *from, *to;     /* Used to copy name        */
    int i;          /* Counts bytes copied into req */
    int32   len;            /* Length of name       */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Verify count is legitimate */

    if ( (count <= 0) || (count > RF_DATALEN) ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Verify pseudo-device is in use and mode allows writing */

    rfptr = &rfltab[devptr->dvminor];
    if ( (rfptr->rfstate == RF_FREE) ||
         ! (rfptr->rfmode & RF_MODE_W) ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Form write request */

    msg.rf_type = htons(RF_MSG_WREQ);
    msg.rf_status = htons(0);
    msg.rf_seq = 0;         /* Rfscomm will set sequence    */
    from = rfptr->rfname;
    to = msg.rf_name;
    memset(to, NULLCH, RF_NAMLEN);  /* Start name as all zero bytes */
    len = 0;
    while ( (*to++ = *from++) ) {   /* Copy name to request     */
        if (++len >= RF_NAMLEN) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
    }
    while ( (*to++ = *from++) ) {   /* Copy name into request   */
        ;
    }
    msg.rf_pos = htonl(rfptr->rfpos);/* Set file position       */
    msg.rf_len = htonl(count);  /* Set count of bytes to write  */
    for (i=0; i<count; i++) {   /* Copy data into message   */
        msg.rf_data[i] = *buff++;
    }
    while (i < RF_DATALEN) {
        msg.rf_data[i++] = NULLCH;
    }

    /* Send message and receive response */

    retval = rfscomm((struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_wreq),
             (struct rf_msg_hdr *)&resp,
                sizeof(struct rf_msg_wres) );

    /* Check response */

    if (retval == SYSERR) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file read\n");
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (ntohs(resp.rf_status) != 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Report results to caller */

    rfptr->rfpos += ntohl(resp.rf_len);

    signal(Rf_data.rf_mutex);
    return ntohl(resp.rf_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfscomm()

int32 rfscomm	(	struct rf_msg_hdr *	,
		int32	,
		struct rf_msg_hdr *	,
		int32
	)

Definition at line 10 of file rfscomm.c.

References htonl, kprintf(), ntohl, ntohs, Rf_data, rfdata::rf_loc_port, RF_MSG_RESPONSE, rfdata::rf_registered, RF_RETRIES, rfdata::rf_seq, rfdata::rf_ser_ip, rfdata::rf_ser_port, RF_TIMEOUT, rfdata::rf_udp_slot, SYSERR, TIMEOUT, TRUE, udp_recv(), udp_register(), and udp_send().

Referenced by rflread(), rflwrite(), rfscontrol(), rfsndmsg(), and rfsopen().

{
    int32   i;          /* Counts retries       */
    int32   retval;         /* Return value         */
    int32   seq;            /* Sequence for this exchange   */
    int16   rtype;          /* Reply type in host byte order*/
    int32   slot;           /* UDP slot         */

    /* For the first time after reboot, register the server port */

    if ( ! Rf_data.rf_registered ) {
        if ( (slot = udp_register(Rf_data.rf_ser_ip,
                Rf_data.rf_ser_port,
                Rf_data.rf_loc_port)) == SYSERR) {
            return SYSERR;
        }
        Rf_data.rf_udp_slot = slot;
        Rf_data.rf_registered = TRUE;
    }

    /* Assign message next sequence number */

    seq = Rf_data.rf_seq++;
    msg->rf_seq = htonl(seq);

    /* Repeat RF_RETRIES times: send message and receive reply */

    for (i=0; i<RF_RETRIES; i++) {

        /* Send a copy of the message */

        retval = udp_send(Rf_data.rf_udp_slot, (char *)msg,
            mlen);
        if (retval == SYSERR) {
            kprintf("Cannot send to remote file server\n");
            return SYSERR;
        }

        /* Receive a reply */

        retval = udp_recv(Rf_data.rf_udp_slot, (char *)reply,
            rlen, RF_TIMEOUT);

        if (retval == TIMEOUT) {
            continue;
        } else if (retval == SYSERR) {
            kprintf("Error reading remote file reply\n");
            return SYSERR;
        }

        /* Verify that sequence in reply matches request */

        if (ntohl(reply->rf_seq) != seq) {
            continue;
        }

        /* Verify the type in the reply matches the request */

        rtype = ntohs(reply->rf_type);
        if (rtype != ( ntohs(msg->rf_type) | RF_MSG_RESPONSE) ) {
            continue;
        }

        return retval;      /* Return length to caller */
    }

    /* Retries exhausted without success */

    kprintf("Timeout on exchange with remote file server\n");
    return TIMEOUT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfscontrol()

devcall rfscontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file rfscontrol.c.

References htons, kprintf(), memset(), ntohl, NULLCH, OK, Rf_data, RF_MSG_DREQ, RF_MSG_MREQ, RF_MSG_SREQ, RF_MSG_TREQ, RF_MSG_XREQ, rfdata::rf_mutex, RF_NAMLEN, RFS_CTL_DEL, RFS_CTL_MKDIR, RFS_CTL_RMDIR, RFS_CTL_SIZE, RFS_CTL_TRUNC, rfscomm(), rfsndmsg(), signal(), SYSERR, TIMEOUT, and wait().

{
    int32   len;            /* Length of name       */
    struct  rf_msg_sreq msg;    /* Buffer for size request  */
    struct  rf_msg_sres resp;   /* Buffer for size response */
    char    *to, *from;     /* Used during name copy    */
    int32   retval;         /* Return value         */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Check length of name (copy during the check even though the  */
    /*  copy is only used for a size request)           */

    from = (char *)arg1;
    to = msg.rf_name;
    len = 0;
    memset(to, NULLCH, RF_NAMLEN);  /* Start name as all zeroes */
    while ( (*to++ = *from++) ) {   /* Copy name to message     */
        len++;
        if (len >= (RF_NAMLEN - 1) ) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
    }

    switch (func) {

    /* Delete a file */

    case RFS_CTL_DEL:
        if (rfsndmsg(RF_MSG_DREQ, (char *)arg1) == SYSERR) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
        break;

    /* Truncate a file */

    case RFS_CTL_TRUNC:
        if (rfsndmsg(RF_MSG_TREQ, (char *)arg1) == SYSERR) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
        break;



    /* Make a directory */

    case RFS_CTL_MKDIR:
        if (rfsndmsg(RF_MSG_MREQ, (char *)arg1) == SYSERR) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
        break;

    /* Remove a directory */

    case RFS_CTL_RMDIR:
        if (rfsndmsg(RF_MSG_XREQ, (char *)arg1) == SYSERR) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
        break;

    /* Obtain current file size (cannot use rfsndmsg because a  */
    /*  response contains a value in addition to the header)    */

    case RFS_CTL_SIZE:

        /* Hand-craft a size request message */

        msg.rf_type = htons(RF_MSG_SREQ);
        msg.rf_status = htons(0);
        msg.rf_seq = 0;     /* Rfscomm will set the seq num */

        /* Send the request to server and obtain a response */

        retval = rfscomm( (struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_sreq),
                  (struct rf_msg_hdr *)&resp,
                    sizeof(struct rf_msg_sres) );
        if ( (retval == SYSERR) || (retval == TIMEOUT) ) {
            signal(Rf_data.rf_mutex);
            return SYSERR;
        } else {
            signal(Rf_data.rf_mutex);
            return ntohl(resp.rf_size);
        }

    default:
        kprintf("rfscontrol: function %d not valid\n", func);
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    signal(Rf_data.rf_mutex);
    return OK;
}

Here is the call graph for this function:

rfsgetmode()

int32 rfsgetmode

(

char *

)

Definition at line 10 of file rfsgetmode.c.

References NULLCH, RF_MODE_N, RF_MODE_O, RF_MODE_R, RF_MODE_RW, RF_MODE_W, and SYSERR.

Referenced by rfsopen().

{
    int32   mbits;          /* Mode bits to return (in host */
                    /*    byte order)       */
    char    ch;         /* Next character in mode string*/

    mbits = 0;

    /* Mode string specifies:                   */
    /*  r - read                        */
    /*  w - write                       */
    /*  o - old (file must exist)               */
    /*  n - new (create a new file)             */

    while ( (ch = *mode++) != NULLCH) {
        switch (ch) {

            case 'r':   if (mbits&RF_MODE_R) {
                    return SYSERR;
                }
                mbits |= RF_MODE_R;
                continue;

            case 'w':   if (mbits&RF_MODE_W) {
                    return SYSERR;
                }
                mbits |= RF_MODE_W;
                continue;

            case 'o':   if (mbits&RF_MODE_O || mbits&RF_MODE_N) {
                    return SYSERR;
                }
                mbits |= RF_MODE_O;
                break;

            case 'n':   if (mbits&RF_MODE_O || mbits&RF_MODE_N) {
                    return SYSERR;
                }
                mbits |= RF_MODE_N;
                break;

            default:    return SYSERR;
        }
    }

    /* If neither read nor write specified, allow both */

    if ( (mbits&RF_MODE_RW) == 0 ) {
        mbits |= RF_MODE_RW;
    }
    return mbits;
}

Here is the caller graph for this function:

rfsinit()

devcall rfsinit

(

struct dentry *

)

Definition at line 16 of file rfsinit.c.

References dot2ip(), FALSE, OK, panic(), Rf_data, RF_LOC_PORT, rfdata::rf_loc_port, rfdata::rf_mutex, rfdata::rf_registered, rfdata::rf_seq, rfdata::rf_ser_ip, rfdata::rf_ser_port, RF_SERVER_IP, RF_SERVER_PORT, semcreate(), and SYSERR.

{

    /* Choose an initial message sequence number */

    Rf_data.rf_seq = 1;

    /* Set the server IP address, server port, and local port */

    if (dot2ip(RF_SERVER_IP, &Rf_data.rf_ser_ip) == SYSERR)
    {
        panic("invalid IP address for remote file server");
    }
    Rf_data.rf_ser_port = RF_SERVER_PORT;
    Rf_data.rf_loc_port = RF_LOC_PORT;

    /* Create a mutual exclusion semaphore */

    if ((Rf_data.rf_mutex = semcreate(1)) == SYSERR)
    {
        panic("Cannot create remote file system semaphore");
    }

    /* Specify that the server port is not yet registered */

    Rf_data.rf_registered = FALSE;

    return OK;
}

Here is the call graph for this function:

rfsndmsg()

status rfsndmsg	(	uint16	,
		char *
	)

Definition at line 9 of file rfsndmsg.c.

References htons, kprintf(), ntohl, OK, rfscomm(), SYSERR, and TIMEOUT.

Referenced by rfscontrol().

{
    struct  rf_msg_hdr  req;    /* Request message to send  */
    struct  rf_msg_hdr resp;    /* Buffer for response      */
    int32   retval;         /* Return value         */
    char    *to;            /* Used during name copy    */

    /* Form a request */

    req.rf_type = htons(type);
    req.rf_status = htons(0);
    req.rf_seq = 0;         /* Rfscomm will set sequence    */
    to = req.rf_name;
    while ( (*to++ = *name++) ) {   /* Copy name to request     */
        ;
    }

    /* Send message and receive response */

    retval = rfscomm(&req,  sizeof(struct rf_msg_hdr),
             &resp, sizeof(struct rf_msg_hdr) );

    /* Check response */

    if (retval == SYSERR) {
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file server access\n");
        return SYSERR;
    } else if (ntohl(resp.rf_status) != 0) {
        return SYSERR;
    }

    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rfsopen()

devcall rfsopen	(	struct dentry *	devptr,
		char *	,
		char *
	)

Definition at line 10 of file rfsopen.c.

References htonl, htons, kprintf(), memset(), Nrfl, ntohs, NULLCH, Rf_data, RF_FREE, rf_msg_oreq::rf_mode, RF_MSG_OREQ, rfdata::rf_mutex, RF_NAMLEN, RF_USED, rflcblk::rfdev, rfltab, rflcblk::rfmode, rflcblk::rfname, rflcblk::rfpos, rfscomm(), rfsgetmode(), rflcblk::rfstate, signal(), SYSERR, TIMEOUT, and wait().

{
    struct  rflcblk *rfptr;     /* Ptr to control block entry   */
    struct  rf_msg_oreq msg;    /* Message to be sent       */
    struct  rf_msg_ores resp;   /* Buffer to hold response  */
    int32   retval;         /* Return value from rfscomm    */
    int32   len;            /* Counts chars in name     */
    char    *nptr;          /* Pointer into name string */
    char    *fptr;          /* Pointer into file name   */
    int32   i;          /* General loop index       */

    /* Wait for exclusive access */

    wait(Rf_data.rf_mutex);

    /* Search control block array to find a free entry */

    for(i=0; i<Nrfl; i++) {
        rfptr = &rfltab[i];
        if (rfptr->rfstate == RF_FREE) {
            break;
        }
    }
    if (i >= Nrfl) {        /* No free table slots remain   */
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Copy name into free table slot */

    nptr = name;
    fptr = rfptr->rfname;
    len = 0;
    while ( (*fptr++ = *nptr++) != NULLCH) {
        len++;
        if (len >= RF_NAMLEN) { /* File name is too long    */
            signal(Rf_data.rf_mutex);
            return SYSERR;
        }
    }

    /* Verify that name is non-null */

    if (len==0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Parse mode string */

    if ( (rfptr->rfmode = rfsgetmode(mode)) == SYSERR ) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Form an open request to create a new file or open an old one */

    msg.rf_type = htons(RF_MSG_OREQ);/* Request a file open     */
    msg.rf_status = htons(0);
    msg.rf_seq = 0;         /* Rfscomm fills in seq. number */
    nptr = msg.rf_name;
    memset(nptr, NULLCH, RF_NAMLEN);/* Initialize name to zero bytes*/
    while ( (*nptr++ = *name++) != NULLCH ) { /* Copy name to req.  */
        ;
    }
    msg.rf_mode = htonl(rfptr->rfmode); /* Set mode in request  */

    /* Send message and receive response */

    retval = rfscomm((struct rf_msg_hdr *)&msg,
                    sizeof(struct rf_msg_oreq),
             (struct rf_msg_hdr *)&resp,
                    sizeof(struct rf_msg_ores) );

    /* Check response */

    if (retval == SYSERR) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (retval == TIMEOUT) {
        kprintf("Timeout during remote file open\n\r");
        signal(Rf_data.rf_mutex);
        return SYSERR;
    } else if (ntohs(resp.rf_status) != 0) {
        signal(Rf_data.rf_mutex);
        return SYSERR;
    }

    /* Set initial file position */

    rfptr->rfpos = 0;

    /* Mark state as currently used */

    rfptr->rfstate = RF_USED;

    /* Return device descriptor of newly created pseudo-device */

    signal(Rf_data.rf_mutex);
    return rfptr->rfdev;
}

Here is the call graph for this function:

seek()

syscall seek	(	did32	,
		uint32
	)

Definition at line 9 of file seek.c.

References devtab, disable(), dentry::dvseek, isbaddev, restore(), and SYSERR.

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvseek) (devptr, pos);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

semcount()

syscall semcount

(

sid32

semid

)

セマフォのカウント値を返す。

Step1. 割り込みを禁止する。
Step2. 「セマフォIDが不正値」か「セマフォがFREE状態」の場合、割り込み許可状態に復元して、処理を終了する。
Step3. 引数で渡されたセマフォIDを基に、セマフォテーブルからセマフォのカウント値を取得する。
Step4. 割り込み許可状態に復元する。

Parameters

[in]

semid

セマフォカウンタを確認したいセマフォのID

Returns

成功時はセマフォのカウント値、「不正なセマフォID」や「セマフォがFREE状態の場合はSYSERR」を返す。

Note

セマフォカウンタ値が整数値（正負問わず）のため、SYSERR（-1）と同じ値になる可能性がある。

Definition at line 18 of file semcount.c.

References disable(), isbadsem, restore(), S_FREE, sentry::scount, semtab, and SYSERR.

Referenced by ethhandler(), ip_enqueue(), ptcount(), rdswrite(), ttycontrol(), ttyhandle_in(), ttyhandle_out(), and ttyread().

{
    intmask mask; /* Saved interrupt mask       */
    int32 count;  /* Current sempahore count    */

    mask = disable();

    if (isbadsem(semid) || semtab[semid].sstate == S_FREE)
    {
        restore(mask);
        return SYSERR;
    }
    count = semtab[semid].scount;
    restore(mask);
    return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

semcreate()

sid32 semcreate

(

int32

count

)

未使用セマフォを割り当て、そのセマフォへのインデックス（セマフォID）を返す。

Step1. 割り込みを禁止する
Step2. セマフォカウント初期値が負の値、もしくは未使用のセマフォがない場合は、割り込みを許可状態に復元し、処理を終了する。
Step3. newsem()で取得したセマフォIDを用いて、セマフォテーブルからセマフォを取り出し、セマフォカウントの初期値を設定する。
Step4. 割り込みを許可状態に復元する。

Parameters

[in]

count

セマフォカウントの初期値

Returns

セマフォが生成できた場合は生成したセマフォのID、
「セマフォカウント初期値が負の値」もしくは「未使用のセマフォがない」場合はSYSERRを返す。

Note

セマフォの状態は、newsem()内で未使用→使用に変更されている。

Definition at line 22 of file semcreate.c.

References disable(), newsem(), restore(), sentry::scount, semtab, and SYSERR.

Referenced by ethinit(), lflinit(), lfsinit(), markinit(), mkbufpool(), net_init(), ptcreate(), rdsinit(), rfsinit(), and ttyinit().

{
    intmask mask; /* Saved interrupt mask       */
    sid32 sem;    /* Semaphore ID to return */

    mask = disable();

    if (count < 0 || ((sem = newsem()) == SYSERR))
    {
        restore(mask);
        return SYSERR;
    }
    semtab[sem].scount = count; /* Initialize table entry   */

    restore(mask);
    return sem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

semdelete()

syscall semdelete

(

sid32

sem

)

セマフォテーブルエントリを解放し、セマフォを削除する。

Step1. 割り込みを禁止する。
Step2. セマフォIDが不正の場合は割り込みを許可状態に復元し、処理を終了する。
Step3. 削除したいセマフォの状態がFREEの場合は、割り込みを許可状態に復元し、処理を終了する。
Step4. セマフォの状態をFREEにする。
Step5. 待機状態プロセスを全てREADY状態に移行するまで、再スケジューリングを遅延（Defer）させる。
Step6. キュー操作API（getfirst()）でキューの先頭から順番にプロセスIDを取り出し、READY状態にする。
Step7. 再スケジューリングの遅延を解除する。
Step8. 割り込みを許可状態に戻す。

Parameters

[in]

sem

削除したいセマフォのID

Returns

セマフォの削除を成功した時はOK、
「セマフォIDが不正の場合」や「セマフォ削除前にセマフォがFREE状態の場合」はSYSERRを返す。

Definition at line 22 of file semdelete.c.

References DEFER_START, DEFER_STOP, disable(), getfirst(), isbadsem, OK, ready(), resched_cntl(), restore(), S_FREE, sentry::scount, semtab, sentry::squeue, sentry::sstate, and SYSERR.

Referenced by _ptclear().

{
    intmask mask;          /* Saved interrupt mask      */
    struct sentry *semptr; /* Ptr to semaphore table entry  */

    mask = disable();
    if (isbadsem(sem))
    {
        restore(mask);
        return SYSERR;
    }

    semptr = &semtab[sem];
    if (semptr->sstate == S_FREE)
    {
        restore(mask);
        return SYSERR;
    }
    semptr->sstate = S_FREE;

    resched_cntl(DEFER_START);
    while (semptr->scount++ < 0)
    { /* Free all waiting processes */
        ready(getfirst(semptr->squeue));
    }
    resched_cntl(DEFER_STOP);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

semreset()

syscall semreset	(	sid32	sem,
		int32	count
	)

セマフォカウントをリセットし、待機中のプロセスを全て解放する。

Step1. 割り込みを禁止する。
Step2. 以下のいずれかを満たす場合、割り込みを許可状態に復元し、処理を終了する。
　・引数で渡されたセマフォカウンタのリセット値が負の値の場合
　・引数で渡されたセマフォIDが不整値の場合
　・セマフォがFREE状態の場合
Step3. 待機状態プロセスを全てREADY状態に移行するまで、再スケジューリングを遅延（Defer）させる。
Step4. キュー操作API（getfirst()）でキューの先頭から順番にプロセスIDを取り出し、READY状態にする。
Step5. 再スケジューリングの遅延を解除する。
Step6. 割り込みを許可状態に戻す。

Parameters

[in]	sem	リセット対象のセマフォID
[in]	count	新しいセマフォカウント（0以上の値）

Returns

セマフォカウンタがリセットできた場合はOK、以下の場合はSYSERRを返す。
　・引数で渡されたセマフォカウンタのリセット値が負の値の場合
　・引数で渡されたセマフォIDが不整値の場合
　・セマフォがFREE状態の場合

Definition at line 25 of file semreset.c.

References DEFER_START, DEFER_STOP, disable(), EMPTY, getfirst(), isbadsem, OK, ready(), resched_cntl(), restore(), S_FREE, sentry::scount, semtab, sentry::squeue, sentry::sstate, and SYSERR.

Referenced by _ptclear(), and rdswrite().

{
    intmask mask;          /* Saved interrupt mask      */
    struct sentry *semptr; /* Ptr to semaphore table entry */
    qid16 semqueue;        /* Semaphore's process queue ID  */
    pid32 pid;             /* ID of a waiting process   */

    mask = disable();

    if (count < 0 || isbadsem(sem) || semtab[sem].sstate == S_FREE)
    {
        restore(mask);
        return SYSERR;
    }

    semptr = &semtab[sem];
    semqueue = semptr->squeue; /* Free any waiting processes */
    resched_cntl(DEFER_START);
    while ((pid = getfirst(semqueue)) != EMPTY)
        ready(pid);
    semptr->scount = count; /* Reset count as specified */
    resched_cntl(DEFER_STOP);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

send()

syscall send	(	pid32	pid,
		umsg32	msg
	)

プロセスにメッセージを送信し、受信側が待機状態の場合はREADY状態にする。

Step1. 割り込みを禁止する。
Step2. 引数で渡されたプロセスのIDが不正値の場合は、割り込みを許可状態に復元し、処理を終了する。
Step3. 受信側プロセスが過去のメッセージを未処理の場合は、割り込みを許可状態に復元し、処理を終了する。
Step4. メッセージを受信側プロセスに送信（セット）し、受信側プロセスのメッセージ所持フラグを有効化する。
Step5. 受信側プロセスが受信待ち状態の場合はREADY状態とし、
受信待ちかタイムアウト待ちの場合はプロセスの休眠状態を解除してからREADY状態に変更する。
Step6. 割り込みを許可状態に復元する。

Parameters

[in]	pid	メッセージを受信するプロセスのID
[in]	msg	メッセージ内容（整数かポインタ）

Returns

メッセージを送信した場合はOK、受信側プロセスIDが不正値の場合や受信側プロセスが過去メッセージ未処理の場合はSYSERRを返す。

Definition at line 21 of file send.c.

References disable(), isbadpid, OK, PR_RECTIM, PR_RECV, procent::prhasmsg, procent::prmsg, proctab, procent::prstate, ready(), restore(), SYSERR, TRUE, and unsleep().

Referenced by arp_in(), icmp_in(), kill(), rdsprocess(), and udp_in().

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */

    mask = disable();
    if (isbadpid(pid))
    {
        restore(mask);
        return SYSERR;
    }

    prptr = &proctab[pid];
    if (prptr->prhasmsg)
    {
        restore(mask);
        return SYSERR;
    }
    prptr->prmsg = msg;     /* Deliver message      */
    prptr->prhasmsg = TRUE; /* Indicate message is waiting  */

    /* If recipient waiting or in timed-wait make it ready */

    if (prptr->prstate == PR_RECV)
    {
        ready(pid);
    }
    else if (prptr->prstate == PR_RECTIM)
    {
        unsleep(pid);
        ready(pid);
    }
    restore(mask); /* Restore interrupts */
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_evec()

int32 set_evec	(	uint32	,
		uint32
	)

Definition at line 37 of file evec.c.

References intc_csreg::banks, intc_vector, intc_bank::mir, OK, and SYSERR.

Referenced by clkinit(), ethinit(), gpioinit(), and ttyinit().

{
    struct  intc_csreg *csrptr = (struct intc_csreg *)0x48200000;
    uint32  bank;   /* bank number in int controller    */
    uint32  mask;   /* used to set bits in bank     */

    /* There are only 127 interrupts allowed 0-126 */

    if(xnum > 127) {
        return SYSERR;
    }

    /* Install the handler */

    intc_vector[xnum] = handler;

    /* Get the bank number based on interrupt number */

    bank = (xnum/32);

    /* Get the bit inside the bank */

    mask = (0x00000001 << (xnum%32));

    /* Reset the bit to enable that interrupt number */

    csrptr->banks[bank].mir &= (~mask);

    return OK;
}

Here is the caller graph for this function:

shell()

process shell

(

did32

)

Definition at line 54 of file shell.c.

References addargs(), cmdent::cbuiltin, cmdent::cfunc, cmdent::cname, control(), create(), EOF, F_CTL_TRUNC, FALSE, fprintf(), lexan(), NAMESPACE, ncmd, NULL, NULLCH, OK, open(), procent::prdesc, proctab, read(), receive(), recvclr(), resume(), SH_NEWLINE, SH_TOK_AMPER, SH_TOK_GREATER, SH_TOK_LESS, SH_TOK_OTHER, SHELL_BAN0, SHELL_BAN1, SHELL_BAN2, SHELL_BAN3, SHELL_BAN4, SHELL_BAN5, SHELL_BAN6, SHELL_BAN7, SHELL_BAN8, SHELL_BAN9, SHELL_BGERRMSG, SHELL_BUFLEN, SHELL_CMDPRIO, SHELL_CMDSTK, SHELL_CREATMSG, SHELL_EXIT, SHELL_EXITMSG, SHELL_INERRMSG, SHELL_MAXTOK, SHELL_OUTERRMSG, SHELL_PROMPT, SHELL_STRTMSG, SHELL_SYNERRMSG, SYSERR, and TRUE.

Referenced by main().

{
    char    buf[SHELL_BUFLEN];  /* Input line (large enough for */
                    /*   one line from a tty device */
    int32   len;            /* Length of line read      */
    char    tokbuf[SHELL_BUFLEN +   /* Buffer to hold a set of  */
            SHELL_MAXTOK];  /* Contiguous null-terminated   */
                    /* Strings of tokens        */
    int32   tlen;           /* Current length of all data   */
                    /*   in array tokbuf        */
    int32   tok[SHELL_MAXTOK];  /* Index of each token in   */
                    /*   array tokbuf       */
    int32   toktyp[SHELL_MAXTOK];   /* Type of each token in tokbuf */
    int32   ntok;           /* Number of tokens on line */
    pid32   child;          /* Process ID of spawned child  */
    bool8   backgnd;        /* Run command in background?   */
    char    *outname, *inname;  /* Pointers to strings for file */
                    /*   names that follow > and <  */
    did32   stdinput, stdoutput;    /* Descriptors for redirected   */
                    /*   input and output       */
    int32   i;          /* Index into array of tokens   */
    int32   j;          /* Index into array of commands */
    int32   msg;            /* Message from receive() for   */
                    /*   child termination      */
    int32   tmparg;         /* Address of this var is used  */
                    /*   when first creating child  */
                    /*   process, but is replaced   */
    char    *src, *cmp;     /* Pointers used during name    */
                    /*   comparison         */
    bool8   diff;           /* Was difference found during  */
                    /*   comparison         */
    char    *args[SHELL_MAXTOK];    /* Argument vector passed to    */
                    /*   builtin commands       */

    /* Print shell banner and startup message */

    fprintf(dev, "\n\n%s%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n",
        SHELL_BAN0,SHELL_BAN1,SHELL_BAN2,SHELL_BAN3,SHELL_BAN4,
        SHELL_BAN5,SHELL_BAN6,SHELL_BAN7,SHELL_BAN8,SHELL_BAN9);

    fprintf(dev, "%s\n\n", SHELL_STRTMSG);

    /* Continually prompt the user, read input, and execute command */

    while (TRUE) {

        /* Display prompt */

        fprintf(dev, SHELL_PROMPT);

        /* Read a command */

        len = read(dev, buf, sizeof(buf));

        /* Exit gracefully on end-of-file */

        if (len == EOF) {
            break;
        }

        /* If line contains only NEWLINE, go to next line */

        if (len <= 1) {
            continue;
        }

        buf[len] = SH_NEWLINE;  /* terminate line */

        /* Parse input line and divide into tokens */

        ntok = lexan(buf, len, tokbuf, &tlen, tok, toktyp);

        /* Handle parsing error */

        if (ntok == SYSERR) {
            fprintf(dev,"%s\n", SHELL_SYNERRMSG);
            continue;
        }

        /* If line is empty, go to next input line */

        if (ntok == 0) {
            fprintf(dev, "\n");
            continue;
        }

        /* If last token is '&', set background */

        if (toktyp[ntok-1] == SH_TOK_AMPER) {
            ntok-- ;
            tlen-= 2;
            backgnd = TRUE;
        } else {
            backgnd = FALSE;
        }


        /* Check for input/output redirection (default is none) */

        outname = inname = NULL;
        if ( (ntok >=3) && ( (toktyp[ntok-2] == SH_TOK_LESS)
                   ||(toktyp[ntok-2] == SH_TOK_GREATER))){
            if (toktyp[ntok-1] != SH_TOK_OTHER) {
                fprintf(dev,"%s\n", SHELL_SYNERRMSG);
                continue;
            }
            if (toktyp[ntok-2] == SH_TOK_LESS) {
                inname =  &tokbuf[tok[ntok-1]];
            } else {
                outname = &tokbuf[tok[ntok-1]];
            }
            ntok -= 2;
            tlen = tok[ntok];
        }


        if ( (ntok >=3) && ( (toktyp[ntok-2] == SH_TOK_LESS)
                   ||(toktyp[ntok-2] == SH_TOK_GREATER))){
            if (toktyp[ntok-1] != SH_TOK_OTHER) {
                fprintf(dev,"%s\n", SHELL_SYNERRMSG);
                continue;
            }
            if (toktyp[ntok-2] == SH_TOK_LESS) {
                if (inname != NULL) {
                    fprintf(dev,"%s\n", SHELL_SYNERRMSG);
                    continue;
                }
                inname = &tokbuf[tok[ntok-1]];
            } else {
                if (outname != NULL) {
                    fprintf(dev,"%s\n", SHELL_SYNERRMSG);
                    continue;
                }
                outname = &tokbuf[tok[ntok-1]];
            }
            ntok -= 2;
            tlen = tok[ntok];
        }

        /* Verify remaining tokens are type "other" */

        for (i=0; i<ntok; i++) {
            if (toktyp[i] != SH_TOK_OTHER) {
                break;
            }
        }
        if ((ntok == 0) || (i < ntok)) {
            fprintf(dev, SHELL_SYNERRMSG);
            continue;
        }

        stdinput = stdoutput = dev;

        /* Lookup first token in the command table */

        for (j = 0; j < ncmd; j++) {
            src = cmdtab[j].cname;
            cmp = tokbuf;
            diff = FALSE;
            while (*src != NULLCH) {
                if (*cmp != *src) {
                    diff = TRUE;
                    break;
                }
                src++;
                cmp++;
            }
            if (diff || (*cmp != NULLCH)) {
                continue;
            } else {
                break;
            }
        }

        /* Handle command not found */

        if (j >= ncmd) {
            fprintf(dev, "command %s not found\n", tokbuf);
            continue;
        }

        /* Handle built-in command */

        if (cmdtab[j].cbuiltin) { /* No background or redirect. */
            if (inname != NULL || outname != NULL || backgnd){
                fprintf(dev, SHELL_BGERRMSG);
                continue;
            } else {
                /* Set up arg vector for call */

                for (i=0; i<ntok; i++) {
                    args[i] = &tokbuf[tok[i]];
                }

                /* Call builtin shell function */

                if ((*cmdtab[j].cfunc)(ntok, args)
                            == SHELL_EXIT) {
                    break;
                }
            }
            continue;
        }

        /* Open files and redirect I/O if specified */

        if (inname != NULL) {
            stdinput = open(NAMESPACE,inname,"ro");
            if (stdinput == SYSERR) {
                fprintf(dev, SHELL_INERRMSG, inname);
                continue;
            }
        }
        if (outname != NULL) {
            stdoutput = open(NAMESPACE,outname,"w");
            if (stdoutput == SYSERR) {
                fprintf(dev, SHELL_OUTERRMSG, outname);
                continue;
            } else {
                control(stdoutput, F_CTL_TRUNC, 0, 0);
            }
        }

        /* Spawn child thread for non-built-in commands */

        child = create(cmdtab[j].cfunc,
            SHELL_CMDSTK, SHELL_CMDPRIO,
            cmdtab[j].cname, 2, ntok, &tmparg);

        /* If creation or argument copy fails, report error */

        if ((child == SYSERR) ||
            (addargs(child, ntok, tok, tlen, tokbuf, &tmparg)
                            == SYSERR) ) {
            fprintf(dev, SHELL_CREATMSG);
            continue;
        }

        /* Set stdinput and stdoutput in child to redirect I/O */

        proctab[child].prdesc[0] = stdinput;
        proctab[child].prdesc[1] = stdoutput;

        msg = recvclr();
        resume(child);
        if (! backgnd) {
            msg = receive();
            while (msg != child) {
                msg = receive();
            }
        }
    }

    /* Terminate the shell process by returning from the top level */

    fprintf(dev,SHELL_EXITMSG);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

signal()

syscall signal

(

sid32

sem

)

セマフォにシグナルを送り、待機プロセスがある場合は解除する。

Step1. 割り込みを禁止する。
Step2. 不正なセマフォIDの場合は、割り込みを許可状態に復元し、処理を終了する。
Step3. 引数で渡されたセマフォがFREE状態の場合は、割り込みを許可状態に復元し、処理を終了する。
Step4. セマフォ待ち状態のプロセスがある場合、キューの先頭にあるプロセスをREADY状態にする。
Step5. 割り込みを許可状態に復元する。

Parameters

[in]

sem

シグナルを送信したいセマフォのID

Returns

シグナルを送信した場合はOK、「セマフォIDが不正な場合」や「引数で渡されたセマフォがFREE状態の場合」はSYSERRを返す。

Definition at line 18 of file signal.c.

References dequeue(), disable(), isbadsem, OK, ready(), restore(), S_FREE, sentry::scount, semtab, sentry::squeue, sentry::sstate, and SYSERR.

Referenced by ethhandler(), freebuf(), ip_enqueue(), lflclose(), lflcontrol(), lflgetc(), lflputc(), lflseek(), lfsetup(), lfsopen(), mark(), ptrecv(), ptsend(), rdscontrol(), rdsprocess(), rdsread(), rdswrite(), rflclose(), rflread(), rflseek(), rflwrite(), rfscontrol(), rfsopen(), ttycontrol(), ttyhandle_in(), and xsh_ls().

{
    intmask mask;          /* Saved interrupt mask      */
    struct sentry *semptr; /* Ptr to sempahore table entry  */

    mask = disable();
    if (isbadsem(sem))
    {
        restore(mask);
        return SYSERR;
    }
    semptr = &semtab[sem];
    if (semptr->sstate == S_FREE)
    {
        restore(mask);
        return SYSERR;
    }
    if ((semptr->scount++) < 0)
    { /* Release a waiting process */
        ready(dequeue(semptr->squeue));
    }
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

signaln()

syscall signaln	(	sid32	sem,
		int32	count
	)

セマフォにシグナルをN回送り、N個の待機プロセスがある場合はそれらをREADY状態にする。

基本的な仕様は signal()と同様であり、差異は以下の通りである。
　・待機プロセスがある限り、シグナル送信を続ける事（送信上限は引数で指定された回数）
　・プロセスをREADY状態にする間は再スケジューリングを遅延（Defer）させる事

Parameters

[in]	sem	シグナルを送信したいセマフォのID
[in]	count	シグナルを送信する数（最大）

Returns

シグナルを送信した場合はOK、「セマフォIDが不正な場合」や「引数で渡されたセマフォがFREE状態の場合」はSYSERRを返す。

Definition at line 16 of file signaln.c.

References DEFER_START, DEFER_STOP, dequeue(), disable(), isbadsem, OK, ready(), resched_cntl(), restore(), S_FREE, sentry::scount, semtab, sentry::squeue, sentry::sstate, and SYSERR.

Referenced by ttyhandle_in(), and ttyhandle_out().

{
    intmask mask;          /* Saved interrupt mask      */
    struct sentry *semptr; /* Ptr to sempahore table entry */

    mask = disable();
    if (isbadsem(sem) || (count < 0))
    {
        restore(mask);
        return SYSERR;
    }
    semptr = &semtab[sem];
    if (semptr->sstate == S_FREE)
    {
        restore(mask);
        return SYSERR;
    }

    resched_cntl(DEFER_START);
    for (; count > 0; count--)
    {
        if ((semptr->scount++) < 0)
        {
            ready(dequeue(semptr->squeue));
        }
    }
    resched_cntl(DEFER_STOP);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sleep()

syscall sleep

(

int32

)

Definition at line 11 of file sleep.c.

References MAXSECONDS, OK, sleepms(), and SYSERR.

Referenced by xsh_sleep().

{
    if ( (delay < 0) || (delay > MAXSECONDS) ) {
        return SYSERR;
    }
    sleepms(1000*delay);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sleepms()

syscall sleepms

(

int32

)

Definition at line 26 of file sleep.c.

References currpid, disable(), insertd(), OK, PR_SLEEP, proctab, procent::prstate, resched(), restore(), sleepq, SYSERR, and yield().

Referenced by main(), and sleep().

{
    intmask mask;           /* Saved interrupt mask     */

    if (delay < 0) {
        return SYSERR;
    }

    if (delay == 0) {
        yield();
        return OK;
    }

    /* Delay calling process */

    mask = disable();
    if (insertd(currpid, sleepq, delay) == SYSERR) {
        restore(mask);
        return SYSERR;
    }

    proctab[currpid].prstate = PR_SLEEP;
    resched();
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

spicontrol()

devcall spicontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file spicontrol.c.

References spi_csreg::ch, spi_csreg::chconf, spi_csreg::chrx, spi_csreg::chstat, spi_csreg::chtx, dentry::dvcsr, spi_transfer::length, OK, spi_transfer::rxbuf, SPI_CHCONF_FORCE, SPI_CHSTAT_RXS, SPI_CHSTAT_TXS, SPI_CTRL_TRANSFER, and spi_transfer::txbuf.

{
    struct  spi_csreg *csrptr;  /* SPI control and status regs  */
    struct  spi_transfer *msg;  /* Message pointer      */
    int i;          /* For loop index       */

    /* Get the pointer to the SPI CSRs */

    csrptr = (struct spi_csreg *)devptr->dvcsr;

    /* Get the pointer to the message */

    msg = (struct spi_transfer *)arg1;

    switch(func) {

     /* This is a SPI transfer */

     case SPI_CTRL_TRANSFER:

        for(i = 0; i < msg->length; i++) {

            /* Wait while the transmit register is not empty */

            while((csrptr->ch[0].chstat & SPI_CHSTAT_TXS) == 0);

            /* Send a byte */

            csrptr->ch[0].chtx = msg->txbuf[i];

            /* Wait until there is a byte in the receive register */

            while((csrptr->ch[0].chstat & SPI_CHSTAT_RXS) == 0);

            /* Read the byte from the receive register */

            msg->rxbuf[i] = csrptr->ch[0].chrx;
        }

        /* End the transfer by changing CS level */

        csrptr->ch[0].chconf &= ~SPI_CHCONF_FORCE;
        csrptr->ch[0].chconf |= SPI_CHCONF_FORCE;

        break;
    }

    return OK;
}

spiinit()

int32 spiinit

(

struct dentry *

)

Definition at line 14 of file spiinit.c.

References am335x_padctl, AM335X_PADCTL_PEN, AM335X_PADCTL_PUP, AM335X_PADCTL_RXTX, AM335X_PADCTL_TX, spi_csreg::ch, spi_csreg::chconf, spi_csreg::chctrl, dentry::dvminor, spi_csreg::modulctrl, OK, SPI_0_ADDR, SPI_0_PADCTL_CS0, SPI_0_PADCTL_D0, SPI_0_PADCTL_D1, SPI_0_PADCTL_SCLK, SPI_1_ADDR, SPI_1_PADCTL_CS0, SPI_1_PADCTL_D0, SPI_1_PADCTL_D1, SPI_1_PADCTL_SCLK, SPI_CHCONF_CLKD, SPI_CHCONF_DPE1, SPI_CHCONF_EPOL, SPI_CHCONF_FORCE, SPI_CHCONF_IS, SPI_CHCONF_WL, SPI_CHCTRL_EN, SPI_MODULCTRL_SINGLE, SPI_SYSCONFIG_SOFTRESET, SPI_SYSSTATUS_RESETDONE, spi_csreg::sysconfig, and spi_csreg::sysstatus.

{
    struct spi_csreg *csrptr; /* SPI control and status regs    */

    /* Set the CSR address and the pads */

    if (devptr->dvminor == 0)
    {
        csrptr = (struct spi_csreg *)SPI_0_ADDR;
        am335x_padctl(SPI_0_PADCTL_SCLK, AM335X_PADCTL_PEN |
                                             AM335X_PADCTL_PUP |
                                             AM335X_PADCTL_RXTX |
                                             0);
        am335x_padctl(SPI_0_PADCTL_D0, AM335X_PADCTL_PEN |
                                           AM335X_PADCTL_PUP |
                                           AM335X_PADCTL_TX |
                                           0);
        am335x_padctl(SPI_0_PADCTL_D1, AM335X_PADCTL_PEN |
                                           AM335X_PADCTL_PUP |
                                           AM335X_PADCTL_RXTX |
                                           0);
        am335x_padctl(SPI_0_PADCTL_CS0, AM335X_PADCTL_PEN |
                                            AM335X_PADCTL_PUP |
                                            AM335X_PADCTL_TX |
                                            0);
    }
    else
    {
        *((uint32 *)0x44E00050) = 0x2;
        csrptr = (struct spi_csreg *)SPI_1_ADDR;
        am335x_padctl(SPI_1_PADCTL_SCLK, AM335X_PADCTL_PEN |
                                             AM335X_PADCTL_PUP |
                                             AM335X_PADCTL_RXTX |
                                             3);
        am335x_padctl(SPI_1_PADCTL_D0, AM335X_PADCTL_PEN |
                                           AM335X_PADCTL_PUP |
                                           AM335X_PADCTL_TX |
                                           3);
        am335x_padctl(SPI_1_PADCTL_D1, AM335X_PADCTL_PEN |
                                           AM335X_PADCTL_PUP |
                                           AM335X_PADCTL_RXTX |
                                           3);
        am335x_padctl(SPI_1_PADCTL_CS0, AM335X_PADCTL_PEN |
                                            AM335X_PADCTL_PUP |
                                            AM335X_PADCTL_RXTX |
                                            3);
    }

    /* Reset the SPI device */

    csrptr->sysconfig |= SPI_SYSCONFIG_SOFTRESET;
    while ((csrptr->sysstatus & SPI_SYSSTATUS_RESETDONE) == 0)
        ;

    /* Put the device in single channel mode */

    csrptr->modulctrl = SPI_MODULCTRL_SINGLE;

    /* Set the default frequency and CS level */

    csrptr->ch[0].chconf = SPI_CHCONF_CLKD | SPI_CHCONF_EPOL |
                           (SPI_CHCONF_WL & 0x00000380) |
                           SPI_CHCONF_DPE1 | SPI_CHCONF_IS |
                           SPI_CHCONF_FORCE;

    /* Enable the channel */

    csrptr->ch[0].chctrl |= SPI_CHCTRL_EN;

    return OK;
}

suspend()

syscall suspend

(

pid32

pid

)

プロセスを一時停止し、休止状態（サスペンド）に遷移させる。

Step1. 割り込み禁止状態とし、割り込みマスクを保持する。
Step2. PIDが正常値か、NULLプロセスではないかを確認する。
NULLプロセスが休止状態になった場合、動かすプロセスがREADYリストから無くなる可能性がある。
Step3. サスペンド対象プロセス情報を取得する。
Step4. サスペンド可能なプロセスは、現在実行中かREADY状態のプロセスだけである。
READY状態の場合：READYリストからサスペンド対象プロセスを除外し、サスペンド状態とする。
実行中の場合：サスペンド状態とし、再スケジューリングを行う。
それ以外：割り込み状態（割り込みマスク）を元に戻し、エラー終了
Step5. 現在の優先度を取得する。 Step6. 割り込み状態（割り込みマスク）を元に戻す。

Parameters

[in]

pid

休止状態に移行させるプロセスのID

Returns

一時休止（サスペンド）されたプロセスの優先度

Definition at line 23 of file suspend.c.

References disable(), getitem(), isbadpid, NULLPROC, PR_CURR, PR_READY, PR_SUSP, proctab, procent::prprio, procent::prstate, resched(), restore(), and SYSERR.

{
    intmask mask;          /* Saved interrupt mask      */
    struct procent *prptr; /* Ptr to process's table entry  */
    pri16 prio;            /* Priority to return        */

    mask = disable();
    if (isbadpid(pid) || (pid == NULLPROC))
    {
        restore(mask);
        return SYSERR;
    }

    /* Only suspend a process that is current or ready */

    prptr = &proctab[pid];
    if ((prptr->prstate != PR_CURR) && (prptr->prstate != PR_READY))
    {
        restore(mask);
        return SYSERR;
    }
    if (prptr->prstate == PR_READY)
    {
        getitem(pid); /* Remove a ready process */
                      /*   from the ready list  */
        prptr->prstate = PR_SUSP;
    }
    else
    {
        prptr->prstate = PR_SUSP; /* Mark the current process   */
        resched();                /*   suspended and resched.   */
    }
    prio = prptr->prprio;
    restore(mask);
    return prio;
}

Here is the call graph for this function:

trap()

void trap

(

int32

)

Referenced by irq_dispatch().

Here is the caller graph for this function:

ttycontrol()

devcall ttycontrol	(	struct dentry *	,
		int32	,
		int32	,
		int32
	)

Definition at line 9 of file ttycontrol.c.

References dentry::dvminor, FALSE, OK, semcount(), signal(), SYSERR, TC_ECHO, TC_ICHARS, TC_MODEC, TC_MODEK, TC_MODER, TC_NEXTC, TC_NOECHO, TRUE, ttytab, TY_IMCBREAK, TY_IMCOOKED, TY_IMRAW, ttycblk::tyiecho, ttycblk::tyimode, ttycblk::tyisem, ttycblk::tyitail, and wait().

{
    struct  ttycblk *typtr;     /* Pointer to tty control block */
    char    ch;         /* Character for lookahead  */

    typtr = &ttytab[devptr->dvminor];

    /* Process the request */

    switch ( func ) {

    case TC_NEXTC:
        wait(typtr->tyisem);
        ch = *typtr->tyitail;
        signal(typtr->tyisem);
        return (devcall)ch;

    case TC_MODER:
        typtr->tyimode = TY_IMRAW;
        return (devcall)OK;

    case TC_MODEC:
        typtr->tyimode = TY_IMCOOKED;
        return (devcall)OK;

    case TC_MODEK:
        typtr->tyimode = TY_IMCBREAK;
        return (devcall)OK;

    case TC_ICHARS:
        return(semcount(typtr->tyisem));

    case TC_ECHO:
        typtr->tyiecho = TRUE;
        return (devcall)OK;

    case TC_NOECHO:
        typtr->tyiecho = FALSE;
        return (devcall)OK;

    default:
        return (devcall)SYSERR;
    }
}

Here is the call graph for this function:

ttygetc()

devcall ttygetc

(

struct dentry *

)

Definition at line 9 of file ttygetc.c.

References dentry::dvminor, EOF, ttytab, TY_IBUFLEN, TY_IMCOOKED, ttycblk::tyeof, ttycblk::tyeofch, ttycblk::tyibuff, ttycblk::tyihead, ttycblk::tyimode, ttycblk::tyisem, and wait().

Referenced by ttyread().

{
    char    ch;         /* Character to return      */
    struct  ttycblk *typtr;     /* Pointer to ttytab entry  */

    typtr = &ttytab[devptr->dvminor];

    /* Wait for a character in the buffer and extract one character */

    wait(typtr->tyisem);
    ch = *typtr->tyihead++;

    /* Wrap around to beginning of buffer, if needed */

    if (typtr->tyihead >= &typtr->tyibuff[TY_IBUFLEN]) {
        typtr->tyihead = typtr->tyibuff;
    }

    /* In cooked mode, check for the EOF character */

    if ( (typtr->tyimode == TY_IMCOOKED) && (typtr->tyeof) &&
         (ch == typtr->tyeofch) ) {
        return (devcall)EOF;
    }

    return (devcall)ch;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ttyhandle_in()

void ttyhandle_in	(	struct ttycblk *	,
		struct uart_csreg *
	)

Definition at line 13 of file ttyhandle_in.c.

References uart_csreg::buffer, echoch(), eputc(), erase1(), FALSE, semcount(), signal(), signaln(), TRUE, ttykickout(), TY_IBUFLEN, TY_IMCBREAK, TY_IMRAW, TY_NEWLINE, TY_RETURN, ttycblk::tyeof, ttycblk::tyeofch, ttycblk::tyibuff, ttycblk::tyicrlf, ttycblk::tyicursor, ttycblk::tyiecho, ttycblk::tyierase, ttycblk::tyierasec, ttycblk::tyierasec2, ttycblk::tyifullc, ttycblk::tyikill, ttycblk::tyikillc, ttycblk::tyimode, ttycblk::tyisem, ttycblk::tyitail, ttycblk::tyoflow, ttycblk::tyoheld, ttycblk::tyostart, and ttycblk::tyostop.

Referenced by ttyhandler().

{
    char    ch;         /* Next char from device    */
    int32   avail;          /* Chars available in buffer    */

    ch = csrptr->buffer;

    /* Compute chars available */

    avail = semcount(typtr->tyisem);
    if (avail < 0) {        /* One or more processes waiting*/
        avail = 0;
    }

    /* Handle raw mode */

    if (typtr->tyimode == TY_IMRAW) {
        if (avail >= TY_IBUFLEN) { /* No space => ignore input  */
            return;
        }

        /* Place char in buffer with no editing */

        *typtr->tyitail++ = ch;

        /* Wrap buffer pointer  */

        if (typtr->tyitail >= &typtr->tyibuff[TY_IBUFLEN]) {
            typtr->tyitail = typtr->tyibuff;
        }

        /* Signal input semaphore and return */
        signal(typtr->tyisem);
        return;
    }

    /* Handle cooked and cbreak modes (common part) */

    if ( (ch == TY_RETURN) && typtr->tyicrlf ) {
        ch = TY_NEWLINE;
    }

    /* If flow control is in effect, handle ^S and ^Q */

    if (typtr->tyoflow) {
        if (ch == typtr->tyostart) {        /* ^Q starts output */
            typtr->tyoheld = FALSE;
            ttykickout(csrptr);
            return;
        } else if (ch == typtr->tyostop) {  /* ^S stops output  */
            typtr->tyoheld = TRUE;
            return;
        }
    }

    typtr->tyoheld = FALSE;     /* Any other char starts output */

    if (typtr->tyimode == TY_IMCBREAK) {       /* Just cbreak mode  */

        /* If input buffer is full, send bell to user */

        if (avail >= TY_IBUFLEN) {
            eputc(typtr->tyifullc, typtr, csrptr);
        } else {    /* Input buffer has space for this char */
            *typtr->tyitail++ = ch;

            /* Wrap around buffer */

            if (typtr->tyitail>=&typtr->tyibuff[TY_IBUFLEN]) {
                typtr->tyitail = typtr->tyibuff;
            }
            if (typtr->tyiecho) {   /* Are we echoing chars?*/
                echoch(ch, typtr, csrptr);
            }
            signal(typtr->tyisem);
        }
        return;

    } else {    /* Just cooked mode (see common code above) */

        /* Line kill character arrives - kill entire line */

        if (ch == typtr->tyikillc && typtr->tyikill) {
            typtr->tyitail -= typtr->tyicursor;
            if (typtr->tyitail < typtr->tyibuff) {
                typtr->tyitail += TY_IBUFLEN;
            }
            typtr->tyicursor = 0;
            eputc(TY_RETURN, typtr, csrptr);
            eputc(TY_NEWLINE, typtr, csrptr);
            return;
        }

        /* Erase (backspace) character */

        if ( ((ch==typtr->tyierasec) || (ch==typtr->tyierasec2))
                         && typtr->tyierase) {
            if (typtr->tyicursor > 0) {
                typtr->tyicursor--;
                erase1(typtr, csrptr);
            }
            return;
        }

        /* End of line */

        if ( (ch == TY_NEWLINE) || (ch == TY_RETURN) ) {
            if (typtr->tyiecho) {
                echoch(ch, typtr, csrptr);
            }
            *typtr->tyitail++ = ch;
            if (typtr->tyitail>=&typtr->tyibuff[TY_IBUFLEN]) {
                typtr->tyitail = typtr->tyibuff;
            }
            /* Make entire line (plus \n or \r) available */
            signaln(typtr->tyisem, typtr->tyicursor + 1);
            typtr->tyicursor = 0;   /* Reset for next line  */
            return;
        }

        /* Character to be placed in buffer - send bell if  */
        /*  buffer has overflowed               */

        avail = semcount(typtr->tyisem);
        if (avail < 0) {
            avail = 0;
        }
        if ((avail + typtr->tyicursor) >= TY_IBUFLEN-1) {
            eputc(typtr->tyifullc, typtr, csrptr);
            return;
        }

        /* EOF character: recognize at beginning of line, but   */
        /*  print and ignore otherwise.         */

        if (ch == typtr->tyeofch && typtr->tyeof) {
            if (typtr->tyiecho) {
                echoch(ch, typtr, csrptr);
            }
            if (typtr->tyicursor != 0) {
                return;
            }
            *typtr->tyitail++ = ch;
            signal(typtr->tyisem);
            return;
        }


        /* Echo the character */

        if (typtr->tyiecho) {
            echoch(ch, typtr, csrptr);
        }

        /* Insert in the input buffer */

        typtr->tyicursor++;
        *typtr->tyitail++ = ch;

        /* Wrap around if needed */

        if (typtr->tyitail >= &typtr->tyibuff[TY_IBUFLEN]) {
            typtr->tyitail = typtr->tyibuff;
        }
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ttyhandle_out()

void ttyhandle_out	(	struct ttycblk *	,
		struct uart_csreg *
	)

Definition at line 10 of file ttyhandle_out.c.

References uart_csreg::buffer, uart_csreg::ier, semcount(), signaln(), uart_csreg::txfifo_lvl, TY_EBUFLEN, TY_OBUFLEN, ttycblk::tyebuff, ttycblk::tyehead, ttycblk::tyetail, ttycblk::tyobuff, ttycblk::tyohead, ttycblk::tyoheld, ttycblk::tyosem, UART_FIFO_SIZE, and UART_IER_ETBEI.

Referenced by ttyhandler().

{
    
    int32   ochars;         /* Number of output chars sent  */
                    /*   to the UART        */
    int32   avail;          /* Available chars in output buf*/
    int32   uspace;         /* Space left in onboard UART   */
                    /*   output FIFO        */
    uint32  ier = 0;

    /* If output is currently held, simply ignore the call */

    if (typtr->tyoheld) {
        return;
    }

    /* If echo and output queues empty, turn off interrupts */

    if ( (typtr->tyehead == typtr->tyetail) &&
         (semcount(typtr->tyosem) >= TY_OBUFLEN) ) {
        ier = csrptr->ier;
        csrptr->ier = ier & ~UART_IER_ETBEI;
        return;
    }
    
    /* Initialize uspace to the available space in the Tx FIFO */

    uspace = UART_FIFO_SIZE - csrptr->txfifo_lvl;

    /* While onboard FIFO is not full and the echo queue is */
    /*   nonempty, xmit chars from the echo queue       */

    while ( (uspace>0) &&  typtr->tyehead != typtr->tyetail) {
        csrptr->buffer = *typtr->tyehead++;
        if (typtr->tyehead >= &typtr->tyebuff[TY_EBUFLEN]) {
            typtr->tyehead = typtr->tyebuff;
        }
        uspace--;
    }

    /* While onboard FIFO is not full and the output queue is   */
    /*   nonempty, transmit chars from the output queue     */

    ochars = 0;
    avail = TY_OBUFLEN - semcount(typtr->tyosem);
    while ( (uspace>0) &&  (avail > 0) ) {
        csrptr->buffer = *typtr->tyohead++;
        if (typtr->tyohead >= &typtr->tyobuff[TY_OBUFLEN]) {
            typtr->tyohead = typtr->tyobuff;
        }
        avail--;
        uspace--;
        ochars++;
    }
    if (ochars > 0) {
        signaln(typtr->tyosem, ochars);
    }

    if ( (typtr->tyehead == typtr->tyetail) &&
         (semcount(typtr->tyosem) >= TY_OBUFLEN) ) {
        ier = csrptr->ier;
        csrptr->ier = (ier & ~UART_IER_ETBEI);
    }
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ttyhandler()

void ttyhandler

(

uint32

)

Definition at line 9 of file ttyhandler.c.

References uart_csreg::buffer, CONSOLE, DEFER_START, DEFER_STOP, devtab, dentry::dvcsr, dentry::dvminor, if(), uart_csreg::iir, uart_csreg::lsr, resched_cntl(), ttyhandle_in(), ttyhandle_out(), ttytab, UART_IIR_IDMASK, UART_IIR_IRQ, UART_IIR_MSC, UART_IIR_RDA, UART_IIR_RLSI, UART_IIR_RTO, UART_IIR_THRE, UART_LSR_BI, and UART_LSR_DR.

                             {
    struct  dentry  *devptr;    /* Address of device control blk*/
    struct  ttycblk *typtr;     /* Pointer to ttytab entry  */  
    struct  uart_csreg *csrptr; /* Address of UART's CSR    */
    uint32  iir = 0;        /* Interrupt identification */
    uint32  lsr = 0;        /* Line status          */


    /* Get CSR address of the device (assume console for now) */

    devptr = (struct dentry *) &devtab[CONSOLE];
    csrptr = (struct uart_csreg *) devptr->dvcsr;

    /* Obtain a pointer to the tty control block */

    typtr = &ttytab[ devptr->dvminor ];

    /* Decode hardware interrupt request from UART device */

        /* Check interrupt identification register */
    iir = csrptr->iir;
        if (iir & UART_IIR_IRQ) {
        return;
        }

    /* Decode the interrupt cause based upon the value extracted    */
    /* from the UART interrupt identification register.  Clear  */
    /* the interrupt source and perform the appropriate handling    */
    /* to coordinate with the upper half of the driver      */

        /* Decode the interrupt cause */

    iir &= UART_IIR_IDMASK;     /* Mask off the interrupt ID */
        switch (iir) {

        /* Receiver line status interrupt (error) */

        case UART_IIR_RLSI:
        lsr = csrptr->lsr;
        if(lsr & UART_LSR_BI) { /* Break Interrupt */

            /* Read the RHR register to acknowledge */

            lsr = csrptr->buffer;
        }
        return;

        /* Receiver data available or timed out */

        case UART_IIR_RDA:
        case UART_IIR_RTO:

        resched_cntl(DEFER_START);

        /* While chars avail. in UART buffer, call ttyhandle_in */

        while ( (csrptr->lsr & UART_LSR_DR) != 0) {
            ttyhandle_in(typtr, csrptr);
                }

        resched_cntl(DEFER_STOP);

        return;

            /* Transmitter output FIFO is empty (i.e., ready for more)  */

        case UART_IIR_THRE:
        ttyhandle_out(typtr, csrptr);
        return;

        /* Modem status change (simply ignore) */

        case UART_IIR_MSC:
        return;
        }
}

Here is the call graph for this function:

ttyinit()

devcall ttyinit

(

struct dentry *

)

Definition at line 17 of file ttyinit.c.

References dentry::dvcsr, dentry::dvintr, dentry::dvirq, dentry::dvminor, FALSE, uart_csreg::lcr, uart_csreg::mdr1, OK, semcreate(), set_evec(), TRUE, ttykickout(), ttytab, TY_BACKSP, TY_BACKSP2, TY_EOFCH, TY_FULLCH, TY_IMCOOKED, TY_KILLCH, TY_OBUFLEN, TY_STOPCH, TY_STRTCH, ttycblk::tyebuff, ttycblk::tyecrlf, ttycblk::tyehead, ttycblk::tyeof, ttycblk::tyeofch, ttycblk::tyetail, ttycblk::tyevis, ttycblk::tyibuff, ttycblk::tyicrlf, ttycblk::tyicursor, ttycblk::tyieback, ttycblk::tyiecho, ttycblk::tyierase, ttycblk::tyierasec, ttycblk::tyierasec2, ttycblk::tyifullc, ttycblk::tyihead, ttycblk::tyikill, ttycblk::tyikillc, ttycblk::tyimode, ttycblk::tyisem, ttycblk::tyitail, ttycblk::tyobuff, ttycblk::tyocrlf, ttycblk::tyoflow, ttycblk::tyohead, ttycblk::tyoheld, ttycblk::tyosem, ttycblk::tyostart, ttycblk::tyostop, ttycblk::tyotail, UART_DLL, UART_DLM, UART_FCR_EFIFO, UART_FCR_RRESET, UART_FCR_TRESET, UART_FCR_TRIG2, UART_LCR_8N1, UART_LCR_DLAB, and UART_MDR1_16X.

{
    struct ttycblk *typtr;   /* Pointer to ttytab entry */
    struct uart_csreg *uptr; /* Address of UART's CSRs  */

    typtr = &ttytab[devptr->dvminor];

    /* Initialize values in the tty control block */

    typtr->tyihead = typtr->tyitail =      /* Set up input queue    */
        &typtr->tyibuff[0];                /*    as empty       */
    typtr->tyisem = semcreate(0);          /* Input semaphore   */
    typtr->tyohead = typtr->tyotail =      /* Set up output queue   */
        &typtr->tyobuff[0];                /*    as empty       */
    typtr->tyosem = semcreate(TY_OBUFLEN); /* Output semaphore  */
    typtr->tyehead = typtr->tyetail =      /* Set up echo queue */
        &typtr->tyebuff[0];                /*    as empty       */
    typtr->tyimode = TY_IMCOOKED;          /* Start in cooked mode  */
    typtr->tyiecho = TRUE;                 /* Echo console input    */
    typtr->tyieback = TRUE;                /* Honor erasing bksp    */
    typtr->tyevis = TRUE;                  /* Visual control chars  */
    typtr->tyecrlf = TRUE;                 /* Echo CRLF for NEWLINE*/
    typtr->tyicrlf = TRUE;                 /* Map CR to NEWLINE */
    typtr->tyierase = TRUE;                /* Do erasing backspace  */
    typtr->tyierasec = TY_BACKSP;          /* Primary erase char    */
    typtr->tyierasec2 = TY_BACKSP2;        /* Alternate erase char  */
    typtr->tyeof = TRUE;                   /* Honor eof on input    */
    typtr->tyeofch = TY_EOFCH;             /* End-of-file character*/
    typtr->tyikill = TRUE;                 /* Allow line kill   */
    typtr->tyikillc = TY_KILLCH;           /* Set line kill to ^U   */
    typtr->tyicursor = 0;                  /* Start of input line   */
    typtr->tyoflow = TRUE;                 /* Handle flow control   */
    typtr->tyoheld = FALSE;                /* Output not held   */
    typtr->tyostop = TY_STOPCH;            /* Stop char is ^S   */
    typtr->tyostart = TY_STRTCH;           /* Start char is ^Q  */
    typtr->tyocrlf = TRUE;                 /* Send CRLF for NEWLINE*/
    typtr->tyifullc = TY_FULLCH;           /* Send ^G when buffer   */
                                           /*   is full     */

    /* Initialize the UART */

    uptr = (struct uart_csreg *)devptr->dvcsr;

    /* Set baud rate */
    uptr->lcr = UART_LCR_DLAB;
    uptr->dlm = UART_DLM;
    uptr->dll = UART_DLL;

    uptr->lcr = UART_LCR_8N1; /* 8 bit char, No Parity, 1 Stop*/
    uptr->fcr = 0x00;         /* Disable FIFO for now       */

    /* Register the interrupt dispatcher for the tty device */

    set_evec(devptr->dvirq, (uint32)devptr->dvintr);

    /* Enable interrupts on the device: reset the transmit and  */
    /*   receive FIFOS, and set the interrupt trigger level     */

    uptr->fcr = UART_FCR_EFIFO | UART_FCR_RRESET |
                UART_FCR_TRESET | UART_FCR_TRIG2;

    /* UART must be in 16x mode (TI AM335X specific) */

    uptr->mdr1 = UART_MDR1_16X;

    /* Start the device */

    ttykickout(uptr);
    return OK;
}

Here is the call graph for this function:

ttykickout()

void ttykickout

(

struct uart_csreg *

)

Definition at line 10 of file ttykickout.c.

References uart_csreg::ier, UART_IER_ERBFI, and UART_IER_ETBEI.

Referenced by eputc(), ttyhandle_in(), ttyinit(), and ttyputc().

{
    /* Force the UART hardware generate an output interrupt */

    csrptr->ier = UART_IER_ERBFI | UART_IER_ETBEI;

    return;
}

Here is the caller graph for this function:

ttyputc()

devcall ttyputc	(	struct dentry *	,
		char
	)

Definition at line 9 of file ttyputc.c.

References dentry::dvcsr, dentry::dvminor, OK, ttykickout(), ttytab, TY_NEWLINE, TY_OBUFLEN, TY_RETURN, ttycblk::tyobuff, ttycblk::tyocrlf, ttycblk::tyosem, ttycblk::tyotail, and wait().

Referenced by ttywrite().

{
    struct  ttycblk *typtr;     /* Pointer to tty control block */

    typtr = &ttytab[devptr->dvminor];

    /* Handle output CRLF by sending CR first */

        if ( ch==TY_NEWLINE && typtr->tyocrlf ) {
                ttyputc(devptr, TY_RETURN);
    }

    wait(typtr->tyosem);        /* Wait for space in queue */
    *typtr->tyotail++ = ch;

    /* Wrap around to beginning of buffer, if needed */

    if (typtr->tyotail >= &typtr->tyobuff[TY_OBUFLEN]) {
        typtr->tyotail = typtr->tyobuff;
    }

    /* Start output in case device is idle */

    ttykickout((struct uart_csreg *)devptr->dvcsr);

    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ttyread()

devcall ttyread	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file ttyread.c.

References dentry::dvminor, EOF, semcount(), SYSERR, ttygetc(), ttytab, TY_IMCOOKED, TY_NEWLINE, TY_RETURN, ttycblk::tyimode, and ttycblk::tyisem.

{
    struct  ttycblk *typtr;     /* Pointer to tty control block */
    int32   avail;          /* Characters available in buff.*/
    int32   nread;          /* Number of characters read    */
    int32   firstch;        /* First input character on line*/
    char    ch;         /* Next input character     */

    if (count < 0) {
        return SYSERR;
    }
    typtr= &ttytab[devptr->dvminor];

    if (typtr->tyimode != TY_IMCOOKED) {

        /* For count of zero, return all available characters */

        if (count == 0) {
            avail = semcount(typtr->tyisem);
            if (avail == 0) {
                return 0;
            } else {
                count = avail;
            }
        }
        for (nread = 0; nread < count; nread++) {
            *buff++ = (char) ttygetc(devptr);
        }
        return nread;
    }

    /* Block until input arrives */

    firstch = ttygetc(devptr);

    /* Check for End-Of-File */

    if (firstch == EOF) {
        return EOF;
    }

    /* Read up to a line */

    ch = (char) firstch;
    *buff++ = ch;
    nread = 1;
    while ( (nread < count) && (ch != TY_NEWLINE) &&
            (ch != TY_RETURN) ) {
        ch = ttygetc(devptr);
        *buff++ = ch;
        nread++;
    }
    return nread;
}

Here is the call graph for this function:

ttywrite()

devcall ttywrite	(	struct dentry *	,
		char *	,
		int32
	)

Definition at line 9 of file ttywrite.c.

References OK, SYSERR, and ttyputc().

{
    /* Handle negative and zero counts */

    if (count < 0) {
        return SYSERR;
    } else if (count == 0){
        return OK;
    }

    /* Write count characters one at a time */

    for (; count>0 ; count--) {
        ttyputc(devptr, *buff++);
    }
    return OK;
}

Here is the call graph for this function:

udp_hton()

void udp_hton

(

struct netpacket *

)

Definition at line 567 of file udp.c.

References htons, netpacket::net_udpdport, netpacket::net_udplen, and netpacket::net_udpsport.

Referenced by ip_out().

{
    pktptr->net_udpsport = htons(pktptr->net_udpsport);
    pktptr->net_udpdport = htons(pktptr->net_udpdport);
    pktptr->net_udplen = htons(pktptr->net_udplen);
    return;
}

Here is the caller graph for this function:

udp_in()

void udp_in

(

struct netpacket *

)

Definition at line 29 of file udp.c.

References disable(), freebuf(), netpacket::net_ipsrc, netpacket::net_udpdport, netpacket::net_udpsport, OK, restore(), send(), udpentry::udcount, udpentry::udlocport, UDP_FREE, UDP_QSIZ, UDP_RECV, UDP_SLOTS, UDP_USED, udpentry::udpid, udptab, udpentry::udqueue, udpentry::udremip, udpentry::udremport, udpentry::udstate, and udpentry::udtail.

Referenced by ip_local().

{
    intmask mask;           /* Saved interrupt mask     */
    int32   i;          /* Index into udptab        */
    struct  udpentry *udptr;    /* Pointer to a udptab entry    */


    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    for (i=0; i<UDP_SLOTS; i++) {
        udptr = &udptab[i];
        if (udptr->udstate == UDP_FREE) {
            continue;
        }

        if ((pktptr->net_udpdport == udptr->udlocport)  &&
                    ((udptr->udremport == 0) ||
                        (pktptr->net_udpsport == udptr->udremport)) &&
                 (  ((udptr->udremip==0)     ||
                        (pktptr->net_ipsrc == udptr->udremip)))    ) {

        /* Entry matches incoming packet */

        if (udptr->udcount < UDP_QSIZ) {
            udptr->udcount++;
            udptr->udqueue[udptr->udtail++] = pktptr;
            if (udptr->udtail >= UDP_QSIZ) {
                udptr->udtail = 0;
            }
            if (udptr->udstate == UDP_RECV) {
                udptr->udstate = UDP_USED;
                send (udptr->udpid, OK);
            }
            restore(mask);
            return;
        }
        }
    }

    /* No match - simply discard packet */

    freebuf((char *) pktptr);
    restore(mask);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_init()

void udp_init

(

void

)

Definition at line 12 of file udp.c.

References UDP_FREE, UDP_SLOTS, udptab, and udpentry::udstate.

Referenced by net_init().

{

    int32   i;          /* Index into the UDP table */

    for(i=0; i<UDP_SLOTS; i++) {
        udptab[i].udstate = UDP_FREE;
    }

    return;
}

Here is the caller graph for this function:

udp_ntoh()

void udp_ntoh

(

struct netpacket *

)

Definition at line 553 of file udp.c.

References netpacket::net_udpdport, netpacket::net_udplen, netpacket::net_udpsport, and ntohs.

Referenced by ip_in().

{
    pktptr->net_udpsport = ntohs(pktptr->net_udpsport);
    pktptr->net_udpdport = ntohs(pktptr->net_udpdport);
    pktptr->net_udplen = ntohs(pktptr->net_udplen);
    return;
}

Here is the caller graph for this function:

udp_recv()

int32 udp_recv	(	uid32	,
		char *	,
		int32	,
		uint32
	)

Definition at line 146 of file udp.c.

References currpid, disable(), freebuf(), if(), netpacket::net_udpdata, netpacket::net_udplen, OK, recvclr(), recvtime(), restore(), SYSERR, TIMEOUT, udpentry::udcount, udpentry::udhead, UDP_HDR_LEN, UDP_QSIZ, UDP_RECV, UDP_SLOTS, UDP_USED, udpentry::udpid, udptab, udpentry::udqueue, and udpentry::udstate.

Referenced by dnslookup(), getlocalip(), getutime(), rdscomm(), rfscomm(), and xsh_udpecho().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  udpentry *udptr;    /* Pointer to udptab entry  */
    umsg32  msg;            /* Message from recvtime()  */
    struct  netpacket *pkt;     /* Pointer to packet being read */
    int32   i;          /* Counts bytes copied      */
    int32   msglen;         /* Length of UDP data in packet */
    char    *udataptr;      /* Pointer to UDP data      */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* Verify that the slot is valid */

    if ((slot < 0) || (slot >= UDP_SLOTS)) {
        restore(mask);
        return SYSERR;
    }

    /* Get pointer to table entry */

    udptr = &udptab[slot];

    /* Verify that the slot has been registered and is valid */

    if (udptr->udstate != UDP_USED) {
        restore(mask);
        return SYSERR;
    }

    /* Wait for a packet to arrive */

    if (udptr->udcount == 0) {      /* No packet is waiting */
        udptr->udstate = UDP_RECV;
        udptr->udpid = currpid;
        msg = recvclr();
        msg = recvtime(timeout);    /* Wait for a packet    */
        udptr->udstate = UDP_USED;
        if (msg == TIMEOUT) {
            restore(mask);
            return TIMEOUT;
        } else if (msg != OK) {
            restore(mask);
            return SYSERR;
        }
    }

    /* Packet has arrived -- dequeue it */

    pkt = udptr->udqueue[udptr->udhead++];
    if (udptr->udhead >= UDP_QSIZ) {
        udptr->udhead = 0;
    }
    udptr->udcount--;

    /* Copy UDP data from packet into caller's buffer */

    msglen = pkt->net_udplen - UDP_HDR_LEN;
    udataptr = (char *)pkt->net_udpdata;
    if (len < msglen) {
        msglen = len;
    }
    for (i=0; i<msglen; i++) {
        *buff++ = *udataptr++;
    }
    freebuf((char *)pkt);
    restore(mask);
    return msglen;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_recvaddr()

int32 udp_recvaddr	(	uid32	,
		uint32 *	,
		uint16 *	,
		char *	,
		int32	,
		uint32
	)

Definition at line 227 of file udp.c.

References currpid, disable(), freebuf(), if(), netpacket::net_ipsrc, netpacket::net_udpdata, netpacket::net_udplen, netpacket::net_udpsport, OK, recvclr(), recvtime(), restore(), SYSERR, TIMEOUT, udpentry::udcount, udpentry::udhead, UDP_HDR_LEN, UDP_QSIZ, UDP_RECV, UDP_SLOTS, UDP_USED, udpentry::udpid, udptab, udpentry::udqueue, and udpentry::udstate.

Referenced by tftp_send1(), and xsh_udpeserver().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  udpentry *udptr;    /* Pointer to udptab entry  */
    umsg32  msg;            /* Message from recvtime()  */
    struct  netpacket *pkt;     /* Pointer to packet being read */
    int32   msglen;         /* Length of UDP data in packet */
    int32   i;          /* Counts bytes copied      */
    char    *udataptr;      /* Pointer to UDP data      */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* Verify that the slot is valid */

    if ((slot < 0) || (slot >= UDP_SLOTS)) {
        restore(mask);
        return SYSERR;
    }

    /* Get pointer to table entry */

    udptr = &udptab[slot];

    /* Verify that the slot has been registered and is valid */

    if (udptr->udstate != UDP_USED) {
        restore(mask);
        return SYSERR;
    }

    /* Wait for a packet to arrive */

    if (udptr->udcount == 0) {      /* No packet is waiting */
        udptr->udstate = UDP_RECV;
        udptr->udpid = currpid;
        msg = recvclr();
        msg = recvtime(timeout);    /* Wait for a packet    */
        udptr->udstate = UDP_USED;
        if (msg == TIMEOUT) {
            restore(mask);
            return TIMEOUT;
        } else if (msg != OK) {
            restore(mask);
            return SYSERR;
        }
    }

    /* Packet has arrived -- dequeue it */

    pkt = udptr->udqueue[udptr->udhead++];
    if (udptr->udhead >= UDP_QSIZ) {
        udptr->udhead = 0;
    }

    /* Record sender's IP address and UDP port number */

    *remip = pkt->net_ipsrc;
    *remport = pkt->net_udpsport;

    udptr->udcount--;

    /* Copy UDP data from packet into caller's buffer */

    msglen = pkt->net_udplen - UDP_HDR_LEN;
    udataptr = (char *)pkt->net_udpdata;
    if (len < msglen) {
        msglen = len;
    }
    for (i=0; i<msglen; i++) {
        *buff++ = *udataptr++;
    }
    freebuf((char *)pkt);
    restore(mask);
    return msglen;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_register()

uid32 udp_register	(	uint32	,
		uint16	,
		uint16
	)

Definition at line 85 of file udp.c.

References disable(), restore(), SYSERR, udpentry::udcount, udpentry::udhead, udpentry::udlocport, UDP_FREE, UDP_SLOTS, UDP_USED, udpentry::udpid, udptab, udpentry::udremip, udpentry::udremport, udpentry::udstate, and udpentry::udtail.

Referenced by dnslookup(), getlocalip(), getutime(), rdscomm(), rfscomm(), tftpget_mb(), xsh_udpecho(), and xsh_udpeserver().

{
    intmask mask;           /* Saved interrupt mask     */
    int32   slot;           /* Index into udptab        */
    struct  udpentry *udptr;    /* Pointer to udptab entry  */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* See if request already registered */

    for (slot=0; slot<UDP_SLOTS; slot++) {
        udptr = &udptab[slot];
        if (udptr->udstate == UDP_FREE) {
            continue;
        }

        /* Look at this entry in table */

        if ( (remport == udptr->udremport) &&
             (locport == udptr->udlocport) &&
             (remip   == udptr->udremip  ) ) {

            /* Request is already in the table */

            restore(mask);
            return SYSERR;
        }
    }

    /* Find a free slot and allocate it */

    for (slot=0; slot<UDP_SLOTS; slot++) {
        udptr = &udptab[slot];
        if (udptr->udstate != UDP_FREE) {
            continue;
        }
        udptr->udlocport = locport;
        udptr->udremport = remport;
        udptr->udremip = remip;
        udptr->udcount = 0;
        udptr->udhead = udptr->udtail = 0;
        udptr->udpid = -1;
        udptr->udstate = UDP_USED;
        restore(mask);
        return slot;
    }

    restore(mask);
    return SYSERR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_release()

status udp_release

(

uid32

)

Definition at line 502 of file udp.c.

References DEFER_START, DEFER_STOP, disable(), freebuf(), OK, resched_cntl(), restore(), SYSERR, udpentry::udcount, udpentry::udhead, UDP_FREE, UDP_QSIZ, UDP_SLOTS, udptab, udpentry::udqueue, and udpentry::udstate.

Referenced by dnslookup(), getlocalip(), getutime(), tftpget_mb(), and xsh_udpecho().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  udpentry *udptr;    /* Pointer to udptab entry  */
    struct  netpacket *pkt;     /* pointer to packet being read */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* Verify that the slot is valid */

    if ( (slot < 0) || (slot >= UDP_SLOTS) ) {
        restore(mask);
        return SYSERR;
    }

    /* Get pointer to table entry */

    udptr = &udptab[slot];

    /* Verify that the slot has been registered and is valid */

    if (udptr->udstate == UDP_FREE) {
        restore(mask);
        return SYSERR;
    }

    /* Defer rescheduling to prevent freebuf from switching context */

    resched_cntl(DEFER_START);
    while (udptr->udcount > 0) {
        pkt = udptr->udqueue[udptr->udhead++];
        if (udptr->udhead >= UDP_QSIZ) {
            udptr->udhead = 0;
        }
        freebuf((char *)pkt);
        udptr->udcount--;
    }
    udptr->udstate = UDP_FREE;
    resched_cntl(DEFER_STOP);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_send()

status udp_send	(	uid32	,
		char *	,
		int32
	)

Definition at line 316 of file udp.c.

References disable(), ETH_ADDR_LEN, ETH_HDR_LEN, network::ethucast, getbuf(), ip_send(), IP_UDP, network::ipucast, memcpy(), netpacket::net_ethsrc, netpacket::net_ethtype, netpacket::net_ipcksum, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipsrc, netpacket::net_iptos, netpacket::net_ipttl, netpacket::net_ipvh, netpacket::net_udpcksum, netpacket::net_udpdata, netpacket::net_udpdport, netpacket::net_udplen, netpacket::net_udpsport, netbufpool, NetData, OK, restore(), SYSERR, udpentry::udlocport, UDP_FREE, UDP_HDR_LEN, UDP_SLOTS, udptab, udpentry::udremip, udpentry::udremport, and udpentry::udstate.

Referenced by dnslookup(), getutime(), rfscomm(), and xsh_udpecho().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  netpacket *pkt;     /* Pointer to packet buffer */
    int32   pktlen;         /* Total packet length      */
    static  uint16 ident = 1;   /* Datagram IDENT field     */
    char    *udataptr;      /* Pointer to UDP data      */
    uint32  remip;          /* Remote IP address to use */
    uint16  remport;        /* Remote protocol port to use  */
    uint16  locport;        /* Local protocol port to use   */
    uint32  locip;          /* Local IP address taken from  */
                    /*   the interface      */
    struct  udpentry *udptr;    /* Pointer to table entry   */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* Verify that the slot is valid */

    if ( (slot < 0) || (slot >= UDP_SLOTS) ) {
        restore(mask);
        return SYSERR;
    }

    /* Get pointer to table entry */

    udptr = &udptab[slot];

    /* Verify that the slot has been registered and is valid */

    if (udptr->udstate == UDP_FREE) {
        restore(mask);
        return SYSERR;
    }

    /* Verify that the slot has a specified remote address */

    remip = udptr->udremip;
    if (remip == 0) {
        restore(mask);
        return SYSERR;
    }

    locip = NetData.ipucast;
    remport = udptr->udremport;
    locport = udptr->udlocport;

    /* Allocate a network buffer to hold the packet */

    pkt = (struct netpacket *)getbuf(netbufpool);

    if ((int32)pkt == SYSERR) {
        restore(mask);
        return SYSERR;
    }

    /* Compute packet length as UDP data size + fixed header size   */

    pktlen = ((char *)&pkt->net_udpdata - (char *)pkt) + len;

    /* Create a UDP packet in pkt */

    memcpy((char *)pkt->net_ethsrc,NetData.ethucast,ETH_ADDR_LEN);
    pkt->net_ethtype = 0x0800;  /* Type is IP           */
    pkt->net_ipvh = 0x45;       /* IP version and hdr length    */
    pkt->net_iptos = 0x00;      /* Type of service      */
    pkt->net_iplen= pktlen - ETH_HDR_LEN;/* Total IP datagram length*/
    pkt->net_ipid = ident++;    /* Datagram gets next IDENT */
    pkt->net_ipfrag = 0x0000;   /* IP flags & fragment offset   */
    pkt->net_ipttl = 0xff;      /* IP time-to-live      */
    pkt->net_ipproto = IP_UDP;  /* Datagram carries UDP     */
    pkt->net_ipcksum = 0x0000;  /* initial checksum     */
    pkt->net_ipsrc = locip;     /* IP source address        */
    pkt->net_ipdst = remip;     /* IP destination address   */

    pkt->net_udpsport = locport;    /* Local UDP protocol port  */
    pkt->net_udpdport = remport;    /* Remote UDP protocol port */
    pkt->net_udplen = (uint16)(UDP_HDR_LEN+len); /* UDP length  */
    pkt->net_udpcksum = 0x0000; /* Ignore UDP checksum      */
    udataptr = (char *) pkt->net_udpdata;
    for (; len>0; len--) {
        *udataptr++ = *buff++;
    }

    /* Call ipsend to send the datagram */

    ip_send(pkt);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

udp_sendto()

status udp_sendto	(	uid32	,
		uint32	,
		uint16	,
		char *	,
		int32
	)

Definition at line 417 of file udp.c.

References disable(), ETH_ADDR_LEN, ETH_HDR_LEN, network::ethucast, getbuf(), ip_send(), IP_UDP, network::ipucast, memcpy(), netpacket::net_ethsrc, netpacket::net_ethtype, netpacket::net_ipcksum, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipsrc, netpacket::net_iptos, netpacket::net_ipttl, netpacket::net_ipvh, netpacket::net_udpcksum, netpacket::net_udpdata, netpacket::net_udpdport, netpacket::net_udplen, netpacket::net_udpsport, netbufpool, NetData, OK, restore(), SYSERR, udpentry::udlocport, UDP_FREE, UDP_HDR_LEN, UDP_SLOTS, udptab, and udpentry::udstate.

Referenced by getlocalip(), rdscomm(), tftp_send1(), tftpget_mb(), and xsh_udpeserver().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  netpacket *pkt;     /* Pointer to a packet buffer   */
    int32   pktlen;         /* Total packet length      */
    static  uint16 ident = 1;   /* Datagram IDENT field     */
    struct  udpentry *udptr;    /* Pointer to a UDP table entry */
    char    *udataptr;      /* Pointer to UDP data      */

    /* Ensure only one process can access the UDP table at a time   */

    mask = disable();

    /* Verify that the slot is valid */

    if ( (slot < 0) || (slot >= UDP_SLOTS) ) {
        restore(mask);
        return SYSERR;
    }

    /* Get pointer to table entry */

    udptr = &udptab[slot];

    /* Verify that the slot has been registered and is valid */

    if (udptr->udstate == UDP_FREE) {
        restore(mask);
        return SYSERR;
    }

    /* Allocate a network buffer to hold the packet */

    pkt = (struct netpacket *)getbuf(netbufpool);

    if ((int32)pkt == SYSERR) {
        restore(mask);
        return SYSERR;
    }

    /* Compute packet length as UDP data size + fixed header size   */

    pktlen = ((char *)&pkt->net_udpdata - (char *)pkt) + len;

    /* Create UDP packet in pkt */

    memcpy((char *)pkt->net_ethsrc,NetData.ethucast,ETH_ADDR_LEN);
        pkt->net_ethtype = 0x0800;  /* Type is IP */
    pkt->net_ipvh = 0x45;       /* IP version and hdr length    */
    pkt->net_iptos = 0x00;      /* Type of service      */
    pkt->net_iplen= pktlen - ETH_HDR_LEN;/* total IP datagram length*/
    pkt->net_ipid = ident++;    /* Datagram gets next IDENT */
    pkt->net_ipfrag = 0x0000;   /* IP flags & fragment offset   */
    pkt->net_ipttl = 0xff;      /* IP time-to-live      */
    pkt->net_ipproto = IP_UDP;  /* Datagram carries UDP     */
    pkt->net_ipcksum = 0x0000;  /* Initial checksum     */
    pkt->net_ipsrc = NetData.ipucast;/* IP source address       */
    pkt->net_ipdst = remip;     /* IP destination address   */
    pkt->net_udpsport = udptr->udlocport;/* local UDP protocol port */
    pkt->net_udpdport = remport;    /* Remote UDP protocol port */
    pkt->net_udplen = (uint16)(UDP_HDR_LEN+len); /* UDP length  */
    pkt->net_udpcksum = 0x0000; /* Ignore UDP checksum      */
    udataptr = (char *) pkt->net_udpdata;
    for (; len>0; len--) {
        *udataptr++ = *buff++;
    }

    /* Call ipsend to send the datagram */

    ip_send(pkt);
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsleep()

syscall unsleep

(

pid32

)

Definition at line 11 of file unsleep.c.

References disable(), getitem(), isbadpid, NPROC, OK, PR_RECTIM, PR_SLEEP, proctab, procent::prstate, qentry::qkey, qentry::qnext, queuetab, restore(), and SYSERR.

Referenced by kill(), and send().

{
    intmask mask;           /* Saved interrupt mask     */
        struct  procent *prptr;     /* Ptr to process's table entry */

        pid32   pidnext;        /* ID of process on sleep queue */
                    /*   that follows the process   */
                    /*   which is being removed */

    mask = disable();

    if (isbadpid(pid)) {
        restore(mask);
        return SYSERR;
    }

    /* Verify that candidate process is on the sleep queue */

    prptr = &proctab[pid];
    if ((prptr->prstate!=PR_SLEEP) && (prptr->prstate!=PR_RECTIM)) {
        restore(mask);
        return SYSERR;
    }

    /* Increment delay of next process if such a process exists */

    pidnext = queuetab[pid].qnext;
    if (pidnext < NPROC) {
        queuetab[pidnext].qkey += queuetab[pid].qkey;
    }

    getitem(pid);           /* Unlink process from queue */
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

userret()

void userret

(

void

)

プロセスが最上位の関数に戻る時に呼ばれる。現在のプロセスを終了させる。

Note

プロセス作成時に、戻りアドレスとしてuserret()がスタックに積まれる。

Definition at line 11 of file userret.c.

{
    kill(getpid()); /* Force process to exit */
}

wait()

syscall wait

(

sid32

)

Definition at line 9 of file wait.c.

References currpid, disable(), enqueue(), isbadsem, OK, PR_WAIT, proctab, procent::prsem, procent::prstate, resched(), restore(), S_FREE, sentry::scount, semtab, sentry::squeue, sentry::sstate, and SYSERR.

Referenced by ethread(), ethwrite(), getbuf(), ipout(), lflclose(), lflcontrol(), lflgetc(), lflputc(), lflseek(), lfsetup(), lfsopen(), mark(), ptrecv(), ptsend(), rdsbufalloc(), rdsprocess(), rflclose(), rflread(), rflseek(), rflwrite(), rfscontrol(), rfsopen(), ttycontrol(), ttygetc(), ttyputc(), and xsh_ls().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  procent *prptr;     /* Ptr to process's table entry */
    struct  sentry *semptr;     /* Ptr to sempahore table entry */

    mask = disable();
    if (isbadsem(sem)) {
        restore(mask);
        return SYSERR;
    }

    semptr = &semtab[sem];
    if (semptr->sstate == S_FREE) {
        restore(mask);
        return SYSERR;
    }

    if (--(semptr->scount) < 0) {       /* If caller must block */
        prptr = &proctab[currpid];
        prptr->prstate = PR_WAIT;   /* Set state to waiting */
        prptr->prsem = sem;     /* Record semaphore ID  */
        enqueue(currpid,semptr->squeue);/* Enqueue on semaphore */
        resched();          /*   and reschedule */
    }

    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

wakeup()

void wakeup

(

void

)

Definition at line 9 of file wakeup.c.

References DEFER_START, DEFER_STOP, dequeue(), firstkey, nonempty, ready(), resched_cntl(), and sleepq.

Referenced by clkhandler().

{
    /* Awaken all processes that have no more time to sleep */

    resched_cntl(DEFER_START);
    while (nonempty(sleepq) && (firstkey(sleepq) <= 0)) {
        ready(dequeue(sleepq));
    }

    resched_cntl(DEFER_STOP);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write()

syscall write	(	did32	,
		char *	,
		uint32
	)

Definition at line 9 of file write.c.

References devtab, disable(), dentry::dvwrite, isbaddev, restore(), and SYSERR.

Referenced by arp_in(), arp_resolve(), ip_out(), lfdballoc(), lfdbfree(), lfflush(), lfiballoc(), lfibput(), lfscreate(), and xsh_rdstest().

{
    intmask     mask;       /* Saved interrupt mask     */
    struct dentry   *devptr;    /* Entry in device switch table */
    int32       retval;     /* Value to return to caller    */

    mask = disable();
    if (isbaddev(descrp)) {
        restore(mask);
        return SYSERR;
    }
    devptr = (struct dentry *) &devtab[descrp];
    retval = (*devptr->dvwrite) (devptr, buffer, count);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xdone()

void xdone

(

void

)

最終プロセスの終了時、システム終了メッセージを表示する。

Definition at line 10 of file xdone.c.

References halt(), and kprintf().

Referenced by kill().

{
    kprintf("\n\nAll user processes have completed.\n\n");
    halt(); /* Halt the processor       */
}

Here is the call graph for this function:

Here is the caller graph for this function:

yield()

syscall yield

(

void

)

CPU実行権を自発的に放棄する（タイムスライスを終了する）。

割り込みを禁止して再スケジューリングを行う。復帰後、割り込み状態を復元する。

Returns

OKを返す。

Definition at line 12 of file yield.c.

References disable(), OK, resched(), and restore().

Referenced by sleepms().

{
    intmask mask; /* Saved interrupt mask       */

    mask = disable();
    resched();
    restore(mask);
    return OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: