clr u.nread / accumulates number of bytes transmitted
tst u.count / is number of bytes to be read greater than 0
rts r0 / no, nothing to read; return to caller
mov r1,-(sp) / save i-number on stack
cmp r1,$40. / want to read a special file (i-nodes 1,...,40 are
jmp dskr / no, jmp to dskr; read file with i-node number (r1)
/ starting at byte ((u.fofp)), read in u.count bytes
asl r1 / multiply inode number by 2
rtty: / read from console tty
mov tty+[8*ntty]-8+6,r5 / r5 is the address of the 4th word of
/ of the control and status block
tst 2(r5) / for the console tty; this word points to the console
bne 1f / 2nd word of console tty buffer contains number
/ of chars. Is this number non-zero?
jsr r0,canon; ttych / if 0, call 'canon' to get a line
tst 2(r5) / is the number of characters zero
beq ret1 / yes, return to caller via 'ret1'
movb *4(r5),r1 / no, put character in r1
inc 4(r5) / 3rd word of console tty buffer points to byte which
/ contains the next char.
dec 2(r5) / decrement the character count
jsr r0,passc / move the character to core (user)
br 1b / get next character
jmp ret / return to caller via 'ret'
jsr r0,pptic / gets next character in clist for ppt input and
br ret / it in r1; if there 1s no problem with reader, it
/ also enables read bit in prs
jsr r0,passc / place character in users buffer area
rmem: / transfer characters from memory to a user area of core
mov *u.fofp,r1 / save file offset which points to the char to
inc *u.fofp / increment file offset to point to 'next' char in
movb (r1),r1 / get character from memory file, put it in r1
jsr r0,passc / move this character to the next byte of the
jmp error / see 'error' routine
mov (sp),r1 / i-number in r1
jsr r0,iget / get i-node (r1) into i-node section of core
mov i.size,r2 / file size in bytes in r2
sub *u.fofp,r2 / subtract file offset
cmp r2,u.count / are enough bytes left in file to carry out read
mov r2,u.count / no, just read to end of file
jsr r0,mget / returns physical block number of block in file
jsr r0,dskrd / read in block, r5 points to 1st word of data in
movb (r2)+,(r1)+ / move data from buffer into working core
bne 2b / branch until proper number of bytes are transferred
tst u.count / all bytes read off disk
movb r1,*u.base / move a character to the next byte of the
inc u.base / increment the pointer to point to the next byte
inc u.nread / increment the number of bytes read
dec u.count / decrement the number of bytes to be read
bne 1f / any more bytes to read?; yes, branch
mov (sp)+,r0 / no, do a non-local return to the caller of
ret: / (1) pop the return address off the stack into r0
mov (sp)+,r1 / (2) pop the i-number off the stack into r1
clr *$ps / clear processor status
rts r0 / return to address currently on top of stack
clr u.nread / clear the number of bytes transmitted during
tst u.count / test the byte count specified by the user
bgt 1f / any bytes to output; yes, branch
rts r0 / no, return - no writing to do
mov r1 ,-(sp) / save the i-node number on the stack
cmp r1,$40. / does the i-node number indicate a special file?
bgt dskw / no, branch to standard file output
asl r1 / yes, calculate the index into the special file
jmp *1f-2(r1) / jump table and jump to the appropriate routine
jsr r0,cpass / get next character from user buffer area; if
/ none go to return address in syswrite
tst r1 / is character = null
beq wtty / yes, get next character
mov $240,*$ps / no, set processor priority to five
cmpb cc+1,$20. / is character count for console tty greater
bhis 2f / yes; branch to put process to sleep
jsr r0,putc; 1 / find place in freelist to assign to console
br 2f / place character in list; if none available
/ branch to put process to sleep
jsr r0,startty / attempt to output character on tty
mov r1,-(sp) / place character on stack
jsr r0,sleep; 1 / put process to sleep
mov (sp)+,r1 / remove character from stack
br 1b / try again to place character in clist and output
jsr r0,cpass / get next character from user buffer area,
/ if none return to writei's calling routine
jsr r0,pptoc / output character on ppt
wmem: / transfer characters from a user area of core to memory file
jsr r0,cpass / get next character from users area of core and
mov r1,-(sp) / put character on the stack
mov *u.fofp,r1 / save file offset in r1
inc *u.fofp / increment file offset to point to next available
movb (sp)+,(r1) / pop char off stack, put in memory loc assigned
dskw: / write routine for non-special files
mov (sp),r1 / get an i-node number from the stack into r1
jsr r0,iget / write i-node out (if modified), read i-node 'r1'
/ into i-node area of core
mov *u.fofp,r2 / put the file offset [(u.off) or the offset in
/ the fsp entry for this file] in r2
add u.count,r2 / no. of bytes to be written + file offset is
cmp r2,i.size / is this greater than the present size of
mov r2,i.size / yes, increase the f11e size to file offset +
jsr r0,setimod / set imod=1 (i.e., core inode has been
/ modified), stuff tlme of modification into
jsr r0,mget / get the block no. in which to write the next data
bit *u.fofp,$777 / test the lower 9 bits of the file offset
bne 2f / if its non-zero, branch; if zero, file offset = 0,
/ 512, 1024,...(i.e., start of new block)
cmp u.count,$512. / if zero, is there enough data to fill an
/ entire block? (i.e., no. of
bhis 3f / bytes to be written greater than 512.? Yes, branch.
/ Don't have to read block
2: / in as no past info. is to be saved (the entire block will be
jsr r0,dskrd / no, must retain old info.. Hence, read block 'r1'
jsr r0,wslot / set write and inhibit bits in I/O queue, proc.
/ status=0, r5 points to 1st word of data
jsr r0,sioreg / r3 = no. of bytes of data, r1 = address of data,
/ r2 points to location in buffer in which to
movb (r1 )+,(r2)+ / transfer a byte of data to the I/O buffer
dec r3 / decrement no. of bytes to be written
bne 2b / have all bytes been transferred? No, branch
jsr r0,dskwr / yes, write the block and the i-node
tst u.count / any more data to write?
jmp ret / no, return to the caller via 'ret'
cpass: / get next character from user area of core and put it in r1
tst u.count / have all the characters been transferred (i.e.,
/ u.count, # of chars. left
beq 1f / to be transferred = 0?) yes, branch
dec u.count / no, decrement u.count
movb *u.base,r1 / take the character pointed to by u.base and
inc u.nread / increment no. of bytes transferred
inc u.base / increment the buffer address to point to the
mov (sp)+,r0 / put return address of calling routine into r0
mov (sp)+,r1 / i-number in r1
rts r0 / non-local return
mov *u.fofp,r2 / file offset (in bytes) is moved to r2
mov r2,r3 / and also to r3
bis $177000,r3 / set bits 9,...,15. of file offset in r3
bic $!777,r2 / calculate file offset mod 512.
add r5,r2 / r2 now points to 1st byte in system buffer where
mov u.base,r1 / address of data is in r1
neg r3 / 512 - file offset (mod512.) in r3 (i.e., the number
/ of free bytes in the file block
cmp r3,u.count / compare this with the number of data bytes to
blos 2f / if less than branch. Use the number of free bytes
/ in the file block as the number to be written
mov u.count,r3 / if greater than, use the number of data bytes
/ as the number to be written
add r3,u.nread / r3 + number of bytes xmitted during write is
sub r3,u.count / u.count = no. of bytes that still must be
add r3,u.base / u.base points to the 1st of the remaining data
add r3,*u.fofp / new file offset = number of bytes done + old
projects / unix-history / blob