ceph/src/common/win32/errno.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2020 SUSE LINUX GmbH
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15
  16 #include <errno.h>
  17 #include <stdlib.h>
  18
  19 #include "include/int_types.h"
  20 #include <ntdef.h>
  21 #include <ntstatus.h>
  22
  23 #include "include/compat.h"
  24 #include "include/int_types.h"
  25 #include "include/types.h"
  26 #include "include/fs_types.h"
  27
  28 // We're only converting errors defined in errno.h, not standard Windows
  29 // system error codes that are usually retrievied using GetLastErrorCode().
  30 // TODO: consider converting WinSock2 (WSA*) error codes, which are quite
  31 // similar to the errno.h ones.
  32
  33 __u32 ceph_to_hostos_errno_unsigned(__u32 r)
  34 {
  35   // using an array like like freebsd_errno.cc might be more readable but
  36   // we have some large values defined by Boost.
  37   switch(r) {
  38     case 1: return EPERM;
  39     case 2: return ENOENT;
  40     case 3: return ESRCH;
  41     case 4: return EINTR;
  42     case 5: return EIO;
  43     case 6: return ENXIO;
  44     case 7: return E2BIG;
  45     case 8: return ENOEXEC;
  46     case 9: return EBADF;
  47     case 10: return ECHILD;
  48     // same as EWOULDBLOCK
  49     case 11: return EAGAIN;
  50     case 12: return ENOMEM;
  51     case 13: return EACCES;
  52     case 14: return EFAULT;
  53     case 15: return ENOTBLK;
  54     case 16: return EBUSY;
  55     case 17: return EEXIST;
  56     case 18: return EXDEV;
  57     case 19: return ENODEV;
  58     case 20: return ENOTDIR;
  59     case 21: return EISDIR;
  60     case 22: return EINVAL;
  61     case 23: return ENFILE;
  62     case 24: return EMFILE;
  63     case 25: return ENOTTY;
  64     case 26: return ETXTBSY;
  65     case 27: return EFBIG;
  66     case 28: return ENOSPC;
  67     case 29: return ESPIPE;
  68     case 30: return EROFS;
  69     case 31: return EMLINK;
  70     case 32: return EPIPE;
  71     case 33: return EDOM;
  72     case 34: return ERANGE;
  73     // same as EDEADLK
  74     case 35: return EDEADLOCK;
  75     case 36: return ENAMETOOLONG;
  76     case 37: return ENOLCK;
  77     case 38: return ENOSYS;
  78     case 39: return ENOTEMPTY;
  79     case 40: return ELOOP;
  80     case 42: return ENOMSG;
  81     case 43: return EIDRM;
  82     case 44: return ECHRNG;
  83     case 45: return EL2NSYNC;
  84     case 46: return EL3HLT;
  85     case 47: return EL3RST;
  86     case 48: return ELNRNG;
  87     case 49: return EUNATCH;
  88     case 50: return ENOCSI;
  89     case 51: return EL2HLT;
  90     case 52: return EBADE;
  91     case 53: return EBADR;
  92     case 54: return EXFULL;
  93     case 55: return ENOANO;
  94     case 56: return EBADRQC;
  95     case 57: return EBADSLT;
  96     case 59: return EBFONT;
  97     case 60: return ENOSTR;
  98     case 61: return ENODATA;
  99     case 62: return ETIME;
 100     case 63: return ENOSR;
 101     case 64: return ENONET;
 102     case 65: return ENOPKG;
 103     case 66: return EREMOTE;
 104     case 67: return ENOLINK;
 105     case 68: return EADV;
 106     case 69: return ESRMNT;
 107     case 70: return ECOMM;
 108     case 71: return EPROTO;
 109     case 72: return EMULTIHOP;
 110     case 73: return EDOTDOT;
 111     case 74: return EBADMSG;
 112     case 75: return EOVERFLOW;
 113     case 76: return ENOTUNIQ;
 114     case 77: return EBADFD;
 115     case 78: return EREMCHG;
 116     case 79: return ELIBACC;
 117     case 80: return ELIBBAD;
 118     case 81: return ELIBSCN;
 119     case 82: return ELIBMAX;
 120     case 83: return ELIBEXEC;
 121     case 84: return EILSEQ;
 122     case 85: return ERESTART;
 123     case 86: return ESTRPIPE;
 124     case 87: return EUSERS;
 125     case 88: return ENOTSOCK;
 126     case 89: return EDESTADDRREQ;
 127     case 90: return EMSGSIZE;
 128     case 91: return EPROTOTYPE;
 129     case 92: return ENOPROTOOPT;
 130     case 93: return EPROTONOSUPPORT;
 131     case 94: return ESOCKTNOSUPPORT;
 132     // same as ENOTSUP
 133     case 95: return EOPNOTSUPP;
 134     case 96: return EPFNOSUPPORT;
 135     case 97: return EAFNOSUPPORT;
 136     case 98: return EADDRINUSE;
 137     case 99: return EADDRNOTAVAIL;
 138     case 100: return ENETDOWN;
 139     case 101: return ENETUNREACH;
 140     case 102: return ENETRESET;
 141     case 103: return ECONNABORTED;
 142     case 104: return ECONNRESET;
 143     case 105: return ENOBUFS;
 144     case 106: return EISCONN;
 145     case 107: return ENOTCONN;
 146     case 108: return ESHUTDOWN;
 147     case 109: return ETOOMANYREFS;
 148     case 110: return ETIMEDOUT;
 149     case 111: return ECONNREFUSED;
 150     case 112: return EHOSTDOWN;
 151     case 113: return EHOSTUNREACH;
 152     case 114: return EALREADY;
 153     case 115: return EINPROGRESS;
 154     case 116: return ESTALE;
 155     case 117: return EUCLEAN;
 156     case 118: return ENOTNAM;
 157     case 119: return ENAVAIL;
 158     case 120: return EISNAM;
 159     case 121: return EREMOTEIO;
 160     case 122: return EDQUOT;
 161     case 123: return ENOMEDIUM;
 162     case 124: return EMEDIUMTYPE;
 163     case 125: return ECANCELED;
 164     case 126: return ENOKEY;
 165     case 127: return EKEYEXPIRED;
 166     case 128: return EKEYREVOKED;
 167     case 129: return EKEYREJECTED;
 168     case 130: return EOWNERDEAD;
 169     case 131: return ENOTRECOVERABLE;
 170     case 132: return ERFKILL;
 171     case 133: return EHWPOISON;
 172     default:
 173       return r;
 174   }
 175 }
 176
 177 __u32 hostos_to_ceph_errno_unsigned(__u32 r) {
 178   // Windows errno -> Linux errno
 179   switch(r) {
 180     case EPERM: return 1;
 181     case ENOENT: return 2;
 182     case ESRCH: return 3;
 183     case EINTR: return 4;
 184     case EIO: return 5;
 185     case ENXIO: return 6;
 186     case E2BIG: return 7;
 187     case ENOEXEC: return 8;
 188     case EBADF: return 9;
 189     case ECHILD: return 10;
 190     case EAGAIN: return 11;
 191     case EWOULDBLOCK: return 11;
 192     case ENOMEM: return 12;
 193     case EACCES: return 13;
 194     case EFAULT: return 14;
 195     case ENOTBLK: return 15;
 196     case EBUSY: return 16;
 197     case EEXIST: return 17;
 198     case EXDEV: return 18;
 199     case ENODEV: return 19;
 200     case ENOTDIR: return 20;
 201     case EISDIR: return 21;
 202     case EINVAL: return 22;
 203     case ENFILE: return 23;
 204     case EMFILE: return 24;
 205     case ENOTTY: return 25;
 206     case ETXTBSY: return 26;
 207     case EFBIG: return 27;
 208     case ENOSPC: return 28;
 209     case ESPIPE: return 29;
 210     case EROFS: return 30;
 211     case EMLINK: return 31;
 212     case EPIPE: return 32;
 213     case EDOM: return 33;
 214     case ERANGE: return 34;
 215     // same as EDEADLOCK
 216     // case EDEADLK: return 35;
 217     case EDEADLOCK: return 35;
 218     case ENAMETOOLONG: return 36;
 219     case ENOLCK: return 37;
 220     case ENOSYS: return 38;
 221     case ENOTEMPTY: return 39;
 222     case ELOOP: return 40;
 223     case ENOMSG: return 42;
 224     case EIDRM: return 43;
 225     case ECHRNG: return 44;
 226     case EL2NSYNC: return 45;
 227     case EL3HLT: return 46;
 228     case EL3RST: return 47;
 229     case ELNRNG: return 48;
 230     case EUNATCH: return 49;
 231     case ENOCSI: return 50;
 232     case EL2HLT: return 51;
 233     case EBADE: return 52;
 234     case EBADR: return 53;
 235     case EXFULL: return 54;
 236     case ENOANO: return 55;
 237     case EBADRQC: return 56;
 238     case EBADSLT: return 57;
 239     case EBFONT: return 59;
 240     case ENOSTR: return 60;
 241     case ENODATA: return 61;
 242     case ETIME: return 62;
 243     case ENOSR: return 63;
 244     case ENONET: return 64;
 245     case ENOPKG: return 65;
 246     case EREMOTE: return 66;
 247     case ENOLINK: return 67;
 248     case EADV: return 68;
 249     case ESRMNT: return 69;
 250     case ECOMM: return 70;
 251     case EPROTO: return 71;
 252     case EMULTIHOP: return 72;
 253     case EDOTDOT: return 73;
 254     case EBADMSG: return 74;
 255     case EOVERFLOW: return 75;
 256     case ENOTUNIQ: return 76;
 257     case EBADFD: return 77;
 258     case EREMCHG: return 78;
 259     case ELIBACC: return 79;
 260     case ELIBBAD: return 80;
 261     case ELIBSCN: return 81;
 262     case ELIBMAX: return 82;
 263     case ELIBEXEC: return 83;
 264     case EILSEQ: return 84;
 265     // compat.h defines ERESTART as EINTR
 266     // case ERESTART: return 85;
 267     case ESTRPIPE: return 86;
 268     case EUSERS: return 87;
 269     case ENOTSOCK: return 88;
 270     case EDESTADDRREQ: return 89;
 271     case EMSGSIZE: return 90;
 272     case EPROTOTYPE: return 91;
 273     case ENOPROTOOPT: return 92;
 274     case EPROTONOSUPPORT: return 93;
 275     case ESOCKTNOSUPPORT: return 94;
 276     case EOPNOTSUPP: return 95;
 277     case ENOTSUP: return 95;
 278     case EPFNOSUPPORT: return 96;
 279     case EAFNOSUPPORT: return 97;
 280     case EADDRINUSE: return 98;
 281     case EADDRNOTAVAIL: return 99;
 282     case ENETDOWN: return 100;
 283     case ENETUNREACH: return 101;
 284     case ENETRESET: return 102;
 285     case ECONNABORTED: return 103;
 286     case ECONNRESET: return 104;
 287     case ENOBUFS: return 105;
 288     case EISCONN: return 106;
 289     case ENOTCONN: return 107;
 290     case ESHUTDOWN: return 108;
 291     case ETOOMANYREFS: return 109;
 292     case ETIMEDOUT: return 110;
 293     case ECONNREFUSED: return 111;
 294     case EHOSTDOWN: return 112;
 295     case EHOSTUNREACH: return 113;
 296     case EALREADY: return 114;
 297     case EINPROGRESS: return 115;
 298     case ESTALE: return 116;
 299     case EUCLEAN: return 117;
 300     case ENOTNAM: return 118;
 301     case ENAVAIL: return 119;
 302     case EISNAM: return 120;
 303     case EREMOTEIO: return 121;
 304     case EDQUOT: return 122;
 305     case ENOMEDIUM: return 123;
 306     case EMEDIUMTYPE: return 124;
 307     case ECANCELED: return 125;
 308     case ENOKEY: return 126;
 309     case EKEYEXPIRED: return 127;
 310     case EKEYREVOKED: return 128;
 311     case EKEYREJECTED: return 129;
 312     case EOWNERDEAD: return 130;
 313     case ENOTRECOVERABLE: return 131;
 314     case ERFKILL: return 132;
 315     case EHWPOISON: return 133;
 316     default:
 317       return r;
 318  }
 319 }
 320
 321 __s32 wsae_to_errno_unsigned(__s32 r)
 322 {
 323   switch(r) {
 324     case WSAEINTR: return EINTR;
 325     case WSAEBADF: return EBADF;
 326     case WSAEACCES: return EACCES;
 327     case WSAEFAULT: return EFAULT;
 328     case WSAEINVAL: return EINVAL;
 329     case WSAEMFILE: return EMFILE;
 330     // Linux defines WSAEWOULDBLOCK as EAGAIN, but not Windows headers.
 331     // Since all ceph code uses EAGAIN instead of EWOULDBLOCK, we'll do
 332     // the same here.
 333     case WSAEWOULDBLOCK: return EAGAIN;
 334     // Some functions (e.g. connect) can return WSAEWOULDBLOCK instead of
 335     // EINPROGRESS.
 336     case WSAEINPROGRESS: return EINPROGRESS;
 337     case WSAEALREADY: return EALREADY;
 338     case WSAENOTSOCK: return ENOTSOCK;
 339     case WSAEDESTADDRREQ: return EDESTADDRREQ;
 340     case WSAEMSGSIZE: return EMSGSIZE;
 341     case WSAEPROTOTYPE: return EPROTOTYPE;
 342     case WSAENOPROTOOPT: return ENOPROTOOPT;
 343     case WSAEPROTONOSUPPORT: return EPROTONOSUPPORT;
 344     case WSAESOCKTNOSUPPORT: return ESOCKTNOSUPPORT;
 345     case WSAEOPNOTSUPP: return EOPNOTSUPP;
 346     case WSAEPFNOSUPPORT: return EPFNOSUPPORT;
 347     case WSAEAFNOSUPPORT: return EAFNOSUPPORT;
 348     case WSAEADDRINUSE: return EADDRINUSE;
 349     case WSAEADDRNOTAVAIL: return EADDRNOTAVAIL;
 350     case WSAENETDOWN: return ENETDOWN;
 351     case WSAENETUNREACH: return ENETUNREACH;
 352     case WSAENETRESET: return ENETRESET;
 353     case WSAECONNABORTED: return ECONNABORTED;
 354     case WSAECONNRESET: return ECONNRESET;
 355     case WSAENOBUFS: return ENOBUFS;
 356     case WSAEISCONN: return EISCONN;
 357     case WSAENOTCONN: return ENOTCONN;
 358     case WSAESHUTDOWN: return ESHUTDOWN;
 359     case WSAETOOMANYREFS: return ETOOMANYREFS;
 360     case WSAETIMEDOUT: return ETIMEDOUT;
 361     case WSAECONNREFUSED: return ECONNREFUSED;
 362     case WSAELOOP: return ELOOP;
 363     case WSAENAMETOOLONG: return ENAMETOOLONG;
 364     case WSAEHOSTDOWN: return EHOSTDOWN;
 365     case WSAEHOSTUNREACH: return EHOSTUNREACH;
 366     case WSAENOTEMPTY: return ENOTEMPTY;
 367     // case WSAEPROCLIM
 368     case WSAEUSERS: return EUSERS;
 369     case WSAEDQUOT: return EDQUOT;
 370     case WSAESTALE: return ESTALE;
 371     case WSAEREMOTE: return EREMOTE;
 372     // case WSASYSNOTREADY
 373     // case WSAVERNOTSUPPORTED
 374     // case WSANOTINITIALISED
 375     case WSAEDISCON: return ESHUTDOWN;
 376     // case WSAENOMORE
 377     case WSAECANCELLED: return ECANCELED;
 378     // We might return EINVAL, but it's probably better if we propagate the
 379     // original error code here.
 380     // case WSAEINVALIDPROCTABLE
 381     // case WSAEINVALIDPROVIDER
 382     // case WSAEPROVIDERFAILEDINIT
 383     // case WSASYSCALLFAILURE
 384     // case WSASERVICE_NOT_FOUND:
 385     // case WSATYPE_NOT_FOUND:
 386     // case WSA_E_NO_MORE:
 387     case WSA_E_CANCELLED: return ECANCELED;
 388     case WSAEREFUSED: return ECONNREFUSED;
 389     case WSAHOST_NOT_FOUND: return EHOSTUNREACH;
 390     case WSATRY_AGAIN: return EAGAIN;
 391     // case WSANO_RECOVERY
 392     // case WSANO_DATA:
 393     default: return r;
 394   }
 395 }
 396
 397 // converts from linux errno values to host values
 398 __s32 ceph_to_hostos_errno(__s32 r)
 399 {
 400   int sign = (r < 0 ? -1 : 1);
 401   return ceph_to_hostos_errno_unsigned(abs(r)) * sign;
 402 }
 403
 404 // converts Host OS errno values to linux/Ceph values
 405 __s32 hostos_to_ceph_errno(__s32 r)
 406 {
 407   int sign = (r < 0 ? -1 : 1);
 408   return hostos_to_ceph_errno_unsigned(abs(r)) * sign;
 409 }
 410
 411 __s32 wsae_to_errno(__s32 r)
 412 {
 413   int sign = (r < 0 ? -1 : 1);
 414   return wsae_to_errno_unsigned(abs(r)) * sign;
 415 }
 416
 417 __u32 errno_to_ntstatus(__s32 r) {
 418   // errno -> NTSTATUS
 419   // In some cases, there might be more than one applicable NTSTATUS
 420   // value or there might be none. Certain values can be overridden
 421   // when the caller (or whoever is supposed to handle the error) is
 422   // expecting a different NTSTATUS value.
 423   r = abs(r);
 424
 425   switch(r) {
 426     case 0: return 0;
 427     case EPERM: return STATUS_ACCESS_DENIED;
 428     case ENOENT: return STATUS_OBJECT_NAME_NOT_FOUND;
 429     case ESRCH: return STATUS_NOT_FOUND;
 430     case EINTR: return STATUS_RETRY;
 431     case EIO: return STATUS_DATA_ERROR;
 432     case ENXIO: return STATUS_NOT_FOUND;
 433     case E2BIG: return STATUS_FILE_TOO_LARGE;
 434     case ENOEXEC: return STATUS_ACCESS_DENIED;
 435     case EBADF: return STATUS_INVALID_HANDLE;
 436     case ECHILD: return STATUS_INTERNAL_ERROR;
 437     case EAGAIN: return STATUS_RETRY;
 438     case EWOULDBLOCK: return STATUS_RETRY;
 439     case ENOMEM: return STATUS_NO_MEMORY;
 440     case EACCES: return STATUS_ACCESS_DENIED;
 441     case EFAULT: return STATUS_INVALID_ADDRESS;
 442     case ENOTBLK: return STATUS_BAD_DEVICE_TYPE;
 443     case EBUSY: return STATUS_DEVICE_BUSY;
 444     case EEXIST: return STATUS_OBJECT_NAME_COLLISION;
 445     case EXDEV: return STATUS_NOT_SAME_DEVICE;
 446     case ENODEV: return STATUS_SYSTEM_DEVICE_NOT_FOUND;
 447     case ENOTDIR: return STATUS_NOT_A_DIRECTORY;
 448     case EISDIR: return STATUS_FILE_IS_A_DIRECTORY;
 449     case EINVAL: return STATUS_INVALID_PARAMETER;
 450     case ENFILE: return STATUS_TOO_MANY_OPENED_FILES;
 451     case EMFILE: return STATUS_TOO_MANY_OPENED_FILES;
 452     case ENOTTY: return STATUS_INVALID_PARAMETER;
 453     case ETXTBSY: return STATUS_DEVICE_BUSY;
 454     case EFBIG: return STATUS_FILE_TOO_LARGE;
 455     case ENOSPC: return STATUS_DISK_FULL;
 456     case ESPIPE: return STATUS_INVALID_PARAMETER;
 457     case EROFS: return STATUS_MEDIA_WRITE_PROTECTED;
 458     case EMLINK: return STATUS_TOO_MANY_LINKS;
 459     case EPIPE: return STATUS_PIPE_BROKEN;
 460     case EDOM: return STATUS_INVALID_PARAMETER;
 461     case ERANGE: return STATUS_INVALID_PARAMETER;
 462     // same as EDEADLOCK
 463     // case EDEADLK: return 35;
 464     case EDEADLOCK: return STATUS_POSSIBLE_DEADLOCK;
 465     case ENAMETOOLONG: return STATUS_NAME_TOO_LONG;
 466     case ENOLCK: return STATUS_NOT_LOCKED;
 467     case ENOSYS: return STATUS_NOT_IMPLEMENTED;
 468     case ENOTEMPTY: return STATUS_DIRECTORY_NOT_EMPTY;
 469     case ELOOP: return STATUS_TOO_MANY_LINKS;
 470     case ENOMSG: return STATUS_MESSAGE_NOT_FOUND;
 471     case EIDRM: return STATUS_INVALID_PARAMETER;
 472     case ECHRNG: return STATUS_INVALID_PARAMETER;
 473     case EL2NSYNC: return STATUS_INTERNAL_ERROR;
 474     case EL3HLT: return STATUS_INTERNAL_ERROR;
 475     case EL3RST: return STATUS_INTERNAL_ERROR;
 476     case ELNRNG: return STATUS_INTERNAL_ERROR;
 477     case EUNATCH: return STATUS_INTERNAL_ERROR;
 478     case ENOCSI: return STATUS_INTERNAL_ERROR;
 479     case EL2HLT: return STATUS_INTERNAL_ERROR;
 480     case EBADE: return STATUS_INTERNAL_ERROR;
 481     case EBADR: return STATUS_INVALID_HANDLE;
 482     case EXFULL: return STATUS_DISK_FULL;
 483     case ENOANO: return STATUS_INTERNAL_ERROR;
 484     case EBADRQC: return STATUS_INVALID_PARAMETER;
 485     case EBADSLT: return STATUS_INVALID_PARAMETER;
 486     case EBFONT: return STATUS_INVALID_PARAMETER;
 487     case ENOSTR: return STATUS_INVALID_PARAMETER;
 488     case ENODATA: return STATUS_NOT_FOUND;
 489     case ETIME: return STATUS_TIMEOUT;
 490     case ENOSR: return STATUS_INSUFFICIENT_RESOURCES;
 491     case ENONET: return STATUS_NETWORK_UNREACHABLE;
 492     case ENOPKG: return STATUS_NO_SUCH_PACKAGE;
 493     case EREMOTE: return STATUS_INVALID_PARAMETER;
 494     case ENOLINK: return STATUS_INTERNAL_ERROR;
 495     case EADV: return STATUS_INTERNAL_ERROR;
 496     case ESRMNT: return STATUS_INTERNAL_ERROR;
 497     case ECOMM: return STATUS_INTERNAL_ERROR;
 498     case EPROTO: return STATUS_PROTOCOL_NOT_SUPPORTED;
 499     case EMULTIHOP: return STATUS_INTERNAL_ERROR;
 500     case EDOTDOT: return STATUS_INTERNAL_ERROR;
 501     case EBADMSG: return STATUS_INVALID_PARAMETER;
 502     case EOVERFLOW: return STATUS_BUFFER_OVERFLOW;
 503     case ENOTUNIQ: return STATUS_DUPLICATE_NAME;
 504     case EBADFD: return STATUS_INVALID_HANDLE;
 505     case EREMCHG: return STATUS_FILE_RENAMED;
 506     case ELIBACC: return STATUS_DLL_NOT_FOUND;
 507     case ELIBBAD: return STATUS_BAD_DLL_ENTRYPOINT;
 508     case ELIBSCN: return STATUS_BAD_DLL_ENTRYPOINT;
 509     case ELIBMAX: return STATUS_TOO_MANY_OPENED_FILES;
 510     case ELIBEXEC: return STATUS_INVALID_PARAMETER;
 511     case EILSEQ: return STATUS_INVALID_PARAMETER;
 512     // compat.h defines ERESTART as EINTR
 513     // case ERESTART: return 85;
 514     case ESTRPIPE: return STATUS_RETRY;
 515     case EUSERS: return STATUS_TOO_MANY_SIDS;
 516     case ENOTSOCK: return STATUS_INVALID_HANDLE;
 517     case EDESTADDRREQ: return STATUS_INVALID_PARAMETER;
 518     case EMSGSIZE: return STATUS_BUFFER_OVERFLOW;
 519     case EPROTOTYPE: return STATUS_INVALID_PARAMETER;
 520     case ENOPROTOOPT: return STATUS_PROTOCOL_NOT_SUPPORTED;
 521     case EPROTONOSUPPORT: return STATUS_PROTOCOL_NOT_SUPPORTED;
 522     case ESOCKTNOSUPPORT: return STATUS_NOT_SUPPORTED;
 523     case EOPNOTSUPP: return STATUS_NOT_SUPPORTED;
 524     case ENOTSUP: return STATUS_NOT_SUPPORTED;
 525     case EPFNOSUPPORT: return STATUS_PROTOCOL_NOT_SUPPORTED;
 526     case EAFNOSUPPORT: return STATUS_NOT_SUPPORTED;
 527     case EADDRINUSE: return STATUS_ADDRESS_ALREADY_EXISTS;
 528     case EADDRNOTAVAIL: return STATUS_INVALID_ADDRESS;
 529     case ENETDOWN: return STATUS_NETWORK_UNREACHABLE;
 530     case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE;
 531     case ENETRESET: return STATUS_CONNECTION_RESET;
 532     case ECONNABORTED: return STATUS_CONNECTION_ABORTED;
 533     case ECONNRESET: return STATUS_CONNECTION_DISCONNECTED;
 534     case ENOBUFS: return STATUS_BUFFER_TOO_SMALL;
 535     case EISCONN: return STATUS_CONNECTION_ACTIVE;
 536     case ENOTCONN: return STATUS_CONNECTION_DISCONNECTED;
 537     case ESHUTDOWN: return STATUS_SYSTEM_SHUTDOWN;
 538     case ETOOMANYREFS: return STATUS_TOO_MANY_LINKS;
 539     case ETIMEDOUT: return STATUS_TIMEOUT;
 540     case ECONNREFUSED: return STATUS_CONNECTION_REFUSED;
 541     case EHOSTDOWN: return STATUS_FILE_CLOSED;
 542     case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE;
 543     case EALREADY: return STATUS_PENDING;
 544     case EINPROGRESS: return STATUS_PENDING;
 545     case ESTALE: return STATUS_INVALID_HANDLE;
 546     case EUCLEAN: return STATUS_INVALID_PARAMETER;
 547     case ENOTNAM: return STATUS_INVALID_PARAMETER;
 548     case ENAVAIL: return STATUS_INVALID_PARAMETER;
 549     case EISNAM: return STATUS_INVALID_PARAMETER;
 550     case EREMOTEIO: return STATUS_DATA_ERROR;
 551     case EDQUOT: return STATUS_QUOTA_EXCEEDED;
 552     case ENOMEDIUM: return STATUS_NO_MEDIA;
 553     case EMEDIUMTYPE: return STATUS_INVALID_PARAMETER;
 554     case ECANCELED: return STATUS_REQUEST_CANCELED;
 555     case ENOKEY: return STATUS_NO_USER_KEYS;
 556     case EKEYEXPIRED: return STATUS_SMARTCARD_CERT_EXPIRED;
 557     case EKEYREVOKED: return STATUS_IMAGE_CERT_REVOKED;
 558     case EKEYREJECTED: return STATUS_ACCESS_DENIED;
 559     case EOWNERDEAD: return STATUS_INTERNAL_ERROR;
 560     case ENOTRECOVERABLE: return STATUS_INTERNAL_ERROR;
 561     case ERFKILL: return STATUS_INTERNAL_ERROR;
 562     case EHWPOISON: return STATUS_INTERNAL_ERROR;
 563     default:
 564       return STATUS_INTERNAL_ERROR;
 565  }
 566 }
 567
 568 std::string win32_strerror(int err)
 569 {
 570   // As opposed to dlerror messages, this has to be freed.
 571   LPSTR msg = NULL;
 572   DWORD msg_len = ::FormatMessageA(
 573     FORMAT_MESSAGE_ALLOCATE_BUFFER |
 574     FORMAT_MESSAGE_FROM_SYSTEM |
 575     FORMAT_MESSAGE_IGNORE_INSERTS,
 576     NULL,
 577     err,
 578     0,
 579     (LPSTR) &msg,
 580     0,
 581     NULL);
 582
 583   std::ostringstream msg_stream;
 584   msg_stream << "(" << err << ") ";
 585   if (!msg_len) {
 586     msg_stream << "Unknown error";
 587   }
 588   else {
 589     msg_stream << msg;
 590     ::LocalFree(msg);
 591   }
 592   return msg_stream.str();
 593 }
 594
 595 std::string win32_lasterror_str()
 596 {
 597   DWORD err = ::GetLastError();
 598   return win32_strerror(err);
 599 }
 600
 601 static const ceph::unordered_map<int,NTSTATUS> cephfs_errno_to_ntstatus = {
 602   {CEPHFS_EBLOCKLISTED,    STATUS_SYSTEM_SHUTDOWN},
 603   {CEPHFS_EPERM,           STATUS_ACCESS_DENIED},
 604   {CEPHFS_ESTALE,          STATUS_INVALID_HANDLE},
 605   {CEPHFS_ENOSPC,          STATUS_DISK_FULL},
 606   {CEPHFS_ETIMEDOUT,       STATUS_TIMEOUT},
 607   {CEPHFS_EIO,             STATUS_DATA_ERROR},
 608   {CEPHFS_ENOTCONN,        STATUS_CONNECTION_DISCONNECTED},
 609   {CEPHFS_EEXIST,          STATUS_OBJECT_NAME_COLLISION},
 610   {CEPHFS_EINTR,           STATUS_RETRY},
 611   {CEPHFS_EINVAL,          STATUS_INVALID_PARAMETER},
 612   {CEPHFS_EBADF,           STATUS_INVALID_HANDLE},
 613   {CEPHFS_EROFS,           STATUS_MEDIA_WRITE_PROTECTED},
 614   {CEPHFS_EAGAIN,          STATUS_RETRY},
 615   {CEPHFS_EACCES,          STATUS_ACCESS_DENIED},
 616   {CEPHFS_ELOOP,           STATUS_TOO_MANY_LINKS},
 617   {CEPHFS_EISDIR,          STATUS_FILE_IS_A_DIRECTORY},
 618   {CEPHFS_ENOENT,          STATUS_OBJECT_NAME_NOT_FOUND},
 619   {CEPHFS_ENOTDIR,         STATUS_NOT_A_DIRECTORY},
 620   {CEPHFS_ENAMETOOLONG,    STATUS_NAME_TOO_LONG},
 621   {CEPHFS_EBUSY,           STATUS_DEVICE_BUSY},
 622   {CEPHFS_EDQUOT,          STATUS_QUOTA_EXCEEDED},
 623   {CEPHFS_EFBIG,           STATUS_FILE_TOO_LARGE},
 624   {CEPHFS_ERANGE,          STATUS_INVALID_PARAMETER},
 625   {CEPHFS_ENXIO,           STATUS_NOT_FOUND},
 626   {CEPHFS_ECANCELED,       STATUS_REQUEST_CANCELED},
 627   {CEPHFS_ENODATA,         STATUS_NOT_FOUND},
 628   {CEPHFS_EOPNOTSUPP,      STATUS_NOT_SUPPORTED},
 629   {CEPHFS_EXDEV,           STATUS_NOT_SAME_DEVICE},
 630   {CEPHFS_ENOMEM,          STATUS_NO_MEMORY},
 631   {CEPHFS_ENOTRECOVERABLE, STATUS_INTERNAL_ERROR},
 632   {CEPHFS_ENOSYS,          STATUS_NOT_IMPLEMENTED},
 633   {CEPHFS_ENOTEMPTY,       STATUS_DIRECTORY_NOT_EMPTY},
 634   {CEPHFS_EDEADLK,         STATUS_POSSIBLE_DEADLOCK},
 635   {CEPHFS_EDOM,            STATUS_INVALID_PARAMETER},
 636   {CEPHFS_EMLINK,          STATUS_TOO_MANY_LINKS},
 637   {CEPHFS_ETIME,           STATUS_TIMEOUT},
 638   {CEPHFS_EOLDSNAPC,       STATUS_DATA_ERROR}
 639 };
 640
 641 __u32 cephfs_errno_to_ntstatus_map(int cephfs_errno)
 642 {
 643   cephfs_errno = abs(cephfs_errno);
 644
 645   if (cephfs_errno == 0)
 646     return 0;
 647
 648   auto it = cephfs_errno_to_ntstatus.find(cephfs_errno);
 649   if (it != cephfs_errno_to_ntstatus.end())
 650     return it->second;
 651   return STATUS_INTERNAL_ERROR;
 652 }