diff options
Diffstat (limited to 'sanei/sanei_DomainOS.c')
| -rwxr-xr-x | sanei/sanei_DomainOS.c | 528 |
1 files changed, 528 insertions, 0 deletions
diff --git a/sanei/sanei_DomainOS.c b/sanei/sanei_DomainOS.c new file mode 100755 index 0000000..5473151 --- /dev/null +++ b/sanei/sanei_DomainOS.c @@ -0,0 +1,528 @@ +/* sane - Scanner Access Now Easy. + Copyright (C) 1996, 1997 David Mosberger-Tang + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + This file defines a server for Apollo Domain/OS systems. It does all +of the scsi_$ calls that are needed for SANE. This is necessary because +Domain/OS will not allow a child process to access a parent's SCSI +device. The interface is through a common, mapped area. Mutex locks +are used to prevent concurrency problems, and eventcounts are used to +notify a waiting process that its request has completed. + + This program is intended to support only one device at a time, +although multiple instances of this program may run concurrently. It is +intended that this program be forked/execd by a SANE application, and +that it will exit when the application exits. + + Upon startup, the program is invoked with the path to an object that +needs to be mapped for communication. The parent process will have +already initialized the 'public' eventcounts and locks, and will be +waiting for the ResultReady eventcount to be incremented. After +initialization, the server will increment this eventcount, and wait for +an incoming request, which is signified by the CommandAvailable +eventcount. This EC will be incremented after another process has +filled in the parameter area. + +DBG levels: + 0 Error - always printed. + 1 Basic monitor - print entry to main functions, or errors that are + normally suppressed because they are reported at a higher level. + 2 Medium monitor - show intermediate steps in functions + 3 Detailed monitor - if its there, print it + +*/ + +#include <assert.h> +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <apollo/base.h> +#include <apollo/ec2.h> +#include <apollo/error.h> +#include <apollo/fault.h> +#include <apollo/ms.h> +#include <apollo/mutex.h> +#include <apollo/pfm.h> +#include <apollo/scsi.h> + +#include "../include/sane/config.h" + +#include "../include/sane/sanei_scsi.h" + +#include "../include/sane/sanei_debug.h" + +#include "sanei_DomainOS.h" + +/* Timeout period for SCSI wait, in milliseconds. +We are using 100 seconds here. */ +#define DomainScsiTimeout 100000 + +/* Communication Area pointer */ +struct DomainServerCommon *com; + +/* Handle for fault handler */ +pfm_$fh_handle_t FaultHandle; + + +static struct + { + void *DomainSCSIPtr; /* Pointer to the data block for this device */ + void *DomainSensePtr; /* Pointer to the sense area for this device */ + u_int in_use : 1; /* is this DomainFdInfo in use? */ + u_int fake_fd : 1; /* is this a fake file descriptor? */ + scsi_$handle_t scsi_handle; /* SCSI handle */ + scsi_$operation_id_t op_id; /* op_id of current request */ + } *DomainFdInfo; + +/* This function is called error might have occured, but it would be one that I +don't know how to handle, or never expect to happen. */ +static void DomainErrorCheck(status_$t status, const char *message) + { + char *subsystem, *module, *code; + short subsystem_length, module_length, code_length; + + if (status.all) + { + DBG(0, "Unrecoverable Domain/OS Error 0x%08x: %s\n", status.all, message); + error_$find_text(status, &subsystem, &subsystem_length, &module, &module_length, &code, &code_length); + if (subsystem_length && module_length && code_length) + DBG(0, "%.*s (%.*s/%.*s)\n", code_length, code, subsystem_length, subsystem, module_length, module); + exit(EXIT_FAILURE); + } + } + + +/* This function is the fault handler for the server. Currently, it only +handles asynchronous faults. It always returns to the faulting code, but +it disables the handler, so that the server can be killed if the parent is +unable to do so. */ +pfm_$fh_func_val_t FaultHandler(pfm_$fault_rec_t *FaultStatusPtr) + { + status_$t status; + + DBG(1, "In fault handler, status is %08x\n", FaultStatusPtr->status.all); + switch (FaultStatusPtr->status.all) + { + case fault_$quit: + pfm_$release_fault_handler(FaultHandle, &status); + DomainErrorCheck(status, "Can't release fault handler"); + return pfm_$return_to_faulting_code; + default: + DBG(0, "Unrecognized fault type %08x, exiting\n", FaultStatusPtr->status.all); + exit(EXIT_FAILURE); + } + } + + +static void DomainSCSIOpen(void) + { + static int num_alloced = 0; + int fd; + scsi_$handle_t scsi_handle; + pinteger len; + void *DataBasePtr; + + /* Find fake fd. */ + for (fd = 0; fd < num_alloced; ++fd) + if (!DomainFdInfo[fd].in_use) + break; + + /* Acquire the device */ + DBG(1, "DomainSCSIOpen: dev='%s', fd=%d\n", com->open_path, fd); + len = strlen(com->open_path); + scsi_$acquire((char *)com->open_path, len, &scsi_handle, &com->CommandStatus); + if (com->CommandStatus.all != status_$ok) + { + /* we have a failure, return an error code, and generate debug output */ + DBG(1, "DomainSCSIOpen: acquire failed, Domain/OS status is %08x\n", com->CommandStatus.all); + error_$print(com->CommandStatus); + return; + } + else + { + /* device acquired, setup buffers and buffer pointers */ + DBG(2, "DomainSCSIOpen: acquire OK, handle is %x\n", scsi_handle); + /* Create/map the data area */ + tmpnam(com->open_path); + DBG(2, "DomainSCSIOpen: Data block name will be '%s'\n", com->open_path); + DataBasePtr = ms_$crmapl(com->open_path, strlen(com->open_path), 0, DomainMaxDataSize + DomainSenseSize, ms_$cowriters, &com->CommandStatus); + DomainErrorCheck(com->CommandStatus, "Creating Data Area"); + assert((((int)DataBasePtr) & 0x3ff) == 0); /* Relies on Domain/OS mapping new objects on page boundary */ + DBG(2, "Data Buffer block created at %p, length = 0x%lx\n", DataBasePtr, DomainMaxDataSize + DomainSenseSize); + /* Wire the buffer */ + scsi_$wire(scsi_handle, (void *)DataBasePtr, DomainMaxDataSize + DomainSenseSize, &com->CommandStatus); + if (com->CommandStatus.all == status_$ok) + { + /* success, indicate status */ + DBG(2, "Buffer wire was successful\n"); + } + else + { + /* failure, print detail and return code */ + DBG(1, "Buffer wire failed, Domain/OS status is %08x\n", com->CommandStatus.all); + error_$print(com->CommandStatus); + return; + } + } + + if (fd >= num_alloced) + { + size_t new_size, old_size; + + old_size = num_alloced * sizeof (DomainFdInfo[0]); + num_alloced = fd + 8; + new_size = num_alloced * sizeof (DomainFdInfo[0]); + if (DomainFdInfo) + DomainFdInfo = realloc (DomainFdInfo, new_size); + else + DomainFdInfo = malloc (new_size); + memset ((char *) DomainFdInfo + old_size, 0, new_size - old_size); + assert(DomainFdInfo); + } + DomainFdInfo[fd].in_use = 1; + DomainFdInfo[fd].scsi_handle = scsi_handle; + DomainFdInfo[fd].DomainSCSIPtr = DataBasePtr; + DomainFdInfo[fd].DomainSensePtr = ((char *)DataBasePtr) + DomainMaxDataSize; + com->fd = fd; + } + + +static void DomainSCSIClose(void) + { + DomainFdInfo[com->fd].in_use = 0; + DBG(1, "sanei_scsi_close: fd=%d\n", com->fd); + /* Unwire the buffer */ + scsi_$unwire(DomainFdInfo[com->fd].scsi_handle, DomainFdInfo[com->fd].DomainSCSIPtr, DomainMaxDataSize + DomainSenseSize, true, &com->CommandStatus); + DomainErrorCheck(com->CommandStatus, "Unwiring SCSI buffers"); + /* Release the device */ + scsi_$release(DomainFdInfo[com->fd].scsi_handle, &com->CommandStatus); + DomainErrorCheck(com->CommandStatus, "Releasing device"); + /* Unmap the buffer area */ + ms_$unmap(DomainFdInfo[com->fd].DomainSCSIPtr, DomainMaxDataSize + DomainSenseSize, &com->CommandStatus); + DomainErrorCheck(com->CommandStatus, "Unmapping device data area"); + } + + +/* I have never seen this called, and I'm not sure what to do with it, so I +guarantee that it will generate a fault, and I can add support for it. */ +static void DomainSCSIFlushAll(void) + { + status_$t status; + + DBG(1, "DomainSCSIFlushAll: ()\n"); + DBG(0, "Error - unimplemented feature in module" "BACKEND_NAME"); + assert(1==0); + } + + +/* This function must only be called from DomainSCSIEnter. The current +server architecture requires that the Wait immediately follow the Enter +command. */ +static void DomainSCSIWait(void) + { + int count; + char *ascii_wait_status, *ascii_op_status; + pinteger return_count; + scsi_$op_status_t status_list[1]; + scsi_$wait_index_t wait_index; + + /* wait for the command completion */ + wait_index = scsi_$wait(DomainFdInfo[com->fd].scsi_handle, DomainScsiTimeout, true, DomainFdInfo[com->fd].op_id, 1, status_list, &return_count, &com->CommandStatus); + DBG(2, " scsi_$wait returned status = %08x\n", com->CommandStatus.all); + if (com->CommandStatus.all == status_$ok) + { + switch (wait_index) + { + case scsi_device_advance: ascii_wait_status = "scsi_device_advance"; break; + case scsi_timeout: ascii_wait_status = "scsi_timeout"; break; + case scsi_async_fault: ascii_wait_status = "scsi_async_fault"; break; + default: ascii_wait_status = "unknown"; break; + } + DBG(2, " scsi_$wait status is %s, return_count is %d\n", ascii_wait_status, return_count); + if (wait_index != scsi_device_advance) + { + DBG(1, "Error - SCSI timeout, or async fault\n"); + com->CommandStatus.all = scsi_$operation_timeout; + } + else for (count = 0; count < return_count; count++) + { + switch (status_list[count].op_status) + { + case scsi_good_status: ascii_op_status = "scsi_good_status"; break; + case scsi_check_condition: ascii_op_status = "scsi_check_condition"; break; + case scsi_condition_met: ascii_op_status = "scsi_condition_met"; break; + case scsi_rsv1: ascii_op_status = "scsi_rsv1"; break; + case scsi_busy: ascii_op_status = "scsi_busy"; break; + case scsi_rsv2: ascii_op_status = "scsi_rsv2"; break; + case scsi_rsv3: ascii_op_status = "scsi_rsv3"; break; + case scsi_rsv4: ascii_op_status = "scsi_rsv4"; break; + case scsi_intermediate_good: ascii_op_status = "scsi_intermediate_good"; break; + case scsi_rsv5: ascii_op_status = "scsi_rsv5"; break; + case scsi_intermediate_condition_met: ascii_op_status = "scsi_intermediate_condition_met"; break; + case scsi_rsv6: ascii_op_status = "scsi_rsv6"; break; + case scsi_reservation_conflict: ascii_op_status = "scsi_reservation_conflict"; break; + case scsi_rsv7: ascii_op_status = "scsi_rsv7"; break; + case scsi_rsv8: ascii_op_status = "scsi_rsv8"; break; + case scsi_rsv9: ascii_op_status = "scsi_rsv9"; break; + case scsi_undefined_status: ascii_op_status = "scsi_undefined_status"; break; + default: ascii_op_status = "unknown"; break; + } + DBG(2, " list[%d]: op=%x cmd_status=%08x, status=%s\n", count, status_list[count].op, status_list[count].cmd_status.all, ascii_op_status); + switch (status_list[count].cmd_status.all) + { + case status_$ok: + switch (status_list[count].op_status) + { + case scsi_good_status: + break; + case scsi_busy: + com->CommandStatus.all = status_$ok | 0x80000000; + com->SCSIStatus = scsi_busy; + break; + case scsi_check_condition: + { + static unsigned char scanner_sense_cdb[] = {3, 0, 0, 0, DomainSenseSize, 0}; + static scsi_$cdb_t sense_cdb; + static linteger sense_cdb_size; + static scsi_$operation_id_t sense_op_id; + static status_$t sense_status; + static pinteger sense_return_count; + static int temp; + + /* Issue the sense command (wire, issue, wait, unwire */ + sense_cdb_size = sizeof(scanner_sense_cdb); + memcpy(&sense_cdb, scanner_sense_cdb, sense_cdb_size); + scsi_$do_command_2(DomainFdInfo[com->fd].scsi_handle, sense_cdb, sense_cdb_size, DomainFdInfo[com->fd].DomainSensePtr, DomainSenseSize, scsi_read, &sense_op_id, &sense_status); + DomainErrorCheck(sense_status, "Executing sense command"); + scsi_$wait(DomainFdInfo[com->fd].scsi_handle, DomainScsiTimeout, true, sense_op_id, 1, status_list, &sense_return_count, &sense_status); + /* The following debug output is scanner specific */ + DBG(2, "Sense information: Error code=%02x, ASC=%02x, ASCQ=%02x\n", ((u_char *)DomainFdInfo[com->fd].DomainSensePtr)[0], ((char *)DomainFdInfo[com->fd].DomainSensePtr)[0xc], ((char *)DomainFdInfo[com->fd].DomainSensePtr)[0xd]); + DBG(2, " Sense dump:\n"); + for (temp = 0; temp < DomainSenseSize; temp++) + DBG(2, " %02x", ((u_char *)DomainFdInfo[com->fd].DomainSensePtr)[temp]); + DBG(2, "\n"); + /* see if buffer underrun - ILI/Valid are set, and command was a read */ + /* Warning - this might be UMAX specific */ + if ((((char *)DomainFdInfo[com->fd].DomainSensePtr)[0] == 0xf0) && (((char *)DomainFdInfo[com->fd].DomainSensePtr)[2] & 0x20) && (com->cdb.g0.cmd == 0x28)) + { + /* Warning - the following code is specific to endianness and int size */ + /* Its also very ugly */ + DBG(2, "Shortening destination length by %x bytes\n", *(int *)(((char *)DomainFdInfo[com->fd].DomainSensePtr)+3)); + com->dst_size -= *(int *)(((char *)DomainFdInfo[com->fd].DomainSensePtr)+3); + DBG(2, "Final dest size is %x\n", com->dst_size); + } + else + { + /* Set this status so that the sense handler can be called */ + com->CommandStatus.all = status_$ok | 0x80000000; + com->SCSIStatus = scsi_check_condition; + } + } + break; + default: + /* I fault out in this case because I want to know about this error, + and this guarantees that it will get attention. */ + DBG(0, "Unrecoverable Domain/OS scsi handler error: status=%08x\n", status_list[count].op_status); + exit(EXIT_FAILURE); + } + break; + /* Handle recognized error conditions by copying the error code over */ + case scsi_$operation_timeout: + case scsi_$dma_underrun: /* received by some backend code */ + case scsi_$hdwr_failure: /* received when both scanners were active */ + com->CommandStatus = status_list[count].cmd_status; + break; + default: + DBG(0, "Unrecoverable DomainOS scsi handler error: status=%08x\n", status_list[count].cmd_status.all); + error_$print(status_list[count].cmd_status); + exit(EXIT_FAILURE); + } + } + /* Dump the buffer contents */ + if (com->direction == scsi_read) + { + DBG(3, "first words of buffer are:\n"); + for (return_count = 0; return_count < com->dst_size; return_count++) + DBG(3, "%02X%c", ((unsigned char *)DomainFdInfo[com->fd].DomainSCSIPtr)[return_count], (return_count % 16) == 15 ? '\n' : ' '); + DBG(3, "\n"); + } + } + else + { + /* scsi_$wait failed */ + DBG(1, "scsi_$wait failed, status is %08x\n", com->CommandStatus.all); + } + } + + +static void DomainSCSIEnter(void) + { + static int count; + + /* Give some debug info */ + DBG(1, "Entering DomainSCSIEnter, fd=%d, opcode=%02X\n", com->fd, com->cdb.all[0]); + DBG(2, " CDB Contents: "); + for (count = 0; count < com->cdb_size; count++) + DBG(2, " %02X", com->cdb.all[count]); + DBG(2, "\n"); + DBG(2, "Buffer address is 0x%08x\n", DomainFdInfo[com->fd].DomainSCSIPtr); + DBG(2, "Buffer size is %x\n", com->buf_size); + DBG(2, "Direction is %s\n", (com->direction == scsi_read) ? "READ" : "WRITE"); + /* now queue the command */ + scsi_$do_command_2(DomainFdInfo[com->fd].scsi_handle, com->cdb, com->cdb_size, DomainFdInfo[com->fd].DomainSCSIPtr, com->buf_size, com->direction, &DomainFdInfo[com->fd].op_id, &com->CommandStatus); + if (com->CommandStatus.all == status_$ok) + { + /* success, indicate status */ + DBG(2, " scsi_$do_command_2 was successful, op_id is %x\n", DomainFdInfo[com->fd].op_id); + + /* If we supported multiple outstanding requests for one device, this would be + a good breakpoint. We would store the op_id in a private place, and construct + a queue for each device. This complicates things, and SANE doesn't seem to need + it, so it won't be implemented. The current server architecture does the wait + automatically, and status for the entire operation is returned. This means that + the sanei_scsi_req_enter and sanei_scsi_req_wait calls don't make sense, and + should generate an error. */ + DomainSCSIWait(); + } + else + { + /* failure, print detail and return code */ + DBG(1, " scsi_$do_command_2 failed, status is %08x\n", com->CommandStatus.all); + } + } + + +/* This function is not currently used. */ +static void DomainSCSIReqWait(void) + { + DBG(1, "sanei_scsi_req_wait: (id=%p)\n", NULL); + return; + } + + +/* Startup the server */ +static void sanei_DomainOS_init(char *path) + { + int done, index; + long CommandTriggerValue; + ec2_$ptr_t CommandAvailablePtr[1]; + status_$t status; + unsigned long length_mapped; + + DBG(1, "Starting Domain SANE Server, common area path = '%s'\n", path); + com = ms_$mapl(path, strlen(path), 0, sizeof(struct DomainServerCommon), ms_$cowriters, ms_$wr, true, &length_mapped, &status); + DomainErrorCheck(status, "Can't open common area"); + if (length_mapped < sizeof(struct DomainServerCommon)) + { + DBG(0, "Error - can't open common area '%s' to required length\n", path); + DBG(0, " Required length = %lx, returned length = %lx\n", sizeof(struct DomainServerCommon), length_mapped); + exit(EXIT_FAILURE); + } + /* Make the file temporary, so it will disappear when it is closed */ + ms_$mk_temporary(com, &status); + DomainErrorCheck(status, "Can't make common file temporary"); + DBG(2, "Domain Server common area mapped, length is %lx\n", length_mapped); + /* The communication area is open, give the initial response */ + ec2_$advance(&com->ResultReady, &status); + DomainErrorCheck(status, "Can't advance ResultReady EC after startup"); + /* Enter the command loop */ + CommandAvailablePtr[0] = &com->CommandAvailable; + CommandTriggerValue = ec2_$read(com->CommandAvailable) + 1; + /* Inhibit asynchronous faults */ +/* pfm_$inhibit();*/ + /* Establish the fault handler */ + FaultHandle = pfm_$establish_fault_handler(pfm_$all_faults, 0, FaultHandler, &status); + DomainErrorCheck(status, "Can't establish fault handler"); + done = 0; + do + { + /* Wait for the command */ + DBG(2, "Waiting for incoming command\n"); + do + { + index = ec2_$wait_svc(CommandAvailablePtr, &CommandTriggerValue, 1, &status); + } + while (status.all == ec2_$wait_quit); + DomainErrorCheck(status, "Error waiting on CommandAvailable EC"); + assert (index == 1); + /* Get the trigger value for next time - this avoids a race/deadlock */ + CommandTriggerValue = ec2_$read(com->CommandAvailable) + 1; + /* decode/execute the command */ + DBG(2, "Received a command - opcode is %x\n", com->opcode); + switch(com->opcode) + { + case Open: + DomainSCSIOpen(); + ec2_$advance(&com->CommandAccepted, &status); + DomainErrorCheck(status, "Can't advance CommandAccepted EC on open"); + break; + case Close: + DomainSCSIClose(); + ec2_$advance(&com->CommandAccepted, &status); + DomainErrorCheck(status, "Can't advance CommandAccepted EC on close"); + break; + case Enter: + DomainSCSIEnter(); + ec2_$advance(&com->CommandAccepted, &status); + DomainErrorCheck(status, "Can't advance CommandAccepted EC on enter"); + break; + case Exit: + done = 1; + /* This lets the parent know that the command was accepted. It can be + used to avoid sending a signal. */ + ec2_$advance(&com->CommandAccepted, &status); + DomainErrorCheck(status, "Can't advance CommandAccepted EC on exit"); + break; + default: + DBG(1, "Invalid command %x received\n", com->opcode); + } + DBG(2, "Command processing complete\n"); + } + while (!done); + /* This would be a good place to close all devices, but for now we'll assume + they have already been closed by a well-behaved program */ + /* Unmap the common area */ + ms_$unmap(com, sizeof(struct DomainServerCommon), &status); + DomainErrorCheck(status, "Error unmapping common area"); + DBG(1, "Exiting Domain SANE Server\n"); +/* pfm_$enable();*/ + exit(EXIT_SUCCESS); + } |