tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge tag '5.2-smb3' of git://git.samba.org/sfrench/cifs-2.6

Pull cifs fixes from Steve French:
"CIFS/SMB3 changes:

- three fixes for stable

- add fiemap support

- improve zero-range support

- various RDMA (smb direct fixes)

I have an additional set of fixes (for improved handling of sparse
files, mode bits, POSIX extensions) that are still being tested that
are not included in this pull request but I expect to send in the next
week"

* tag '5.2-smb3' of git://git.samba.org/sfrench/cifs-2.6: (29 commits)
cifs: update module internal version number
SMB3: Clean up query symlink when reparse point
cifs: fix strcat buffer overflow and reduce raciness in smb21_set_oplock_level()
Negotiate and save preferred compression algorithms
cifs: rename and clarify CIFS_ASYNC_OP and CIFS_NO_RESP
cifs: fix credits leak for SMB1 oplock breaks
smb3: Add protocol structs for change notify support
cifs: fix smb3_zero_range for Azure
cifs: zero-range does not require the file is sparse
Add new flag on SMB3.1.1 read
cifs: add fiemap support
SMB3: Add defines for new negotiate contexts
cifs: fix bi-directional fsctl passthrough calls
cifs: smbd: take an array of reqeusts when sending upper layer data
SMB3: Add handling for different FSCTL access flags
cifs: Add support for FSCTL passthrough that write data to the server
cifs: remove superfluous inode_lock in cifs_{strict_}fsync
cifs: Call MID callback before destroying transport
cifs: smbd: Retry on memory registration failure
cifs: smbd: Indicate to retry on transport sending failure
...

Linus Torvalds 78d9affb 8c79f4cd

+2582 -2184
+26 -7
fs/cifs/cifs_debug.c
··· 312 312 atomic_read(&server->smbd_conn->send_credits), 313 313 atomic_read(&server->smbd_conn->receive_credits), 314 314 server->smbd_conn->receive_credit_target); 315 - seq_printf(m, "\nPending send_pending: %x send_payload_pending:" 316 - " %x smbd_send_pending: %x smbd_recv_pending: %x", 315 + seq_printf(m, "\nPending send_pending: %x " 316 + "send_payload_pending: %x", 317 317 atomic_read(&server->smbd_conn->send_pending), 318 - atomic_read(&server->smbd_conn->send_payload_pending), 319 - server->smbd_conn->smbd_send_pending, 320 - server->smbd_conn->smbd_recv_pending); 318 + atomic_read(&server->smbd_conn->send_payload_pending)); 321 319 seq_printf(m, "\nReceive buffers count_receive_queue: %x " 322 320 "count_empty_packet_queue: %x", 323 321 server->smbd_conn->count_receive_queue, ··· 332 334 #endif 333 335 seq_printf(m, "\nNumber of credits: %d Dialect 0x%x", 334 336 server->credits, server->dialect); 337 + if (server->compress_algorithm == SMB3_COMPRESS_LZNT1) 338 + seq_printf(m, " COMPRESS_LZNT1"); 339 + else if (server->compress_algorithm == SMB3_COMPRESS_LZ77) 340 + seq_printf(m, " COMPRESS_LZ77"); 341 + else if (server->compress_algorithm == SMB3_COMPRESS_LZ77_HUFF) 342 + seq_printf(m, " COMPRESS_LZ77_HUFF"); 335 343 if (server->sign) 336 344 seq_printf(m, " signed"); 337 345 if (server->posix_ext_supported) ··· 466 462 server = list_entry(tmp1, struct TCP_Server_Info, 467 463 tcp_ses_list); 468 464 #ifdef CONFIG_CIFS_STATS2 469 - for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) 465 + for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) { 466 + atomic_set(&server->num_cmds[i], 0); 470 467 atomic_set(&server->smb2slowcmd[i], 0); 468 + server->time_per_cmd[i] = 0; 469 + server->slowest_cmd[i] = 0; 470 + server->fastest_cmd[0] = 0; 471 + } 471 472 #endif /* CONFIG_CIFS_STATS2 */ 472 473 list_for_each(tmp2, &server->smb_ses_list) { 473 474 ses = list_entry(tmp2, struct cifs_ses, ··· 540 531 server = list_entry(tmp1, struct TCP_Server_Info, 541 532 tcp_ses_list); 542 533 #ifdef CONFIG_CIFS_STATS2 534 + seq_puts(m, "\nTotal time spent processing by command. Time "); 535 + seq_printf(m, "units are jiffies (%d per second)\n", HZ); 536 + seq_puts(m, " SMB3 CMD\tNumber\tTotal Time\tFastest\tSlowest\n"); 537 + seq_puts(m, " --------\t------\t----------\t-------\t-------\n"); 538 + for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++) 539 + seq_printf(m, " %d\t\t%d\t%llu\t\t%u\t%u\n", j, 540 + atomic_read(&server->num_cmds[j]), 541 + server->time_per_cmd[j], 542 + server->fastest_cmd[j], 543 + server->slowest_cmd[j]); 543 544 for (j = 0; j < NUMBER_OF_SMB2_COMMANDS; j++) 544 545 if (atomic_read(&server->smb2slowcmd[j])) 545 - seq_printf(m, "%d slow responses from %s for command %d\n", 546 + seq_printf(m, " %d slow responses from %s for command %d\n", 546 547 atomic_read(&server->smb2slowcmd[j]), 547 548 server->hostname, j); 548 549 #endif /* STATS2 */
+3
fs/cifs/cifsfs.c
··· 483 483 seq_puts(s, ",seal"); 484 484 if (tcon->nocase) 485 485 seq_puts(s, ",nocase"); 486 + if (tcon->local_lease) 487 + seq_puts(s, ",locallease"); 486 488 if (tcon->retry) 487 489 seq_puts(s, ",hard"); 488 490 else ··· 986 984 .getattr = cifs_getattr, 987 985 .permission = cifs_permission, 988 986 .listxattr = cifs_listxattr, 987 + .fiemap = cifs_fiemap, 989 988 }; 990 989 991 990 const struct inode_operations cifs_symlink_inode_ops = {
+3 -1
fs/cifs/cifsfs.h
··· 84 84 extern int cifs_zap_mapping(struct inode *inode); 85 85 extern int cifs_getattr(const struct path *, struct kstat *, u32, unsigned int); 86 86 extern int cifs_setattr(struct dentry *, struct iattr *); 87 + extern int cifs_fiemap(struct inode *, struct fiemap_extent_info *, u64 start, 88 + u64 len); 87 89 88 90 extern const struct inode_operations cifs_file_inode_ops; 89 91 extern const struct inode_operations cifs_symlink_inode_ops; ··· 152 150 extern const struct export_operations cifs_export_ops; 153 151 #endif /* CONFIG_CIFS_NFSD_EXPORT */ 154 152 155 - #define CIFS_VERSION "2.19" 153 + #define CIFS_VERSION "2.20" 156 154 #endif /* _CIFSFS_H */
+23 -4
fs/cifs/cifsglob.h
··· 355 355 struct cifs_sb_info *); 356 356 /* query symlink target */ 357 357 int (*query_symlink)(const unsigned int, struct cifs_tcon *, 358 - const char *, char **, struct cifs_sb_info *); 358 + struct cifs_sb_info *, const char *, 359 + char **, bool); 359 360 /* open a file for non-posix mounts */ 360 361 int (*open)(const unsigned int, struct cifs_open_parms *, 361 362 __u32 *, FILE_ALL_INFO *); ··· 494 493 char *full_path, 495 494 umode_t mode, 496 495 dev_t device_number); 496 + /* version specific fiemap implementation */ 497 + int (*fiemap)(struct cifs_tcon *tcon, struct cifsFileInfo *, 498 + struct fiemap_extent_info *, u64, u64); 497 499 }; 498 500 499 501 struct smb_version_values { ··· 600 596 unsigned int max_credits; /* smb3 max_credits 10 < credits < 60000 */ 601 597 }; 602 598 599 + /** 600 + * CIFS superblock mount flags (mnt_cifs_flags) to consider when 601 + * trying to reuse existing superblock for a new mount 602 + */ 603 603 #define CIFS_MOUNT_MASK (CIFS_MOUNT_NO_PERM | CIFS_MOUNT_SET_UID | \ 604 604 CIFS_MOUNT_SERVER_INUM | CIFS_MOUNT_DIRECT_IO | \ 605 605 CIFS_MOUNT_NO_XATTR | CIFS_MOUNT_MAP_SPECIAL_CHR | \ ··· 614 606 CIFS_MOUNT_NOPOSIXBRL | CIFS_MOUNT_NOSSYNC | \ 615 607 CIFS_MOUNT_FSCACHE | CIFS_MOUNT_MF_SYMLINKS | \ 616 608 CIFS_MOUNT_MULTIUSER | CIFS_MOUNT_STRICT_IO | \ 617 - CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID) 609 + CIFS_MOUNT_CIFS_BACKUPUID | CIFS_MOUNT_CIFS_BACKUPGID | \ 610 + CIFS_MOUNT_NO_DFS) 618 611 612 + /** 613 + * Generic VFS superblock mount flags (s_flags) to consider when 614 + * trying to reuse existing superblock for a new mount 615 + */ 619 616 #define CIFS_MS_MASK (SB_RDONLY | SB_MANDLOCK | SB_NOEXEC | SB_NOSUID | \ 620 617 SB_NODEV | SB_SYNCHRONOUS) 621 618 ··· 727 714 #ifdef CONFIG_CIFS_STATS2 728 715 atomic_t in_send; /* requests trying to send */ 729 716 atomic_t num_waiters; /* blocked waiting to get in sendrecv */ 717 + atomic_t num_cmds[NUMBER_OF_SMB2_COMMANDS]; /* total requests by cmd */ 730 718 atomic_t smb2slowcmd[NUMBER_OF_SMB2_COMMANDS]; /* count resps > 1 sec */ 719 + __u64 time_per_cmd[NUMBER_OF_SMB2_COMMANDS]; /* total time per cmd */ 720 + __u32 slowest_cmd[NUMBER_OF_SMB2_COMMANDS]; 721 + __u32 fastest_cmd[NUMBER_OF_SMB2_COMMANDS]; 731 722 #endif /* STATS2 */ 732 723 unsigned int max_read; 733 724 unsigned int max_write; 725 + __le16 compress_algorithm; 734 726 __le16 cipher_type; 735 727 /* save initital negprot hash */ 736 728 __u8 preauth_sha_hash[SMB2_PREAUTH_HASH_SIZE]; ··· 1691 1673 1692 1674 /* Type of Request to SendReceive2 */ 1693 1675 #define CIFS_BLOCKING_OP 1 /* operation can block */ 1694 - #define CIFS_ASYNC_OP 2 /* do not wait for response */ 1676 + #define CIFS_NON_BLOCKING 2 /* do not block waiting for credits */ 1695 1677 #define CIFS_TIMEOUT_MASK 0x003 /* only one of above set in req */ 1696 1678 #define CIFS_LOG_ERROR 0x010 /* log NT STATUS if non-zero */ 1697 1679 #define CIFS_LARGE_BUF_OP 0x020 /* large request buffer */ 1698 - #define CIFS_NO_RESP 0x040 /* no response buffer required */ 1680 + #define CIFS_NO_RSP_BUF 0x040 /* no response buffer required */ 1699 1681 1700 1682 /* Type of request operation */ 1701 1683 #define CIFS_ECHO_OP 0x080 /* echo request */ ··· 1705 1687 1706 1688 #define CIFS_HAS_CREDITS 0x0400 /* already has credits */ 1707 1689 #define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */ 1690 + #define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */ 1708 1691 1709 1692 /* Security Flags: indicate type of session setup needed */ 1710 1693 #define CIFSSEC_MAY_SIGN 0x00001
+9
fs/cifs/cifsproto.h
··· 526 526 const struct nls_table *codepage); 527 527 extern int SMBencrypt(unsigned char *passwd, const unsigned char *c8, 528 528 unsigned char *p24); 529 + 530 + extern int 531 + cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data, 532 + const char *devname, bool is_smb3); 529 533 extern void 530 534 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info); 531 535 532 536 extern struct TCP_Server_Info * 533 537 cifs_find_tcp_session(struct smb_vol *vol); 538 + 539 + extern void cifs_put_smb_ses(struct cifs_ses *ses); 540 + 541 + extern struct cifs_ses * 542 + cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info); 534 543 535 544 void cifs_readdata_release(struct kref *refcount); 536 545 int cifs_async_readv(struct cifs_readdata *rdata);
+4 -94
fs/cifs/cifssmb.c
··· 860 860 iov[1].iov_base = (char *)smb + 4; 861 861 862 862 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback, NULL, 863 - server, CIFS_ASYNC_OP | CIFS_ECHO_OP, NULL); 863 + server, CIFS_NON_BLOCKING | CIFS_ECHO_OP, NULL); 864 864 if (rc) 865 865 cifs_dbg(FYI, "Echo request failed: %d\n", rc); 866 866 ··· 2508 2508 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE); 2509 2509 2510 2510 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks); 2511 - rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP, 2512 - &rsp_iov); 2511 + rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, 2512 + CIFS_NO_RSP_BUF, &rsp_iov); 2513 2513 cifs_small_buf_release(pSMB); 2514 2514 if (rc) 2515 2515 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc); ··· 2540 2540 2541 2541 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) { 2542 2542 /* no response expected */ 2543 - flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP; 2543 + flags = CIFS_NO_SRV_RSP | CIFS_NON_BLOCKING | CIFS_OBREAK_OP; 2544 2544 pSMB->Timeout = 0; 2545 2545 } else if (waitFlag) { 2546 2546 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */ ··· 6567 6567 return rc; 6568 6568 } 6569 6569 #endif 6570 - 6571 - #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */ 6572 - /* 6573 - * Years ago the kernel added a "dnotify" function for Samba server, 6574 - * to allow network clients (such as Windows) to display updated 6575 - * lists of files in directory listings automatically when 6576 - * files are added by one user when another user has the 6577 - * same directory open on their desktop. The Linux cifs kernel 6578 - * client hooked into the kernel side of this interface for 6579 - * the same reason, but ironically when the VFS moved from 6580 - * "dnotify" to "inotify" it became harder to plug in Linux 6581 - * network file system clients (the most obvious use case 6582 - * for notify interfaces is when multiple users can update 6583 - * the contents of the same directory - exactly what network 6584 - * file systems can do) although the server (Samba) could 6585 - * still use it. For the short term we leave the worker 6586 - * function ifdeffed out (below) until inotify is fixed 6587 - * in the VFS to make it easier to plug in network file 6588 - * system clients. If inotify turns out to be permanently 6589 - * incompatible for network fs clients, we could instead simply 6590 - * expose this config flag by adding a future cifs (and smb2) notify ioctl. 6591 - */ 6592 - int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon, 6593 - const int notify_subdirs, const __u16 netfid, 6594 - __u32 filter, struct file *pfile, int multishot, 6595 - const struct nls_table *nls_codepage) 6596 - { 6597 - int rc = 0; 6598 - struct smb_com_transaction_change_notify_req *pSMB = NULL; 6599 - struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL; 6600 - struct dir_notify_req *dnotify_req; 6601 - int bytes_returned; 6602 - 6603 - cifs_dbg(FYI, "In CIFSSMBNotify for file handle %d\n", (int)netfid); 6604 - rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB, 6605 - (void **) &pSMBr); 6606 - if (rc) 6607 - return rc; 6608 - 6609 - pSMB->TotalParameterCount = 0 ; 6610 - pSMB->TotalDataCount = 0; 6611 - pSMB->MaxParameterCount = cpu_to_le32(2); 6612 - pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00); 6613 - pSMB->MaxSetupCount = 4; 6614 - pSMB->Reserved = 0; 6615 - pSMB->ParameterOffset = 0; 6616 - pSMB->DataCount = 0; 6617 - pSMB->DataOffset = 0; 6618 - pSMB->SetupCount = 4; /* single byte does not need le conversion */ 6619 - pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE); 6620 - pSMB->ParameterCount = pSMB->TotalParameterCount; 6621 - if (notify_subdirs) 6622 - pSMB->WatchTree = 1; /* one byte - no le conversion needed */ 6623 - pSMB->Reserved2 = 0; 6624 - pSMB->CompletionFilter = cpu_to_le32(filter); 6625 - pSMB->Fid = netfid; /* file handle always le */ 6626 - pSMB->ByteCount = 0; 6627 - 6628 - rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB, 6629 - (struct smb_hdr *)pSMBr, &bytes_returned, 6630 - CIFS_ASYNC_OP); 6631 - if (rc) { 6632 - cifs_dbg(FYI, "Error in Notify = %d\n", rc); 6633 - } else { 6634 - /* Add file to outstanding requests */ 6635 - /* BB change to kmem cache alloc */ 6636 - dnotify_req = kmalloc( 6637 - sizeof(struct dir_notify_req), 6638 - GFP_KERNEL); 6639 - if (dnotify_req) { 6640 - dnotify_req->Pid = pSMB->hdr.Pid; 6641 - dnotify_req->PidHigh = pSMB->hdr.PidHigh; 6642 - dnotify_req->Mid = pSMB->hdr.Mid; 6643 - dnotify_req->Tid = pSMB->hdr.Tid; 6644 - dnotify_req->Uid = pSMB->hdr.Uid; 6645 - dnotify_req->netfid = netfid; 6646 - dnotify_req->pfile = pfile; 6647 - dnotify_req->filter = filter; 6648 - dnotify_req->multishot = multishot; 6649 - spin_lock(&GlobalMid_Lock); 6650 - list_add_tail(&dnotify_req->lhead, 6651 - &GlobalDnotifyReqList); 6652 - spin_unlock(&GlobalMid_Lock); 6653 - } else 6654 - rc = -ENOMEM; 6655 - } 6656 - cifs_buf_release(pSMB); 6657 - return rc; 6658 - } 6659 - #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
+35 -28
fs/cifs/connect.c
··· 323 323 static int generic_ip_connect(struct TCP_Server_Info *server); 324 324 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink); 325 325 static void cifs_prune_tlinks(struct work_struct *work); 326 - static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data, 327 - const char *devname, bool is_smb3); 328 326 static char *extract_hostname(const char *unc); 329 327 330 328 /* ··· 528 530 /* do not want to be sending data on a socket we are freeing */ 529 531 cifs_dbg(FYI, "%s: tearing down socket\n", __func__); 530 532 mutex_lock(&server->srv_mutex); 531 - if (server->ssocket) { 532 - cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", 533 - server->ssocket->state, server->ssocket->flags); 534 - kernel_sock_shutdown(server->ssocket, SHUT_WR); 535 - cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", 536 - server->ssocket->state, server->ssocket->flags); 537 - sock_release(server->ssocket); 538 - server->ssocket = NULL; 539 - } 540 - server->sequence_number = 0; 541 - server->session_estab = false; 542 - kfree(server->session_key.response); 543 - server->session_key.response = NULL; 544 - server->session_key.len = 0; 545 - server->lstrp = jiffies; 546 533 547 534 /* mark submitted MIDs for retry and issue callback */ 548 535 INIT_LIST_HEAD(&retry_list); ··· 540 557 list_move(&mid_entry->qhead, &retry_list); 541 558 } 542 559 spin_unlock(&GlobalMid_Lock); 543 - mutex_unlock(&server->srv_mutex); 544 560 545 561 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__); 546 562 list_for_each_safe(tmp, tmp2, &retry_list) { ··· 547 565 list_del_init(&mid_entry->qhead); 548 566 mid_entry->callback(mid_entry); 549 567 } 568 + 569 + if (server->ssocket) { 570 + cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", 571 + server->ssocket->state, server->ssocket->flags); 572 + kernel_sock_shutdown(server->ssocket, SHUT_WR); 573 + cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", 574 + server->ssocket->state, server->ssocket->flags); 575 + sock_release(server->ssocket); 576 + server->ssocket = NULL; 577 + } else if (cifs_rdma_enabled(server)) 578 + smbd_destroy(server); 579 + server->sequence_number = 0; 580 + server->session_estab = false; 581 + kfree(server->session_key.response); 582 + server->session_key.response = NULL; 583 + server->session_key.len = 0; 584 + server->lstrp = jiffies; 585 + 586 + mutex_unlock(&server->srv_mutex); 550 587 551 588 do { 552 589 try_to_freeze(); ··· 932 931 wake_up_all(&server->request_q); 933 932 /* give those requests time to exit */ 934 933 msleep(125); 935 - if (cifs_rdma_enabled(server) && server->smbd_conn) { 936 - smbd_destroy(server->smbd_conn); 937 - server->smbd_conn = NULL; 938 - } 934 + if (cifs_rdma_enabled(server)) 935 + smbd_destroy(server); 939 936 if (server->ssocket) { 940 937 sock_release(server->ssocket); 941 938 server->ssocket = NULL; ··· 2903 2904 return NULL; 2904 2905 } 2905 2906 2906 - static void 2907 - cifs_put_smb_ses(struct cifs_ses *ses) 2907 + void cifs_put_smb_ses(struct cifs_ses *ses) 2908 2908 { 2909 2909 unsigned int rc, xid; 2910 2910 struct TCP_Server_Info *server = ses->server; ··· 3080 3082 * already got a server reference (server refcount +1). See 3081 3083 * cifs_get_tcon() for refcount explanations. 3082 3084 */ 3083 - static struct cifs_ses * 3085 + struct cifs_ses * 3084 3086 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info) 3085 3087 { 3086 3088 int rc = -ENOMEM; ··· 4387 4389 } 4388 4390 #endif 4389 4391 4390 - static int 4392 + int 4391 4393 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data, 4392 4394 const char *devname, bool is_smb3) 4393 4395 { ··· 4541 4543 struct cifs_tcon *tcon = NULL; 4542 4544 struct TCP_Server_Info *server; 4543 4545 char *root_path = NULL, *full_path = NULL; 4544 - char *old_mountdata; 4546 + char *old_mountdata, *origin_mountdata = NULL; 4545 4547 int count; 4546 4548 4547 4549 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon); ··· 4597 4599 4598 4600 if (cifs_sb->mountdata == NULL) { 4599 4601 rc = -ENOENT; 4602 + goto error; 4603 + } 4604 + 4605 + /* Save DFS root volume information for DFS refresh worker */ 4606 + origin_mountdata = kstrndup(cifs_sb->mountdata, 4607 + strlen(cifs_sb->mountdata), GFP_KERNEL); 4608 + if (!origin_mountdata) { 4609 + rc = -ENOMEM; 4600 4610 goto error; 4601 4611 } 4602 4612 ··· 4716 4710 } 4717 4711 spin_unlock(&cifs_tcp_ses_lock); 4718 4712 4719 - rc = dfs_cache_add_vol(vol, cifs_sb->origin_fullpath); 4713 + rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath); 4720 4714 if (rc) { 4721 4715 kfree(cifs_sb->origin_fullpath); 4722 4716 goto error; ··· 4734 4728 error: 4735 4729 kfree(full_path); 4736 4730 kfree(root_path); 4731 + kfree(origin_mountdata); 4737 4732 mount_put_conns(cifs_sb, xid, server, ses, tcon); 4738 4733 return rc; 4739 4734 }
+125 -15
fs/cifs/dfs_cache.c
··· 2 2 /* 3 3 * DFS referral cache routines 4 4 * 5 - * Copyright (c) 2018 Paulo Alcantara <palcantara@suse.de> 5 + * Copyright (c) 2018-2019 Paulo Alcantara <palcantara@suse.de> 6 6 */ 7 7 8 8 #include <linux/rcupdate.h> ··· 52 52 struct dfs_cache_vol_info { 53 53 char *vi_fullpath; 54 54 struct smb_vol vi_vol; 55 + char *vi_mntdata; 55 56 struct list_head vi_list; 56 57 }; 57 58 ··· 530 529 { 531 530 list_del(&vi->vi_list); 532 531 kfree(vi->vi_fullpath); 532 + kfree(vi->vi_mntdata); 533 533 cifs_cleanup_volume_info_contents(&vi->vi_vol); 534 534 kfree(vi); 535 535 } ··· 1141 1139 * dfs_cache_add_vol - add a cifs volume during mount() that will be handled by 1142 1140 * DFS cache refresh worker. 1143 1141 * 1142 + * @mntdata: mount data. 1144 1143 * @vol: cifs volume. 1145 1144 * @fullpath: origin full path. 1146 1145 * 1147 1146 * Return zero if volume was set up correctly, otherwise non-zero. 1148 1147 */ 1149 - int dfs_cache_add_vol(struct smb_vol *vol, const char *fullpath) 1148 + int dfs_cache_add_vol(char *mntdata, struct smb_vol *vol, const char *fullpath) 1150 1149 { 1151 1150 int rc; 1152 1151 struct dfs_cache_vol_info *vi; 1153 1152 1154 - if (!vol || !fullpath) 1153 + if (!vol || !fullpath || !mntdata) 1155 1154 return -EINVAL; 1156 1155 1157 1156 cifs_dbg(FYI, "%s: fullpath: %s\n", __func__, fullpath); ··· 1170 1167 rc = dup_vol(vol, &vi->vi_vol); 1171 1168 if (rc) 1172 1169 goto err_free_fullpath; 1170 + 1171 + vi->vi_mntdata = mntdata; 1173 1172 1174 1173 mutex_lock(&dfs_cache.dc_lock); 1175 1174 list_add_tail(&vi->vi_list, &dfs_cache.dc_vol_list); ··· 1280 1275 spin_unlock(&cifs_tcp_ses_lock); 1281 1276 } 1282 1277 1278 + static inline bool is_dfs_link(const char *path) 1279 + { 1280 + char *s; 1281 + 1282 + s = strchr(path + 1, '\\'); 1283 + if (!s) 1284 + return false; 1285 + return !!strchr(s + 1, '\\'); 1286 + } 1287 + 1288 + static inline char *get_dfs_root(const char *path) 1289 + { 1290 + char *s, *npath; 1291 + 1292 + s = strchr(path + 1, '\\'); 1293 + if (!s) 1294 + return ERR_PTR(-EINVAL); 1295 + 1296 + s = strchr(s + 1, '\\'); 1297 + if (!s) 1298 + return ERR_PTR(-EINVAL); 1299 + 1300 + npath = kstrndup(path, s - path, GFP_KERNEL); 1301 + if (!npath) 1302 + return ERR_PTR(-ENOMEM); 1303 + 1304 + return npath; 1305 + } 1306 + 1307 + /* Find root SMB session out of a DFS link path */ 1308 + static struct cifs_ses *find_root_ses(struct dfs_cache_vol_info *vi, 1309 + struct cifs_tcon *tcon, const char *path) 1310 + { 1311 + char *rpath; 1312 + int rc; 1313 + struct dfs_info3_param ref = {0}; 1314 + char *mdata = NULL, *devname = NULL; 1315 + bool is_smb3 = tcon->ses->server->vals->header_preamble_size == 0; 1316 + struct TCP_Server_Info *server; 1317 + struct cifs_ses *ses; 1318 + struct smb_vol vol; 1319 + 1320 + rpath = get_dfs_root(path); 1321 + if (IS_ERR(rpath)) 1322 + return ERR_CAST(rpath); 1323 + 1324 + memset(&vol, 0, sizeof(vol)); 1325 + 1326 + rc = dfs_cache_noreq_find(rpath, &ref, NULL); 1327 + if (rc) { 1328 + ses = ERR_PTR(rc); 1329 + goto out; 1330 + } 1331 + 1332 + mdata = cifs_compose_mount_options(vi->vi_mntdata, rpath, &ref, 1333 + &devname); 1334 + free_dfs_info_param(&ref); 1335 + 1336 + if (IS_ERR(mdata)) { 1337 + ses = ERR_CAST(mdata); 1338 + mdata = NULL; 1339 + goto out; 1340 + } 1341 + 1342 + rc = cifs_setup_volume_info(&vol, mdata, devname, is_smb3); 1343 + kfree(devname); 1344 + 1345 + if (rc) { 1346 + ses = ERR_PTR(rc); 1347 + goto out; 1348 + } 1349 + 1350 + server = cifs_find_tcp_session(&vol); 1351 + if (IS_ERR_OR_NULL(server)) { 1352 + ses = ERR_PTR(-EHOSTDOWN); 1353 + goto out; 1354 + } 1355 + if (server->tcpStatus != CifsGood) { 1356 + cifs_put_tcp_session(server, 0); 1357 + ses = ERR_PTR(-EHOSTDOWN); 1358 + goto out; 1359 + } 1360 + 1361 + ses = cifs_get_smb_ses(server, &vol); 1362 + 1363 + out: 1364 + cifs_cleanup_volume_info_contents(&vol); 1365 + kfree(mdata); 1366 + kfree(rpath); 1367 + 1368 + return ses; 1369 + } 1370 + 1283 1371 /* Refresh DFS cache entry from a given tcon */ 1284 - static void do_refresh_tcon(struct dfs_cache *dc, struct cifs_tcon *tcon) 1372 + static void do_refresh_tcon(struct dfs_cache *dc, struct dfs_cache_vol_info *vi, 1373 + struct cifs_tcon *tcon) 1285 1374 { 1286 1375 int rc = 0; 1287 1376 unsigned int xid; ··· 1384 1285 struct dfs_cache_entry *ce; 1385 1286 struct dfs_info3_param *refs = NULL; 1386 1287 int numrefs = 0; 1288 + struct cifs_ses *root_ses = NULL, *ses; 1387 1289 1388 1290 xid = get_xid(); 1389 1291 ··· 1406 1306 if (!cache_entry_expired(ce)) 1407 1307 goto out; 1408 1308 1409 - if (unlikely(!tcon->ses->server->ops->get_dfs_refer)) { 1309 + /* If it's a DFS Link, then use root SMB session for refreshing it */ 1310 + if (is_dfs_link(npath)) { 1311 + ses = root_ses = find_root_ses(vi, tcon, npath); 1312 + if (IS_ERR(ses)) { 1313 + rc = PTR_ERR(ses); 1314 + root_ses = NULL; 1315 + goto out; 1316 + } 1317 + } else { 1318 + ses = tcon->ses; 1319 + } 1320 + 1321 + if (unlikely(!ses->server->ops->get_dfs_refer)) { 1410 1322 rc = -EOPNOTSUPP; 1411 1323 } else { 1412 - rc = tcon->ses->server->ops->get_dfs_refer(xid, tcon->ses, path, 1413 - &refs, &numrefs, 1414 - dc->dc_nlsc, 1415 - tcon->remap); 1324 + rc = ses->server->ops->get_dfs_refer(xid, ses, path, &refs, 1325 + &numrefs, dc->dc_nlsc, 1326 + tcon->remap); 1416 1327 if (!rc) { 1417 1328 mutex_lock(&dfs_cache_list_lock); 1418 1329 ce = __update_cache_entry(npath, refs, numrefs); ··· 1434 1323 rc = PTR_ERR(ce); 1435 1324 } 1436 1325 } 1437 - if (rc) 1438 - cifs_dbg(FYI, "%s: failed to update expired entry\n", __func__); 1326 + 1439 1327 out: 1328 + if (root_ses) 1329 + cifs_put_smb_ses(root_ses); 1330 + 1440 1331 free_xid(xid); 1441 1332 free_normalized_path(path, npath); 1442 1333 } ··· 1446 1333 /* 1447 1334 * Worker that will refresh DFS cache based on lowest TTL value from a DFS 1448 1335 * referral. 1449 - * 1450 - * FIXME: ensure that all requests are sent to DFS root for refreshing the 1451 - * cache. 1452 1336 */ 1453 1337 static void refresh_cache_worker(struct work_struct *work) 1454 1338 { ··· 1466 1356 goto next; 1467 1357 get_tcons(server, &list); 1468 1358 list_for_each_entry_safe(tcon, ntcon, &list, ulist) { 1469 - do_refresh_tcon(dc, tcon); 1359 + do_refresh_tcon(dc, vi, tcon); 1470 1360 list_del_init(&tcon->ulist); 1471 1361 cifs_put_tcon(tcon); 1472 1362 }
+3 -2
fs/cifs/dfs_cache.h
··· 2 2 /* 3 3 * DFS referral cache routines 4 4 * 5 - * Copyright (c) 2018 Paulo Alcantara <palcantara@suse.de> 5 + * Copyright (c) 2018-2019 Paulo Alcantara <palcantara@suse.de> 6 6 */ 7 7 8 8 #ifndef _CIFS_DFS_CACHE_H ··· 43 43 extern int dfs_cache_get_tgt_referral(const char *path, 44 44 const struct dfs_cache_tgt_iterator *it, 45 45 struct dfs_info3_param *ref); 46 - extern int dfs_cache_add_vol(struct smb_vol *vol, const char *fullpath); 46 + extern int dfs_cache_add_vol(char *mntdata, struct smb_vol *vol, 47 + const char *fullpath); 47 48 extern int dfs_cache_update_vol(const char *fullpath, 48 49 struct TCP_Server_Info *server); 49 50 extern void dfs_cache_del_vol(const char *fullpath);
-5
fs/cifs/file.c
··· 2443 2443 rc = file_write_and_wait_range(file, start, end); 2444 2444 if (rc) 2445 2445 return rc; 2446 - inode_lock(inode); 2447 2446 2448 2447 xid = get_xid(); 2449 2448 ··· 2467 2468 } 2468 2469 2469 2470 free_xid(xid); 2470 - inode_unlock(inode); 2471 2471 return rc; 2472 2472 } 2473 2473 ··· 2478 2480 struct TCP_Server_Info *server; 2479 2481 struct cifsFileInfo *smbfile = file->private_data; 2480 2482 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); 2481 - struct inode *inode = file->f_mapping->host; 2482 2483 2483 2484 rc = file_write_and_wait_range(file, start, end); 2484 2485 if (rc) 2485 2486 return rc; 2486 - inode_lock(inode); 2487 2487 2488 2488 xid = get_xid(); 2489 2489 ··· 2498 2502 } 2499 2503 2500 2504 free_xid(xid); 2501 - inode_unlock(inode); 2502 2505 return rc; 2503 2506 } 2504 2507
+37
fs/cifs/inode.c
··· 2116 2116 return rc; 2117 2117 } 2118 2118 2119 + int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start, 2120 + u64 len) 2121 + { 2122 + struct cifsInodeInfo *cifs_i = CIFS_I(inode); 2123 + struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb); 2124 + struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 2125 + struct TCP_Server_Info *server = tcon->ses->server; 2126 + struct cifsFileInfo *cfile; 2127 + int rc; 2128 + 2129 + /* 2130 + * We need to be sure that all dirty pages are written as they 2131 + * might fill holes on the server. 2132 + */ 2133 + if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping && 2134 + inode->i_mapping->nrpages != 0) { 2135 + rc = filemap_fdatawait(inode->i_mapping); 2136 + if (rc) { 2137 + mapping_set_error(inode->i_mapping, rc); 2138 + return rc; 2139 + } 2140 + } 2141 + 2142 + cfile = find_readable_file(cifs_i, false); 2143 + if (cfile == NULL) 2144 + return -EINVAL; 2145 + 2146 + if (server->ops->fiemap) { 2147 + rc = server->ops->fiemap(tcon, cfile, fei, start, len); 2148 + cifsFileInfo_put(cfile); 2149 + return rc; 2150 + } 2151 + 2152 + cifsFileInfo_put(cfile); 2153 + return -ENOTSUPP; 2154 + } 2155 + 2119 2156 static int cifs_truncate_page(struct address_space *mapping, loff_t from) 2120 2157 { 2121 2158 pgoff_t index = from >> PAGE_SHIFT;
+10 -3
fs/cifs/link.c
··· 648 648 rc = query_mf_symlink(xid, tcon, cifs_sb, full_path, 649 649 &target_path); 650 650 651 - if (rc != 0 && server->ops->query_symlink) 652 - rc = server->ops->query_symlink(xid, tcon, full_path, 653 - &target_path, cifs_sb); 651 + if (rc != 0 && server->ops->query_symlink) { 652 + struct cifsInodeInfo *cifsi = CIFS_I(inode); 653 + bool reparse_point = false; 654 + 655 + if (cifsi->cifsAttrs & ATTR_REPARSE) 656 + reparse_point = true; 657 + 658 + rc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path, 659 + &target_path, reparse_point); 660 + } 654 661 655 662 kfree(full_path); 656 663 free_xid(xid);
+7 -2
fs/cifs/smb1ops.c
··· 950 950 951 951 static int 952 952 cifs_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, 953 - const char *full_path, char **target_path, 954 - struct cifs_sb_info *cifs_sb) 953 + struct cifs_sb_info *cifs_sb, const char *full_path, 954 + char **target_path, bool is_reparse_point) 955 955 { 956 956 int rc; 957 957 int oplock = 0; ··· 959 959 struct cifs_open_parms oparms; 960 960 961 961 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path); 962 + 963 + if (is_reparse_point) { 964 + cifs_dbg(VFS, "reparse points not handled for SMB1 symlinks\n"); 965 + return -EOPNOTSUPP; 966 + } 962 967 963 968 /* Check for unix extensions */ 964 969 if (cap_unix(tcon->ses)) {
+230 -79
fs/cifs/smb2ops.c
··· 1382 1382 oparms.fid = &fid; 1383 1383 oparms.reconnect = false; 1384 1384 1385 + /* 1386 + * FSCTL codes encode the special access they need in the fsctl code. 1387 + */ 1388 + if (qi.flags & PASSTHRU_FSCTL) { 1389 + switch (qi.info_type & FSCTL_DEVICE_ACCESS_MASK) { 1390 + case FSCTL_DEVICE_ACCESS_FILE_READ_WRITE_ACCESS: 1391 + oparms.desired_access = FILE_READ_DATA | FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE; 1392 + break; 1393 + case FSCTL_DEVICE_ACCESS_FILE_ANY_ACCESS: 1394 + oparms.desired_access = GENERIC_ALL; 1395 + break; 1396 + case FSCTL_DEVICE_ACCESS_FILE_READ_ACCESS: 1397 + oparms.desired_access = GENERIC_READ; 1398 + break; 1399 + case FSCTL_DEVICE_ACCESS_FILE_WRITE_ACCESS: 1400 + oparms.desired_access = GENERIC_WRITE; 1401 + break; 1402 + } 1403 + } 1404 + 1385 1405 rc = SMB2_open_init(tcon, &rqst[0], &oplock, &oparms, path); 1386 1406 if (rc) 1387 1407 goto iqinf_exit; ··· 1419 1399 1420 1400 rc = SMB2_ioctl_init(tcon, &rqst[1], 1421 1401 COMPOUND_FID, COMPOUND_FID, 1422 - qi.info_type, true, NULL, 1423 - 0, CIFSMaxBufSize); 1402 + qi.info_type, true, buffer, 1403 + qi.output_buffer_length, 1404 + CIFSMaxBufSize); 1424 1405 } 1425 1406 } else if (qi.flags == PASSTHRU_QUERY_INFO) { 1426 1407 memset(&qi_iov, 0, sizeof(qi_iov)); ··· 1462 1441 io_rsp = (struct smb2_ioctl_rsp *)rsp_iov[1].iov_base; 1463 1442 if (le32_to_cpu(io_rsp->OutputCount) < qi.input_buffer_length) 1464 1443 qi.input_buffer_length = le32_to_cpu(io_rsp->OutputCount); 1444 + if (qi.input_buffer_length > 0 && 1445 + le32_to_cpu(io_rsp->OutputOffset) + qi.input_buffer_length > rsp_iov[1].iov_len) { 1446 + rc = -EFAULT; 1447 + goto iqinf_exit; 1448 + } 1465 1449 if (copy_to_user(&pqi->input_buffer_length, &qi.input_buffer_length, 1466 1450 sizeof(qi.input_buffer_length))) { 1467 1451 rc = -EFAULT; 1468 1452 goto iqinf_exit; 1469 1453 } 1470 - if (copy_to_user(pqi + 1, &io_rsp[1], qi.input_buffer_length)) { 1454 + if (copy_to_user((void __user *)pqi + sizeof(struct smb_query_info), 1455 + (const void *)io_rsp + le32_to_cpu(io_rsp->OutputOffset), 1456 + qi.input_buffer_length)) { 1471 1457 rc = -EFAULT; 1472 1458 goto iqinf_exit; 1473 1459 } ··· 1849 1821 u32 max_response_size; 1850 1822 struct smb_snapshot_array snapshot_in; 1851 1823 1824 + /* 1825 + * On the first query to enumerate the list of snapshots available 1826 + * for this volume the buffer begins with 0 (number of snapshots 1827 + * which can be returned is zero since at that point we do not know 1828 + * how big the buffer needs to be). On the second query, 1829 + * it (ret_data_len) is set to number of snapshots so we can 1830 + * know to set the maximum response size larger (see below). 1831 + */ 1852 1832 if (get_user(ret_data_len, (unsigned int __user *)ioc_buf)) 1853 1833 return -EFAULT; 1854 1834 ··· 2390 2354 2391 2355 static int 2392 2356 smb2_query_symlink(const unsigned int xid, struct cifs_tcon *tcon, 2393 - const char *full_path, char **target_path, 2394 - struct cifs_sb_info *cifs_sb) 2357 + struct cifs_sb_info *cifs_sb, const char *full_path, 2358 + char **target_path, bool is_reparse_point) 2395 2359 { 2396 2360 int rc; 2397 - __le16 *utf16_path; 2361 + __le16 *utf16_path = NULL; 2398 2362 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 2399 2363 struct cifs_open_parms oparms; 2400 2364 struct cifs_fid fid; 2401 2365 struct kvec err_iov = {NULL, 0}; 2402 2366 struct smb2_err_rsp *err_buf = NULL; 2403 - int resp_buftype; 2404 2367 struct smb2_symlink_err_rsp *symlink; 2405 2368 unsigned int sub_len; 2406 2369 unsigned int sub_offset; 2407 2370 unsigned int print_len; 2408 2371 unsigned int print_offset; 2372 + int flags = 0; 2373 + struct smb_rqst rqst[3]; 2374 + int resp_buftype[3]; 2375 + struct kvec rsp_iov[3]; 2376 + struct kvec open_iov[SMB2_CREATE_IOV_SIZE]; 2377 + struct kvec io_iov[SMB2_IOCTL_IOV_SIZE]; 2378 + struct kvec close_iov[1]; 2379 + struct smb2_create_rsp *create_rsp; 2380 + struct smb2_ioctl_rsp *ioctl_rsp; 2381 + char *ioctl_buf; 2382 + u32 plen; 2409 2383 2410 2384 cifs_dbg(FYI, "%s: path: %s\n", __func__, full_path); 2385 + 2386 + if (smb3_encryption_required(tcon)) 2387 + flags |= CIFS_TRANSFORM_REQ; 2388 + 2389 + memset(rqst, 0, sizeof(rqst)); 2390 + resp_buftype[0] = resp_buftype[1] = resp_buftype[2] = CIFS_NO_BUFFER; 2391 + memset(rsp_iov, 0, sizeof(rsp_iov)); 2411 2392 2412 2393 utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb); 2413 2394 if (!utf16_path) 2414 2395 return -ENOMEM; 2415 2396 2397 + /* Open */ 2398 + memset(&open_iov, 0, sizeof(open_iov)); 2399 + rqst[0].rq_iov = open_iov; 2400 + rqst[0].rq_nvec = SMB2_CREATE_IOV_SIZE; 2401 + 2402 + memset(&oparms, 0, sizeof(oparms)); 2416 2403 oparms.tcon = tcon; 2417 2404 oparms.desired_access = FILE_READ_ATTRIBUTES; 2418 2405 oparms.disposition = FILE_OPEN; 2406 + 2419 2407 if (backup_cred(cifs_sb)) 2420 2408 oparms.create_options = CREATE_OPEN_BACKUP_INTENT; 2421 2409 else 2422 2410 oparms.create_options = 0; 2411 + if (is_reparse_point) 2412 + oparms.create_options = OPEN_REPARSE_POINT; 2413 + 2423 2414 oparms.fid = &fid; 2424 2415 oparms.reconnect = false; 2425 2416 2426 - rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, &err_iov, 2427 - &resp_buftype); 2428 - if (!rc) 2429 - SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid); 2417 + rc = SMB2_open_init(tcon, &rqst[0], &oplock, &oparms, utf16_path); 2418 + if (rc) 2419 + goto querty_exit; 2420 + smb2_set_next_command(tcon, &rqst[0]); 2421 + 2422 + 2423 + /* IOCTL */ 2424 + memset(&io_iov, 0, sizeof(io_iov)); 2425 + rqst[1].rq_iov = io_iov; 2426 + rqst[1].rq_nvec = SMB2_IOCTL_IOV_SIZE; 2427 + 2428 + rc = SMB2_ioctl_init(tcon, &rqst[1], fid.persistent_fid, 2429 + fid.volatile_fid, FSCTL_GET_REPARSE_POINT, 2430 + true /* is_fctl */, NULL, 0, CIFSMaxBufSize); 2431 + if (rc) 2432 + goto querty_exit; 2433 + 2434 + smb2_set_next_command(tcon, &rqst[1]); 2435 + smb2_set_related(&rqst[1]); 2436 + 2437 + 2438 + /* Close */ 2439 + memset(&close_iov, 0, sizeof(close_iov)); 2440 + rqst[2].rq_iov = close_iov; 2441 + rqst[2].rq_nvec = 1; 2442 + 2443 + rc = SMB2_close_init(tcon, &rqst[2], COMPOUND_FID, COMPOUND_FID); 2444 + if (rc) 2445 + goto querty_exit; 2446 + 2447 + smb2_set_related(&rqst[2]); 2448 + 2449 + rc = compound_send_recv(xid, tcon->ses, flags, 3, rqst, 2450 + resp_buftype, rsp_iov); 2451 + 2452 + create_rsp = rsp_iov[0].iov_base; 2453 + if (create_rsp && create_rsp->sync_hdr.Status) 2454 + err_iov = rsp_iov[0]; 2455 + ioctl_rsp = rsp_iov[1].iov_base; 2456 + 2457 + /* 2458 + * Open was successful and we got an ioctl response. 2459 + */ 2460 + if ((rc == 0) && (is_reparse_point)) { 2461 + /* See MS-FSCC 2.3.23 */ 2462 + 2463 + ioctl_buf = (char *)ioctl_rsp + le32_to_cpu(ioctl_rsp->OutputOffset); 2464 + plen = le32_to_cpu(ioctl_rsp->OutputCount); 2465 + 2466 + if (plen + le32_to_cpu(ioctl_rsp->OutputOffset) > 2467 + rsp_iov[1].iov_len) { 2468 + cifs_dbg(VFS, "srv returned invalid ioctl length: %d\n", plen); 2469 + rc = -EIO; 2470 + goto querty_exit; 2471 + } 2472 + 2473 + /* Do stuff with ioctl_buf/plen */ 2474 + goto querty_exit; 2475 + } 2476 + 2430 2477 if (!rc || !err_iov.iov_base) { 2431 2478 rc = -ENOENT; 2432 - goto free_path; 2479 + goto querty_exit; 2433 2480 } 2434 2481 2435 2482 err_buf = err_iov.iov_base; ··· 2552 2433 cifs_dbg(FYI, "%s: target path: %s\n", __func__, *target_path); 2553 2434 2554 2435 querty_exit: 2555 - free_rsp_buf(resp_buftype, err_buf); 2556 - free_path: 2436 + cifs_dbg(FYI, "query symlink rc %d\n", rc); 2557 2437 kfree(utf16_path); 2438 + SMB2_open_free(&rqst[0]); 2439 + SMB2_ioctl_free(&rqst[1]); 2440 + SMB2_close_free(&rqst[2]); 2441 + free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base); 2442 + free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base); 2443 + free_rsp_buf(resp_buftype[2], rsp_iov[2].iov_base); 2558 2444 return rc; 2559 2445 } 2560 2446 ··· 2736 2612 struct cifsInodeInfo *cifsi; 2737 2613 struct cifsFileInfo *cfile = file->private_data; 2738 2614 struct file_zero_data_information fsctl_buf; 2739 - struct smb_rqst rqst[2]; 2740 - int resp_buftype[2]; 2741 - struct kvec rsp_iov[2]; 2742 - struct kvec io_iov[SMB2_IOCTL_IOV_SIZE]; 2743 - struct kvec si_iov[1]; 2744 - unsigned int size[1]; 2745 - void *data[1]; 2746 2615 long rc; 2747 2616 unsigned int xid; 2748 - int num = 0, flags = 0; 2749 2617 __le64 eof; 2750 2618 2751 2619 xid = get_xid(); ··· 2759 2643 return rc; 2760 2644 } 2761 2645 2762 - /* 2763 - * Must check if file sparse since fallocate -z (zero range) assumes 2764 - * non-sparse allocation 2765 - */ 2766 - if (!(cifsi->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE)) { 2767 - rc = -EOPNOTSUPP; 2768 - trace_smb3_zero_err(xid, cfile->fid.persistent_fid, tcon->tid, 2769 - ses->Suid, offset, len, rc); 2770 - free_xid(xid); 2771 - return rc; 2772 - } 2773 - 2774 2646 cifs_dbg(FYI, "offset %lld len %lld", offset, len); 2775 2647 2776 2648 fsctl_buf.FileOffset = cpu_to_le64(offset); 2777 2649 fsctl_buf.BeyondFinalZero = cpu_to_le64(offset + len); 2778 2650 2779 - if (smb3_encryption_required(tcon)) 2780 - flags |= CIFS_TRANSFORM_REQ; 2781 - 2782 - memset(rqst, 0, sizeof(rqst)); 2783 - resp_buftype[0] = resp_buftype[1] = CIFS_NO_BUFFER; 2784 - memset(rsp_iov, 0, sizeof(rsp_iov)); 2785 - 2786 - 2787 - memset(&io_iov, 0, sizeof(io_iov)); 2788 - rqst[num].rq_iov = io_iov; 2789 - rqst[num].rq_nvec = SMB2_IOCTL_IOV_SIZE; 2790 - rc = SMB2_ioctl_init(tcon, &rqst[num++], cfile->fid.persistent_fid, 2791 - cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, 2792 - true /* is_fctl */, (char *)&fsctl_buf, 2793 - sizeof(struct file_zero_data_information), 2794 - CIFSMaxBufSize); 2651 + rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 2652 + cfile->fid.volatile_fid, FSCTL_SET_ZERO_DATA, true, 2653 + (char *)&fsctl_buf, 2654 + sizeof(struct file_zero_data_information), 2655 + 0, NULL, NULL); 2795 2656 if (rc) 2796 2657 goto zero_range_exit; 2797 2658 ··· 2776 2683 * do we also need to change the size of the file? 2777 2684 */ 2778 2685 if (keep_size == false && i_size_read(inode) < offset + len) { 2779 - smb2_set_next_command(tcon, &rqst[0]); 2780 - 2781 - memset(&si_iov, 0, sizeof(si_iov)); 2782 - rqst[num].rq_iov = si_iov; 2783 - rqst[num].rq_nvec = 1; 2784 - 2785 2686 eof = cpu_to_le64(offset + len); 2786 - size[0] = 8; /* sizeof __le64 */ 2787 - data[0] = &eof; 2788 - 2789 - rc = SMB2_set_info_init(tcon, &rqst[num++], 2790 - cfile->fid.persistent_fid, 2791 - cfile->fid.persistent_fid, 2792 - current->tgid, 2793 - FILE_END_OF_FILE_INFORMATION, 2794 - SMB2_O_INFO_FILE, 0, data, size); 2795 - smb2_set_related(&rqst[1]); 2687 + rc = SMB2_set_eof(xid, tcon, cfile->fid.persistent_fid, 2688 + cfile->fid.volatile_fid, cfile->pid, &eof); 2796 2689 } 2797 2690 2798 - rc = compound_send_recv(xid, ses, flags, num, rqst, 2799 - resp_buftype, rsp_iov); 2800 - 2801 2691 zero_range_exit: 2802 - SMB2_ioctl_free(&rqst[0]); 2803 - SMB2_set_info_free(&rqst[1]); 2804 - free_rsp_buf(resp_buftype[0], rsp_iov[0].iov_base); 2805 - free_rsp_buf(resp_buftype[1], rsp_iov[1].iov_base); 2806 2692 free_xid(xid); 2807 2693 if (rc) 2808 2694 trace_smb3_zero_err(xid, cfile->fid.persistent_fid, tcon->tid, ··· 2922 2850 return rc; 2923 2851 } 2924 2852 2853 + static int smb3_fiemap(struct cifs_tcon *tcon, 2854 + struct cifsFileInfo *cfile, 2855 + struct fiemap_extent_info *fei, u64 start, u64 len) 2856 + { 2857 + unsigned int xid; 2858 + struct file_allocated_range_buffer in_data, *out_data; 2859 + u32 out_data_len; 2860 + int i, num, rc, flags, last_blob; 2861 + u64 next; 2862 + 2863 + if (fiemap_check_flags(fei, FIEMAP_FLAG_SYNC)) 2864 + return -EBADR; 2865 + 2866 + xid = get_xid(); 2867 + again: 2868 + in_data.file_offset = cpu_to_le64(start); 2869 + in_data.length = cpu_to_le64(len); 2870 + 2871 + rc = SMB2_ioctl(xid, tcon, cfile->fid.persistent_fid, 2872 + cfile->fid.volatile_fid, 2873 + FSCTL_QUERY_ALLOCATED_RANGES, true, 2874 + (char *)&in_data, sizeof(in_data), 2875 + 1024 * sizeof(struct file_allocated_range_buffer), 2876 + (char **)&out_data, &out_data_len); 2877 + if (rc == -E2BIG) { 2878 + last_blob = 0; 2879 + rc = 0; 2880 + } else 2881 + last_blob = 1; 2882 + if (rc) 2883 + goto out; 2884 + 2885 + if (out_data_len < sizeof(struct file_allocated_range_buffer)) { 2886 + rc = -EINVAL; 2887 + goto out; 2888 + } 2889 + if (out_data_len % sizeof(struct file_allocated_range_buffer)) { 2890 + rc = -EINVAL; 2891 + goto out; 2892 + } 2893 + 2894 + num = out_data_len / sizeof(struct file_allocated_range_buffer); 2895 + for (i = 0; i < num; i++) { 2896 + flags = 0; 2897 + if (i == num - 1 && last_blob) 2898 + flags |= FIEMAP_EXTENT_LAST; 2899 + 2900 + rc = fiemap_fill_next_extent(fei, 2901 + le64_to_cpu(out_data[i].file_offset), 2902 + le64_to_cpu(out_data[i].file_offset), 2903 + le64_to_cpu(out_data[i].length), 2904 + flags); 2905 + if (rc < 0) 2906 + goto out; 2907 + if (rc == 1) { 2908 + rc = 0; 2909 + goto out; 2910 + } 2911 + } 2912 + 2913 + if (!last_blob) { 2914 + next = le64_to_cpu(out_data[num - 1].file_offset) + 2915 + le64_to_cpu(out_data[num - 1].length); 2916 + len = len - (next - start); 2917 + start = next; 2918 + goto again; 2919 + } 2920 + 2921 + out: 2922 + free_xid(xid); 2923 + kfree(out_data); 2924 + return rc; 2925 + } 2925 2926 2926 2927 static long smb3_fallocate(struct file *file, struct cifs_tcon *tcon, int mode, 2927 2928 loff_t off, loff_t len) ··· 3062 2917 unsigned int epoch, bool *purge_cache) 3063 2918 { 3064 2919 char message[5] = {0}; 2920 + unsigned int new_oplock = 0; 3065 2921 3066 2922 oplock &= 0xFF; 3067 2923 if (oplock == SMB2_OPLOCK_LEVEL_NOCHANGE) 3068 2924 return; 3069 2925 3070 - cinode->oplock = 0; 3071 2926 if (oplock & SMB2_LEASE_READ_CACHING_HE) { 3072 - cinode->oplock |= CIFS_CACHE_READ_FLG; 2927 + new_oplock |= CIFS_CACHE_READ_FLG; 3073 2928 strcat(message, "R"); 3074 2929 } 3075 2930 if (oplock & SMB2_LEASE_HANDLE_CACHING_HE) { 3076 - cinode->oplock |= CIFS_CACHE_HANDLE_FLG; 2931 + new_oplock |= CIFS_CACHE_HANDLE_FLG; 3077 2932 strcat(message, "H"); 3078 2933 } 3079 2934 if (oplock & SMB2_LEASE_WRITE_CACHING_HE) { 3080 - cinode->oplock |= CIFS_CACHE_WRITE_FLG; 2935 + new_oplock |= CIFS_CACHE_WRITE_FLG; 3081 2936 strcat(message, "W"); 3082 2937 } 3083 - if (!cinode->oplock) 3084 - strcat(message, "None"); 2938 + if (!new_oplock) 2939 + strncpy(message, "None", sizeof(message)); 2940 + 2941 + cinode->oplock = new_oplock; 3085 2942 cifs_dbg(FYI, "%s Lease granted on inode %p\n", message, 3086 2943 &cinode->vfs_inode); 3087 2944 } ··· 4165 4018 .next_header = smb2_next_header, 4166 4019 .ioctl_query_info = smb2_ioctl_query_info, 4167 4020 .make_node = smb2_make_node, 4021 + .fiemap = smb3_fiemap, 4168 4022 }; 4169 4023 4170 4024 struct smb_version_operations smb21_operations = { ··· 4265 4117 .next_header = smb2_next_header, 4266 4118 .ioctl_query_info = smb2_ioctl_query_info, 4267 4119 .make_node = smb2_make_node, 4120 + .fiemap = smb3_fiemap, 4268 4121 }; 4269 4122 4270 4123 struct smb_version_operations smb30_operations = { ··· 4374 4225 .next_header = smb2_next_header, 4375 4226 .ioctl_query_info = smb2_ioctl_query_info, 4376 4227 .make_node = smb2_make_node, 4228 + .fiemap = smb3_fiemap, 4377 4229 }; 4378 4230 4379 4231 struct smb_version_operations smb311_operations = { ··· 4484 4334 .next_header = smb2_next_header, 4485 4335 .ioctl_query_info = smb2_ioctl_query_info, 4486 4336 .make_node = smb2_make_node, 4337 + .fiemap = smb3_fiemap, 4487 4338 }; 4488 4339 4489 4340 struct smb_version_values smb20_values = {
+59 -13
fs/cifs/smb2pdu.c
··· 459 459 return rc; 460 460 } 461 461 462 - 463 - #define SMB2_PREAUTH_INTEGRITY_CAPABILITIES cpu_to_le16(1) 464 - #define SMB2_ENCRYPTION_CAPABILITIES cpu_to_le16(2) 465 - #define SMB2_POSIX_EXTENSIONS_AVAILABLE cpu_to_le16(0x100) 462 + /* For explanation of negotiate contexts see MS-SMB2 section 2.2.3.1 */ 466 463 467 464 static void 468 465 build_preauth_ctxt(struct smb2_preauth_neg_context *pneg_ctxt) ··· 470 473 pneg_ctxt->SaltLength = cpu_to_le16(SMB311_SALT_SIZE); 471 474 get_random_bytes(pneg_ctxt->Salt, SMB311_SALT_SIZE); 472 475 pneg_ctxt->HashAlgorithms = SMB2_PREAUTH_INTEGRITY_SHA512; 476 + } 477 + 478 + static void 479 + build_compression_ctxt(struct smb2_compression_capabilities_context *pneg_ctxt) 480 + { 481 + pneg_ctxt->ContextType = SMB2_COMPRESSION_CAPABILITIES; 482 + pneg_ctxt->DataLength = 483 + cpu_to_le16(sizeof(struct smb2_compression_capabilities_context) 484 + - sizeof(struct smb2_neg_context)); 485 + pneg_ctxt->CompressionAlgorithmCount = cpu_to_le16(3); 486 + pneg_ctxt->CompressionAlgorithms[0] = SMB3_COMPRESS_LZ77; 487 + pneg_ctxt->CompressionAlgorithms[1] = SMB3_COMPRESS_LZ77_HUFF; 488 + pneg_ctxt->CompressionAlgorithms[2] = SMB3_COMPRESS_LZNT1; 473 489 } 474 490 475 491 static void ··· 551 541 *total_len += ctxt_len; 552 542 pneg_ctxt += ctxt_len; 553 543 544 + build_compression_ctxt((struct smb2_compression_capabilities_context *) 545 + pneg_ctxt); 546 + ctxt_len = DIV_ROUND_UP( 547 + sizeof(struct smb2_compression_capabilities_context), 8) * 8; 548 + *total_len += ctxt_len; 549 + pneg_ctxt += ctxt_len; 550 + 554 551 build_posix_ctxt((struct smb2_posix_neg_context *)pneg_ctxt); 555 552 *total_len += sizeof(struct smb2_posix_neg_context); 556 553 557 - req->NegotiateContextCount = cpu_to_le16(3); 554 + req->NegotiateContextCount = cpu_to_le16(4); 558 555 } 559 556 560 557 static void decode_preauth_context(struct smb2_preauth_neg_context *ctxt) ··· 577 560 printk_once(KERN_WARNING "illegal SMB3 hash algorithm count\n"); 578 561 if (ctxt->HashAlgorithms != SMB2_PREAUTH_INTEGRITY_SHA512) 579 562 printk_once(KERN_WARNING "unknown SMB3 hash algorithm\n"); 563 + } 564 + 565 + static void decode_compress_ctx(struct TCP_Server_Info *server, 566 + struct smb2_compression_capabilities_context *ctxt) 567 + { 568 + unsigned int len = le16_to_cpu(ctxt->DataLength); 569 + 570 + /* sizeof compress context is a one element compression capbility struct */ 571 + if (len < 10) { 572 + printk_once(KERN_WARNING "server sent bad compression cntxt\n"); 573 + return; 574 + } 575 + if (le16_to_cpu(ctxt->CompressionAlgorithmCount) != 1) { 576 + printk_once(KERN_WARNING "illegal SMB3 compress algorithm count\n"); 577 + return; 578 + } 579 + if (le16_to_cpu(ctxt->CompressionAlgorithms[0]) > 3) { 580 + printk_once(KERN_WARNING "unknown compression algorithm\n"); 581 + return; 582 + } 583 + server->compress_algorithm = ctxt->CompressionAlgorithms[0]; 580 584 } 581 585 582 586 static int decode_encrypt_ctx(struct TCP_Server_Info *server, ··· 664 626 else if (pctx->ContextType == SMB2_ENCRYPTION_CAPABILITIES) 665 627 rc = decode_encrypt_ctx(server, 666 628 (struct smb2_encryption_neg_context *)pctx); 629 + else if (pctx->ContextType == SMB2_COMPRESSION_CAPABILITIES) 630 + decode_compress_ctx(server, 631 + (struct smb2_compression_capabilities_context *)pctx); 667 632 else if (pctx->ContextType == SMB2_POSIX_EXTENSIONS_AVAILABLE) 668 633 server->posix_ext_supported = true; 669 634 else ··· 1582 1541 else if (server->sign) 1583 1542 req->sync_hdr.Flags |= SMB2_FLAGS_SIGNED; 1584 1543 1585 - flags |= CIFS_NO_RESP; 1544 + flags |= CIFS_NO_RSP_BUF; 1586 1545 1587 1546 iov[0].iov_base = (char *)req; 1588 1547 iov[0].iov_len = total_len; ··· 1783 1742 if (smb3_encryption_required(tcon)) 1784 1743 flags |= CIFS_TRANSFORM_REQ; 1785 1744 1786 - flags |= CIFS_NO_RESP; 1745 + flags |= CIFS_NO_RSP_BUF; 1787 1746 1788 1747 iov[0].iov_base = (char *)req; 1789 1748 iov[0].iov_len = total_len; ··· 2666 2625 trace_smb3_fsctl_err(xid, persistent_fid, tcon->tid, 2667 2626 ses->Suid, 0, opcode, rc); 2668 2627 2669 - if ((rc != 0) && (rc != -EINVAL)) { 2628 + if ((rc != 0) && (rc != -EINVAL) && (rc != -E2BIG)) { 2670 2629 cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 2671 2630 goto ioctl_exit; 2672 2631 } else if (rc == -EINVAL) { 2673 2632 if ((opcode != FSCTL_SRV_COPYCHUNK_WRITE) && 2674 2633 (opcode != FSCTL_SRV_COPYCHUNK)) { 2634 + cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 2635 + goto ioctl_exit; 2636 + } 2637 + } else if (rc == -E2BIG) { 2638 + if (opcode != FSCTL_QUERY_ALLOCATED_RANGES) { 2675 2639 cifs_stats_fail_inc(tcon, SMB2_IOCTL_HE); 2676 2640 goto ioctl_exit; 2677 2641 } ··· 3269 3223 rdata->nr_pages, rdata->page_offset, 3270 3224 rdata->tailsz, true, need_invalidate); 3271 3225 if (!rdata->mr) 3272 - return -ENOBUFS; 3226 + return -EAGAIN; 3273 3227 3274 3228 req->Channel = SMB2_CHANNEL_RDMA_V1_INVALIDATE; 3275 3229 if (need_invalidate) ··· 3674 3628 wdata->nr_pages, wdata->page_offset, 3675 3629 wdata->tailsz, false, need_invalidate); 3676 3630 if (!wdata->mr) { 3677 - rc = -ENOBUFS; 3631 + rc = -EAGAIN; 3678 3632 goto async_writev_out; 3679 3633 } 3680 3634 req->Length = 0; ··· 4210 4164 req->OplockLevel = oplock_level; 4211 4165 req->sync_hdr.CreditRequest = cpu_to_le16(1); 4212 4166 4213 - flags |= CIFS_NO_RESP; 4167 + flags |= CIFS_NO_RSP_BUF; 4214 4168 4215 4169 iov[0].iov_base = (char *)req; 4216 4170 iov[0].iov_len = total_len; ··· 4484 4438 struct kvec rsp_iov; 4485 4439 int resp_buf_type; 4486 4440 unsigned int count; 4487 - int flags = CIFS_NO_RESP; 4441 + int flags = CIFS_NO_RSP_BUF; 4488 4442 unsigned int total_len; 4489 4443 4490 4444 cifs_dbg(FYI, "smb2_lockv num lock %d\n", num_lock); ··· 4577 4531 memcpy(req->LeaseKey, lease_key, 16); 4578 4532 req->LeaseState = lease_state; 4579 4533 4580 - flags |= CIFS_NO_RESP; 4534 + flags |= CIFS_NO_RSP_BUF; 4581 4535 4582 4536 iov[0].iov_base = (char *)req; 4583 4537 iov[0].iov_len = total_len;
+71
fs/cifs/smb2pdu.h
··· 251 251 #define SMB2_NT_FIND 0x00100000 252 252 #define SMB2_LARGE_FILES 0x00200000 253 253 254 + 255 + /* Negotiate Contexts - ContextTypes. See MS-SMB2 section 2.2.3.1 for details */ 256 + #define SMB2_PREAUTH_INTEGRITY_CAPABILITIES cpu_to_le16(1) 257 + #define SMB2_ENCRYPTION_CAPABILITIES cpu_to_le16(2) 258 + #define SMB2_COMPRESSION_CAPABILITIES cpu_to_le16(3) 259 + #define SMB2_NETNAME_NEGOTIATE_CONTEXT_ID cpu_to_le16(5) 260 + #define SMB2_POSIX_EXTENSIONS_AVAILABLE cpu_to_le16(0x100) 261 + 254 262 struct smb2_neg_context { 255 263 __le16 ContextType; 256 264 __le16 DataLength; ··· 295 287 __le16 CipherCount; /* AES-128-GCM and AES-128-CCM */ 296 288 __le16 Ciphers[1]; /* Ciphers[0] since only one used now */ 297 289 } __packed; 290 + 291 + /* See MS-SMB2 2.2.3.1.3 */ 292 + #define SMB3_COMPRESS_NONE cpu_to_le16(0x0000) 293 + #define SMB3_COMPRESS_LZNT1 cpu_to_le16(0x0001) 294 + #define SMB3_COMPRESS_LZ77 cpu_to_le16(0x0002) 295 + #define SMB3_COMPRESS_LZ77_HUFF cpu_to_le16(0x0003) 296 + 297 + struct smb2_compression_capabilities_context { 298 + __le16 ContextType; /* 3 */ 299 + __le16 DataLength; 300 + __u32 Reserved; 301 + __le16 CompressionAlgorithmCount; 302 + __u16 Padding; 303 + __u32 Reserved1; 304 + __le16 CompressionAlgorithms[3]; 305 + } __packed; 306 + 307 + /* 308 + * For smb2_netname_negotiate_context_id See MS-SMB2 2.2.3.1.4. 309 + * Its struct simply contains NetName, an array of Unicode characters 310 + */ 298 311 299 312 #define POSIX_CTXT_DATA_LEN 16 300 313 struct smb2_posix_neg_context { ··· 871 842 __le32 ClusterSizeInBytes; 872 843 } __packed; 873 844 845 + struct file_allocated_range_buffer { 846 + __le64 file_offset; 847 + __le64 length; 848 + } __packed; 849 + 874 850 /* Integrity ChecksumAlgorithm choices for above */ 875 851 #define CHECKSUM_TYPE_NONE 0x0000 876 852 #define CHECKSUM_TYPE_CRC64 0x0002 ··· 1081 1047 1082 1048 /* For read request Flags field below, following flag is defined for SMB3.02 */ 1083 1049 #define SMB2_READFLAG_READ_UNBUFFERED 0x01 1050 + #define SMB2_READFLAG_REQUEST_COMPRESSED 0x02 /* See MS-SMB2 2.2.19 */ 1084 1051 1085 1052 /* Channel field for read and write: exactly one of following flags can be set*/ 1086 1053 #define SMB2_CHANNEL_NONE cpu_to_le32(0x00000000) ··· 1146 1111 __le32 DataRemaining; 1147 1112 __u32 Reserved2; 1148 1113 __u8 Buffer[1]; 1114 + } __packed; 1115 + 1116 + /* notify flags */ 1117 + #define SMB2_WATCH_TREE 0x0001 1118 + 1119 + /* notify completion filter flags. See MS-FSCC 2.6 and MS-SMB2 2.2.35 */ 1120 + #define FILE_NOTIFY_CHANGE_FILE_NAME 0x00000001 1121 + #define FILE_NOTIFY_CHANGE_DIR_NAME 0x00000002 1122 + #define FILE_NOTIFY_CHANGE_ATTRIBUTES 0x00000004 1123 + #define FILE_NOTIFY_CHANGE_SIZE 0x00000008 1124 + #define FILE_NOTIFY_CHANGE_LAST_WRITE 0x00000010 1125 + #define FILE_NOTIFY_CHANGE_LAST_ACCESS 0x00000020 1126 + #define FILE_NOTIFY_CHANGE_CREATION 0x00000040 1127 + #define FILE_NOTIFY_CHANGE_EA 0x00000080 1128 + #define FILE_NOTIFY_CHANGE_SECURITY 0x00000100 1129 + #define FILE_NOTIFY_CHANGE_STREAM_NAME 0x00000200 1130 + #define FILE_NOTIFY_CHANGE_STREAM_SIZE 0x00000400 1131 + #define FILE_NOTIFY_CHANGE_STREAM_WRITE 0x00000800 1132 + 1133 + struct smb2_change_notify_req { 1134 + struct smb2_sync_hdr sync_hdr; 1135 + __le16 StructureSize; 1136 + __le16 Flags; 1137 + __le32 OutputBufferLength; 1138 + __u64 PersistentFileId; /* opaque endianness */ 1139 + __u64 VolatileFileId; /* opaque endianness */ 1140 + __le32 CompletionFilter; 1141 + __u32 Reserved; 1142 + } __packed; 1143 + 1144 + struct smb2_change_notify_rsp { 1145 + struct smb2_sync_hdr sync_hdr; 1146 + __le16 StructureSize; /* Must be 9 */ 1147 + __le16 OutputBufferOffset; 1148 + __le32 OutputBufferLength; 1149 + __u8 Buffer[1]; /* array of file notify structs */ 1149 1150 } __packed; 1150 1151 1151 1152 #define SMB2_LOCKFLAG_SHARED_LOCK 0x0001
+1740 -1740
fs/cifs/smb2status.h
··· 40 40 __le32 Code; 41 41 }; 42 42 43 - #define STATUS_SUCCESS __constant_cpu_to_le32(0x00000000) 44 - #define STATUS_WAIT_0 __constant_cpu_to_le32(0x00000000) 45 - #define STATUS_WAIT_1 __constant_cpu_to_le32(0x00000001) 46 - #define STATUS_WAIT_2 __constant_cpu_to_le32(0x00000002) 47 - #define STATUS_WAIT_3 __constant_cpu_to_le32(0x00000003) 48 - #define STATUS_WAIT_63 __constant_cpu_to_le32(0x0000003F) 49 - #define STATUS_ABANDONED __constant_cpu_to_le32(0x00000080) 50 - #define STATUS_ABANDONED_WAIT_0 __constant_cpu_to_le32(0x00000080) 51 - #define STATUS_ABANDONED_WAIT_63 __constant_cpu_to_le32(0x000000BF) 52 - #define STATUS_USER_APC __constant_cpu_to_le32(0x000000C0) 53 - #define STATUS_KERNEL_APC __constant_cpu_to_le32(0x00000100) 54 - #define STATUS_ALERTED __constant_cpu_to_le32(0x00000101) 55 - #define STATUS_TIMEOUT __constant_cpu_to_le32(0x00000102) 56 - #define STATUS_PENDING __constant_cpu_to_le32(0x00000103) 57 - #define STATUS_REPARSE __constant_cpu_to_le32(0x00000104) 58 - #define STATUS_MORE_ENTRIES __constant_cpu_to_le32(0x00000105) 59 - #define STATUS_NOT_ALL_ASSIGNED __constant_cpu_to_le32(0x00000106) 60 - #define STATUS_SOME_NOT_MAPPED __constant_cpu_to_le32(0x00000107) 61 - #define STATUS_OPLOCK_BREAK_IN_PROGRESS __constant_cpu_to_le32(0x00000108) 62 - #define STATUS_VOLUME_MOUNTED __constant_cpu_to_le32(0x00000109) 63 - #define STATUS_RXACT_COMMITTED __constant_cpu_to_le32(0x0000010A) 64 - #define STATUS_NOTIFY_CLEANUP __constant_cpu_to_le32(0x0000010B) 65 - #define STATUS_NOTIFY_ENUM_DIR __constant_cpu_to_le32(0x0000010C) 66 - #define STATUS_NO_QUOTAS_FOR_ACCOUNT __constant_cpu_to_le32(0x0000010D) 67 - #define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED __constant_cpu_to_le32(0x0000010E) 68 - #define STATUS_PAGE_FAULT_TRANSITION __constant_cpu_to_le32(0x00000110) 69 - #define STATUS_PAGE_FAULT_DEMAND_ZERO __constant_cpu_to_le32(0x00000111) 70 - #define STATUS_PAGE_FAULT_COPY_ON_WRITE __constant_cpu_to_le32(0x00000112) 71 - #define STATUS_PAGE_FAULT_GUARD_PAGE __constant_cpu_to_le32(0x00000113) 72 - #define STATUS_PAGE_FAULT_PAGING_FILE __constant_cpu_to_le32(0x00000114) 73 - #define STATUS_CACHE_PAGE_LOCKED __constant_cpu_to_le32(0x00000115) 74 - #define STATUS_CRASH_DUMP __constant_cpu_to_le32(0x00000116) 75 - #define STATUS_BUFFER_ALL_ZEROS __constant_cpu_to_le32(0x00000117) 76 - #define STATUS_REPARSE_OBJECT __constant_cpu_to_le32(0x00000118) 77 - #define STATUS_RESOURCE_REQUIREMENTS_CHANGED __constant_cpu_to_le32(0x00000119) 78 - #define STATUS_TRANSLATION_COMPLETE __constant_cpu_to_le32(0x00000120) 79 - #define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY __constant_cpu_to_le32(0x00000121) 80 - #define STATUS_NOTHING_TO_TERMINATE __constant_cpu_to_le32(0x00000122) 81 - #define STATUS_PROCESS_NOT_IN_JOB __constant_cpu_to_le32(0x00000123) 82 - #define STATUS_PROCESS_IN_JOB __constant_cpu_to_le32(0x00000124) 83 - #define STATUS_VOLSNAP_HIBERNATE_READY __constant_cpu_to_le32(0x00000125) 84 - #define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY __constant_cpu_to_le32(0x00000126) 85 - #define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED __constant_cpu_to_le32(0x00000127) 86 - #define STATUS_INTERRUPT_STILL_CONNECTED __constant_cpu_to_le32(0x00000128) 87 - #define STATUS_PROCESS_CLONED __constant_cpu_to_le32(0x00000129) 88 - #define STATUS_FILE_LOCKED_WITH_ONLY_READERS __constant_cpu_to_le32(0x0000012A) 89 - #define STATUS_FILE_LOCKED_WITH_WRITERS __constant_cpu_to_le32(0x0000012B) 90 - #define STATUS_RESOURCEMANAGER_READ_ONLY __constant_cpu_to_le32(0x00000202) 91 - #define STATUS_WAIT_FOR_OPLOCK __constant_cpu_to_le32(0x00000367) 92 - #define DBG_EXCEPTION_HANDLED __constant_cpu_to_le32(0x00010001) 93 - #define DBG_CONTINUE __constant_cpu_to_le32(0x00010002) 94 - #define STATUS_FLT_IO_COMPLETE __constant_cpu_to_le32(0x001C0001) 95 - #define STATUS_OBJECT_NAME_EXISTS __constant_cpu_to_le32(0x40000000) 96 - #define STATUS_THREAD_WAS_SUSPENDED __constant_cpu_to_le32(0x40000001) 97 - #define STATUS_WORKING_SET_LIMIT_RANGE __constant_cpu_to_le32(0x40000002) 98 - #define STATUS_IMAGE_NOT_AT_BASE __constant_cpu_to_le32(0x40000003) 99 - #define STATUS_RXACT_STATE_CREATED __constant_cpu_to_le32(0x40000004) 100 - #define STATUS_SEGMENT_NOTIFICATION __constant_cpu_to_le32(0x40000005) 101 - #define STATUS_LOCAL_USER_SESSION_KEY __constant_cpu_to_le32(0x40000006) 102 - #define STATUS_BAD_CURRENT_DIRECTORY __constant_cpu_to_le32(0x40000007) 103 - #define STATUS_SERIAL_MORE_WRITES __constant_cpu_to_le32(0x40000008) 104 - #define STATUS_REGISTRY_RECOVERED __constant_cpu_to_le32(0x40000009) 105 - #define STATUS_FT_READ_RECOVERY_FROM_BACKUP __constant_cpu_to_le32(0x4000000A) 106 - #define STATUS_FT_WRITE_RECOVERY __constant_cpu_to_le32(0x4000000B) 107 - #define STATUS_SERIAL_COUNTER_TIMEOUT __constant_cpu_to_le32(0x4000000C) 108 - #define STATUS_NULL_LM_PASSWORD __constant_cpu_to_le32(0x4000000D) 109 - #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH __constant_cpu_to_le32(0x4000000E) 110 - #define STATUS_RECEIVE_PARTIAL __constant_cpu_to_le32(0x4000000F) 111 - #define STATUS_RECEIVE_EXPEDITED __constant_cpu_to_le32(0x40000010) 112 - #define STATUS_RECEIVE_PARTIAL_EXPEDITED __constant_cpu_to_le32(0x40000011) 113 - #define STATUS_EVENT_DONE __constant_cpu_to_le32(0x40000012) 114 - #define STATUS_EVENT_PENDING __constant_cpu_to_le32(0x40000013) 115 - #define STATUS_CHECKING_FILE_SYSTEM __constant_cpu_to_le32(0x40000014) 116 - #define STATUS_FATAL_APP_EXIT __constant_cpu_to_le32(0x40000015) 117 - #define STATUS_PREDEFINED_HANDLE __constant_cpu_to_le32(0x40000016) 118 - #define STATUS_WAS_UNLOCKED __constant_cpu_to_le32(0x40000017) 119 - #define STATUS_SERVICE_NOTIFICATION __constant_cpu_to_le32(0x40000018) 120 - #define STATUS_WAS_LOCKED __constant_cpu_to_le32(0x40000019) 121 - #define STATUS_LOG_HARD_ERROR __constant_cpu_to_le32(0x4000001A) 122 - #define STATUS_ALREADY_WIN32 __constant_cpu_to_le32(0x4000001B) 123 - #define STATUS_WX86_UNSIMULATE __constant_cpu_to_le32(0x4000001C) 124 - #define STATUS_WX86_CONTINUE __constant_cpu_to_le32(0x4000001D) 125 - #define STATUS_WX86_SINGLE_STEP __constant_cpu_to_le32(0x4000001E) 126 - #define STATUS_WX86_BREAKPOINT __constant_cpu_to_le32(0x4000001F) 127 - #define STATUS_WX86_EXCEPTION_CONTINUE __constant_cpu_to_le32(0x40000020) 128 - #define STATUS_WX86_EXCEPTION_LASTCHANCE __constant_cpu_to_le32(0x40000021) 129 - #define STATUS_WX86_EXCEPTION_CHAIN __constant_cpu_to_le32(0x40000022) 130 - #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE __constant_cpu_to_le32(0x40000023) 131 - #define STATUS_NO_YIELD_PERFORMED __constant_cpu_to_le32(0x40000024) 132 - #define STATUS_TIMER_RESUME_IGNORED __constant_cpu_to_le32(0x40000025) 133 - #define STATUS_ARBITRATION_UNHANDLED __constant_cpu_to_le32(0x40000026) 134 - #define STATUS_CARDBUS_NOT_SUPPORTED __constant_cpu_to_le32(0x40000027) 135 - #define STATUS_WX86_CREATEWX86TIB __constant_cpu_to_le32(0x40000028) 136 - #define STATUS_MP_PROCESSOR_MISMATCH __constant_cpu_to_le32(0x40000029) 137 - #define STATUS_HIBERNATED __constant_cpu_to_le32(0x4000002A) 138 - #define STATUS_RESUME_HIBERNATION __constant_cpu_to_le32(0x4000002B) 139 - #define STATUS_FIRMWARE_UPDATED __constant_cpu_to_le32(0x4000002C) 140 - #define STATUS_DRIVERS_LEAKING_LOCKED_PAGES __constant_cpu_to_le32(0x4000002D) 141 - #define STATUS_MESSAGE_RETRIEVED __constant_cpu_to_le32(0x4000002E) 142 - #define STATUS_SYSTEM_POWERSTATE_TRANSITION __constant_cpu_to_le32(0x4000002F) 143 - #define STATUS_ALPC_CHECK_COMPLETION_LIST __constant_cpu_to_le32(0x40000030) 144 - #define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION __constant_cpu_to_le32(0x40000031) 145 - #define STATUS_ACCESS_AUDIT_BY_POLICY __constant_cpu_to_le32(0x40000032) 146 - #define STATUS_ABANDON_HIBERFILE __constant_cpu_to_le32(0x40000033) 147 - #define STATUS_BIZRULES_NOT_ENABLED __constant_cpu_to_le32(0x40000034) 148 - #define STATUS_WAKE_SYSTEM __constant_cpu_to_le32(0x40000294) 149 - #define STATUS_DS_SHUTTING_DOWN __constant_cpu_to_le32(0x40000370) 150 - #define DBG_REPLY_LATER __constant_cpu_to_le32(0x40010001) 151 - #define DBG_UNABLE_TO_PROVIDE_HANDLE __constant_cpu_to_le32(0x40010002) 152 - #define DBG_TERMINATE_THREAD __constant_cpu_to_le32(0x40010003) 153 - #define DBG_TERMINATE_PROCESS __constant_cpu_to_le32(0x40010004) 154 - #define DBG_CONTROL_C __constant_cpu_to_le32(0x40010005) 155 - #define DBG_PRINTEXCEPTION_C __constant_cpu_to_le32(0x40010006) 156 - #define DBG_RIPEXCEPTION __constant_cpu_to_le32(0x40010007) 157 - #define DBG_CONTROL_BREAK __constant_cpu_to_le32(0x40010008) 158 - #define DBG_COMMAND_EXCEPTION __constant_cpu_to_le32(0x40010009) 159 - #define RPC_NT_UUID_LOCAL_ONLY __constant_cpu_to_le32(0x40020056) 160 - #define RPC_NT_SEND_INCOMPLETE __constant_cpu_to_le32(0x400200AF) 161 - #define STATUS_CTX_CDM_CONNECT __constant_cpu_to_le32(0x400A0004) 162 - #define STATUS_CTX_CDM_DISCONNECT __constant_cpu_to_le32(0x400A0005) 163 - #define STATUS_SXS_RELEASE_ACTIVATION_CONTEXT __constant_cpu_to_le32(0x4015000D) 164 - #define STATUS_RECOVERY_NOT_NEEDED __constant_cpu_to_le32(0x40190034) 165 - #define STATUS_RM_ALREADY_STARTED __constant_cpu_to_le32(0x40190035) 166 - #define STATUS_LOG_NO_RESTART __constant_cpu_to_le32(0x401A000C) 167 - #define STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST __constant_cpu_to_le32(0x401B00EC) 168 - #define STATUS_GRAPHICS_PARTIAL_DATA_POPULATED __constant_cpu_to_le32(0x401E000A) 169 - #define STATUS_GRAPHICS_DRIVER_MISMATCH __constant_cpu_to_le32(0x401E0117) 170 - #define STATUS_GRAPHICS_MODE_NOT_PINNED __constant_cpu_to_le32(0x401E0307) 171 - #define STATUS_GRAPHICS_NO_PREFERRED_MODE __constant_cpu_to_le32(0x401E031E) 172 - #define STATUS_GRAPHICS_DATASET_IS_EMPTY __constant_cpu_to_le32(0x401E034B) 173 - #define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET __constant_cpu_to_le32(0x401E034C) 174 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED __constant_cpu_to_le32(0x401E0351) 175 - #define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS __constant_cpu_to_le32(0x401E042F) 176 - #define STATUS_GRAPHICS_LEADLINK_START_DEFERRED __constant_cpu_to_le32(0x401E0437) 177 - #define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY __constant_cpu_to_le32(0x401E0439) 178 - #define STATUS_GRAPHICS_START_DEFERRED __constant_cpu_to_le32(0x401E043A) 179 - #define STATUS_NDIS_INDICATION_REQUIRED __constant_cpu_to_le32(0x40230001) 180 - #define STATUS_GUARD_PAGE_VIOLATION __constant_cpu_to_le32(0x80000001) 181 - #define STATUS_DATATYPE_MISALIGNMENT __constant_cpu_to_le32(0x80000002) 182 - #define STATUS_BREAKPOINT __constant_cpu_to_le32(0x80000003) 183 - #define STATUS_SINGLE_STEP __constant_cpu_to_le32(0x80000004) 184 - #define STATUS_BUFFER_OVERFLOW __constant_cpu_to_le32(0x80000005) 185 - #define STATUS_NO_MORE_FILES __constant_cpu_to_le32(0x80000006) 186 - #define STATUS_WAKE_SYSTEM_DEBUGGER __constant_cpu_to_le32(0x80000007) 187 - #define STATUS_HANDLES_CLOSED __constant_cpu_to_le32(0x8000000A) 188 - #define STATUS_NO_INHERITANCE __constant_cpu_to_le32(0x8000000B) 189 - #define STATUS_GUID_SUBSTITUTION_MADE __constant_cpu_to_le32(0x8000000C) 190 - #define STATUS_PARTIAL_COPY __constant_cpu_to_le32(0x8000000D) 191 - #define STATUS_DEVICE_PAPER_EMPTY __constant_cpu_to_le32(0x8000000E) 192 - #define STATUS_DEVICE_POWERED_OFF __constant_cpu_to_le32(0x8000000F) 193 - #define STATUS_DEVICE_OFF_LINE __constant_cpu_to_le32(0x80000010) 194 - #define STATUS_DEVICE_BUSY __constant_cpu_to_le32(0x80000011) 195 - #define STATUS_NO_MORE_EAS __constant_cpu_to_le32(0x80000012) 196 - #define STATUS_INVALID_EA_NAME __constant_cpu_to_le32(0x80000013) 197 - #define STATUS_EA_LIST_INCONSISTENT __constant_cpu_to_le32(0x80000014) 198 - #define STATUS_INVALID_EA_FLAG __constant_cpu_to_le32(0x80000015) 199 - #define STATUS_VERIFY_REQUIRED __constant_cpu_to_le32(0x80000016) 200 - #define STATUS_EXTRANEOUS_INFORMATION __constant_cpu_to_le32(0x80000017) 201 - #define STATUS_RXACT_COMMIT_NECESSARY __constant_cpu_to_le32(0x80000018) 202 - #define STATUS_NO_MORE_ENTRIES __constant_cpu_to_le32(0x8000001A) 203 - #define STATUS_FILEMARK_DETECTED __constant_cpu_to_le32(0x8000001B) 204 - #define STATUS_MEDIA_CHANGED __constant_cpu_to_le32(0x8000001C) 205 - #define STATUS_BUS_RESET __constant_cpu_to_le32(0x8000001D) 206 - #define STATUS_END_OF_MEDIA __constant_cpu_to_le32(0x8000001E) 207 - #define STATUS_BEGINNING_OF_MEDIA __constant_cpu_to_le32(0x8000001F) 208 - #define STATUS_MEDIA_CHECK __constant_cpu_to_le32(0x80000020) 209 - #define STATUS_SETMARK_DETECTED __constant_cpu_to_le32(0x80000021) 210 - #define STATUS_NO_DATA_DETECTED __constant_cpu_to_le32(0x80000022) 211 - #define STATUS_REDIRECTOR_HAS_OPEN_HANDLES __constant_cpu_to_le32(0x80000023) 212 - #define STATUS_SERVER_HAS_OPEN_HANDLES __constant_cpu_to_le32(0x80000024) 213 - #define STATUS_ALREADY_DISCONNECTED __constant_cpu_to_le32(0x80000025) 214 - #define STATUS_LONGJUMP __constant_cpu_to_le32(0x80000026) 215 - #define STATUS_CLEANER_CARTRIDGE_INSTALLED __constant_cpu_to_le32(0x80000027) 216 - #define STATUS_PLUGPLAY_QUERY_VETOED __constant_cpu_to_le32(0x80000028) 217 - #define STATUS_UNWIND_CONSOLIDATE __constant_cpu_to_le32(0x80000029) 218 - #define STATUS_REGISTRY_HIVE_RECOVERED __constant_cpu_to_le32(0x8000002A) 219 - #define STATUS_DLL_MIGHT_BE_INSECURE __constant_cpu_to_le32(0x8000002B) 220 - #define STATUS_DLL_MIGHT_BE_INCOMPATIBLE __constant_cpu_to_le32(0x8000002C) 221 - #define STATUS_STOPPED_ON_SYMLINK __constant_cpu_to_le32(0x8000002D) 222 - #define STATUS_DEVICE_REQUIRES_CLEANING __constant_cpu_to_le32(0x80000288) 223 - #define STATUS_DEVICE_DOOR_OPEN __constant_cpu_to_le32(0x80000289) 224 - #define STATUS_DATA_LOST_REPAIR __constant_cpu_to_le32(0x80000803) 225 - #define DBG_EXCEPTION_NOT_HANDLED __constant_cpu_to_le32(0x80010001) 226 - #define STATUS_CLUSTER_NODE_ALREADY_UP __constant_cpu_to_le32(0x80130001) 227 - #define STATUS_CLUSTER_NODE_ALREADY_DOWN __constant_cpu_to_le32(0x80130002) 228 - #define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE __constant_cpu_to_le32(0x80130003) 229 - #define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE __constant_cpu_to_le32(0x80130004) 230 - #define STATUS_CLUSTER_NODE_ALREADY_MEMBER __constant_cpu_to_le32(0x80130005) 231 - #define STATUS_COULD_NOT_RESIZE_LOG __constant_cpu_to_le32(0x80190009) 232 - #define STATUS_NO_TXF_METADATA __constant_cpu_to_le32(0x80190029) 233 - #define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN __constant_cpu_to_le32(0x80190031) 234 - #define STATUS_TXF_METADATA_ALREADY_PRESENT __constant_cpu_to_le32(0x80190041) 235 - #define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET __constant_cpu_to_le32(0x80190042) 236 - #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED __constant_cpu_to_le32(0x801B00EB) 237 - #define STATUS_FLT_BUFFER_TOO_SMALL __constant_cpu_to_le32(0x801C0001) 238 - #define STATUS_FVE_PARTIAL_METADATA __constant_cpu_to_le32(0x80210001) 239 - #define STATUS_UNSUCCESSFUL __constant_cpu_to_le32(0xC0000001) 240 - #define STATUS_NOT_IMPLEMENTED __constant_cpu_to_le32(0xC0000002) 241 - #define STATUS_INVALID_INFO_CLASS __constant_cpu_to_le32(0xC0000003) 242 - #define STATUS_INFO_LENGTH_MISMATCH __constant_cpu_to_le32(0xC0000004) 243 - #define STATUS_ACCESS_VIOLATION __constant_cpu_to_le32(0xC0000005) 244 - #define STATUS_IN_PAGE_ERROR __constant_cpu_to_le32(0xC0000006) 245 - #define STATUS_PAGEFILE_QUOTA __constant_cpu_to_le32(0xC0000007) 246 - #define STATUS_INVALID_HANDLE __constant_cpu_to_le32(0xC0000008) 247 - #define STATUS_BAD_INITIAL_STACK __constant_cpu_to_le32(0xC0000009) 248 - #define STATUS_BAD_INITIAL_PC __constant_cpu_to_le32(0xC000000A) 249 - #define STATUS_INVALID_CID __constant_cpu_to_le32(0xC000000B) 250 - #define STATUS_TIMER_NOT_CANCELED __constant_cpu_to_le32(0xC000000C) 251 - #define STATUS_INVALID_PARAMETER __constant_cpu_to_le32(0xC000000D) 252 - #define STATUS_NO_SUCH_DEVICE __constant_cpu_to_le32(0xC000000E) 253 - #define STATUS_NO_SUCH_FILE __constant_cpu_to_le32(0xC000000F) 254 - #define STATUS_INVALID_DEVICE_REQUEST __constant_cpu_to_le32(0xC0000010) 255 - #define STATUS_END_OF_FILE __constant_cpu_to_le32(0xC0000011) 256 - #define STATUS_WRONG_VOLUME __constant_cpu_to_le32(0xC0000012) 257 - #define STATUS_NO_MEDIA_IN_DEVICE __constant_cpu_to_le32(0xC0000013) 258 - #define STATUS_UNRECOGNIZED_MEDIA __constant_cpu_to_le32(0xC0000014) 259 - #define STATUS_NONEXISTENT_SECTOR __constant_cpu_to_le32(0xC0000015) 260 - #define STATUS_MORE_PROCESSING_REQUIRED __constant_cpu_to_le32(0xC0000016) 261 - #define STATUS_NO_MEMORY __constant_cpu_to_le32(0xC0000017) 262 - #define STATUS_CONFLICTING_ADDRESSES __constant_cpu_to_le32(0xC0000018) 263 - #define STATUS_NOT_MAPPED_VIEW __constant_cpu_to_le32(0xC0000019) 264 - #define STATUS_UNABLE_TO_FREE_VM __constant_cpu_to_le32(0xC000001A) 265 - #define STATUS_UNABLE_TO_DELETE_SECTION __constant_cpu_to_le32(0xC000001B) 266 - #define STATUS_INVALID_SYSTEM_SERVICE __constant_cpu_to_le32(0xC000001C) 267 - #define STATUS_ILLEGAL_INSTRUCTION __constant_cpu_to_le32(0xC000001D) 268 - #define STATUS_INVALID_LOCK_SEQUENCE __constant_cpu_to_le32(0xC000001E) 269 - #define STATUS_INVALID_VIEW_SIZE __constant_cpu_to_le32(0xC000001F) 270 - #define STATUS_INVALID_FILE_FOR_SECTION __constant_cpu_to_le32(0xC0000020) 271 - #define STATUS_ALREADY_COMMITTED __constant_cpu_to_le32(0xC0000021) 272 - #define STATUS_ACCESS_DENIED __constant_cpu_to_le32(0xC0000022) 273 - #define STATUS_BUFFER_TOO_SMALL __constant_cpu_to_le32(0xC0000023) 274 - #define STATUS_OBJECT_TYPE_MISMATCH __constant_cpu_to_le32(0xC0000024) 275 - #define STATUS_NONCONTINUABLE_EXCEPTION __constant_cpu_to_le32(0xC0000025) 276 - #define STATUS_INVALID_DISPOSITION __constant_cpu_to_le32(0xC0000026) 277 - #define STATUS_UNWIND __constant_cpu_to_le32(0xC0000027) 278 - #define STATUS_BAD_STACK __constant_cpu_to_le32(0xC0000028) 279 - #define STATUS_INVALID_UNWIND_TARGET __constant_cpu_to_le32(0xC0000029) 280 - #define STATUS_NOT_LOCKED __constant_cpu_to_le32(0xC000002A) 281 - #define STATUS_PARITY_ERROR __constant_cpu_to_le32(0xC000002B) 282 - #define STATUS_UNABLE_TO_DECOMMIT_VM __constant_cpu_to_le32(0xC000002C) 283 - #define STATUS_NOT_COMMITTED __constant_cpu_to_le32(0xC000002D) 284 - #define STATUS_INVALID_PORT_ATTRIBUTES __constant_cpu_to_le32(0xC000002E) 285 - #define STATUS_PORT_MESSAGE_TOO_LONG __constant_cpu_to_le32(0xC000002F) 286 - #define STATUS_INVALID_PARAMETER_MIX __constant_cpu_to_le32(0xC0000030) 287 - #define STATUS_INVALID_QUOTA_LOWER __constant_cpu_to_le32(0xC0000031) 288 - #define STATUS_DISK_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000032) 289 - #define STATUS_OBJECT_NAME_INVALID __constant_cpu_to_le32(0xC0000033) 290 - #define STATUS_OBJECT_NAME_NOT_FOUND __constant_cpu_to_le32(0xC0000034) 291 - #define STATUS_OBJECT_NAME_COLLISION __constant_cpu_to_le32(0xC0000035) 292 - #define STATUS_PORT_DISCONNECTED __constant_cpu_to_le32(0xC0000037) 293 - #define STATUS_DEVICE_ALREADY_ATTACHED __constant_cpu_to_le32(0xC0000038) 294 - #define STATUS_OBJECT_PATH_INVALID __constant_cpu_to_le32(0xC0000039) 295 - #define STATUS_OBJECT_PATH_NOT_FOUND __constant_cpu_to_le32(0xC000003A) 296 - #define STATUS_OBJECT_PATH_SYNTAX_BAD __constant_cpu_to_le32(0xC000003B) 297 - #define STATUS_DATA_OVERRUN __constant_cpu_to_le32(0xC000003C) 298 - #define STATUS_DATA_LATE_ERROR __constant_cpu_to_le32(0xC000003D) 299 - #define STATUS_DATA_ERROR __constant_cpu_to_le32(0xC000003E) 300 - #define STATUS_CRC_ERROR __constant_cpu_to_le32(0xC000003F) 301 - #define STATUS_SECTION_TOO_BIG __constant_cpu_to_le32(0xC0000040) 302 - #define STATUS_PORT_CONNECTION_REFUSED __constant_cpu_to_le32(0xC0000041) 303 - #define STATUS_INVALID_PORT_HANDLE __constant_cpu_to_le32(0xC0000042) 304 - #define STATUS_SHARING_VIOLATION __constant_cpu_to_le32(0xC0000043) 305 - #define STATUS_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000044) 306 - #define STATUS_INVALID_PAGE_PROTECTION __constant_cpu_to_le32(0xC0000045) 307 - #define STATUS_MUTANT_NOT_OWNED __constant_cpu_to_le32(0xC0000046) 308 - #define STATUS_SEMAPHORE_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC0000047) 309 - #define STATUS_PORT_ALREADY_SET __constant_cpu_to_le32(0xC0000048) 310 - #define STATUS_SECTION_NOT_IMAGE __constant_cpu_to_le32(0xC0000049) 311 - #define STATUS_SUSPEND_COUNT_EXCEEDED __constant_cpu_to_le32(0xC000004A) 312 - #define STATUS_THREAD_IS_TERMINATING __constant_cpu_to_le32(0xC000004B) 313 - #define STATUS_BAD_WORKING_SET_LIMIT __constant_cpu_to_le32(0xC000004C) 314 - #define STATUS_INCOMPATIBLE_FILE_MAP __constant_cpu_to_le32(0xC000004D) 315 - #define STATUS_SECTION_PROTECTION __constant_cpu_to_le32(0xC000004E) 316 - #define STATUS_EAS_NOT_SUPPORTED __constant_cpu_to_le32(0xC000004F) 317 - #define STATUS_EA_TOO_LARGE __constant_cpu_to_le32(0xC0000050) 318 - #define STATUS_NONEXISTENT_EA_ENTRY __constant_cpu_to_le32(0xC0000051) 319 - #define STATUS_NO_EAS_ON_FILE __constant_cpu_to_le32(0xC0000052) 320 - #define STATUS_EA_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000053) 321 - #define STATUS_FILE_LOCK_CONFLICT __constant_cpu_to_le32(0xC0000054) 322 - #define STATUS_LOCK_NOT_GRANTED __constant_cpu_to_le32(0xC0000055) 323 - #define STATUS_DELETE_PENDING __constant_cpu_to_le32(0xC0000056) 324 - #define STATUS_CTL_FILE_NOT_SUPPORTED __constant_cpu_to_le32(0xC0000057) 325 - #define STATUS_UNKNOWN_REVISION __constant_cpu_to_le32(0xC0000058) 326 - #define STATUS_REVISION_MISMATCH __constant_cpu_to_le32(0xC0000059) 327 - #define STATUS_INVALID_OWNER __constant_cpu_to_le32(0xC000005A) 328 - #define STATUS_INVALID_PRIMARY_GROUP __constant_cpu_to_le32(0xC000005B) 329 - #define STATUS_NO_IMPERSONATION_TOKEN __constant_cpu_to_le32(0xC000005C) 330 - #define STATUS_CANT_DISABLE_MANDATORY __constant_cpu_to_le32(0xC000005D) 331 - #define STATUS_NO_LOGON_SERVERS __constant_cpu_to_le32(0xC000005E) 332 - #define STATUS_NO_SUCH_LOGON_SESSION __constant_cpu_to_le32(0xC000005F) 333 - #define STATUS_NO_SUCH_PRIVILEGE __constant_cpu_to_le32(0xC0000060) 334 - #define STATUS_PRIVILEGE_NOT_HELD __constant_cpu_to_le32(0xC0000061) 335 - #define STATUS_INVALID_ACCOUNT_NAME __constant_cpu_to_le32(0xC0000062) 336 - #define STATUS_USER_EXISTS __constant_cpu_to_le32(0xC0000063) 337 - #define STATUS_NO_SUCH_USER __constant_cpu_to_le32(0xC0000064) 338 - #define STATUS_GROUP_EXISTS __constant_cpu_to_le32(0xC0000065) 339 - #define STATUS_NO_SUCH_GROUP __constant_cpu_to_le32(0xC0000066) 340 - #define STATUS_MEMBER_IN_GROUP __constant_cpu_to_le32(0xC0000067) 341 - #define STATUS_MEMBER_NOT_IN_GROUP __constant_cpu_to_le32(0xC0000068) 342 - #define STATUS_LAST_ADMIN __constant_cpu_to_le32(0xC0000069) 343 - #define STATUS_WRONG_PASSWORD __constant_cpu_to_le32(0xC000006A) 344 - #define STATUS_ILL_FORMED_PASSWORD __constant_cpu_to_le32(0xC000006B) 345 - #define STATUS_PASSWORD_RESTRICTION __constant_cpu_to_le32(0xC000006C) 346 - #define STATUS_LOGON_FAILURE __constant_cpu_to_le32(0xC000006D) 347 - #define STATUS_ACCOUNT_RESTRICTION __constant_cpu_to_le32(0xC000006E) 348 - #define STATUS_INVALID_LOGON_HOURS __constant_cpu_to_le32(0xC000006F) 349 - #define STATUS_INVALID_WORKSTATION __constant_cpu_to_le32(0xC0000070) 350 - #define STATUS_PASSWORD_EXPIRED __constant_cpu_to_le32(0xC0000071) 351 - #define STATUS_ACCOUNT_DISABLED __constant_cpu_to_le32(0xC0000072) 352 - #define STATUS_NONE_MAPPED __constant_cpu_to_le32(0xC0000073) 353 - #define STATUS_TOO_MANY_LUIDS_REQUESTED __constant_cpu_to_le32(0xC0000074) 354 - #define STATUS_LUIDS_EXHAUSTED __constant_cpu_to_le32(0xC0000075) 355 - #define STATUS_INVALID_SUB_AUTHORITY __constant_cpu_to_le32(0xC0000076) 356 - #define STATUS_INVALID_ACL __constant_cpu_to_le32(0xC0000077) 357 - #define STATUS_INVALID_SID __constant_cpu_to_le32(0xC0000078) 358 - #define STATUS_INVALID_SECURITY_DESCR __constant_cpu_to_le32(0xC0000079) 359 - #define STATUS_PROCEDURE_NOT_FOUND __constant_cpu_to_le32(0xC000007A) 360 - #define STATUS_INVALID_IMAGE_FORMAT __constant_cpu_to_le32(0xC000007B) 361 - #define STATUS_NO_TOKEN __constant_cpu_to_le32(0xC000007C) 362 - #define STATUS_BAD_INHERITANCE_ACL __constant_cpu_to_le32(0xC000007D) 363 - #define STATUS_RANGE_NOT_LOCKED __constant_cpu_to_le32(0xC000007E) 364 - #define STATUS_DISK_FULL __constant_cpu_to_le32(0xC000007F) 365 - #define STATUS_SERVER_DISABLED __constant_cpu_to_le32(0xC0000080) 366 - #define STATUS_SERVER_NOT_DISABLED __constant_cpu_to_le32(0xC0000081) 367 - #define STATUS_TOO_MANY_GUIDS_REQUESTED __constant_cpu_to_le32(0xC0000082) 368 - #define STATUS_GUIDS_EXHAUSTED __constant_cpu_to_le32(0xC0000083) 369 - #define STATUS_INVALID_ID_AUTHORITY __constant_cpu_to_le32(0xC0000084) 370 - #define STATUS_AGENTS_EXHAUSTED __constant_cpu_to_le32(0xC0000085) 371 - #define STATUS_INVALID_VOLUME_LABEL __constant_cpu_to_le32(0xC0000086) 372 - #define STATUS_SECTION_NOT_EXTENDED __constant_cpu_to_le32(0xC0000087) 373 - #define STATUS_NOT_MAPPED_DATA __constant_cpu_to_le32(0xC0000088) 374 - #define STATUS_RESOURCE_DATA_NOT_FOUND __constant_cpu_to_le32(0xC0000089) 375 - #define STATUS_RESOURCE_TYPE_NOT_FOUND __constant_cpu_to_le32(0xC000008A) 376 - #define STATUS_RESOURCE_NAME_NOT_FOUND __constant_cpu_to_le32(0xC000008B) 377 - #define STATUS_ARRAY_BOUNDS_EXCEEDED __constant_cpu_to_le32(0xC000008C) 378 - #define STATUS_FLOAT_DENORMAL_OPERAND __constant_cpu_to_le32(0xC000008D) 379 - #define STATUS_FLOAT_DIVIDE_BY_ZERO __constant_cpu_to_le32(0xC000008E) 380 - #define STATUS_FLOAT_INEXACT_RESULT __constant_cpu_to_le32(0xC000008F) 381 - #define STATUS_FLOAT_INVALID_OPERATION __constant_cpu_to_le32(0xC0000090) 382 - #define STATUS_FLOAT_OVERFLOW __constant_cpu_to_le32(0xC0000091) 383 - #define STATUS_FLOAT_STACK_CHECK __constant_cpu_to_le32(0xC0000092) 384 - #define STATUS_FLOAT_UNDERFLOW __constant_cpu_to_le32(0xC0000093) 385 - #define STATUS_INTEGER_DIVIDE_BY_ZERO __constant_cpu_to_le32(0xC0000094) 386 - #define STATUS_INTEGER_OVERFLOW __constant_cpu_to_le32(0xC0000095) 387 - #define STATUS_PRIVILEGED_INSTRUCTION __constant_cpu_to_le32(0xC0000096) 388 - #define STATUS_TOO_MANY_PAGING_FILES __constant_cpu_to_le32(0xC0000097) 389 - #define STATUS_FILE_INVALID __constant_cpu_to_le32(0xC0000098) 390 - #define STATUS_ALLOTTED_SPACE_EXCEEDED __constant_cpu_to_le32(0xC0000099) 391 - #define STATUS_INSUFFICIENT_RESOURCES __constant_cpu_to_le32(0xC000009A) 392 - #define STATUS_DFS_EXIT_PATH_FOUND __constant_cpu_to_le32(0xC000009B) 393 - #define STATUS_DEVICE_DATA_ERROR __constant_cpu_to_le32(0xC000009C) 394 - #define STATUS_DEVICE_NOT_CONNECTED __constant_cpu_to_le32(0xC000009D) 395 - #define STATUS_DEVICE_POWER_FAILURE __constant_cpu_to_le32(0xC000009E) 396 - #define STATUS_FREE_VM_NOT_AT_BASE __constant_cpu_to_le32(0xC000009F) 397 - #define STATUS_MEMORY_NOT_ALLOCATED __constant_cpu_to_le32(0xC00000A0) 398 - #define STATUS_WORKING_SET_QUOTA __constant_cpu_to_le32(0xC00000A1) 399 - #define STATUS_MEDIA_WRITE_PROTECTED __constant_cpu_to_le32(0xC00000A2) 400 - #define STATUS_DEVICE_NOT_READY __constant_cpu_to_le32(0xC00000A3) 401 - #define STATUS_INVALID_GROUP_ATTRIBUTES __constant_cpu_to_le32(0xC00000A4) 402 - #define STATUS_BAD_IMPERSONATION_LEVEL __constant_cpu_to_le32(0xC00000A5) 403 - #define STATUS_CANT_OPEN_ANONYMOUS __constant_cpu_to_le32(0xC00000A6) 404 - #define STATUS_BAD_VALIDATION_CLASS __constant_cpu_to_le32(0xC00000A7) 405 - #define STATUS_BAD_TOKEN_TYPE __constant_cpu_to_le32(0xC00000A8) 406 - #define STATUS_BAD_MASTER_BOOT_RECORD __constant_cpu_to_le32(0xC00000A9) 407 - #define STATUS_INSTRUCTION_MISALIGNMENT __constant_cpu_to_le32(0xC00000AA) 408 - #define STATUS_INSTANCE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00000AB) 409 - #define STATUS_PIPE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00000AC) 410 - #define STATUS_INVALID_PIPE_STATE __constant_cpu_to_le32(0xC00000AD) 411 - #define STATUS_PIPE_BUSY __constant_cpu_to_le32(0xC00000AE) 412 - #define STATUS_ILLEGAL_FUNCTION __constant_cpu_to_le32(0xC00000AF) 413 - #define STATUS_PIPE_DISCONNECTED __constant_cpu_to_le32(0xC00000B0) 414 - #define STATUS_PIPE_CLOSING __constant_cpu_to_le32(0xC00000B1) 415 - #define STATUS_PIPE_CONNECTED __constant_cpu_to_le32(0xC00000B2) 416 - #define STATUS_PIPE_LISTENING __constant_cpu_to_le32(0xC00000B3) 417 - #define STATUS_INVALID_READ_MODE __constant_cpu_to_le32(0xC00000B4) 418 - #define STATUS_IO_TIMEOUT __constant_cpu_to_le32(0xC00000B5) 419 - #define STATUS_FILE_FORCED_CLOSED __constant_cpu_to_le32(0xC00000B6) 420 - #define STATUS_PROFILING_NOT_STARTED __constant_cpu_to_le32(0xC00000B7) 421 - #define STATUS_PROFILING_NOT_STOPPED __constant_cpu_to_le32(0xC00000B8) 422 - #define STATUS_COULD_NOT_INTERPRET __constant_cpu_to_le32(0xC00000B9) 423 - #define STATUS_FILE_IS_A_DIRECTORY __constant_cpu_to_le32(0xC00000BA) 424 - #define STATUS_NOT_SUPPORTED __constant_cpu_to_le32(0xC00000BB) 425 - #define STATUS_REMOTE_NOT_LISTENING __constant_cpu_to_le32(0xC00000BC) 426 - #define STATUS_DUPLICATE_NAME __constant_cpu_to_le32(0xC00000BD) 427 - #define STATUS_BAD_NETWORK_PATH __constant_cpu_to_le32(0xC00000BE) 428 - #define STATUS_NETWORK_BUSY __constant_cpu_to_le32(0xC00000BF) 429 - #define STATUS_DEVICE_DOES_NOT_EXIST __constant_cpu_to_le32(0xC00000C0) 430 - #define STATUS_TOO_MANY_COMMANDS __constant_cpu_to_le32(0xC00000C1) 431 - #define STATUS_ADAPTER_HARDWARE_ERROR __constant_cpu_to_le32(0xC00000C2) 432 - #define STATUS_INVALID_NETWORK_RESPONSE __constant_cpu_to_le32(0xC00000C3) 433 - #define STATUS_UNEXPECTED_NETWORK_ERROR __constant_cpu_to_le32(0xC00000C4) 434 - #define STATUS_BAD_REMOTE_ADAPTER __constant_cpu_to_le32(0xC00000C5) 435 - #define STATUS_PRINT_QUEUE_FULL __constant_cpu_to_le32(0xC00000C6) 436 - #define STATUS_NO_SPOOL_SPACE __constant_cpu_to_le32(0xC00000C7) 437 - #define STATUS_PRINT_CANCELLED __constant_cpu_to_le32(0xC00000C8) 438 - #define STATUS_NETWORK_NAME_DELETED __constant_cpu_to_le32(0xC00000C9) 439 - #define STATUS_NETWORK_ACCESS_DENIED __constant_cpu_to_le32(0xC00000CA) 440 - #define STATUS_BAD_DEVICE_TYPE __constant_cpu_to_le32(0xC00000CB) 441 - #define STATUS_BAD_NETWORK_NAME __constant_cpu_to_le32(0xC00000CC) 442 - #define STATUS_TOO_MANY_NAMES __constant_cpu_to_le32(0xC00000CD) 443 - #define STATUS_TOO_MANY_SESSIONS __constant_cpu_to_le32(0xC00000CE) 444 - #define STATUS_SHARING_PAUSED __constant_cpu_to_le32(0xC00000CF) 445 - #define STATUS_REQUEST_NOT_ACCEPTED __constant_cpu_to_le32(0xC00000D0) 446 - #define STATUS_REDIRECTOR_PAUSED __constant_cpu_to_le32(0xC00000D1) 447 - #define STATUS_NET_WRITE_FAULT __constant_cpu_to_le32(0xC00000D2) 448 - #define STATUS_PROFILING_AT_LIMIT __constant_cpu_to_le32(0xC00000D3) 449 - #define STATUS_NOT_SAME_DEVICE __constant_cpu_to_le32(0xC00000D4) 450 - #define STATUS_FILE_RENAMED __constant_cpu_to_le32(0xC00000D5) 451 - #define STATUS_VIRTUAL_CIRCUIT_CLOSED __constant_cpu_to_le32(0xC00000D6) 452 - #define STATUS_NO_SECURITY_ON_OBJECT __constant_cpu_to_le32(0xC00000D7) 453 - #define STATUS_CANT_WAIT __constant_cpu_to_le32(0xC00000D8) 454 - #define STATUS_PIPE_EMPTY __constant_cpu_to_le32(0xC00000D9) 455 - #define STATUS_CANT_ACCESS_DOMAIN_INFO __constant_cpu_to_le32(0xC00000DA) 456 - #define STATUS_CANT_TERMINATE_SELF __constant_cpu_to_le32(0xC00000DB) 457 - #define STATUS_INVALID_SERVER_STATE __constant_cpu_to_le32(0xC00000DC) 458 - #define STATUS_INVALID_DOMAIN_STATE __constant_cpu_to_le32(0xC00000DD) 459 - #define STATUS_INVALID_DOMAIN_ROLE __constant_cpu_to_le32(0xC00000DE) 460 - #define STATUS_NO_SUCH_DOMAIN __constant_cpu_to_le32(0xC00000DF) 461 - #define STATUS_DOMAIN_EXISTS __constant_cpu_to_le32(0xC00000E0) 462 - #define STATUS_DOMAIN_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC00000E1) 463 - #define STATUS_OPLOCK_NOT_GRANTED __constant_cpu_to_le32(0xC00000E2) 464 - #define STATUS_INVALID_OPLOCK_PROTOCOL __constant_cpu_to_le32(0xC00000E3) 465 - #define STATUS_INTERNAL_DB_CORRUPTION __constant_cpu_to_le32(0xC00000E4) 466 - #define STATUS_INTERNAL_ERROR __constant_cpu_to_le32(0xC00000E5) 467 - #define STATUS_GENERIC_NOT_MAPPED __constant_cpu_to_le32(0xC00000E6) 468 - #define STATUS_BAD_DESCRIPTOR_FORMAT __constant_cpu_to_le32(0xC00000E7) 469 - #define STATUS_INVALID_USER_BUFFER __constant_cpu_to_le32(0xC00000E8) 470 - #define STATUS_UNEXPECTED_IO_ERROR __constant_cpu_to_le32(0xC00000E9) 471 - #define STATUS_UNEXPECTED_MM_CREATE_ERR __constant_cpu_to_le32(0xC00000EA) 472 - #define STATUS_UNEXPECTED_MM_MAP_ERROR __constant_cpu_to_le32(0xC00000EB) 473 - #define STATUS_UNEXPECTED_MM_EXTEND_ERR __constant_cpu_to_le32(0xC00000EC) 474 - #define STATUS_NOT_LOGON_PROCESS __constant_cpu_to_le32(0xC00000ED) 475 - #define STATUS_LOGON_SESSION_EXISTS __constant_cpu_to_le32(0xC00000EE) 476 - #define STATUS_INVALID_PARAMETER_1 __constant_cpu_to_le32(0xC00000EF) 477 - #define STATUS_INVALID_PARAMETER_2 __constant_cpu_to_le32(0xC00000F0) 478 - #define STATUS_INVALID_PARAMETER_3 __constant_cpu_to_le32(0xC00000F1) 479 - #define STATUS_INVALID_PARAMETER_4 __constant_cpu_to_le32(0xC00000F2) 480 - #define STATUS_INVALID_PARAMETER_5 __constant_cpu_to_le32(0xC00000F3) 481 - #define STATUS_INVALID_PARAMETER_6 __constant_cpu_to_le32(0xC00000F4) 482 - #define STATUS_INVALID_PARAMETER_7 __constant_cpu_to_le32(0xC00000F5) 483 - #define STATUS_INVALID_PARAMETER_8 __constant_cpu_to_le32(0xC00000F6) 484 - #define STATUS_INVALID_PARAMETER_9 __constant_cpu_to_le32(0xC00000F7) 485 - #define STATUS_INVALID_PARAMETER_10 __constant_cpu_to_le32(0xC00000F8) 486 - #define STATUS_INVALID_PARAMETER_11 __constant_cpu_to_le32(0xC00000F9) 487 - #define STATUS_INVALID_PARAMETER_12 __constant_cpu_to_le32(0xC00000FA) 488 - #define STATUS_REDIRECTOR_NOT_STARTED __constant_cpu_to_le32(0xC00000FB) 489 - #define STATUS_REDIRECTOR_STARTED __constant_cpu_to_le32(0xC00000FC) 490 - #define STATUS_STACK_OVERFLOW __constant_cpu_to_le32(0xC00000FD) 491 - #define STATUS_NO_SUCH_PACKAGE __constant_cpu_to_le32(0xC00000FE) 492 - #define STATUS_BAD_FUNCTION_TABLE __constant_cpu_to_le32(0xC00000FF) 493 - #define STATUS_VARIABLE_NOT_FOUND __constant_cpu_to_le32(0xC0000100) 494 - #define STATUS_DIRECTORY_NOT_EMPTY __constant_cpu_to_le32(0xC0000101) 495 - #define STATUS_FILE_CORRUPT_ERROR __constant_cpu_to_le32(0xC0000102) 496 - #define STATUS_NOT_A_DIRECTORY __constant_cpu_to_le32(0xC0000103) 497 - #define STATUS_BAD_LOGON_SESSION_STATE __constant_cpu_to_le32(0xC0000104) 498 - #define STATUS_LOGON_SESSION_COLLISION __constant_cpu_to_le32(0xC0000105) 499 - #define STATUS_NAME_TOO_LONG __constant_cpu_to_le32(0xC0000106) 500 - #define STATUS_FILES_OPEN __constant_cpu_to_le32(0xC0000107) 501 - #define STATUS_CONNECTION_IN_USE __constant_cpu_to_le32(0xC0000108) 502 - #define STATUS_MESSAGE_NOT_FOUND __constant_cpu_to_le32(0xC0000109) 503 - #define STATUS_PROCESS_IS_TERMINATING __constant_cpu_to_le32(0xC000010A) 504 - #define STATUS_INVALID_LOGON_TYPE __constant_cpu_to_le32(0xC000010B) 505 - #define STATUS_NO_GUID_TRANSLATION __constant_cpu_to_le32(0xC000010C) 506 - #define STATUS_CANNOT_IMPERSONATE __constant_cpu_to_le32(0xC000010D) 507 - #define STATUS_IMAGE_ALREADY_LOADED __constant_cpu_to_le32(0xC000010E) 508 - #define STATUS_ABIOS_NOT_PRESENT __constant_cpu_to_le32(0xC000010F) 509 - #define STATUS_ABIOS_LID_NOT_EXIST __constant_cpu_to_le32(0xC0000110) 510 - #define STATUS_ABIOS_LID_ALREADY_OWNED __constant_cpu_to_le32(0xC0000111) 511 - #define STATUS_ABIOS_NOT_LID_OWNER __constant_cpu_to_le32(0xC0000112) 512 - #define STATUS_ABIOS_INVALID_COMMAND __constant_cpu_to_le32(0xC0000113) 513 - #define STATUS_ABIOS_INVALID_LID __constant_cpu_to_le32(0xC0000114) 514 - #define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE __constant_cpu_to_le32(0xC0000115) 515 - #define STATUS_ABIOS_INVALID_SELECTOR __constant_cpu_to_le32(0xC0000116) 516 - #define STATUS_NO_LDT __constant_cpu_to_le32(0xC0000117) 517 - #define STATUS_INVALID_LDT_SIZE __constant_cpu_to_le32(0xC0000118) 518 - #define STATUS_INVALID_LDT_OFFSET __constant_cpu_to_le32(0xC0000119) 519 - #define STATUS_INVALID_LDT_DESCRIPTOR __constant_cpu_to_le32(0xC000011A) 520 - #define STATUS_INVALID_IMAGE_NE_FORMAT __constant_cpu_to_le32(0xC000011B) 521 - #define STATUS_RXACT_INVALID_STATE __constant_cpu_to_le32(0xC000011C) 522 - #define STATUS_RXACT_COMMIT_FAILURE __constant_cpu_to_le32(0xC000011D) 523 - #define STATUS_MAPPED_FILE_SIZE_ZERO __constant_cpu_to_le32(0xC000011E) 524 - #define STATUS_TOO_MANY_OPENED_FILES __constant_cpu_to_le32(0xC000011F) 525 - #define STATUS_CANCELLED __constant_cpu_to_le32(0xC0000120) 526 - #define STATUS_CANNOT_DELETE __constant_cpu_to_le32(0xC0000121) 527 - #define STATUS_INVALID_COMPUTER_NAME __constant_cpu_to_le32(0xC0000122) 528 - #define STATUS_FILE_DELETED __constant_cpu_to_le32(0xC0000123) 529 - #define STATUS_SPECIAL_ACCOUNT __constant_cpu_to_le32(0xC0000124) 530 - #define STATUS_SPECIAL_GROUP __constant_cpu_to_le32(0xC0000125) 531 - #define STATUS_SPECIAL_USER __constant_cpu_to_le32(0xC0000126) 532 - #define STATUS_MEMBERS_PRIMARY_GROUP __constant_cpu_to_le32(0xC0000127) 533 - #define STATUS_FILE_CLOSED __constant_cpu_to_le32(0xC0000128) 534 - #define STATUS_TOO_MANY_THREADS __constant_cpu_to_le32(0xC0000129) 535 - #define STATUS_THREAD_NOT_IN_PROCESS __constant_cpu_to_le32(0xC000012A) 536 - #define STATUS_TOKEN_ALREADY_IN_USE __constant_cpu_to_le32(0xC000012B) 537 - #define STATUS_PAGEFILE_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC000012C) 538 - #define STATUS_COMMITMENT_LIMIT __constant_cpu_to_le32(0xC000012D) 539 - #define STATUS_INVALID_IMAGE_LE_FORMAT __constant_cpu_to_le32(0xC000012E) 540 - #define STATUS_INVALID_IMAGE_NOT_MZ __constant_cpu_to_le32(0xC000012F) 541 - #define STATUS_INVALID_IMAGE_PROTECT __constant_cpu_to_le32(0xC0000130) 542 - #define STATUS_INVALID_IMAGE_WIN_16 __constant_cpu_to_le32(0xC0000131) 543 - #define STATUS_LOGON_SERVER_CONFLICT __constant_cpu_to_le32(0xC0000132) 544 - #define STATUS_TIME_DIFFERENCE_AT_DC __constant_cpu_to_le32(0xC0000133) 545 - #define STATUS_SYNCHRONIZATION_REQUIRED __constant_cpu_to_le32(0xC0000134) 546 - #define STATUS_DLL_NOT_FOUND __constant_cpu_to_le32(0xC0000135) 547 - #define STATUS_OPEN_FAILED __constant_cpu_to_le32(0xC0000136) 548 - #define STATUS_IO_PRIVILEGE_FAILED __constant_cpu_to_le32(0xC0000137) 549 - #define STATUS_ORDINAL_NOT_FOUND __constant_cpu_to_le32(0xC0000138) 550 - #define STATUS_ENTRYPOINT_NOT_FOUND __constant_cpu_to_le32(0xC0000139) 551 - #define STATUS_CONTROL_C_EXIT __constant_cpu_to_le32(0xC000013A) 552 - #define STATUS_LOCAL_DISCONNECT __constant_cpu_to_le32(0xC000013B) 553 - #define STATUS_REMOTE_DISCONNECT __constant_cpu_to_le32(0xC000013C) 554 - #define STATUS_REMOTE_RESOURCES __constant_cpu_to_le32(0xC000013D) 555 - #define STATUS_LINK_FAILED __constant_cpu_to_le32(0xC000013E) 556 - #define STATUS_LINK_TIMEOUT __constant_cpu_to_le32(0xC000013F) 557 - #define STATUS_INVALID_CONNECTION __constant_cpu_to_le32(0xC0000140) 558 - #define STATUS_INVALID_ADDRESS __constant_cpu_to_le32(0xC0000141) 559 - #define STATUS_DLL_INIT_FAILED __constant_cpu_to_le32(0xC0000142) 560 - #define STATUS_MISSING_SYSTEMFILE __constant_cpu_to_le32(0xC0000143) 561 - #define STATUS_UNHANDLED_EXCEPTION __constant_cpu_to_le32(0xC0000144) 562 - #define STATUS_APP_INIT_FAILURE __constant_cpu_to_le32(0xC0000145) 563 - #define STATUS_PAGEFILE_CREATE_FAILED __constant_cpu_to_le32(0xC0000146) 564 - #define STATUS_NO_PAGEFILE __constant_cpu_to_le32(0xC0000147) 565 - #define STATUS_INVALID_LEVEL __constant_cpu_to_le32(0xC0000148) 566 - #define STATUS_WRONG_PASSWORD_CORE __constant_cpu_to_le32(0xC0000149) 567 - #define STATUS_ILLEGAL_FLOAT_CONTEXT __constant_cpu_to_le32(0xC000014A) 568 - #define STATUS_PIPE_BROKEN __constant_cpu_to_le32(0xC000014B) 569 - #define STATUS_REGISTRY_CORRUPT __constant_cpu_to_le32(0xC000014C) 570 - #define STATUS_REGISTRY_IO_FAILED __constant_cpu_to_le32(0xC000014D) 571 - #define STATUS_NO_EVENT_PAIR __constant_cpu_to_le32(0xC000014E) 572 - #define STATUS_UNRECOGNIZED_VOLUME __constant_cpu_to_le32(0xC000014F) 573 - #define STATUS_SERIAL_NO_DEVICE_INITED __constant_cpu_to_le32(0xC0000150) 574 - #define STATUS_NO_SUCH_ALIAS __constant_cpu_to_le32(0xC0000151) 575 - #define STATUS_MEMBER_NOT_IN_ALIAS __constant_cpu_to_le32(0xC0000152) 576 - #define STATUS_MEMBER_IN_ALIAS __constant_cpu_to_le32(0xC0000153) 577 - #define STATUS_ALIAS_EXISTS __constant_cpu_to_le32(0xC0000154) 578 - #define STATUS_LOGON_NOT_GRANTED __constant_cpu_to_le32(0xC0000155) 579 - #define STATUS_TOO_MANY_SECRETS __constant_cpu_to_le32(0xC0000156) 580 - #define STATUS_SECRET_TOO_LONG __constant_cpu_to_le32(0xC0000157) 581 - #define STATUS_INTERNAL_DB_ERROR __constant_cpu_to_le32(0xC0000158) 582 - #define STATUS_FULLSCREEN_MODE __constant_cpu_to_le32(0xC0000159) 583 - #define STATUS_TOO_MANY_CONTEXT_IDS __constant_cpu_to_le32(0xC000015A) 584 - #define STATUS_LOGON_TYPE_NOT_GRANTED __constant_cpu_to_le32(0xC000015B) 585 - #define STATUS_NOT_REGISTRY_FILE __constant_cpu_to_le32(0xC000015C) 586 - #define STATUS_NT_CROSS_ENCRYPTION_REQUIRED __constant_cpu_to_le32(0xC000015D) 587 - #define STATUS_DOMAIN_CTRLR_CONFIG_ERROR __constant_cpu_to_le32(0xC000015E) 588 - #define STATUS_FT_MISSING_MEMBER __constant_cpu_to_le32(0xC000015F) 589 - #define STATUS_ILL_FORMED_SERVICE_ENTRY __constant_cpu_to_le32(0xC0000160) 590 - #define STATUS_ILLEGAL_CHARACTER __constant_cpu_to_le32(0xC0000161) 591 - #define STATUS_UNMAPPABLE_CHARACTER __constant_cpu_to_le32(0xC0000162) 592 - #define STATUS_UNDEFINED_CHARACTER __constant_cpu_to_le32(0xC0000163) 593 - #define STATUS_FLOPPY_VOLUME __constant_cpu_to_le32(0xC0000164) 594 - #define STATUS_FLOPPY_ID_MARK_NOT_FOUND __constant_cpu_to_le32(0xC0000165) 595 - #define STATUS_FLOPPY_WRONG_CYLINDER __constant_cpu_to_le32(0xC0000166) 596 - #define STATUS_FLOPPY_UNKNOWN_ERROR __constant_cpu_to_le32(0xC0000167) 597 - #define STATUS_FLOPPY_BAD_REGISTERS __constant_cpu_to_le32(0xC0000168) 598 - #define STATUS_DISK_RECALIBRATE_FAILED __constant_cpu_to_le32(0xC0000169) 599 - #define STATUS_DISK_OPERATION_FAILED __constant_cpu_to_le32(0xC000016A) 600 - #define STATUS_DISK_RESET_FAILED __constant_cpu_to_le32(0xC000016B) 601 - #define STATUS_SHARED_IRQ_BUSY __constant_cpu_to_le32(0xC000016C) 602 - #define STATUS_FT_ORPHANING __constant_cpu_to_le32(0xC000016D) 603 - #define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT __constant_cpu_to_le32(0xC000016E) 604 - #define STATUS_PARTITION_FAILURE __constant_cpu_to_le32(0xC0000172) 605 - #define STATUS_INVALID_BLOCK_LENGTH __constant_cpu_to_le32(0xC0000173) 606 - #define STATUS_DEVICE_NOT_PARTITIONED __constant_cpu_to_le32(0xC0000174) 607 - #define STATUS_UNABLE_TO_LOCK_MEDIA __constant_cpu_to_le32(0xC0000175) 608 - #define STATUS_UNABLE_TO_UNLOAD_MEDIA __constant_cpu_to_le32(0xC0000176) 609 - #define STATUS_EOM_OVERFLOW __constant_cpu_to_le32(0xC0000177) 610 - #define STATUS_NO_MEDIA __constant_cpu_to_le32(0xC0000178) 611 - #define STATUS_NO_SUCH_MEMBER __constant_cpu_to_le32(0xC000017A) 612 - #define STATUS_INVALID_MEMBER __constant_cpu_to_le32(0xC000017B) 613 - #define STATUS_KEY_DELETED __constant_cpu_to_le32(0xC000017C) 614 - #define STATUS_NO_LOG_SPACE __constant_cpu_to_le32(0xC000017D) 615 - #define STATUS_TOO_MANY_SIDS __constant_cpu_to_le32(0xC000017E) 616 - #define STATUS_LM_CROSS_ENCRYPTION_REQUIRED __constant_cpu_to_le32(0xC000017F) 617 - #define STATUS_KEY_HAS_CHILDREN __constant_cpu_to_le32(0xC0000180) 618 - #define STATUS_CHILD_MUST_BE_VOLATILE __constant_cpu_to_le32(0xC0000181) 619 - #define STATUS_DEVICE_CONFIGURATION_ERROR __constant_cpu_to_le32(0xC0000182) 620 - #define STATUS_DRIVER_INTERNAL_ERROR __constant_cpu_to_le32(0xC0000183) 621 - #define STATUS_INVALID_DEVICE_STATE __constant_cpu_to_le32(0xC0000184) 622 - #define STATUS_IO_DEVICE_ERROR __constant_cpu_to_le32(0xC0000185) 623 - #define STATUS_DEVICE_PROTOCOL_ERROR __constant_cpu_to_le32(0xC0000186) 624 - #define STATUS_BACKUP_CONTROLLER __constant_cpu_to_le32(0xC0000187) 625 - #define STATUS_LOG_FILE_FULL __constant_cpu_to_le32(0xC0000188) 626 - #define STATUS_TOO_LATE __constant_cpu_to_le32(0xC0000189) 627 - #define STATUS_NO_TRUST_LSA_SECRET __constant_cpu_to_le32(0xC000018A) 628 - #define STATUS_NO_TRUST_SAM_ACCOUNT __constant_cpu_to_le32(0xC000018B) 629 - #define STATUS_TRUSTED_DOMAIN_FAILURE __constant_cpu_to_le32(0xC000018C) 630 - #define STATUS_TRUSTED_RELATIONSHIP_FAILURE __constant_cpu_to_le32(0xC000018D) 631 - #define STATUS_EVENTLOG_FILE_CORRUPT __constant_cpu_to_le32(0xC000018E) 632 - #define STATUS_EVENTLOG_CANT_START __constant_cpu_to_le32(0xC000018F) 633 - #define STATUS_TRUST_FAILURE __constant_cpu_to_le32(0xC0000190) 634 - #define STATUS_MUTANT_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC0000191) 635 - #define STATUS_NETLOGON_NOT_STARTED __constant_cpu_to_le32(0xC0000192) 636 - #define STATUS_ACCOUNT_EXPIRED __constant_cpu_to_le32(0xC0000193) 637 - #define STATUS_POSSIBLE_DEADLOCK __constant_cpu_to_le32(0xC0000194) 638 - #define STATUS_NETWORK_CREDENTIAL_CONFLICT __constant_cpu_to_le32(0xC0000195) 639 - #define STATUS_REMOTE_SESSION_LIMIT __constant_cpu_to_le32(0xC0000196) 640 - #define STATUS_EVENTLOG_FILE_CHANGED __constant_cpu_to_le32(0xC0000197) 641 - #define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT __constant_cpu_to_le32(0xC0000198) 642 - #define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT __constant_cpu_to_le32(0xC0000199) 643 - #define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT __constant_cpu_to_le32(0xC000019A) 644 - #define STATUS_DOMAIN_TRUST_INCONSISTENT __constant_cpu_to_le32(0xC000019B) 645 - #define STATUS_FS_DRIVER_REQUIRED __constant_cpu_to_le32(0xC000019C) 646 - #define STATUS_IMAGE_ALREADY_LOADED_AS_DLL __constant_cpu_to_le32(0xC000019D) 647 - #define STATUS_NETWORK_OPEN_RESTRICTION __constant_cpu_to_le32(0xC0000201) 648 - #define STATUS_NO_USER_SESSION_KEY __constant_cpu_to_le32(0xC0000202) 649 - #define STATUS_USER_SESSION_DELETED __constant_cpu_to_le32(0xC0000203) 650 - #define STATUS_RESOURCE_LANG_NOT_FOUND __constant_cpu_to_le32(0xC0000204) 651 - #define STATUS_INSUFF_SERVER_RESOURCES __constant_cpu_to_le32(0xC0000205) 652 - #define STATUS_INVALID_BUFFER_SIZE __constant_cpu_to_le32(0xC0000206) 653 - #define STATUS_INVALID_ADDRESS_COMPONENT __constant_cpu_to_le32(0xC0000207) 654 - #define STATUS_INVALID_ADDRESS_WILDCARD __constant_cpu_to_le32(0xC0000208) 655 - #define STATUS_TOO_MANY_ADDRESSES __constant_cpu_to_le32(0xC0000209) 656 - #define STATUS_ADDRESS_ALREADY_EXISTS __constant_cpu_to_le32(0xC000020A) 657 - #define STATUS_ADDRESS_CLOSED __constant_cpu_to_le32(0xC000020B) 658 - #define STATUS_CONNECTION_DISCONNECTED __constant_cpu_to_le32(0xC000020C) 659 - #define STATUS_CONNECTION_RESET __constant_cpu_to_le32(0xC000020D) 660 - #define STATUS_TOO_MANY_NODES __constant_cpu_to_le32(0xC000020E) 661 - #define STATUS_TRANSACTION_ABORTED __constant_cpu_to_le32(0xC000020F) 662 - #define STATUS_TRANSACTION_TIMED_OUT __constant_cpu_to_le32(0xC0000210) 663 - #define STATUS_TRANSACTION_NO_RELEASE __constant_cpu_to_le32(0xC0000211) 664 - #define STATUS_TRANSACTION_NO_MATCH __constant_cpu_to_le32(0xC0000212) 665 - #define STATUS_TRANSACTION_RESPONDED __constant_cpu_to_le32(0xC0000213) 666 - #define STATUS_TRANSACTION_INVALID_ID __constant_cpu_to_le32(0xC0000214) 667 - #define STATUS_TRANSACTION_INVALID_TYPE __constant_cpu_to_le32(0xC0000215) 668 - #define STATUS_NOT_SERVER_SESSION __constant_cpu_to_le32(0xC0000216) 669 - #define STATUS_NOT_CLIENT_SESSION __constant_cpu_to_le32(0xC0000217) 670 - #define STATUS_CANNOT_LOAD_REGISTRY_FILE __constant_cpu_to_le32(0xC0000218) 671 - #define STATUS_DEBUG_ATTACH_FAILED __constant_cpu_to_le32(0xC0000219) 672 - #define STATUS_SYSTEM_PROCESS_TERMINATED __constant_cpu_to_le32(0xC000021A) 673 - #define STATUS_DATA_NOT_ACCEPTED __constant_cpu_to_le32(0xC000021B) 674 - #define STATUS_NO_BROWSER_SERVERS_FOUND __constant_cpu_to_le32(0xC000021C) 675 - #define STATUS_VDM_HARD_ERROR __constant_cpu_to_le32(0xC000021D) 676 - #define STATUS_DRIVER_CANCEL_TIMEOUT __constant_cpu_to_le32(0xC000021E) 677 - #define STATUS_REPLY_MESSAGE_MISMATCH __constant_cpu_to_le32(0xC000021F) 678 - #define STATUS_MAPPED_ALIGNMENT __constant_cpu_to_le32(0xC0000220) 679 - #define STATUS_IMAGE_CHECKSUM_MISMATCH __constant_cpu_to_le32(0xC0000221) 680 - #define STATUS_LOST_WRITEBEHIND_DATA __constant_cpu_to_le32(0xC0000222) 681 - #define STATUS_CLIENT_SERVER_PARAMETERS_INVALID __constant_cpu_to_le32(0xC0000223) 682 - #define STATUS_PASSWORD_MUST_CHANGE __constant_cpu_to_le32(0xC0000224) 683 - #define STATUS_NOT_FOUND __constant_cpu_to_le32(0xC0000225) 684 - #define STATUS_NOT_TINY_STREAM __constant_cpu_to_le32(0xC0000226) 685 - #define STATUS_RECOVERY_FAILURE __constant_cpu_to_le32(0xC0000227) 686 - #define STATUS_STACK_OVERFLOW_READ __constant_cpu_to_le32(0xC0000228) 687 - #define STATUS_FAIL_CHECK __constant_cpu_to_le32(0xC0000229) 688 - #define STATUS_DUPLICATE_OBJECTID __constant_cpu_to_le32(0xC000022A) 689 - #define STATUS_OBJECTID_EXISTS __constant_cpu_to_le32(0xC000022B) 690 - #define STATUS_CONVERT_TO_LARGE __constant_cpu_to_le32(0xC000022C) 691 - #define STATUS_RETRY __constant_cpu_to_le32(0xC000022D) 692 - #define STATUS_FOUND_OUT_OF_SCOPE __constant_cpu_to_le32(0xC000022E) 693 - #define STATUS_ALLOCATE_BUCKET __constant_cpu_to_le32(0xC000022F) 694 - #define STATUS_PROPSET_NOT_FOUND __constant_cpu_to_le32(0xC0000230) 695 - #define STATUS_MARSHALL_OVERFLOW __constant_cpu_to_le32(0xC0000231) 696 - #define STATUS_INVALID_VARIANT __constant_cpu_to_le32(0xC0000232) 697 - #define STATUS_DOMAIN_CONTROLLER_NOT_FOUND __constant_cpu_to_le32(0xC0000233) 698 - #define STATUS_ACCOUNT_LOCKED_OUT __constant_cpu_to_le32(0xC0000234) 699 - #define STATUS_HANDLE_NOT_CLOSABLE __constant_cpu_to_le32(0xC0000235) 700 - #define STATUS_CONNECTION_REFUSED __constant_cpu_to_le32(0xC0000236) 701 - #define STATUS_GRACEFUL_DISCONNECT __constant_cpu_to_le32(0xC0000237) 702 - #define STATUS_ADDRESS_ALREADY_ASSOCIATED __constant_cpu_to_le32(0xC0000238) 703 - #define STATUS_ADDRESS_NOT_ASSOCIATED __constant_cpu_to_le32(0xC0000239) 704 - #define STATUS_CONNECTION_INVALID __constant_cpu_to_le32(0xC000023A) 705 - #define STATUS_CONNECTION_ACTIVE __constant_cpu_to_le32(0xC000023B) 706 - #define STATUS_NETWORK_UNREACHABLE __constant_cpu_to_le32(0xC000023C) 707 - #define STATUS_HOST_UNREACHABLE __constant_cpu_to_le32(0xC000023D) 708 - #define STATUS_PROTOCOL_UNREACHABLE __constant_cpu_to_le32(0xC000023E) 709 - #define STATUS_PORT_UNREACHABLE __constant_cpu_to_le32(0xC000023F) 710 - #define STATUS_REQUEST_ABORTED __constant_cpu_to_le32(0xC0000240) 711 - #define STATUS_CONNECTION_ABORTED __constant_cpu_to_le32(0xC0000241) 712 - #define STATUS_BAD_COMPRESSION_BUFFER __constant_cpu_to_le32(0xC0000242) 713 - #define STATUS_USER_MAPPED_FILE __constant_cpu_to_le32(0xC0000243) 714 - #define STATUS_AUDIT_FAILED __constant_cpu_to_le32(0xC0000244) 715 - #define STATUS_TIMER_RESOLUTION_NOT_SET __constant_cpu_to_le32(0xC0000245) 716 - #define STATUS_CONNECTION_COUNT_LIMIT __constant_cpu_to_le32(0xC0000246) 717 - #define STATUS_LOGIN_TIME_RESTRICTION __constant_cpu_to_le32(0xC0000247) 718 - #define STATUS_LOGIN_WKSTA_RESTRICTION __constant_cpu_to_le32(0xC0000248) 719 - #define STATUS_IMAGE_MP_UP_MISMATCH __constant_cpu_to_le32(0xC0000249) 720 - #define STATUS_INSUFFICIENT_LOGON_INFO __constant_cpu_to_le32(0xC0000250) 721 - #define STATUS_BAD_DLL_ENTRYPOINT __constant_cpu_to_le32(0xC0000251) 722 - #define STATUS_BAD_SERVICE_ENTRYPOINT __constant_cpu_to_le32(0xC0000252) 723 - #define STATUS_LPC_REPLY_LOST __constant_cpu_to_le32(0xC0000253) 724 - #define STATUS_IP_ADDRESS_CONFLICT1 __constant_cpu_to_le32(0xC0000254) 725 - #define STATUS_IP_ADDRESS_CONFLICT2 __constant_cpu_to_le32(0xC0000255) 726 - #define STATUS_REGISTRY_QUOTA_LIMIT __constant_cpu_to_le32(0xC0000256) 727 - #define STATUS_PATH_NOT_COVERED __constant_cpu_to_le32(0xC0000257) 728 - #define STATUS_NO_CALLBACK_ACTIVE __constant_cpu_to_le32(0xC0000258) 729 - #define STATUS_LICENSE_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000259) 730 - #define STATUS_PWD_TOO_SHORT __constant_cpu_to_le32(0xC000025A) 731 - #define STATUS_PWD_TOO_RECENT __constant_cpu_to_le32(0xC000025B) 732 - #define STATUS_PWD_HISTORY_CONFLICT __constant_cpu_to_le32(0xC000025C) 733 - #define STATUS_PLUGPLAY_NO_DEVICE __constant_cpu_to_le32(0xC000025E) 734 - #define STATUS_UNSUPPORTED_COMPRESSION __constant_cpu_to_le32(0xC000025F) 735 - #define STATUS_INVALID_HW_PROFILE __constant_cpu_to_le32(0xC0000260) 736 - #define STATUS_INVALID_PLUGPLAY_DEVICE_PATH __constant_cpu_to_le32(0xC0000261) 737 - #define STATUS_DRIVER_ORDINAL_NOT_FOUND __constant_cpu_to_le32(0xC0000262) 738 - #define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND __constant_cpu_to_le32(0xC0000263) 739 - #define STATUS_RESOURCE_NOT_OWNED __constant_cpu_to_le32(0xC0000264) 740 - #define STATUS_TOO_MANY_LINKS __constant_cpu_to_le32(0xC0000265) 741 - #define STATUS_QUOTA_LIST_INCONSISTENT __constant_cpu_to_le32(0xC0000266) 742 - #define STATUS_FILE_IS_OFFLINE __constant_cpu_to_le32(0xC0000267) 743 - #define STATUS_EVALUATION_EXPIRATION __constant_cpu_to_le32(0xC0000268) 744 - #define STATUS_ILLEGAL_DLL_RELOCATION __constant_cpu_to_le32(0xC0000269) 745 - #define STATUS_LICENSE_VIOLATION __constant_cpu_to_le32(0xC000026A) 746 - #define STATUS_DLL_INIT_FAILED_LOGOFF __constant_cpu_to_le32(0xC000026B) 747 - #define STATUS_DRIVER_UNABLE_TO_LOAD __constant_cpu_to_le32(0xC000026C) 748 - #define STATUS_DFS_UNAVAILABLE __constant_cpu_to_le32(0xC000026D) 749 - #define STATUS_VOLUME_DISMOUNTED __constant_cpu_to_le32(0xC000026E) 750 - #define STATUS_WX86_INTERNAL_ERROR __constant_cpu_to_le32(0xC000026F) 751 - #define STATUS_WX86_FLOAT_STACK_CHECK __constant_cpu_to_le32(0xC0000270) 752 - #define STATUS_VALIDATE_CONTINUE __constant_cpu_to_le32(0xC0000271) 753 - #define STATUS_NO_MATCH __constant_cpu_to_le32(0xC0000272) 754 - #define STATUS_NO_MORE_MATCHES __constant_cpu_to_le32(0xC0000273) 755 - #define STATUS_NOT_A_REPARSE_POINT __constant_cpu_to_le32(0xC0000275) 756 - #define STATUS_IO_REPARSE_TAG_INVALID __constant_cpu_to_le32(0xC0000276) 757 - #define STATUS_IO_REPARSE_TAG_MISMATCH __constant_cpu_to_le32(0xC0000277) 758 - #define STATUS_IO_REPARSE_DATA_INVALID __constant_cpu_to_le32(0xC0000278) 759 - #define STATUS_IO_REPARSE_TAG_NOT_HANDLED __constant_cpu_to_le32(0xC0000279) 760 - #define STATUS_REPARSE_POINT_NOT_RESOLVED __constant_cpu_to_le32(0xC0000280) 761 - #define STATUS_DIRECTORY_IS_A_REPARSE_POINT __constant_cpu_to_le32(0xC0000281) 762 - #define STATUS_RANGE_LIST_CONFLICT __constant_cpu_to_le32(0xC0000282) 763 - #define STATUS_SOURCE_ELEMENT_EMPTY __constant_cpu_to_le32(0xC0000283) 764 - #define STATUS_DESTINATION_ELEMENT_FULL __constant_cpu_to_le32(0xC0000284) 765 - #define STATUS_ILLEGAL_ELEMENT_ADDRESS __constant_cpu_to_le32(0xC0000285) 766 - #define STATUS_MAGAZINE_NOT_PRESENT __constant_cpu_to_le32(0xC0000286) 767 - #define STATUS_REINITIALIZATION_NEEDED __constant_cpu_to_le32(0xC0000287) 768 - #define STATUS_ENCRYPTION_FAILED __constant_cpu_to_le32(0xC000028A) 769 - #define STATUS_DECRYPTION_FAILED __constant_cpu_to_le32(0xC000028B) 770 - #define STATUS_RANGE_NOT_FOUND __constant_cpu_to_le32(0xC000028C) 771 - #define STATUS_NO_RECOVERY_POLICY __constant_cpu_to_le32(0xC000028D) 772 - #define STATUS_NO_EFS __constant_cpu_to_le32(0xC000028E) 773 - #define STATUS_WRONG_EFS __constant_cpu_to_le32(0xC000028F) 774 - #define STATUS_NO_USER_KEYS __constant_cpu_to_le32(0xC0000290) 775 - #define STATUS_FILE_NOT_ENCRYPTED __constant_cpu_to_le32(0xC0000291) 776 - #define STATUS_NOT_EXPORT_FORMAT __constant_cpu_to_le32(0xC0000292) 777 - #define STATUS_FILE_ENCRYPTED __constant_cpu_to_le32(0xC0000293) 778 - #define STATUS_WMI_GUID_NOT_FOUND __constant_cpu_to_le32(0xC0000295) 779 - #define STATUS_WMI_INSTANCE_NOT_FOUND __constant_cpu_to_le32(0xC0000296) 780 - #define STATUS_WMI_ITEMID_NOT_FOUND __constant_cpu_to_le32(0xC0000297) 781 - #define STATUS_WMI_TRY_AGAIN __constant_cpu_to_le32(0xC0000298) 782 - #define STATUS_SHARED_POLICY __constant_cpu_to_le32(0xC0000299) 783 - #define STATUS_POLICY_OBJECT_NOT_FOUND __constant_cpu_to_le32(0xC000029A) 784 - #define STATUS_POLICY_ONLY_IN_DS __constant_cpu_to_le32(0xC000029B) 785 - #define STATUS_VOLUME_NOT_UPGRADED __constant_cpu_to_le32(0xC000029C) 786 - #define STATUS_REMOTE_STORAGE_NOT_ACTIVE __constant_cpu_to_le32(0xC000029D) 787 - #define STATUS_REMOTE_STORAGE_MEDIA_ERROR __constant_cpu_to_le32(0xC000029E) 788 - #define STATUS_NO_TRACKING_SERVICE __constant_cpu_to_le32(0xC000029F) 789 - #define STATUS_SERVER_SID_MISMATCH __constant_cpu_to_le32(0xC00002A0) 790 - #define STATUS_DS_NO_ATTRIBUTE_OR_VALUE __constant_cpu_to_le32(0xC00002A1) 791 - #define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX __constant_cpu_to_le32(0xC00002A2) 792 - #define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED __constant_cpu_to_le32(0xC00002A3) 793 - #define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS __constant_cpu_to_le32(0xC00002A4) 794 - #define STATUS_DS_BUSY __constant_cpu_to_le32(0xC00002A5) 795 - #define STATUS_DS_UNAVAILABLE __constant_cpu_to_le32(0xC00002A6) 796 - #define STATUS_DS_NO_RIDS_ALLOCATED __constant_cpu_to_le32(0xC00002A7) 797 - #define STATUS_DS_NO_MORE_RIDS __constant_cpu_to_le32(0xC00002A8) 798 - #define STATUS_DS_INCORRECT_ROLE_OWNER __constant_cpu_to_le32(0xC00002A9) 799 - #define STATUS_DS_RIDMGR_INIT_ERROR __constant_cpu_to_le32(0xC00002AA) 800 - #define STATUS_DS_OBJ_CLASS_VIOLATION __constant_cpu_to_le32(0xC00002AB) 801 - #define STATUS_DS_CANT_ON_NON_LEAF __constant_cpu_to_le32(0xC00002AC) 802 - #define STATUS_DS_CANT_ON_RDN __constant_cpu_to_le32(0xC00002AD) 803 - #define STATUS_DS_CANT_MOD_OBJ_CLASS __constant_cpu_to_le32(0xC00002AE) 804 - #define STATUS_DS_CROSS_DOM_MOVE_FAILED __constant_cpu_to_le32(0xC00002AF) 805 - #define STATUS_DS_GC_NOT_AVAILABLE __constant_cpu_to_le32(0xC00002B0) 806 - #define STATUS_DIRECTORY_SERVICE_REQUIRED __constant_cpu_to_le32(0xC00002B1) 807 - #define STATUS_REPARSE_ATTRIBUTE_CONFLICT __constant_cpu_to_le32(0xC00002B2) 808 - #define STATUS_CANT_ENABLE_DENY_ONLY __constant_cpu_to_le32(0xC00002B3) 809 - #define STATUS_FLOAT_MULTIPLE_FAULTS __constant_cpu_to_le32(0xC00002B4) 810 - #define STATUS_FLOAT_MULTIPLE_TRAPS __constant_cpu_to_le32(0xC00002B5) 811 - #define STATUS_DEVICE_REMOVED __constant_cpu_to_le32(0xC00002B6) 812 - #define STATUS_JOURNAL_DELETE_IN_PROGRESS __constant_cpu_to_le32(0xC00002B7) 813 - #define STATUS_JOURNAL_NOT_ACTIVE __constant_cpu_to_le32(0xC00002B8) 814 - #define STATUS_NOINTERFACE __constant_cpu_to_le32(0xC00002B9) 815 - #define STATUS_DS_ADMIN_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC00002C1) 816 - #define STATUS_DRIVER_FAILED_SLEEP __constant_cpu_to_le32(0xC00002C2) 817 - #define STATUS_MUTUAL_AUTHENTICATION_FAILED __constant_cpu_to_le32(0xC00002C3) 818 - #define STATUS_CORRUPT_SYSTEM_FILE __constant_cpu_to_le32(0xC00002C4) 819 - #define STATUS_DATATYPE_MISALIGNMENT_ERROR __constant_cpu_to_le32(0xC00002C5) 820 - #define STATUS_WMI_READ_ONLY __constant_cpu_to_le32(0xC00002C6) 821 - #define STATUS_WMI_SET_FAILURE __constant_cpu_to_le32(0xC00002C7) 822 - #define STATUS_COMMITMENT_MINIMUM __constant_cpu_to_le32(0xC00002C8) 823 - #define STATUS_REG_NAT_CONSUMPTION __constant_cpu_to_le32(0xC00002C9) 824 - #define STATUS_TRANSPORT_FULL __constant_cpu_to_le32(0xC00002CA) 825 - #define STATUS_DS_SAM_INIT_FAILURE __constant_cpu_to_le32(0xC00002CB) 826 - #define STATUS_ONLY_IF_CONNECTED __constant_cpu_to_le32(0xC00002CC) 827 - #define STATUS_DS_SENSITIVE_GROUP_VIOLATION __constant_cpu_to_le32(0xC00002CD) 828 - #define STATUS_PNP_RESTART_ENUMERATION __constant_cpu_to_le32(0xC00002CE) 829 - #define STATUS_JOURNAL_ENTRY_DELETED __constant_cpu_to_le32(0xC00002CF) 830 - #define STATUS_DS_CANT_MOD_PRIMARYGROUPID __constant_cpu_to_le32(0xC00002D0) 831 - #define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE __constant_cpu_to_le32(0xC00002D1) 832 - #define STATUS_PNP_REBOOT_REQUIRED __constant_cpu_to_le32(0xC00002D2) 833 - #define STATUS_POWER_STATE_INVALID __constant_cpu_to_le32(0xC00002D3) 834 - #define STATUS_DS_INVALID_GROUP_TYPE __constant_cpu_to_le32(0xC00002D4) 835 - #define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN __constant_cpu_to_le32(0xC00002D5) 836 - #define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN __constant_cpu_to_le32(0xC00002D6) 837 - #define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002D7) 838 - #define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER __constant_cpu_to_le32(0xC00002D8) 839 - #define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002D9) 840 - #define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER __constant_cpu_to_le32(0xC00002DA) 841 - #define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER __constant_cpu_to_le32(0xC00002DB) 842 - #define STATUS_DS_HAVE_PRIMARY_MEMBERS __constant_cpu_to_le32(0xC00002DC) 843 - #define STATUS_WMI_NOT_SUPPORTED __constant_cpu_to_le32(0xC00002DD) 844 - #define STATUS_INSUFFICIENT_POWER __constant_cpu_to_le32(0xC00002DE) 845 - #define STATUS_SAM_NEED_BOOTKEY_PASSWORD __constant_cpu_to_le32(0xC00002DF) 846 - #define STATUS_SAM_NEED_BOOTKEY_FLOPPY __constant_cpu_to_le32(0xC00002E0) 847 - #define STATUS_DS_CANT_START __constant_cpu_to_le32(0xC00002E1) 848 - #define STATUS_DS_INIT_FAILURE __constant_cpu_to_le32(0xC00002E2) 849 - #define STATUS_SAM_INIT_FAILURE __constant_cpu_to_le32(0xC00002E3) 850 - #define STATUS_DS_GC_REQUIRED __constant_cpu_to_le32(0xC00002E4) 851 - #define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY __constant_cpu_to_le32(0xC00002E5) 852 - #define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS __constant_cpu_to_le32(0xC00002E6) 853 - #define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC00002E7) 854 - #define STATUS_MULTIPLE_FAULT_VIOLATION __constant_cpu_to_le32(0xC00002E8) 855 - #define STATUS_CURRENT_DOMAIN_NOT_ALLOWED __constant_cpu_to_le32(0xC00002E9) 856 - #define STATUS_CANNOT_MAKE __constant_cpu_to_le32(0xC00002EA) 857 - #define STATUS_SYSTEM_SHUTDOWN __constant_cpu_to_le32(0xC00002EB) 858 - #define STATUS_DS_INIT_FAILURE_CONSOLE __constant_cpu_to_le32(0xC00002EC) 859 - #define STATUS_DS_SAM_INIT_FAILURE_CONSOLE __constant_cpu_to_le32(0xC00002ED) 860 - #define STATUS_UNFINISHED_CONTEXT_DELETED __constant_cpu_to_le32(0xC00002EE) 861 - #define STATUS_NO_TGT_REPLY __constant_cpu_to_le32(0xC00002EF) 862 - #define STATUS_OBJECTID_NOT_FOUND __constant_cpu_to_le32(0xC00002F0) 863 - #define STATUS_NO_IP_ADDRESSES __constant_cpu_to_le32(0xC00002F1) 864 - #define STATUS_WRONG_CREDENTIAL_HANDLE __constant_cpu_to_le32(0xC00002F2) 865 - #define STATUS_CRYPTO_SYSTEM_INVALID __constant_cpu_to_le32(0xC00002F3) 866 - #define STATUS_MAX_REFERRALS_EXCEEDED __constant_cpu_to_le32(0xC00002F4) 867 - #define STATUS_MUST_BE_KDC __constant_cpu_to_le32(0xC00002F5) 868 - #define STATUS_STRONG_CRYPTO_NOT_SUPPORTED __constant_cpu_to_le32(0xC00002F6) 869 - #define STATUS_TOO_MANY_PRINCIPALS __constant_cpu_to_le32(0xC00002F7) 870 - #define STATUS_NO_PA_DATA __constant_cpu_to_le32(0xC00002F8) 871 - #define STATUS_PKINIT_NAME_MISMATCH __constant_cpu_to_le32(0xC00002F9) 872 - #define STATUS_SMARTCARD_LOGON_REQUIRED __constant_cpu_to_le32(0xC00002FA) 873 - #define STATUS_KDC_INVALID_REQUEST __constant_cpu_to_le32(0xC00002FB) 874 - #define STATUS_KDC_UNABLE_TO_REFER __constant_cpu_to_le32(0xC00002FC) 875 - #define STATUS_KDC_UNKNOWN_ETYPE __constant_cpu_to_le32(0xC00002FD) 876 - #define STATUS_SHUTDOWN_IN_PROGRESS __constant_cpu_to_le32(0xC00002FE) 877 - #define STATUS_SERVER_SHUTDOWN_IN_PROGRESS __constant_cpu_to_le32(0xC00002FF) 878 - #define STATUS_NOT_SUPPORTED_ON_SBS __constant_cpu_to_le32(0xC0000300) 879 - #define STATUS_WMI_GUID_DISCONNECTED __constant_cpu_to_le32(0xC0000301) 880 - #define STATUS_WMI_ALREADY_DISABLED __constant_cpu_to_le32(0xC0000302) 881 - #define STATUS_WMI_ALREADY_ENABLED __constant_cpu_to_le32(0xC0000303) 882 - #define STATUS_MFT_TOO_FRAGMENTED __constant_cpu_to_le32(0xC0000304) 883 - #define STATUS_COPY_PROTECTION_FAILURE __constant_cpu_to_le32(0xC0000305) 884 - #define STATUS_CSS_AUTHENTICATION_FAILURE __constant_cpu_to_le32(0xC0000306) 885 - #define STATUS_CSS_KEY_NOT_PRESENT __constant_cpu_to_le32(0xC0000307) 886 - #define STATUS_CSS_KEY_NOT_ESTABLISHED __constant_cpu_to_le32(0xC0000308) 887 - #define STATUS_CSS_SCRAMBLED_SECTOR __constant_cpu_to_le32(0xC0000309) 888 - #define STATUS_CSS_REGION_MISMATCH __constant_cpu_to_le32(0xC000030A) 889 - #define STATUS_CSS_RESETS_EXHAUSTED __constant_cpu_to_le32(0xC000030B) 890 - #define STATUS_PKINIT_FAILURE __constant_cpu_to_le32(0xC0000320) 891 - #define STATUS_SMARTCARD_SUBSYSTEM_FAILURE __constant_cpu_to_le32(0xC0000321) 892 - #define STATUS_NO_KERB_KEY __constant_cpu_to_le32(0xC0000322) 893 - #define STATUS_HOST_DOWN __constant_cpu_to_le32(0xC0000350) 894 - #define STATUS_UNSUPPORTED_PREAUTH __constant_cpu_to_le32(0xC0000351) 895 - #define STATUS_EFS_ALG_BLOB_TOO_BIG __constant_cpu_to_le32(0xC0000352) 896 - #define STATUS_PORT_NOT_SET __constant_cpu_to_le32(0xC0000353) 897 - #define STATUS_DEBUGGER_INACTIVE __constant_cpu_to_le32(0xC0000354) 898 - #define STATUS_DS_VERSION_CHECK_FAILURE __constant_cpu_to_le32(0xC0000355) 899 - #define STATUS_AUDITING_DISABLED __constant_cpu_to_le32(0xC0000356) 900 - #define STATUS_PRENT4_MACHINE_ACCOUNT __constant_cpu_to_le32(0xC0000357) 901 - #define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER __constant_cpu_to_le32(0xC0000358) 902 - #define STATUS_INVALID_IMAGE_WIN_32 __constant_cpu_to_le32(0xC0000359) 903 - #define STATUS_INVALID_IMAGE_WIN_64 __constant_cpu_to_le32(0xC000035A) 904 - #define STATUS_BAD_BINDINGS __constant_cpu_to_le32(0xC000035B) 905 - #define STATUS_NETWORK_SESSION_EXPIRED __constant_cpu_to_le32(0xC000035C) 906 - #define STATUS_APPHELP_BLOCK __constant_cpu_to_le32(0xC000035D) 907 - #define STATUS_ALL_SIDS_FILTERED __constant_cpu_to_le32(0xC000035E) 908 - #define STATUS_NOT_SAFE_MODE_DRIVER __constant_cpu_to_le32(0xC000035F) 909 - #define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT __constant_cpu_to_le32(0xC0000361) 910 - #define STATUS_ACCESS_DISABLED_BY_POLICY_PATH __constant_cpu_to_le32(0xC0000362) 911 - #define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER __constant_cpu_to_le32(0xC0000363) 912 - #define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER __constant_cpu_to_le32(0xC0000364) 913 - #define STATUS_FAILED_DRIVER_ENTRY __constant_cpu_to_le32(0xC0000365) 914 - #define STATUS_DEVICE_ENUMERATION_ERROR __constant_cpu_to_le32(0xC0000366) 915 - #define STATUS_MOUNT_POINT_NOT_RESOLVED __constant_cpu_to_le32(0xC0000368) 916 - #define STATUS_INVALID_DEVICE_OBJECT_PARAMETER __constant_cpu_to_le32(0xC0000369) 917 - #define STATUS_MCA_OCCURED __constant_cpu_to_le32(0xC000036A) 918 - #define STATUS_DRIVER_BLOCKED_CRITICAL __constant_cpu_to_le32(0xC000036B) 919 - #define STATUS_DRIVER_BLOCKED __constant_cpu_to_le32(0xC000036C) 920 - #define STATUS_DRIVER_DATABASE_ERROR __constant_cpu_to_le32(0xC000036D) 921 - #define STATUS_SYSTEM_HIVE_TOO_LARGE __constant_cpu_to_le32(0xC000036E) 922 - #define STATUS_INVALID_IMPORT_OF_NON_DLL __constant_cpu_to_le32(0xC000036F) 923 - #define STATUS_NO_SECRETS __constant_cpu_to_le32(0xC0000371) 924 - #define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY __constant_cpu_to_le32(0xC0000372) 925 - #define STATUS_FAILED_STACK_SWITCH __constant_cpu_to_le32(0xC0000373) 926 - #define STATUS_HEAP_CORRUPTION __constant_cpu_to_le32(0xC0000374) 927 - #define STATUS_SMARTCARD_WRONG_PIN __constant_cpu_to_le32(0xC0000380) 928 - #define STATUS_SMARTCARD_CARD_BLOCKED __constant_cpu_to_le32(0xC0000381) 929 - #define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED __constant_cpu_to_le32(0xC0000382) 930 - #define STATUS_SMARTCARD_NO_CARD __constant_cpu_to_le32(0xC0000383) 931 - #define STATUS_SMARTCARD_NO_KEY_CONTAINER __constant_cpu_to_le32(0xC0000384) 932 - #define STATUS_SMARTCARD_NO_CERTIFICATE __constant_cpu_to_le32(0xC0000385) 933 - #define STATUS_SMARTCARD_NO_KEYSET __constant_cpu_to_le32(0xC0000386) 934 - #define STATUS_SMARTCARD_IO_ERROR __constant_cpu_to_le32(0xC0000387) 935 - #define STATUS_DOWNGRADE_DETECTED __constant_cpu_to_le32(0xC0000388) 936 - #define STATUS_SMARTCARD_CERT_REVOKED __constant_cpu_to_le32(0xC0000389) 937 - #define STATUS_ISSUING_CA_UNTRUSTED __constant_cpu_to_le32(0xC000038A) 938 - #define STATUS_REVOCATION_OFFLINE_C __constant_cpu_to_le32(0xC000038B) 939 - #define STATUS_PKINIT_CLIENT_FAILURE __constant_cpu_to_le32(0xC000038C) 940 - #define STATUS_SMARTCARD_CERT_EXPIRED __constant_cpu_to_le32(0xC000038D) 941 - #define STATUS_DRIVER_FAILED_PRIOR_UNLOAD __constant_cpu_to_le32(0xC000038E) 942 - #define STATUS_SMARTCARD_SILENT_CONTEXT __constant_cpu_to_le32(0xC000038F) 943 - #define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000401) 944 - #define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000402) 945 - #define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000403) 946 - #define STATUS_DS_NAME_NOT_UNIQUE __constant_cpu_to_le32(0xC0000404) 947 - #define STATUS_DS_DUPLICATE_ID_FOUND __constant_cpu_to_le32(0xC0000405) 948 - #define STATUS_DS_GROUP_CONVERSION_ERROR __constant_cpu_to_le32(0xC0000406) 949 - #define STATUS_VOLSNAP_PREPARE_HIBERNATE __constant_cpu_to_le32(0xC0000407) 950 - #define STATUS_USER2USER_REQUIRED __constant_cpu_to_le32(0xC0000408) 951 - #define STATUS_STACK_BUFFER_OVERRUN __constant_cpu_to_le32(0xC0000409) 952 - #define STATUS_NO_S4U_PROT_SUPPORT __constant_cpu_to_le32(0xC000040A) 953 - #define STATUS_CROSSREALM_DELEGATION_FAILURE __constant_cpu_to_le32(0xC000040B) 954 - #define STATUS_REVOCATION_OFFLINE_KDC __constant_cpu_to_le32(0xC000040C) 955 - #define STATUS_ISSUING_CA_UNTRUSTED_KDC __constant_cpu_to_le32(0xC000040D) 956 - #define STATUS_KDC_CERT_EXPIRED __constant_cpu_to_le32(0xC000040E) 957 - #define STATUS_KDC_CERT_REVOKED __constant_cpu_to_le32(0xC000040F) 958 - #define STATUS_PARAMETER_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000410) 959 - #define STATUS_HIBERNATION_FAILURE __constant_cpu_to_le32(0xC0000411) 960 - #define STATUS_DELAY_LOAD_FAILED __constant_cpu_to_le32(0xC0000412) 961 - #define STATUS_AUTHENTICATION_FIREWALL_FAILED __constant_cpu_to_le32(0xC0000413) 962 - #define STATUS_VDM_DISALLOWED __constant_cpu_to_le32(0xC0000414) 963 - #define STATUS_HUNG_DISPLAY_DRIVER_THREAD __constant_cpu_to_le32(0xC0000415) 964 - #define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE __constant_cpu_to_le32(0xC0000416) 965 - #define STATUS_INVALID_CRUNTIME_PARAMETER __constant_cpu_to_le32(0xC0000417) 966 - #define STATUS_NTLM_BLOCKED __constant_cpu_to_le32(0xC0000418) 967 - #define STATUS_ASSERTION_FAILURE __constant_cpu_to_le32(0xC0000420) 968 - #define STATUS_VERIFIER_STOP __constant_cpu_to_le32(0xC0000421) 969 - #define STATUS_CALLBACK_POP_STACK __constant_cpu_to_le32(0xC0000423) 970 - #define STATUS_INCOMPATIBLE_DRIVER_BLOCKED __constant_cpu_to_le32(0xC0000424) 971 - #define STATUS_HIVE_UNLOADED __constant_cpu_to_le32(0xC0000425) 972 - #define STATUS_COMPRESSION_DISABLED __constant_cpu_to_le32(0xC0000426) 973 - #define STATUS_FILE_SYSTEM_LIMITATION __constant_cpu_to_le32(0xC0000427) 974 - #define STATUS_INVALID_IMAGE_HASH __constant_cpu_to_le32(0xC0000428) 975 - #define STATUS_NOT_CAPABLE __constant_cpu_to_le32(0xC0000429) 976 - #define STATUS_REQUEST_OUT_OF_SEQUENCE __constant_cpu_to_le32(0xC000042A) 977 - #define STATUS_IMPLEMENTATION_LIMIT __constant_cpu_to_le32(0xC000042B) 978 - #define STATUS_ELEVATION_REQUIRED __constant_cpu_to_le32(0xC000042C) 979 - #define STATUS_BEYOND_VDL __constant_cpu_to_le32(0xC0000432) 980 - #define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS __constant_cpu_to_le32(0xC0000433) 981 - #define STATUS_PTE_CHANGED __constant_cpu_to_le32(0xC0000434) 982 - #define STATUS_PURGE_FAILED __constant_cpu_to_le32(0xC0000435) 983 - #define STATUS_CRED_REQUIRES_CONFIRMATION __constant_cpu_to_le32(0xC0000440) 984 - #define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE __constant_cpu_to_le32(0xC0000441) 985 - #define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER __constant_cpu_to_le32(0xC0000442) 986 - #define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE __constant_cpu_to_le32(0xC0000443) 987 - #define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE __constant_cpu_to_le32(0xC0000444) 988 - #define STATUS_CS_ENCRYPTION_FILE_NOT_CSE __constant_cpu_to_le32(0xC0000445) 989 - #define STATUS_INVALID_LABEL __constant_cpu_to_le32(0xC0000446) 990 - #define STATUS_DRIVER_PROCESS_TERMINATED __constant_cpu_to_le32(0xC0000450) 991 - #define STATUS_AMBIGUOUS_SYSTEM_DEVICE __constant_cpu_to_le32(0xC0000451) 992 - #define STATUS_SYSTEM_DEVICE_NOT_FOUND __constant_cpu_to_le32(0xC0000452) 993 - #define STATUS_RESTART_BOOT_APPLICATION __constant_cpu_to_le32(0xC0000453) 994 - #define STATUS_INVALID_TASK_NAME __constant_cpu_to_le32(0xC0000500) 995 - #define STATUS_INVALID_TASK_INDEX __constant_cpu_to_le32(0xC0000501) 996 - #define STATUS_THREAD_ALREADY_IN_TASK __constant_cpu_to_le32(0xC0000502) 997 - #define STATUS_CALLBACK_BYPASS __constant_cpu_to_le32(0xC0000503) 998 - #define STATUS_PORT_CLOSED __constant_cpu_to_le32(0xC0000700) 999 - #define STATUS_MESSAGE_LOST __constant_cpu_to_le32(0xC0000701) 1000 - #define STATUS_INVALID_MESSAGE __constant_cpu_to_le32(0xC0000702) 1001 - #define STATUS_REQUEST_CANCELED __constant_cpu_to_le32(0xC0000703) 1002 - #define STATUS_RECURSIVE_DISPATCH __constant_cpu_to_le32(0xC0000704) 1003 - #define STATUS_LPC_RECEIVE_BUFFER_EXPECTED __constant_cpu_to_le32(0xC0000705) 1004 - #define STATUS_LPC_INVALID_CONNECTION_USAGE __constant_cpu_to_le32(0xC0000706) 1005 - #define STATUS_LPC_REQUESTS_NOT_ALLOWED __constant_cpu_to_le32(0xC0000707) 1006 - #define STATUS_RESOURCE_IN_USE __constant_cpu_to_le32(0xC0000708) 1007 - #define STATUS_HARDWARE_MEMORY_ERROR __constant_cpu_to_le32(0xC0000709) 1008 - #define STATUS_THREADPOOL_HANDLE_EXCEPTION __constant_cpu_to_le32(0xC000070A) 1009 - #define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070B) 1010 - #define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070C) 1011 - #define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070D) 1012 - #define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED __constant_cpu_to_le32(0xC000070E) 1013 - #define STATUS_THREADPOOL_RELEASED_DURING_OPERATION __constant_cpu_to_le32(0xC000070F) 1014 - #define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING __constant_cpu_to_le32(0xC0000710) 1015 - #define STATUS_APC_RETURNED_WHILE_IMPERSONATING __constant_cpu_to_le32(0xC0000711) 1016 - #define STATUS_PROCESS_IS_PROTECTED __constant_cpu_to_le32(0xC0000712) 1017 - #define STATUS_MCA_EXCEPTION __constant_cpu_to_le32(0xC0000713) 1018 - #define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE __constant_cpu_to_le32(0xC0000714) 1019 - #define STATUS_SYMLINK_CLASS_DISABLED __constant_cpu_to_le32(0xC0000715) 1020 - #define STATUS_INVALID_IDN_NORMALIZATION __constant_cpu_to_le32(0xC0000716) 1021 - #define STATUS_NO_UNICODE_TRANSLATION __constant_cpu_to_le32(0xC0000717) 1022 - #define STATUS_ALREADY_REGISTERED __constant_cpu_to_le32(0xC0000718) 1023 - #define STATUS_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0000719) 1024 - #define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST __constant_cpu_to_le32(0xC000071A) 1025 - #define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY __constant_cpu_to_le32(0xC000071B) 1026 - #define STATUS_INVALID_THREAD __constant_cpu_to_le32(0xC000071C) 1027 - #define STATUS_CALLBACK_RETURNED_TRANSACTION __constant_cpu_to_le32(0xC000071D) 1028 - #define STATUS_CALLBACK_RETURNED_LDR_LOCK __constant_cpu_to_le32(0xC000071E) 1029 - #define STATUS_CALLBACK_RETURNED_LANG __constant_cpu_to_le32(0xC000071F) 1030 - #define STATUS_CALLBACK_RETURNED_PRI_BACK __constant_cpu_to_le32(0xC0000720) 1031 - #define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY __constant_cpu_to_le32(0xC0000721) 1032 - #define STATUS_DISK_REPAIR_DISABLED __constant_cpu_to_le32(0xC0000800) 1033 - #define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS __constant_cpu_to_le32(0xC0000801) 1034 - #define STATUS_DISK_QUOTA_EXCEEDED __constant_cpu_to_le32(0xC0000802) 1035 - #define STATUS_CONTENT_BLOCKED __constant_cpu_to_le32(0xC0000804) 1036 - #define STATUS_BAD_CLUSTERS __constant_cpu_to_le32(0xC0000805) 1037 - #define STATUS_VOLUME_DIRTY __constant_cpu_to_le32(0xC0000806) 1038 - #define STATUS_FILE_CHECKED_OUT __constant_cpu_to_le32(0xC0000901) 1039 - #define STATUS_CHECKOUT_REQUIRED __constant_cpu_to_le32(0xC0000902) 1040 - #define STATUS_BAD_FILE_TYPE __constant_cpu_to_le32(0xC0000903) 1041 - #define STATUS_FILE_TOO_LARGE __constant_cpu_to_le32(0xC0000904) 1042 - #define STATUS_FORMS_AUTH_REQUIRED __constant_cpu_to_le32(0xC0000905) 1043 - #define STATUS_VIRUS_INFECTED __constant_cpu_to_le32(0xC0000906) 1044 - #define STATUS_VIRUS_DELETED __constant_cpu_to_le32(0xC0000907) 1045 - #define STATUS_BAD_MCFG_TABLE __constant_cpu_to_le32(0xC0000908) 1046 - #define STATUS_WOW_ASSERTION __constant_cpu_to_le32(0xC0009898) 1047 - #define STATUS_INVALID_SIGNATURE __constant_cpu_to_le32(0xC000A000) 1048 - #define STATUS_HMAC_NOT_SUPPORTED __constant_cpu_to_le32(0xC000A001) 1049 - #define STATUS_IPSEC_QUEUE_OVERFLOW __constant_cpu_to_le32(0xC000A010) 1050 - #define STATUS_ND_QUEUE_OVERFLOW __constant_cpu_to_le32(0xC000A011) 1051 - #define STATUS_HOPLIMIT_EXCEEDED __constant_cpu_to_le32(0xC000A012) 1052 - #define STATUS_PROTOCOL_NOT_SUPPORTED __constant_cpu_to_le32(0xC000A013) 1053 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED __constant_cpu_to_le32(0xC000A080) 1054 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR __constant_cpu_to_le32(0xC000A081) 1055 - #define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR __constant_cpu_to_le32(0xC000A082) 1056 - #define STATUS_XML_PARSE_ERROR __constant_cpu_to_le32(0xC000A083) 1057 - #define STATUS_XMLDSIG_ERROR __constant_cpu_to_le32(0xC000A084) 1058 - #define STATUS_WRONG_COMPARTMENT __constant_cpu_to_le32(0xC000A085) 1059 - #define STATUS_AUTHIP_FAILURE __constant_cpu_to_le32(0xC000A086) 1060 - #define DBG_NO_STATE_CHANGE __constant_cpu_to_le32(0xC0010001) 1061 - #define DBG_APP_NOT_IDLE __constant_cpu_to_le32(0xC0010002) 1062 - #define RPC_NT_INVALID_STRING_BINDING __constant_cpu_to_le32(0xC0020001) 1063 - #define RPC_NT_WRONG_KIND_OF_BINDING __constant_cpu_to_le32(0xC0020002) 1064 - #define RPC_NT_INVALID_BINDING __constant_cpu_to_le32(0xC0020003) 1065 - #define RPC_NT_PROTSEQ_NOT_SUPPORTED __constant_cpu_to_le32(0xC0020004) 1066 - #define RPC_NT_INVALID_RPC_PROTSEQ __constant_cpu_to_le32(0xC0020005) 1067 - #define RPC_NT_INVALID_STRING_UUID __constant_cpu_to_le32(0xC0020006) 1068 - #define RPC_NT_INVALID_ENDPOINT_FORMAT __constant_cpu_to_le32(0xC0020007) 1069 - #define RPC_NT_INVALID_NET_ADDR __constant_cpu_to_le32(0xC0020008) 1070 - #define RPC_NT_NO_ENDPOINT_FOUND __constant_cpu_to_le32(0xC0020009) 1071 - #define RPC_NT_INVALID_TIMEOUT __constant_cpu_to_le32(0xC002000A) 1072 - #define RPC_NT_OBJECT_NOT_FOUND __constant_cpu_to_le32(0xC002000B) 1073 - #define RPC_NT_ALREADY_REGISTERED __constant_cpu_to_le32(0xC002000C) 1074 - #define RPC_NT_TYPE_ALREADY_REGISTERED __constant_cpu_to_le32(0xC002000D) 1075 - #define RPC_NT_ALREADY_LISTENING __constant_cpu_to_le32(0xC002000E) 1076 - #define RPC_NT_NO_PROTSEQS_REGISTERED __constant_cpu_to_le32(0xC002000F) 1077 - #define RPC_NT_NOT_LISTENING __constant_cpu_to_le32(0xC0020010) 1078 - #define RPC_NT_UNKNOWN_MGR_TYPE __constant_cpu_to_le32(0xC0020011) 1079 - #define RPC_NT_UNKNOWN_IF __constant_cpu_to_le32(0xC0020012) 1080 - #define RPC_NT_NO_BINDINGS __constant_cpu_to_le32(0xC0020013) 1081 - #define RPC_NT_NO_PROTSEQS __constant_cpu_to_le32(0xC0020014) 1082 - #define RPC_NT_CANT_CREATE_ENDPOINT __constant_cpu_to_le32(0xC0020015) 1083 - #define RPC_NT_OUT_OF_RESOURCES __constant_cpu_to_le32(0xC0020016) 1084 - #define RPC_NT_SERVER_UNAVAILABLE __constant_cpu_to_le32(0xC0020017) 1085 - #define RPC_NT_SERVER_TOO_BUSY __constant_cpu_to_le32(0xC0020018) 1086 - #define RPC_NT_INVALID_NETWORK_OPTIONS __constant_cpu_to_le32(0xC0020019) 1087 - #define RPC_NT_NO_CALL_ACTIVE __constant_cpu_to_le32(0xC002001A) 1088 - #define RPC_NT_CALL_FAILED __constant_cpu_to_le32(0xC002001B) 1089 - #define RPC_NT_CALL_FAILED_DNE __constant_cpu_to_le32(0xC002001C) 1090 - #define RPC_NT_PROTOCOL_ERROR __constant_cpu_to_le32(0xC002001D) 1091 - #define RPC_NT_UNSUPPORTED_TRANS_SYN __constant_cpu_to_le32(0xC002001F) 1092 - #define RPC_NT_UNSUPPORTED_TYPE __constant_cpu_to_le32(0xC0020021) 1093 - #define RPC_NT_INVALID_TAG __constant_cpu_to_le32(0xC0020022) 1094 - #define RPC_NT_INVALID_BOUND __constant_cpu_to_le32(0xC0020023) 1095 - #define RPC_NT_NO_ENTRY_NAME __constant_cpu_to_le32(0xC0020024) 1096 - #define RPC_NT_INVALID_NAME_SYNTAX __constant_cpu_to_le32(0xC0020025) 1097 - #define RPC_NT_UNSUPPORTED_NAME_SYNTAX __constant_cpu_to_le32(0xC0020026) 1098 - #define RPC_NT_UUID_NO_ADDRESS __constant_cpu_to_le32(0xC0020028) 1099 - #define RPC_NT_DUPLICATE_ENDPOINT __constant_cpu_to_le32(0xC0020029) 1100 - #define RPC_NT_UNKNOWN_AUTHN_TYPE __constant_cpu_to_le32(0xC002002A) 1101 - #define RPC_NT_MAX_CALLS_TOO_SMALL __constant_cpu_to_le32(0xC002002B) 1102 - #define RPC_NT_STRING_TOO_LONG __constant_cpu_to_le32(0xC002002C) 1103 - #define RPC_NT_PROTSEQ_NOT_FOUND __constant_cpu_to_le32(0xC002002D) 1104 - #define RPC_NT_PROCNUM_OUT_OF_RANGE __constant_cpu_to_le32(0xC002002E) 1105 - #define RPC_NT_BINDING_HAS_NO_AUTH __constant_cpu_to_le32(0xC002002F) 1106 - #define RPC_NT_UNKNOWN_AUTHN_SERVICE __constant_cpu_to_le32(0xC0020030) 1107 - #define RPC_NT_UNKNOWN_AUTHN_LEVEL __constant_cpu_to_le32(0xC0020031) 1108 - #define RPC_NT_INVALID_AUTH_IDENTITY __constant_cpu_to_le32(0xC0020032) 1109 - #define RPC_NT_UNKNOWN_AUTHZ_SERVICE __constant_cpu_to_le32(0xC0020033) 1110 - #define EPT_NT_INVALID_ENTRY __constant_cpu_to_le32(0xC0020034) 1111 - #define EPT_NT_CANT_PERFORM_OP __constant_cpu_to_le32(0xC0020035) 1112 - #define EPT_NT_NOT_REGISTERED __constant_cpu_to_le32(0xC0020036) 1113 - #define RPC_NT_NOTHING_TO_EXPORT __constant_cpu_to_le32(0xC0020037) 1114 - #define RPC_NT_INCOMPLETE_NAME __constant_cpu_to_le32(0xC0020038) 1115 - #define RPC_NT_INVALID_VERS_OPTION __constant_cpu_to_le32(0xC0020039) 1116 - #define RPC_NT_NO_MORE_MEMBERS __constant_cpu_to_le32(0xC002003A) 1117 - #define RPC_NT_NOT_ALL_OBJS_UNEXPORTED __constant_cpu_to_le32(0xC002003B) 1118 - #define RPC_NT_INTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC002003C) 1119 - #define RPC_NT_ENTRY_ALREADY_EXISTS __constant_cpu_to_le32(0xC002003D) 1120 - #define RPC_NT_ENTRY_NOT_FOUND __constant_cpu_to_le32(0xC002003E) 1121 - #define RPC_NT_NAME_SERVICE_UNAVAILABLE __constant_cpu_to_le32(0xC002003F) 1122 - #define RPC_NT_INVALID_NAF_ID __constant_cpu_to_le32(0xC0020040) 1123 - #define RPC_NT_CANNOT_SUPPORT __constant_cpu_to_le32(0xC0020041) 1124 - #define RPC_NT_NO_CONTEXT_AVAILABLE __constant_cpu_to_le32(0xC0020042) 1125 - #define RPC_NT_INTERNAL_ERROR __constant_cpu_to_le32(0xC0020043) 1126 - #define RPC_NT_ZERO_DIVIDE __constant_cpu_to_le32(0xC0020044) 1127 - #define RPC_NT_ADDRESS_ERROR __constant_cpu_to_le32(0xC0020045) 1128 - #define RPC_NT_FP_DIV_ZERO __constant_cpu_to_le32(0xC0020046) 1129 - #define RPC_NT_FP_UNDERFLOW __constant_cpu_to_le32(0xC0020047) 1130 - #define RPC_NT_FP_OVERFLOW __constant_cpu_to_le32(0xC0020048) 1131 - #define RPC_NT_CALL_IN_PROGRESS __constant_cpu_to_le32(0xC0020049) 1132 - #define RPC_NT_NO_MORE_BINDINGS __constant_cpu_to_le32(0xC002004A) 1133 - #define RPC_NT_GROUP_MEMBER_NOT_FOUND __constant_cpu_to_le32(0xC002004B) 1134 - #define EPT_NT_CANT_CREATE __constant_cpu_to_le32(0xC002004C) 1135 - #define RPC_NT_INVALID_OBJECT __constant_cpu_to_le32(0xC002004D) 1136 - #define RPC_NT_NO_INTERFACES __constant_cpu_to_le32(0xC002004F) 1137 - #define RPC_NT_CALL_CANCELLED __constant_cpu_to_le32(0xC0020050) 1138 - #define RPC_NT_BINDING_INCOMPLETE __constant_cpu_to_le32(0xC0020051) 1139 - #define RPC_NT_COMM_FAILURE __constant_cpu_to_le32(0xC0020052) 1140 - #define RPC_NT_UNSUPPORTED_AUTHN_LEVEL __constant_cpu_to_le32(0xC0020053) 1141 - #define RPC_NT_NO_PRINC_NAME __constant_cpu_to_le32(0xC0020054) 1142 - #define RPC_NT_NOT_RPC_ERROR __constant_cpu_to_le32(0xC0020055) 1143 - #define RPC_NT_SEC_PKG_ERROR __constant_cpu_to_le32(0xC0020057) 1144 - #define RPC_NT_NOT_CANCELLED __constant_cpu_to_le32(0xC0020058) 1145 - #define RPC_NT_INVALID_ASYNC_HANDLE __constant_cpu_to_le32(0xC0020062) 1146 - #define RPC_NT_INVALID_ASYNC_CALL __constant_cpu_to_le32(0xC0020063) 1147 - #define RPC_NT_PROXY_ACCESS_DENIED __constant_cpu_to_le32(0xC0020064) 1148 - #define RPC_NT_NO_MORE_ENTRIES __constant_cpu_to_le32(0xC0030001) 1149 - #define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL __constant_cpu_to_le32(0xC0030002) 1150 - #define RPC_NT_SS_CHAR_TRANS_SHORT_FILE __constant_cpu_to_le32(0xC0030003) 1151 - #define RPC_NT_SS_IN_NULL_CONTEXT __constant_cpu_to_le32(0xC0030004) 1152 - #define RPC_NT_SS_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0030005) 1153 - #define RPC_NT_SS_CONTEXT_DAMAGED __constant_cpu_to_le32(0xC0030006) 1154 - #define RPC_NT_SS_HANDLES_MISMATCH __constant_cpu_to_le32(0xC0030007) 1155 - #define RPC_NT_SS_CANNOT_GET_CALL_HANDLE __constant_cpu_to_le32(0xC0030008) 1156 - #define RPC_NT_NULL_REF_POINTER __constant_cpu_to_le32(0xC0030009) 1157 - #define RPC_NT_ENUM_VALUE_OUT_OF_RANGE __constant_cpu_to_le32(0xC003000A) 1158 - #define RPC_NT_BYTE_COUNT_TOO_SMALL __constant_cpu_to_le32(0xC003000B) 1159 - #define RPC_NT_BAD_STUB_DATA __constant_cpu_to_le32(0xC003000C) 1160 - #define RPC_NT_INVALID_ES_ACTION __constant_cpu_to_le32(0xC0030059) 1161 - #define RPC_NT_WRONG_ES_VERSION __constant_cpu_to_le32(0xC003005A) 1162 - #define RPC_NT_WRONG_STUB_VERSION __constant_cpu_to_le32(0xC003005B) 1163 - #define RPC_NT_INVALID_PIPE_OBJECT __constant_cpu_to_le32(0xC003005C) 1164 - #define RPC_NT_INVALID_PIPE_OPERATION __constant_cpu_to_le32(0xC003005D) 1165 - #define RPC_NT_WRONG_PIPE_VERSION __constant_cpu_to_le32(0xC003005E) 1166 - #define RPC_NT_PIPE_CLOSED __constant_cpu_to_le32(0xC003005F) 1167 - #define RPC_NT_PIPE_DISCIPLINE_ERROR __constant_cpu_to_le32(0xC0030060) 1168 - #define RPC_NT_PIPE_EMPTY __constant_cpu_to_le32(0xC0030061) 1169 - #define STATUS_PNP_BAD_MPS_TABLE __constant_cpu_to_le32(0xC0040035) 1170 - #define STATUS_PNP_TRANSLATION_FAILED __constant_cpu_to_le32(0xC0040036) 1171 - #define STATUS_PNP_IRQ_TRANSLATION_FAILED __constant_cpu_to_le32(0xC0040037) 1172 - #define STATUS_PNP_INVALID_ID __constant_cpu_to_le32(0xC0040038) 1173 - #define STATUS_IO_REISSUE_AS_CACHED __constant_cpu_to_le32(0xC0040039) 1174 - #define STATUS_CTX_WINSTATION_NAME_INVALID __constant_cpu_to_le32(0xC00A0001) 1175 - #define STATUS_CTX_INVALID_PD __constant_cpu_to_le32(0xC00A0002) 1176 - #define STATUS_CTX_PD_NOT_FOUND __constant_cpu_to_le32(0xC00A0003) 1177 - #define STATUS_CTX_CLOSE_PENDING __constant_cpu_to_le32(0xC00A0006) 1178 - #define STATUS_CTX_NO_OUTBUF __constant_cpu_to_le32(0xC00A0007) 1179 - #define STATUS_CTX_MODEM_INF_NOT_FOUND __constant_cpu_to_le32(0xC00A0008) 1180 - #define STATUS_CTX_INVALID_MODEMNAME __constant_cpu_to_le32(0xC00A0009) 1181 - #define STATUS_CTX_RESPONSE_ERROR __constant_cpu_to_le32(0xC00A000A) 1182 - #define STATUS_CTX_MODEM_RESPONSE_TIMEOUT __constant_cpu_to_le32(0xC00A000B) 1183 - #define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER __constant_cpu_to_le32(0xC00A000C) 1184 - #define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE __constant_cpu_to_le32(0xC00A000D) 1185 - #define STATUS_CTX_MODEM_RESPONSE_BUSY __constant_cpu_to_le32(0xC00A000E) 1186 - #define STATUS_CTX_MODEM_RESPONSE_VOICE __constant_cpu_to_le32(0xC00A000F) 1187 - #define STATUS_CTX_TD_ERROR __constant_cpu_to_le32(0xC00A0010) 1188 - #define STATUS_CTX_LICENSE_CLIENT_INVALID __constant_cpu_to_le32(0xC00A0012) 1189 - #define STATUS_CTX_LICENSE_NOT_AVAILABLE __constant_cpu_to_le32(0xC00A0013) 1190 - #define STATUS_CTX_LICENSE_EXPIRED __constant_cpu_to_le32(0xC00A0014) 1191 - #define STATUS_CTX_WINSTATION_NOT_FOUND __constant_cpu_to_le32(0xC00A0015) 1192 - #define STATUS_CTX_WINSTATION_NAME_COLLISION __constant_cpu_to_le32(0xC00A0016) 1193 - #define STATUS_CTX_WINSTATION_BUSY __constant_cpu_to_le32(0xC00A0017) 1194 - #define STATUS_CTX_BAD_VIDEO_MODE __constant_cpu_to_le32(0xC00A0018) 1195 - #define STATUS_CTX_GRAPHICS_INVALID __constant_cpu_to_le32(0xC00A0022) 1196 - #define STATUS_CTX_NOT_CONSOLE __constant_cpu_to_le32(0xC00A0024) 1197 - #define STATUS_CTX_CLIENT_QUERY_TIMEOUT __constant_cpu_to_le32(0xC00A0026) 1198 - #define STATUS_CTX_CONSOLE_DISCONNECT __constant_cpu_to_le32(0xC00A0027) 1199 - #define STATUS_CTX_CONSOLE_CONNECT __constant_cpu_to_le32(0xC00A0028) 1200 - #define STATUS_CTX_SHADOW_DENIED __constant_cpu_to_le32(0xC00A002A) 1201 - #define STATUS_CTX_WINSTATION_ACCESS_DENIED __constant_cpu_to_le32(0xC00A002B) 1202 - #define STATUS_CTX_INVALID_WD __constant_cpu_to_le32(0xC00A002E) 1203 - #define STATUS_CTX_WD_NOT_FOUND __constant_cpu_to_le32(0xC00A002F) 1204 - #define STATUS_CTX_SHADOW_INVALID __constant_cpu_to_le32(0xC00A0030) 1205 - #define STATUS_CTX_SHADOW_DISABLED __constant_cpu_to_le32(0xC00A0031) 1206 - #define STATUS_RDP_PROTOCOL_ERROR __constant_cpu_to_le32(0xC00A0032) 1207 - #define STATUS_CTX_CLIENT_LICENSE_NOT_SET __constant_cpu_to_le32(0xC00A0033) 1208 - #define STATUS_CTX_CLIENT_LICENSE_IN_USE __constant_cpu_to_le32(0xC00A0034) 1209 - #define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE __constant_cpu_to_le32(0xC00A0035) 1210 - #define STATUS_CTX_SHADOW_NOT_RUNNING __constant_cpu_to_le32(0xC00A0036) 1211 - #define STATUS_CTX_LOGON_DISABLED __constant_cpu_to_le32(0xC00A0037) 1212 - #define STATUS_CTX_SECURITY_LAYER_ERROR __constant_cpu_to_le32(0xC00A0038) 1213 - #define STATUS_TS_INCOMPATIBLE_SESSIONS __constant_cpu_to_le32(0xC00A0039) 1214 - #define STATUS_MUI_FILE_NOT_FOUND __constant_cpu_to_le32(0xC00B0001) 1215 - #define STATUS_MUI_INVALID_FILE __constant_cpu_to_le32(0xC00B0002) 1216 - #define STATUS_MUI_INVALID_RC_CONFIG __constant_cpu_to_le32(0xC00B0003) 1217 - #define STATUS_MUI_INVALID_LOCALE_NAME __constant_cpu_to_le32(0xC00B0004) 1218 - #define STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME __constant_cpu_to_le32(0xC00B0005) 1219 - #define STATUS_MUI_FILE_NOT_LOADED __constant_cpu_to_le32(0xC00B0006) 1220 - #define STATUS_RESOURCE_ENUM_USER_STOP __constant_cpu_to_le32(0xC00B0007) 1221 - #define STATUS_CLUSTER_INVALID_NODE __constant_cpu_to_le32(0xC0130001) 1222 - #define STATUS_CLUSTER_NODE_EXISTS __constant_cpu_to_le32(0xC0130002) 1223 - #define STATUS_CLUSTER_JOIN_IN_PROGRESS __constant_cpu_to_le32(0xC0130003) 1224 - #define STATUS_CLUSTER_NODE_NOT_FOUND __constant_cpu_to_le32(0xC0130004) 1225 - #define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND __constant_cpu_to_le32(0xC0130005) 1226 - #define STATUS_CLUSTER_NETWORK_EXISTS __constant_cpu_to_le32(0xC0130006) 1227 - #define STATUS_CLUSTER_NETWORK_NOT_FOUND __constant_cpu_to_le32(0xC0130007) 1228 - #define STATUS_CLUSTER_NETINTERFACE_EXISTS __constant_cpu_to_le32(0xC0130008) 1229 - #define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC0130009) 1230 - #define STATUS_CLUSTER_INVALID_REQUEST __constant_cpu_to_le32(0xC013000A) 1231 - #define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER __constant_cpu_to_le32(0xC013000B) 1232 - #define STATUS_CLUSTER_NODE_DOWN __constant_cpu_to_le32(0xC013000C) 1233 - #define STATUS_CLUSTER_NODE_UNREACHABLE __constant_cpu_to_le32(0xC013000D) 1234 - #define STATUS_CLUSTER_NODE_NOT_MEMBER __constant_cpu_to_le32(0xC013000E) 1235 - #define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS __constant_cpu_to_le32(0xC013000F) 1236 - #define STATUS_CLUSTER_INVALID_NETWORK __constant_cpu_to_le32(0xC0130010) 1237 - #define STATUS_CLUSTER_NO_NET_ADAPTERS __constant_cpu_to_le32(0xC0130011) 1238 - #define STATUS_CLUSTER_NODE_UP __constant_cpu_to_le32(0xC0130012) 1239 - #define STATUS_CLUSTER_NODE_PAUSED __constant_cpu_to_le32(0xC0130013) 1240 - #define STATUS_CLUSTER_NODE_NOT_PAUSED __constant_cpu_to_le32(0xC0130014) 1241 - #define STATUS_CLUSTER_NO_SECURITY_CONTEXT __constant_cpu_to_le32(0xC0130015) 1242 - #define STATUS_CLUSTER_NETWORK_NOT_INTERNAL __constant_cpu_to_le32(0xC0130016) 1243 - #define STATUS_CLUSTER_POISONED __constant_cpu_to_le32(0xC0130017) 1244 - #define STATUS_ACPI_INVALID_OPCODE __constant_cpu_to_le32(0xC0140001) 1245 - #define STATUS_ACPI_STACK_OVERFLOW __constant_cpu_to_le32(0xC0140002) 1246 - #define STATUS_ACPI_ASSERT_FAILED __constant_cpu_to_le32(0xC0140003) 1247 - #define STATUS_ACPI_INVALID_INDEX __constant_cpu_to_le32(0xC0140004) 1248 - #define STATUS_ACPI_INVALID_ARGUMENT __constant_cpu_to_le32(0xC0140005) 1249 - #define STATUS_ACPI_FATAL __constant_cpu_to_le32(0xC0140006) 1250 - #define STATUS_ACPI_INVALID_SUPERNAME __constant_cpu_to_le32(0xC0140007) 1251 - #define STATUS_ACPI_INVALID_ARGTYPE __constant_cpu_to_le32(0xC0140008) 1252 - #define STATUS_ACPI_INVALID_OBJTYPE __constant_cpu_to_le32(0xC0140009) 1253 - #define STATUS_ACPI_INVALID_TARGETTYPE __constant_cpu_to_le32(0xC014000A) 1254 - #define STATUS_ACPI_INCORRECT_ARGUMENT_COUNT __constant_cpu_to_le32(0xC014000B) 1255 - #define STATUS_ACPI_ADDRESS_NOT_MAPPED __constant_cpu_to_le32(0xC014000C) 1256 - #define STATUS_ACPI_INVALID_EVENTTYPE __constant_cpu_to_le32(0xC014000D) 1257 - #define STATUS_ACPI_HANDLER_COLLISION __constant_cpu_to_le32(0xC014000E) 1258 - #define STATUS_ACPI_INVALID_DATA __constant_cpu_to_le32(0xC014000F) 1259 - #define STATUS_ACPI_INVALID_REGION __constant_cpu_to_le32(0xC0140010) 1260 - #define STATUS_ACPI_INVALID_ACCESS_SIZE __constant_cpu_to_le32(0xC0140011) 1261 - #define STATUS_ACPI_ACQUIRE_GLOBAL_LOCK __constant_cpu_to_le32(0xC0140012) 1262 - #define STATUS_ACPI_ALREADY_INITIALIZED __constant_cpu_to_le32(0xC0140013) 1263 - #define STATUS_ACPI_NOT_INITIALIZED __constant_cpu_to_le32(0xC0140014) 1264 - #define STATUS_ACPI_INVALID_MUTEX_LEVEL __constant_cpu_to_le32(0xC0140015) 1265 - #define STATUS_ACPI_MUTEX_NOT_OWNED __constant_cpu_to_le32(0xC0140016) 1266 - #define STATUS_ACPI_MUTEX_NOT_OWNER __constant_cpu_to_le32(0xC0140017) 1267 - #define STATUS_ACPI_RS_ACCESS __constant_cpu_to_le32(0xC0140018) 1268 - #define STATUS_ACPI_INVALID_TABLE __constant_cpu_to_le32(0xC0140019) 1269 - #define STATUS_ACPI_REG_HANDLER_FAILED __constant_cpu_to_le32(0xC0140020) 1270 - #define STATUS_ACPI_POWER_REQUEST_FAILED __constant_cpu_to_le32(0xC0140021) 1271 - #define STATUS_SXS_SECTION_NOT_FOUND __constant_cpu_to_le32(0xC0150001) 1272 - #define STATUS_SXS_CANT_GEN_ACTCTX __constant_cpu_to_le32(0xC0150002) 1273 - #define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT __constant_cpu_to_le32(0xC0150003) 1274 - #define STATUS_SXS_ASSEMBLY_NOT_FOUND __constant_cpu_to_le32(0xC0150004) 1275 - #define STATUS_SXS_MANIFEST_FORMAT_ERROR __constant_cpu_to_le32(0xC0150005) 1276 - #define STATUS_SXS_MANIFEST_PARSE_ERROR __constant_cpu_to_le32(0xC0150006) 1277 - #define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED __constant_cpu_to_le32(0xC0150007) 1278 - #define STATUS_SXS_KEY_NOT_FOUND __constant_cpu_to_le32(0xC0150008) 1279 - #define STATUS_SXS_VERSION_CONFLICT __constant_cpu_to_le32(0xC0150009) 1280 - #define STATUS_SXS_WRONG_SECTION_TYPE __constant_cpu_to_le32(0xC015000A) 1281 - #define STATUS_SXS_THREAD_QUERIES_DISABLED __constant_cpu_to_le32(0xC015000B) 1282 - #define STATUS_SXS_ASSEMBLY_MISSING __constant_cpu_to_le32(0xC015000C) 1283 - #define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET __constant_cpu_to_le32(0xC015000E) 1284 - #define STATUS_SXS_EARLY_DEACTIVATION __constant_cpu_to_le32(0xC015000F) 1285 - #define STATUS_SXS_INVALID_DEACTIVATION __constant_cpu_to_le32(0xC0150010) 1286 - #define STATUS_SXS_MULTIPLE_DEACTIVATION __constant_cpu_to_le32(0xC0150011) 1287 - #define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY __constant_cpu_to_le32(0xC0150012) 1288 - #define STATUS_SXS_PROCESS_TERMINATION_REQUESTED __constant_cpu_to_le32(0xC0150013) 1289 - #define STATUS_SXS_CORRUPT_ACTIVATION_STACK __constant_cpu_to_le32(0xC0150014) 1290 - #define STATUS_SXS_CORRUPTION __constant_cpu_to_le32(0xC0150015) 1291 - #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE __constant_cpu_to_le32(0xC0150016) 1292 - #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME __constant_cpu_to_le32(0xC0150017) 1293 - #define STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE __constant_cpu_to_le32(0xC0150018) 1294 - #define STATUS_SXS_IDENTITY_PARSE_ERROR __constant_cpu_to_le32(0xC0150019) 1295 - #define STATUS_SXS_COMPONENT_STORE_CORRUPT __constant_cpu_to_le32(0xC015001A) 1296 - #define STATUS_SXS_FILE_HASH_MISMATCH __constant_cpu_to_le32(0xC015001B) 1297 - #define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT __constant_cpu_to_le32(0xC015001C) 1298 - #define STATUS_SXS_IDENTITIES_DIFFERENT __constant_cpu_to_le32(0xC015001D) 1299 - #define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT __constant_cpu_to_le32(0xC015001E) 1300 - #define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY __constant_cpu_to_le32(0xC015001F) 1301 - #define STATUS_ADVANCED_INSTALLER_FAILED __constant_cpu_to_le32(0xC0150020) 1302 - #define STATUS_XML_ENCODING_MISMATCH __constant_cpu_to_le32(0xC0150021) 1303 - #define STATUS_SXS_MANIFEST_TOO_BIG __constant_cpu_to_le32(0xC0150022) 1304 - #define STATUS_SXS_SETTING_NOT_REGISTERED __constant_cpu_to_le32(0xC0150023) 1305 - #define STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE __constant_cpu_to_le32(0xC0150024) 1306 - #define STATUS_SMI_PRIMITIVE_INSTALLER_FAILED __constant_cpu_to_le32(0xC0150025) 1307 - #define STATUS_GENERIC_COMMAND_FAILED __constant_cpu_to_le32(0xC0150026) 1308 - #define STATUS_SXS_FILE_HASH_MISSING __constant_cpu_to_le32(0xC0150027) 1309 - #define STATUS_TRANSACTIONAL_CONFLICT __constant_cpu_to_le32(0xC0190001) 1310 - #define STATUS_INVALID_TRANSACTION __constant_cpu_to_le32(0xC0190002) 1311 - #define STATUS_TRANSACTION_NOT_ACTIVE __constant_cpu_to_le32(0xC0190003) 1312 - #define STATUS_TM_INITIALIZATION_FAILED __constant_cpu_to_le32(0xC0190004) 1313 - #define STATUS_RM_NOT_ACTIVE __constant_cpu_to_le32(0xC0190005) 1314 - #define STATUS_RM_METADATA_CORRUPT __constant_cpu_to_le32(0xC0190006) 1315 - #define STATUS_TRANSACTION_NOT_JOINED __constant_cpu_to_le32(0xC0190007) 1316 - #define STATUS_DIRECTORY_NOT_RM __constant_cpu_to_le32(0xC0190008) 1317 - #define STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE __constant_cpu_to_le32(0xC019000A) 1318 - #define STATUS_LOG_RESIZE_INVALID_SIZE __constant_cpu_to_le32(0xC019000B) 1319 - #define STATUS_REMOTE_FILE_VERSION_MISMATCH __constant_cpu_to_le32(0xC019000C) 1320 - #define STATUS_CRM_PROTOCOL_ALREADY_EXISTS __constant_cpu_to_le32(0xC019000F) 1321 - #define STATUS_TRANSACTION_PROPAGATION_FAILED __constant_cpu_to_le32(0xC0190010) 1322 - #define STATUS_CRM_PROTOCOL_NOT_FOUND __constant_cpu_to_le32(0xC0190011) 1323 - #define STATUS_TRANSACTION_SUPERIOR_EXISTS __constant_cpu_to_le32(0xC0190012) 1324 - #define STATUS_TRANSACTION_REQUEST_NOT_VALID __constant_cpu_to_le32(0xC0190013) 1325 - #define STATUS_TRANSACTION_NOT_REQUESTED __constant_cpu_to_le32(0xC0190014) 1326 - #define STATUS_TRANSACTION_ALREADY_ABORTED __constant_cpu_to_le32(0xC0190015) 1327 - #define STATUS_TRANSACTION_ALREADY_COMMITTED __constant_cpu_to_le32(0xC0190016) 1328 - #define STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER __constant_cpu_to_le32(0xC0190017) 1329 - #define STATUS_CURRENT_TRANSACTION_NOT_VALID __constant_cpu_to_le32(0xC0190018) 1330 - #define STATUS_LOG_GROWTH_FAILED __constant_cpu_to_le32(0xC0190019) 1331 - #define STATUS_OBJECT_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC0190021) 1332 - #define STATUS_STREAM_MINIVERSION_NOT_FOUND __constant_cpu_to_le32(0xC0190022) 1333 - #define STATUS_STREAM_MINIVERSION_NOT_VALID __constant_cpu_to_le32(0xC0190023) 1334 - #define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION __constant_cpu_to_le32(0xC0190024) 1335 - #define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT __constant_cpu_to_le32(0xC0190025) 1336 - #define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS __constant_cpu_to_le32(0xC0190026) 1337 - #define STATUS_HANDLE_NO_LONGER_VALID __constant_cpu_to_le32(0xC0190028) 1338 - #define STATUS_LOG_CORRUPTION_DETECTED __constant_cpu_to_le32(0xC0190030) 1339 - #define STATUS_RM_DISCONNECTED __constant_cpu_to_le32(0xC0190032) 1340 - #define STATUS_ENLISTMENT_NOT_SUPERIOR __constant_cpu_to_le32(0xC0190033) 1341 - #define STATUS_FILE_IDENTITY_NOT_PERSISTENT __constant_cpu_to_le32(0xC0190036) 1342 - #define STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY __constant_cpu_to_le32(0xC0190037) 1343 - #define STATUS_CANT_CROSS_RM_BOUNDARY __constant_cpu_to_le32(0xC0190038) 1344 - #define STATUS_TXF_DIR_NOT_EMPTY __constant_cpu_to_le32(0xC0190039) 1345 - #define STATUS_INDOUBT_TRANSACTIONS_EXIST __constant_cpu_to_le32(0xC019003A) 1346 - #define STATUS_TM_VOLATILE __constant_cpu_to_le32(0xC019003B) 1347 - #define STATUS_ROLLBACK_TIMER_EXPIRED __constant_cpu_to_le32(0xC019003C) 1348 - #define STATUS_TXF_ATTRIBUTE_CORRUPT __constant_cpu_to_le32(0xC019003D) 1349 - #define STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC019003E) 1350 - #define STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED __constant_cpu_to_le32(0xC019003F) 1351 - #define STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE __constant_cpu_to_le32(0xC0190040) 1352 - #define STATUS_TRANSACTION_REQUIRED_PROMOTION __constant_cpu_to_le32(0xC0190043) 1353 - #define STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION __constant_cpu_to_le32(0xC0190044) 1354 - #define STATUS_TRANSACTIONS_NOT_FROZEN __constant_cpu_to_le32(0xC0190045) 1355 - #define STATUS_TRANSACTION_FREEZE_IN_PROGRESS __constant_cpu_to_le32(0xC0190046) 1356 - #define STATUS_NOT_SNAPSHOT_VOLUME __constant_cpu_to_le32(0xC0190047) 1357 - #define STATUS_NO_SAVEPOINT_WITH_OPEN_FILES __constant_cpu_to_le32(0xC0190048) 1358 - #define STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC0190049) 1359 - #define STATUS_TM_IDENTITY_MISMATCH __constant_cpu_to_le32(0xC019004A) 1360 - #define STATUS_FLOATED_SECTION __constant_cpu_to_le32(0xC019004B) 1361 - #define STATUS_CANNOT_ACCEPT_TRANSACTED_WORK __constant_cpu_to_le32(0xC019004C) 1362 - #define STATUS_CANNOT_ABORT_TRANSACTIONS __constant_cpu_to_le32(0xC019004D) 1363 - #define STATUS_TRANSACTION_NOT_FOUND __constant_cpu_to_le32(0xC019004E) 1364 - #define STATUS_RESOURCEMANAGER_NOT_FOUND __constant_cpu_to_le32(0xC019004F) 1365 - #define STATUS_ENLISTMENT_NOT_FOUND __constant_cpu_to_le32(0xC0190050) 1366 - #define STATUS_TRANSACTIONMANAGER_NOT_FOUND __constant_cpu_to_le32(0xC0190051) 1367 - #define STATUS_TRANSACTIONMANAGER_NOT_ONLINE __constant_cpu_to_le32(0xC0190052) 1368 - #define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION __constant_cpu_to_le32(0xC0190053) 1369 - #define STATUS_TRANSACTION_NOT_ROOT __constant_cpu_to_le32(0xC0190054) 1370 - #define STATUS_TRANSACTION_OBJECT_EXPIRED __constant_cpu_to_le32(0xC0190055) 1371 - #define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION __constant_cpu_to_le32(0xC0190056) 1372 - #define STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED __constant_cpu_to_le32(0xC0190057) 1373 - #define STATUS_TRANSACTION_RECORD_TOO_LONG __constant_cpu_to_le32(0xC0190058) 1374 - #define STATUS_NO_LINK_TRACKING_IN_TRANSACTION __constant_cpu_to_le32(0xC0190059) 1375 - #define STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION __constant_cpu_to_le32(0xC019005A) 1376 - #define STATUS_TRANSACTION_INTEGRITY_VIOLATED __constant_cpu_to_le32(0xC019005B) 1377 - #define STATUS_LOG_SECTOR_INVALID __constant_cpu_to_le32(0xC01A0001) 1378 - #define STATUS_LOG_SECTOR_PARITY_INVALID __constant_cpu_to_le32(0xC01A0002) 1379 - #define STATUS_LOG_SECTOR_REMAPPED __constant_cpu_to_le32(0xC01A0003) 1380 - #define STATUS_LOG_BLOCK_INCOMPLETE __constant_cpu_to_le32(0xC01A0004) 1381 - #define STATUS_LOG_INVALID_RANGE __constant_cpu_to_le32(0xC01A0005) 1382 - #define STATUS_LOG_BLOCKS_EXHAUSTED __constant_cpu_to_le32(0xC01A0006) 1383 - #define STATUS_LOG_READ_CONTEXT_INVALID __constant_cpu_to_le32(0xC01A0007) 1384 - #define STATUS_LOG_RESTART_INVALID __constant_cpu_to_le32(0xC01A0008) 1385 - #define STATUS_LOG_BLOCK_VERSION __constant_cpu_to_le32(0xC01A0009) 1386 - #define STATUS_LOG_BLOCK_INVALID __constant_cpu_to_le32(0xC01A000A) 1387 - #define STATUS_LOG_READ_MODE_INVALID __constant_cpu_to_le32(0xC01A000B) 1388 - #define STATUS_LOG_METADATA_CORRUPT __constant_cpu_to_le32(0xC01A000D) 1389 - #define STATUS_LOG_METADATA_INVALID __constant_cpu_to_le32(0xC01A000E) 1390 - #define STATUS_LOG_METADATA_INCONSISTENT __constant_cpu_to_le32(0xC01A000F) 1391 - #define STATUS_LOG_RESERVATION_INVALID __constant_cpu_to_le32(0xC01A0010) 1392 - #define STATUS_LOG_CANT_DELETE __constant_cpu_to_le32(0xC01A0011) 1393 - #define STATUS_LOG_CONTAINER_LIMIT_EXCEEDED __constant_cpu_to_le32(0xC01A0012) 1394 - #define STATUS_LOG_START_OF_LOG __constant_cpu_to_le32(0xC01A0013) 1395 - #define STATUS_LOG_POLICY_ALREADY_INSTALLED __constant_cpu_to_le32(0xC01A0014) 1396 - #define STATUS_LOG_POLICY_NOT_INSTALLED __constant_cpu_to_le32(0xC01A0015) 1397 - #define STATUS_LOG_POLICY_INVALID __constant_cpu_to_le32(0xC01A0016) 1398 - #define STATUS_LOG_POLICY_CONFLICT __constant_cpu_to_le32(0xC01A0017) 1399 - #define STATUS_LOG_PINNED_ARCHIVE_TAIL __constant_cpu_to_le32(0xC01A0018) 1400 - #define STATUS_LOG_RECORD_NONEXISTENT __constant_cpu_to_le32(0xC01A0019) 1401 - #define STATUS_LOG_RECORDS_RESERVED_INVALID __constant_cpu_to_le32(0xC01A001A) 1402 - #define STATUS_LOG_SPACE_RESERVED_INVALID __constant_cpu_to_le32(0xC01A001B) 1403 - #define STATUS_LOG_TAIL_INVALID __constant_cpu_to_le32(0xC01A001C) 1404 - #define STATUS_LOG_FULL __constant_cpu_to_le32(0xC01A001D) 1405 - #define STATUS_LOG_MULTIPLEXED __constant_cpu_to_le32(0xC01A001E) 1406 - #define STATUS_LOG_DEDICATED __constant_cpu_to_le32(0xC01A001F) 1407 - #define STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS __constant_cpu_to_le32(0xC01A0020) 1408 - #define STATUS_LOG_ARCHIVE_IN_PROGRESS __constant_cpu_to_le32(0xC01A0021) 1409 - #define STATUS_LOG_EPHEMERAL __constant_cpu_to_le32(0xC01A0022) 1410 - #define STATUS_LOG_NOT_ENOUGH_CONTAINERS __constant_cpu_to_le32(0xC01A0023) 1411 - #define STATUS_LOG_CLIENT_ALREADY_REGISTERED __constant_cpu_to_le32(0xC01A0024) 1412 - #define STATUS_LOG_CLIENT_NOT_REGISTERED __constant_cpu_to_le32(0xC01A0025) 1413 - #define STATUS_LOG_FULL_HANDLER_IN_PROGRESS __constant_cpu_to_le32(0xC01A0026) 1414 - #define STATUS_LOG_CONTAINER_READ_FAILED __constant_cpu_to_le32(0xC01A0027) 1415 - #define STATUS_LOG_CONTAINER_WRITE_FAILED __constant_cpu_to_le32(0xC01A0028) 1416 - #define STATUS_LOG_CONTAINER_OPEN_FAILED __constant_cpu_to_le32(0xC01A0029) 1417 - #define STATUS_LOG_CONTAINER_STATE_INVALID __constant_cpu_to_le32(0xC01A002A) 1418 - #define STATUS_LOG_STATE_INVALID __constant_cpu_to_le32(0xC01A002B) 1419 - #define STATUS_LOG_PINNED __constant_cpu_to_le32(0xC01A002C) 1420 - #define STATUS_LOG_METADATA_FLUSH_FAILED __constant_cpu_to_le32(0xC01A002D) 1421 - #define STATUS_LOG_INCONSISTENT_SECURITY __constant_cpu_to_le32(0xC01A002E) 1422 - #define STATUS_LOG_APPENDED_FLUSH_FAILED __constant_cpu_to_le32(0xC01A002F) 1423 - #define STATUS_LOG_PINNED_RESERVATION __constant_cpu_to_le32(0xC01A0030) 1424 - #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD __constant_cpu_to_le32(0xC01B00EA) 1425 - #define STATUS_FLT_NO_HANDLER_DEFINED __constant_cpu_to_le32(0xC01C0001) 1426 - #define STATUS_FLT_CONTEXT_ALREADY_DEFINED __constant_cpu_to_le32(0xC01C0002) 1427 - #define STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST __constant_cpu_to_le32(0xC01C0003) 1428 - #define STATUS_FLT_DISALLOW_FAST_IO __constant_cpu_to_le32(0xC01C0004) 1429 - #define STATUS_FLT_INVALID_NAME_REQUEST __constant_cpu_to_le32(0xC01C0005) 1430 - #define STATUS_FLT_NOT_SAFE_TO_POST_OPERATION __constant_cpu_to_le32(0xC01C0006) 1431 - #define STATUS_FLT_NOT_INITIALIZED __constant_cpu_to_le32(0xC01C0007) 1432 - #define STATUS_FLT_FILTER_NOT_READY __constant_cpu_to_le32(0xC01C0008) 1433 - #define STATUS_FLT_POST_OPERATION_CLEANUP __constant_cpu_to_le32(0xC01C0009) 1434 - #define STATUS_FLT_INTERNAL_ERROR __constant_cpu_to_le32(0xC01C000A) 1435 - #define STATUS_FLT_DELETING_OBJECT __constant_cpu_to_le32(0xC01C000B) 1436 - #define STATUS_FLT_MUST_BE_NONPAGED_POOL __constant_cpu_to_le32(0xC01C000C) 1437 - #define STATUS_FLT_DUPLICATE_ENTRY __constant_cpu_to_le32(0xC01C000D) 1438 - #define STATUS_FLT_CBDQ_DISABLED __constant_cpu_to_le32(0xC01C000E) 1439 - #define STATUS_FLT_DO_NOT_ATTACH __constant_cpu_to_le32(0xC01C000F) 1440 - #define STATUS_FLT_DO_NOT_DETACH __constant_cpu_to_le32(0xC01C0010) 1441 - #define STATUS_FLT_INSTANCE_ALTITUDE_COLLISION __constant_cpu_to_le32(0xC01C0011) 1442 - #define STATUS_FLT_INSTANCE_NAME_COLLISION __constant_cpu_to_le32(0xC01C0012) 1443 - #define STATUS_FLT_FILTER_NOT_FOUND __constant_cpu_to_le32(0xC01C0013) 1444 - #define STATUS_FLT_VOLUME_NOT_FOUND __constant_cpu_to_le32(0xC01C0014) 1445 - #define STATUS_FLT_INSTANCE_NOT_FOUND __constant_cpu_to_le32(0xC01C0015) 1446 - #define STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND __constant_cpu_to_le32(0xC01C0016) 1447 - #define STATUS_FLT_INVALID_CONTEXT_REGISTRATION __constant_cpu_to_le32(0xC01C0017) 1448 - #define STATUS_FLT_NAME_CACHE_MISS __constant_cpu_to_le32(0xC01C0018) 1449 - #define STATUS_FLT_NO_DEVICE_OBJECT __constant_cpu_to_le32(0xC01C0019) 1450 - #define STATUS_FLT_VOLUME_ALREADY_MOUNTED __constant_cpu_to_le32(0xC01C001A) 1451 - #define STATUS_FLT_ALREADY_ENLISTED __constant_cpu_to_le32(0xC01C001B) 1452 - #define STATUS_FLT_CONTEXT_ALREADY_LINKED __constant_cpu_to_le32(0xC01C001C) 1453 - #define STATUS_FLT_NO_WAITER_FOR_REPLY __constant_cpu_to_le32(0xC01C0020) 1454 - #define STATUS_MONITOR_NO_DESCRIPTOR __constant_cpu_to_le32(0xC01D0001) 1455 - #define STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT __constant_cpu_to_le32(0xC01D0002) 1456 - #define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM __constant_cpu_to_le32(0xC01D0003) 1457 - #define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK __constant_cpu_to_le32(0xC01D0004) 1458 - #define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED __constant_cpu_to_le32(0xC01D0005) 1459 - #define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK __constant_cpu_to_le32(0xC01D0006) 1460 - #define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK __constant_cpu_to_le32(0xC01D0007) 1461 - #define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA __constant_cpu_to_le32(0xC01D0008) 1462 - #define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK __constant_cpu_to_le32(0xC01D0009) 1463 - #define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER __constant_cpu_to_le32(0xC01E0000) 1464 - #define STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER __constant_cpu_to_le32(0xC01E0001) 1465 - #define STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER __constant_cpu_to_le32(0xC01E0002) 1466 - #define STATUS_GRAPHICS_ADAPTER_WAS_RESET __constant_cpu_to_le32(0xC01E0003) 1467 - #define STATUS_GRAPHICS_INVALID_DRIVER_MODEL __constant_cpu_to_le32(0xC01E0004) 1468 - #define STATUS_GRAPHICS_PRESENT_MODE_CHANGED __constant_cpu_to_le32(0xC01E0005) 1469 - #define STATUS_GRAPHICS_PRESENT_OCCLUDED __constant_cpu_to_le32(0xC01E0006) 1470 - #define STATUS_GRAPHICS_PRESENT_DENIED __constant_cpu_to_le32(0xC01E0007) 1471 - #define STATUS_GRAPHICS_CANNOTCOLORCONVERT __constant_cpu_to_le32(0xC01E0008) 1472 - #define STATUS_GRAPHICS_NO_VIDEO_MEMORY __constant_cpu_to_le32(0xC01E0100) 1473 - #define STATUS_GRAPHICS_CANT_LOCK_MEMORY __constant_cpu_to_le32(0xC01E0101) 1474 - #define STATUS_GRAPHICS_ALLOCATION_BUSY __constant_cpu_to_le32(0xC01E0102) 1475 - #define STATUS_GRAPHICS_TOO_MANY_REFERENCES __constant_cpu_to_le32(0xC01E0103) 1476 - #define STATUS_GRAPHICS_TRY_AGAIN_LATER __constant_cpu_to_le32(0xC01E0104) 1477 - #define STATUS_GRAPHICS_TRY_AGAIN_NOW __constant_cpu_to_le32(0xC01E0105) 1478 - #define STATUS_GRAPHICS_ALLOCATION_INVALID __constant_cpu_to_le32(0xC01E0106) 1479 - #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE __constant_cpu_to_le32(0xC01E0107) 1480 - #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED __constant_cpu_to_le32(0xC01E0108) 1481 - #define STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION __constant_cpu_to_le32(0xC01E0109) 1482 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE __constant_cpu_to_le32(0xC01E0110) 1483 - #define STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION __constant_cpu_to_le32(0xC01E0111) 1484 - #define STATUS_GRAPHICS_ALLOCATION_CLOSED __constant_cpu_to_le32(0xC01E0112) 1485 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE __constant_cpu_to_le32(0xC01E0113) 1486 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE __constant_cpu_to_le32(0xC01E0114) 1487 - #define STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE __constant_cpu_to_le32(0xC01E0115) 1488 - #define STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST __constant_cpu_to_le32(0xC01E0116) 1489 - #define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE __constant_cpu_to_le32(0xC01E0200) 1490 - #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E0300) 1491 - #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0301) 1492 - #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0302) 1493 - #define STATUS_GRAPHICS_INVALID_VIDPN __constant_cpu_to_le32(0xC01E0303) 1494 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE __constant_cpu_to_le32(0xC01E0304) 1495 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET __constant_cpu_to_le32(0xC01E0305) 1496 - #define STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0306) 1497 - #define STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET __constant_cpu_to_le32(0xC01E0308) 1498 - #define STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET __constant_cpu_to_le32(0xC01E0309) 1499 - #define STATUS_GRAPHICS_INVALID_FREQUENCY __constant_cpu_to_le32(0xC01E030A) 1500 - #define STATUS_GRAPHICS_INVALID_ACTIVE_REGION __constant_cpu_to_le32(0xC01E030B) 1501 - #define STATUS_GRAPHICS_INVALID_TOTAL_REGION __constant_cpu_to_le32(0xC01E030C) 1502 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE __constant_cpu_to_le32(0xC01E0310) 1503 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE __constant_cpu_to_le32(0xC01E0311) 1504 - #define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET __constant_cpu_to_le32(0xC01E0312) 1505 - #define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0313) 1506 - #define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET __constant_cpu_to_le32(0xC01E0314) 1507 - #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET __constant_cpu_to_le32(0xC01E0315) 1508 - #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET __constant_cpu_to_le32(0xC01E0316) 1509 - #define STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E0317) 1510 - #define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E0318) 1511 - #define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH __constant_cpu_to_le32(0xC01E0319) 1512 - #define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E031A) 1513 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET __constant_cpu_to_le32(0xC01E031B) 1514 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE __constant_cpu_to_le32(0xC01E031C) 1515 - #define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET __constant_cpu_to_le32(0xC01E031D) 1516 - #define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E031F) 1517 - #define STATUS_GRAPHICS_STALE_MODESET __constant_cpu_to_le32(0xC01E0320) 1518 - #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET __constant_cpu_to_le32(0xC01E0321) 1519 - #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE __constant_cpu_to_le32(0xC01E0322) 1520 - #define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN __constant_cpu_to_le32(0xC01E0323) 1521 - #define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0324) 1522 - #define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION __constant_cpu_to_le32(0xC01E0325) 1523 - #define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES __constant_cpu_to_le32(0xC01E0326) 1524 - #define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0327) 1525 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE __constant_cpu_to_le32(0xC01E0328) 1526 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET __constant_cpu_to_le32(0xC01E0329) 1527 - #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET __constant_cpu_to_le32(0xC01E032A) 1528 - #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR __constant_cpu_to_le32(0xC01E032B) 1529 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET __constant_cpu_to_le32(0xC01E032C) 1530 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET __constant_cpu_to_le32(0xC01E032D) 1531 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E032E) 1532 - #define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE __constant_cpu_to_le32(0xC01E032F) 1533 - #define STATUS_GRAPHICS_RESOURCES_NOT_RELATED __constant_cpu_to_le32(0xC01E0330) 1534 - #define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0331) 1535 - #define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE __constant_cpu_to_le32(0xC01E0332) 1536 - #define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET __constant_cpu_to_le32(0xC01E0333) 1537 - #define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER __constant_cpu_to_le32(0xC01E0334) 1538 - #define STATUS_GRAPHICS_NO_VIDPNMGR __constant_cpu_to_le32(0xC01E0335) 1539 - #define STATUS_GRAPHICS_NO_ACTIVE_VIDPN __constant_cpu_to_le32(0xC01E0336) 1540 - #define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY __constant_cpu_to_le32(0xC01E0337) 1541 - #define STATUS_GRAPHICS_MONITOR_NOT_CONNECTED __constant_cpu_to_le32(0xC01E0338) 1542 - #define STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0339) 1543 - #define STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE __constant_cpu_to_le32(0xC01E033A) 1544 - #define STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE __constant_cpu_to_le32(0xC01E033B) 1545 - #define STATUS_GRAPHICS_INVALID_STRIDE __constant_cpu_to_le32(0xC01E033C) 1546 - #define STATUS_GRAPHICS_INVALID_PIXELFORMAT __constant_cpu_to_le32(0xC01E033D) 1547 - #define STATUS_GRAPHICS_INVALID_COLORBASIS __constant_cpu_to_le32(0xC01E033E) 1548 - #define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE __constant_cpu_to_le32(0xC01E033F) 1549 - #define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY __constant_cpu_to_le32(0xC01E0340) 1550 - #define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT __constant_cpu_to_le32(0xC01E0341) 1551 - #define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE __constant_cpu_to_le32(0xC01E0342) 1552 - #define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN __constant_cpu_to_le32(0xC01E0343) 1553 - #define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL __constant_cpu_to_le32(0xC01E0344) 1554 - #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION __constant_cpu_to_le32(0xC01E0345) 1555 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0346) 1556 - #define STATUS_GRAPHICS_INVALID_GAMMA_RAMP __constant_cpu_to_le32(0xC01E0347) 1557 - #define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0348) 1558 - #define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0349) 1559 - #define STATUS_GRAPHICS_MODE_NOT_IN_MODESET __constant_cpu_to_le32(0xC01E034A) 1560 - #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON __constant_cpu_to_le32(0xC01E034D) 1561 - #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE __constant_cpu_to_le32(0xC01E034E) 1562 - #define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE __constant_cpu_to_le32(0xC01E034F) 1563 - #define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS __constant_cpu_to_le32(0xC01E0350) 1564 - #define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING __constant_cpu_to_le32(0xC01E0352) 1565 - #define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED __constant_cpu_to_le32(0xC01E0353) 1566 - #define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS __constant_cpu_to_le32(0xC01E0354) 1567 - #define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT __constant_cpu_to_le32(0xC01E0355) 1568 - #define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM __constant_cpu_to_le32(0xC01E0356) 1569 - #define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN __constant_cpu_to_le32(0xC01E0357) 1570 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT __constant_cpu_to_le32(0xC01E0358) 1571 - #define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED __constant_cpu_to_le32(0xC01E0359) 1572 - #define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION __constant_cpu_to_le32(0xC01E035A) 1573 - #define STATUS_GRAPHICS_INVALID_CLIENT_TYPE __constant_cpu_to_le32(0xC01E035B) 1574 - #define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET __constant_cpu_to_le32(0xC01E035C) 1575 - #define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED __constant_cpu_to_le32(0xC01E0400) 1576 - #define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0401) 1577 - #define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER __constant_cpu_to_le32(0xC01E0430) 1578 - #define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED __constant_cpu_to_le32(0xC01E0431) 1579 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED __constant_cpu_to_le32(0xC01E0432) 1580 - #define STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY __constant_cpu_to_le32(0xC01E0433) 1581 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED __constant_cpu_to_le32(0xC01E0434) 1582 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON __constant_cpu_to_le32(0xC01E0435) 1583 - #define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE __constant_cpu_to_le32(0xC01E0436) 1584 - #define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER __constant_cpu_to_le32(0xC01E0438) 1585 - #define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED __constant_cpu_to_le32(0xC01E043B) 1586 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS __constant_cpu_to_le32(0xC01E051C) 1587 - #define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST __constant_cpu_to_le32(0xC01E051D) 1588 - #define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E051E) 1589 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS __constant_cpu_to_le32(0xC01E051F) 1590 - #define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0520) 1591 - #define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST __constant_cpu_to_le32(0xC01E0521) 1592 - #define STATUS_GRAPHICS_OPM_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0500) 1593 - #define STATUS_GRAPHICS_COPP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0501) 1594 - #define STATUS_GRAPHICS_UAB_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0502) 1595 - #define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS __constant_cpu_to_le32(0xC01E0503) 1596 - #define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL __constant_cpu_to_le32(0xC01E0504) 1597 - #define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST __constant_cpu_to_le32(0xC01E0505) 1598 - #define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME __constant_cpu_to_le32(0xC01E0506) 1599 - #define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP __constant_cpu_to_le32(0xC01E0507) 1600 - #define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0508) 1601 - #define STATUS_GRAPHICS_OPM_INVALID_POINTER __constant_cpu_to_le32(0xC01E050A) 1602 - #define STATUS_GRAPHICS_OPM_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E050B) 1603 - #define STATUS_GRAPHICS_OPM_INVALID_HANDLE __constant_cpu_to_le32(0xC01E050C) 1604 - #define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE __constant_cpu_to_le32(0xC01E050D) 1605 - #define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH __constant_cpu_to_le32(0xC01E050E) 1606 - #define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED __constant_cpu_to_le32(0xC01E050F) 1607 - #define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED __constant_cpu_to_le32(0xC01E0510) 1608 - #define STATUS_GRAPHICS_PVP_HFS_FAILED __constant_cpu_to_le32(0xC01E0511) 1609 - #define STATUS_GRAPHICS_OPM_INVALID_SRM __constant_cpu_to_le32(0xC01E0512) 1610 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP __constant_cpu_to_le32(0xC01E0513) 1611 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP __constant_cpu_to_le32(0xC01E0514) 1612 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA __constant_cpu_to_le32(0xC01E0515) 1613 - #define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET __constant_cpu_to_le32(0xC01E0516) 1614 - #define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH __constant_cpu_to_le32(0xC01E0517) 1615 - #define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE __constant_cpu_to_le32(0xC01E0518) 1616 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC01E051A) 1617 - #define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS __constant_cpu_to_le32(0xC01E051B) 1618 - #define STATUS_GRAPHICS_I2C_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0580) 1619 - #define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST __constant_cpu_to_le32(0xC01E0581) 1620 - #define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA __constant_cpu_to_le32(0xC01E0582) 1621 - #define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA __constant_cpu_to_le32(0xC01E0583) 1622 - #define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E0584) 1623 - #define STATUS_GRAPHICS_DDCCI_INVALID_DATA __constant_cpu_to_le32(0xC01E0585) 1624 - #define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE __constant_cpu_to_le32(0xC01E0586) 1625 - #define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING __constant_cpu_to_le32(0xC01E0587) 1626 - #define STATUS_GRAPHICS_MCA_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E0588) 1627 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND __constant_cpu_to_le32(0xC01E0589) 1628 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH __constant_cpu_to_le32(0xC01E058A) 1629 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM __constant_cpu_to_le32(0xC01E058B) 1630 - #define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE __constant_cpu_to_le32(0xC01E058C) 1631 - #define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS __constant_cpu_to_le32(0xC01E058D) 1632 - #define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED __constant_cpu_to_le32(0xC01E05E0) 1633 - #define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME __constant_cpu_to_le32(0xC01E05E1) 1634 - #define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP __constant_cpu_to_le32(0xC01E05E2) 1635 - #define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED __constant_cpu_to_le32(0xC01E05E3) 1636 - #define STATUS_GRAPHICS_INVALID_POINTER __constant_cpu_to_le32(0xC01E05E4) 1637 - #define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE __constant_cpu_to_le32(0xC01E05E5) 1638 - #define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL __constant_cpu_to_le32(0xC01E05E6) 1639 - #define STATUS_GRAPHICS_INTERNAL_ERROR __constant_cpu_to_le32(0xC01E05E7) 1640 - #define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS __constant_cpu_to_le32(0xC01E05E8) 1641 - #define STATUS_FVE_LOCKED_VOLUME __constant_cpu_to_le32(0xC0210000) 1642 - #define STATUS_FVE_NOT_ENCRYPTED __constant_cpu_to_le32(0xC0210001) 1643 - #define STATUS_FVE_BAD_INFORMATION __constant_cpu_to_le32(0xC0210002) 1644 - #define STATUS_FVE_TOO_SMALL __constant_cpu_to_le32(0xC0210003) 1645 - #define STATUS_FVE_FAILED_WRONG_FS __constant_cpu_to_le32(0xC0210004) 1646 - #define STATUS_FVE_FAILED_BAD_FS __constant_cpu_to_le32(0xC0210005) 1647 - #define STATUS_FVE_FS_NOT_EXTENDED __constant_cpu_to_le32(0xC0210006) 1648 - #define STATUS_FVE_FS_MOUNTED __constant_cpu_to_le32(0xC0210007) 1649 - #define STATUS_FVE_NO_LICENSE __constant_cpu_to_le32(0xC0210008) 1650 - #define STATUS_FVE_ACTION_NOT_ALLOWED __constant_cpu_to_le32(0xC0210009) 1651 - #define STATUS_FVE_BAD_DATA __constant_cpu_to_le32(0xC021000A) 1652 - #define STATUS_FVE_VOLUME_NOT_BOUND __constant_cpu_to_le32(0xC021000B) 1653 - #define STATUS_FVE_NOT_DATA_VOLUME __constant_cpu_to_le32(0xC021000C) 1654 - #define STATUS_FVE_CONV_READ_ERROR __constant_cpu_to_le32(0xC021000D) 1655 - #define STATUS_FVE_CONV_WRITE_ERROR __constant_cpu_to_le32(0xC021000E) 1656 - #define STATUS_FVE_OVERLAPPED_UPDATE __constant_cpu_to_le32(0xC021000F) 1657 - #define STATUS_FVE_FAILED_SECTOR_SIZE __constant_cpu_to_le32(0xC0210010) 1658 - #define STATUS_FVE_FAILED_AUTHENTICATION __constant_cpu_to_le32(0xC0210011) 1659 - #define STATUS_FVE_NOT_OS_VOLUME __constant_cpu_to_le32(0xC0210012) 1660 - #define STATUS_FVE_KEYFILE_NOT_FOUND __constant_cpu_to_le32(0xC0210013) 1661 - #define STATUS_FVE_KEYFILE_INVALID __constant_cpu_to_le32(0xC0210014) 1662 - #define STATUS_FVE_KEYFILE_NO_VMK __constant_cpu_to_le32(0xC0210015) 1663 - #define STATUS_FVE_TPM_DISABLED __constant_cpu_to_le32(0xC0210016) 1664 - #define STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO __constant_cpu_to_le32(0xC0210017) 1665 - #define STATUS_FVE_TPM_INVALID_PCR __constant_cpu_to_le32(0xC0210018) 1666 - #define STATUS_FVE_TPM_NO_VMK __constant_cpu_to_le32(0xC0210019) 1667 - #define STATUS_FVE_PIN_INVALID __constant_cpu_to_le32(0xC021001A) 1668 - #define STATUS_FVE_AUTH_INVALID_APPLICATION __constant_cpu_to_le32(0xC021001B) 1669 - #define STATUS_FVE_AUTH_INVALID_CONFIG __constant_cpu_to_le32(0xC021001C) 1670 - #define STATUS_FVE_DEBUGGER_ENABLED __constant_cpu_to_le32(0xC021001D) 1671 - #define STATUS_FVE_DRY_RUN_FAILED __constant_cpu_to_le32(0xC021001E) 1672 - #define STATUS_FVE_BAD_METADATA_POINTER __constant_cpu_to_le32(0xC021001F) 1673 - #define STATUS_FVE_OLD_METADATA_COPY __constant_cpu_to_le32(0xC0210020) 1674 - #define STATUS_FVE_REBOOT_REQUIRED __constant_cpu_to_le32(0xC0210021) 1675 - #define STATUS_FVE_RAW_ACCESS __constant_cpu_to_le32(0xC0210022) 1676 - #define STATUS_FVE_RAW_BLOCKED __constant_cpu_to_le32(0xC0210023) 1677 - #define STATUS_FWP_CALLOUT_NOT_FOUND __constant_cpu_to_le32(0xC0220001) 1678 - #define STATUS_FWP_CONDITION_NOT_FOUND __constant_cpu_to_le32(0xC0220002) 1679 - #define STATUS_FWP_FILTER_NOT_FOUND __constant_cpu_to_le32(0xC0220003) 1680 - #define STATUS_FWP_LAYER_NOT_FOUND __constant_cpu_to_le32(0xC0220004) 1681 - #define STATUS_FWP_PROVIDER_NOT_FOUND __constant_cpu_to_le32(0xC0220005) 1682 - #define STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND __constant_cpu_to_le32(0xC0220006) 1683 - #define STATUS_FWP_SUBLAYER_NOT_FOUND __constant_cpu_to_le32(0xC0220007) 1684 - #define STATUS_FWP_NOT_FOUND __constant_cpu_to_le32(0xC0220008) 1685 - #define STATUS_FWP_ALREADY_EXISTS __constant_cpu_to_le32(0xC0220009) 1686 - #define STATUS_FWP_IN_USE __constant_cpu_to_le32(0xC022000A) 1687 - #define STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS __constant_cpu_to_le32(0xC022000B) 1688 - #define STATUS_FWP_WRONG_SESSION __constant_cpu_to_le32(0xC022000C) 1689 - #define STATUS_FWP_NO_TXN_IN_PROGRESS __constant_cpu_to_le32(0xC022000D) 1690 - #define STATUS_FWP_TXN_IN_PROGRESS __constant_cpu_to_le32(0xC022000E) 1691 - #define STATUS_FWP_TXN_ABORTED __constant_cpu_to_le32(0xC022000F) 1692 - #define STATUS_FWP_SESSION_ABORTED __constant_cpu_to_le32(0xC0220010) 1693 - #define STATUS_FWP_INCOMPATIBLE_TXN __constant_cpu_to_le32(0xC0220011) 1694 - #define STATUS_FWP_TIMEOUT __constant_cpu_to_le32(0xC0220012) 1695 - #define STATUS_FWP_NET_EVENTS_DISABLED __constant_cpu_to_le32(0xC0220013) 1696 - #define STATUS_FWP_INCOMPATIBLE_LAYER __constant_cpu_to_le32(0xC0220014) 1697 - #define STATUS_FWP_KM_CLIENTS_ONLY __constant_cpu_to_le32(0xC0220015) 1698 - #define STATUS_FWP_LIFETIME_MISMATCH __constant_cpu_to_le32(0xC0220016) 1699 - #define STATUS_FWP_BUILTIN_OBJECT __constant_cpu_to_le32(0xC0220017) 1700 - #define STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS __constant_cpu_to_le32(0xC0220018) 1701 - #define STATUS_FWP_TOO_MANY_CALLOUTS __constant_cpu_to_le32(0xC0220018) 1702 - #define STATUS_FWP_NOTIFICATION_DROPPED __constant_cpu_to_le32(0xC0220019) 1703 - #define STATUS_FWP_TRAFFIC_MISMATCH __constant_cpu_to_le32(0xC022001A) 1704 - #define STATUS_FWP_INCOMPATIBLE_SA_STATE __constant_cpu_to_le32(0xC022001B) 1705 - #define STATUS_FWP_NULL_POINTER __constant_cpu_to_le32(0xC022001C) 1706 - #define STATUS_FWP_INVALID_ENUMERATOR __constant_cpu_to_le32(0xC022001D) 1707 - #define STATUS_FWP_INVALID_FLAGS __constant_cpu_to_le32(0xC022001E) 1708 - #define STATUS_FWP_INVALID_NET_MASK __constant_cpu_to_le32(0xC022001F) 1709 - #define STATUS_FWP_INVALID_RANGE __constant_cpu_to_le32(0xC0220020) 1710 - #define STATUS_FWP_INVALID_INTERVAL __constant_cpu_to_le32(0xC0220021) 1711 - #define STATUS_FWP_ZERO_LENGTH_ARRAY __constant_cpu_to_le32(0xC0220022) 1712 - #define STATUS_FWP_NULL_DISPLAY_NAME __constant_cpu_to_le32(0xC0220023) 1713 - #define STATUS_FWP_INVALID_ACTION_TYPE __constant_cpu_to_le32(0xC0220024) 1714 - #define STATUS_FWP_INVALID_WEIGHT __constant_cpu_to_le32(0xC0220025) 1715 - #define STATUS_FWP_MATCH_TYPE_MISMATCH __constant_cpu_to_le32(0xC0220026) 1716 - #define STATUS_FWP_TYPE_MISMATCH __constant_cpu_to_le32(0xC0220027) 1717 - #define STATUS_FWP_OUT_OF_BOUNDS __constant_cpu_to_le32(0xC0220028) 1718 - #define STATUS_FWP_RESERVED __constant_cpu_to_le32(0xC0220029) 1719 - #define STATUS_FWP_DUPLICATE_CONDITION __constant_cpu_to_le32(0xC022002A) 1720 - #define STATUS_FWP_DUPLICATE_KEYMOD __constant_cpu_to_le32(0xC022002B) 1721 - #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER __constant_cpu_to_le32(0xC022002C) 1722 - #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER __constant_cpu_to_le32(0xC022002D) 1723 - #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER __constant_cpu_to_le32(0xC022002E) 1724 - #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT __constant_cpu_to_le32(0xC022002F) 1725 - #define STATUS_FWP_INCOMPATIBLE_AUTH_METHOD __constant_cpu_to_le32(0xC0220030) 1726 - #define STATUS_FWP_INCOMPATIBLE_DH_GROUP __constant_cpu_to_le32(0xC0220031) 1727 - #define STATUS_FWP_EM_NOT_SUPPORTED __constant_cpu_to_le32(0xC0220032) 1728 - #define STATUS_FWP_NEVER_MATCH __constant_cpu_to_le32(0xC0220033) 1729 - #define STATUS_FWP_PROVIDER_CONTEXT_MISMATCH __constant_cpu_to_le32(0xC0220034) 1730 - #define STATUS_FWP_INVALID_PARAMETER __constant_cpu_to_le32(0xC0220035) 1731 - #define STATUS_FWP_TOO_MANY_SUBLAYERS __constant_cpu_to_le32(0xC0220036) 1732 - #define STATUS_FWP_CALLOUT_NOTIFICATION_FAILED __constant_cpu_to_le32(0xC0220037) 1733 - #define STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG __constant_cpu_to_le32(0xC0220038) 1734 - #define STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG __constant_cpu_to_le32(0xC0220039) 1735 - #define STATUS_FWP_TCPIP_NOT_READY __constant_cpu_to_le32(0xC0220100) 1736 - #define STATUS_FWP_INJECT_HANDLE_CLOSING __constant_cpu_to_le32(0xC0220101) 1737 - #define STATUS_FWP_INJECT_HANDLE_STALE __constant_cpu_to_le32(0xC0220102) 1738 - #define STATUS_FWP_CANNOT_PEND __constant_cpu_to_le32(0xC0220103) 1739 - #define STATUS_NDIS_CLOSING __constant_cpu_to_le32(0xC0230002) 1740 - #define STATUS_NDIS_BAD_VERSION __constant_cpu_to_le32(0xC0230004) 1741 - #define STATUS_NDIS_BAD_CHARACTERISTICS __constant_cpu_to_le32(0xC0230005) 1742 - #define STATUS_NDIS_ADAPTER_NOT_FOUND __constant_cpu_to_le32(0xC0230006) 1743 - #define STATUS_NDIS_OPEN_FAILED __constant_cpu_to_le32(0xC0230007) 1744 - #define STATUS_NDIS_DEVICE_FAILED __constant_cpu_to_le32(0xC0230008) 1745 - #define STATUS_NDIS_MULTICAST_FULL __constant_cpu_to_le32(0xC0230009) 1746 - #define STATUS_NDIS_MULTICAST_EXISTS __constant_cpu_to_le32(0xC023000A) 1747 - #define STATUS_NDIS_MULTICAST_NOT_FOUND __constant_cpu_to_le32(0xC023000B) 1748 - #define STATUS_NDIS_REQUEST_ABORTED __constant_cpu_to_le32(0xC023000C) 1749 - #define STATUS_NDIS_RESET_IN_PROGRESS __constant_cpu_to_le32(0xC023000D) 1750 - #define STATUS_NDIS_INVALID_PACKET __constant_cpu_to_le32(0xC023000F) 1751 - #define STATUS_NDIS_INVALID_DEVICE_REQUEST __constant_cpu_to_le32(0xC0230010) 1752 - #define STATUS_NDIS_ADAPTER_NOT_READY __constant_cpu_to_le32(0xC0230011) 1753 - #define STATUS_NDIS_INVALID_LENGTH __constant_cpu_to_le32(0xC0230014) 1754 - #define STATUS_NDIS_INVALID_DATA __constant_cpu_to_le32(0xC0230015) 1755 - #define STATUS_NDIS_BUFFER_TOO_SHORT __constant_cpu_to_le32(0xC0230016) 1756 - #define STATUS_NDIS_INVALID_OID __constant_cpu_to_le32(0xC0230017) 1757 - #define STATUS_NDIS_ADAPTER_REMOVED __constant_cpu_to_le32(0xC0230018) 1758 - #define STATUS_NDIS_UNSUPPORTED_MEDIA __constant_cpu_to_le32(0xC0230019) 1759 - #define STATUS_NDIS_GROUP_ADDRESS_IN_USE __constant_cpu_to_le32(0xC023001A) 1760 - #define STATUS_NDIS_FILE_NOT_FOUND __constant_cpu_to_le32(0xC023001B) 1761 - #define STATUS_NDIS_ERROR_READING_FILE __constant_cpu_to_le32(0xC023001C) 1762 - #define STATUS_NDIS_ALREADY_MAPPED __constant_cpu_to_le32(0xC023001D) 1763 - #define STATUS_NDIS_RESOURCE_CONFLICT __constant_cpu_to_le32(0xC023001E) 1764 - #define STATUS_NDIS_MEDIA_DISCONNECTED __constant_cpu_to_le32(0xC023001F) 1765 - #define STATUS_NDIS_INVALID_ADDRESS __constant_cpu_to_le32(0xC0230022) 1766 - #define STATUS_NDIS_PAUSED __constant_cpu_to_le32(0xC023002A) 1767 - #define STATUS_NDIS_INTERFACE_NOT_FOUND __constant_cpu_to_le32(0xC023002B) 1768 - #define STATUS_NDIS_UNSUPPORTED_REVISION __constant_cpu_to_le32(0xC023002C) 1769 - #define STATUS_NDIS_INVALID_PORT __constant_cpu_to_le32(0xC023002D) 1770 - #define STATUS_NDIS_INVALID_PORT_STATE __constant_cpu_to_le32(0xC023002E) 1771 - #define STATUS_NDIS_LOW_POWER_STATE __constant_cpu_to_le32(0xC023002F) 1772 - #define STATUS_NDIS_NOT_SUPPORTED __constant_cpu_to_le32(0xC02300BB) 1773 - #define STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED __constant_cpu_to_le32(0xC0232000) 1774 - #define STATUS_NDIS_DOT11_MEDIA_IN_USE __constant_cpu_to_le32(0xC0232001) 1775 - #define STATUS_NDIS_DOT11_POWER_STATE_INVALID __constant_cpu_to_le32(0xC0232002) 1776 - #define STATUS_IPSEC_BAD_SPI __constant_cpu_to_le32(0xC0360001) 1777 - #define STATUS_IPSEC_SA_LIFETIME_EXPIRED __constant_cpu_to_le32(0xC0360002) 1778 - #define STATUS_IPSEC_WRONG_SA __constant_cpu_to_le32(0xC0360003) 1779 - #define STATUS_IPSEC_REPLAY_CHECK_FAILED __constant_cpu_to_le32(0xC0360004) 1780 - #define STATUS_IPSEC_INVALID_PACKET __constant_cpu_to_le32(0xC0360005) 1781 - #define STATUS_IPSEC_INTEGRITY_CHECK_FAILED __constant_cpu_to_le32(0xC0360006) 1782 - #define STATUS_IPSEC_CLEAR_TEXT_DROP __constant_cpu_to_le32(0xC0360007) 43 + #define STATUS_SUCCESS cpu_to_le32(0x00000000) 44 + #define STATUS_WAIT_0 cpu_to_le32(0x00000000) 45 + #define STATUS_WAIT_1 cpu_to_le32(0x00000001) 46 + #define STATUS_WAIT_2 cpu_to_le32(0x00000002) 47 + #define STATUS_WAIT_3 cpu_to_le32(0x00000003) 48 + #define STATUS_WAIT_63 cpu_to_le32(0x0000003F) 49 + #define STATUS_ABANDONED cpu_to_le32(0x00000080) 50 + #define STATUS_ABANDONED_WAIT_0 cpu_to_le32(0x00000080) 51 + #define STATUS_ABANDONED_WAIT_63 cpu_to_le32(0x000000BF) 52 + #define STATUS_USER_APC cpu_to_le32(0x000000C0) 53 + #define STATUS_KERNEL_APC cpu_to_le32(0x00000100) 54 + #define STATUS_ALERTED cpu_to_le32(0x00000101) 55 + #define STATUS_TIMEOUT cpu_to_le32(0x00000102) 56 + #define STATUS_PENDING cpu_to_le32(0x00000103) 57 + #define STATUS_REPARSE cpu_to_le32(0x00000104) 58 + #define STATUS_MORE_ENTRIES cpu_to_le32(0x00000105) 59 + #define STATUS_NOT_ALL_ASSIGNED cpu_to_le32(0x00000106) 60 + #define STATUS_SOME_NOT_MAPPED cpu_to_le32(0x00000107) 61 + #define STATUS_OPLOCK_BREAK_IN_PROGRESS cpu_to_le32(0x00000108) 62 + #define STATUS_VOLUME_MOUNTED cpu_to_le32(0x00000109) 63 + #define STATUS_RXACT_COMMITTED cpu_to_le32(0x0000010A) 64 + #define STATUS_NOTIFY_CLEANUP cpu_to_le32(0x0000010B) 65 + #define STATUS_NOTIFY_ENUM_DIR cpu_to_le32(0x0000010C) 66 + #define STATUS_NO_QUOTAS_FOR_ACCOUNT cpu_to_le32(0x0000010D) 67 + #define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED cpu_to_le32(0x0000010E) 68 + #define STATUS_PAGE_FAULT_TRANSITION cpu_to_le32(0x00000110) 69 + #define STATUS_PAGE_FAULT_DEMAND_ZERO cpu_to_le32(0x00000111) 70 + #define STATUS_PAGE_FAULT_COPY_ON_WRITE cpu_to_le32(0x00000112) 71 + #define STATUS_PAGE_FAULT_GUARD_PAGE cpu_to_le32(0x00000113) 72 + #define STATUS_PAGE_FAULT_PAGING_FILE cpu_to_le32(0x00000114) 73 + #define STATUS_CACHE_PAGE_LOCKED cpu_to_le32(0x00000115) 74 + #define STATUS_CRASH_DUMP cpu_to_le32(0x00000116) 75 + #define STATUS_BUFFER_ALL_ZEROS cpu_to_le32(0x00000117) 76 + #define STATUS_REPARSE_OBJECT cpu_to_le32(0x00000118) 77 + #define STATUS_RESOURCE_REQUIREMENTS_CHANGED cpu_to_le32(0x00000119) 78 + #define STATUS_TRANSLATION_COMPLETE cpu_to_le32(0x00000120) 79 + #define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY cpu_to_le32(0x00000121) 80 + #define STATUS_NOTHING_TO_TERMINATE cpu_to_le32(0x00000122) 81 + #define STATUS_PROCESS_NOT_IN_JOB cpu_to_le32(0x00000123) 82 + #define STATUS_PROCESS_IN_JOB cpu_to_le32(0x00000124) 83 + #define STATUS_VOLSNAP_HIBERNATE_READY cpu_to_le32(0x00000125) 84 + #define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY cpu_to_le32(0x00000126) 85 + #define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED cpu_to_le32(0x00000127) 86 + #define STATUS_INTERRUPT_STILL_CONNECTED cpu_to_le32(0x00000128) 87 + #define STATUS_PROCESS_CLONED cpu_to_le32(0x00000129) 88 + #define STATUS_FILE_LOCKED_WITH_ONLY_READERS cpu_to_le32(0x0000012A) 89 + #define STATUS_FILE_LOCKED_WITH_WRITERS cpu_to_le32(0x0000012B) 90 + #define STATUS_RESOURCEMANAGER_READ_ONLY cpu_to_le32(0x00000202) 91 + #define STATUS_WAIT_FOR_OPLOCK cpu_to_le32(0x00000367) 92 + #define DBG_EXCEPTION_HANDLED cpu_to_le32(0x00010001) 93 + #define DBG_CONTINUE cpu_to_le32(0x00010002) 94 + #define STATUS_FLT_IO_COMPLETE cpu_to_le32(0x001C0001) 95 + #define STATUS_OBJECT_NAME_EXISTS cpu_to_le32(0x40000000) 96 + #define STATUS_THREAD_WAS_SUSPENDED cpu_to_le32(0x40000001) 97 + #define STATUS_WORKING_SET_LIMIT_RANGE cpu_to_le32(0x40000002) 98 + #define STATUS_IMAGE_NOT_AT_BASE cpu_to_le32(0x40000003) 99 + #define STATUS_RXACT_STATE_CREATED cpu_to_le32(0x40000004) 100 + #define STATUS_SEGMENT_NOTIFICATION cpu_to_le32(0x40000005) 101 + #define STATUS_LOCAL_USER_SESSION_KEY cpu_to_le32(0x40000006) 102 + #define STATUS_BAD_CURRENT_DIRECTORY cpu_to_le32(0x40000007) 103 + #define STATUS_SERIAL_MORE_WRITES cpu_to_le32(0x40000008) 104 + #define STATUS_REGISTRY_RECOVERED cpu_to_le32(0x40000009) 105 + #define STATUS_FT_READ_RECOVERY_FROM_BACKUP cpu_to_le32(0x4000000A) 106 + #define STATUS_FT_WRITE_RECOVERY cpu_to_le32(0x4000000B) 107 + #define STATUS_SERIAL_COUNTER_TIMEOUT cpu_to_le32(0x4000000C) 108 + #define STATUS_NULL_LM_PASSWORD cpu_to_le32(0x4000000D) 109 + #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH cpu_to_le32(0x4000000E) 110 + #define STATUS_RECEIVE_PARTIAL cpu_to_le32(0x4000000F) 111 + #define STATUS_RECEIVE_EXPEDITED cpu_to_le32(0x40000010) 112 + #define STATUS_RECEIVE_PARTIAL_EXPEDITED cpu_to_le32(0x40000011) 113 + #define STATUS_EVENT_DONE cpu_to_le32(0x40000012) 114 + #define STATUS_EVENT_PENDING cpu_to_le32(0x40000013) 115 + #define STATUS_CHECKING_FILE_SYSTEM cpu_to_le32(0x40000014) 116 + #define STATUS_FATAL_APP_EXIT cpu_to_le32(0x40000015) 117 + #define STATUS_PREDEFINED_HANDLE cpu_to_le32(0x40000016) 118 + #define STATUS_WAS_UNLOCKED cpu_to_le32(0x40000017) 119 + #define STATUS_SERVICE_NOTIFICATION cpu_to_le32(0x40000018) 120 + #define STATUS_WAS_LOCKED cpu_to_le32(0x40000019) 121 + #define STATUS_LOG_HARD_ERROR cpu_to_le32(0x4000001A) 122 + #define STATUS_ALREADY_WIN32 cpu_to_le32(0x4000001B) 123 + #define STATUS_WX86_UNSIMULATE cpu_to_le32(0x4000001C) 124 + #define STATUS_WX86_CONTINUE cpu_to_le32(0x4000001D) 125 + #define STATUS_WX86_SINGLE_STEP cpu_to_le32(0x4000001E) 126 + #define STATUS_WX86_BREAKPOINT cpu_to_le32(0x4000001F) 127 + #define STATUS_WX86_EXCEPTION_CONTINUE cpu_to_le32(0x40000020) 128 + #define STATUS_WX86_EXCEPTION_LASTCHANCE cpu_to_le32(0x40000021) 129 + #define STATUS_WX86_EXCEPTION_CHAIN cpu_to_le32(0x40000022) 130 + #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE cpu_to_le32(0x40000023) 131 + #define STATUS_NO_YIELD_PERFORMED cpu_to_le32(0x40000024) 132 + #define STATUS_TIMER_RESUME_IGNORED cpu_to_le32(0x40000025) 133 + #define STATUS_ARBITRATION_UNHANDLED cpu_to_le32(0x40000026) 134 + #define STATUS_CARDBUS_NOT_SUPPORTED cpu_to_le32(0x40000027) 135 + #define STATUS_WX86_CREATEWX86TIB cpu_to_le32(0x40000028) 136 + #define STATUS_MP_PROCESSOR_MISMATCH cpu_to_le32(0x40000029) 137 + #define STATUS_HIBERNATED cpu_to_le32(0x4000002A) 138 + #define STATUS_RESUME_HIBERNATION cpu_to_le32(0x4000002B) 139 + #define STATUS_FIRMWARE_UPDATED cpu_to_le32(0x4000002C) 140 + #define STATUS_DRIVERS_LEAKING_LOCKED_PAGES cpu_to_le32(0x4000002D) 141 + #define STATUS_MESSAGE_RETRIEVED cpu_to_le32(0x4000002E) 142 + #define STATUS_SYSTEM_POWERSTATE_TRANSITION cpu_to_le32(0x4000002F) 143 + #define STATUS_ALPC_CHECK_COMPLETION_LIST cpu_to_le32(0x40000030) 144 + #define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION cpu_to_le32(0x40000031) 145 + #define STATUS_ACCESS_AUDIT_BY_POLICY cpu_to_le32(0x40000032) 146 + #define STATUS_ABANDON_HIBERFILE cpu_to_le32(0x40000033) 147 + #define STATUS_BIZRULES_NOT_ENABLED cpu_to_le32(0x40000034) 148 + #define STATUS_WAKE_SYSTEM cpu_to_le32(0x40000294) 149 + #define STATUS_DS_SHUTTING_DOWN cpu_to_le32(0x40000370) 150 + #define DBG_REPLY_LATER cpu_to_le32(0x40010001) 151 + #define DBG_UNABLE_TO_PROVIDE_HANDLE cpu_to_le32(0x40010002) 152 + #define DBG_TERMINATE_THREAD cpu_to_le32(0x40010003) 153 + #define DBG_TERMINATE_PROCESS cpu_to_le32(0x40010004) 154 + #define DBG_CONTROL_C cpu_to_le32(0x40010005) 155 + #define DBG_PRINTEXCEPTION_C cpu_to_le32(0x40010006) 156 + #define DBG_RIPEXCEPTION cpu_to_le32(0x40010007) 157 + #define DBG_CONTROL_BREAK cpu_to_le32(0x40010008) 158 + #define DBG_COMMAND_EXCEPTION cpu_to_le32(0x40010009) 159 + #define RPC_NT_UUID_LOCAL_ONLY cpu_to_le32(0x40020056) 160 + #define RPC_NT_SEND_INCOMPLETE cpu_to_le32(0x400200AF) 161 + #define STATUS_CTX_CDM_CONNECT cpu_to_le32(0x400A0004) 162 + #define STATUS_CTX_CDM_DISCONNECT cpu_to_le32(0x400A0005) 163 + #define STATUS_SXS_RELEASE_ACTIVATION_CONTEXT cpu_to_le32(0x4015000D) 164 + #define STATUS_RECOVERY_NOT_NEEDED cpu_to_le32(0x40190034) 165 + #define STATUS_RM_ALREADY_STARTED cpu_to_le32(0x40190035) 166 + #define STATUS_LOG_NO_RESTART cpu_to_le32(0x401A000C) 167 + #define STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST cpu_to_le32(0x401B00EC) 168 + #define STATUS_GRAPHICS_PARTIAL_DATA_POPULATED cpu_to_le32(0x401E000A) 169 + #define STATUS_GRAPHICS_DRIVER_MISMATCH cpu_to_le32(0x401E0117) 170 + #define STATUS_GRAPHICS_MODE_NOT_PINNED cpu_to_le32(0x401E0307) 171 + #define STATUS_GRAPHICS_NO_PREFERRED_MODE cpu_to_le32(0x401E031E) 172 + #define STATUS_GRAPHICS_DATASET_IS_EMPTY cpu_to_le32(0x401E034B) 173 + #define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET cpu_to_le32(0x401E034C) 174 + #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED cpu_to_le32(0x401E0351) 175 + #define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS cpu_to_le32(0x401E042F) 176 + #define STATUS_GRAPHICS_LEADLINK_START_DEFERRED cpu_to_le32(0x401E0437) 177 + #define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY cpu_to_le32(0x401E0439) 178 + #define STATUS_GRAPHICS_START_DEFERRED cpu_to_le32(0x401E043A) 179 + #define STATUS_NDIS_INDICATION_REQUIRED cpu_to_le32(0x40230001) 180 + #define STATUS_GUARD_PAGE_VIOLATION cpu_to_le32(0x80000001) 181 + #define STATUS_DATATYPE_MISALIGNMENT cpu_to_le32(0x80000002) 182 + #define STATUS_BREAKPOINT cpu_to_le32(0x80000003) 183 + #define STATUS_SINGLE_STEP cpu_to_le32(0x80000004) 184 + #define STATUS_BUFFER_OVERFLOW cpu_to_le32(0x80000005) 185 + #define STATUS_NO_MORE_FILES cpu_to_le32(0x80000006) 186 + #define STATUS_WAKE_SYSTEM_DEBUGGER cpu_to_le32(0x80000007) 187 + #define STATUS_HANDLES_CLOSED cpu_to_le32(0x8000000A) 188 + #define STATUS_NO_INHERITANCE cpu_to_le32(0x8000000B) 189 + #define STATUS_GUID_SUBSTITUTION_MADE cpu_to_le32(0x8000000C) 190 + #define STATUS_PARTIAL_COPY cpu_to_le32(0x8000000D) 191 + #define STATUS_DEVICE_PAPER_EMPTY cpu_to_le32(0x8000000E) 192 + #define STATUS_DEVICE_POWERED_OFF cpu_to_le32(0x8000000F) 193 + #define STATUS_DEVICE_OFF_LINE cpu_to_le32(0x80000010) 194 + #define STATUS_DEVICE_BUSY cpu_to_le32(0x80000011) 195 + #define STATUS_NO_MORE_EAS cpu_to_le32(0x80000012) 196 + #define STATUS_INVALID_EA_NAME cpu_to_le32(0x80000013) 197 + #define STATUS_EA_LIST_INCONSISTENT cpu_to_le32(0x80000014) 198 + #define STATUS_INVALID_EA_FLAG cpu_to_le32(0x80000015) 199 + #define STATUS_VERIFY_REQUIRED cpu_to_le32(0x80000016) 200 + #define STATUS_EXTRANEOUS_INFORMATION cpu_to_le32(0x80000017) 201 + #define STATUS_RXACT_COMMIT_NECESSARY cpu_to_le32(0x80000018) 202 + #define STATUS_NO_MORE_ENTRIES cpu_to_le32(0x8000001A) 203 + #define STATUS_FILEMARK_DETECTED cpu_to_le32(0x8000001B) 204 + #define STATUS_MEDIA_CHANGED cpu_to_le32(0x8000001C) 205 + #define STATUS_BUS_RESET cpu_to_le32(0x8000001D) 206 + #define STATUS_END_OF_MEDIA cpu_to_le32(0x8000001E) 207 + #define STATUS_BEGINNING_OF_MEDIA cpu_to_le32(0x8000001F) 208 + #define STATUS_MEDIA_CHECK cpu_to_le32(0x80000020) 209 + #define STATUS_SETMARK_DETECTED cpu_to_le32(0x80000021) 210 + #define STATUS_NO_DATA_DETECTED cpu_to_le32(0x80000022) 211 + #define STATUS_REDIRECTOR_HAS_OPEN_HANDLES cpu_to_le32(0x80000023) 212 + #define STATUS_SERVER_HAS_OPEN_HANDLES cpu_to_le32(0x80000024) 213 + #define STATUS_ALREADY_DISCONNECTED cpu_to_le32(0x80000025) 214 + #define STATUS_LONGJUMP cpu_to_le32(0x80000026) 215 + #define STATUS_CLEANER_CARTRIDGE_INSTALLED cpu_to_le32(0x80000027) 216 + #define STATUS_PLUGPLAY_QUERY_VETOED cpu_to_le32(0x80000028) 217 + #define STATUS_UNWIND_CONSOLIDATE cpu_to_le32(0x80000029) 218 + #define STATUS_REGISTRY_HIVE_RECOVERED cpu_to_le32(0x8000002A) 219 + #define STATUS_DLL_MIGHT_BE_INSECURE cpu_to_le32(0x8000002B) 220 + #define STATUS_DLL_MIGHT_BE_INCOMPATIBLE cpu_to_le32(0x8000002C) 221 + #define STATUS_STOPPED_ON_SYMLINK cpu_to_le32(0x8000002D) 222 + #define STATUS_DEVICE_REQUIRES_CLEANING cpu_to_le32(0x80000288) 223 + #define STATUS_DEVICE_DOOR_OPEN cpu_to_le32(0x80000289) 224 + #define STATUS_DATA_LOST_REPAIR cpu_to_le32(0x80000803) 225 + #define DBG_EXCEPTION_NOT_HANDLED cpu_to_le32(0x80010001) 226 + #define STATUS_CLUSTER_NODE_ALREADY_UP cpu_to_le32(0x80130001) 227 + #define STATUS_CLUSTER_NODE_ALREADY_DOWN cpu_to_le32(0x80130002) 228 + #define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE cpu_to_le32(0x80130003) 229 + #define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE cpu_to_le32(0x80130004) 230 + #define STATUS_CLUSTER_NODE_ALREADY_MEMBER cpu_to_le32(0x80130005) 231 + #define STATUS_COULD_NOT_RESIZE_LOG cpu_to_le32(0x80190009) 232 + #define STATUS_NO_TXF_METADATA cpu_to_le32(0x80190029) 233 + #define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN cpu_to_le32(0x80190031) 234 + #define STATUS_TXF_METADATA_ALREADY_PRESENT cpu_to_le32(0x80190041) 235 + #define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET cpu_to_le32(0x80190042) 236 + #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED cpu_to_le32(0x801B00EB) 237 + #define STATUS_FLT_BUFFER_TOO_SMALL cpu_to_le32(0x801C0001) 238 + #define STATUS_FVE_PARTIAL_METADATA cpu_to_le32(0x80210001) 239 + #define STATUS_UNSUCCESSFUL cpu_to_le32(0xC0000001) 240 + #define STATUS_NOT_IMPLEMENTED cpu_to_le32(0xC0000002) 241 + #define STATUS_INVALID_INFO_CLASS cpu_to_le32(0xC0000003) 242 + #define STATUS_INFO_LENGTH_MISMATCH cpu_to_le32(0xC0000004) 243 + #define STATUS_ACCESS_VIOLATION cpu_to_le32(0xC0000005) 244 + #define STATUS_IN_PAGE_ERROR cpu_to_le32(0xC0000006) 245 + #define STATUS_PAGEFILE_QUOTA cpu_to_le32(0xC0000007) 246 + #define STATUS_INVALID_HANDLE cpu_to_le32(0xC0000008) 247 + #define STATUS_BAD_INITIAL_STACK cpu_to_le32(0xC0000009) 248 + #define STATUS_BAD_INITIAL_PC cpu_to_le32(0xC000000A) 249 + #define STATUS_INVALID_CID cpu_to_le32(0xC000000B) 250 + #define STATUS_TIMER_NOT_CANCELED cpu_to_le32(0xC000000C) 251 + #define STATUS_INVALID_PARAMETER cpu_to_le32(0xC000000D) 252 + #define STATUS_NO_SUCH_DEVICE cpu_to_le32(0xC000000E) 253 + #define STATUS_NO_SUCH_FILE cpu_to_le32(0xC000000F) 254 + #define STATUS_INVALID_DEVICE_REQUEST cpu_to_le32(0xC0000010) 255 + #define STATUS_END_OF_FILE cpu_to_le32(0xC0000011) 256 + #define STATUS_WRONG_VOLUME cpu_to_le32(0xC0000012) 257 + #define STATUS_NO_MEDIA_IN_DEVICE cpu_to_le32(0xC0000013) 258 + #define STATUS_UNRECOGNIZED_MEDIA cpu_to_le32(0xC0000014) 259 + #define STATUS_NONEXISTENT_SECTOR cpu_to_le32(0xC0000015) 260 + #define STATUS_MORE_PROCESSING_REQUIRED cpu_to_le32(0xC0000016) 261 + #define STATUS_NO_MEMORY cpu_to_le32(0xC0000017) 262 + #define STATUS_CONFLICTING_ADDRESSES cpu_to_le32(0xC0000018) 263 + #define STATUS_NOT_MAPPED_VIEW cpu_to_le32(0xC0000019) 264 + #define STATUS_UNABLE_TO_FREE_VM cpu_to_le32(0xC000001A) 265 + #define STATUS_UNABLE_TO_DELETE_SECTION cpu_to_le32(0xC000001B) 266 + #define STATUS_INVALID_SYSTEM_SERVICE cpu_to_le32(0xC000001C) 267 + #define STATUS_ILLEGAL_INSTRUCTION cpu_to_le32(0xC000001D) 268 + #define STATUS_INVALID_LOCK_SEQUENCE cpu_to_le32(0xC000001E) 269 + #define STATUS_INVALID_VIEW_SIZE cpu_to_le32(0xC000001F) 270 + #define STATUS_INVALID_FILE_FOR_SECTION cpu_to_le32(0xC0000020) 271 + #define STATUS_ALREADY_COMMITTED cpu_to_le32(0xC0000021) 272 + #define STATUS_ACCESS_DENIED cpu_to_le32(0xC0000022) 273 + #define STATUS_BUFFER_TOO_SMALL cpu_to_le32(0xC0000023) 274 + #define STATUS_OBJECT_TYPE_MISMATCH cpu_to_le32(0xC0000024) 275 + #define STATUS_NONCONTINUABLE_EXCEPTION cpu_to_le32(0xC0000025) 276 + #define STATUS_INVALID_DISPOSITION cpu_to_le32(0xC0000026) 277 + #define STATUS_UNWIND cpu_to_le32(0xC0000027) 278 + #define STATUS_BAD_STACK cpu_to_le32(0xC0000028) 279 + #define STATUS_INVALID_UNWIND_TARGET cpu_to_le32(0xC0000029) 280 + #define STATUS_NOT_LOCKED cpu_to_le32(0xC000002A) 281 + #define STATUS_PARITY_ERROR cpu_to_le32(0xC000002B) 282 + #define STATUS_UNABLE_TO_DECOMMIT_VM cpu_to_le32(0xC000002C) 283 + #define STATUS_NOT_COMMITTED cpu_to_le32(0xC000002D) 284 + #define STATUS_INVALID_PORT_ATTRIBUTES cpu_to_le32(0xC000002E) 285 + #define STATUS_PORT_MESSAGE_TOO_LONG cpu_to_le32(0xC000002F) 286 + #define STATUS_INVALID_PARAMETER_MIX cpu_to_le32(0xC0000030) 287 + #define STATUS_INVALID_QUOTA_LOWER cpu_to_le32(0xC0000031) 288 + #define STATUS_DISK_CORRUPT_ERROR cpu_to_le32(0xC0000032) 289 + #define STATUS_OBJECT_NAME_INVALID cpu_to_le32(0xC0000033) 290 + #define STATUS_OBJECT_NAME_NOT_FOUND cpu_to_le32(0xC0000034) 291 + #define STATUS_OBJECT_NAME_COLLISION cpu_to_le32(0xC0000035) 292 + #define STATUS_PORT_DISCONNECTED cpu_to_le32(0xC0000037) 293 + #define STATUS_DEVICE_ALREADY_ATTACHED cpu_to_le32(0xC0000038) 294 + #define STATUS_OBJECT_PATH_INVALID cpu_to_le32(0xC0000039) 295 + #define STATUS_OBJECT_PATH_NOT_FOUND cpu_to_le32(0xC000003A) 296 + #define STATUS_OBJECT_PATH_SYNTAX_BAD cpu_to_le32(0xC000003B) 297 + #define STATUS_DATA_OVERRUN cpu_to_le32(0xC000003C) 298 + #define STATUS_DATA_LATE_ERROR cpu_to_le32(0xC000003D) 299 + #define STATUS_DATA_ERROR cpu_to_le32(0xC000003E) 300 + #define STATUS_CRC_ERROR cpu_to_le32(0xC000003F) 301 + #define STATUS_SECTION_TOO_BIG cpu_to_le32(0xC0000040) 302 + #define STATUS_PORT_CONNECTION_REFUSED cpu_to_le32(0xC0000041) 303 + #define STATUS_INVALID_PORT_HANDLE cpu_to_le32(0xC0000042) 304 + #define STATUS_SHARING_VIOLATION cpu_to_le32(0xC0000043) 305 + #define STATUS_QUOTA_EXCEEDED cpu_to_le32(0xC0000044) 306 + #define STATUS_INVALID_PAGE_PROTECTION cpu_to_le32(0xC0000045) 307 + #define STATUS_MUTANT_NOT_OWNED cpu_to_le32(0xC0000046) 308 + #define STATUS_SEMAPHORE_LIMIT_EXCEEDED cpu_to_le32(0xC0000047) 309 + #define STATUS_PORT_ALREADY_SET cpu_to_le32(0xC0000048) 310 + #define STATUS_SECTION_NOT_IMAGE cpu_to_le32(0xC0000049) 311 + #define STATUS_SUSPEND_COUNT_EXCEEDED cpu_to_le32(0xC000004A) 312 + #define STATUS_THREAD_IS_TERMINATING cpu_to_le32(0xC000004B) 313 + #define STATUS_BAD_WORKING_SET_LIMIT cpu_to_le32(0xC000004C) 314 + #define STATUS_INCOMPATIBLE_FILE_MAP cpu_to_le32(0xC000004D) 315 + #define STATUS_SECTION_PROTECTION cpu_to_le32(0xC000004E) 316 + #define STATUS_EAS_NOT_SUPPORTED cpu_to_le32(0xC000004F) 317 + #define STATUS_EA_TOO_LARGE cpu_to_le32(0xC0000050) 318 + #define STATUS_NONEXISTENT_EA_ENTRY cpu_to_le32(0xC0000051) 319 + #define STATUS_NO_EAS_ON_FILE cpu_to_le32(0xC0000052) 320 + #define STATUS_EA_CORRUPT_ERROR cpu_to_le32(0xC0000053) 321 + #define STATUS_FILE_LOCK_CONFLICT cpu_to_le32(0xC0000054) 322 + #define STATUS_LOCK_NOT_GRANTED cpu_to_le32(0xC0000055) 323 + #define STATUS_DELETE_PENDING cpu_to_le32(0xC0000056) 324 + #define STATUS_CTL_FILE_NOT_SUPPORTED cpu_to_le32(0xC0000057) 325 + #define STATUS_UNKNOWN_REVISION cpu_to_le32(0xC0000058) 326 + #define STATUS_REVISION_MISMATCH cpu_to_le32(0xC0000059) 327 + #define STATUS_INVALID_OWNER cpu_to_le32(0xC000005A) 328 + #define STATUS_INVALID_PRIMARY_GROUP cpu_to_le32(0xC000005B) 329 + #define STATUS_NO_IMPERSONATION_TOKEN cpu_to_le32(0xC000005C) 330 + #define STATUS_CANT_DISABLE_MANDATORY cpu_to_le32(0xC000005D) 331 + #define STATUS_NO_LOGON_SERVERS cpu_to_le32(0xC000005E) 332 + #define STATUS_NO_SUCH_LOGON_SESSION cpu_to_le32(0xC000005F) 333 + #define STATUS_NO_SUCH_PRIVILEGE cpu_to_le32(0xC0000060) 334 + #define STATUS_PRIVILEGE_NOT_HELD cpu_to_le32(0xC0000061) 335 + #define STATUS_INVALID_ACCOUNT_NAME cpu_to_le32(0xC0000062) 336 + #define STATUS_USER_EXISTS cpu_to_le32(0xC0000063) 337 + #define STATUS_NO_SUCH_USER cpu_to_le32(0xC0000064) 338 + #define STATUS_GROUP_EXISTS cpu_to_le32(0xC0000065) 339 + #define STATUS_NO_SUCH_GROUP cpu_to_le32(0xC0000066) 340 + #define STATUS_MEMBER_IN_GROUP cpu_to_le32(0xC0000067) 341 + #define STATUS_MEMBER_NOT_IN_GROUP cpu_to_le32(0xC0000068) 342 + #define STATUS_LAST_ADMIN cpu_to_le32(0xC0000069) 343 + #define STATUS_WRONG_PASSWORD cpu_to_le32(0xC000006A) 344 + #define STATUS_ILL_FORMED_PASSWORD cpu_to_le32(0xC000006B) 345 + #define STATUS_PASSWORD_RESTRICTION cpu_to_le32(0xC000006C) 346 + #define STATUS_LOGON_FAILURE cpu_to_le32(0xC000006D) 347 + #define STATUS_ACCOUNT_RESTRICTION cpu_to_le32(0xC000006E) 348 + #define STATUS_INVALID_LOGON_HOURS cpu_to_le32(0xC000006F) 349 + #define STATUS_INVALID_WORKSTATION cpu_to_le32(0xC0000070) 350 + #define STATUS_PASSWORD_EXPIRED cpu_to_le32(0xC0000071) 351 + #define STATUS_ACCOUNT_DISABLED cpu_to_le32(0xC0000072) 352 + #define STATUS_NONE_MAPPED cpu_to_le32(0xC0000073) 353 + #define STATUS_TOO_MANY_LUIDS_REQUESTED cpu_to_le32(0xC0000074) 354 + #define STATUS_LUIDS_EXHAUSTED cpu_to_le32(0xC0000075) 355 + #define STATUS_INVALID_SUB_AUTHORITY cpu_to_le32(0xC0000076) 356 + #define STATUS_INVALID_ACL cpu_to_le32(0xC0000077) 357 + #define STATUS_INVALID_SID cpu_to_le32(0xC0000078) 358 + #define STATUS_INVALID_SECURITY_DESCR cpu_to_le32(0xC0000079) 359 + #define STATUS_PROCEDURE_NOT_FOUND cpu_to_le32(0xC000007A) 360 + #define STATUS_INVALID_IMAGE_FORMAT cpu_to_le32(0xC000007B) 361 + #define STATUS_NO_TOKEN cpu_to_le32(0xC000007C) 362 + #define STATUS_BAD_INHERITANCE_ACL cpu_to_le32(0xC000007D) 363 + #define STATUS_RANGE_NOT_LOCKED cpu_to_le32(0xC000007E) 364 + #define STATUS_DISK_FULL cpu_to_le32(0xC000007F) 365 + #define STATUS_SERVER_DISABLED cpu_to_le32(0xC0000080) 366 + #define STATUS_SERVER_NOT_DISABLED cpu_to_le32(0xC0000081) 367 + #define STATUS_TOO_MANY_GUIDS_REQUESTED cpu_to_le32(0xC0000082) 368 + #define STATUS_GUIDS_EXHAUSTED cpu_to_le32(0xC0000083) 369 + #define STATUS_INVALID_ID_AUTHORITY cpu_to_le32(0xC0000084) 370 + #define STATUS_AGENTS_EXHAUSTED cpu_to_le32(0xC0000085) 371 + #define STATUS_INVALID_VOLUME_LABEL cpu_to_le32(0xC0000086) 372 + #define STATUS_SECTION_NOT_EXTENDED cpu_to_le32(0xC0000087) 373 + #define STATUS_NOT_MAPPED_DATA cpu_to_le32(0xC0000088) 374 + #define STATUS_RESOURCE_DATA_NOT_FOUND cpu_to_le32(0xC0000089) 375 + #define STATUS_RESOURCE_TYPE_NOT_FOUND cpu_to_le32(0xC000008A) 376 + #define STATUS_RESOURCE_NAME_NOT_FOUND cpu_to_le32(0xC000008B) 377 + #define STATUS_ARRAY_BOUNDS_EXCEEDED cpu_to_le32(0xC000008C) 378 + #define STATUS_FLOAT_DENORMAL_OPERAND cpu_to_le32(0xC000008D) 379 + #define STATUS_FLOAT_DIVIDE_BY_ZERO cpu_to_le32(0xC000008E) 380 + #define STATUS_FLOAT_INEXACT_RESULT cpu_to_le32(0xC000008F) 381 + #define STATUS_FLOAT_INVALID_OPERATION cpu_to_le32(0xC0000090) 382 + #define STATUS_FLOAT_OVERFLOW cpu_to_le32(0xC0000091) 383 + #define STATUS_FLOAT_STACK_CHECK cpu_to_le32(0xC0000092) 384 + #define STATUS_FLOAT_UNDERFLOW cpu_to_le32(0xC0000093) 385 + #define STATUS_INTEGER_DIVIDE_BY_ZERO cpu_to_le32(0xC0000094) 386 + #define STATUS_INTEGER_OVERFLOW cpu_to_le32(0xC0000095) 387 + #define STATUS_PRIVILEGED_INSTRUCTION cpu_to_le32(0xC0000096) 388 + #define STATUS_TOO_MANY_PAGING_FILES cpu_to_le32(0xC0000097) 389 + #define STATUS_FILE_INVALID cpu_to_le32(0xC0000098) 390 + #define STATUS_ALLOTTED_SPACE_EXCEEDED cpu_to_le32(0xC0000099) 391 + #define STATUS_INSUFFICIENT_RESOURCES cpu_to_le32(0xC000009A) 392 + #define STATUS_DFS_EXIT_PATH_FOUND cpu_to_le32(0xC000009B) 393 + #define STATUS_DEVICE_DATA_ERROR cpu_to_le32(0xC000009C) 394 + #define STATUS_DEVICE_NOT_CONNECTED cpu_to_le32(0xC000009D) 395 + #define STATUS_DEVICE_POWER_FAILURE cpu_to_le32(0xC000009E) 396 + #define STATUS_FREE_VM_NOT_AT_BASE cpu_to_le32(0xC000009F) 397 + #define STATUS_MEMORY_NOT_ALLOCATED cpu_to_le32(0xC00000A0) 398 + #define STATUS_WORKING_SET_QUOTA cpu_to_le32(0xC00000A1) 399 + #define STATUS_MEDIA_WRITE_PROTECTED cpu_to_le32(0xC00000A2) 400 + #define STATUS_DEVICE_NOT_READY cpu_to_le32(0xC00000A3) 401 + #define STATUS_INVALID_GROUP_ATTRIBUTES cpu_to_le32(0xC00000A4) 402 + #define STATUS_BAD_IMPERSONATION_LEVEL cpu_to_le32(0xC00000A5) 403 + #define STATUS_CANT_OPEN_ANONYMOUS cpu_to_le32(0xC00000A6) 404 + #define STATUS_BAD_VALIDATION_CLASS cpu_to_le32(0xC00000A7) 405 + #define STATUS_BAD_TOKEN_TYPE cpu_to_le32(0xC00000A8) 406 + #define STATUS_BAD_MASTER_BOOT_RECORD cpu_to_le32(0xC00000A9) 407 + #define STATUS_INSTRUCTION_MISALIGNMENT cpu_to_le32(0xC00000AA) 408 + #define STATUS_INSTANCE_NOT_AVAILABLE cpu_to_le32(0xC00000AB) 409 + #define STATUS_PIPE_NOT_AVAILABLE cpu_to_le32(0xC00000AC) 410 + #define STATUS_INVALID_PIPE_STATE cpu_to_le32(0xC00000AD) 411 + #define STATUS_PIPE_BUSY cpu_to_le32(0xC00000AE) 412 + #define STATUS_ILLEGAL_FUNCTION cpu_to_le32(0xC00000AF) 413 + #define STATUS_PIPE_DISCONNECTED cpu_to_le32(0xC00000B0) 414 + #define STATUS_PIPE_CLOSING cpu_to_le32(0xC00000B1) 415 + #define STATUS_PIPE_CONNECTED cpu_to_le32(0xC00000B2) 416 + #define STATUS_PIPE_LISTENING cpu_to_le32(0xC00000B3) 417 + #define STATUS_INVALID_READ_MODE cpu_to_le32(0xC00000B4) 418 + #define STATUS_IO_TIMEOUT cpu_to_le32(0xC00000B5) 419 + #define STATUS_FILE_FORCED_CLOSED cpu_to_le32(0xC00000B6) 420 + #define STATUS_PROFILING_NOT_STARTED cpu_to_le32(0xC00000B7) 421 + #define STATUS_PROFILING_NOT_STOPPED cpu_to_le32(0xC00000B8) 422 + #define STATUS_COULD_NOT_INTERPRET cpu_to_le32(0xC00000B9) 423 + #define STATUS_FILE_IS_A_DIRECTORY cpu_to_le32(0xC00000BA) 424 + #define STATUS_NOT_SUPPORTED cpu_to_le32(0xC00000BB) 425 + #define STATUS_REMOTE_NOT_LISTENING cpu_to_le32(0xC00000BC) 426 + #define STATUS_DUPLICATE_NAME cpu_to_le32(0xC00000BD) 427 + #define STATUS_BAD_NETWORK_PATH cpu_to_le32(0xC00000BE) 428 + #define STATUS_NETWORK_BUSY cpu_to_le32(0xC00000BF) 429 + #define STATUS_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC00000C0) 430 + #define STATUS_TOO_MANY_COMMANDS cpu_to_le32(0xC00000C1) 431 + #define STATUS_ADAPTER_HARDWARE_ERROR cpu_to_le32(0xC00000C2) 432 + #define STATUS_INVALID_NETWORK_RESPONSE cpu_to_le32(0xC00000C3) 433 + #define STATUS_UNEXPECTED_NETWORK_ERROR cpu_to_le32(0xC00000C4) 434 + #define STATUS_BAD_REMOTE_ADAPTER cpu_to_le32(0xC00000C5) 435 + #define STATUS_PRINT_QUEUE_FULL cpu_to_le32(0xC00000C6) 436 + #define STATUS_NO_SPOOL_SPACE cpu_to_le32(0xC00000C7) 437 + #define STATUS_PRINT_CANCELLED cpu_to_le32(0xC00000C8) 438 + #define STATUS_NETWORK_NAME_DELETED cpu_to_le32(0xC00000C9) 439 + #define STATUS_NETWORK_ACCESS_DENIED cpu_to_le32(0xC00000CA) 440 + #define STATUS_BAD_DEVICE_TYPE cpu_to_le32(0xC00000CB) 441 + #define STATUS_BAD_NETWORK_NAME cpu_to_le32(0xC00000CC) 442 + #define STATUS_TOO_MANY_NAMES cpu_to_le32(0xC00000CD) 443 + #define STATUS_TOO_MANY_SESSIONS cpu_to_le32(0xC00000CE) 444 + #define STATUS_SHARING_PAUSED cpu_to_le32(0xC00000CF) 445 + #define STATUS_REQUEST_NOT_ACCEPTED cpu_to_le32(0xC00000D0) 446 + #define STATUS_REDIRECTOR_PAUSED cpu_to_le32(0xC00000D1) 447 + #define STATUS_NET_WRITE_FAULT cpu_to_le32(0xC00000D2) 448 + #define STATUS_PROFILING_AT_LIMIT cpu_to_le32(0xC00000D3) 449 + #define STATUS_NOT_SAME_DEVICE cpu_to_le32(0xC00000D4) 450 + #define STATUS_FILE_RENAMED cpu_to_le32(0xC00000D5) 451 + #define STATUS_VIRTUAL_CIRCUIT_CLOSED cpu_to_le32(0xC00000D6) 452 + #define STATUS_NO_SECURITY_ON_OBJECT cpu_to_le32(0xC00000D7) 453 + #define STATUS_CANT_WAIT cpu_to_le32(0xC00000D8) 454 + #define STATUS_PIPE_EMPTY cpu_to_le32(0xC00000D9) 455 + #define STATUS_CANT_ACCESS_DOMAIN_INFO cpu_to_le32(0xC00000DA) 456 + #define STATUS_CANT_TERMINATE_SELF cpu_to_le32(0xC00000DB) 457 + #define STATUS_INVALID_SERVER_STATE cpu_to_le32(0xC00000DC) 458 + #define STATUS_INVALID_DOMAIN_STATE cpu_to_le32(0xC00000DD) 459 + #define STATUS_INVALID_DOMAIN_ROLE cpu_to_le32(0xC00000DE) 460 + #define STATUS_NO_SUCH_DOMAIN cpu_to_le32(0xC00000DF) 461 + #define STATUS_DOMAIN_EXISTS cpu_to_le32(0xC00000E0) 462 + #define STATUS_DOMAIN_LIMIT_EXCEEDED cpu_to_le32(0xC00000E1) 463 + #define STATUS_OPLOCK_NOT_GRANTED cpu_to_le32(0xC00000E2) 464 + #define STATUS_INVALID_OPLOCK_PROTOCOL cpu_to_le32(0xC00000E3) 465 + #define STATUS_INTERNAL_DB_CORRUPTION cpu_to_le32(0xC00000E4) 466 + #define STATUS_INTERNAL_ERROR cpu_to_le32(0xC00000E5) 467 + #define STATUS_GENERIC_NOT_MAPPED cpu_to_le32(0xC00000E6) 468 + #define STATUS_BAD_DESCRIPTOR_FORMAT cpu_to_le32(0xC00000E7) 469 + #define STATUS_INVALID_USER_BUFFER cpu_to_le32(0xC00000E8) 470 + #define STATUS_UNEXPECTED_IO_ERROR cpu_to_le32(0xC00000E9) 471 + #define STATUS_UNEXPECTED_MM_CREATE_ERR cpu_to_le32(0xC00000EA) 472 + #define STATUS_UNEXPECTED_MM_MAP_ERROR cpu_to_le32(0xC00000EB) 473 + #define STATUS_UNEXPECTED_MM_EXTEND_ERR cpu_to_le32(0xC00000EC) 474 + #define STATUS_NOT_LOGON_PROCESS cpu_to_le32(0xC00000ED) 475 + #define STATUS_LOGON_SESSION_EXISTS cpu_to_le32(0xC00000EE) 476 + #define STATUS_INVALID_PARAMETER_1 cpu_to_le32(0xC00000EF) 477 + #define STATUS_INVALID_PARAMETER_2 cpu_to_le32(0xC00000F0) 478 + #define STATUS_INVALID_PARAMETER_3 cpu_to_le32(0xC00000F1) 479 + #define STATUS_INVALID_PARAMETER_4 cpu_to_le32(0xC00000F2) 480 + #define STATUS_INVALID_PARAMETER_5 cpu_to_le32(0xC00000F3) 481 + #define STATUS_INVALID_PARAMETER_6 cpu_to_le32(0xC00000F4) 482 + #define STATUS_INVALID_PARAMETER_7 cpu_to_le32(0xC00000F5) 483 + #define STATUS_INVALID_PARAMETER_8 cpu_to_le32(0xC00000F6) 484 + #define STATUS_INVALID_PARAMETER_9 cpu_to_le32(0xC00000F7) 485 + #define STATUS_INVALID_PARAMETER_10 cpu_to_le32(0xC00000F8) 486 + #define STATUS_INVALID_PARAMETER_11 cpu_to_le32(0xC00000F9) 487 + #define STATUS_INVALID_PARAMETER_12 cpu_to_le32(0xC00000FA) 488 + #define STATUS_REDIRECTOR_NOT_STARTED cpu_to_le32(0xC00000FB) 489 + #define STATUS_REDIRECTOR_STARTED cpu_to_le32(0xC00000FC) 490 + #define STATUS_STACK_OVERFLOW cpu_to_le32(0xC00000FD) 491 + #define STATUS_NO_SUCH_PACKAGE cpu_to_le32(0xC00000FE) 492 + #define STATUS_BAD_FUNCTION_TABLE cpu_to_le32(0xC00000FF) 493 + #define STATUS_VARIABLE_NOT_FOUND cpu_to_le32(0xC0000100) 494 + #define STATUS_DIRECTORY_NOT_EMPTY cpu_to_le32(0xC0000101) 495 + #define STATUS_FILE_CORRUPT_ERROR cpu_to_le32(0xC0000102) 496 + #define STATUS_NOT_A_DIRECTORY cpu_to_le32(0xC0000103) 497 + #define STATUS_BAD_LOGON_SESSION_STATE cpu_to_le32(0xC0000104) 498 + #define STATUS_LOGON_SESSION_COLLISION cpu_to_le32(0xC0000105) 499 + #define STATUS_NAME_TOO_LONG cpu_to_le32(0xC0000106) 500 + #define STATUS_FILES_OPEN cpu_to_le32(0xC0000107) 501 + #define STATUS_CONNECTION_IN_USE cpu_to_le32(0xC0000108) 502 + #define STATUS_MESSAGE_NOT_FOUND cpu_to_le32(0xC0000109) 503 + #define STATUS_PROCESS_IS_TERMINATING cpu_to_le32(0xC000010A) 504 + #define STATUS_INVALID_LOGON_TYPE cpu_to_le32(0xC000010B) 505 + #define STATUS_NO_GUID_TRANSLATION cpu_to_le32(0xC000010C) 506 + #define STATUS_CANNOT_IMPERSONATE cpu_to_le32(0xC000010D) 507 + #define STATUS_IMAGE_ALREADY_LOADED cpu_to_le32(0xC000010E) 508 + #define STATUS_ABIOS_NOT_PRESENT cpu_to_le32(0xC000010F) 509 + #define STATUS_ABIOS_LID_NOT_EXIST cpu_to_le32(0xC0000110) 510 + #define STATUS_ABIOS_LID_ALREADY_OWNED cpu_to_le32(0xC0000111) 511 + #define STATUS_ABIOS_NOT_LID_OWNER cpu_to_le32(0xC0000112) 512 + #define STATUS_ABIOS_INVALID_COMMAND cpu_to_le32(0xC0000113) 513 + #define STATUS_ABIOS_INVALID_LID cpu_to_le32(0xC0000114) 514 + #define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE cpu_to_le32(0xC0000115) 515 + #define STATUS_ABIOS_INVALID_SELECTOR cpu_to_le32(0xC0000116) 516 + #define STATUS_NO_LDT cpu_to_le32(0xC0000117) 517 + #define STATUS_INVALID_LDT_SIZE cpu_to_le32(0xC0000118) 518 + #define STATUS_INVALID_LDT_OFFSET cpu_to_le32(0xC0000119) 519 + #define STATUS_INVALID_LDT_DESCRIPTOR cpu_to_le32(0xC000011A) 520 + #define STATUS_INVALID_IMAGE_NE_FORMAT cpu_to_le32(0xC000011B) 521 + #define STATUS_RXACT_INVALID_STATE cpu_to_le32(0xC000011C) 522 + #define STATUS_RXACT_COMMIT_FAILURE cpu_to_le32(0xC000011D) 523 + #define STATUS_MAPPED_FILE_SIZE_ZERO cpu_to_le32(0xC000011E) 524 + #define STATUS_TOO_MANY_OPENED_FILES cpu_to_le32(0xC000011F) 525 + #define STATUS_CANCELLED cpu_to_le32(0xC0000120) 526 + #define STATUS_CANNOT_DELETE cpu_to_le32(0xC0000121) 527 + #define STATUS_INVALID_COMPUTER_NAME cpu_to_le32(0xC0000122) 528 + #define STATUS_FILE_DELETED cpu_to_le32(0xC0000123) 529 + #define STATUS_SPECIAL_ACCOUNT cpu_to_le32(0xC0000124) 530 + #define STATUS_SPECIAL_GROUP cpu_to_le32(0xC0000125) 531 + #define STATUS_SPECIAL_USER cpu_to_le32(0xC0000126) 532 + #define STATUS_MEMBERS_PRIMARY_GROUP cpu_to_le32(0xC0000127) 533 + #define STATUS_FILE_CLOSED cpu_to_le32(0xC0000128) 534 + #define STATUS_TOO_MANY_THREADS cpu_to_le32(0xC0000129) 535 + #define STATUS_THREAD_NOT_IN_PROCESS cpu_to_le32(0xC000012A) 536 + #define STATUS_TOKEN_ALREADY_IN_USE cpu_to_le32(0xC000012B) 537 + #define STATUS_PAGEFILE_QUOTA_EXCEEDED cpu_to_le32(0xC000012C) 538 + #define STATUS_COMMITMENT_LIMIT cpu_to_le32(0xC000012D) 539 + #define STATUS_INVALID_IMAGE_LE_FORMAT cpu_to_le32(0xC000012E) 540 + #define STATUS_INVALID_IMAGE_NOT_MZ cpu_to_le32(0xC000012F) 541 + #define STATUS_INVALID_IMAGE_PROTECT cpu_to_le32(0xC0000130) 542 + #define STATUS_INVALID_IMAGE_WIN_16 cpu_to_le32(0xC0000131) 543 + #define STATUS_LOGON_SERVER_CONFLICT cpu_to_le32(0xC0000132) 544 + #define STATUS_TIME_DIFFERENCE_AT_DC cpu_to_le32(0xC0000133) 545 + #define STATUS_SYNCHRONIZATION_REQUIRED cpu_to_le32(0xC0000134) 546 + #define STATUS_DLL_NOT_FOUND cpu_to_le32(0xC0000135) 547 + #define STATUS_OPEN_FAILED cpu_to_le32(0xC0000136) 548 + #define STATUS_IO_PRIVILEGE_FAILED cpu_to_le32(0xC0000137) 549 + #define STATUS_ORDINAL_NOT_FOUND cpu_to_le32(0xC0000138) 550 + #define STATUS_ENTRYPOINT_NOT_FOUND cpu_to_le32(0xC0000139) 551 + #define STATUS_CONTROL_C_EXIT cpu_to_le32(0xC000013A) 552 + #define STATUS_LOCAL_DISCONNECT cpu_to_le32(0xC000013B) 553 + #define STATUS_REMOTE_DISCONNECT cpu_to_le32(0xC000013C) 554 + #define STATUS_REMOTE_RESOURCES cpu_to_le32(0xC000013D) 555 + #define STATUS_LINK_FAILED cpu_to_le32(0xC000013E) 556 + #define STATUS_LINK_TIMEOUT cpu_to_le32(0xC000013F) 557 + #define STATUS_INVALID_CONNECTION cpu_to_le32(0xC0000140) 558 + #define STATUS_INVALID_ADDRESS cpu_to_le32(0xC0000141) 559 + #define STATUS_DLL_INIT_FAILED cpu_to_le32(0xC0000142) 560 + #define STATUS_MISSING_SYSTEMFILE cpu_to_le32(0xC0000143) 561 + #define STATUS_UNHANDLED_EXCEPTION cpu_to_le32(0xC0000144) 562 + #define STATUS_APP_INIT_FAILURE cpu_to_le32(0xC0000145) 563 + #define STATUS_PAGEFILE_CREATE_FAILED cpu_to_le32(0xC0000146) 564 + #define STATUS_NO_PAGEFILE cpu_to_le32(0xC0000147) 565 + #define STATUS_INVALID_LEVEL cpu_to_le32(0xC0000148) 566 + #define STATUS_WRONG_PASSWORD_CORE cpu_to_le32(0xC0000149) 567 + #define STATUS_ILLEGAL_FLOAT_CONTEXT cpu_to_le32(0xC000014A) 568 + #define STATUS_PIPE_BROKEN cpu_to_le32(0xC000014B) 569 + #define STATUS_REGISTRY_CORRUPT cpu_to_le32(0xC000014C) 570 + #define STATUS_REGISTRY_IO_FAILED cpu_to_le32(0xC000014D) 571 + #define STATUS_NO_EVENT_PAIR cpu_to_le32(0xC000014E) 572 + #define STATUS_UNRECOGNIZED_VOLUME cpu_to_le32(0xC000014F) 573 + #define STATUS_SERIAL_NO_DEVICE_INITED cpu_to_le32(0xC0000150) 574 + #define STATUS_NO_SUCH_ALIAS cpu_to_le32(0xC0000151) 575 + #define STATUS_MEMBER_NOT_IN_ALIAS cpu_to_le32(0xC0000152) 576 + #define STATUS_MEMBER_IN_ALIAS cpu_to_le32(0xC0000153) 577 + #define STATUS_ALIAS_EXISTS cpu_to_le32(0xC0000154) 578 + #define STATUS_LOGON_NOT_GRANTED cpu_to_le32(0xC0000155) 579 + #define STATUS_TOO_MANY_SECRETS cpu_to_le32(0xC0000156) 580 + #define STATUS_SECRET_TOO_LONG cpu_to_le32(0xC0000157) 581 + #define STATUS_INTERNAL_DB_ERROR cpu_to_le32(0xC0000158) 582 + #define STATUS_FULLSCREEN_MODE cpu_to_le32(0xC0000159) 583 + #define STATUS_TOO_MANY_CONTEXT_IDS cpu_to_le32(0xC000015A) 584 + #define STATUS_LOGON_TYPE_NOT_GRANTED cpu_to_le32(0xC000015B) 585 + #define STATUS_NOT_REGISTRY_FILE cpu_to_le32(0xC000015C) 586 + #define STATUS_NT_CROSS_ENCRYPTION_REQUIRED cpu_to_le32(0xC000015D) 587 + #define STATUS_DOMAIN_CTRLR_CONFIG_ERROR cpu_to_le32(0xC000015E) 588 + #define STATUS_FT_MISSING_MEMBER cpu_to_le32(0xC000015F) 589 + #define STATUS_ILL_FORMED_SERVICE_ENTRY cpu_to_le32(0xC0000160) 590 + #define STATUS_ILLEGAL_CHARACTER cpu_to_le32(0xC0000161) 591 + #define STATUS_UNMAPPABLE_CHARACTER cpu_to_le32(0xC0000162) 592 + #define STATUS_UNDEFINED_CHARACTER cpu_to_le32(0xC0000163) 593 + #define STATUS_FLOPPY_VOLUME cpu_to_le32(0xC0000164) 594 + #define STATUS_FLOPPY_ID_MARK_NOT_FOUND cpu_to_le32(0xC0000165) 595 + #define STATUS_FLOPPY_WRONG_CYLINDER cpu_to_le32(0xC0000166) 596 + #define STATUS_FLOPPY_UNKNOWN_ERROR cpu_to_le32(0xC0000167) 597 + #define STATUS_FLOPPY_BAD_REGISTERS cpu_to_le32(0xC0000168) 598 + #define STATUS_DISK_RECALIBRATE_FAILED cpu_to_le32(0xC0000169) 599 + #define STATUS_DISK_OPERATION_FAILED cpu_to_le32(0xC000016A) 600 + #define STATUS_DISK_RESET_FAILED cpu_to_le32(0xC000016B) 601 + #define STATUS_SHARED_IRQ_BUSY cpu_to_le32(0xC000016C) 602 + #define STATUS_FT_ORPHANING cpu_to_le32(0xC000016D) 603 + #define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT cpu_to_le32(0xC000016E) 604 + #define STATUS_PARTITION_FAILURE cpu_to_le32(0xC0000172) 605 + #define STATUS_INVALID_BLOCK_LENGTH cpu_to_le32(0xC0000173) 606 + #define STATUS_DEVICE_NOT_PARTITIONED cpu_to_le32(0xC0000174) 607 + #define STATUS_UNABLE_TO_LOCK_MEDIA cpu_to_le32(0xC0000175) 608 + #define STATUS_UNABLE_TO_UNLOAD_MEDIA cpu_to_le32(0xC0000176) 609 + #define STATUS_EOM_OVERFLOW cpu_to_le32(0xC0000177) 610 + #define STATUS_NO_MEDIA cpu_to_le32(0xC0000178) 611 + #define STATUS_NO_SUCH_MEMBER cpu_to_le32(0xC000017A) 612 + #define STATUS_INVALID_MEMBER cpu_to_le32(0xC000017B) 613 + #define STATUS_KEY_DELETED cpu_to_le32(0xC000017C) 614 + #define STATUS_NO_LOG_SPACE cpu_to_le32(0xC000017D) 615 + #define STATUS_TOO_MANY_SIDS cpu_to_le32(0xC000017E) 616 + #define STATUS_LM_CROSS_ENCRYPTION_REQUIRED cpu_to_le32(0xC000017F) 617 + #define STATUS_KEY_HAS_CHILDREN cpu_to_le32(0xC0000180) 618 + #define STATUS_CHILD_MUST_BE_VOLATILE cpu_to_le32(0xC0000181) 619 + #define STATUS_DEVICE_CONFIGURATION_ERROR cpu_to_le32(0xC0000182) 620 + #define STATUS_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC0000183) 621 + #define STATUS_INVALID_DEVICE_STATE cpu_to_le32(0xC0000184) 622 + #define STATUS_IO_DEVICE_ERROR cpu_to_le32(0xC0000185) 623 + #define STATUS_DEVICE_PROTOCOL_ERROR cpu_to_le32(0xC0000186) 624 + #define STATUS_BACKUP_CONTROLLER cpu_to_le32(0xC0000187) 625 + #define STATUS_LOG_FILE_FULL cpu_to_le32(0xC0000188) 626 + #define STATUS_TOO_LATE cpu_to_le32(0xC0000189) 627 + #define STATUS_NO_TRUST_LSA_SECRET cpu_to_le32(0xC000018A) 628 + #define STATUS_NO_TRUST_SAM_ACCOUNT cpu_to_le32(0xC000018B) 629 + #define STATUS_TRUSTED_DOMAIN_FAILURE cpu_to_le32(0xC000018C) 630 + #define STATUS_TRUSTED_RELATIONSHIP_FAILURE cpu_to_le32(0xC000018D) 631 + #define STATUS_EVENTLOG_FILE_CORRUPT cpu_to_le32(0xC000018E) 632 + #define STATUS_EVENTLOG_CANT_START cpu_to_le32(0xC000018F) 633 + #define STATUS_TRUST_FAILURE cpu_to_le32(0xC0000190) 634 + #define STATUS_MUTANT_LIMIT_EXCEEDED cpu_to_le32(0xC0000191) 635 + #define STATUS_NETLOGON_NOT_STARTED cpu_to_le32(0xC0000192) 636 + #define STATUS_ACCOUNT_EXPIRED cpu_to_le32(0xC0000193) 637 + #define STATUS_POSSIBLE_DEADLOCK cpu_to_le32(0xC0000194) 638 + #define STATUS_NETWORK_CREDENTIAL_CONFLICT cpu_to_le32(0xC0000195) 639 + #define STATUS_REMOTE_SESSION_LIMIT cpu_to_le32(0xC0000196) 640 + #define STATUS_EVENTLOG_FILE_CHANGED cpu_to_le32(0xC0000197) 641 + #define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT cpu_to_le32(0xC0000198) 642 + #define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT cpu_to_le32(0xC0000199) 643 + #define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT cpu_to_le32(0xC000019A) 644 + #define STATUS_DOMAIN_TRUST_INCONSISTENT cpu_to_le32(0xC000019B) 645 + #define STATUS_FS_DRIVER_REQUIRED cpu_to_le32(0xC000019C) 646 + #define STATUS_IMAGE_ALREADY_LOADED_AS_DLL cpu_to_le32(0xC000019D) 647 + #define STATUS_NETWORK_OPEN_RESTRICTION cpu_to_le32(0xC0000201) 648 + #define STATUS_NO_USER_SESSION_KEY cpu_to_le32(0xC0000202) 649 + #define STATUS_USER_SESSION_DELETED cpu_to_le32(0xC0000203) 650 + #define STATUS_RESOURCE_LANG_NOT_FOUND cpu_to_le32(0xC0000204) 651 + #define STATUS_INSUFF_SERVER_RESOURCES cpu_to_le32(0xC0000205) 652 + #define STATUS_INVALID_BUFFER_SIZE cpu_to_le32(0xC0000206) 653 + #define STATUS_INVALID_ADDRESS_COMPONENT cpu_to_le32(0xC0000207) 654 + #define STATUS_INVALID_ADDRESS_WILDCARD cpu_to_le32(0xC0000208) 655 + #define STATUS_TOO_MANY_ADDRESSES cpu_to_le32(0xC0000209) 656 + #define STATUS_ADDRESS_ALREADY_EXISTS cpu_to_le32(0xC000020A) 657 + #define STATUS_ADDRESS_CLOSED cpu_to_le32(0xC000020B) 658 + #define STATUS_CONNECTION_DISCONNECTED cpu_to_le32(0xC000020C) 659 + #define STATUS_CONNECTION_RESET cpu_to_le32(0xC000020D) 660 + #define STATUS_TOO_MANY_NODES cpu_to_le32(0xC000020E) 661 + #define STATUS_TRANSACTION_ABORTED cpu_to_le32(0xC000020F) 662 + #define STATUS_TRANSACTION_TIMED_OUT cpu_to_le32(0xC0000210) 663 + #define STATUS_TRANSACTION_NO_RELEASE cpu_to_le32(0xC0000211) 664 + #define STATUS_TRANSACTION_NO_MATCH cpu_to_le32(0xC0000212) 665 + #define STATUS_TRANSACTION_RESPONDED cpu_to_le32(0xC0000213) 666 + #define STATUS_TRANSACTION_INVALID_ID cpu_to_le32(0xC0000214) 667 + #define STATUS_TRANSACTION_INVALID_TYPE cpu_to_le32(0xC0000215) 668 + #define STATUS_NOT_SERVER_SESSION cpu_to_le32(0xC0000216) 669 + #define STATUS_NOT_CLIENT_SESSION cpu_to_le32(0xC0000217) 670 + #define STATUS_CANNOT_LOAD_REGISTRY_FILE cpu_to_le32(0xC0000218) 671 + #define STATUS_DEBUG_ATTACH_FAILED cpu_to_le32(0xC0000219) 672 + #define STATUS_SYSTEM_PROCESS_TERMINATED cpu_to_le32(0xC000021A) 673 + #define STATUS_DATA_NOT_ACCEPTED cpu_to_le32(0xC000021B) 674 + #define STATUS_NO_BROWSER_SERVERS_FOUND cpu_to_le32(0xC000021C) 675 + #define STATUS_VDM_HARD_ERROR cpu_to_le32(0xC000021D) 676 + #define STATUS_DRIVER_CANCEL_TIMEOUT cpu_to_le32(0xC000021E) 677 + #define STATUS_REPLY_MESSAGE_MISMATCH cpu_to_le32(0xC000021F) 678 + #define STATUS_MAPPED_ALIGNMENT cpu_to_le32(0xC0000220) 679 + #define STATUS_IMAGE_CHECKSUM_MISMATCH cpu_to_le32(0xC0000221) 680 + #define STATUS_LOST_WRITEBEHIND_DATA cpu_to_le32(0xC0000222) 681 + #define STATUS_CLIENT_SERVER_PARAMETERS_INVALID cpu_to_le32(0xC0000223) 682 + #define STATUS_PASSWORD_MUST_CHANGE cpu_to_le32(0xC0000224) 683 + #define STATUS_NOT_FOUND cpu_to_le32(0xC0000225) 684 + #define STATUS_NOT_TINY_STREAM cpu_to_le32(0xC0000226) 685 + #define STATUS_RECOVERY_FAILURE cpu_to_le32(0xC0000227) 686 + #define STATUS_STACK_OVERFLOW_READ cpu_to_le32(0xC0000228) 687 + #define STATUS_FAIL_CHECK cpu_to_le32(0xC0000229) 688 + #define STATUS_DUPLICATE_OBJECTID cpu_to_le32(0xC000022A) 689 + #define STATUS_OBJECTID_EXISTS cpu_to_le32(0xC000022B) 690 + #define STATUS_CONVERT_TO_LARGE cpu_to_le32(0xC000022C) 691 + #define STATUS_RETRY cpu_to_le32(0xC000022D) 692 + #define STATUS_FOUND_OUT_OF_SCOPE cpu_to_le32(0xC000022E) 693 + #define STATUS_ALLOCATE_BUCKET cpu_to_le32(0xC000022F) 694 + #define STATUS_PROPSET_NOT_FOUND cpu_to_le32(0xC0000230) 695 + #define STATUS_MARSHALL_OVERFLOW cpu_to_le32(0xC0000231) 696 + #define STATUS_INVALID_VARIANT cpu_to_le32(0xC0000232) 697 + #define STATUS_DOMAIN_CONTROLLER_NOT_FOUND cpu_to_le32(0xC0000233) 698 + #define STATUS_ACCOUNT_LOCKED_OUT cpu_to_le32(0xC0000234) 699 + #define STATUS_HANDLE_NOT_CLOSABLE cpu_to_le32(0xC0000235) 700 + #define STATUS_CONNECTION_REFUSED cpu_to_le32(0xC0000236) 701 + #define STATUS_GRACEFUL_DISCONNECT cpu_to_le32(0xC0000237) 702 + #define STATUS_ADDRESS_ALREADY_ASSOCIATED cpu_to_le32(0xC0000238) 703 + #define STATUS_ADDRESS_NOT_ASSOCIATED cpu_to_le32(0xC0000239) 704 + #define STATUS_CONNECTION_INVALID cpu_to_le32(0xC000023A) 705 + #define STATUS_CONNECTION_ACTIVE cpu_to_le32(0xC000023B) 706 + #define STATUS_NETWORK_UNREACHABLE cpu_to_le32(0xC000023C) 707 + #define STATUS_HOST_UNREACHABLE cpu_to_le32(0xC000023D) 708 + #define STATUS_PROTOCOL_UNREACHABLE cpu_to_le32(0xC000023E) 709 + #define STATUS_PORT_UNREACHABLE cpu_to_le32(0xC000023F) 710 + #define STATUS_REQUEST_ABORTED cpu_to_le32(0xC0000240) 711 + #define STATUS_CONNECTION_ABORTED cpu_to_le32(0xC0000241) 712 + #define STATUS_BAD_COMPRESSION_BUFFER cpu_to_le32(0xC0000242) 713 + #define STATUS_USER_MAPPED_FILE cpu_to_le32(0xC0000243) 714 + #define STATUS_AUDIT_FAILED cpu_to_le32(0xC0000244) 715 + #define STATUS_TIMER_RESOLUTION_NOT_SET cpu_to_le32(0xC0000245) 716 + #define STATUS_CONNECTION_COUNT_LIMIT cpu_to_le32(0xC0000246) 717 + #define STATUS_LOGIN_TIME_RESTRICTION cpu_to_le32(0xC0000247) 718 + #define STATUS_LOGIN_WKSTA_RESTRICTION cpu_to_le32(0xC0000248) 719 + #define STATUS_IMAGE_MP_UP_MISMATCH cpu_to_le32(0xC0000249) 720 + #define STATUS_INSUFFICIENT_LOGON_INFO cpu_to_le32(0xC0000250) 721 + #define STATUS_BAD_DLL_ENTRYPOINT cpu_to_le32(0xC0000251) 722 + #define STATUS_BAD_SERVICE_ENTRYPOINT cpu_to_le32(0xC0000252) 723 + #define STATUS_LPC_REPLY_LOST cpu_to_le32(0xC0000253) 724 + #define STATUS_IP_ADDRESS_CONFLICT1 cpu_to_le32(0xC0000254) 725 + #define STATUS_IP_ADDRESS_CONFLICT2 cpu_to_le32(0xC0000255) 726 + #define STATUS_REGISTRY_QUOTA_LIMIT cpu_to_le32(0xC0000256) 727 + #define STATUS_PATH_NOT_COVERED cpu_to_le32(0xC0000257) 728 + #define STATUS_NO_CALLBACK_ACTIVE cpu_to_le32(0xC0000258) 729 + #define STATUS_LICENSE_QUOTA_EXCEEDED cpu_to_le32(0xC0000259) 730 + #define STATUS_PWD_TOO_SHORT cpu_to_le32(0xC000025A) 731 + #define STATUS_PWD_TOO_RECENT cpu_to_le32(0xC000025B) 732 + #define STATUS_PWD_HISTORY_CONFLICT cpu_to_le32(0xC000025C) 733 + #define STATUS_PLUGPLAY_NO_DEVICE cpu_to_le32(0xC000025E) 734 + #define STATUS_UNSUPPORTED_COMPRESSION cpu_to_le32(0xC000025F) 735 + #define STATUS_INVALID_HW_PROFILE cpu_to_le32(0xC0000260) 736 + #define STATUS_INVALID_PLUGPLAY_DEVICE_PATH cpu_to_le32(0xC0000261) 737 + #define STATUS_DRIVER_ORDINAL_NOT_FOUND cpu_to_le32(0xC0000262) 738 + #define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND cpu_to_le32(0xC0000263) 739 + #define STATUS_RESOURCE_NOT_OWNED cpu_to_le32(0xC0000264) 740 + #define STATUS_TOO_MANY_LINKS cpu_to_le32(0xC0000265) 741 + #define STATUS_QUOTA_LIST_INCONSISTENT cpu_to_le32(0xC0000266) 742 + #define STATUS_FILE_IS_OFFLINE cpu_to_le32(0xC0000267) 743 + #define STATUS_EVALUATION_EXPIRATION cpu_to_le32(0xC0000268) 744 + #define STATUS_ILLEGAL_DLL_RELOCATION cpu_to_le32(0xC0000269) 745 + #define STATUS_LICENSE_VIOLATION cpu_to_le32(0xC000026A) 746 + #define STATUS_DLL_INIT_FAILED_LOGOFF cpu_to_le32(0xC000026B) 747 + #define STATUS_DRIVER_UNABLE_TO_LOAD cpu_to_le32(0xC000026C) 748 + #define STATUS_DFS_UNAVAILABLE cpu_to_le32(0xC000026D) 749 + #define STATUS_VOLUME_DISMOUNTED cpu_to_le32(0xC000026E) 750 + #define STATUS_WX86_INTERNAL_ERROR cpu_to_le32(0xC000026F) 751 + #define STATUS_WX86_FLOAT_STACK_CHECK cpu_to_le32(0xC0000270) 752 + #define STATUS_VALIDATE_CONTINUE cpu_to_le32(0xC0000271) 753 + #define STATUS_NO_MATCH cpu_to_le32(0xC0000272) 754 + #define STATUS_NO_MORE_MATCHES cpu_to_le32(0xC0000273) 755 + #define STATUS_NOT_A_REPARSE_POINT cpu_to_le32(0xC0000275) 756 + #define STATUS_IO_REPARSE_TAG_INVALID cpu_to_le32(0xC0000276) 757 + #define STATUS_IO_REPARSE_TAG_MISMATCH cpu_to_le32(0xC0000277) 758 + #define STATUS_IO_REPARSE_DATA_INVALID cpu_to_le32(0xC0000278) 759 + #define STATUS_IO_REPARSE_TAG_NOT_HANDLED cpu_to_le32(0xC0000279) 760 + #define STATUS_REPARSE_POINT_NOT_RESOLVED cpu_to_le32(0xC0000280) 761 + #define STATUS_DIRECTORY_IS_A_REPARSE_POINT cpu_to_le32(0xC0000281) 762 + #define STATUS_RANGE_LIST_CONFLICT cpu_to_le32(0xC0000282) 763 + #define STATUS_SOURCE_ELEMENT_EMPTY cpu_to_le32(0xC0000283) 764 + #define STATUS_DESTINATION_ELEMENT_FULL cpu_to_le32(0xC0000284) 765 + #define STATUS_ILLEGAL_ELEMENT_ADDRESS cpu_to_le32(0xC0000285) 766 + #define STATUS_MAGAZINE_NOT_PRESENT cpu_to_le32(0xC0000286) 767 + #define STATUS_REINITIALIZATION_NEEDED cpu_to_le32(0xC0000287) 768 + #define STATUS_ENCRYPTION_FAILED cpu_to_le32(0xC000028A) 769 + #define STATUS_DECRYPTION_FAILED cpu_to_le32(0xC000028B) 770 + #define STATUS_RANGE_NOT_FOUND cpu_to_le32(0xC000028C) 771 + #define STATUS_NO_RECOVERY_POLICY cpu_to_le32(0xC000028D) 772 + #define STATUS_NO_EFS cpu_to_le32(0xC000028E) 773 + #define STATUS_WRONG_EFS cpu_to_le32(0xC000028F) 774 + #define STATUS_NO_USER_KEYS cpu_to_le32(0xC0000290) 775 + #define STATUS_FILE_NOT_ENCRYPTED cpu_to_le32(0xC0000291) 776 + #define STATUS_NOT_EXPORT_FORMAT cpu_to_le32(0xC0000292) 777 + #define STATUS_FILE_ENCRYPTED cpu_to_le32(0xC0000293) 778 + #define STATUS_WMI_GUID_NOT_FOUND cpu_to_le32(0xC0000295) 779 + #define STATUS_WMI_INSTANCE_NOT_FOUND cpu_to_le32(0xC0000296) 780 + #define STATUS_WMI_ITEMID_NOT_FOUND cpu_to_le32(0xC0000297) 781 + #define STATUS_WMI_TRY_AGAIN cpu_to_le32(0xC0000298) 782 + #define STATUS_SHARED_POLICY cpu_to_le32(0xC0000299) 783 + #define STATUS_POLICY_OBJECT_NOT_FOUND cpu_to_le32(0xC000029A) 784 + #define STATUS_POLICY_ONLY_IN_DS cpu_to_le32(0xC000029B) 785 + #define STATUS_VOLUME_NOT_UPGRADED cpu_to_le32(0xC000029C) 786 + #define STATUS_REMOTE_STORAGE_NOT_ACTIVE cpu_to_le32(0xC000029D) 787 + #define STATUS_REMOTE_STORAGE_MEDIA_ERROR cpu_to_le32(0xC000029E) 788 + #define STATUS_NO_TRACKING_SERVICE cpu_to_le32(0xC000029F) 789 + #define STATUS_SERVER_SID_MISMATCH cpu_to_le32(0xC00002A0) 790 + #define STATUS_DS_NO_ATTRIBUTE_OR_VALUE cpu_to_le32(0xC00002A1) 791 + #define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX cpu_to_le32(0xC00002A2) 792 + #define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED cpu_to_le32(0xC00002A3) 793 + #define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS cpu_to_le32(0xC00002A4) 794 + #define STATUS_DS_BUSY cpu_to_le32(0xC00002A5) 795 + #define STATUS_DS_UNAVAILABLE cpu_to_le32(0xC00002A6) 796 + #define STATUS_DS_NO_RIDS_ALLOCATED cpu_to_le32(0xC00002A7) 797 + #define STATUS_DS_NO_MORE_RIDS cpu_to_le32(0xC00002A8) 798 + #define STATUS_DS_INCORRECT_ROLE_OWNER cpu_to_le32(0xC00002A9) 799 + #define STATUS_DS_RIDMGR_INIT_ERROR cpu_to_le32(0xC00002AA) 800 + #define STATUS_DS_OBJ_CLASS_VIOLATION cpu_to_le32(0xC00002AB) 801 + #define STATUS_DS_CANT_ON_NON_LEAF cpu_to_le32(0xC00002AC) 802 + #define STATUS_DS_CANT_ON_RDN cpu_to_le32(0xC00002AD) 803 + #define STATUS_DS_CANT_MOD_OBJ_CLASS cpu_to_le32(0xC00002AE) 804 + #define STATUS_DS_CROSS_DOM_MOVE_FAILED cpu_to_le32(0xC00002AF) 805 + #define STATUS_DS_GC_NOT_AVAILABLE cpu_to_le32(0xC00002B0) 806 + #define STATUS_DIRECTORY_SERVICE_REQUIRED cpu_to_le32(0xC00002B1) 807 + #define STATUS_REPARSE_ATTRIBUTE_CONFLICT cpu_to_le32(0xC00002B2) 808 + #define STATUS_CANT_ENABLE_DENY_ONLY cpu_to_le32(0xC00002B3) 809 + #define STATUS_FLOAT_MULTIPLE_FAULTS cpu_to_le32(0xC00002B4) 810 + #define STATUS_FLOAT_MULTIPLE_TRAPS cpu_to_le32(0xC00002B5) 811 + #define STATUS_DEVICE_REMOVED cpu_to_le32(0xC00002B6) 812 + #define STATUS_JOURNAL_DELETE_IN_PROGRESS cpu_to_le32(0xC00002B7) 813 + #define STATUS_JOURNAL_NOT_ACTIVE cpu_to_le32(0xC00002B8) 814 + #define STATUS_NOINTERFACE cpu_to_le32(0xC00002B9) 815 + #define STATUS_DS_ADMIN_LIMIT_EXCEEDED cpu_to_le32(0xC00002C1) 816 + #define STATUS_DRIVER_FAILED_SLEEP cpu_to_le32(0xC00002C2) 817 + #define STATUS_MUTUAL_AUTHENTICATION_FAILED cpu_to_le32(0xC00002C3) 818 + #define STATUS_CORRUPT_SYSTEM_FILE cpu_to_le32(0xC00002C4) 819 + #define STATUS_DATATYPE_MISALIGNMENT_ERROR cpu_to_le32(0xC00002C5) 820 + #define STATUS_WMI_READ_ONLY cpu_to_le32(0xC00002C6) 821 + #define STATUS_WMI_SET_FAILURE cpu_to_le32(0xC00002C7) 822 + #define STATUS_COMMITMENT_MINIMUM cpu_to_le32(0xC00002C8) 823 + #define STATUS_REG_NAT_CONSUMPTION cpu_to_le32(0xC00002C9) 824 + #define STATUS_TRANSPORT_FULL cpu_to_le32(0xC00002CA) 825 + #define STATUS_DS_SAM_INIT_FAILURE cpu_to_le32(0xC00002CB) 826 + #define STATUS_ONLY_IF_CONNECTED cpu_to_le32(0xC00002CC) 827 + #define STATUS_DS_SENSITIVE_GROUP_VIOLATION cpu_to_le32(0xC00002CD) 828 + #define STATUS_PNP_RESTART_ENUMERATION cpu_to_le32(0xC00002CE) 829 + #define STATUS_JOURNAL_ENTRY_DELETED cpu_to_le32(0xC00002CF) 830 + #define STATUS_DS_CANT_MOD_PRIMARYGROUPID cpu_to_le32(0xC00002D0) 831 + #define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE cpu_to_le32(0xC00002D1) 832 + #define STATUS_PNP_REBOOT_REQUIRED cpu_to_le32(0xC00002D2) 833 + #define STATUS_POWER_STATE_INVALID cpu_to_le32(0xC00002D3) 834 + #define STATUS_DS_INVALID_GROUP_TYPE cpu_to_le32(0xC00002D4) 835 + #define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D5) 836 + #define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D6) 837 + #define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D7) 838 + #define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC00002D8) 839 + #define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D9) 840 + #define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER cpu_to_le32(0xC00002DA) 841 + #define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER cpu_to_le32(0xC00002DB) 842 + #define STATUS_DS_HAVE_PRIMARY_MEMBERS cpu_to_le32(0xC00002DC) 843 + #define STATUS_WMI_NOT_SUPPORTED cpu_to_le32(0xC00002DD) 844 + #define STATUS_INSUFFICIENT_POWER cpu_to_le32(0xC00002DE) 845 + #define STATUS_SAM_NEED_BOOTKEY_PASSWORD cpu_to_le32(0xC00002DF) 846 + #define STATUS_SAM_NEED_BOOTKEY_FLOPPY cpu_to_le32(0xC00002E0) 847 + #define STATUS_DS_CANT_START cpu_to_le32(0xC00002E1) 848 + #define STATUS_DS_INIT_FAILURE cpu_to_le32(0xC00002E2) 849 + #define STATUS_SAM_INIT_FAILURE cpu_to_le32(0xC00002E3) 850 + #define STATUS_DS_GC_REQUIRED cpu_to_le32(0xC00002E4) 851 + #define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY cpu_to_le32(0xC00002E5) 852 + #define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS cpu_to_le32(0xC00002E6) 853 + #define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED cpu_to_le32(0xC00002E7) 854 + #define STATUS_MULTIPLE_FAULT_VIOLATION cpu_to_le32(0xC00002E8) 855 + #define STATUS_CURRENT_DOMAIN_NOT_ALLOWED cpu_to_le32(0xC00002E9) 856 + #define STATUS_CANNOT_MAKE cpu_to_le32(0xC00002EA) 857 + #define STATUS_SYSTEM_SHUTDOWN cpu_to_le32(0xC00002EB) 858 + #define STATUS_DS_INIT_FAILURE_CONSOLE cpu_to_le32(0xC00002EC) 859 + #define STATUS_DS_SAM_INIT_FAILURE_CONSOLE cpu_to_le32(0xC00002ED) 860 + #define STATUS_UNFINISHED_CONTEXT_DELETED cpu_to_le32(0xC00002EE) 861 + #define STATUS_NO_TGT_REPLY cpu_to_le32(0xC00002EF) 862 + #define STATUS_OBJECTID_NOT_FOUND cpu_to_le32(0xC00002F0) 863 + #define STATUS_NO_IP_ADDRESSES cpu_to_le32(0xC00002F1) 864 + #define STATUS_WRONG_CREDENTIAL_HANDLE cpu_to_le32(0xC00002F2) 865 + #define STATUS_CRYPTO_SYSTEM_INVALID cpu_to_le32(0xC00002F3) 866 + #define STATUS_MAX_REFERRALS_EXCEEDED cpu_to_le32(0xC00002F4) 867 + #define STATUS_MUST_BE_KDC cpu_to_le32(0xC00002F5) 868 + #define STATUS_STRONG_CRYPTO_NOT_SUPPORTED cpu_to_le32(0xC00002F6) 869 + #define STATUS_TOO_MANY_PRINCIPALS cpu_to_le32(0xC00002F7) 870 + #define STATUS_NO_PA_DATA cpu_to_le32(0xC00002F8) 871 + #define STATUS_PKINIT_NAME_MISMATCH cpu_to_le32(0xC00002F9) 872 + #define STATUS_SMARTCARD_LOGON_REQUIRED cpu_to_le32(0xC00002FA) 873 + #define STATUS_KDC_INVALID_REQUEST cpu_to_le32(0xC00002FB) 874 + #define STATUS_KDC_UNABLE_TO_REFER cpu_to_le32(0xC00002FC) 875 + #define STATUS_KDC_UNKNOWN_ETYPE cpu_to_le32(0xC00002FD) 876 + #define STATUS_SHUTDOWN_IN_PROGRESS cpu_to_le32(0xC00002FE) 877 + #define STATUS_SERVER_SHUTDOWN_IN_PROGRESS cpu_to_le32(0xC00002FF) 878 + #define STATUS_NOT_SUPPORTED_ON_SBS cpu_to_le32(0xC0000300) 879 + #define STATUS_WMI_GUID_DISCONNECTED cpu_to_le32(0xC0000301) 880 + #define STATUS_WMI_ALREADY_DISABLED cpu_to_le32(0xC0000302) 881 + #define STATUS_WMI_ALREADY_ENABLED cpu_to_le32(0xC0000303) 882 + #define STATUS_MFT_TOO_FRAGMENTED cpu_to_le32(0xC0000304) 883 + #define STATUS_COPY_PROTECTION_FAILURE cpu_to_le32(0xC0000305) 884 + #define STATUS_CSS_AUTHENTICATION_FAILURE cpu_to_le32(0xC0000306) 885 + #define STATUS_CSS_KEY_NOT_PRESENT cpu_to_le32(0xC0000307) 886 + #define STATUS_CSS_KEY_NOT_ESTABLISHED cpu_to_le32(0xC0000308) 887 + #define STATUS_CSS_SCRAMBLED_SECTOR cpu_to_le32(0xC0000309) 888 + #define STATUS_CSS_REGION_MISMATCH cpu_to_le32(0xC000030A) 889 + #define STATUS_CSS_RESETS_EXHAUSTED cpu_to_le32(0xC000030B) 890 + #define STATUS_PKINIT_FAILURE cpu_to_le32(0xC0000320) 891 + #define STATUS_SMARTCARD_SUBSYSTEM_FAILURE cpu_to_le32(0xC0000321) 892 + #define STATUS_NO_KERB_KEY cpu_to_le32(0xC0000322) 893 + #define STATUS_HOST_DOWN cpu_to_le32(0xC0000350) 894 + #define STATUS_UNSUPPORTED_PREAUTH cpu_to_le32(0xC0000351) 895 + #define STATUS_EFS_ALG_BLOB_TOO_BIG cpu_to_le32(0xC0000352) 896 + #define STATUS_PORT_NOT_SET cpu_to_le32(0xC0000353) 897 + #define STATUS_DEBUGGER_INACTIVE cpu_to_le32(0xC0000354) 898 + #define STATUS_DS_VERSION_CHECK_FAILURE cpu_to_le32(0xC0000355) 899 + #define STATUS_AUDITING_DISABLED cpu_to_le32(0xC0000356) 900 + #define STATUS_PRENT4_MACHINE_ACCOUNT cpu_to_le32(0xC0000357) 901 + #define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC0000358) 902 + #define STATUS_INVALID_IMAGE_WIN_32 cpu_to_le32(0xC0000359) 903 + #define STATUS_INVALID_IMAGE_WIN_64 cpu_to_le32(0xC000035A) 904 + #define STATUS_BAD_BINDINGS cpu_to_le32(0xC000035B) 905 + #define STATUS_NETWORK_SESSION_EXPIRED cpu_to_le32(0xC000035C) 906 + #define STATUS_APPHELP_BLOCK cpu_to_le32(0xC000035D) 907 + #define STATUS_ALL_SIDS_FILTERED cpu_to_le32(0xC000035E) 908 + #define STATUS_NOT_SAFE_MODE_DRIVER cpu_to_le32(0xC000035F) 909 + #define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT cpu_to_le32(0xC0000361) 910 + #define STATUS_ACCESS_DISABLED_BY_POLICY_PATH cpu_to_le32(0xC0000362) 911 + #define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER cpu_to_le32(0xC0000363) 912 + #define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER cpu_to_le32(0xC0000364) 913 + #define STATUS_FAILED_DRIVER_ENTRY cpu_to_le32(0xC0000365) 914 + #define STATUS_DEVICE_ENUMERATION_ERROR cpu_to_le32(0xC0000366) 915 + #define STATUS_MOUNT_POINT_NOT_RESOLVED cpu_to_le32(0xC0000368) 916 + #define STATUS_INVALID_DEVICE_OBJECT_PARAMETER cpu_to_le32(0xC0000369) 917 + #define STATUS_MCA_OCCURED cpu_to_le32(0xC000036A) 918 + #define STATUS_DRIVER_BLOCKED_CRITICAL cpu_to_le32(0xC000036B) 919 + #define STATUS_DRIVER_BLOCKED cpu_to_le32(0xC000036C) 920 + #define STATUS_DRIVER_DATABASE_ERROR cpu_to_le32(0xC000036D) 921 + #define STATUS_SYSTEM_HIVE_TOO_LARGE cpu_to_le32(0xC000036E) 922 + #define STATUS_INVALID_IMPORT_OF_NON_DLL cpu_to_le32(0xC000036F) 923 + #define STATUS_NO_SECRETS cpu_to_le32(0xC0000371) 924 + #define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY cpu_to_le32(0xC0000372) 925 + #define STATUS_FAILED_STACK_SWITCH cpu_to_le32(0xC0000373) 926 + #define STATUS_HEAP_CORRUPTION cpu_to_le32(0xC0000374) 927 + #define STATUS_SMARTCARD_WRONG_PIN cpu_to_le32(0xC0000380) 928 + #define STATUS_SMARTCARD_CARD_BLOCKED cpu_to_le32(0xC0000381) 929 + #define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED cpu_to_le32(0xC0000382) 930 + #define STATUS_SMARTCARD_NO_CARD cpu_to_le32(0xC0000383) 931 + #define STATUS_SMARTCARD_NO_KEY_CONTAINER cpu_to_le32(0xC0000384) 932 + #define STATUS_SMARTCARD_NO_CERTIFICATE cpu_to_le32(0xC0000385) 933 + #define STATUS_SMARTCARD_NO_KEYSET cpu_to_le32(0xC0000386) 934 + #define STATUS_SMARTCARD_IO_ERROR cpu_to_le32(0xC0000387) 935 + #define STATUS_DOWNGRADE_DETECTED cpu_to_le32(0xC0000388) 936 + #define STATUS_SMARTCARD_CERT_REVOKED cpu_to_le32(0xC0000389) 937 + #define STATUS_ISSUING_CA_UNTRUSTED cpu_to_le32(0xC000038A) 938 + #define STATUS_REVOCATION_OFFLINE_C cpu_to_le32(0xC000038B) 939 + #define STATUS_PKINIT_CLIENT_FAILURE cpu_to_le32(0xC000038C) 940 + #define STATUS_SMARTCARD_CERT_EXPIRED cpu_to_le32(0xC000038D) 941 + #define STATUS_DRIVER_FAILED_PRIOR_UNLOAD cpu_to_le32(0xC000038E) 942 + #define STATUS_SMARTCARD_SILENT_CONTEXT cpu_to_le32(0xC000038F) 943 + #define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000401) 944 + #define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000402) 945 + #define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000403) 946 + #define STATUS_DS_NAME_NOT_UNIQUE cpu_to_le32(0xC0000404) 947 + #define STATUS_DS_DUPLICATE_ID_FOUND cpu_to_le32(0xC0000405) 948 + #define STATUS_DS_GROUP_CONVERSION_ERROR cpu_to_le32(0xC0000406) 949 + #define STATUS_VOLSNAP_PREPARE_HIBERNATE cpu_to_le32(0xC0000407) 950 + #define STATUS_USER2USER_REQUIRED cpu_to_le32(0xC0000408) 951 + #define STATUS_STACK_BUFFER_OVERRUN cpu_to_le32(0xC0000409) 952 + #define STATUS_NO_S4U_PROT_SUPPORT cpu_to_le32(0xC000040A) 953 + #define STATUS_CROSSREALM_DELEGATION_FAILURE cpu_to_le32(0xC000040B) 954 + #define STATUS_REVOCATION_OFFLINE_KDC cpu_to_le32(0xC000040C) 955 + #define STATUS_ISSUING_CA_UNTRUSTED_KDC cpu_to_le32(0xC000040D) 956 + #define STATUS_KDC_CERT_EXPIRED cpu_to_le32(0xC000040E) 957 + #define STATUS_KDC_CERT_REVOKED cpu_to_le32(0xC000040F) 958 + #define STATUS_PARAMETER_QUOTA_EXCEEDED cpu_to_le32(0xC0000410) 959 + #define STATUS_HIBERNATION_FAILURE cpu_to_le32(0xC0000411) 960 + #define STATUS_DELAY_LOAD_FAILED cpu_to_le32(0xC0000412) 961 + #define STATUS_AUTHENTICATION_FIREWALL_FAILED cpu_to_le32(0xC0000413) 962 + #define STATUS_VDM_DISALLOWED cpu_to_le32(0xC0000414) 963 + #define STATUS_HUNG_DISPLAY_DRIVER_THREAD cpu_to_le32(0xC0000415) 964 + #define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE cpu_to_le32(0xC0000416) 965 + #define STATUS_INVALID_CRUNTIME_PARAMETER cpu_to_le32(0xC0000417) 966 + #define STATUS_NTLM_BLOCKED cpu_to_le32(0xC0000418) 967 + #define STATUS_ASSERTION_FAILURE cpu_to_le32(0xC0000420) 968 + #define STATUS_VERIFIER_STOP cpu_to_le32(0xC0000421) 969 + #define STATUS_CALLBACK_POP_STACK cpu_to_le32(0xC0000423) 970 + #define STATUS_INCOMPATIBLE_DRIVER_BLOCKED cpu_to_le32(0xC0000424) 971 + #define STATUS_HIVE_UNLOADED cpu_to_le32(0xC0000425) 972 + #define STATUS_COMPRESSION_DISABLED cpu_to_le32(0xC0000426) 973 + #define STATUS_FILE_SYSTEM_LIMITATION cpu_to_le32(0xC0000427) 974 + #define STATUS_INVALID_IMAGE_HASH cpu_to_le32(0xC0000428) 975 + #define STATUS_NOT_CAPABLE cpu_to_le32(0xC0000429) 976 + #define STATUS_REQUEST_OUT_OF_SEQUENCE cpu_to_le32(0xC000042A) 977 + #define STATUS_IMPLEMENTATION_LIMIT cpu_to_le32(0xC000042B) 978 + #define STATUS_ELEVATION_REQUIRED cpu_to_le32(0xC000042C) 979 + #define STATUS_BEYOND_VDL cpu_to_le32(0xC0000432) 980 + #define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS cpu_to_le32(0xC0000433) 981 + #define STATUS_PTE_CHANGED cpu_to_le32(0xC0000434) 982 + #define STATUS_PURGE_FAILED cpu_to_le32(0xC0000435) 983 + #define STATUS_CRED_REQUIRES_CONFIRMATION cpu_to_le32(0xC0000440) 984 + #define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE cpu_to_le32(0xC0000441) 985 + #define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER cpu_to_le32(0xC0000442) 986 + #define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE cpu_to_le32(0xC0000443) 987 + #define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE cpu_to_le32(0xC0000444) 988 + #define STATUS_CS_ENCRYPTION_FILE_NOT_CSE cpu_to_le32(0xC0000445) 989 + #define STATUS_INVALID_LABEL cpu_to_le32(0xC0000446) 990 + #define STATUS_DRIVER_PROCESS_TERMINATED cpu_to_le32(0xC0000450) 991 + #define STATUS_AMBIGUOUS_SYSTEM_DEVICE cpu_to_le32(0xC0000451) 992 + #define STATUS_SYSTEM_DEVICE_NOT_FOUND cpu_to_le32(0xC0000452) 993 + #define STATUS_RESTART_BOOT_APPLICATION cpu_to_le32(0xC0000453) 994 + #define STATUS_INVALID_TASK_NAME cpu_to_le32(0xC0000500) 995 + #define STATUS_INVALID_TASK_INDEX cpu_to_le32(0xC0000501) 996 + #define STATUS_THREAD_ALREADY_IN_TASK cpu_to_le32(0xC0000502) 997 + #define STATUS_CALLBACK_BYPASS cpu_to_le32(0xC0000503) 998 + #define STATUS_PORT_CLOSED cpu_to_le32(0xC0000700) 999 + #define STATUS_MESSAGE_LOST cpu_to_le32(0xC0000701) 1000 + #define STATUS_INVALID_MESSAGE cpu_to_le32(0xC0000702) 1001 + #define STATUS_REQUEST_CANCELED cpu_to_le32(0xC0000703) 1002 + #define STATUS_RECURSIVE_DISPATCH cpu_to_le32(0xC0000704) 1003 + #define STATUS_LPC_RECEIVE_BUFFER_EXPECTED cpu_to_le32(0xC0000705) 1004 + #define STATUS_LPC_INVALID_CONNECTION_USAGE cpu_to_le32(0xC0000706) 1005 + #define STATUS_LPC_REQUESTS_NOT_ALLOWED cpu_to_le32(0xC0000707) 1006 + #define STATUS_RESOURCE_IN_USE cpu_to_le32(0xC0000708) 1007 + #define STATUS_HARDWARE_MEMORY_ERROR cpu_to_le32(0xC0000709) 1008 + #define STATUS_THREADPOOL_HANDLE_EXCEPTION cpu_to_le32(0xC000070A) 1009 + #define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED cpu_to_le32(0xC000070B) 1010 + #define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED cpu_to_le32(0xC000070C) 1011 + #define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED cpu_to_le32(0xC000070D) 1012 + #define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED cpu_to_le32(0xC000070E) 1013 + #define STATUS_THREADPOOL_RELEASED_DURING_OPERATION cpu_to_le32(0xC000070F) 1014 + #define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000710) 1015 + #define STATUS_APC_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000711) 1016 + #define STATUS_PROCESS_IS_PROTECTED cpu_to_le32(0xC0000712) 1017 + #define STATUS_MCA_EXCEPTION cpu_to_le32(0xC0000713) 1018 + #define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE cpu_to_le32(0xC0000714) 1019 + #define STATUS_SYMLINK_CLASS_DISABLED cpu_to_le32(0xC0000715) 1020 + #define STATUS_INVALID_IDN_NORMALIZATION cpu_to_le32(0xC0000716) 1021 + #define STATUS_NO_UNICODE_TRANSLATION cpu_to_le32(0xC0000717) 1022 + #define STATUS_ALREADY_REGISTERED cpu_to_le32(0xC0000718) 1023 + #define STATUS_CONTEXT_MISMATCH cpu_to_le32(0xC0000719) 1024 + #define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST cpu_to_le32(0xC000071A) 1025 + #define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY cpu_to_le32(0xC000071B) 1026 + #define STATUS_INVALID_THREAD cpu_to_le32(0xC000071C) 1027 + #define STATUS_CALLBACK_RETURNED_TRANSACTION cpu_to_le32(0xC000071D) 1028 + #define STATUS_CALLBACK_RETURNED_LDR_LOCK cpu_to_le32(0xC000071E) 1029 + #define STATUS_CALLBACK_RETURNED_LANG cpu_to_le32(0xC000071F) 1030 + #define STATUS_CALLBACK_RETURNED_PRI_BACK cpu_to_le32(0xC0000720) 1031 + #define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY cpu_to_le32(0xC0000721) 1032 + #define STATUS_DISK_REPAIR_DISABLED cpu_to_le32(0xC0000800) 1033 + #define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS cpu_to_le32(0xC0000801) 1034 + #define STATUS_DISK_QUOTA_EXCEEDED cpu_to_le32(0xC0000802) 1035 + #define STATUS_CONTENT_BLOCKED cpu_to_le32(0xC0000804) 1036 + #define STATUS_BAD_CLUSTERS cpu_to_le32(0xC0000805) 1037 + #define STATUS_VOLUME_DIRTY cpu_to_le32(0xC0000806) 1038 + #define STATUS_FILE_CHECKED_OUT cpu_to_le32(0xC0000901) 1039 + #define STATUS_CHECKOUT_REQUIRED cpu_to_le32(0xC0000902) 1040 + #define STATUS_BAD_FILE_TYPE cpu_to_le32(0xC0000903) 1041 + #define STATUS_FILE_TOO_LARGE cpu_to_le32(0xC0000904) 1042 + #define STATUS_FORMS_AUTH_REQUIRED cpu_to_le32(0xC0000905) 1043 + #define STATUS_VIRUS_INFECTED cpu_to_le32(0xC0000906) 1044 + #define STATUS_VIRUS_DELETED cpu_to_le32(0xC0000907) 1045 + #define STATUS_BAD_MCFG_TABLE cpu_to_le32(0xC0000908) 1046 + #define STATUS_WOW_ASSERTION cpu_to_le32(0xC0009898) 1047 + #define STATUS_INVALID_SIGNATURE cpu_to_le32(0xC000A000) 1048 + #define STATUS_HMAC_NOT_SUPPORTED cpu_to_le32(0xC000A001) 1049 + #define STATUS_IPSEC_QUEUE_OVERFLOW cpu_to_le32(0xC000A010) 1050 + #define STATUS_ND_QUEUE_OVERFLOW cpu_to_le32(0xC000A011) 1051 + #define STATUS_HOPLIMIT_EXCEEDED cpu_to_le32(0xC000A012) 1052 + #define STATUS_PROTOCOL_NOT_SUPPORTED cpu_to_le32(0xC000A013) 1053 + #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED cpu_to_le32(0xC000A080) 1054 + #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR cpu_to_le32(0xC000A081) 1055 + #define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR cpu_to_le32(0xC000A082) 1056 + #define STATUS_XML_PARSE_ERROR cpu_to_le32(0xC000A083) 1057 + #define STATUS_XMLDSIG_ERROR cpu_to_le32(0xC000A084) 1058 + #define STATUS_WRONG_COMPARTMENT cpu_to_le32(0xC000A085) 1059 + #define STATUS_AUTHIP_FAILURE cpu_to_le32(0xC000A086) 1060 + #define DBG_NO_STATE_CHANGE cpu_to_le32(0xC0010001) 1061 + #define DBG_APP_NOT_IDLE cpu_to_le32(0xC0010002) 1062 + #define RPC_NT_INVALID_STRING_BINDING cpu_to_le32(0xC0020001) 1063 + #define RPC_NT_WRONG_KIND_OF_BINDING cpu_to_le32(0xC0020002) 1064 + #define RPC_NT_INVALID_BINDING cpu_to_le32(0xC0020003) 1065 + #define RPC_NT_PROTSEQ_NOT_SUPPORTED cpu_to_le32(0xC0020004) 1066 + #define RPC_NT_INVALID_RPC_PROTSEQ cpu_to_le32(0xC0020005) 1067 + #define RPC_NT_INVALID_STRING_UUID cpu_to_le32(0xC0020006) 1068 + #define RPC_NT_INVALID_ENDPOINT_FORMAT cpu_to_le32(0xC0020007) 1069 + #define RPC_NT_INVALID_NET_ADDR cpu_to_le32(0xC0020008) 1070 + #define RPC_NT_NO_ENDPOINT_FOUND cpu_to_le32(0xC0020009) 1071 + #define RPC_NT_INVALID_TIMEOUT cpu_to_le32(0xC002000A) 1072 + #define RPC_NT_OBJECT_NOT_FOUND cpu_to_le32(0xC002000B) 1073 + #define RPC_NT_ALREADY_REGISTERED cpu_to_le32(0xC002000C) 1074 + #define RPC_NT_TYPE_ALREADY_REGISTERED cpu_to_le32(0xC002000D) 1075 + #define RPC_NT_ALREADY_LISTENING cpu_to_le32(0xC002000E) 1076 + #define RPC_NT_NO_PROTSEQS_REGISTERED cpu_to_le32(0xC002000F) 1077 + #define RPC_NT_NOT_LISTENING cpu_to_le32(0xC0020010) 1078 + #define RPC_NT_UNKNOWN_MGR_TYPE cpu_to_le32(0xC0020011) 1079 + #define RPC_NT_UNKNOWN_IF cpu_to_le32(0xC0020012) 1080 + #define RPC_NT_NO_BINDINGS cpu_to_le32(0xC0020013) 1081 + #define RPC_NT_NO_PROTSEQS cpu_to_le32(0xC0020014) 1082 + #define RPC_NT_CANT_CREATE_ENDPOINT cpu_to_le32(0xC0020015) 1083 + #define RPC_NT_OUT_OF_RESOURCES cpu_to_le32(0xC0020016) 1084 + #define RPC_NT_SERVER_UNAVAILABLE cpu_to_le32(0xC0020017) 1085 + #define RPC_NT_SERVER_TOO_BUSY cpu_to_le32(0xC0020018) 1086 + #define RPC_NT_INVALID_NETWORK_OPTIONS cpu_to_le32(0xC0020019) 1087 + #define RPC_NT_NO_CALL_ACTIVE cpu_to_le32(0xC002001A) 1088 + #define RPC_NT_CALL_FAILED cpu_to_le32(0xC002001B) 1089 + #define RPC_NT_CALL_FAILED_DNE cpu_to_le32(0xC002001C) 1090 + #define RPC_NT_PROTOCOL_ERROR cpu_to_le32(0xC002001D) 1091 + #define RPC_NT_UNSUPPORTED_TRANS_SYN cpu_to_le32(0xC002001F) 1092 + #define RPC_NT_UNSUPPORTED_TYPE cpu_to_le32(0xC0020021) 1093 + #define RPC_NT_INVALID_TAG cpu_to_le32(0xC0020022) 1094 + #define RPC_NT_INVALID_BOUND cpu_to_le32(0xC0020023) 1095 + #define RPC_NT_NO_ENTRY_NAME cpu_to_le32(0xC0020024) 1096 + #define RPC_NT_INVALID_NAME_SYNTAX cpu_to_le32(0xC0020025) 1097 + #define RPC_NT_UNSUPPORTED_NAME_SYNTAX cpu_to_le32(0xC0020026) 1098 + #define RPC_NT_UUID_NO_ADDRESS cpu_to_le32(0xC0020028) 1099 + #define RPC_NT_DUPLICATE_ENDPOINT cpu_to_le32(0xC0020029) 1100 + #define RPC_NT_UNKNOWN_AUTHN_TYPE cpu_to_le32(0xC002002A) 1101 + #define RPC_NT_MAX_CALLS_TOO_SMALL cpu_to_le32(0xC002002B) 1102 + #define RPC_NT_STRING_TOO_LONG cpu_to_le32(0xC002002C) 1103 + #define RPC_NT_PROTSEQ_NOT_FOUND cpu_to_le32(0xC002002D) 1104 + #define RPC_NT_PROCNUM_OUT_OF_RANGE cpu_to_le32(0xC002002E) 1105 + #define RPC_NT_BINDING_HAS_NO_AUTH cpu_to_le32(0xC002002F) 1106 + #define RPC_NT_UNKNOWN_AUTHN_SERVICE cpu_to_le32(0xC0020030) 1107 + #define RPC_NT_UNKNOWN_AUTHN_LEVEL cpu_to_le32(0xC0020031) 1108 + #define RPC_NT_INVALID_AUTH_IDENTITY cpu_to_le32(0xC0020032) 1109 + #define RPC_NT_UNKNOWN_AUTHZ_SERVICE cpu_to_le32(0xC0020033) 1110 + #define EPT_NT_INVALID_ENTRY cpu_to_le32(0xC0020034) 1111 + #define EPT_NT_CANT_PERFORM_OP cpu_to_le32(0xC0020035) 1112 + #define EPT_NT_NOT_REGISTERED cpu_to_le32(0xC0020036) 1113 + #define RPC_NT_NOTHING_TO_EXPORT cpu_to_le32(0xC0020037) 1114 + #define RPC_NT_INCOMPLETE_NAME cpu_to_le32(0xC0020038) 1115 + #define RPC_NT_INVALID_VERS_OPTION cpu_to_le32(0xC0020039) 1116 + #define RPC_NT_NO_MORE_MEMBERS cpu_to_le32(0xC002003A) 1117 + #define RPC_NT_NOT_ALL_OBJS_UNEXPORTED cpu_to_le32(0xC002003B) 1118 + #define RPC_NT_INTERFACE_NOT_FOUND cpu_to_le32(0xC002003C) 1119 + #define RPC_NT_ENTRY_ALREADY_EXISTS cpu_to_le32(0xC002003D) 1120 + #define RPC_NT_ENTRY_NOT_FOUND cpu_to_le32(0xC002003E) 1121 + #define RPC_NT_NAME_SERVICE_UNAVAILABLE cpu_to_le32(0xC002003F) 1122 + #define RPC_NT_INVALID_NAF_ID cpu_to_le32(0xC0020040) 1123 + #define RPC_NT_CANNOT_SUPPORT cpu_to_le32(0xC0020041) 1124 + #define RPC_NT_NO_CONTEXT_AVAILABLE cpu_to_le32(0xC0020042) 1125 + #define RPC_NT_INTERNAL_ERROR cpu_to_le32(0xC0020043) 1126 + #define RPC_NT_ZERO_DIVIDE cpu_to_le32(0xC0020044) 1127 + #define RPC_NT_ADDRESS_ERROR cpu_to_le32(0xC0020045) 1128 + #define RPC_NT_FP_DIV_ZERO cpu_to_le32(0xC0020046) 1129 + #define RPC_NT_FP_UNDERFLOW cpu_to_le32(0xC0020047) 1130 + #define RPC_NT_FP_OVERFLOW cpu_to_le32(0xC0020048) 1131 + #define RPC_NT_CALL_IN_PROGRESS cpu_to_le32(0xC0020049) 1132 + #define RPC_NT_NO_MORE_BINDINGS cpu_to_le32(0xC002004A) 1133 + #define RPC_NT_GROUP_MEMBER_NOT_FOUND cpu_to_le32(0xC002004B) 1134 + #define EPT_NT_CANT_CREATE cpu_to_le32(0xC002004C) 1135 + #define RPC_NT_INVALID_OBJECT cpu_to_le32(0xC002004D) 1136 + #define RPC_NT_NO_INTERFACES cpu_to_le32(0xC002004F) 1137 + #define RPC_NT_CALL_CANCELLED cpu_to_le32(0xC0020050) 1138 + #define RPC_NT_BINDING_INCOMPLETE cpu_to_le32(0xC0020051) 1139 + #define RPC_NT_COMM_FAILURE cpu_to_le32(0xC0020052) 1140 + #define RPC_NT_UNSUPPORTED_AUTHN_LEVEL cpu_to_le32(0xC0020053) 1141 + #define RPC_NT_NO_PRINC_NAME cpu_to_le32(0xC0020054) 1142 + #define RPC_NT_NOT_RPC_ERROR cpu_to_le32(0xC0020055) 1143 + #define RPC_NT_SEC_PKG_ERROR cpu_to_le32(0xC0020057) 1144 + #define RPC_NT_NOT_CANCELLED cpu_to_le32(0xC0020058) 1145 + #define RPC_NT_INVALID_ASYNC_HANDLE cpu_to_le32(0xC0020062) 1146 + #define RPC_NT_INVALID_ASYNC_CALL cpu_to_le32(0xC0020063) 1147 + #define RPC_NT_PROXY_ACCESS_DENIED cpu_to_le32(0xC0020064) 1148 + #define RPC_NT_NO_MORE_ENTRIES cpu_to_le32(0xC0030001) 1149 + #define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL cpu_to_le32(0xC0030002) 1150 + #define RPC_NT_SS_CHAR_TRANS_SHORT_FILE cpu_to_le32(0xC0030003) 1151 + #define RPC_NT_SS_IN_NULL_CONTEXT cpu_to_le32(0xC0030004) 1152 + #define RPC_NT_SS_CONTEXT_MISMATCH cpu_to_le32(0xC0030005) 1153 + #define RPC_NT_SS_CONTEXT_DAMAGED cpu_to_le32(0xC0030006) 1154 + #define RPC_NT_SS_HANDLES_MISMATCH cpu_to_le32(0xC0030007) 1155 + #define RPC_NT_SS_CANNOT_GET_CALL_HANDLE cpu_to_le32(0xC0030008) 1156 + #define RPC_NT_NULL_REF_POINTER cpu_to_le32(0xC0030009) 1157 + #define RPC_NT_ENUM_VALUE_OUT_OF_RANGE cpu_to_le32(0xC003000A) 1158 + #define RPC_NT_BYTE_COUNT_TOO_SMALL cpu_to_le32(0xC003000B) 1159 + #define RPC_NT_BAD_STUB_DATA cpu_to_le32(0xC003000C) 1160 + #define RPC_NT_INVALID_ES_ACTION cpu_to_le32(0xC0030059) 1161 + #define RPC_NT_WRONG_ES_VERSION cpu_to_le32(0xC003005A) 1162 + #define RPC_NT_WRONG_STUB_VERSION cpu_to_le32(0xC003005B) 1163 + #define RPC_NT_INVALID_PIPE_OBJECT cpu_to_le32(0xC003005C) 1164 + #define RPC_NT_INVALID_PIPE_OPERATION cpu_to_le32(0xC003005D) 1165 + #define RPC_NT_WRONG_PIPE_VERSION cpu_to_le32(0xC003005E) 1166 + #define RPC_NT_PIPE_CLOSED cpu_to_le32(0xC003005F) 1167 + #define RPC_NT_PIPE_DISCIPLINE_ERROR cpu_to_le32(0xC0030060) 1168 + #define RPC_NT_PIPE_EMPTY cpu_to_le32(0xC0030061) 1169 + #define STATUS_PNP_BAD_MPS_TABLE cpu_to_le32(0xC0040035) 1170 + #define STATUS_PNP_TRANSLATION_FAILED cpu_to_le32(0xC0040036) 1171 + #define STATUS_PNP_IRQ_TRANSLATION_FAILED cpu_to_le32(0xC0040037) 1172 + #define STATUS_PNP_INVALID_ID cpu_to_le32(0xC0040038) 1173 + #define STATUS_IO_REISSUE_AS_CACHED cpu_to_le32(0xC0040039) 1174 + #define STATUS_CTX_WINSTATION_NAME_INVALID cpu_to_le32(0xC00A0001) 1175 + #define STATUS_CTX_INVALID_PD cpu_to_le32(0xC00A0002) 1176 + #define STATUS_CTX_PD_NOT_FOUND cpu_to_le32(0xC00A0003) 1177 + #define STATUS_CTX_CLOSE_PENDING cpu_to_le32(0xC00A0006) 1178 + #define STATUS_CTX_NO_OUTBUF cpu_to_le32(0xC00A0007) 1179 + #define STATUS_CTX_MODEM_INF_NOT_FOUND cpu_to_le32(0xC00A0008) 1180 + #define STATUS_CTX_INVALID_MODEMNAME cpu_to_le32(0xC00A0009) 1181 + #define STATUS_CTX_RESPONSE_ERROR cpu_to_le32(0xC00A000A) 1182 + #define STATUS_CTX_MODEM_RESPONSE_TIMEOUT cpu_to_le32(0xC00A000B) 1183 + #define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER cpu_to_le32(0xC00A000C) 1184 + #define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE cpu_to_le32(0xC00A000D) 1185 + #define STATUS_CTX_MODEM_RESPONSE_BUSY cpu_to_le32(0xC00A000E) 1186 + #define STATUS_CTX_MODEM_RESPONSE_VOICE cpu_to_le32(0xC00A000F) 1187 + #define STATUS_CTX_TD_ERROR cpu_to_le32(0xC00A0010) 1188 + #define STATUS_CTX_LICENSE_CLIENT_INVALID cpu_to_le32(0xC00A0012) 1189 + #define STATUS_CTX_LICENSE_NOT_AVAILABLE cpu_to_le32(0xC00A0013) 1190 + #define STATUS_CTX_LICENSE_EXPIRED cpu_to_le32(0xC00A0014) 1191 + #define STATUS_CTX_WINSTATION_NOT_FOUND cpu_to_le32(0xC00A0015) 1192 + #define STATUS_CTX_WINSTATION_NAME_COLLISION cpu_to_le32(0xC00A0016) 1193 + #define STATUS_CTX_WINSTATION_BUSY cpu_to_le32(0xC00A0017) 1194 + #define STATUS_CTX_BAD_VIDEO_MODE cpu_to_le32(0xC00A0018) 1195 + #define STATUS_CTX_GRAPHICS_INVALID cpu_to_le32(0xC00A0022) 1196 + #define STATUS_CTX_NOT_CONSOLE cpu_to_le32(0xC00A0024) 1197 + #define STATUS_CTX_CLIENT_QUERY_TIMEOUT cpu_to_le32(0xC00A0026) 1198 + #define STATUS_CTX_CONSOLE_DISCONNECT cpu_to_le32(0xC00A0027) 1199 + #define STATUS_CTX_CONSOLE_CONNECT cpu_to_le32(0xC00A0028) 1200 + #define STATUS_CTX_SHADOW_DENIED cpu_to_le32(0xC00A002A) 1201 + #define STATUS_CTX_WINSTATION_ACCESS_DENIED cpu_to_le32(0xC00A002B) 1202 + #define STATUS_CTX_INVALID_WD cpu_to_le32(0xC00A002E) 1203 + #define STATUS_CTX_WD_NOT_FOUND cpu_to_le32(0xC00A002F) 1204 + #define STATUS_CTX_SHADOW_INVALID cpu_to_le32(0xC00A0030) 1205 + #define STATUS_CTX_SHADOW_DISABLED cpu_to_le32(0xC00A0031) 1206 + #define STATUS_RDP_PROTOCOL_ERROR cpu_to_le32(0xC00A0032) 1207 + #define STATUS_CTX_CLIENT_LICENSE_NOT_SET cpu_to_le32(0xC00A0033) 1208 + #define STATUS_CTX_CLIENT_LICENSE_IN_USE cpu_to_le32(0xC00A0034) 1209 + #define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE cpu_to_le32(0xC00A0035) 1210 + #define STATUS_CTX_SHADOW_NOT_RUNNING cpu_to_le32(0xC00A0036) 1211 + #define STATUS_CTX_LOGON_DISABLED cpu_to_le32(0xC00A0037) 1212 + #define STATUS_CTX_SECURITY_LAYER_ERROR cpu_to_le32(0xC00A0038) 1213 + #define STATUS_TS_INCOMPATIBLE_SESSIONS cpu_to_le32(0xC00A0039) 1214 + #define STATUS_MUI_FILE_NOT_FOUND cpu_to_le32(0xC00B0001) 1215 + #define STATUS_MUI_INVALID_FILE cpu_to_le32(0xC00B0002) 1216 + #define STATUS_MUI_INVALID_RC_CONFIG cpu_to_le32(0xC00B0003) 1217 + #define STATUS_MUI_INVALID_LOCALE_NAME cpu_to_le32(0xC00B0004) 1218 + #define STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME cpu_to_le32(0xC00B0005) 1219 + #define STATUS_MUI_FILE_NOT_LOADED cpu_to_le32(0xC00B0006) 1220 + #define STATUS_RESOURCE_ENUM_USER_STOP cpu_to_le32(0xC00B0007) 1221 + #define STATUS_CLUSTER_INVALID_NODE cpu_to_le32(0xC0130001) 1222 + #define STATUS_CLUSTER_NODE_EXISTS cpu_to_le32(0xC0130002) 1223 + #define STATUS_CLUSTER_JOIN_IN_PROGRESS cpu_to_le32(0xC0130003) 1224 + #define STATUS_CLUSTER_NODE_NOT_FOUND cpu_to_le32(0xC0130004) 1225 + #define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND cpu_to_le32(0xC0130005) 1226 + #define STATUS_CLUSTER_NETWORK_EXISTS cpu_to_le32(0xC0130006) 1227 + #define STATUS_CLUSTER_NETWORK_NOT_FOUND cpu_to_le32(0xC0130007) 1228 + #define STATUS_CLUSTER_NETINTERFACE_EXISTS cpu_to_le32(0xC0130008) 1229 + #define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND cpu_to_le32(0xC0130009) 1230 + #define STATUS_CLUSTER_INVALID_REQUEST cpu_to_le32(0xC013000A) 1231 + #define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER cpu_to_le32(0xC013000B) 1232 + #define STATUS_CLUSTER_NODE_DOWN cpu_to_le32(0xC013000C) 1233 + #define STATUS_CLUSTER_NODE_UNREACHABLE cpu_to_le32(0xC013000D) 1234 + #define STATUS_CLUSTER_NODE_NOT_MEMBER cpu_to_le32(0xC013000E) 1235 + #define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS cpu_to_le32(0xC013000F) 1236 + #define STATUS_CLUSTER_INVALID_NETWORK cpu_to_le32(0xC0130010) 1237 + #define STATUS_CLUSTER_NO_NET_ADAPTERS cpu_to_le32(0xC0130011) 1238 + #define STATUS_CLUSTER_NODE_UP cpu_to_le32(0xC0130012) 1239 + #define STATUS_CLUSTER_NODE_PAUSED cpu_to_le32(0xC0130013) 1240 + #define STATUS_CLUSTER_NODE_NOT_PAUSED cpu_to_le32(0xC0130014) 1241 + #define STATUS_CLUSTER_NO_SECURITY_CONTEXT cpu_to_le32(0xC0130015) 1242 + #define STATUS_CLUSTER_NETWORK_NOT_INTERNAL cpu_to_le32(0xC0130016) 1243 + #define STATUS_CLUSTER_POISONED cpu_to_le32(0xC0130017) 1244 + #define STATUS_ACPI_INVALID_OPCODE cpu_to_le32(0xC0140001) 1245 + #define STATUS_ACPI_STACK_OVERFLOW cpu_to_le32(0xC0140002) 1246 + #define STATUS_ACPI_ASSERT_FAILED cpu_to_le32(0xC0140003) 1247 + #define STATUS_ACPI_INVALID_INDEX cpu_to_le32(0xC0140004) 1248 + #define STATUS_ACPI_INVALID_ARGUMENT cpu_to_le32(0xC0140005) 1249 + #define STATUS_ACPI_FATAL cpu_to_le32(0xC0140006) 1250 + #define STATUS_ACPI_INVALID_SUPERNAME cpu_to_le32(0xC0140007) 1251 + #define STATUS_ACPI_INVALID_ARGTYPE cpu_to_le32(0xC0140008) 1252 + #define STATUS_ACPI_INVALID_OBJTYPE cpu_to_le32(0xC0140009) 1253 + #define STATUS_ACPI_INVALID_TARGETTYPE cpu_to_le32(0xC014000A) 1254 + #define STATUS_ACPI_INCORRECT_ARGUMENT_COUNT cpu_to_le32(0xC014000B) 1255 + #define STATUS_ACPI_ADDRESS_NOT_MAPPED cpu_to_le32(0xC014000C) 1256 + #define STATUS_ACPI_INVALID_EVENTTYPE cpu_to_le32(0xC014000D) 1257 + #define STATUS_ACPI_HANDLER_COLLISION cpu_to_le32(0xC014000E) 1258 + #define STATUS_ACPI_INVALID_DATA cpu_to_le32(0xC014000F) 1259 + #define STATUS_ACPI_INVALID_REGION cpu_to_le32(0xC0140010) 1260 + #define STATUS_ACPI_INVALID_ACCESS_SIZE cpu_to_le32(0xC0140011) 1261 + #define STATUS_ACPI_ACQUIRE_GLOBAL_LOCK cpu_to_le32(0xC0140012) 1262 + #define STATUS_ACPI_ALREADY_INITIALIZED cpu_to_le32(0xC0140013) 1263 + #define STATUS_ACPI_NOT_INITIALIZED cpu_to_le32(0xC0140014) 1264 + #define STATUS_ACPI_INVALID_MUTEX_LEVEL cpu_to_le32(0xC0140015) 1265 + #define STATUS_ACPI_MUTEX_NOT_OWNED cpu_to_le32(0xC0140016) 1266 + #define STATUS_ACPI_MUTEX_NOT_OWNER cpu_to_le32(0xC0140017) 1267 + #define STATUS_ACPI_RS_ACCESS cpu_to_le32(0xC0140018) 1268 + #define STATUS_ACPI_INVALID_TABLE cpu_to_le32(0xC0140019) 1269 + #define STATUS_ACPI_REG_HANDLER_FAILED cpu_to_le32(0xC0140020) 1270 + #define STATUS_ACPI_POWER_REQUEST_FAILED cpu_to_le32(0xC0140021) 1271 + #define STATUS_SXS_SECTION_NOT_FOUND cpu_to_le32(0xC0150001) 1272 + #define STATUS_SXS_CANT_GEN_ACTCTX cpu_to_le32(0xC0150002) 1273 + #define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT cpu_to_le32(0xC0150003) 1274 + #define STATUS_SXS_ASSEMBLY_NOT_FOUND cpu_to_le32(0xC0150004) 1275 + #define STATUS_SXS_MANIFEST_FORMAT_ERROR cpu_to_le32(0xC0150005) 1276 + #define STATUS_SXS_MANIFEST_PARSE_ERROR cpu_to_le32(0xC0150006) 1277 + #define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED cpu_to_le32(0xC0150007) 1278 + #define STATUS_SXS_KEY_NOT_FOUND cpu_to_le32(0xC0150008) 1279 + #define STATUS_SXS_VERSION_CONFLICT cpu_to_le32(0xC0150009) 1280 + #define STATUS_SXS_WRONG_SECTION_TYPE cpu_to_le32(0xC015000A) 1281 + #define STATUS_SXS_THREAD_QUERIES_DISABLED cpu_to_le32(0xC015000B) 1282 + #define STATUS_SXS_ASSEMBLY_MISSING cpu_to_le32(0xC015000C) 1283 + #define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET cpu_to_le32(0xC015000E) 1284 + #define STATUS_SXS_EARLY_DEACTIVATION cpu_to_le32(0xC015000F) 1285 + #define STATUS_SXS_INVALID_DEACTIVATION cpu_to_le32(0xC0150010) 1286 + #define STATUS_SXS_MULTIPLE_DEACTIVATION cpu_to_le32(0xC0150011) 1287 + #define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY cpu_to_le32(0xC0150012) 1288 + #define STATUS_SXS_PROCESS_TERMINATION_REQUESTED cpu_to_le32(0xC0150013) 1289 + #define STATUS_SXS_CORRUPT_ACTIVATION_STACK cpu_to_le32(0xC0150014) 1290 + #define STATUS_SXS_CORRUPTION cpu_to_le32(0xC0150015) 1291 + #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE cpu_to_le32(0xC0150016) 1292 + #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME cpu_to_le32(0xC0150017) 1293 + #define STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE cpu_to_le32(0xC0150018) 1294 + #define STATUS_SXS_IDENTITY_PARSE_ERROR cpu_to_le32(0xC0150019) 1295 + #define STATUS_SXS_COMPONENT_STORE_CORRUPT cpu_to_le32(0xC015001A) 1296 + #define STATUS_SXS_FILE_HASH_MISMATCH cpu_to_le32(0xC015001B) 1297 + #define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT cpu_to_le32(0xC015001C) 1298 + #define STATUS_SXS_IDENTITIES_DIFFERENT cpu_to_le32(0xC015001D) 1299 + #define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT cpu_to_le32(0xC015001E) 1300 + #define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY cpu_to_le32(0xC015001F) 1301 + #define STATUS_ADVANCED_INSTALLER_FAILED cpu_to_le32(0xC0150020) 1302 + #define STATUS_XML_ENCODING_MISMATCH cpu_to_le32(0xC0150021) 1303 + #define STATUS_SXS_MANIFEST_TOO_BIG cpu_to_le32(0xC0150022) 1304 + #define STATUS_SXS_SETTING_NOT_REGISTERED cpu_to_le32(0xC0150023) 1305 + #define STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE cpu_to_le32(0xC0150024) 1306 + #define STATUS_SMI_PRIMITIVE_INSTALLER_FAILED cpu_to_le32(0xC0150025) 1307 + #define STATUS_GENERIC_COMMAND_FAILED cpu_to_le32(0xC0150026) 1308 + #define STATUS_SXS_FILE_HASH_MISSING cpu_to_le32(0xC0150027) 1309 + #define STATUS_TRANSACTIONAL_CONFLICT cpu_to_le32(0xC0190001) 1310 + #define STATUS_INVALID_TRANSACTION cpu_to_le32(0xC0190002) 1311 + #define STATUS_TRANSACTION_NOT_ACTIVE cpu_to_le32(0xC0190003) 1312 + #define STATUS_TM_INITIALIZATION_FAILED cpu_to_le32(0xC0190004) 1313 + #define STATUS_RM_NOT_ACTIVE cpu_to_le32(0xC0190005) 1314 + #define STATUS_RM_METADATA_CORRUPT cpu_to_le32(0xC0190006) 1315 + #define STATUS_TRANSACTION_NOT_JOINED cpu_to_le32(0xC0190007) 1316 + #define STATUS_DIRECTORY_NOT_RM cpu_to_le32(0xC0190008) 1317 + #define STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE cpu_to_le32(0xC019000A) 1318 + #define STATUS_LOG_RESIZE_INVALID_SIZE cpu_to_le32(0xC019000B) 1319 + #define STATUS_REMOTE_FILE_VERSION_MISMATCH cpu_to_le32(0xC019000C) 1320 + #define STATUS_CRM_PROTOCOL_ALREADY_EXISTS cpu_to_le32(0xC019000F) 1321 + #define STATUS_TRANSACTION_PROPAGATION_FAILED cpu_to_le32(0xC0190010) 1322 + #define STATUS_CRM_PROTOCOL_NOT_FOUND cpu_to_le32(0xC0190011) 1323 + #define STATUS_TRANSACTION_SUPERIOR_EXISTS cpu_to_le32(0xC0190012) 1324 + #define STATUS_TRANSACTION_REQUEST_NOT_VALID cpu_to_le32(0xC0190013) 1325 + #define STATUS_TRANSACTION_NOT_REQUESTED cpu_to_le32(0xC0190014) 1326 + #define STATUS_TRANSACTION_ALREADY_ABORTED cpu_to_le32(0xC0190015) 1327 + #define STATUS_TRANSACTION_ALREADY_COMMITTED cpu_to_le32(0xC0190016) 1328 + #define STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER cpu_to_le32(0xC0190017) 1329 + #define STATUS_CURRENT_TRANSACTION_NOT_VALID cpu_to_le32(0xC0190018) 1330 + #define STATUS_LOG_GROWTH_FAILED cpu_to_le32(0xC0190019) 1331 + #define STATUS_OBJECT_NO_LONGER_EXISTS cpu_to_le32(0xC0190021) 1332 + #define STATUS_STREAM_MINIVERSION_NOT_FOUND cpu_to_le32(0xC0190022) 1333 + #define STATUS_STREAM_MINIVERSION_NOT_VALID cpu_to_le32(0xC0190023) 1334 + #define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION cpu_to_le32(0xC0190024) 1335 + #define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT cpu_to_le32(0xC0190025) 1336 + #define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS cpu_to_le32(0xC0190026) 1337 + #define STATUS_HANDLE_NO_LONGER_VALID cpu_to_le32(0xC0190028) 1338 + #define STATUS_LOG_CORRUPTION_DETECTED cpu_to_le32(0xC0190030) 1339 + #define STATUS_RM_DISCONNECTED cpu_to_le32(0xC0190032) 1340 + #define STATUS_ENLISTMENT_NOT_SUPERIOR cpu_to_le32(0xC0190033) 1341 + #define STATUS_FILE_IDENTITY_NOT_PERSISTENT cpu_to_le32(0xC0190036) 1342 + #define STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY cpu_to_le32(0xC0190037) 1343 + #define STATUS_CANT_CROSS_RM_BOUNDARY cpu_to_le32(0xC0190038) 1344 + #define STATUS_TXF_DIR_NOT_EMPTY cpu_to_le32(0xC0190039) 1345 + #define STATUS_INDOUBT_TRANSACTIONS_EXIST cpu_to_le32(0xC019003A) 1346 + #define STATUS_TM_VOLATILE cpu_to_le32(0xC019003B) 1347 + #define STATUS_ROLLBACK_TIMER_EXPIRED cpu_to_le32(0xC019003C) 1348 + #define STATUS_TXF_ATTRIBUTE_CORRUPT cpu_to_le32(0xC019003D) 1349 + #define STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC019003E) 1350 + #define STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED cpu_to_le32(0xC019003F) 1351 + #define STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE cpu_to_le32(0xC0190040) 1352 + #define STATUS_TRANSACTION_REQUIRED_PROMOTION cpu_to_le32(0xC0190043) 1353 + #define STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION cpu_to_le32(0xC0190044) 1354 + #define STATUS_TRANSACTIONS_NOT_FROZEN cpu_to_le32(0xC0190045) 1355 + #define STATUS_TRANSACTION_FREEZE_IN_PROGRESS cpu_to_le32(0xC0190046) 1356 + #define STATUS_NOT_SNAPSHOT_VOLUME cpu_to_le32(0xC0190047) 1357 + #define STATUS_NO_SAVEPOINT_WITH_OPEN_FILES cpu_to_le32(0xC0190048) 1358 + #define STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190049) 1359 + #define STATUS_TM_IDENTITY_MISMATCH cpu_to_le32(0xC019004A) 1360 + #define STATUS_FLOATED_SECTION cpu_to_le32(0xC019004B) 1361 + #define STATUS_CANNOT_ACCEPT_TRANSACTED_WORK cpu_to_le32(0xC019004C) 1362 + #define STATUS_CANNOT_ABORT_TRANSACTIONS cpu_to_le32(0xC019004D) 1363 + #define STATUS_TRANSACTION_NOT_FOUND cpu_to_le32(0xC019004E) 1364 + #define STATUS_RESOURCEMANAGER_NOT_FOUND cpu_to_le32(0xC019004F) 1365 + #define STATUS_ENLISTMENT_NOT_FOUND cpu_to_le32(0xC0190050) 1366 + #define STATUS_TRANSACTIONMANAGER_NOT_FOUND cpu_to_le32(0xC0190051) 1367 + #define STATUS_TRANSACTIONMANAGER_NOT_ONLINE cpu_to_le32(0xC0190052) 1368 + #define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION cpu_to_le32(0xC0190053) 1369 + #define STATUS_TRANSACTION_NOT_ROOT cpu_to_le32(0xC0190054) 1370 + #define STATUS_TRANSACTION_OBJECT_EXPIRED cpu_to_le32(0xC0190055) 1371 + #define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190056) 1372 + #define STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED cpu_to_le32(0xC0190057) 1373 + #define STATUS_TRANSACTION_RECORD_TOO_LONG cpu_to_le32(0xC0190058) 1374 + #define STATUS_NO_LINK_TRACKING_IN_TRANSACTION cpu_to_le32(0xC0190059) 1375 + #define STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION cpu_to_le32(0xC019005A) 1376 + #define STATUS_TRANSACTION_INTEGRITY_VIOLATED cpu_to_le32(0xC019005B) 1377 + #define STATUS_LOG_SECTOR_INVALID cpu_to_le32(0xC01A0001) 1378 + #define STATUS_LOG_SECTOR_PARITY_INVALID cpu_to_le32(0xC01A0002) 1379 + #define STATUS_LOG_SECTOR_REMAPPED cpu_to_le32(0xC01A0003) 1380 + #define STATUS_LOG_BLOCK_INCOMPLETE cpu_to_le32(0xC01A0004) 1381 + #define STATUS_LOG_INVALID_RANGE cpu_to_le32(0xC01A0005) 1382 + #define STATUS_LOG_BLOCKS_EXHAUSTED cpu_to_le32(0xC01A0006) 1383 + #define STATUS_LOG_READ_CONTEXT_INVALID cpu_to_le32(0xC01A0007) 1384 + #define STATUS_LOG_RESTART_INVALID cpu_to_le32(0xC01A0008) 1385 + #define STATUS_LOG_BLOCK_VERSION cpu_to_le32(0xC01A0009) 1386 + #define STATUS_LOG_BLOCK_INVALID cpu_to_le32(0xC01A000A) 1387 + #define STATUS_LOG_READ_MODE_INVALID cpu_to_le32(0xC01A000B) 1388 + #define STATUS_LOG_METADATA_CORRUPT cpu_to_le32(0xC01A000D) 1389 + #define STATUS_LOG_METADATA_INVALID cpu_to_le32(0xC01A000E) 1390 + #define STATUS_LOG_METADATA_INCONSISTENT cpu_to_le32(0xC01A000F) 1391 + #define STATUS_LOG_RESERVATION_INVALID cpu_to_le32(0xC01A0010) 1392 + #define STATUS_LOG_CANT_DELETE cpu_to_le32(0xC01A0011) 1393 + #define STATUS_LOG_CONTAINER_LIMIT_EXCEEDED cpu_to_le32(0xC01A0012) 1394 + #define STATUS_LOG_START_OF_LOG cpu_to_le32(0xC01A0013) 1395 + #define STATUS_LOG_POLICY_ALREADY_INSTALLED cpu_to_le32(0xC01A0014) 1396 + #define STATUS_LOG_POLICY_NOT_INSTALLED cpu_to_le32(0xC01A0015) 1397 + #define STATUS_LOG_POLICY_INVALID cpu_to_le32(0xC01A0016) 1398 + #define STATUS_LOG_POLICY_CONFLICT cpu_to_le32(0xC01A0017) 1399 + #define STATUS_LOG_PINNED_ARCHIVE_TAIL cpu_to_le32(0xC01A0018) 1400 + #define STATUS_LOG_RECORD_NONEXISTENT cpu_to_le32(0xC01A0019) 1401 + #define STATUS_LOG_RECORDS_RESERVED_INVALID cpu_to_le32(0xC01A001A) 1402 + #define STATUS_LOG_SPACE_RESERVED_INVALID cpu_to_le32(0xC01A001B) 1403 + #define STATUS_LOG_TAIL_INVALID cpu_to_le32(0xC01A001C) 1404 + #define STATUS_LOG_FULL cpu_to_le32(0xC01A001D) 1405 + #define STATUS_LOG_MULTIPLEXED cpu_to_le32(0xC01A001E) 1406 + #define STATUS_LOG_DEDICATED cpu_to_le32(0xC01A001F) 1407 + #define STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS cpu_to_le32(0xC01A0020) 1408 + #define STATUS_LOG_ARCHIVE_IN_PROGRESS cpu_to_le32(0xC01A0021) 1409 + #define STATUS_LOG_EPHEMERAL cpu_to_le32(0xC01A0022) 1410 + #define STATUS_LOG_NOT_ENOUGH_CONTAINERS cpu_to_le32(0xC01A0023) 1411 + #define STATUS_LOG_CLIENT_ALREADY_REGISTERED cpu_to_le32(0xC01A0024) 1412 + #define STATUS_LOG_CLIENT_NOT_REGISTERED cpu_to_le32(0xC01A0025) 1413 + #define STATUS_LOG_FULL_HANDLER_IN_PROGRESS cpu_to_le32(0xC01A0026) 1414 + #define STATUS_LOG_CONTAINER_READ_FAILED cpu_to_le32(0xC01A0027) 1415 + #define STATUS_LOG_CONTAINER_WRITE_FAILED cpu_to_le32(0xC01A0028) 1416 + #define STATUS_LOG_CONTAINER_OPEN_FAILED cpu_to_le32(0xC01A0029) 1417 + #define STATUS_LOG_CONTAINER_STATE_INVALID cpu_to_le32(0xC01A002A) 1418 + #define STATUS_LOG_STATE_INVALID cpu_to_le32(0xC01A002B) 1419 + #define STATUS_LOG_PINNED cpu_to_le32(0xC01A002C) 1420 + #define STATUS_LOG_METADATA_FLUSH_FAILED cpu_to_le32(0xC01A002D) 1421 + #define STATUS_LOG_INCONSISTENT_SECURITY cpu_to_le32(0xC01A002E) 1422 + #define STATUS_LOG_APPENDED_FLUSH_FAILED cpu_to_le32(0xC01A002F) 1423 + #define STATUS_LOG_PINNED_RESERVATION cpu_to_le32(0xC01A0030) 1424 + #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD cpu_to_le32(0xC01B00EA) 1425 + #define STATUS_FLT_NO_HANDLER_DEFINED cpu_to_le32(0xC01C0001) 1426 + #define STATUS_FLT_CONTEXT_ALREADY_DEFINED cpu_to_le32(0xC01C0002) 1427 + #define STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST cpu_to_le32(0xC01C0003) 1428 + #define STATUS_FLT_DISALLOW_FAST_IO cpu_to_le32(0xC01C0004) 1429 + #define STATUS_FLT_INVALID_NAME_REQUEST cpu_to_le32(0xC01C0005) 1430 + #define STATUS_FLT_NOT_SAFE_TO_POST_OPERATION cpu_to_le32(0xC01C0006) 1431 + #define STATUS_FLT_NOT_INITIALIZED cpu_to_le32(0xC01C0007) 1432 + #define STATUS_FLT_FILTER_NOT_READY cpu_to_le32(0xC01C0008) 1433 + #define STATUS_FLT_POST_OPERATION_CLEANUP cpu_to_le32(0xC01C0009) 1434 + #define STATUS_FLT_INTERNAL_ERROR cpu_to_le32(0xC01C000A) 1435 + #define STATUS_FLT_DELETING_OBJECT cpu_to_le32(0xC01C000B) 1436 + #define STATUS_FLT_MUST_BE_NONPAGED_POOL cpu_to_le32(0xC01C000C) 1437 + #define STATUS_FLT_DUPLICATE_ENTRY cpu_to_le32(0xC01C000D) 1438 + #define STATUS_FLT_CBDQ_DISABLED cpu_to_le32(0xC01C000E) 1439 + #define STATUS_FLT_DO_NOT_ATTACH cpu_to_le32(0xC01C000F) 1440 + #define STATUS_FLT_DO_NOT_DETACH cpu_to_le32(0xC01C0010) 1441 + #define STATUS_FLT_INSTANCE_ALTITUDE_COLLISION cpu_to_le32(0xC01C0011) 1442 + #define STATUS_FLT_INSTANCE_NAME_COLLISION cpu_to_le32(0xC01C0012) 1443 + #define STATUS_FLT_FILTER_NOT_FOUND cpu_to_le32(0xC01C0013) 1444 + #define STATUS_FLT_VOLUME_NOT_FOUND cpu_to_le32(0xC01C0014) 1445 + #define STATUS_FLT_INSTANCE_NOT_FOUND cpu_to_le32(0xC01C0015) 1446 + #define STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND cpu_to_le32(0xC01C0016) 1447 + #define STATUS_FLT_INVALID_CONTEXT_REGISTRATION cpu_to_le32(0xC01C0017) 1448 + #define STATUS_FLT_NAME_CACHE_MISS cpu_to_le32(0xC01C0018) 1449 + #define STATUS_FLT_NO_DEVICE_OBJECT cpu_to_le32(0xC01C0019) 1450 + #define STATUS_FLT_VOLUME_ALREADY_MOUNTED cpu_to_le32(0xC01C001A) 1451 + #define STATUS_FLT_ALREADY_ENLISTED cpu_to_le32(0xC01C001B) 1452 + #define STATUS_FLT_CONTEXT_ALREADY_LINKED cpu_to_le32(0xC01C001C) 1453 + #define STATUS_FLT_NO_WAITER_FOR_REPLY cpu_to_le32(0xC01C0020) 1454 + #define STATUS_MONITOR_NO_DESCRIPTOR cpu_to_le32(0xC01D0001) 1455 + #define STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT cpu_to_le32(0xC01D0002) 1456 + #define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM cpu_to_le32(0xC01D0003) 1457 + #define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK cpu_to_le32(0xC01D0004) 1458 + #define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED cpu_to_le32(0xC01D0005) 1459 + #define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK cpu_to_le32(0xC01D0006) 1460 + #define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK cpu_to_le32(0xC01D0007) 1461 + #define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA cpu_to_le32(0xC01D0008) 1462 + #define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK cpu_to_le32(0xC01D0009) 1463 + #define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER cpu_to_le32(0xC01E0000) 1464 + #define STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER cpu_to_le32(0xC01E0001) 1465 + #define STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER cpu_to_le32(0xC01E0002) 1466 + #define STATUS_GRAPHICS_ADAPTER_WAS_RESET cpu_to_le32(0xC01E0003) 1467 + #define STATUS_GRAPHICS_INVALID_DRIVER_MODEL cpu_to_le32(0xC01E0004) 1468 + #define STATUS_GRAPHICS_PRESENT_MODE_CHANGED cpu_to_le32(0xC01E0005) 1469 + #define STATUS_GRAPHICS_PRESENT_OCCLUDED cpu_to_le32(0xC01E0006) 1470 + #define STATUS_GRAPHICS_PRESENT_DENIED cpu_to_le32(0xC01E0007) 1471 + #define STATUS_GRAPHICS_CANNOTCOLORCONVERT cpu_to_le32(0xC01E0008) 1472 + #define STATUS_GRAPHICS_NO_VIDEO_MEMORY cpu_to_le32(0xC01E0100) 1473 + #define STATUS_GRAPHICS_CANT_LOCK_MEMORY cpu_to_le32(0xC01E0101) 1474 + #define STATUS_GRAPHICS_ALLOCATION_BUSY cpu_to_le32(0xC01E0102) 1475 + #define STATUS_GRAPHICS_TOO_MANY_REFERENCES cpu_to_le32(0xC01E0103) 1476 + #define STATUS_GRAPHICS_TRY_AGAIN_LATER cpu_to_le32(0xC01E0104) 1477 + #define STATUS_GRAPHICS_TRY_AGAIN_NOW cpu_to_le32(0xC01E0105) 1478 + #define STATUS_GRAPHICS_ALLOCATION_INVALID cpu_to_le32(0xC01E0106) 1479 + #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE cpu_to_le32(0xC01E0107) 1480 + #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED cpu_to_le32(0xC01E0108) 1481 + #define STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION cpu_to_le32(0xC01E0109) 1482 + #define STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE cpu_to_le32(0xC01E0110) 1483 + #define STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION cpu_to_le32(0xC01E0111) 1484 + #define STATUS_GRAPHICS_ALLOCATION_CLOSED cpu_to_le32(0xC01E0112) 1485 + #define STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE cpu_to_le32(0xC01E0113) 1486 + #define STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE cpu_to_le32(0xC01E0114) 1487 + #define STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE cpu_to_le32(0xC01E0115) 1488 + #define STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST cpu_to_le32(0xC01E0116) 1489 + #define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE cpu_to_le32(0xC01E0200) 1490 + #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0300) 1491 + #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED cpu_to_le32(0xC01E0301) 1492 + #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED cpu_to_le32(0xC01E0302) 1493 + #define STATUS_GRAPHICS_INVALID_VIDPN cpu_to_le32(0xC01E0303) 1494 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE cpu_to_le32(0xC01E0304) 1495 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET cpu_to_le32(0xC01E0305) 1496 + #define STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED cpu_to_le32(0xC01E0306) 1497 + #define STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET cpu_to_le32(0xC01E0308) 1498 + #define STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET cpu_to_le32(0xC01E0309) 1499 + #define STATUS_GRAPHICS_INVALID_FREQUENCY cpu_to_le32(0xC01E030A) 1500 + #define STATUS_GRAPHICS_INVALID_ACTIVE_REGION cpu_to_le32(0xC01E030B) 1501 + #define STATUS_GRAPHICS_INVALID_TOTAL_REGION cpu_to_le32(0xC01E030C) 1502 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE cpu_to_le32(0xC01E0310) 1503 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE cpu_to_le32(0xC01E0311) 1504 + #define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET cpu_to_le32(0xC01E0312) 1505 + #define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY cpu_to_le32(0xC01E0313) 1506 + #define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET cpu_to_le32(0xC01E0314) 1507 + #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET cpu_to_le32(0xC01E0315) 1508 + #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET cpu_to_le32(0xC01E0316) 1509 + #define STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET cpu_to_le32(0xC01E0317) 1510 + #define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET cpu_to_le32(0xC01E0318) 1511 + #define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH cpu_to_le32(0xC01E0319) 1512 + #define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY cpu_to_le32(0xC01E031A) 1513 + #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET cpu_to_le32(0xC01E031B) 1514 + #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE cpu_to_le32(0xC01E031C) 1515 + #define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET cpu_to_le32(0xC01E031D) 1516 + #define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET cpu_to_le32(0xC01E031F) 1517 + #define STATUS_GRAPHICS_STALE_MODESET cpu_to_le32(0xC01E0320) 1518 + #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET cpu_to_le32(0xC01E0321) 1519 + #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE cpu_to_le32(0xC01E0322) 1520 + #define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN cpu_to_le32(0xC01E0323) 1521 + #define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0324) 1522 + #define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION cpu_to_le32(0xC01E0325) 1523 + #define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES cpu_to_le32(0xC01E0326) 1524 + #define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0327) 1525 + #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE cpu_to_le32(0xC01E0328) 1526 + #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET cpu_to_le32(0xC01E0329) 1527 + #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET cpu_to_le32(0xC01E032A) 1528 + #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR cpu_to_le32(0xC01E032B) 1529 + #define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET cpu_to_le32(0xC01E032C) 1530 + #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET cpu_to_le32(0xC01E032D) 1531 + #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E032E) 1532 + #define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE cpu_to_le32(0xC01E032F) 1533 + #define STATUS_GRAPHICS_RESOURCES_NOT_RELATED cpu_to_le32(0xC01E0330) 1534 + #define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0331) 1535 + #define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0332) 1536 + #define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET cpu_to_le32(0xC01E0333) 1537 + #define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER cpu_to_le32(0xC01E0334) 1538 + #define STATUS_GRAPHICS_NO_VIDPNMGR cpu_to_le32(0xC01E0335) 1539 + #define STATUS_GRAPHICS_NO_ACTIVE_VIDPN cpu_to_le32(0xC01E0336) 1540 + #define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0337) 1541 + #define STATUS_GRAPHICS_MONITOR_NOT_CONNECTED cpu_to_le32(0xC01E0338) 1542 + #define STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0339) 1543 + #define STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE cpu_to_le32(0xC01E033A) 1544 + #define STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE cpu_to_le32(0xC01E033B) 1545 + #define STATUS_GRAPHICS_INVALID_STRIDE cpu_to_le32(0xC01E033C) 1546 + #define STATUS_GRAPHICS_INVALID_PIXELFORMAT cpu_to_le32(0xC01E033D) 1547 + #define STATUS_GRAPHICS_INVALID_COLORBASIS cpu_to_le32(0xC01E033E) 1548 + #define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE cpu_to_le32(0xC01E033F) 1549 + #define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0340) 1550 + #define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT cpu_to_le32(0xC01E0341) 1551 + #define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE cpu_to_le32(0xC01E0342) 1552 + #define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN cpu_to_le32(0xC01E0343) 1553 + #define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL cpu_to_le32(0xC01E0344) 1554 + #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION cpu_to_le32(0xC01E0345) 1555 + #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED cpu_to_le32(0xC01E0346) 1556 + #define STATUS_GRAPHICS_INVALID_GAMMA_RAMP cpu_to_le32(0xC01E0347) 1557 + #define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED cpu_to_le32(0xC01E0348) 1558 + #define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED cpu_to_le32(0xC01E0349) 1559 + #define STATUS_GRAPHICS_MODE_NOT_IN_MODESET cpu_to_le32(0xC01E034A) 1560 + #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON cpu_to_le32(0xC01E034D) 1561 + #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE cpu_to_le32(0xC01E034E) 1562 + #define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE cpu_to_le32(0xC01E034F) 1563 + #define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS cpu_to_le32(0xC01E0350) 1564 + #define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING cpu_to_le32(0xC01E0352) 1565 + #define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED cpu_to_le32(0xC01E0353) 1566 + #define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS cpu_to_le32(0xC01E0354) 1567 + #define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT cpu_to_le32(0xC01E0355) 1568 + #define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM cpu_to_le32(0xC01E0356) 1569 + #define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN cpu_to_le32(0xC01E0357) 1570 + #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT cpu_to_le32(0xC01E0358) 1571 + #define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED cpu_to_le32(0xC01E0359) 1572 + #define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION cpu_to_le32(0xC01E035A) 1573 + #define STATUS_GRAPHICS_INVALID_CLIENT_TYPE cpu_to_le32(0xC01E035B) 1574 + #define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET cpu_to_le32(0xC01E035C) 1575 + #define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED cpu_to_le32(0xC01E0400) 1576 + #define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED cpu_to_le32(0xC01E0401) 1577 + #define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER cpu_to_le32(0xC01E0430) 1578 + #define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED cpu_to_le32(0xC01E0431) 1579 + #define STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED cpu_to_le32(0xC01E0432) 1580 + #define STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY cpu_to_le32(0xC01E0433) 1581 + #define STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED cpu_to_le32(0xC01E0434) 1582 + #define STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON cpu_to_le32(0xC01E0435) 1583 + #define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE cpu_to_le32(0xC01E0436) 1584 + #define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER cpu_to_le32(0xC01E0438) 1585 + #define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED cpu_to_le32(0xC01E043B) 1586 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS cpu_to_le32(0xC01E051C) 1587 + #define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST cpu_to_le32(0xC01E051D) 1588 + #define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC01E051E) 1589 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS cpu_to_le32(0xC01E051F) 1590 + #define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED cpu_to_le32(0xC01E0520) 1591 + #define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST cpu_to_le32(0xC01E0521) 1592 + #define STATUS_GRAPHICS_OPM_NOT_SUPPORTED cpu_to_le32(0xC01E0500) 1593 + #define STATUS_GRAPHICS_COPP_NOT_SUPPORTED cpu_to_le32(0xC01E0501) 1594 + #define STATUS_GRAPHICS_UAB_NOT_SUPPORTED cpu_to_le32(0xC01E0502) 1595 + #define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS cpu_to_le32(0xC01E0503) 1596 + #define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E0504) 1597 + #define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST cpu_to_le32(0xC01E0505) 1598 + #define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E0506) 1599 + #define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E0507) 1600 + #define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E0508) 1601 + #define STATUS_GRAPHICS_OPM_INVALID_POINTER cpu_to_le32(0xC01E050A) 1602 + #define STATUS_GRAPHICS_OPM_INTERNAL_ERROR cpu_to_le32(0xC01E050B) 1603 + #define STATUS_GRAPHICS_OPM_INVALID_HANDLE cpu_to_le32(0xC01E050C) 1604 + #define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E050D) 1605 + #define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH cpu_to_le32(0xC01E050E) 1606 + #define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED cpu_to_le32(0xC01E050F) 1607 + #define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED cpu_to_le32(0xC01E0510) 1608 + #define STATUS_GRAPHICS_PVP_HFS_FAILED cpu_to_le32(0xC01E0511) 1609 + #define STATUS_GRAPHICS_OPM_INVALID_SRM cpu_to_le32(0xC01E0512) 1610 + #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP cpu_to_le32(0xC01E0513) 1611 + #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP cpu_to_le32(0xC01E0514) 1612 + #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA cpu_to_le32(0xC01E0515) 1613 + #define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET cpu_to_le32(0xC01E0516) 1614 + #define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH cpu_to_le32(0xC01E0517) 1615 + #define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE cpu_to_le32(0xC01E0518) 1616 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS cpu_to_le32(0xC01E051A) 1617 + #define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E051B) 1618 + #define STATUS_GRAPHICS_I2C_NOT_SUPPORTED cpu_to_le32(0xC01E0580) 1619 + #define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC01E0581) 1620 + #define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA cpu_to_le32(0xC01E0582) 1621 + #define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA cpu_to_le32(0xC01E0583) 1622 + #define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED cpu_to_le32(0xC01E0584) 1623 + #define STATUS_GRAPHICS_DDCCI_INVALID_DATA cpu_to_le32(0xC01E0585) 1624 + #define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE cpu_to_le32(0xC01E0586) 1625 + #define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING cpu_to_le32(0xC01E0587) 1626 + #define STATUS_GRAPHICS_MCA_INTERNAL_ERROR cpu_to_le32(0xC01E0588) 1627 + #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND cpu_to_le32(0xC01E0589) 1628 + #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH cpu_to_le32(0xC01E058A) 1629 + #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM cpu_to_le32(0xC01E058B) 1630 + #define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE cpu_to_le32(0xC01E058C) 1631 + #define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS cpu_to_le32(0xC01E058D) 1632 + #define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED cpu_to_le32(0xC01E05E0) 1633 + #define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E05E1) 1634 + #define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E05E2) 1635 + #define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E05E3) 1636 + #define STATUS_GRAPHICS_INVALID_POINTER cpu_to_le32(0xC01E05E4) 1637 + #define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E05E5) 1638 + #define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E05E6) 1639 + #define STATUS_GRAPHICS_INTERNAL_ERROR cpu_to_le32(0xC01E05E7) 1640 + #define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E05E8) 1641 + #define STATUS_FVE_LOCKED_VOLUME cpu_to_le32(0xC0210000) 1642 + #define STATUS_FVE_NOT_ENCRYPTED cpu_to_le32(0xC0210001) 1643 + #define STATUS_FVE_BAD_INFORMATION cpu_to_le32(0xC0210002) 1644 + #define STATUS_FVE_TOO_SMALL cpu_to_le32(0xC0210003) 1645 + #define STATUS_FVE_FAILED_WRONG_FS cpu_to_le32(0xC0210004) 1646 + #define STATUS_FVE_FAILED_BAD_FS cpu_to_le32(0xC0210005) 1647 + #define STATUS_FVE_FS_NOT_EXTENDED cpu_to_le32(0xC0210006) 1648 + #define STATUS_FVE_FS_MOUNTED cpu_to_le32(0xC0210007) 1649 + #define STATUS_FVE_NO_LICENSE cpu_to_le32(0xC0210008) 1650 + #define STATUS_FVE_ACTION_NOT_ALLOWED cpu_to_le32(0xC0210009) 1651 + #define STATUS_FVE_BAD_DATA cpu_to_le32(0xC021000A) 1652 + #define STATUS_FVE_VOLUME_NOT_BOUND cpu_to_le32(0xC021000B) 1653 + #define STATUS_FVE_NOT_DATA_VOLUME cpu_to_le32(0xC021000C) 1654 + #define STATUS_FVE_CONV_READ_ERROR cpu_to_le32(0xC021000D) 1655 + #define STATUS_FVE_CONV_WRITE_ERROR cpu_to_le32(0xC021000E) 1656 + #define STATUS_FVE_OVERLAPPED_UPDATE cpu_to_le32(0xC021000F) 1657 + #define STATUS_FVE_FAILED_SECTOR_SIZE cpu_to_le32(0xC0210010) 1658 + #define STATUS_FVE_FAILED_AUTHENTICATION cpu_to_le32(0xC0210011) 1659 + #define STATUS_FVE_NOT_OS_VOLUME cpu_to_le32(0xC0210012) 1660 + #define STATUS_FVE_KEYFILE_NOT_FOUND cpu_to_le32(0xC0210013) 1661 + #define STATUS_FVE_KEYFILE_INVALID cpu_to_le32(0xC0210014) 1662 + #define STATUS_FVE_KEYFILE_NO_VMK cpu_to_le32(0xC0210015) 1663 + #define STATUS_FVE_TPM_DISABLED cpu_to_le32(0xC0210016) 1664 + #define STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO cpu_to_le32(0xC0210017) 1665 + #define STATUS_FVE_TPM_INVALID_PCR cpu_to_le32(0xC0210018) 1666 + #define STATUS_FVE_TPM_NO_VMK cpu_to_le32(0xC0210019) 1667 + #define STATUS_FVE_PIN_INVALID cpu_to_le32(0xC021001A) 1668 + #define STATUS_FVE_AUTH_INVALID_APPLICATION cpu_to_le32(0xC021001B) 1669 + #define STATUS_FVE_AUTH_INVALID_CONFIG cpu_to_le32(0xC021001C) 1670 + #define STATUS_FVE_DEBUGGER_ENABLED cpu_to_le32(0xC021001D) 1671 + #define STATUS_FVE_DRY_RUN_FAILED cpu_to_le32(0xC021001E) 1672 + #define STATUS_FVE_BAD_METADATA_POINTER cpu_to_le32(0xC021001F) 1673 + #define STATUS_FVE_OLD_METADATA_COPY cpu_to_le32(0xC0210020) 1674 + #define STATUS_FVE_REBOOT_REQUIRED cpu_to_le32(0xC0210021) 1675 + #define STATUS_FVE_RAW_ACCESS cpu_to_le32(0xC0210022) 1676 + #define STATUS_FVE_RAW_BLOCKED cpu_to_le32(0xC0210023) 1677 + #define STATUS_FWP_CALLOUT_NOT_FOUND cpu_to_le32(0xC0220001) 1678 + #define STATUS_FWP_CONDITION_NOT_FOUND cpu_to_le32(0xC0220002) 1679 + #define STATUS_FWP_FILTER_NOT_FOUND cpu_to_le32(0xC0220003) 1680 + #define STATUS_FWP_LAYER_NOT_FOUND cpu_to_le32(0xC0220004) 1681 + #define STATUS_FWP_PROVIDER_NOT_FOUND cpu_to_le32(0xC0220005) 1682 + #define STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND cpu_to_le32(0xC0220006) 1683 + #define STATUS_FWP_SUBLAYER_NOT_FOUND cpu_to_le32(0xC0220007) 1684 + #define STATUS_FWP_NOT_FOUND cpu_to_le32(0xC0220008) 1685 + #define STATUS_FWP_ALREADY_EXISTS cpu_to_le32(0xC0220009) 1686 + #define STATUS_FWP_IN_USE cpu_to_le32(0xC022000A) 1687 + #define STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS cpu_to_le32(0xC022000B) 1688 + #define STATUS_FWP_WRONG_SESSION cpu_to_le32(0xC022000C) 1689 + #define STATUS_FWP_NO_TXN_IN_PROGRESS cpu_to_le32(0xC022000D) 1690 + #define STATUS_FWP_TXN_IN_PROGRESS cpu_to_le32(0xC022000E) 1691 + #define STATUS_FWP_TXN_ABORTED cpu_to_le32(0xC022000F) 1692 + #define STATUS_FWP_SESSION_ABORTED cpu_to_le32(0xC0220010) 1693 + #define STATUS_FWP_INCOMPATIBLE_TXN cpu_to_le32(0xC0220011) 1694 + #define STATUS_FWP_TIMEOUT cpu_to_le32(0xC0220012) 1695 + #define STATUS_FWP_NET_EVENTS_DISABLED cpu_to_le32(0xC0220013) 1696 + #define STATUS_FWP_INCOMPATIBLE_LAYER cpu_to_le32(0xC0220014) 1697 + #define STATUS_FWP_KM_CLIENTS_ONLY cpu_to_le32(0xC0220015) 1698 + #define STATUS_FWP_LIFETIME_MISMATCH cpu_to_le32(0xC0220016) 1699 + #define STATUS_FWP_BUILTIN_OBJECT cpu_to_le32(0xC0220017) 1700 + #define STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS cpu_to_le32(0xC0220018) 1701 + #define STATUS_FWP_TOO_MANY_CALLOUTS cpu_to_le32(0xC0220018) 1702 + #define STATUS_FWP_NOTIFICATION_DROPPED cpu_to_le32(0xC0220019) 1703 + #define STATUS_FWP_TRAFFIC_MISMATCH cpu_to_le32(0xC022001A) 1704 + #define STATUS_FWP_INCOMPATIBLE_SA_STATE cpu_to_le32(0xC022001B) 1705 + #define STATUS_FWP_NULL_POINTER cpu_to_le32(0xC022001C) 1706 + #define STATUS_FWP_INVALID_ENUMERATOR cpu_to_le32(0xC022001D) 1707 + #define STATUS_FWP_INVALID_FLAGS cpu_to_le32(0xC022001E) 1708 + #define STATUS_FWP_INVALID_NET_MASK cpu_to_le32(0xC022001F) 1709 + #define STATUS_FWP_INVALID_RANGE cpu_to_le32(0xC0220020) 1710 + #define STATUS_FWP_INVALID_INTERVAL cpu_to_le32(0xC0220021) 1711 + #define STATUS_FWP_ZERO_LENGTH_ARRAY cpu_to_le32(0xC0220022) 1712 + #define STATUS_FWP_NULL_DISPLAY_NAME cpu_to_le32(0xC0220023) 1713 + #define STATUS_FWP_INVALID_ACTION_TYPE cpu_to_le32(0xC0220024) 1714 + #define STATUS_FWP_INVALID_WEIGHT cpu_to_le32(0xC0220025) 1715 + #define STATUS_FWP_MATCH_TYPE_MISMATCH cpu_to_le32(0xC0220026) 1716 + #define STATUS_FWP_TYPE_MISMATCH cpu_to_le32(0xC0220027) 1717 + #define STATUS_FWP_OUT_OF_BOUNDS cpu_to_le32(0xC0220028) 1718 + #define STATUS_FWP_RESERVED cpu_to_le32(0xC0220029) 1719 + #define STATUS_FWP_DUPLICATE_CONDITION cpu_to_le32(0xC022002A) 1720 + #define STATUS_FWP_DUPLICATE_KEYMOD cpu_to_le32(0xC022002B) 1721 + #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002C) 1722 + #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER cpu_to_le32(0xC022002D) 1723 + #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002E) 1724 + #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT cpu_to_le32(0xC022002F) 1725 + #define STATUS_FWP_INCOMPATIBLE_AUTH_METHOD cpu_to_le32(0xC0220030) 1726 + #define STATUS_FWP_INCOMPATIBLE_DH_GROUP cpu_to_le32(0xC0220031) 1727 + #define STATUS_FWP_EM_NOT_SUPPORTED cpu_to_le32(0xC0220032) 1728 + #define STATUS_FWP_NEVER_MATCH cpu_to_le32(0xC0220033) 1729 + #define STATUS_FWP_PROVIDER_CONTEXT_MISMATCH cpu_to_le32(0xC0220034) 1730 + #define STATUS_FWP_INVALID_PARAMETER cpu_to_le32(0xC0220035) 1731 + #define STATUS_FWP_TOO_MANY_SUBLAYERS cpu_to_le32(0xC0220036) 1732 + #define STATUS_FWP_CALLOUT_NOTIFICATION_FAILED cpu_to_le32(0xC0220037) 1733 + #define STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG cpu_to_le32(0xC0220038) 1734 + #define STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG cpu_to_le32(0xC0220039) 1735 + #define STATUS_FWP_TCPIP_NOT_READY cpu_to_le32(0xC0220100) 1736 + #define STATUS_FWP_INJECT_HANDLE_CLOSING cpu_to_le32(0xC0220101) 1737 + #define STATUS_FWP_INJECT_HANDLE_STALE cpu_to_le32(0xC0220102) 1738 + #define STATUS_FWP_CANNOT_PEND cpu_to_le32(0xC0220103) 1739 + #define STATUS_NDIS_CLOSING cpu_to_le32(0xC0230002) 1740 + #define STATUS_NDIS_BAD_VERSION cpu_to_le32(0xC0230004) 1741 + #define STATUS_NDIS_BAD_CHARACTERISTICS cpu_to_le32(0xC0230005) 1742 + #define STATUS_NDIS_ADAPTER_NOT_FOUND cpu_to_le32(0xC0230006) 1743 + #define STATUS_NDIS_OPEN_FAILED cpu_to_le32(0xC0230007) 1744 + #define STATUS_NDIS_DEVICE_FAILED cpu_to_le32(0xC0230008) 1745 + #define STATUS_NDIS_MULTICAST_FULL cpu_to_le32(0xC0230009) 1746 + #define STATUS_NDIS_MULTICAST_EXISTS cpu_to_le32(0xC023000A) 1747 + #define STATUS_NDIS_MULTICAST_NOT_FOUND cpu_to_le32(0xC023000B) 1748 + #define STATUS_NDIS_REQUEST_ABORTED cpu_to_le32(0xC023000C) 1749 + #define STATUS_NDIS_RESET_IN_PROGRESS cpu_to_le32(0xC023000D) 1750 + #define STATUS_NDIS_INVALID_PACKET cpu_to_le32(0xC023000F) 1751 + #define STATUS_NDIS_INVALID_DEVICE_REQUEST cpu_to_le32(0xC0230010) 1752 + #define STATUS_NDIS_ADAPTER_NOT_READY cpu_to_le32(0xC0230011) 1753 + #define STATUS_NDIS_INVALID_LENGTH cpu_to_le32(0xC0230014) 1754 + #define STATUS_NDIS_INVALID_DATA cpu_to_le32(0xC0230015) 1755 + #define STATUS_NDIS_BUFFER_TOO_SHORT cpu_to_le32(0xC0230016) 1756 + #define STATUS_NDIS_INVALID_OID cpu_to_le32(0xC0230017) 1757 + #define STATUS_NDIS_ADAPTER_REMOVED cpu_to_le32(0xC0230018) 1758 + #define STATUS_NDIS_UNSUPPORTED_MEDIA cpu_to_le32(0xC0230019) 1759 + #define STATUS_NDIS_GROUP_ADDRESS_IN_USE cpu_to_le32(0xC023001A) 1760 + #define STATUS_NDIS_FILE_NOT_FOUND cpu_to_le32(0xC023001B) 1761 + #define STATUS_NDIS_ERROR_READING_FILE cpu_to_le32(0xC023001C) 1762 + #define STATUS_NDIS_ALREADY_MAPPED cpu_to_le32(0xC023001D) 1763 + #define STATUS_NDIS_RESOURCE_CONFLICT cpu_to_le32(0xC023001E) 1764 + #define STATUS_NDIS_MEDIA_DISCONNECTED cpu_to_le32(0xC023001F) 1765 + #define STATUS_NDIS_INVALID_ADDRESS cpu_to_le32(0xC0230022) 1766 + #define STATUS_NDIS_PAUSED cpu_to_le32(0xC023002A) 1767 + #define STATUS_NDIS_INTERFACE_NOT_FOUND cpu_to_le32(0xC023002B) 1768 + #define STATUS_NDIS_UNSUPPORTED_REVISION cpu_to_le32(0xC023002C) 1769 + #define STATUS_NDIS_INVALID_PORT cpu_to_le32(0xC023002D) 1770 + #define STATUS_NDIS_INVALID_PORT_STATE cpu_to_le32(0xC023002E) 1771 + #define STATUS_NDIS_LOW_POWER_STATE cpu_to_le32(0xC023002F) 1772 + #define STATUS_NDIS_NOT_SUPPORTED cpu_to_le32(0xC02300BB) 1773 + #define STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED cpu_to_le32(0xC0232000) 1774 + #define STATUS_NDIS_DOT11_MEDIA_IN_USE cpu_to_le32(0xC0232001) 1775 + #define STATUS_NDIS_DOT11_POWER_STATE_INVALID cpu_to_le32(0xC0232002) 1776 + #define STATUS_IPSEC_BAD_SPI cpu_to_le32(0xC0360001) 1777 + #define STATUS_IPSEC_SA_LIFETIME_EXPIRED cpu_to_le32(0xC0360002) 1778 + #define STATUS_IPSEC_WRONG_SA cpu_to_le32(0xC0360003) 1779 + #define STATUS_IPSEC_REPLAY_CHECK_FAILED cpu_to_le32(0xC0360004) 1780 + #define STATUS_IPSEC_INVALID_PACKET cpu_to_le32(0xC0360005) 1781 + #define STATUS_IPSEC_INTEGRITY_CHECK_FAILED cpu_to_le32(0xC0360006) 1782 + #define STATUS_IPSEC_CLEAR_TEXT_DROP cpu_to_le32(0xC0360007)
+131 -161
fs/cifs/smbdirect.c
··· 164 164 #define log_rdma_mr(level, fmt, args...) \ 165 165 log_rdma(level, LOG_RDMA_MR, fmt, ##args) 166 166 167 - /* 168 - * Destroy the transport and related RDMA and memory resources 169 - * Need to go through all the pending counters and make sure on one is using 170 - * the transport while it is destroyed 171 - */ 172 - static void smbd_destroy_rdma_work(struct work_struct *work) 173 - { 174 - struct smbd_response *response; 175 - struct smbd_connection *info = 176 - container_of(work, struct smbd_connection, destroy_work); 177 - unsigned long flags; 178 - 179 - log_rdma_event(INFO, "destroying qp\n"); 180 - ib_drain_qp(info->id->qp); 181 - rdma_destroy_qp(info->id); 182 - 183 - /* Unblock all I/O waiting on the send queue */ 184 - wake_up_interruptible_all(&info->wait_send_queue); 185 - 186 - log_rdma_event(INFO, "cancelling idle timer\n"); 187 - cancel_delayed_work_sync(&info->idle_timer_work); 188 - log_rdma_event(INFO, "cancelling send immediate work\n"); 189 - cancel_delayed_work_sync(&info->send_immediate_work); 190 - 191 - log_rdma_event(INFO, "wait for all send to finish\n"); 192 - wait_event(info->wait_smbd_send_pending, 193 - info->smbd_send_pending == 0); 194 - 195 - log_rdma_event(INFO, "wait for all recv to finish\n"); 196 - wake_up_interruptible(&info->wait_reassembly_queue); 197 - wait_event(info->wait_smbd_recv_pending, 198 - info->smbd_recv_pending == 0); 199 - 200 - log_rdma_event(INFO, "wait for all send posted to IB to finish\n"); 201 - wait_event(info->wait_send_pending, 202 - atomic_read(&info->send_pending) == 0); 203 - wait_event(info->wait_send_payload_pending, 204 - atomic_read(&info->send_payload_pending) == 0); 205 - 206 - log_rdma_event(INFO, "freeing mr list\n"); 207 - wake_up_interruptible_all(&info->wait_mr); 208 - wait_event(info->wait_for_mr_cleanup, 209 - atomic_read(&info->mr_used_count) == 0); 210 - destroy_mr_list(info); 211 - 212 - /* It's not posssible for upper layer to get to reassembly */ 213 - log_rdma_event(INFO, "drain the reassembly queue\n"); 214 - do { 215 - spin_lock_irqsave(&info->reassembly_queue_lock, flags); 216 - response = _get_first_reassembly(info); 217 - if (response) { 218 - list_del(&response->list); 219 - spin_unlock_irqrestore( 220 - &info->reassembly_queue_lock, flags); 221 - put_receive_buffer(info, response); 222 - } else 223 - spin_unlock_irqrestore(&info->reassembly_queue_lock, flags); 224 - } while (response); 225 - 226 - info->reassembly_data_length = 0; 227 - 228 - log_rdma_event(INFO, "free receive buffers\n"); 229 - wait_event(info->wait_receive_queues, 230 - info->count_receive_queue + info->count_empty_packet_queue 231 - == info->receive_credit_max); 232 - destroy_receive_buffers(info); 233 - 234 - ib_free_cq(info->send_cq); 235 - ib_free_cq(info->recv_cq); 236 - ib_dealloc_pd(info->pd); 237 - rdma_destroy_id(info->id); 238 - 239 - /* free mempools */ 240 - mempool_destroy(info->request_mempool); 241 - kmem_cache_destroy(info->request_cache); 242 - 243 - mempool_destroy(info->response_mempool); 244 - kmem_cache_destroy(info->response_cache); 245 - 246 - info->transport_status = SMBD_DESTROYED; 247 - wake_up_all(&info->wait_destroy); 248 - } 249 - 250 - static int smbd_process_disconnected(struct smbd_connection *info) 251 - { 252 - schedule_work(&info->destroy_work); 253 - return 0; 254 - } 255 - 256 167 static void smbd_disconnect_rdma_work(struct work_struct *work) 257 168 { 258 169 struct smbd_connection *info = ··· 230 319 } 231 320 232 321 info->transport_status = SMBD_DISCONNECTED; 233 - smbd_process_disconnected(info); 322 + wake_up_interruptible(&info->disconn_wait); 323 + wake_up_interruptible(&info->wait_reassembly_queue); 324 + wake_up_interruptible_all(&info->wait_send_queue); 234 325 break; 235 326 236 327 default: ··· 853 940 854 941 if (info->transport_status != SMBD_CONNECTED) { 855 942 log_outgoing(ERR, "disconnected not sending\n"); 856 - return -ENOENT; 943 + return -EAGAIN; 857 944 } 858 945 atomic_dec(&info->send_credits); 859 946 ··· 979 1066 wake_up(&info->wait_send_pending); 980 1067 } 981 1068 smbd_disconnect_rdma_connection(info); 1069 + rc = -EAGAIN; 982 1070 } else 983 1071 /* Reset timer for idle connection after packet is sent */ 984 1072 mod_delayed_work(info->workqueue, &info->idle_timer_work, ··· 1392 1478 info->keep_alive_interval*HZ); 1393 1479 } 1394 1480 1395 - /* Destroy this SMBD connection, called from upper layer */ 1396 - void smbd_destroy(struct smbd_connection *info) 1481 + /* 1482 + * Destroy the transport and related RDMA and memory resources 1483 + * Need to go through all the pending counters and make sure on one is using 1484 + * the transport while it is destroyed 1485 + */ 1486 + void smbd_destroy(struct TCP_Server_Info *server) 1397 1487 { 1488 + struct smbd_connection *info = server->smbd_conn; 1489 + struct smbd_response *response; 1490 + unsigned long flags; 1491 + 1492 + if (!info) { 1493 + log_rdma_event(INFO, "rdma session already destroyed\n"); 1494 + return; 1495 + } 1496 + 1398 1497 log_rdma_event(INFO, "destroying rdma session\n"); 1498 + if (info->transport_status != SMBD_DISCONNECTED) { 1499 + rdma_disconnect(server->smbd_conn->id); 1500 + log_rdma_event(INFO, "wait for transport being disconnected\n"); 1501 + wait_event_interruptible( 1502 + info->disconn_wait, 1503 + info->transport_status == SMBD_DISCONNECTED); 1504 + } 1399 1505 1400 - /* Kick off the disconnection process */ 1401 - smbd_disconnect_rdma_connection(info); 1506 + log_rdma_event(INFO, "destroying qp\n"); 1507 + ib_drain_qp(info->id->qp); 1508 + rdma_destroy_qp(info->id); 1402 1509 1403 - log_rdma_event(INFO, "wait for transport being destroyed\n"); 1404 - wait_event(info->wait_destroy, 1405 - info->transport_status == SMBD_DESTROYED); 1510 + log_rdma_event(INFO, "cancelling idle timer\n"); 1511 + cancel_delayed_work_sync(&info->idle_timer_work); 1512 + log_rdma_event(INFO, "cancelling send immediate work\n"); 1513 + cancel_delayed_work_sync(&info->send_immediate_work); 1514 + 1515 + log_rdma_event(INFO, "wait for all send posted to IB to finish\n"); 1516 + wait_event(info->wait_send_pending, 1517 + atomic_read(&info->send_pending) == 0); 1518 + wait_event(info->wait_send_payload_pending, 1519 + atomic_read(&info->send_payload_pending) == 0); 1520 + 1521 + /* It's not posssible for upper layer to get to reassembly */ 1522 + log_rdma_event(INFO, "drain the reassembly queue\n"); 1523 + do { 1524 + spin_lock_irqsave(&info->reassembly_queue_lock, flags); 1525 + response = _get_first_reassembly(info); 1526 + if (response) { 1527 + list_del(&response->list); 1528 + spin_unlock_irqrestore( 1529 + &info->reassembly_queue_lock, flags); 1530 + put_receive_buffer(info, response); 1531 + } else 1532 + spin_unlock_irqrestore( 1533 + &info->reassembly_queue_lock, flags); 1534 + } while (response); 1535 + info->reassembly_data_length = 0; 1536 + 1537 + log_rdma_event(INFO, "free receive buffers\n"); 1538 + wait_event(info->wait_receive_queues, 1539 + info->count_receive_queue + info->count_empty_packet_queue 1540 + == info->receive_credit_max); 1541 + destroy_receive_buffers(info); 1542 + 1543 + /* 1544 + * For performance reasons, memory registration and deregistration 1545 + * are not locked by srv_mutex. It is possible some processes are 1546 + * blocked on transport srv_mutex while holding memory registration. 1547 + * Release the transport srv_mutex to allow them to hit the failure 1548 + * path when sending data, and then release memory registartions. 1549 + */ 1550 + log_rdma_event(INFO, "freeing mr list\n"); 1551 + wake_up_interruptible_all(&info->wait_mr); 1552 + while (atomic_read(&info->mr_used_count)) { 1553 + mutex_unlock(&server->srv_mutex); 1554 + msleep(1000); 1555 + mutex_lock(&server->srv_mutex); 1556 + } 1557 + destroy_mr_list(info); 1558 + 1559 + ib_free_cq(info->send_cq); 1560 + ib_free_cq(info->recv_cq); 1561 + ib_dealloc_pd(info->pd); 1562 + rdma_destroy_id(info->id); 1563 + 1564 + /* free mempools */ 1565 + mempool_destroy(info->request_mempool); 1566 + kmem_cache_destroy(info->request_cache); 1567 + 1568 + mempool_destroy(info->response_mempool); 1569 + kmem_cache_destroy(info->response_cache); 1570 + 1571 + info->transport_status = SMBD_DESTROYED; 1406 1572 1407 1573 destroy_workqueue(info->workqueue); 1408 1574 kfree(info); ··· 1507 1513 */ 1508 1514 if (server->smbd_conn->transport_status == SMBD_CONNECTED) { 1509 1515 log_rdma_event(INFO, "disconnecting transport\n"); 1510 - smbd_disconnect_rdma_connection(server->smbd_conn); 1516 + smbd_destroy(server); 1511 1517 } 1512 - 1513 - /* wait until the transport is destroyed */ 1514 - if (!wait_event_timeout(server->smbd_conn->wait_destroy, 1515 - server->smbd_conn->transport_status == SMBD_DESTROYED, 5*HZ)) 1516 - return -EAGAIN; 1517 - 1518 - destroy_workqueue(server->smbd_conn->workqueue); 1519 - kfree(server->smbd_conn); 1520 1518 1521 1519 create_conn: 1522 1520 log_rdma_event(INFO, "creating rdma session\n"); ··· 1725 1739 conn_param.retry_count = SMBD_CM_RETRY; 1726 1740 conn_param.rnr_retry_count = SMBD_CM_RNR_RETRY; 1727 1741 conn_param.flow_control = 0; 1728 - init_waitqueue_head(&info->wait_destroy); 1729 1742 1730 1743 log_rdma_event(INFO, "connecting to IP %pI4 port %d\n", 1731 1744 &addr_in->sin_addr, port); 1732 1745 1733 1746 init_waitqueue_head(&info->conn_wait); 1747 + init_waitqueue_head(&info->disconn_wait); 1748 + init_waitqueue_head(&info->wait_reassembly_queue); 1734 1749 rc = rdma_connect(info->id, &conn_param); 1735 1750 if (rc) { 1736 1751 log_rdma_event(ERR, "rdma_connect() failed with %i\n", rc); ··· 1755 1768 } 1756 1769 1757 1770 init_waitqueue_head(&info->wait_send_queue); 1758 - init_waitqueue_head(&info->wait_reassembly_queue); 1759 - 1760 1771 INIT_DELAYED_WORK(&info->idle_timer_work, idle_connection_timer); 1761 1772 INIT_DELAYED_WORK(&info->send_immediate_work, send_immediate_work); 1762 1773 queue_delayed_work(info->workqueue, &info->idle_timer_work, 1763 1774 info->keep_alive_interval*HZ); 1764 - 1765 - init_waitqueue_head(&info->wait_smbd_send_pending); 1766 - info->smbd_send_pending = 0; 1767 - 1768 - init_waitqueue_head(&info->wait_smbd_recv_pending); 1769 - info->smbd_recv_pending = 0; 1770 1775 1771 1776 init_waitqueue_head(&info->wait_send_pending); 1772 1777 atomic_set(&info->send_pending, 0); ··· 1767 1788 atomic_set(&info->send_payload_pending, 0); 1768 1789 1769 1790 INIT_WORK(&info->disconnect_work, smbd_disconnect_rdma_work); 1770 - INIT_WORK(&info->destroy_work, smbd_destroy_rdma_work); 1771 1791 INIT_WORK(&info->recv_done_work, smbd_recv_done_work); 1772 1792 INIT_WORK(&info->post_send_credits_work, smbd_post_send_credits); 1773 1793 info->new_credits_offered = 0; ··· 1788 1810 1789 1811 allocate_mr_failed: 1790 1812 /* At this point, need to a full transport shutdown */ 1791 - smbd_destroy(info); 1813 + smbd_destroy(server); 1792 1814 return NULL; 1793 1815 1794 1816 negotiation_failed: ··· 1860 1882 int rc; 1861 1883 1862 1884 again: 1863 - if (info->transport_status != SMBD_CONNECTED) { 1864 - log_read(ERR, "disconnected\n"); 1865 - return -ENODEV; 1866 - } 1867 - 1868 1885 /* 1869 1886 * No need to hold the reassembly queue lock all the time as we are 1870 1887 * the only one reading from the front of the queue. The transport ··· 1973 2000 info->transport_status != SMBD_CONNECTED); 1974 2001 /* Don't return any data if interrupted */ 1975 2002 if (rc) 1976 - return -ENODEV; 2003 + return rc; 2004 + 2005 + if (info->transport_status != SMBD_CONNECTED) { 2006 + log_read(ERR, "disconnected\n"); 2007 + return 0; 2008 + } 1977 2009 1978 2010 goto again; 1979 2011 } ··· 2030 2052 unsigned int to_read, page_offset; 2031 2053 int rc; 2032 2054 2033 - info->smbd_recv_pending++; 2034 - 2035 2055 if (iov_iter_rw(&msg->msg_iter) == WRITE) { 2036 2056 /* It's a bug in upper layer to get there */ 2037 2057 cifs_dbg(VFS, "CIFS: invalid msg iter dir %u\n", ··· 2060 2084 } 2061 2085 2062 2086 out: 2063 - info->smbd_recv_pending--; 2064 - wake_up(&info->wait_smbd_recv_pending); 2065 - 2066 2087 /* SMBDirect will read it all or nothing */ 2067 2088 if (rc > 0) 2068 2089 msg->msg_iter.count = 0; ··· 2072 2099 * rqst: the data to write 2073 2100 * return value: 0 if successfully write, otherwise error code 2074 2101 */ 2075 - int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst) 2102 + int smbd_send(struct TCP_Server_Info *server, 2103 + int num_rqst, struct smb_rqst *rqst_array) 2076 2104 { 2077 2105 struct smbd_connection *info = server->smbd_conn; 2078 2106 struct kvec vec; ··· 2085 2111 info->max_send_size - sizeof(struct smbd_data_transfer); 2086 2112 struct kvec *iov; 2087 2113 int rc; 2114 + struct smb_rqst *rqst; 2115 + int rqst_idx; 2088 2116 2089 - info->smbd_send_pending++; 2090 2117 if (info->transport_status != SMBD_CONNECTED) { 2091 - rc = -ENODEV; 2118 + rc = -EAGAIN; 2092 2119 goto done; 2093 - } 2094 - 2095 - /* 2096 - * Skip the RFC1002 length defined in MS-SMB2 section 2.1 2097 - * It is used only for TCP transport in the iov[0] 2098 - * In future we may want to add a transport layer under protocol 2099 - * layer so this will only be issued to TCP transport 2100 - */ 2101 - 2102 - if (rqst->rq_iov[0].iov_len != 4) { 2103 - log_write(ERR, "expected the pdu length in 1st iov, but got %zu\n", rqst->rq_iov[0].iov_len); 2104 - return -EINVAL; 2105 2120 } 2106 2121 2107 2122 /* ··· 2098 2135 * rq_tailsz to PAGE_SIZE when the buffer has multiple pages and 2099 2136 * ends at page boundary 2100 2137 */ 2101 - buflen = smb_rqst_len(server, rqst); 2138 + remaining_data_length = 0; 2139 + for (i = 0; i < num_rqst; i++) 2140 + remaining_data_length += smb_rqst_len(server, &rqst_array[i]); 2102 2141 2103 - if (buflen + sizeof(struct smbd_data_transfer) > 2142 + if (remaining_data_length + sizeof(struct smbd_data_transfer) > 2104 2143 info->max_fragmented_send_size) { 2105 2144 log_write(ERR, "payload size %d > max size %d\n", 2106 - buflen, info->max_fragmented_send_size); 2145 + remaining_data_length, info->max_fragmented_send_size); 2107 2146 rc = -EINVAL; 2108 2147 goto done; 2109 2148 } 2110 2149 2111 - iov = &rqst->rq_iov[1]; 2150 + rqst_idx = 0; 2112 2151 2113 - cifs_dbg(FYI, "Sending smb (RDMA): smb_len=%u\n", buflen); 2114 - for (i = 0; i < rqst->rq_nvec-1; i++) 2152 + next_rqst: 2153 + rqst = &rqst_array[rqst_idx]; 2154 + iov = rqst->rq_iov; 2155 + 2156 + cifs_dbg(FYI, "Sending smb (RDMA): idx=%d smb_len=%lu\n", 2157 + rqst_idx, smb_rqst_len(server, rqst)); 2158 + for (i = 0; i < rqst->rq_nvec; i++) 2115 2159 dump_smb(iov[i].iov_base, iov[i].iov_len); 2116 2160 2117 - remaining_data_length = buflen; 2118 2161 2119 - log_write(INFO, "rqst->rq_nvec=%d rqst->rq_npages=%d rq_pagesz=%d " 2120 - "rq_tailsz=%d buflen=%d\n", 2121 - rqst->rq_nvec, rqst->rq_npages, rqst->rq_pagesz, 2122 - rqst->rq_tailsz, buflen); 2162 + log_write(INFO, "rqst_idx=%d nvec=%d rqst->rq_npages=%d rq_pagesz=%d " 2163 + "rq_tailsz=%d buflen=%lu\n", 2164 + rqst_idx, rqst->rq_nvec, rqst->rq_npages, rqst->rq_pagesz, 2165 + rqst->rq_tailsz, smb_rqst_len(server, rqst)); 2123 2166 2124 - start = i = iov[0].iov_len ? 0 : 1; 2167 + start = i = 0; 2125 2168 buflen = 0; 2126 2169 while (true) { 2127 2170 buflen += iov[i].iov_len; ··· 2175 2206 goto done; 2176 2207 } 2177 2208 i++; 2178 - if (i == rqst->rq_nvec-1) 2209 + if (i == rqst->rq_nvec) 2179 2210 break; 2180 2211 } 2181 2212 start = i; 2182 2213 buflen = 0; 2183 2214 } else { 2184 2215 i++; 2185 - if (i == rqst->rq_nvec-1) { 2216 + if (i == rqst->rq_nvec) { 2186 2217 /* send out all remaining vecs */ 2187 2218 remaining_data_length -= buflen; 2188 2219 log_write(INFO, ··· 2226 2257 } 2227 2258 } 2228 2259 2260 + rqst_idx++; 2261 + if (rqst_idx < num_rqst) 2262 + goto next_rqst; 2263 + 2229 2264 done: 2230 2265 /* 2231 2266 * As an optimization, we don't wait for individual I/O to finish ··· 2240 2267 2241 2268 wait_event(info->wait_send_payload_pending, 2242 2269 atomic_read(&info->send_payload_pending) == 0); 2243 - 2244 - info->smbd_send_pending--; 2245 - wake_up(&info->wait_smbd_send_pending); 2246 2270 2247 2271 return rc; 2248 2272 }
+6 -13
fs/cifs/smbdirect.h
··· 70 70 int ri_rc; 71 71 struct completion ri_done; 72 72 wait_queue_head_t conn_wait; 73 - wait_queue_head_t wait_destroy; 73 + wait_queue_head_t disconn_wait; 74 74 75 75 struct completion negotiate_completion; 76 76 bool negotiate_done; 77 77 78 - struct work_struct destroy_work; 79 78 struct work_struct disconnect_work; 80 79 struct work_struct recv_done_work; 81 80 struct work_struct post_send_credits_work; ··· 122 123 wait_queue_head_t wait_for_mr_cleanup; 123 124 124 125 /* Activity accoutning */ 125 - /* Pending reqeusts issued from upper layer */ 126 - int smbd_send_pending; 127 - wait_queue_head_t wait_smbd_send_pending; 128 - 129 - int smbd_recv_pending; 130 - wait_queue_head_t wait_smbd_recv_pending; 131 - 132 126 atomic_t send_pending; 133 127 wait_queue_head_t wait_send_pending; 134 128 atomic_t send_payload_pending; ··· 280 288 /* Reconnect SMBDirect session */ 281 289 int smbd_reconnect(struct TCP_Server_Info *server); 282 290 /* Destroy SMBDirect session */ 283 - void smbd_destroy(struct smbd_connection *info); 291 + void smbd_destroy(struct TCP_Server_Info *server); 284 292 285 293 /* Interface for carrying upper layer I/O through send/recv */ 286 294 int smbd_recv(struct smbd_connection *info, struct msghdr *msg); 287 - int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst); 295 + int smbd_send(struct TCP_Server_Info *server, 296 + int num_rqst, struct smb_rqst *rqst); 288 297 289 298 enum mr_state { 290 299 MR_READY, ··· 323 330 static inline void *smbd_get_connection( 324 331 struct TCP_Server_Info *server, struct sockaddr *dstaddr) {return NULL;} 325 332 static inline int smbd_reconnect(struct TCP_Server_Info *server) {return -1; } 326 - static inline void smbd_destroy(struct smbd_connection *info) {} 333 + static inline void smbd_destroy(struct TCP_Server_Info *server) {} 327 334 static inline int smbd_recv(struct smbd_connection *info, struct msghdr *msg) {return -1; } 328 - static inline int smbd_send(struct TCP_Server_Info *server, struct smb_rqst *rqst) {return -1; } 335 + static inline int smbd_send(struct TCP_Server_Info *server, int num_rqst, struct smb_rqst *rqst) {return -1; } 329 336 #endif 330 337 331 338 #endif
+28 -1
fs/cifs/smbfsctl.h
··· 35 35 * below). Additional detail on less common ones can be found in MS-FSCC 36 36 * section 2.3. 37 37 */ 38 + 39 + /* 40 + * FSCTL values are 32 bits and are constructed as 41 + * <device 16bits> <access 2bits> <function 12bits> <method 2bits> 42 + */ 43 + /* Device */ 44 + #define FSCTL_DEVICE_DFS (0x0006 << 16) 45 + #define FSCTL_DEVICE_FILE_SYSTEM (0x0009 << 16) 46 + #define FSCTL_DEVICE_NAMED_PIPE (0x0011 << 16) 47 + #define FSCTL_DEVICE_NETWORK_FILE_SYSTEM (0x0014 << 16) 48 + #define FSCTL_DEVICE_MASK 0xffff0000 49 + /* Access */ 50 + #define FSCTL_DEVICE_ACCESS_FILE_ANY_ACCESS (0x00 << 14) 51 + #define FSCTL_DEVICE_ACCESS_FILE_READ_ACCESS (0x01 << 14) 52 + #define FSCTL_DEVICE_ACCESS_FILE_WRITE_ACCESS (0x02 << 14) 53 + #define FSCTL_DEVICE_ACCESS_FILE_READ_WRITE_ACCESS (0x03 << 14) 54 + #define FSCTL_DEVICE_ACCESS_MASK 0x0000c000 55 + /* Function */ 56 + #define FSCTL_DEVICE_FUNCTION_MASK 0x00003ffc 57 + /* Method */ 58 + #define FSCTL_DEVICE_METHOD_BUFFERED 0x00 59 + #define FSCTL_DEVICE_METHOD_IN_DIRECT 0x01 60 + #define FSCTL_DEVICE_METHOD_OUT_DIRECT 0x02 61 + #define FSCTL_DEVICE_METHOD_NEITHER 0x03 62 + #define FSCTL_DEVICE_METHOD_MASK 0x00000003 63 + 64 + 38 65 #define FSCTL_DFS_GET_REFERRALS 0x00060194 39 66 #define FSCTL_DFS_GET_REFERRALS_EX 0x000601B0 40 67 #define FSCTL_REQUEST_OPLOCK_LEVEL_1 0x00090000 ··· 103 76 #define FSCTL_SET_ZERO_ON_DEALLOC 0x00090194 /* BB add struct */ 104 77 #define FSCTL_SET_SHORT_NAME_BEHAVIOR 0x000901B4 /* BB add struct */ 105 78 #define FSCTL_GET_INTEGRITY_INFORMATION 0x0009027C 106 - #define FSCTL_QUERY_ALLOCATED_RANGES 0x000940CF /* BB add struct */ 79 + #define FSCTL_QUERY_ALLOCATED_RANGES 0x000940CF 107 80 #define FSCTL_SET_DEFECT_MANAGEMENT 0x00098134 /* BB add struct */ 108 81 #define FSCTL_FILE_LEVEL_TRIM 0x00098208 /* BB add struct */ 109 82 #define FSCTL_DUPLICATE_EXTENTS_TO_FILE 0x00098344
+32 -16
fs/cifs/transport.c
··· 104 104 { 105 105 #ifdef CONFIG_CIFS_STATS2 106 106 __le16 command = midEntry->server->vals->lock_cmd; 107 + __u16 smb_cmd = le16_to_cpu(midEntry->command); 107 108 unsigned long now; 109 + unsigned long roundtrip_time; 110 + struct TCP_Server_Info *server = midEntry->server; 108 111 #endif 109 112 midEntry->mid_state = MID_FREE; 110 113 atomic_dec(&midCount); ··· 117 114 cifs_small_buf_release(midEntry->resp_buf); 118 115 #ifdef CONFIG_CIFS_STATS2 119 116 now = jiffies; 117 + if (now < midEntry->when_alloc) 118 + cifs_dbg(VFS, "invalid mid allocation time\n"); 119 + roundtrip_time = now - midEntry->when_alloc; 120 + 121 + if (smb_cmd < NUMBER_OF_SMB2_COMMANDS) { 122 + if (atomic_read(&server->num_cmds[smb_cmd]) == 0) { 123 + server->slowest_cmd[smb_cmd] = roundtrip_time; 124 + server->fastest_cmd[smb_cmd] = roundtrip_time; 125 + } else { 126 + if (server->slowest_cmd[smb_cmd] < roundtrip_time) 127 + server->slowest_cmd[smb_cmd] = roundtrip_time; 128 + else if (server->fastest_cmd[smb_cmd] > roundtrip_time) 129 + server->fastest_cmd[smb_cmd] = roundtrip_time; 130 + } 131 + cifs_stats_inc(&server->num_cmds[smb_cmd]); 132 + server->time_per_cmd[smb_cmd] += roundtrip_time; 133 + } 120 134 /* 121 135 * commands taking longer than one second (default) can be indications 122 136 * that something is wrong, unless it is quite a slow link or a very ··· 151 131 * smb2slowcmd[NUMBER_OF_SMB2_COMMANDS] counts by command 152 132 * NB: le16_to_cpu returns unsigned so can not be negative below 153 133 */ 154 - if (le16_to_cpu(midEntry->command) < NUMBER_OF_SMB2_COMMANDS) 155 - cifs_stats_inc(&midEntry->server->smb2slowcmd[le16_to_cpu(midEntry->command)]); 134 + if (smb_cmd < NUMBER_OF_SMB2_COMMANDS) 135 + cifs_stats_inc(&server->smb2slowcmd[smb_cmd]); 156 136 157 - trace_smb3_slow_rsp(le16_to_cpu(midEntry->command), 158 - midEntry->mid, midEntry->pid, 137 + trace_smb3_slow_rsp(smb_cmd, midEntry->mid, midEntry->pid, 159 138 midEntry->when_sent, midEntry->when_received); 160 139 if (cifsFYI & CIFS_TIMER) { 161 140 pr_debug(" CIFS slow rsp: cmd %d mid %llu", ··· 319 300 __be32 rfc1002_marker; 320 301 321 302 if (cifs_rdma_enabled(server) && server->smbd_conn) { 322 - rc = smbd_send(server, rqst); 303 + rc = smbd_send(server, num_rqst, rqst); 323 304 goto smbd_done; 324 305 } 325 306 ··· 529 510 return -EAGAIN; 530 511 531 512 spin_lock(&server->req_lock); 532 - if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP) { 513 + if ((flags & CIFS_TIMEOUT_MASK) == CIFS_NON_BLOCKING) { 533 514 /* oplock breaks must not be held up */ 534 515 server->in_flight++; 535 516 *credits -= 1; ··· 838 819 839 820 iov[0].iov_base = in_buf; 840 821 iov[0].iov_len = get_rfc1002_length(in_buf) + 4; 841 - flags |= CIFS_NO_RESP; 822 + flags |= CIFS_NO_RSP_BUF; 842 823 rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags, &rsp_iov); 843 824 cifs_dbg(NOISY, "SendRcvNoRsp flags %d rc %d\n", flags, rc); 844 825 ··· 1073 1054 1074 1055 mutex_unlock(&ses->server->srv_mutex); 1075 1056 1076 - if (rc < 0) { 1077 - /* Sending failed for some reason - return credits back */ 1057 + /* 1058 + * If sending failed for some reason or it is an oplock break that we 1059 + * will not receive a response to - return credits back 1060 + */ 1061 + if (rc < 0 || (flags & CIFS_NO_SRV_RSP)) { 1078 1062 for (i = 0; i < num_rqst; i++) 1079 1063 add_credits(ses->server, &credits[i], optype); 1080 1064 goto out; ··· 1097 1075 if ((ses->status == CifsNew) || (optype & CIFS_NEG_OP)) 1098 1076 smb311_update_preauth_hash(ses, rqst[0].rq_iov, 1099 1077 rqst[0].rq_nvec); 1100 - 1101 - if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP) 1102 - goto out; 1103 1078 1104 1079 for (i = 0; i < num_rqst; i++) { 1105 1080 rc = wait_for_response(ses->server, midQ[i]); ··· 1151 1132 flags & CIFS_LOG_ERROR); 1152 1133 1153 1134 /* mark it so buf will not be freed by cifs_delete_mid */ 1154 - if ((flags & CIFS_NO_RESP) == 0) 1135 + if ((flags & CIFS_NO_RSP_BUF) == 0) 1155 1136 midQ[i]->resp_buf = NULL; 1156 1137 1157 1138 } ··· 1300 1281 mutex_unlock(&ses->server->srv_mutex); 1301 1282 1302 1283 if (rc < 0) 1303 - goto out; 1304 - 1305 - if ((flags & CIFS_TIMEOUT_MASK) == CIFS_ASYNC_OP) 1306 1284 goto out; 1307 1285 1308 1286 rc = wait_for_response(ses->server, midQ);