Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit f012edf688f867dc35a3501808afc6fa9fba640d

Authored by Steve French
Committed by Greg Kroah-Hartman
1 parent 7365af4980
Exists in ti-linux-3.14.y and in 2 other branches processor-sdk-linux-01.00.00, smarc-ti-linux-3.14.y

Fix problem recognizing symlinks 

commit 19e81573fca7b87ced7701e01ba164b968d929bd upstream.

Changeset eb85d94bd introduced a problem where if a cifs open
fails during query info of a file we
will still try to close the file (happens with certain types
of reparse points) even though the file handle is not valid.

In addition for SMB2/SMB3 we were not mapping the return code returned
by Windows when trying to open a file (like a Windows NFS symlink)
which is a reparse point.

Signed-off-by: Steve French <smfrench@gmail.com>
Reviewed-by: Pavel Shilovsky <pshilovsky@samba.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 2 changed files with 3 additions and 1 deletions Inline Diff

1 /* 1 /*
2 * SMB1 (CIFS) version specific operations 2 * SMB1 (CIFS) version specific operations
3 * 3 *
4 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com> 4 * Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
5 * 5 *
6 * This library is free software; you can redistribute it and/or modify 6 * This library is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License v2 as published 7 * it under the terms of the GNU General Public License v2 as published
8 * by the Free Software Foundation. 8 * by the Free Software Foundation.
9 * 9 *
10 * This library is distributed in the hope that it will be useful, 10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13 * the GNU Lesser General Public License for more details. 13 * the GNU Lesser General Public License for more details.
14 * 14 *
15 * You should have received a copy of the GNU Lesser General Public License 15 * You should have received a copy of the GNU Lesser General Public License
16 * along with this library; if not, write to the Free Software 16 * along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */ 18 */
19 19
20 #include <linux/pagemap.h> 20 #include <linux/pagemap.h>
21 #include <linux/vfs.h> 21 #include <linux/vfs.h>
22 #include "cifsglob.h" 22 #include "cifsglob.h"
23 #include "cifsproto.h" 23 #include "cifsproto.h"
24 #include "cifs_debug.h" 24 #include "cifs_debug.h"
25 #include "cifspdu.h" 25 #include "cifspdu.h"
26 26
27 /* 27 /*
28 * An NT cancel request header looks just like the original request except: 28 * An NT cancel request header looks just like the original request except:
29 * 29 *
30 * The Command is SMB_COM_NT_CANCEL 30 * The Command is SMB_COM_NT_CANCEL
31 * The WordCount is zeroed out 31 * The WordCount is zeroed out
32 * The ByteCount is zeroed out 32 * The ByteCount is zeroed out
33 * 33 *
34 * This function mangles an existing request buffer into a 34 * This function mangles an existing request buffer into a
35 * SMB_COM_NT_CANCEL request and then sends it. 35 * SMB_COM_NT_CANCEL request and then sends it.
36 */ 36 */
37 static int 37 static int
38 send_nt_cancel(struct TCP_Server_Info *server, void *buf, 38 send_nt_cancel(struct TCP_Server_Info *server, void *buf,
39 struct mid_q_entry *mid) 39 struct mid_q_entry *mid)
40 { 40 {
41 int rc = 0; 41 int rc = 0;
42 struct smb_hdr *in_buf = (struct smb_hdr *)buf; 42 struct smb_hdr *in_buf = (struct smb_hdr *)buf;
43 43
44 /* -4 for RFC1001 length and +2 for BCC field */ 44 /* -4 for RFC1001 length and +2 for BCC field */
45 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2); 45 in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
46 in_buf->Command = SMB_COM_NT_CANCEL; 46 in_buf->Command = SMB_COM_NT_CANCEL;
47 in_buf->WordCount = 0; 47 in_buf->WordCount = 0;
48 put_bcc(0, in_buf); 48 put_bcc(0, in_buf);
49 49
50 mutex_lock(&server->srv_mutex); 50 mutex_lock(&server->srv_mutex);
51 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number); 51 rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
52 if (rc) { 52 if (rc) {
53 mutex_unlock(&server->srv_mutex); 53 mutex_unlock(&server->srv_mutex);
54 return rc; 54 return rc;
55 } 55 }
56 56
57 /* 57 /*
58 * The response to this call was already factored into the sequence 58 * The response to this call was already factored into the sequence
59 * number when the call went out, so we must adjust it back downward 59 * number when the call went out, so we must adjust it back downward
60 * after signing here. 60 * after signing here.
61 */ 61 */
62 --server->sequence_number; 62 --server->sequence_number;
63 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length)); 63 rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
64 if (rc < 0) 64 if (rc < 0)
65 server->sequence_number--; 65 server->sequence_number--;
66 66
67 mutex_unlock(&server->srv_mutex); 67 mutex_unlock(&server->srv_mutex);
68 68
69 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n", 69 cifs_dbg(FYI, "issued NT_CANCEL for mid %u, rc = %d\n",
70 get_mid(in_buf), rc); 70 get_mid(in_buf), rc);
71 71
72 return rc; 72 return rc;
73 } 73 }
74 74
75 static bool 75 static bool
76 cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2) 76 cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
77 { 77 {
78 return ob1->fid.netfid == ob2->fid.netfid; 78 return ob1->fid.netfid == ob2->fid.netfid;
79 } 79 }
80 80
81 static unsigned int 81 static unsigned int
82 cifs_read_data_offset(char *buf) 82 cifs_read_data_offset(char *buf)
83 { 83 {
84 READ_RSP *rsp = (READ_RSP *)buf; 84 READ_RSP *rsp = (READ_RSP *)buf;
85 return le16_to_cpu(rsp->DataOffset); 85 return le16_to_cpu(rsp->DataOffset);
86 } 86 }
87 87
88 static unsigned int 88 static unsigned int
89 cifs_read_data_length(char *buf) 89 cifs_read_data_length(char *buf)
90 { 90 {
91 READ_RSP *rsp = (READ_RSP *)buf; 91 READ_RSP *rsp = (READ_RSP *)buf;
92 return (le16_to_cpu(rsp->DataLengthHigh) << 16) + 92 return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
93 le16_to_cpu(rsp->DataLength); 93 le16_to_cpu(rsp->DataLength);
94 } 94 }
95 95
96 static struct mid_q_entry * 96 static struct mid_q_entry *
97 cifs_find_mid(struct TCP_Server_Info *server, char *buffer) 97 cifs_find_mid(struct TCP_Server_Info *server, char *buffer)
98 { 98 {
99 struct smb_hdr *buf = (struct smb_hdr *)buffer; 99 struct smb_hdr *buf = (struct smb_hdr *)buffer;
100 struct mid_q_entry *mid; 100 struct mid_q_entry *mid;
101 101
102 spin_lock(&GlobalMid_Lock); 102 spin_lock(&GlobalMid_Lock);
103 list_for_each_entry(mid, &server->pending_mid_q, qhead) { 103 list_for_each_entry(mid, &server->pending_mid_q, qhead) {
104 if (compare_mid(mid->mid, buf) && 104 if (compare_mid(mid->mid, buf) &&
105 mid->mid_state == MID_REQUEST_SUBMITTED && 105 mid->mid_state == MID_REQUEST_SUBMITTED &&
106 le16_to_cpu(mid->command) == buf->Command) { 106 le16_to_cpu(mid->command) == buf->Command) {
107 spin_unlock(&GlobalMid_Lock); 107 spin_unlock(&GlobalMid_Lock);
108 return mid; 108 return mid;
109 } 109 }
110 } 110 }
111 spin_unlock(&GlobalMid_Lock); 111 spin_unlock(&GlobalMid_Lock);
112 return NULL; 112 return NULL;
113 } 113 }
114 114
115 static void 115 static void
116 cifs_add_credits(struct TCP_Server_Info *server, const unsigned int add, 116 cifs_add_credits(struct TCP_Server_Info *server, const unsigned int add,
117 const int optype) 117 const int optype)
118 { 118 {
119 spin_lock(&server->req_lock); 119 spin_lock(&server->req_lock);
120 server->credits += add; 120 server->credits += add;
121 server->in_flight--; 121 server->in_flight--;
122 spin_unlock(&server->req_lock); 122 spin_unlock(&server->req_lock);
123 wake_up(&server->request_q); 123 wake_up(&server->request_q);
124 } 124 }
125 125
126 static void 126 static void
127 cifs_set_credits(struct TCP_Server_Info *server, const int val) 127 cifs_set_credits(struct TCP_Server_Info *server, const int val)
128 { 128 {
129 spin_lock(&server->req_lock); 129 spin_lock(&server->req_lock);
130 server->credits = val; 130 server->credits = val;
131 server->oplocks = val > 1 ? enable_oplocks : false; 131 server->oplocks = val > 1 ? enable_oplocks : false;
132 spin_unlock(&server->req_lock); 132 spin_unlock(&server->req_lock);
133 } 133 }
134 134
135 static int * 135 static int *
136 cifs_get_credits_field(struct TCP_Server_Info *server, const int optype) 136 cifs_get_credits_field(struct TCP_Server_Info *server, const int optype)
137 { 137 {
138 return &server->credits; 138 return &server->credits;
139 } 139 }
140 140
141 static unsigned int 141 static unsigned int
142 cifs_get_credits(struct mid_q_entry *mid) 142 cifs_get_credits(struct mid_q_entry *mid)
143 { 143 {
144 return 1; 144 return 1;
145 } 145 }
146 146
147 /* 147 /*
148 * Find a free multiplex id (SMB mid). Otherwise there could be 148 * Find a free multiplex id (SMB mid). Otherwise there could be
149 * mid collisions which might cause problems, demultiplexing the 149 * mid collisions which might cause problems, demultiplexing the
150 * wrong response to this request. Multiplex ids could collide if 150 * wrong response to this request. Multiplex ids could collide if
151 * one of a series requests takes much longer than the others, or 151 * one of a series requests takes much longer than the others, or
152 * if a very large number of long lived requests (byte range 152 * if a very large number of long lived requests (byte range
153 * locks or FindNotify requests) are pending. No more than 153 * locks or FindNotify requests) are pending. No more than
154 * 64K-1 requests can be outstanding at one time. If no 154 * 64K-1 requests can be outstanding at one time. If no
155 * mids are available, return zero. A future optimization 155 * mids are available, return zero. A future optimization
156 * could make the combination of mids and uid the key we use 156 * could make the combination of mids and uid the key we use
157 * to demultiplex on (rather than mid alone). 157 * to demultiplex on (rather than mid alone).
158 * In addition to the above check, the cifs demultiplex 158 * In addition to the above check, the cifs demultiplex
159 * code already used the command code as a secondary 159 * code already used the command code as a secondary
160 * check of the frame and if signing is negotiated the 160 * check of the frame and if signing is negotiated the
161 * response would be discarded if the mid were the same 161 * response would be discarded if the mid were the same
162 * but the signature was wrong. Since the mid is not put in the 162 * but the signature was wrong. Since the mid is not put in the
163 * pending queue until later (when it is about to be dispatched) 163 * pending queue until later (when it is about to be dispatched)
164 * we do have to limit the number of outstanding requests 164 * we do have to limit the number of outstanding requests
165 * to somewhat less than 64K-1 although it is hard to imagine 165 * to somewhat less than 64K-1 although it is hard to imagine
166 * so many threads being in the vfs at one time. 166 * so many threads being in the vfs at one time.
167 */ 167 */
168 static __u64 168 static __u64
169 cifs_get_next_mid(struct TCP_Server_Info *server) 169 cifs_get_next_mid(struct TCP_Server_Info *server)
170 { 170 {
171 __u64 mid = 0; 171 __u64 mid = 0;
172 __u16 last_mid, cur_mid; 172 __u16 last_mid, cur_mid;
173 bool collision; 173 bool collision;
174 174
175 spin_lock(&GlobalMid_Lock); 175 spin_lock(&GlobalMid_Lock);
176 176
177 /* mid is 16 bit only for CIFS/SMB */ 177 /* mid is 16 bit only for CIFS/SMB */
178 cur_mid = (__u16)((server->CurrentMid) & 0xffff); 178 cur_mid = (__u16)((server->CurrentMid) & 0xffff);
179 /* we do not want to loop forever */ 179 /* we do not want to loop forever */
180 last_mid = cur_mid; 180 last_mid = cur_mid;
181 cur_mid++; 181 cur_mid++;
182 182
183 /* 183 /*
184 * This nested loop looks more expensive than it is. 184 * This nested loop looks more expensive than it is.
185 * In practice the list of pending requests is short, 185 * In practice the list of pending requests is short,
186 * fewer than 50, and the mids are likely to be unique 186 * fewer than 50, and the mids are likely to be unique
187 * on the first pass through the loop unless some request 187 * on the first pass through the loop unless some request
188 * takes longer than the 64 thousand requests before it 188 * takes longer than the 64 thousand requests before it
189 * (and it would also have to have been a request that 189 * (and it would also have to have been a request that
190 * did not time out). 190 * did not time out).
191 */ 191 */
192 while (cur_mid != last_mid) { 192 while (cur_mid != last_mid) {
193 struct mid_q_entry *mid_entry; 193 struct mid_q_entry *mid_entry;
194 unsigned int num_mids; 194 unsigned int num_mids;
195 195
196 collision = false; 196 collision = false;
197 if (cur_mid == 0) 197 if (cur_mid == 0)
198 cur_mid++; 198 cur_mid++;
199 199
200 num_mids = 0; 200 num_mids = 0;
201 list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) { 201 list_for_each_entry(mid_entry, &server->pending_mid_q, qhead) {
202 ++num_mids; 202 ++num_mids;
203 if (mid_entry->mid == cur_mid && 203 if (mid_entry->mid == cur_mid &&
204 mid_entry->mid_state == MID_REQUEST_SUBMITTED) { 204 mid_entry->mid_state == MID_REQUEST_SUBMITTED) {
205 /* This mid is in use, try a different one */ 205 /* This mid is in use, try a different one */
206 collision = true; 206 collision = true;
207 break; 207 break;
208 } 208 }
209 } 209 }
210 210
211 /* 211 /*
212 * if we have more than 32k mids in the list, then something 212 * if we have more than 32k mids in the list, then something
213 * is very wrong. Possibly a local user is trying to DoS the 213 * is very wrong. Possibly a local user is trying to DoS the
214 * box by issuing long-running calls and SIGKILL'ing them. If 214 * box by issuing long-running calls and SIGKILL'ing them. If
215 * we get to 2^16 mids then we're in big trouble as this 215 * we get to 2^16 mids then we're in big trouble as this
216 * function could loop forever. 216 * function could loop forever.
217 * 217 *
218 * Go ahead and assign out the mid in this situation, but force 218 * Go ahead and assign out the mid in this situation, but force
219 * an eventual reconnect to clean out the pending_mid_q. 219 * an eventual reconnect to clean out the pending_mid_q.
220 */ 220 */
221 if (num_mids > 32768) 221 if (num_mids > 32768)
222 server->tcpStatus = CifsNeedReconnect; 222 server->tcpStatus = CifsNeedReconnect;
223 223
224 if (!collision) { 224 if (!collision) {
225 mid = (__u64)cur_mid; 225 mid = (__u64)cur_mid;
226 server->CurrentMid = mid; 226 server->CurrentMid = mid;
227 break; 227 break;
228 } 228 }
229 cur_mid++; 229 cur_mid++;
230 } 230 }
231 spin_unlock(&GlobalMid_Lock); 231 spin_unlock(&GlobalMid_Lock);
232 return mid; 232 return mid;
233 } 233 }
234 234
235 /* 235 /*
236 return codes: 236 return codes:
237 0 not a transact2, or all data present 237 0 not a transact2, or all data present
238 >0 transact2 with that much data missing 238 >0 transact2 with that much data missing
239 -EINVAL invalid transact2 239 -EINVAL invalid transact2
240 */ 240 */
241 static int 241 static int
242 check2ndT2(char *buf) 242 check2ndT2(char *buf)
243 { 243 {
244 struct smb_hdr *pSMB = (struct smb_hdr *)buf; 244 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
245 struct smb_t2_rsp *pSMBt; 245 struct smb_t2_rsp *pSMBt;
246 int remaining; 246 int remaining;
247 __u16 total_data_size, data_in_this_rsp; 247 __u16 total_data_size, data_in_this_rsp;
248 248
249 if (pSMB->Command != SMB_COM_TRANSACTION2) 249 if (pSMB->Command != SMB_COM_TRANSACTION2)
250 return 0; 250 return 0;
251 251
252 /* check for plausible wct, bcc and t2 data and parm sizes */ 252 /* check for plausible wct, bcc and t2 data and parm sizes */
253 /* check for parm and data offset going beyond end of smb */ 253 /* check for parm and data offset going beyond end of smb */
254 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */ 254 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
255 cifs_dbg(FYI, "invalid transact2 word count\n"); 255 cifs_dbg(FYI, "invalid transact2 word count\n");
256 return -EINVAL; 256 return -EINVAL;
257 } 257 }
258 258
259 pSMBt = (struct smb_t2_rsp *)pSMB; 259 pSMBt = (struct smb_t2_rsp *)pSMB;
260 260
261 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount); 261 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
262 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount); 262 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
263 263
264 if (total_data_size == data_in_this_rsp) 264 if (total_data_size == data_in_this_rsp)
265 return 0; 265 return 0;
266 else if (total_data_size < data_in_this_rsp) { 266 else if (total_data_size < data_in_this_rsp) {
267 cifs_dbg(FYI, "total data %d smaller than data in frame %d\n", 267 cifs_dbg(FYI, "total data %d smaller than data in frame %d\n",
268 total_data_size, data_in_this_rsp); 268 total_data_size, data_in_this_rsp);
269 return -EINVAL; 269 return -EINVAL;
270 } 270 }
271 271
272 remaining = total_data_size - data_in_this_rsp; 272 remaining = total_data_size - data_in_this_rsp;
273 273
274 cifs_dbg(FYI, "missing %d bytes from transact2, check next response\n", 274 cifs_dbg(FYI, "missing %d bytes from transact2, check next response\n",
275 remaining); 275 remaining);
276 if (total_data_size > CIFSMaxBufSize) { 276 if (total_data_size > CIFSMaxBufSize) {
277 cifs_dbg(VFS, "TotalDataSize %d is over maximum buffer %d\n", 277 cifs_dbg(VFS, "TotalDataSize %d is over maximum buffer %d\n",
278 total_data_size, CIFSMaxBufSize); 278 total_data_size, CIFSMaxBufSize);
279 return -EINVAL; 279 return -EINVAL;
280 } 280 }
281 return remaining; 281 return remaining;
282 } 282 }
283 283
284 static int 284 static int
285 coalesce_t2(char *second_buf, struct smb_hdr *target_hdr) 285 coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
286 { 286 {
287 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf; 287 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
288 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr; 288 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
289 char *data_area_of_tgt; 289 char *data_area_of_tgt;
290 char *data_area_of_src; 290 char *data_area_of_src;
291 int remaining; 291 int remaining;
292 unsigned int byte_count, total_in_tgt; 292 unsigned int byte_count, total_in_tgt;
293 __u16 tgt_total_cnt, src_total_cnt, total_in_src; 293 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
294 294
295 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount); 295 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
296 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount); 296 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
297 297
298 if (tgt_total_cnt != src_total_cnt) 298 if (tgt_total_cnt != src_total_cnt)
299 cifs_dbg(FYI, "total data count of primary and secondary t2 differ source=%hu target=%hu\n", 299 cifs_dbg(FYI, "total data count of primary and secondary t2 differ source=%hu target=%hu\n",
300 src_total_cnt, tgt_total_cnt); 300 src_total_cnt, tgt_total_cnt);
301 301
302 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount); 302 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
303 303
304 remaining = tgt_total_cnt - total_in_tgt; 304 remaining = tgt_total_cnt - total_in_tgt;
305 305
306 if (remaining < 0) { 306 if (remaining < 0) {
307 cifs_dbg(FYI, "Server sent too much data. tgt_total_cnt=%hu total_in_tgt=%hu\n", 307 cifs_dbg(FYI, "Server sent too much data. tgt_total_cnt=%hu total_in_tgt=%hu\n",
308 tgt_total_cnt, total_in_tgt); 308 tgt_total_cnt, total_in_tgt);
309 return -EPROTO; 309 return -EPROTO;
310 } 310 }
311 311
312 if (remaining == 0) { 312 if (remaining == 0) {
313 /* nothing to do, ignore */ 313 /* nothing to do, ignore */
314 cifs_dbg(FYI, "no more data remains\n"); 314 cifs_dbg(FYI, "no more data remains\n");
315 return 0; 315 return 0;
316 } 316 }
317 317
318 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount); 318 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
319 if (remaining < total_in_src) 319 if (remaining < total_in_src)
320 cifs_dbg(FYI, "transact2 2nd response contains too much data\n"); 320 cifs_dbg(FYI, "transact2 2nd response contains too much data\n");
321 321
322 /* find end of first SMB data area */ 322 /* find end of first SMB data area */
323 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol + 323 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
324 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset); 324 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
325 325
326 /* validate target area */ 326 /* validate target area */
327 data_area_of_src = (char *)&pSMBs->hdr.Protocol + 327 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
328 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset); 328 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
329 329
330 data_area_of_tgt += total_in_tgt; 330 data_area_of_tgt += total_in_tgt;
331 331
332 total_in_tgt += total_in_src; 332 total_in_tgt += total_in_src;
333 /* is the result too big for the field? */ 333 /* is the result too big for the field? */
334 if (total_in_tgt > USHRT_MAX) { 334 if (total_in_tgt > USHRT_MAX) {
335 cifs_dbg(FYI, "coalesced DataCount too large (%u)\n", 335 cifs_dbg(FYI, "coalesced DataCount too large (%u)\n",
336 total_in_tgt); 336 total_in_tgt);
337 return -EPROTO; 337 return -EPROTO;
338 } 338 }
339 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount); 339 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
340 340
341 /* fix up the BCC */ 341 /* fix up the BCC */
342 byte_count = get_bcc(target_hdr); 342 byte_count = get_bcc(target_hdr);
343 byte_count += total_in_src; 343 byte_count += total_in_src;
344 /* is the result too big for the field? */ 344 /* is the result too big for the field? */
345 if (byte_count > USHRT_MAX) { 345 if (byte_count > USHRT_MAX) {
346 cifs_dbg(FYI, "coalesced BCC too large (%u)\n", byte_count); 346 cifs_dbg(FYI, "coalesced BCC too large (%u)\n", byte_count);
347 return -EPROTO; 347 return -EPROTO;
348 } 348 }
349 put_bcc(byte_count, target_hdr); 349 put_bcc(byte_count, target_hdr);
350 350
351 byte_count = be32_to_cpu(target_hdr->smb_buf_length); 351 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
352 byte_count += total_in_src; 352 byte_count += total_in_src;
353 /* don't allow buffer to overflow */ 353 /* don't allow buffer to overflow */
354 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) { 354 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
355 cifs_dbg(FYI, "coalesced BCC exceeds buffer size (%u)\n", 355 cifs_dbg(FYI, "coalesced BCC exceeds buffer size (%u)\n",
356 byte_count); 356 byte_count);
357 return -ENOBUFS; 357 return -ENOBUFS;
358 } 358 }
359 target_hdr->smb_buf_length = cpu_to_be32(byte_count); 359 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
360 360
361 /* copy second buffer into end of first buffer */ 361 /* copy second buffer into end of first buffer */
362 memcpy(data_area_of_tgt, data_area_of_src, total_in_src); 362 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
363 363
364 if (remaining != total_in_src) { 364 if (remaining != total_in_src) {
365 /* more responses to go */ 365 /* more responses to go */
366 cifs_dbg(FYI, "waiting for more secondary responses\n"); 366 cifs_dbg(FYI, "waiting for more secondary responses\n");
367 return 1; 367 return 1;
368 } 368 }
369 369
370 /* we are done */ 370 /* we are done */
371 cifs_dbg(FYI, "found the last secondary response\n"); 371 cifs_dbg(FYI, "found the last secondary response\n");
372 return 0; 372 return 0;
373 } 373 }
374 374
375 static void 375 static void
376 cifs_downgrade_oplock(struct TCP_Server_Info *server, 376 cifs_downgrade_oplock(struct TCP_Server_Info *server,
377 struct cifsInodeInfo *cinode, bool set_level2) 377 struct cifsInodeInfo *cinode, bool set_level2)
378 { 378 {
379 if (set_level2) 379 if (set_level2)
380 cifs_set_oplock_level(cinode, OPLOCK_READ); 380 cifs_set_oplock_level(cinode, OPLOCK_READ);
381 else 381 else
382 cifs_set_oplock_level(cinode, 0); 382 cifs_set_oplock_level(cinode, 0);
383 } 383 }
384 384
385 static bool 385 static bool
386 cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server, 386 cifs_check_trans2(struct mid_q_entry *mid, struct TCP_Server_Info *server,
387 char *buf, int malformed) 387 char *buf, int malformed)
388 { 388 {
389 if (malformed) 389 if (malformed)
390 return false; 390 return false;
391 if (check2ndT2(buf) <= 0) 391 if (check2ndT2(buf) <= 0)
392 return false; 392 return false;
393 mid->multiRsp = true; 393 mid->multiRsp = true;
394 if (mid->resp_buf) { 394 if (mid->resp_buf) {
395 /* merge response - fix up 1st*/ 395 /* merge response - fix up 1st*/
396 malformed = coalesce_t2(buf, mid->resp_buf); 396 malformed = coalesce_t2(buf, mid->resp_buf);
397 if (malformed > 0) 397 if (malformed > 0)
398 return true; 398 return true;
399 /* All parts received or packet is malformed. */ 399 /* All parts received or packet is malformed. */
400 mid->multiEnd = true; 400 mid->multiEnd = true;
401 dequeue_mid(mid, malformed); 401 dequeue_mid(mid, malformed);
402 return true; 402 return true;
403 } 403 }
404 if (!server->large_buf) { 404 if (!server->large_buf) {
405 /*FIXME: switch to already allocated largebuf?*/ 405 /*FIXME: switch to already allocated largebuf?*/
406 cifs_dbg(VFS, "1st trans2 resp needs bigbuf\n"); 406 cifs_dbg(VFS, "1st trans2 resp needs bigbuf\n");
407 } else { 407 } else {
408 /* Have first buffer */ 408 /* Have first buffer */
409 mid->resp_buf = buf; 409 mid->resp_buf = buf;
410 mid->large_buf = true; 410 mid->large_buf = true;
411 server->bigbuf = NULL; 411 server->bigbuf = NULL;
412 } 412 }
413 return true; 413 return true;
414 } 414 }
415 415
416 static bool 416 static bool
417 cifs_need_neg(struct TCP_Server_Info *server) 417 cifs_need_neg(struct TCP_Server_Info *server)
418 { 418 {
419 return server->maxBuf == 0; 419 return server->maxBuf == 0;
420 } 420 }
421 421
422 static int 422 static int
423 cifs_negotiate(const unsigned int xid, struct cifs_ses *ses) 423 cifs_negotiate(const unsigned int xid, struct cifs_ses *ses)
424 { 424 {
425 int rc; 425 int rc;
426 rc = CIFSSMBNegotiate(xid, ses); 426 rc = CIFSSMBNegotiate(xid, ses);
427 if (rc == -EAGAIN) { 427 if (rc == -EAGAIN) {
428 /* retry only once on 1st time connection */ 428 /* retry only once on 1st time connection */
429 set_credits(ses->server, 1); 429 set_credits(ses->server, 1);
430 rc = CIFSSMBNegotiate(xid, ses); 430 rc = CIFSSMBNegotiate(xid, ses);
431 if (rc == -EAGAIN) 431 if (rc == -EAGAIN)
432 rc = -EHOSTDOWN; 432 rc = -EHOSTDOWN;
433 } 433 }
434 return rc; 434 return rc;
435 } 435 }
436 436
437 static unsigned int 437 static unsigned int
438 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) 438 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
439 { 439 {
440 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability); 440 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
441 struct TCP_Server_Info *server = tcon->ses->server; 441 struct TCP_Server_Info *server = tcon->ses->server;
442 unsigned int wsize; 442 unsigned int wsize;
443 443
444 /* start with specified wsize, or default */ 444 /* start with specified wsize, or default */
445 if (volume_info->wsize) 445 if (volume_info->wsize)
446 wsize = volume_info->wsize; 446 wsize = volume_info->wsize;
447 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP)) 447 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
448 wsize = CIFS_DEFAULT_IOSIZE; 448 wsize = CIFS_DEFAULT_IOSIZE;
449 else 449 else
450 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE; 450 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
451 451
452 /* can server support 24-bit write sizes? (via UNIX extensions) */ 452 /* can server support 24-bit write sizes? (via UNIX extensions) */
453 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP)) 453 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
454 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE); 454 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
455 455
456 /* 456 /*
457 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set? 457 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
458 * Limit it to max buffer offered by the server, minus the size of the 458 * Limit it to max buffer offered by the server, minus the size of the
459 * WRITEX header, not including the 4 byte RFC1001 length. 459 * WRITEX header, not including the 4 byte RFC1001 length.
460 */ 460 */
461 if (!(server->capabilities & CAP_LARGE_WRITE_X) || 461 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
462 (!(server->capabilities & CAP_UNIX) && server->sign)) 462 (!(server->capabilities & CAP_UNIX) && server->sign))
463 wsize = min_t(unsigned int, wsize, 463 wsize = min_t(unsigned int, wsize,
464 server->maxBuf - sizeof(WRITE_REQ) + 4); 464 server->maxBuf - sizeof(WRITE_REQ) + 4);
465 465
466 /* hard limit of CIFS_MAX_WSIZE */ 466 /* hard limit of CIFS_MAX_WSIZE */
467 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE); 467 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
468 468
469 return wsize; 469 return wsize;
470 } 470 }
471 471
472 static unsigned int 472 static unsigned int
473 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info) 473 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
474 { 474 {
475 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability); 475 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
476 struct TCP_Server_Info *server = tcon->ses->server; 476 struct TCP_Server_Info *server = tcon->ses->server;
477 unsigned int rsize, defsize; 477 unsigned int rsize, defsize;
478 478
479 /* 479 /*
480 * Set default value... 480 * Set default value...
481 * 481 *
482 * HACK alert! Ancient servers have very small buffers. Even though 482 * HACK alert! Ancient servers have very small buffers. Even though
483 * MS-CIFS indicates that servers are only limited by the client's 483 * MS-CIFS indicates that servers are only limited by the client's
484 * bufsize for reads, testing against win98se shows that it throws 484 * bufsize for reads, testing against win98se shows that it throws
485 * INVALID_PARAMETER errors if you try to request too large a read. 485 * INVALID_PARAMETER errors if you try to request too large a read.
486 * OS/2 just sends back short reads. 486 * OS/2 just sends back short reads.
487 * 487 *
488 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that 488 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
489 * it can't handle a read request larger than its MaxBufferSize either. 489 * it can't handle a read request larger than its MaxBufferSize either.
490 */ 490 */
491 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP)) 491 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
492 defsize = CIFS_DEFAULT_IOSIZE; 492 defsize = CIFS_DEFAULT_IOSIZE;
493 else if (server->capabilities & CAP_LARGE_READ_X) 493 else if (server->capabilities & CAP_LARGE_READ_X)
494 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE; 494 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
495 else 495 else
496 defsize = server->maxBuf - sizeof(READ_RSP); 496 defsize = server->maxBuf - sizeof(READ_RSP);
497 497
498 rsize = volume_info->rsize ? volume_info->rsize : defsize; 498 rsize = volume_info->rsize ? volume_info->rsize : defsize;
499 499
500 /* 500 /*
501 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to 501 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
502 * the client's MaxBufferSize. 502 * the client's MaxBufferSize.
503 */ 503 */
504 if (!(server->capabilities & CAP_LARGE_READ_X)) 504 if (!(server->capabilities & CAP_LARGE_READ_X))
505 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize); 505 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
506 506
507 /* hard limit of CIFS_MAX_RSIZE */ 507 /* hard limit of CIFS_MAX_RSIZE */
508 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE); 508 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
509 509
510 return rsize; 510 return rsize;
511 } 511 }
512 512
513 static void 513 static void
514 cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon) 514 cifs_qfs_tcon(const unsigned int xid, struct cifs_tcon *tcon)
515 { 515 {
516 CIFSSMBQFSDeviceInfo(xid, tcon); 516 CIFSSMBQFSDeviceInfo(xid, tcon);
517 CIFSSMBQFSAttributeInfo(xid, tcon); 517 CIFSSMBQFSAttributeInfo(xid, tcon);
518 } 518 }
519 519
520 static int 520 static int
521 cifs_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon, 521 cifs_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
522 struct cifs_sb_info *cifs_sb, const char *full_path) 522 struct cifs_sb_info *cifs_sb, const char *full_path)
523 { 523 {
524 int rc; 524 int rc;
525 FILE_ALL_INFO *file_info; 525 FILE_ALL_INFO *file_info;
526 526
527 file_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL); 527 file_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
528 if (file_info == NULL) 528 if (file_info == NULL)
529 return -ENOMEM; 529 return -ENOMEM;
530 530
531 rc = CIFSSMBQPathInfo(xid, tcon, full_path, file_info, 531 rc = CIFSSMBQPathInfo(xid, tcon, full_path, file_info,
532 0 /* not legacy */, cifs_sb->local_nls, 532 0 /* not legacy */, cifs_sb->local_nls,
533 cifs_sb->mnt_cifs_flags & 533 cifs_sb->mnt_cifs_flags &
534 CIFS_MOUNT_MAP_SPECIAL_CHR); 534 CIFS_MOUNT_MAP_SPECIAL_CHR);
535 535
536 if (rc == -EOPNOTSUPP || rc == -EINVAL) 536 if (rc == -EOPNOTSUPP || rc == -EINVAL)
537 rc = SMBQueryInformation(xid, tcon, full_path, file_info, 537 rc = SMBQueryInformation(xid, tcon, full_path, file_info,
538 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags & 538 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
539 CIFS_MOUNT_MAP_SPECIAL_CHR); 539 CIFS_MOUNT_MAP_SPECIAL_CHR);
540 kfree(file_info); 540 kfree(file_info);
541 return rc; 541 return rc;
542 } 542 }
543 543
544 static int 544 static int
545 cifs_query_path_info(const unsigned int xid, struct cifs_tcon *tcon, 545 cifs_query_path_info(const unsigned int xid, struct cifs_tcon *tcon,
546 struct cifs_sb_info *cifs_sb, const char *full_path, 546 struct cifs_sb_info *cifs_sb, const char *full_path,
547 FILE_ALL_INFO *data, bool *adjustTZ, bool *symlink) 547 FILE_ALL_INFO *data, bool *adjustTZ, bool *symlink)
548 { 548 {
549 int rc; 549 int rc;
550 550
551 *symlink = false; 551 *symlink = false;
552 552
553 /* could do find first instead but this returns more info */ 553 /* could do find first instead but this returns more info */
554 rc = CIFSSMBQPathInfo(xid, tcon, full_path, data, 0 /* not legacy */, 554 rc = CIFSSMBQPathInfo(xid, tcon, full_path, data, 0 /* not legacy */,
555 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags & 555 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
556 CIFS_MOUNT_MAP_SPECIAL_CHR); 556 CIFS_MOUNT_MAP_SPECIAL_CHR);
557 /* 557 /*
558 * BB optimize code so we do not make the above call when server claims 558 * BB optimize code so we do not make the above call when server claims
559 * no NT SMB support and the above call failed at least once - set flag 559 * no NT SMB support and the above call failed at least once - set flag
560 * in tcon or mount. 560 * in tcon or mount.
561 */ 561 */
562 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) { 562 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
563 rc = SMBQueryInformation(xid, tcon, full_path, data, 563 rc = SMBQueryInformation(xid, tcon, full_path, data,
564 cifs_sb->local_nls, 564 cifs_sb->local_nls,
565 cifs_sb->mnt_cifs_flags & 565 cifs_sb->mnt_cifs_flags &
566 CIFS_MOUNT_MAP_SPECIAL_CHR); 566 CIFS_MOUNT_MAP_SPECIAL_CHR);
567 *adjustTZ = true; 567 *adjustTZ = true;
568 } 568 }
569 569
570 if (!rc && (le32_to_cpu(data->Attributes) & ATTR_REPARSE)) { 570 if (!rc && (le32_to_cpu(data->Attributes) & ATTR_REPARSE)) {
571 int tmprc; 571 int tmprc;
572 int oplock = 0; 572 int oplock = 0;
573 struct cifs_fid fid; 573 struct cifs_fid fid;
574 struct cifs_open_parms oparms; 574 struct cifs_open_parms oparms;
575 575
576 oparms.tcon = tcon; 576 oparms.tcon = tcon;
577 oparms.cifs_sb = cifs_sb; 577 oparms.cifs_sb = cifs_sb;
578 oparms.desired_access = FILE_READ_ATTRIBUTES; 578 oparms.desired_access = FILE_READ_ATTRIBUTES;
579 oparms.create_options = 0; 579 oparms.create_options = 0;
580 oparms.disposition = FILE_OPEN; 580 oparms.disposition = FILE_OPEN;
581 oparms.path = full_path; 581 oparms.path = full_path;
582 oparms.fid = &fid; 582 oparms.fid = &fid;
583 oparms.reconnect = false; 583 oparms.reconnect = false;
584 584
585 /* Need to check if this is a symbolic link or not */ 585 /* Need to check if this is a symbolic link or not */
586 tmprc = CIFS_open(xid, &oparms, &oplock, NULL); 586 tmprc = CIFS_open(xid, &oparms, &oplock, NULL);
587 if (tmprc == -EOPNOTSUPP) 587 if (tmprc == -EOPNOTSUPP)
588 *symlink = true; 588 *symlink = true;
589 else 589 else if (tmprc == 0)
590 CIFSSMBClose(xid, tcon, fid.netfid); 590 CIFSSMBClose(xid, tcon, fid.netfid);
591 } 591 }
592 592
593 return rc; 593 return rc;
594 } 594 }
595 595
596 static int 596 static int
597 cifs_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon, 597 cifs_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
598 struct cifs_sb_info *cifs_sb, const char *full_path, 598 struct cifs_sb_info *cifs_sb, const char *full_path,
599 u64 *uniqueid, FILE_ALL_INFO *data) 599 u64 *uniqueid, FILE_ALL_INFO *data)
600 { 600 {
601 /* 601 /*
602 * We can not use the IndexNumber field by default from Windows or 602 * We can not use the IndexNumber field by default from Windows or
603 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA 603 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
604 * CIFS spec claims that this value is unique within the scope of a 604 * CIFS spec claims that this value is unique within the scope of a
605 * share, and the windows docs hint that it's actually unique 605 * share, and the windows docs hint that it's actually unique
606 * per-machine. 606 * per-machine.
607 * 607 *
608 * There may be higher info levels that work but are there Windows 608 * There may be higher info levels that work but are there Windows
609 * server or network appliances for which IndexNumber field is not 609 * server or network appliances for which IndexNumber field is not
610 * guaranteed unique? 610 * guaranteed unique?
611 */ 611 */
612 return CIFSGetSrvInodeNumber(xid, tcon, full_path, uniqueid, 612 return CIFSGetSrvInodeNumber(xid, tcon, full_path, uniqueid,
613 cifs_sb->local_nls, 613 cifs_sb->local_nls,
614 cifs_sb->mnt_cifs_flags & 614 cifs_sb->mnt_cifs_flags &
615 CIFS_MOUNT_MAP_SPECIAL_CHR); 615 CIFS_MOUNT_MAP_SPECIAL_CHR);
616 } 616 }
617 617
618 static int 618 static int
619 cifs_query_file_info(const unsigned int xid, struct cifs_tcon *tcon, 619 cifs_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
620 struct cifs_fid *fid, FILE_ALL_INFO *data) 620 struct cifs_fid *fid, FILE_ALL_INFO *data)
621 { 621 {
622 return CIFSSMBQFileInfo(xid, tcon, fid->netfid, data); 622 return CIFSSMBQFileInfo(xid, tcon, fid->netfid, data);
623 } 623 }
624 624
625 static void 625 static void
626 cifs_clear_stats(struct cifs_tcon *tcon) 626 cifs_clear_stats(struct cifs_tcon *tcon)
627 { 627 {
628 #ifdef CONFIG_CIFS_STATS 628 #ifdef CONFIG_CIFS_STATS
629 atomic_set(&tcon->stats.cifs_stats.num_writes, 0); 629 atomic_set(&tcon->stats.cifs_stats.num_writes, 0);
630 atomic_set(&tcon->stats.cifs_stats.num_reads, 0); 630 atomic_set(&tcon->stats.cifs_stats.num_reads, 0);
631 atomic_set(&tcon->stats.cifs_stats.num_flushes, 0); 631 atomic_set(&tcon->stats.cifs_stats.num_flushes, 0);
632 atomic_set(&tcon->stats.cifs_stats.num_oplock_brks, 0); 632 atomic_set(&tcon->stats.cifs_stats.num_oplock_brks, 0);
633 atomic_set(&tcon->stats.cifs_stats.num_opens, 0); 633 atomic_set(&tcon->stats.cifs_stats.num_opens, 0);
634 atomic_set(&tcon->stats.cifs_stats.num_posixopens, 0); 634 atomic_set(&tcon->stats.cifs_stats.num_posixopens, 0);
635 atomic_set(&tcon->stats.cifs_stats.num_posixmkdirs, 0); 635 atomic_set(&tcon->stats.cifs_stats.num_posixmkdirs, 0);
636 atomic_set(&tcon->stats.cifs_stats.num_closes, 0); 636 atomic_set(&tcon->stats.cifs_stats.num_closes, 0);
637 atomic_set(&tcon->stats.cifs_stats.num_deletes, 0); 637 atomic_set(&tcon->stats.cifs_stats.num_deletes, 0);
638 atomic_set(&tcon->stats.cifs_stats.num_mkdirs, 0); 638 atomic_set(&tcon->stats.cifs_stats.num_mkdirs, 0);
639 atomic_set(&tcon->stats.cifs_stats.num_rmdirs, 0); 639 atomic_set(&tcon->stats.cifs_stats.num_rmdirs, 0);
640 atomic_set(&tcon->stats.cifs_stats.num_renames, 0); 640 atomic_set(&tcon->stats.cifs_stats.num_renames, 0);
641 atomic_set(&tcon->stats.cifs_stats.num_t2renames, 0); 641 atomic_set(&tcon->stats.cifs_stats.num_t2renames, 0);
642 atomic_set(&tcon->stats.cifs_stats.num_ffirst, 0); 642 atomic_set(&tcon->stats.cifs_stats.num_ffirst, 0);
643 atomic_set(&tcon->stats.cifs_stats.num_fnext, 0); 643 atomic_set(&tcon->stats.cifs_stats.num_fnext, 0);
644 atomic_set(&tcon->stats.cifs_stats.num_fclose, 0); 644 atomic_set(&tcon->stats.cifs_stats.num_fclose, 0);
645 atomic_set(&tcon->stats.cifs_stats.num_hardlinks, 0); 645 atomic_set(&tcon->stats.cifs_stats.num_hardlinks, 0);
646 atomic_set(&tcon->stats.cifs_stats.num_symlinks, 0); 646 atomic_set(&tcon->stats.cifs_stats.num_symlinks, 0);
647 atomic_set(&tcon->stats.cifs_stats.num_locks, 0); 647 atomic_set(&tcon->stats.cifs_stats.num_locks, 0);
648 atomic_set(&tcon->stats.cifs_stats.num_acl_get, 0); 648 atomic_set(&tcon->stats.cifs_stats.num_acl_get, 0);
649 atomic_set(&tcon->stats.cifs_stats.num_acl_set, 0); 649 atomic_set(&tcon->stats.cifs_stats.num_acl_set, 0);
650 #endif 650 #endif
651 } 651 }
652 652
653 static void 653 static void
654 cifs_print_stats(struct seq_file *m, struct cifs_tcon *tcon) 654 cifs_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
655 { 655 {
656 #ifdef CONFIG_CIFS_STATS 656 #ifdef CONFIG_CIFS_STATS
657 seq_printf(m, " Oplocks breaks: %d", 657 seq_printf(m, " Oplocks breaks: %d",
658 atomic_read(&tcon->stats.cifs_stats.num_oplock_brks)); 658 atomic_read(&tcon->stats.cifs_stats.num_oplock_brks));
659 seq_printf(m, "\nReads: %d Bytes: %llu", 659 seq_printf(m, "\nReads: %d Bytes: %llu",
660 atomic_read(&tcon->stats.cifs_stats.num_reads), 660 atomic_read(&tcon->stats.cifs_stats.num_reads),
661 (long long)(tcon->bytes_read)); 661 (long long)(tcon->bytes_read));
662 seq_printf(m, "\nWrites: %d Bytes: %llu", 662 seq_printf(m, "\nWrites: %d Bytes: %llu",
663 atomic_read(&tcon->stats.cifs_stats.num_writes), 663 atomic_read(&tcon->stats.cifs_stats.num_writes),
664 (long long)(tcon->bytes_written)); 664 (long long)(tcon->bytes_written));
665 seq_printf(m, "\nFlushes: %d", 665 seq_printf(m, "\nFlushes: %d",
666 atomic_read(&tcon->stats.cifs_stats.num_flushes)); 666 atomic_read(&tcon->stats.cifs_stats.num_flushes));
667 seq_printf(m, "\nLocks: %d HardLinks: %d Symlinks: %d", 667 seq_printf(m, "\nLocks: %d HardLinks: %d Symlinks: %d",
668 atomic_read(&tcon->stats.cifs_stats.num_locks), 668 atomic_read(&tcon->stats.cifs_stats.num_locks),
669 atomic_read(&tcon->stats.cifs_stats.num_hardlinks), 669 atomic_read(&tcon->stats.cifs_stats.num_hardlinks),
670 atomic_read(&tcon->stats.cifs_stats.num_symlinks)); 670 atomic_read(&tcon->stats.cifs_stats.num_symlinks));
671 seq_printf(m, "\nOpens: %d Closes: %d Deletes: %d", 671 seq_printf(m, "\nOpens: %d Closes: %d Deletes: %d",
672 atomic_read(&tcon->stats.cifs_stats.num_opens), 672 atomic_read(&tcon->stats.cifs_stats.num_opens),
673 atomic_read(&tcon->stats.cifs_stats.num_closes), 673 atomic_read(&tcon->stats.cifs_stats.num_closes),
674 atomic_read(&tcon->stats.cifs_stats.num_deletes)); 674 atomic_read(&tcon->stats.cifs_stats.num_deletes));
675 seq_printf(m, "\nPosix Opens: %d Posix Mkdirs: %d", 675 seq_printf(m, "\nPosix Opens: %d Posix Mkdirs: %d",
676 atomic_read(&tcon->stats.cifs_stats.num_posixopens), 676 atomic_read(&tcon->stats.cifs_stats.num_posixopens),
677 atomic_read(&tcon->stats.cifs_stats.num_posixmkdirs)); 677 atomic_read(&tcon->stats.cifs_stats.num_posixmkdirs));
678 seq_printf(m, "\nMkdirs: %d Rmdirs: %d", 678 seq_printf(m, "\nMkdirs: %d Rmdirs: %d",
679 atomic_read(&tcon->stats.cifs_stats.num_mkdirs), 679 atomic_read(&tcon->stats.cifs_stats.num_mkdirs),
680 atomic_read(&tcon->stats.cifs_stats.num_rmdirs)); 680 atomic_read(&tcon->stats.cifs_stats.num_rmdirs));
681 seq_printf(m, "\nRenames: %d T2 Renames %d", 681 seq_printf(m, "\nRenames: %d T2 Renames %d",
682 atomic_read(&tcon->stats.cifs_stats.num_renames), 682 atomic_read(&tcon->stats.cifs_stats.num_renames),
683 atomic_read(&tcon->stats.cifs_stats.num_t2renames)); 683 atomic_read(&tcon->stats.cifs_stats.num_t2renames));
684 seq_printf(m, "\nFindFirst: %d FNext %d FClose %d", 684 seq_printf(m, "\nFindFirst: %d FNext %d FClose %d",
685 atomic_read(&tcon->stats.cifs_stats.num_ffirst), 685 atomic_read(&tcon->stats.cifs_stats.num_ffirst),
686 atomic_read(&tcon->stats.cifs_stats.num_fnext), 686 atomic_read(&tcon->stats.cifs_stats.num_fnext),
687 atomic_read(&tcon->stats.cifs_stats.num_fclose)); 687 atomic_read(&tcon->stats.cifs_stats.num_fclose));
688 #endif 688 #endif
689 } 689 }
690 690
691 static void 691 static void
692 cifs_mkdir_setinfo(struct inode *inode, const char *full_path, 692 cifs_mkdir_setinfo(struct inode *inode, const char *full_path,
693 struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon, 693 struct cifs_sb_info *cifs_sb, struct cifs_tcon *tcon,
694 const unsigned int xid) 694 const unsigned int xid)
695 { 695 {
696 FILE_BASIC_INFO info; 696 FILE_BASIC_INFO info;
697 struct cifsInodeInfo *cifsInode; 697 struct cifsInodeInfo *cifsInode;
698 u32 dosattrs; 698 u32 dosattrs;
699 int rc; 699 int rc;
700 700
701 memset(&info, 0, sizeof(info)); 701 memset(&info, 0, sizeof(info));
702 cifsInode = CIFS_I(inode); 702 cifsInode = CIFS_I(inode);
703 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY; 703 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
704 info.Attributes = cpu_to_le32(dosattrs); 704 info.Attributes = cpu_to_le32(dosattrs);
705 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, &info, cifs_sb->local_nls, 705 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, &info, cifs_sb->local_nls,
706 cifs_sb->mnt_cifs_flags & 706 cifs_sb->mnt_cifs_flags &
707 CIFS_MOUNT_MAP_SPECIAL_CHR); 707 CIFS_MOUNT_MAP_SPECIAL_CHR);
708 if (rc == 0) 708 if (rc == 0)
709 cifsInode->cifsAttrs = dosattrs; 709 cifsInode->cifsAttrs = dosattrs;
710 } 710 }
711 711
712 static int 712 static int
713 cifs_open_file(const unsigned int xid, struct cifs_open_parms *oparms, 713 cifs_open_file(const unsigned int xid, struct cifs_open_parms *oparms,
714 __u32 *oplock, FILE_ALL_INFO *buf) 714 __u32 *oplock, FILE_ALL_INFO *buf)
715 { 715 {
716 if (!(oparms->tcon->ses->capabilities & CAP_NT_SMBS)) 716 if (!(oparms->tcon->ses->capabilities & CAP_NT_SMBS))
717 return SMBLegacyOpen(xid, oparms->tcon, oparms->path, 717 return SMBLegacyOpen(xid, oparms->tcon, oparms->path,
718 oparms->disposition, 718 oparms->disposition,
719 oparms->desired_access, 719 oparms->desired_access,
720 oparms->create_options, 720 oparms->create_options,
721 &oparms->fid->netfid, oplock, buf, 721 &oparms->fid->netfid, oplock, buf,
722 oparms->cifs_sb->local_nls, 722 oparms->cifs_sb->local_nls,
723 oparms->cifs_sb->mnt_cifs_flags 723 oparms->cifs_sb->mnt_cifs_flags
724 & CIFS_MOUNT_MAP_SPECIAL_CHR); 724 & CIFS_MOUNT_MAP_SPECIAL_CHR);
725 return CIFS_open(xid, oparms, oplock, buf); 725 return CIFS_open(xid, oparms, oplock, buf);
726 } 726 }
727 727
728 static void 728 static void
729 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock) 729 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
730 { 730 {
731 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 731 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
732 cfile->fid.netfid = fid->netfid; 732 cfile->fid.netfid = fid->netfid;
733 cifs_set_oplock_level(cinode, oplock); 733 cifs_set_oplock_level(cinode, oplock);
734 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode); 734 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);
735 } 735 }
736 736
737 static void 737 static void
738 cifs_close_file(const unsigned int xid, struct cifs_tcon *tcon, 738 cifs_close_file(const unsigned int xid, struct cifs_tcon *tcon,
739 struct cifs_fid *fid) 739 struct cifs_fid *fid)
740 { 740 {
741 CIFSSMBClose(xid, tcon, fid->netfid); 741 CIFSSMBClose(xid, tcon, fid->netfid);
742 } 742 }
743 743
744 static int 744 static int
745 cifs_flush_file(const unsigned int xid, struct cifs_tcon *tcon, 745 cifs_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
746 struct cifs_fid *fid) 746 struct cifs_fid *fid)
747 { 747 {
748 return CIFSSMBFlush(xid, tcon, fid->netfid); 748 return CIFSSMBFlush(xid, tcon, fid->netfid);
749 } 749 }
750 750
751 static int 751 static int
752 cifs_sync_read(const unsigned int xid, struct cifsFileInfo *cfile, 752 cifs_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
753 struct cifs_io_parms *parms, unsigned int *bytes_read, 753 struct cifs_io_parms *parms, unsigned int *bytes_read,
754 char **buf, int *buf_type) 754 char **buf, int *buf_type)
755 { 755 {
756 parms->netfid = cfile->fid.netfid; 756 parms->netfid = cfile->fid.netfid;
757 return CIFSSMBRead(xid, parms, bytes_read, buf, buf_type); 757 return CIFSSMBRead(xid, parms, bytes_read, buf, buf_type);
758 } 758 }
759 759
760 static int 760 static int
761 cifs_sync_write(const unsigned int xid, struct cifsFileInfo *cfile, 761 cifs_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
762 struct cifs_io_parms *parms, unsigned int *written, 762 struct cifs_io_parms *parms, unsigned int *written,
763 struct kvec *iov, unsigned long nr_segs) 763 struct kvec *iov, unsigned long nr_segs)
764 { 764 {
765 765
766 parms->netfid = cfile->fid.netfid; 766 parms->netfid = cfile->fid.netfid;
767 return CIFSSMBWrite2(xid, parms, written, iov, nr_segs); 767 return CIFSSMBWrite2(xid, parms, written, iov, nr_segs);
768 } 768 }
769 769
770 static int 770 static int
771 smb_set_file_info(struct inode *inode, const char *full_path, 771 smb_set_file_info(struct inode *inode, const char *full_path,
772 FILE_BASIC_INFO *buf, const unsigned int xid) 772 FILE_BASIC_INFO *buf, const unsigned int xid)
773 { 773 {
774 int oplock = 0; 774 int oplock = 0;
775 int rc; 775 int rc;
776 __u32 netpid; 776 __u32 netpid;
777 struct cifs_fid fid; 777 struct cifs_fid fid;
778 struct cifs_open_parms oparms; 778 struct cifs_open_parms oparms;
779 struct cifsFileInfo *open_file; 779 struct cifsFileInfo *open_file;
780 struct cifsInodeInfo *cinode = CIFS_I(inode); 780 struct cifsInodeInfo *cinode = CIFS_I(inode);
781 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 781 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
782 struct tcon_link *tlink = NULL; 782 struct tcon_link *tlink = NULL;
783 struct cifs_tcon *tcon; 783 struct cifs_tcon *tcon;
784 784
785 /* if the file is already open for write, just use that fileid */ 785 /* if the file is already open for write, just use that fileid */
786 open_file = find_writable_file(cinode, true); 786 open_file = find_writable_file(cinode, true);
787 if (open_file) { 787 if (open_file) {
788 fid.netfid = open_file->fid.netfid; 788 fid.netfid = open_file->fid.netfid;
789 netpid = open_file->pid; 789 netpid = open_file->pid;
790 tcon = tlink_tcon(open_file->tlink); 790 tcon = tlink_tcon(open_file->tlink);
791 goto set_via_filehandle; 791 goto set_via_filehandle;
792 } 792 }
793 793
794 tlink = cifs_sb_tlink(cifs_sb); 794 tlink = cifs_sb_tlink(cifs_sb);
795 if (IS_ERR(tlink)) { 795 if (IS_ERR(tlink)) {
796 rc = PTR_ERR(tlink); 796 rc = PTR_ERR(tlink);
797 tlink = NULL; 797 tlink = NULL;
798 goto out; 798 goto out;
799 } 799 }
800 tcon = tlink_tcon(tlink); 800 tcon = tlink_tcon(tlink);
801 801
802 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, buf, cifs_sb->local_nls, 802 rc = CIFSSMBSetPathInfo(xid, tcon, full_path, buf, cifs_sb->local_nls,
803 cifs_sb->mnt_cifs_flags & 803 cifs_sb->mnt_cifs_flags &
804 CIFS_MOUNT_MAP_SPECIAL_CHR); 804 CIFS_MOUNT_MAP_SPECIAL_CHR);
805 if (rc == 0) { 805 if (rc == 0) {
806 cinode->cifsAttrs = le32_to_cpu(buf->Attributes); 806 cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
807 goto out; 807 goto out;
808 } else if (rc != -EOPNOTSUPP && rc != -EINVAL) { 808 } else if (rc != -EOPNOTSUPP && rc != -EINVAL) {
809 goto out; 809 goto out;
810 } 810 }
811 811
812 oparms.tcon = tcon; 812 oparms.tcon = tcon;
813 oparms.cifs_sb = cifs_sb; 813 oparms.cifs_sb = cifs_sb;
814 oparms.desired_access = SYNCHRONIZE | FILE_WRITE_ATTRIBUTES; 814 oparms.desired_access = SYNCHRONIZE | FILE_WRITE_ATTRIBUTES;
815 oparms.create_options = CREATE_NOT_DIR; 815 oparms.create_options = CREATE_NOT_DIR;
816 oparms.disposition = FILE_OPEN; 816 oparms.disposition = FILE_OPEN;
817 oparms.path = full_path; 817 oparms.path = full_path;
818 oparms.fid = &fid; 818 oparms.fid = &fid;
819 oparms.reconnect = false; 819 oparms.reconnect = false;
820 820
821 cifs_dbg(FYI, "calling SetFileInfo since SetPathInfo for times not supported by this server\n"); 821 cifs_dbg(FYI, "calling SetFileInfo since SetPathInfo for times not supported by this server\n");
822 rc = CIFS_open(xid, &oparms, &oplock, NULL); 822 rc = CIFS_open(xid, &oparms, &oplock, NULL);
823 if (rc != 0) { 823 if (rc != 0) {
824 if (rc == -EIO) 824 if (rc == -EIO)
825 rc = -EINVAL; 825 rc = -EINVAL;
826 goto out; 826 goto out;
827 } 827 }
828 828
829 netpid = current->tgid; 829 netpid = current->tgid;
830 830
831 set_via_filehandle: 831 set_via_filehandle:
832 rc = CIFSSMBSetFileInfo(xid, tcon, buf, fid.netfid, netpid); 832 rc = CIFSSMBSetFileInfo(xid, tcon, buf, fid.netfid, netpid);
833 if (!rc) 833 if (!rc)
834 cinode->cifsAttrs = le32_to_cpu(buf->Attributes); 834 cinode->cifsAttrs = le32_to_cpu(buf->Attributes);
835 835
836 if (open_file == NULL) 836 if (open_file == NULL)
837 CIFSSMBClose(xid, tcon, fid.netfid); 837 CIFSSMBClose(xid, tcon, fid.netfid);
838 else 838 else
839 cifsFileInfo_put(open_file); 839 cifsFileInfo_put(open_file);
840 out: 840 out:
841 if (tlink != NULL) 841 if (tlink != NULL)
842 cifs_put_tlink(tlink); 842 cifs_put_tlink(tlink);
843 return rc; 843 return rc;
844 } 844 }
845 845
846 static int 846 static int
847 cifs_set_compression(const unsigned int xid, struct cifs_tcon *tcon, 847 cifs_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
848 struct cifsFileInfo *cfile) 848 struct cifsFileInfo *cfile)
849 { 849 {
850 return CIFSSMB_set_compression(xid, tcon, cfile->fid.netfid); 850 return CIFSSMB_set_compression(xid, tcon, cfile->fid.netfid);
851 } 851 }
852 852
853 static int 853 static int
854 cifs_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon, 854 cifs_query_dir_first(const unsigned int xid, struct cifs_tcon *tcon,
855 const char *path, struct cifs_sb_info *cifs_sb, 855 const char *path, struct cifs_sb_info *cifs_sb,
856 struct cifs_fid *fid, __u16 search_flags, 856 struct cifs_fid *fid, __u16 search_flags,
857 struct cifs_search_info *srch_inf) 857 struct cifs_search_info *srch_inf)
858 { 858 {
859 return CIFSFindFirst(xid, tcon, path, cifs_sb, 859 return CIFSFindFirst(xid, tcon, path, cifs_sb,
860 &fid->netfid, search_flags, srch_inf, true); 860 &fid->netfid, search_flags, srch_inf, true);
861 } 861 }
862 862
863 static int 863 static int
864 cifs_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon, 864 cifs_query_dir_next(const unsigned int xid, struct cifs_tcon *tcon,
865 struct cifs_fid *fid, __u16 search_flags, 865 struct cifs_fid *fid, __u16 search_flags,
866 struct cifs_search_info *srch_inf) 866 struct cifs_search_info *srch_inf)
867 { 867 {
868 return CIFSFindNext(xid, tcon, fid->netfid, search_flags, srch_inf); 868 return CIFSFindNext(xid, tcon, fid->netfid, search_flags, srch_inf);
869 } 869 }
870 870
871 static int 871 static int
872 cifs_close_dir(const unsigned int xid, struct cifs_tcon *tcon, 872 cifs_close_dir(const unsigned int xid, struct cifs_tcon *tcon,
873 struct cifs_fid *fid) 873 struct cifs_fid *fid)
874 { 874 {
875 return CIFSFindClose(xid, tcon, fid->netfid); 875 return CIFSFindClose(xid, tcon, fid->netfid);
876 } 876 }
877 877
878 static int 878 static int
879 cifs_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid, 879 cifs_oplock_response(struct cifs_tcon *tcon, struct cifs_fid *fid,
880 struct cifsInodeInfo *cinode) 880 struct cifsInodeInfo *cinode)
881 { 881 {
882 return CIFSSMBLock(0, tcon, fid->netfid, current->tgid, 0, 0, 0, 0, 882 return CIFSSMBLock(0, tcon, fid->netfid, current->tgid, 0, 0, 0, 0,
883 LOCKING_ANDX_OPLOCK_RELEASE, false, 883 LOCKING_ANDX_OPLOCK_RELEASE, false,
884 CIFS_CACHE_READ(cinode) ? 1 : 0); 884 CIFS_CACHE_READ(cinode) ? 1 : 0);
885 } 885 }
886 886
887 static int 887 static int
888 cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon, 888 cifs_queryfs(const unsigned int xid, struct cifs_tcon *tcon,
889 struct kstatfs *buf) 889 struct kstatfs *buf)
890 { 890 {
891 int rc = -EOPNOTSUPP; 891 int rc = -EOPNOTSUPP;
892 892
893 buf->f_type = CIFS_MAGIC_NUMBER; 893 buf->f_type = CIFS_MAGIC_NUMBER;
894 894
895 /* 895 /*
896 * We could add a second check for a QFS Unix capability bit 896 * We could add a second check for a QFS Unix capability bit
897 */ 897 */
898 if ((tcon->ses->capabilities & CAP_UNIX) && 898 if ((tcon->ses->capabilities & CAP_UNIX) &&
899 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability))) 899 (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
900 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf); 900 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
901 901
902 /* 902 /*
903 * Only need to call the old QFSInfo if failed on newer one, 903 * Only need to call the old QFSInfo if failed on newer one,
904 * e.g. by OS/2. 904 * e.g. by OS/2.
905 **/ 905 **/
906 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS)) 906 if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
907 rc = CIFSSMBQFSInfo(xid, tcon, buf); 907 rc = CIFSSMBQFSInfo(xid, tcon, buf);
908 908
909 /* 909 /*
910 * Some old Windows servers also do not support level 103, retry with 910 * Some old Windows servers also do not support level 103, retry with
911 * older level one if old server failed the previous call or we 911 * older level one if old server failed the previous call or we
912 * bypassed it because we detected that this was an older LANMAN sess 912 * bypassed it because we detected that this was an older LANMAN sess
913 */ 913 */
914 if (rc) 914 if (rc)
915 rc = SMBOldQFSInfo(xid, tcon, buf); 915 rc = SMBOldQFSInfo(xid, tcon, buf);
916 return rc; 916 return rc;
917 } 917 }
918 918
919 static int 919 static int
920 cifs_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset, 920 cifs_mand_lock(const unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
921 __u64 length, __u32 type, int lock, int unlock, bool wait) 921 __u64 length, __u32 type, int lock, int unlock, bool wait)
922 { 922 {
923 return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid, 923 return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid,
924 current->tgid, length, offset, unlock, lock, 924 current->tgid, length, offset, unlock, lock,
925 (__u8)type, wait, 0); 925 (__u8)type, wait, 0);
926 } 926 }
927 927
928 static int 928 static int
929 cifs_unix_dfs_readlink(const unsigned int xid, struct cifs_tcon *tcon, 929 cifs_unix_dfs_readlink(const unsigned int xid, struct cifs_tcon *tcon,
930 const unsigned char *searchName, char **symlinkinfo, 930 const unsigned char *searchName, char **symlinkinfo,
931 const struct nls_table *nls_codepage) 931 const struct nls_table *nls_codepage)
932 { 932 {
933 #ifdef CONFIG_CIFS_DFS_UPCALL 933 #ifdef CONFIG_CIFS_DFS_UPCALL
934 int rc; 934 int rc;
935 unsigned int num_referrals = 0; 935 unsigned int num_referrals = 0;
936 struct dfs_info3_param *referrals = NULL; 936 struct dfs_info3_param *referrals = NULL;
937 937
938 rc = get_dfs_path(xid, tcon->ses, searchName, nls_codepage, 938 rc = get_dfs_path(xid, tcon->ses, searchName, nls_codepage,
939 &num_referrals, &referrals, 0); 939 &num_referrals, &referrals, 0);
940 940
941 if (!rc && num_referrals > 0) { 941 if (!rc && num_referrals > 0) {
942 *symlinkinfo = kstrndup(referrals->node_name, 942 *symlinkinfo = kstrndup(referrals->node_name,
943 strlen(referrals->node_name), 943 strlen(referrals->node_name),
944 GFP_KERNEL); 944 GFP_KERNEL);
945 if (!*symlinkinfo) 945 if (!*symlinkinfo)
946 rc = -ENOMEM; 946 rc = -ENOMEM;
947 free_dfs_info_array(referrals, num_referrals); 947 free_dfs_info_array(referrals, num_referrals);
948 } 948 }
949 return rc; 949 return rc;
950 #else /* No DFS support */ 950 #else /* No DFS support */
951 return -EREMOTE; 951 return -EREMOTE;
952 #endif 952 #endif
953 } 953 }
954 954
955 static int 955 static int
956 cifs_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, 956 cifs_query_symlink(const unsigned int xid, struct cifs_tcon *tcon,
957 const char *full_path, char **target_path, 957 const char *full_path, char **target_path,
958 struct cifs_sb_info *cifs_sb) 958 struct cifs_sb_info *cifs_sb)
959 { 959 {
960 int rc; 960 int rc;
961 int oplock = 0; 961 int oplock = 0;
962 struct cifs_fid fid; 962 struct cifs_fid fid;
963 struct cifs_open_parms oparms; 963 struct cifs_open_parms oparms;
964 964
965 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path); 965 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path);
966 966
967 /* Check for unix extensions */ 967 /* Check for unix extensions */
968 if (cap_unix(tcon->ses)) { 968 if (cap_unix(tcon->ses)) {
969 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, target_path, 969 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, target_path,
970 cifs_sb->local_nls); 970 cifs_sb->local_nls);
971 if (rc == -EREMOTE) 971 if (rc == -EREMOTE)
972 rc = cifs_unix_dfs_readlink(xid, tcon, full_path, 972 rc = cifs_unix_dfs_readlink(xid, tcon, full_path,
973 target_path, 973 target_path,
974 cifs_sb->local_nls); 974 cifs_sb->local_nls);
975 975
976 goto out; 976 goto out;
977 } 977 }
978 978
979 oparms.tcon = tcon; 979 oparms.tcon = tcon;
980 oparms.cifs_sb = cifs_sb; 980 oparms.cifs_sb = cifs_sb;
981 oparms.desired_access = FILE_READ_ATTRIBUTES; 981 oparms.desired_access = FILE_READ_ATTRIBUTES;
982 oparms.create_options = OPEN_REPARSE_POINT; 982 oparms.create_options = OPEN_REPARSE_POINT;
983 oparms.disposition = FILE_OPEN; 983 oparms.disposition = FILE_OPEN;
984 oparms.path = full_path; 984 oparms.path = full_path;
985 oparms.fid = &fid; 985 oparms.fid = &fid;
986 oparms.reconnect = false; 986 oparms.reconnect = false;
987 987
988 rc = CIFS_open(xid, &oparms, &oplock, NULL); 988 rc = CIFS_open(xid, &oparms, &oplock, NULL);
989 if (rc) 989 if (rc)
990 goto out; 990 goto out;
991 991
992 rc = CIFSSMBQuerySymLink(xid, tcon, fid.netfid, target_path, 992 rc = CIFSSMBQuerySymLink(xid, tcon, fid.netfid, target_path,
993 cifs_sb->local_nls); 993 cifs_sb->local_nls);
994 if (rc) 994 if (rc)
995 goto out_close; 995 goto out_close;
996 996
997 convert_delimiter(*target_path, '/'); 997 convert_delimiter(*target_path, '/');
998 out_close: 998 out_close:
999 CIFSSMBClose(xid, tcon, fid.netfid); 999 CIFSSMBClose(xid, tcon, fid.netfid);
1000 out: 1000 out:
1001 if (!rc) 1001 if (!rc)
1002 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path); 1002 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path);
1003 return rc; 1003 return rc;
1004 } 1004 }
1005 1005
1006 static bool 1006 static bool
1007 cifs_is_read_op(__u32 oplock) 1007 cifs_is_read_op(__u32 oplock)
1008 { 1008 {
1009 return oplock == OPLOCK_READ; 1009 return oplock == OPLOCK_READ;
1010 } 1010 }
1011 1011
1012 struct smb_version_operations smb1_operations = { 1012 struct smb_version_operations smb1_operations = {
1013 .send_cancel = send_nt_cancel, 1013 .send_cancel = send_nt_cancel,
1014 .compare_fids = cifs_compare_fids, 1014 .compare_fids = cifs_compare_fids,
1015 .setup_request = cifs_setup_request, 1015 .setup_request = cifs_setup_request,
1016 .setup_async_request = cifs_setup_async_request, 1016 .setup_async_request = cifs_setup_async_request,
1017 .check_receive = cifs_check_receive, 1017 .check_receive = cifs_check_receive,
1018 .add_credits = cifs_add_credits, 1018 .add_credits = cifs_add_credits,
1019 .set_credits = cifs_set_credits, 1019 .set_credits = cifs_set_credits,
1020 .get_credits_field = cifs_get_credits_field, 1020 .get_credits_field = cifs_get_credits_field,
1021 .get_credits = cifs_get_credits, 1021 .get_credits = cifs_get_credits,
1022 .get_next_mid = cifs_get_next_mid, 1022 .get_next_mid = cifs_get_next_mid,
1023 .read_data_offset = cifs_read_data_offset, 1023 .read_data_offset = cifs_read_data_offset,
1024 .read_data_length = cifs_read_data_length, 1024 .read_data_length = cifs_read_data_length,
1025 .map_error = map_smb_to_linux_error, 1025 .map_error = map_smb_to_linux_error,
1026 .find_mid = cifs_find_mid, 1026 .find_mid = cifs_find_mid,
1027 .check_message = checkSMB, 1027 .check_message = checkSMB,
1028 .dump_detail = cifs_dump_detail, 1028 .dump_detail = cifs_dump_detail,
1029 .clear_stats = cifs_clear_stats, 1029 .clear_stats = cifs_clear_stats,
1030 .print_stats = cifs_print_stats, 1030 .print_stats = cifs_print_stats,
1031 .is_oplock_break = is_valid_oplock_break, 1031 .is_oplock_break = is_valid_oplock_break,
1032 .downgrade_oplock = cifs_downgrade_oplock, 1032 .downgrade_oplock = cifs_downgrade_oplock,
1033 .check_trans2 = cifs_check_trans2, 1033 .check_trans2 = cifs_check_trans2,
1034 .need_neg = cifs_need_neg, 1034 .need_neg = cifs_need_neg,
1035 .negotiate = cifs_negotiate, 1035 .negotiate = cifs_negotiate,
1036 .negotiate_wsize = cifs_negotiate_wsize, 1036 .negotiate_wsize = cifs_negotiate_wsize,
1037 .negotiate_rsize = cifs_negotiate_rsize, 1037 .negotiate_rsize = cifs_negotiate_rsize,
1038 .sess_setup = CIFS_SessSetup, 1038 .sess_setup = CIFS_SessSetup,
1039 .logoff = CIFSSMBLogoff, 1039 .logoff = CIFSSMBLogoff,
1040 .tree_connect = CIFSTCon, 1040 .tree_connect = CIFSTCon,
1041 .tree_disconnect = CIFSSMBTDis, 1041 .tree_disconnect = CIFSSMBTDis,
1042 .get_dfs_refer = CIFSGetDFSRefer, 1042 .get_dfs_refer = CIFSGetDFSRefer,
1043 .qfs_tcon = cifs_qfs_tcon, 1043 .qfs_tcon = cifs_qfs_tcon,
1044 .is_path_accessible = cifs_is_path_accessible, 1044 .is_path_accessible = cifs_is_path_accessible,
1045 .query_path_info = cifs_query_path_info, 1045 .query_path_info = cifs_query_path_info,
1046 .query_file_info = cifs_query_file_info, 1046 .query_file_info = cifs_query_file_info,
1047 .get_srv_inum = cifs_get_srv_inum, 1047 .get_srv_inum = cifs_get_srv_inum,
1048 .set_path_size = CIFSSMBSetEOF, 1048 .set_path_size = CIFSSMBSetEOF,
1049 .set_file_size = CIFSSMBSetFileSize, 1049 .set_file_size = CIFSSMBSetFileSize,
1050 .set_file_info = smb_set_file_info, 1050 .set_file_info = smb_set_file_info,
1051 .set_compression = cifs_set_compression, 1051 .set_compression = cifs_set_compression,
1052 .echo = CIFSSMBEcho, 1052 .echo = CIFSSMBEcho,
1053 .mkdir = CIFSSMBMkDir, 1053 .mkdir = CIFSSMBMkDir,
1054 .mkdir_setinfo = cifs_mkdir_setinfo, 1054 .mkdir_setinfo = cifs_mkdir_setinfo,
1055 .rmdir = CIFSSMBRmDir, 1055 .rmdir = CIFSSMBRmDir,
1056 .unlink = CIFSSMBDelFile, 1056 .unlink = CIFSSMBDelFile,
1057 .rename_pending_delete = cifs_rename_pending_delete, 1057 .rename_pending_delete = cifs_rename_pending_delete,
1058 .rename = CIFSSMBRename, 1058 .rename = CIFSSMBRename,
1059 .create_hardlink = CIFSCreateHardLink, 1059 .create_hardlink = CIFSCreateHardLink,
1060 .query_symlink = cifs_query_symlink, 1060 .query_symlink = cifs_query_symlink,
1061 .open = cifs_open_file, 1061 .open = cifs_open_file,
1062 .set_fid = cifs_set_fid, 1062 .set_fid = cifs_set_fid,
1063 .close = cifs_close_file, 1063 .close = cifs_close_file,
1064 .flush = cifs_flush_file, 1064 .flush = cifs_flush_file,
1065 .async_readv = cifs_async_readv, 1065 .async_readv = cifs_async_readv,
1066 .async_writev = cifs_async_writev, 1066 .async_writev = cifs_async_writev,
1067 .sync_read = cifs_sync_read, 1067 .sync_read = cifs_sync_read,
1068 .sync_write = cifs_sync_write, 1068 .sync_write = cifs_sync_write,
1069 .query_dir_first = cifs_query_dir_first, 1069 .query_dir_first = cifs_query_dir_first,
1070 .query_dir_next = cifs_query_dir_next, 1070 .query_dir_next = cifs_query_dir_next,
1071 .close_dir = cifs_close_dir, 1071 .close_dir = cifs_close_dir,
1072 .calc_smb_size = smbCalcSize, 1072 .calc_smb_size = smbCalcSize,
1073 .oplock_response = cifs_oplock_response, 1073 .oplock_response = cifs_oplock_response,
1074 .queryfs = cifs_queryfs, 1074 .queryfs = cifs_queryfs,
1075 .mand_lock = cifs_mand_lock, 1075 .mand_lock = cifs_mand_lock,
1076 .mand_unlock_range = cifs_unlock_range, 1076 .mand_unlock_range = cifs_unlock_range,
1077 .push_mand_locks = cifs_push_mandatory_locks, 1077 .push_mand_locks = cifs_push_mandatory_locks,
1078 .query_mf_symlink = cifs_query_mf_symlink, 1078 .query_mf_symlink = cifs_query_mf_symlink,
1079 .create_mf_symlink = cifs_create_mf_symlink, 1079 .create_mf_symlink = cifs_create_mf_symlink,
1080 .is_read_op = cifs_is_read_op, 1080 .is_read_op = cifs_is_read_op,
1081 #ifdef CONFIG_CIFS_XATTR 1081 #ifdef CONFIG_CIFS_XATTR
1082 .query_all_EAs = CIFSSMBQAllEAs, 1082 .query_all_EAs = CIFSSMBQAllEAs,
1083 .set_EA = CIFSSMBSetEA, 1083 .set_EA = CIFSSMBSetEA,
1084 #endif /* CIFS_XATTR */ 1084 #endif /* CIFS_XATTR */
1085 #ifdef CONFIG_CIFS_ACL 1085 #ifdef CONFIG_CIFS_ACL
1086 .get_acl = get_cifs_acl, 1086 .get_acl = get_cifs_acl,
1087 .get_acl_by_fid = get_cifs_acl_by_fid, 1087 .get_acl_by_fid = get_cifs_acl_by_fid,
1088 .set_acl = set_cifs_acl, 1088 .set_acl = set_cifs_acl,
1089 #endif /* CIFS_ACL */ 1089 #endif /* CIFS_ACL */
1090 }; 1090 };
1091 1091
1092 struct smb_version_values smb1_values = { 1092 struct smb_version_values smb1_values = {
1093 .version_string = SMB1_VERSION_STRING, 1093 .version_string = SMB1_VERSION_STRING,
1094 .large_lock_type = LOCKING_ANDX_LARGE_FILES, 1094 .large_lock_type = LOCKING_ANDX_LARGE_FILES,
1095 .exclusive_lock_type = 0, 1095 .exclusive_lock_type = 0,
1096 .shared_lock_type = LOCKING_ANDX_SHARED_LOCK, 1096 .shared_lock_type = LOCKING_ANDX_SHARED_LOCK,
1097 .unlock_lock_type = 0, 1097 .unlock_lock_type = 0,
1098 .header_size = sizeof(struct smb_hdr), 1098 .header_size = sizeof(struct smb_hdr),
1099 .max_header_size = MAX_CIFS_HDR_SIZE, 1099 .max_header_size = MAX_CIFS_HDR_SIZE,
1100 .read_rsp_size = sizeof(READ_RSP), 1100 .read_rsp_size = sizeof(READ_RSP),
1101 .lock_cmd = cpu_to_le16(SMB_COM_LOCKING_ANDX), 1101 .lock_cmd = cpu_to_le16(SMB_COM_LOCKING_ANDX),
1102 .cap_unix = CAP_UNIX, 1102 .cap_unix = CAP_UNIX,
1103 .cap_nt_find = CAP_NT_SMBS | CAP_NT_FIND, 1103 .cap_nt_find = CAP_NT_SMBS | CAP_NT_FIND,
1104 .cap_large_files = CAP_LARGE_FILES, 1104 .cap_large_files = CAP_LARGE_FILES,
1105 .signing_enabled = SECMODE_SIGN_ENABLED, 1105 .signing_enabled = SECMODE_SIGN_ENABLED,
1106 .signing_required = SECMODE_SIGN_REQUIRED, 1106 .signing_required = SECMODE_SIGN_REQUIRED,
1107 }; 1107 };
1108 1108
fs/cifs/smb2maperror.c
Diff comments   View file @ f012edf
1 /* 1 /*
2 * fs/smb2/smb2maperror.c 2 * fs/smb2/smb2maperror.c
3 * 3 *
4 * Functions which do error mapping of SMB2 status codes to POSIX errors 4 * Functions which do error mapping of SMB2 status codes to POSIX errors
5 * 5 *
6 * Copyright (C) International Business Machines Corp., 2009 6 * Copyright (C) International Business Machines Corp., 2009
7 * Author(s): Steve French (sfrench@us.ibm.com) 7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * 8 *
9 * This library is free software; you can redistribute it and/or modify 9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published 10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or 11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version. 12 * (at your option) any later version.
13 * 13 *
14 * This library is distributed in the hope that it will be useful, 14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details. 17 * the GNU Lesser General Public License for more details.
18 * 18 *
19 * You should have received a copy of the GNU Lesser General Public License 19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software 20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */ 22 */
23 #include <linux/errno.h> 23 #include <linux/errno.h>
24 #include "cifsglob.h" 24 #include "cifsglob.h"
25 #include "cifs_debug.h" 25 #include "cifs_debug.h"
26 #include "smb2pdu.h" 26 #include "smb2pdu.h"
27 #include "smb2proto.h" 27 #include "smb2proto.h"
28 #include "smb2status.h" 28 #include "smb2status.h"
29 29
30 struct status_to_posix_error { 30 struct status_to_posix_error {
31 __le32 smb2_status; 31 __le32 smb2_status;
32 int posix_error; 32 int posix_error;
33 char *status_string; 33 char *status_string;
34 }; 34 };
35 35
36 static const struct status_to_posix_error smb2_error_map_table[] = { 36 static const struct status_to_posix_error smb2_error_map_table[] = {
37 {STATUS_SUCCESS, 0, "STATUS_SUCCESS"}, 37 {STATUS_SUCCESS, 0, "STATUS_SUCCESS"},
38 {STATUS_WAIT_0, 0, "STATUS_WAIT_0"}, 38 {STATUS_WAIT_0, 0, "STATUS_WAIT_0"},
39 {STATUS_WAIT_1, -EIO, "STATUS_WAIT_1"}, 39 {STATUS_WAIT_1, -EIO, "STATUS_WAIT_1"},
40 {STATUS_WAIT_2, -EIO, "STATUS_WAIT_2"}, 40 {STATUS_WAIT_2, -EIO, "STATUS_WAIT_2"},
41 {STATUS_WAIT_3, -EIO, "STATUS_WAIT_3"}, 41 {STATUS_WAIT_3, -EIO, "STATUS_WAIT_3"},
42 {STATUS_WAIT_63, -EIO, "STATUS_WAIT_63"}, 42 {STATUS_WAIT_63, -EIO, "STATUS_WAIT_63"},
43 {STATUS_ABANDONED, -EIO, "STATUS_ABANDONED"}, 43 {STATUS_ABANDONED, -EIO, "STATUS_ABANDONED"},
44 {STATUS_ABANDONED_WAIT_0, -EIO, "STATUS_ABANDONED_WAIT_0"}, 44 {STATUS_ABANDONED_WAIT_0, -EIO, "STATUS_ABANDONED_WAIT_0"},
45 {STATUS_ABANDONED_WAIT_63, -EIO, "STATUS_ABANDONED_WAIT_63"}, 45 {STATUS_ABANDONED_WAIT_63, -EIO, "STATUS_ABANDONED_WAIT_63"},
46 {STATUS_USER_APC, -EIO, "STATUS_USER_APC"}, 46 {STATUS_USER_APC, -EIO, "STATUS_USER_APC"},
47 {STATUS_KERNEL_APC, -EIO, "STATUS_KERNEL_APC"}, 47 {STATUS_KERNEL_APC, -EIO, "STATUS_KERNEL_APC"},
48 {STATUS_ALERTED, -EIO, "STATUS_ALERTED"}, 48 {STATUS_ALERTED, -EIO, "STATUS_ALERTED"},
49 {STATUS_TIMEOUT, -ETIMEDOUT, "STATUS_TIMEOUT"}, 49 {STATUS_TIMEOUT, -ETIMEDOUT, "STATUS_TIMEOUT"},
50 {STATUS_PENDING, -EIO, "STATUS_PENDING"}, 50 {STATUS_PENDING, -EIO, "STATUS_PENDING"},
51 {STATUS_REPARSE, -EIO, "STATUS_REPARSE"}, 51 {STATUS_REPARSE, -EIO, "STATUS_REPARSE"},
52 {STATUS_MORE_ENTRIES, -EIO, "STATUS_MORE_ENTRIES"}, 52 {STATUS_MORE_ENTRIES, -EIO, "STATUS_MORE_ENTRIES"},
53 {STATUS_NOT_ALL_ASSIGNED, -EIO, "STATUS_NOT_ALL_ASSIGNED"}, 53 {STATUS_NOT_ALL_ASSIGNED, -EIO, "STATUS_NOT_ALL_ASSIGNED"},
54 {STATUS_SOME_NOT_MAPPED, -EIO, "STATUS_SOME_NOT_MAPPED"}, 54 {STATUS_SOME_NOT_MAPPED, -EIO, "STATUS_SOME_NOT_MAPPED"},
55 {STATUS_OPLOCK_BREAK_IN_PROGRESS, -EIO, 55 {STATUS_OPLOCK_BREAK_IN_PROGRESS, -EIO,
56 "STATUS_OPLOCK_BREAK_IN_PROGRESS"}, 56 "STATUS_OPLOCK_BREAK_IN_PROGRESS"},
57 {STATUS_VOLUME_MOUNTED, -EIO, "STATUS_VOLUME_MOUNTED"}, 57 {STATUS_VOLUME_MOUNTED, -EIO, "STATUS_VOLUME_MOUNTED"},
58 {STATUS_RXACT_COMMITTED, -EIO, "STATUS_RXACT_COMMITTED"}, 58 {STATUS_RXACT_COMMITTED, -EIO, "STATUS_RXACT_COMMITTED"},
59 {STATUS_NOTIFY_CLEANUP, -EIO, "STATUS_NOTIFY_CLEANUP"}, 59 {STATUS_NOTIFY_CLEANUP, -EIO, "STATUS_NOTIFY_CLEANUP"},
60 {STATUS_NOTIFY_ENUM_DIR, -EIO, "STATUS_NOTIFY_ENUM_DIR"}, 60 {STATUS_NOTIFY_ENUM_DIR, -EIO, "STATUS_NOTIFY_ENUM_DIR"},
61 {STATUS_NO_QUOTAS_FOR_ACCOUNT, -EIO, "STATUS_NO_QUOTAS_FOR_ACCOUNT"}, 61 {STATUS_NO_QUOTAS_FOR_ACCOUNT, -EIO, "STATUS_NO_QUOTAS_FOR_ACCOUNT"},
62 {STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED, -EIO, 62 {STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED, -EIO,
63 "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"}, 63 "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED"},
64 {STATUS_PAGE_FAULT_TRANSITION, -EIO, "STATUS_PAGE_FAULT_TRANSITION"}, 64 {STATUS_PAGE_FAULT_TRANSITION, -EIO, "STATUS_PAGE_FAULT_TRANSITION"},
65 {STATUS_PAGE_FAULT_DEMAND_ZERO, -EIO, "STATUS_PAGE_FAULT_DEMAND_ZERO"}, 65 {STATUS_PAGE_FAULT_DEMAND_ZERO, -EIO, "STATUS_PAGE_FAULT_DEMAND_ZERO"},
66 {STATUS_PAGE_FAULT_COPY_ON_WRITE, -EIO, 66 {STATUS_PAGE_FAULT_COPY_ON_WRITE, -EIO,
67 "STATUS_PAGE_FAULT_COPY_ON_WRITE"}, 67 "STATUS_PAGE_FAULT_COPY_ON_WRITE"},
68 {STATUS_PAGE_FAULT_GUARD_PAGE, -EIO, "STATUS_PAGE_FAULT_GUARD_PAGE"}, 68 {STATUS_PAGE_FAULT_GUARD_PAGE, -EIO, "STATUS_PAGE_FAULT_GUARD_PAGE"},
69 {STATUS_PAGE_FAULT_PAGING_FILE, -EIO, "STATUS_PAGE_FAULT_PAGING_FILE"}, 69 {STATUS_PAGE_FAULT_PAGING_FILE, -EIO, "STATUS_PAGE_FAULT_PAGING_FILE"},
70 {STATUS_CACHE_PAGE_LOCKED, -EIO, "STATUS_CACHE_PAGE_LOCKED"}, 70 {STATUS_CACHE_PAGE_LOCKED, -EIO, "STATUS_CACHE_PAGE_LOCKED"},
71 {STATUS_CRASH_DUMP, -EIO, "STATUS_CRASH_DUMP"}, 71 {STATUS_CRASH_DUMP, -EIO, "STATUS_CRASH_DUMP"},
72 {STATUS_BUFFER_ALL_ZEROS, -EIO, "STATUS_BUFFER_ALL_ZEROS"}, 72 {STATUS_BUFFER_ALL_ZEROS, -EIO, "STATUS_BUFFER_ALL_ZEROS"},
73 {STATUS_REPARSE_OBJECT, -EIO, "STATUS_REPARSE_OBJECT"}, 73 {STATUS_REPARSE_OBJECT, -EIO, "STATUS_REPARSE_OBJECT"},
74 {STATUS_RESOURCE_REQUIREMENTS_CHANGED, -EIO, 74 {STATUS_RESOURCE_REQUIREMENTS_CHANGED, -EIO,
75 "STATUS_RESOURCE_REQUIREMENTS_CHANGED"}, 75 "STATUS_RESOURCE_REQUIREMENTS_CHANGED"},
76 {STATUS_TRANSLATION_COMPLETE, -EIO, "STATUS_TRANSLATION_COMPLETE"}, 76 {STATUS_TRANSLATION_COMPLETE, -EIO, "STATUS_TRANSLATION_COMPLETE"},
77 {STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, -EIO, 77 {STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY, -EIO,
78 "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"}, 78 "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY"},
79 {STATUS_NOTHING_TO_TERMINATE, -EIO, "STATUS_NOTHING_TO_TERMINATE"}, 79 {STATUS_NOTHING_TO_TERMINATE, -EIO, "STATUS_NOTHING_TO_TERMINATE"},
80 {STATUS_PROCESS_NOT_IN_JOB, -EIO, "STATUS_PROCESS_NOT_IN_JOB"}, 80 {STATUS_PROCESS_NOT_IN_JOB, -EIO, "STATUS_PROCESS_NOT_IN_JOB"},
81 {STATUS_PROCESS_IN_JOB, -EIO, "STATUS_PROCESS_IN_JOB"}, 81 {STATUS_PROCESS_IN_JOB, -EIO, "STATUS_PROCESS_IN_JOB"},
82 {STATUS_VOLSNAP_HIBERNATE_READY, -EIO, 82 {STATUS_VOLSNAP_HIBERNATE_READY, -EIO,
83 "STATUS_VOLSNAP_HIBERNATE_READY"}, 83 "STATUS_VOLSNAP_HIBERNATE_READY"},
84 {STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY, -EIO, 84 {STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY, -EIO,
85 "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"}, 85 "STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY"},
86 {STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED, -EIO, 86 {STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED, -EIO,
87 "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED"}, 87 "STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED"},
88 {STATUS_INTERRUPT_STILL_CONNECTED, -EIO, 88 {STATUS_INTERRUPT_STILL_CONNECTED, -EIO,
89 "STATUS_INTERRUPT_STILL_CONNECTED"}, 89 "STATUS_INTERRUPT_STILL_CONNECTED"},
90 {STATUS_PROCESS_CLONED, -EIO, "STATUS_PROCESS_CLONED"}, 90 {STATUS_PROCESS_CLONED, -EIO, "STATUS_PROCESS_CLONED"},
91 {STATUS_FILE_LOCKED_WITH_ONLY_READERS, -EIO, 91 {STATUS_FILE_LOCKED_WITH_ONLY_READERS, -EIO,
92 "STATUS_FILE_LOCKED_WITH_ONLY_READERS"}, 92 "STATUS_FILE_LOCKED_WITH_ONLY_READERS"},
93 {STATUS_FILE_LOCKED_WITH_WRITERS, -EIO, 93 {STATUS_FILE_LOCKED_WITH_WRITERS, -EIO,
94 "STATUS_FILE_LOCKED_WITH_WRITERS"}, 94 "STATUS_FILE_LOCKED_WITH_WRITERS"},
95 {STATUS_RESOURCEMANAGER_READ_ONLY, -EROFS, 95 {STATUS_RESOURCEMANAGER_READ_ONLY, -EROFS,
96 "STATUS_RESOURCEMANAGER_READ_ONLY"}, 96 "STATUS_RESOURCEMANAGER_READ_ONLY"},
97 {STATUS_WAIT_FOR_OPLOCK, -EIO, "STATUS_WAIT_FOR_OPLOCK"}, 97 {STATUS_WAIT_FOR_OPLOCK, -EIO, "STATUS_WAIT_FOR_OPLOCK"},
98 {DBG_EXCEPTION_HANDLED, -EIO, "DBG_EXCEPTION_HANDLED"}, 98 {DBG_EXCEPTION_HANDLED, -EIO, "DBG_EXCEPTION_HANDLED"},
99 {DBG_CONTINUE, -EIO, "DBG_CONTINUE"}, 99 {DBG_CONTINUE, -EIO, "DBG_CONTINUE"},
100 {STATUS_FLT_IO_COMPLETE, -EIO, "STATUS_FLT_IO_COMPLETE"}, 100 {STATUS_FLT_IO_COMPLETE, -EIO, "STATUS_FLT_IO_COMPLETE"},
101 {STATUS_OBJECT_NAME_EXISTS, -EIO, "STATUS_OBJECT_NAME_EXISTS"}, 101 {STATUS_OBJECT_NAME_EXISTS, -EIO, "STATUS_OBJECT_NAME_EXISTS"},
102 {STATUS_THREAD_WAS_SUSPENDED, -EIO, "STATUS_THREAD_WAS_SUSPENDED"}, 102 {STATUS_THREAD_WAS_SUSPENDED, -EIO, "STATUS_THREAD_WAS_SUSPENDED"},
103 {STATUS_WORKING_SET_LIMIT_RANGE, -EIO, 103 {STATUS_WORKING_SET_LIMIT_RANGE, -EIO,
104 "STATUS_WORKING_SET_LIMIT_RANGE"}, 104 "STATUS_WORKING_SET_LIMIT_RANGE"},
105 {STATUS_IMAGE_NOT_AT_BASE, -EIO, "STATUS_IMAGE_NOT_AT_BASE"}, 105 {STATUS_IMAGE_NOT_AT_BASE, -EIO, "STATUS_IMAGE_NOT_AT_BASE"},
106 {STATUS_RXACT_STATE_CREATED, -EIO, "STATUS_RXACT_STATE_CREATED"}, 106 {STATUS_RXACT_STATE_CREATED, -EIO, "STATUS_RXACT_STATE_CREATED"},
107 {STATUS_SEGMENT_NOTIFICATION, -EIO, "STATUS_SEGMENT_NOTIFICATION"}, 107 {STATUS_SEGMENT_NOTIFICATION, -EIO, "STATUS_SEGMENT_NOTIFICATION"},
108 {STATUS_LOCAL_USER_SESSION_KEY, -EIO, "STATUS_LOCAL_USER_SESSION_KEY"}, 108 {STATUS_LOCAL_USER_SESSION_KEY, -EIO, "STATUS_LOCAL_USER_SESSION_KEY"},
109 {STATUS_BAD_CURRENT_DIRECTORY, -EIO, "STATUS_BAD_CURRENT_DIRECTORY"}, 109 {STATUS_BAD_CURRENT_DIRECTORY, -EIO, "STATUS_BAD_CURRENT_DIRECTORY"},
110 {STATUS_SERIAL_MORE_WRITES, -EIO, "STATUS_SERIAL_MORE_WRITES"}, 110 {STATUS_SERIAL_MORE_WRITES, -EIO, "STATUS_SERIAL_MORE_WRITES"},
111 {STATUS_REGISTRY_RECOVERED, -EIO, "STATUS_REGISTRY_RECOVERED"}, 111 {STATUS_REGISTRY_RECOVERED, -EIO, "STATUS_REGISTRY_RECOVERED"},
112 {STATUS_FT_READ_RECOVERY_FROM_BACKUP, -EIO, 112 {STATUS_FT_READ_RECOVERY_FROM_BACKUP, -EIO,
113 "STATUS_FT_READ_RECOVERY_FROM_BACKUP"}, 113 "STATUS_FT_READ_RECOVERY_FROM_BACKUP"},
114 {STATUS_FT_WRITE_RECOVERY, -EIO, "STATUS_FT_WRITE_RECOVERY"}, 114 {STATUS_FT_WRITE_RECOVERY, -EIO, "STATUS_FT_WRITE_RECOVERY"},
115 {STATUS_SERIAL_COUNTER_TIMEOUT, -ETIMEDOUT, 115 {STATUS_SERIAL_COUNTER_TIMEOUT, -ETIMEDOUT,
116 "STATUS_SERIAL_COUNTER_TIMEOUT"}, 116 "STATUS_SERIAL_COUNTER_TIMEOUT"},
117 {STATUS_NULL_LM_PASSWORD, -EIO, "STATUS_NULL_LM_PASSWORD"}, 117 {STATUS_NULL_LM_PASSWORD, -EIO, "STATUS_NULL_LM_PASSWORD"},
118 {STATUS_IMAGE_MACHINE_TYPE_MISMATCH, -EIO, 118 {STATUS_IMAGE_MACHINE_TYPE_MISMATCH, -EIO,
119 "STATUS_IMAGE_MACHINE_TYPE_MISMATCH"}, 119 "STATUS_IMAGE_MACHINE_TYPE_MISMATCH"},
120 {STATUS_RECEIVE_PARTIAL, -EIO, "STATUS_RECEIVE_PARTIAL"}, 120 {STATUS_RECEIVE_PARTIAL, -EIO, "STATUS_RECEIVE_PARTIAL"},
121 {STATUS_RECEIVE_EXPEDITED, -EIO, "STATUS_RECEIVE_EXPEDITED"}, 121 {STATUS_RECEIVE_EXPEDITED, -EIO, "STATUS_RECEIVE_EXPEDITED"},
122 {STATUS_RECEIVE_PARTIAL_EXPEDITED, -EIO, 122 {STATUS_RECEIVE_PARTIAL_EXPEDITED, -EIO,
123 "STATUS_RECEIVE_PARTIAL_EXPEDITED"}, 123 "STATUS_RECEIVE_PARTIAL_EXPEDITED"},
124 {STATUS_EVENT_DONE, -EIO, "STATUS_EVENT_DONE"}, 124 {STATUS_EVENT_DONE, -EIO, "STATUS_EVENT_DONE"},
125 {STATUS_EVENT_PENDING, -EIO, "STATUS_EVENT_PENDING"}, 125 {STATUS_EVENT_PENDING, -EIO, "STATUS_EVENT_PENDING"},
126 {STATUS_CHECKING_FILE_SYSTEM, -EIO, "STATUS_CHECKING_FILE_SYSTEM"}, 126 {STATUS_CHECKING_FILE_SYSTEM, -EIO, "STATUS_CHECKING_FILE_SYSTEM"},
127 {STATUS_FATAL_APP_EXIT, -EIO, "STATUS_FATAL_APP_EXIT"}, 127 {STATUS_FATAL_APP_EXIT, -EIO, "STATUS_FATAL_APP_EXIT"},
128 {STATUS_PREDEFINED_HANDLE, -EIO, "STATUS_PREDEFINED_HANDLE"}, 128 {STATUS_PREDEFINED_HANDLE, -EIO, "STATUS_PREDEFINED_HANDLE"},
129 {STATUS_WAS_UNLOCKED, -EIO, "STATUS_WAS_UNLOCKED"}, 129 {STATUS_WAS_UNLOCKED, -EIO, "STATUS_WAS_UNLOCKED"},
130 {STATUS_SERVICE_NOTIFICATION, -EIO, "STATUS_SERVICE_NOTIFICATION"}, 130 {STATUS_SERVICE_NOTIFICATION, -EIO, "STATUS_SERVICE_NOTIFICATION"},
131 {STATUS_WAS_LOCKED, -EIO, "STATUS_WAS_LOCKED"}, 131 {STATUS_WAS_LOCKED, -EIO, "STATUS_WAS_LOCKED"},
132 {STATUS_LOG_HARD_ERROR, -EIO, "STATUS_LOG_HARD_ERROR"}, 132 {STATUS_LOG_HARD_ERROR, -EIO, "STATUS_LOG_HARD_ERROR"},
133 {STATUS_ALREADY_WIN32, -EIO, "STATUS_ALREADY_WIN32"}, 133 {STATUS_ALREADY_WIN32, -EIO, "STATUS_ALREADY_WIN32"},
134 {STATUS_WX86_UNSIMULATE, -EIO, "STATUS_WX86_UNSIMULATE"}, 134 {STATUS_WX86_UNSIMULATE, -EIO, "STATUS_WX86_UNSIMULATE"},
135 {STATUS_WX86_CONTINUE, -EIO, "STATUS_WX86_CONTINUE"}, 135 {STATUS_WX86_CONTINUE, -EIO, "STATUS_WX86_CONTINUE"},
136 {STATUS_WX86_SINGLE_STEP, -EIO, "STATUS_WX86_SINGLE_STEP"}, 136 {STATUS_WX86_SINGLE_STEP, -EIO, "STATUS_WX86_SINGLE_STEP"},
137 {STATUS_WX86_BREAKPOINT, -EIO, "STATUS_WX86_BREAKPOINT"}, 137 {STATUS_WX86_BREAKPOINT, -EIO, "STATUS_WX86_BREAKPOINT"},
138 {STATUS_WX86_EXCEPTION_CONTINUE, -EIO, 138 {STATUS_WX86_EXCEPTION_CONTINUE, -EIO,
139 "STATUS_WX86_EXCEPTION_CONTINUE"}, 139 "STATUS_WX86_EXCEPTION_CONTINUE"},
140 {STATUS_WX86_EXCEPTION_LASTCHANCE, -EIO, 140 {STATUS_WX86_EXCEPTION_LASTCHANCE, -EIO,
141 "STATUS_WX86_EXCEPTION_LASTCHANCE"}, 141 "STATUS_WX86_EXCEPTION_LASTCHANCE"},
142 {STATUS_WX86_EXCEPTION_CHAIN, -EIO, "STATUS_WX86_EXCEPTION_CHAIN"}, 142 {STATUS_WX86_EXCEPTION_CHAIN, -EIO, "STATUS_WX86_EXCEPTION_CHAIN"},
143 {STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE, -EIO, 143 {STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE, -EIO,
144 "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"}, 144 "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE"},
145 {STATUS_NO_YIELD_PERFORMED, -EIO, "STATUS_NO_YIELD_PERFORMED"}, 145 {STATUS_NO_YIELD_PERFORMED, -EIO, "STATUS_NO_YIELD_PERFORMED"},
146 {STATUS_TIMER_RESUME_IGNORED, -EIO, "STATUS_TIMER_RESUME_IGNORED"}, 146 {STATUS_TIMER_RESUME_IGNORED, -EIO, "STATUS_TIMER_RESUME_IGNORED"},
147 {STATUS_ARBITRATION_UNHANDLED, -EIO, "STATUS_ARBITRATION_UNHANDLED"}, 147 {STATUS_ARBITRATION_UNHANDLED, -EIO, "STATUS_ARBITRATION_UNHANDLED"},
148 {STATUS_CARDBUS_NOT_SUPPORTED, -ENOSYS, "STATUS_CARDBUS_NOT_SUPPORTED"}, 148 {STATUS_CARDBUS_NOT_SUPPORTED, -ENOSYS, "STATUS_CARDBUS_NOT_SUPPORTED"},
149 {STATUS_WX86_CREATEWX86TIB, -EIO, "STATUS_WX86_CREATEWX86TIB"}, 149 {STATUS_WX86_CREATEWX86TIB, -EIO, "STATUS_WX86_CREATEWX86TIB"},
150 {STATUS_MP_PROCESSOR_MISMATCH, -EIO, "STATUS_MP_PROCESSOR_MISMATCH"}, 150 {STATUS_MP_PROCESSOR_MISMATCH, -EIO, "STATUS_MP_PROCESSOR_MISMATCH"},
151 {STATUS_HIBERNATED, -EIO, "STATUS_HIBERNATED"}, 151 {STATUS_HIBERNATED, -EIO, "STATUS_HIBERNATED"},
152 {STATUS_RESUME_HIBERNATION, -EIO, "STATUS_RESUME_HIBERNATION"}, 152 {STATUS_RESUME_HIBERNATION, -EIO, "STATUS_RESUME_HIBERNATION"},
153 {STATUS_FIRMWARE_UPDATED, -EIO, "STATUS_FIRMWARE_UPDATED"}, 153 {STATUS_FIRMWARE_UPDATED, -EIO, "STATUS_FIRMWARE_UPDATED"},
154 {STATUS_DRIVERS_LEAKING_LOCKED_PAGES, -EIO, 154 {STATUS_DRIVERS_LEAKING_LOCKED_PAGES, -EIO,
155 "STATUS_DRIVERS_LEAKING_LOCKED_PAGES"}, 155 "STATUS_DRIVERS_LEAKING_LOCKED_PAGES"},
156 {STATUS_MESSAGE_RETRIEVED, -EIO, "STATUS_MESSAGE_RETRIEVED"}, 156 {STATUS_MESSAGE_RETRIEVED, -EIO, "STATUS_MESSAGE_RETRIEVED"},
157 {STATUS_SYSTEM_POWERSTATE_TRANSITION, -EIO, 157 {STATUS_SYSTEM_POWERSTATE_TRANSITION, -EIO,
158 "STATUS_SYSTEM_POWERSTATE_TRANSITION"}, 158 "STATUS_SYSTEM_POWERSTATE_TRANSITION"},
159 {STATUS_ALPC_CHECK_COMPLETION_LIST, -EIO, 159 {STATUS_ALPC_CHECK_COMPLETION_LIST, -EIO,
160 "STATUS_ALPC_CHECK_COMPLETION_LIST"}, 160 "STATUS_ALPC_CHECK_COMPLETION_LIST"},
161 {STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, -EIO, 161 {STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION, -EIO,
162 "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION"}, 162 "STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION"},
163 {STATUS_ACCESS_AUDIT_BY_POLICY, -EIO, "STATUS_ACCESS_AUDIT_BY_POLICY"}, 163 {STATUS_ACCESS_AUDIT_BY_POLICY, -EIO, "STATUS_ACCESS_AUDIT_BY_POLICY"},
164 {STATUS_ABANDON_HIBERFILE, -EIO, "STATUS_ABANDON_HIBERFILE"}, 164 {STATUS_ABANDON_HIBERFILE, -EIO, "STATUS_ABANDON_HIBERFILE"},
165 {STATUS_BIZRULES_NOT_ENABLED, -EIO, "STATUS_BIZRULES_NOT_ENABLED"}, 165 {STATUS_BIZRULES_NOT_ENABLED, -EIO, "STATUS_BIZRULES_NOT_ENABLED"},
166 {STATUS_WAKE_SYSTEM, -EIO, "STATUS_WAKE_SYSTEM"}, 166 {STATUS_WAKE_SYSTEM, -EIO, "STATUS_WAKE_SYSTEM"},
167 {STATUS_DS_SHUTTING_DOWN, -EIO, "STATUS_DS_SHUTTING_DOWN"}, 167 {STATUS_DS_SHUTTING_DOWN, -EIO, "STATUS_DS_SHUTTING_DOWN"},
168 {DBG_REPLY_LATER, -EIO, "DBG_REPLY_LATER"}, 168 {DBG_REPLY_LATER, -EIO, "DBG_REPLY_LATER"},
169 {DBG_UNABLE_TO_PROVIDE_HANDLE, -EIO, "DBG_UNABLE_TO_PROVIDE_HANDLE"}, 169 {DBG_UNABLE_TO_PROVIDE_HANDLE, -EIO, "DBG_UNABLE_TO_PROVIDE_HANDLE"},
170 {DBG_TERMINATE_THREAD, -EIO, "DBG_TERMINATE_THREAD"}, 170 {DBG_TERMINATE_THREAD, -EIO, "DBG_TERMINATE_THREAD"},
171 {DBG_TERMINATE_PROCESS, -EIO, "DBG_TERMINATE_PROCESS"}, 171 {DBG_TERMINATE_PROCESS, -EIO, "DBG_TERMINATE_PROCESS"},
172 {DBG_CONTROL_C, -EIO, "DBG_CONTROL_C"}, 172 {DBG_CONTROL_C, -EIO, "DBG_CONTROL_C"},
173 {DBG_PRINTEXCEPTION_C, -EIO, "DBG_PRINTEXCEPTION_C"}, 173 {DBG_PRINTEXCEPTION_C, -EIO, "DBG_PRINTEXCEPTION_C"},
174 {DBG_RIPEXCEPTION, -EIO, "DBG_RIPEXCEPTION"}, 174 {DBG_RIPEXCEPTION, -EIO, "DBG_RIPEXCEPTION"},
175 {DBG_CONTROL_BREAK, -EIO, "DBG_CONTROL_BREAK"}, 175 {DBG_CONTROL_BREAK, -EIO, "DBG_CONTROL_BREAK"},
176 {DBG_COMMAND_EXCEPTION, -EIO, "DBG_COMMAND_EXCEPTION"}, 176 {DBG_COMMAND_EXCEPTION, -EIO, "DBG_COMMAND_EXCEPTION"},
177 {RPC_NT_UUID_LOCAL_ONLY, -EIO, "RPC_NT_UUID_LOCAL_ONLY"}, 177 {RPC_NT_UUID_LOCAL_ONLY, -EIO, "RPC_NT_UUID_LOCAL_ONLY"},
178 {RPC_NT_SEND_INCOMPLETE, -EIO, "RPC_NT_SEND_INCOMPLETE"}, 178 {RPC_NT_SEND_INCOMPLETE, -EIO, "RPC_NT_SEND_INCOMPLETE"},
179 {STATUS_CTX_CDM_CONNECT, -EIO, "STATUS_CTX_CDM_CONNECT"}, 179 {STATUS_CTX_CDM_CONNECT, -EIO, "STATUS_CTX_CDM_CONNECT"},
180 {STATUS_CTX_CDM_DISCONNECT, -EIO, "STATUS_CTX_CDM_DISCONNECT"}, 180 {STATUS_CTX_CDM_DISCONNECT, -EIO, "STATUS_CTX_CDM_DISCONNECT"},
181 {STATUS_SXS_RELEASE_ACTIVATION_CONTEXT, -EIO, 181 {STATUS_SXS_RELEASE_ACTIVATION_CONTEXT, -EIO,
182 "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT"}, 182 "STATUS_SXS_RELEASE_ACTIVATION_CONTEXT"},
183 {STATUS_RECOVERY_NOT_NEEDED, -EIO, "STATUS_RECOVERY_NOT_NEEDED"}, 183 {STATUS_RECOVERY_NOT_NEEDED, -EIO, "STATUS_RECOVERY_NOT_NEEDED"},
184 {STATUS_RM_ALREADY_STARTED, -EIO, "STATUS_RM_ALREADY_STARTED"}, 184 {STATUS_RM_ALREADY_STARTED, -EIO, "STATUS_RM_ALREADY_STARTED"},
185 {STATUS_LOG_NO_RESTART, -EIO, "STATUS_LOG_NO_RESTART"}, 185 {STATUS_LOG_NO_RESTART, -EIO, "STATUS_LOG_NO_RESTART"},
186 {STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST, -EIO, 186 {STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST, -EIO,
187 "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST"}, 187 "STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST"},
188 {STATUS_GRAPHICS_PARTIAL_DATA_POPULATED, -EIO, 188 {STATUS_GRAPHICS_PARTIAL_DATA_POPULATED, -EIO,
189 "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED"}, 189 "STATUS_GRAPHICS_PARTIAL_DATA_POPULATED"},
190 {STATUS_GRAPHICS_DRIVER_MISMATCH, -EIO, 190 {STATUS_GRAPHICS_DRIVER_MISMATCH, -EIO,
191 "STATUS_GRAPHICS_DRIVER_MISMATCH"}, 191 "STATUS_GRAPHICS_DRIVER_MISMATCH"},
192 {STATUS_GRAPHICS_MODE_NOT_PINNED, -EIO, 192 {STATUS_GRAPHICS_MODE_NOT_PINNED, -EIO,
193 "STATUS_GRAPHICS_MODE_NOT_PINNED"}, 193 "STATUS_GRAPHICS_MODE_NOT_PINNED"},
194 {STATUS_GRAPHICS_NO_PREFERRED_MODE, -EIO, 194 {STATUS_GRAPHICS_NO_PREFERRED_MODE, -EIO,
195 "STATUS_GRAPHICS_NO_PREFERRED_MODE"}, 195 "STATUS_GRAPHICS_NO_PREFERRED_MODE"},
196 {STATUS_GRAPHICS_DATASET_IS_EMPTY, -EIO, 196 {STATUS_GRAPHICS_DATASET_IS_EMPTY, -EIO,
197 "STATUS_GRAPHICS_DATASET_IS_EMPTY"}, 197 "STATUS_GRAPHICS_DATASET_IS_EMPTY"},
198 {STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET, -EIO, 198 {STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET, -EIO,
199 "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET"}, 199 "STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET"},
200 {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED, -EIO, 200 {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED, -EIO,
201 "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED"}, 201 "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED"},
202 {STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS, -EIO, 202 {STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS, -EIO,
203 "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS"}, 203 "STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS"},
204 {STATUS_GRAPHICS_LEADLINK_START_DEFERRED, -EIO, 204 {STATUS_GRAPHICS_LEADLINK_START_DEFERRED, -EIO,
205 "STATUS_GRAPHICS_LEADLINK_START_DEFERRED"}, 205 "STATUS_GRAPHICS_LEADLINK_START_DEFERRED"},
206 {STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY, -EIO, 206 {STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY, -EIO,
207 "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY"}, 207 "STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY"},
208 {STATUS_GRAPHICS_START_DEFERRED, -EIO, 208 {STATUS_GRAPHICS_START_DEFERRED, -EIO,
209 "STATUS_GRAPHICS_START_DEFERRED"}, 209 "STATUS_GRAPHICS_START_DEFERRED"},
210 {STATUS_NDIS_INDICATION_REQUIRED, -EIO, 210 {STATUS_NDIS_INDICATION_REQUIRED, -EIO,
211 "STATUS_NDIS_INDICATION_REQUIRED"}, 211 "STATUS_NDIS_INDICATION_REQUIRED"},
212 {STATUS_GUARD_PAGE_VIOLATION, -EIO, "STATUS_GUARD_PAGE_VIOLATION"}, 212 {STATUS_GUARD_PAGE_VIOLATION, -EIO, "STATUS_GUARD_PAGE_VIOLATION"},
213 {STATUS_DATATYPE_MISALIGNMENT, -EIO, "STATUS_DATATYPE_MISALIGNMENT"}, 213 {STATUS_DATATYPE_MISALIGNMENT, -EIO, "STATUS_DATATYPE_MISALIGNMENT"},
214 {STATUS_BREAKPOINT, -EIO, "STATUS_BREAKPOINT"}, 214 {STATUS_BREAKPOINT, -EIO, "STATUS_BREAKPOINT"},
215 {STATUS_SINGLE_STEP, -EIO, "STATUS_SINGLE_STEP"}, 215 {STATUS_SINGLE_STEP, -EIO, "STATUS_SINGLE_STEP"},
216 {STATUS_BUFFER_OVERFLOW, -EIO, "STATUS_BUFFER_OVERFLOW"}, 216 {STATUS_BUFFER_OVERFLOW, -EIO, "STATUS_BUFFER_OVERFLOW"},
217 {STATUS_NO_MORE_FILES, -EIO, "STATUS_NO_MORE_FILES"}, 217 {STATUS_NO_MORE_FILES, -EIO, "STATUS_NO_MORE_FILES"},
218 {STATUS_WAKE_SYSTEM_DEBUGGER, -EIO, "STATUS_WAKE_SYSTEM_DEBUGGER"}, 218 {STATUS_WAKE_SYSTEM_DEBUGGER, -EIO, "STATUS_WAKE_SYSTEM_DEBUGGER"},
219 {STATUS_HANDLES_CLOSED, -EIO, "STATUS_HANDLES_CLOSED"}, 219 {STATUS_HANDLES_CLOSED, -EIO, "STATUS_HANDLES_CLOSED"},
220 {STATUS_NO_INHERITANCE, -EIO, "STATUS_NO_INHERITANCE"}, 220 {STATUS_NO_INHERITANCE, -EIO, "STATUS_NO_INHERITANCE"},
221 {STATUS_GUID_SUBSTITUTION_MADE, -EIO, "STATUS_GUID_SUBSTITUTION_MADE"}, 221 {STATUS_GUID_SUBSTITUTION_MADE, -EIO, "STATUS_GUID_SUBSTITUTION_MADE"},
222 {STATUS_PARTIAL_COPY, -EIO, "STATUS_PARTIAL_COPY"}, 222 {STATUS_PARTIAL_COPY, -EIO, "STATUS_PARTIAL_COPY"},
223 {STATUS_DEVICE_PAPER_EMPTY, -EIO, "STATUS_DEVICE_PAPER_EMPTY"}, 223 {STATUS_DEVICE_PAPER_EMPTY, -EIO, "STATUS_DEVICE_PAPER_EMPTY"},
224 {STATUS_DEVICE_POWERED_OFF, -EIO, "STATUS_DEVICE_POWERED_OFF"}, 224 {STATUS_DEVICE_POWERED_OFF, -EIO, "STATUS_DEVICE_POWERED_OFF"},
225 {STATUS_DEVICE_OFF_LINE, -EIO, "STATUS_DEVICE_OFF_LINE"}, 225 {STATUS_DEVICE_OFF_LINE, -EIO, "STATUS_DEVICE_OFF_LINE"},
226 {STATUS_DEVICE_BUSY, -EBUSY, "STATUS_DEVICE_BUSY"}, 226 {STATUS_DEVICE_BUSY, -EBUSY, "STATUS_DEVICE_BUSY"},
227 {STATUS_NO_MORE_EAS, -EIO, "STATUS_NO_MORE_EAS"}, 227 {STATUS_NO_MORE_EAS, -EIO, "STATUS_NO_MORE_EAS"},
228 {STATUS_INVALID_EA_NAME, -EINVAL, "STATUS_INVALID_EA_NAME"}, 228 {STATUS_INVALID_EA_NAME, -EINVAL, "STATUS_INVALID_EA_NAME"},
229 {STATUS_EA_LIST_INCONSISTENT, -EIO, "STATUS_EA_LIST_INCONSISTENT"}, 229 {STATUS_EA_LIST_INCONSISTENT, -EIO, "STATUS_EA_LIST_INCONSISTENT"},
230 {STATUS_INVALID_EA_FLAG, -EINVAL, "STATUS_INVALID_EA_FLAG"}, 230 {STATUS_INVALID_EA_FLAG, -EINVAL, "STATUS_INVALID_EA_FLAG"},
231 {STATUS_VERIFY_REQUIRED, -EIO, "STATUS_VERIFY_REQUIRED"}, 231 {STATUS_VERIFY_REQUIRED, -EIO, "STATUS_VERIFY_REQUIRED"},
232 {STATUS_EXTRANEOUS_INFORMATION, -EIO, "STATUS_EXTRANEOUS_INFORMATION"}, 232 {STATUS_EXTRANEOUS_INFORMATION, -EIO, "STATUS_EXTRANEOUS_INFORMATION"},
233 {STATUS_RXACT_COMMIT_NECESSARY, -EIO, "STATUS_RXACT_COMMIT_NECESSARY"}, 233 {STATUS_RXACT_COMMIT_NECESSARY, -EIO, "STATUS_RXACT_COMMIT_NECESSARY"},
234 {STATUS_NO_MORE_ENTRIES, -EIO, "STATUS_NO_MORE_ENTRIES"}, 234 {STATUS_NO_MORE_ENTRIES, -EIO, "STATUS_NO_MORE_ENTRIES"},
235 {STATUS_FILEMARK_DETECTED, -EIO, "STATUS_FILEMARK_DETECTED"}, 235 {STATUS_FILEMARK_DETECTED, -EIO, "STATUS_FILEMARK_DETECTED"},
236 {STATUS_MEDIA_CHANGED, -EIO, "STATUS_MEDIA_CHANGED"}, 236 {STATUS_MEDIA_CHANGED, -EIO, "STATUS_MEDIA_CHANGED"},
237 {STATUS_BUS_RESET, -EIO, "STATUS_BUS_RESET"}, 237 {STATUS_BUS_RESET, -EIO, "STATUS_BUS_RESET"},
238 {STATUS_END_OF_MEDIA, -EIO, "STATUS_END_OF_MEDIA"}, 238 {STATUS_END_OF_MEDIA, -EIO, "STATUS_END_OF_MEDIA"},
239 {STATUS_BEGINNING_OF_MEDIA, -EIO, "STATUS_BEGINNING_OF_MEDIA"}, 239 {STATUS_BEGINNING_OF_MEDIA, -EIO, "STATUS_BEGINNING_OF_MEDIA"},
240 {STATUS_MEDIA_CHECK, -EIO, "STATUS_MEDIA_CHECK"}, 240 {STATUS_MEDIA_CHECK, -EIO, "STATUS_MEDIA_CHECK"},
241 {STATUS_SETMARK_DETECTED, -EIO, "STATUS_SETMARK_DETECTED"}, 241 {STATUS_SETMARK_DETECTED, -EIO, "STATUS_SETMARK_DETECTED"},
242 {STATUS_NO_DATA_DETECTED, -EIO, "STATUS_NO_DATA_DETECTED"}, 242 {STATUS_NO_DATA_DETECTED, -EIO, "STATUS_NO_DATA_DETECTED"},
243 {STATUS_REDIRECTOR_HAS_OPEN_HANDLES, -EIO, 243 {STATUS_REDIRECTOR_HAS_OPEN_HANDLES, -EIO,
244 "STATUS_REDIRECTOR_HAS_OPEN_HANDLES"}, 244 "STATUS_REDIRECTOR_HAS_OPEN_HANDLES"},
245 {STATUS_SERVER_HAS_OPEN_HANDLES, -EIO, 245 {STATUS_SERVER_HAS_OPEN_HANDLES, -EIO,
246 "STATUS_SERVER_HAS_OPEN_HANDLES"}, 246 "STATUS_SERVER_HAS_OPEN_HANDLES"},
247 {STATUS_ALREADY_DISCONNECTED, -EIO, "STATUS_ALREADY_DISCONNECTED"}, 247 {STATUS_ALREADY_DISCONNECTED, -EIO, "STATUS_ALREADY_DISCONNECTED"},
248 {STATUS_LONGJUMP, -EIO, "STATUS_LONGJUMP"}, 248 {STATUS_LONGJUMP, -EIO, "STATUS_LONGJUMP"},
249 {STATUS_CLEANER_CARTRIDGE_INSTALLED, -EIO, 249 {STATUS_CLEANER_CARTRIDGE_INSTALLED, -EIO,
250 "STATUS_CLEANER_CARTRIDGE_INSTALLED"}, 250 "STATUS_CLEANER_CARTRIDGE_INSTALLED"},
251 {STATUS_PLUGPLAY_QUERY_VETOED, -EIO, "STATUS_PLUGPLAY_QUERY_VETOED"}, 251 {STATUS_PLUGPLAY_QUERY_VETOED, -EIO, "STATUS_PLUGPLAY_QUERY_VETOED"},
252 {STATUS_UNWIND_CONSOLIDATE, -EIO, "STATUS_UNWIND_CONSOLIDATE"}, 252 {STATUS_UNWIND_CONSOLIDATE, -EIO, "STATUS_UNWIND_CONSOLIDATE"},
253 {STATUS_REGISTRY_HIVE_RECOVERED, -EIO, 253 {STATUS_REGISTRY_HIVE_RECOVERED, -EIO,
254 "STATUS_REGISTRY_HIVE_RECOVERED"}, 254 "STATUS_REGISTRY_HIVE_RECOVERED"},
255 {STATUS_DLL_MIGHT_BE_INSECURE, -EIO, "STATUS_DLL_MIGHT_BE_INSECURE"}, 255 {STATUS_DLL_MIGHT_BE_INSECURE, -EIO, "STATUS_DLL_MIGHT_BE_INSECURE"},
256 {STATUS_DLL_MIGHT_BE_INCOMPATIBLE, -EIO, 256 {STATUS_DLL_MIGHT_BE_INCOMPATIBLE, -EIO,
257 "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"}, 257 "STATUS_DLL_MIGHT_BE_INCOMPATIBLE"},
258 {STATUS_STOPPED_ON_SYMLINK, -EOPNOTSUPP, "STATUS_STOPPED_ON_SYMLINK"}, 258 {STATUS_STOPPED_ON_SYMLINK, -EOPNOTSUPP, "STATUS_STOPPED_ON_SYMLINK"},
259 {STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EOPNOTSUPP,
260 "STATUS_REPARSE_NOT_HANDLED"},
259 {STATUS_DEVICE_REQUIRES_CLEANING, -EIO, 261 {STATUS_DEVICE_REQUIRES_CLEANING, -EIO,
260 "STATUS_DEVICE_REQUIRES_CLEANING"}, 262 "STATUS_DEVICE_REQUIRES_CLEANING"},
261 {STATUS_DEVICE_DOOR_OPEN, -EIO, "STATUS_DEVICE_DOOR_OPEN"}, 263 {STATUS_DEVICE_DOOR_OPEN, -EIO, "STATUS_DEVICE_DOOR_OPEN"},
262 {STATUS_DATA_LOST_REPAIR, -EIO, "STATUS_DATA_LOST_REPAIR"}, 264 {STATUS_DATA_LOST_REPAIR, -EIO, "STATUS_DATA_LOST_REPAIR"},
263 {DBG_EXCEPTION_NOT_HANDLED, -EIO, "DBG_EXCEPTION_NOT_HANDLED"}, 265 {DBG_EXCEPTION_NOT_HANDLED, -EIO, "DBG_EXCEPTION_NOT_HANDLED"},
264 {STATUS_CLUSTER_NODE_ALREADY_UP, -EIO, 266 {STATUS_CLUSTER_NODE_ALREADY_UP, -EIO,
265 "STATUS_CLUSTER_NODE_ALREADY_UP"}, 267 "STATUS_CLUSTER_NODE_ALREADY_UP"},
266 {STATUS_CLUSTER_NODE_ALREADY_DOWN, -EIO, 268 {STATUS_CLUSTER_NODE_ALREADY_DOWN, -EIO,
267 "STATUS_CLUSTER_NODE_ALREADY_DOWN"}, 269 "STATUS_CLUSTER_NODE_ALREADY_DOWN"},
268 {STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, -EIO, 270 {STATUS_CLUSTER_NETWORK_ALREADY_ONLINE, -EIO,
269 "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"}, 271 "STATUS_CLUSTER_NETWORK_ALREADY_ONLINE"},
270 {STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, -EIO, 272 {STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE, -EIO,
271 "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"}, 273 "STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE"},
272 {STATUS_CLUSTER_NODE_ALREADY_MEMBER, -EIO, 274 {STATUS_CLUSTER_NODE_ALREADY_MEMBER, -EIO,
273 "STATUS_CLUSTER_NODE_ALREADY_MEMBER"}, 275 "STATUS_CLUSTER_NODE_ALREADY_MEMBER"},
274 {STATUS_COULD_NOT_RESIZE_LOG, -EIO, "STATUS_COULD_NOT_RESIZE_LOG"}, 276 {STATUS_COULD_NOT_RESIZE_LOG, -EIO, "STATUS_COULD_NOT_RESIZE_LOG"},
275 {STATUS_NO_TXF_METADATA, -EIO, "STATUS_NO_TXF_METADATA"}, 277 {STATUS_NO_TXF_METADATA, -EIO, "STATUS_NO_TXF_METADATA"},
276 {STATUS_CANT_RECOVER_WITH_HANDLE_OPEN, -EIO, 278 {STATUS_CANT_RECOVER_WITH_HANDLE_OPEN, -EIO,
277 "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN"}, 279 "STATUS_CANT_RECOVER_WITH_HANDLE_OPEN"},
278 {STATUS_TXF_METADATA_ALREADY_PRESENT, -EIO, 280 {STATUS_TXF_METADATA_ALREADY_PRESENT, -EIO,
279 "STATUS_TXF_METADATA_ALREADY_PRESENT"}, 281 "STATUS_TXF_METADATA_ALREADY_PRESENT"},
280 {STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, -EIO, 282 {STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET, -EIO,
281 "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET"}, 283 "STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET"},
282 {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED, -EIO, 284 {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED, -EIO,
283 "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED"}, 285 "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED"},
284 {STATUS_FLT_BUFFER_TOO_SMALL, -ENOBUFS, "STATUS_FLT_BUFFER_TOO_SMALL"}, 286 {STATUS_FLT_BUFFER_TOO_SMALL, -ENOBUFS, "STATUS_FLT_BUFFER_TOO_SMALL"},
285 {STATUS_FVE_PARTIAL_METADATA, -EIO, "STATUS_FVE_PARTIAL_METADATA"}, 287 {STATUS_FVE_PARTIAL_METADATA, -EIO, "STATUS_FVE_PARTIAL_METADATA"},
286 {STATUS_UNSUCCESSFUL, -EIO, "STATUS_UNSUCCESSFUL"}, 288 {STATUS_UNSUCCESSFUL, -EIO, "STATUS_UNSUCCESSFUL"},
287 {STATUS_NOT_IMPLEMENTED, -ENOSYS, "STATUS_NOT_IMPLEMENTED"}, 289 {STATUS_NOT_IMPLEMENTED, -ENOSYS, "STATUS_NOT_IMPLEMENTED"},
288 {STATUS_INVALID_INFO_CLASS, -EIO, "STATUS_INVALID_INFO_CLASS"}, 290 {STATUS_INVALID_INFO_CLASS, -EIO, "STATUS_INVALID_INFO_CLASS"},
289 {STATUS_INFO_LENGTH_MISMATCH, -EIO, "STATUS_INFO_LENGTH_MISMATCH"}, 291 {STATUS_INFO_LENGTH_MISMATCH, -EIO, "STATUS_INFO_LENGTH_MISMATCH"},
290 {STATUS_ACCESS_VIOLATION, -EACCES, "STATUS_ACCESS_VIOLATION"}, 292 {STATUS_ACCESS_VIOLATION, -EACCES, "STATUS_ACCESS_VIOLATION"},
291 {STATUS_IN_PAGE_ERROR, -EFAULT, "STATUS_IN_PAGE_ERROR"}, 293 {STATUS_IN_PAGE_ERROR, -EFAULT, "STATUS_IN_PAGE_ERROR"},
292 {STATUS_PAGEFILE_QUOTA, -EDQUOT, "STATUS_PAGEFILE_QUOTA"}, 294 {STATUS_PAGEFILE_QUOTA, -EDQUOT, "STATUS_PAGEFILE_QUOTA"},
293 {STATUS_INVALID_HANDLE, -EBADF, "STATUS_INVALID_HANDLE"}, 295 {STATUS_INVALID_HANDLE, -EBADF, "STATUS_INVALID_HANDLE"},
294 {STATUS_BAD_INITIAL_STACK, -EIO, "STATUS_BAD_INITIAL_STACK"}, 296 {STATUS_BAD_INITIAL_STACK, -EIO, "STATUS_BAD_INITIAL_STACK"},
295 {STATUS_BAD_INITIAL_PC, -EIO, "STATUS_BAD_INITIAL_PC"}, 297 {STATUS_BAD_INITIAL_PC, -EIO, "STATUS_BAD_INITIAL_PC"},
296 {STATUS_INVALID_CID, -EIO, "STATUS_INVALID_CID"}, 298 {STATUS_INVALID_CID, -EIO, "STATUS_INVALID_CID"},
297 {STATUS_TIMER_NOT_CANCELED, -EIO, "STATUS_TIMER_NOT_CANCELED"}, 299 {STATUS_TIMER_NOT_CANCELED, -EIO, "STATUS_TIMER_NOT_CANCELED"},
298 {STATUS_INVALID_PARAMETER, -EINVAL, "STATUS_INVALID_PARAMETER"}, 300 {STATUS_INVALID_PARAMETER, -EINVAL, "STATUS_INVALID_PARAMETER"},
299 {STATUS_NO_SUCH_DEVICE, -ENODEV, "STATUS_NO_SUCH_DEVICE"}, 301 {STATUS_NO_SUCH_DEVICE, -ENODEV, "STATUS_NO_SUCH_DEVICE"},
300 {STATUS_NO_SUCH_FILE, -ENOENT, "STATUS_NO_SUCH_FILE"}, 302 {STATUS_NO_SUCH_FILE, -ENOENT, "STATUS_NO_SUCH_FILE"},
301 {STATUS_INVALID_DEVICE_REQUEST, -EIO, "STATUS_INVALID_DEVICE_REQUEST"}, 303 {STATUS_INVALID_DEVICE_REQUEST, -EIO, "STATUS_INVALID_DEVICE_REQUEST"},
302 {STATUS_END_OF_FILE, -ENODATA, "STATUS_END_OF_FILE"}, 304 {STATUS_END_OF_FILE, -ENODATA, "STATUS_END_OF_FILE"},
303 {STATUS_WRONG_VOLUME, -EIO, "STATUS_WRONG_VOLUME"}, 305 {STATUS_WRONG_VOLUME, -EIO, "STATUS_WRONG_VOLUME"},
304 {STATUS_NO_MEDIA_IN_DEVICE, -EIO, "STATUS_NO_MEDIA_IN_DEVICE"}, 306 {STATUS_NO_MEDIA_IN_DEVICE, -EIO, "STATUS_NO_MEDIA_IN_DEVICE"},
305 {STATUS_UNRECOGNIZED_MEDIA, -EIO, "STATUS_UNRECOGNIZED_MEDIA"}, 307 {STATUS_UNRECOGNIZED_MEDIA, -EIO, "STATUS_UNRECOGNIZED_MEDIA"},
306 {STATUS_NONEXISTENT_SECTOR, -EIO, "STATUS_NONEXISTENT_SECTOR"}, 308 {STATUS_NONEXISTENT_SECTOR, -EIO, "STATUS_NONEXISTENT_SECTOR"},
307 {STATUS_MORE_PROCESSING_REQUIRED, -EIO, 309 {STATUS_MORE_PROCESSING_REQUIRED, -EIO,
308 "STATUS_MORE_PROCESSING_REQUIRED"}, 310 "STATUS_MORE_PROCESSING_REQUIRED"},
309 {STATUS_NO_MEMORY, -EREMOTEIO, "STATUS_NO_MEMORY"}, 311 {STATUS_NO_MEMORY, -EREMOTEIO, "STATUS_NO_MEMORY"},
310 {STATUS_CONFLICTING_ADDRESSES, -EADDRINUSE, 312 {STATUS_CONFLICTING_ADDRESSES, -EADDRINUSE,
311 "STATUS_CONFLICTING_ADDRESSES"}, 313 "STATUS_CONFLICTING_ADDRESSES"},
312 {STATUS_NOT_MAPPED_VIEW, -EIO, "STATUS_NOT_MAPPED_VIEW"}, 314 {STATUS_NOT_MAPPED_VIEW, -EIO, "STATUS_NOT_MAPPED_VIEW"},
313 {STATUS_UNABLE_TO_FREE_VM, -EIO, "STATUS_UNABLE_TO_FREE_VM"}, 315 {STATUS_UNABLE_TO_FREE_VM, -EIO, "STATUS_UNABLE_TO_FREE_VM"},
314 {STATUS_UNABLE_TO_DELETE_SECTION, -EIO, 316 {STATUS_UNABLE_TO_DELETE_SECTION, -EIO,
315 "STATUS_UNABLE_TO_DELETE_SECTION"}, 317 "STATUS_UNABLE_TO_DELETE_SECTION"},
316 {STATUS_INVALID_SYSTEM_SERVICE, -EIO, "STATUS_INVALID_SYSTEM_SERVICE"}, 318 {STATUS_INVALID_SYSTEM_SERVICE, -EIO, "STATUS_INVALID_SYSTEM_SERVICE"},
317 {STATUS_ILLEGAL_INSTRUCTION, -EIO, "STATUS_ILLEGAL_INSTRUCTION"}, 319 {STATUS_ILLEGAL_INSTRUCTION, -EIO, "STATUS_ILLEGAL_INSTRUCTION"},
318 {STATUS_INVALID_LOCK_SEQUENCE, -EIO, "STATUS_INVALID_LOCK_SEQUENCE"}, 320 {STATUS_INVALID_LOCK_SEQUENCE, -EIO, "STATUS_INVALID_LOCK_SEQUENCE"},
319 {STATUS_INVALID_VIEW_SIZE, -EIO, "STATUS_INVALID_VIEW_SIZE"}, 321 {STATUS_INVALID_VIEW_SIZE, -EIO, "STATUS_INVALID_VIEW_SIZE"},
320 {STATUS_INVALID_FILE_FOR_SECTION, -EIO, 322 {STATUS_INVALID_FILE_FOR_SECTION, -EIO,
321 "STATUS_INVALID_FILE_FOR_SECTION"}, 323 "STATUS_INVALID_FILE_FOR_SECTION"},
322 {STATUS_ALREADY_COMMITTED, -EIO, "STATUS_ALREADY_COMMITTED"}, 324 {STATUS_ALREADY_COMMITTED, -EIO, "STATUS_ALREADY_COMMITTED"},
323 {STATUS_ACCESS_DENIED, -EACCES, "STATUS_ACCESS_DENIED"}, 325 {STATUS_ACCESS_DENIED, -EACCES, "STATUS_ACCESS_DENIED"},
324 {STATUS_BUFFER_TOO_SMALL, -EIO, "STATUS_BUFFER_TOO_SMALL"}, 326 {STATUS_BUFFER_TOO_SMALL, -EIO, "STATUS_BUFFER_TOO_SMALL"},
325 {STATUS_OBJECT_TYPE_MISMATCH, -EIO, "STATUS_OBJECT_TYPE_MISMATCH"}, 327 {STATUS_OBJECT_TYPE_MISMATCH, -EIO, "STATUS_OBJECT_TYPE_MISMATCH"},
326 {STATUS_NONCONTINUABLE_EXCEPTION, -EIO, 328 {STATUS_NONCONTINUABLE_EXCEPTION, -EIO,
327 "STATUS_NONCONTINUABLE_EXCEPTION"}, 329 "STATUS_NONCONTINUABLE_EXCEPTION"},
328 {STATUS_INVALID_DISPOSITION, -EIO, "STATUS_INVALID_DISPOSITION"}, 330 {STATUS_INVALID_DISPOSITION, -EIO, "STATUS_INVALID_DISPOSITION"},
329 {STATUS_UNWIND, -EIO, "STATUS_UNWIND"}, 331 {STATUS_UNWIND, -EIO, "STATUS_UNWIND"},
330 {STATUS_BAD_STACK, -EIO, "STATUS_BAD_STACK"}, 332 {STATUS_BAD_STACK, -EIO, "STATUS_BAD_STACK"},
331 {STATUS_INVALID_UNWIND_TARGET, -EIO, "STATUS_INVALID_UNWIND_TARGET"}, 333 {STATUS_INVALID_UNWIND_TARGET, -EIO, "STATUS_INVALID_UNWIND_TARGET"},
332 {STATUS_NOT_LOCKED, -EIO, "STATUS_NOT_LOCKED"}, 334 {STATUS_NOT_LOCKED, -EIO, "STATUS_NOT_LOCKED"},
333 {STATUS_PARITY_ERROR, -EIO, "STATUS_PARITY_ERROR"}, 335 {STATUS_PARITY_ERROR, -EIO, "STATUS_PARITY_ERROR"},
334 {STATUS_UNABLE_TO_DECOMMIT_VM, -EIO, "STATUS_UNABLE_TO_DECOMMIT_VM"}, 336 {STATUS_UNABLE_TO_DECOMMIT_VM, -EIO, "STATUS_UNABLE_TO_DECOMMIT_VM"},
335 {STATUS_NOT_COMMITTED, -EIO, "STATUS_NOT_COMMITTED"}, 337 {STATUS_NOT_COMMITTED, -EIO, "STATUS_NOT_COMMITTED"},
336 {STATUS_INVALID_PORT_ATTRIBUTES, -EIO, 338 {STATUS_INVALID_PORT_ATTRIBUTES, -EIO,
337 "STATUS_INVALID_PORT_ATTRIBUTES"}, 339 "STATUS_INVALID_PORT_ATTRIBUTES"},
338 {STATUS_PORT_MESSAGE_TOO_LONG, -EIO, "STATUS_PORT_MESSAGE_TOO_LONG"}, 340 {STATUS_PORT_MESSAGE_TOO_LONG, -EIO, "STATUS_PORT_MESSAGE_TOO_LONG"},
339 {STATUS_INVALID_PARAMETER_MIX, -EINVAL, "STATUS_INVALID_PARAMETER_MIX"}, 341 {STATUS_INVALID_PARAMETER_MIX, -EINVAL, "STATUS_INVALID_PARAMETER_MIX"},
340 {STATUS_INVALID_QUOTA_LOWER, -EIO, "STATUS_INVALID_QUOTA_LOWER"}, 342 {STATUS_INVALID_QUOTA_LOWER, -EIO, "STATUS_INVALID_QUOTA_LOWER"},
341 {STATUS_DISK_CORRUPT_ERROR, -EIO, "STATUS_DISK_CORRUPT_ERROR"}, 343 {STATUS_DISK_CORRUPT_ERROR, -EIO, "STATUS_DISK_CORRUPT_ERROR"},
342 {STATUS_OBJECT_NAME_INVALID, -ENOENT, "STATUS_OBJECT_NAME_INVALID"}, 344 {STATUS_OBJECT_NAME_INVALID, -ENOENT, "STATUS_OBJECT_NAME_INVALID"},
343 {STATUS_OBJECT_NAME_NOT_FOUND, -ENOENT, "STATUS_OBJECT_NAME_NOT_FOUND"}, 345 {STATUS_OBJECT_NAME_NOT_FOUND, -ENOENT, "STATUS_OBJECT_NAME_NOT_FOUND"},
344 {STATUS_OBJECT_NAME_COLLISION, -EEXIST, "STATUS_OBJECT_NAME_COLLISION"}, 346 {STATUS_OBJECT_NAME_COLLISION, -EEXIST, "STATUS_OBJECT_NAME_COLLISION"},
345 {STATUS_PORT_DISCONNECTED, -EIO, "STATUS_PORT_DISCONNECTED"}, 347 {STATUS_PORT_DISCONNECTED, -EIO, "STATUS_PORT_DISCONNECTED"},
346 {STATUS_DEVICE_ALREADY_ATTACHED, -EIO, 348 {STATUS_DEVICE_ALREADY_ATTACHED, -EIO,
347 "STATUS_DEVICE_ALREADY_ATTACHED"}, 349 "STATUS_DEVICE_ALREADY_ATTACHED"},
348 {STATUS_OBJECT_PATH_INVALID, -ENOTDIR, "STATUS_OBJECT_PATH_INVALID"}, 350 {STATUS_OBJECT_PATH_INVALID, -ENOTDIR, "STATUS_OBJECT_PATH_INVALID"},
349 {STATUS_OBJECT_PATH_NOT_FOUND, -ENOENT, "STATUS_OBJECT_PATH_NOT_FOUND"}, 351 {STATUS_OBJECT_PATH_NOT_FOUND, -ENOENT, "STATUS_OBJECT_PATH_NOT_FOUND"},
350 {STATUS_OBJECT_PATH_SYNTAX_BAD, -EIO, "STATUS_OBJECT_PATH_SYNTAX_BAD"}, 352 {STATUS_OBJECT_PATH_SYNTAX_BAD, -EIO, "STATUS_OBJECT_PATH_SYNTAX_BAD"},
351 {STATUS_DATA_OVERRUN, -EIO, "STATUS_DATA_OVERRUN"}, 353 {STATUS_DATA_OVERRUN, -EIO, "STATUS_DATA_OVERRUN"},
352 {STATUS_DATA_LATE_ERROR, -EIO, "STATUS_DATA_LATE_ERROR"}, 354 {STATUS_DATA_LATE_ERROR, -EIO, "STATUS_DATA_LATE_ERROR"},
353 {STATUS_DATA_ERROR, -EIO, "STATUS_DATA_ERROR"}, 355 {STATUS_DATA_ERROR, -EIO, "STATUS_DATA_ERROR"},
354 {STATUS_CRC_ERROR, -EIO, "STATUS_CRC_ERROR"}, 356 {STATUS_CRC_ERROR, -EIO, "STATUS_CRC_ERROR"},
355 {STATUS_SECTION_TOO_BIG, -EIO, "STATUS_SECTION_TOO_BIG"}, 357 {STATUS_SECTION_TOO_BIG, -EIO, "STATUS_SECTION_TOO_BIG"},
356 {STATUS_PORT_CONNECTION_REFUSED, -ECONNREFUSED, 358 {STATUS_PORT_CONNECTION_REFUSED, -ECONNREFUSED,
357 "STATUS_PORT_CONNECTION_REFUSED"}, 359 "STATUS_PORT_CONNECTION_REFUSED"},
358 {STATUS_INVALID_PORT_HANDLE, -EIO, "STATUS_INVALID_PORT_HANDLE"}, 360 {STATUS_INVALID_PORT_HANDLE, -EIO, "STATUS_INVALID_PORT_HANDLE"},
359 {STATUS_SHARING_VIOLATION, -EBUSY, "STATUS_SHARING_VIOLATION"}, 361 {STATUS_SHARING_VIOLATION, -EBUSY, "STATUS_SHARING_VIOLATION"},
360 {STATUS_QUOTA_EXCEEDED, -EDQUOT, "STATUS_QUOTA_EXCEEDED"}, 362 {STATUS_QUOTA_EXCEEDED, -EDQUOT, "STATUS_QUOTA_EXCEEDED"},
361 {STATUS_INVALID_PAGE_PROTECTION, -EIO, 363 {STATUS_INVALID_PAGE_PROTECTION, -EIO,
362 "STATUS_INVALID_PAGE_PROTECTION"}, 364 "STATUS_INVALID_PAGE_PROTECTION"},
363 {STATUS_MUTANT_NOT_OWNED, -EIO, "STATUS_MUTANT_NOT_OWNED"}, 365 {STATUS_MUTANT_NOT_OWNED, -EIO, "STATUS_MUTANT_NOT_OWNED"},
364 {STATUS_SEMAPHORE_LIMIT_EXCEEDED, -EIO, 366 {STATUS_SEMAPHORE_LIMIT_EXCEEDED, -EIO,
365 "STATUS_SEMAPHORE_LIMIT_EXCEEDED"}, 367 "STATUS_SEMAPHORE_LIMIT_EXCEEDED"},
366 {STATUS_PORT_ALREADY_SET, -EIO, "STATUS_PORT_ALREADY_SET"}, 368 {STATUS_PORT_ALREADY_SET, -EIO, "STATUS_PORT_ALREADY_SET"},
367 {STATUS_SECTION_NOT_IMAGE, -EIO, "STATUS_SECTION_NOT_IMAGE"}, 369 {STATUS_SECTION_NOT_IMAGE, -EIO, "STATUS_SECTION_NOT_IMAGE"},
368 {STATUS_SUSPEND_COUNT_EXCEEDED, -EIO, "STATUS_SUSPEND_COUNT_EXCEEDED"}, 370 {STATUS_SUSPEND_COUNT_EXCEEDED, -EIO, "STATUS_SUSPEND_COUNT_EXCEEDED"},
369 {STATUS_THREAD_IS_TERMINATING, -EIO, "STATUS_THREAD_IS_TERMINATING"}, 371 {STATUS_THREAD_IS_TERMINATING, -EIO, "STATUS_THREAD_IS_TERMINATING"},
370 {STATUS_BAD_WORKING_SET_LIMIT, -EIO, "STATUS_BAD_WORKING_SET_LIMIT"}, 372 {STATUS_BAD_WORKING_SET_LIMIT, -EIO, "STATUS_BAD_WORKING_SET_LIMIT"},
371 {STATUS_INCOMPATIBLE_FILE_MAP, -EIO, "STATUS_INCOMPATIBLE_FILE_MAP"}, 373 {STATUS_INCOMPATIBLE_FILE_MAP, -EIO, "STATUS_INCOMPATIBLE_FILE_MAP"},
372 {STATUS_SECTION_PROTECTION, -EIO, "STATUS_SECTION_PROTECTION"}, 374 {STATUS_SECTION_PROTECTION, -EIO, "STATUS_SECTION_PROTECTION"},
373 {STATUS_EAS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_EAS_NOT_SUPPORTED"}, 375 {STATUS_EAS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_EAS_NOT_SUPPORTED"},
374 {STATUS_EA_TOO_LARGE, -EIO, "STATUS_EA_TOO_LARGE"}, 376 {STATUS_EA_TOO_LARGE, -EIO, "STATUS_EA_TOO_LARGE"},
375 {STATUS_NONEXISTENT_EA_ENTRY, -EIO, "STATUS_NONEXISTENT_EA_ENTRY"}, 377 {STATUS_NONEXISTENT_EA_ENTRY, -EIO, "STATUS_NONEXISTENT_EA_ENTRY"},
376 {STATUS_NO_EAS_ON_FILE, -ENODATA, "STATUS_NO_EAS_ON_FILE"}, 378 {STATUS_NO_EAS_ON_FILE, -ENODATA, "STATUS_NO_EAS_ON_FILE"},
377 {STATUS_EA_CORRUPT_ERROR, -EIO, "STATUS_EA_CORRUPT_ERROR"}, 379 {STATUS_EA_CORRUPT_ERROR, -EIO, "STATUS_EA_CORRUPT_ERROR"},
378 {STATUS_FILE_LOCK_CONFLICT, -EIO, "STATUS_FILE_LOCK_CONFLICT"}, 380 {STATUS_FILE_LOCK_CONFLICT, -EIO, "STATUS_FILE_LOCK_CONFLICT"},
379 {STATUS_LOCK_NOT_GRANTED, -EIO, "STATUS_LOCK_NOT_GRANTED"}, 381 {STATUS_LOCK_NOT_GRANTED, -EIO, "STATUS_LOCK_NOT_GRANTED"},
380 {STATUS_DELETE_PENDING, -ENOENT, "STATUS_DELETE_PENDING"}, 382 {STATUS_DELETE_PENDING, -ENOENT, "STATUS_DELETE_PENDING"},
381 {STATUS_CTL_FILE_NOT_SUPPORTED, -ENOSYS, 383 {STATUS_CTL_FILE_NOT_SUPPORTED, -ENOSYS,
382 "STATUS_CTL_FILE_NOT_SUPPORTED"}, 384 "STATUS_CTL_FILE_NOT_SUPPORTED"},
383 {STATUS_UNKNOWN_REVISION, -EIO, "STATUS_UNKNOWN_REVISION"}, 385 {STATUS_UNKNOWN_REVISION, -EIO, "STATUS_UNKNOWN_REVISION"},
384 {STATUS_REVISION_MISMATCH, -EIO, "STATUS_REVISION_MISMATCH"}, 386 {STATUS_REVISION_MISMATCH, -EIO, "STATUS_REVISION_MISMATCH"},
385 {STATUS_INVALID_OWNER, -EIO, "STATUS_INVALID_OWNER"}, 387 {STATUS_INVALID_OWNER, -EIO, "STATUS_INVALID_OWNER"},
386 {STATUS_INVALID_PRIMARY_GROUP, -EIO, "STATUS_INVALID_PRIMARY_GROUP"}, 388 {STATUS_INVALID_PRIMARY_GROUP, -EIO, "STATUS_INVALID_PRIMARY_GROUP"},
387 {STATUS_NO_IMPERSONATION_TOKEN, -EIO, "STATUS_NO_IMPERSONATION_TOKEN"}, 389 {STATUS_NO_IMPERSONATION_TOKEN, -EIO, "STATUS_NO_IMPERSONATION_TOKEN"},
388 {STATUS_CANT_DISABLE_MANDATORY, -EIO, "STATUS_CANT_DISABLE_MANDATORY"}, 390 {STATUS_CANT_DISABLE_MANDATORY, -EIO, "STATUS_CANT_DISABLE_MANDATORY"},
389 {STATUS_NO_LOGON_SERVERS, -EIO, "STATUS_NO_LOGON_SERVERS"}, 391 {STATUS_NO_LOGON_SERVERS, -EIO, "STATUS_NO_LOGON_SERVERS"},
390 {STATUS_NO_SUCH_LOGON_SESSION, -EIO, "STATUS_NO_SUCH_LOGON_SESSION"}, 392 {STATUS_NO_SUCH_LOGON_SESSION, -EIO, "STATUS_NO_SUCH_LOGON_SESSION"},
391 {STATUS_NO_SUCH_PRIVILEGE, -EIO, "STATUS_NO_SUCH_PRIVILEGE"}, 393 {STATUS_NO_SUCH_PRIVILEGE, -EIO, "STATUS_NO_SUCH_PRIVILEGE"},
392 {STATUS_PRIVILEGE_NOT_HELD, -EIO, "STATUS_PRIVILEGE_NOT_HELD"}, 394 {STATUS_PRIVILEGE_NOT_HELD, -EIO, "STATUS_PRIVILEGE_NOT_HELD"},
393 {STATUS_INVALID_ACCOUNT_NAME, -EIO, "STATUS_INVALID_ACCOUNT_NAME"}, 395 {STATUS_INVALID_ACCOUNT_NAME, -EIO, "STATUS_INVALID_ACCOUNT_NAME"},
394 {STATUS_USER_EXISTS, -EIO, "STATUS_USER_EXISTS"}, 396 {STATUS_USER_EXISTS, -EIO, "STATUS_USER_EXISTS"},
395 {STATUS_NO_SUCH_USER, -EIO, "STATUS_NO_SUCH_USER"}, 397 {STATUS_NO_SUCH_USER, -EIO, "STATUS_NO_SUCH_USER"},
396 {STATUS_GROUP_EXISTS, -EIO, "STATUS_GROUP_EXISTS"}, 398 {STATUS_GROUP_EXISTS, -EIO, "STATUS_GROUP_EXISTS"},
397 {STATUS_NO_SUCH_GROUP, -EIO, "STATUS_NO_SUCH_GROUP"}, 399 {STATUS_NO_SUCH_GROUP, -EIO, "STATUS_NO_SUCH_GROUP"},
398 {STATUS_MEMBER_IN_GROUP, -EIO, "STATUS_MEMBER_IN_GROUP"}, 400 {STATUS_MEMBER_IN_GROUP, -EIO, "STATUS_MEMBER_IN_GROUP"},
399 {STATUS_MEMBER_NOT_IN_GROUP, -EIO, "STATUS_MEMBER_NOT_IN_GROUP"}, 401 {STATUS_MEMBER_NOT_IN_GROUP, -EIO, "STATUS_MEMBER_NOT_IN_GROUP"},
400 {STATUS_LAST_ADMIN, -EIO, "STATUS_LAST_ADMIN"}, 402 {STATUS_LAST_ADMIN, -EIO, "STATUS_LAST_ADMIN"},
401 {STATUS_WRONG_PASSWORD, -EACCES, "STATUS_WRONG_PASSWORD"}, 403 {STATUS_WRONG_PASSWORD, -EACCES, "STATUS_WRONG_PASSWORD"},
402 {STATUS_ILL_FORMED_PASSWORD, -EINVAL, "STATUS_ILL_FORMED_PASSWORD"}, 404 {STATUS_ILL_FORMED_PASSWORD, -EINVAL, "STATUS_ILL_FORMED_PASSWORD"},
403 {STATUS_PASSWORD_RESTRICTION, -EACCES, "STATUS_PASSWORD_RESTRICTION"}, 405 {STATUS_PASSWORD_RESTRICTION, -EACCES, "STATUS_PASSWORD_RESTRICTION"},
404 {STATUS_LOGON_FAILURE, -EACCES, "STATUS_LOGON_FAILURE"}, 406 {STATUS_LOGON_FAILURE, -EACCES, "STATUS_LOGON_FAILURE"},
405 {STATUS_ACCOUNT_RESTRICTION, -EACCES, "STATUS_ACCOUNT_RESTRICTION"}, 407 {STATUS_ACCOUNT_RESTRICTION, -EACCES, "STATUS_ACCOUNT_RESTRICTION"},
406 {STATUS_INVALID_LOGON_HOURS, -EACCES, "STATUS_INVALID_LOGON_HOURS"}, 408 {STATUS_INVALID_LOGON_HOURS, -EACCES, "STATUS_INVALID_LOGON_HOURS"},
407 {STATUS_INVALID_WORKSTATION, -EACCES, "STATUS_INVALID_WORKSTATION"}, 409 {STATUS_INVALID_WORKSTATION, -EACCES, "STATUS_INVALID_WORKSTATION"},
408 {STATUS_PASSWORD_EXPIRED, -EKEYEXPIRED, "STATUS_PASSWORD_EXPIRED"}, 410 {STATUS_PASSWORD_EXPIRED, -EKEYEXPIRED, "STATUS_PASSWORD_EXPIRED"},
409 {STATUS_ACCOUNT_DISABLED, -EKEYREVOKED, "STATUS_ACCOUNT_DISABLED"}, 411 {STATUS_ACCOUNT_DISABLED, -EKEYREVOKED, "STATUS_ACCOUNT_DISABLED"},
410 {STATUS_NONE_MAPPED, -EIO, "STATUS_NONE_MAPPED"}, 412 {STATUS_NONE_MAPPED, -EIO, "STATUS_NONE_MAPPED"},
411 {STATUS_TOO_MANY_LUIDS_REQUESTED, -EIO, 413 {STATUS_TOO_MANY_LUIDS_REQUESTED, -EIO,
412 "STATUS_TOO_MANY_LUIDS_REQUESTED"}, 414 "STATUS_TOO_MANY_LUIDS_REQUESTED"},
413 {STATUS_LUIDS_EXHAUSTED, -EIO, "STATUS_LUIDS_EXHAUSTED"}, 415 {STATUS_LUIDS_EXHAUSTED, -EIO, "STATUS_LUIDS_EXHAUSTED"},
414 {STATUS_INVALID_SUB_AUTHORITY, -EIO, "STATUS_INVALID_SUB_AUTHORITY"}, 416 {STATUS_INVALID_SUB_AUTHORITY, -EIO, "STATUS_INVALID_SUB_AUTHORITY"},
415 {STATUS_INVALID_ACL, -EIO, "STATUS_INVALID_ACL"}, 417 {STATUS_INVALID_ACL, -EIO, "STATUS_INVALID_ACL"},
416 {STATUS_INVALID_SID, -EIO, "STATUS_INVALID_SID"}, 418 {STATUS_INVALID_SID, -EIO, "STATUS_INVALID_SID"},
417 {STATUS_INVALID_SECURITY_DESCR, -EIO, "STATUS_INVALID_SECURITY_DESCR"}, 419 {STATUS_INVALID_SECURITY_DESCR, -EIO, "STATUS_INVALID_SECURITY_DESCR"},
418 {STATUS_PROCEDURE_NOT_FOUND, -EIO, "STATUS_PROCEDURE_NOT_FOUND"}, 420 {STATUS_PROCEDURE_NOT_FOUND, -EIO, "STATUS_PROCEDURE_NOT_FOUND"},
419 {STATUS_INVALID_IMAGE_FORMAT, -EIO, "STATUS_INVALID_IMAGE_FORMAT"}, 421 {STATUS_INVALID_IMAGE_FORMAT, -EIO, "STATUS_INVALID_IMAGE_FORMAT"},
420 {STATUS_NO_TOKEN, -EIO, "STATUS_NO_TOKEN"}, 422 {STATUS_NO_TOKEN, -EIO, "STATUS_NO_TOKEN"},
421 {STATUS_BAD_INHERITANCE_ACL, -EIO, "STATUS_BAD_INHERITANCE_ACL"}, 423 {STATUS_BAD_INHERITANCE_ACL, -EIO, "STATUS_BAD_INHERITANCE_ACL"},
422 {STATUS_RANGE_NOT_LOCKED, -EIO, "STATUS_RANGE_NOT_LOCKED"}, 424 {STATUS_RANGE_NOT_LOCKED, -EIO, "STATUS_RANGE_NOT_LOCKED"},
423 {STATUS_DISK_FULL, -ENOSPC, "STATUS_DISK_FULL"}, 425 {STATUS_DISK_FULL, -ENOSPC, "STATUS_DISK_FULL"},
424 {STATUS_SERVER_DISABLED, -EIO, "STATUS_SERVER_DISABLED"}, 426 {STATUS_SERVER_DISABLED, -EIO, "STATUS_SERVER_DISABLED"},
425 {STATUS_SERVER_NOT_DISABLED, -EIO, "STATUS_SERVER_NOT_DISABLED"}, 427 {STATUS_SERVER_NOT_DISABLED, -EIO, "STATUS_SERVER_NOT_DISABLED"},
426 {STATUS_TOO_MANY_GUIDS_REQUESTED, -EIO, 428 {STATUS_TOO_MANY_GUIDS_REQUESTED, -EIO,
427 "STATUS_TOO_MANY_GUIDS_REQUESTED"}, 429 "STATUS_TOO_MANY_GUIDS_REQUESTED"},
428 {STATUS_GUIDS_EXHAUSTED, -EIO, "STATUS_GUIDS_EXHAUSTED"}, 430 {STATUS_GUIDS_EXHAUSTED, -EIO, "STATUS_GUIDS_EXHAUSTED"},
429 {STATUS_INVALID_ID_AUTHORITY, -EIO, "STATUS_INVALID_ID_AUTHORITY"}, 431 {STATUS_INVALID_ID_AUTHORITY, -EIO, "STATUS_INVALID_ID_AUTHORITY"},
430 {STATUS_AGENTS_EXHAUSTED, -EIO, "STATUS_AGENTS_EXHAUSTED"}, 432 {STATUS_AGENTS_EXHAUSTED, -EIO, "STATUS_AGENTS_EXHAUSTED"},
431 {STATUS_INVALID_VOLUME_LABEL, -EIO, "STATUS_INVALID_VOLUME_LABEL"}, 433 {STATUS_INVALID_VOLUME_LABEL, -EIO, "STATUS_INVALID_VOLUME_LABEL"},
432 {STATUS_SECTION_NOT_EXTENDED, -EIO, "STATUS_SECTION_NOT_EXTENDED"}, 434 {STATUS_SECTION_NOT_EXTENDED, -EIO, "STATUS_SECTION_NOT_EXTENDED"},
433 {STATUS_NOT_MAPPED_DATA, -EIO, "STATUS_NOT_MAPPED_DATA"}, 435 {STATUS_NOT_MAPPED_DATA, -EIO, "STATUS_NOT_MAPPED_DATA"},
434 {STATUS_RESOURCE_DATA_NOT_FOUND, -EIO, 436 {STATUS_RESOURCE_DATA_NOT_FOUND, -EIO,
435 "STATUS_RESOURCE_DATA_NOT_FOUND"}, 437 "STATUS_RESOURCE_DATA_NOT_FOUND"},
436 {STATUS_RESOURCE_TYPE_NOT_FOUND, -EIO, 438 {STATUS_RESOURCE_TYPE_NOT_FOUND, -EIO,
437 "STATUS_RESOURCE_TYPE_NOT_FOUND"}, 439 "STATUS_RESOURCE_TYPE_NOT_FOUND"},
438 {STATUS_RESOURCE_NAME_NOT_FOUND, -EIO, 440 {STATUS_RESOURCE_NAME_NOT_FOUND, -EIO,
439 "STATUS_RESOURCE_NAME_NOT_FOUND"}, 441 "STATUS_RESOURCE_NAME_NOT_FOUND"},
440 {STATUS_ARRAY_BOUNDS_EXCEEDED, -EIO, "STATUS_ARRAY_BOUNDS_EXCEEDED"}, 442 {STATUS_ARRAY_BOUNDS_EXCEEDED, -EIO, "STATUS_ARRAY_BOUNDS_EXCEEDED"},
441 {STATUS_FLOAT_DENORMAL_OPERAND, -EIO, "STATUS_FLOAT_DENORMAL_OPERAND"}, 443 {STATUS_FLOAT_DENORMAL_OPERAND, -EIO, "STATUS_FLOAT_DENORMAL_OPERAND"},
442 {STATUS_FLOAT_DIVIDE_BY_ZERO, -EIO, "STATUS_FLOAT_DIVIDE_BY_ZERO"}, 444 {STATUS_FLOAT_DIVIDE_BY_ZERO, -EIO, "STATUS_FLOAT_DIVIDE_BY_ZERO"},
443 {STATUS_FLOAT_INEXACT_RESULT, -EIO, "STATUS_FLOAT_INEXACT_RESULT"}, 445 {STATUS_FLOAT_INEXACT_RESULT, -EIO, "STATUS_FLOAT_INEXACT_RESULT"},
444 {STATUS_FLOAT_INVALID_OPERATION, -EIO, 446 {STATUS_FLOAT_INVALID_OPERATION, -EIO,
445 "STATUS_FLOAT_INVALID_OPERATION"}, 447 "STATUS_FLOAT_INVALID_OPERATION"},
446 {STATUS_FLOAT_OVERFLOW, -EIO, "STATUS_FLOAT_OVERFLOW"}, 448 {STATUS_FLOAT_OVERFLOW, -EIO, "STATUS_FLOAT_OVERFLOW"},
447 {STATUS_FLOAT_STACK_CHECK, -EIO, "STATUS_FLOAT_STACK_CHECK"}, 449 {STATUS_FLOAT_STACK_CHECK, -EIO, "STATUS_FLOAT_STACK_CHECK"},
448 {STATUS_FLOAT_UNDERFLOW, -EIO, "STATUS_FLOAT_UNDERFLOW"}, 450 {STATUS_FLOAT_UNDERFLOW, -EIO, "STATUS_FLOAT_UNDERFLOW"},
449 {STATUS_INTEGER_DIVIDE_BY_ZERO, -EIO, "STATUS_INTEGER_DIVIDE_BY_ZERO"}, 451 {STATUS_INTEGER_DIVIDE_BY_ZERO, -EIO, "STATUS_INTEGER_DIVIDE_BY_ZERO"},
450 {STATUS_INTEGER_OVERFLOW, -EIO, "STATUS_INTEGER_OVERFLOW"}, 452 {STATUS_INTEGER_OVERFLOW, -EIO, "STATUS_INTEGER_OVERFLOW"},
451 {STATUS_PRIVILEGED_INSTRUCTION, -EIO, "STATUS_PRIVILEGED_INSTRUCTION"}, 453 {STATUS_PRIVILEGED_INSTRUCTION, -EIO, "STATUS_PRIVILEGED_INSTRUCTION"},
452 {STATUS_TOO_MANY_PAGING_FILES, -EIO, "STATUS_TOO_MANY_PAGING_FILES"}, 454 {STATUS_TOO_MANY_PAGING_FILES, -EIO, "STATUS_TOO_MANY_PAGING_FILES"},
453 {STATUS_FILE_INVALID, -EIO, "STATUS_FILE_INVALID"}, 455 {STATUS_FILE_INVALID, -EIO, "STATUS_FILE_INVALID"},
454 {STATUS_ALLOTTED_SPACE_EXCEEDED, -EIO, 456 {STATUS_ALLOTTED_SPACE_EXCEEDED, -EIO,
455 "STATUS_ALLOTTED_SPACE_EXCEEDED"}, 457 "STATUS_ALLOTTED_SPACE_EXCEEDED"},
456 {STATUS_INSUFFICIENT_RESOURCES, -EREMOTEIO, 458 {STATUS_INSUFFICIENT_RESOURCES, -EREMOTEIO,
457 "STATUS_INSUFFICIENT_RESOURCES"}, 459 "STATUS_INSUFFICIENT_RESOURCES"},
458 {STATUS_DFS_EXIT_PATH_FOUND, -EIO, "STATUS_DFS_EXIT_PATH_FOUND"}, 460 {STATUS_DFS_EXIT_PATH_FOUND, -EIO, "STATUS_DFS_EXIT_PATH_FOUND"},
459 {STATUS_DEVICE_DATA_ERROR, -EIO, "STATUS_DEVICE_DATA_ERROR"}, 461 {STATUS_DEVICE_DATA_ERROR, -EIO, "STATUS_DEVICE_DATA_ERROR"},
460 {STATUS_DEVICE_NOT_CONNECTED, -EIO, "STATUS_DEVICE_NOT_CONNECTED"}, 462 {STATUS_DEVICE_NOT_CONNECTED, -EIO, "STATUS_DEVICE_NOT_CONNECTED"},
461 {STATUS_DEVICE_POWER_FAILURE, -EIO, "STATUS_DEVICE_POWER_FAILURE"}, 463 {STATUS_DEVICE_POWER_FAILURE, -EIO, "STATUS_DEVICE_POWER_FAILURE"},
462 {STATUS_FREE_VM_NOT_AT_BASE, -EIO, "STATUS_FREE_VM_NOT_AT_BASE"}, 464 {STATUS_FREE_VM_NOT_AT_BASE, -EIO, "STATUS_FREE_VM_NOT_AT_BASE"},
463 {STATUS_MEMORY_NOT_ALLOCATED, -EFAULT, "STATUS_MEMORY_NOT_ALLOCATED"}, 465 {STATUS_MEMORY_NOT_ALLOCATED, -EFAULT, "STATUS_MEMORY_NOT_ALLOCATED"},
464 {STATUS_WORKING_SET_QUOTA, -EIO, "STATUS_WORKING_SET_QUOTA"}, 466 {STATUS_WORKING_SET_QUOTA, -EIO, "STATUS_WORKING_SET_QUOTA"},
465 {STATUS_MEDIA_WRITE_PROTECTED, -EROFS, "STATUS_MEDIA_WRITE_PROTECTED"}, 467 {STATUS_MEDIA_WRITE_PROTECTED, -EROFS, "STATUS_MEDIA_WRITE_PROTECTED"},
466 {STATUS_DEVICE_NOT_READY, -EIO, "STATUS_DEVICE_NOT_READY"}, 468 {STATUS_DEVICE_NOT_READY, -EIO, "STATUS_DEVICE_NOT_READY"},
467 {STATUS_INVALID_GROUP_ATTRIBUTES, -EIO, 469 {STATUS_INVALID_GROUP_ATTRIBUTES, -EIO,
468 "STATUS_INVALID_GROUP_ATTRIBUTES"}, 470 "STATUS_INVALID_GROUP_ATTRIBUTES"},
469 {STATUS_BAD_IMPERSONATION_LEVEL, -EIO, 471 {STATUS_BAD_IMPERSONATION_LEVEL, -EIO,
470 "STATUS_BAD_IMPERSONATION_LEVEL"}, 472 "STATUS_BAD_IMPERSONATION_LEVEL"},
471 {STATUS_CANT_OPEN_ANONYMOUS, -EIO, "STATUS_CANT_OPEN_ANONYMOUS"}, 473 {STATUS_CANT_OPEN_ANONYMOUS, -EIO, "STATUS_CANT_OPEN_ANONYMOUS"},
472 {STATUS_BAD_VALIDATION_CLASS, -EIO, "STATUS_BAD_VALIDATION_CLASS"}, 474 {STATUS_BAD_VALIDATION_CLASS, -EIO, "STATUS_BAD_VALIDATION_CLASS"},
473 {STATUS_BAD_TOKEN_TYPE, -EIO, "STATUS_BAD_TOKEN_TYPE"}, 475 {STATUS_BAD_TOKEN_TYPE, -EIO, "STATUS_BAD_TOKEN_TYPE"},
474 {STATUS_BAD_MASTER_BOOT_RECORD, -EIO, "STATUS_BAD_MASTER_BOOT_RECORD"}, 476 {STATUS_BAD_MASTER_BOOT_RECORD, -EIO, "STATUS_BAD_MASTER_BOOT_RECORD"},
475 {STATUS_INSTRUCTION_MISALIGNMENT, -EIO, 477 {STATUS_INSTRUCTION_MISALIGNMENT, -EIO,
476 "STATUS_INSTRUCTION_MISALIGNMENT"}, 478 "STATUS_INSTRUCTION_MISALIGNMENT"},
477 {STATUS_INSTANCE_NOT_AVAILABLE, -EIO, "STATUS_INSTANCE_NOT_AVAILABLE"}, 479 {STATUS_INSTANCE_NOT_AVAILABLE, -EIO, "STATUS_INSTANCE_NOT_AVAILABLE"},
478 {STATUS_PIPE_NOT_AVAILABLE, -EIO, "STATUS_PIPE_NOT_AVAILABLE"}, 480 {STATUS_PIPE_NOT_AVAILABLE, -EIO, "STATUS_PIPE_NOT_AVAILABLE"},
479 {STATUS_INVALID_PIPE_STATE, -EIO, "STATUS_INVALID_PIPE_STATE"}, 481 {STATUS_INVALID_PIPE_STATE, -EIO, "STATUS_INVALID_PIPE_STATE"},
480 {STATUS_PIPE_BUSY, -EBUSY, "STATUS_PIPE_BUSY"}, 482 {STATUS_PIPE_BUSY, -EBUSY, "STATUS_PIPE_BUSY"},
481 {STATUS_ILLEGAL_FUNCTION, -EIO, "STATUS_ILLEGAL_FUNCTION"}, 483 {STATUS_ILLEGAL_FUNCTION, -EIO, "STATUS_ILLEGAL_FUNCTION"},
482 {STATUS_PIPE_DISCONNECTED, -EPIPE, "STATUS_PIPE_DISCONNECTED"}, 484 {STATUS_PIPE_DISCONNECTED, -EPIPE, "STATUS_PIPE_DISCONNECTED"},
483 {STATUS_PIPE_CLOSING, -EIO, "STATUS_PIPE_CLOSING"}, 485 {STATUS_PIPE_CLOSING, -EIO, "STATUS_PIPE_CLOSING"},
484 {STATUS_PIPE_CONNECTED, -EIO, "STATUS_PIPE_CONNECTED"}, 486 {STATUS_PIPE_CONNECTED, -EIO, "STATUS_PIPE_CONNECTED"},
485 {STATUS_PIPE_LISTENING, -EIO, "STATUS_PIPE_LISTENING"}, 487 {STATUS_PIPE_LISTENING, -EIO, "STATUS_PIPE_LISTENING"},
486 {STATUS_INVALID_READ_MODE, -EIO, "STATUS_INVALID_READ_MODE"}, 488 {STATUS_INVALID_READ_MODE, -EIO, "STATUS_INVALID_READ_MODE"},
487 {STATUS_IO_TIMEOUT, -ETIMEDOUT, "STATUS_IO_TIMEOUT"}, 489 {STATUS_IO_TIMEOUT, -ETIMEDOUT, "STATUS_IO_TIMEOUT"},
488 {STATUS_FILE_FORCED_CLOSED, -EIO, "STATUS_FILE_FORCED_CLOSED"}, 490 {STATUS_FILE_FORCED_CLOSED, -EIO, "STATUS_FILE_FORCED_CLOSED"},
489 {STATUS_PROFILING_NOT_STARTED, -EIO, "STATUS_PROFILING_NOT_STARTED"}, 491 {STATUS_PROFILING_NOT_STARTED, -EIO, "STATUS_PROFILING_NOT_STARTED"},
490 {STATUS_PROFILING_NOT_STOPPED, -EIO, "STATUS_PROFILING_NOT_STOPPED"}, 492 {STATUS_PROFILING_NOT_STOPPED, -EIO, "STATUS_PROFILING_NOT_STOPPED"},
491 {STATUS_COULD_NOT_INTERPRET, -EIO, "STATUS_COULD_NOT_INTERPRET"}, 493 {STATUS_COULD_NOT_INTERPRET, -EIO, "STATUS_COULD_NOT_INTERPRET"},
492 {STATUS_FILE_IS_A_DIRECTORY, -EISDIR, "STATUS_FILE_IS_A_DIRECTORY"}, 494 {STATUS_FILE_IS_A_DIRECTORY, -EISDIR, "STATUS_FILE_IS_A_DIRECTORY"},
493 {STATUS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_NOT_SUPPORTED"}, 495 {STATUS_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_NOT_SUPPORTED"},
494 {STATUS_REMOTE_NOT_LISTENING, -EHOSTDOWN, 496 {STATUS_REMOTE_NOT_LISTENING, -EHOSTDOWN,
495 "STATUS_REMOTE_NOT_LISTENING"}, 497 "STATUS_REMOTE_NOT_LISTENING"},
496 {STATUS_DUPLICATE_NAME, -ENOTUNIQ, "STATUS_DUPLICATE_NAME"}, 498 {STATUS_DUPLICATE_NAME, -ENOTUNIQ, "STATUS_DUPLICATE_NAME"},
497 {STATUS_BAD_NETWORK_PATH, -EINVAL, "STATUS_BAD_NETWORK_PATH"}, 499 {STATUS_BAD_NETWORK_PATH, -EINVAL, "STATUS_BAD_NETWORK_PATH"},
498 {STATUS_NETWORK_BUSY, -EBUSY, "STATUS_NETWORK_BUSY"}, 500 {STATUS_NETWORK_BUSY, -EBUSY, "STATUS_NETWORK_BUSY"},
499 {STATUS_DEVICE_DOES_NOT_EXIST, -ENODEV, "STATUS_DEVICE_DOES_NOT_EXIST"}, 501 {STATUS_DEVICE_DOES_NOT_EXIST, -ENODEV, "STATUS_DEVICE_DOES_NOT_EXIST"},
500 {STATUS_TOO_MANY_COMMANDS, -EIO, "STATUS_TOO_MANY_COMMANDS"}, 502 {STATUS_TOO_MANY_COMMANDS, -EIO, "STATUS_TOO_MANY_COMMANDS"},
501 {STATUS_ADAPTER_HARDWARE_ERROR, -EIO, "STATUS_ADAPTER_HARDWARE_ERROR"}, 503 {STATUS_ADAPTER_HARDWARE_ERROR, -EIO, "STATUS_ADAPTER_HARDWARE_ERROR"},
502 {STATUS_INVALID_NETWORK_RESPONSE, -EIO, 504 {STATUS_INVALID_NETWORK_RESPONSE, -EIO,
503 "STATUS_INVALID_NETWORK_RESPONSE"}, 505 "STATUS_INVALID_NETWORK_RESPONSE"},
504 {STATUS_UNEXPECTED_NETWORK_ERROR, -EIO, 506 {STATUS_UNEXPECTED_NETWORK_ERROR, -EIO,
505 "STATUS_UNEXPECTED_NETWORK_ERROR"}, 507 "STATUS_UNEXPECTED_NETWORK_ERROR"},
506 {STATUS_BAD_REMOTE_ADAPTER, -EIO, "STATUS_BAD_REMOTE_ADAPTER"}, 508 {STATUS_BAD_REMOTE_ADAPTER, -EIO, "STATUS_BAD_REMOTE_ADAPTER"},
507 {STATUS_PRINT_QUEUE_FULL, -EIO, "STATUS_PRINT_QUEUE_FULL"}, 509 {STATUS_PRINT_QUEUE_FULL, -EIO, "STATUS_PRINT_QUEUE_FULL"},
508 {STATUS_NO_SPOOL_SPACE, -EIO, "STATUS_NO_SPOOL_SPACE"}, 510 {STATUS_NO_SPOOL_SPACE, -EIO, "STATUS_NO_SPOOL_SPACE"},
509 {STATUS_PRINT_CANCELLED, -EIO, "STATUS_PRINT_CANCELLED"}, 511 {STATUS_PRINT_CANCELLED, -EIO, "STATUS_PRINT_CANCELLED"},
510 {STATUS_NETWORK_NAME_DELETED, -EIO, "STATUS_NETWORK_NAME_DELETED"}, 512 {STATUS_NETWORK_NAME_DELETED, -EIO, "STATUS_NETWORK_NAME_DELETED"},
511 {STATUS_NETWORK_ACCESS_DENIED, -EACCES, "STATUS_NETWORK_ACCESS_DENIED"}, 513 {STATUS_NETWORK_ACCESS_DENIED, -EACCES, "STATUS_NETWORK_ACCESS_DENIED"},
512 {STATUS_BAD_DEVICE_TYPE, -EIO, "STATUS_BAD_DEVICE_TYPE"}, 514 {STATUS_BAD_DEVICE_TYPE, -EIO, "STATUS_BAD_DEVICE_TYPE"},
513 {STATUS_BAD_NETWORK_NAME, -ENOENT, "STATUS_BAD_NETWORK_NAME"}, 515 {STATUS_BAD_NETWORK_NAME, -ENOENT, "STATUS_BAD_NETWORK_NAME"},
514 {STATUS_TOO_MANY_NAMES, -EIO, "STATUS_TOO_MANY_NAMES"}, 516 {STATUS_TOO_MANY_NAMES, -EIO, "STATUS_TOO_MANY_NAMES"},
515 {STATUS_TOO_MANY_SESSIONS, -EIO, "STATUS_TOO_MANY_SESSIONS"}, 517 {STATUS_TOO_MANY_SESSIONS, -EIO, "STATUS_TOO_MANY_SESSIONS"},
516 {STATUS_SHARING_PAUSED, -EIO, "STATUS_SHARING_PAUSED"}, 518 {STATUS_SHARING_PAUSED, -EIO, "STATUS_SHARING_PAUSED"},
517 {STATUS_REQUEST_NOT_ACCEPTED, -EIO, "STATUS_REQUEST_NOT_ACCEPTED"}, 519 {STATUS_REQUEST_NOT_ACCEPTED, -EIO, "STATUS_REQUEST_NOT_ACCEPTED"},
518 {STATUS_REDIRECTOR_PAUSED, -EIO, "STATUS_REDIRECTOR_PAUSED"}, 520 {STATUS_REDIRECTOR_PAUSED, -EIO, "STATUS_REDIRECTOR_PAUSED"},
519 {STATUS_NET_WRITE_FAULT, -EIO, "STATUS_NET_WRITE_FAULT"}, 521 {STATUS_NET_WRITE_FAULT, -EIO, "STATUS_NET_WRITE_FAULT"},
520 {STATUS_PROFILING_AT_LIMIT, -EIO, "STATUS_PROFILING_AT_LIMIT"}, 522 {STATUS_PROFILING_AT_LIMIT, -EIO, "STATUS_PROFILING_AT_LIMIT"},
521 {STATUS_NOT_SAME_DEVICE, -EXDEV, "STATUS_NOT_SAME_DEVICE"}, 523 {STATUS_NOT_SAME_DEVICE, -EXDEV, "STATUS_NOT_SAME_DEVICE"},
522 {STATUS_FILE_RENAMED, -EIO, "STATUS_FILE_RENAMED"}, 524 {STATUS_FILE_RENAMED, -EIO, "STATUS_FILE_RENAMED"},
523 {STATUS_VIRTUAL_CIRCUIT_CLOSED, -EIO, "STATUS_VIRTUAL_CIRCUIT_CLOSED"}, 525 {STATUS_VIRTUAL_CIRCUIT_CLOSED, -EIO, "STATUS_VIRTUAL_CIRCUIT_CLOSED"},
524 {STATUS_NO_SECURITY_ON_OBJECT, -EIO, "STATUS_NO_SECURITY_ON_OBJECT"}, 526 {STATUS_NO_SECURITY_ON_OBJECT, -EIO, "STATUS_NO_SECURITY_ON_OBJECT"},
525 {STATUS_CANT_WAIT, -EIO, "STATUS_CANT_WAIT"}, 527 {STATUS_CANT_WAIT, -EIO, "STATUS_CANT_WAIT"},
526 {STATUS_PIPE_EMPTY, -EIO, "STATUS_PIPE_EMPTY"}, 528 {STATUS_PIPE_EMPTY, -EIO, "STATUS_PIPE_EMPTY"},
527 {STATUS_CANT_ACCESS_DOMAIN_INFO, -EIO, 529 {STATUS_CANT_ACCESS_DOMAIN_INFO, -EIO,
528 "STATUS_CANT_ACCESS_DOMAIN_INFO"}, 530 "STATUS_CANT_ACCESS_DOMAIN_INFO"},
529 {STATUS_CANT_TERMINATE_SELF, -EIO, "STATUS_CANT_TERMINATE_SELF"}, 531 {STATUS_CANT_TERMINATE_SELF, -EIO, "STATUS_CANT_TERMINATE_SELF"},
530 {STATUS_INVALID_SERVER_STATE, -EIO, "STATUS_INVALID_SERVER_STATE"}, 532 {STATUS_INVALID_SERVER_STATE, -EIO, "STATUS_INVALID_SERVER_STATE"},
531 {STATUS_INVALID_DOMAIN_STATE, -EIO, "STATUS_INVALID_DOMAIN_STATE"}, 533 {STATUS_INVALID_DOMAIN_STATE, -EIO, "STATUS_INVALID_DOMAIN_STATE"},
532 {STATUS_INVALID_DOMAIN_ROLE, -EIO, "STATUS_INVALID_DOMAIN_ROLE"}, 534 {STATUS_INVALID_DOMAIN_ROLE, -EIO, "STATUS_INVALID_DOMAIN_ROLE"},
533 {STATUS_NO_SUCH_DOMAIN, -EIO, "STATUS_NO_SUCH_DOMAIN"}, 535 {STATUS_NO_SUCH_DOMAIN, -EIO, "STATUS_NO_SUCH_DOMAIN"},
534 {STATUS_DOMAIN_EXISTS, -EIO, "STATUS_DOMAIN_EXISTS"}, 536 {STATUS_DOMAIN_EXISTS, -EIO, "STATUS_DOMAIN_EXISTS"},
535 {STATUS_DOMAIN_LIMIT_EXCEEDED, -EIO, "STATUS_DOMAIN_LIMIT_EXCEEDED"}, 537 {STATUS_DOMAIN_LIMIT_EXCEEDED, -EIO, "STATUS_DOMAIN_LIMIT_EXCEEDED"},
536 {STATUS_OPLOCK_NOT_GRANTED, -EIO, "STATUS_OPLOCK_NOT_GRANTED"}, 538 {STATUS_OPLOCK_NOT_GRANTED, -EIO, "STATUS_OPLOCK_NOT_GRANTED"},
537 {STATUS_INVALID_OPLOCK_PROTOCOL, -EIO, 539 {STATUS_INVALID_OPLOCK_PROTOCOL, -EIO,
538 "STATUS_INVALID_OPLOCK_PROTOCOL"}, 540 "STATUS_INVALID_OPLOCK_PROTOCOL"},
539 {STATUS_INTERNAL_DB_CORRUPTION, -EIO, "STATUS_INTERNAL_DB_CORRUPTION"}, 541 {STATUS_INTERNAL_DB_CORRUPTION, -EIO, "STATUS_INTERNAL_DB_CORRUPTION"},
540 {STATUS_INTERNAL_ERROR, -EIO, "STATUS_INTERNAL_ERROR"}, 542 {STATUS_INTERNAL_ERROR, -EIO, "STATUS_INTERNAL_ERROR"},
541 {STATUS_GENERIC_NOT_MAPPED, -EIO, "STATUS_GENERIC_NOT_MAPPED"}, 543 {STATUS_GENERIC_NOT_MAPPED, -EIO, "STATUS_GENERIC_NOT_MAPPED"},
542 {STATUS_BAD_DESCRIPTOR_FORMAT, -EIO, "STATUS_BAD_DESCRIPTOR_FORMAT"}, 544 {STATUS_BAD_DESCRIPTOR_FORMAT, -EIO, "STATUS_BAD_DESCRIPTOR_FORMAT"},
543 {STATUS_INVALID_USER_BUFFER, -EIO, "STATUS_INVALID_USER_BUFFER"}, 545 {STATUS_INVALID_USER_BUFFER, -EIO, "STATUS_INVALID_USER_BUFFER"},
544 {STATUS_UNEXPECTED_IO_ERROR, -EIO, "STATUS_UNEXPECTED_IO_ERROR"}, 546 {STATUS_UNEXPECTED_IO_ERROR, -EIO, "STATUS_UNEXPECTED_IO_ERROR"},
545 {STATUS_UNEXPECTED_MM_CREATE_ERR, -EIO, 547 {STATUS_UNEXPECTED_MM_CREATE_ERR, -EIO,
546 "STATUS_UNEXPECTED_MM_CREATE_ERR"}, 548 "STATUS_UNEXPECTED_MM_CREATE_ERR"},
547 {STATUS_UNEXPECTED_MM_MAP_ERROR, -EIO, 549 {STATUS_UNEXPECTED_MM_MAP_ERROR, -EIO,
548 "STATUS_UNEXPECTED_MM_MAP_ERROR"}, 550 "STATUS_UNEXPECTED_MM_MAP_ERROR"},
549 {STATUS_UNEXPECTED_MM_EXTEND_ERR, -EIO, 551 {STATUS_UNEXPECTED_MM_EXTEND_ERR, -EIO,
550 "STATUS_UNEXPECTED_MM_EXTEND_ERR"}, 552 "STATUS_UNEXPECTED_MM_EXTEND_ERR"},
551 {STATUS_NOT_LOGON_PROCESS, -EIO, "STATUS_NOT_LOGON_PROCESS"}, 553 {STATUS_NOT_LOGON_PROCESS, -EIO, "STATUS_NOT_LOGON_PROCESS"},
552 {STATUS_LOGON_SESSION_EXISTS, -EIO, "STATUS_LOGON_SESSION_EXISTS"}, 554 {STATUS_LOGON_SESSION_EXISTS, -EIO, "STATUS_LOGON_SESSION_EXISTS"},
553 {STATUS_INVALID_PARAMETER_1, -EINVAL, "STATUS_INVALID_PARAMETER_1"}, 555 {STATUS_INVALID_PARAMETER_1, -EINVAL, "STATUS_INVALID_PARAMETER_1"},
554 {STATUS_INVALID_PARAMETER_2, -EINVAL, "STATUS_INVALID_PARAMETER_2"}, 556 {STATUS_INVALID_PARAMETER_2, -EINVAL, "STATUS_INVALID_PARAMETER_2"},
555 {STATUS_INVALID_PARAMETER_3, -EINVAL, "STATUS_INVALID_PARAMETER_3"}, 557 {STATUS_INVALID_PARAMETER_3, -EINVAL, "STATUS_INVALID_PARAMETER_3"},
556 {STATUS_INVALID_PARAMETER_4, -EINVAL, "STATUS_INVALID_PARAMETER_4"}, 558 {STATUS_INVALID_PARAMETER_4, -EINVAL, "STATUS_INVALID_PARAMETER_4"},
557 {STATUS_INVALID_PARAMETER_5, -EINVAL, "STATUS_INVALID_PARAMETER_5"}, 559 {STATUS_INVALID_PARAMETER_5, -EINVAL, "STATUS_INVALID_PARAMETER_5"},
558 {STATUS_INVALID_PARAMETER_6, -EINVAL, "STATUS_INVALID_PARAMETER_6"}, 560 {STATUS_INVALID_PARAMETER_6, -EINVAL, "STATUS_INVALID_PARAMETER_6"},
559 {STATUS_INVALID_PARAMETER_7, -EINVAL, "STATUS_INVALID_PARAMETER_7"}, 561 {STATUS_INVALID_PARAMETER_7, -EINVAL, "STATUS_INVALID_PARAMETER_7"},
560 {STATUS_INVALID_PARAMETER_8, -EINVAL, "STATUS_INVALID_PARAMETER_8"}, 562 {STATUS_INVALID_PARAMETER_8, -EINVAL, "STATUS_INVALID_PARAMETER_8"},
561 {STATUS_INVALID_PARAMETER_9, -EINVAL, "STATUS_INVALID_PARAMETER_9"}, 563 {STATUS_INVALID_PARAMETER_9, -EINVAL, "STATUS_INVALID_PARAMETER_9"},
562 {STATUS_INVALID_PARAMETER_10, -EINVAL, "STATUS_INVALID_PARAMETER_10"}, 564 {STATUS_INVALID_PARAMETER_10, -EINVAL, "STATUS_INVALID_PARAMETER_10"},
563 {STATUS_INVALID_PARAMETER_11, -EINVAL, "STATUS_INVALID_PARAMETER_11"}, 565 {STATUS_INVALID_PARAMETER_11, -EINVAL, "STATUS_INVALID_PARAMETER_11"},
564 {STATUS_INVALID_PARAMETER_12, -EINVAL, "STATUS_INVALID_PARAMETER_12"}, 566 {STATUS_INVALID_PARAMETER_12, -EINVAL, "STATUS_INVALID_PARAMETER_12"},
565 {STATUS_REDIRECTOR_NOT_STARTED, -EIO, "STATUS_REDIRECTOR_NOT_STARTED"}, 567 {STATUS_REDIRECTOR_NOT_STARTED, -EIO, "STATUS_REDIRECTOR_NOT_STARTED"},
566 {STATUS_REDIRECTOR_STARTED, -EIO, "STATUS_REDIRECTOR_STARTED"}, 568 {STATUS_REDIRECTOR_STARTED, -EIO, "STATUS_REDIRECTOR_STARTED"},
567 {STATUS_STACK_OVERFLOW, -EIO, "STATUS_STACK_OVERFLOW"}, 569 {STATUS_STACK_OVERFLOW, -EIO, "STATUS_STACK_OVERFLOW"},
568 {STATUS_NO_SUCH_PACKAGE, -EIO, "STATUS_NO_SUCH_PACKAGE"}, 570 {STATUS_NO_SUCH_PACKAGE, -EIO, "STATUS_NO_SUCH_PACKAGE"},
569 {STATUS_BAD_FUNCTION_TABLE, -EIO, "STATUS_BAD_FUNCTION_TABLE"}, 571 {STATUS_BAD_FUNCTION_TABLE, -EIO, "STATUS_BAD_FUNCTION_TABLE"},
570 {STATUS_VARIABLE_NOT_FOUND, -EIO, "STATUS_VARIABLE_NOT_FOUND"}, 572 {STATUS_VARIABLE_NOT_FOUND, -EIO, "STATUS_VARIABLE_NOT_FOUND"},
571 {STATUS_DIRECTORY_NOT_EMPTY, -ENOTEMPTY, "STATUS_DIRECTORY_NOT_EMPTY"}, 573 {STATUS_DIRECTORY_NOT_EMPTY, -ENOTEMPTY, "STATUS_DIRECTORY_NOT_EMPTY"},
572 {STATUS_FILE_CORRUPT_ERROR, -EIO, "STATUS_FILE_CORRUPT_ERROR"}, 574 {STATUS_FILE_CORRUPT_ERROR, -EIO, "STATUS_FILE_CORRUPT_ERROR"},
573 {STATUS_NOT_A_DIRECTORY, -ENOTDIR, "STATUS_NOT_A_DIRECTORY"}, 575 {STATUS_NOT_A_DIRECTORY, -ENOTDIR, "STATUS_NOT_A_DIRECTORY"},
574 {STATUS_BAD_LOGON_SESSION_STATE, -EIO, 576 {STATUS_BAD_LOGON_SESSION_STATE, -EIO,
575 "STATUS_BAD_LOGON_SESSION_STATE"}, 577 "STATUS_BAD_LOGON_SESSION_STATE"},
576 {STATUS_LOGON_SESSION_COLLISION, -EIO, 578 {STATUS_LOGON_SESSION_COLLISION, -EIO,
577 "STATUS_LOGON_SESSION_COLLISION"}, 579 "STATUS_LOGON_SESSION_COLLISION"},
578 {STATUS_NAME_TOO_LONG, -ENAMETOOLONG, "STATUS_NAME_TOO_LONG"}, 580 {STATUS_NAME_TOO_LONG, -ENAMETOOLONG, "STATUS_NAME_TOO_LONG"},
579 {STATUS_FILES_OPEN, -EIO, "STATUS_FILES_OPEN"}, 581 {STATUS_FILES_OPEN, -EIO, "STATUS_FILES_OPEN"},
580 {STATUS_CONNECTION_IN_USE, -EIO, "STATUS_CONNECTION_IN_USE"}, 582 {STATUS_CONNECTION_IN_USE, -EIO, "STATUS_CONNECTION_IN_USE"},
581 {STATUS_MESSAGE_NOT_FOUND, -EIO, "STATUS_MESSAGE_NOT_FOUND"}, 583 {STATUS_MESSAGE_NOT_FOUND, -EIO, "STATUS_MESSAGE_NOT_FOUND"},
582 {STATUS_PROCESS_IS_TERMINATING, -EIO, "STATUS_PROCESS_IS_TERMINATING"}, 584 {STATUS_PROCESS_IS_TERMINATING, -EIO, "STATUS_PROCESS_IS_TERMINATING"},
583 {STATUS_INVALID_LOGON_TYPE, -EIO, "STATUS_INVALID_LOGON_TYPE"}, 585 {STATUS_INVALID_LOGON_TYPE, -EIO, "STATUS_INVALID_LOGON_TYPE"},
584 {STATUS_NO_GUID_TRANSLATION, -EIO, "STATUS_NO_GUID_TRANSLATION"}, 586 {STATUS_NO_GUID_TRANSLATION, -EIO, "STATUS_NO_GUID_TRANSLATION"},
585 {STATUS_CANNOT_IMPERSONATE, -EIO, "STATUS_CANNOT_IMPERSONATE"}, 587 {STATUS_CANNOT_IMPERSONATE, -EIO, "STATUS_CANNOT_IMPERSONATE"},
586 {STATUS_IMAGE_ALREADY_LOADED, -EIO, "STATUS_IMAGE_ALREADY_LOADED"}, 588 {STATUS_IMAGE_ALREADY_LOADED, -EIO, "STATUS_IMAGE_ALREADY_LOADED"},
587 {STATUS_ABIOS_NOT_PRESENT, -EIO, "STATUS_ABIOS_NOT_PRESENT"}, 589 {STATUS_ABIOS_NOT_PRESENT, -EIO, "STATUS_ABIOS_NOT_PRESENT"},
588 {STATUS_ABIOS_LID_NOT_EXIST, -EIO, "STATUS_ABIOS_LID_NOT_EXIST"}, 590 {STATUS_ABIOS_LID_NOT_EXIST, -EIO, "STATUS_ABIOS_LID_NOT_EXIST"},
589 {STATUS_ABIOS_LID_ALREADY_OWNED, -EIO, 591 {STATUS_ABIOS_LID_ALREADY_OWNED, -EIO,
590 "STATUS_ABIOS_LID_ALREADY_OWNED"}, 592 "STATUS_ABIOS_LID_ALREADY_OWNED"},
591 {STATUS_ABIOS_NOT_LID_OWNER, -EIO, "STATUS_ABIOS_NOT_LID_OWNER"}, 593 {STATUS_ABIOS_NOT_LID_OWNER, -EIO, "STATUS_ABIOS_NOT_LID_OWNER"},
592 {STATUS_ABIOS_INVALID_COMMAND, -EIO, "STATUS_ABIOS_INVALID_COMMAND"}, 594 {STATUS_ABIOS_INVALID_COMMAND, -EIO, "STATUS_ABIOS_INVALID_COMMAND"},
593 {STATUS_ABIOS_INVALID_LID, -EIO, "STATUS_ABIOS_INVALID_LID"}, 595 {STATUS_ABIOS_INVALID_LID, -EIO, "STATUS_ABIOS_INVALID_LID"},
594 {STATUS_ABIOS_SELECTOR_NOT_AVAILABLE, -EIO, 596 {STATUS_ABIOS_SELECTOR_NOT_AVAILABLE, -EIO,
595 "STATUS_ABIOS_SELECTOR_NOT_AVAILABLE"}, 597 "STATUS_ABIOS_SELECTOR_NOT_AVAILABLE"},
596 {STATUS_ABIOS_INVALID_SELECTOR, -EIO, "STATUS_ABIOS_INVALID_SELECTOR"}, 598 {STATUS_ABIOS_INVALID_SELECTOR, -EIO, "STATUS_ABIOS_INVALID_SELECTOR"},
597 {STATUS_NO_LDT, -EIO, "STATUS_NO_LDT"}, 599 {STATUS_NO_LDT, -EIO, "STATUS_NO_LDT"},
598 {STATUS_INVALID_LDT_SIZE, -EIO, "STATUS_INVALID_LDT_SIZE"}, 600 {STATUS_INVALID_LDT_SIZE, -EIO, "STATUS_INVALID_LDT_SIZE"},
599 {STATUS_INVALID_LDT_OFFSET, -EIO, "STATUS_INVALID_LDT_OFFSET"}, 601 {STATUS_INVALID_LDT_OFFSET, -EIO, "STATUS_INVALID_LDT_OFFSET"},
600 {STATUS_INVALID_LDT_DESCRIPTOR, -EIO, "STATUS_INVALID_LDT_DESCRIPTOR"}, 602 {STATUS_INVALID_LDT_DESCRIPTOR, -EIO, "STATUS_INVALID_LDT_DESCRIPTOR"},
601 {STATUS_INVALID_IMAGE_NE_FORMAT, -EIO, 603 {STATUS_INVALID_IMAGE_NE_FORMAT, -EIO,
602 "STATUS_INVALID_IMAGE_NE_FORMAT"}, 604 "STATUS_INVALID_IMAGE_NE_FORMAT"},
603 {STATUS_RXACT_INVALID_STATE, -EIO, "STATUS_RXACT_INVALID_STATE"}, 605 {STATUS_RXACT_INVALID_STATE, -EIO, "STATUS_RXACT_INVALID_STATE"},
604 {STATUS_RXACT_COMMIT_FAILURE, -EIO, "STATUS_RXACT_COMMIT_FAILURE"}, 606 {STATUS_RXACT_COMMIT_FAILURE, -EIO, "STATUS_RXACT_COMMIT_FAILURE"},
605 {STATUS_MAPPED_FILE_SIZE_ZERO, -EIO, "STATUS_MAPPED_FILE_SIZE_ZERO"}, 607 {STATUS_MAPPED_FILE_SIZE_ZERO, -EIO, "STATUS_MAPPED_FILE_SIZE_ZERO"},
606 {STATUS_TOO_MANY_OPENED_FILES, -EMFILE, "STATUS_TOO_MANY_OPENED_FILES"}, 608 {STATUS_TOO_MANY_OPENED_FILES, -EMFILE, "STATUS_TOO_MANY_OPENED_FILES"},
607 {STATUS_CANCELLED, -EIO, "STATUS_CANCELLED"}, 609 {STATUS_CANCELLED, -EIO, "STATUS_CANCELLED"},
608 {STATUS_CANNOT_DELETE, -EACCES, "STATUS_CANNOT_DELETE"}, 610 {STATUS_CANNOT_DELETE, -EACCES, "STATUS_CANNOT_DELETE"},
609 {STATUS_INVALID_COMPUTER_NAME, -EIO, "STATUS_INVALID_COMPUTER_NAME"}, 611 {STATUS_INVALID_COMPUTER_NAME, -EIO, "STATUS_INVALID_COMPUTER_NAME"},
610 {STATUS_FILE_DELETED, -EIO, "STATUS_FILE_DELETED"}, 612 {STATUS_FILE_DELETED, -EIO, "STATUS_FILE_DELETED"},
611 {STATUS_SPECIAL_ACCOUNT, -EIO, "STATUS_SPECIAL_ACCOUNT"}, 613 {STATUS_SPECIAL_ACCOUNT, -EIO, "STATUS_SPECIAL_ACCOUNT"},
612 {STATUS_SPECIAL_GROUP, -EIO, "STATUS_SPECIAL_GROUP"}, 614 {STATUS_SPECIAL_GROUP, -EIO, "STATUS_SPECIAL_GROUP"},
613 {STATUS_SPECIAL_USER, -EIO, "STATUS_SPECIAL_USER"}, 615 {STATUS_SPECIAL_USER, -EIO, "STATUS_SPECIAL_USER"},
614 {STATUS_MEMBERS_PRIMARY_GROUP, -EIO, "STATUS_MEMBERS_PRIMARY_GROUP"}, 616 {STATUS_MEMBERS_PRIMARY_GROUP, -EIO, "STATUS_MEMBERS_PRIMARY_GROUP"},
615 {STATUS_FILE_CLOSED, -EBADF, "STATUS_FILE_CLOSED"}, 617 {STATUS_FILE_CLOSED, -EBADF, "STATUS_FILE_CLOSED"},
616 {STATUS_TOO_MANY_THREADS, -EIO, "STATUS_TOO_MANY_THREADS"}, 618 {STATUS_TOO_MANY_THREADS, -EIO, "STATUS_TOO_MANY_THREADS"},
617 {STATUS_THREAD_NOT_IN_PROCESS, -EIO, "STATUS_THREAD_NOT_IN_PROCESS"}, 619 {STATUS_THREAD_NOT_IN_PROCESS, -EIO, "STATUS_THREAD_NOT_IN_PROCESS"},
618 {STATUS_TOKEN_ALREADY_IN_USE, -EIO, "STATUS_TOKEN_ALREADY_IN_USE"}, 620 {STATUS_TOKEN_ALREADY_IN_USE, -EIO, "STATUS_TOKEN_ALREADY_IN_USE"},
619 {STATUS_PAGEFILE_QUOTA_EXCEEDED, -EDQUOT, 621 {STATUS_PAGEFILE_QUOTA_EXCEEDED, -EDQUOT,
620 "STATUS_PAGEFILE_QUOTA_EXCEEDED"}, 622 "STATUS_PAGEFILE_QUOTA_EXCEEDED"},
621 {STATUS_COMMITMENT_LIMIT, -EIO, "STATUS_COMMITMENT_LIMIT"}, 623 {STATUS_COMMITMENT_LIMIT, -EIO, "STATUS_COMMITMENT_LIMIT"},
622 {STATUS_INVALID_IMAGE_LE_FORMAT, -EIO, 624 {STATUS_INVALID_IMAGE_LE_FORMAT, -EIO,
623 "STATUS_INVALID_IMAGE_LE_FORMAT"}, 625 "STATUS_INVALID_IMAGE_LE_FORMAT"},
624 {STATUS_INVALID_IMAGE_NOT_MZ, -EIO, "STATUS_INVALID_IMAGE_NOT_MZ"}, 626 {STATUS_INVALID_IMAGE_NOT_MZ, -EIO, "STATUS_INVALID_IMAGE_NOT_MZ"},
625 {STATUS_INVALID_IMAGE_PROTECT, -EIO, "STATUS_INVALID_IMAGE_PROTECT"}, 627 {STATUS_INVALID_IMAGE_PROTECT, -EIO, "STATUS_INVALID_IMAGE_PROTECT"},
626 {STATUS_INVALID_IMAGE_WIN_16, -EIO, "STATUS_INVALID_IMAGE_WIN_16"}, 628 {STATUS_INVALID_IMAGE_WIN_16, -EIO, "STATUS_INVALID_IMAGE_WIN_16"},
627 {STATUS_LOGON_SERVER_CONFLICT, -EIO, "STATUS_LOGON_SERVER_CONFLICT"}, 629 {STATUS_LOGON_SERVER_CONFLICT, -EIO, "STATUS_LOGON_SERVER_CONFLICT"},
628 {STATUS_TIME_DIFFERENCE_AT_DC, -EIO, "STATUS_TIME_DIFFERENCE_AT_DC"}, 630 {STATUS_TIME_DIFFERENCE_AT_DC, -EIO, "STATUS_TIME_DIFFERENCE_AT_DC"},
629 {STATUS_SYNCHRONIZATION_REQUIRED, -EIO, 631 {STATUS_SYNCHRONIZATION_REQUIRED, -EIO,
630 "STATUS_SYNCHRONIZATION_REQUIRED"}, 632 "STATUS_SYNCHRONIZATION_REQUIRED"},
631 {STATUS_DLL_NOT_FOUND, -ENOENT, "STATUS_DLL_NOT_FOUND"}, 633 {STATUS_DLL_NOT_FOUND, -ENOENT, "STATUS_DLL_NOT_FOUND"},
632 {STATUS_OPEN_FAILED, -EIO, "STATUS_OPEN_FAILED"}, 634 {STATUS_OPEN_FAILED, -EIO, "STATUS_OPEN_FAILED"},
633 {STATUS_IO_PRIVILEGE_FAILED, -EIO, "STATUS_IO_PRIVILEGE_FAILED"}, 635 {STATUS_IO_PRIVILEGE_FAILED, -EIO, "STATUS_IO_PRIVILEGE_FAILED"},
634 {STATUS_ORDINAL_NOT_FOUND, -EIO, "STATUS_ORDINAL_NOT_FOUND"}, 636 {STATUS_ORDINAL_NOT_FOUND, -EIO, "STATUS_ORDINAL_NOT_FOUND"},
635 {STATUS_ENTRYPOINT_NOT_FOUND, -EIO, "STATUS_ENTRYPOINT_NOT_FOUND"}, 637 {STATUS_ENTRYPOINT_NOT_FOUND, -EIO, "STATUS_ENTRYPOINT_NOT_FOUND"},
636 {STATUS_CONTROL_C_EXIT, -EIO, "STATUS_CONTROL_C_EXIT"}, 638 {STATUS_CONTROL_C_EXIT, -EIO, "STATUS_CONTROL_C_EXIT"},
637 {STATUS_LOCAL_DISCONNECT, -EIO, "STATUS_LOCAL_DISCONNECT"}, 639 {STATUS_LOCAL_DISCONNECT, -EIO, "STATUS_LOCAL_DISCONNECT"},
638 {STATUS_REMOTE_DISCONNECT, -ESHUTDOWN, "STATUS_REMOTE_DISCONNECT"}, 640 {STATUS_REMOTE_DISCONNECT, -ESHUTDOWN, "STATUS_REMOTE_DISCONNECT"},
639 {STATUS_REMOTE_RESOURCES, -EIO, "STATUS_REMOTE_RESOURCES"}, 641 {STATUS_REMOTE_RESOURCES, -EIO, "STATUS_REMOTE_RESOURCES"},
640 {STATUS_LINK_FAILED, -EXDEV, "STATUS_LINK_FAILED"}, 642 {STATUS_LINK_FAILED, -EXDEV, "STATUS_LINK_FAILED"},
641 {STATUS_LINK_TIMEOUT, -ETIMEDOUT, "STATUS_LINK_TIMEOUT"}, 643 {STATUS_LINK_TIMEOUT, -ETIMEDOUT, "STATUS_LINK_TIMEOUT"},
642 {STATUS_INVALID_CONNECTION, -EIO, "STATUS_INVALID_CONNECTION"}, 644 {STATUS_INVALID_CONNECTION, -EIO, "STATUS_INVALID_CONNECTION"},
643 {STATUS_INVALID_ADDRESS, -EIO, "STATUS_INVALID_ADDRESS"}, 645 {STATUS_INVALID_ADDRESS, -EIO, "STATUS_INVALID_ADDRESS"},
644 {STATUS_DLL_INIT_FAILED, -EIO, "STATUS_DLL_INIT_FAILED"}, 646 {STATUS_DLL_INIT_FAILED, -EIO, "STATUS_DLL_INIT_FAILED"},
645 {STATUS_MISSING_SYSTEMFILE, -EIO, "STATUS_MISSING_SYSTEMFILE"}, 647 {STATUS_MISSING_SYSTEMFILE, -EIO, "STATUS_MISSING_SYSTEMFILE"},
646 {STATUS_UNHANDLED_EXCEPTION, -EIO, "STATUS_UNHANDLED_EXCEPTION"}, 648 {STATUS_UNHANDLED_EXCEPTION, -EIO, "STATUS_UNHANDLED_EXCEPTION"},
647 {STATUS_APP_INIT_FAILURE, -EIO, "STATUS_APP_INIT_FAILURE"}, 649 {STATUS_APP_INIT_FAILURE, -EIO, "STATUS_APP_INIT_FAILURE"},
648 {STATUS_PAGEFILE_CREATE_FAILED, -EIO, "STATUS_PAGEFILE_CREATE_FAILED"}, 650 {STATUS_PAGEFILE_CREATE_FAILED, -EIO, "STATUS_PAGEFILE_CREATE_FAILED"},
649 {STATUS_NO_PAGEFILE, -EIO, "STATUS_NO_PAGEFILE"}, 651 {STATUS_NO_PAGEFILE, -EIO, "STATUS_NO_PAGEFILE"},
650 {STATUS_INVALID_LEVEL, -EIO, "STATUS_INVALID_LEVEL"}, 652 {STATUS_INVALID_LEVEL, -EIO, "STATUS_INVALID_LEVEL"},
651 {STATUS_WRONG_PASSWORD_CORE, -EIO, "STATUS_WRONG_PASSWORD_CORE"}, 653 {STATUS_WRONG_PASSWORD_CORE, -EIO, "STATUS_WRONG_PASSWORD_CORE"},
652 {STATUS_ILLEGAL_FLOAT_CONTEXT, -EIO, "STATUS_ILLEGAL_FLOAT_CONTEXT"}, 654 {STATUS_ILLEGAL_FLOAT_CONTEXT, -EIO, "STATUS_ILLEGAL_FLOAT_CONTEXT"},
653 {STATUS_PIPE_BROKEN, -EPIPE, "STATUS_PIPE_BROKEN"}, 655 {STATUS_PIPE_BROKEN, -EPIPE, "STATUS_PIPE_BROKEN"},
654 {STATUS_REGISTRY_CORRUPT, -EIO, "STATUS_REGISTRY_CORRUPT"}, 656 {STATUS_REGISTRY_CORRUPT, -EIO, "STATUS_REGISTRY_CORRUPT"},
655 {STATUS_REGISTRY_IO_FAILED, -EIO, "STATUS_REGISTRY_IO_FAILED"}, 657 {STATUS_REGISTRY_IO_FAILED, -EIO, "STATUS_REGISTRY_IO_FAILED"},
656 {STATUS_NO_EVENT_PAIR, -EIO, "STATUS_NO_EVENT_PAIR"}, 658 {STATUS_NO_EVENT_PAIR, -EIO, "STATUS_NO_EVENT_PAIR"},
657 {STATUS_UNRECOGNIZED_VOLUME, -EIO, "STATUS_UNRECOGNIZED_VOLUME"}, 659 {STATUS_UNRECOGNIZED_VOLUME, -EIO, "STATUS_UNRECOGNIZED_VOLUME"},
658 {STATUS_SERIAL_NO_DEVICE_INITED, -EIO, 660 {STATUS_SERIAL_NO_DEVICE_INITED, -EIO,
659 "STATUS_SERIAL_NO_DEVICE_INITED"}, 661 "STATUS_SERIAL_NO_DEVICE_INITED"},
660 {STATUS_NO_SUCH_ALIAS, -EIO, "STATUS_NO_SUCH_ALIAS"}, 662 {STATUS_NO_SUCH_ALIAS, -EIO, "STATUS_NO_SUCH_ALIAS"},
661 {STATUS_MEMBER_NOT_IN_ALIAS, -EIO, "STATUS_MEMBER_NOT_IN_ALIAS"}, 663 {STATUS_MEMBER_NOT_IN_ALIAS, -EIO, "STATUS_MEMBER_NOT_IN_ALIAS"},
662 {STATUS_MEMBER_IN_ALIAS, -EIO, "STATUS_MEMBER_IN_ALIAS"}, 664 {STATUS_MEMBER_IN_ALIAS, -EIO, "STATUS_MEMBER_IN_ALIAS"},
663 {STATUS_ALIAS_EXISTS, -EIO, "STATUS_ALIAS_EXISTS"}, 665 {STATUS_ALIAS_EXISTS, -EIO, "STATUS_ALIAS_EXISTS"},
664 {STATUS_LOGON_NOT_GRANTED, -EIO, "STATUS_LOGON_NOT_GRANTED"}, 666 {STATUS_LOGON_NOT_GRANTED, -EIO, "STATUS_LOGON_NOT_GRANTED"},
665 {STATUS_TOO_MANY_SECRETS, -EIO, "STATUS_TOO_MANY_SECRETS"}, 667 {STATUS_TOO_MANY_SECRETS, -EIO, "STATUS_TOO_MANY_SECRETS"},
666 {STATUS_SECRET_TOO_LONG, -EIO, "STATUS_SECRET_TOO_LONG"}, 668 {STATUS_SECRET_TOO_LONG, -EIO, "STATUS_SECRET_TOO_LONG"},
667 {STATUS_INTERNAL_DB_ERROR, -EIO, "STATUS_INTERNAL_DB_ERROR"}, 669 {STATUS_INTERNAL_DB_ERROR, -EIO, "STATUS_INTERNAL_DB_ERROR"},
668 {STATUS_FULLSCREEN_MODE, -EIO, "STATUS_FULLSCREEN_MODE"}, 670 {STATUS_FULLSCREEN_MODE, -EIO, "STATUS_FULLSCREEN_MODE"},
669 {STATUS_TOO_MANY_CONTEXT_IDS, -EIO, "STATUS_TOO_MANY_CONTEXT_IDS"}, 671 {STATUS_TOO_MANY_CONTEXT_IDS, -EIO, "STATUS_TOO_MANY_CONTEXT_IDS"},
670 {STATUS_LOGON_TYPE_NOT_GRANTED, -EIO, "STATUS_LOGON_TYPE_NOT_GRANTED"}, 672 {STATUS_LOGON_TYPE_NOT_GRANTED, -EIO, "STATUS_LOGON_TYPE_NOT_GRANTED"},
671 {STATUS_NOT_REGISTRY_FILE, -EIO, "STATUS_NOT_REGISTRY_FILE"}, 673 {STATUS_NOT_REGISTRY_FILE, -EIO, "STATUS_NOT_REGISTRY_FILE"},
672 {STATUS_NT_CROSS_ENCRYPTION_REQUIRED, -EIO, 674 {STATUS_NT_CROSS_ENCRYPTION_REQUIRED, -EIO,
673 "STATUS_NT_CROSS_ENCRYPTION_REQUIRED"}, 675 "STATUS_NT_CROSS_ENCRYPTION_REQUIRED"},
674 {STATUS_DOMAIN_CTRLR_CONFIG_ERROR, -EIO, 676 {STATUS_DOMAIN_CTRLR_CONFIG_ERROR, -EIO,
675 "STATUS_DOMAIN_CTRLR_CONFIG_ERROR"}, 677 "STATUS_DOMAIN_CTRLR_CONFIG_ERROR"},
676 {STATUS_FT_MISSING_MEMBER, -EIO, "STATUS_FT_MISSING_MEMBER"}, 678 {STATUS_FT_MISSING_MEMBER, -EIO, "STATUS_FT_MISSING_MEMBER"},
677 {STATUS_ILL_FORMED_SERVICE_ENTRY, -EIO, 679 {STATUS_ILL_FORMED_SERVICE_ENTRY, -EIO,
678 "STATUS_ILL_FORMED_SERVICE_ENTRY"}, 680 "STATUS_ILL_FORMED_SERVICE_ENTRY"},
679 {STATUS_ILLEGAL_CHARACTER, -EIO, "STATUS_ILLEGAL_CHARACTER"}, 681 {STATUS_ILLEGAL_CHARACTER, -EIO, "STATUS_ILLEGAL_CHARACTER"},
680 {STATUS_UNMAPPABLE_CHARACTER, -EIO, "STATUS_UNMAPPABLE_CHARACTER"}, 682 {STATUS_UNMAPPABLE_CHARACTER, -EIO, "STATUS_UNMAPPABLE_CHARACTER"},
681 {STATUS_UNDEFINED_CHARACTER, -EIO, "STATUS_UNDEFINED_CHARACTER"}, 683 {STATUS_UNDEFINED_CHARACTER, -EIO, "STATUS_UNDEFINED_CHARACTER"},
682 {STATUS_FLOPPY_VOLUME, -EIO, "STATUS_FLOPPY_VOLUME"}, 684 {STATUS_FLOPPY_VOLUME, -EIO, "STATUS_FLOPPY_VOLUME"},
683 {STATUS_FLOPPY_ID_MARK_NOT_FOUND, -EIO, 685 {STATUS_FLOPPY_ID_MARK_NOT_FOUND, -EIO,
684 "STATUS_FLOPPY_ID_MARK_NOT_FOUND"}, 686 "STATUS_FLOPPY_ID_MARK_NOT_FOUND"},
685 {STATUS_FLOPPY_WRONG_CYLINDER, -EIO, "STATUS_FLOPPY_WRONG_CYLINDER"}, 687 {STATUS_FLOPPY_WRONG_CYLINDER, -EIO, "STATUS_FLOPPY_WRONG_CYLINDER"},
686 {STATUS_FLOPPY_UNKNOWN_ERROR, -EIO, "STATUS_FLOPPY_UNKNOWN_ERROR"}, 688 {STATUS_FLOPPY_UNKNOWN_ERROR, -EIO, "STATUS_FLOPPY_UNKNOWN_ERROR"},
687 {STATUS_FLOPPY_BAD_REGISTERS, -EIO, "STATUS_FLOPPY_BAD_REGISTERS"}, 689 {STATUS_FLOPPY_BAD_REGISTERS, -EIO, "STATUS_FLOPPY_BAD_REGISTERS"},
688 {STATUS_DISK_RECALIBRATE_FAILED, -EIO, 690 {STATUS_DISK_RECALIBRATE_FAILED, -EIO,
689 "STATUS_DISK_RECALIBRATE_FAILED"}, 691 "STATUS_DISK_RECALIBRATE_FAILED"},
690 {STATUS_DISK_OPERATION_FAILED, -EIO, "STATUS_DISK_OPERATION_FAILED"}, 692 {STATUS_DISK_OPERATION_FAILED, -EIO, "STATUS_DISK_OPERATION_FAILED"},
691 {STATUS_DISK_RESET_FAILED, -EIO, "STATUS_DISK_RESET_FAILED"}, 693 {STATUS_DISK_RESET_FAILED, -EIO, "STATUS_DISK_RESET_FAILED"},
692 {STATUS_SHARED_IRQ_BUSY, -EBUSY, "STATUS_SHARED_IRQ_BUSY"}, 694 {STATUS_SHARED_IRQ_BUSY, -EBUSY, "STATUS_SHARED_IRQ_BUSY"},
693 {STATUS_FT_ORPHANING, -EIO, "STATUS_FT_ORPHANING"}, 695 {STATUS_FT_ORPHANING, -EIO, "STATUS_FT_ORPHANING"},
694 {STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT, -EIO, 696 {STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT, -EIO,
695 "STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT"}, 697 "STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT"},
696 {STATUS_PARTITION_FAILURE, -EIO, "STATUS_PARTITION_FAILURE"}, 698 {STATUS_PARTITION_FAILURE, -EIO, "STATUS_PARTITION_FAILURE"},
697 {STATUS_INVALID_BLOCK_LENGTH, -EIO, "STATUS_INVALID_BLOCK_LENGTH"}, 699 {STATUS_INVALID_BLOCK_LENGTH, -EIO, "STATUS_INVALID_BLOCK_LENGTH"},
698 {STATUS_DEVICE_NOT_PARTITIONED, -EIO, "STATUS_DEVICE_NOT_PARTITIONED"}, 700 {STATUS_DEVICE_NOT_PARTITIONED, -EIO, "STATUS_DEVICE_NOT_PARTITIONED"},
699 {STATUS_UNABLE_TO_LOCK_MEDIA, -EIO, "STATUS_UNABLE_TO_LOCK_MEDIA"}, 701 {STATUS_UNABLE_TO_LOCK_MEDIA, -EIO, "STATUS_UNABLE_TO_LOCK_MEDIA"},
700 {STATUS_UNABLE_TO_UNLOAD_MEDIA, -EIO, "STATUS_UNABLE_TO_UNLOAD_MEDIA"}, 702 {STATUS_UNABLE_TO_UNLOAD_MEDIA, -EIO, "STATUS_UNABLE_TO_UNLOAD_MEDIA"},
701 {STATUS_EOM_OVERFLOW, -EIO, "STATUS_EOM_OVERFLOW"}, 703 {STATUS_EOM_OVERFLOW, -EIO, "STATUS_EOM_OVERFLOW"},
702 {STATUS_NO_MEDIA, -EIO, "STATUS_NO_MEDIA"}, 704 {STATUS_NO_MEDIA, -EIO, "STATUS_NO_MEDIA"},
703 {STATUS_NO_SUCH_MEMBER, -EIO, "STATUS_NO_SUCH_MEMBER"}, 705 {STATUS_NO_SUCH_MEMBER, -EIO, "STATUS_NO_SUCH_MEMBER"},
704 {STATUS_INVALID_MEMBER, -EIO, "STATUS_INVALID_MEMBER"}, 706 {STATUS_INVALID_MEMBER, -EIO, "STATUS_INVALID_MEMBER"},
705 {STATUS_KEY_DELETED, -EIO, "STATUS_KEY_DELETED"}, 707 {STATUS_KEY_DELETED, -EIO, "STATUS_KEY_DELETED"},
706 {STATUS_NO_LOG_SPACE, -EIO, "STATUS_NO_LOG_SPACE"}, 708 {STATUS_NO_LOG_SPACE, -EIO, "STATUS_NO_LOG_SPACE"},
707 {STATUS_TOO_MANY_SIDS, -EIO, "STATUS_TOO_MANY_SIDS"}, 709 {STATUS_TOO_MANY_SIDS, -EIO, "STATUS_TOO_MANY_SIDS"},
708 {STATUS_LM_CROSS_ENCRYPTION_REQUIRED, -EIO, 710 {STATUS_LM_CROSS_ENCRYPTION_REQUIRED, -EIO,
709 "STATUS_LM_CROSS_ENCRYPTION_REQUIRED"}, 711 "STATUS_LM_CROSS_ENCRYPTION_REQUIRED"},
710 {STATUS_KEY_HAS_CHILDREN, -EIO, "STATUS_KEY_HAS_CHILDREN"}, 712 {STATUS_KEY_HAS_CHILDREN, -EIO, "STATUS_KEY_HAS_CHILDREN"},
711 {STATUS_CHILD_MUST_BE_VOLATILE, -EIO, "STATUS_CHILD_MUST_BE_VOLATILE"}, 713 {STATUS_CHILD_MUST_BE_VOLATILE, -EIO, "STATUS_CHILD_MUST_BE_VOLATILE"},
712 {STATUS_DEVICE_CONFIGURATION_ERROR, -EIO, 714 {STATUS_DEVICE_CONFIGURATION_ERROR, -EIO,
713 "STATUS_DEVICE_CONFIGURATION_ERROR"}, 715 "STATUS_DEVICE_CONFIGURATION_ERROR"},
714 {STATUS_DRIVER_INTERNAL_ERROR, -EIO, "STATUS_DRIVER_INTERNAL_ERROR"}, 716 {STATUS_DRIVER_INTERNAL_ERROR, -EIO, "STATUS_DRIVER_INTERNAL_ERROR"},
715 {STATUS_INVALID_DEVICE_STATE, -EIO, "STATUS_INVALID_DEVICE_STATE"}, 717 {STATUS_INVALID_DEVICE_STATE, -EIO, "STATUS_INVALID_DEVICE_STATE"},
716 {STATUS_IO_DEVICE_ERROR, -EIO, "STATUS_IO_DEVICE_ERROR"}, 718 {STATUS_IO_DEVICE_ERROR, -EIO, "STATUS_IO_DEVICE_ERROR"},
717 {STATUS_DEVICE_PROTOCOL_ERROR, -EIO, "STATUS_DEVICE_PROTOCOL_ERROR"}, 719 {STATUS_DEVICE_PROTOCOL_ERROR, -EIO, "STATUS_DEVICE_PROTOCOL_ERROR"},
718 {STATUS_BACKUP_CONTROLLER, -EIO, "STATUS_BACKUP_CONTROLLER"}, 720 {STATUS_BACKUP_CONTROLLER, -EIO, "STATUS_BACKUP_CONTROLLER"},
719 {STATUS_LOG_FILE_FULL, -EIO, "STATUS_LOG_FILE_FULL"}, 721 {STATUS_LOG_FILE_FULL, -EIO, "STATUS_LOG_FILE_FULL"},
720 {STATUS_TOO_LATE, -EIO, "STATUS_TOO_LATE"}, 722 {STATUS_TOO_LATE, -EIO, "STATUS_TOO_LATE"},
721 {STATUS_NO_TRUST_LSA_SECRET, -EIO, "STATUS_NO_TRUST_LSA_SECRET"}, 723 {STATUS_NO_TRUST_LSA_SECRET, -EIO, "STATUS_NO_TRUST_LSA_SECRET"},
722 {STATUS_NO_TRUST_SAM_ACCOUNT, -EIO, "STATUS_NO_TRUST_SAM_ACCOUNT"}, 724 {STATUS_NO_TRUST_SAM_ACCOUNT, -EIO, "STATUS_NO_TRUST_SAM_ACCOUNT"},
723 {STATUS_TRUSTED_DOMAIN_FAILURE, -EIO, "STATUS_TRUSTED_DOMAIN_FAILURE"}, 725 {STATUS_TRUSTED_DOMAIN_FAILURE, -EIO, "STATUS_TRUSTED_DOMAIN_FAILURE"},
724 {STATUS_TRUSTED_RELATIONSHIP_FAILURE, -EIO, 726 {STATUS_TRUSTED_RELATIONSHIP_FAILURE, -EIO,
725 "STATUS_TRUSTED_RELATIONSHIP_FAILURE"}, 727 "STATUS_TRUSTED_RELATIONSHIP_FAILURE"},
726 {STATUS_EVENTLOG_FILE_CORRUPT, -EIO, "STATUS_EVENTLOG_FILE_CORRUPT"}, 728 {STATUS_EVENTLOG_FILE_CORRUPT, -EIO, "STATUS_EVENTLOG_FILE_CORRUPT"},
727 {STATUS_EVENTLOG_CANT_START, -EIO, "STATUS_EVENTLOG_CANT_START"}, 729 {STATUS_EVENTLOG_CANT_START, -EIO, "STATUS_EVENTLOG_CANT_START"},
728 {STATUS_TRUST_FAILURE, -EIO, "STATUS_TRUST_FAILURE"}, 730 {STATUS_TRUST_FAILURE, -EIO, "STATUS_TRUST_FAILURE"},
729 {STATUS_MUTANT_LIMIT_EXCEEDED, -EIO, "STATUS_MUTANT_LIMIT_EXCEEDED"}, 731 {STATUS_MUTANT_LIMIT_EXCEEDED, -EIO, "STATUS_MUTANT_LIMIT_EXCEEDED"},
730 {STATUS_NETLOGON_NOT_STARTED, -EIO, "STATUS_NETLOGON_NOT_STARTED"}, 732 {STATUS_NETLOGON_NOT_STARTED, -EIO, "STATUS_NETLOGON_NOT_STARTED"},
731 {STATUS_ACCOUNT_EXPIRED, -EKEYEXPIRED, "STATUS_ACCOUNT_EXPIRED"}, 733 {STATUS_ACCOUNT_EXPIRED, -EKEYEXPIRED, "STATUS_ACCOUNT_EXPIRED"},
732 {STATUS_POSSIBLE_DEADLOCK, -EIO, "STATUS_POSSIBLE_DEADLOCK"}, 734 {STATUS_POSSIBLE_DEADLOCK, -EIO, "STATUS_POSSIBLE_DEADLOCK"},
733 {STATUS_NETWORK_CREDENTIAL_CONFLICT, -EIO, 735 {STATUS_NETWORK_CREDENTIAL_CONFLICT, -EIO,
734 "STATUS_NETWORK_CREDENTIAL_CONFLICT"}, 736 "STATUS_NETWORK_CREDENTIAL_CONFLICT"},
735 {STATUS_REMOTE_SESSION_LIMIT, -EIO, "STATUS_REMOTE_SESSION_LIMIT"}, 737 {STATUS_REMOTE_SESSION_LIMIT, -EIO, "STATUS_REMOTE_SESSION_LIMIT"},
736 {STATUS_EVENTLOG_FILE_CHANGED, -EIO, "STATUS_EVENTLOG_FILE_CHANGED"}, 738 {STATUS_EVENTLOG_FILE_CHANGED, -EIO, "STATUS_EVENTLOG_FILE_CHANGED"},
737 {STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, -EIO, 739 {STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT, -EIO,
738 "STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT"}, 740 "STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT"},
739 {STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, -EIO, 741 {STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT, -EIO,
740 "STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT"}, 742 "STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT"},
741 {STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, -EIO, 743 {STATUS_NOLOGON_SERVER_TRUST_ACCOUNT, -EIO,
742 "STATUS_NOLOGON_SERVER_TRUST_ACCOUNT"}, 744 "STATUS_NOLOGON_SERVER_TRUST_ACCOUNT"},
743 {STATUS_DOMAIN_TRUST_INCONSISTENT, -EIO, 745 {STATUS_DOMAIN_TRUST_INCONSISTENT, -EIO,
744 "STATUS_DOMAIN_TRUST_INCONSISTENT"}, 746 "STATUS_DOMAIN_TRUST_INCONSISTENT"},
745 {STATUS_FS_DRIVER_REQUIRED, -EIO, "STATUS_FS_DRIVER_REQUIRED"}, 747 {STATUS_FS_DRIVER_REQUIRED, -EIO, "STATUS_FS_DRIVER_REQUIRED"},
746 {STATUS_IMAGE_ALREADY_LOADED_AS_DLL, -EIO, 748 {STATUS_IMAGE_ALREADY_LOADED_AS_DLL, -EIO,
747 "STATUS_IMAGE_ALREADY_LOADED_AS_DLL"}, 749 "STATUS_IMAGE_ALREADY_LOADED_AS_DLL"},
748 {STATUS_NETWORK_OPEN_RESTRICTION, -EIO, 750 {STATUS_NETWORK_OPEN_RESTRICTION, -EIO,
749 "STATUS_NETWORK_OPEN_RESTRICTION"}, 751 "STATUS_NETWORK_OPEN_RESTRICTION"},
750 {STATUS_NO_USER_SESSION_KEY, -EIO, "STATUS_NO_USER_SESSION_KEY"}, 752 {STATUS_NO_USER_SESSION_KEY, -EIO, "STATUS_NO_USER_SESSION_KEY"},
751 {STATUS_USER_SESSION_DELETED, -EIO, "STATUS_USER_SESSION_DELETED"}, 753 {STATUS_USER_SESSION_DELETED, -EIO, "STATUS_USER_SESSION_DELETED"},
752 {STATUS_RESOURCE_LANG_NOT_FOUND, -EIO, 754 {STATUS_RESOURCE_LANG_NOT_FOUND, -EIO,
753 "STATUS_RESOURCE_LANG_NOT_FOUND"}, 755 "STATUS_RESOURCE_LANG_NOT_FOUND"},
754 {STATUS_INSUFF_SERVER_RESOURCES, -EIO, 756 {STATUS_INSUFF_SERVER_RESOURCES, -EIO,
755 "STATUS_INSUFF_SERVER_RESOURCES"}, 757 "STATUS_INSUFF_SERVER_RESOURCES"},
756 {STATUS_INVALID_BUFFER_SIZE, -EIO, "STATUS_INVALID_BUFFER_SIZE"}, 758 {STATUS_INVALID_BUFFER_SIZE, -EIO, "STATUS_INVALID_BUFFER_SIZE"},
757 {STATUS_INVALID_ADDRESS_COMPONENT, -EIO, 759 {STATUS_INVALID_ADDRESS_COMPONENT, -EIO,
758 "STATUS_INVALID_ADDRESS_COMPONENT"}, 760 "STATUS_INVALID_ADDRESS_COMPONENT"},
759 {STATUS_INVALID_ADDRESS_WILDCARD, -EIO, 761 {STATUS_INVALID_ADDRESS_WILDCARD, -EIO,
760 "STATUS_INVALID_ADDRESS_WILDCARD"}, 762 "STATUS_INVALID_ADDRESS_WILDCARD"},
761 {STATUS_TOO_MANY_ADDRESSES, -EIO, "STATUS_TOO_MANY_ADDRESSES"}, 763 {STATUS_TOO_MANY_ADDRESSES, -EIO, "STATUS_TOO_MANY_ADDRESSES"},
762 {STATUS_ADDRESS_ALREADY_EXISTS, -EADDRINUSE, 764 {STATUS_ADDRESS_ALREADY_EXISTS, -EADDRINUSE,
763 "STATUS_ADDRESS_ALREADY_EXISTS"}, 765 "STATUS_ADDRESS_ALREADY_EXISTS"},
764 {STATUS_ADDRESS_CLOSED, -EIO, "STATUS_ADDRESS_CLOSED"}, 766 {STATUS_ADDRESS_CLOSED, -EIO, "STATUS_ADDRESS_CLOSED"},
765 {STATUS_CONNECTION_DISCONNECTED, -ECONNABORTED, 767 {STATUS_CONNECTION_DISCONNECTED, -ECONNABORTED,
766 "STATUS_CONNECTION_DISCONNECTED"}, 768 "STATUS_CONNECTION_DISCONNECTED"},
767 {STATUS_CONNECTION_RESET, -ENETRESET, "STATUS_CONNECTION_RESET"}, 769 {STATUS_CONNECTION_RESET, -ENETRESET, "STATUS_CONNECTION_RESET"},
768 {STATUS_TOO_MANY_NODES, -EIO, "STATUS_TOO_MANY_NODES"}, 770 {STATUS_TOO_MANY_NODES, -EIO, "STATUS_TOO_MANY_NODES"},
769 {STATUS_TRANSACTION_ABORTED, -EIO, "STATUS_TRANSACTION_ABORTED"}, 771 {STATUS_TRANSACTION_ABORTED, -EIO, "STATUS_TRANSACTION_ABORTED"},
770 {STATUS_TRANSACTION_TIMED_OUT, -EIO, "STATUS_TRANSACTION_TIMED_OUT"}, 772 {STATUS_TRANSACTION_TIMED_OUT, -EIO, "STATUS_TRANSACTION_TIMED_OUT"},
771 {STATUS_TRANSACTION_NO_RELEASE, -EIO, "STATUS_TRANSACTION_NO_RELEASE"}, 773 {STATUS_TRANSACTION_NO_RELEASE, -EIO, "STATUS_TRANSACTION_NO_RELEASE"},
772 {STATUS_TRANSACTION_NO_MATCH, -EIO, "STATUS_TRANSACTION_NO_MATCH"}, 774 {STATUS_TRANSACTION_NO_MATCH, -EIO, "STATUS_TRANSACTION_NO_MATCH"},
773 {STATUS_TRANSACTION_RESPONDED, -EIO, "STATUS_TRANSACTION_RESPONDED"}, 775 {STATUS_TRANSACTION_RESPONDED, -EIO, "STATUS_TRANSACTION_RESPONDED"},
774 {STATUS_TRANSACTION_INVALID_ID, -EIO, "STATUS_TRANSACTION_INVALID_ID"}, 776 {STATUS_TRANSACTION_INVALID_ID, -EIO, "STATUS_TRANSACTION_INVALID_ID"},
775 {STATUS_TRANSACTION_INVALID_TYPE, -EIO, 777 {STATUS_TRANSACTION_INVALID_TYPE, -EIO,
776 "STATUS_TRANSACTION_INVALID_TYPE"}, 778 "STATUS_TRANSACTION_INVALID_TYPE"},
777 {STATUS_NOT_SERVER_SESSION, -EIO, "STATUS_NOT_SERVER_SESSION"}, 779 {STATUS_NOT_SERVER_SESSION, -EIO, "STATUS_NOT_SERVER_SESSION"},
778 {STATUS_NOT_CLIENT_SESSION, -EIO, "STATUS_NOT_CLIENT_SESSION"}, 780 {STATUS_NOT_CLIENT_SESSION, -EIO, "STATUS_NOT_CLIENT_SESSION"},
779 {STATUS_CANNOT_LOAD_REGISTRY_FILE, -EIO, 781 {STATUS_CANNOT_LOAD_REGISTRY_FILE, -EIO,
780 "STATUS_CANNOT_LOAD_REGISTRY_FILE"}, 782 "STATUS_CANNOT_LOAD_REGISTRY_FILE"},
781 {STATUS_DEBUG_ATTACH_FAILED, -EIO, "STATUS_DEBUG_ATTACH_FAILED"}, 783 {STATUS_DEBUG_ATTACH_FAILED, -EIO, "STATUS_DEBUG_ATTACH_FAILED"},
782 {STATUS_SYSTEM_PROCESS_TERMINATED, -EIO, 784 {STATUS_SYSTEM_PROCESS_TERMINATED, -EIO,
783 "STATUS_SYSTEM_PROCESS_TERMINATED"}, 785 "STATUS_SYSTEM_PROCESS_TERMINATED"},
784 {STATUS_DATA_NOT_ACCEPTED, -EIO, "STATUS_DATA_NOT_ACCEPTED"}, 786 {STATUS_DATA_NOT_ACCEPTED, -EIO, "STATUS_DATA_NOT_ACCEPTED"},
785 {STATUS_NO_BROWSER_SERVERS_FOUND, -EIO, 787 {STATUS_NO_BROWSER_SERVERS_FOUND, -EIO,
786 "STATUS_NO_BROWSER_SERVERS_FOUND"}, 788 "STATUS_NO_BROWSER_SERVERS_FOUND"},
787 {STATUS_VDM_HARD_ERROR, -EIO, "STATUS_VDM_HARD_ERROR"}, 789 {STATUS_VDM_HARD_ERROR, -EIO, "STATUS_VDM_HARD_ERROR"},
788 {STATUS_DRIVER_CANCEL_TIMEOUT, -EIO, "STATUS_DRIVER_CANCEL_TIMEOUT"}, 790 {STATUS_DRIVER_CANCEL_TIMEOUT, -EIO, "STATUS_DRIVER_CANCEL_TIMEOUT"},
789 {STATUS_REPLY_MESSAGE_MISMATCH, -EIO, "STATUS_REPLY_MESSAGE_MISMATCH"}, 791 {STATUS_REPLY_MESSAGE_MISMATCH, -EIO, "STATUS_REPLY_MESSAGE_MISMATCH"},
790 {STATUS_MAPPED_ALIGNMENT, -EIO, "STATUS_MAPPED_ALIGNMENT"}, 792 {STATUS_MAPPED_ALIGNMENT, -EIO, "STATUS_MAPPED_ALIGNMENT"},
791 {STATUS_IMAGE_CHECKSUM_MISMATCH, -EIO, 793 {STATUS_IMAGE_CHECKSUM_MISMATCH, -EIO,
792 "STATUS_IMAGE_CHECKSUM_MISMATCH"}, 794 "STATUS_IMAGE_CHECKSUM_MISMATCH"},
793 {STATUS_LOST_WRITEBEHIND_DATA, -EIO, "STATUS_LOST_WRITEBEHIND_DATA"}, 795 {STATUS_LOST_WRITEBEHIND_DATA, -EIO, "STATUS_LOST_WRITEBEHIND_DATA"},
794 {STATUS_CLIENT_SERVER_PARAMETERS_INVALID, -EIO, 796 {STATUS_CLIENT_SERVER_PARAMETERS_INVALID, -EIO,
795 "STATUS_CLIENT_SERVER_PARAMETERS_INVALID"}, 797 "STATUS_CLIENT_SERVER_PARAMETERS_INVALID"},
796 {STATUS_PASSWORD_MUST_CHANGE, -EIO, "STATUS_PASSWORD_MUST_CHANGE"}, 798 {STATUS_PASSWORD_MUST_CHANGE, -EIO, "STATUS_PASSWORD_MUST_CHANGE"},
797 {STATUS_NOT_FOUND, -ENOENT, "STATUS_NOT_FOUND"}, 799 {STATUS_NOT_FOUND, -ENOENT, "STATUS_NOT_FOUND"},
798 {STATUS_NOT_TINY_STREAM, -EIO, "STATUS_NOT_TINY_STREAM"}, 800 {STATUS_NOT_TINY_STREAM, -EIO, "STATUS_NOT_TINY_STREAM"},
799 {STATUS_RECOVERY_FAILURE, -EIO, "STATUS_RECOVERY_FAILURE"}, 801 {STATUS_RECOVERY_FAILURE, -EIO, "STATUS_RECOVERY_FAILURE"},
800 {STATUS_STACK_OVERFLOW_READ, -EIO, "STATUS_STACK_OVERFLOW_READ"}, 802 {STATUS_STACK_OVERFLOW_READ, -EIO, "STATUS_STACK_OVERFLOW_READ"},
801 {STATUS_FAIL_CHECK, -EIO, "STATUS_FAIL_CHECK"}, 803 {STATUS_FAIL_CHECK, -EIO, "STATUS_FAIL_CHECK"},
802 {STATUS_DUPLICATE_OBJECTID, -EIO, "STATUS_DUPLICATE_OBJECTID"}, 804 {STATUS_DUPLICATE_OBJECTID, -EIO, "STATUS_DUPLICATE_OBJECTID"},
803 {STATUS_OBJECTID_EXISTS, -EIO, "STATUS_OBJECTID_EXISTS"}, 805 {STATUS_OBJECTID_EXISTS, -EIO, "STATUS_OBJECTID_EXISTS"},
804 {STATUS_CONVERT_TO_LARGE, -EIO, "STATUS_CONVERT_TO_LARGE"}, 806 {STATUS_CONVERT_TO_LARGE, -EIO, "STATUS_CONVERT_TO_LARGE"},
805 {STATUS_RETRY, -EAGAIN, "STATUS_RETRY"}, 807 {STATUS_RETRY, -EAGAIN, "STATUS_RETRY"},
806 {STATUS_FOUND_OUT_OF_SCOPE, -EIO, "STATUS_FOUND_OUT_OF_SCOPE"}, 808 {STATUS_FOUND_OUT_OF_SCOPE, -EIO, "STATUS_FOUND_OUT_OF_SCOPE"},
807 {STATUS_ALLOCATE_BUCKET, -EIO, "STATUS_ALLOCATE_BUCKET"}, 809 {STATUS_ALLOCATE_BUCKET, -EIO, "STATUS_ALLOCATE_BUCKET"},
808 {STATUS_PROPSET_NOT_FOUND, -EIO, "STATUS_PROPSET_NOT_FOUND"}, 810 {STATUS_PROPSET_NOT_FOUND, -EIO, "STATUS_PROPSET_NOT_FOUND"},
809 {STATUS_MARSHALL_OVERFLOW, -EIO, "STATUS_MARSHALL_OVERFLOW"}, 811 {STATUS_MARSHALL_OVERFLOW, -EIO, "STATUS_MARSHALL_OVERFLOW"},
810 {STATUS_INVALID_VARIANT, -EIO, "STATUS_INVALID_VARIANT"}, 812 {STATUS_INVALID_VARIANT, -EIO, "STATUS_INVALID_VARIANT"},
811 {STATUS_DOMAIN_CONTROLLER_NOT_FOUND, -EIO, 813 {STATUS_DOMAIN_CONTROLLER_NOT_FOUND, -EIO,
812 "STATUS_DOMAIN_CONTROLLER_NOT_FOUND"}, 814 "STATUS_DOMAIN_CONTROLLER_NOT_FOUND"},
813 {STATUS_ACCOUNT_LOCKED_OUT, -EIO, "STATUS_ACCOUNT_LOCKED_OUT"}, 815 {STATUS_ACCOUNT_LOCKED_OUT, -EIO, "STATUS_ACCOUNT_LOCKED_OUT"},
814 {STATUS_HANDLE_NOT_CLOSABLE, -EIO, "STATUS_HANDLE_NOT_CLOSABLE"}, 816 {STATUS_HANDLE_NOT_CLOSABLE, -EIO, "STATUS_HANDLE_NOT_CLOSABLE"},
815 {STATUS_CONNECTION_REFUSED, -EIO, "STATUS_CONNECTION_REFUSED"}, 817 {STATUS_CONNECTION_REFUSED, -EIO, "STATUS_CONNECTION_REFUSED"},
816 {STATUS_GRACEFUL_DISCONNECT, -EIO, "STATUS_GRACEFUL_DISCONNECT"}, 818 {STATUS_GRACEFUL_DISCONNECT, -EIO, "STATUS_GRACEFUL_DISCONNECT"},
817 {STATUS_ADDRESS_ALREADY_ASSOCIATED, -EIO, 819 {STATUS_ADDRESS_ALREADY_ASSOCIATED, -EIO,
818 "STATUS_ADDRESS_ALREADY_ASSOCIATED"}, 820 "STATUS_ADDRESS_ALREADY_ASSOCIATED"},
819 {STATUS_ADDRESS_NOT_ASSOCIATED, -EIO, "STATUS_ADDRESS_NOT_ASSOCIATED"}, 821 {STATUS_ADDRESS_NOT_ASSOCIATED, -EIO, "STATUS_ADDRESS_NOT_ASSOCIATED"},
820 {STATUS_CONNECTION_INVALID, -EIO, "STATUS_CONNECTION_INVALID"}, 822 {STATUS_CONNECTION_INVALID, -EIO, "STATUS_CONNECTION_INVALID"},
821 {STATUS_CONNECTION_ACTIVE, -EIO, "STATUS_CONNECTION_ACTIVE"}, 823 {STATUS_CONNECTION_ACTIVE, -EIO, "STATUS_CONNECTION_ACTIVE"},
822 {STATUS_NETWORK_UNREACHABLE, -ENETUNREACH, 824 {STATUS_NETWORK_UNREACHABLE, -ENETUNREACH,
823 "STATUS_NETWORK_UNREACHABLE"}, 825 "STATUS_NETWORK_UNREACHABLE"},
824 {STATUS_HOST_UNREACHABLE, -EHOSTDOWN, "STATUS_HOST_UNREACHABLE"}, 826 {STATUS_HOST_UNREACHABLE, -EHOSTDOWN, "STATUS_HOST_UNREACHABLE"},
825 {STATUS_PROTOCOL_UNREACHABLE, -ENETUNREACH, 827 {STATUS_PROTOCOL_UNREACHABLE, -ENETUNREACH,
826 "STATUS_PROTOCOL_UNREACHABLE"}, 828 "STATUS_PROTOCOL_UNREACHABLE"},
827 {STATUS_PORT_UNREACHABLE, -ENETUNREACH, "STATUS_PORT_UNREACHABLE"}, 829 {STATUS_PORT_UNREACHABLE, -ENETUNREACH, "STATUS_PORT_UNREACHABLE"},
828 {STATUS_REQUEST_ABORTED, -EIO, "STATUS_REQUEST_ABORTED"}, 830 {STATUS_REQUEST_ABORTED, -EIO, "STATUS_REQUEST_ABORTED"},
829 {STATUS_CONNECTION_ABORTED, -ECONNABORTED, "STATUS_CONNECTION_ABORTED"}, 831 {STATUS_CONNECTION_ABORTED, -ECONNABORTED, "STATUS_CONNECTION_ABORTED"},
830 {STATUS_BAD_COMPRESSION_BUFFER, -EIO, "STATUS_BAD_COMPRESSION_BUFFER"}, 832 {STATUS_BAD_COMPRESSION_BUFFER, -EIO, "STATUS_BAD_COMPRESSION_BUFFER"},
831 {STATUS_USER_MAPPED_FILE, -EIO, "STATUS_USER_MAPPED_FILE"}, 833 {STATUS_USER_MAPPED_FILE, -EIO, "STATUS_USER_MAPPED_FILE"},
832 {STATUS_AUDIT_FAILED, -EIO, "STATUS_AUDIT_FAILED"}, 834 {STATUS_AUDIT_FAILED, -EIO, "STATUS_AUDIT_FAILED"},
833 {STATUS_TIMER_RESOLUTION_NOT_SET, -EIO, 835 {STATUS_TIMER_RESOLUTION_NOT_SET, -EIO,
834 "STATUS_TIMER_RESOLUTION_NOT_SET"}, 836 "STATUS_TIMER_RESOLUTION_NOT_SET"},
835 {STATUS_CONNECTION_COUNT_LIMIT, -EIO, "STATUS_CONNECTION_COUNT_LIMIT"}, 837 {STATUS_CONNECTION_COUNT_LIMIT, -EIO, "STATUS_CONNECTION_COUNT_LIMIT"},
836 {STATUS_LOGIN_TIME_RESTRICTION, -EACCES, 838 {STATUS_LOGIN_TIME_RESTRICTION, -EACCES,
837 "STATUS_LOGIN_TIME_RESTRICTION"}, 839 "STATUS_LOGIN_TIME_RESTRICTION"},
838 {STATUS_LOGIN_WKSTA_RESTRICTION, -EACCES, 840 {STATUS_LOGIN_WKSTA_RESTRICTION, -EACCES,
839 "STATUS_LOGIN_WKSTA_RESTRICTION"}, 841 "STATUS_LOGIN_WKSTA_RESTRICTION"},
840 {STATUS_IMAGE_MP_UP_MISMATCH, -EIO, "STATUS_IMAGE_MP_UP_MISMATCH"}, 842 {STATUS_IMAGE_MP_UP_MISMATCH, -EIO, "STATUS_IMAGE_MP_UP_MISMATCH"},
841 {STATUS_INSUFFICIENT_LOGON_INFO, -EIO, 843 {STATUS_INSUFFICIENT_LOGON_INFO, -EIO,
842 "STATUS_INSUFFICIENT_LOGON_INFO"}, 844 "STATUS_INSUFFICIENT_LOGON_INFO"},
843 {STATUS_BAD_DLL_ENTRYPOINT, -EIO, "STATUS_BAD_DLL_ENTRYPOINT"}, 845 {STATUS_BAD_DLL_ENTRYPOINT, -EIO, "STATUS_BAD_DLL_ENTRYPOINT"},
844 {STATUS_BAD_SERVICE_ENTRYPOINT, -EIO, "STATUS_BAD_SERVICE_ENTRYPOINT"}, 846 {STATUS_BAD_SERVICE_ENTRYPOINT, -EIO, "STATUS_BAD_SERVICE_ENTRYPOINT"},
845 {STATUS_LPC_REPLY_LOST, -EIO, "STATUS_LPC_REPLY_LOST"}, 847 {STATUS_LPC_REPLY_LOST, -EIO, "STATUS_LPC_REPLY_LOST"},
846 {STATUS_IP_ADDRESS_CONFLICT1, -EIO, "STATUS_IP_ADDRESS_CONFLICT1"}, 848 {STATUS_IP_ADDRESS_CONFLICT1, -EIO, "STATUS_IP_ADDRESS_CONFLICT1"},
847 {STATUS_IP_ADDRESS_CONFLICT2, -EIO, "STATUS_IP_ADDRESS_CONFLICT2"}, 849 {STATUS_IP_ADDRESS_CONFLICT2, -EIO, "STATUS_IP_ADDRESS_CONFLICT2"},
848 {STATUS_REGISTRY_QUOTA_LIMIT, -EDQUOT, "STATUS_REGISTRY_QUOTA_LIMIT"}, 850 {STATUS_REGISTRY_QUOTA_LIMIT, -EDQUOT, "STATUS_REGISTRY_QUOTA_LIMIT"},
849 {STATUS_PATH_NOT_COVERED, -EREMOTE, "STATUS_PATH_NOT_COVERED"}, 851 {STATUS_PATH_NOT_COVERED, -EREMOTE, "STATUS_PATH_NOT_COVERED"},
850 {STATUS_NO_CALLBACK_ACTIVE, -EIO, "STATUS_NO_CALLBACK_ACTIVE"}, 852 {STATUS_NO_CALLBACK_ACTIVE, -EIO, "STATUS_NO_CALLBACK_ACTIVE"},
851 {STATUS_LICENSE_QUOTA_EXCEEDED, -EACCES, 853 {STATUS_LICENSE_QUOTA_EXCEEDED, -EACCES,
852 "STATUS_LICENSE_QUOTA_EXCEEDED"}, 854 "STATUS_LICENSE_QUOTA_EXCEEDED"},
853 {STATUS_PWD_TOO_SHORT, -EIO, "STATUS_PWD_TOO_SHORT"}, 855 {STATUS_PWD_TOO_SHORT, -EIO, "STATUS_PWD_TOO_SHORT"},
854 {STATUS_PWD_TOO_RECENT, -EIO, "STATUS_PWD_TOO_RECENT"}, 856 {STATUS_PWD_TOO_RECENT, -EIO, "STATUS_PWD_TOO_RECENT"},
855 {STATUS_PWD_HISTORY_CONFLICT, -EIO, "STATUS_PWD_HISTORY_CONFLICT"}, 857 {STATUS_PWD_HISTORY_CONFLICT, -EIO, "STATUS_PWD_HISTORY_CONFLICT"},
856 {STATUS_PLUGPLAY_NO_DEVICE, -EIO, "STATUS_PLUGPLAY_NO_DEVICE"}, 858 {STATUS_PLUGPLAY_NO_DEVICE, -EIO, "STATUS_PLUGPLAY_NO_DEVICE"},
857 {STATUS_UNSUPPORTED_COMPRESSION, -EIO, 859 {STATUS_UNSUPPORTED_COMPRESSION, -EIO,
858 "STATUS_UNSUPPORTED_COMPRESSION"}, 860 "STATUS_UNSUPPORTED_COMPRESSION"},
859 {STATUS_INVALID_HW_PROFILE, -EIO, "STATUS_INVALID_HW_PROFILE"}, 861 {STATUS_INVALID_HW_PROFILE, -EIO, "STATUS_INVALID_HW_PROFILE"},
860 {STATUS_INVALID_PLUGPLAY_DEVICE_PATH, -EIO, 862 {STATUS_INVALID_PLUGPLAY_DEVICE_PATH, -EIO,
861 "STATUS_INVALID_PLUGPLAY_DEVICE_PATH"}, 863 "STATUS_INVALID_PLUGPLAY_DEVICE_PATH"},
862 {STATUS_DRIVER_ORDINAL_NOT_FOUND, -EIO, 864 {STATUS_DRIVER_ORDINAL_NOT_FOUND, -EIO,
863 "STATUS_DRIVER_ORDINAL_NOT_FOUND"}, 865 "STATUS_DRIVER_ORDINAL_NOT_FOUND"},
864 {STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, -EIO, 866 {STATUS_DRIVER_ENTRYPOINT_NOT_FOUND, -EIO,
865 "STATUS_DRIVER_ENTRYPOINT_NOT_FOUND"}, 867 "STATUS_DRIVER_ENTRYPOINT_NOT_FOUND"},
866 {STATUS_RESOURCE_NOT_OWNED, -EIO, "STATUS_RESOURCE_NOT_OWNED"}, 868 {STATUS_RESOURCE_NOT_OWNED, -EIO, "STATUS_RESOURCE_NOT_OWNED"},
867 {STATUS_TOO_MANY_LINKS, -EMLINK, "STATUS_TOO_MANY_LINKS"}, 869 {STATUS_TOO_MANY_LINKS, -EMLINK, "STATUS_TOO_MANY_LINKS"},
868 {STATUS_QUOTA_LIST_INCONSISTENT, -EIO, 870 {STATUS_QUOTA_LIST_INCONSISTENT, -EIO,
869 "STATUS_QUOTA_LIST_INCONSISTENT"}, 871 "STATUS_QUOTA_LIST_INCONSISTENT"},
870 {STATUS_FILE_IS_OFFLINE, -EIO, "STATUS_FILE_IS_OFFLINE"}, 872 {STATUS_FILE_IS_OFFLINE, -EIO, "STATUS_FILE_IS_OFFLINE"},
871 {STATUS_EVALUATION_EXPIRATION, -EIO, "STATUS_EVALUATION_EXPIRATION"}, 873 {STATUS_EVALUATION_EXPIRATION, -EIO, "STATUS_EVALUATION_EXPIRATION"},
872 {STATUS_ILLEGAL_DLL_RELOCATION, -EIO, "STATUS_ILLEGAL_DLL_RELOCATION"}, 874 {STATUS_ILLEGAL_DLL_RELOCATION, -EIO, "STATUS_ILLEGAL_DLL_RELOCATION"},
873 {STATUS_LICENSE_VIOLATION, -EIO, "STATUS_LICENSE_VIOLATION"}, 875 {STATUS_LICENSE_VIOLATION, -EIO, "STATUS_LICENSE_VIOLATION"},
874 {STATUS_DLL_INIT_FAILED_LOGOFF, -EIO, "STATUS_DLL_INIT_FAILED_LOGOFF"}, 876 {STATUS_DLL_INIT_FAILED_LOGOFF, -EIO, "STATUS_DLL_INIT_FAILED_LOGOFF"},
875 {STATUS_DRIVER_UNABLE_TO_LOAD, -EIO, "STATUS_DRIVER_UNABLE_TO_LOAD"}, 877 {STATUS_DRIVER_UNABLE_TO_LOAD, -EIO, "STATUS_DRIVER_UNABLE_TO_LOAD"},
876 {STATUS_DFS_UNAVAILABLE, -EIO, "STATUS_DFS_UNAVAILABLE"}, 878 {STATUS_DFS_UNAVAILABLE, -EIO, "STATUS_DFS_UNAVAILABLE"},
877 {STATUS_VOLUME_DISMOUNTED, -EIO, "STATUS_VOLUME_DISMOUNTED"}, 879 {STATUS_VOLUME_DISMOUNTED, -EIO, "STATUS_VOLUME_DISMOUNTED"},
878 {STATUS_WX86_INTERNAL_ERROR, -EIO, "STATUS_WX86_INTERNAL_ERROR"}, 880 {STATUS_WX86_INTERNAL_ERROR, -EIO, "STATUS_WX86_INTERNAL_ERROR"},
879 {STATUS_WX86_FLOAT_STACK_CHECK, -EIO, "STATUS_WX86_FLOAT_STACK_CHECK"}, 881 {STATUS_WX86_FLOAT_STACK_CHECK, -EIO, "STATUS_WX86_FLOAT_STACK_CHECK"},
880 {STATUS_VALIDATE_CONTINUE, -EIO, "STATUS_VALIDATE_CONTINUE"}, 882 {STATUS_VALIDATE_CONTINUE, -EIO, "STATUS_VALIDATE_CONTINUE"},
881 {STATUS_NO_MATCH, -EIO, "STATUS_NO_MATCH"}, 883 {STATUS_NO_MATCH, -EIO, "STATUS_NO_MATCH"},
882 {STATUS_NO_MORE_MATCHES, -EIO, "STATUS_NO_MORE_MATCHES"}, 884 {STATUS_NO_MORE_MATCHES, -EIO, "STATUS_NO_MORE_MATCHES"},
883 {STATUS_NOT_A_REPARSE_POINT, -EIO, "STATUS_NOT_A_REPARSE_POINT"}, 885 {STATUS_NOT_A_REPARSE_POINT, -EIO, "STATUS_NOT_A_REPARSE_POINT"},
884 {STATUS_IO_REPARSE_TAG_INVALID, -EIO, "STATUS_IO_REPARSE_TAG_INVALID"}, 886 {STATUS_IO_REPARSE_TAG_INVALID, -EIO, "STATUS_IO_REPARSE_TAG_INVALID"},
885 {STATUS_IO_REPARSE_TAG_MISMATCH, -EIO, 887 {STATUS_IO_REPARSE_TAG_MISMATCH, -EIO,
886 "STATUS_IO_REPARSE_TAG_MISMATCH"}, 888 "STATUS_IO_REPARSE_TAG_MISMATCH"},
887 {STATUS_IO_REPARSE_DATA_INVALID, -EIO, 889 {STATUS_IO_REPARSE_DATA_INVALID, -EIO,
888 "STATUS_IO_REPARSE_DATA_INVALID"}, 890 "STATUS_IO_REPARSE_DATA_INVALID"},
889 {STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EIO, 891 {STATUS_IO_REPARSE_TAG_NOT_HANDLED, -EIO,
890 "STATUS_IO_REPARSE_TAG_NOT_HANDLED"}, 892 "STATUS_IO_REPARSE_TAG_NOT_HANDLED"},
891 {STATUS_REPARSE_POINT_NOT_RESOLVED, -EIO, 893 {STATUS_REPARSE_POINT_NOT_RESOLVED, -EIO,
892 "STATUS_REPARSE_POINT_NOT_RESOLVED"}, 894 "STATUS_REPARSE_POINT_NOT_RESOLVED"},
893 {STATUS_DIRECTORY_IS_A_REPARSE_POINT, -EIO, 895 {STATUS_DIRECTORY_IS_A_REPARSE_POINT, -EIO,
894 "STATUS_DIRECTORY_IS_A_REPARSE_POINT"}, 896 "STATUS_DIRECTORY_IS_A_REPARSE_POINT"},
895 {STATUS_RANGE_LIST_CONFLICT, -EIO, "STATUS_RANGE_LIST_CONFLICT"}, 897 {STATUS_RANGE_LIST_CONFLICT, -EIO, "STATUS_RANGE_LIST_CONFLICT"},
896 {STATUS_SOURCE_ELEMENT_EMPTY, -EIO, "STATUS_SOURCE_ELEMENT_EMPTY"}, 898 {STATUS_SOURCE_ELEMENT_EMPTY, -EIO, "STATUS_SOURCE_ELEMENT_EMPTY"},
897 {STATUS_DESTINATION_ELEMENT_FULL, -EIO, 899 {STATUS_DESTINATION_ELEMENT_FULL, -EIO,
898 "STATUS_DESTINATION_ELEMENT_FULL"}, 900 "STATUS_DESTINATION_ELEMENT_FULL"},
899 {STATUS_ILLEGAL_ELEMENT_ADDRESS, -EIO, 901 {STATUS_ILLEGAL_ELEMENT_ADDRESS, -EIO,
900 "STATUS_ILLEGAL_ELEMENT_ADDRESS"}, 902 "STATUS_ILLEGAL_ELEMENT_ADDRESS"},
901 {STATUS_MAGAZINE_NOT_PRESENT, -EIO, "STATUS_MAGAZINE_NOT_PRESENT"}, 903 {STATUS_MAGAZINE_NOT_PRESENT, -EIO, "STATUS_MAGAZINE_NOT_PRESENT"},
902 {STATUS_REINITIALIZATION_NEEDED, -EIO, 904 {STATUS_REINITIALIZATION_NEEDED, -EIO,
903 "STATUS_REINITIALIZATION_NEEDED"}, 905 "STATUS_REINITIALIZATION_NEEDED"},
904 {STATUS_ENCRYPTION_FAILED, -EIO, "STATUS_ENCRYPTION_FAILED"}, 906 {STATUS_ENCRYPTION_FAILED, -EIO, "STATUS_ENCRYPTION_FAILED"},
905 {STATUS_DECRYPTION_FAILED, -EIO, "STATUS_DECRYPTION_FAILED"}, 907 {STATUS_DECRYPTION_FAILED, -EIO, "STATUS_DECRYPTION_FAILED"},
906 {STATUS_RANGE_NOT_FOUND, -EIO, "STATUS_RANGE_NOT_FOUND"}, 908 {STATUS_RANGE_NOT_FOUND, -EIO, "STATUS_RANGE_NOT_FOUND"},
907 {STATUS_NO_RECOVERY_POLICY, -EIO, "STATUS_NO_RECOVERY_POLICY"}, 909 {STATUS_NO_RECOVERY_POLICY, -EIO, "STATUS_NO_RECOVERY_POLICY"},
908 {STATUS_NO_EFS, -EIO, "STATUS_NO_EFS"}, 910 {STATUS_NO_EFS, -EIO, "STATUS_NO_EFS"},
909 {STATUS_WRONG_EFS, -EIO, "STATUS_WRONG_EFS"}, 911 {STATUS_WRONG_EFS, -EIO, "STATUS_WRONG_EFS"},
910 {STATUS_NO_USER_KEYS, -EIO, "STATUS_NO_USER_KEYS"}, 912 {STATUS_NO_USER_KEYS, -EIO, "STATUS_NO_USER_KEYS"},
911 {STATUS_FILE_NOT_ENCRYPTED, -EIO, "STATUS_FILE_NOT_ENCRYPTED"}, 913 {STATUS_FILE_NOT_ENCRYPTED, -EIO, "STATUS_FILE_NOT_ENCRYPTED"},
912 {STATUS_NOT_EXPORT_FORMAT, -EIO, "STATUS_NOT_EXPORT_FORMAT"}, 914 {STATUS_NOT_EXPORT_FORMAT, -EIO, "STATUS_NOT_EXPORT_FORMAT"},
913 {STATUS_FILE_ENCRYPTED, -EIO, "STATUS_FILE_ENCRYPTED"}, 915 {STATUS_FILE_ENCRYPTED, -EIO, "STATUS_FILE_ENCRYPTED"},
914 {STATUS_WMI_GUID_NOT_FOUND, -EIO, "STATUS_WMI_GUID_NOT_FOUND"}, 916 {STATUS_WMI_GUID_NOT_FOUND, -EIO, "STATUS_WMI_GUID_NOT_FOUND"},
915 {STATUS_WMI_INSTANCE_NOT_FOUND, -EIO, "STATUS_WMI_INSTANCE_NOT_FOUND"}, 917 {STATUS_WMI_INSTANCE_NOT_FOUND, -EIO, "STATUS_WMI_INSTANCE_NOT_FOUND"},
916 {STATUS_WMI_ITEMID_NOT_FOUND, -EIO, "STATUS_WMI_ITEMID_NOT_FOUND"}, 918 {STATUS_WMI_ITEMID_NOT_FOUND, -EIO, "STATUS_WMI_ITEMID_NOT_FOUND"},
917 {STATUS_WMI_TRY_AGAIN, -EIO, "STATUS_WMI_TRY_AGAIN"}, 919 {STATUS_WMI_TRY_AGAIN, -EIO, "STATUS_WMI_TRY_AGAIN"},
918 {STATUS_SHARED_POLICY, -EIO, "STATUS_SHARED_POLICY"}, 920 {STATUS_SHARED_POLICY, -EIO, "STATUS_SHARED_POLICY"},
919 {STATUS_POLICY_OBJECT_NOT_FOUND, -EIO, 921 {STATUS_POLICY_OBJECT_NOT_FOUND, -EIO,
920 "STATUS_POLICY_OBJECT_NOT_FOUND"}, 922 "STATUS_POLICY_OBJECT_NOT_FOUND"},
921 {STATUS_POLICY_ONLY_IN_DS, -EIO, "STATUS_POLICY_ONLY_IN_DS"}, 923 {STATUS_POLICY_ONLY_IN_DS, -EIO, "STATUS_POLICY_ONLY_IN_DS"},
922 {STATUS_VOLUME_NOT_UPGRADED, -EIO, "STATUS_VOLUME_NOT_UPGRADED"}, 924 {STATUS_VOLUME_NOT_UPGRADED, -EIO, "STATUS_VOLUME_NOT_UPGRADED"},
923 {STATUS_REMOTE_STORAGE_NOT_ACTIVE, -EIO, 925 {STATUS_REMOTE_STORAGE_NOT_ACTIVE, -EIO,
924 "STATUS_REMOTE_STORAGE_NOT_ACTIVE"}, 926 "STATUS_REMOTE_STORAGE_NOT_ACTIVE"},
925 {STATUS_REMOTE_STORAGE_MEDIA_ERROR, -EIO, 927 {STATUS_REMOTE_STORAGE_MEDIA_ERROR, -EIO,
926 "STATUS_REMOTE_STORAGE_MEDIA_ERROR"}, 928 "STATUS_REMOTE_STORAGE_MEDIA_ERROR"},
927 {STATUS_NO_TRACKING_SERVICE, -EIO, "STATUS_NO_TRACKING_SERVICE"}, 929 {STATUS_NO_TRACKING_SERVICE, -EIO, "STATUS_NO_TRACKING_SERVICE"},
928 {STATUS_SERVER_SID_MISMATCH, -EIO, "STATUS_SERVER_SID_MISMATCH"}, 930 {STATUS_SERVER_SID_MISMATCH, -EIO, "STATUS_SERVER_SID_MISMATCH"},
929 {STATUS_DS_NO_ATTRIBUTE_OR_VALUE, -EIO, 931 {STATUS_DS_NO_ATTRIBUTE_OR_VALUE, -EIO,
930 "STATUS_DS_NO_ATTRIBUTE_OR_VALUE"}, 932 "STATUS_DS_NO_ATTRIBUTE_OR_VALUE"},
931 {STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, -EIO, 933 {STATUS_DS_INVALID_ATTRIBUTE_SYNTAX, -EIO,
932 "STATUS_DS_INVALID_ATTRIBUTE_SYNTAX"}, 934 "STATUS_DS_INVALID_ATTRIBUTE_SYNTAX"},
933 {STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, -EIO, 935 {STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED, -EIO,
934 "STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED"}, 936 "STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED"},
935 {STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, -EIO, 937 {STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS, -EIO,
936 "STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS"}, 938 "STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS"},
937 {STATUS_DS_BUSY, -EBUSY, "STATUS_DS_BUSY"}, 939 {STATUS_DS_BUSY, -EBUSY, "STATUS_DS_BUSY"},
938 {STATUS_DS_UNAVAILABLE, -EIO, "STATUS_DS_UNAVAILABLE"}, 940 {STATUS_DS_UNAVAILABLE, -EIO, "STATUS_DS_UNAVAILABLE"},
939 {STATUS_DS_NO_RIDS_ALLOCATED, -EIO, "STATUS_DS_NO_RIDS_ALLOCATED"}, 941 {STATUS_DS_NO_RIDS_ALLOCATED, -EIO, "STATUS_DS_NO_RIDS_ALLOCATED"},
940 {STATUS_DS_NO_MORE_RIDS, -EIO, "STATUS_DS_NO_MORE_RIDS"}, 942 {STATUS_DS_NO_MORE_RIDS, -EIO, "STATUS_DS_NO_MORE_RIDS"},
941 {STATUS_DS_INCORRECT_ROLE_OWNER, -EIO, 943 {STATUS_DS_INCORRECT_ROLE_OWNER, -EIO,
942 "STATUS_DS_INCORRECT_ROLE_OWNER"}, 944 "STATUS_DS_INCORRECT_ROLE_OWNER"},
943 {STATUS_DS_RIDMGR_INIT_ERROR, -EIO, "STATUS_DS_RIDMGR_INIT_ERROR"}, 945 {STATUS_DS_RIDMGR_INIT_ERROR, -EIO, "STATUS_DS_RIDMGR_INIT_ERROR"},
944 {STATUS_DS_OBJ_CLASS_VIOLATION, -EIO, "STATUS_DS_OBJ_CLASS_VIOLATION"}, 946 {STATUS_DS_OBJ_CLASS_VIOLATION, -EIO, "STATUS_DS_OBJ_CLASS_VIOLATION"},
945 {STATUS_DS_CANT_ON_NON_LEAF, -EIO, "STATUS_DS_CANT_ON_NON_LEAF"}, 947 {STATUS_DS_CANT_ON_NON_LEAF, -EIO, "STATUS_DS_CANT_ON_NON_LEAF"},
946 {STATUS_DS_CANT_ON_RDN, -EIO, "STATUS_DS_CANT_ON_RDN"}, 948 {STATUS_DS_CANT_ON_RDN, -EIO, "STATUS_DS_CANT_ON_RDN"},
947 {STATUS_DS_CANT_MOD_OBJ_CLASS, -EIO, "STATUS_DS_CANT_MOD_OBJ_CLASS"}, 949 {STATUS_DS_CANT_MOD_OBJ_CLASS, -EIO, "STATUS_DS_CANT_MOD_OBJ_CLASS"},
948 {STATUS_DS_CROSS_DOM_MOVE_FAILED, -EIO, 950 {STATUS_DS_CROSS_DOM_MOVE_FAILED, -EIO,
949 "STATUS_DS_CROSS_DOM_MOVE_FAILED"}, 951 "STATUS_DS_CROSS_DOM_MOVE_FAILED"},
950 {STATUS_DS_GC_NOT_AVAILABLE, -EIO, "STATUS_DS_GC_NOT_AVAILABLE"}, 952 {STATUS_DS_GC_NOT_AVAILABLE, -EIO, "STATUS_DS_GC_NOT_AVAILABLE"},
951 {STATUS_DIRECTORY_SERVICE_REQUIRED, -EIO, 953 {STATUS_DIRECTORY_SERVICE_REQUIRED, -EIO,
952 "STATUS_DIRECTORY_SERVICE_REQUIRED"}, 954 "STATUS_DIRECTORY_SERVICE_REQUIRED"},
953 {STATUS_REPARSE_ATTRIBUTE_CONFLICT, -EIO, 955 {STATUS_REPARSE_ATTRIBUTE_CONFLICT, -EIO,
954 "STATUS_REPARSE_ATTRIBUTE_CONFLICT"}, 956 "STATUS_REPARSE_ATTRIBUTE_CONFLICT"},
955 {STATUS_CANT_ENABLE_DENY_ONLY, -EIO, "STATUS_CANT_ENABLE_DENY_ONLY"}, 957 {STATUS_CANT_ENABLE_DENY_ONLY, -EIO, "STATUS_CANT_ENABLE_DENY_ONLY"},
956 {STATUS_FLOAT_MULTIPLE_FAULTS, -EIO, "STATUS_FLOAT_MULTIPLE_FAULTS"}, 958 {STATUS_FLOAT_MULTIPLE_FAULTS, -EIO, "STATUS_FLOAT_MULTIPLE_FAULTS"},
957 {STATUS_FLOAT_MULTIPLE_TRAPS, -EIO, "STATUS_FLOAT_MULTIPLE_TRAPS"}, 959 {STATUS_FLOAT_MULTIPLE_TRAPS, -EIO, "STATUS_FLOAT_MULTIPLE_TRAPS"},
958 {STATUS_DEVICE_REMOVED, -EIO, "STATUS_DEVICE_REMOVED"}, 960 {STATUS_DEVICE_REMOVED, -EIO, "STATUS_DEVICE_REMOVED"},
959 {STATUS_JOURNAL_DELETE_IN_PROGRESS, -EIO, 961 {STATUS_JOURNAL_DELETE_IN_PROGRESS, -EIO,
960 "STATUS_JOURNAL_DELETE_IN_PROGRESS"}, 962 "STATUS_JOURNAL_DELETE_IN_PROGRESS"},
961 {STATUS_JOURNAL_NOT_ACTIVE, -EIO, "STATUS_JOURNAL_NOT_ACTIVE"}, 963 {STATUS_JOURNAL_NOT_ACTIVE, -EIO, "STATUS_JOURNAL_NOT_ACTIVE"},
962 {STATUS_NOINTERFACE, -EIO, "STATUS_NOINTERFACE"}, 964 {STATUS_NOINTERFACE, -EIO, "STATUS_NOINTERFACE"},
963 {STATUS_DS_ADMIN_LIMIT_EXCEEDED, -EIO, 965 {STATUS_DS_ADMIN_LIMIT_EXCEEDED, -EIO,
964 "STATUS_DS_ADMIN_LIMIT_EXCEEDED"}, 966 "STATUS_DS_ADMIN_LIMIT_EXCEEDED"},
965 {STATUS_DRIVER_FAILED_SLEEP, -EIO, "STATUS_DRIVER_FAILED_SLEEP"}, 967 {STATUS_DRIVER_FAILED_SLEEP, -EIO, "STATUS_DRIVER_FAILED_SLEEP"},
966 {STATUS_MUTUAL_AUTHENTICATION_FAILED, -EIO, 968 {STATUS_MUTUAL_AUTHENTICATION_FAILED, -EIO,
967 "STATUS_MUTUAL_AUTHENTICATION_FAILED"}, 969 "STATUS_MUTUAL_AUTHENTICATION_FAILED"},
968 {STATUS_CORRUPT_SYSTEM_FILE, -EIO, "STATUS_CORRUPT_SYSTEM_FILE"}, 970 {STATUS_CORRUPT_SYSTEM_FILE, -EIO, "STATUS_CORRUPT_SYSTEM_FILE"},
969 {STATUS_DATATYPE_MISALIGNMENT_ERROR, -EIO, 971 {STATUS_DATATYPE_MISALIGNMENT_ERROR, -EIO,
970 "STATUS_DATATYPE_MISALIGNMENT_ERROR"}, 972 "STATUS_DATATYPE_MISALIGNMENT_ERROR"},
971 {STATUS_WMI_READ_ONLY, -EROFS, "STATUS_WMI_READ_ONLY"}, 973 {STATUS_WMI_READ_ONLY, -EROFS, "STATUS_WMI_READ_ONLY"},
972 {STATUS_WMI_SET_FAILURE, -EIO, "STATUS_WMI_SET_FAILURE"}, 974 {STATUS_WMI_SET_FAILURE, -EIO, "STATUS_WMI_SET_FAILURE"},
973 {STATUS_COMMITMENT_MINIMUM, -EIO, "STATUS_COMMITMENT_MINIMUM"}, 975 {STATUS_COMMITMENT_MINIMUM, -EIO, "STATUS_COMMITMENT_MINIMUM"},
974 {STATUS_REG_NAT_CONSUMPTION, -EIO, "STATUS_REG_NAT_CONSUMPTION"}, 976 {STATUS_REG_NAT_CONSUMPTION, -EIO, "STATUS_REG_NAT_CONSUMPTION"},
975 {STATUS_TRANSPORT_FULL, -EIO, "STATUS_TRANSPORT_FULL"}, 977 {STATUS_TRANSPORT_FULL, -EIO, "STATUS_TRANSPORT_FULL"},
976 {STATUS_DS_SAM_INIT_FAILURE, -EIO, "STATUS_DS_SAM_INIT_FAILURE"}, 978 {STATUS_DS_SAM_INIT_FAILURE, -EIO, "STATUS_DS_SAM_INIT_FAILURE"},
977 {STATUS_ONLY_IF_CONNECTED, -EIO, "STATUS_ONLY_IF_CONNECTED"}, 979 {STATUS_ONLY_IF_CONNECTED, -EIO, "STATUS_ONLY_IF_CONNECTED"},
978 {STATUS_DS_SENSITIVE_GROUP_VIOLATION, -EIO, 980 {STATUS_DS_SENSITIVE_GROUP_VIOLATION, -EIO,
979 "STATUS_DS_SENSITIVE_GROUP_VIOLATION"}, 981 "STATUS_DS_SENSITIVE_GROUP_VIOLATION"},
980 {STATUS_PNP_RESTART_ENUMERATION, -EIO, 982 {STATUS_PNP_RESTART_ENUMERATION, -EIO,
981 "STATUS_PNP_RESTART_ENUMERATION"}, 983 "STATUS_PNP_RESTART_ENUMERATION"},
982 {STATUS_JOURNAL_ENTRY_DELETED, -EIO, "STATUS_JOURNAL_ENTRY_DELETED"}, 984 {STATUS_JOURNAL_ENTRY_DELETED, -EIO, "STATUS_JOURNAL_ENTRY_DELETED"},
983 {STATUS_DS_CANT_MOD_PRIMARYGROUPID, -EIO, 985 {STATUS_DS_CANT_MOD_PRIMARYGROUPID, -EIO,
984 "STATUS_DS_CANT_MOD_PRIMARYGROUPID"}, 986 "STATUS_DS_CANT_MOD_PRIMARYGROUPID"},
985 {STATUS_SYSTEM_IMAGE_BAD_SIGNATURE, -EIO, 987 {STATUS_SYSTEM_IMAGE_BAD_SIGNATURE, -EIO,
986 "STATUS_SYSTEM_IMAGE_BAD_SIGNATURE"}, 988 "STATUS_SYSTEM_IMAGE_BAD_SIGNATURE"},
987 {STATUS_PNP_REBOOT_REQUIRED, -EIO, "STATUS_PNP_REBOOT_REQUIRED"}, 989 {STATUS_PNP_REBOOT_REQUIRED, -EIO, "STATUS_PNP_REBOOT_REQUIRED"},
988 {STATUS_POWER_STATE_INVALID, -EIO, "STATUS_POWER_STATE_INVALID"}, 990 {STATUS_POWER_STATE_INVALID, -EIO, "STATUS_POWER_STATE_INVALID"},
989 {STATUS_DS_INVALID_GROUP_TYPE, -EIO, "STATUS_DS_INVALID_GROUP_TYPE"}, 991 {STATUS_DS_INVALID_GROUP_TYPE, -EIO, "STATUS_DS_INVALID_GROUP_TYPE"},
990 {STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, -EIO, 992 {STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN, -EIO,
991 "STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN"}, 993 "STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN"},
992 {STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, -EIO, 994 {STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN, -EIO,
993 "STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN"}, 995 "STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN"},
994 {STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, -EIO, 996 {STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER, -EIO,
995 "STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER"}, 997 "STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER"},
996 {STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, -EIO, 998 {STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER, -EIO,
997 "STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER"}, 999 "STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER"},
998 {STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, -EIO, 1000 {STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER, -EIO,
999 "STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER"}, 1001 "STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER"},
1000 {STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, -EIO, 1002 {STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER, -EIO,
1001 "STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER"}, 1003 "STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER"},
1002 {STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, -EIO, 1004 {STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER, -EIO,
1003 "STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER"}, 1005 "STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER"},
1004 {STATUS_DS_HAVE_PRIMARY_MEMBERS, -EIO, 1006 {STATUS_DS_HAVE_PRIMARY_MEMBERS, -EIO,
1005 "STATUS_DS_HAVE_PRIMARY_MEMBERS"}, 1007 "STATUS_DS_HAVE_PRIMARY_MEMBERS"},
1006 {STATUS_WMI_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_WMI_NOT_SUPPORTED"}, 1008 {STATUS_WMI_NOT_SUPPORTED, -EOPNOTSUPP, "STATUS_WMI_NOT_SUPPORTED"},
1007 {STATUS_INSUFFICIENT_POWER, -EIO, "STATUS_INSUFFICIENT_POWER"}, 1009 {STATUS_INSUFFICIENT_POWER, -EIO, "STATUS_INSUFFICIENT_POWER"},
1008 {STATUS_SAM_NEED_BOOTKEY_PASSWORD, -EIO, 1010 {STATUS_SAM_NEED_BOOTKEY_PASSWORD, -EIO,
1009 "STATUS_SAM_NEED_BOOTKEY_PASSWORD"}, 1011 "STATUS_SAM_NEED_BOOTKEY_PASSWORD"},
1010 {STATUS_SAM_NEED_BOOTKEY_FLOPPY, -EIO, 1012 {STATUS_SAM_NEED_BOOTKEY_FLOPPY, -EIO,
1011 "STATUS_SAM_NEED_BOOTKEY_FLOPPY"}, 1013 "STATUS_SAM_NEED_BOOTKEY_FLOPPY"},
1012 {STATUS_DS_CANT_START, -EIO, "STATUS_DS_CANT_START"}, 1014 {STATUS_DS_CANT_START, -EIO, "STATUS_DS_CANT_START"},
1013 {STATUS_DS_INIT_FAILURE, -EIO, "STATUS_DS_INIT_FAILURE"}, 1015 {STATUS_DS_INIT_FAILURE, -EIO, "STATUS_DS_INIT_FAILURE"},
1014 {STATUS_SAM_INIT_FAILURE, -EIO, "STATUS_SAM_INIT_FAILURE"}, 1016 {STATUS_SAM_INIT_FAILURE, -EIO, "STATUS_SAM_INIT_FAILURE"},
1015 {STATUS_DS_GC_REQUIRED, -EIO, "STATUS_DS_GC_REQUIRED"}, 1017 {STATUS_DS_GC_REQUIRED, -EIO, "STATUS_DS_GC_REQUIRED"},
1016 {STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, -EIO, 1018 {STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY, -EIO,
1017 "STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY"}, 1019 "STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY"},
1018 {STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, -EIO, 1020 {STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS, -EIO,
1019 "STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS"}, 1021 "STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS"},
1020 {STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, -EDQUOT, 1022 {STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED, -EDQUOT,
1021 "STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"}, 1023 "STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED"},
1022 {STATUS_MULTIPLE_FAULT_VIOLATION, -EIO, 1024 {STATUS_MULTIPLE_FAULT_VIOLATION, -EIO,
1023 "STATUS_MULTIPLE_FAULT_VIOLATION"}, 1025 "STATUS_MULTIPLE_FAULT_VIOLATION"},
1024 {STATUS_CURRENT_DOMAIN_NOT_ALLOWED, -EIO, 1026 {STATUS_CURRENT_DOMAIN_NOT_ALLOWED, -EIO,
1025 "STATUS_CURRENT_DOMAIN_NOT_ALLOWED"}, 1027 "STATUS_CURRENT_DOMAIN_NOT_ALLOWED"},
1026 {STATUS_CANNOT_MAKE, -EIO, "STATUS_CANNOT_MAKE"}, 1028 {STATUS_CANNOT_MAKE, -EIO, "STATUS_CANNOT_MAKE"},
1027 {STATUS_SYSTEM_SHUTDOWN, -EIO, "STATUS_SYSTEM_SHUTDOWN"}, 1029 {STATUS_SYSTEM_SHUTDOWN, -EIO, "STATUS_SYSTEM_SHUTDOWN"},
1028 {STATUS_DS_INIT_FAILURE_CONSOLE, -EIO, 1030 {STATUS_DS_INIT_FAILURE_CONSOLE, -EIO,
1029 "STATUS_DS_INIT_FAILURE_CONSOLE"}, 1031 "STATUS_DS_INIT_FAILURE_CONSOLE"},
1030 {STATUS_DS_SAM_INIT_FAILURE_CONSOLE, -EIO, 1032 {STATUS_DS_SAM_INIT_FAILURE_CONSOLE, -EIO,
1031 "STATUS_DS_SAM_INIT_FAILURE_CONSOLE"}, 1033 "STATUS_DS_SAM_INIT_FAILURE_CONSOLE"},
1032 {STATUS_UNFINISHED_CONTEXT_DELETED, -EIO, 1034 {STATUS_UNFINISHED_CONTEXT_DELETED, -EIO,
1033 "STATUS_UNFINISHED_CONTEXT_DELETED"}, 1035 "STATUS_UNFINISHED_CONTEXT_DELETED"},
1034 {STATUS_NO_TGT_REPLY, -EIO, "STATUS_NO_TGT_REPLY"}, 1036 {STATUS_NO_TGT_REPLY, -EIO, "STATUS_NO_TGT_REPLY"},
1035 {STATUS_OBJECTID_NOT_FOUND, -EIO, "STATUS_OBJECTID_NOT_FOUND"}, 1037 {STATUS_OBJECTID_NOT_FOUND, -EIO, "STATUS_OBJECTID_NOT_FOUND"},
1036 {STATUS_NO_IP_ADDRESSES, -EIO, "STATUS_NO_IP_ADDRESSES"}, 1038 {STATUS_NO_IP_ADDRESSES, -EIO, "STATUS_NO_IP_ADDRESSES"},
1037 {STATUS_WRONG_CREDENTIAL_HANDLE, -EIO, 1039 {STATUS_WRONG_CREDENTIAL_HANDLE, -EIO,
1038 "STATUS_WRONG_CREDENTIAL_HANDLE"}, 1040 "STATUS_WRONG_CREDENTIAL_HANDLE"},
1039 {STATUS_CRYPTO_SYSTEM_INVALID, -EIO, "STATUS_CRYPTO_SYSTEM_INVALID"}, 1041 {STATUS_CRYPTO_SYSTEM_INVALID, -EIO, "STATUS_CRYPTO_SYSTEM_INVALID"},
1040 {STATUS_MAX_REFERRALS_EXCEEDED, -EIO, "STATUS_MAX_REFERRALS_EXCEEDED"}, 1042 {STATUS_MAX_REFERRALS_EXCEEDED, -EIO, "STATUS_MAX_REFERRALS_EXCEEDED"},
1041 {STATUS_MUST_BE_KDC, -EIO, "STATUS_MUST_BE_KDC"}, 1043 {STATUS_MUST_BE_KDC, -EIO, "STATUS_MUST_BE_KDC"},
1042 {STATUS_STRONG_CRYPTO_NOT_SUPPORTED, -EIO, 1044 {STATUS_STRONG_CRYPTO_NOT_SUPPORTED, -EIO,
1043 "STATUS_STRONG_CRYPTO_NOT_SUPPORTED"}, 1045 "STATUS_STRONG_CRYPTO_NOT_SUPPORTED"},
1044 {STATUS_TOO_MANY_PRINCIPALS, -EIO, "STATUS_TOO_MANY_PRINCIPALS"}, 1046 {STATUS_TOO_MANY_PRINCIPALS, -EIO, "STATUS_TOO_MANY_PRINCIPALS"},
1045 {STATUS_NO_PA_DATA, -EIO, "STATUS_NO_PA_DATA"}, 1047 {STATUS_NO_PA_DATA, -EIO, "STATUS_NO_PA_DATA"},
1046 {STATUS_PKINIT_NAME_MISMATCH, -EIO, "STATUS_PKINIT_NAME_MISMATCH"}, 1048 {STATUS_PKINIT_NAME_MISMATCH, -EIO, "STATUS_PKINIT_NAME_MISMATCH"},
1047 {STATUS_SMARTCARD_LOGON_REQUIRED, -EIO, 1049 {STATUS_SMARTCARD_LOGON_REQUIRED, -EIO,
1048 "STATUS_SMARTCARD_LOGON_REQUIRED"}, 1050 "STATUS_SMARTCARD_LOGON_REQUIRED"},
1049 {STATUS_KDC_INVALID_REQUEST, -EIO, "STATUS_KDC_INVALID_REQUEST"}, 1051 {STATUS_KDC_INVALID_REQUEST, -EIO, "STATUS_KDC_INVALID_REQUEST"},
1050 {STATUS_KDC_UNABLE_TO_REFER, -EIO, "STATUS_KDC_UNABLE_TO_REFER"}, 1052 {STATUS_KDC_UNABLE_TO_REFER, -EIO, "STATUS_KDC_UNABLE_TO_REFER"},
1051 {STATUS_KDC_UNKNOWN_ETYPE, -EIO, "STATUS_KDC_UNKNOWN_ETYPE"}, 1053 {STATUS_KDC_UNKNOWN_ETYPE, -EIO, "STATUS_KDC_UNKNOWN_ETYPE"},
1052 {STATUS_SHUTDOWN_IN_PROGRESS, -EIO, "STATUS_SHUTDOWN_IN_PROGRESS"}, 1054 {STATUS_SHUTDOWN_IN_PROGRESS, -EIO, "STATUS_SHUTDOWN_IN_PROGRESS"},
1053 {STATUS_SERVER_SHUTDOWN_IN_PROGRESS, -EIO, 1055 {STATUS_SERVER_SHUTDOWN_IN_PROGRESS, -EIO,
1054 "STATUS_SERVER_SHUTDOWN_IN_PROGRESS"}, 1056 "STATUS_SERVER_SHUTDOWN_IN_PROGRESS"},
1055 {STATUS_NOT_SUPPORTED_ON_SBS, -EOPNOTSUPP, 1057 {STATUS_NOT_SUPPORTED_ON_SBS, -EOPNOTSUPP,
1056 "STATUS_NOT_SUPPORTED_ON_SBS"}, 1058 "STATUS_NOT_SUPPORTED_ON_SBS"},
1057 {STATUS_WMI_GUID_DISCONNECTED, -EIO, "STATUS_WMI_GUID_DISCONNECTED"}, 1059 {STATUS_WMI_GUID_DISCONNECTED, -EIO, "STATUS_WMI_GUID_DISCONNECTED"},
1058 {STATUS_WMI_ALREADY_DISABLED, -EIO, "STATUS_WMI_ALREADY_DISABLED"}, 1060 {STATUS_WMI_ALREADY_DISABLED, -EIO, "STATUS_WMI_ALREADY_DISABLED"},
1059 {STATUS_WMI_ALREADY_ENABLED, -EIO, "STATUS_WMI_ALREADY_ENABLED"}, 1061 {STATUS_WMI_ALREADY_ENABLED, -EIO, "STATUS_WMI_ALREADY_ENABLED"},
1060 {STATUS_MFT_TOO_FRAGMENTED, -EIO, "STATUS_MFT_TOO_FRAGMENTED"}, 1062 {STATUS_MFT_TOO_FRAGMENTED, -EIO, "STATUS_MFT_TOO_FRAGMENTED"},
1061 {STATUS_COPY_PROTECTION_FAILURE, -EIO, 1063 {STATUS_COPY_PROTECTION_FAILURE, -EIO,
1062 "STATUS_COPY_PROTECTION_FAILURE"}, 1064 "STATUS_COPY_PROTECTION_FAILURE"},
1063 {STATUS_CSS_AUTHENTICATION_FAILURE, -EIO, 1065 {STATUS_CSS_AUTHENTICATION_FAILURE, -EIO,
1064 "STATUS_CSS_AUTHENTICATION_FAILURE"}, 1066 "STATUS_CSS_AUTHENTICATION_FAILURE"},
1065 {STATUS_CSS_KEY_NOT_PRESENT, -EIO, "STATUS_CSS_KEY_NOT_PRESENT"}, 1067 {STATUS_CSS_KEY_NOT_PRESENT, -EIO, "STATUS_CSS_KEY_NOT_PRESENT"},
1066 {STATUS_CSS_KEY_NOT_ESTABLISHED, -EIO, 1068 {STATUS_CSS_KEY_NOT_ESTABLISHED, -EIO,
1067 "STATUS_CSS_KEY_NOT_ESTABLISHED"}, 1069 "STATUS_CSS_KEY_NOT_ESTABLISHED"},
1068 {STATUS_CSS_SCRAMBLED_SECTOR, -EIO, "STATUS_CSS_SCRAMBLED_SECTOR"}, 1070 {STATUS_CSS_SCRAMBLED_SECTOR, -EIO, "STATUS_CSS_SCRAMBLED_SECTOR"},
1069 {STATUS_CSS_REGION_MISMATCH, -EIO, "STATUS_CSS_REGION_MISMATCH"}, 1071 {STATUS_CSS_REGION_MISMATCH, -EIO, "STATUS_CSS_REGION_MISMATCH"},
1070 {STATUS_CSS_RESETS_EXHAUSTED, -EIO, "STATUS_CSS_RESETS_EXHAUSTED"}, 1072 {STATUS_CSS_RESETS_EXHAUSTED, -EIO, "STATUS_CSS_RESETS_EXHAUSTED"},
1071 {STATUS_PKINIT_FAILURE, -EIO, "STATUS_PKINIT_FAILURE"}, 1073 {STATUS_PKINIT_FAILURE, -EIO, "STATUS_PKINIT_FAILURE"},
1072 {STATUS_SMARTCARD_SUBSYSTEM_FAILURE, -EIO, 1074 {STATUS_SMARTCARD_SUBSYSTEM_FAILURE, -EIO,
1073 "STATUS_SMARTCARD_SUBSYSTEM_FAILURE"}, 1075 "STATUS_SMARTCARD_SUBSYSTEM_FAILURE"},
1074 {STATUS_NO_KERB_KEY, -EIO, "STATUS_NO_KERB_KEY"}, 1076 {STATUS_NO_KERB_KEY, -EIO, "STATUS_NO_KERB_KEY"},
1075 {STATUS_HOST_DOWN, -EIO, "STATUS_HOST_DOWN"}, 1077 {STATUS_HOST_DOWN, -EIO, "STATUS_HOST_DOWN"},
1076 {STATUS_UNSUPPORTED_PREAUTH, -EIO, "STATUS_UNSUPPORTED_PREAUTH"}, 1078 {STATUS_UNSUPPORTED_PREAUTH, -EIO, "STATUS_UNSUPPORTED_PREAUTH"},
1077 {STATUS_EFS_ALG_BLOB_TOO_BIG, -EIO, "STATUS_EFS_ALG_BLOB_TOO_BIG"}, 1079 {STATUS_EFS_ALG_BLOB_TOO_BIG, -EIO, "STATUS_EFS_ALG_BLOB_TOO_BIG"},
1078 {STATUS_PORT_NOT_SET, -EIO, "STATUS_PORT_NOT_SET"}, 1080 {STATUS_PORT_NOT_SET, -EIO, "STATUS_PORT_NOT_SET"},
1079 {STATUS_DEBUGGER_INACTIVE, -EIO, "STATUS_DEBUGGER_INACTIVE"}, 1081 {STATUS_DEBUGGER_INACTIVE, -EIO, "STATUS_DEBUGGER_INACTIVE"},
1080 {STATUS_DS_VERSION_CHECK_FAILURE, -EIO, 1082 {STATUS_DS_VERSION_CHECK_FAILURE, -EIO,
1081 "STATUS_DS_VERSION_CHECK_FAILURE"}, 1083 "STATUS_DS_VERSION_CHECK_FAILURE"},
1082 {STATUS_AUDITING_DISABLED, -EIO, "STATUS_AUDITING_DISABLED"}, 1084 {STATUS_AUDITING_DISABLED, -EIO, "STATUS_AUDITING_DISABLED"},
1083 {STATUS_PRENT4_MACHINE_ACCOUNT, -EIO, "STATUS_PRENT4_MACHINE_ACCOUNT"}, 1085 {STATUS_PRENT4_MACHINE_ACCOUNT, -EIO, "STATUS_PRENT4_MACHINE_ACCOUNT"},
1084 {STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, -EIO, 1086 {STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER, -EIO,
1085 "STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER"}, 1087 "STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER"},
1086 {STATUS_INVALID_IMAGE_WIN_32, -EIO, "STATUS_INVALID_IMAGE_WIN_32"}, 1088 {STATUS_INVALID_IMAGE_WIN_32, -EIO, "STATUS_INVALID_IMAGE_WIN_32"},
1087 {STATUS_INVALID_IMAGE_WIN_64, -EIO, "STATUS_INVALID_IMAGE_WIN_64"}, 1089 {STATUS_INVALID_IMAGE_WIN_64, -EIO, "STATUS_INVALID_IMAGE_WIN_64"},
1088 {STATUS_BAD_BINDINGS, -EIO, "STATUS_BAD_BINDINGS"}, 1090 {STATUS_BAD_BINDINGS, -EIO, "STATUS_BAD_BINDINGS"},
1089 {STATUS_NETWORK_SESSION_EXPIRED, -EIO, 1091 {STATUS_NETWORK_SESSION_EXPIRED, -EIO,
1090 "STATUS_NETWORK_SESSION_EXPIRED"}, 1092 "STATUS_NETWORK_SESSION_EXPIRED"},
1091 {STATUS_APPHELP_BLOCK, -EIO, "STATUS_APPHELP_BLOCK"}, 1093 {STATUS_APPHELP_BLOCK, -EIO, "STATUS_APPHELP_BLOCK"},
1092 {STATUS_ALL_SIDS_FILTERED, -EIO, "STATUS_ALL_SIDS_FILTERED"}, 1094 {STATUS_ALL_SIDS_FILTERED, -EIO, "STATUS_ALL_SIDS_FILTERED"},
1093 {STATUS_NOT_SAFE_MODE_DRIVER, -EIO, "STATUS_NOT_SAFE_MODE_DRIVER"}, 1095 {STATUS_NOT_SAFE_MODE_DRIVER, -EIO, "STATUS_NOT_SAFE_MODE_DRIVER"},
1094 {STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, -EACCES, 1096 {STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT, -EACCES,
1095 "STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT"}, 1097 "STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT"},
1096 {STATUS_ACCESS_DISABLED_BY_POLICY_PATH, -EACCES, 1098 {STATUS_ACCESS_DISABLED_BY_POLICY_PATH, -EACCES,
1097 "STATUS_ACCESS_DISABLED_BY_POLICY_PATH"}, 1099 "STATUS_ACCESS_DISABLED_BY_POLICY_PATH"},
1098 {STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, -EACCES, 1100 {STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER, -EACCES,
1099 "STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER"}, 1101 "STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER"},
1100 {STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, -EACCES, 1102 {STATUS_ACCESS_DISABLED_BY_POLICY_OTHER, -EACCES,
1101 "STATUS_ACCESS_DISABLED_BY_POLICY_OTHER"}, 1103 "STATUS_ACCESS_DISABLED_BY_POLICY_OTHER"},
1102 {STATUS_FAILED_DRIVER_ENTRY, -EIO, "STATUS_FAILED_DRIVER_ENTRY"}, 1104 {STATUS_FAILED_DRIVER_ENTRY, -EIO, "STATUS_FAILED_DRIVER_ENTRY"},
1103 {STATUS_DEVICE_ENUMERATION_ERROR, -EIO, 1105 {STATUS_DEVICE_ENUMERATION_ERROR, -EIO,
1104 "STATUS_DEVICE_ENUMERATION_ERROR"}, 1106 "STATUS_DEVICE_ENUMERATION_ERROR"},
1105 {STATUS_MOUNT_POINT_NOT_RESOLVED, -EIO, 1107 {STATUS_MOUNT_POINT_NOT_RESOLVED, -EIO,
1106 "STATUS_MOUNT_POINT_NOT_RESOLVED"}, 1108 "STATUS_MOUNT_POINT_NOT_RESOLVED"},
1107 {STATUS_INVALID_DEVICE_OBJECT_PARAMETER, -EIO, 1109 {STATUS_INVALID_DEVICE_OBJECT_PARAMETER, -EIO,
1108 "STATUS_INVALID_DEVICE_OBJECT_PARAMETER"}, 1110 "STATUS_INVALID_DEVICE_OBJECT_PARAMETER"},
1109 {STATUS_MCA_OCCURED, -EIO, "STATUS_MCA_OCCURED"}, 1111 {STATUS_MCA_OCCURED, -EIO, "STATUS_MCA_OCCURED"},
1110 {STATUS_DRIVER_BLOCKED_CRITICAL, -EIO, 1112 {STATUS_DRIVER_BLOCKED_CRITICAL, -EIO,
1111 "STATUS_DRIVER_BLOCKED_CRITICAL"}, 1113 "STATUS_DRIVER_BLOCKED_CRITICAL"},
1112 {STATUS_DRIVER_BLOCKED, -EIO, "STATUS_DRIVER_BLOCKED"}, 1114 {STATUS_DRIVER_BLOCKED, -EIO, "STATUS_DRIVER_BLOCKED"},
1113 {STATUS_DRIVER_DATABASE_ERROR, -EIO, "STATUS_DRIVER_DATABASE_ERROR"}, 1115 {STATUS_DRIVER_DATABASE_ERROR, -EIO, "STATUS_DRIVER_DATABASE_ERROR"},
1114 {STATUS_SYSTEM_HIVE_TOO_LARGE, -EIO, "STATUS_SYSTEM_HIVE_TOO_LARGE"}, 1116 {STATUS_SYSTEM_HIVE_TOO_LARGE, -EIO, "STATUS_SYSTEM_HIVE_TOO_LARGE"},
1115 {STATUS_INVALID_IMPORT_OF_NON_DLL, -EIO, 1117 {STATUS_INVALID_IMPORT_OF_NON_DLL, -EIO,
1116 "STATUS_INVALID_IMPORT_OF_NON_DLL"}, 1118 "STATUS_INVALID_IMPORT_OF_NON_DLL"},
1117 {STATUS_NO_SECRETS, -EIO, "STATUS_NO_SECRETS"}, 1119 {STATUS_NO_SECRETS, -EIO, "STATUS_NO_SECRETS"},
1118 {STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, -EACCES, 1120 {STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY, -EACCES,
1119 "STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY"}, 1121 "STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY"},
1120 {STATUS_FAILED_STACK_SWITCH, -EIO, "STATUS_FAILED_STACK_SWITCH"}, 1122 {STATUS_FAILED_STACK_SWITCH, -EIO, "STATUS_FAILED_STACK_SWITCH"},
1121 {STATUS_HEAP_CORRUPTION, -EIO, "STATUS_HEAP_CORRUPTION"}, 1123 {STATUS_HEAP_CORRUPTION, -EIO, "STATUS_HEAP_CORRUPTION"},
1122 {STATUS_SMARTCARD_WRONG_PIN, -EIO, "STATUS_SMARTCARD_WRONG_PIN"}, 1124 {STATUS_SMARTCARD_WRONG_PIN, -EIO, "STATUS_SMARTCARD_WRONG_PIN"},
1123 {STATUS_SMARTCARD_CARD_BLOCKED, -EIO, "STATUS_SMARTCARD_CARD_BLOCKED"}, 1125 {STATUS_SMARTCARD_CARD_BLOCKED, -EIO, "STATUS_SMARTCARD_CARD_BLOCKED"},
1124 {STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED, -EIO, 1126 {STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED, -EIO,
1125 "STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED"}, 1127 "STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED"},
1126 {STATUS_SMARTCARD_NO_CARD, -EIO, "STATUS_SMARTCARD_NO_CARD"}, 1128 {STATUS_SMARTCARD_NO_CARD, -EIO, "STATUS_SMARTCARD_NO_CARD"},
1127 {STATUS_SMARTCARD_NO_KEY_CONTAINER, -EIO, 1129 {STATUS_SMARTCARD_NO_KEY_CONTAINER, -EIO,
1128 "STATUS_SMARTCARD_NO_KEY_CONTAINER"}, 1130 "STATUS_SMARTCARD_NO_KEY_CONTAINER"},
1129 {STATUS_SMARTCARD_NO_CERTIFICATE, -EIO, 1131 {STATUS_SMARTCARD_NO_CERTIFICATE, -EIO,
1130 "STATUS_SMARTCARD_NO_CERTIFICATE"}, 1132 "STATUS_SMARTCARD_NO_CERTIFICATE"},
1131 {STATUS_SMARTCARD_NO_KEYSET, -EIO, "STATUS_SMARTCARD_NO_KEYSET"}, 1133 {STATUS_SMARTCARD_NO_KEYSET, -EIO, "STATUS_SMARTCARD_NO_KEYSET"},
1132 {STATUS_SMARTCARD_IO_ERROR, -EIO, "STATUS_SMARTCARD_IO_ERROR"}, 1134 {STATUS_SMARTCARD_IO_ERROR, -EIO, "STATUS_SMARTCARD_IO_ERROR"},
1133 {STATUS_DOWNGRADE_DETECTED, -EIO, "STATUS_DOWNGRADE_DETECTED"}, 1135 {STATUS_DOWNGRADE_DETECTED, -EIO, "STATUS_DOWNGRADE_DETECTED"},
1134 {STATUS_SMARTCARD_CERT_REVOKED, -EIO, "STATUS_SMARTCARD_CERT_REVOKED"}, 1136 {STATUS_SMARTCARD_CERT_REVOKED, -EIO, "STATUS_SMARTCARD_CERT_REVOKED"},
1135 {STATUS_ISSUING_CA_UNTRUSTED, -EIO, "STATUS_ISSUING_CA_UNTRUSTED"}, 1137 {STATUS_ISSUING_CA_UNTRUSTED, -EIO, "STATUS_ISSUING_CA_UNTRUSTED"},
1136 {STATUS_REVOCATION_OFFLINE_C, -EIO, "STATUS_REVOCATION_OFFLINE_C"}, 1138 {STATUS_REVOCATION_OFFLINE_C, -EIO, "STATUS_REVOCATION_OFFLINE_C"},
1137 {STATUS_PKINIT_CLIENT_FAILURE, -EIO, "STATUS_PKINIT_CLIENT_FAILURE"}, 1139 {STATUS_PKINIT_CLIENT_FAILURE, -EIO, "STATUS_PKINIT_CLIENT_FAILURE"},
1138 {STATUS_SMARTCARD_CERT_EXPIRED, -EIO, "STATUS_SMARTCARD_CERT_EXPIRED"}, 1140 {STATUS_SMARTCARD_CERT_EXPIRED, -EIO, "STATUS_SMARTCARD_CERT_EXPIRED"},
1139 {STATUS_DRIVER_FAILED_PRIOR_UNLOAD, -EIO, 1141 {STATUS_DRIVER_FAILED_PRIOR_UNLOAD, -EIO,
1140 "STATUS_DRIVER_FAILED_PRIOR_UNLOAD"}, 1142 "STATUS_DRIVER_FAILED_PRIOR_UNLOAD"},
1141 {STATUS_SMARTCARD_SILENT_CONTEXT, -EIO, 1143 {STATUS_SMARTCARD_SILENT_CONTEXT, -EIO,
1142 "STATUS_SMARTCARD_SILENT_CONTEXT"}, 1144 "STATUS_SMARTCARD_SILENT_CONTEXT"},
1143 {STATUS_PER_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT, 1145 {STATUS_PER_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT,
1144 "STATUS_PER_USER_TRUST_QUOTA_EXCEEDED"}, 1146 "STATUS_PER_USER_TRUST_QUOTA_EXCEEDED"},
1145 {STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT, 1147 {STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED, -EDQUOT,
1146 "STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED"}, 1148 "STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED"},
1147 {STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED, -EDQUOT, 1149 {STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED, -EDQUOT,
1148 "STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED"}, 1150 "STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED"},
1149 {STATUS_DS_NAME_NOT_UNIQUE, -EIO, "STATUS_DS_NAME_NOT_UNIQUE"}, 1151 {STATUS_DS_NAME_NOT_UNIQUE, -EIO, "STATUS_DS_NAME_NOT_UNIQUE"},
1150 {STATUS_DS_DUPLICATE_ID_FOUND, -EIO, "STATUS_DS_DUPLICATE_ID_FOUND"}, 1152 {STATUS_DS_DUPLICATE_ID_FOUND, -EIO, "STATUS_DS_DUPLICATE_ID_FOUND"},
1151 {STATUS_DS_GROUP_CONVERSION_ERROR, -EIO, 1153 {STATUS_DS_GROUP_CONVERSION_ERROR, -EIO,
1152 "STATUS_DS_GROUP_CONVERSION_ERROR"}, 1154 "STATUS_DS_GROUP_CONVERSION_ERROR"},
1153 {STATUS_VOLSNAP_PREPARE_HIBERNATE, -EIO, 1155 {STATUS_VOLSNAP_PREPARE_HIBERNATE, -EIO,
1154 "STATUS_VOLSNAP_PREPARE_HIBERNATE"}, 1156 "STATUS_VOLSNAP_PREPARE_HIBERNATE"},
1155 {STATUS_USER2USER_REQUIRED, -EIO, "STATUS_USER2USER_REQUIRED"}, 1157 {STATUS_USER2USER_REQUIRED, -EIO, "STATUS_USER2USER_REQUIRED"},
1156 {STATUS_STACK_BUFFER_OVERRUN, -EIO, "STATUS_STACK_BUFFER_OVERRUN"}, 1158 {STATUS_STACK_BUFFER_OVERRUN, -EIO, "STATUS_STACK_BUFFER_OVERRUN"},
1157 {STATUS_NO_S4U_PROT_SUPPORT, -EIO, "STATUS_NO_S4U_PROT_SUPPORT"}, 1159 {STATUS_NO_S4U_PROT_SUPPORT, -EIO, "STATUS_NO_S4U_PROT_SUPPORT"},
1158 {STATUS_CROSSREALM_DELEGATION_FAILURE, -EIO, 1160 {STATUS_CROSSREALM_DELEGATION_FAILURE, -EIO,
1159 "STATUS_CROSSREALM_DELEGATION_FAILURE"}, 1161 "STATUS_CROSSREALM_DELEGATION_FAILURE"},
1160 {STATUS_REVOCATION_OFFLINE_KDC, -EIO, "STATUS_REVOCATION_OFFLINE_KDC"}, 1162 {STATUS_REVOCATION_OFFLINE_KDC, -EIO, "STATUS_REVOCATION_OFFLINE_KDC"},
1161 {STATUS_ISSUING_CA_UNTRUSTED_KDC, -EIO, 1163 {STATUS_ISSUING_CA_UNTRUSTED_KDC, -EIO,
1162 "STATUS_ISSUING_CA_UNTRUSTED_KDC"}, 1164 "STATUS_ISSUING_CA_UNTRUSTED_KDC"},
1163 {STATUS_KDC_CERT_EXPIRED, -EIO, "STATUS_KDC_CERT_EXPIRED"}, 1165 {STATUS_KDC_CERT_EXPIRED, -EIO, "STATUS_KDC_CERT_EXPIRED"},
1164 {STATUS_KDC_CERT_REVOKED, -EIO, "STATUS_KDC_CERT_REVOKED"}, 1166 {STATUS_KDC_CERT_REVOKED, -EIO, "STATUS_KDC_CERT_REVOKED"},
1165 {STATUS_PARAMETER_QUOTA_EXCEEDED, -EDQUOT, 1167 {STATUS_PARAMETER_QUOTA_EXCEEDED, -EDQUOT,
1166 "STATUS_PARAMETER_QUOTA_EXCEEDED"}, 1168 "STATUS_PARAMETER_QUOTA_EXCEEDED"},
1167 {STATUS_HIBERNATION_FAILURE, -EIO, "STATUS_HIBERNATION_FAILURE"}, 1169 {STATUS_HIBERNATION_FAILURE, -EIO, "STATUS_HIBERNATION_FAILURE"},
1168 {STATUS_DELAY_LOAD_FAILED, -EIO, "STATUS_DELAY_LOAD_FAILED"}, 1170 {STATUS_DELAY_LOAD_FAILED, -EIO, "STATUS_DELAY_LOAD_FAILED"},
1169 {STATUS_AUTHENTICATION_FIREWALL_FAILED, -EIO, 1171 {STATUS_AUTHENTICATION_FIREWALL_FAILED, -EIO,
1170 "STATUS_AUTHENTICATION_FIREWALL_FAILED"}, 1172 "STATUS_AUTHENTICATION_FIREWALL_FAILED"},
1171 {STATUS_VDM_DISALLOWED, -EIO, "STATUS_VDM_DISALLOWED"}, 1173 {STATUS_VDM_DISALLOWED, -EIO, "STATUS_VDM_DISALLOWED"},
1172 {STATUS_HUNG_DISPLAY_DRIVER_THREAD, -EIO, 1174 {STATUS_HUNG_DISPLAY_DRIVER_THREAD, -EIO,
1173 "STATUS_HUNG_DISPLAY_DRIVER_THREAD"}, 1175 "STATUS_HUNG_DISPLAY_DRIVER_THREAD"},
1174 {STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, -EIO, 1176 {STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE, -EIO,
1175 "STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE"}, 1177 "STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE"},
1176 {STATUS_INVALID_CRUNTIME_PARAMETER, -EIO, 1178 {STATUS_INVALID_CRUNTIME_PARAMETER, -EIO,
1177 "STATUS_INVALID_CRUNTIME_PARAMETER"}, 1179 "STATUS_INVALID_CRUNTIME_PARAMETER"},
1178 {STATUS_NTLM_BLOCKED, -EIO, "STATUS_NTLM_BLOCKED"}, 1180 {STATUS_NTLM_BLOCKED, -EIO, "STATUS_NTLM_BLOCKED"},
1179 {STATUS_ASSERTION_FAILURE, -EIO, "STATUS_ASSERTION_FAILURE"}, 1181 {STATUS_ASSERTION_FAILURE, -EIO, "STATUS_ASSERTION_FAILURE"},
1180 {STATUS_VERIFIER_STOP, -EIO, "STATUS_VERIFIER_STOP"}, 1182 {STATUS_VERIFIER_STOP, -EIO, "STATUS_VERIFIER_STOP"},
1181 {STATUS_CALLBACK_POP_STACK, -EIO, "STATUS_CALLBACK_POP_STACK"}, 1183 {STATUS_CALLBACK_POP_STACK, -EIO, "STATUS_CALLBACK_POP_STACK"},
1182 {STATUS_INCOMPATIBLE_DRIVER_BLOCKED, -EIO, 1184 {STATUS_INCOMPATIBLE_DRIVER_BLOCKED, -EIO,
1183 "STATUS_INCOMPATIBLE_DRIVER_BLOCKED"}, 1185 "STATUS_INCOMPATIBLE_DRIVER_BLOCKED"},
1184 {STATUS_HIVE_UNLOADED, -EIO, "STATUS_HIVE_UNLOADED"}, 1186 {STATUS_HIVE_UNLOADED, -EIO, "STATUS_HIVE_UNLOADED"},
1185 {STATUS_COMPRESSION_DISABLED, -EIO, "STATUS_COMPRESSION_DISABLED"}, 1187 {STATUS_COMPRESSION_DISABLED, -EIO, "STATUS_COMPRESSION_DISABLED"},
1186 {STATUS_FILE_SYSTEM_LIMITATION, -EIO, "STATUS_FILE_SYSTEM_LIMITATION"}, 1188 {STATUS_FILE_SYSTEM_LIMITATION, -EIO, "STATUS_FILE_SYSTEM_LIMITATION"},
1187 {STATUS_INVALID_IMAGE_HASH, -EIO, "STATUS_INVALID_IMAGE_HASH"}, 1189 {STATUS_INVALID_IMAGE_HASH, -EIO, "STATUS_INVALID_IMAGE_HASH"},
1188 {STATUS_NOT_CAPABLE, -EIO, "STATUS_NOT_CAPABLE"}, 1190 {STATUS_NOT_CAPABLE, -EIO, "STATUS_NOT_CAPABLE"},
1189 {STATUS_REQUEST_OUT_OF_SEQUENCE, -EIO, 1191 {STATUS_REQUEST_OUT_OF_SEQUENCE, -EIO,
1190 "STATUS_REQUEST_OUT_OF_SEQUENCE"}, 1192 "STATUS_REQUEST_OUT_OF_SEQUENCE"},
1191 {STATUS_IMPLEMENTATION_LIMIT, -EIO, "STATUS_IMPLEMENTATION_LIMIT"}, 1193 {STATUS_IMPLEMENTATION_LIMIT, -EIO, "STATUS_IMPLEMENTATION_LIMIT"},
1192 {STATUS_ELEVATION_REQUIRED, -EIO, "STATUS_ELEVATION_REQUIRED"}, 1194 {STATUS_ELEVATION_REQUIRED, -EIO, "STATUS_ELEVATION_REQUIRED"},
1193 {STATUS_BEYOND_VDL, -EIO, "STATUS_BEYOND_VDL"}, 1195 {STATUS_BEYOND_VDL, -EIO, "STATUS_BEYOND_VDL"},
1194 {STATUS_ENCOUNTERED_WRITE_IN_PROGRESS, -EIO, 1196 {STATUS_ENCOUNTERED_WRITE_IN_PROGRESS, -EIO,
1195 "STATUS_ENCOUNTERED_WRITE_IN_PROGRESS"}, 1197 "STATUS_ENCOUNTERED_WRITE_IN_PROGRESS"},
1196 {STATUS_PTE_CHANGED, -EIO, "STATUS_PTE_CHANGED"}, 1198 {STATUS_PTE_CHANGED, -EIO, "STATUS_PTE_CHANGED"},
1197 {STATUS_PURGE_FAILED, -EIO, "STATUS_PURGE_FAILED"}, 1199 {STATUS_PURGE_FAILED, -EIO, "STATUS_PURGE_FAILED"},
1198 {STATUS_CRED_REQUIRES_CONFIRMATION, -EIO, 1200 {STATUS_CRED_REQUIRES_CONFIRMATION, -EIO,
1199 "STATUS_CRED_REQUIRES_CONFIRMATION"}, 1201 "STATUS_CRED_REQUIRES_CONFIRMATION"},
1200 {STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, -EIO, 1202 {STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE, -EIO,
1201 "STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE"}, 1203 "STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE"},
1202 {STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER, -EIO, 1204 {STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER, -EIO,
1203 "STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER"}, 1205 "STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER"},
1204 {STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, -EIO, 1206 {STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE, -EIO,
1205 "STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE"}, 1207 "STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE"},
1206 {STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, -EIO, 1208 {STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE, -EIO,
1207 "STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE"}, 1209 "STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE"},
1208 {STATUS_CS_ENCRYPTION_FILE_NOT_CSE, -EIO, 1210 {STATUS_CS_ENCRYPTION_FILE_NOT_CSE, -EIO,
1209 "STATUS_CS_ENCRYPTION_FILE_NOT_CSE"}, 1211 "STATUS_CS_ENCRYPTION_FILE_NOT_CSE"},
1210 {STATUS_INVALID_LABEL, -EIO, "STATUS_INVALID_LABEL"}, 1212 {STATUS_INVALID_LABEL, -EIO, "STATUS_INVALID_LABEL"},
1211 {STATUS_DRIVER_PROCESS_TERMINATED, -EIO, 1213 {STATUS_DRIVER_PROCESS_TERMINATED, -EIO,
1212 "STATUS_DRIVER_PROCESS_TERMINATED"}, 1214 "STATUS_DRIVER_PROCESS_TERMINATED"},
1213 {STATUS_AMBIGUOUS_SYSTEM_DEVICE, -EIO, 1215 {STATUS_AMBIGUOUS_SYSTEM_DEVICE, -EIO,
1214 "STATUS_AMBIGUOUS_SYSTEM_DEVICE"}, 1216 "STATUS_AMBIGUOUS_SYSTEM_DEVICE"},
1215 {STATUS_SYSTEM_DEVICE_NOT_FOUND, -EIO, 1217 {STATUS_SYSTEM_DEVICE_NOT_FOUND, -EIO,
1216 "STATUS_SYSTEM_DEVICE_NOT_FOUND"}, 1218 "STATUS_SYSTEM_DEVICE_NOT_FOUND"},
1217 {STATUS_RESTART_BOOT_APPLICATION, -EIO, 1219 {STATUS_RESTART_BOOT_APPLICATION, -EIO,
1218 "STATUS_RESTART_BOOT_APPLICATION"}, 1220 "STATUS_RESTART_BOOT_APPLICATION"},
1219 {STATUS_INVALID_TASK_NAME, -EIO, "STATUS_INVALID_TASK_NAME"}, 1221 {STATUS_INVALID_TASK_NAME, -EIO, "STATUS_INVALID_TASK_NAME"},
1220 {STATUS_INVALID_TASK_INDEX, -EIO, "STATUS_INVALID_TASK_INDEX"}, 1222 {STATUS_INVALID_TASK_INDEX, -EIO, "STATUS_INVALID_TASK_INDEX"},
1221 {STATUS_THREAD_ALREADY_IN_TASK, -EIO, "STATUS_THREAD_ALREADY_IN_TASK"}, 1223 {STATUS_THREAD_ALREADY_IN_TASK, -EIO, "STATUS_THREAD_ALREADY_IN_TASK"},
1222 {STATUS_CALLBACK_BYPASS, -EIO, "STATUS_CALLBACK_BYPASS"}, 1224 {STATUS_CALLBACK_BYPASS, -EIO, "STATUS_CALLBACK_BYPASS"},
1223 {STATUS_PORT_CLOSED, -EIO, "STATUS_PORT_CLOSED"}, 1225 {STATUS_PORT_CLOSED, -EIO, "STATUS_PORT_CLOSED"},
1224 {STATUS_MESSAGE_LOST, -EIO, "STATUS_MESSAGE_LOST"}, 1226 {STATUS_MESSAGE_LOST, -EIO, "STATUS_MESSAGE_LOST"},
1225 {STATUS_INVALID_MESSAGE, -EIO, "STATUS_INVALID_MESSAGE"}, 1227 {STATUS_INVALID_MESSAGE, -EIO, "STATUS_INVALID_MESSAGE"},
1226 {STATUS_REQUEST_CANCELED, -EIO, "STATUS_REQUEST_CANCELED"}, 1228 {STATUS_REQUEST_CANCELED, -EIO, "STATUS_REQUEST_CANCELED"},
1227 {STATUS_RECURSIVE_DISPATCH, -EIO, "STATUS_RECURSIVE_DISPATCH"}, 1229 {STATUS_RECURSIVE_DISPATCH, -EIO, "STATUS_RECURSIVE_DISPATCH"},
1228 {STATUS_LPC_RECEIVE_BUFFER_EXPECTED, -EIO, 1230 {STATUS_LPC_RECEIVE_BUFFER_EXPECTED, -EIO,
1229 "STATUS_LPC_RECEIVE_BUFFER_EXPECTED"}, 1231 "STATUS_LPC_RECEIVE_BUFFER_EXPECTED"},
1230 {STATUS_LPC_INVALID_CONNECTION_USAGE, -EIO, 1232 {STATUS_LPC_INVALID_CONNECTION_USAGE, -EIO,
1231 "STATUS_LPC_INVALID_CONNECTION_USAGE"}, 1233 "STATUS_LPC_INVALID_CONNECTION_USAGE"},
1232 {STATUS_LPC_REQUESTS_NOT_ALLOWED, -EIO, 1234 {STATUS_LPC_REQUESTS_NOT_ALLOWED, -EIO,
1233 "STATUS_LPC_REQUESTS_NOT_ALLOWED"}, 1235 "STATUS_LPC_REQUESTS_NOT_ALLOWED"},
1234 {STATUS_RESOURCE_IN_USE, -EIO, "STATUS_RESOURCE_IN_USE"}, 1236 {STATUS_RESOURCE_IN_USE, -EIO, "STATUS_RESOURCE_IN_USE"},
1235 {STATUS_HARDWARE_MEMORY_ERROR, -EIO, "STATUS_HARDWARE_MEMORY_ERROR"}, 1237 {STATUS_HARDWARE_MEMORY_ERROR, -EIO, "STATUS_HARDWARE_MEMORY_ERROR"},
1236 {STATUS_THREADPOOL_HANDLE_EXCEPTION, -EIO, 1238 {STATUS_THREADPOOL_HANDLE_EXCEPTION, -EIO,
1237 "STATUS_THREADPOOL_HANDLE_EXCEPTION"}, 1239 "STATUS_THREADPOOL_HANDLE_EXCEPTION"},
1238 {STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED, -EIO, 1240 {STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED, -EIO,
1239 "STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED"}, 1241 "STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED"},
1240 {STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED, -EIO, 1242 {STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED, -EIO,
1241 "STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED"}, 1243 "STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED"},
1242 {STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED, -EIO, 1244 {STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED, -EIO,
1243 "STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED"}, 1245 "STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED"},
1244 {STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED, -EIO, 1246 {STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED, -EIO,
1245 "STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED"}, 1247 "STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED"},
1246 {STATUS_THREADPOOL_RELEASED_DURING_OPERATION, -EIO, 1248 {STATUS_THREADPOOL_RELEASED_DURING_OPERATION, -EIO,
1247 "STATUS_THREADPOOL_RELEASED_DURING_OPERATION"}, 1249 "STATUS_THREADPOOL_RELEASED_DURING_OPERATION"},
1248 {STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING, -EIO, 1250 {STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING, -EIO,
1249 "STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING"}, 1251 "STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING"},
1250 {STATUS_APC_RETURNED_WHILE_IMPERSONATING, -EIO, 1252 {STATUS_APC_RETURNED_WHILE_IMPERSONATING, -EIO,
1251 "STATUS_APC_RETURNED_WHILE_IMPERSONATING"}, 1253 "STATUS_APC_RETURNED_WHILE_IMPERSONATING"},
1252 {STATUS_PROCESS_IS_PROTECTED, -EIO, "STATUS_PROCESS_IS_PROTECTED"}, 1254 {STATUS_PROCESS_IS_PROTECTED, -EIO, "STATUS_PROCESS_IS_PROTECTED"},
1253 {STATUS_MCA_EXCEPTION, -EIO, "STATUS_MCA_EXCEPTION"}, 1255 {STATUS_MCA_EXCEPTION, -EIO, "STATUS_MCA_EXCEPTION"},
1254 {STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE, -EIO, 1256 {STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE, -EIO,
1255 "STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE"}, 1257 "STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE"},
1256 {STATUS_SYMLINK_CLASS_DISABLED, -EIO, "STATUS_SYMLINK_CLASS_DISABLED"}, 1258 {STATUS_SYMLINK_CLASS_DISABLED, -EIO, "STATUS_SYMLINK_CLASS_DISABLED"},
1257 {STATUS_INVALID_IDN_NORMALIZATION, -EIO, 1259 {STATUS_INVALID_IDN_NORMALIZATION, -EIO,
1258 "STATUS_INVALID_IDN_NORMALIZATION"}, 1260 "STATUS_INVALID_IDN_NORMALIZATION"},
1259 {STATUS_NO_UNICODE_TRANSLATION, -EIO, "STATUS_NO_UNICODE_TRANSLATION"}, 1261 {STATUS_NO_UNICODE_TRANSLATION, -EIO, "STATUS_NO_UNICODE_TRANSLATION"},
1260 {STATUS_ALREADY_REGISTERED, -EIO, "STATUS_ALREADY_REGISTERED"}, 1262 {STATUS_ALREADY_REGISTERED, -EIO, "STATUS_ALREADY_REGISTERED"},
1261 {STATUS_CONTEXT_MISMATCH, -EIO, "STATUS_CONTEXT_MISMATCH"}, 1263 {STATUS_CONTEXT_MISMATCH, -EIO, "STATUS_CONTEXT_MISMATCH"},
1262 {STATUS_PORT_ALREADY_HAS_COMPLETION_LIST, -EIO, 1264 {STATUS_PORT_ALREADY_HAS_COMPLETION_LIST, -EIO,
1263 "STATUS_PORT_ALREADY_HAS_COMPLETION_LIST"}, 1265 "STATUS_PORT_ALREADY_HAS_COMPLETION_LIST"},
1264 {STATUS_CALLBACK_RETURNED_THREAD_PRIORITY, -EIO, 1266 {STATUS_CALLBACK_RETURNED_THREAD_PRIORITY, -EIO,
1265 "STATUS_CALLBACK_RETURNED_THREAD_PRIORITY"}, 1267 "STATUS_CALLBACK_RETURNED_THREAD_PRIORITY"},
1266 {STATUS_INVALID_THREAD, -EIO, "STATUS_INVALID_THREAD"}, 1268 {STATUS_INVALID_THREAD, -EIO, "STATUS_INVALID_THREAD"},
1267 {STATUS_CALLBACK_RETURNED_TRANSACTION, -EIO, 1269 {STATUS_CALLBACK_RETURNED_TRANSACTION, -EIO,
1268 "STATUS_CALLBACK_RETURNED_TRANSACTION"}, 1270 "STATUS_CALLBACK_RETURNED_TRANSACTION"},
1269 {STATUS_CALLBACK_RETURNED_LDR_LOCK, -EIO, 1271 {STATUS_CALLBACK_RETURNED_LDR_LOCK, -EIO,
1270 "STATUS_CALLBACK_RETURNED_LDR_LOCK"}, 1272 "STATUS_CALLBACK_RETURNED_LDR_LOCK"},
1271 {STATUS_CALLBACK_RETURNED_LANG, -EIO, "STATUS_CALLBACK_RETURNED_LANG"}, 1273 {STATUS_CALLBACK_RETURNED_LANG, -EIO, "STATUS_CALLBACK_RETURNED_LANG"},
1272 {STATUS_CALLBACK_RETURNED_PRI_BACK, -EIO, 1274 {STATUS_CALLBACK_RETURNED_PRI_BACK, -EIO,
1273 "STATUS_CALLBACK_RETURNED_PRI_BACK"}, 1275 "STATUS_CALLBACK_RETURNED_PRI_BACK"},
1274 {STATUS_CALLBACK_RETURNED_THREAD_AFFINITY, -EIO, 1276 {STATUS_CALLBACK_RETURNED_THREAD_AFFINITY, -EIO,
1275 "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY"}, 1277 "STATUS_CALLBACK_RETURNED_THREAD_AFFINITY"},
1276 {STATUS_DISK_REPAIR_DISABLED, -EIO, "STATUS_DISK_REPAIR_DISABLED"}, 1278 {STATUS_DISK_REPAIR_DISABLED, -EIO, "STATUS_DISK_REPAIR_DISABLED"},
1277 {STATUS_DS_DOMAIN_RENAME_IN_PROGRESS, -EIO, 1279 {STATUS_DS_DOMAIN_RENAME_IN_PROGRESS, -EIO,
1278 "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS"}, 1280 "STATUS_DS_DOMAIN_RENAME_IN_PROGRESS"},
1279 {STATUS_DISK_QUOTA_EXCEEDED, -EDQUOT, "STATUS_DISK_QUOTA_EXCEEDED"}, 1281 {STATUS_DISK_QUOTA_EXCEEDED, -EDQUOT, "STATUS_DISK_QUOTA_EXCEEDED"},
1280 {STATUS_CONTENT_BLOCKED, -EIO, "STATUS_CONTENT_BLOCKED"}, 1282 {STATUS_CONTENT_BLOCKED, -EIO, "STATUS_CONTENT_BLOCKED"},
1281 {STATUS_BAD_CLUSTERS, -EIO, "STATUS_BAD_CLUSTERS"}, 1283 {STATUS_BAD_CLUSTERS, -EIO, "STATUS_BAD_CLUSTERS"},
1282 {STATUS_VOLUME_DIRTY, -EIO, "STATUS_VOLUME_DIRTY"}, 1284 {STATUS_VOLUME_DIRTY, -EIO, "STATUS_VOLUME_DIRTY"},
1283 {STATUS_FILE_CHECKED_OUT, -EIO, "STATUS_FILE_CHECKED_OUT"}, 1285 {STATUS_FILE_CHECKED_OUT, -EIO, "STATUS_FILE_CHECKED_OUT"},
1284 {STATUS_CHECKOUT_REQUIRED, -EIO, "STATUS_CHECKOUT_REQUIRED"}, 1286 {STATUS_CHECKOUT_REQUIRED, -EIO, "STATUS_CHECKOUT_REQUIRED"},
1285 {STATUS_BAD_FILE_TYPE, -EIO, "STATUS_BAD_FILE_TYPE"}, 1287 {STATUS_BAD_FILE_TYPE, -EIO, "STATUS_BAD_FILE_TYPE"},
1286 {STATUS_FILE_TOO_LARGE, -EIO, "STATUS_FILE_TOO_LARGE"}, 1288 {STATUS_FILE_TOO_LARGE, -EIO, "STATUS_FILE_TOO_LARGE"},
1287 {STATUS_FORMS_AUTH_REQUIRED, -EIO, "STATUS_FORMS_AUTH_REQUIRED"}, 1289 {STATUS_FORMS_AUTH_REQUIRED, -EIO, "STATUS_FORMS_AUTH_REQUIRED"},
1288 {STATUS_VIRUS_INFECTED, -EIO, "STATUS_VIRUS_INFECTED"}, 1290 {STATUS_VIRUS_INFECTED, -EIO, "STATUS_VIRUS_INFECTED"},
1289 {STATUS_VIRUS_DELETED, -EIO, "STATUS_VIRUS_DELETED"}, 1291 {STATUS_VIRUS_DELETED, -EIO, "STATUS_VIRUS_DELETED"},
1290 {STATUS_BAD_MCFG_TABLE, -EIO, "STATUS_BAD_MCFG_TABLE"}, 1292 {STATUS_BAD_MCFG_TABLE, -EIO, "STATUS_BAD_MCFG_TABLE"},
1291 {STATUS_WOW_ASSERTION, -EIO, "STATUS_WOW_ASSERTION"}, 1293 {STATUS_WOW_ASSERTION, -EIO, "STATUS_WOW_ASSERTION"},
1292 {STATUS_INVALID_SIGNATURE, -EIO, "STATUS_INVALID_SIGNATURE"}, 1294 {STATUS_INVALID_SIGNATURE, -EIO, "STATUS_INVALID_SIGNATURE"},
1293 {STATUS_HMAC_NOT_SUPPORTED, -EIO, "STATUS_HMAC_NOT_SUPPORTED"}, 1295 {STATUS_HMAC_NOT_SUPPORTED, -EIO, "STATUS_HMAC_NOT_SUPPORTED"},
1294 {STATUS_IPSEC_QUEUE_OVERFLOW, -EIO, "STATUS_IPSEC_QUEUE_OVERFLOW"}, 1296 {STATUS_IPSEC_QUEUE_OVERFLOW, -EIO, "STATUS_IPSEC_QUEUE_OVERFLOW"},
1295 {STATUS_ND_QUEUE_OVERFLOW, -EIO, "STATUS_ND_QUEUE_OVERFLOW"}, 1297 {STATUS_ND_QUEUE_OVERFLOW, -EIO, "STATUS_ND_QUEUE_OVERFLOW"},
1296 {STATUS_HOPLIMIT_EXCEEDED, -EIO, "STATUS_HOPLIMIT_EXCEEDED"}, 1298 {STATUS_HOPLIMIT_EXCEEDED, -EIO, "STATUS_HOPLIMIT_EXCEEDED"},
1297 {STATUS_PROTOCOL_NOT_SUPPORTED, -EOPNOTSUPP, 1299 {STATUS_PROTOCOL_NOT_SUPPORTED, -EOPNOTSUPP,
1298 "STATUS_PROTOCOL_NOT_SUPPORTED"}, 1300 "STATUS_PROTOCOL_NOT_SUPPORTED"},
1299 {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, -EIO, 1301 {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED, -EIO,
1300 "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED"}, 1302 "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED"},
1301 {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, -EIO, 1303 {STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR, -EIO,
1302 "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR"}, 1304 "STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR"},
1303 {STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, -EIO, 1305 {STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR, -EIO,
1304 "STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR"}, 1306 "STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR"},
1305 {STATUS_XML_PARSE_ERROR, -EIO, "STATUS_XML_PARSE_ERROR"}, 1307 {STATUS_XML_PARSE_ERROR, -EIO, "STATUS_XML_PARSE_ERROR"},
1306 {STATUS_XMLDSIG_ERROR, -EIO, "STATUS_XMLDSIG_ERROR"}, 1308 {STATUS_XMLDSIG_ERROR, -EIO, "STATUS_XMLDSIG_ERROR"},
1307 {STATUS_WRONG_COMPARTMENT, -EIO, "STATUS_WRONG_COMPARTMENT"}, 1309 {STATUS_WRONG_COMPARTMENT, -EIO, "STATUS_WRONG_COMPARTMENT"},
1308 {STATUS_AUTHIP_FAILURE, -EIO, "STATUS_AUTHIP_FAILURE"}, 1310 {STATUS_AUTHIP_FAILURE, -EIO, "STATUS_AUTHIP_FAILURE"},
1309 {DBG_NO_STATE_CHANGE, -EIO, "DBG_NO_STATE_CHANGE"}, 1311 {DBG_NO_STATE_CHANGE, -EIO, "DBG_NO_STATE_CHANGE"},
1310 {DBG_APP_NOT_IDLE, -EIO, "DBG_APP_NOT_IDLE"}, 1312 {DBG_APP_NOT_IDLE, -EIO, "DBG_APP_NOT_IDLE"},
1311 {RPC_NT_INVALID_STRING_BINDING, -EIO, "RPC_NT_INVALID_STRING_BINDING"}, 1313 {RPC_NT_INVALID_STRING_BINDING, -EIO, "RPC_NT_INVALID_STRING_BINDING"},
1312 {RPC_NT_WRONG_KIND_OF_BINDING, -EIO, "RPC_NT_WRONG_KIND_OF_BINDING"}, 1314 {RPC_NT_WRONG_KIND_OF_BINDING, -EIO, "RPC_NT_WRONG_KIND_OF_BINDING"},
1313 {RPC_NT_INVALID_BINDING, -EIO, "RPC_NT_INVALID_BINDING"}, 1315 {RPC_NT_INVALID_BINDING, -EIO, "RPC_NT_INVALID_BINDING"},
1314 {RPC_NT_PROTSEQ_NOT_SUPPORTED, -EOPNOTSUPP, 1316 {RPC_NT_PROTSEQ_NOT_SUPPORTED, -EOPNOTSUPP,
1315 "RPC_NT_PROTSEQ_NOT_SUPPORTED"}, 1317 "RPC_NT_PROTSEQ_NOT_SUPPORTED"},
1316 {RPC_NT_INVALID_RPC_PROTSEQ, -EIO, "RPC_NT_INVALID_RPC_PROTSEQ"}, 1318 {RPC_NT_INVALID_RPC_PROTSEQ, -EIO, "RPC_NT_INVALID_RPC_PROTSEQ"},
1317 {RPC_NT_INVALID_STRING_UUID, -EIO, "RPC_NT_INVALID_STRING_UUID"}, 1319 {RPC_NT_INVALID_STRING_UUID, -EIO, "RPC_NT_INVALID_STRING_UUID"},
1318 {RPC_NT_INVALID_ENDPOINT_FORMAT, -EIO, 1320 {RPC_NT_INVALID_ENDPOINT_FORMAT, -EIO,
1319 "RPC_NT_INVALID_ENDPOINT_FORMAT"}, 1321 "RPC_NT_INVALID_ENDPOINT_FORMAT"},
1320 {RPC_NT_INVALID_NET_ADDR, -EIO, "RPC_NT_INVALID_NET_ADDR"}, 1322 {RPC_NT_INVALID_NET_ADDR, -EIO, "RPC_NT_INVALID_NET_ADDR"},
1321 {RPC_NT_NO_ENDPOINT_FOUND, -EIO, "RPC_NT_NO_ENDPOINT_FOUND"}, 1323 {RPC_NT_NO_ENDPOINT_FOUND, -EIO, "RPC_NT_NO_ENDPOINT_FOUND"},
1322 {RPC_NT_INVALID_TIMEOUT, -EINVAL, "RPC_NT_INVALID_TIMEOUT"}, 1324 {RPC_NT_INVALID_TIMEOUT, -EINVAL, "RPC_NT_INVALID_TIMEOUT"},
1323 {RPC_NT_OBJECT_NOT_FOUND, -ENOENT, "RPC_NT_OBJECT_NOT_FOUND"}, 1325 {RPC_NT_OBJECT_NOT_FOUND, -ENOENT, "RPC_NT_OBJECT_NOT_FOUND"},
1324 {RPC_NT_ALREADY_REGISTERED, -EIO, "RPC_NT_ALREADY_REGISTERED"}, 1326 {RPC_NT_ALREADY_REGISTERED, -EIO, "RPC_NT_ALREADY_REGISTERED"},
1325 {RPC_NT_TYPE_ALREADY_REGISTERED, -EIO, 1327 {RPC_NT_TYPE_ALREADY_REGISTERED, -EIO,
1326 "RPC_NT_TYPE_ALREADY_REGISTERED"}, 1328 "RPC_NT_TYPE_ALREADY_REGISTERED"},
1327 {RPC_NT_ALREADY_LISTENING, -EIO, "RPC_NT_ALREADY_LISTENING"}, 1329 {RPC_NT_ALREADY_LISTENING, -EIO, "RPC_NT_ALREADY_LISTENING"},
1328 {RPC_NT_NO_PROTSEQS_REGISTERED, -EIO, "RPC_NT_NO_PROTSEQS_REGISTERED"}, 1330 {RPC_NT_NO_PROTSEQS_REGISTERED, -EIO, "RPC_NT_NO_PROTSEQS_REGISTERED"},
1329 {RPC_NT_NOT_LISTENING, -EIO, "RPC_NT_NOT_LISTENING"}, 1331 {RPC_NT_NOT_LISTENING, -EIO, "RPC_NT_NOT_LISTENING"},
1330 {RPC_NT_UNKNOWN_MGR_TYPE, -EIO, "RPC_NT_UNKNOWN_MGR_TYPE"}, 1332 {RPC_NT_UNKNOWN_MGR_TYPE, -EIO, "RPC_NT_UNKNOWN_MGR_TYPE"},
1331 {RPC_NT_UNKNOWN_IF, -EIO, "RPC_NT_UNKNOWN_IF"}, 1333 {RPC_NT_UNKNOWN_IF, -EIO, "RPC_NT_UNKNOWN_IF"},
1332 {RPC_NT_NO_BINDINGS, -EIO, "RPC_NT_NO_BINDINGS"}, 1334 {RPC_NT_NO_BINDINGS, -EIO, "RPC_NT_NO_BINDINGS"},
1333 {RPC_NT_NO_PROTSEQS, -EIO, "RPC_NT_NO_PROTSEQS"}, 1335 {RPC_NT_NO_PROTSEQS, -EIO, "RPC_NT_NO_PROTSEQS"},
1334 {RPC_NT_CANT_CREATE_ENDPOINT, -EIO, "RPC_NT_CANT_CREATE_ENDPOINT"}, 1336 {RPC_NT_CANT_CREATE_ENDPOINT, -EIO, "RPC_NT_CANT_CREATE_ENDPOINT"},
1335 {RPC_NT_OUT_OF_RESOURCES, -EIO, "RPC_NT_OUT_OF_RESOURCES"}, 1337 {RPC_NT_OUT_OF_RESOURCES, -EIO, "RPC_NT_OUT_OF_RESOURCES"},
1336 {RPC_NT_SERVER_UNAVAILABLE, -EIO, "RPC_NT_SERVER_UNAVAILABLE"}, 1338 {RPC_NT_SERVER_UNAVAILABLE, -EIO, "RPC_NT_SERVER_UNAVAILABLE"},
1337 {RPC_NT_SERVER_TOO_BUSY, -EBUSY, "RPC_NT_SERVER_TOO_BUSY"}, 1339 {RPC_NT_SERVER_TOO_BUSY, -EBUSY, "RPC_NT_SERVER_TOO_BUSY"},
1338 {RPC_NT_INVALID_NETWORK_OPTIONS, -EIO, 1340 {RPC_NT_INVALID_NETWORK_OPTIONS, -EIO,
1339 "RPC_NT_INVALID_NETWORK_OPTIONS"}, 1341 "RPC_NT_INVALID_NETWORK_OPTIONS"},
1340 {RPC_NT_NO_CALL_ACTIVE, -EIO, "RPC_NT_NO_CALL_ACTIVE"}, 1342 {RPC_NT_NO_CALL_ACTIVE, -EIO, "RPC_NT_NO_CALL_ACTIVE"},
1341 {RPC_NT_CALL_FAILED, -EIO, "RPC_NT_CALL_FAILED"}, 1343 {RPC_NT_CALL_FAILED, -EIO, "RPC_NT_CALL_FAILED"},
1342 {RPC_NT_CALL_FAILED_DNE, -EIO, "RPC_NT_CALL_FAILED_DNE"}, 1344 {RPC_NT_CALL_FAILED_DNE, -EIO, "RPC_NT_CALL_FAILED_DNE"},
1343 {RPC_NT_PROTOCOL_ERROR, -EIO, "RPC_NT_PROTOCOL_ERROR"}, 1345 {RPC_NT_PROTOCOL_ERROR, -EIO, "RPC_NT_PROTOCOL_ERROR"},
1344 {RPC_NT_UNSUPPORTED_TRANS_SYN, -EIO, "RPC_NT_UNSUPPORTED_TRANS_SYN"}, 1346 {RPC_NT_UNSUPPORTED_TRANS_SYN, -EIO, "RPC_NT_UNSUPPORTED_TRANS_SYN"},
1345 {RPC_NT_UNSUPPORTED_TYPE, -EIO, "RPC_NT_UNSUPPORTED_TYPE"}, 1347 {RPC_NT_UNSUPPORTED_TYPE, -EIO, "RPC_NT_UNSUPPORTED_TYPE"},
1346 {RPC_NT_INVALID_TAG, -EIO, "RPC_NT_INVALID_TAG"}, 1348 {RPC_NT_INVALID_TAG, -EIO, "RPC_NT_INVALID_TAG"},
1347 {RPC_NT_INVALID_BOUND, -EIO, "RPC_NT_INVALID_BOUND"}, 1349 {RPC_NT_INVALID_BOUND, -EIO, "RPC_NT_INVALID_BOUND"},
1348 {RPC_NT_NO_ENTRY_NAME, -EIO, "RPC_NT_NO_ENTRY_NAME"}, 1350 {RPC_NT_NO_ENTRY_NAME, -EIO, "RPC_NT_NO_ENTRY_NAME"},
1349 {RPC_NT_INVALID_NAME_SYNTAX, -EIO, "RPC_NT_INVALID_NAME_SYNTAX"}, 1351 {RPC_NT_INVALID_NAME_SYNTAX, -EIO, "RPC_NT_INVALID_NAME_SYNTAX"},
1350 {RPC_NT_UNSUPPORTED_NAME_SYNTAX, -EIO, 1352 {RPC_NT_UNSUPPORTED_NAME_SYNTAX, -EIO,
1351 "RPC_NT_UNSUPPORTED_NAME_SYNTAX"}, 1353 "RPC_NT_UNSUPPORTED_NAME_SYNTAX"},
1352 {RPC_NT_UUID_NO_ADDRESS, -EIO, "RPC_NT_UUID_NO_ADDRESS"}, 1354 {RPC_NT_UUID_NO_ADDRESS, -EIO, "RPC_NT_UUID_NO_ADDRESS"},
1353 {RPC_NT_DUPLICATE_ENDPOINT, -ENOTUNIQ, "RPC_NT_DUPLICATE_ENDPOINT"}, 1355 {RPC_NT_DUPLICATE_ENDPOINT, -ENOTUNIQ, "RPC_NT_DUPLICATE_ENDPOINT"},
1354 {RPC_NT_UNKNOWN_AUTHN_TYPE, -EIO, "RPC_NT_UNKNOWN_AUTHN_TYPE"}, 1356 {RPC_NT_UNKNOWN_AUTHN_TYPE, -EIO, "RPC_NT_UNKNOWN_AUTHN_TYPE"},
1355 {RPC_NT_MAX_CALLS_TOO_SMALL, -EIO, "RPC_NT_MAX_CALLS_TOO_SMALL"}, 1357 {RPC_NT_MAX_CALLS_TOO_SMALL, -EIO, "RPC_NT_MAX_CALLS_TOO_SMALL"},
1356 {RPC_NT_STRING_TOO_LONG, -EIO, "RPC_NT_STRING_TOO_LONG"}, 1358 {RPC_NT_STRING_TOO_LONG, -EIO, "RPC_NT_STRING_TOO_LONG"},
1357 {RPC_NT_PROTSEQ_NOT_FOUND, -EIO, "RPC_NT_PROTSEQ_NOT_FOUND"}, 1359 {RPC_NT_PROTSEQ_NOT_FOUND, -EIO, "RPC_NT_PROTSEQ_NOT_FOUND"},
1358 {RPC_NT_PROCNUM_OUT_OF_RANGE, -EIO, "RPC_NT_PROCNUM_OUT_OF_RANGE"}, 1360 {RPC_NT_PROCNUM_OUT_OF_RANGE, -EIO, "RPC_NT_PROCNUM_OUT_OF_RANGE"},
1359 {RPC_NT_BINDING_HAS_NO_AUTH, -EIO, "RPC_NT_BINDING_HAS_NO_AUTH"}, 1361 {RPC_NT_BINDING_HAS_NO_AUTH, -EIO, "RPC_NT_BINDING_HAS_NO_AUTH"},
1360 {RPC_NT_UNKNOWN_AUTHN_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHN_SERVICE"}, 1362 {RPC_NT_UNKNOWN_AUTHN_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHN_SERVICE"},
1361 {RPC_NT_UNKNOWN_AUTHN_LEVEL, -EIO, "RPC_NT_UNKNOWN_AUTHN_LEVEL"}, 1363 {RPC_NT_UNKNOWN_AUTHN_LEVEL, -EIO, "RPC_NT_UNKNOWN_AUTHN_LEVEL"},
1362 {RPC_NT_INVALID_AUTH_IDENTITY, -EIO, "RPC_NT_INVALID_AUTH_IDENTITY"}, 1364 {RPC_NT_INVALID_AUTH_IDENTITY, -EIO, "RPC_NT_INVALID_AUTH_IDENTITY"},
1363 {RPC_NT_UNKNOWN_AUTHZ_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHZ_SERVICE"}, 1365 {RPC_NT_UNKNOWN_AUTHZ_SERVICE, -EIO, "RPC_NT_UNKNOWN_AUTHZ_SERVICE"},
1364 {EPT_NT_INVALID_ENTRY, -EIO, "EPT_NT_INVALID_ENTRY"}, 1366 {EPT_NT_INVALID_ENTRY, -EIO, "EPT_NT_INVALID_ENTRY"},
1365 {EPT_NT_CANT_PERFORM_OP, -EIO, "EPT_NT_CANT_PERFORM_OP"}, 1367 {EPT_NT_CANT_PERFORM_OP, -EIO, "EPT_NT_CANT_PERFORM_OP"},
1366 {EPT_NT_NOT_REGISTERED, -EIO, "EPT_NT_NOT_REGISTERED"}, 1368 {EPT_NT_NOT_REGISTERED, -EIO, "EPT_NT_NOT_REGISTERED"},
1367 {RPC_NT_NOTHING_TO_EXPORT, -EIO, "RPC_NT_NOTHING_TO_EXPORT"}, 1369 {RPC_NT_NOTHING_TO_EXPORT, -EIO, "RPC_NT_NOTHING_TO_EXPORT"},
1368 {RPC_NT_INCOMPLETE_NAME, -EIO, "RPC_NT_INCOMPLETE_NAME"}, 1370 {RPC_NT_INCOMPLETE_NAME, -EIO, "RPC_NT_INCOMPLETE_NAME"},
1369 {RPC_NT_INVALID_VERS_OPTION, -EIO, "RPC_NT_INVALID_VERS_OPTION"}, 1371 {RPC_NT_INVALID_VERS_OPTION, -EIO, "RPC_NT_INVALID_VERS_OPTION"},
1370 {RPC_NT_NO_MORE_MEMBERS, -EIO, "RPC_NT_NO_MORE_MEMBERS"}, 1372 {RPC_NT_NO_MORE_MEMBERS, -EIO, "RPC_NT_NO_MORE_MEMBERS"},
1371 {RPC_NT_NOT_ALL_OBJS_UNEXPORTED, -EIO, 1373 {RPC_NT_NOT_ALL_OBJS_UNEXPORTED, -EIO,
1372 "RPC_NT_NOT_ALL_OBJS_UNEXPORTED"}, 1374 "RPC_NT_NOT_ALL_OBJS_UNEXPORTED"},
1373 {RPC_NT_INTERFACE_NOT_FOUND, -EIO, "RPC_NT_INTERFACE_NOT_FOUND"}, 1375 {RPC_NT_INTERFACE_NOT_FOUND, -EIO, "RPC_NT_INTERFACE_NOT_FOUND"},
1374 {RPC_NT_ENTRY_ALREADY_EXISTS, -EIO, "RPC_NT_ENTRY_ALREADY_EXISTS"}, 1376 {RPC_NT_ENTRY_ALREADY_EXISTS, -EIO, "RPC_NT_ENTRY_ALREADY_EXISTS"},
1375 {RPC_NT_ENTRY_NOT_FOUND, -EIO, "RPC_NT_ENTRY_NOT_FOUND"}, 1377 {RPC_NT_ENTRY_NOT_FOUND, -EIO, "RPC_NT_ENTRY_NOT_FOUND"},
1376 {RPC_NT_NAME_SERVICE_UNAVAILABLE, -EIO, 1378 {RPC_NT_NAME_SERVICE_UNAVAILABLE, -EIO,
1377 "RPC_NT_NAME_SERVICE_UNAVAILABLE"}, 1379 "RPC_NT_NAME_SERVICE_UNAVAILABLE"},
1378 {RPC_NT_INVALID_NAF_ID, -EIO, "RPC_NT_INVALID_NAF_ID"}, 1380 {RPC_NT_INVALID_NAF_ID, -EIO, "RPC_NT_INVALID_NAF_ID"},
1379 {RPC_NT_CANNOT_SUPPORT, -EOPNOTSUPP, "RPC_NT_CANNOT_SUPPORT"}, 1381 {RPC_NT_CANNOT_SUPPORT, -EOPNOTSUPP, "RPC_NT_CANNOT_SUPPORT"},
1380 {RPC_NT_NO_CONTEXT_AVAILABLE, -EIO, "RPC_NT_NO_CONTEXT_AVAILABLE"}, 1382 {RPC_NT_NO_CONTEXT_AVAILABLE, -EIO, "RPC_NT_NO_CONTEXT_AVAILABLE"},
1381 {RPC_NT_INTERNAL_ERROR, -EIO, "RPC_NT_INTERNAL_ERROR"}, 1383 {RPC_NT_INTERNAL_ERROR, -EIO, "RPC_NT_INTERNAL_ERROR"},
1382 {RPC_NT_ZERO_DIVIDE, -EIO, "RPC_NT_ZERO_DIVIDE"}, 1384 {RPC_NT_ZERO_DIVIDE, -EIO, "RPC_NT_ZERO_DIVIDE"},
1383 {RPC_NT_ADDRESS_ERROR, -EIO, "RPC_NT_ADDRESS_ERROR"}, 1385 {RPC_NT_ADDRESS_ERROR, -EIO, "RPC_NT_ADDRESS_ERROR"},
1384 {RPC_NT_FP_DIV_ZERO, -EIO, "RPC_NT_FP_DIV_ZERO"}, 1386 {RPC_NT_FP_DIV_ZERO, -EIO, "RPC_NT_FP_DIV_ZERO"},
1385 {RPC_NT_FP_UNDERFLOW, -EIO, "RPC_NT_FP_UNDERFLOW"}, 1387 {RPC_NT_FP_UNDERFLOW, -EIO, "RPC_NT_FP_UNDERFLOW"},
1386 {RPC_NT_FP_OVERFLOW, -EIO, "RPC_NT_FP_OVERFLOW"}, 1388 {RPC_NT_FP_OVERFLOW, -EIO, "RPC_NT_FP_OVERFLOW"},
1387 {RPC_NT_CALL_IN_PROGRESS, -EIO, "RPC_NT_CALL_IN_PROGRESS"}, 1389 {RPC_NT_CALL_IN_PROGRESS, -EIO, "RPC_NT_CALL_IN_PROGRESS"},
1388 {RPC_NT_NO_MORE_BINDINGS, -EIO, "RPC_NT_NO_MORE_BINDINGS"}, 1390 {RPC_NT_NO_MORE_BINDINGS, -EIO, "RPC_NT_NO_MORE_BINDINGS"},
1389 {RPC_NT_GROUP_MEMBER_NOT_FOUND, -EIO, "RPC_NT_GROUP_MEMBER_NOT_FOUND"}, 1391 {RPC_NT_GROUP_MEMBER_NOT_FOUND, -EIO, "RPC_NT_GROUP_MEMBER_NOT_FOUND"},
1390 {EPT_NT_CANT_CREATE, -EIO, "EPT_NT_CANT_CREATE"}, 1392 {EPT_NT_CANT_CREATE, -EIO, "EPT_NT_CANT_CREATE"},
1391 {RPC_NT_INVALID_OBJECT, -EIO, "RPC_NT_INVALID_OBJECT"}, 1393 {RPC_NT_INVALID_OBJECT, -EIO, "RPC_NT_INVALID_OBJECT"},
1392 {RPC_NT_NO_INTERFACES, -EIO, "RPC_NT_NO_INTERFACES"}, 1394 {RPC_NT_NO_INTERFACES, -EIO, "RPC_NT_NO_INTERFACES"},
1393 {RPC_NT_CALL_CANCELLED, -EIO, "RPC_NT_CALL_CANCELLED"}, 1395 {RPC_NT_CALL_CANCELLED, -EIO, "RPC_NT_CALL_CANCELLED"},
1394 {RPC_NT_BINDING_INCOMPLETE, -EIO, "RPC_NT_BINDING_INCOMPLETE"}, 1396 {RPC_NT_BINDING_INCOMPLETE, -EIO, "RPC_NT_BINDING_INCOMPLETE"},
1395 {RPC_NT_COMM_FAILURE, -EIO, "RPC_NT_COMM_FAILURE"}, 1397 {RPC_NT_COMM_FAILURE, -EIO, "RPC_NT_COMM_FAILURE"},
1396 {RPC_NT_UNSUPPORTED_AUTHN_LEVEL, -EIO, 1398 {RPC_NT_UNSUPPORTED_AUTHN_LEVEL, -EIO,
1397 "RPC_NT_UNSUPPORTED_AUTHN_LEVEL"}, 1399 "RPC_NT_UNSUPPORTED_AUTHN_LEVEL"},
1398 {RPC_NT_NO_PRINC_NAME, -EIO, "RPC_NT_NO_PRINC_NAME"}, 1400 {RPC_NT_NO_PRINC_NAME, -EIO, "RPC_NT_NO_PRINC_NAME"},
1399 {RPC_NT_NOT_RPC_ERROR, -EIO, "RPC_NT_NOT_RPC_ERROR"}, 1401 {RPC_NT_NOT_RPC_ERROR, -EIO, "RPC_NT_NOT_RPC_ERROR"},
1400 {RPC_NT_SEC_PKG_ERROR, -EIO, "RPC_NT_SEC_PKG_ERROR"}, 1402 {RPC_NT_SEC_PKG_ERROR, -EIO, "RPC_NT_SEC_PKG_ERROR"},
1401 {RPC_NT_NOT_CANCELLED, -EIO, "RPC_NT_NOT_CANCELLED"}, 1403 {RPC_NT_NOT_CANCELLED, -EIO, "RPC_NT_NOT_CANCELLED"},
1402 {RPC_NT_INVALID_ASYNC_HANDLE, -EIO, "RPC_NT_INVALID_ASYNC_HANDLE"}, 1404 {RPC_NT_INVALID_ASYNC_HANDLE, -EIO, "RPC_NT_INVALID_ASYNC_HANDLE"},
1403 {RPC_NT_INVALID_ASYNC_CALL, -EIO, "RPC_NT_INVALID_ASYNC_CALL"}, 1405 {RPC_NT_INVALID_ASYNC_CALL, -EIO, "RPC_NT_INVALID_ASYNC_CALL"},
1404 {RPC_NT_PROXY_ACCESS_DENIED, -EACCES, "RPC_NT_PROXY_ACCESS_DENIED"}, 1406 {RPC_NT_PROXY_ACCESS_DENIED, -EACCES, "RPC_NT_PROXY_ACCESS_DENIED"},
1405 {RPC_NT_NO_MORE_ENTRIES, -EIO, "RPC_NT_NO_MORE_ENTRIES"}, 1407 {RPC_NT_NO_MORE_ENTRIES, -EIO, "RPC_NT_NO_MORE_ENTRIES"},
1406 {RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, -EIO, 1408 {RPC_NT_SS_CHAR_TRANS_OPEN_FAIL, -EIO,
1407 "RPC_NT_SS_CHAR_TRANS_OPEN_FAIL"}, 1409 "RPC_NT_SS_CHAR_TRANS_OPEN_FAIL"},
1408 {RPC_NT_SS_CHAR_TRANS_SHORT_FILE, -EIO, 1410 {RPC_NT_SS_CHAR_TRANS_SHORT_FILE, -EIO,
1409 "RPC_NT_SS_CHAR_TRANS_SHORT_FILE"}, 1411 "RPC_NT_SS_CHAR_TRANS_SHORT_FILE"},
1410 {RPC_NT_SS_IN_NULL_CONTEXT, -EIO, "RPC_NT_SS_IN_NULL_CONTEXT"}, 1412 {RPC_NT_SS_IN_NULL_CONTEXT, -EIO, "RPC_NT_SS_IN_NULL_CONTEXT"},
1411 {RPC_NT_SS_CONTEXT_MISMATCH, -EIO, "RPC_NT_SS_CONTEXT_MISMATCH"}, 1413 {RPC_NT_SS_CONTEXT_MISMATCH, -EIO, "RPC_NT_SS_CONTEXT_MISMATCH"},
1412 {RPC_NT_SS_CONTEXT_DAMAGED, -EIO, "RPC_NT_SS_CONTEXT_DAMAGED"}, 1414 {RPC_NT_SS_CONTEXT_DAMAGED, -EIO, "RPC_NT_SS_CONTEXT_DAMAGED"},
1413 {RPC_NT_SS_HANDLES_MISMATCH, -EIO, "RPC_NT_SS_HANDLES_MISMATCH"}, 1415 {RPC_NT_SS_HANDLES_MISMATCH, -EIO, "RPC_NT_SS_HANDLES_MISMATCH"},
1414 {RPC_NT_SS_CANNOT_GET_CALL_HANDLE, -EIO, 1416 {RPC_NT_SS_CANNOT_GET_CALL_HANDLE, -EIO,
1415 "RPC_NT_SS_CANNOT_GET_CALL_HANDLE"}, 1417 "RPC_NT_SS_CANNOT_GET_CALL_HANDLE"},
1416 {RPC_NT_NULL_REF_POINTER, -EIO, "RPC_NT_NULL_REF_POINTER"}, 1418 {RPC_NT_NULL_REF_POINTER, -EIO, "RPC_NT_NULL_REF_POINTER"},
1417 {RPC_NT_ENUM_VALUE_OUT_OF_RANGE, -EIO, 1419 {RPC_NT_ENUM_VALUE_OUT_OF_RANGE, -EIO,
1418 "RPC_NT_ENUM_VALUE_OUT_OF_RANGE"}, 1420 "RPC_NT_ENUM_VALUE_OUT_OF_RANGE"},
1419 {RPC_NT_BYTE_COUNT_TOO_SMALL, -EIO, "RPC_NT_BYTE_COUNT_TOO_SMALL"}, 1421 {RPC_NT_BYTE_COUNT_TOO_SMALL, -EIO, "RPC_NT_BYTE_COUNT_TOO_SMALL"},
1420 {RPC_NT_BAD_STUB_DATA, -EIO, "RPC_NT_BAD_STUB_DATA"}, 1422 {RPC_NT_BAD_STUB_DATA, -EIO, "RPC_NT_BAD_STUB_DATA"},
1421 {RPC_NT_INVALID_ES_ACTION, -EIO, "RPC_NT_INVALID_ES_ACTION"}, 1423 {RPC_NT_INVALID_ES_ACTION, -EIO, "RPC_NT_INVALID_ES_ACTION"},
1422 {RPC_NT_WRONG_ES_VERSION, -EIO, "RPC_NT_WRONG_ES_VERSION"}, 1424 {RPC_NT_WRONG_ES_VERSION, -EIO, "RPC_NT_WRONG_ES_VERSION"},
1423 {RPC_NT_WRONG_STUB_VERSION, -EIO, "RPC_NT_WRONG_STUB_VERSION"}, 1425 {RPC_NT_WRONG_STUB_VERSION, -EIO, "RPC_NT_WRONG_STUB_VERSION"},
1424 {RPC_NT_INVALID_PIPE_OBJECT, -EIO, "RPC_NT_INVALID_PIPE_OBJECT"}, 1426 {RPC_NT_INVALID_PIPE_OBJECT, -EIO, "RPC_NT_INVALID_PIPE_OBJECT"},
1425 {RPC_NT_INVALID_PIPE_OPERATION, -EIO, "RPC_NT_INVALID_PIPE_OPERATION"}, 1427 {RPC_NT_INVALID_PIPE_OPERATION, -EIO, "RPC_NT_INVALID_PIPE_OPERATION"},
1426 {RPC_NT_WRONG_PIPE_VERSION, -EIO, "RPC_NT_WRONG_PIPE_VERSION"}, 1428 {RPC_NT_WRONG_PIPE_VERSION, -EIO, "RPC_NT_WRONG_PIPE_VERSION"},
1427 {RPC_NT_PIPE_CLOSED, -EIO, "RPC_NT_PIPE_CLOSED"}, 1429 {RPC_NT_PIPE_CLOSED, -EIO, "RPC_NT_PIPE_CLOSED"},
1428 {RPC_NT_PIPE_DISCIPLINE_ERROR, -EIO, "RPC_NT_PIPE_DISCIPLINE_ERROR"}, 1430 {RPC_NT_PIPE_DISCIPLINE_ERROR, -EIO, "RPC_NT_PIPE_DISCIPLINE_ERROR"},
1429 {RPC_NT_PIPE_EMPTY, -EIO, "RPC_NT_PIPE_EMPTY"}, 1431 {RPC_NT_PIPE_EMPTY, -EIO, "RPC_NT_PIPE_EMPTY"},
1430 {STATUS_PNP_BAD_MPS_TABLE, -EIO, "STATUS_PNP_BAD_MPS_TABLE"}, 1432 {STATUS_PNP_BAD_MPS_TABLE, -EIO, "STATUS_PNP_BAD_MPS_TABLE"},
1431 {STATUS_PNP_TRANSLATION_FAILED, -EIO, "STATUS_PNP_TRANSLATION_FAILED"}, 1433 {STATUS_PNP_TRANSLATION_FAILED, -EIO, "STATUS_PNP_TRANSLATION_FAILED"},
1432 {STATUS_PNP_IRQ_TRANSLATION_FAILED, -EIO, 1434 {STATUS_PNP_IRQ_TRANSLATION_FAILED, -EIO,
1433 "STATUS_PNP_IRQ_TRANSLATION_FAILED"}, 1435 "STATUS_PNP_IRQ_TRANSLATION_FAILED"},
1434 {STATUS_PNP_INVALID_ID, -EIO, "STATUS_PNP_INVALID_ID"}, 1436 {STATUS_PNP_INVALID_ID, -EIO, "STATUS_PNP_INVALID_ID"},
1435 {STATUS_IO_REISSUE_AS_CACHED, -EIO, "STATUS_IO_REISSUE_AS_CACHED"}, 1437 {STATUS_IO_REISSUE_AS_CACHED, -EIO, "STATUS_IO_REISSUE_AS_CACHED"},
1436 {STATUS_CTX_WINSTATION_NAME_INVALID, -EIO, 1438 {STATUS_CTX_WINSTATION_NAME_INVALID, -EIO,
1437 "STATUS_CTX_WINSTATION_NAME_INVALID"}, 1439 "STATUS_CTX_WINSTATION_NAME_INVALID"},
1438 {STATUS_CTX_INVALID_PD, -EIO, "STATUS_CTX_INVALID_PD"}, 1440 {STATUS_CTX_INVALID_PD, -EIO, "STATUS_CTX_INVALID_PD"},
1439 {STATUS_CTX_PD_NOT_FOUND, -EIO, "STATUS_CTX_PD_NOT_FOUND"}, 1441 {STATUS_CTX_PD_NOT_FOUND, -EIO, "STATUS_CTX_PD_NOT_FOUND"},
1440 {STATUS_CTX_CLOSE_PENDING, -EIO, "STATUS_CTX_CLOSE_PENDING"}, 1442 {STATUS_CTX_CLOSE_PENDING, -EIO, "STATUS_CTX_CLOSE_PENDING"},
1441 {STATUS_CTX_NO_OUTBUF, -EIO, "STATUS_CTX_NO_OUTBUF"}, 1443 {STATUS_CTX_NO_OUTBUF, -EIO, "STATUS_CTX_NO_OUTBUF"},
1442 {STATUS_CTX_MODEM_INF_NOT_FOUND, -EIO, 1444 {STATUS_CTX_MODEM_INF_NOT_FOUND, -EIO,
1443 "STATUS_CTX_MODEM_INF_NOT_FOUND"}, 1445 "STATUS_CTX_MODEM_INF_NOT_FOUND"},
1444 {STATUS_CTX_INVALID_MODEMNAME, -EIO, "STATUS_CTX_INVALID_MODEMNAME"}, 1446 {STATUS_CTX_INVALID_MODEMNAME, -EIO, "STATUS_CTX_INVALID_MODEMNAME"},
1445 {STATUS_CTX_RESPONSE_ERROR, -EIO, "STATUS_CTX_RESPONSE_ERROR"}, 1447 {STATUS_CTX_RESPONSE_ERROR, -EIO, "STATUS_CTX_RESPONSE_ERROR"},
1446 {STATUS_CTX_MODEM_RESPONSE_TIMEOUT, -ETIMEDOUT, 1448 {STATUS_CTX_MODEM_RESPONSE_TIMEOUT, -ETIMEDOUT,
1447 "STATUS_CTX_MODEM_RESPONSE_TIMEOUT"}, 1449 "STATUS_CTX_MODEM_RESPONSE_TIMEOUT"},
1448 {STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, -EIO, 1450 {STATUS_CTX_MODEM_RESPONSE_NO_CARRIER, -EIO,
1449 "STATUS_CTX_MODEM_RESPONSE_NO_CARRIER"}, 1451 "STATUS_CTX_MODEM_RESPONSE_NO_CARRIER"},
1450 {STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, -EIO, 1452 {STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE, -EIO,
1451 "STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE"}, 1453 "STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE"},
1452 {STATUS_CTX_MODEM_RESPONSE_BUSY, -EBUSY, 1454 {STATUS_CTX_MODEM_RESPONSE_BUSY, -EBUSY,
1453 "STATUS_CTX_MODEM_RESPONSE_BUSY"}, 1455 "STATUS_CTX_MODEM_RESPONSE_BUSY"},
1454 {STATUS_CTX_MODEM_RESPONSE_VOICE, -EIO, 1456 {STATUS_CTX_MODEM_RESPONSE_VOICE, -EIO,
1455 "STATUS_CTX_MODEM_RESPONSE_VOICE"}, 1457 "STATUS_CTX_MODEM_RESPONSE_VOICE"},
1456 {STATUS_CTX_TD_ERROR, -EIO, "STATUS_CTX_TD_ERROR"}, 1458 {STATUS_CTX_TD_ERROR, -EIO, "STATUS_CTX_TD_ERROR"},
1457 {STATUS_CTX_LICENSE_CLIENT_INVALID, -EIO, 1459 {STATUS_CTX_LICENSE_CLIENT_INVALID, -EIO,
1458 "STATUS_CTX_LICENSE_CLIENT_INVALID"}, 1460 "STATUS_CTX_LICENSE_CLIENT_INVALID"},
1459 {STATUS_CTX_LICENSE_NOT_AVAILABLE, -EIO, 1461 {STATUS_CTX_LICENSE_NOT_AVAILABLE, -EIO,
1460 "STATUS_CTX_LICENSE_NOT_AVAILABLE"}, 1462 "STATUS_CTX_LICENSE_NOT_AVAILABLE"},
1461 {STATUS_CTX_LICENSE_EXPIRED, -EIO, "STATUS_CTX_LICENSE_EXPIRED"}, 1463 {STATUS_CTX_LICENSE_EXPIRED, -EIO, "STATUS_CTX_LICENSE_EXPIRED"},
1462 {STATUS_CTX_WINSTATION_NOT_FOUND, -EIO, 1464 {STATUS_CTX_WINSTATION_NOT_FOUND, -EIO,
1463 "STATUS_CTX_WINSTATION_NOT_FOUND"}, 1465 "STATUS_CTX_WINSTATION_NOT_FOUND"},
1464 {STATUS_CTX_WINSTATION_NAME_COLLISION, -EIO, 1466 {STATUS_CTX_WINSTATION_NAME_COLLISION, -EIO,
1465 "STATUS_CTX_WINSTATION_NAME_COLLISION"}, 1467 "STATUS_CTX_WINSTATION_NAME_COLLISION"},
1466 {STATUS_CTX_WINSTATION_BUSY, -EBUSY, "STATUS_CTX_WINSTATION_BUSY"}, 1468 {STATUS_CTX_WINSTATION_BUSY, -EBUSY, "STATUS_CTX_WINSTATION_BUSY"},
1467 {STATUS_CTX_BAD_VIDEO_MODE, -EIO, "STATUS_CTX_BAD_VIDEO_MODE"}, 1469 {STATUS_CTX_BAD_VIDEO_MODE, -EIO, "STATUS_CTX_BAD_VIDEO_MODE"},
1468 {STATUS_CTX_GRAPHICS_INVALID, -EIO, "STATUS_CTX_GRAPHICS_INVALID"}, 1470 {STATUS_CTX_GRAPHICS_INVALID, -EIO, "STATUS_CTX_GRAPHICS_INVALID"},
1469 {STATUS_CTX_NOT_CONSOLE, -EIO, "STATUS_CTX_NOT_CONSOLE"}, 1471 {STATUS_CTX_NOT_CONSOLE, -EIO, "STATUS_CTX_NOT_CONSOLE"},
1470 {STATUS_CTX_CLIENT_QUERY_TIMEOUT, -EIO, 1472 {STATUS_CTX_CLIENT_QUERY_TIMEOUT, -EIO,
1471 "STATUS_CTX_CLIENT_QUERY_TIMEOUT"}, 1473 "STATUS_CTX_CLIENT_QUERY_TIMEOUT"},
1472 {STATUS_CTX_CONSOLE_DISCONNECT, -EIO, "STATUS_CTX_CONSOLE_DISCONNECT"}, 1474 {STATUS_CTX_CONSOLE_DISCONNECT, -EIO, "STATUS_CTX_CONSOLE_DISCONNECT"},
1473 {STATUS_CTX_CONSOLE_CONNECT, -EIO, "STATUS_CTX_CONSOLE_CONNECT"}, 1475 {STATUS_CTX_CONSOLE_CONNECT, -EIO, "STATUS_CTX_CONSOLE_CONNECT"},
1474 {STATUS_CTX_SHADOW_DENIED, -EIO, "STATUS_CTX_SHADOW_DENIED"}, 1476 {STATUS_CTX_SHADOW_DENIED, -EIO, "STATUS_CTX_SHADOW_DENIED"},
1475 {STATUS_CTX_WINSTATION_ACCESS_DENIED, -EACCES, 1477 {STATUS_CTX_WINSTATION_ACCESS_DENIED, -EACCES,
1476 "STATUS_CTX_WINSTATION_ACCESS_DENIED"}, 1478 "STATUS_CTX_WINSTATION_ACCESS_DENIED"},
1477 {STATUS_CTX_INVALID_WD, -EIO, "STATUS_CTX_INVALID_WD"}, 1479 {STATUS_CTX_INVALID_WD, -EIO, "STATUS_CTX_INVALID_WD"},
1478 {STATUS_CTX_WD_NOT_FOUND, -EIO, "STATUS_CTX_WD_NOT_FOUND"}, 1480 {STATUS_CTX_WD_NOT_FOUND, -EIO, "STATUS_CTX_WD_NOT_FOUND"},
1479 {STATUS_CTX_SHADOW_INVALID, -EIO, "STATUS_CTX_SHADOW_INVALID"}, 1481 {STATUS_CTX_SHADOW_INVALID, -EIO, "STATUS_CTX_SHADOW_INVALID"},
1480 {STATUS_CTX_SHADOW_DISABLED, -EIO, "STATUS_CTX_SHADOW_DISABLED"}, 1482 {STATUS_CTX_SHADOW_DISABLED, -EIO, "STATUS_CTX_SHADOW_DISABLED"},
1481 {STATUS_RDP_PROTOCOL_ERROR, -EIO, "STATUS_RDP_PROTOCOL_ERROR"}, 1483 {STATUS_RDP_PROTOCOL_ERROR, -EIO, "STATUS_RDP_PROTOCOL_ERROR"},
1482 {STATUS_CTX_CLIENT_LICENSE_NOT_SET, -EIO, 1484 {STATUS_CTX_CLIENT_LICENSE_NOT_SET, -EIO,
1483 "STATUS_CTX_CLIENT_LICENSE_NOT_SET"}, 1485 "STATUS_CTX_CLIENT_LICENSE_NOT_SET"},
1484 {STATUS_CTX_CLIENT_LICENSE_IN_USE, -EIO, 1486 {STATUS_CTX_CLIENT_LICENSE_IN_USE, -EIO,
1485 "STATUS_CTX_CLIENT_LICENSE_IN_USE"}, 1487 "STATUS_CTX_CLIENT_LICENSE_IN_USE"},
1486 {STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, -EIO, 1488 {STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE, -EIO,
1487 "STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE"}, 1489 "STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE"},
1488 {STATUS_CTX_SHADOW_NOT_RUNNING, -EIO, "STATUS_CTX_SHADOW_NOT_RUNNING"}, 1490 {STATUS_CTX_SHADOW_NOT_RUNNING, -EIO, "STATUS_CTX_SHADOW_NOT_RUNNING"},
1489 {STATUS_CTX_LOGON_DISABLED, -EIO, "STATUS_CTX_LOGON_DISABLED"}, 1491 {STATUS_CTX_LOGON_DISABLED, -EIO, "STATUS_CTX_LOGON_DISABLED"},
1490 {STATUS_CTX_SECURITY_LAYER_ERROR, -EIO, 1492 {STATUS_CTX_SECURITY_LAYER_ERROR, -EIO,
1491 "STATUS_CTX_SECURITY_LAYER_ERROR"}, 1493 "STATUS_CTX_SECURITY_LAYER_ERROR"},
1492 {STATUS_TS_INCOMPATIBLE_SESSIONS, -EIO, 1494 {STATUS_TS_INCOMPATIBLE_SESSIONS, -EIO,
1493 "STATUS_TS_INCOMPATIBLE_SESSIONS"}, 1495 "STATUS_TS_INCOMPATIBLE_SESSIONS"},
1494 {STATUS_MUI_FILE_NOT_FOUND, -EIO, "STATUS_MUI_FILE_NOT_FOUND"}, 1496 {STATUS_MUI_FILE_NOT_FOUND, -EIO, "STATUS_MUI_FILE_NOT_FOUND"},
1495 {STATUS_MUI_INVALID_FILE, -EIO, "STATUS_MUI_INVALID_FILE"}, 1497 {STATUS_MUI_INVALID_FILE, -EIO, "STATUS_MUI_INVALID_FILE"},
1496 {STATUS_MUI_INVALID_RC_CONFIG, -EIO, "STATUS_MUI_INVALID_RC_CONFIG"}, 1498 {STATUS_MUI_INVALID_RC_CONFIG, -EIO, "STATUS_MUI_INVALID_RC_CONFIG"},
1497 {STATUS_MUI_INVALID_LOCALE_NAME, -EIO, 1499 {STATUS_MUI_INVALID_LOCALE_NAME, -EIO,
1498 "STATUS_MUI_INVALID_LOCALE_NAME"}, 1500 "STATUS_MUI_INVALID_LOCALE_NAME"},
1499 {STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME, -EIO, 1501 {STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME, -EIO,
1500 "STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME"}, 1502 "STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME"},
1501 {STATUS_MUI_FILE_NOT_LOADED, -EIO, "STATUS_MUI_FILE_NOT_LOADED"}, 1503 {STATUS_MUI_FILE_NOT_LOADED, -EIO, "STATUS_MUI_FILE_NOT_LOADED"},
1502 {STATUS_RESOURCE_ENUM_USER_STOP, -EIO, 1504 {STATUS_RESOURCE_ENUM_USER_STOP, -EIO,
1503 "STATUS_RESOURCE_ENUM_USER_STOP"}, 1505 "STATUS_RESOURCE_ENUM_USER_STOP"},
1504 {STATUS_CLUSTER_INVALID_NODE, -EIO, "STATUS_CLUSTER_INVALID_NODE"}, 1506 {STATUS_CLUSTER_INVALID_NODE, -EIO, "STATUS_CLUSTER_INVALID_NODE"},
1505 {STATUS_CLUSTER_NODE_EXISTS, -EIO, "STATUS_CLUSTER_NODE_EXISTS"}, 1507 {STATUS_CLUSTER_NODE_EXISTS, -EIO, "STATUS_CLUSTER_NODE_EXISTS"},
1506 {STATUS_CLUSTER_JOIN_IN_PROGRESS, -EIO, 1508 {STATUS_CLUSTER_JOIN_IN_PROGRESS, -EIO,
1507 "STATUS_CLUSTER_JOIN_IN_PROGRESS"}, 1509 "STATUS_CLUSTER_JOIN_IN_PROGRESS"},
1508 {STATUS_CLUSTER_NODE_NOT_FOUND, -EIO, "STATUS_CLUSTER_NODE_NOT_FOUND"}, 1510 {STATUS_CLUSTER_NODE_NOT_FOUND, -EIO, "STATUS_CLUSTER_NODE_NOT_FOUND"},
1509 {STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, -EIO, 1511 {STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND, -EIO,
1510 "STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND"}, 1512 "STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND"},
1511 {STATUS_CLUSTER_NETWORK_EXISTS, -EIO, "STATUS_CLUSTER_NETWORK_EXISTS"}, 1513 {STATUS_CLUSTER_NETWORK_EXISTS, -EIO, "STATUS_CLUSTER_NETWORK_EXISTS"},
1512 {STATUS_CLUSTER_NETWORK_NOT_FOUND, -EIO, 1514 {STATUS_CLUSTER_NETWORK_NOT_FOUND, -EIO,
1513 "STATUS_CLUSTER_NETWORK_NOT_FOUND"}, 1515 "STATUS_CLUSTER_NETWORK_NOT_FOUND"},
1514 {STATUS_CLUSTER_NETINTERFACE_EXISTS, -EIO, 1516 {STATUS_CLUSTER_NETINTERFACE_EXISTS, -EIO,
1515 "STATUS_CLUSTER_NETINTERFACE_EXISTS"}, 1517 "STATUS_CLUSTER_NETINTERFACE_EXISTS"},
1516 {STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, -EIO, 1518 {STATUS_CLUSTER_NETINTERFACE_NOT_FOUND, -EIO,
1517 "STATUS_CLUSTER_NETINTERFACE_NOT_FOUND"}, 1519 "STATUS_CLUSTER_NETINTERFACE_NOT_FOUND"},
1518 {STATUS_CLUSTER_INVALID_REQUEST, -EIO, 1520 {STATUS_CLUSTER_INVALID_REQUEST, -EIO,
1519 "STATUS_CLUSTER_INVALID_REQUEST"}, 1521 "STATUS_CLUSTER_INVALID_REQUEST"},
1520 {STATUS_CLUSTER_INVALID_NETWORK_PROVIDER, -EIO, 1522 {STATUS_CLUSTER_INVALID_NETWORK_PROVIDER, -EIO,
1521 "STATUS_CLUSTER_INVALID_NETWORK_PROVIDER"}, 1523 "STATUS_CLUSTER_INVALID_NETWORK_PROVIDER"},
1522 {STATUS_CLUSTER_NODE_DOWN, -EIO, "STATUS_CLUSTER_NODE_DOWN"}, 1524 {STATUS_CLUSTER_NODE_DOWN, -EIO, "STATUS_CLUSTER_NODE_DOWN"},
1523 {STATUS_CLUSTER_NODE_UNREACHABLE, -EIO, 1525 {STATUS_CLUSTER_NODE_UNREACHABLE, -EIO,
1524 "STATUS_CLUSTER_NODE_UNREACHABLE"}, 1526 "STATUS_CLUSTER_NODE_UNREACHABLE"},
1525 {STATUS_CLUSTER_NODE_NOT_MEMBER, -EIO, 1527 {STATUS_CLUSTER_NODE_NOT_MEMBER, -EIO,
1526 "STATUS_CLUSTER_NODE_NOT_MEMBER"}, 1528 "STATUS_CLUSTER_NODE_NOT_MEMBER"},
1527 {STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, -EIO, 1529 {STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS, -EIO,
1528 "STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS"}, 1530 "STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS"},
1529 {STATUS_CLUSTER_INVALID_NETWORK, -EIO, 1531 {STATUS_CLUSTER_INVALID_NETWORK, -EIO,
1530 "STATUS_CLUSTER_INVALID_NETWORK"}, 1532 "STATUS_CLUSTER_INVALID_NETWORK"},
1531 {STATUS_CLUSTER_NO_NET_ADAPTERS, -EIO, 1533 {STATUS_CLUSTER_NO_NET_ADAPTERS, -EIO,
1532 "STATUS_CLUSTER_NO_NET_ADAPTERS"}, 1534 "STATUS_CLUSTER_NO_NET_ADAPTERS"},
1533 {STATUS_CLUSTER_NODE_UP, -EIO, "STATUS_CLUSTER_NODE_UP"}, 1535 {STATUS_CLUSTER_NODE_UP, -EIO, "STATUS_CLUSTER_NODE_UP"},
1534 {STATUS_CLUSTER_NODE_PAUSED, -EIO, "STATUS_CLUSTER_NODE_PAUSED"}, 1536 {STATUS_CLUSTER_NODE_PAUSED, -EIO, "STATUS_CLUSTER_NODE_PAUSED"},
1535 {STATUS_CLUSTER_NODE_NOT_PAUSED, -EIO, 1537 {STATUS_CLUSTER_NODE_NOT_PAUSED, -EIO,
1536 "STATUS_CLUSTER_NODE_NOT_PAUSED"}, 1538 "STATUS_CLUSTER_NODE_NOT_PAUSED"},
1537 {STATUS_CLUSTER_NO_SECURITY_CONTEXT, -EIO, 1539 {STATUS_CLUSTER_NO_SECURITY_CONTEXT, -EIO,
1538 "STATUS_CLUSTER_NO_SECURITY_CONTEXT"}, 1540 "STATUS_CLUSTER_NO_SECURITY_CONTEXT"},
1539 {STATUS_CLUSTER_NETWORK_NOT_INTERNAL, -EIO, 1541 {STATUS_CLUSTER_NETWORK_NOT_INTERNAL, -EIO,
1540 "STATUS_CLUSTER_NETWORK_NOT_INTERNAL"}, 1542 "STATUS_CLUSTER_NETWORK_NOT_INTERNAL"},
1541 {STATUS_CLUSTER_POISONED, -EIO, "STATUS_CLUSTER_POISONED"}, 1543 {STATUS_CLUSTER_POISONED, -EIO, "STATUS_CLUSTER_POISONED"},
1542 {STATUS_ACPI_INVALID_OPCODE, -EIO, "STATUS_ACPI_INVALID_OPCODE"}, 1544 {STATUS_ACPI_INVALID_OPCODE, -EIO, "STATUS_ACPI_INVALID_OPCODE"},
1543 {STATUS_ACPI_STACK_OVERFLOW, -EIO, "STATUS_ACPI_STACK_OVERFLOW"}, 1545 {STATUS_ACPI_STACK_OVERFLOW, -EIO, "STATUS_ACPI_STACK_OVERFLOW"},
1544 {STATUS_ACPI_ASSERT_FAILED, -EIO, "STATUS_ACPI_ASSERT_FAILED"}, 1546 {STATUS_ACPI_ASSERT_FAILED, -EIO, "STATUS_ACPI_ASSERT_FAILED"},
1545 {STATUS_ACPI_INVALID_INDEX, -EIO, "STATUS_ACPI_INVALID_INDEX"}, 1547 {STATUS_ACPI_INVALID_INDEX, -EIO, "STATUS_ACPI_INVALID_INDEX"},
1546 {STATUS_ACPI_INVALID_ARGUMENT, -EIO, "STATUS_ACPI_INVALID_ARGUMENT"}, 1548 {STATUS_ACPI_INVALID_ARGUMENT, -EIO, "STATUS_ACPI_INVALID_ARGUMENT"},
1547 {STATUS_ACPI_FATAL, -EIO, "STATUS_ACPI_FATAL"}, 1549 {STATUS_ACPI_FATAL, -EIO, "STATUS_ACPI_FATAL"},
1548 {STATUS_ACPI_INVALID_SUPERNAME, -EIO, "STATUS_ACPI_INVALID_SUPERNAME"}, 1550 {STATUS_ACPI_INVALID_SUPERNAME, -EIO, "STATUS_ACPI_INVALID_SUPERNAME"},
1549 {STATUS_ACPI_INVALID_ARGTYPE, -EIO, "STATUS_ACPI_INVALID_ARGTYPE"}, 1551 {STATUS_ACPI_INVALID_ARGTYPE, -EIO, "STATUS_ACPI_INVALID_ARGTYPE"},
1550 {STATUS_ACPI_INVALID_OBJTYPE, -EIO, "STATUS_ACPI_INVALID_OBJTYPE"}, 1552 {STATUS_ACPI_INVALID_OBJTYPE, -EIO, "STATUS_ACPI_INVALID_OBJTYPE"},
1551 {STATUS_ACPI_INVALID_TARGETTYPE, -EIO, 1553 {STATUS_ACPI_INVALID_TARGETTYPE, -EIO,
1552 "STATUS_ACPI_INVALID_TARGETTYPE"}, 1554 "STATUS_ACPI_INVALID_TARGETTYPE"},
1553 {STATUS_ACPI_INCORRECT_ARGUMENT_COUNT, -EIO, 1555 {STATUS_ACPI_INCORRECT_ARGUMENT_COUNT, -EIO,
1554 "STATUS_ACPI_INCORRECT_ARGUMENT_COUNT"}, 1556 "STATUS_ACPI_INCORRECT_ARGUMENT_COUNT"},
1555 {STATUS_ACPI_ADDRESS_NOT_MAPPED, -EIO, 1557 {STATUS_ACPI_ADDRESS_NOT_MAPPED, -EIO,
1556 "STATUS_ACPI_ADDRESS_NOT_MAPPED"}, 1558 "STATUS_ACPI_ADDRESS_NOT_MAPPED"},
1557 {STATUS_ACPI_INVALID_EVENTTYPE, -EIO, "STATUS_ACPI_INVALID_EVENTTYPE"}, 1559 {STATUS_ACPI_INVALID_EVENTTYPE, -EIO, "STATUS_ACPI_INVALID_EVENTTYPE"},
1558 {STATUS_ACPI_HANDLER_COLLISION, -EIO, "STATUS_ACPI_HANDLER_COLLISION"}, 1560 {STATUS_ACPI_HANDLER_COLLISION, -EIO, "STATUS_ACPI_HANDLER_COLLISION"},
1559 {STATUS_ACPI_INVALID_DATA, -EIO, "STATUS_ACPI_INVALID_DATA"}, 1561 {STATUS_ACPI_INVALID_DATA, -EIO, "STATUS_ACPI_INVALID_DATA"},
1560 {STATUS_ACPI_INVALID_REGION, -EIO, "STATUS_ACPI_INVALID_REGION"}, 1562 {STATUS_ACPI_INVALID_REGION, -EIO, "STATUS_ACPI_INVALID_REGION"},
1561 {STATUS_ACPI_INVALID_ACCESS_SIZE, -EIO, 1563 {STATUS_ACPI_INVALID_ACCESS_SIZE, -EIO,
1562 "STATUS_ACPI_INVALID_ACCESS_SIZE"}, 1564 "STATUS_ACPI_INVALID_ACCESS_SIZE"},
1563 {STATUS_ACPI_ACQUIRE_GLOBAL_LOCK, -EIO, 1565 {STATUS_ACPI_ACQUIRE_GLOBAL_LOCK, -EIO,
1564 "STATUS_ACPI_ACQUIRE_GLOBAL_LOCK"}, 1566 "STATUS_ACPI_ACQUIRE_GLOBAL_LOCK"},
1565 {STATUS_ACPI_ALREADY_INITIALIZED, -EIO, 1567 {STATUS_ACPI_ALREADY_INITIALIZED, -EIO,
1566 "STATUS_ACPI_ALREADY_INITIALIZED"}, 1568 "STATUS_ACPI_ALREADY_INITIALIZED"},
1567 {STATUS_ACPI_NOT_INITIALIZED, -EIO, "STATUS_ACPI_NOT_INITIALIZED"}, 1569 {STATUS_ACPI_NOT_INITIALIZED, -EIO, "STATUS_ACPI_NOT_INITIALIZED"},
1568 {STATUS_ACPI_INVALID_MUTEX_LEVEL, -EIO, 1570 {STATUS_ACPI_INVALID_MUTEX_LEVEL, -EIO,
1569 "STATUS_ACPI_INVALID_MUTEX_LEVEL"}, 1571 "STATUS_ACPI_INVALID_MUTEX_LEVEL"},
1570 {STATUS_ACPI_MUTEX_NOT_OWNED, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNED"}, 1572 {STATUS_ACPI_MUTEX_NOT_OWNED, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNED"},
1571 {STATUS_ACPI_MUTEX_NOT_OWNER, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNER"}, 1573 {STATUS_ACPI_MUTEX_NOT_OWNER, -EIO, "STATUS_ACPI_MUTEX_NOT_OWNER"},
1572 {STATUS_ACPI_RS_ACCESS, -EIO, "STATUS_ACPI_RS_ACCESS"}, 1574 {STATUS_ACPI_RS_ACCESS, -EIO, "STATUS_ACPI_RS_ACCESS"},
1573 {STATUS_ACPI_INVALID_TABLE, -EIO, "STATUS_ACPI_INVALID_TABLE"}, 1575 {STATUS_ACPI_INVALID_TABLE, -EIO, "STATUS_ACPI_INVALID_TABLE"},
1574 {STATUS_ACPI_REG_HANDLER_FAILED, -EIO, 1576 {STATUS_ACPI_REG_HANDLER_FAILED, -EIO,
1575 "STATUS_ACPI_REG_HANDLER_FAILED"}, 1577 "STATUS_ACPI_REG_HANDLER_FAILED"},
1576 {STATUS_ACPI_POWER_REQUEST_FAILED, -EIO, 1578 {STATUS_ACPI_POWER_REQUEST_FAILED, -EIO,
1577 "STATUS_ACPI_POWER_REQUEST_FAILED"}, 1579 "STATUS_ACPI_POWER_REQUEST_FAILED"},
1578 {STATUS_SXS_SECTION_NOT_FOUND, -EIO, "STATUS_SXS_SECTION_NOT_FOUND"}, 1580 {STATUS_SXS_SECTION_NOT_FOUND, -EIO, "STATUS_SXS_SECTION_NOT_FOUND"},
1579 {STATUS_SXS_CANT_GEN_ACTCTX, -EIO, "STATUS_SXS_CANT_GEN_ACTCTX"}, 1581 {STATUS_SXS_CANT_GEN_ACTCTX, -EIO, "STATUS_SXS_CANT_GEN_ACTCTX"},
1580 {STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, -EIO, 1582 {STATUS_SXS_INVALID_ACTCTXDATA_FORMAT, -EIO,
1581 "STATUS_SXS_INVALID_ACTCTXDATA_FORMAT"}, 1583 "STATUS_SXS_INVALID_ACTCTXDATA_FORMAT"},
1582 {STATUS_SXS_ASSEMBLY_NOT_FOUND, -EIO, "STATUS_SXS_ASSEMBLY_NOT_FOUND"}, 1584 {STATUS_SXS_ASSEMBLY_NOT_FOUND, -EIO, "STATUS_SXS_ASSEMBLY_NOT_FOUND"},
1583 {STATUS_SXS_MANIFEST_FORMAT_ERROR, -EIO, 1585 {STATUS_SXS_MANIFEST_FORMAT_ERROR, -EIO,
1584 "STATUS_SXS_MANIFEST_FORMAT_ERROR"}, 1586 "STATUS_SXS_MANIFEST_FORMAT_ERROR"},
1585 {STATUS_SXS_MANIFEST_PARSE_ERROR, -EIO, 1587 {STATUS_SXS_MANIFEST_PARSE_ERROR, -EIO,
1586 "STATUS_SXS_MANIFEST_PARSE_ERROR"}, 1588 "STATUS_SXS_MANIFEST_PARSE_ERROR"},
1587 {STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, -EIO, 1589 {STATUS_SXS_ACTIVATION_CONTEXT_DISABLED, -EIO,
1588 "STATUS_SXS_ACTIVATION_CONTEXT_DISABLED"}, 1590 "STATUS_SXS_ACTIVATION_CONTEXT_DISABLED"},
1589 {STATUS_SXS_KEY_NOT_FOUND, -EIO, "STATUS_SXS_KEY_NOT_FOUND"}, 1591 {STATUS_SXS_KEY_NOT_FOUND, -EIO, "STATUS_SXS_KEY_NOT_FOUND"},
1590 {STATUS_SXS_VERSION_CONFLICT, -EIO, "STATUS_SXS_VERSION_CONFLICT"}, 1592 {STATUS_SXS_VERSION_CONFLICT, -EIO, "STATUS_SXS_VERSION_CONFLICT"},
1591 {STATUS_SXS_WRONG_SECTION_TYPE, -EIO, "STATUS_SXS_WRONG_SECTION_TYPE"}, 1593 {STATUS_SXS_WRONG_SECTION_TYPE, -EIO, "STATUS_SXS_WRONG_SECTION_TYPE"},
1592 {STATUS_SXS_THREAD_QUERIES_DISABLED, -EIO, 1594 {STATUS_SXS_THREAD_QUERIES_DISABLED, -EIO,
1593 "STATUS_SXS_THREAD_QUERIES_DISABLED"}, 1595 "STATUS_SXS_THREAD_QUERIES_DISABLED"},
1594 {STATUS_SXS_ASSEMBLY_MISSING, -EIO, "STATUS_SXS_ASSEMBLY_MISSING"}, 1596 {STATUS_SXS_ASSEMBLY_MISSING, -EIO, "STATUS_SXS_ASSEMBLY_MISSING"},
1595 {STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, -EIO, 1597 {STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET, -EIO,
1596 "STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET"}, 1598 "STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET"},
1597 {STATUS_SXS_EARLY_DEACTIVATION, -EIO, "STATUS_SXS_EARLY_DEACTIVATION"}, 1599 {STATUS_SXS_EARLY_DEACTIVATION, -EIO, "STATUS_SXS_EARLY_DEACTIVATION"},
1598 {STATUS_SXS_INVALID_DEACTIVATION, -EIO, 1600 {STATUS_SXS_INVALID_DEACTIVATION, -EIO,
1599 "STATUS_SXS_INVALID_DEACTIVATION"}, 1601 "STATUS_SXS_INVALID_DEACTIVATION"},
1600 {STATUS_SXS_MULTIPLE_DEACTIVATION, -EIO, 1602 {STATUS_SXS_MULTIPLE_DEACTIVATION, -EIO,
1601 "STATUS_SXS_MULTIPLE_DEACTIVATION"}, 1603 "STATUS_SXS_MULTIPLE_DEACTIVATION"},
1602 {STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, -EIO, 1604 {STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY, -EIO,
1603 "STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY"}, 1605 "STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY"},
1604 {STATUS_SXS_PROCESS_TERMINATION_REQUESTED, -EIO, 1606 {STATUS_SXS_PROCESS_TERMINATION_REQUESTED, -EIO,
1605 "STATUS_SXS_PROCESS_TERMINATION_REQUESTED"}, 1607 "STATUS_SXS_PROCESS_TERMINATION_REQUESTED"},
1606 {STATUS_SXS_CORRUPT_ACTIVATION_STACK, -EIO, 1608 {STATUS_SXS_CORRUPT_ACTIVATION_STACK, -EIO,
1607 "STATUS_SXS_CORRUPT_ACTIVATION_STACK"}, 1609 "STATUS_SXS_CORRUPT_ACTIVATION_STACK"},
1608 {STATUS_SXS_CORRUPTION, -EIO, "STATUS_SXS_CORRUPTION"}, 1610 {STATUS_SXS_CORRUPTION, -EIO, "STATUS_SXS_CORRUPTION"},
1609 {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, -EIO, 1611 {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE, -EIO,
1610 "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE"}, 1612 "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE"},
1611 {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, -EIO, 1613 {STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME, -EIO,
1612 "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME"}, 1614 "STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME"},
1613 {STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, -EIO, 1615 {STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE, -EIO,
1614 "STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE"}, 1616 "STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE"},
1615 {STATUS_SXS_IDENTITY_PARSE_ERROR, -EIO, 1617 {STATUS_SXS_IDENTITY_PARSE_ERROR, -EIO,
1616 "STATUS_SXS_IDENTITY_PARSE_ERROR"}, 1618 "STATUS_SXS_IDENTITY_PARSE_ERROR"},
1617 {STATUS_SXS_COMPONENT_STORE_CORRUPT, -EIO, 1619 {STATUS_SXS_COMPONENT_STORE_CORRUPT, -EIO,
1618 "STATUS_SXS_COMPONENT_STORE_CORRUPT"}, 1620 "STATUS_SXS_COMPONENT_STORE_CORRUPT"},
1619 {STATUS_SXS_FILE_HASH_MISMATCH, -EIO, "STATUS_SXS_FILE_HASH_MISMATCH"}, 1621 {STATUS_SXS_FILE_HASH_MISMATCH, -EIO, "STATUS_SXS_FILE_HASH_MISMATCH"},
1620 {STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, -EIO, 1622 {STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT, -EIO,
1621 "STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT"}, 1623 "STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT"},
1622 {STATUS_SXS_IDENTITIES_DIFFERENT, -EIO, 1624 {STATUS_SXS_IDENTITIES_DIFFERENT, -EIO,
1623 "STATUS_SXS_IDENTITIES_DIFFERENT"}, 1625 "STATUS_SXS_IDENTITIES_DIFFERENT"},
1624 {STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, -EIO, 1626 {STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT, -EIO,
1625 "STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT"}, 1627 "STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT"},
1626 {STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY, -EIO, 1628 {STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY, -EIO,
1627 "STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY"}, 1629 "STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY"},
1628 {STATUS_ADVANCED_INSTALLER_FAILED, -EIO, 1630 {STATUS_ADVANCED_INSTALLER_FAILED, -EIO,
1629 "STATUS_ADVANCED_INSTALLER_FAILED"}, 1631 "STATUS_ADVANCED_INSTALLER_FAILED"},
1630 {STATUS_XML_ENCODING_MISMATCH, -EIO, "STATUS_XML_ENCODING_MISMATCH"}, 1632 {STATUS_XML_ENCODING_MISMATCH, -EIO, "STATUS_XML_ENCODING_MISMATCH"},
1631 {STATUS_SXS_MANIFEST_TOO_BIG, -EIO, "STATUS_SXS_MANIFEST_TOO_BIG"}, 1633 {STATUS_SXS_MANIFEST_TOO_BIG, -EIO, "STATUS_SXS_MANIFEST_TOO_BIG"},
1632 {STATUS_SXS_SETTING_NOT_REGISTERED, -EIO, 1634 {STATUS_SXS_SETTING_NOT_REGISTERED, -EIO,
1633 "STATUS_SXS_SETTING_NOT_REGISTERED"}, 1635 "STATUS_SXS_SETTING_NOT_REGISTERED"},
1634 {STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE, -EIO, 1636 {STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE, -EIO,
1635 "STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE"}, 1637 "STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE"},
1636 {STATUS_SMI_PRIMITIVE_INSTALLER_FAILED, -EIO, 1638 {STATUS_SMI_PRIMITIVE_INSTALLER_FAILED, -EIO,
1637 "STATUS_SMI_PRIMITIVE_INSTALLER_FAILED"}, 1639 "STATUS_SMI_PRIMITIVE_INSTALLER_FAILED"},
1638 {STATUS_GENERIC_COMMAND_FAILED, -EIO, "STATUS_GENERIC_COMMAND_FAILED"}, 1640 {STATUS_GENERIC_COMMAND_FAILED, -EIO, "STATUS_GENERIC_COMMAND_FAILED"},
1639 {STATUS_SXS_FILE_HASH_MISSING, -EIO, "STATUS_SXS_FILE_HASH_MISSING"}, 1641 {STATUS_SXS_FILE_HASH_MISSING, -EIO, "STATUS_SXS_FILE_HASH_MISSING"},
1640 {STATUS_TRANSACTIONAL_CONFLICT, -EIO, "STATUS_TRANSACTIONAL_CONFLICT"}, 1642 {STATUS_TRANSACTIONAL_CONFLICT, -EIO, "STATUS_TRANSACTIONAL_CONFLICT"},
1641 {STATUS_INVALID_TRANSACTION, -EIO, "STATUS_INVALID_TRANSACTION"}, 1643 {STATUS_INVALID_TRANSACTION, -EIO, "STATUS_INVALID_TRANSACTION"},
1642 {STATUS_TRANSACTION_NOT_ACTIVE, -EIO, "STATUS_TRANSACTION_NOT_ACTIVE"}, 1644 {STATUS_TRANSACTION_NOT_ACTIVE, -EIO, "STATUS_TRANSACTION_NOT_ACTIVE"},
1643 {STATUS_TM_INITIALIZATION_FAILED, -EIO, 1645 {STATUS_TM_INITIALIZATION_FAILED, -EIO,
1644 "STATUS_TM_INITIALIZATION_FAILED"}, 1646 "STATUS_TM_INITIALIZATION_FAILED"},
1645 {STATUS_RM_NOT_ACTIVE, -EIO, "STATUS_RM_NOT_ACTIVE"}, 1647 {STATUS_RM_NOT_ACTIVE, -EIO, "STATUS_RM_NOT_ACTIVE"},
1646 {STATUS_RM_METADATA_CORRUPT, -EIO, "STATUS_RM_METADATA_CORRUPT"}, 1648 {STATUS_RM_METADATA_CORRUPT, -EIO, "STATUS_RM_METADATA_CORRUPT"},
1647 {STATUS_TRANSACTION_NOT_JOINED, -EIO, "STATUS_TRANSACTION_NOT_JOINED"}, 1649 {STATUS_TRANSACTION_NOT_JOINED, -EIO, "STATUS_TRANSACTION_NOT_JOINED"},
1648 {STATUS_DIRECTORY_NOT_RM, -EIO, "STATUS_DIRECTORY_NOT_RM"}, 1650 {STATUS_DIRECTORY_NOT_RM, -EIO, "STATUS_DIRECTORY_NOT_RM"},
1649 {STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE, -EIO, 1651 {STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE, -EIO,
1650 "STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE"}, 1652 "STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE"},
1651 {STATUS_LOG_RESIZE_INVALID_SIZE, -EIO, 1653 {STATUS_LOG_RESIZE_INVALID_SIZE, -EIO,
1652 "STATUS_LOG_RESIZE_INVALID_SIZE"}, 1654 "STATUS_LOG_RESIZE_INVALID_SIZE"},
1653 {STATUS_REMOTE_FILE_VERSION_MISMATCH, -EIO, 1655 {STATUS_REMOTE_FILE_VERSION_MISMATCH, -EIO,
1654 "STATUS_REMOTE_FILE_VERSION_MISMATCH"}, 1656 "STATUS_REMOTE_FILE_VERSION_MISMATCH"},
1655 {STATUS_CRM_PROTOCOL_ALREADY_EXISTS, -EIO, 1657 {STATUS_CRM_PROTOCOL_ALREADY_EXISTS, -EIO,
1656 "STATUS_CRM_PROTOCOL_ALREADY_EXISTS"}, 1658 "STATUS_CRM_PROTOCOL_ALREADY_EXISTS"},
1657 {STATUS_TRANSACTION_PROPAGATION_FAILED, -EIO, 1659 {STATUS_TRANSACTION_PROPAGATION_FAILED, -EIO,
1658 "STATUS_TRANSACTION_PROPAGATION_FAILED"}, 1660 "STATUS_TRANSACTION_PROPAGATION_FAILED"},
1659 {STATUS_CRM_PROTOCOL_NOT_FOUND, -EIO, "STATUS_CRM_PROTOCOL_NOT_FOUND"}, 1661 {STATUS_CRM_PROTOCOL_NOT_FOUND, -EIO, "STATUS_CRM_PROTOCOL_NOT_FOUND"},
1660 {STATUS_TRANSACTION_SUPERIOR_EXISTS, -EIO, 1662 {STATUS_TRANSACTION_SUPERIOR_EXISTS, -EIO,
1661 "STATUS_TRANSACTION_SUPERIOR_EXISTS"}, 1663 "STATUS_TRANSACTION_SUPERIOR_EXISTS"},
1662 {STATUS_TRANSACTION_REQUEST_NOT_VALID, -EIO, 1664 {STATUS_TRANSACTION_REQUEST_NOT_VALID, -EIO,
1663 "STATUS_TRANSACTION_REQUEST_NOT_VALID"}, 1665 "STATUS_TRANSACTION_REQUEST_NOT_VALID"},
1664 {STATUS_TRANSACTION_NOT_REQUESTED, -EIO, 1666 {STATUS_TRANSACTION_NOT_REQUESTED, -EIO,
1665 "STATUS_TRANSACTION_NOT_REQUESTED"}, 1667 "STATUS_TRANSACTION_NOT_REQUESTED"},
1666 {STATUS_TRANSACTION_ALREADY_ABORTED, -EIO, 1668 {STATUS_TRANSACTION_ALREADY_ABORTED, -EIO,
1667 "STATUS_TRANSACTION_ALREADY_ABORTED"}, 1669 "STATUS_TRANSACTION_ALREADY_ABORTED"},
1668 {STATUS_TRANSACTION_ALREADY_COMMITTED, -EIO, 1670 {STATUS_TRANSACTION_ALREADY_COMMITTED, -EIO,
1669 "STATUS_TRANSACTION_ALREADY_COMMITTED"}, 1671 "STATUS_TRANSACTION_ALREADY_COMMITTED"},
1670 {STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER, -EIO, 1672 {STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER, -EIO,
1671 "STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER"}, 1673 "STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER"},
1672 {STATUS_CURRENT_TRANSACTION_NOT_VALID, -EIO, 1674 {STATUS_CURRENT_TRANSACTION_NOT_VALID, -EIO,
1673 "STATUS_CURRENT_TRANSACTION_NOT_VALID"}, 1675 "STATUS_CURRENT_TRANSACTION_NOT_VALID"},
1674 {STATUS_LOG_GROWTH_FAILED, -EIO, "STATUS_LOG_GROWTH_FAILED"}, 1676 {STATUS_LOG_GROWTH_FAILED, -EIO, "STATUS_LOG_GROWTH_FAILED"},
1675 {STATUS_OBJECT_NO_LONGER_EXISTS, -EIO, 1677 {STATUS_OBJECT_NO_LONGER_EXISTS, -EIO,
1676 "STATUS_OBJECT_NO_LONGER_EXISTS"}, 1678 "STATUS_OBJECT_NO_LONGER_EXISTS"},
1677 {STATUS_STREAM_MINIVERSION_NOT_FOUND, -EIO, 1679 {STATUS_STREAM_MINIVERSION_NOT_FOUND, -EIO,
1678 "STATUS_STREAM_MINIVERSION_NOT_FOUND"}, 1680 "STATUS_STREAM_MINIVERSION_NOT_FOUND"},
1679 {STATUS_STREAM_MINIVERSION_NOT_VALID, -EIO, 1681 {STATUS_STREAM_MINIVERSION_NOT_VALID, -EIO,
1680 "STATUS_STREAM_MINIVERSION_NOT_VALID"}, 1682 "STATUS_STREAM_MINIVERSION_NOT_VALID"},
1681 {STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, -EIO, 1683 {STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION, -EIO,
1682 "STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION"}, 1684 "STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION"},
1683 {STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, -EIO, 1685 {STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT, -EIO,
1684 "STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT"}, 1686 "STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT"},
1685 {STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS, -EIO, 1687 {STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS, -EIO,
1686 "STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS"}, 1688 "STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS"},
1687 {STATUS_HANDLE_NO_LONGER_VALID, -EIO, "STATUS_HANDLE_NO_LONGER_VALID"}, 1689 {STATUS_HANDLE_NO_LONGER_VALID, -EIO, "STATUS_HANDLE_NO_LONGER_VALID"},
1688 {STATUS_LOG_CORRUPTION_DETECTED, -EIO, 1690 {STATUS_LOG_CORRUPTION_DETECTED, -EIO,
1689 "STATUS_LOG_CORRUPTION_DETECTED"}, 1691 "STATUS_LOG_CORRUPTION_DETECTED"},
1690 {STATUS_RM_DISCONNECTED, -EIO, "STATUS_RM_DISCONNECTED"}, 1692 {STATUS_RM_DISCONNECTED, -EIO, "STATUS_RM_DISCONNECTED"},
1691 {STATUS_ENLISTMENT_NOT_SUPERIOR, -EIO, 1693 {STATUS_ENLISTMENT_NOT_SUPERIOR, -EIO,
1692 "STATUS_ENLISTMENT_NOT_SUPERIOR"}, 1694 "STATUS_ENLISTMENT_NOT_SUPERIOR"},
1693 {STATUS_FILE_IDENTITY_NOT_PERSISTENT, -EIO, 1695 {STATUS_FILE_IDENTITY_NOT_PERSISTENT, -EIO,
1694 "STATUS_FILE_IDENTITY_NOT_PERSISTENT"}, 1696 "STATUS_FILE_IDENTITY_NOT_PERSISTENT"},
1695 {STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, -EIO, 1697 {STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY, -EIO,
1696 "STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY"}, 1698 "STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY"},
1697 {STATUS_CANT_CROSS_RM_BOUNDARY, -EIO, "STATUS_CANT_CROSS_RM_BOUNDARY"}, 1699 {STATUS_CANT_CROSS_RM_BOUNDARY, -EIO, "STATUS_CANT_CROSS_RM_BOUNDARY"},
1698 {STATUS_TXF_DIR_NOT_EMPTY, -EIO, "STATUS_TXF_DIR_NOT_EMPTY"}, 1700 {STATUS_TXF_DIR_NOT_EMPTY, -EIO, "STATUS_TXF_DIR_NOT_EMPTY"},
1699 {STATUS_INDOUBT_TRANSACTIONS_EXIST, -EIO, 1701 {STATUS_INDOUBT_TRANSACTIONS_EXIST, -EIO,
1700 "STATUS_INDOUBT_TRANSACTIONS_EXIST"}, 1702 "STATUS_INDOUBT_TRANSACTIONS_EXIST"},
1701 {STATUS_TM_VOLATILE, -EIO, "STATUS_TM_VOLATILE"}, 1703 {STATUS_TM_VOLATILE, -EIO, "STATUS_TM_VOLATILE"},
1702 {STATUS_ROLLBACK_TIMER_EXPIRED, -EIO, "STATUS_ROLLBACK_TIMER_EXPIRED"}, 1704 {STATUS_ROLLBACK_TIMER_EXPIRED, -EIO, "STATUS_ROLLBACK_TIMER_EXPIRED"},
1703 {STATUS_TXF_ATTRIBUTE_CORRUPT, -EIO, "STATUS_TXF_ATTRIBUTE_CORRUPT"}, 1705 {STATUS_TXF_ATTRIBUTE_CORRUPT, -EIO, "STATUS_TXF_ATTRIBUTE_CORRUPT"},
1704 {STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION, -EIO, 1706 {STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION, -EIO,
1705 "STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION"}, 1707 "STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION"},
1706 {STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED, -EIO, 1708 {STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED, -EIO,
1707 "STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED"}, 1709 "STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED"},
1708 {STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, -EIO, 1710 {STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE, -EIO,
1709 "STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE"}, 1711 "STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE"},
1710 {STATUS_TRANSACTION_REQUIRED_PROMOTION, -EIO, 1712 {STATUS_TRANSACTION_REQUIRED_PROMOTION, -EIO,
1711 "STATUS_TRANSACTION_REQUIRED_PROMOTION"}, 1713 "STATUS_TRANSACTION_REQUIRED_PROMOTION"},
1712 {STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION, -EIO, 1714 {STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION, -EIO,
1713 "STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION"}, 1715 "STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION"},
1714 {STATUS_TRANSACTIONS_NOT_FROZEN, -EIO, 1716 {STATUS_TRANSACTIONS_NOT_FROZEN, -EIO,
1715 "STATUS_TRANSACTIONS_NOT_FROZEN"}, 1717 "STATUS_TRANSACTIONS_NOT_FROZEN"},
1716 {STATUS_TRANSACTION_FREEZE_IN_PROGRESS, -EIO, 1718 {STATUS_TRANSACTION_FREEZE_IN_PROGRESS, -EIO,
1717 "STATUS_TRANSACTION_FREEZE_IN_PROGRESS"}, 1719 "STATUS_TRANSACTION_FREEZE_IN_PROGRESS"},
1718 {STATUS_NOT_SNAPSHOT_VOLUME, -EIO, "STATUS_NOT_SNAPSHOT_VOLUME"}, 1720 {STATUS_NOT_SNAPSHOT_VOLUME, -EIO, "STATUS_NOT_SNAPSHOT_VOLUME"},
1719 {STATUS_NO_SAVEPOINT_WITH_OPEN_FILES, -EIO, 1721 {STATUS_NO_SAVEPOINT_WITH_OPEN_FILES, -EIO,
1720 "STATUS_NO_SAVEPOINT_WITH_OPEN_FILES"}, 1722 "STATUS_NO_SAVEPOINT_WITH_OPEN_FILES"},
1721 {STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION, -EIO, 1723 {STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION, -EIO,
1722 "STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION"}, 1724 "STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION"},
1723 {STATUS_TM_IDENTITY_MISMATCH, -EIO, "STATUS_TM_IDENTITY_MISMATCH"}, 1725 {STATUS_TM_IDENTITY_MISMATCH, -EIO, "STATUS_TM_IDENTITY_MISMATCH"},
1724 {STATUS_FLOATED_SECTION, -EIO, "STATUS_FLOATED_SECTION"}, 1726 {STATUS_FLOATED_SECTION, -EIO, "STATUS_FLOATED_SECTION"},
1725 {STATUS_CANNOT_ACCEPT_TRANSACTED_WORK, -EIO, 1727 {STATUS_CANNOT_ACCEPT_TRANSACTED_WORK, -EIO,
1726 "STATUS_CANNOT_ACCEPT_TRANSACTED_WORK"}, 1728 "STATUS_CANNOT_ACCEPT_TRANSACTED_WORK"},
1727 {STATUS_CANNOT_ABORT_TRANSACTIONS, -EIO, 1729 {STATUS_CANNOT_ABORT_TRANSACTIONS, -EIO,
1728 "STATUS_CANNOT_ABORT_TRANSACTIONS"}, 1730 "STATUS_CANNOT_ABORT_TRANSACTIONS"},
1729 {STATUS_TRANSACTION_NOT_FOUND, -EIO, "STATUS_TRANSACTION_NOT_FOUND"}, 1731 {STATUS_TRANSACTION_NOT_FOUND, -EIO, "STATUS_TRANSACTION_NOT_FOUND"},
1730 {STATUS_RESOURCEMANAGER_NOT_FOUND, -EIO, 1732 {STATUS_RESOURCEMANAGER_NOT_FOUND, -EIO,
1731 "STATUS_RESOURCEMANAGER_NOT_FOUND"}, 1733 "STATUS_RESOURCEMANAGER_NOT_FOUND"},
1732 {STATUS_ENLISTMENT_NOT_FOUND, -EIO, "STATUS_ENLISTMENT_NOT_FOUND"}, 1734 {STATUS_ENLISTMENT_NOT_FOUND, -EIO, "STATUS_ENLISTMENT_NOT_FOUND"},
1733 {STATUS_TRANSACTIONMANAGER_NOT_FOUND, -EIO, 1735 {STATUS_TRANSACTIONMANAGER_NOT_FOUND, -EIO,
1734 "STATUS_TRANSACTIONMANAGER_NOT_FOUND"}, 1736 "STATUS_TRANSACTIONMANAGER_NOT_FOUND"},
1735 {STATUS_TRANSACTIONMANAGER_NOT_ONLINE, -EIO, 1737 {STATUS_TRANSACTIONMANAGER_NOT_ONLINE, -EIO,
1736 "STATUS_TRANSACTIONMANAGER_NOT_ONLINE"}, 1738 "STATUS_TRANSACTIONMANAGER_NOT_ONLINE"},
1737 {STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, -EIO, 1739 {STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION, -EIO,
1738 "STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION"}, 1740 "STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION"},
1739 {STATUS_TRANSACTION_NOT_ROOT, -EIO, "STATUS_TRANSACTION_NOT_ROOT"}, 1741 {STATUS_TRANSACTION_NOT_ROOT, -EIO, "STATUS_TRANSACTION_NOT_ROOT"},
1740 {STATUS_TRANSACTION_OBJECT_EXPIRED, -EIO, 1742 {STATUS_TRANSACTION_OBJECT_EXPIRED, -EIO,
1741 "STATUS_TRANSACTION_OBJECT_EXPIRED"}, 1743 "STATUS_TRANSACTION_OBJECT_EXPIRED"},
1742 {STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION, -EIO, 1744 {STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION, -EIO,
1743 "STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION"}, 1745 "STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION"},
1744 {STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED, -EIO, 1746 {STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED, -EIO,
1745 "STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED"}, 1747 "STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED"},
1746 {STATUS_TRANSACTION_RECORD_TOO_LONG, -EIO, 1748 {STATUS_TRANSACTION_RECORD_TOO_LONG, -EIO,
1747 "STATUS_TRANSACTION_RECORD_TOO_LONG"}, 1749 "STATUS_TRANSACTION_RECORD_TOO_LONG"},
1748 {STATUS_NO_LINK_TRACKING_IN_TRANSACTION, -EIO, 1750 {STATUS_NO_LINK_TRACKING_IN_TRANSACTION, -EIO,
1749 "STATUS_NO_LINK_TRACKING_IN_TRANSACTION"}, 1751 "STATUS_NO_LINK_TRACKING_IN_TRANSACTION"},
1750 {STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION, -EOPNOTSUPP, 1752 {STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION, -EOPNOTSUPP,
1751 "STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION"}, 1753 "STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION"},
1752 {STATUS_TRANSACTION_INTEGRITY_VIOLATED, -EIO, 1754 {STATUS_TRANSACTION_INTEGRITY_VIOLATED, -EIO,
1753 "STATUS_TRANSACTION_INTEGRITY_VIOLATED"}, 1755 "STATUS_TRANSACTION_INTEGRITY_VIOLATED"},
1754 {STATUS_LOG_SECTOR_INVALID, -EIO, "STATUS_LOG_SECTOR_INVALID"}, 1756 {STATUS_LOG_SECTOR_INVALID, -EIO, "STATUS_LOG_SECTOR_INVALID"},
1755 {STATUS_LOG_SECTOR_PARITY_INVALID, -EIO, 1757 {STATUS_LOG_SECTOR_PARITY_INVALID, -EIO,
1756 "STATUS_LOG_SECTOR_PARITY_INVALID"}, 1758 "STATUS_LOG_SECTOR_PARITY_INVALID"},
1757 {STATUS_LOG_SECTOR_REMAPPED, -EIO, "STATUS_LOG_SECTOR_REMAPPED"}, 1759 {STATUS_LOG_SECTOR_REMAPPED, -EIO, "STATUS_LOG_SECTOR_REMAPPED"},
1758 {STATUS_LOG_BLOCK_INCOMPLETE, -EIO, "STATUS_LOG_BLOCK_INCOMPLETE"}, 1760 {STATUS_LOG_BLOCK_INCOMPLETE, -EIO, "STATUS_LOG_BLOCK_INCOMPLETE"},
1759 {STATUS_LOG_INVALID_RANGE, -EIO, "STATUS_LOG_INVALID_RANGE"}, 1761 {STATUS_LOG_INVALID_RANGE, -EIO, "STATUS_LOG_INVALID_RANGE"},
1760 {STATUS_LOG_BLOCKS_EXHAUSTED, -EIO, "STATUS_LOG_BLOCKS_EXHAUSTED"}, 1762 {STATUS_LOG_BLOCKS_EXHAUSTED, -EIO, "STATUS_LOG_BLOCKS_EXHAUSTED"},
1761 {STATUS_LOG_READ_CONTEXT_INVALID, -EIO, 1763 {STATUS_LOG_READ_CONTEXT_INVALID, -EIO,
1762 "STATUS_LOG_READ_CONTEXT_INVALID"}, 1764 "STATUS_LOG_READ_CONTEXT_INVALID"},
1763 {STATUS_LOG_RESTART_INVALID, -EIO, "STATUS_LOG_RESTART_INVALID"}, 1765 {STATUS_LOG_RESTART_INVALID, -EIO, "STATUS_LOG_RESTART_INVALID"},
1764 {STATUS_LOG_BLOCK_VERSION, -EIO, "STATUS_LOG_BLOCK_VERSION"}, 1766 {STATUS_LOG_BLOCK_VERSION, -EIO, "STATUS_LOG_BLOCK_VERSION"},
1765 {STATUS_LOG_BLOCK_INVALID, -EIO, "STATUS_LOG_BLOCK_INVALID"}, 1767 {STATUS_LOG_BLOCK_INVALID, -EIO, "STATUS_LOG_BLOCK_INVALID"},
1766 {STATUS_LOG_READ_MODE_INVALID, -EIO, "STATUS_LOG_READ_MODE_INVALID"}, 1768 {STATUS_LOG_READ_MODE_INVALID, -EIO, "STATUS_LOG_READ_MODE_INVALID"},
1767 {STATUS_LOG_METADATA_CORRUPT, -EIO, "STATUS_LOG_METADATA_CORRUPT"}, 1769 {STATUS_LOG_METADATA_CORRUPT, -EIO, "STATUS_LOG_METADATA_CORRUPT"},
1768 {STATUS_LOG_METADATA_INVALID, -EIO, "STATUS_LOG_METADATA_INVALID"}, 1770 {STATUS_LOG_METADATA_INVALID, -EIO, "STATUS_LOG_METADATA_INVALID"},
1769 {STATUS_LOG_METADATA_INCONSISTENT, -EIO, 1771 {STATUS_LOG_METADATA_INCONSISTENT, -EIO,
1770 "STATUS_LOG_METADATA_INCONSISTENT"}, 1772 "STATUS_LOG_METADATA_INCONSISTENT"},
1771 {STATUS_LOG_RESERVATION_INVALID, -EIO, 1773 {STATUS_LOG_RESERVATION_INVALID, -EIO,
1772 "STATUS_LOG_RESERVATION_INVALID"}, 1774 "STATUS_LOG_RESERVATION_INVALID"},
1773 {STATUS_LOG_CANT_DELETE, -EIO, "STATUS_LOG_CANT_DELETE"}, 1775 {STATUS_LOG_CANT_DELETE, -EIO, "STATUS_LOG_CANT_DELETE"},
1774 {STATUS_LOG_CONTAINER_LIMIT_EXCEEDED, -EIO, 1776 {STATUS_LOG_CONTAINER_LIMIT_EXCEEDED, -EIO,
1775 "STATUS_LOG_CONTAINER_LIMIT_EXCEEDED"}, 1777 "STATUS_LOG_CONTAINER_LIMIT_EXCEEDED"},
1776 {STATUS_LOG_START_OF_LOG, -EIO, "STATUS_LOG_START_OF_LOG"}, 1778 {STATUS_LOG_START_OF_LOG, -EIO, "STATUS_LOG_START_OF_LOG"},
1777 {STATUS_LOG_POLICY_ALREADY_INSTALLED, -EIO, 1779 {STATUS_LOG_POLICY_ALREADY_INSTALLED, -EIO,
1778 "STATUS_LOG_POLICY_ALREADY_INSTALLED"}, 1780 "STATUS_LOG_POLICY_ALREADY_INSTALLED"},
1779 {STATUS_LOG_POLICY_NOT_INSTALLED, -EIO, 1781 {STATUS_LOG_POLICY_NOT_INSTALLED, -EIO,
1780 "STATUS_LOG_POLICY_NOT_INSTALLED"}, 1782 "STATUS_LOG_POLICY_NOT_INSTALLED"},
1781 {STATUS_LOG_POLICY_INVALID, -EIO, "STATUS_LOG_POLICY_INVALID"}, 1783 {STATUS_LOG_POLICY_INVALID, -EIO, "STATUS_LOG_POLICY_INVALID"},
1782 {STATUS_LOG_POLICY_CONFLICT, -EIO, "STATUS_LOG_POLICY_CONFLICT"}, 1784 {STATUS_LOG_POLICY_CONFLICT, -EIO, "STATUS_LOG_POLICY_CONFLICT"},
1783 {STATUS_LOG_PINNED_ARCHIVE_TAIL, -EIO, 1785 {STATUS_LOG_PINNED_ARCHIVE_TAIL, -EIO,
1784 "STATUS_LOG_PINNED_ARCHIVE_TAIL"}, 1786 "STATUS_LOG_PINNED_ARCHIVE_TAIL"},
1785 {STATUS_LOG_RECORD_NONEXISTENT, -EIO, "STATUS_LOG_RECORD_NONEXISTENT"}, 1787 {STATUS_LOG_RECORD_NONEXISTENT, -EIO, "STATUS_LOG_RECORD_NONEXISTENT"},
1786 {STATUS_LOG_RECORDS_RESERVED_INVALID, -EIO, 1788 {STATUS_LOG_RECORDS_RESERVED_INVALID, -EIO,
1787 "STATUS_LOG_RECORDS_RESERVED_INVALID"}, 1789 "STATUS_LOG_RECORDS_RESERVED_INVALID"},
1788 {STATUS_LOG_SPACE_RESERVED_INVALID, -EIO, 1790 {STATUS_LOG_SPACE_RESERVED_INVALID, -EIO,
1789 "STATUS_LOG_SPACE_RESERVED_INVALID"}, 1791 "STATUS_LOG_SPACE_RESERVED_INVALID"},
1790 {STATUS_LOG_TAIL_INVALID, -EIO, "STATUS_LOG_TAIL_INVALID"}, 1792 {STATUS_LOG_TAIL_INVALID, -EIO, "STATUS_LOG_TAIL_INVALID"},
1791 {STATUS_LOG_FULL, -EIO, "STATUS_LOG_FULL"}, 1793 {STATUS_LOG_FULL, -EIO, "STATUS_LOG_FULL"},
1792 {STATUS_LOG_MULTIPLEXED, -EIO, "STATUS_LOG_MULTIPLEXED"}, 1794 {STATUS_LOG_MULTIPLEXED, -EIO, "STATUS_LOG_MULTIPLEXED"},
1793 {STATUS_LOG_DEDICATED, -EIO, "STATUS_LOG_DEDICATED"}, 1795 {STATUS_LOG_DEDICATED, -EIO, "STATUS_LOG_DEDICATED"},
1794 {STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS, -EIO, 1796 {STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS, -EIO,
1795 "STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS"}, 1797 "STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS"},
1796 {STATUS_LOG_ARCHIVE_IN_PROGRESS, -EIO, 1798 {STATUS_LOG_ARCHIVE_IN_PROGRESS, -EIO,
1797 "STATUS_LOG_ARCHIVE_IN_PROGRESS"}, 1799 "STATUS_LOG_ARCHIVE_IN_PROGRESS"},
1798 {STATUS_LOG_EPHEMERAL, -EIO, "STATUS_LOG_EPHEMERAL"}, 1800 {STATUS_LOG_EPHEMERAL, -EIO, "STATUS_LOG_EPHEMERAL"},
1799 {STATUS_LOG_NOT_ENOUGH_CONTAINERS, -EIO, 1801 {STATUS_LOG_NOT_ENOUGH_CONTAINERS, -EIO,
1800 "STATUS_LOG_NOT_ENOUGH_CONTAINERS"}, 1802 "STATUS_LOG_NOT_ENOUGH_CONTAINERS"},
1801 {STATUS_LOG_CLIENT_ALREADY_REGISTERED, -EIO, 1803 {STATUS_LOG_CLIENT_ALREADY_REGISTERED, -EIO,
1802 "STATUS_LOG_CLIENT_ALREADY_REGISTERED"}, 1804 "STATUS_LOG_CLIENT_ALREADY_REGISTERED"},
1803 {STATUS_LOG_CLIENT_NOT_REGISTERED, -EIO, 1805 {STATUS_LOG_CLIENT_NOT_REGISTERED, -EIO,
1804 "STATUS_LOG_CLIENT_NOT_REGISTERED"}, 1806 "STATUS_LOG_CLIENT_NOT_REGISTERED"},
1805 {STATUS_LOG_FULL_HANDLER_IN_PROGRESS, -EIO, 1807 {STATUS_LOG_FULL_HANDLER_IN_PROGRESS, -EIO,
1806 "STATUS_LOG_FULL_HANDLER_IN_PROGRESS"}, 1808 "STATUS_LOG_FULL_HANDLER_IN_PROGRESS"},
1807 {STATUS_LOG_CONTAINER_READ_FAILED, -EIO, 1809 {STATUS_LOG_CONTAINER_READ_FAILED, -EIO,
1808 "STATUS_LOG_CONTAINER_READ_FAILED"}, 1810 "STATUS_LOG_CONTAINER_READ_FAILED"},
1809 {STATUS_LOG_CONTAINER_WRITE_FAILED, -EIO, 1811 {STATUS_LOG_CONTAINER_WRITE_FAILED, -EIO,
1810 "STATUS_LOG_CONTAINER_WRITE_FAILED"}, 1812 "STATUS_LOG_CONTAINER_WRITE_FAILED"},
1811 {STATUS_LOG_CONTAINER_OPEN_FAILED, -EIO, 1813 {STATUS_LOG_CONTAINER_OPEN_FAILED, -EIO,
1812 "STATUS_LOG_CONTAINER_OPEN_FAILED"}, 1814 "STATUS_LOG_CONTAINER_OPEN_FAILED"},
1813 {STATUS_LOG_CONTAINER_STATE_INVALID, -EIO, 1815 {STATUS_LOG_CONTAINER_STATE_INVALID, -EIO,
1814 "STATUS_LOG_CONTAINER_STATE_INVALID"}, 1816 "STATUS_LOG_CONTAINER_STATE_INVALID"},
1815 {STATUS_LOG_STATE_INVALID, -EIO, "STATUS_LOG_STATE_INVALID"}, 1817 {STATUS_LOG_STATE_INVALID, -EIO, "STATUS_LOG_STATE_INVALID"},
1816 {STATUS_LOG_PINNED, -EIO, "STATUS_LOG_PINNED"}, 1818 {STATUS_LOG_PINNED, -EIO, "STATUS_LOG_PINNED"},
1817 {STATUS_LOG_METADATA_FLUSH_FAILED, -EIO, 1819 {STATUS_LOG_METADATA_FLUSH_FAILED, -EIO,
1818 "STATUS_LOG_METADATA_FLUSH_FAILED"}, 1820 "STATUS_LOG_METADATA_FLUSH_FAILED"},
1819 {STATUS_LOG_INCONSISTENT_SECURITY, -EIO, 1821 {STATUS_LOG_INCONSISTENT_SECURITY, -EIO,
1820 "STATUS_LOG_INCONSISTENT_SECURITY"}, 1822 "STATUS_LOG_INCONSISTENT_SECURITY"},
1821 {STATUS_LOG_APPENDED_FLUSH_FAILED, -EIO, 1823 {STATUS_LOG_APPENDED_FLUSH_FAILED, -EIO,
1822 "STATUS_LOG_APPENDED_FLUSH_FAILED"}, 1824 "STATUS_LOG_APPENDED_FLUSH_FAILED"},
1823 {STATUS_LOG_PINNED_RESERVATION, -EIO, "STATUS_LOG_PINNED_RESERVATION"}, 1825 {STATUS_LOG_PINNED_RESERVATION, -EIO, "STATUS_LOG_PINNED_RESERVATION"},
1824 {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD, -EIO, 1826 {STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD, -EIO,
1825 "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD"}, 1827 "STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD"},
1826 {STATUS_FLT_NO_HANDLER_DEFINED, -EIO, "STATUS_FLT_NO_HANDLER_DEFINED"}, 1828 {STATUS_FLT_NO_HANDLER_DEFINED, -EIO, "STATUS_FLT_NO_HANDLER_DEFINED"},
1827 {STATUS_FLT_CONTEXT_ALREADY_DEFINED, -EIO, 1829 {STATUS_FLT_CONTEXT_ALREADY_DEFINED, -EIO,
1828 "STATUS_FLT_CONTEXT_ALREADY_DEFINED"}, 1830 "STATUS_FLT_CONTEXT_ALREADY_DEFINED"},
1829 {STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST, -EIO, 1831 {STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST, -EIO,
1830 "STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST"}, 1832 "STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST"},
1831 {STATUS_FLT_DISALLOW_FAST_IO, -EIO, "STATUS_FLT_DISALLOW_FAST_IO"}, 1833 {STATUS_FLT_DISALLOW_FAST_IO, -EIO, "STATUS_FLT_DISALLOW_FAST_IO"},
1832 {STATUS_FLT_INVALID_NAME_REQUEST, -EIO, 1834 {STATUS_FLT_INVALID_NAME_REQUEST, -EIO,
1833 "STATUS_FLT_INVALID_NAME_REQUEST"}, 1835 "STATUS_FLT_INVALID_NAME_REQUEST"},
1834 {STATUS_FLT_NOT_SAFE_TO_POST_OPERATION, -EIO, 1836 {STATUS_FLT_NOT_SAFE_TO_POST_OPERATION, -EIO,
1835 "STATUS_FLT_NOT_SAFE_TO_POST_OPERATION"}, 1837 "STATUS_FLT_NOT_SAFE_TO_POST_OPERATION"},
1836 {STATUS_FLT_NOT_INITIALIZED, -EIO, "STATUS_FLT_NOT_INITIALIZED"}, 1838 {STATUS_FLT_NOT_INITIALIZED, -EIO, "STATUS_FLT_NOT_INITIALIZED"},
1837 {STATUS_FLT_FILTER_NOT_READY, -EIO, "STATUS_FLT_FILTER_NOT_READY"}, 1839 {STATUS_FLT_FILTER_NOT_READY, -EIO, "STATUS_FLT_FILTER_NOT_READY"},
1838 {STATUS_FLT_POST_OPERATION_CLEANUP, -EIO, 1840 {STATUS_FLT_POST_OPERATION_CLEANUP, -EIO,
1839 "STATUS_FLT_POST_OPERATION_CLEANUP"}, 1841 "STATUS_FLT_POST_OPERATION_CLEANUP"},
1840 {STATUS_FLT_INTERNAL_ERROR, -EIO, "STATUS_FLT_INTERNAL_ERROR"}, 1842 {STATUS_FLT_INTERNAL_ERROR, -EIO, "STATUS_FLT_INTERNAL_ERROR"},
1841 {STATUS_FLT_DELETING_OBJECT, -EIO, "STATUS_FLT_DELETING_OBJECT"}, 1843 {STATUS_FLT_DELETING_OBJECT, -EIO, "STATUS_FLT_DELETING_OBJECT"},
1842 {STATUS_FLT_MUST_BE_NONPAGED_POOL, -EIO, 1844 {STATUS_FLT_MUST_BE_NONPAGED_POOL, -EIO,
1843 "STATUS_FLT_MUST_BE_NONPAGED_POOL"}, 1845 "STATUS_FLT_MUST_BE_NONPAGED_POOL"},
1844 {STATUS_FLT_DUPLICATE_ENTRY, -EIO, "STATUS_FLT_DUPLICATE_ENTRY"}, 1846 {STATUS_FLT_DUPLICATE_ENTRY, -EIO, "STATUS_FLT_DUPLICATE_ENTRY"},
1845 {STATUS_FLT_CBDQ_DISABLED, -EIO, "STATUS_FLT_CBDQ_DISABLED"}, 1847 {STATUS_FLT_CBDQ_DISABLED, -EIO, "STATUS_FLT_CBDQ_DISABLED"},
1846 {STATUS_FLT_DO_NOT_ATTACH, -EIO, "STATUS_FLT_DO_NOT_ATTACH"}, 1848 {STATUS_FLT_DO_NOT_ATTACH, -EIO, "STATUS_FLT_DO_NOT_ATTACH"},
1847 {STATUS_FLT_DO_NOT_DETACH, -EIO, "STATUS_FLT_DO_NOT_DETACH"}, 1849 {STATUS_FLT_DO_NOT_DETACH, -EIO, "STATUS_FLT_DO_NOT_DETACH"},
1848 {STATUS_FLT_INSTANCE_ALTITUDE_COLLISION, -EIO, 1850 {STATUS_FLT_INSTANCE_ALTITUDE_COLLISION, -EIO,
1849 "STATUS_FLT_INSTANCE_ALTITUDE_COLLISION"}, 1851 "STATUS_FLT_INSTANCE_ALTITUDE_COLLISION"},
1850 {STATUS_FLT_INSTANCE_NAME_COLLISION, -EIO, 1852 {STATUS_FLT_INSTANCE_NAME_COLLISION, -EIO,
1851 "STATUS_FLT_INSTANCE_NAME_COLLISION"}, 1853 "STATUS_FLT_INSTANCE_NAME_COLLISION"},
1852 {STATUS_FLT_FILTER_NOT_FOUND, -EIO, "STATUS_FLT_FILTER_NOT_FOUND"}, 1854 {STATUS_FLT_FILTER_NOT_FOUND, -EIO, "STATUS_FLT_FILTER_NOT_FOUND"},
1853 {STATUS_FLT_VOLUME_NOT_FOUND, -EIO, "STATUS_FLT_VOLUME_NOT_FOUND"}, 1855 {STATUS_FLT_VOLUME_NOT_FOUND, -EIO, "STATUS_FLT_VOLUME_NOT_FOUND"},
1854 {STATUS_FLT_INSTANCE_NOT_FOUND, -EIO, "STATUS_FLT_INSTANCE_NOT_FOUND"}, 1856 {STATUS_FLT_INSTANCE_NOT_FOUND, -EIO, "STATUS_FLT_INSTANCE_NOT_FOUND"},
1855 {STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND, -EIO, 1857 {STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND, -EIO,
1856 "STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND"}, 1858 "STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND"},
1857 {STATUS_FLT_INVALID_CONTEXT_REGISTRATION, -EIO, 1859 {STATUS_FLT_INVALID_CONTEXT_REGISTRATION, -EIO,
1858 "STATUS_FLT_INVALID_CONTEXT_REGISTRATION"}, 1860 "STATUS_FLT_INVALID_CONTEXT_REGISTRATION"},
1859 {STATUS_FLT_NAME_CACHE_MISS, -EIO, "STATUS_FLT_NAME_CACHE_MISS"}, 1861 {STATUS_FLT_NAME_CACHE_MISS, -EIO, "STATUS_FLT_NAME_CACHE_MISS"},
1860 {STATUS_FLT_NO_DEVICE_OBJECT, -EIO, "STATUS_FLT_NO_DEVICE_OBJECT"}, 1862 {STATUS_FLT_NO_DEVICE_OBJECT, -EIO, "STATUS_FLT_NO_DEVICE_OBJECT"},
1861 {STATUS_FLT_VOLUME_ALREADY_MOUNTED, -EIO, 1863 {STATUS_FLT_VOLUME_ALREADY_MOUNTED, -EIO,
1862 "STATUS_FLT_VOLUME_ALREADY_MOUNTED"}, 1864 "STATUS_FLT_VOLUME_ALREADY_MOUNTED"},
1863 {STATUS_FLT_ALREADY_ENLISTED, -EIO, "STATUS_FLT_ALREADY_ENLISTED"}, 1865 {STATUS_FLT_ALREADY_ENLISTED, -EIO, "STATUS_FLT_ALREADY_ENLISTED"},
1864 {STATUS_FLT_CONTEXT_ALREADY_LINKED, -EIO, 1866 {STATUS_FLT_CONTEXT_ALREADY_LINKED, -EIO,
1865 "STATUS_FLT_CONTEXT_ALREADY_LINKED"}, 1867 "STATUS_FLT_CONTEXT_ALREADY_LINKED"},
1866 {STATUS_FLT_NO_WAITER_FOR_REPLY, -EIO, 1868 {STATUS_FLT_NO_WAITER_FOR_REPLY, -EIO,
1867 "STATUS_FLT_NO_WAITER_FOR_REPLY"}, 1869 "STATUS_FLT_NO_WAITER_FOR_REPLY"},
1868 {STATUS_MONITOR_NO_DESCRIPTOR, -EIO, "STATUS_MONITOR_NO_DESCRIPTOR"}, 1870 {STATUS_MONITOR_NO_DESCRIPTOR, -EIO, "STATUS_MONITOR_NO_DESCRIPTOR"},
1869 {STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT, -EIO, 1871 {STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT, -EIO,
1870 "STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT"}, 1872 "STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT"},
1871 {STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM, -EIO, 1873 {STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM, -EIO,
1872 "STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM"}, 1874 "STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM"},
1873 {STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK, -EIO, 1875 {STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK, -EIO,
1874 "STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK"}, 1876 "STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK"},
1875 {STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED, -EIO, 1877 {STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED, -EIO,
1876 "STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED"}, 1878 "STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED"},
1877 {STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK, -EIO, 1879 {STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK, -EIO,
1878 "STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK"}, 1880 "STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK"},
1879 {STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK, -EIO, 1881 {STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK, -EIO,
1880 "STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK"}, 1882 "STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK"},
1881 {STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA, -EIO, 1883 {STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA, -EIO,
1882 "STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA"}, 1884 "STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA"},
1883 {STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK, -EIO, 1885 {STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK, -EIO,
1884 "STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK"}, 1886 "STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK"},
1885 {STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER, -EIO, 1887 {STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER, -EIO,
1886 "STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER"}, 1888 "STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER"},
1887 {STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER, -EIO, 1889 {STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER, -EIO,
1888 "STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER"}, 1890 "STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER"},
1889 {STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER, -EIO, 1891 {STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER, -EIO,
1890 "STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER"}, 1892 "STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER"},
1891 {STATUS_GRAPHICS_ADAPTER_WAS_RESET, -EIO, 1893 {STATUS_GRAPHICS_ADAPTER_WAS_RESET, -EIO,
1892 "STATUS_GRAPHICS_ADAPTER_WAS_RESET"}, 1894 "STATUS_GRAPHICS_ADAPTER_WAS_RESET"},
1893 {STATUS_GRAPHICS_INVALID_DRIVER_MODEL, -EIO, 1895 {STATUS_GRAPHICS_INVALID_DRIVER_MODEL, -EIO,
1894 "STATUS_GRAPHICS_INVALID_DRIVER_MODEL"}, 1896 "STATUS_GRAPHICS_INVALID_DRIVER_MODEL"},
1895 {STATUS_GRAPHICS_PRESENT_MODE_CHANGED, -EIO, 1897 {STATUS_GRAPHICS_PRESENT_MODE_CHANGED, -EIO,
1896 "STATUS_GRAPHICS_PRESENT_MODE_CHANGED"}, 1898 "STATUS_GRAPHICS_PRESENT_MODE_CHANGED"},
1897 {STATUS_GRAPHICS_PRESENT_OCCLUDED, -EIO, 1899 {STATUS_GRAPHICS_PRESENT_OCCLUDED, -EIO,
1898 "STATUS_GRAPHICS_PRESENT_OCCLUDED"}, 1900 "STATUS_GRAPHICS_PRESENT_OCCLUDED"},
1899 {STATUS_GRAPHICS_PRESENT_DENIED, -EIO, 1901 {STATUS_GRAPHICS_PRESENT_DENIED, -EIO,
1900 "STATUS_GRAPHICS_PRESENT_DENIED"}, 1902 "STATUS_GRAPHICS_PRESENT_DENIED"},
1901 {STATUS_GRAPHICS_CANNOTCOLORCONVERT, -EIO, 1903 {STATUS_GRAPHICS_CANNOTCOLORCONVERT, -EIO,
1902 "STATUS_GRAPHICS_CANNOTCOLORCONVERT"}, 1904 "STATUS_GRAPHICS_CANNOTCOLORCONVERT"},
1903 {STATUS_GRAPHICS_NO_VIDEO_MEMORY, -EIO, 1905 {STATUS_GRAPHICS_NO_VIDEO_MEMORY, -EIO,
1904 "STATUS_GRAPHICS_NO_VIDEO_MEMORY"}, 1906 "STATUS_GRAPHICS_NO_VIDEO_MEMORY"},
1905 {STATUS_GRAPHICS_CANT_LOCK_MEMORY, -EIO, 1907 {STATUS_GRAPHICS_CANT_LOCK_MEMORY, -EIO,
1906 "STATUS_GRAPHICS_CANT_LOCK_MEMORY"}, 1908 "STATUS_GRAPHICS_CANT_LOCK_MEMORY"},
1907 {STATUS_GRAPHICS_ALLOCATION_BUSY, -EBUSY, 1909 {STATUS_GRAPHICS_ALLOCATION_BUSY, -EBUSY,
1908 "STATUS_GRAPHICS_ALLOCATION_BUSY"}, 1910 "STATUS_GRAPHICS_ALLOCATION_BUSY"},
1909 {STATUS_GRAPHICS_TOO_MANY_REFERENCES, -EIO, 1911 {STATUS_GRAPHICS_TOO_MANY_REFERENCES, -EIO,
1910 "STATUS_GRAPHICS_TOO_MANY_REFERENCES"}, 1912 "STATUS_GRAPHICS_TOO_MANY_REFERENCES"},
1911 {STATUS_GRAPHICS_TRY_AGAIN_LATER, -EIO, 1913 {STATUS_GRAPHICS_TRY_AGAIN_LATER, -EIO,
1912 "STATUS_GRAPHICS_TRY_AGAIN_LATER"}, 1914 "STATUS_GRAPHICS_TRY_AGAIN_LATER"},
1913 {STATUS_GRAPHICS_TRY_AGAIN_NOW, -EIO, "STATUS_GRAPHICS_TRY_AGAIN_NOW"}, 1915 {STATUS_GRAPHICS_TRY_AGAIN_NOW, -EIO, "STATUS_GRAPHICS_TRY_AGAIN_NOW"},
1914 {STATUS_GRAPHICS_ALLOCATION_INVALID, -EIO, 1916 {STATUS_GRAPHICS_ALLOCATION_INVALID, -EIO,
1915 "STATUS_GRAPHICS_ALLOCATION_INVALID"}, 1917 "STATUS_GRAPHICS_ALLOCATION_INVALID"},
1916 {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE, -EIO, 1918 {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE, -EIO,
1917 "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE"}, 1919 "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE"},
1918 {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED, -EIO, 1920 {STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED, -EIO,
1919 "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED"}, 1921 "STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED"},
1920 {STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION, -EIO, 1922 {STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION, -EIO,
1921 "STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION"}, 1923 "STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION"},
1922 {STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE, -EIO, 1924 {STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE, -EIO,
1923 "STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE"}, 1925 "STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE"},
1924 {STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION, -EIO, 1926 {STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION, -EIO,
1925 "STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION"}, 1927 "STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION"},
1926 {STATUS_GRAPHICS_ALLOCATION_CLOSED, -EIO, 1928 {STATUS_GRAPHICS_ALLOCATION_CLOSED, -EIO,
1927 "STATUS_GRAPHICS_ALLOCATION_CLOSED"}, 1929 "STATUS_GRAPHICS_ALLOCATION_CLOSED"},
1928 {STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE, -EIO, 1930 {STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE, -EIO,
1929 "STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE"}, 1931 "STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE"},
1930 {STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE, -EIO, 1932 {STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE, -EIO,
1931 "STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE"}, 1933 "STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE"},
1932 {STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE, -EIO, 1934 {STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE, -EIO,
1933 "STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE"}, 1935 "STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE"},
1934 {STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST, -EIO, 1936 {STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST, -EIO,
1935 "STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST"}, 1937 "STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST"},
1936 {STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE, -EIO, 1938 {STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE, -EIO,
1937 "STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE"}, 1939 "STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE"},
1938 {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY, -EIO, 1940 {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY, -EIO,
1939 "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY"}, 1941 "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY"},
1940 {STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED, -EIO, 1942 {STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED, -EIO,
1941 "STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED"}, 1943 "STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED"},
1942 {STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED, -EIO, 1944 {STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED, -EIO,
1943 "STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED"}, 1945 "STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED"},
1944 {STATUS_GRAPHICS_INVALID_VIDPN, -EIO, "STATUS_GRAPHICS_INVALID_VIDPN"}, 1946 {STATUS_GRAPHICS_INVALID_VIDPN, -EIO, "STATUS_GRAPHICS_INVALID_VIDPN"},
1945 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE, -EIO, 1947 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE, -EIO,
1946 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE"}, 1948 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE"},
1947 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET, -EIO, 1949 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET, -EIO,
1948 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET"}, 1950 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET"},
1949 {STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED, -EIO, 1951 {STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED, -EIO,
1950 "STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED"}, 1952 "STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED"},
1951 {STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET, -EIO, 1953 {STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET, -EIO,
1952 "STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET"}, 1954 "STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET"},
1953 {STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET, -EIO, 1955 {STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET, -EIO,
1954 "STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET"}, 1956 "STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET"},
1955 {STATUS_GRAPHICS_INVALID_FREQUENCY, -EIO, 1957 {STATUS_GRAPHICS_INVALID_FREQUENCY, -EIO,
1956 "STATUS_GRAPHICS_INVALID_FREQUENCY"}, 1958 "STATUS_GRAPHICS_INVALID_FREQUENCY"},
1957 {STATUS_GRAPHICS_INVALID_ACTIVE_REGION, -EIO, 1959 {STATUS_GRAPHICS_INVALID_ACTIVE_REGION, -EIO,
1958 "STATUS_GRAPHICS_INVALID_ACTIVE_REGION"}, 1960 "STATUS_GRAPHICS_INVALID_ACTIVE_REGION"},
1959 {STATUS_GRAPHICS_INVALID_TOTAL_REGION, -EIO, 1961 {STATUS_GRAPHICS_INVALID_TOTAL_REGION, -EIO,
1960 "STATUS_GRAPHICS_INVALID_TOTAL_REGION"}, 1962 "STATUS_GRAPHICS_INVALID_TOTAL_REGION"},
1961 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE, -EIO, 1963 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE, -EIO,
1962 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE"}, 1964 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE"},
1963 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE, -EIO, 1965 {STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE, -EIO,
1964 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE"}, 1966 "STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE"},
1965 {STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET, -EIO, 1967 {STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET, -EIO,
1966 "STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET"}, 1968 "STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET"},
1967 {STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY, -EIO, 1969 {STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY, -EIO,
1968 "STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY"}, 1970 "STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY"},
1969 {STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET, -EIO, 1971 {STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET, -EIO,
1970 "STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET"}, 1972 "STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET"},
1971 {STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET, -EIO, 1973 {STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET, -EIO,
1972 "STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET"}, 1974 "STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET"},
1973 {STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET, -EIO, 1975 {STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET, -EIO,
1974 "STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET"}, 1976 "STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET"},
1975 {STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET, -EIO, 1977 {STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET, -EIO,
1976 "STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET"}, 1978 "STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET"},
1977 {STATUS_GRAPHICS_TARGET_ALREADY_IN_SET, -EIO, 1979 {STATUS_GRAPHICS_TARGET_ALREADY_IN_SET, -EIO,
1978 "STATUS_GRAPHICS_TARGET_ALREADY_IN_SET"}, 1980 "STATUS_GRAPHICS_TARGET_ALREADY_IN_SET"},
1979 {STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH, -EIO, 1981 {STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH, -EIO,
1980 "STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH"}, 1982 "STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH"},
1981 {STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY, -EIO, 1983 {STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY, -EIO,
1982 "STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY"}, 1984 "STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY"},
1983 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET, -EIO, 1985 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET, -EIO,
1984 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET"}, 1986 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET"},
1985 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE, -EIO, 1987 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE, -EIO,
1986 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE"}, 1988 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE"},
1987 {STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET, -EIO, 1989 {STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET, -EIO,
1988 "STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET"}, 1990 "STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET"},
1989 {STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET, -EIO, 1991 {STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET, -EIO,
1990 "STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET"}, 1992 "STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET"},
1991 {STATUS_GRAPHICS_STALE_MODESET, -EIO, "STATUS_GRAPHICS_STALE_MODESET"}, 1993 {STATUS_GRAPHICS_STALE_MODESET, -EIO, "STATUS_GRAPHICS_STALE_MODESET"},
1992 {STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET, -EIO, 1994 {STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET, -EIO,
1993 "STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET"}, 1995 "STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET"},
1994 {STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE, -EIO, 1996 {STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE, -EIO,
1995 "STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE"}, 1997 "STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE"},
1996 {STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN, -EIO, 1998 {STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN, -EIO,
1997 "STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN"}, 1999 "STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN"},
1998 {STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE, -EIO, 2000 {STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE, -EIO,
1999 "STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE"}, 2001 "STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE"},
2000 {STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION, -EIO, 2002 {STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION, -EIO,
2001 "STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION"}, 2003 "STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION"},
2002 {STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES, -EIO, 2004 {STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES, -EIO,
2003 "STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES"}, 2005 "STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES"},
2004 {STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY, -EIO, 2006 {STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY, -EIO,
2005 "STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY"}, 2007 "STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY"},
2006 {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE, -EIO, 2008 {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE, -EIO,
2007 "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE"}, 2009 "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE"},
2008 {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET, -EIO, 2010 {STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET, -EIO,
2009 "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET"}, 2011 "STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET"},
2010 {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET, -EIO, 2012 {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET, -EIO,
2011 "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET"}, 2013 "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET"},
2012 {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR, -EIO, 2014 {STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR, -EIO,
2013 "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR"}, 2015 "STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR"},
2014 {STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET, -EIO, 2016 {STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET, -EIO,
2015 "STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET"}, 2017 "STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET"},
2016 {STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET, -EIO, 2018 {STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET, -EIO,
2017 "STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET"}, 2019 "STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET"},
2018 {STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE, -EIO, 2020 {STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE, -EIO,
2019 "STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE"}, 2021 "STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE"},
2020 {STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE, -EIO, 2022 {STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE, -EIO,
2021 "STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE"}, 2023 "STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE"},
2022 {STATUS_GRAPHICS_RESOURCES_NOT_RELATED, -EIO, 2024 {STATUS_GRAPHICS_RESOURCES_NOT_RELATED, -EIO,
2023 "STATUS_GRAPHICS_RESOURCES_NOT_RELATED"}, 2025 "STATUS_GRAPHICS_RESOURCES_NOT_RELATED"},
2024 {STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE, -EIO, 2026 {STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE, -EIO,
2025 "STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE"}, 2027 "STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE"},
2026 {STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE, -EIO, 2028 {STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE, -EIO,
2027 "STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE"}, 2029 "STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE"},
2028 {STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET, -EIO, 2030 {STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET, -EIO,
2029 "STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET"}, 2031 "STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET"},
2030 {STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER, -EIO, 2032 {STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER, -EIO,
2031 "STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER"}, 2033 "STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER"},
2032 {STATUS_GRAPHICS_NO_VIDPNMGR, -EIO, "STATUS_GRAPHICS_NO_VIDPNMGR"}, 2034 {STATUS_GRAPHICS_NO_VIDPNMGR, -EIO, "STATUS_GRAPHICS_NO_VIDPNMGR"},
2033 {STATUS_GRAPHICS_NO_ACTIVE_VIDPN, -EIO, 2035 {STATUS_GRAPHICS_NO_ACTIVE_VIDPN, -EIO,
2034 "STATUS_GRAPHICS_NO_ACTIVE_VIDPN"}, 2036 "STATUS_GRAPHICS_NO_ACTIVE_VIDPN"},
2035 {STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY, -EIO, 2037 {STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY, -EIO,
2036 "STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY"}, 2038 "STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY"},
2037 {STATUS_GRAPHICS_MONITOR_NOT_CONNECTED, -EIO, 2039 {STATUS_GRAPHICS_MONITOR_NOT_CONNECTED, -EIO,
2038 "STATUS_GRAPHICS_MONITOR_NOT_CONNECTED"}, 2040 "STATUS_GRAPHICS_MONITOR_NOT_CONNECTED"},
2039 {STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY, -EIO, 2041 {STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY, -EIO,
2040 "STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY"}, 2042 "STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY"},
2041 {STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE, -EIO, 2043 {STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE, -EIO,
2042 "STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE"}, 2044 "STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE"},
2043 {STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE, -EIO, 2045 {STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE, -EIO,
2044 "STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE"}, 2046 "STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE"},
2045 {STATUS_GRAPHICS_INVALID_STRIDE, -EIO, 2047 {STATUS_GRAPHICS_INVALID_STRIDE, -EIO,
2046 "STATUS_GRAPHICS_INVALID_STRIDE"}, 2048 "STATUS_GRAPHICS_INVALID_STRIDE"},
2047 {STATUS_GRAPHICS_INVALID_PIXELFORMAT, -EIO, 2049 {STATUS_GRAPHICS_INVALID_PIXELFORMAT, -EIO,
2048 "STATUS_GRAPHICS_INVALID_PIXELFORMAT"}, 2050 "STATUS_GRAPHICS_INVALID_PIXELFORMAT"},
2049 {STATUS_GRAPHICS_INVALID_COLORBASIS, -EIO, 2051 {STATUS_GRAPHICS_INVALID_COLORBASIS, -EIO,
2050 "STATUS_GRAPHICS_INVALID_COLORBASIS"}, 2052 "STATUS_GRAPHICS_INVALID_COLORBASIS"},
2051 {STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE, -EIO, 2053 {STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE, -EIO,
2052 "STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE"}, 2054 "STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE"},
2053 {STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY, -EIO, 2055 {STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY, -EIO,
2054 "STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY"}, 2056 "STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY"},
2055 {STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT, -EIO, 2057 {STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT, -EIO,
2056 "STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT"}, 2058 "STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT"},
2057 {STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, -EIO, 2059 {STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, -EIO,
2058 "STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE"}, 2060 "STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE"},
2059 {STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN, -EIO, 2061 {STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN, -EIO,
2060 "STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN"}, 2062 "STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN"},
2061 {STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL, -EIO, 2063 {STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL, -EIO,
2062 "STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL"}, 2064 "STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL"},
2063 {STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION, -EIO, 2065 {STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION, -EIO,
2064 "STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION"}, 2066 "STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION"},
2065 {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED, 2067 {STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED,
2066 -EIO, 2068 -EIO,
2067 "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED"}, 2069 "STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED"},
2068 {STATUS_GRAPHICS_INVALID_GAMMA_RAMP, -EIO, 2070 {STATUS_GRAPHICS_INVALID_GAMMA_RAMP, -EIO,
2069 "STATUS_GRAPHICS_INVALID_GAMMA_RAMP"}, 2071 "STATUS_GRAPHICS_INVALID_GAMMA_RAMP"},
2070 {STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED, -EIO, 2072 {STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED, -EIO,
2071 "STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED"}, 2073 "STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED"},
2072 {STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED, -EIO, 2074 {STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED, -EIO,
2073 "STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED"}, 2075 "STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED"},
2074 {STATUS_GRAPHICS_MODE_NOT_IN_MODESET, -EIO, 2076 {STATUS_GRAPHICS_MODE_NOT_IN_MODESET, -EIO,
2075 "STATUS_GRAPHICS_MODE_NOT_IN_MODESET"}, 2077 "STATUS_GRAPHICS_MODE_NOT_IN_MODESET"},
2076 {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON, -EIO, 2078 {STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON, -EIO,
2077 "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON"}, 2079 "STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON"},
2078 {STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE, -EIO, 2080 {STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE, -EIO,
2079 "STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE"}, 2081 "STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE"},
2080 {STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE, -EIO, 2082 {STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE, -EIO,
2081 "STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE"}, 2083 "STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE"},
2082 {STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS, -EIO, 2084 {STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS, -EIO,
2083 "STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS"}, 2085 "STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS"},
2084 {STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING, -EIO, 2086 {STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING, -EIO,
2085 "STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING"}, 2087 "STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING"},
2086 {STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED, -EIO, 2088 {STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED, -EIO,
2087 "STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED"}, 2089 "STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED"},
2088 {STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS, -EIO, 2090 {STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS, -EIO,
2089 "STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS"}, 2091 "STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS"},
2090 {STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT, -EIO, 2092 {STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT, -EIO,
2091 "STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT"}, 2093 "STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT"},
2092 {STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM, -EIO, 2094 {STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM, -EIO,
2093 "STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM"}, 2095 "STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM"},
2094 {STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN, -EIO, 2096 {STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN, -EIO,
2095 "STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN"}, 2097 "STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN"},
2096 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT, -EIO, 2098 {STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT, -EIO,
2097 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT"}, 2099 "STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT"},
2098 {STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED, -EIO, 2100 {STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED, -EIO,
2099 "STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED"}, 2101 "STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED"},
2100 {STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION, -EIO, 2102 {STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION, -EIO,
2101 "STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION"}, 2103 "STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION"},
2102 {STATUS_GRAPHICS_INVALID_CLIENT_TYPE, -EIO, 2104 {STATUS_GRAPHICS_INVALID_CLIENT_TYPE, -EIO,
2103 "STATUS_GRAPHICS_INVALID_CLIENT_TYPE"}, 2105 "STATUS_GRAPHICS_INVALID_CLIENT_TYPE"},
2104 {STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET, -EIO, 2106 {STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET, -EIO,
2105 "STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET"}, 2107 "STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET"},
2106 {STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED, -EIO, 2108 {STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED, -EIO,
2107 "STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED"}, 2109 "STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED"},
2108 {STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED, -EIO, 2110 {STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED, -EIO,
2109 "STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED"}, 2111 "STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED"},
2110 {STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER, -EIO, 2112 {STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER, -EIO,
2111 "STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER"}, 2113 "STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER"},
2112 {STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED, -EIO, 2114 {STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED, -EIO,
2113 "STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED"}, 2115 "STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED"},
2114 {STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED, -EIO, 2116 {STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED, -EIO,
2115 "STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED"}, 2117 "STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED"},
2116 {STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY, -EIO, 2118 {STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY, -EIO,
2117 "STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY"}, 2119 "STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY"},
2118 {STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED, -EIO, 2120 {STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED, -EIO,
2119 "STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED"}, 2121 "STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED"},
2120 {STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON, -EIO, 2122 {STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON, -EIO,
2121 "STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON"}, 2123 "STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON"},
2122 {STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE, -EIO, 2124 {STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE, -EIO,
2123 "STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE"}, 2125 "STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE"},
2124 {STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER, -EIO, 2126 {STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER, -EIO,
2125 "STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER"}, 2127 "STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER"},
2126 {STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED, -EIO, 2128 {STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED, -EIO,
2127 "STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED"}, 2129 "STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED"},
2128 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS, 2130 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS,
2129 -EIO, 2131 -EIO,
2130 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS"}, 2132 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS"},
2131 {STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST, -EIO, 2133 {STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST, -EIO,
2132 "STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST"}, 2134 "STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST"},
2133 {STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR, -EIO, 2135 {STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR, -EIO,
2134 "STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR"}, 2136 "STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR"},
2135 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS, -EIO, 2137 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS, -EIO,
2136 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS"}, 2138 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS"},
2137 {STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED, -EIO, 2139 {STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED, -EIO,
2138 "STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED"}, 2140 "STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED"},
2139 {STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST, -EIO, 2141 {STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST, -EIO,
2140 "STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST"}, 2142 "STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST"},
2141 {STATUS_GRAPHICS_OPM_NOT_SUPPORTED, -EIO, 2143 {STATUS_GRAPHICS_OPM_NOT_SUPPORTED, -EIO,
2142 "STATUS_GRAPHICS_OPM_NOT_SUPPORTED"}, 2144 "STATUS_GRAPHICS_OPM_NOT_SUPPORTED"},
2143 {STATUS_GRAPHICS_COPP_NOT_SUPPORTED, -EIO, 2145 {STATUS_GRAPHICS_COPP_NOT_SUPPORTED, -EIO,
2144 "STATUS_GRAPHICS_COPP_NOT_SUPPORTED"}, 2146 "STATUS_GRAPHICS_COPP_NOT_SUPPORTED"},
2145 {STATUS_GRAPHICS_UAB_NOT_SUPPORTED, -EIO, 2147 {STATUS_GRAPHICS_UAB_NOT_SUPPORTED, -EIO,
2146 "STATUS_GRAPHICS_UAB_NOT_SUPPORTED"}, 2148 "STATUS_GRAPHICS_UAB_NOT_SUPPORTED"},
2147 {STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS, -EIO, 2149 {STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS, -EIO,
2148 "STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS"}, 2150 "STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS"},
2149 {STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL, -EIO, 2151 {STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL, -EIO,
2150 "STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL"}, 2152 "STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL"},
2151 {STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST, -EIO, 2153 {STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST, -EIO,
2152 "STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST"}, 2154 "STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST"},
2153 {STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO, 2155 {STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO,
2154 "STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"}, 2156 "STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"},
2155 {STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO, 2157 {STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO,
2156 "STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"}, 2158 "STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"},
2157 {STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO, 2159 {STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO,
2158 "STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED"}, 2160 "STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED"},
2159 {STATUS_GRAPHICS_OPM_INVALID_POINTER, -EIO, 2161 {STATUS_GRAPHICS_OPM_INVALID_POINTER, -EIO,
2160 "STATUS_GRAPHICS_OPM_INVALID_POINTER"}, 2162 "STATUS_GRAPHICS_OPM_INVALID_POINTER"},
2161 {STATUS_GRAPHICS_OPM_INTERNAL_ERROR, -EIO, 2163 {STATUS_GRAPHICS_OPM_INTERNAL_ERROR, -EIO,
2162 "STATUS_GRAPHICS_OPM_INTERNAL_ERROR"}, 2164 "STATUS_GRAPHICS_OPM_INTERNAL_ERROR"},
2163 {STATUS_GRAPHICS_OPM_INVALID_HANDLE, -EIO, 2165 {STATUS_GRAPHICS_OPM_INVALID_HANDLE, -EIO,
2164 "STATUS_GRAPHICS_OPM_INVALID_HANDLE"}, 2166 "STATUS_GRAPHICS_OPM_INVALID_HANDLE"},
2165 {STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO, 2167 {STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO,
2166 "STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"}, 2168 "STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"},
2167 {STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH, -EIO, 2169 {STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH, -EIO,
2168 "STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH"}, 2170 "STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH"},
2169 {STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED, -EIO, 2171 {STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED, -EIO,
2170 "STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED"}, 2172 "STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED"},
2171 {STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED, -EIO, 2173 {STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED, -EIO,
2172 "STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED"}, 2174 "STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED"},
2173 {STATUS_GRAPHICS_PVP_HFS_FAILED, -EIO, 2175 {STATUS_GRAPHICS_PVP_HFS_FAILED, -EIO,
2174 "STATUS_GRAPHICS_PVP_HFS_FAILED"}, 2176 "STATUS_GRAPHICS_PVP_HFS_FAILED"},
2175 {STATUS_GRAPHICS_OPM_INVALID_SRM, -EIO, 2177 {STATUS_GRAPHICS_OPM_INVALID_SRM, -EIO,
2176 "STATUS_GRAPHICS_OPM_INVALID_SRM"}, 2178 "STATUS_GRAPHICS_OPM_INVALID_SRM"},
2177 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP, -EIO, 2179 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP, -EIO,
2178 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP"}, 2180 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP"},
2179 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP, -EIO, 2181 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP, -EIO,
2180 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP"}, 2182 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP"},
2181 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA, -EIO, 2183 {STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA, -EIO,
2182 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA"}, 2184 "STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA"},
2183 {STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET, -EIO, 2185 {STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET, -EIO,
2184 "STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET"}, 2186 "STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET"},
2185 {STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH, -EIO, 2187 {STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH, -EIO,
2186 "STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH"}, 2188 "STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH"},
2187 {STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE, -EIO, 2189 {STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE, -EIO,
2188 "STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE"}, 2190 "STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE"},
2189 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS, -EIO, 2191 {STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS, -EIO,
2190 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS"}, 2192 "STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS"},
2191 {STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO, 2193 {STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO,
2192 "STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS"}, 2194 "STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS"},
2193 {STATUS_GRAPHICS_I2C_NOT_SUPPORTED, -EIO, 2195 {STATUS_GRAPHICS_I2C_NOT_SUPPORTED, -EIO,
2194 "STATUS_GRAPHICS_I2C_NOT_SUPPORTED"}, 2196 "STATUS_GRAPHICS_I2C_NOT_SUPPORTED"},
2195 {STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST, -EIO, 2197 {STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST, -EIO,
2196 "STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST"}, 2198 "STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST"},
2197 {STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA, -EIO, 2199 {STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA, -EIO,
2198 "STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA"}, 2200 "STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA"},
2199 {STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA, -EIO, 2201 {STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA, -EIO,
2200 "STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA"}, 2202 "STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA"},
2201 {STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED, -EIO, 2203 {STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED, -EIO,
2202 "STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED"}, 2204 "STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED"},
2203 {STATUS_GRAPHICS_DDCCI_INVALID_DATA, -EIO, 2205 {STATUS_GRAPHICS_DDCCI_INVALID_DATA, -EIO,
2204 "STATUS_GRAPHICS_DDCCI_INVALID_DATA"}, 2206 "STATUS_GRAPHICS_DDCCI_INVALID_DATA"},
2205 {STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE, 2207 {STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE,
2206 -EIO, 2208 -EIO,
2207 "STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE"}, 2209 "STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE"},
2208 {STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING, -EIO, 2210 {STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING, -EIO,
2209 "STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING"}, 2211 "STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING"},
2210 {STATUS_GRAPHICS_MCA_INTERNAL_ERROR, -EIO, 2212 {STATUS_GRAPHICS_MCA_INTERNAL_ERROR, -EIO,
2211 "STATUS_GRAPHICS_MCA_INTERNAL_ERROR"}, 2213 "STATUS_GRAPHICS_MCA_INTERNAL_ERROR"},
2212 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND, -EIO, 2214 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND, -EIO,
2213 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND"}, 2215 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND"},
2214 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH, -EIO, 2216 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH, -EIO,
2215 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH"}, 2217 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH"},
2216 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM, -EIO, 2218 {STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM, -EIO,
2217 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM"}, 2219 "STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM"},
2218 {STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE, -EIO, 2220 {STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE, -EIO,
2219 "STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE"}, 2221 "STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE"},
2220 {STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS, -EIO, 2222 {STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS, -EIO,
2221 "STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS"}, 2223 "STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS"},
2222 {STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED, -EIO, 2224 {STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED, -EIO,
2223 "STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED"}, 2225 "STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED"},
2224 {STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO, 2226 {STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME, -EIO,
2225 "STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"}, 2227 "STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME"},
2226 {STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO, 2228 {STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP, -EIO,
2227 "STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"}, 2229 "STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP"},
2228 {STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO, 2230 {STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED, -EIO,
2229 "STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED"}, 2231 "STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED"},
2230 {STATUS_GRAPHICS_INVALID_POINTER, -EIO, 2232 {STATUS_GRAPHICS_INVALID_POINTER, -EIO,
2231 "STATUS_GRAPHICS_INVALID_POINTER"}, 2233 "STATUS_GRAPHICS_INVALID_POINTER"},
2232 {STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO, 2234 {STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE, -EIO,
2233 "STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"}, 2235 "STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE"},
2234 {STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL, -EIO, 2236 {STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL, -EIO,
2235 "STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL"}, 2237 "STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL"},
2236 {STATUS_GRAPHICS_INTERNAL_ERROR, -EIO, 2238 {STATUS_GRAPHICS_INTERNAL_ERROR, -EIO,
2237 "STATUS_GRAPHICS_INTERNAL_ERROR"}, 2239 "STATUS_GRAPHICS_INTERNAL_ERROR"},
2238 {STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO, 2240 {STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS, -EIO,
2239 "STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS"}, 2241 "STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS"},
2240 {STATUS_FVE_LOCKED_VOLUME, -EIO, "STATUS_FVE_LOCKED_VOLUME"}, 2242 {STATUS_FVE_LOCKED_VOLUME, -EIO, "STATUS_FVE_LOCKED_VOLUME"},
2241 {STATUS_FVE_NOT_ENCRYPTED, -EIO, "STATUS_FVE_NOT_ENCRYPTED"}, 2243 {STATUS_FVE_NOT_ENCRYPTED, -EIO, "STATUS_FVE_NOT_ENCRYPTED"},
2242 {STATUS_FVE_BAD_INFORMATION, -EIO, "STATUS_FVE_BAD_INFORMATION"}, 2244 {STATUS_FVE_BAD_INFORMATION, -EIO, "STATUS_FVE_BAD_INFORMATION"},
2243 {STATUS_FVE_TOO_SMALL, -EIO, "STATUS_FVE_TOO_SMALL"}, 2245 {STATUS_FVE_TOO_SMALL, -EIO, "STATUS_FVE_TOO_SMALL"},
2244 {STATUS_FVE_FAILED_WRONG_FS, -EIO, "STATUS_FVE_FAILED_WRONG_FS"}, 2246 {STATUS_FVE_FAILED_WRONG_FS, -EIO, "STATUS_FVE_FAILED_WRONG_FS"},
2245 {STATUS_FVE_FAILED_BAD_FS, -EIO, "STATUS_FVE_FAILED_BAD_FS"}, 2247 {STATUS_FVE_FAILED_BAD_FS, -EIO, "STATUS_FVE_FAILED_BAD_FS"},
2246 {STATUS_FVE_FS_NOT_EXTENDED, -EIO, "STATUS_FVE_FS_NOT_EXTENDED"}, 2248 {STATUS_FVE_FS_NOT_EXTENDED, -EIO, "STATUS_FVE_FS_NOT_EXTENDED"},
2247 {STATUS_FVE_FS_MOUNTED, -EIO, "STATUS_FVE_FS_MOUNTED"}, 2249 {STATUS_FVE_FS_MOUNTED, -EIO, "STATUS_FVE_FS_MOUNTED"},
2248 {STATUS_FVE_NO_LICENSE, -EIO, "STATUS_FVE_NO_LICENSE"}, 2250 {STATUS_FVE_NO_LICENSE, -EIO, "STATUS_FVE_NO_LICENSE"},
2249 {STATUS_FVE_ACTION_NOT_ALLOWED, -EIO, "STATUS_FVE_ACTION_NOT_ALLOWED"}, 2251 {STATUS_FVE_ACTION_NOT_ALLOWED, -EIO, "STATUS_FVE_ACTION_NOT_ALLOWED"},
2250 {STATUS_FVE_BAD_DATA, -EIO, "STATUS_FVE_BAD_DATA"}, 2252 {STATUS_FVE_BAD_DATA, -EIO, "STATUS_FVE_BAD_DATA"},
2251 {STATUS_FVE_VOLUME_NOT_BOUND, -EIO, "STATUS_FVE_VOLUME_NOT_BOUND"}, 2253 {STATUS_FVE_VOLUME_NOT_BOUND, -EIO, "STATUS_FVE_VOLUME_NOT_BOUND"},
2252 {STATUS_FVE_NOT_DATA_VOLUME, -EIO, "STATUS_FVE_NOT_DATA_VOLUME"}, 2254 {STATUS_FVE_NOT_DATA_VOLUME, -EIO, "STATUS_FVE_NOT_DATA_VOLUME"},
2253 {STATUS_FVE_CONV_READ_ERROR, -EIO, "STATUS_FVE_CONV_READ_ERROR"}, 2255 {STATUS_FVE_CONV_READ_ERROR, -EIO, "STATUS_FVE_CONV_READ_ERROR"},
2254 {STATUS_FVE_CONV_WRITE_ERROR, -EIO, "STATUS_FVE_CONV_WRITE_ERROR"}, 2256 {STATUS_FVE_CONV_WRITE_ERROR, -EIO, "STATUS_FVE_CONV_WRITE_ERROR"},
2255 {STATUS_FVE_OVERLAPPED_UPDATE, -EIO, "STATUS_FVE_OVERLAPPED_UPDATE"}, 2257 {STATUS_FVE_OVERLAPPED_UPDATE, -EIO, "STATUS_FVE_OVERLAPPED_UPDATE"},
2256 {STATUS_FVE_FAILED_SECTOR_SIZE, -EIO, "STATUS_FVE_FAILED_SECTOR_SIZE"}, 2258 {STATUS_FVE_FAILED_SECTOR_SIZE, -EIO, "STATUS_FVE_FAILED_SECTOR_SIZE"},
2257 {STATUS_FVE_FAILED_AUTHENTICATION, -EIO, 2259 {STATUS_FVE_FAILED_AUTHENTICATION, -EIO,
2258 "STATUS_FVE_FAILED_AUTHENTICATION"}, 2260 "STATUS_FVE_FAILED_AUTHENTICATION"},
2259 {STATUS_FVE_NOT_OS_VOLUME, -EIO, "STATUS_FVE_NOT_OS_VOLUME"}, 2261 {STATUS_FVE_NOT_OS_VOLUME, -EIO, "STATUS_FVE_NOT_OS_VOLUME"},
2260 {STATUS_FVE_KEYFILE_NOT_FOUND, -EIO, "STATUS_FVE_KEYFILE_NOT_FOUND"}, 2262 {STATUS_FVE_KEYFILE_NOT_FOUND, -EIO, "STATUS_FVE_KEYFILE_NOT_FOUND"},
2261 {STATUS_FVE_KEYFILE_INVALID, -EIO, "STATUS_FVE_KEYFILE_INVALID"}, 2263 {STATUS_FVE_KEYFILE_INVALID, -EIO, "STATUS_FVE_KEYFILE_INVALID"},
2262 {STATUS_FVE_KEYFILE_NO_VMK, -EIO, "STATUS_FVE_KEYFILE_NO_VMK"}, 2264 {STATUS_FVE_KEYFILE_NO_VMK, -EIO, "STATUS_FVE_KEYFILE_NO_VMK"},
2263 {STATUS_FVE_TPM_DISABLED, -EIO, "STATUS_FVE_TPM_DISABLED"}, 2265 {STATUS_FVE_TPM_DISABLED, -EIO, "STATUS_FVE_TPM_DISABLED"},
2264 {STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO, -EIO, 2266 {STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO, -EIO,
2265 "STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO"}, 2267 "STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO"},
2266 {STATUS_FVE_TPM_INVALID_PCR, -EIO, "STATUS_FVE_TPM_INVALID_PCR"}, 2268 {STATUS_FVE_TPM_INVALID_PCR, -EIO, "STATUS_FVE_TPM_INVALID_PCR"},
2267 {STATUS_FVE_TPM_NO_VMK, -EIO, "STATUS_FVE_TPM_NO_VMK"}, 2269 {STATUS_FVE_TPM_NO_VMK, -EIO, "STATUS_FVE_TPM_NO_VMK"},
2268 {STATUS_FVE_PIN_INVALID, -EIO, "STATUS_FVE_PIN_INVALID"}, 2270 {STATUS_FVE_PIN_INVALID, -EIO, "STATUS_FVE_PIN_INVALID"},
2269 {STATUS_FVE_AUTH_INVALID_APPLICATION, -EIO, 2271 {STATUS_FVE_AUTH_INVALID_APPLICATION, -EIO,
2270 "STATUS_FVE_AUTH_INVALID_APPLICATION"}, 2272 "STATUS_FVE_AUTH_INVALID_APPLICATION"},
2271 {STATUS_FVE_AUTH_INVALID_CONFIG, -EIO, 2273 {STATUS_FVE_AUTH_INVALID_CONFIG, -EIO,
2272 "STATUS_FVE_AUTH_INVALID_CONFIG"}, 2274 "STATUS_FVE_AUTH_INVALID_CONFIG"},
2273 {STATUS_FVE_DEBUGGER_ENABLED, -EIO, "STATUS_FVE_DEBUGGER_ENABLED"}, 2275 {STATUS_FVE_DEBUGGER_ENABLED, -EIO, "STATUS_FVE_DEBUGGER_ENABLED"},
2274 {STATUS_FVE_DRY_RUN_FAILED, -EIO, "STATUS_FVE_DRY_RUN_FAILED"}, 2276 {STATUS_FVE_DRY_RUN_FAILED, -EIO, "STATUS_FVE_DRY_RUN_FAILED"},
2275 {STATUS_FVE_BAD_METADATA_POINTER, -EIO, 2277 {STATUS_FVE_BAD_METADATA_POINTER, -EIO,
2276 "STATUS_FVE_BAD_METADATA_POINTER"}, 2278 "STATUS_FVE_BAD_METADATA_POINTER"},
2277 {STATUS_FVE_OLD_METADATA_COPY, -EIO, "STATUS_FVE_OLD_METADATA_COPY"}, 2279 {STATUS_FVE_OLD_METADATA_COPY, -EIO, "STATUS_FVE_OLD_METADATA_COPY"},
2278 {STATUS_FVE_REBOOT_REQUIRED, -EIO, "STATUS_FVE_REBOOT_REQUIRED"}, 2280 {STATUS_FVE_REBOOT_REQUIRED, -EIO, "STATUS_FVE_REBOOT_REQUIRED"},
2279 {STATUS_FVE_RAW_ACCESS, -EIO, "STATUS_FVE_RAW_ACCESS"}, 2281 {STATUS_FVE_RAW_ACCESS, -EIO, "STATUS_FVE_RAW_ACCESS"},
2280 {STATUS_FVE_RAW_BLOCKED, -EIO, "STATUS_FVE_RAW_BLOCKED"}, 2282 {STATUS_FVE_RAW_BLOCKED, -EIO, "STATUS_FVE_RAW_BLOCKED"},
2281 {STATUS_FWP_CALLOUT_NOT_FOUND, -EIO, "STATUS_FWP_CALLOUT_NOT_FOUND"}, 2283 {STATUS_FWP_CALLOUT_NOT_FOUND, -EIO, "STATUS_FWP_CALLOUT_NOT_FOUND"},
2282 {STATUS_FWP_CONDITION_NOT_FOUND, -EIO, 2284 {STATUS_FWP_CONDITION_NOT_FOUND, -EIO,
2283 "STATUS_FWP_CONDITION_NOT_FOUND"}, 2285 "STATUS_FWP_CONDITION_NOT_FOUND"},
2284 {STATUS_FWP_FILTER_NOT_FOUND, -EIO, "STATUS_FWP_FILTER_NOT_FOUND"}, 2286 {STATUS_FWP_FILTER_NOT_FOUND, -EIO, "STATUS_FWP_FILTER_NOT_FOUND"},
2285 {STATUS_FWP_LAYER_NOT_FOUND, -EIO, "STATUS_FWP_LAYER_NOT_FOUND"}, 2287 {STATUS_FWP_LAYER_NOT_FOUND, -EIO, "STATUS_FWP_LAYER_NOT_FOUND"},
2286 {STATUS_FWP_PROVIDER_NOT_FOUND, -EIO, "STATUS_FWP_PROVIDER_NOT_FOUND"}, 2288 {STATUS_FWP_PROVIDER_NOT_FOUND, -EIO, "STATUS_FWP_PROVIDER_NOT_FOUND"},
2287 {STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND, -EIO, 2289 {STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND, -EIO,
2288 "STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND"}, 2290 "STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND"},
2289 {STATUS_FWP_SUBLAYER_NOT_FOUND, -EIO, "STATUS_FWP_SUBLAYER_NOT_FOUND"}, 2291 {STATUS_FWP_SUBLAYER_NOT_FOUND, -EIO, "STATUS_FWP_SUBLAYER_NOT_FOUND"},
2290 {STATUS_FWP_NOT_FOUND, -EIO, "STATUS_FWP_NOT_FOUND"}, 2292 {STATUS_FWP_NOT_FOUND, -EIO, "STATUS_FWP_NOT_FOUND"},
2291 {STATUS_FWP_ALREADY_EXISTS, -EIO, "STATUS_FWP_ALREADY_EXISTS"}, 2293 {STATUS_FWP_ALREADY_EXISTS, -EIO, "STATUS_FWP_ALREADY_EXISTS"},
2292 {STATUS_FWP_IN_USE, -EIO, "STATUS_FWP_IN_USE"}, 2294 {STATUS_FWP_IN_USE, -EIO, "STATUS_FWP_IN_USE"},
2293 {STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS, -EIO, 2295 {STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS, -EIO,
2294 "STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS"}, 2296 "STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS"},
2295 {STATUS_FWP_WRONG_SESSION, -EIO, "STATUS_FWP_WRONG_SESSION"}, 2297 {STATUS_FWP_WRONG_SESSION, -EIO, "STATUS_FWP_WRONG_SESSION"},
2296 {STATUS_FWP_NO_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_NO_TXN_IN_PROGRESS"}, 2298 {STATUS_FWP_NO_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_NO_TXN_IN_PROGRESS"},
2297 {STATUS_FWP_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_TXN_IN_PROGRESS"}, 2299 {STATUS_FWP_TXN_IN_PROGRESS, -EIO, "STATUS_FWP_TXN_IN_PROGRESS"},
2298 {STATUS_FWP_TXN_ABORTED, -EIO, "STATUS_FWP_TXN_ABORTED"}, 2300 {STATUS_FWP_TXN_ABORTED, -EIO, "STATUS_FWP_TXN_ABORTED"},
2299 {STATUS_FWP_SESSION_ABORTED, -EIO, "STATUS_FWP_SESSION_ABORTED"}, 2301 {STATUS_FWP_SESSION_ABORTED, -EIO, "STATUS_FWP_SESSION_ABORTED"},
2300 {STATUS_FWP_INCOMPATIBLE_TXN, -EIO, "STATUS_FWP_INCOMPATIBLE_TXN"}, 2302 {STATUS_FWP_INCOMPATIBLE_TXN, -EIO, "STATUS_FWP_INCOMPATIBLE_TXN"},
2301 {STATUS_FWP_TIMEOUT, -ETIMEDOUT, "STATUS_FWP_TIMEOUT"}, 2303 {STATUS_FWP_TIMEOUT, -ETIMEDOUT, "STATUS_FWP_TIMEOUT"},
2302 {STATUS_FWP_NET_EVENTS_DISABLED, -EIO, 2304 {STATUS_FWP_NET_EVENTS_DISABLED, -EIO,
2303 "STATUS_FWP_NET_EVENTS_DISABLED"}, 2305 "STATUS_FWP_NET_EVENTS_DISABLED"},
2304 {STATUS_FWP_INCOMPATIBLE_LAYER, -EIO, "STATUS_FWP_INCOMPATIBLE_LAYER"}, 2306 {STATUS_FWP_INCOMPATIBLE_LAYER, -EIO, "STATUS_FWP_INCOMPATIBLE_LAYER"},
2305 {STATUS_FWP_KM_CLIENTS_ONLY, -EIO, "STATUS_FWP_KM_CLIENTS_ONLY"}, 2307 {STATUS_FWP_KM_CLIENTS_ONLY, -EIO, "STATUS_FWP_KM_CLIENTS_ONLY"},
2306 {STATUS_FWP_LIFETIME_MISMATCH, -EIO, "STATUS_FWP_LIFETIME_MISMATCH"}, 2308 {STATUS_FWP_LIFETIME_MISMATCH, -EIO, "STATUS_FWP_LIFETIME_MISMATCH"},
2307 {STATUS_FWP_BUILTIN_OBJECT, -EIO, "STATUS_FWP_BUILTIN_OBJECT"}, 2309 {STATUS_FWP_BUILTIN_OBJECT, -EIO, "STATUS_FWP_BUILTIN_OBJECT"},
2308 {STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS, -EIO, 2310 {STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS, -EIO,
2309 "STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS"}, 2311 "STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS"},
2310 {STATUS_FWP_TOO_MANY_CALLOUTS, -EIO, "STATUS_FWP_TOO_MANY_CALLOUTS"}, 2312 {STATUS_FWP_TOO_MANY_CALLOUTS, -EIO, "STATUS_FWP_TOO_MANY_CALLOUTS"},
2311 {STATUS_FWP_NOTIFICATION_DROPPED, -EIO, 2313 {STATUS_FWP_NOTIFICATION_DROPPED, -EIO,
2312 "STATUS_FWP_NOTIFICATION_DROPPED"}, 2314 "STATUS_FWP_NOTIFICATION_DROPPED"},
2313 {STATUS_FWP_TRAFFIC_MISMATCH, -EIO, "STATUS_FWP_TRAFFIC_MISMATCH"}, 2315 {STATUS_FWP_TRAFFIC_MISMATCH, -EIO, "STATUS_FWP_TRAFFIC_MISMATCH"},
2314 {STATUS_FWP_INCOMPATIBLE_SA_STATE, -EIO, 2316 {STATUS_FWP_INCOMPATIBLE_SA_STATE, -EIO,
2315 "STATUS_FWP_INCOMPATIBLE_SA_STATE"}, 2317 "STATUS_FWP_INCOMPATIBLE_SA_STATE"},
2316 {STATUS_FWP_NULL_POINTER, -EIO, "STATUS_FWP_NULL_POINTER"}, 2318 {STATUS_FWP_NULL_POINTER, -EIO, "STATUS_FWP_NULL_POINTER"},
2317 {STATUS_FWP_INVALID_ENUMERATOR, -EIO, "STATUS_FWP_INVALID_ENUMERATOR"}, 2319 {STATUS_FWP_INVALID_ENUMERATOR, -EIO, "STATUS_FWP_INVALID_ENUMERATOR"},
2318 {STATUS_FWP_INVALID_FLAGS, -EIO, "STATUS_FWP_INVALID_FLAGS"}, 2320 {STATUS_FWP_INVALID_FLAGS, -EIO, "STATUS_FWP_INVALID_FLAGS"},
2319 {STATUS_FWP_INVALID_NET_MASK, -EIO, "STATUS_FWP_INVALID_NET_MASK"}, 2321 {STATUS_FWP_INVALID_NET_MASK, -EIO, "STATUS_FWP_INVALID_NET_MASK"},
2320 {STATUS_FWP_INVALID_RANGE, -EIO, "STATUS_FWP_INVALID_RANGE"}, 2322 {STATUS_FWP_INVALID_RANGE, -EIO, "STATUS_FWP_INVALID_RANGE"},
2321 {STATUS_FWP_INVALID_INTERVAL, -EIO, "STATUS_FWP_INVALID_INTERVAL"}, 2323 {STATUS_FWP_INVALID_INTERVAL, -EIO, "STATUS_FWP_INVALID_INTERVAL"},
2322 {STATUS_FWP_ZERO_LENGTH_ARRAY, -EIO, "STATUS_FWP_ZERO_LENGTH_ARRAY"}, 2324 {STATUS_FWP_ZERO_LENGTH_ARRAY, -EIO, "STATUS_FWP_ZERO_LENGTH_ARRAY"},
2323 {STATUS_FWP_NULL_DISPLAY_NAME, -EIO, "STATUS_FWP_NULL_DISPLAY_NAME"}, 2325 {STATUS_FWP_NULL_DISPLAY_NAME, -EIO, "STATUS_FWP_NULL_DISPLAY_NAME"},
2324 {STATUS_FWP_INVALID_ACTION_TYPE, -EIO, 2326 {STATUS_FWP_INVALID_ACTION_TYPE, -EIO,
2325 "STATUS_FWP_INVALID_ACTION_TYPE"}, 2327 "STATUS_FWP_INVALID_ACTION_TYPE"},
2326 {STATUS_FWP_INVALID_WEIGHT, -EIO, "STATUS_FWP_INVALID_WEIGHT"}, 2328 {STATUS_FWP_INVALID_WEIGHT, -EIO, "STATUS_FWP_INVALID_WEIGHT"},
2327 {STATUS_FWP_MATCH_TYPE_MISMATCH, -EIO, 2329 {STATUS_FWP_MATCH_TYPE_MISMATCH, -EIO,
2328 "STATUS_FWP_MATCH_TYPE_MISMATCH"}, 2330 "STATUS_FWP_MATCH_TYPE_MISMATCH"},
2329 {STATUS_FWP_TYPE_MISMATCH, -EIO, "STATUS_FWP_TYPE_MISMATCH"}, 2331 {STATUS_FWP_TYPE_MISMATCH, -EIO, "STATUS_FWP_TYPE_MISMATCH"},
2330 {STATUS_FWP_OUT_OF_BOUNDS, -EIO, "STATUS_FWP_OUT_OF_BOUNDS"}, 2332 {STATUS_FWP_OUT_OF_BOUNDS, -EIO, "STATUS_FWP_OUT_OF_BOUNDS"},
2331 {STATUS_FWP_RESERVED, -EIO, "STATUS_FWP_RESERVED"}, 2333 {STATUS_FWP_RESERVED, -EIO, "STATUS_FWP_RESERVED"},
2332 {STATUS_FWP_DUPLICATE_CONDITION, -EIO, 2334 {STATUS_FWP_DUPLICATE_CONDITION, -EIO,
2333 "STATUS_FWP_DUPLICATE_CONDITION"}, 2335 "STATUS_FWP_DUPLICATE_CONDITION"},
2334 {STATUS_FWP_DUPLICATE_KEYMOD, -EIO, "STATUS_FWP_DUPLICATE_KEYMOD"}, 2336 {STATUS_FWP_DUPLICATE_KEYMOD, -EIO, "STATUS_FWP_DUPLICATE_KEYMOD"},
2335 {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER, -EIO, 2337 {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER, -EIO,
2336 "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER"}, 2338 "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER"},
2337 {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER, -EIO, 2339 {STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER, -EIO,
2338 "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER"}, 2340 "STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER"},
2339 {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER, -EIO, 2341 {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER, -EIO,
2340 "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER"}, 2342 "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER"},
2341 {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT, -EIO, 2343 {STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT, -EIO,
2342 "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT"}, 2344 "STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT"},
2343 {STATUS_FWP_INCOMPATIBLE_AUTH_METHOD, -EIO, 2345 {STATUS_FWP_INCOMPATIBLE_AUTH_METHOD, -EIO,
2344 "STATUS_FWP_INCOMPATIBLE_AUTH_METHOD"}, 2346 "STATUS_FWP_INCOMPATIBLE_AUTH_METHOD"},
2345 {STATUS_FWP_INCOMPATIBLE_DH_GROUP, -EIO, 2347 {STATUS_FWP_INCOMPATIBLE_DH_GROUP, -EIO,
2346 "STATUS_FWP_INCOMPATIBLE_DH_GROUP"}, 2348 "STATUS_FWP_INCOMPATIBLE_DH_GROUP"},
2347 {STATUS_FWP_EM_NOT_SUPPORTED, -EOPNOTSUPP, 2349 {STATUS_FWP_EM_NOT_SUPPORTED, -EOPNOTSUPP,
2348 "STATUS_FWP_EM_NOT_SUPPORTED"}, 2350 "STATUS_FWP_EM_NOT_SUPPORTED"},
2349 {STATUS_FWP_NEVER_MATCH, -EIO, "STATUS_FWP_NEVER_MATCH"}, 2351 {STATUS_FWP_NEVER_MATCH, -EIO, "STATUS_FWP_NEVER_MATCH"},
2350 {STATUS_FWP_PROVIDER_CONTEXT_MISMATCH, -EIO, 2352 {STATUS_FWP_PROVIDER_CONTEXT_MISMATCH, -EIO,
2351 "STATUS_FWP_PROVIDER_CONTEXT_MISMATCH"}, 2353 "STATUS_FWP_PROVIDER_CONTEXT_MISMATCH"},
2352 {STATUS_FWP_INVALID_PARAMETER, -EIO, "STATUS_FWP_INVALID_PARAMETER"}, 2354 {STATUS_FWP_INVALID_PARAMETER, -EIO, "STATUS_FWP_INVALID_PARAMETER"},
2353 {STATUS_FWP_TOO_MANY_SUBLAYERS, -EIO, "STATUS_FWP_TOO_MANY_SUBLAYERS"}, 2355 {STATUS_FWP_TOO_MANY_SUBLAYERS, -EIO, "STATUS_FWP_TOO_MANY_SUBLAYERS"},
2354 {STATUS_FWP_CALLOUT_NOTIFICATION_FAILED, -EIO, 2356 {STATUS_FWP_CALLOUT_NOTIFICATION_FAILED, -EIO,
2355 "STATUS_FWP_CALLOUT_NOTIFICATION_FAILED"}, 2357 "STATUS_FWP_CALLOUT_NOTIFICATION_FAILED"},
2356 {STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG, -EIO, 2358 {STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG, -EIO,
2357 "STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG"}, 2359 "STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG"},
2358 {STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG, -EIO, 2360 {STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG, -EIO,
2359 "STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG"}, 2361 "STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG"},
2360 {STATUS_FWP_TCPIP_NOT_READY, -EIO, "STATUS_FWP_TCPIP_NOT_READY"}, 2362 {STATUS_FWP_TCPIP_NOT_READY, -EIO, "STATUS_FWP_TCPIP_NOT_READY"},
2361 {STATUS_FWP_INJECT_HANDLE_CLOSING, -EIO, 2363 {STATUS_FWP_INJECT_HANDLE_CLOSING, -EIO,
2362 "STATUS_FWP_INJECT_HANDLE_CLOSING"}, 2364 "STATUS_FWP_INJECT_HANDLE_CLOSING"},
2363 {STATUS_FWP_INJECT_HANDLE_STALE, -EIO, 2365 {STATUS_FWP_INJECT_HANDLE_STALE, -EIO,
2364 "STATUS_FWP_INJECT_HANDLE_STALE"}, 2366 "STATUS_FWP_INJECT_HANDLE_STALE"},
2365 {STATUS_FWP_CANNOT_PEND, -EIO, "STATUS_FWP_CANNOT_PEND"}, 2367 {STATUS_FWP_CANNOT_PEND, -EIO, "STATUS_FWP_CANNOT_PEND"},
2366 {STATUS_NDIS_CLOSING, -EIO, "STATUS_NDIS_CLOSING"}, 2368 {STATUS_NDIS_CLOSING, -EIO, "STATUS_NDIS_CLOSING"},
2367 {STATUS_NDIS_BAD_VERSION, -EIO, "STATUS_NDIS_BAD_VERSION"}, 2369 {STATUS_NDIS_BAD_VERSION, -EIO, "STATUS_NDIS_BAD_VERSION"},
2368 {STATUS_NDIS_BAD_CHARACTERISTICS, -EIO, 2370 {STATUS_NDIS_BAD_CHARACTERISTICS, -EIO,
2369 "STATUS_NDIS_BAD_CHARACTERISTICS"}, 2371 "STATUS_NDIS_BAD_CHARACTERISTICS"},
2370 {STATUS_NDIS_ADAPTER_NOT_FOUND, -EIO, "STATUS_NDIS_ADAPTER_NOT_FOUND"}, 2372 {STATUS_NDIS_ADAPTER_NOT_FOUND, -EIO, "STATUS_NDIS_ADAPTER_NOT_FOUND"},
2371 {STATUS_NDIS_OPEN_FAILED, -EIO, "STATUS_NDIS_OPEN_FAILED"}, 2373 {STATUS_NDIS_OPEN_FAILED, -EIO, "STATUS_NDIS_OPEN_FAILED"},
2372 {STATUS_NDIS_DEVICE_FAILED, -EIO, "STATUS_NDIS_DEVICE_FAILED"}, 2374 {STATUS_NDIS_DEVICE_FAILED, -EIO, "STATUS_NDIS_DEVICE_FAILED"},
2373 {STATUS_NDIS_MULTICAST_FULL, -EIO, "STATUS_NDIS_MULTICAST_FULL"}, 2375 {STATUS_NDIS_MULTICAST_FULL, -EIO, "STATUS_NDIS_MULTICAST_FULL"},
2374 {STATUS_NDIS_MULTICAST_EXISTS, -EIO, "STATUS_NDIS_MULTICAST_EXISTS"}, 2376 {STATUS_NDIS_MULTICAST_EXISTS, -EIO, "STATUS_NDIS_MULTICAST_EXISTS"},
2375 {STATUS_NDIS_MULTICAST_NOT_FOUND, -EIO, 2377 {STATUS_NDIS_MULTICAST_NOT_FOUND, -EIO,
2376 "STATUS_NDIS_MULTICAST_NOT_FOUND"}, 2378 "STATUS_NDIS_MULTICAST_NOT_FOUND"},
2377 {STATUS_NDIS_REQUEST_ABORTED, -EIO, "STATUS_NDIS_REQUEST_ABORTED"}, 2379 {STATUS_NDIS_REQUEST_ABORTED, -EIO, "STATUS_NDIS_REQUEST_ABORTED"},
2378 {STATUS_NDIS_RESET_IN_PROGRESS, -EIO, "STATUS_NDIS_RESET_IN_PROGRESS"}, 2380 {STATUS_NDIS_RESET_IN_PROGRESS, -EIO, "STATUS_NDIS_RESET_IN_PROGRESS"},
2379 {STATUS_NDIS_INVALID_PACKET, -EIO, "STATUS_NDIS_INVALID_PACKET"}, 2381 {STATUS_NDIS_INVALID_PACKET, -EIO, "STATUS_NDIS_INVALID_PACKET"},
2380 {STATUS_NDIS_INVALID_DEVICE_REQUEST, -EIO, 2382 {STATUS_NDIS_INVALID_DEVICE_REQUEST, -EIO,
2381 "STATUS_NDIS_INVALID_DEVICE_REQUEST"}, 2383 "STATUS_NDIS_INVALID_DEVICE_REQUEST"},
2382 {STATUS_NDIS_ADAPTER_NOT_READY, -EIO, "STATUS_NDIS_ADAPTER_NOT_READY"}, 2384 {STATUS_NDIS_ADAPTER_NOT_READY, -EIO, "STATUS_NDIS_ADAPTER_NOT_READY"},
2383 {STATUS_NDIS_INVALID_LENGTH, -EIO, "STATUS_NDIS_INVALID_LENGTH"}, 2385 {STATUS_NDIS_INVALID_LENGTH, -EIO, "STATUS_NDIS_INVALID_LENGTH"},
2384 {STATUS_NDIS_INVALID_DATA, -EIO, "STATUS_NDIS_INVALID_DATA"}, 2386 {STATUS_NDIS_INVALID_DATA, -EIO, "STATUS_NDIS_INVALID_DATA"},
2385 {STATUS_NDIS_BUFFER_TOO_SHORT, -ENOBUFS, 2387 {STATUS_NDIS_BUFFER_TOO_SHORT, -ENOBUFS,
2386 "STATUS_NDIS_BUFFER_TOO_SHORT"}, 2388 "STATUS_NDIS_BUFFER_TOO_SHORT"},
2387 {STATUS_NDIS_INVALID_OID, -EIO, "STATUS_NDIS_INVALID_OID"}, 2389 {STATUS_NDIS_INVALID_OID, -EIO, "STATUS_NDIS_INVALID_OID"},
2388 {STATUS_NDIS_ADAPTER_REMOVED, -EIO, "STATUS_NDIS_ADAPTER_REMOVED"}, 2390 {STATUS_NDIS_ADAPTER_REMOVED, -EIO, "STATUS_NDIS_ADAPTER_REMOVED"},
2389 {STATUS_NDIS_UNSUPPORTED_MEDIA, -EIO, "STATUS_NDIS_UNSUPPORTED_MEDIA"}, 2391 {STATUS_NDIS_UNSUPPORTED_MEDIA, -EIO, "STATUS_NDIS_UNSUPPORTED_MEDIA"},
2390 {STATUS_NDIS_GROUP_ADDRESS_IN_USE, -EIO, 2392 {STATUS_NDIS_GROUP_ADDRESS_IN_USE, -EIO,
2391 "STATUS_NDIS_GROUP_ADDRESS_IN_USE"}, 2393 "STATUS_NDIS_GROUP_ADDRESS_IN_USE"},
2392 {STATUS_NDIS_FILE_NOT_FOUND, -EIO, "STATUS_NDIS_FILE_NOT_FOUND"}, 2394 {STATUS_NDIS_FILE_NOT_FOUND, -EIO, "STATUS_NDIS_FILE_NOT_FOUND"},
2393 {STATUS_NDIS_ERROR_READING_FILE, -EIO, 2395 {STATUS_NDIS_ERROR_READING_FILE, -EIO,
2394 "STATUS_NDIS_ERROR_READING_FILE"}, 2396 "STATUS_NDIS_ERROR_READING_FILE"},
2395 {STATUS_NDIS_ALREADY_MAPPED, -EIO, "STATUS_NDIS_ALREADY_MAPPED"}, 2397 {STATUS_NDIS_ALREADY_MAPPED, -EIO, "STATUS_NDIS_ALREADY_MAPPED"},
2396 {STATUS_NDIS_RESOURCE_CONFLICT, -EIO, "STATUS_NDIS_RESOURCE_CONFLICT"}, 2398 {STATUS_NDIS_RESOURCE_CONFLICT, -EIO, "STATUS_NDIS_RESOURCE_CONFLICT"},
2397 {STATUS_NDIS_MEDIA_DISCONNECTED, -EIO, 2399 {STATUS_NDIS_MEDIA_DISCONNECTED, -EIO,
2398 "STATUS_NDIS_MEDIA_DISCONNECTED"}, 2400 "STATUS_NDIS_MEDIA_DISCONNECTED"},
2399 {STATUS_NDIS_INVALID_ADDRESS, -EIO, "STATUS_NDIS_INVALID_ADDRESS"}, 2401 {STATUS_NDIS_INVALID_ADDRESS, -EIO, "STATUS_NDIS_INVALID_ADDRESS"},
2400 {STATUS_NDIS_PAUSED, -EIO, "STATUS_NDIS_PAUSED"}, 2402 {STATUS_NDIS_PAUSED, -EIO, "STATUS_NDIS_PAUSED"},
2401 {STATUS_NDIS_INTERFACE_NOT_FOUND, -EIO, 2403 {STATUS_NDIS_INTERFACE_NOT_FOUND, -EIO,
2402 "STATUS_NDIS_INTERFACE_NOT_FOUND"}, 2404 "STATUS_NDIS_INTERFACE_NOT_FOUND"},
2403 {STATUS_NDIS_UNSUPPORTED_REVISION, -EIO, 2405 {STATUS_NDIS_UNSUPPORTED_REVISION, -EIO,
2404 "STATUS_NDIS_UNSUPPORTED_REVISION"}, 2406 "STATUS_NDIS_UNSUPPORTED_REVISION"},
2405 {STATUS_NDIS_INVALID_PORT, -EIO, "STATUS_NDIS_INVALID_PORT"}, 2407 {STATUS_NDIS_INVALID_PORT, -EIO, "STATUS_NDIS_INVALID_PORT"},
2406 {STATUS_NDIS_INVALID_PORT_STATE, -EIO, 2408 {STATUS_NDIS_INVALID_PORT_STATE, -EIO,
2407 "STATUS_NDIS_INVALID_PORT_STATE"}, 2409 "STATUS_NDIS_INVALID_PORT_STATE"},
2408 {STATUS_NDIS_LOW_POWER_STATE, -EIO, "STATUS_NDIS_LOW_POWER_STATE"}, 2410 {STATUS_NDIS_LOW_POWER_STATE, -EIO, "STATUS_NDIS_LOW_POWER_STATE"},
2409 {STATUS_NDIS_NOT_SUPPORTED, -ENOSYS, "STATUS_NDIS_NOT_SUPPORTED"}, 2411 {STATUS_NDIS_NOT_SUPPORTED, -ENOSYS, "STATUS_NDIS_NOT_SUPPORTED"},
2410 {STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED, -EIO, 2412 {STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED, -EIO,
2411 "STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED"}, 2413 "STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED"},
2412 {STATUS_NDIS_DOT11_MEDIA_IN_USE, -EIO, 2414 {STATUS_NDIS_DOT11_MEDIA_IN_USE, -EIO,
2413 "STATUS_NDIS_DOT11_MEDIA_IN_USE"}, 2415 "STATUS_NDIS_DOT11_MEDIA_IN_USE"},
2414 {STATUS_NDIS_DOT11_POWER_STATE_INVALID, -EIO, 2416 {STATUS_NDIS_DOT11_POWER_STATE_INVALID, -EIO,
2415 "STATUS_NDIS_DOT11_POWER_STATE_INVALID"}, 2417 "STATUS_NDIS_DOT11_POWER_STATE_INVALID"},
2416 {STATUS_IPSEC_BAD_SPI, -EIO, "STATUS_IPSEC_BAD_SPI"}, 2418 {STATUS_IPSEC_BAD_SPI, -EIO, "STATUS_IPSEC_BAD_SPI"},
2417 {STATUS_IPSEC_SA_LIFETIME_EXPIRED, -EIO, 2419 {STATUS_IPSEC_SA_LIFETIME_EXPIRED, -EIO,
2418 "STATUS_IPSEC_SA_LIFETIME_EXPIRED"}, 2420 "STATUS_IPSEC_SA_LIFETIME_EXPIRED"},
2419 {STATUS_IPSEC_WRONG_SA, -EIO, "STATUS_IPSEC_WRONG_SA"}, 2421 {STATUS_IPSEC_WRONG_SA, -EIO, "STATUS_IPSEC_WRONG_SA"},
2420 {STATUS_IPSEC_REPLAY_CHECK_FAILED, -EIO, 2422 {STATUS_IPSEC_REPLAY_CHECK_FAILED, -EIO,
2421 "STATUS_IPSEC_REPLAY_CHECK_FAILED"}, 2423 "STATUS_IPSEC_REPLAY_CHECK_FAILED"},
2422 {STATUS_IPSEC_INVALID_PACKET, -EIO, "STATUS_IPSEC_INVALID_PACKET"}, 2424 {STATUS_IPSEC_INVALID_PACKET, -EIO, "STATUS_IPSEC_INVALID_PACKET"},
2423 {STATUS_IPSEC_INTEGRITY_CHECK_FAILED, -EIO, 2425 {STATUS_IPSEC_INTEGRITY_CHECK_FAILED, -EIO,
2424 "STATUS_IPSEC_INTEGRITY_CHECK_FAILED"}, 2426 "STATUS_IPSEC_INTEGRITY_CHECK_FAILED"},
2425 {STATUS_IPSEC_CLEAR_TEXT_DROP, -EIO, "STATUS_IPSEC_CLEAR_TEXT_DROP"}, 2427 {STATUS_IPSEC_CLEAR_TEXT_DROP, -EIO, "STATUS_IPSEC_CLEAR_TEXT_DROP"},
2426 {0, 0, NULL} 2428 {0, 0, NULL}
2427 }; 2429 };
2428 2430
2429 /***************************************************************************** 2431 /*****************************************************************************
2430 Print an error message from the status code 2432 Print an error message from the status code
2431 *****************************************************************************/ 2433 *****************************************************************************/
2432 static void 2434 static void
2433 smb2_print_status(__le32 status) 2435 smb2_print_status(__le32 status)
2434 { 2436 {
2435 int idx = 0; 2437 int idx = 0;
2436 2438
2437 while (smb2_error_map_table[idx].status_string != NULL) { 2439 while (smb2_error_map_table[idx].status_string != NULL) {
2438 if ((smb2_error_map_table[idx].smb2_status) == status) { 2440 if ((smb2_error_map_table[idx].smb2_status) == status) {
2439 pr_notice("Status code returned 0x%08x %s\n", status, 2441 pr_notice("Status code returned 0x%08x %s\n", status,
2440 smb2_error_map_table[idx].status_string); 2442 smb2_error_map_table[idx].status_string);
2441 } 2443 }
2442 idx++; 2444 idx++;
2443 } 2445 }
2444 return; 2446 return;
2445 } 2447 }
2446 2448
2447 int 2449 int
2448 map_smb2_to_linux_error(char *buf, bool log_err) 2450 map_smb2_to_linux_error(char *buf, bool log_err)
2449 { 2451 {
2450 struct smb2_hdr *hdr = (struct smb2_hdr *)buf; 2452 struct smb2_hdr *hdr = (struct smb2_hdr *)buf;
2451 unsigned int i; 2453 unsigned int i;
2452 int rc = -EIO; 2454 int rc = -EIO;
2453 __le32 smb2err = hdr->Status; 2455 __le32 smb2err = hdr->Status;
2454 2456
2455 if (smb2err == 0) 2457 if (smb2err == 0)
2456 return 0; 2458 return 0;
2457 2459
2458 /* mask facility */ 2460 /* mask facility */
2459 if (log_err && (smb2err != STATUS_MORE_PROCESSING_REQUIRED) && 2461 if (log_err && (smb2err != STATUS_MORE_PROCESSING_REQUIRED) &&
2460 (smb2err != STATUS_END_OF_FILE)) 2462 (smb2err != STATUS_END_OF_FILE))
2461 smb2_print_status(smb2err); 2463 smb2_print_status(smb2err);
2462 else if (cifsFYI & CIFS_RC) 2464 else if (cifsFYI & CIFS_RC)
2463 smb2_print_status(smb2err); 2465 smb2_print_status(smb2err);
2464 2466
2465 for (i = 0; i < sizeof(smb2_error_map_table) / 2467 for (i = 0; i < sizeof(smb2_error_map_table) /
2466 sizeof(struct status_to_posix_error); i++) { 2468 sizeof(struct status_to_posix_error); i++) {
2467 if (smb2_error_map_table[i].smb2_status == smb2err) { 2469 if (smb2_error_map_table[i].smb2_status == smb2err) {
2468 rc = smb2_error_map_table[i].posix_error; 2470 rc = smb2_error_map_table[i].posix_error;
2469 break; 2471 break;
2470 } 2472 }
2471 } 2473 }
2472 2474
2473 /* on error mapping not found - return EIO */ 2475 /* on error mapping not found - return EIO */
2474 2476
2475 cifs_dbg(FYI, "Mapping SMB2 status code %d to POSIX err %d\n", 2477 cifs_dbg(FYI, "Mapping SMB2 status code %d to POSIX err %d\n",
2476 smb2err, rc); 2478 smb2err, rc);
2477 2479
2478 return rc; 2480 return rc;
2479 } 2481 }
2480 2482