// DDTapeServerDOs.bcpl Tape Server Do* command procedures // Last modified by Tim Diebert, June 22, 1981 4:01 PM // get "DDTapes.d" get "PUP.decl" get "DDTapeServer.decl" //--------------------------------------------------------------- external //--------------------------------------------------------------- [ //Imports //From DDTapeServerDispUtil InitDisplay; DWs; DWo; MonitorKeys //From 'System' Ws; Wo; Endofs; keys; Block; Gets; CallSwat //From BSP BSPWriteBlock; BSPForceOutput //Imported Globals rwBlock; rwKey; kbdKey; usedidnos; useddrives; ctxQ currentVersionString //Exports (to TSPServer) ReplyNo; ReplyYes DoOpenDrive; DoCloseDrive; DoReadRecord; DoWriteRecord DoFwdSpaceRecord; DoBackSpaceRecord; DoFwdSpaceFile DoBackSpaceFile; DoWriteEOF; DoWriteBlankTape DoRewind; DoUnload; DoGetStatus; DoSetStatus DoSendText; DoGetText ] // Command Processors: Do*() //These routines handle the processing for a received command. Most //verify that there is a drive open (Service.drives = -1). //Error recovery and Replying are all done at this level. //--------------------------------------------------------------- let DoOpenDrive(ser) be //--------------------------------------------------------------- [ let blk = ser>>Service.blk // process the OpenDrive command, opening the given drive if allowed. test ser>>Service.drive ge 0 ifso //this Server has a drive open already ReplyNo(ser, openAlready) ifnot [ let dr = blk>>OpenDrive.driveNumber test dr ls maxDrives ifnot ReplyNo(ser, badDriveNo) ifso test useddrives!dr ifso ReplyNo(ser, driveInUse) ifnot [ let tape = OpenDDTape(dr, DoErrorProc, DoErrorProc) test tape ifnot ReplyNo(ser, badDrive) ifso [ //All went well!! ser>>Service.tape = tape ser>>Service.drive = dr useddrives!dr = true ser>>Service.density = PE if tape>>VDDTCB.opDensity eq NRZI then ser>>Service.density = NRZI ReplyYes(ser, cmdOpenDrive) ] ] ] ] //--------------------------------------------------------------- and DoCloseDrive(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then //drive is open, close it [ let dr = ser>>Service.drive useddrives!dr = false CloseDDTape(ser>>Service.tape) ser>>Service.tape = false ser>>Service.drive = -1 ReplyYes(ser, cmdCloseDrive) ] ] //--------------------------------------------------------------- and DoReadRecord(ser) be //--------------------------------------------------------------- [ //Read a record from tape if VerifyOpen(ser) then [ //Do read, and return status as well let blk = ser>>Service.blk //get command block ActOnDDTape(ser>>Service.tape, ReadFwd, lv blk>>HereIsRecord.record, rwBlockLength, 0, 0, ser>>Service.retries) let count = (ser>>Service.tape)>>DDTCB.ByteCount if count gr rwBlockLength then count = rwBlockLength //truncate to fit blk>>HereIsRecord.recordLength = (ser>>Service.tape)>>DDTCB.ByteCount blk>>HereIsRecord.endingStatus = (ser>>Service.tape)>>DDTCB.Flags blk>>HereIsRecord.type = cmdHereIsRecord blk>>HereIsRecord.length = 4+(count+1)/2 count = 2 * blk>>HereIsRecord.length BSPWriteBlock(ser>>Service.bspStr, blk, 0, count) BSPForceOutput(ser>>Service.bspSoc) ] ] //--------------------------------------------------------------- and DoWriteRecord(ser) be //--------------------------------------------------------------- [ //Write a record to tape if VerifyOpen(ser) then if OkToWrite(ser) then [ let blk = ser>>Service.blk if blk>>WriteRecord.recordLength gr rwBlockLength then blk>>WriteRecord.recordLength = rwBlockLength ActOnDDTape(ser>>Service.tape, Write, 0, 0, lv blk>>WriteRecord.record, blk>>WriteRecord.recordLength, ser>>Service.retries) ReplyStatus(ser, cmdWriteRecord) ] ] //--------------------------------------------------------------- and DoFwdSpaceRecord(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ ActOnDDTape(ser>>Service.tape, FwdSpaceRecord) ReplyStatus(ser, cmdFwdSpaceRecord) //reply with ending status ] ] //--------------------------------------------------------------- and DoBackSpaceRecord(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ ActOnDDTape(ser>>Service.tape, BackSpaceRecord) ReplyStatus(ser, cmdBackSpaceRecord) //reply with ending status ] ] //--------------------------------------------------------------- and DoFwdSpaceFile(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ ActOnDDTape(ser>>Service.tape, FwdSpaceFile) ReplyStatus(ser, cmdFwdSpaceFile) //reply with ending status ] ] //--------------------------------------------------------------- and DoBackSpaceFile(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ ActOnDDTape(ser>>Service.tape, BackSpaceFile) ReplyStatus(ser, cmdBackSpaceFile) //reply with ending status ] ] //--------------------------------------------------------------- and DoWriteEOF(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then if OkToWrite(ser) then [ ActOnDDTape(ser>>Service.tape, WriteEOF) //Write an EOF ReplyStatus(ser, cmdWriteEOF) //reply with ending status ] ] //--------------------------------------------------------------- and DoWriteBlankTape(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then if OkToWrite(ser) then [ let blk = ser>>Service.blk let inches = blk>>WriteBlankTape.gap //get gap size let vtape = ser>>Service.tape //get ptr to TCB let gapsize = 960 //number of bytes in PE gap. if vtape>>VDDTCB.opDensity eq NRZI then gapsize = 480 //number of bytes in NRZI gap. let bytes = (inches * vtape>>VDDTCB.opDensity) - gapsize //get gap size if bytes le 0 then bytes = 1 ActOnDDTape(vtape, EraseVar, bytes) //Write inches of blank tape ReplyStatus(ser, cmdWriteBlankTape) //reply with ending status ] ] //--------------------------------------------------------------- and DoRewind(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ PerformVDDTCB(ser>>Service.tape, Rewind) //initiate rewind ReplyYes(ser, cmdRewind) //reply before rewind complete ] ] //--------------------------------------------------------------- and DoUnload(ser) be //--------------------------------------------------------------- [ if VerifyOpen(ser) then [ PerformVDDTCB(ser>>Service.tape, Unload) //initiate Unload ReplyYes(ser, cmdUnload) //reply before rewind complete ] ] //--------------------------------------------------------------- and DoGetStatus(ser) be //--------------------------------------------------------------- [ let blk = ser>>Service.blk let tape = ser>>Service.tape blk>>HereIsStatus.length = 6 blk>>HereIsStatus.type = cmdHereIsStatus blk>>HereIsStatus.drive = ser>>Service.drive blk>>HereIsStatus.retries = ser>>Service.retries blk>>HereIsStatus.density = ser>>Service.density if ser>>Service.drive ge 0 then //open tape [ blk>>HereIsStatus.tstatus = PerformVDDTCB(tape, NoOp) ] //Send message BSPWriteBlock(ser>>Service.bspStr, blk, 0, 12) BSPForceOutput(ser>>Service.bspSoc) ] //--------------------------------------------------------------- and DoSetStatus(ser) be //--------------------------------------------------------------- [ let blk = ser>>Service.blk let which = blk>>SetStatus.selector //get selector let set = blk>>SetStatus.newsetting switchon which into [ case setRetries: [ test (set ge 0 & set le 8) ifso [ ser>>Service.retries = set ReplyYes(ser, cmdSetStatus) ] ifnot ReplyNo(ser, badRetrySetting) endcase ] case setDensity: [ test (set eq PE % set eq NRZI) ifso [ ser>>Service.density = set let ok = SetDensity(ser>>Service.tape, set) test ok ifso [ ReplyYes(ser, cmdSetStatus) ser>>Service.density = set ] ifnot ReplyNo(ser, DensitySetNotatBOT) ] ifnot ReplyNo(ser, badDensitySetting) endcase ] default: ReplyNo(ser, badStatusSelector); endcase ] ] //--------------------------------------------------------------- and DoSendText(ser) be //--------------------------------------------------------------- [ //display text string to operator let blk = ser>>Service.blk DWs(lv blk>>SendText.text) ReplyYes(ser, cmdSendText) ] //--------------------------------------------------------------- and DoGetText(ser) be //--------------------------------------------------------------- [ //Get a line of Text from operator (terminated by cr) while kbdKey ge 0 do Block() //wait for keyboard kbdKey = ser>>Service.idnumber //take keyboard DWs("*nReply? ") //prompt let blk = ser>>Service.blk blk>>HereIsText.type = cmdHereIsText let str = lv blk>>HereIsText.text let echo = "x" let i = 1 let chr = 0 until chr eq 13 do //until cr [ while Endofs(keys) do Block() //wait for key chr = Gets(keys) if chr eq 8 then [ if i gr 1 then [ //backspace, echo \ and backup i i = i-1 echo>>String.char^1 = $\ DWs(echo) echo>>String.char^1 = str>>String.char^i DWs(echo) ] loop ] if i ls (cmdBlockLength-2)/2 then [ str>>String.char^i = chr i = i+1 echo>>String.char^1 = chr DWs(echo) ] ] str>>String.length = i-1 blk>>HereIsText.length = 2+(i+1)/2 //full words plus header BSPWriteBlock(ser>>Service.bspStr, blk, 0, blk>>HereIsText.length*2) BSPForceOutput(ser>>Service.bspSoc) DWs("sent") kbdKey = -1 //release beyboard ] //--------------------------------------------------------------- and VerifyOpen(ser) = valof //--------------------------------------------------------------- [ if ser>>Service.drive ge 0 then resultis true ReplyNo(ser, driveNotOpened) resultis false ] //--------------------------------------------------------------- and OkToWrite(ser) = valof //--------------------------------------------------------------- [ let stat = PerformVDDTCB(ser>>Service.tape, NoOp) unless stat<>Service.tape)>>VDDTCB.WFP = 1 // fake write error ReplyNo(ser, writeProtected) resultis false ] //--------------------------------------------------------------- and ReplyYes(ser, code) be //--------------------------------------------------------------- [ //Sends back Yes reply, not switchon code for string yet let blk = ser>>Service.blk //get command block blk>>YesNo.type = cmdYes blk>>YesNo.cause = doneOperation let stat = (ser>>Service.tape)>>DDTCB.Flags //get tape status blk>>YesNo.stat = stat let str = "Good Command" YesNoMessage(blk, str, ser) //set up string and send out ] //--------------------------------------------------------------- and ReplyNo(ser, code) be //--------------------------------------------------------------- [ //Sends back No block, with correct string let str = " " switchon code into [ case noVersion: str = "Version Check Unmade"; endcase case noGoodMessage: str = "Illegal Command"; endcase case openAlready: str = "Drive Already Open"; endcase case driveInUse: str = "Drive In Use"; endcase case badDrive: str = "Drive Bad"; endcase case badDriveNo: str = "Bad Drive Number"; endcase case driveNotOpened: str = "Drive Not Open"; endcase case badStatusSelector: str = "Cannot set that Status"; endcase case badRetrySetting: str = "Bad Setting for Retries"; endcase case writeProtected: str = "Tape Write Protected"; endcase case badDensitySetting: str = "Illegal Density Setting"; endcase case DensitySetNotatBOT: str = "Density set at place other than BOT"; endcase default: str = "Illegal Command"; endcase ] let blk = ser>>Service.blk //get command block blk>>YesNo.type = cmdNo blk>>YesNo.cause = code let stat = (ser>>Service.tape)>>DDTCB.Flags //get tape status blk>>YesNo.stat = stat YesNoMessage(blk, str, ser) //set up string and send out ] //--------------------------------------------------------------- and ReplyStatus(ser, cmd) be //--------------------------------------------------------------- [ //Send back the ending status of the tape drive // used by most action commands let blk = ser>>Service.blk let stat = (ser>>Service.tape)>>DDTCB.Flags //get tape status blk>>YesNo.cause = doneOperation blk>>YesNo.stat = stat //return status bits blk>>YesNo.type = cmdYes //assume Yes // always no if not online or not ready or error unless stat<>YesNo.type = cmdNo unless stat<>YesNo.type = cmdNo let error = stat & TapeErr if error then blk>>YesNo.type = cmdNo switchon cmd into //other changes to No depend on command [ case cmdWriteRecord: [ //No if write protected if stat<>YesNo.type = cmdNo if stat<>YesNo.type = cmdNo endcase ] case cmdFwdSpaceRecord: [ //No special no endcase ] case cmdBackSpaceRecord: [ //No special no endcase ] case cmdFwdSpaceFile: [ //No special no endcase ] case cmdBackSpaceFile: [ //No special no endcase ] case cmdWriteEOF: [ //No if not EOF unless stat<>YesNo.type = cmdNo endcase ] case cmdWriteBlankTape: [ //No special no endcase ] ] //put in string of good or bad operation let str = "Good Operation" if blk>>YesNo.type eq cmdNo then str = "Bad Ending Status" YesNoMessage(blk, str, ser) //set up string and send out ] //--------------------------------------------------------------- and YesNoMessage(blk, str, ser) be //--------------------------------------------------------------- [ let i = 0 blk>>YesNo.length = 5 + ((str>>String.length + 2) / 2) for i = 0 to blk>>YesNo.length - 4 do [ (lv blk>>YesNo.str)!i = str!i //copy string ] // and send block out BSPWriteBlock(ser>>Service.bspStr, blk, 0, 2*blk>>YesNo.length) BSPForceOutput(ser>>Service.bspSoc) ] //--------------------------------------------------------------- and DoErrorProc(str) be //--------------------------------------------------------------- [ DWs(str) ]