]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
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_ntsatus(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 | } |