git.oblomov.eu Git - wine/blob - dlls/wnaspi32/aspi.c

   1 /**************************************************************************
   2  * ASPI routines
   3  * Copyright (C) 2000 David Elliott <dfe@infinite-internet.net>
   4  * Copyright (C) 2005 Vitaliy Margolen
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /* These routines are to be called from either WNASPI32 or WINASPI */
  22
  23 /* FIXME:
  24  * - No way to override automatic /proc detection, maybe provide an
  25  *   HKEY_LOCAL_MACHINE\Software\Wine\Wine\Scsi regkey
  26  * - Somewhat debating an #ifdef linux... technically all this code will
  27  *   run on another UNIX.. it will fail nicely.
  28  * - Please add support for mapping multiple channels on host adapters to
  29  *   aspi controllers, e-mail me if you need help.
  30  */
  31
  32
  33 #include "config.h"
  34 #include "wine/port.h"
  35
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <sys/types.h>
  39 #ifdef HAVE_SYS_IOCTL_H
  40 #include <sys/ioctl.h>
  41 #endif
  42 #include <fcntl.h>
  43 #include <dirent.h>
  44 #ifdef HAVE_UNISTD_H
  45 # include <unistd.h>
  46 #endif
  47 #include <errno.h>
  48 #include <string.h>
  49
  50 #include "windef.h"
  51 #include "winbase.h"
  52 #include "winreg.h"
  53 #include "winerror.h"
  54 #include "winescsi.h"
  55
  56 #include "wine/debug.h"
  57 #include "wine/unicode.h"
  58
  59 WINE_DEFAULT_DEBUG_CHANNEL(aspi);
  60
  61 #ifdef linux
  62 static void set_last_error(void)
  63 {
  64     int save_errno = errno; /* errno gets overwritten by printf */
  65     switch (errno)
  66     {
  67     case EAGAIN:
  68         SetLastError( ERROR_SHARING_VIOLATION );
  69         break;
  70     case EBADF:
  71         SetLastError( ERROR_INVALID_HANDLE );
  72         break;
  73     case ENOSPC:
  74         SetLastError( ERROR_HANDLE_DISK_FULL );
  75         break;
  76     case EACCES:
  77     case EPERM:
  78     case EROFS:
  79         SetLastError( ERROR_ACCESS_DENIED );
  80         break;
  81     case EBUSY:
  82         SetLastError( ERROR_LOCK_VIOLATION );
  83         break;
  84     case ENOENT:
  85         SetLastError( ERROR_FILE_NOT_FOUND );
  86         break;
  87     case EISDIR:
  88         SetLastError( ERROR_CANNOT_MAKE );
  89         break;
  90     case ENFILE:
  91     case EMFILE:
  92         SetLastError( ERROR_NO_MORE_FILES );
  93         break;
  94     case EEXIST:
  95         SetLastError( ERROR_FILE_EXISTS );
  96         break;
  97     case EINVAL:
  98     case ESPIPE:
  99         SetLastError( ERROR_SEEK );
 100         break;
 101     case ENOTEMPTY:
 102         SetLastError( ERROR_DIR_NOT_EMPTY );
 103         break;
 104     case ENOEXEC:
 105         SetLastError( ERROR_BAD_FORMAT );
 106         break;
 107     default:
 108         WARN( "unknown file error: %s\n", strerror(save_errno) );
 109         SetLastError( ERROR_GEN_FAILURE );
 110         break;
 111     }
 112     errno = save_errno;
 113 }
 114 #endif
 115
 116 static const WCHAR wDevicemapScsi[] = {'H','A','R','D','W','A','R','E','\\','D','E','V','I','C','E','M','A','P','\\','S','c','s','i',0};
 117
 118 /* Exported functions */
 119 int ASPI_GetNumControllers(void)
 120 {
 121     HKEY hkeyScsi, hkeyPort;
 122     DWORD i = 0, numPorts, num_ha = 0;
 123     WCHAR wPortName[11];
 124
 125     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wDevicemapScsi, 0,
 126         KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hkeyScsi) != ERROR_SUCCESS )
 127     {
 128         ERR("Could not open HKLM\\%s\n", debugstr_w(wDevicemapScsi));
 129         return 0;
 130     }
 131     while (RegEnumKeyW(hkeyScsi, i++, wPortName, sizeof(wPortName)) == ERROR_SUCCESS)
 132     {
 133         if (RegOpenKeyExW(hkeyScsi, wPortName, 0, KEY_QUERY_VALUE, &hkeyPort) == ERROR_SUCCESS)
 134         {
 135             if (RegQueryInfoKeyW(hkeyPort, NULL, NULL, NULL, &numPorts, NULL, NULL,
 136                              NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 137             {
 138                 num_ha += numPorts;
 139             }
 140             RegCloseKey(hkeyPort);
 141         }
 142     }
 143
 144     RegCloseKey(hkeyScsi);
 145     TRACE("Returning %d host adapters\n", num_ha );
 146     return num_ha;
 147 }
 148
 149 BOOL SCSI_GetDeviceName( int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData )
 150 {
 151     char buffer[200];
 152     HKEY hkeyScsi;
 153     DWORD type;
 154
 155     snprintf(buffer, sizeof(buffer), KEYNAME_SCSI, h, c, t, d);
 156     if( RegOpenKeyExA(HKEY_LOCAL_MACHINE, buffer, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
 157     {
 158         TRACE("Could not open HKLM\\%s; device does not exist\n", buffer);
 159         return FALSE;
 160     }
 161
 162     if( RegQueryValueExA(hkeyScsi, "UnixDeviceName", NULL, &type, (LPBYTE)devstr, lpcbData) != ERROR_SUCCESS )
 163     {
 164         WARN("Could not query value HKLM\\%s\\UnixDeviceName\n", buffer);
 165         RegCloseKey(hkeyScsi);
 166         return FALSE;
 167     }
 168     RegCloseKey(hkeyScsi);
 169
 170     TRACE("Device name: %s\n", devstr);
 171     return TRUE;
 172 }
 173
 174 /* SCSI_GetHCforController
 175  * RETURNS
 176  *      HIWORD: Host Adapter
 177  *      LOWORD: Channel
 178  */
 179 DWORD ASPI_GetHCforController( int controller )
 180 {
 181     HKEY hkeyScsi, hkeyPort;
 182     DWORD i = 0, numPorts;
 183     int num_ha = controller + 1;
 184     WCHAR wPortName[15];
 185     WCHAR wBusName[15];
 186
 187     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wDevicemapScsi, 0,
 188         KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hkeyScsi) != ERROR_SUCCESS )
 189     {
 190         ERR("Could not open HKLM\\%s\n", debugstr_w(wDevicemapScsi));
 191         return 0xFFFFFFFF;
 192     }
 193     while (RegEnumKeyW(hkeyScsi, i++, wPortName, sizeof(wPortName)) == ERROR_SUCCESS)
 194     {
 195         if (RegOpenKeyExW(hkeyScsi, wPortName, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
 196                           &hkeyPort) == ERROR_SUCCESS)
 197         {
 198             if (RegQueryInfoKeyW(hkeyPort, NULL, NULL, NULL, &numPorts, NULL, NULL,
 199                              NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 200             {
 201                 num_ha -= numPorts;
 202                 if (num_ha <= 0) break;
 203             }
 204             else
 205             RegCloseKey(hkeyPort);
 206         }
 207     }
 208     RegCloseKey(hkeyScsi);
 209
 210     if (num_ha > 0)
 211     {
 212         ERR("Invalid controller(%d)\n", controller);
 213         return 0xFFFFFFFF;
 214     }
 215
 216     if (RegEnumKeyW(hkeyPort, -num_ha, wBusName, sizeof(wBusName)) != ERROR_SUCCESS)
 217     {
 218         ERR("Failed to enumerate keys\n");
 219         RegCloseKey(hkeyPort);
 220         return 0xFFFFFFFF;
 221     }
 222     RegCloseKey(hkeyPort);
 223
 224     return (atoiW(&wPortName[9]) << 16) + atoiW(&wBusName[9]);
 225 }
 226
 227 int SCSI_OpenDevice( int h, int c, int t, int d )
 228 {
 229     char devstr[20];
 230     DWORD cbData = 20;
 231     int fd = -1;
 232
 233     if(!SCSI_GetDeviceName( h, c, t, d, devstr, &cbData ))
 234     {
 235         WARN("Could not get device name for h%02dc%02dt%02dd%02d\n", h, c, t, d);
 236         return -1;
 237     }
 238
 239     TRACE("Opening device %s mode O_RDWR\n",devstr);
 240     fd = open(devstr, O_RDWR);
 241     if (fd == -1) {
 242         char *errstring = strerror(errno);
 243         ERR("Failed to open device %s: %s\n", devstr, errstring);
 244     }
 245
 246     return fd;
 247 }
 248
 249 #ifdef linux
 250 /* SCSI_Fix_CMD_LEN
 251  *      Checks to make sure the CMD_LEN is correct
 252  */
 253 void
 254 SCSI_Fix_CMD_LEN(int fd, int cmd, int len)
 255 {
 256         /* This is what the linux kernel thinks.... */
 257         static const unsigned char scsi_command_size[8] =
 258         {
 259                 6, 10, 10, 12,
 260                 12, 12, 10, 10
 261         };
 262
 263         int index=(cmd>>5)&7;
 264
 265         if (len!=scsi_command_size[index])
 266         {
 267                 TRACE("CDBLen for command %d claims to be %d, expected %d\n",
 268                                 cmd, len, scsi_command_size[index]);
 269                 ioctl(fd,SG_NEXT_CMD_LEN,&len);
 270         }
 271 }
 272
 273 int
 274 SCSI_LinuxSetTimeout( int fd, int timeout )
 275 {
 276         int retval;
 277         TRACE("Setting timeout to %d jiffies\n", timeout);
 278         retval=ioctl(fd,SG_SET_TIMEOUT,&timeout);
 279         if(retval)
 280         {
 281                 WARN("Could not set timeout ! (%s)\n", strerror(errno));
 282         }
 283         return retval;
 284
 285 }
 286
 287 /* This function takes care of the write/read to the linux sg device.
 288  * It returns TRUE or FALSE and uses set_last_error() to convert
 289  * UNIX errno to Windows GetLastError().  The reason for that is that
 290  * several programs will check that error and we might as well set
 291  * it here.  We also return the value of the read call in
 292  * lpcbBytesReturned.
 293  */
 294 BOOL /* NOTE: This function SHOULD BLOCK */
 295 SCSI_LinuxDeviceIo( int fd,
 296                 struct sg_header * lpInBuffer, DWORD cbInBuffer,
 297                 struct sg_header * lpOutBuffer, DWORD cbOutBuffer,
 298                 LPDWORD lpcbBytesReturned )
 299 {
 300         DWORD dwBytes;
 301         DWORD save_error;
 302
 303         TRACE("Writing to Linux sg device\n");
 304         dwBytes = write( fd, lpInBuffer, cbInBuffer );
 305         if( dwBytes != cbInBuffer )
 306         {
 307                 set_last_error();
 308                 save_error = GetLastError();
 309                 WARN("Not enough bytes written to scsi device. bytes=%d .. %d\n", cbInBuffer, dwBytes );
 310                 /* FIXME: set_last_error() never sets error to ERROR_NOT_ENOUGH_MEMORY... */
 311                 if( save_error == ERROR_NOT_ENOUGH_MEMORY )
 312                         MESSAGE("Your Linux kernel was not able to handle the amount of data sent to the scsi device. Try recompiling with a larger SG_BIG_BUFF value (kernel 2.0.x sg.h)");
 313                 WARN("error= %d\n", save_error );
 314                 *lpcbBytesReturned = 0;
 315                 return FALSE;
 316         }
 317
 318         TRACE("Reading reply from Linux sg device\n");
 319         *lpcbBytesReturned = read( fd, lpOutBuffer, cbOutBuffer );
 320         if( *lpcbBytesReturned != cbOutBuffer )
 321         {
 322                 set_last_error();
 323                 save_error = GetLastError();
 324                 WARN("Not enough bytes read from scsi device. bytes=%d .. %d\n", cbOutBuffer, *lpcbBytesReturned);
 325                 WARN("error= %d\n", save_error );
 326                 return FALSE;
 327         }
 328         return TRUE;
 329 }
 330
 331 static void SCSI_Linux_CheckDevices(void)
 332 {
 333     DIR *devdir;
 334     struct dirent *dent = NULL;
 335
 336     devdir = opendir("/dev");
 337     for (dent=readdir(devdir);dent;dent=readdir(devdir))
 338     {
 339         if (!(strncmp(dent->d_name, "sg", 2)))
 340             break;
 341     }
 342     closedir(devdir);
 343
 344     if (dent == NULL)
 345     {
 346         TRACE("WARNING: You don't have any /dev/sgX generic scsi devices ! \"man MAKEDEV\" !\n");
 347         return;
 348     }
 349 }
 350 #endif
 351
 352 void SCSI_Init(void)
 353 {
 354 #ifdef linux
 355     SCSI_Linux_CheckDevices();
 356 #endif
 357 }