// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- // vim: ts=8 sw=2 smarttab /* * Ceph - scalable distributed file system * * Copyright (C) 2020 SUSE LINUX GmbH * * This is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software * Foundation. See file COPYING. * */ #include #include #include "include/int_types.h" #include #include #include "include/compat.h" #include "include/int_types.h" #include "include/types.h" #include "include/fs_types.h" // We're only converting errors defined in errno.h, not standard Windows // system error codes that are usually retrievied using GetLastErrorCode(). // TODO: consider converting WinSock2 (WSA*) error codes, which are quite // similar to the errno.h ones. __u32 ceph_to_hostos_errno_unsigned(__u32 r) { // using an array like like freebsd_errno.cc might be more readable but // we have some large values defined by Boost. switch(r) { case 1: return EPERM; case 2: return ENOENT; case 3: return ESRCH; case 4: return EINTR; case 5: return EIO; case 6: return ENXIO; case 7: return E2BIG; case 8: return ENOEXEC; case 9: return EBADF; case 10: return ECHILD; // same as EWOULDBLOCK case 11: return EAGAIN; case 12: return ENOMEM; case 13: return EACCES; case 14: return EFAULT; case 15: return ENOTBLK; case 16: return EBUSY; case 17: return EEXIST; case 18: return EXDEV; case 19: return ENODEV; case 20: return ENOTDIR; case 21: return EISDIR; case 22: return EINVAL; case 23: return ENFILE; case 24: return EMFILE; case 25: return ENOTTY; case 26: return ETXTBSY; case 27: return EFBIG; case 28: return ENOSPC; case 29: return ESPIPE; case 30: return EROFS; case 31: return EMLINK; case 32: return EPIPE; case 33: return EDOM; case 34: return ERANGE; // same as EDEADLK case 35: return EDEADLOCK; case 36: return ENAMETOOLONG; case 37: return ENOLCK; case 38: return ENOSYS; case 39: return ENOTEMPTY; case 40: return ELOOP; case 42: return ENOMSG; case 43: return EIDRM; case 44: return ECHRNG; case 45: return EL2NSYNC; case 46: return EL3HLT; case 47: return EL3RST; case 48: return ELNRNG; case 49: return EUNATCH; case 50: return ENOCSI; case 51: return EL2HLT; case 52: return EBADE; case 53: return EBADR; case 54: return EXFULL; case 55: return ENOANO; case 56: return EBADRQC; case 57: return EBADSLT; case 59: return EBFONT; case 60: return ENOSTR; case 61: return ENODATA; case 62: return ETIME; case 63: return ENOSR; case 64: return ENONET; case 65: return ENOPKG; case 66: return EREMOTE; case 67: return ENOLINK; case 68: return EADV; case 69: return ESRMNT; case 70: return ECOMM; case 71: return EPROTO; case 72: return EMULTIHOP; case 73: return EDOTDOT; case 74: return EBADMSG; case 75: return EOVERFLOW; case 76: return ENOTUNIQ; case 77: return EBADFD; case 78: return EREMCHG; case 79: return ELIBACC; case 80: return ELIBBAD; case 81: return ELIBSCN; case 82: return ELIBMAX; case 83: return ELIBEXEC; case 84: return EILSEQ; case 85: return ERESTART; case 86: return ESTRPIPE; case 87: return EUSERS; case 88: return ENOTSOCK; case 89: return EDESTADDRREQ; case 90: return EMSGSIZE; case 91: return EPROTOTYPE; case 92: return ENOPROTOOPT; case 93: return EPROTONOSUPPORT; case 94: return ESOCKTNOSUPPORT; // same as ENOTSUP case 95: return EOPNOTSUPP; case 96: return EPFNOSUPPORT; case 97: return EAFNOSUPPORT; case 98: return EADDRINUSE; case 99: return EADDRNOTAVAIL; case 100: return ENETDOWN; case 101: return ENETUNREACH; case 102: return ENETRESET; case 103: return ECONNABORTED; case 104: return ECONNRESET; case 105: return ENOBUFS; case 106: return EISCONN; case 107: return ENOTCONN; case 108: return ESHUTDOWN; case 109: return ETOOMANYREFS; case 110: return ETIMEDOUT; case 111: return ECONNREFUSED; case 112: return EHOSTDOWN; case 113: return EHOSTUNREACH; case 114: return EALREADY; case 115: return EINPROGRESS; case 116: return ESTALE; case 117: return EUCLEAN; case 118: return ENOTNAM; case 119: return ENAVAIL; case 120: return EISNAM; case 121: return EREMOTEIO; case 122: return EDQUOT; case 123: return ENOMEDIUM; case 124: return EMEDIUMTYPE; case 125: return ECANCELED; case 126: return ENOKEY; case 127: return EKEYEXPIRED; case 128: return EKEYREVOKED; case 129: return EKEYREJECTED; case 130: return EOWNERDEAD; case 131: return ENOTRECOVERABLE; case 132: return ERFKILL; case 133: return EHWPOISON; default: return r; } } __u32 hostos_to_ceph_errno_unsigned(__u32 r) { // Windows errno -> Linux errno switch(r) { case EPERM: return 1; case ENOENT: return 2; case ESRCH: return 3; case EINTR: return 4; case EIO: return 5; case ENXIO: return 6; case E2BIG: return 7; case ENOEXEC: return 8; case EBADF: return 9; case ECHILD: return 10; case EAGAIN: return 11; case EWOULDBLOCK: return 11; case ENOMEM: return 12; case EACCES: return 13; case EFAULT: return 14; case ENOTBLK: return 15; case EBUSY: return 16; case EEXIST: return 17; case EXDEV: return 18; case ENODEV: return 19; case ENOTDIR: return 20; case EISDIR: return 21; case EINVAL: return 22; case ENFILE: return 23; case EMFILE: return 24; case ENOTTY: return 25; case ETXTBSY: return 26; case EFBIG: return 27; case ENOSPC: return 28; case ESPIPE: return 29; case EROFS: return 30; case EMLINK: return 31; case EPIPE: return 32; case EDOM: return 33; case ERANGE: return 34; // same as EDEADLOCK // case EDEADLK: return 35; case EDEADLOCK: return 35; case ENAMETOOLONG: return 36; case ENOLCK: return 37; case ENOSYS: return 38; case ENOTEMPTY: return 39; case ELOOP: return 40; case ENOMSG: return 42; case EIDRM: return 43; case ECHRNG: return 44; case EL2NSYNC: return 45; case EL3HLT: return 46; case EL3RST: return 47; case ELNRNG: return 48; case EUNATCH: return 49; case ENOCSI: return 50; case EL2HLT: return 51; case EBADE: return 52; case EBADR: return 53; case EXFULL: return 54; case ENOANO: return 55; case EBADRQC: return 56; case EBADSLT: return 57; case EBFONT: return 59; case ENOSTR: return 60; case ENODATA: return 61; case ETIME: return 62; case ENOSR: return 63; case ENONET: return 64; case ENOPKG: return 65; case EREMOTE: return 66; case ENOLINK: return 67; case EADV: return 68; case ESRMNT: return 69; case ECOMM: return 70; case EPROTO: return 71; case EMULTIHOP: return 72; case EDOTDOT: return 73; case EBADMSG: return 74; case EOVERFLOW: return 75; case ENOTUNIQ: return 76; case EBADFD: return 77; case EREMCHG: return 78; case ELIBACC: return 79; case ELIBBAD: return 80; case ELIBSCN: return 81; case ELIBMAX: return 82; case ELIBEXEC: return 83; case EILSEQ: return 84; // compat.h defines ERESTART as EINTR // case ERESTART: return 85; case ESTRPIPE: return 86; case EUSERS: return 87; case ENOTSOCK: return 88; case EDESTADDRREQ: return 89; case EMSGSIZE: return 90; case EPROTOTYPE: return 91; case ENOPROTOOPT: return 92; case EPROTONOSUPPORT: return 93; case ESOCKTNOSUPPORT: return 94; case EOPNOTSUPP: return 95; case ENOTSUP: return 95; case EPFNOSUPPORT: return 96; case EAFNOSUPPORT: return 97; case EADDRINUSE: return 98; case EADDRNOTAVAIL: return 99; case ENETDOWN: return 100; case ENETUNREACH: return 101; case ENETRESET: return 102; case ECONNABORTED: return 103; case ECONNRESET: return 104; case ENOBUFS: return 105; case EISCONN: return 106; case ENOTCONN: return 107; case ESHUTDOWN: return 108; case ETOOMANYREFS: return 109; case ETIMEDOUT: return 110; case ECONNREFUSED: return 111; case EHOSTDOWN: return 112; case EHOSTUNREACH: return 113; case EALREADY: return 114; case EINPROGRESS: return 115; case ESTALE: return 116; case EUCLEAN: return 117; case ENOTNAM: return 118; case ENAVAIL: return 119; case EISNAM: return 120; case EREMOTEIO: return 121; case EDQUOT: return 122; case ENOMEDIUM: return 123; case EMEDIUMTYPE: return 124; case ECANCELED: return 125; case ENOKEY: return 126; case EKEYEXPIRED: return 127; case EKEYREVOKED: return 128; case EKEYREJECTED: return 129; case EOWNERDEAD: return 130; case ENOTRECOVERABLE: return 131; case ERFKILL: return 132; case EHWPOISON: return 133; default: return r; } } __s32 wsae_to_errno_unsigned(__s32 r) { switch(r) { case WSAEINTR: return EINTR; case WSAEBADF: return EBADF; case WSAEACCES: return EACCES; case WSAEFAULT: return EFAULT; case WSAEINVAL: return EINVAL; case WSAEMFILE: return EMFILE; // Linux defines WSAEWOULDBLOCK as EAGAIN, but not Windows headers. // Since all ceph code uses EAGAIN instead of EWOULDBLOCK, we'll do // the same here. case WSAEWOULDBLOCK: return EAGAIN; // Some functions (e.g. connect) can return WSAEWOULDBLOCK instead of // EINPROGRESS. case WSAEINPROGRESS: return EINPROGRESS; case WSAEALREADY: return EALREADY; case WSAENOTSOCK: return ENOTSOCK; case WSAEDESTADDRREQ: return EDESTADDRREQ; case WSAEMSGSIZE: return EMSGSIZE; case WSAEPROTOTYPE: return EPROTOTYPE; case WSAENOPROTOOPT: return ENOPROTOOPT; case WSAEPROTONOSUPPORT: return EPROTONOSUPPORT; case WSAESOCKTNOSUPPORT: return ESOCKTNOSUPPORT; case WSAEOPNOTSUPP: return EOPNOTSUPP; case WSAEPFNOSUPPORT: return EPFNOSUPPORT; case WSAEAFNOSUPPORT: return EAFNOSUPPORT; case WSAEADDRINUSE: return EADDRINUSE; case WSAEADDRNOTAVAIL: return EADDRNOTAVAIL; case WSAENETDOWN: return ENETDOWN; case WSAENETUNREACH: return ENETUNREACH; case WSAENETRESET: return ENETRESET; case WSAECONNABORTED: return ECONNABORTED; case WSAECONNRESET: return ECONNRESET; case WSAENOBUFS: return ENOBUFS; case WSAEISCONN: return EISCONN; case WSAENOTCONN: return ENOTCONN; case WSAESHUTDOWN: return ESHUTDOWN; case WSAETOOMANYREFS: return ETOOMANYREFS; case WSAETIMEDOUT: return ETIMEDOUT; case WSAECONNREFUSED: return ECONNREFUSED; case WSAELOOP: return ELOOP; case WSAENAMETOOLONG: return ENAMETOOLONG; case WSAEHOSTDOWN: return EHOSTDOWN; case WSAEHOSTUNREACH: return EHOSTUNREACH; case WSAENOTEMPTY: return ENOTEMPTY; // case WSAEPROCLIM case WSAEUSERS: return EUSERS; case WSAEDQUOT: return EDQUOT; case WSAESTALE: return ESTALE; case WSAEREMOTE: return EREMOTE; // case WSASYSNOTREADY // case WSAVERNOTSUPPORTED // case WSANOTINITIALISED case WSAEDISCON: return ESHUTDOWN; // case WSAENOMORE case WSAECANCELLED: return ECANCELED; // We might return EINVAL, but it's probably better if we propagate the // original error code here. // case WSAEINVALIDPROCTABLE // case WSAEINVALIDPROVIDER // case WSAEPROVIDERFAILEDINIT // case WSASYSCALLFAILURE // case WSASERVICE_NOT_FOUND: // case WSATYPE_NOT_FOUND: // case WSA_E_NO_MORE: case WSA_E_CANCELLED: return ECANCELED; case WSAEREFUSED: return ECONNREFUSED; case WSAHOST_NOT_FOUND: return EHOSTUNREACH; case WSATRY_AGAIN: return EAGAIN; // case WSANO_RECOVERY // case WSANO_DATA: default: return r; } } // converts from linux errno values to host values __s32 ceph_to_hostos_errno(__s32 r) { int sign = (r < 0 ? -1 : 1); return ceph_to_hostos_errno_unsigned(abs(r)) * sign; } // converts Host OS errno values to linux/Ceph values __s32 hostos_to_ceph_errno(__s32 r) { int sign = (r < 0 ? -1 : 1); return hostos_to_ceph_errno_unsigned(abs(r)) * sign; } __s32 wsae_to_errno(__s32 r) { int sign = (r < 0 ? -1 : 1); return wsae_to_errno_unsigned(abs(r)) * sign; } __u32 errno_to_ntstatus(__s32 r) { // errno -> NTSTATUS // In some cases, there might be more than one applicable NTSTATUS // value or there might be none. Certain values can be overridden // when the caller (or whoever is supposed to handle the error) is // expecting a different NTSTATUS value. r = abs(r); switch(r) { case 0: return 0; case EPERM: return STATUS_ACCESS_DENIED; case ENOENT: return STATUS_OBJECT_NAME_NOT_FOUND; case ESRCH: return STATUS_NOT_FOUND; case EINTR: return STATUS_RETRY; case EIO: return STATUS_DATA_ERROR; case ENXIO: return STATUS_NOT_FOUND; case E2BIG: return STATUS_FILE_TOO_LARGE; case ENOEXEC: return STATUS_ACCESS_DENIED; case EBADF: return STATUS_INVALID_HANDLE; case ECHILD: return STATUS_INTERNAL_ERROR; case EAGAIN: return STATUS_RETRY; case EWOULDBLOCK: return STATUS_RETRY; case ENOMEM: return STATUS_NO_MEMORY; case EACCES: return STATUS_ACCESS_DENIED; case EFAULT: return STATUS_INVALID_ADDRESS; case ENOTBLK: return STATUS_BAD_DEVICE_TYPE; case EBUSY: return STATUS_DEVICE_BUSY; case EEXIST: return STATUS_OBJECT_NAME_COLLISION; case EXDEV: return STATUS_NOT_SAME_DEVICE; case ENODEV: return STATUS_SYSTEM_DEVICE_NOT_FOUND; case ENOTDIR: return STATUS_NOT_A_DIRECTORY; case EISDIR: return STATUS_FILE_IS_A_DIRECTORY; case EINVAL: return STATUS_INVALID_PARAMETER; case ENFILE: return STATUS_TOO_MANY_OPENED_FILES; case EMFILE: return STATUS_TOO_MANY_OPENED_FILES; case ENOTTY: return STATUS_INVALID_PARAMETER; case ETXTBSY: return STATUS_DEVICE_BUSY; case EFBIG: return STATUS_FILE_TOO_LARGE; case ENOSPC: return STATUS_DISK_FULL; case ESPIPE: return STATUS_INVALID_PARAMETER; case EROFS: return STATUS_MEDIA_WRITE_PROTECTED; case EMLINK: return STATUS_TOO_MANY_LINKS; case EPIPE: return STATUS_PIPE_BROKEN; case EDOM: return STATUS_INVALID_PARAMETER; case ERANGE: return STATUS_INVALID_PARAMETER; // same as EDEADLOCK // case EDEADLK: return 35; case EDEADLOCK: return STATUS_POSSIBLE_DEADLOCK; case ENAMETOOLONG: return STATUS_NAME_TOO_LONG; case ENOLCK: return STATUS_NOT_LOCKED; case ENOSYS: return STATUS_NOT_IMPLEMENTED; case ENOTEMPTY: return STATUS_DIRECTORY_NOT_EMPTY; case ELOOP: return STATUS_TOO_MANY_LINKS; case ENOMSG: return STATUS_MESSAGE_NOT_FOUND; case EIDRM: return STATUS_INVALID_PARAMETER; case ECHRNG: return STATUS_INVALID_PARAMETER; case EL2NSYNC: return STATUS_INTERNAL_ERROR; case EL3HLT: return STATUS_INTERNAL_ERROR; case EL3RST: return STATUS_INTERNAL_ERROR; case ELNRNG: return STATUS_INTERNAL_ERROR; case EUNATCH: return STATUS_INTERNAL_ERROR; case ENOCSI: return STATUS_INTERNAL_ERROR; case EL2HLT: return STATUS_INTERNAL_ERROR; case EBADE: return STATUS_INTERNAL_ERROR; case EBADR: return STATUS_INVALID_HANDLE; case EXFULL: return STATUS_DISK_FULL; case ENOANO: return STATUS_INTERNAL_ERROR; case EBADRQC: return STATUS_INVALID_PARAMETER; case EBADSLT: return STATUS_INVALID_PARAMETER; case EBFONT: return STATUS_INVALID_PARAMETER; case ENOSTR: return STATUS_INVALID_PARAMETER; case ENODATA: return STATUS_NOT_FOUND; case ETIME: return STATUS_TIMEOUT; case ENOSR: return STATUS_INSUFFICIENT_RESOURCES; case ENONET: return STATUS_NETWORK_UNREACHABLE; case ENOPKG: return STATUS_NO_SUCH_PACKAGE; case EREMOTE: return STATUS_INVALID_PARAMETER; case ENOLINK: return STATUS_INTERNAL_ERROR; case EADV: return STATUS_INTERNAL_ERROR; case ESRMNT: return STATUS_INTERNAL_ERROR; case ECOMM: return STATUS_INTERNAL_ERROR; case EPROTO: return STATUS_PROTOCOL_NOT_SUPPORTED; case EMULTIHOP: return STATUS_INTERNAL_ERROR; case EDOTDOT: return STATUS_INTERNAL_ERROR; case EBADMSG: return STATUS_INVALID_PARAMETER; case EOVERFLOW: return STATUS_BUFFER_OVERFLOW; case ENOTUNIQ: return STATUS_DUPLICATE_NAME; case EBADFD: return STATUS_INVALID_HANDLE; case EREMCHG: return STATUS_FILE_RENAMED; case ELIBACC: return STATUS_DLL_NOT_FOUND; case ELIBBAD: return STATUS_BAD_DLL_ENTRYPOINT; case ELIBSCN: return STATUS_BAD_DLL_ENTRYPOINT; case ELIBMAX: return STATUS_TOO_MANY_OPENED_FILES; case ELIBEXEC: return STATUS_INVALID_PARAMETER; case EILSEQ: return STATUS_INVALID_PARAMETER; // compat.h defines ERESTART as EINTR // case ERESTART: return 85; case ESTRPIPE: return STATUS_RETRY; case EUSERS: return STATUS_TOO_MANY_SIDS; case ENOTSOCK: return STATUS_INVALID_HANDLE; case EDESTADDRREQ: return STATUS_INVALID_PARAMETER; case EMSGSIZE: return STATUS_BUFFER_OVERFLOW; case EPROTOTYPE: return STATUS_INVALID_PARAMETER; case ENOPROTOOPT: return STATUS_PROTOCOL_NOT_SUPPORTED; case EPROTONOSUPPORT: return STATUS_PROTOCOL_NOT_SUPPORTED; case ESOCKTNOSUPPORT: return STATUS_NOT_SUPPORTED; case EOPNOTSUPP: return STATUS_NOT_SUPPORTED; case ENOTSUP: return STATUS_NOT_SUPPORTED; case EPFNOSUPPORT: return STATUS_PROTOCOL_NOT_SUPPORTED; case EAFNOSUPPORT: return STATUS_NOT_SUPPORTED; case EADDRINUSE: return STATUS_ADDRESS_ALREADY_EXISTS; case EADDRNOTAVAIL: return STATUS_INVALID_ADDRESS; case ENETDOWN: return STATUS_NETWORK_UNREACHABLE; case ENETUNREACH: return STATUS_NETWORK_UNREACHABLE; case ENETRESET: return STATUS_CONNECTION_RESET; case ECONNABORTED: return STATUS_CONNECTION_ABORTED; case ECONNRESET: return STATUS_CONNECTION_DISCONNECTED; case ENOBUFS: return STATUS_BUFFER_TOO_SMALL; case EISCONN: return STATUS_CONNECTION_ACTIVE; case ENOTCONN: return STATUS_CONNECTION_DISCONNECTED; case ESHUTDOWN: return STATUS_SYSTEM_SHUTDOWN; case ETOOMANYREFS: return STATUS_TOO_MANY_LINKS; case ETIMEDOUT: return STATUS_TIMEOUT; case ECONNREFUSED: return STATUS_CONNECTION_REFUSED; case EHOSTDOWN: return STATUS_FILE_CLOSED; case EHOSTUNREACH: return STATUS_HOST_UNREACHABLE; case EALREADY: return STATUS_PENDING; case EINPROGRESS: return STATUS_PENDING; case ESTALE: return STATUS_INVALID_HANDLE; case EUCLEAN: return STATUS_INVALID_PARAMETER; case ENOTNAM: return STATUS_INVALID_PARAMETER; case ENAVAIL: return STATUS_INVALID_PARAMETER; case EISNAM: return STATUS_INVALID_PARAMETER; case EREMOTEIO: return STATUS_DATA_ERROR; case EDQUOT: return STATUS_QUOTA_EXCEEDED; case ENOMEDIUM: return STATUS_NO_MEDIA; case EMEDIUMTYPE: return STATUS_INVALID_PARAMETER; case ECANCELED: return STATUS_REQUEST_CANCELED; case ENOKEY: return STATUS_NO_USER_KEYS; case EKEYEXPIRED: return STATUS_SMARTCARD_CERT_EXPIRED; case EKEYREVOKED: return STATUS_IMAGE_CERT_REVOKED; case EKEYREJECTED: return STATUS_ACCESS_DENIED; case EOWNERDEAD: return STATUS_INTERNAL_ERROR; case ENOTRECOVERABLE: return STATUS_INTERNAL_ERROR; case ERFKILL: return STATUS_INTERNAL_ERROR; case EHWPOISON: return STATUS_INTERNAL_ERROR; default: return STATUS_INTERNAL_ERROR; } } std::string win32_strerror(int err) { // As opposed to dlerror messages, this has to be freed. LPSTR msg = NULL; DWORD msg_len = ::FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, 0, (LPSTR) &msg, 0, NULL); std::ostringstream msg_stream; msg_stream << "(" << err << ") "; if (!msg_len) { msg_stream << "Unknown error"; } else { msg_stream << msg; ::LocalFree(msg); } return msg_stream.str(); } std::string win32_lasterror_str() { DWORD err = ::GetLastError(); return win32_strerror(err); } static const ceph::unordered_map cephfs_errno_to_ntstatus = { {CEPHFS_EBLOCKLISTED, STATUS_SYSTEM_SHUTDOWN}, {CEPHFS_EPERM, STATUS_ACCESS_DENIED}, {CEPHFS_ESTALE, STATUS_INVALID_HANDLE}, {CEPHFS_ENOSPC, STATUS_DISK_FULL}, {CEPHFS_ETIMEDOUT, STATUS_TIMEOUT}, {CEPHFS_EIO, STATUS_DATA_ERROR}, {CEPHFS_ENOTCONN, STATUS_CONNECTION_DISCONNECTED}, {CEPHFS_EEXIST, STATUS_OBJECT_NAME_COLLISION}, {CEPHFS_EINTR, STATUS_RETRY}, {CEPHFS_EINVAL, STATUS_INVALID_PARAMETER}, {CEPHFS_EBADF, STATUS_INVALID_HANDLE}, {CEPHFS_EROFS, STATUS_MEDIA_WRITE_PROTECTED}, {CEPHFS_EAGAIN, STATUS_RETRY}, {CEPHFS_EACCES, STATUS_ACCESS_DENIED}, {CEPHFS_ELOOP, STATUS_TOO_MANY_LINKS}, {CEPHFS_EISDIR, STATUS_FILE_IS_A_DIRECTORY}, {CEPHFS_ENOENT, STATUS_OBJECT_NAME_NOT_FOUND}, {CEPHFS_ENOTDIR, STATUS_NOT_A_DIRECTORY}, {CEPHFS_ENAMETOOLONG, STATUS_NAME_TOO_LONG}, {CEPHFS_EBUSY, STATUS_DEVICE_BUSY}, {CEPHFS_EDQUOT, STATUS_QUOTA_EXCEEDED}, {CEPHFS_EFBIG, STATUS_FILE_TOO_LARGE}, {CEPHFS_ERANGE, STATUS_INVALID_PARAMETER}, {CEPHFS_ENXIO, STATUS_NOT_FOUND}, {CEPHFS_ECANCELED, STATUS_REQUEST_CANCELED}, {CEPHFS_ENODATA, STATUS_NOT_FOUND}, {CEPHFS_EOPNOTSUPP, STATUS_NOT_SUPPORTED}, {CEPHFS_EXDEV, STATUS_NOT_SAME_DEVICE}, {CEPHFS_ENOMEM, STATUS_NO_MEMORY}, {CEPHFS_ENOTRECOVERABLE, STATUS_INTERNAL_ERROR}, {CEPHFS_ENOSYS, STATUS_NOT_IMPLEMENTED}, {CEPHFS_ENOTEMPTY, STATUS_DIRECTORY_NOT_EMPTY}, {CEPHFS_EDEADLK, STATUS_POSSIBLE_DEADLOCK}, {CEPHFS_EDOM, STATUS_INVALID_PARAMETER}, {CEPHFS_EMLINK, STATUS_TOO_MANY_LINKS}, {CEPHFS_ETIME, STATUS_TIMEOUT}, {CEPHFS_EOLDSNAPC, STATUS_DATA_ERROR} }; __u32 cephfs_errno_to_ntsatus(int cephfs_errno) { cephfs_errno = abs(cephfs_errno); if (cephfs_errno == 0) return 0; auto it = cephfs_errno_to_ntstatus.find(cephfs_errno); if (it != cephfs_errno_to_ntstatus.end()) return it->second; return STATUS_INTERNAL_ERROR; }