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