+14

fs/smb/client/Kconfig

reviewed

··· 204 204 205 205 Most people say N here. 206 206 207 207 + config CIFS_COMPRESSION 208 208 + bool "SMB message compression (Experimental)" 209 209 + depends on CIFS 210 210 + default n 211 211 + help 212 212 + Enables over-the-wire message compression for SMB 3.1.1 213 213 + mounts when negotiated with the server. 214 214 + 215 215 + Only write requests with data size >= PAGE_SIZE will be 216 216 + compressed to avoid wasting resources. 217 217 + 218 218 + Say Y here if you want SMB traffic to be compressed. 219 219 + If unsure, say N. 220 220 + 207 221 endif

+2

fs/smb/client/Makefile

reviewed

··· 33 33 cifs-$(CONFIG_CIFS_ROOT) += cifsroot.o 34 34 35 35 cifs-$(CONFIG_CIFS_ALLOW_INSECURE_LEGACY) += smb1ops.o cifssmb.o 36 36 + 37 37 + cifs-$(CONFIG_CIFS_COMPRESSION) += compress.o compress/lz77.o

+6 -1

fs/smb/client/cifs_debug.c

reviewed

··· 350 350 #ifdef CONFIG_CIFS_SWN_UPCALL 351 351 seq_puts(m, ",WITNESS"); 352 352 #endif 353 353 + #ifdef CONFIG_CIFS_COMPRESSION 354 354 + seq_puts(m, ",COMPRESSION"); 355 355 + #endif 353 356 seq_putc(m, '\n'); 354 357 seq_printf(m, "CIFSMaxBufSize: %d\n", CIFSMaxBufSize); 355 358 seq_printf(m, "Active VFS Requests: %d\n", GlobalTotalActiveXid); ··· 478 475 } 479 476 480 477 seq_puts(m, "\nCompression: "); 481 481 - if (!server->compression.requested) 478 478 + if (!IS_ENABLED(CONFIG_CIFS_COMPRESSION)) 479 479 + seq_puts(m, "no built-in support"); 480 480 + else if (!server->compression.requested) 482 481 seq_puts(m, "disabled on mount"); 483 482 else if (server->compression.enabled) 484 483 seq_printf(m, "enabled (%s)", compression_alg_str(server->compression.alg));

+113 -113

fs/smb/client/cifsacl.c

reviewed

··· 27 27 #include "cifs_unicode.h" 28 28 29 29 /* security id for everyone/world system group */ 30 30 - static const struct cifs_sid sid_everyone = { 30 30 + static const struct smb_sid sid_everyone = { 31 31 1, 1, {0, 0, 0, 0, 0, 1}, {0} }; 32 32 /* security id for Authenticated Users system group */ 33 33 - static const struct cifs_sid sid_authusers = { 33 33 + static const struct smb_sid sid_authusers = { 34 34 1, 1, {0, 0, 0, 0, 0, 5}, {cpu_to_le32(11)} }; 35 35 36 36 /* S-1-22-1 Unmapped Unix users */ 37 37 - static const struct cifs_sid sid_unix_users = {1, 1, {0, 0, 0, 0, 0, 22}, 37 37 + static const struct smb_sid sid_unix_users = {1, 1, {0, 0, 0, 0, 0, 22}, 38 38 {cpu_to_le32(1), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 39 39 40 40 /* S-1-22-2 Unmapped Unix groups */ 41 41 - static const struct cifs_sid sid_unix_groups = { 1, 1, {0, 0, 0, 0, 0, 22}, 41 41 + static const struct smb_sid sid_unix_groups = { 1, 1, {0, 0, 0, 0, 0, 22}, 42 42 {cpu_to_le32(2), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 43 43 44 44 /* ··· 48 48 /* S-1-5-88 MS NFS and Apple style UID/GID/mode */ 49 49 50 50 /* S-1-5-88-1 Unix uid */ 51 51 - static const struct cifs_sid sid_unix_NFS_users = { 1, 2, {0, 0, 0, 0, 0, 5}, 51 51 + static const struct smb_sid sid_unix_NFS_users = { 1, 2, {0, 0, 0, 0, 0, 5}, 52 52 {cpu_to_le32(88), 53 53 cpu_to_le32(1), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 54 54 55 55 /* S-1-5-88-2 Unix gid */ 56 56 - static const struct cifs_sid sid_unix_NFS_groups = { 1, 2, {0, 0, 0, 0, 0, 5}, 56 56 + static const struct smb_sid sid_unix_NFS_groups = { 1, 2, {0, 0, 0, 0, 0, 5}, 57 57 {cpu_to_le32(88), 58 58 cpu_to_le32(2), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 59 59 60 60 /* S-1-5-88-3 Unix mode */ 61 61 - static const struct cifs_sid sid_unix_NFS_mode = { 1, 2, {0, 0, 0, 0, 0, 5}, 61 61 + static const struct smb_sid sid_unix_NFS_mode = { 1, 2, {0, 0, 0, 0, 0, 5}, 62 62 {cpu_to_le32(88), 63 63 cpu_to_le32(3), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; 64 64 ··· 106 106 }; 107 107 108 108 static char * 109 109 - sid_to_key_str(struct cifs_sid *sidptr, unsigned int type) 109 109 + sid_to_key_str(struct smb_sid *sidptr, unsigned int type) 110 110 { 111 111 int i, len; 112 112 unsigned int saval; ··· 158 158 * the same returns zero, if they do not match returns non-zero. 159 159 */ 160 160 static int 161 161 - compare_sids(const struct cifs_sid *ctsid, const struct cifs_sid *cwsid) 161 161 + compare_sids(const struct smb_sid *ctsid, const struct smb_sid *cwsid) 162 162 { 163 163 int i; 164 164 int num_subauth, num_sat, num_saw; ··· 187 187 /* compare all of the subauth values if any */ 188 188 num_sat = ctsid->num_subauth; 189 189 num_saw = cwsid->num_subauth; 190 190 - num_subauth = num_sat < num_saw ? num_sat : num_saw; 190 190 + num_subauth = min(num_sat, num_saw); 191 191 if (num_subauth) { 192 192 for (i = 0; i < num_subauth; ++i) { 193 193 if (ctsid->sub_auth[i] != cwsid->sub_auth[i]) { ··· 204 204 } 205 205 206 206 static bool 207 207 - is_well_known_sid(const struct cifs_sid *psid, uint32_t *puid, bool is_group) 207 207 + is_well_known_sid(const struct smb_sid *psid, uint32_t *puid, bool is_group) 208 208 { 209 209 int i; 210 210 int num_subauth; 211 211 - const struct cifs_sid *pwell_known_sid; 211 211 + const struct smb_sid *pwell_known_sid; 212 212 213 213 if (!psid || (puid == NULL)) 214 214 return false; ··· 260 260 } 261 261 262 262 static __u16 263 263 - cifs_copy_sid(struct cifs_sid *dst, const struct cifs_sid *src) 263 263 + cifs_copy_sid(struct smb_sid *dst, const struct smb_sid *src) 264 264 { 265 265 int i; 266 266 __u16 size = 1 + 1 + 6; ··· 277 277 } 278 278 279 279 static int 280 280 - id_to_sid(unsigned int cid, uint sidtype, struct cifs_sid *ssid) 280 280 + id_to_sid(unsigned int cid, uint sidtype, struct smb_sid *ssid) 281 281 { 282 282 int rc; 283 283 struct key *sidkey; 284 284 - struct cifs_sid *ksid; 284 284 + struct smb_sid *ksid; 285 285 unsigned int ksid_size; 286 286 char desc[3 + 10 + 1]; /* 3 byte prefix + 10 bytes for value + NULL */ 287 287 const struct cred *saved_cred; ··· 312 312 * it could be. 313 313 */ 314 314 ksid = sidkey->datalen <= sizeof(sidkey->payload) ? 315 315 - (struct cifs_sid *)&sidkey->payload : 316 316 - (struct cifs_sid *)sidkey->payload.data[0]; 315 315 + (struct smb_sid *)&sidkey->payload : 316 316 + (struct smb_sid *)sidkey->payload.data[0]; 317 317 318 318 ksid_size = CIFS_SID_BASE_SIZE + (ksid->num_subauth * sizeof(__le32)); 319 319 if (ksid_size > sidkey->datalen) { ··· 336 336 } 337 337 338 338 int 339 339 - sid_to_id(struct cifs_sb_info *cifs_sb, struct cifs_sid *psid, 339 339 + sid_to_id(struct cifs_sb_info *cifs_sb, struct smb_sid *psid, 340 340 struct cifs_fattr *fattr, uint sidtype) 341 341 { 342 342 int rc = 0; ··· 515 515 } 516 516 517 517 /* copy ntsd, owner sid, and group sid from a security descriptor to another */ 518 518 - static __u32 copy_sec_desc(const struct cifs_ntsd *pntsd, 519 519 - struct cifs_ntsd *pnntsd, 518 518 + static __u32 copy_sec_desc(const struct smb_ntsd *pntsd, 519 519 + struct smb_ntsd *pnntsd, 520 520 __u32 sidsoffset, 521 521 - struct cifs_sid *pownersid, 522 522 - struct cifs_sid *pgrpsid) 521 521 + struct smb_sid *pownersid, 522 522 + struct smb_sid *pgrpsid) 523 523 { 524 524 - struct cifs_sid *owner_sid_ptr, *group_sid_ptr; 525 525 - struct cifs_sid *nowner_sid_ptr, *ngroup_sid_ptr; 524 524 + struct smb_sid *owner_sid_ptr, *group_sid_ptr; 525 525 + struct smb_sid *nowner_sid_ptr, *ngroup_sid_ptr; 526 526 527 527 /* copy security descriptor control portion */ 528 528 pnntsd->revision = pntsd->revision; 529 529 pnntsd->type = pntsd->type; 530 530 - pnntsd->dacloffset = cpu_to_le32(sizeof(struct cifs_ntsd)); 530 530 + pnntsd->dacloffset = cpu_to_le32(sizeof(struct smb_ntsd)); 531 531 pnntsd->sacloffset = 0; 532 532 pnntsd->osidoffset = cpu_to_le32(sidsoffset); 533 533 - pnntsd->gsidoffset = cpu_to_le32(sidsoffset + sizeof(struct cifs_sid)); 533 533 + pnntsd->gsidoffset = cpu_to_le32(sidsoffset + sizeof(struct smb_sid)); 534 534 535 535 /* copy owner sid */ 536 536 if (pownersid) 537 537 owner_sid_ptr = pownersid; 538 538 else 539 539 - owner_sid_ptr = (struct cifs_sid *)((char *)pntsd + 539 539 + owner_sid_ptr = (struct smb_sid *)((char *)pntsd + 540 540 le32_to_cpu(pntsd->osidoffset)); 541 541 - nowner_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset); 541 541 + nowner_sid_ptr = (struct smb_sid *)((char *)pnntsd + sidsoffset); 542 542 cifs_copy_sid(nowner_sid_ptr, owner_sid_ptr); 543 543 544 544 /* copy group sid */ 545 545 if (pgrpsid) 546 546 group_sid_ptr = pgrpsid; 547 547 else 548 548 - group_sid_ptr = (struct cifs_sid *)((char *)pntsd + 548 548 + group_sid_ptr = (struct smb_sid *)((char *)pntsd + 549 549 le32_to_cpu(pntsd->gsidoffset)); 550 550 - ngroup_sid_ptr = (struct cifs_sid *)((char *)pnntsd + sidsoffset + 551 551 - sizeof(struct cifs_sid)); 550 550 + ngroup_sid_ptr = (struct smb_sid *)((char *)pnntsd + sidsoffset + 551 551 + sizeof(struct smb_sid)); 552 552 cifs_copy_sid(ngroup_sid_ptr, group_sid_ptr); 553 553 554 554 - return sidsoffset + (2 * sizeof(struct cifs_sid)); 554 554 + return sidsoffset + (2 * sizeof(struct smb_sid)); 555 555 } 556 556 557 557 ··· 666 666 return; 667 667 } 668 668 669 669 - static __u16 cifs_copy_ace(struct cifs_ace *dst, struct cifs_ace *src, struct cifs_sid *psid) 669 669 + static __u16 cifs_copy_ace(struct smb_ace *dst, struct smb_ace *src, struct smb_sid *psid) 670 670 { 671 671 __u16 size = 1 + 1 + 2 + 4; 672 672 ··· 685 685 return size; 686 686 } 687 687 688 688 - static __u16 fill_ace_for_sid(struct cifs_ace *pntace, 689 689 - const struct cifs_sid *psid, __u64 nmode, 688 688 + static __u16 fill_ace_for_sid(struct smb_ace *pntace, 689 689 + const struct smb_sid *psid, __u64 nmode, 690 690 umode_t bits, __u8 access_type, 691 691 bool allow_delete_child) 692 692 { ··· 723 723 724 724 725 725 #ifdef CONFIG_CIFS_DEBUG2 726 726 - static void dump_ace(struct cifs_ace *pace, char *end_of_acl) 726 726 + static void dump_ace(struct smb_ace *pace, char *end_of_acl) 727 727 { 728 728 int num_subauth; 729 729 ··· 758 758 } 759 759 #endif 760 760 761 761 - static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl, 762 762 - struct cifs_sid *pownersid, struct cifs_sid *pgrpsid, 761 761 + static void parse_dacl(struct smb_acl *pdacl, char *end_of_acl, 762 762 + struct smb_sid *pownersid, struct smb_sid *pgrpsid, 763 763 struct cifs_fattr *fattr, bool mode_from_special_sid) 764 764 { 765 765 int i; 766 766 int num_aces = 0; 767 767 int acl_size; 768 768 char *acl_base; 769 769 - struct cifs_ace **ppace; 769 769 + struct smb_ace **ppace; 770 770 771 771 /* BB need to add parm so we can store the SID BB */ 772 772 ··· 793 793 fattr->cf_mode &= ~(0777); 794 794 795 795 acl_base = (char *)pdacl; 796 796 - acl_size = sizeof(struct cifs_acl); 796 796 + acl_size = sizeof(struct smb_acl); 797 797 798 798 num_aces = le32_to_cpu(pdacl->num_aces); 799 799 if (num_aces > 0) { 800 800 umode_t denied_mode = 0; 801 801 802 802 - if (num_aces > ULONG_MAX / sizeof(struct cifs_ace *)) 802 802 + if (num_aces > ULONG_MAX / sizeof(struct smb_ace *)) 803 803 return; 804 804 - ppace = kmalloc_array(num_aces, sizeof(struct cifs_ace *), 804 804 + ppace = kmalloc_array(num_aces, sizeof(struct smb_ace *), 805 805 GFP_KERNEL); 806 806 if (!ppace) 807 807 return; 808 808 809 809 for (i = 0; i < num_aces; ++i) { 810 810 - ppace[i] = (struct cifs_ace *) (acl_base + acl_size); 810 810 + ppace[i] = (struct smb_ace *) (acl_base + acl_size); 811 811 #ifdef CONFIG_CIFS_DEBUG2 812 812 dump_ace(ppace[i], end_of_acl); 813 813 #endif ··· 849 849 850 850 /* memcpy((void *)(&(cifscred->aces[i])), 851 851 (void *)ppace[i], 852 852 - sizeof(struct cifs_ace)); */ 852 852 + sizeof(struct smb_ace)); */ 853 853 854 854 acl_base = (char *)ppace[i]; 855 855 acl_size = le16_to_cpu(ppace[i]->size); ··· 861 861 return; 862 862 } 863 863 864 864 - unsigned int setup_authusers_ACE(struct cifs_ace *pntace) 864 864 + unsigned int setup_authusers_ACE(struct smb_ace *pntace) 865 865 { 866 866 int i; 867 867 unsigned int ace_size = 20; ··· 885 885 * Fill in the special SID based on the mode. See 886 886 * https://technet.microsoft.com/en-us/library/hh509017(v=ws.10).aspx 887 887 */ 888 888 - unsigned int setup_special_mode_ACE(struct cifs_ace *pntace, __u64 nmode) 888 888 + unsigned int setup_special_mode_ACE(struct smb_ace *pntace, __u64 nmode) 889 889 { 890 890 int i; 891 891 unsigned int ace_size = 28; ··· 907 907 return ace_size; 908 908 } 909 909 910 910 - unsigned int setup_special_user_owner_ACE(struct cifs_ace *pntace) 910 910 + unsigned int setup_special_user_owner_ACE(struct smb_ace *pntace) 911 911 { 912 912 int i; 913 913 unsigned int ace_size = 28; ··· 930 930 } 931 931 932 932 static void populate_new_aces(char *nacl_base, 933 933 - struct cifs_sid *pownersid, 934 934 - struct cifs_sid *pgrpsid, 933 933 + struct smb_sid *pownersid, 934 934 + struct smb_sid *pgrpsid, 935 935 __u64 *pnmode, u32 *pnum_aces, u16 *pnsize, 936 936 bool modefromsid) 937 937 { ··· 944 944 __u64 deny_user_mode = 0; 945 945 __u64 deny_group_mode = 0; 946 946 bool sticky_set = false; 947 947 - struct cifs_ace *pnntace = NULL; 947 947 + struct smb_ace *pnntace = NULL; 948 948 949 949 nmode = *pnmode; 950 950 num_aces = *pnum_aces; 951 951 nsize = *pnsize; 952 952 953 953 if (modefromsid) { 954 954 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 954 954 + pnntace = (struct smb_ace *) (nacl_base + nsize); 955 955 nsize += setup_special_mode_ACE(pnntace, nmode); 956 956 num_aces++; 957 957 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 957 957 + pnntace = (struct smb_ace *) (nacl_base + nsize); 958 958 nsize += setup_authusers_ACE(pnntace); 959 959 num_aces++; 960 960 goto set_size; ··· 967 967 * updated in the inode. 968 968 */ 969 969 970 970 - if (!memcmp(pownersid, pgrpsid, sizeof(struct cifs_sid))) { 970 970 + if (!memcmp(pownersid, pgrpsid, sizeof(struct smb_sid))) { 971 971 /* 972 972 * Case when owner and group SIDs are the same. 973 973 * Set the more restrictive of the two modes. ··· 992 992 sticky_set = true; 993 993 994 994 if (deny_user_mode) { 995 995 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 995 995 + pnntace = (struct smb_ace *) (nacl_base + nsize); 996 996 nsize += fill_ace_for_sid(pnntace, pownersid, deny_user_mode, 997 997 0700, ACCESS_DENIED, false); 998 998 num_aces++; ··· 1000 1000 1001 1001 /* Group DENY ACE does not conflict with owner ALLOW ACE. Keep in preferred order*/ 1002 1002 if (deny_group_mode && !(deny_group_mode & (user_mode >> 3))) { 1003 1003 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1003 1003 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1004 1004 nsize += fill_ace_for_sid(pnntace, pgrpsid, deny_group_mode, 1005 1005 0070, ACCESS_DENIED, false); 1006 1006 num_aces++; 1007 1007 } 1008 1008 1009 1009 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1009 1009 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1010 1010 nsize += fill_ace_for_sid(pnntace, pownersid, user_mode, 1011 1011 0700, ACCESS_ALLOWED, true); 1012 1012 num_aces++; 1013 1013 1014 1014 /* Group DENY ACE conflicts with owner ALLOW ACE. So keep it after. */ 1015 1015 if (deny_group_mode && (deny_group_mode & (user_mode >> 3))) { 1016 1016 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1016 1016 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1017 1017 nsize += fill_ace_for_sid(pnntace, pgrpsid, deny_group_mode, 1018 1018 0070, ACCESS_DENIED, false); 1019 1019 num_aces++; 1020 1020 } 1021 1021 1022 1022 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1022 1022 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1023 1023 nsize += fill_ace_for_sid(pnntace, pgrpsid, group_mode, 1024 1024 0070, ACCESS_ALLOWED, !sticky_set); 1025 1025 num_aces++; 1026 1026 1027 1027 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1027 1027 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1028 1028 nsize += fill_ace_for_sid(pnntace, &sid_everyone, other_mode, 1029 1029 0007, ACCESS_ALLOWED, !sticky_set); 1030 1030 num_aces++; ··· 1034 1034 *pnsize = nsize; 1035 1035 } 1036 1036 1037 1037 - static __u16 replace_sids_and_copy_aces(struct cifs_acl *pdacl, struct cifs_acl *pndacl, 1038 1038 - struct cifs_sid *pownersid, struct cifs_sid *pgrpsid, 1039 1039 - struct cifs_sid *pnownersid, struct cifs_sid *pngrpsid) 1037 1037 + static __u16 replace_sids_and_copy_aces(struct smb_acl *pdacl, struct smb_acl *pndacl, 1038 1038 + struct smb_sid *pownersid, struct smb_sid *pgrpsid, 1039 1039 + struct smb_sid *pnownersid, struct smb_sid *pngrpsid) 1040 1040 { 1041 1041 int i; 1042 1042 u16 size = 0; 1043 1043 - struct cifs_ace *pntace = NULL; 1043 1043 + struct smb_ace *pntace = NULL; 1044 1044 char *acl_base = NULL; 1045 1045 u32 src_num_aces = 0; 1046 1046 u16 nsize = 0; 1047 1047 - struct cifs_ace *pnntace = NULL; 1047 1047 + struct smb_ace *pnntace = NULL; 1048 1048 char *nacl_base = NULL; 1049 1049 u16 ace_size = 0; 1050 1050 1051 1051 acl_base = (char *)pdacl; 1052 1052 - size = sizeof(struct cifs_acl); 1052 1052 + size = sizeof(struct smb_acl); 1053 1053 src_num_aces = le32_to_cpu(pdacl->num_aces); 1054 1054 1055 1055 nacl_base = (char *)pndacl; 1056 1056 - nsize = sizeof(struct cifs_acl); 1056 1056 + nsize = sizeof(struct smb_acl); 1057 1057 1058 1058 /* Go through all the ACEs */ 1059 1059 for (i = 0; i < src_num_aces; ++i) { 1060 1060 - pntace = (struct cifs_ace *) (acl_base + size); 1061 1061 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1060 1060 + pntace = (struct smb_ace *) (acl_base + size); 1061 1061 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1062 1062 1063 1063 if (pnownersid && compare_sids(&pntace->sid, pownersid) == 0) 1064 1064 ace_size = cifs_copy_ace(pnntace, pntace, pnownersid); ··· 1074 1074 return nsize; 1075 1075 } 1076 1076 1077 1077 - static int set_chmod_dacl(struct cifs_acl *pdacl, struct cifs_acl *pndacl, 1078 1078 - struct cifs_sid *pownersid, struct cifs_sid *pgrpsid, 1077 1077 + static int set_chmod_dacl(struct smb_acl *pdacl, struct smb_acl *pndacl, 1078 1078 + struct smb_sid *pownersid, struct smb_sid *pgrpsid, 1079 1079 __u64 *pnmode, bool mode_from_sid) 1080 1080 { 1081 1081 int i; 1082 1082 u16 size = 0; 1083 1083 - struct cifs_ace *pntace = NULL; 1083 1083 + struct smb_ace *pntace = NULL; 1084 1084 char *acl_base = NULL; 1085 1085 u32 src_num_aces = 0; 1086 1086 u16 nsize = 0; 1087 1087 - struct cifs_ace *pnntace = NULL; 1087 1087 + struct smb_ace *pnntace = NULL; 1088 1088 char *nacl_base = NULL; 1089 1089 u32 num_aces = 0; 1090 1090 bool new_aces_set = false; 1091 1091 1092 1092 /* Assuming that pndacl and pnmode are never NULL */ 1093 1093 nacl_base = (char *)pndacl; 1094 1094 - nsize = sizeof(struct cifs_acl); 1094 1094 + nsize = sizeof(struct smb_acl); 1095 1095 1096 1096 /* If pdacl is NULL, we don't have a src. Simply populate new ACL. */ 1097 1097 if (!pdacl) { ··· 1103 1103 } 1104 1104 1105 1105 acl_base = (char *)pdacl; 1106 1106 - size = sizeof(struct cifs_acl); 1106 1106 + size = sizeof(struct smb_acl); 1107 1107 src_num_aces = le32_to_cpu(pdacl->num_aces); 1108 1108 1109 1109 /* Retain old ACEs which we can retain */ 1110 1110 for (i = 0; i < src_num_aces; ++i) { 1111 1111 - pntace = (struct cifs_ace *) (acl_base + size); 1111 1111 + pntace = (struct smb_ace *) (acl_base + size); 1112 1112 1113 1113 if (!new_aces_set && (pntace->flags & INHERITED_ACE)) { 1114 1114 /* Place the new ACEs in between existing explicit and inherited */ ··· 1130 1130 } 1131 1131 1132 1132 /* update the pointer to the next ACE to populate*/ 1133 1133 - pnntace = (struct cifs_ace *) (nacl_base + nsize); 1133 1133 + pnntace = (struct smb_ace *) (nacl_base + nsize); 1134 1134 1135 1135 nsize += cifs_copy_ace(pnntace, pntace, NULL); 1136 1136 num_aces++; ··· 1156 1156 return 0; 1157 1157 } 1158 1158 1159 1159 - static int parse_sid(struct cifs_sid *psid, char *end_of_acl) 1159 1159 + static int parse_sid(struct smb_sid *psid, char *end_of_acl) 1160 1160 { 1161 1161 /* BB need to add parm so we can store the SID BB */ 1162 1162 ··· 1191 1191 1192 1192 /* Convert CIFS ACL to POSIX form */ 1193 1193 static int parse_sec_desc(struct cifs_sb_info *cifs_sb, 1194 1194 - struct cifs_ntsd *pntsd, int acl_len, struct cifs_fattr *fattr, 1194 1194 + struct smb_ntsd *pntsd, int acl_len, struct cifs_fattr *fattr, 1195 1195 bool get_mode_from_special_sid) 1196 1196 { 1197 1197 int rc = 0; 1198 1198 - struct cifs_sid *owner_sid_ptr, *group_sid_ptr; 1199 1199 - struct cifs_acl *dacl_ptr; /* no need for SACL ptr */ 1198 1198 + struct smb_sid *owner_sid_ptr, *group_sid_ptr; 1199 1199 + struct smb_acl *dacl_ptr; /* no need for SACL ptr */ 1200 1200 char *end_of_acl = ((char *)pntsd) + acl_len; 1201 1201 __u32 dacloffset; 1202 1202 1203 1203 if (pntsd == NULL) 1204 1204 return -EIO; 1205 1205 1206 1206 - owner_sid_ptr = (struct cifs_sid *)((char *)pntsd + 1206 1206 + owner_sid_ptr = (struct smb_sid *)((char *)pntsd + 1207 1207 le32_to_cpu(pntsd->osidoffset)); 1208 1208 - group_sid_ptr = (struct cifs_sid *)((char *)pntsd + 1208 1208 + group_sid_ptr = (struct smb_sid *)((char *)pntsd + 1209 1209 le32_to_cpu(pntsd->gsidoffset)); 1210 1210 dacloffset = le32_to_cpu(pntsd->dacloffset); 1211 1211 - dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset); 1211 1211 + dacl_ptr = (struct smb_acl *)((char *)pntsd + dacloffset); 1212 1212 cifs_dbg(NOISY, "revision %d type 0x%x ooffset 0x%x goffset 0x%x sacloffset 0x%x dacloffset 0x%x\n", 1213 1213 pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset), 1214 1214 le32_to_cpu(pntsd->gsidoffset), ··· 1249 1249 } 1250 1250 1251 1251 /* Convert permission bits from mode to equivalent CIFS ACL */ 1252 1252 - static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd, 1252 1252 + static int build_sec_desc(struct smb_ntsd *pntsd, struct smb_ntsd *pnntsd, 1253 1253 __u32 secdesclen, __u32 *pnsecdesclen, __u64 *pnmode, kuid_t uid, kgid_t gid, 1254 1254 bool mode_from_sid, bool id_from_sid, int *aclflag) 1255 1255 { ··· 1257 1257 __u32 dacloffset; 1258 1258 __u32 ndacloffset; 1259 1259 __u32 sidsoffset; 1260 1260 - struct cifs_sid *owner_sid_ptr, *group_sid_ptr; 1261 1261 - struct cifs_sid *nowner_sid_ptr = NULL, *ngroup_sid_ptr = NULL; 1262 1262 - struct cifs_acl *dacl_ptr = NULL; /* no need for SACL ptr */ 1263 1263 - struct cifs_acl *ndacl_ptr = NULL; /* no need for SACL ptr */ 1260 1260 + struct smb_sid *owner_sid_ptr, *group_sid_ptr; 1261 1261 + struct smb_sid *nowner_sid_ptr = NULL, *ngroup_sid_ptr = NULL; 1262 1262 + struct smb_acl *dacl_ptr = NULL; /* no need for SACL ptr */ 1263 1263 + struct smb_acl *ndacl_ptr = NULL; /* no need for SACL ptr */ 1264 1264 char *end_of_acl = ((char *)pntsd) + secdesclen; 1265 1265 u16 size = 0; 1266 1266 1267 1267 dacloffset = le32_to_cpu(pntsd->dacloffset); 1268 1268 if (dacloffset) { 1269 1269 - dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset); 1269 1269 + dacl_ptr = (struct smb_acl *)((char *)pntsd + dacloffset); 1270 1270 if (end_of_acl < (char *)dacl_ptr + le16_to_cpu(dacl_ptr->size)) { 1271 1271 cifs_dbg(VFS, "Server returned illegal ACL size\n"); 1272 1272 return -EINVAL; 1273 1273 } 1274 1274 } 1275 1275 1276 1276 - owner_sid_ptr = (struct cifs_sid *)((char *)pntsd + 1276 1276 + owner_sid_ptr = (struct smb_sid *)((char *)pntsd + 1277 1277 le32_to_cpu(pntsd->osidoffset)); 1278 1278 - group_sid_ptr = (struct cifs_sid *)((char *)pntsd + 1278 1278 + group_sid_ptr = (struct smb_sid *)((char *)pntsd + 1279 1279 le32_to_cpu(pntsd->gsidoffset)); 1280 1280 1281 1281 if (pnmode && *pnmode != NO_CHANGE_64) { /* chmod */ 1282 1282 - ndacloffset = sizeof(struct cifs_ntsd); 1283 1283 - ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset); 1282 1282 + ndacloffset = sizeof(struct smb_ntsd); 1283 1283 + ndacl_ptr = (struct smb_acl *)((char *)pnntsd + ndacloffset); 1284 1284 ndacl_ptr->revision = 1285 1285 dacloffset ? dacl_ptr->revision : cpu_to_le16(ACL_REVISION); 1286 1286 ··· 1297 1297 1298 1298 *aclflag |= CIFS_ACL_DACL; 1299 1299 } else { 1300 1300 - ndacloffset = sizeof(struct cifs_ntsd); 1301 1301 - ndacl_ptr = (struct cifs_acl *)((char *)pnntsd + ndacloffset); 1300 1300 + ndacloffset = sizeof(struct smb_ntsd); 1301 1301 + ndacl_ptr = (struct smb_acl *)((char *)pnntsd + ndacloffset); 1302 1302 ndacl_ptr->revision = 1303 1303 dacloffset ? dacl_ptr->revision : cpu_to_le16(ACL_REVISION); 1304 1304 ndacl_ptr->num_aces = dacl_ptr ? dacl_ptr->num_aces : 0; 1305 1305 1306 1306 if (uid_valid(uid)) { /* chown */ 1307 1307 uid_t id; 1308 1308 - nowner_sid_ptr = kzalloc(sizeof(struct cifs_sid), 1308 1308 + nowner_sid_ptr = kzalloc(sizeof(struct smb_sid), 1309 1309 GFP_KERNEL); 1310 1310 if (!nowner_sid_ptr) { 1311 1311 rc = -ENOMEM; ··· 1334 1334 } 1335 1335 if (gid_valid(gid)) { /* chgrp */ 1336 1336 gid_t id; 1337 1337 - ngroup_sid_ptr = kzalloc(sizeof(struct cifs_sid), 1337 1337 + ngroup_sid_ptr = kzalloc(sizeof(struct smb_sid), 1338 1338 GFP_KERNEL); 1339 1339 if (!ngroup_sid_ptr) { 1340 1340 rc = -ENOMEM; ··· 1385 1385 } 1386 1386 1387 1387 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1388 1388 - struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb, 1388 1388 + struct smb_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb, 1389 1389 const struct cifs_fid *cifsfid, u32 *pacllen, 1390 1390 u32 __maybe_unused unused) 1391 1391 { 1392 1392 - struct cifs_ntsd *pntsd = NULL; 1392 1392 + struct smb_ntsd *pntsd = NULL; 1393 1393 unsigned int xid; 1394 1394 int rc; 1395 1395 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb); ··· 1410 1410 return pntsd; 1411 1411 } 1412 1412 1413 1413 - static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb, 1413 1413 + static struct smb_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb, 1414 1414 const char *path, u32 *pacllen) 1415 1415 { 1416 1416 - struct cifs_ntsd *pntsd = NULL; 1416 1416 + struct smb_ntsd *pntsd = NULL; 1417 1417 int oplock = 0; 1418 1418 unsigned int xid; 1419 1419 int rc; ··· 1454 1454 } 1455 1455 1456 1456 /* Retrieve an ACL from the server */ 1457 1457 - struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb, 1457 1457 + struct smb_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb, 1458 1458 struct inode *inode, const char *path, 1459 1459 u32 *pacllen, u32 info) 1460 1460 { 1461 1461 - struct cifs_ntsd *pntsd = NULL; 1461 1461 + struct smb_ntsd *pntsd = NULL; 1462 1462 struct cifsFileInfo *open_file = NULL; 1463 1463 1464 1464 if (inode) ··· 1472 1472 } 1473 1473 1474 1474 /* Set an ACL on the server */ 1475 1475 - int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen, 1475 1475 + int set_cifs_acl(struct smb_ntsd *pnntsd, __u32 acllen, 1476 1476 struct inode *inode, const char *path, int aclflag) 1477 1477 { 1478 1478 int oplock = 0; ··· 1528 1528 struct inode *inode, bool mode_from_special_sid, 1529 1529 const char *path, const struct cifs_fid *pfid) 1530 1530 { 1531 1531 - struct cifs_ntsd *pntsd = NULL; 1531 1531 + struct smb_ntsd *pntsd = NULL; 1532 1532 u32 acllen = 0; 1533 1533 int rc = 0; 1534 1534 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb); ··· 1580 1580 __u32 secdesclen = 0; 1581 1581 __u32 nsecdesclen = 0; 1582 1582 __u32 dacloffset = 0; 1583 1583 - struct cifs_acl *dacl_ptr = NULL; 1584 1584 - struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */ 1585 1585 - struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */ 1583 1583 + struct smb_acl *dacl_ptr = NULL; 1584 1584 + struct smb_ntsd *pntsd = NULL; /* acl obtained from server */ 1585 1585 + struct smb_ntsd *pnntsd = NULL; /* modified acl to be sent to server */ 1586 1586 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1587 1587 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb); 1588 1588 struct smb_version_operations *ops; ··· 1625 1625 nsecdesclen = secdesclen; 1626 1626 if (pnmode && *pnmode != NO_CHANGE_64) { /* chmod */ 1627 1627 if (mode_from_sid) 1628 1628 - nsecdesclen += 2 * sizeof(struct cifs_ace); 1628 1628 + nsecdesclen += 2 * sizeof(struct smb_ace); 1629 1629 else /* cifsacl */ 1630 1630 - nsecdesclen += 5 * sizeof(struct cifs_ace); 1630 1630 + nsecdesclen += 5 * sizeof(struct smb_ace); 1631 1631 } else { /* chown */ 1632 1632 /* When ownership changes, changes new owner sid length could be different */ 1633 1633 - nsecdesclen = sizeof(struct cifs_ntsd) + (sizeof(struct cifs_sid) * 2); 1633 1633 + nsecdesclen = sizeof(struct smb_ntsd) + (sizeof(struct smb_sid) * 2); 1634 1634 dacloffset = le32_to_cpu(pntsd->dacloffset); 1635 1635 if (dacloffset) { 1636 1636 - dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset); 1636 1636 + dacl_ptr = (struct smb_acl *)((char *)pntsd + dacloffset); 1637 1637 if (mode_from_sid) 1638 1638 nsecdesclen += 1639 1639 - le32_to_cpu(dacl_ptr->num_aces) * sizeof(struct cifs_ace); 1639 1639 + le32_to_cpu(dacl_ptr->num_aces) * sizeof(struct smb_ace); 1640 1640 else /* cifsacl */ 1641 1641 nsecdesclen += le16_to_cpu(dacl_ptr->size); 1642 1642 }

+5 -94

fs/smb/client/cifsacl.h

reviewed

··· 9 9 #ifndef _CIFSACL_H 10 10 #define _CIFSACL_H 11 11 12 12 - #define NUM_AUTHS (6) /* number of authority fields */ 13 13 - #define SID_MAX_SUB_AUTHORITIES (15) /* max number of sub authority fields */ 12 12 + #include "../common/smbacl.h" 14 13 15 14 #define READ_BIT 0x4 16 15 #define WRITE_BIT 0x2 ··· 22 23 #define UBITSHIFT 6 23 24 #define GBITSHIFT 3 24 25 25 25 - #define ACCESS_ALLOWED 0 26 26 - #define ACCESS_DENIED 1 27 27 - 28 28 - #define SIDOWNER 1 29 29 - #define SIDGROUP 2 30 30 - 31 26 /* 32 27 * Security Descriptor length containing DACL with 3 ACEs (one each for 33 28 * owner, group and world). 34 29 */ 35 35 - #define DEFAULT_SEC_DESC_LEN (sizeof(struct cifs_ntsd) + \ 36 36 - sizeof(struct cifs_acl) + \ 37 37 - (sizeof(struct cifs_ace) * 4)) 38 38 - 39 39 - /* 40 40 - * Maximum size of a string representation of a SID: 41 41 - * 42 42 - * The fields are unsigned values in decimal. So: 43 43 - * 44 44 - * u8: max 3 bytes in decimal 45 45 - * u32: max 10 bytes in decimal 46 46 - * 47 47 - * "S-" + 3 bytes for version field + 15 for authority field + NULL terminator 48 48 - * 49 49 - * For authority field, max is when all 6 values are non-zero and it must be 50 50 - * represented in hex. So "-0x" + 12 hex digits. 51 51 - * 52 52 - * Add 11 bytes for each subauthority field (10 bytes each + 1 for '-') 53 53 - */ 54 54 - #define SID_STRING_BASE_SIZE (2 + 3 + 15 + 1) 55 55 - #define SID_STRING_SUBAUTH_SIZE (11) /* size of a single subauth string */ 56 56 - 57 57 - struct cifs_ntsd { 58 58 - __le16 revision; /* revision level */ 59 59 - __le16 type; 60 60 - __le32 osidoffset; 61 61 - __le32 gsidoffset; 62 62 - __le32 sacloffset; 63 63 - __le32 dacloffset; 64 64 - } __attribute__((packed)); 65 65 - 66 66 - struct cifs_sid { 67 67 - __u8 revision; /* revision level */ 68 68 - __u8 num_subauth; 69 69 - __u8 authority[NUM_AUTHS]; 70 70 - __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */ 71 71 - } __attribute__((packed)); 72 72 - 73 73 - /* size of a struct cifs_sid, sans sub_auth array */ 74 74 - #define CIFS_SID_BASE_SIZE (1 + 1 + NUM_AUTHS) 75 75 - 76 76 - struct cifs_acl { 77 77 - __le16 revision; /* revision level */ 78 78 - __le16 size; 79 79 - __le32 num_aces; 80 80 - } __attribute__((packed)); 81 81 - 82 82 - /* ACE types - see MS-DTYP 2.4.4.1 */ 83 83 - #define ACCESS_ALLOWED_ACE_TYPE 0x00 84 84 - #define ACCESS_DENIED_ACE_TYPE 0x01 85 85 - #define SYSTEM_AUDIT_ACE_TYPE 0x02 86 86 - #define SYSTEM_ALARM_ACE_TYPE 0x03 87 87 - #define ACCESS_ALLOWED_COMPOUND_ACE_TYPE 0x04 88 88 - #define ACCESS_ALLOWED_OBJECT_ACE_TYPE 0x05 89 89 - #define ACCESS_DENIED_OBJECT_ACE_TYPE 0x06 90 90 - #define SYSTEM_AUDIT_OBJECT_ACE_TYPE 0x07 91 91 - #define SYSTEM_ALARM_OBJECT_ACE_TYPE 0x08 92 92 - #define ACCESS_ALLOWED_CALLBACK_ACE_TYPE 0x09 93 93 - #define ACCESS_DENIED_CALLBACK_ACE_TYPE 0x0A 94 94 - #define ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE 0x0B 95 95 - #define ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE 0x0C 96 96 - #define SYSTEM_AUDIT_CALLBACK_ACE_TYPE 0x0D 97 97 - #define SYSTEM_ALARM_CALLBACK_ACE_TYPE 0x0E /* Reserved */ 98 98 - #define SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE 0x0F 99 99 - #define SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 0x10 /* reserved */ 100 100 - #define SYSTEM_MANDATORY_LABEL_ACE_TYPE 0x11 101 101 - #define SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE 0x12 102 102 - #define SYSTEM_SCOPED_POLICY_ID_ACE_TYPE 0x13 103 103 - 104 104 - /* ACE flags */ 105 105 - #define OBJECT_INHERIT_ACE 0x01 106 106 - #define CONTAINER_INHERIT_ACE 0x02 107 107 - #define NO_PROPAGATE_INHERIT_ACE 0x04 108 108 - #define INHERIT_ONLY_ACE 0x08 109 109 - #define INHERITED_ACE 0x10 110 110 - #define SUCCESSFUL_ACCESS_ACE_FLAG 0x40 111 111 - #define FAILED_ACCESS_ACE_FLAG 0x80 112 112 - 113 113 - struct cifs_ace { 114 114 - __u8 type; /* see above and MS-DTYP 2.4.4.1 */ 115 115 - __u8 flags; 116 116 - __le16 size; 117 117 - __le32 access_req; 118 118 - struct cifs_sid sid; /* ie UUID of user or group who gets these perms */ 119 119 - } __attribute__((packed)); 30 30 + #define DEFAULT_SEC_DESC_LEN (sizeof(struct smb_ntsd) + \ 31 31 + sizeof(struct smb_acl) + \ 32 32 + (sizeof(struct smb_ace) * 4)) 120 33 121 34 /* 122 35 * The current SMB3 form of security descriptor is similar to what was used for ··· 105 194 * Minimum security descriptor can be one without any SACL and DACL and can 106 195 * consist of revision, type, and two sids of minimum size for owner and group 107 196 */ 108 108 - #define MIN_SEC_DESC_LEN (sizeof(struct cifs_ntsd) + (2 * MIN_SID_LEN)) 197 197 + #define MIN_SEC_DESC_LEN (sizeof(struct smb_ntsd) + (2 * MIN_SID_LEN)) 109 198 110 199 #endif /* _CIFSACL_H */

-1

fs/smb/client/cifsfs.h

reviewed

··· 106 106 extern int cifs_file_mmap(struct file *file, struct vm_area_struct *vma); 107 107 extern int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma); 108 108 extern const struct file_operations cifs_dir_ops; 109 109 - extern int cifs_dir_open(struct inode *inode, struct file *file); 110 109 extern int cifs_readdir(struct file *file, struct dir_context *ctx); 111 110 112 111 /* Functions related to dir entries */

+13 -12

fs/smb/client/cifsglob.h

reviewed

··· 202 202 int gid; 203 203 int mode; 204 204 int cecount; 205 205 - struct cifs_sid osid; 206 206 - struct cifs_sid gsid; 205 205 + struct smb_sid osid; 206 206 + struct smb_sid gsid; 207 207 struct cifs_ntace *ntaces; 208 208 - struct cifs_ace *aces; 208 208 + struct smb_ace *aces; 209 209 }; 210 210 211 211 struct cifs_open_info_data { ··· 231 231 unsigned int eas_len; 232 232 } wsl; 233 233 char *symlink_target; 234 234 - struct cifs_sid posix_owner; 235 235 - struct cifs_sid posix_group; 234 234 + struct smb_sid posix_owner; 235 235 + struct smb_sid posix_group; 236 236 union { 237 237 struct smb2_file_all_info fi; 238 238 struct smb311_posix_qinfo posix_fi; ··· 536 536 int (*set_EA)(const unsigned int, struct cifs_tcon *, const char *, 537 537 const char *, const void *, const __u16, 538 538 const struct nls_table *, struct cifs_sb_info *); 539 539 - struct cifs_ntsd * (*get_acl)(struct cifs_sb_info *, struct inode *, 540 540 - const char *, u32 *, u32); 541 541 - struct cifs_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *, 542 542 - const struct cifs_fid *, u32 *, u32); 543 543 - int (*set_acl)(struct cifs_ntsd *, __u32, struct inode *, const char *, 544 544 - int); 539 539 + struct smb_ntsd * (*get_acl)(struct cifs_sb_info *cifssb, struct inode *ino, 540 540 + const char *patch, u32 *plen, u32 info); 541 541 + struct smb_ntsd * (*get_acl_by_fid)(struct cifs_sb_info *cifssmb, 542 542 + const struct cifs_fid *pfid, u32 *plen, u32 info); 543 543 + int (*set_acl)(struct smb_ntsd *pntsd, __u32 len, struct inode *ino, const char *path, 544 544 + int flag); 545 545 /* writepages retry size */ 546 546 unsigned int (*wp_retry_size)(struct inode *); 547 547 /* get mtu credits */ ··· 555 555 bool (*dir_needs_close)(struct cifsFileInfo *); 556 556 long (*fallocate)(struct file *, struct cifs_tcon *, int, loff_t, 557 557 loff_t); 558 558 - /* init transform request - used for encryption for now */ 558 558 + /* init transform (compress/encrypt) request */ 559 559 int (*init_transform_rq)(struct TCP_Server_Info *, int num_rqst, 560 560 struct smb_rqst *, struct smb_rqst *); 561 561 int (*is_transform_hdr)(void *buf); ··· 1874 1874 #define CIFS_HAS_CREDITS 0x0400 /* already has credits */ 1875 1875 #define CIFS_TRANSFORM_REQ 0x0800 /* transform request before sending */ 1876 1876 #define CIFS_NO_SRV_RSP 0x1000 /* there is no server response */ 1877 1877 + #define CIFS_COMPRESS_REQ 0x4000 /* compress request before sending */ 1877 1878 1878 1879 /* Security Flags: indicate type of session setup needed */ 1879 1880 #define CIFSSEC_MAY_SIGN 0x00001

-6

fs/smb/client/cifspdu.h

reviewed

··· 2573 2573 } __attribute__((packed)) FIND_FILE_STANDARD_INFO; /* level 0x1 FF resp data */ 2574 2574 2575 2575 2576 2576 - struct win_dev { 2577 2577 - unsigned char type[8]; /* IntxCHR or IntxBLK or LnxFIFO or LnxSOCK */ 2578 2578 - __le64 major; 2579 2579 - __le64 minor; 2580 2580 - } __attribute__((packed)); 2581 2581 - 2582 2576 struct fea { 2583 2577 unsigned char EA_flags; 2584 2578 __u8 name_len;

+16 -12

fs/smb/client/cifsproto.h

reviewed

··· 225 225 extern int cifs_rename_pending_delete(const char *full_path, 226 226 struct dentry *dentry, 227 227 const unsigned int xid); 228 228 - extern int sid_to_id(struct cifs_sb_info *cifs_sb, struct cifs_sid *psid, 228 228 + extern int sid_to_id(struct cifs_sb_info *cifs_sb, struct smb_sid *psid, 229 229 struct cifs_fattr *fattr, uint sidtype); 230 230 extern int cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb, 231 231 struct cifs_fattr *fattr, struct inode *inode, ··· 233 233 const char *path, const struct cifs_fid *pfid); 234 234 extern int id_mode_to_cifs_acl(struct inode *inode, const char *path, __u64 *pnmode, 235 235 kuid_t uid, kgid_t gid); 236 236 - extern struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *, struct inode *, 237 237 - const char *, u32 *, u32); 238 238 - extern struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *, 239 239 - const struct cifs_fid *, u32 *, u32); 236 236 + extern struct smb_ntsd *get_cifs_acl(struct cifs_sb_info *cifssmb, struct inode *ino, 237 237 + const char *path, u32 *plen, u32 info); 238 238 + extern struct smb_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifssb, 239 239 + const struct cifs_fid *pfid, u32 *plen, u32 info); 240 240 extern struct posix_acl *cifs_get_acl(struct mnt_idmap *idmap, 241 241 struct dentry *dentry, int type); 242 242 extern int cifs_set_acl(struct mnt_idmap *idmap, 243 243 struct dentry *dentry, struct posix_acl *acl, int type); 244 244 - extern int set_cifs_acl(struct cifs_ntsd *, __u32, struct inode *, 245 245 - const char *, int); 246 246 - extern unsigned int setup_authusers_ACE(struct cifs_ace *pace); 247 247 - extern unsigned int setup_special_mode_ACE(struct cifs_ace *pace, __u64 nmode); 248 248 - extern unsigned int setup_special_user_owner_ACE(struct cifs_ace *pace); 244 244 + extern int set_cifs_acl(struct smb_ntsd *pntsd, __u32 len, struct inode *ino, 245 245 + const char *path, int flag); 246 246 + extern unsigned int setup_authusers_ACE(struct smb_ace *pace); 247 247 + extern unsigned int setup_special_mode_ACE(struct smb_ace *pace, __u64 nmode); 248 248 + extern unsigned int setup_special_user_owner_ACE(struct smb_ace *pace); 249 249 250 250 extern void dequeue_mid(struct mid_q_entry *mid, bool malformed); 251 251 extern int cifs_read_from_socket(struct TCP_Server_Info *server, char *buf, ··· 570 570 const struct nls_table *nls_codepage, 571 571 struct cifs_sb_info *cifs_sb); 572 572 extern int CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, 573 573 - __u16 fid, struct cifs_ntsd **acl_inf, __u32 *buflen); 573 573 + __u16 fid, struct smb_ntsd **acl_inf, __u32 *buflen); 574 574 extern int CIFSSMBSetCIFSACL(const unsigned int, struct cifs_tcon *, __u16, 575 575 - struct cifs_ntsd *, __u32, int); 575 575 + struct smb_ntsd *pntsd, __u32 len, int aclflag); 576 576 extern int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon, 577 577 const unsigned char *searchName, 578 578 struct posix_acl **acl, const int acl_type, ··· 676 676 int parse_reparse_point(struct reparse_data_buffer *buf, 677 677 u32 plen, struct cifs_sb_info *cifs_sb, 678 678 bool unicode, struct cifs_open_info_data *data); 679 679 + int __cifs_sfu_make_node(unsigned int xid, struct inode *inode, 680 680 + struct dentry *dentry, struct cifs_tcon *tcon, 681 681 + const char *full_path, umode_t mode, dev_t dev, 682 682 + const char *symname); 679 683 int cifs_sfu_make_node(unsigned int xid, struct inode *inode, 680 684 struct dentry *dentry, struct cifs_tcon *tcon, 681 685 const char *full_path, umode_t mode, dev_t dev);

+7 -7

fs/smb/client/cifssmb.c

reviewed

··· 1076 1076 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO); 1077 1077 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags)); 1078 1078 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */ 1079 1079 - /* set file as system file if special file such 1080 1080 - as fifo and server expecting SFU style and 1079 1079 + /* set file as system file if special file such as fifo, 1080 1080 + * socket, char or block and server expecting SFU style and 1081 1081 no Unix extensions */ 1082 1082 1083 1083 if (create_options & CREATE_OPTION_SPECIAL) ··· 1193 1193 req->AllocationSize = 0; 1194 1194 1195 1195 /* 1196 1196 - * Set file as system file if special file such as fifo and server 1197 1197 - * expecting SFU style and no Unix extensions. 1196 1196 + * Set file as system file if special file such as fifo, socket, char 1197 1197 + * or block and server expecting SFU style and no Unix extensions. 1198 1198 */ 1199 1199 if (create_options & CREATE_OPTION_SPECIAL) 1200 1200 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM); ··· 3427 3427 /* Get Security Descriptor (by handle) from remote server for a file or dir */ 3428 3428 int 3429 3429 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3430 3430 - struct cifs_ntsd **acl_inf, __u32 *pbuflen) 3430 3430 + struct smb_ntsd **acl_inf, __u32 *pbuflen) 3431 3431 { 3432 3432 int rc = 0; 3433 3433 int buf_type = 0; ··· 3497 3497 3498 3498 /* check if buffer is big enough for the acl 3499 3499 header followed by the smallest SID */ 3500 3500 - if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) || 3500 3500 + if ((*pbuflen < sizeof(struct smb_ntsd) + 8) || 3501 3501 (*pbuflen >= 64 * 1024)) { 3502 3502 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen); 3503 3503 rc = -EINVAL; ··· 3517 3517 3518 3518 int 3519 3519 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid, 3520 3520 - struct cifs_ntsd *pntsd, __u32 acllen, int aclflag) 3520 3520 + struct smb_ntsd *pntsd, __u32 acllen, int aclflag) 3521 3521 { 3522 3522 __u16 byte_count, param_count, data_count, param_offset, data_offset; 3523 3523 int rc = 0;

+390

fs/smb/client/compress.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0-only 2 2 + /* 3 3 + * Copyright (C) 2024, SUSE LLC 4 4 + * 5 5 + * Authors: Enzo Matsumiya <ematsumiya@suse.de> 6 6 + * 7 7 + * This file implements I/O compression support for SMB2 messages (SMB 3.1.1 only). 8 8 + * See compress/ for implementation details of each algorithm. 9 9 + * 10 10 + * References: 11 11 + * MS-SMB2 "3.1.4.4 Compressing the Message" 12 12 + * MS-SMB2 "3.1.5.3 Decompressing the Chained Message" 13 13 + * MS-XCA - for details of the supported algorithms 14 14 + */ 15 15 + #include <linux/slab.h> 16 16 + #include <linux/kernel.h> 17 17 + #include <linux/uio.h> 18 18 + #include <linux/sort.h> 19 19 + 20 20 + #include "cifsglob.h" 21 21 + #include "../common/smb2pdu.h" 22 22 + #include "cifsproto.h" 23 23 + #include "smb2proto.h" 24 24 + 25 25 + #include "compress/lz77.h" 26 26 + #include "compress.h" 27 27 + 28 28 + /* 29 29 + * The heuristic_*() functions below try to determine data compressibility. 30 30 + * 31 31 + * Derived from fs/btrfs/compression.c, changing coding style, some parameters, and removing 32 32 + * unused parts. 33 33 + * 34 34 + * Read that file for better and more detailed explanation of the calculations. 35 35 + * 36 36 + * The algorithms are ran in a collected sample of the input (uncompressed) data. 37 37 + * The sample is formed of 2K reads in PAGE_SIZE intervals, with a maximum size of 4M. 38 38 + * 39 39 + * Parsing the sample goes from "low-hanging fruits" (fastest algorithms, likely compressible) 40 40 + * to "need more analysis" (likely uncompressible). 41 41 + */ 42 42 + 43 43 + struct bucket { 44 44 + unsigned int count; 45 45 + }; 46 46 + 47 47 + /** 48 48 + * has_low_entropy() - Compute Shannon entropy of the sampled data. 49 49 + * @bkt: Bytes counts of the sample. 50 50 + * @slen: Size of the sample. 51 51 + * 52 52 + * Return: true if the level (percentage of number of bits that would be required to 53 53 + * compress the data) is below the minimum threshold. 54 54 + * 55 55 + * Note: 56 56 + * There _is_ an entropy level here that's > 65 (minimum threshold) that would indicate a 57 57 + * possibility of compression, but compressing, or even further analysing, it would waste so much 58 58 + * resources that it's simply not worth it. 59 59 + * 60 60 + * Also Shannon entropy is the last computed heuristic; if we got this far and ended up 61 61 + * with uncertainty, just stay on the safe side and call it uncompressible. 62 62 + */ 63 63 + static bool has_low_entropy(struct bucket *bkt, size_t slen) 64 64 + { 65 65 + const size_t threshold = 65, max_entropy = 8 * ilog2(16); 66 66 + size_t i, p, p2, len, sum = 0; 67 67 + 68 68 + #define pow4(n) (n * n * n * n) 69 69 + len = ilog2(pow4(slen)); 70 70 + 71 71 + for (i = 0; i < 256 && bkt[i].count > 0; i++) { 72 72 + p = bkt[i].count; 73 73 + p2 = ilog2(pow4(p)); 74 74 + sum += p * (len - p2); 75 75 + } 76 76 + 77 77 + sum /= slen; 78 78 + 79 79 + return ((sum * 100 / max_entropy) <= threshold); 80 80 + } 81 81 + 82 82 + #define BYTE_DIST_BAD 0 83 83 + #define BYTE_DIST_GOOD 1 84 84 + #define BYTE_DIST_MAYBE 2 85 85 + /** 86 86 + * calc_byte_distribution() - Compute byte distribution on the sampled data. 87 87 + * @bkt: Byte counts of the sample. 88 88 + * @slen: Size of the sample. 89 89 + * 90 90 + * Return: 91 91 + * BYTE_DIST_BAD: A "hard no" for compression -- a computed uniform distribution of 92 92 + * the bytes (e.g. random or encrypted data). 93 93 + * BYTE_DIST_GOOD: High probability (normal (Gaussian) distribution) of the data being 94 94 + * compressible. 95 95 + * BYTE_DIST_MAYBE: When computed byte distribution resulted in "low > n < high" 96 96 + * grounds. has_low_entropy() should be used for a final decision. 97 97 + */ 98 98 + static int calc_byte_distribution(struct bucket *bkt, size_t slen) 99 99 + { 100 100 + const size_t low = 64, high = 200, threshold = slen * 90 / 100; 101 101 + size_t sum = 0; 102 102 + int i; 103 103 + 104 104 + for (i = 0; i < low; i++) 105 105 + sum += bkt[i].count; 106 106 + 107 107 + if (sum > threshold) 108 108 + return BYTE_DIST_BAD; 109 109 + 110 110 + for (; i < high && bkt[i].count > 0; i++) { 111 111 + sum += bkt[i].count; 112 112 + if (sum > threshold) 113 113 + break; 114 114 + } 115 115 + 116 116 + if (i <= low) 117 117 + return BYTE_DIST_GOOD; 118 118 + 119 119 + if (i >= high) 120 120 + return BYTE_DIST_BAD; 121 121 + 122 122 + return BYTE_DIST_MAYBE; 123 123 + } 124 124 + 125 125 + static bool is_mostly_ascii(const struct bucket *bkt) 126 126 + { 127 127 + size_t count = 0; 128 128 + int i; 129 129 + 130 130 + for (i = 0; i < 256; i++) 131 131 + if (bkt[i].count > 0) 132 132 + /* Too many non-ASCII (0-63) bytes. */ 133 133 + if (++count > 64) 134 134 + return false; 135 135 + 136 136 + return true; 137 137 + } 138 138 + 139 139 + static bool has_repeated_data(const u8 *sample, size_t len) 140 140 + { 141 141 + size_t s = len / 2; 142 142 + 143 143 + return (!memcmp(&sample[0], &sample[s], s)); 144 144 + } 145 145 + 146 146 + static int cmp_bkt(const void *_a, const void *_b) 147 147 + { 148 148 + const struct bucket *a = _a, *b = _b; 149 149 + 150 150 + /* Reverse sort. */ 151 151 + if (a->count > b->count) 152 152 + return -1; 153 153 + 154 154 + return 1; 155 155 + } 156 156 + 157 157 + /* 158 158 + * TODO: 159 159 + * Support other iter types, if required. 160 160 + * Only ITER_XARRAY is supported for now. 161 161 + */ 162 162 + static int collect_sample(const struct iov_iter *iter, ssize_t max, u8 *sample) 163 163 + { 164 164 + struct folio *folios[16], *folio; 165 165 + unsigned int nr, i, j, npages; 166 166 + loff_t start = iter->xarray_start + iter->iov_offset; 167 167 + pgoff_t last, index = start / PAGE_SIZE; 168 168 + size_t len, off, foff; 169 169 + ssize_t ret = 0; 170 170 + void *p; 171 171 + int s = 0; 172 172 + 173 173 + last = (start + max - 1) / PAGE_SIZE; 174 174 + do { 175 175 + nr = xa_extract(iter->xarray, (void **)folios, index, last, ARRAY_SIZE(folios), 176 176 + XA_PRESENT); 177 177 + if (nr == 0) 178 178 + return -EIO; 179 179 + 180 180 + for (i = 0; i < nr; i++) { 181 181 + folio = folios[i]; 182 182 + npages = folio_nr_pages(folio); 183 183 + foff = start - folio_pos(folio); 184 184 + off = foff % PAGE_SIZE; 185 185 + 186 186 + for (j = foff / PAGE_SIZE; j < npages; j++) { 187 187 + size_t len2; 188 188 + 189 189 + len = min_t(size_t, max, PAGE_SIZE - off); 190 190 + len2 = min_t(size_t, len, SZ_2K); 191 191 + 192 192 + p = kmap_local_page(folio_page(folio, j)); 193 193 + memcpy(&sample[s], p, len2); 194 194 + kunmap_local(p); 195 195 + 196 196 + if (ret < 0) 197 197 + return ret; 198 198 + 199 199 + s += len2; 200 200 + 201 201 + if (len2 < SZ_2K || s >= max - SZ_2K) 202 202 + return s; 203 203 + 204 204 + max -= len; 205 205 + if (max <= 0) 206 206 + return s; 207 207 + 208 208 + start += len; 209 209 + off = 0; 210 210 + index++; 211 211 + } 212 212 + } 213 213 + } while (nr == ARRAY_SIZE(folios)); 214 214 + 215 215 + return s; 216 216 + } 217 217 + 218 218 + /** 219 219 + * is_compressible() - Determines if a chunk of data is compressible. 220 220 + * @data: Iterator containing uncompressed data. 221 221 + * 222 222 + * Return: true if @data is compressible, false otherwise. 223 223 + * 224 224 + * Tests shows that this function is quite reliable in predicting data compressibility, 225 225 + * matching close to 1:1 with the behaviour of LZ77 compression success and failures. 226 226 + */ 227 227 + static bool is_compressible(const struct iov_iter *data) 228 228 + { 229 229 + const size_t read_size = SZ_2K, bkt_size = 256, max = SZ_4M; 230 230 + struct bucket *bkt = NULL; 231 231 + size_t len; 232 232 + u8 *sample; 233 233 + bool ret = false; 234 234 + int i; 235 235 + 236 236 + /* Preventive double check -- already checked in should_compress(). */ 237 237 + len = iov_iter_count(data); 238 238 + if (unlikely(len < read_size)) 239 239 + return ret; 240 240 + 241 241 + if (len - read_size > max) 242 242 + len = max; 243 243 + 244 244 + sample = kvzalloc(len, GFP_KERNEL); 245 245 + if (!sample) { 246 246 + WARN_ON_ONCE(1); 247 247 + 248 248 + return ret; 249 249 + } 250 250 + 251 251 + /* Sample 2K bytes per page of the uncompressed data. */ 252 252 + i = collect_sample(data, len, sample); 253 253 + if (i <= 0) { 254 254 + WARN_ON_ONCE(1); 255 255 + 256 256 + goto out; 257 257 + } 258 258 + 259 259 + len = i; 260 260 + ret = true; 261 261 + 262 262 + if (has_repeated_data(sample, len)) 263 263 + goto out; 264 264 + 265 265 + bkt = kcalloc(bkt_size, sizeof(*bkt), GFP_KERNEL); 266 266 + if (!bkt) { 267 267 + WARN_ON_ONCE(1); 268 268 + ret = false; 269 269 + 270 270 + goto out; 271 271 + } 272 272 + 273 273 + for (i = 0; i < len; i++) 274 274 + bkt[sample[i]].count++; 275 275 + 276 276 + if (is_mostly_ascii(bkt)) 277 277 + goto out; 278 278 + 279 279 + /* Sort in descending order */ 280 280 + sort(bkt, bkt_size, sizeof(*bkt), cmp_bkt, NULL); 281 281 + 282 282 + i = calc_byte_distribution(bkt, len); 283 283 + if (i != BYTE_DIST_MAYBE) { 284 284 + ret = !!i; 285 285 + 286 286 + goto out; 287 287 + } 288 288 + 289 289 + ret = has_low_entropy(bkt, len); 290 290 + out: 291 291 + kvfree(sample); 292 292 + kfree(bkt); 293 293 + 294 294 + return ret; 295 295 + } 296 296 + 297 297 + bool should_compress(const struct cifs_tcon *tcon, const struct smb_rqst *rq) 298 298 + { 299 299 + const struct smb2_hdr *shdr = rq->rq_iov->iov_base; 300 300 + 301 301 + if (unlikely(!tcon || !tcon->ses || !tcon->ses->server)) 302 302 + return false; 303 303 + 304 304 + if (!tcon->ses->server->compression.enabled) 305 305 + return false; 306 306 + 307 307 + if (!(tcon->share_flags & SMB2_SHAREFLAG_COMPRESS_DATA)) 308 308 + return false; 309 309 + 310 310 + if (shdr->Command == SMB2_WRITE) { 311 311 + const struct smb2_write_req *wreq = rq->rq_iov->iov_base; 312 312 + 313 313 + if (le32_to_cpu(wreq->Length) < SMB_COMPRESS_MIN_LEN) 314 314 + return false; 315 315 + 316 316 + return is_compressible(&rq->rq_iter); 317 317 + } 318 318 + 319 319 + return (shdr->Command == SMB2_READ); 320 320 + } 321 321 + 322 322 + int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq, compress_send_fn send_fn) 323 323 + { 324 324 + struct iov_iter iter; 325 325 + u32 slen, dlen; 326 326 + void *src, *dst = NULL; 327 327 + int ret; 328 328 + 329 329 + if (!server || !rq || !rq->rq_iov || !rq->rq_iov->iov_base) 330 330 + return -EINVAL; 331 331 + 332 332 + if (rq->rq_iov->iov_len != sizeof(struct smb2_write_req)) 333 333 + return -EINVAL; 334 334 + 335 335 + slen = iov_iter_count(&rq->rq_iter); 336 336 + src = kvzalloc(slen, GFP_KERNEL); 337 337 + if (!src) { 338 338 + ret = -ENOMEM; 339 339 + goto err_free; 340 340 + } 341 341 + 342 342 + /* Keep the original iter intact. */ 343 343 + iter = rq->rq_iter; 344 344 + 345 345 + if (!copy_from_iter_full(src, slen, &iter)) { 346 346 + ret = -EIO; 347 347 + goto err_free; 348 348 + } 349 349 + 350 350 + /* 351 351 + * This is just overprovisioning, as the algorithm will error out if @dst reaches 7/8 352 352 + * of @slen. 353 353 + */ 354 354 + dlen = slen; 355 355 + dst = kvzalloc(dlen, GFP_KERNEL); 356 356 + if (!dst) { 357 357 + ret = -ENOMEM; 358 358 + goto err_free; 359 359 + } 360 360 + 361 361 + ret = lz77_compress(src, slen, dst, &dlen); 362 362 + if (!ret) { 363 363 + struct smb2_compression_hdr hdr = { 0 }; 364 364 + struct smb_rqst comp_rq = { .rq_nvec = 3, }; 365 365 + struct kvec iov[3]; 366 366 + 367 367 + hdr.ProtocolId = SMB2_COMPRESSION_TRANSFORM_ID; 368 368 + hdr.OriginalCompressedSegmentSize = cpu_to_le32(slen); 369 369 + hdr.CompressionAlgorithm = SMB3_COMPRESS_LZ77; 370 370 + hdr.Flags = SMB2_COMPRESSION_FLAG_NONE; 371 371 + hdr.Offset = cpu_to_le32(rq->rq_iov[0].iov_len); 372 372 + 373 373 + iov[0].iov_base = &hdr; 374 374 + iov[0].iov_len = sizeof(hdr); 375 375 + iov[1] = rq->rq_iov[0]; 376 376 + iov[2].iov_base = dst; 377 377 + iov[2].iov_len = dlen; 378 378 + 379 379 + comp_rq.rq_iov = iov; 380 380 + 381 381 + ret = send_fn(server, 1, &comp_rq); 382 382 + } else if (ret == -EMSGSIZE || dlen >= slen) { 383 383 + ret = send_fn(server, 1, rq); 384 384 + } 385 385 + err_free: 386 386 + kvfree(dst); 387 387 + kvfree(src); 388 388 + 389 389 + return ret; 390 390 + }

+90

fs/smb/client/compress.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 + /* 3 3 + * Copyright (C) 2024, SUSE LLC 4 4 + * 5 5 + * Authors: Enzo Matsumiya <ematsumiya@suse.de> 6 6 + * 7 7 + * This file implements I/O compression support for SMB2 messages (SMB 3.1.1 only). 8 8 + * See compress/ for implementation details of each algorithm. 9 9 + * 10 10 + * References: 11 11 + * MS-SMB2 "3.1.4.4 Compressing the Message" - for compression details 12 12 + * MS-SMB2 "3.1.5.3 Decompressing the Chained Message" - for decompression details 13 13 + * MS-XCA - for details of the supported algorithms 14 14 + */ 15 15 + #ifndef _SMB_COMPRESS_H 16 16 + #define _SMB_COMPRESS_H 17 17 + 18 18 + #include <linux/uio.h> 19 19 + #include <linux/kernel.h> 20 20 + #include "../common/smb2pdu.h" 21 21 + #include "cifsglob.h" 22 22 + 23 23 + /* sizeof(smb2_compression_hdr) - sizeof(OriginalPayloadSize) */ 24 24 + #define SMB_COMPRESS_HDR_LEN 16 25 25 + /* sizeof(smb2_compression_payload_hdr) - sizeof(OriginalPayloadSize) */ 26 26 + #define SMB_COMPRESS_PAYLOAD_HDR_LEN 8 27 27 + #define SMB_COMPRESS_MIN_LEN PAGE_SIZE 28 28 + 29 29 + #ifdef CONFIG_CIFS_COMPRESSION 30 30 + typedef int (*compress_send_fn)(struct TCP_Server_Info *, int, struct smb_rqst *); 31 31 + 32 32 + int smb_compress(struct TCP_Server_Info *server, struct smb_rqst *rq, compress_send_fn send_fn); 33 33 + 34 34 + /** 35 35 + * should_compress() - Determines if a request (write) or the response to a 36 36 + * request (read) should be compressed. 37 37 + * @tcon: tcon of the request is being sent to 38 38 + * @rqst: request to evaluate 39 39 + * 40 40 + * Return: true iff: 41 41 + * - compression was successfully negotiated with server 42 42 + * - server has enabled compression for the share 43 43 + * - it's a read or write request 44 44 + * - (write only) request length is >= SMB_COMPRESS_MIN_LEN 45 45 + * - (write only) is_compressible() returns 1 46 46 + * 47 47 + * Return false otherwise. 48 48 + */ 49 49 + bool should_compress(const struct cifs_tcon *tcon, const struct smb_rqst *rq); 50 50 + 51 51 + /** 52 52 + * smb_compress_alg_valid() - Validate a compression algorithm. 53 53 + * @alg: Compression algorithm to check. 54 54 + * @valid_none: Conditional check whether NONE algorithm should be 55 55 + * considered valid or not. 56 56 + * 57 57 + * If @alg is SMB3_COMPRESS_NONE, this function returns @valid_none. 58 58 + * 59 59 + * Note that 'NONE' (0) compressor type is considered invalid in protocol 60 60 + * negotiation, as it's never requested to/returned from the server. 61 61 + * 62 62 + * Return: true if @alg is valid/supported, false otherwise. 63 63 + */ 64 64 + static __always_inline int smb_compress_alg_valid(__le16 alg, bool valid_none) 65 65 + { 66 66 + if (alg == SMB3_COMPRESS_NONE) 67 67 + return valid_none; 68 68 + 69 69 + if (alg == SMB3_COMPRESS_LZ77 || alg == SMB3_COMPRESS_PATTERN) 70 70 + return true; 71 71 + 72 72 + return false; 73 73 + } 74 74 + #else /* !CONFIG_CIFS_COMPRESSION */ 75 75 + static inline int smb_compress(void *unused1, void *unused2, void *unused3) 76 76 + { 77 77 + return -EOPNOTSUPP; 78 78 + } 79 79 + 80 80 + static inline bool should_compress(void *unused1, void *unused2) 81 81 + { 82 82 + return false; 83 83 + } 84 84 + 85 85 + static inline int smb_compress_alg_valid(__le16 unused1, bool unused2) 86 86 + { 87 87 + return -EOPNOTSUPP; 88 88 + } 89 89 + #endif /* !CONFIG_CIFS_COMPRESSION */ 90 90 + #endif /* _SMB_COMPRESS_H */

+235

fs/smb/client/compress/lz77.c

reviewed

··· 1 1 + // SPDX-License-Identifier: GPL-2.0-only 2 2 + /* 3 3 + * Copyright (C) 2024, SUSE LLC 4 4 + * 5 5 + * Authors: Enzo Matsumiya <ematsumiya@suse.de> 6 6 + * 7 7 + * Implementation of the LZ77 "plain" compression algorithm, as per MS-XCA spec. 8 8 + */ 9 9 + #include <linux/slab.h> 10 10 + #include <linux/sizes.h> 11 11 + #include <linux/count_zeros.h> 12 12 + #include <asm/unaligned.h> 13 13 + 14 14 + #include "lz77.h" 15 15 + 16 16 + /* 17 17 + * Compression parameters. 18 18 + */ 19 19 + #define LZ77_MATCH_MIN_LEN 4 20 20 + #define LZ77_MATCH_MIN_DIST 1 21 21 + #define LZ77_MATCH_MAX_DIST SZ_1K 22 22 + #define LZ77_HASH_LOG 15 23 23 + #define LZ77_HASH_SIZE (1 << LZ77_HASH_LOG) 24 24 + #define LZ77_STEP_SIZE sizeof(u64) 25 25 + 26 26 + static __always_inline u8 lz77_read8(const u8 *ptr) 27 27 + { 28 28 + return get_unaligned(ptr); 29 29 + } 30 30 + 31 31 + static __always_inline u64 lz77_read64(const u64 *ptr) 32 32 + { 33 33 + return get_unaligned(ptr); 34 34 + } 35 35 + 36 36 + static __always_inline void lz77_write8(u8 *ptr, u8 v) 37 37 + { 38 38 + put_unaligned(v, ptr); 39 39 + } 40 40 + 41 41 + static __always_inline void lz77_write16(u16 *ptr, u16 v) 42 42 + { 43 43 + put_unaligned_le16(v, ptr); 44 44 + } 45 45 + 46 46 + static __always_inline void lz77_write32(u32 *ptr, u32 v) 47 47 + { 48 48 + put_unaligned_le32(v, ptr); 49 49 + } 50 50 + 51 51 + static __always_inline u32 lz77_match_len(const void *wnd, const void *cur, const void *end) 52 52 + { 53 53 + const void *start = cur; 54 54 + u64 diff; 55 55 + 56 56 + /* Safe for a do/while because otherwise we wouldn't reach here from the main loop. */ 57 57 + do { 58 58 + diff = lz77_read64(cur) ^ lz77_read64(wnd); 59 59 + if (!diff) { 60 60 + cur += LZ77_STEP_SIZE; 61 61 + wnd += LZ77_STEP_SIZE; 62 62 + 63 63 + continue; 64 64 + } 65 65 + 66 66 + /* This computes the number of common bytes in @diff. */ 67 67 + cur += count_trailing_zeros(diff) >> 3; 68 68 + 69 69 + return (cur - start); 70 70 + } while (likely(cur + LZ77_STEP_SIZE < end)); 71 71 + 72 72 + while (cur < end && lz77_read8(cur++) == lz77_read8(wnd++)) 73 73 + ; 74 74 + 75 75 + return (cur - start); 76 76 + } 77 77 + 78 78 + static __always_inline void *lz77_write_match(void *dst, void **nib, u32 dist, u32 len) 79 79 + { 80 80 + len -= 3; 81 81 + dist--; 82 82 + dist <<= 3; 83 83 + 84 84 + if (len < 7) { 85 85 + lz77_write16(dst, dist + len); 86 86 + 87 87 + return dst + 2; 88 88 + } 89 89 + 90 90 + dist |= 7; 91 91 + lz77_write16(dst, dist); 92 92 + dst += 2; 93 93 + len -= 7; 94 94 + 95 95 + if (!*nib) { 96 96 + lz77_write8(dst, umin(len, 15)); 97 97 + *nib = dst; 98 98 + dst++; 99 99 + } else { 100 100 + u8 *b = *nib; 101 101 + 102 102 + lz77_write8(b, *b | umin(len, 15) << 4); 103 103 + *nib = NULL; 104 104 + } 105 105 + 106 106 + if (len < 15) 107 107 + return dst; 108 108 + 109 109 + len -= 15; 110 110 + if (len < 255) { 111 111 + lz77_write8(dst, len); 112 112 + 113 113 + return dst + 1; 114 114 + } 115 115 + 116 116 + lz77_write8(dst, 0xff); 117 117 + dst++; 118 118 + len += 7 + 15; 119 119 + if (len <= 0xffff) { 120 120 + lz77_write16(dst, len); 121 121 + 122 122 + return dst + 2; 123 123 + } 124 124 + 125 125 + lz77_write16(dst, 0); 126 126 + dst += 2; 127 127 + lz77_write32(dst, len); 128 128 + 129 129 + return dst + 4; 130 130 + } 131 131 + 132 132 + noinline int lz77_compress(const void *src, u32 slen, void *dst, u32 *dlen) 133 133 + { 134 134 + const void *srcp, *end; 135 135 + void *dstp, *nib, *flag_pos; 136 136 + u32 flag_count = 0; 137 137 + long flag = 0; 138 138 + u64 *htable; 139 139 + 140 140 + srcp = src; 141 141 + end = src + slen; 142 142 + dstp = dst; 143 143 + nib = NULL; 144 144 + flag_pos = dstp; 145 145 + dstp += 4; 146 146 + 147 147 + htable = kvcalloc(LZ77_HASH_SIZE, sizeof(*htable), GFP_KERNEL); 148 148 + if (!htable) 149 149 + return -ENOMEM; 150 150 + 151 151 + /* Main loop. */ 152 152 + do { 153 153 + u32 dist, len = 0; 154 154 + const void *wnd; 155 155 + u64 hash; 156 156 + 157 157 + hash = ((lz77_read64(srcp) << 24) * 889523592379ULL) >> (64 - LZ77_HASH_LOG); 158 158 + wnd = src + htable[hash]; 159 159 + htable[hash] = srcp - src; 160 160 + dist = srcp - wnd; 161 161 + 162 162 + if (dist && dist < LZ77_MATCH_MAX_DIST) 163 163 + len = lz77_match_len(wnd, srcp, end); 164 164 + 165 165 + if (len < LZ77_MATCH_MIN_LEN) { 166 166 + lz77_write8(dstp, lz77_read8(srcp)); 167 167 + 168 168 + dstp++; 169 169 + srcp++; 170 170 + 171 171 + flag <<= 1; 172 172 + flag_count++; 173 173 + if (flag_count == 32) { 174 174 + lz77_write32(flag_pos, flag); 175 175 + flag_count = 0; 176 176 + flag_pos = dstp; 177 177 + dstp += 4; 178 178 + } 179 179 + 180 180 + continue; 181 181 + } 182 182 + 183 183 + /* 184 184 + * Bail out if @dstp reached >= 7/8 of @slen -- already compressed badly, not worth 185 185 + * going further. 186 186 + */ 187 187 + if (unlikely(dstp - dst >= slen - (slen >> 3))) { 188 188 + *dlen = slen; 189 189 + goto out; 190 190 + } 191 191 + 192 192 + dstp = lz77_write_match(dstp, &nib, dist, len); 193 193 + srcp += len; 194 194 + 195 195 + flag = (flag << 1) | 1; 196 196 + flag_count++; 197 197 + if (flag_count == 32) { 198 198 + lz77_write32(flag_pos, flag); 199 199 + flag_count = 0; 200 200 + flag_pos = dstp; 201 201 + dstp += 4; 202 202 + } 203 203 + } while (likely(srcp + LZ77_STEP_SIZE < end)); 204 204 + 205 205 + while (srcp < end) { 206 206 + u32 c = umin(end - srcp, 32 - flag_count); 207 207 + 208 208 + memcpy(dstp, srcp, c); 209 209 + 210 210 + dstp += c; 211 211 + srcp += c; 212 212 + 213 213 + flag <<= c; 214 214 + flag_count += c; 215 215 + if (flag_count == 32) { 216 216 + lz77_write32(flag_pos, flag); 217 217 + flag_count = 0; 218 218 + flag_pos = dstp; 219 219 + dstp += 4; 220 220 + } 221 221 + } 222 222 + 223 223 + flag <<= (32 - flag_count); 224 224 + flag |= (1 << (32 - flag_count)) - 1; 225 225 + lz77_write32(flag_pos, flag); 226 226 + 227 227 + *dlen = dstp - dst; 228 228 + out: 229 229 + kvfree(htable); 230 230 + 231 231 + if (*dlen < slen) 232 232 + return 0; 233 233 + 234 234 + return -EMSGSIZE; 235 235 + }

+15

fs/smb/client/compress/lz77.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: GPL-2.0-only */ 2 2 + /* 3 3 + * Copyright (C) 2024, SUSE LLC 4 4 + * 5 5 + * Authors: Enzo Matsumiya <ematsumiya@suse.de> 6 6 + * 7 7 + * Implementation of the LZ77 "plain" compression algorithm, as per MS-XCA spec. 8 8 + */ 9 9 + #ifndef _SMB_COMPRESS_LZ77_H 10 10 + #define _SMB_COMPRESS_LZ77_H 11 11 + 12 12 + #include <linux/kernel.h> 13 13 + 14 14 + int lz77_compress(const void *src, u32 slen, void *dst, u32 *dlen); 15 15 + #endif /* _SMB_COMPRESS_LZ77_H */

+2 -3

fs/smb/client/connect.c

reviewed

··· 1009 1009 } 1010 1010 1011 1011 if (!list_empty(&server->pending_mid_q)) { 1012 1012 - struct list_head dispose_list; 1013 1012 struct mid_q_entry *mid_entry; 1014 1013 struct list_head *tmp, *tmp2; 1014 1014 + LIST_HEAD(dispose_list); 1015 1015 1016 1016 - INIT_LIST_HEAD(&dispose_list); 1017 1016 spin_lock(&server->mid_lock); 1018 1017 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) { 1019 1018 mid_entry = list_entry(tmp, struct mid_q_entry, qhead); ··· 4080 4081 4081 4082 ses = cifs_get_smb_ses(master_tcon->ses->server, ctx); 4082 4083 if (IS_ERR(ses)) { 4083 4083 - tcon = (struct cifs_tcon *)ses; 4084 4084 + tcon = ERR_CAST(ses); 4084 4085 cifs_put_tcp_session(master_tcon->ses->server, 0); 4085 4086 goto out; 4086 4087 }

+2 -5

fs/smb/client/file.c

reviewed

··· 1403 1403 cifs_reopen_persistent_handles(struct cifs_tcon *tcon) 1404 1404 { 1405 1405 struct cifsFileInfo *open_file, *tmp; 1406 1406 - struct list_head tmp_list; 1406 1406 + LIST_HEAD(tmp_list); 1407 1407 1408 1408 if (!tcon->use_persistent || !tcon->need_reopen_files) 1409 1409 return; ··· 1411 1411 tcon->need_reopen_files = false; 1412 1412 1413 1413 cifs_dbg(FYI, "Reopen persistent handles\n"); 1414 1414 - INIT_LIST_HEAD(&tmp_list); 1415 1414 1416 1415 /* list all files open on tree connection, reopen resilient handles */ 1417 1416 spin_lock(&tcon->open_file_lock); ··· 2093 2094 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 2094 2095 struct cifsLockInfo *li, *tmp; 2095 2096 __u64 length = cifs_flock_len(flock); 2096 2096 - struct list_head tmp_llist; 2097 2097 - 2098 2098 - INIT_LIST_HEAD(&tmp_llist); 2097 2097 + LIST_HEAD(tmp_llist); 2099 2098 2100 2099 /* 2101 2100 * Accessing maxBuf is racy with cifs_reconnect - need to store value

+13 -7

fs/smb/client/fs_context.c

reviewed

··· 978 978 979 979 switch (opt) { 980 980 case Opt_compress: 981 981 + if (!IS_ENABLED(CONFIG_CIFS_COMPRESSION)) { 982 982 + cifs_errorf(fc, "CONFIG_CIFS_COMPRESSION kernel config option is unset\n"); 983 983 + goto cifs_parse_mount_err; 984 984 + } 981 985 ctx->compress = true; 982 982 - cifs_dbg(VFS, 983 983 - "SMB3 compression support is experimental\n"); 986 986 + cifs_dbg(VFS, "SMB3 compression support is experimental\n"); 984 987 break; 985 988 case Opt_nodfs: 986 989 ctx->nodfs = 1; ··· 1899 1896 if (ctx->mfsymlinks) { 1900 1897 if (ctx->sfu_emul) { 1901 1898 /* 1902 1902 - * Our SFU ("Services for Unix" emulation does not allow 1903 1903 - * creating symlinks but does allow reading existing SFU 1904 1904 - * symlinks (it does allow both creating and reading SFU 1905 1905 - * style mknod and FIFOs though). When "mfsymlinks" and 1899 1899 + * Our SFU ("Services for Unix") emulation allows now 1900 1900 + * creating new and reading existing SFU symlinks. 1901 1901 + * Older Linux kernel versions were not able to neither 1902 1902 + * read existing nor create new SFU symlinks. But 1903 1903 + * creating and reading SFU style mknod and FIFOs was 1904 1904 + * supported for long time. When "mfsymlinks" and 1906 1905 * "sfu" are both enabled at the same time, it allows 1907 1906 * reading both types of symlinks, but will only create 1908 1907 * them with mfsymlinks format. This allows better 1909 1909 - * Apple compatibility (probably better for Samba too) 1908 1908 + * Apple compatibility, compatibility with older Linux 1909 1909 + * kernel clients (probably better for Samba too) 1910 1910 * while still recognizing old Windows style symlinks. 1911 1911 */ 1912 1912 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");

+38 -4

fs/smb/client/inode.c

reviewed

··· 529 529 struct cifs_fid fid; 530 530 struct cifs_open_parms oparms; 531 531 struct cifs_io_parms io_parms = {0}; 532 532 + char *symlink_buf_utf16; 533 533 + unsigned int symlink_len_utf16; 532 534 char buf[24]; 533 535 unsigned int bytes_read; 534 536 char *pbuf; ··· 541 539 fattr->cf_mode &= ~S_IFMT; 542 540 543 541 if (fattr->cf_eof == 0) { 542 542 + cifs_dbg(FYI, "Fifo\n"); 544 543 fattr->cf_mode |= S_IFIFO; 545 544 fattr->cf_dtype = DT_FIFO; 546 545 return 0; 547 547 - } else if (fattr->cf_eof < 8) { 546 546 + } else if (fattr->cf_eof > 1 && fattr->cf_eof < 8) { 548 547 fattr->cf_mode |= S_IFREG; 549 548 fattr->cf_dtype = DT_REG; 550 549 return -EINVAL; /* EOPNOTSUPP? */ ··· 587 584 rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms, 588 585 &bytes_read, &pbuf, &buf_type); 589 586 if ((rc == 0) && (bytes_read >= 8)) { 590 590 - if (memcmp("IntxBLK", pbuf, 8) == 0) { 587 587 + if (memcmp("IntxBLK\0", pbuf, 8) == 0) { 591 588 cifs_dbg(FYI, "Block device\n"); 592 589 fattr->cf_mode |= S_IFBLK; 593 590 fattr->cf_dtype = DT_BLK; ··· 599 596 mnr = le64_to_cpu(*(__le64 *)(pbuf+16)); 600 597 fattr->cf_rdev = MKDEV(mjr, mnr); 601 598 } 602 602 - } else if (memcmp("IntxCHR", pbuf, 8) == 0) { 599 599 + } else if (memcmp("IntxCHR\0", pbuf, 8) == 0) { 603 600 cifs_dbg(FYI, "Char device\n"); 604 601 fattr->cf_mode |= S_IFCHR; 605 602 fattr->cf_dtype = DT_CHR; ··· 615 612 cifs_dbg(FYI, "Socket\n"); 616 613 fattr->cf_mode |= S_IFSOCK; 617 614 fattr->cf_dtype = DT_SOCK; 618 618 - } else if (memcmp("IntxLNK", pbuf, 7) == 0) { 615 615 + } else if (memcmp("IntxLNK\1", pbuf, 8) == 0) { 619 616 cifs_dbg(FYI, "Symlink\n"); 620 617 fattr->cf_mode |= S_IFLNK; 621 618 fattr->cf_dtype = DT_LNK; 619 619 + if ((fattr->cf_eof > 8) && (fattr->cf_eof % 2 == 0)) { 620 620 + symlink_buf_utf16 = kmalloc(fattr->cf_eof-8 + 1, GFP_KERNEL); 621 621 + if (symlink_buf_utf16) { 622 622 + io_parms.offset = 8; 623 623 + io_parms.length = fattr->cf_eof-8 + 1; 624 624 + buf_type = CIFS_NO_BUFFER; 625 625 + rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms, 626 626 + &symlink_len_utf16, 627 627 + &symlink_buf_utf16, 628 628 + &buf_type); 629 629 + if ((rc == 0) && 630 630 + (symlink_len_utf16 > 0) && 631 631 + (symlink_len_utf16 < fattr->cf_eof-8 + 1) && 632 632 + (symlink_len_utf16 % 2 == 0)) { 633 633 + fattr->cf_symlink_target = 634 634 + cifs_strndup_from_utf16(symlink_buf_utf16, 635 635 + symlink_len_utf16, 636 636 + true, 637 637 + cifs_sb->local_nls); 638 638 + if (!fattr->cf_symlink_target) 639 639 + rc = -ENOMEM; 640 640 + } 641 641 + kfree(symlink_buf_utf16); 642 642 + } else { 643 643 + rc = -ENOMEM; 644 644 + } 645 645 + } 622 646 } else if (memcmp("LnxFIFO", pbuf, 8) == 0) { 623 647 cifs_dbg(FYI, "FIFO\n"); 624 648 fattr->cf_mode |= S_IFIFO; ··· 655 625 fattr->cf_dtype = DT_REG; 656 626 rc = -EOPNOTSUPP; 657 627 } 628 628 + } else if ((rc == 0) && (bytes_read == 1) && (pbuf[0] == '\0')) { 629 629 + cifs_dbg(FYI, "Socket\n"); 630 630 + fattr->cf_mode |= S_IFSOCK; 631 631 + fattr->cf_dtype = DT_SOCK; 658 632 } else { 659 633 fattr->cf_mode |= S_IFREG; /* then it is a file */ 660 634 fattr->cf_dtype = DT_REG;

+3

fs/smb/client/link.c

reviewed

··· 606 606 /* BB what if DFS and this volume is on different share? BB */ 607 607 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) { 608 608 rc = create_mf_symlink(xid, pTcon, cifs_sb, full_path, symname); 609 609 + } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) { 610 610 + rc = __cifs_sfu_make_node(xid, inode, direntry, pTcon, 611 611 + full_path, S_IFLNK, 0, symname); 609 612 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 610 613 } else if (pTcon->unix_ext) { 611 614 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,

+3 -6

fs/smb/client/misc.c

reviewed

··· 751 751 { 752 752 struct cifsFileInfo *cfile = NULL; 753 753 struct file_list *tmp_list, *tmp_next_list; 754 754 - struct list_head file_head; 754 754 + LIST_HEAD(file_head); 755 755 756 756 if (cifs_inode == NULL) 757 757 return; 758 758 759 759 - INIT_LIST_HEAD(&file_head); 760 759 spin_lock(&cifs_inode->open_file_lock); 761 760 list_for_each_entry(cfile, &cifs_inode->openFileList, flist) { 762 761 if (delayed_work_pending(&cfile->deferred)) { ··· 786 787 { 787 788 struct cifsFileInfo *cfile; 788 789 struct file_list *tmp_list, *tmp_next_list; 789 789 - struct list_head file_head; 790 790 + LIST_HEAD(file_head); 790 791 791 791 - INIT_LIST_HEAD(&file_head); 792 792 spin_lock(&tcon->open_file_lock); 793 793 list_for_each_entry(cfile, &tcon->openFileList, tlist) { 794 794 if (delayed_work_pending(&cfile->deferred)) { ··· 817 819 { 818 820 struct cifsFileInfo *cfile; 819 821 struct file_list *tmp_list, *tmp_next_list; 820 820 - struct list_head file_head; 821 822 void *page; 822 823 const char *full_path; 824 824 + LIST_HEAD(file_head); 823 825 824 824 - INIT_LIST_HEAD(&file_head); 825 826 page = alloc_dentry_path(); 826 827 spin_lock(&tcon->open_file_lock); 827 828 list_for_each_entry(cfile, &tcon->openFileList, tlist) {

+1 -1

fs/smb/client/smb1ops.c

reviewed

··· 1078 1078 /* 1079 1079 * Check if mounted with mount parm 'sfu' mount parm. 1080 1080 * SFU emulation should work with all servers, but only 1081 1081 - * supports block and char device (no socket & fifo), 1081 1081 + * supports block and char device, socket & fifo, 1082 1082 * and was used by default in earlier versions of Windows 1083 1083 */ 1084 1084 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))

+2 -4

fs/smb/client/smb2file.c

reviewed

··· 21 21 #include "cifs_unicode.h" 22 22 #include "fscache.h" 23 23 #include "smb2proto.h" 24 24 - #include "smb2status.h" 24 24 + #include "../common/smb2status.h" 25 25 26 26 static struct smb2_symlink_err_rsp *symlink_data(const struct kvec *iov) 27 27 { ··· 196 196 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 197 197 struct cifsLockInfo *li, *tmp; 198 198 __u64 length = 1 + flock->fl_end - flock->fl_start; 199 199 - struct list_head tmp_llist; 200 200 - 201 201 - INIT_LIST_HEAD(&tmp_llist); 199 199 + LIST_HEAD(tmp_llist); 202 200 203 201 /* 204 202 * Accessing maxBuf is racy with cifs_reconnect - need to store value

+3 -3

fs/smb/client/smb2inode.c

reviewed

··· 24 24 #include "smb2pdu.h" 25 25 #include "smb2proto.h" 26 26 #include "cached_dir.h" 27 27 - #include "smb2status.h" 27 27 + #include "../common/smb2status.h" 28 28 29 29 static struct reparse_data_buffer *reparse_buf_ptr(struct kvec *iov) 30 30 { ··· 315 315 SMB2_O_INFO_FILE, 0, 316 316 sizeof(struct smb311_posix_qinfo *) + 317 317 (PATH_MAX * 2) + 318 318 - (sizeof(struct cifs_sid) * 2), 0, NULL); 318 318 + (sizeof(struct smb_sid) * 2), 0, NULL); 319 319 } else { 320 320 rc = SMB2_query_info_init(tcon, server, 321 321 &rqst[num_rqst], ··· 325 325 SMB2_O_INFO_FILE, 0, 326 326 sizeof(struct smb311_posix_qinfo *) + 327 327 (PATH_MAX * 2) + 328 328 - (sizeof(struct cifs_sid) * 2), 0, NULL); 328 328 + (sizeof(struct smb_sid) * 2), 0, NULL); 329 329 } 330 330 if (!rc && (!cfile || num_rqst > 1)) { 331 331 smb2_set_next_command(tcon, &rqst[num_rqst]);

+1 -1

fs/smb/client/smb2maperror.c

reviewed

··· 12 12 #include "cifs_debug.h" 13 13 #include "smb2pdu.h" 14 14 #include "smb2proto.h" 15 15 - #include "smb2status.h" 15 15 + #include "../common/smb2status.h" 16 16 #include "smb2glob.h" 17 17 #include "trace.h" 18 18

+1 -1

fs/smb/client/smb2misc.c

reviewed

··· 13 13 #include "smb2proto.h" 14 14 #include "cifs_debug.h" 15 15 #include "cifs_unicode.h" 16 16 - #include "smb2status.h" 16 16 + #include "../common/smb2status.h" 17 17 #include "smb2glob.h" 18 18 #include "nterr.h" 19 19 #include "cached_dir.h"

+71 -27

fs/smb/client/smb2ops.c

reviewed

··· 22 22 #include "cifsproto.h" 23 23 #include "cifs_debug.h" 24 24 #include "cifs_unicode.h" 25 25 - #include "smb2status.h" 25 25 + #include "../common/smb2status.h" 26 26 #include "smb2glob.h" 27 27 #include "cifs_ioctl.h" 28 28 #include "smbdirect.h" ··· 3050 3050 return rc; 3051 3051 } 3052 3052 3053 3053 - static struct cifs_ntsd * 3053 3053 + static struct smb_ntsd * 3054 3054 get_smb2_acl_by_fid(struct cifs_sb_info *cifs_sb, 3055 3055 const struct cifs_fid *cifsfid, u32 *pacllen, u32 info) 3056 3056 { 3057 3057 - struct cifs_ntsd *pntsd = NULL; 3057 3057 + struct smb_ntsd *pntsd = NULL; 3058 3058 unsigned int xid; 3059 3059 int rc = -EOPNOTSUPP; 3060 3060 struct tcon_link *tlink = cifs_sb_tlink(cifs_sb); ··· 3079 3079 3080 3080 } 3081 3081 3082 3082 - static struct cifs_ntsd * 3082 3082 + static struct smb_ntsd * 3083 3083 get_smb2_acl_by_path(struct cifs_sb_info *cifs_sb, 3084 3084 const char *path, u32 *pacllen, u32 info) 3085 3085 { 3086 3086 - struct cifs_ntsd *pntsd = NULL; 3086 3086 + struct smb_ntsd *pntsd = NULL; 3087 3087 u8 oplock = SMB2_OPLOCK_LEVEL_NONE; 3088 3088 unsigned int xid; 3089 3089 int rc; ··· 3146 3146 } 3147 3147 3148 3148 static int 3149 3149 - set_smb2_acl(struct cifs_ntsd *pnntsd, __u32 acllen, 3149 3149 + set_smb2_acl(struct smb_ntsd *pnntsd, __u32 acllen, 3150 3150 struct inode *inode, const char *path, int aclflag) 3151 3151 { 3152 3152 u8 oplock = SMB2_OPLOCK_LEVEL_NONE; ··· 3204 3204 } 3205 3205 3206 3206 /* Retrieve an ACL from the server */ 3207 3207 - static struct cifs_ntsd * 3207 3207 + static struct smb_ntsd * 3208 3208 get_smb2_acl(struct cifs_sb_info *cifs_sb, 3209 3209 struct inode *inode, const char *path, 3210 3210 u32 *pacllen, u32 info) 3211 3211 { 3212 3212 - struct cifs_ntsd *pntsd = NULL; 3212 3212 + struct smb_ntsd *pntsd = NULL; 3213 3213 struct cifsFileInfo *open_file = NULL; 3214 3214 3215 3215 if (inode && !(info & SACL_SECINFO)) ··· 5078 5078 return 0; 5079 5079 } 5080 5080 5081 5081 - static int __cifs_sfu_make_node(unsigned int xid, struct inode *inode, 5081 5081 + int __cifs_sfu_make_node(unsigned int xid, struct inode *inode, 5082 5082 struct dentry *dentry, struct cifs_tcon *tcon, 5083 5083 - const char *full_path, umode_t mode, dev_t dev) 5083 5083 + const char *full_path, umode_t mode, dev_t dev, 5084 5084 + const char *symname) 5084 5085 { 5085 5086 struct TCP_Server_Info *server = tcon->ses->server; 5086 5087 struct cifs_open_parms oparms; ··· 5089 5088 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 5090 5089 struct cifs_fid fid; 5091 5090 unsigned int bytes_written; 5092 5092 - struct win_dev pdev = {}; 5093 5093 - struct kvec iov[2]; 5091 5091 + u8 type[8]; 5092 5092 + int type_len = 0; 5093 5093 + struct { 5094 5094 + __le64 major; 5095 5095 + __le64 minor; 5096 5096 + } __packed pdev = {}; 5097 5097 + __le16 *symname_utf16 = NULL; 5098 5098 + u8 *data = NULL; 5099 5099 + int data_len = 0; 5100 5100 + struct kvec iov[3]; 5094 5101 __u32 oplock = server->oplocks ? REQ_OPLOCK : 0; 5095 5102 int rc; 5096 5103 5097 5104 switch (mode & S_IFMT) { 5098 5105 case S_IFCHR: 5099 5099 - strscpy(pdev.type, "IntxCHR"); 5106 5106 + type_len = 8; 5107 5107 + memcpy(type, "IntxCHR\0", type_len); 5100 5108 pdev.major = cpu_to_le64(MAJOR(dev)); 5101 5109 pdev.minor = cpu_to_le64(MINOR(dev)); 5110 5110 + data = (u8 *)&pdev; 5111 5111 + data_len = sizeof(pdev); 5102 5112 break; 5103 5113 case S_IFBLK: 5104 5104 - strscpy(pdev.type, "IntxBLK"); 5114 5114 + type_len = 8; 5115 5115 + memcpy(type, "IntxBLK\0", type_len); 5105 5116 pdev.major = cpu_to_le64(MAJOR(dev)); 5106 5117 pdev.minor = cpu_to_le64(MINOR(dev)); 5118 5118 + data = (u8 *)&pdev; 5119 5119 + data_len = sizeof(pdev); 5120 5120 + break; 5121 5121 + case S_IFLNK: 5122 5122 + type_len = 8; 5123 5123 + memcpy(type, "IntxLNK\1", type_len); 5124 5124 + symname_utf16 = cifs_strndup_to_utf16(symname, strlen(symname), 5125 5125 + &data_len, cifs_sb->local_nls, 5126 5126 + NO_MAP_UNI_RSVD); 5127 5127 + if (!symname_utf16) { 5128 5128 + rc = -ENOMEM; 5129 5129 + goto out; 5130 5130 + } 5131 5131 + data_len -= 2; /* symlink is without trailing wide-nul */ 5132 5132 + data = (u8 *)symname_utf16; 5107 5133 break; 5108 5134 case S_IFSOCK: 5109 5109 - strscpy(pdev.type, "LnxSOCK"); 5135 5135 + type_len = 8; 5136 5136 + strscpy(type, "LnxSOCK"); 5137 5137 + data = (u8 *)&pdev; 5138 5138 + data_len = sizeof(pdev); 5110 5139 break; 5111 5140 case S_IFIFO: 5112 5112 - strscpy(pdev.type, "LnxFIFO"); 5141 5141 + type_len = 8; 5142 5142 + strscpy(type, "LnxFIFO"); 5143 5143 + data = (u8 *)&pdev; 5144 5144 + data_len = sizeof(pdev); 5113 5145 break; 5114 5146 default: 5115 5115 - return -EPERM; 5147 5147 + rc = -EPERM; 5148 5148 + goto out; 5116 5149 } 5117 5150 5118 5151 oparms = CIFS_OPARMS(cifs_sb, tcon, full_path, GENERIC_WRITE, ··· 5156 5121 5157 5122 rc = server->ops->open(xid, &oparms, &oplock, NULL); 5158 5123 if (rc) 5159 5159 - return rc; 5124 5124 + goto out; 5160 5125 5161 5161 - io_parms.pid = current->tgid; 5162 5162 - io_parms.tcon = tcon; 5163 5163 - io_parms.length = sizeof(pdev); 5164 5164 - iov[1].iov_base = &pdev; 5165 5165 - iov[1].iov_len = sizeof(pdev); 5126 5126 + if (type_len + data_len > 0) { 5127 5127 + io_parms.pid = current->tgid; 5128 5128 + io_parms.tcon = tcon; 5129 5129 + io_parms.length = type_len + data_len; 5130 5130 + iov[1].iov_base = type; 5131 5131 + iov[1].iov_len = type_len; 5132 5132 + iov[2].iov_base = data; 5133 5133 + iov[2].iov_len = data_len; 5166 5134 5167 5167 - rc = server->ops->sync_write(xid, &fid, &io_parms, 5168 5168 - &bytes_written, iov, 1); 5135 5135 + rc = server->ops->sync_write(xid, &fid, &io_parms, 5136 5136 + &bytes_written, 5137 5137 + iov, ARRAY_SIZE(iov)-1); 5138 5138 + } 5139 5139 + 5169 5140 server->ops->close(xid, tcon, &fid); 5141 5141 + 5142 5142 + out: 5143 5143 + kfree(symname_utf16); 5170 5144 return rc; 5171 5145 } 5172 5146 ··· 5187 5143 int rc; 5188 5144 5189 5145 rc = __cifs_sfu_make_node(xid, inode, dentry, tcon, 5190 5190 - full_path, mode, dev); 5146 5146 + full_path, mode, dev, NULL); 5191 5147 if (rc) 5192 5148 return rc; 5193 5149 ··· 5216 5172 /* 5217 5173 * Check if mounted with mount parm 'sfu' mount parm. 5218 5174 * SFU emulation should work with all servers, but only 5219 5219 - * supports block and char device (no socket & fifo), 5175 5175 + * supports block and char device, socket & fifo, 5220 5176 * and was used by default in earlier versions of Windows 5221 5177 */ 5222 5178 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {

+12 -7

fs/smb/client/smb2pdu.c

reviewed

··· 32 32 #include "cifs_unicode.h" 33 33 #include "cifs_debug.h" 34 34 #include "ntlmssp.h" 35 35 - #include "smb2status.h" 35 35 + #include "../common/smb2status.h" 36 36 #include "smb2glob.h" 37 37 #include "cifspdu.h" 38 38 #include "cifs_spnego.h" ··· 42 42 #include "dfs_cache.h" 43 43 #endif 44 44 #include "cached_dir.h" 45 45 + #include "compress.h" 45 46 46 47 /* 47 48 * The following table defines the expected "StructureSize" of SMB2 requests ··· 2624 2623 unsigned int group_offset = 0; 2625 2624 struct smb3_acl acl = {}; 2626 2625 2627 2627 - *len = round_up(sizeof(struct crt_sd_ctxt) + (sizeof(struct cifs_ace) * 4), 8); 2626 2626 + *len = round_up(sizeof(struct crt_sd_ctxt) + (sizeof(struct smb_ace) * 4), 8); 2628 2627 2629 2628 if (set_owner) { 2630 2629 /* sizeof(struct owner_group_sids) is already multiple of 8 so no need to round */ ··· 2673 2672 ptr += sizeof(struct smb3_acl); 2674 2673 2675 2674 /* create one ACE to hold the mode embedded in reserved special SID */ 2676 2676 - acelen = setup_special_mode_ACE((struct cifs_ace *)ptr, (__u64)mode); 2675 2675 + acelen = setup_special_mode_ACE((struct smb_ace *)ptr, (__u64)mode); 2677 2676 ptr += acelen; 2678 2677 acl_size = acelen + sizeof(struct smb3_acl); 2679 2678 ace_count = 1; 2680 2679 2681 2680 if (set_owner) { 2682 2681 /* we do not need to reallocate buffer to add the two more ACEs. plenty of space */ 2683 2683 - acelen = setup_special_user_owner_ACE((struct cifs_ace *)ptr); 2682 2682 + acelen = setup_special_user_owner_ACE((struct smb_ace *)ptr); 2684 2683 ptr += acelen; 2685 2684 acl_size += acelen; 2686 2685 ace_count += 1; 2687 2686 } 2688 2687 2689 2688 /* and one more ACE to allow access for authenticated users */ 2690 2690 - acelen = setup_authusers_ACE((struct cifs_ace *)ptr); 2689 2689 + acelen = setup_authusers_ACE((struct smb_ace *)ptr); 2691 2690 ptr += acelen; 2692 2691 acl_size += acelen; 2693 2692 ace_count += 1; ··· 3907 3906 u64 persistent_fid, u64 volatile_fid, struct smb311_posix_qinfo *data, u32 *plen) 3908 3907 { 3909 3908 size_t output_len = sizeof(struct smb311_posix_qinfo *) + 3910 3910 - (sizeof(struct cifs_sid) * 2) + (PATH_MAX * 2); 3909 3909 + (sizeof(struct smb_sid) * 2) + (PATH_MAX * 2); 3911 3910 *plen = 0; 3912 3911 3913 3912 return query_info(xid, tcon, persistent_fid, volatile_fid, ··· 5024 5023 flags |= CIFS_HAS_CREDITS; 5025 5024 } 5026 5025 5026 5026 + /* XXX: compression + encryption is unsupported for now */ 5027 5027 + if (((flags & CIFS_TRANSFORM_REQ) != CIFS_TRANSFORM_REQ) && should_compress(tcon, &rqst)) 5028 5028 + flags |= CIFS_COMPRESS_REQ; 5029 5029 + 5027 5030 rc = cifs_call_async(server, &rqst, NULL, smb2_writev_callback, NULL, 5028 5031 wdata, flags, &wdata->credits); 5029 5032 /* Can't touch wdata if rc == 0 */ ··· 5691 5686 int 5692 5687 SMB2_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 5693 5688 u64 persistent_fid, u64 volatile_fid, 5694 5694 - struct cifs_ntsd *pnntsd, int pacllen, int aclflag) 5689 5689 + struct smb_ntsd *pnntsd, int pacllen, int aclflag) 5695 5690 { 5696 5691 return send_set_info(xid, tcon, persistent_fid, volatile_fid, 5697 5692 current->tgid, 0, SMB2_O_INFO_SECURITY, aclflag,

+4 -4

fs/smb/client/smb2pdu.h

reviewed

··· 364 364 u32 nlink; 365 365 u32 reparse_tag; 366 366 u32 mode; 367 367 - struct cifs_sid owner; /* var-sized on the wire */ 368 368 - struct cifs_sid group; /* var-sized on the wire */ 367 367 + struct smb_sid owner; /* var-sized on the wire */ 368 368 + struct smb_sid group; /* var-sized on the wire */ 369 369 } __packed; 370 370 371 371 #define SMB2_QUERY_DIRECTORY_IOV_SIZE 2 ··· 408 408 struct smb2_posix_info_parsed { 409 409 const struct smb2_posix_info *base; 410 410 size_t size; 411 411 - struct cifs_sid owner; 412 412 - struct cifs_sid group; 411 411 + struct smb_sid owner; 412 412 + struct smb_sid group; 413 413 int name_len; 414 414 const u8 *name; 415 415 };

+1 -1

fs/smb/client/smb2proto.h

reviewed

··· 238 238 extern void SMB2_set_info_free(struct smb_rqst *rqst); 239 239 extern int SMB2_set_acl(const unsigned int xid, struct cifs_tcon *tcon, 240 240 u64 persistent_fid, u64 volatile_fid, 241 241 - struct cifs_ntsd *pnntsd, int pacllen, int aclflag); 241 241 + struct smb_ntsd *pnntsd, int pacllen, int aclflag); 242 242 extern int SMB2_set_ea(const unsigned int xid, struct cifs_tcon *tcon, 243 243 u64 persistent_fid, u64 volatile_fid, 244 244 struct smb2_file_full_ea_info *buf, int len);

-1771

fs/smb/client/smb2status.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: LGPL-2.1 */ 2 2 - /* 3 3 - * 4 4 - * SMB2 Status code (network error) definitions 5 5 - * Definitions are from MS-ERREF 6 6 - * 7 7 - * Copyright (c) International Business Machines Corp., 2009,2011 8 8 - * Author(s): Steve French (sfrench@us.ibm.com) 9 9 - * 10 10 - */ 11 11 - 12 12 - /* 13 13 - * 0 1 2 3 4 5 6 7 8 9 0 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F 14 14 - * SEV C N <-------Facility--------> <------Error Status Code------> 15 15 - * 16 16 - * C is set if "customer defined" error, N bit is reserved and MBZ 17 17 - */ 18 18 - 19 19 - #define STATUS_SEVERITY_SUCCESS __constant_cpu_to_le32(0x0000) 20 20 - #define STATUS_SEVERITY_INFORMATIONAL cpu_to_le32(0x0001) 21 21 - #define STATUS_SEVERITY_WARNING cpu_to_le32(0x0002) 22 22 - #define STATUS_SEVERITY_ERROR cpu_to_le32(0x0003) 23 23 - 24 24 - struct ntstatus { 25 25 - /* Facility is the high 12 bits of the following field */ 26 26 - __le32 Facility; /* low 2 bits Severity, next is Customer, then rsrvd */ 27 27 - __le32 Code; 28 28 - }; 29 29 - 30 30 - #define STATUS_SUCCESS cpu_to_le32(0x00000000) 31 31 - #define STATUS_WAIT_0 cpu_to_le32(0x00000000) 32 32 - #define STATUS_WAIT_1 cpu_to_le32(0x00000001) 33 33 - #define STATUS_WAIT_2 cpu_to_le32(0x00000002) 34 34 - #define STATUS_WAIT_3 cpu_to_le32(0x00000003) 35 35 - #define STATUS_WAIT_63 cpu_to_le32(0x0000003F) 36 36 - #define STATUS_ABANDONED cpu_to_le32(0x00000080) 37 37 - #define STATUS_ABANDONED_WAIT_0 cpu_to_le32(0x00000080) 38 38 - #define STATUS_ABANDONED_WAIT_63 cpu_to_le32(0x000000BF) 39 39 - #define STATUS_USER_APC cpu_to_le32(0x000000C0) 40 40 - #define STATUS_KERNEL_APC cpu_to_le32(0x00000100) 41 41 - #define STATUS_ALERTED cpu_to_le32(0x00000101) 42 42 - #define STATUS_TIMEOUT cpu_to_le32(0x00000102) 43 43 - #define STATUS_PENDING cpu_to_le32(0x00000103) 44 44 - #define STATUS_REPARSE cpu_to_le32(0x00000104) 45 45 - #define STATUS_MORE_ENTRIES cpu_to_le32(0x00000105) 46 46 - #define STATUS_NOT_ALL_ASSIGNED cpu_to_le32(0x00000106) 47 47 - #define STATUS_SOME_NOT_MAPPED cpu_to_le32(0x00000107) 48 48 - #define STATUS_OPLOCK_BREAK_IN_PROGRESS cpu_to_le32(0x00000108) 49 49 - #define STATUS_VOLUME_MOUNTED cpu_to_le32(0x00000109) 50 50 - #define STATUS_RXACT_COMMITTED cpu_to_le32(0x0000010A) 51 51 - #define STATUS_NOTIFY_CLEANUP cpu_to_le32(0x0000010B) 52 52 - #define STATUS_NOTIFY_ENUM_DIR cpu_to_le32(0x0000010C) 53 53 - #define STATUS_NO_QUOTAS_FOR_ACCOUNT cpu_to_le32(0x0000010D) 54 54 - #define STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED cpu_to_le32(0x0000010E) 55 55 - #define STATUS_PAGE_FAULT_TRANSITION cpu_to_le32(0x00000110) 56 56 - #define STATUS_PAGE_FAULT_DEMAND_ZERO cpu_to_le32(0x00000111) 57 57 - #define STATUS_PAGE_FAULT_COPY_ON_WRITE cpu_to_le32(0x00000112) 58 58 - #define STATUS_PAGE_FAULT_GUARD_PAGE cpu_to_le32(0x00000113) 59 59 - #define STATUS_PAGE_FAULT_PAGING_FILE cpu_to_le32(0x00000114) 60 60 - #define STATUS_CACHE_PAGE_LOCKED cpu_to_le32(0x00000115) 61 61 - #define STATUS_CRASH_DUMP cpu_to_le32(0x00000116) 62 62 - #define STATUS_BUFFER_ALL_ZEROS cpu_to_le32(0x00000117) 63 63 - #define STATUS_REPARSE_OBJECT cpu_to_le32(0x00000118) 64 64 - #define STATUS_RESOURCE_REQUIREMENTS_CHANGED cpu_to_le32(0x00000119) 65 65 - #define STATUS_TRANSLATION_COMPLETE cpu_to_le32(0x00000120) 66 66 - #define STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY cpu_to_le32(0x00000121) 67 67 - #define STATUS_NOTHING_TO_TERMINATE cpu_to_le32(0x00000122) 68 68 - #define STATUS_PROCESS_NOT_IN_JOB cpu_to_le32(0x00000123) 69 69 - #define STATUS_PROCESS_IN_JOB cpu_to_le32(0x00000124) 70 70 - #define STATUS_VOLSNAP_HIBERNATE_READY cpu_to_le32(0x00000125) 71 71 - #define STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY cpu_to_le32(0x00000126) 72 72 - #define STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED cpu_to_le32(0x00000127) 73 73 - #define STATUS_INTERRUPT_STILL_CONNECTED cpu_to_le32(0x00000128) 74 74 - #define STATUS_PROCESS_CLONED cpu_to_le32(0x00000129) 75 75 - #define STATUS_FILE_LOCKED_WITH_ONLY_READERS cpu_to_le32(0x0000012A) 76 76 - #define STATUS_FILE_LOCKED_WITH_WRITERS cpu_to_le32(0x0000012B) 77 77 - #define STATUS_RESOURCEMANAGER_READ_ONLY cpu_to_le32(0x00000202) 78 78 - #define STATUS_WAIT_FOR_OPLOCK cpu_to_le32(0x00000367) 79 79 - #define DBG_EXCEPTION_HANDLED cpu_to_le32(0x00010001) 80 80 - #define DBG_CONTINUE cpu_to_le32(0x00010002) 81 81 - #define STATUS_FLT_IO_COMPLETE cpu_to_le32(0x001C0001) 82 82 - #define STATUS_OBJECT_NAME_EXISTS cpu_to_le32(0x40000000) 83 83 - #define STATUS_THREAD_WAS_SUSPENDED cpu_to_le32(0x40000001) 84 84 - #define STATUS_WORKING_SET_LIMIT_RANGE cpu_to_le32(0x40000002) 85 85 - #define STATUS_IMAGE_NOT_AT_BASE cpu_to_le32(0x40000003) 86 86 - #define STATUS_RXACT_STATE_CREATED cpu_to_le32(0x40000004) 87 87 - #define STATUS_SEGMENT_NOTIFICATION cpu_to_le32(0x40000005) 88 88 - #define STATUS_LOCAL_USER_SESSION_KEY cpu_to_le32(0x40000006) 89 89 - #define STATUS_BAD_CURRENT_DIRECTORY cpu_to_le32(0x40000007) 90 90 - #define STATUS_SERIAL_MORE_WRITES cpu_to_le32(0x40000008) 91 91 - #define STATUS_REGISTRY_RECOVERED cpu_to_le32(0x40000009) 92 92 - #define STATUS_FT_READ_RECOVERY_FROM_BACKUP cpu_to_le32(0x4000000A) 93 93 - #define STATUS_FT_WRITE_RECOVERY cpu_to_le32(0x4000000B) 94 94 - #define STATUS_SERIAL_COUNTER_TIMEOUT cpu_to_le32(0x4000000C) 95 95 - #define STATUS_NULL_LM_PASSWORD cpu_to_le32(0x4000000D) 96 96 - #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH cpu_to_le32(0x4000000E) 97 97 - #define STATUS_RECEIVE_PARTIAL cpu_to_le32(0x4000000F) 98 98 - #define STATUS_RECEIVE_EXPEDITED cpu_to_le32(0x40000010) 99 99 - #define STATUS_RECEIVE_PARTIAL_EXPEDITED cpu_to_le32(0x40000011) 100 100 - #define STATUS_EVENT_DONE cpu_to_le32(0x40000012) 101 101 - #define STATUS_EVENT_PENDING cpu_to_le32(0x40000013) 102 102 - #define STATUS_CHECKING_FILE_SYSTEM cpu_to_le32(0x40000014) 103 103 - #define STATUS_FATAL_APP_EXIT cpu_to_le32(0x40000015) 104 104 - #define STATUS_PREDEFINED_HANDLE cpu_to_le32(0x40000016) 105 105 - #define STATUS_WAS_UNLOCKED cpu_to_le32(0x40000017) 106 106 - #define STATUS_SERVICE_NOTIFICATION cpu_to_le32(0x40000018) 107 107 - #define STATUS_WAS_LOCKED cpu_to_le32(0x40000019) 108 108 - #define STATUS_LOG_HARD_ERROR cpu_to_le32(0x4000001A) 109 109 - #define STATUS_ALREADY_WIN32 cpu_to_le32(0x4000001B) 110 110 - #define STATUS_WX86_UNSIMULATE cpu_to_le32(0x4000001C) 111 111 - #define STATUS_WX86_CONTINUE cpu_to_le32(0x4000001D) 112 112 - #define STATUS_WX86_SINGLE_STEP cpu_to_le32(0x4000001E) 113 113 - #define STATUS_WX86_BREAKPOINT cpu_to_le32(0x4000001F) 114 114 - #define STATUS_WX86_EXCEPTION_CONTINUE cpu_to_le32(0x40000020) 115 115 - #define STATUS_WX86_EXCEPTION_LASTCHANCE cpu_to_le32(0x40000021) 116 116 - #define STATUS_WX86_EXCEPTION_CHAIN cpu_to_le32(0x40000022) 117 117 - #define STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE cpu_to_le32(0x40000023) 118 118 - #define STATUS_NO_YIELD_PERFORMED cpu_to_le32(0x40000024) 119 119 - #define STATUS_TIMER_RESUME_IGNORED cpu_to_le32(0x40000025) 120 120 - #define STATUS_ARBITRATION_UNHANDLED cpu_to_le32(0x40000026) 121 121 - #define STATUS_CARDBUS_NOT_SUPPORTED cpu_to_le32(0x40000027) 122 122 - #define STATUS_WX86_CREATEWX86TIB cpu_to_le32(0x40000028) 123 123 - #define STATUS_MP_PROCESSOR_MISMATCH cpu_to_le32(0x40000029) 124 124 - #define STATUS_HIBERNATED cpu_to_le32(0x4000002A) 125 125 - #define STATUS_RESUME_HIBERNATION cpu_to_le32(0x4000002B) 126 126 - #define STATUS_FIRMWARE_UPDATED cpu_to_le32(0x4000002C) 127 127 - #define STATUS_DRIVERS_LEAKING_LOCKED_PAGES cpu_to_le32(0x4000002D) 128 128 - #define STATUS_MESSAGE_RETRIEVED cpu_to_le32(0x4000002E) 129 129 - #define STATUS_SYSTEM_POWERSTATE_TRANSITION cpu_to_le32(0x4000002F) 130 130 - #define STATUS_ALPC_CHECK_COMPLETION_LIST cpu_to_le32(0x40000030) 131 131 - #define STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION cpu_to_le32(0x40000031) 132 132 - #define STATUS_ACCESS_AUDIT_BY_POLICY cpu_to_le32(0x40000032) 133 133 - #define STATUS_ABANDON_HIBERFILE cpu_to_le32(0x40000033) 134 134 - #define STATUS_BIZRULES_NOT_ENABLED cpu_to_le32(0x40000034) 135 135 - #define STATUS_WAKE_SYSTEM cpu_to_le32(0x40000294) 136 136 - #define STATUS_DS_SHUTTING_DOWN cpu_to_le32(0x40000370) 137 137 - #define DBG_REPLY_LATER cpu_to_le32(0x40010001) 138 138 - #define DBG_UNABLE_TO_PROVIDE_HANDLE cpu_to_le32(0x40010002) 139 139 - #define DBG_TERMINATE_THREAD cpu_to_le32(0x40010003) 140 140 - #define DBG_TERMINATE_PROCESS cpu_to_le32(0x40010004) 141 141 - #define DBG_CONTROL_C cpu_to_le32(0x40010005) 142 142 - #define DBG_PRINTEXCEPTION_C cpu_to_le32(0x40010006) 143 143 - #define DBG_RIPEXCEPTION cpu_to_le32(0x40010007) 144 144 - #define DBG_CONTROL_BREAK cpu_to_le32(0x40010008) 145 145 - #define DBG_COMMAND_EXCEPTION cpu_to_le32(0x40010009) 146 146 - #define RPC_NT_UUID_LOCAL_ONLY cpu_to_le32(0x40020056) 147 147 - #define RPC_NT_SEND_INCOMPLETE cpu_to_le32(0x400200AF) 148 148 - #define STATUS_CTX_CDM_CONNECT cpu_to_le32(0x400A0004) 149 149 - #define STATUS_CTX_CDM_DISCONNECT cpu_to_le32(0x400A0005) 150 150 - #define STATUS_SXS_RELEASE_ACTIVATION_CONTEXT cpu_to_le32(0x4015000D) 151 151 - #define STATUS_RECOVERY_NOT_NEEDED cpu_to_le32(0x40190034) 152 152 - #define STATUS_RM_ALREADY_STARTED cpu_to_le32(0x40190035) 153 153 - #define STATUS_LOG_NO_RESTART cpu_to_le32(0x401A000C) 154 154 - #define STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST cpu_to_le32(0x401B00EC) 155 155 - #define STATUS_GRAPHICS_PARTIAL_DATA_POPULATED cpu_to_le32(0x401E000A) 156 156 - #define STATUS_GRAPHICS_DRIVER_MISMATCH cpu_to_le32(0x401E0117) 157 157 - #define STATUS_GRAPHICS_MODE_NOT_PINNED cpu_to_le32(0x401E0307) 158 158 - #define STATUS_GRAPHICS_NO_PREFERRED_MODE cpu_to_le32(0x401E031E) 159 159 - #define STATUS_GRAPHICS_DATASET_IS_EMPTY cpu_to_le32(0x401E034B) 160 160 - #define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET cpu_to_le32(0x401E034C) 161 161 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED cpu_to_le32(0x401E0351) 162 162 - #define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS cpu_to_le32(0x401E042F) 163 163 - #define STATUS_GRAPHICS_LEADLINK_START_DEFERRED cpu_to_le32(0x401E0437) 164 164 - #define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY cpu_to_le32(0x401E0439) 165 165 - #define STATUS_GRAPHICS_START_DEFERRED cpu_to_le32(0x401E043A) 166 166 - #define STATUS_NDIS_INDICATION_REQUIRED cpu_to_le32(0x40230001) 167 167 - #define STATUS_GUARD_PAGE_VIOLATION cpu_to_le32(0x80000001) 168 168 - #define STATUS_DATATYPE_MISALIGNMENT cpu_to_le32(0x80000002) 169 169 - #define STATUS_BREAKPOINT cpu_to_le32(0x80000003) 170 170 - #define STATUS_SINGLE_STEP cpu_to_le32(0x80000004) 171 171 - #define STATUS_BUFFER_OVERFLOW cpu_to_le32(0x80000005) 172 172 - #define STATUS_NO_MORE_FILES cpu_to_le32(0x80000006) 173 173 - #define STATUS_WAKE_SYSTEM_DEBUGGER cpu_to_le32(0x80000007) 174 174 - #define STATUS_HANDLES_CLOSED cpu_to_le32(0x8000000A) 175 175 - #define STATUS_NO_INHERITANCE cpu_to_le32(0x8000000B) 176 176 - #define STATUS_GUID_SUBSTITUTION_MADE cpu_to_le32(0x8000000C) 177 177 - #define STATUS_PARTIAL_COPY cpu_to_le32(0x8000000D) 178 178 - #define STATUS_DEVICE_PAPER_EMPTY cpu_to_le32(0x8000000E) 179 179 - #define STATUS_DEVICE_POWERED_OFF cpu_to_le32(0x8000000F) 180 180 - #define STATUS_DEVICE_OFF_LINE cpu_to_le32(0x80000010) 181 181 - #define STATUS_DEVICE_BUSY cpu_to_le32(0x80000011) 182 182 - #define STATUS_NO_MORE_EAS cpu_to_le32(0x80000012) 183 183 - #define STATUS_INVALID_EA_NAME cpu_to_le32(0x80000013) 184 184 - #define STATUS_EA_LIST_INCONSISTENT cpu_to_le32(0x80000014) 185 185 - #define STATUS_INVALID_EA_FLAG cpu_to_le32(0x80000015) 186 186 - #define STATUS_VERIFY_REQUIRED cpu_to_le32(0x80000016) 187 187 - #define STATUS_EXTRANEOUS_INFORMATION cpu_to_le32(0x80000017) 188 188 - #define STATUS_RXACT_COMMIT_NECESSARY cpu_to_le32(0x80000018) 189 189 - #define STATUS_NO_MORE_ENTRIES cpu_to_le32(0x8000001A) 190 190 - #define STATUS_FILEMARK_DETECTED cpu_to_le32(0x8000001B) 191 191 - #define STATUS_MEDIA_CHANGED cpu_to_le32(0x8000001C) 192 192 - #define STATUS_BUS_RESET cpu_to_le32(0x8000001D) 193 193 - #define STATUS_END_OF_MEDIA cpu_to_le32(0x8000001E) 194 194 - #define STATUS_BEGINNING_OF_MEDIA cpu_to_le32(0x8000001F) 195 195 - #define STATUS_MEDIA_CHECK cpu_to_le32(0x80000020) 196 196 - #define STATUS_SETMARK_DETECTED cpu_to_le32(0x80000021) 197 197 - #define STATUS_NO_DATA_DETECTED cpu_to_le32(0x80000022) 198 198 - #define STATUS_REDIRECTOR_HAS_OPEN_HANDLES cpu_to_le32(0x80000023) 199 199 - #define STATUS_SERVER_HAS_OPEN_HANDLES cpu_to_le32(0x80000024) 200 200 - #define STATUS_ALREADY_DISCONNECTED cpu_to_le32(0x80000025) 201 201 - #define STATUS_LONGJUMP cpu_to_le32(0x80000026) 202 202 - #define STATUS_CLEANER_CARTRIDGE_INSTALLED cpu_to_le32(0x80000027) 203 203 - #define STATUS_PLUGPLAY_QUERY_VETOED cpu_to_le32(0x80000028) 204 204 - #define STATUS_UNWIND_CONSOLIDATE cpu_to_le32(0x80000029) 205 205 - #define STATUS_REGISTRY_HIVE_RECOVERED cpu_to_le32(0x8000002A) 206 206 - #define STATUS_DLL_MIGHT_BE_INSECURE cpu_to_le32(0x8000002B) 207 207 - #define STATUS_DLL_MIGHT_BE_INCOMPATIBLE cpu_to_le32(0x8000002C) 208 208 - #define STATUS_STOPPED_ON_SYMLINK cpu_to_le32(0x8000002D) 209 209 - #define STATUS_DEVICE_REQUIRES_CLEANING cpu_to_le32(0x80000288) 210 210 - #define STATUS_DEVICE_DOOR_OPEN cpu_to_le32(0x80000289) 211 211 - #define STATUS_DATA_LOST_REPAIR cpu_to_le32(0x80000803) 212 212 - #define DBG_EXCEPTION_NOT_HANDLED cpu_to_le32(0x80010001) 213 213 - #define STATUS_CLUSTER_NODE_ALREADY_UP cpu_to_le32(0x80130001) 214 214 - #define STATUS_CLUSTER_NODE_ALREADY_DOWN cpu_to_le32(0x80130002) 215 215 - #define STATUS_CLUSTER_NETWORK_ALREADY_ONLINE cpu_to_le32(0x80130003) 216 216 - #define STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE cpu_to_le32(0x80130004) 217 217 - #define STATUS_CLUSTER_NODE_ALREADY_MEMBER cpu_to_le32(0x80130005) 218 218 - #define STATUS_COULD_NOT_RESIZE_LOG cpu_to_le32(0x80190009) 219 219 - #define STATUS_NO_TXF_METADATA cpu_to_le32(0x80190029) 220 220 - #define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN cpu_to_le32(0x80190031) 221 221 - #define STATUS_TXF_METADATA_ALREADY_PRESENT cpu_to_le32(0x80190041) 222 222 - #define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET cpu_to_le32(0x80190042) 223 223 - #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED cpu_to_le32(0x801B00EB) 224 224 - #define STATUS_FLT_BUFFER_TOO_SMALL cpu_to_le32(0x801C0001) 225 225 - #define STATUS_FVE_PARTIAL_METADATA cpu_to_le32(0x80210001) 226 226 - #define STATUS_UNSUCCESSFUL cpu_to_le32(0xC0000001) 227 227 - #define STATUS_NOT_IMPLEMENTED cpu_to_le32(0xC0000002) 228 228 - #define STATUS_INVALID_INFO_CLASS cpu_to_le32(0xC0000003) 229 229 - #define STATUS_INFO_LENGTH_MISMATCH cpu_to_le32(0xC0000004) 230 230 - #define STATUS_ACCESS_VIOLATION cpu_to_le32(0xC0000005) 231 231 - #define STATUS_IN_PAGE_ERROR cpu_to_le32(0xC0000006) 232 232 - #define STATUS_PAGEFILE_QUOTA cpu_to_le32(0xC0000007) 233 233 - #define STATUS_INVALID_HANDLE cpu_to_le32(0xC0000008) 234 234 - #define STATUS_BAD_INITIAL_STACK cpu_to_le32(0xC0000009) 235 235 - #define STATUS_BAD_INITIAL_PC cpu_to_le32(0xC000000A) 236 236 - #define STATUS_INVALID_CID cpu_to_le32(0xC000000B) 237 237 - #define STATUS_TIMER_NOT_CANCELED cpu_to_le32(0xC000000C) 238 238 - #define STATUS_INVALID_PARAMETER cpu_to_le32(0xC000000D) 239 239 - #define STATUS_NO_SUCH_DEVICE cpu_to_le32(0xC000000E) 240 240 - #define STATUS_NO_SUCH_FILE cpu_to_le32(0xC000000F) 241 241 - #define STATUS_INVALID_DEVICE_REQUEST cpu_to_le32(0xC0000010) 242 242 - #define STATUS_END_OF_FILE cpu_to_le32(0xC0000011) 243 243 - #define STATUS_WRONG_VOLUME cpu_to_le32(0xC0000012) 244 244 - #define STATUS_NO_MEDIA_IN_DEVICE cpu_to_le32(0xC0000013) 245 245 - #define STATUS_UNRECOGNIZED_MEDIA cpu_to_le32(0xC0000014) 246 246 - #define STATUS_NONEXISTENT_SECTOR cpu_to_le32(0xC0000015) 247 247 - #define STATUS_MORE_PROCESSING_REQUIRED cpu_to_le32(0xC0000016) 248 248 - #define STATUS_NO_MEMORY cpu_to_le32(0xC0000017) 249 249 - #define STATUS_CONFLICTING_ADDRESSES cpu_to_le32(0xC0000018) 250 250 - #define STATUS_NOT_MAPPED_VIEW cpu_to_le32(0xC0000019) 251 251 - #define STATUS_UNABLE_TO_FREE_VM cpu_to_le32(0xC000001A) 252 252 - #define STATUS_UNABLE_TO_DELETE_SECTION cpu_to_le32(0xC000001B) 253 253 - #define STATUS_INVALID_SYSTEM_SERVICE cpu_to_le32(0xC000001C) 254 254 - #define STATUS_ILLEGAL_INSTRUCTION cpu_to_le32(0xC000001D) 255 255 - #define STATUS_INVALID_LOCK_SEQUENCE cpu_to_le32(0xC000001E) 256 256 - #define STATUS_INVALID_VIEW_SIZE cpu_to_le32(0xC000001F) 257 257 - #define STATUS_INVALID_FILE_FOR_SECTION cpu_to_le32(0xC0000020) 258 258 - #define STATUS_ALREADY_COMMITTED cpu_to_le32(0xC0000021) 259 259 - #define STATUS_ACCESS_DENIED cpu_to_le32(0xC0000022) 260 260 - #define STATUS_BUFFER_TOO_SMALL cpu_to_le32(0xC0000023) 261 261 - #define STATUS_OBJECT_TYPE_MISMATCH cpu_to_le32(0xC0000024) 262 262 - #define STATUS_NONCONTINUABLE_EXCEPTION cpu_to_le32(0xC0000025) 263 263 - #define STATUS_INVALID_DISPOSITION cpu_to_le32(0xC0000026) 264 264 - #define STATUS_UNWIND cpu_to_le32(0xC0000027) 265 265 - #define STATUS_BAD_STACK cpu_to_le32(0xC0000028) 266 266 - #define STATUS_INVALID_UNWIND_TARGET cpu_to_le32(0xC0000029) 267 267 - #define STATUS_NOT_LOCKED cpu_to_le32(0xC000002A) 268 268 - #define STATUS_PARITY_ERROR cpu_to_le32(0xC000002B) 269 269 - #define STATUS_UNABLE_TO_DECOMMIT_VM cpu_to_le32(0xC000002C) 270 270 - #define STATUS_NOT_COMMITTED cpu_to_le32(0xC000002D) 271 271 - #define STATUS_INVALID_PORT_ATTRIBUTES cpu_to_le32(0xC000002E) 272 272 - #define STATUS_PORT_MESSAGE_TOO_LONG cpu_to_le32(0xC000002F) 273 273 - #define STATUS_INVALID_PARAMETER_MIX cpu_to_le32(0xC0000030) 274 274 - #define STATUS_INVALID_QUOTA_LOWER cpu_to_le32(0xC0000031) 275 275 - #define STATUS_DISK_CORRUPT_ERROR cpu_to_le32(0xC0000032) 276 276 - #define STATUS_OBJECT_NAME_INVALID cpu_to_le32(0xC0000033) 277 277 - #define STATUS_OBJECT_NAME_NOT_FOUND cpu_to_le32(0xC0000034) 278 278 - #define STATUS_OBJECT_NAME_COLLISION cpu_to_le32(0xC0000035) 279 279 - #define STATUS_PORT_DISCONNECTED cpu_to_le32(0xC0000037) 280 280 - #define STATUS_DEVICE_ALREADY_ATTACHED cpu_to_le32(0xC0000038) 281 281 - #define STATUS_OBJECT_PATH_INVALID cpu_to_le32(0xC0000039) 282 282 - #define STATUS_OBJECT_PATH_NOT_FOUND cpu_to_le32(0xC000003A) 283 283 - #define STATUS_OBJECT_PATH_SYNTAX_BAD cpu_to_le32(0xC000003B) 284 284 - #define STATUS_DATA_OVERRUN cpu_to_le32(0xC000003C) 285 285 - #define STATUS_DATA_LATE_ERROR cpu_to_le32(0xC000003D) 286 286 - #define STATUS_DATA_ERROR cpu_to_le32(0xC000003E) 287 287 - #define STATUS_CRC_ERROR cpu_to_le32(0xC000003F) 288 288 - #define STATUS_SECTION_TOO_BIG cpu_to_le32(0xC0000040) 289 289 - #define STATUS_PORT_CONNECTION_REFUSED cpu_to_le32(0xC0000041) 290 290 - #define STATUS_INVALID_PORT_HANDLE cpu_to_le32(0xC0000042) 291 291 - #define STATUS_SHARING_VIOLATION cpu_to_le32(0xC0000043) 292 292 - #define STATUS_QUOTA_EXCEEDED cpu_to_le32(0xC0000044) 293 293 - #define STATUS_INVALID_PAGE_PROTECTION cpu_to_le32(0xC0000045) 294 294 - #define STATUS_MUTANT_NOT_OWNED cpu_to_le32(0xC0000046) 295 295 - #define STATUS_SEMAPHORE_LIMIT_EXCEEDED cpu_to_le32(0xC0000047) 296 296 - #define STATUS_PORT_ALREADY_SET cpu_to_le32(0xC0000048) 297 297 - #define STATUS_SECTION_NOT_IMAGE cpu_to_le32(0xC0000049) 298 298 - #define STATUS_SUSPEND_COUNT_EXCEEDED cpu_to_le32(0xC000004A) 299 299 - #define STATUS_THREAD_IS_TERMINATING cpu_to_le32(0xC000004B) 300 300 - #define STATUS_BAD_WORKING_SET_LIMIT cpu_to_le32(0xC000004C) 301 301 - #define STATUS_INCOMPATIBLE_FILE_MAP cpu_to_le32(0xC000004D) 302 302 - #define STATUS_SECTION_PROTECTION cpu_to_le32(0xC000004E) 303 303 - #define STATUS_EAS_NOT_SUPPORTED cpu_to_le32(0xC000004F) 304 304 - #define STATUS_EA_TOO_LARGE cpu_to_le32(0xC0000050) 305 305 - #define STATUS_NONEXISTENT_EA_ENTRY cpu_to_le32(0xC0000051) 306 306 - #define STATUS_NO_EAS_ON_FILE cpu_to_le32(0xC0000052) 307 307 - #define STATUS_EA_CORRUPT_ERROR cpu_to_le32(0xC0000053) 308 308 - #define STATUS_FILE_LOCK_CONFLICT cpu_to_le32(0xC0000054) 309 309 - #define STATUS_LOCK_NOT_GRANTED cpu_to_le32(0xC0000055) 310 310 - #define STATUS_DELETE_PENDING cpu_to_le32(0xC0000056) 311 311 - #define STATUS_CTL_FILE_NOT_SUPPORTED cpu_to_le32(0xC0000057) 312 312 - #define STATUS_UNKNOWN_REVISION cpu_to_le32(0xC0000058) 313 313 - #define STATUS_REVISION_MISMATCH cpu_to_le32(0xC0000059) 314 314 - #define STATUS_INVALID_OWNER cpu_to_le32(0xC000005A) 315 315 - #define STATUS_INVALID_PRIMARY_GROUP cpu_to_le32(0xC000005B) 316 316 - #define STATUS_NO_IMPERSONATION_TOKEN cpu_to_le32(0xC000005C) 317 317 - #define STATUS_CANT_DISABLE_MANDATORY cpu_to_le32(0xC000005D) 318 318 - #define STATUS_NO_LOGON_SERVERS cpu_to_le32(0xC000005E) 319 319 - #define STATUS_NO_SUCH_LOGON_SESSION cpu_to_le32(0xC000005F) 320 320 - #define STATUS_NO_SUCH_PRIVILEGE cpu_to_le32(0xC0000060) 321 321 - #define STATUS_PRIVILEGE_NOT_HELD cpu_to_le32(0xC0000061) 322 322 - #define STATUS_INVALID_ACCOUNT_NAME cpu_to_le32(0xC0000062) 323 323 - #define STATUS_USER_EXISTS cpu_to_le32(0xC0000063) 324 324 - #define STATUS_NO_SUCH_USER cpu_to_le32(0xC0000064) 325 325 - #define STATUS_GROUP_EXISTS cpu_to_le32(0xC0000065) 326 326 - #define STATUS_NO_SUCH_GROUP cpu_to_le32(0xC0000066) 327 327 - #define STATUS_MEMBER_IN_GROUP cpu_to_le32(0xC0000067) 328 328 - #define STATUS_MEMBER_NOT_IN_GROUP cpu_to_le32(0xC0000068) 329 329 - #define STATUS_LAST_ADMIN cpu_to_le32(0xC0000069) 330 330 - #define STATUS_WRONG_PASSWORD cpu_to_le32(0xC000006A) 331 331 - #define STATUS_ILL_FORMED_PASSWORD cpu_to_le32(0xC000006B) 332 332 - #define STATUS_PASSWORD_RESTRICTION cpu_to_le32(0xC000006C) 333 333 - #define STATUS_LOGON_FAILURE cpu_to_le32(0xC000006D) 334 334 - #define STATUS_ACCOUNT_RESTRICTION cpu_to_le32(0xC000006E) 335 335 - #define STATUS_INVALID_LOGON_HOURS cpu_to_le32(0xC000006F) 336 336 - #define STATUS_INVALID_WORKSTATION cpu_to_le32(0xC0000070) 337 337 - #define STATUS_PASSWORD_EXPIRED cpu_to_le32(0xC0000071) 338 338 - #define STATUS_ACCOUNT_DISABLED cpu_to_le32(0xC0000072) 339 339 - #define STATUS_NONE_MAPPED cpu_to_le32(0xC0000073) 340 340 - #define STATUS_TOO_MANY_LUIDS_REQUESTED cpu_to_le32(0xC0000074) 341 341 - #define STATUS_LUIDS_EXHAUSTED cpu_to_le32(0xC0000075) 342 342 - #define STATUS_INVALID_SUB_AUTHORITY cpu_to_le32(0xC0000076) 343 343 - #define STATUS_INVALID_ACL cpu_to_le32(0xC0000077) 344 344 - #define STATUS_INVALID_SID cpu_to_le32(0xC0000078) 345 345 - #define STATUS_INVALID_SECURITY_DESCR cpu_to_le32(0xC0000079) 346 346 - #define STATUS_PROCEDURE_NOT_FOUND cpu_to_le32(0xC000007A) 347 347 - #define STATUS_INVALID_IMAGE_FORMAT cpu_to_le32(0xC000007B) 348 348 - #define STATUS_NO_TOKEN cpu_to_le32(0xC000007C) 349 349 - #define STATUS_BAD_INHERITANCE_ACL cpu_to_le32(0xC000007D) 350 350 - #define STATUS_RANGE_NOT_LOCKED cpu_to_le32(0xC000007E) 351 351 - #define STATUS_DISK_FULL cpu_to_le32(0xC000007F) 352 352 - #define STATUS_SERVER_DISABLED cpu_to_le32(0xC0000080) 353 353 - #define STATUS_SERVER_NOT_DISABLED cpu_to_le32(0xC0000081) 354 354 - #define STATUS_TOO_MANY_GUIDS_REQUESTED cpu_to_le32(0xC0000082) 355 355 - #define STATUS_GUIDS_EXHAUSTED cpu_to_le32(0xC0000083) 356 356 - #define STATUS_INVALID_ID_AUTHORITY cpu_to_le32(0xC0000084) 357 357 - #define STATUS_AGENTS_EXHAUSTED cpu_to_le32(0xC0000085) 358 358 - #define STATUS_INVALID_VOLUME_LABEL cpu_to_le32(0xC0000086) 359 359 - #define STATUS_SECTION_NOT_EXTENDED cpu_to_le32(0xC0000087) 360 360 - #define STATUS_NOT_MAPPED_DATA cpu_to_le32(0xC0000088) 361 361 - #define STATUS_RESOURCE_DATA_NOT_FOUND cpu_to_le32(0xC0000089) 362 362 - #define STATUS_RESOURCE_TYPE_NOT_FOUND cpu_to_le32(0xC000008A) 363 363 - #define STATUS_RESOURCE_NAME_NOT_FOUND cpu_to_le32(0xC000008B) 364 364 - #define STATUS_ARRAY_BOUNDS_EXCEEDED cpu_to_le32(0xC000008C) 365 365 - #define STATUS_FLOAT_DENORMAL_OPERAND cpu_to_le32(0xC000008D) 366 366 - #define STATUS_FLOAT_DIVIDE_BY_ZERO cpu_to_le32(0xC000008E) 367 367 - #define STATUS_FLOAT_INEXACT_RESULT cpu_to_le32(0xC000008F) 368 368 - #define STATUS_FLOAT_INVALID_OPERATION cpu_to_le32(0xC0000090) 369 369 - #define STATUS_FLOAT_OVERFLOW cpu_to_le32(0xC0000091) 370 370 - #define STATUS_FLOAT_STACK_CHECK cpu_to_le32(0xC0000092) 371 371 - #define STATUS_FLOAT_UNDERFLOW cpu_to_le32(0xC0000093) 372 372 - #define STATUS_INTEGER_DIVIDE_BY_ZERO cpu_to_le32(0xC0000094) 373 373 - #define STATUS_INTEGER_OVERFLOW cpu_to_le32(0xC0000095) 374 374 - #define STATUS_PRIVILEGED_INSTRUCTION cpu_to_le32(0xC0000096) 375 375 - #define STATUS_TOO_MANY_PAGING_FILES cpu_to_le32(0xC0000097) 376 376 - #define STATUS_FILE_INVALID cpu_to_le32(0xC0000098) 377 377 - #define STATUS_ALLOTTED_SPACE_EXCEEDED cpu_to_le32(0xC0000099) 378 378 - #define STATUS_INSUFFICIENT_RESOURCES cpu_to_le32(0xC000009A) 379 379 - #define STATUS_DFS_EXIT_PATH_FOUND cpu_to_le32(0xC000009B) 380 380 - #define STATUS_DEVICE_DATA_ERROR cpu_to_le32(0xC000009C) 381 381 - #define STATUS_DEVICE_NOT_CONNECTED cpu_to_le32(0xC000009D) 382 382 - #define STATUS_DEVICE_POWER_FAILURE cpu_to_le32(0xC000009E) 383 383 - #define STATUS_FREE_VM_NOT_AT_BASE cpu_to_le32(0xC000009F) 384 384 - #define STATUS_MEMORY_NOT_ALLOCATED cpu_to_le32(0xC00000A0) 385 385 - #define STATUS_WORKING_SET_QUOTA cpu_to_le32(0xC00000A1) 386 386 - #define STATUS_MEDIA_WRITE_PROTECTED cpu_to_le32(0xC00000A2) 387 387 - #define STATUS_DEVICE_NOT_READY cpu_to_le32(0xC00000A3) 388 388 - #define STATUS_INVALID_GROUP_ATTRIBUTES cpu_to_le32(0xC00000A4) 389 389 - #define STATUS_BAD_IMPERSONATION_LEVEL cpu_to_le32(0xC00000A5) 390 390 - #define STATUS_CANT_OPEN_ANONYMOUS cpu_to_le32(0xC00000A6) 391 391 - #define STATUS_BAD_VALIDATION_CLASS cpu_to_le32(0xC00000A7) 392 392 - #define STATUS_BAD_TOKEN_TYPE cpu_to_le32(0xC00000A8) 393 393 - #define STATUS_BAD_MASTER_BOOT_RECORD cpu_to_le32(0xC00000A9) 394 394 - #define STATUS_INSTRUCTION_MISALIGNMENT cpu_to_le32(0xC00000AA) 395 395 - #define STATUS_INSTANCE_NOT_AVAILABLE cpu_to_le32(0xC00000AB) 396 396 - #define STATUS_PIPE_NOT_AVAILABLE cpu_to_le32(0xC00000AC) 397 397 - #define STATUS_INVALID_PIPE_STATE cpu_to_le32(0xC00000AD) 398 398 - #define STATUS_PIPE_BUSY cpu_to_le32(0xC00000AE) 399 399 - #define STATUS_ILLEGAL_FUNCTION cpu_to_le32(0xC00000AF) 400 400 - #define STATUS_PIPE_DISCONNECTED cpu_to_le32(0xC00000B0) 401 401 - #define STATUS_PIPE_CLOSING cpu_to_le32(0xC00000B1) 402 402 - #define STATUS_PIPE_CONNECTED cpu_to_le32(0xC00000B2) 403 403 - #define STATUS_PIPE_LISTENING cpu_to_le32(0xC00000B3) 404 404 - #define STATUS_INVALID_READ_MODE cpu_to_le32(0xC00000B4) 405 405 - #define STATUS_IO_TIMEOUT cpu_to_le32(0xC00000B5) 406 406 - #define STATUS_FILE_FORCED_CLOSED cpu_to_le32(0xC00000B6) 407 407 - #define STATUS_PROFILING_NOT_STARTED cpu_to_le32(0xC00000B7) 408 408 - #define STATUS_PROFILING_NOT_STOPPED cpu_to_le32(0xC00000B8) 409 409 - #define STATUS_COULD_NOT_INTERPRET cpu_to_le32(0xC00000B9) 410 410 - #define STATUS_FILE_IS_A_DIRECTORY cpu_to_le32(0xC00000BA) 411 411 - #define STATUS_NOT_SUPPORTED cpu_to_le32(0xC00000BB) 412 412 - #define STATUS_REMOTE_NOT_LISTENING cpu_to_le32(0xC00000BC) 413 413 - #define STATUS_DUPLICATE_NAME cpu_to_le32(0xC00000BD) 414 414 - #define STATUS_BAD_NETWORK_PATH cpu_to_le32(0xC00000BE) 415 415 - #define STATUS_NETWORK_BUSY cpu_to_le32(0xC00000BF) 416 416 - #define STATUS_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC00000C0) 417 417 - #define STATUS_TOO_MANY_COMMANDS cpu_to_le32(0xC00000C1) 418 418 - #define STATUS_ADAPTER_HARDWARE_ERROR cpu_to_le32(0xC00000C2) 419 419 - #define STATUS_INVALID_NETWORK_RESPONSE cpu_to_le32(0xC00000C3) 420 420 - #define STATUS_UNEXPECTED_NETWORK_ERROR cpu_to_le32(0xC00000C4) 421 421 - #define STATUS_BAD_REMOTE_ADAPTER cpu_to_le32(0xC00000C5) 422 422 - #define STATUS_PRINT_QUEUE_FULL cpu_to_le32(0xC00000C6) 423 423 - #define STATUS_NO_SPOOL_SPACE cpu_to_le32(0xC00000C7) 424 424 - #define STATUS_PRINT_CANCELLED cpu_to_le32(0xC00000C8) 425 425 - #define STATUS_NETWORK_NAME_DELETED cpu_to_le32(0xC00000C9) 426 426 - #define STATUS_NETWORK_ACCESS_DENIED cpu_to_le32(0xC00000CA) 427 427 - #define STATUS_BAD_DEVICE_TYPE cpu_to_le32(0xC00000CB) 428 428 - #define STATUS_BAD_NETWORK_NAME cpu_to_le32(0xC00000CC) 429 429 - #define STATUS_TOO_MANY_NAMES cpu_to_le32(0xC00000CD) 430 430 - #define STATUS_TOO_MANY_SESSIONS cpu_to_le32(0xC00000CE) 431 431 - #define STATUS_SHARING_PAUSED cpu_to_le32(0xC00000CF) 432 432 - #define STATUS_REQUEST_NOT_ACCEPTED cpu_to_le32(0xC00000D0) 433 433 - #define STATUS_REDIRECTOR_PAUSED cpu_to_le32(0xC00000D1) 434 434 - #define STATUS_NET_WRITE_FAULT cpu_to_le32(0xC00000D2) 435 435 - #define STATUS_PROFILING_AT_LIMIT cpu_to_le32(0xC00000D3) 436 436 - #define STATUS_NOT_SAME_DEVICE cpu_to_le32(0xC00000D4) 437 437 - #define STATUS_FILE_RENAMED cpu_to_le32(0xC00000D5) 438 438 - #define STATUS_VIRTUAL_CIRCUIT_CLOSED cpu_to_le32(0xC00000D6) 439 439 - #define STATUS_NO_SECURITY_ON_OBJECT cpu_to_le32(0xC00000D7) 440 440 - #define STATUS_CANT_WAIT cpu_to_le32(0xC00000D8) 441 441 - #define STATUS_PIPE_EMPTY cpu_to_le32(0xC00000D9) 442 442 - #define STATUS_CANT_ACCESS_DOMAIN_INFO cpu_to_le32(0xC00000DA) 443 443 - #define STATUS_CANT_TERMINATE_SELF cpu_to_le32(0xC00000DB) 444 444 - #define STATUS_INVALID_SERVER_STATE cpu_to_le32(0xC00000DC) 445 445 - #define STATUS_INVALID_DOMAIN_STATE cpu_to_le32(0xC00000DD) 446 446 - #define STATUS_INVALID_DOMAIN_ROLE cpu_to_le32(0xC00000DE) 447 447 - #define STATUS_NO_SUCH_DOMAIN cpu_to_le32(0xC00000DF) 448 448 - #define STATUS_DOMAIN_EXISTS cpu_to_le32(0xC00000E0) 449 449 - #define STATUS_DOMAIN_LIMIT_EXCEEDED cpu_to_le32(0xC00000E1) 450 450 - #define STATUS_OPLOCK_NOT_GRANTED cpu_to_le32(0xC00000E2) 451 451 - #define STATUS_INVALID_OPLOCK_PROTOCOL cpu_to_le32(0xC00000E3) 452 452 - #define STATUS_INTERNAL_DB_CORRUPTION cpu_to_le32(0xC00000E4) 453 453 - #define STATUS_INTERNAL_ERROR cpu_to_le32(0xC00000E5) 454 454 - #define STATUS_GENERIC_NOT_MAPPED cpu_to_le32(0xC00000E6) 455 455 - #define STATUS_BAD_DESCRIPTOR_FORMAT cpu_to_le32(0xC00000E7) 456 456 - #define STATUS_INVALID_USER_BUFFER cpu_to_le32(0xC00000E8) 457 457 - #define STATUS_UNEXPECTED_IO_ERROR cpu_to_le32(0xC00000E9) 458 458 - #define STATUS_UNEXPECTED_MM_CREATE_ERR cpu_to_le32(0xC00000EA) 459 459 - #define STATUS_UNEXPECTED_MM_MAP_ERROR cpu_to_le32(0xC00000EB) 460 460 - #define STATUS_UNEXPECTED_MM_EXTEND_ERR cpu_to_le32(0xC00000EC) 461 461 - #define STATUS_NOT_LOGON_PROCESS cpu_to_le32(0xC00000ED) 462 462 - #define STATUS_LOGON_SESSION_EXISTS cpu_to_le32(0xC00000EE) 463 463 - #define STATUS_INVALID_PARAMETER_1 cpu_to_le32(0xC00000EF) 464 464 - #define STATUS_INVALID_PARAMETER_2 cpu_to_le32(0xC00000F0) 465 465 - #define STATUS_INVALID_PARAMETER_3 cpu_to_le32(0xC00000F1) 466 466 - #define STATUS_INVALID_PARAMETER_4 cpu_to_le32(0xC00000F2) 467 467 - #define STATUS_INVALID_PARAMETER_5 cpu_to_le32(0xC00000F3) 468 468 - #define STATUS_INVALID_PARAMETER_6 cpu_to_le32(0xC00000F4) 469 469 - #define STATUS_INVALID_PARAMETER_7 cpu_to_le32(0xC00000F5) 470 470 - #define STATUS_INVALID_PARAMETER_8 cpu_to_le32(0xC00000F6) 471 471 - #define STATUS_INVALID_PARAMETER_9 cpu_to_le32(0xC00000F7) 472 472 - #define STATUS_INVALID_PARAMETER_10 cpu_to_le32(0xC00000F8) 473 473 - #define STATUS_INVALID_PARAMETER_11 cpu_to_le32(0xC00000F9) 474 474 - #define STATUS_INVALID_PARAMETER_12 cpu_to_le32(0xC00000FA) 475 475 - #define STATUS_REDIRECTOR_NOT_STARTED cpu_to_le32(0xC00000FB) 476 476 - #define STATUS_REDIRECTOR_STARTED cpu_to_le32(0xC00000FC) 477 477 - #define STATUS_STACK_OVERFLOW cpu_to_le32(0xC00000FD) 478 478 - #define STATUS_NO_SUCH_PACKAGE cpu_to_le32(0xC00000FE) 479 479 - #define STATUS_BAD_FUNCTION_TABLE cpu_to_le32(0xC00000FF) 480 480 - #define STATUS_VARIABLE_NOT_FOUND cpu_to_le32(0xC0000100) 481 481 - #define STATUS_DIRECTORY_NOT_EMPTY cpu_to_le32(0xC0000101) 482 482 - #define STATUS_FILE_CORRUPT_ERROR cpu_to_le32(0xC0000102) 483 483 - #define STATUS_NOT_A_DIRECTORY cpu_to_le32(0xC0000103) 484 484 - #define STATUS_BAD_LOGON_SESSION_STATE cpu_to_le32(0xC0000104) 485 485 - #define STATUS_LOGON_SESSION_COLLISION cpu_to_le32(0xC0000105) 486 486 - #define STATUS_NAME_TOO_LONG cpu_to_le32(0xC0000106) 487 487 - #define STATUS_FILES_OPEN cpu_to_le32(0xC0000107) 488 488 - #define STATUS_CONNECTION_IN_USE cpu_to_le32(0xC0000108) 489 489 - #define STATUS_MESSAGE_NOT_FOUND cpu_to_le32(0xC0000109) 490 490 - #define STATUS_PROCESS_IS_TERMINATING cpu_to_le32(0xC000010A) 491 491 - #define STATUS_INVALID_LOGON_TYPE cpu_to_le32(0xC000010B) 492 492 - #define STATUS_NO_GUID_TRANSLATION cpu_to_le32(0xC000010C) 493 493 - #define STATUS_CANNOT_IMPERSONATE cpu_to_le32(0xC000010D) 494 494 - #define STATUS_IMAGE_ALREADY_LOADED cpu_to_le32(0xC000010E) 495 495 - #define STATUS_ABIOS_NOT_PRESENT cpu_to_le32(0xC000010F) 496 496 - #define STATUS_ABIOS_LID_NOT_EXIST cpu_to_le32(0xC0000110) 497 497 - #define STATUS_ABIOS_LID_ALREADY_OWNED cpu_to_le32(0xC0000111) 498 498 - #define STATUS_ABIOS_NOT_LID_OWNER cpu_to_le32(0xC0000112) 499 499 - #define STATUS_ABIOS_INVALID_COMMAND cpu_to_le32(0xC0000113) 500 500 - #define STATUS_ABIOS_INVALID_LID cpu_to_le32(0xC0000114) 501 501 - #define STATUS_ABIOS_SELECTOR_NOT_AVAILABLE cpu_to_le32(0xC0000115) 502 502 - #define STATUS_ABIOS_INVALID_SELECTOR cpu_to_le32(0xC0000116) 503 503 - #define STATUS_NO_LDT cpu_to_le32(0xC0000117) 504 504 - #define STATUS_INVALID_LDT_SIZE cpu_to_le32(0xC0000118) 505 505 - #define STATUS_INVALID_LDT_OFFSET cpu_to_le32(0xC0000119) 506 506 - #define STATUS_INVALID_LDT_DESCRIPTOR cpu_to_le32(0xC000011A) 507 507 - #define STATUS_INVALID_IMAGE_NE_FORMAT cpu_to_le32(0xC000011B) 508 508 - #define STATUS_RXACT_INVALID_STATE cpu_to_le32(0xC000011C) 509 509 - #define STATUS_RXACT_COMMIT_FAILURE cpu_to_le32(0xC000011D) 510 510 - #define STATUS_MAPPED_FILE_SIZE_ZERO cpu_to_le32(0xC000011E) 511 511 - #define STATUS_TOO_MANY_OPENED_FILES cpu_to_le32(0xC000011F) 512 512 - #define STATUS_CANCELLED cpu_to_le32(0xC0000120) 513 513 - #define STATUS_CANNOT_DELETE cpu_to_le32(0xC0000121) 514 514 - #define STATUS_INVALID_COMPUTER_NAME cpu_to_le32(0xC0000122) 515 515 - #define STATUS_FILE_DELETED cpu_to_le32(0xC0000123) 516 516 - #define STATUS_SPECIAL_ACCOUNT cpu_to_le32(0xC0000124) 517 517 - #define STATUS_SPECIAL_GROUP cpu_to_le32(0xC0000125) 518 518 - #define STATUS_SPECIAL_USER cpu_to_le32(0xC0000126) 519 519 - #define STATUS_MEMBERS_PRIMARY_GROUP cpu_to_le32(0xC0000127) 520 520 - #define STATUS_FILE_CLOSED cpu_to_le32(0xC0000128) 521 521 - #define STATUS_TOO_MANY_THREADS cpu_to_le32(0xC0000129) 522 522 - #define STATUS_THREAD_NOT_IN_PROCESS cpu_to_le32(0xC000012A) 523 523 - #define STATUS_TOKEN_ALREADY_IN_USE cpu_to_le32(0xC000012B) 524 524 - #define STATUS_PAGEFILE_QUOTA_EXCEEDED cpu_to_le32(0xC000012C) 525 525 - #define STATUS_COMMITMENT_LIMIT cpu_to_le32(0xC000012D) 526 526 - #define STATUS_INVALID_IMAGE_LE_FORMAT cpu_to_le32(0xC000012E) 527 527 - #define STATUS_INVALID_IMAGE_NOT_MZ cpu_to_le32(0xC000012F) 528 528 - #define STATUS_INVALID_IMAGE_PROTECT cpu_to_le32(0xC0000130) 529 529 - #define STATUS_INVALID_IMAGE_WIN_16 cpu_to_le32(0xC0000131) 530 530 - #define STATUS_LOGON_SERVER_CONFLICT cpu_to_le32(0xC0000132) 531 531 - #define STATUS_TIME_DIFFERENCE_AT_DC cpu_to_le32(0xC0000133) 532 532 - #define STATUS_SYNCHRONIZATION_REQUIRED cpu_to_le32(0xC0000134) 533 533 - #define STATUS_DLL_NOT_FOUND cpu_to_le32(0xC0000135) 534 534 - #define STATUS_OPEN_FAILED cpu_to_le32(0xC0000136) 535 535 - #define STATUS_IO_PRIVILEGE_FAILED cpu_to_le32(0xC0000137) 536 536 - #define STATUS_ORDINAL_NOT_FOUND cpu_to_le32(0xC0000138) 537 537 - #define STATUS_ENTRYPOINT_NOT_FOUND cpu_to_le32(0xC0000139) 538 538 - #define STATUS_CONTROL_C_EXIT cpu_to_le32(0xC000013A) 539 539 - #define STATUS_LOCAL_DISCONNECT cpu_to_le32(0xC000013B) 540 540 - #define STATUS_REMOTE_DISCONNECT cpu_to_le32(0xC000013C) 541 541 - #define STATUS_REMOTE_RESOURCES cpu_to_le32(0xC000013D) 542 542 - #define STATUS_LINK_FAILED cpu_to_le32(0xC000013E) 543 543 - #define STATUS_LINK_TIMEOUT cpu_to_le32(0xC000013F) 544 544 - #define STATUS_INVALID_CONNECTION cpu_to_le32(0xC0000140) 545 545 - #define STATUS_INVALID_ADDRESS cpu_to_le32(0xC0000141) 546 546 - #define STATUS_DLL_INIT_FAILED cpu_to_le32(0xC0000142) 547 547 - #define STATUS_MISSING_SYSTEMFILE cpu_to_le32(0xC0000143) 548 548 - #define STATUS_UNHANDLED_EXCEPTION cpu_to_le32(0xC0000144) 549 549 - #define STATUS_APP_INIT_FAILURE cpu_to_le32(0xC0000145) 550 550 - #define STATUS_PAGEFILE_CREATE_FAILED cpu_to_le32(0xC0000146) 551 551 - #define STATUS_NO_PAGEFILE cpu_to_le32(0xC0000147) 552 552 - #define STATUS_INVALID_LEVEL cpu_to_le32(0xC0000148) 553 553 - #define STATUS_WRONG_PASSWORD_CORE cpu_to_le32(0xC0000149) 554 554 - #define STATUS_ILLEGAL_FLOAT_CONTEXT cpu_to_le32(0xC000014A) 555 555 - #define STATUS_PIPE_BROKEN cpu_to_le32(0xC000014B) 556 556 - #define STATUS_REGISTRY_CORRUPT cpu_to_le32(0xC000014C) 557 557 - #define STATUS_REGISTRY_IO_FAILED cpu_to_le32(0xC000014D) 558 558 - #define STATUS_NO_EVENT_PAIR cpu_to_le32(0xC000014E) 559 559 - #define STATUS_UNRECOGNIZED_VOLUME cpu_to_le32(0xC000014F) 560 560 - #define STATUS_SERIAL_NO_DEVICE_INITED cpu_to_le32(0xC0000150) 561 561 - #define STATUS_NO_SUCH_ALIAS cpu_to_le32(0xC0000151) 562 562 - #define STATUS_MEMBER_NOT_IN_ALIAS cpu_to_le32(0xC0000152) 563 563 - #define STATUS_MEMBER_IN_ALIAS cpu_to_le32(0xC0000153) 564 564 - #define STATUS_ALIAS_EXISTS cpu_to_le32(0xC0000154) 565 565 - #define STATUS_LOGON_NOT_GRANTED cpu_to_le32(0xC0000155) 566 566 - #define STATUS_TOO_MANY_SECRETS cpu_to_le32(0xC0000156) 567 567 - #define STATUS_SECRET_TOO_LONG cpu_to_le32(0xC0000157) 568 568 - #define STATUS_INTERNAL_DB_ERROR cpu_to_le32(0xC0000158) 569 569 - #define STATUS_FULLSCREEN_MODE cpu_to_le32(0xC0000159) 570 570 - #define STATUS_TOO_MANY_CONTEXT_IDS cpu_to_le32(0xC000015A) 571 571 - #define STATUS_LOGON_TYPE_NOT_GRANTED cpu_to_le32(0xC000015B) 572 572 - #define STATUS_NOT_REGISTRY_FILE cpu_to_le32(0xC000015C) 573 573 - #define STATUS_NT_CROSS_ENCRYPTION_REQUIRED cpu_to_le32(0xC000015D) 574 574 - #define STATUS_DOMAIN_CTRLR_CONFIG_ERROR cpu_to_le32(0xC000015E) 575 575 - #define STATUS_FT_MISSING_MEMBER cpu_to_le32(0xC000015F) 576 576 - #define STATUS_ILL_FORMED_SERVICE_ENTRY cpu_to_le32(0xC0000160) 577 577 - #define STATUS_ILLEGAL_CHARACTER cpu_to_le32(0xC0000161) 578 578 - #define STATUS_UNMAPPABLE_CHARACTER cpu_to_le32(0xC0000162) 579 579 - #define STATUS_UNDEFINED_CHARACTER cpu_to_le32(0xC0000163) 580 580 - #define STATUS_FLOPPY_VOLUME cpu_to_le32(0xC0000164) 581 581 - #define STATUS_FLOPPY_ID_MARK_NOT_FOUND cpu_to_le32(0xC0000165) 582 582 - #define STATUS_FLOPPY_WRONG_CYLINDER cpu_to_le32(0xC0000166) 583 583 - #define STATUS_FLOPPY_UNKNOWN_ERROR cpu_to_le32(0xC0000167) 584 584 - #define STATUS_FLOPPY_BAD_REGISTERS cpu_to_le32(0xC0000168) 585 585 - #define STATUS_DISK_RECALIBRATE_FAILED cpu_to_le32(0xC0000169) 586 586 - #define STATUS_DISK_OPERATION_FAILED cpu_to_le32(0xC000016A) 587 587 - #define STATUS_DISK_RESET_FAILED cpu_to_le32(0xC000016B) 588 588 - #define STATUS_SHARED_IRQ_BUSY cpu_to_le32(0xC000016C) 589 589 - #define STATUS_FT_ORPHANING cpu_to_le32(0xC000016D) 590 590 - #define STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT cpu_to_le32(0xC000016E) 591 591 - #define STATUS_PARTITION_FAILURE cpu_to_le32(0xC0000172) 592 592 - #define STATUS_INVALID_BLOCK_LENGTH cpu_to_le32(0xC0000173) 593 593 - #define STATUS_DEVICE_NOT_PARTITIONED cpu_to_le32(0xC0000174) 594 594 - #define STATUS_UNABLE_TO_LOCK_MEDIA cpu_to_le32(0xC0000175) 595 595 - #define STATUS_UNABLE_TO_UNLOAD_MEDIA cpu_to_le32(0xC0000176) 596 596 - #define STATUS_EOM_OVERFLOW cpu_to_le32(0xC0000177) 597 597 - #define STATUS_NO_MEDIA cpu_to_le32(0xC0000178) 598 598 - #define STATUS_NO_SUCH_MEMBER cpu_to_le32(0xC000017A) 599 599 - #define STATUS_INVALID_MEMBER cpu_to_le32(0xC000017B) 600 600 - #define STATUS_KEY_DELETED cpu_to_le32(0xC000017C) 601 601 - #define STATUS_NO_LOG_SPACE cpu_to_le32(0xC000017D) 602 602 - #define STATUS_TOO_MANY_SIDS cpu_to_le32(0xC000017E) 603 603 - #define STATUS_LM_CROSS_ENCRYPTION_REQUIRED cpu_to_le32(0xC000017F) 604 604 - #define STATUS_KEY_HAS_CHILDREN cpu_to_le32(0xC0000180) 605 605 - #define STATUS_CHILD_MUST_BE_VOLATILE cpu_to_le32(0xC0000181) 606 606 - #define STATUS_DEVICE_CONFIGURATION_ERROR cpu_to_le32(0xC0000182) 607 607 - #define STATUS_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC0000183) 608 608 - #define STATUS_INVALID_DEVICE_STATE cpu_to_le32(0xC0000184) 609 609 - #define STATUS_IO_DEVICE_ERROR cpu_to_le32(0xC0000185) 610 610 - #define STATUS_DEVICE_PROTOCOL_ERROR cpu_to_le32(0xC0000186) 611 611 - #define STATUS_BACKUP_CONTROLLER cpu_to_le32(0xC0000187) 612 612 - #define STATUS_LOG_FILE_FULL cpu_to_le32(0xC0000188) 613 613 - #define STATUS_TOO_LATE cpu_to_le32(0xC0000189) 614 614 - #define STATUS_NO_TRUST_LSA_SECRET cpu_to_le32(0xC000018A) 615 615 - #define STATUS_NO_TRUST_SAM_ACCOUNT cpu_to_le32(0xC000018B) 616 616 - #define STATUS_TRUSTED_DOMAIN_FAILURE cpu_to_le32(0xC000018C) 617 617 - #define STATUS_TRUSTED_RELATIONSHIP_FAILURE cpu_to_le32(0xC000018D) 618 618 - #define STATUS_EVENTLOG_FILE_CORRUPT cpu_to_le32(0xC000018E) 619 619 - #define STATUS_EVENTLOG_CANT_START cpu_to_le32(0xC000018F) 620 620 - #define STATUS_TRUST_FAILURE cpu_to_le32(0xC0000190) 621 621 - #define STATUS_MUTANT_LIMIT_EXCEEDED cpu_to_le32(0xC0000191) 622 622 - #define STATUS_NETLOGON_NOT_STARTED cpu_to_le32(0xC0000192) 623 623 - #define STATUS_ACCOUNT_EXPIRED cpu_to_le32(0xC0000193) 624 624 - #define STATUS_POSSIBLE_DEADLOCK cpu_to_le32(0xC0000194) 625 625 - #define STATUS_NETWORK_CREDENTIAL_CONFLICT cpu_to_le32(0xC0000195) 626 626 - #define STATUS_REMOTE_SESSION_LIMIT cpu_to_le32(0xC0000196) 627 627 - #define STATUS_EVENTLOG_FILE_CHANGED cpu_to_le32(0xC0000197) 628 628 - #define STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT cpu_to_le32(0xC0000198) 629 629 - #define STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT cpu_to_le32(0xC0000199) 630 630 - #define STATUS_NOLOGON_SERVER_TRUST_ACCOUNT cpu_to_le32(0xC000019A) 631 631 - #define STATUS_DOMAIN_TRUST_INCONSISTENT cpu_to_le32(0xC000019B) 632 632 - #define STATUS_FS_DRIVER_REQUIRED cpu_to_le32(0xC000019C) 633 633 - #define STATUS_IMAGE_ALREADY_LOADED_AS_DLL cpu_to_le32(0xC000019D) 634 634 - #define STATUS_NETWORK_OPEN_RESTRICTION cpu_to_le32(0xC0000201) 635 635 - #define STATUS_NO_USER_SESSION_KEY cpu_to_le32(0xC0000202) 636 636 - #define STATUS_USER_SESSION_DELETED cpu_to_le32(0xC0000203) 637 637 - #define STATUS_RESOURCE_LANG_NOT_FOUND cpu_to_le32(0xC0000204) 638 638 - #define STATUS_INSUFF_SERVER_RESOURCES cpu_to_le32(0xC0000205) 639 639 - #define STATUS_INVALID_BUFFER_SIZE cpu_to_le32(0xC0000206) 640 640 - #define STATUS_INVALID_ADDRESS_COMPONENT cpu_to_le32(0xC0000207) 641 641 - #define STATUS_INVALID_ADDRESS_WILDCARD cpu_to_le32(0xC0000208) 642 642 - #define STATUS_TOO_MANY_ADDRESSES cpu_to_le32(0xC0000209) 643 643 - #define STATUS_ADDRESS_ALREADY_EXISTS cpu_to_le32(0xC000020A) 644 644 - #define STATUS_ADDRESS_CLOSED cpu_to_le32(0xC000020B) 645 645 - #define STATUS_CONNECTION_DISCONNECTED cpu_to_le32(0xC000020C) 646 646 - #define STATUS_CONNECTION_RESET cpu_to_le32(0xC000020D) 647 647 - #define STATUS_TOO_MANY_NODES cpu_to_le32(0xC000020E) 648 648 - #define STATUS_TRANSACTION_ABORTED cpu_to_le32(0xC000020F) 649 649 - #define STATUS_TRANSACTION_TIMED_OUT cpu_to_le32(0xC0000210) 650 650 - #define STATUS_TRANSACTION_NO_RELEASE cpu_to_le32(0xC0000211) 651 651 - #define STATUS_TRANSACTION_NO_MATCH cpu_to_le32(0xC0000212) 652 652 - #define STATUS_TRANSACTION_RESPONDED cpu_to_le32(0xC0000213) 653 653 - #define STATUS_TRANSACTION_INVALID_ID cpu_to_le32(0xC0000214) 654 654 - #define STATUS_TRANSACTION_INVALID_TYPE cpu_to_le32(0xC0000215) 655 655 - #define STATUS_NOT_SERVER_SESSION cpu_to_le32(0xC0000216) 656 656 - #define STATUS_NOT_CLIENT_SESSION cpu_to_le32(0xC0000217) 657 657 - #define STATUS_CANNOT_LOAD_REGISTRY_FILE cpu_to_le32(0xC0000218) 658 658 - #define STATUS_DEBUG_ATTACH_FAILED cpu_to_le32(0xC0000219) 659 659 - #define STATUS_SYSTEM_PROCESS_TERMINATED cpu_to_le32(0xC000021A) 660 660 - #define STATUS_DATA_NOT_ACCEPTED cpu_to_le32(0xC000021B) 661 661 - #define STATUS_NO_BROWSER_SERVERS_FOUND cpu_to_le32(0xC000021C) 662 662 - #define STATUS_VDM_HARD_ERROR cpu_to_le32(0xC000021D) 663 663 - #define STATUS_DRIVER_CANCEL_TIMEOUT cpu_to_le32(0xC000021E) 664 664 - #define STATUS_REPLY_MESSAGE_MISMATCH cpu_to_le32(0xC000021F) 665 665 - #define STATUS_MAPPED_ALIGNMENT cpu_to_le32(0xC0000220) 666 666 - #define STATUS_IMAGE_CHECKSUM_MISMATCH cpu_to_le32(0xC0000221) 667 667 - #define STATUS_LOST_WRITEBEHIND_DATA cpu_to_le32(0xC0000222) 668 668 - #define STATUS_CLIENT_SERVER_PARAMETERS_INVALID cpu_to_le32(0xC0000223) 669 669 - #define STATUS_PASSWORD_MUST_CHANGE cpu_to_le32(0xC0000224) 670 670 - #define STATUS_NOT_FOUND cpu_to_le32(0xC0000225) 671 671 - #define STATUS_NOT_TINY_STREAM cpu_to_le32(0xC0000226) 672 672 - #define STATUS_RECOVERY_FAILURE cpu_to_le32(0xC0000227) 673 673 - #define STATUS_STACK_OVERFLOW_READ cpu_to_le32(0xC0000228) 674 674 - #define STATUS_FAIL_CHECK cpu_to_le32(0xC0000229) 675 675 - #define STATUS_DUPLICATE_OBJECTID cpu_to_le32(0xC000022A) 676 676 - #define STATUS_OBJECTID_EXISTS cpu_to_le32(0xC000022B) 677 677 - #define STATUS_CONVERT_TO_LARGE cpu_to_le32(0xC000022C) 678 678 - #define STATUS_RETRY cpu_to_le32(0xC000022D) 679 679 - #define STATUS_FOUND_OUT_OF_SCOPE cpu_to_le32(0xC000022E) 680 680 - #define STATUS_ALLOCATE_BUCKET cpu_to_le32(0xC000022F) 681 681 - #define STATUS_PROPSET_NOT_FOUND cpu_to_le32(0xC0000230) 682 682 - #define STATUS_MARSHALL_OVERFLOW cpu_to_le32(0xC0000231) 683 683 - #define STATUS_INVALID_VARIANT cpu_to_le32(0xC0000232) 684 684 - #define STATUS_DOMAIN_CONTROLLER_NOT_FOUND cpu_to_le32(0xC0000233) 685 685 - #define STATUS_ACCOUNT_LOCKED_OUT cpu_to_le32(0xC0000234) 686 686 - #define STATUS_HANDLE_NOT_CLOSABLE cpu_to_le32(0xC0000235) 687 687 - #define STATUS_CONNECTION_REFUSED cpu_to_le32(0xC0000236) 688 688 - #define STATUS_GRACEFUL_DISCONNECT cpu_to_le32(0xC0000237) 689 689 - #define STATUS_ADDRESS_ALREADY_ASSOCIATED cpu_to_le32(0xC0000238) 690 690 - #define STATUS_ADDRESS_NOT_ASSOCIATED cpu_to_le32(0xC0000239) 691 691 - #define STATUS_CONNECTION_INVALID cpu_to_le32(0xC000023A) 692 692 - #define STATUS_CONNECTION_ACTIVE cpu_to_le32(0xC000023B) 693 693 - #define STATUS_NETWORK_UNREACHABLE cpu_to_le32(0xC000023C) 694 694 - #define STATUS_HOST_UNREACHABLE cpu_to_le32(0xC000023D) 695 695 - #define STATUS_PROTOCOL_UNREACHABLE cpu_to_le32(0xC000023E) 696 696 - #define STATUS_PORT_UNREACHABLE cpu_to_le32(0xC000023F) 697 697 - #define STATUS_REQUEST_ABORTED cpu_to_le32(0xC0000240) 698 698 - #define STATUS_CONNECTION_ABORTED cpu_to_le32(0xC0000241) 699 699 - #define STATUS_BAD_COMPRESSION_BUFFER cpu_to_le32(0xC0000242) 700 700 - #define STATUS_USER_MAPPED_FILE cpu_to_le32(0xC0000243) 701 701 - #define STATUS_AUDIT_FAILED cpu_to_le32(0xC0000244) 702 702 - #define STATUS_TIMER_RESOLUTION_NOT_SET cpu_to_le32(0xC0000245) 703 703 - #define STATUS_CONNECTION_COUNT_LIMIT cpu_to_le32(0xC0000246) 704 704 - #define STATUS_LOGIN_TIME_RESTRICTION cpu_to_le32(0xC0000247) 705 705 - #define STATUS_LOGIN_WKSTA_RESTRICTION cpu_to_le32(0xC0000248) 706 706 - #define STATUS_IMAGE_MP_UP_MISMATCH cpu_to_le32(0xC0000249) 707 707 - #define STATUS_INSUFFICIENT_LOGON_INFO cpu_to_le32(0xC0000250) 708 708 - #define STATUS_BAD_DLL_ENTRYPOINT cpu_to_le32(0xC0000251) 709 709 - #define STATUS_BAD_SERVICE_ENTRYPOINT cpu_to_le32(0xC0000252) 710 710 - #define STATUS_LPC_REPLY_LOST cpu_to_le32(0xC0000253) 711 711 - #define STATUS_IP_ADDRESS_CONFLICT1 cpu_to_le32(0xC0000254) 712 712 - #define STATUS_IP_ADDRESS_CONFLICT2 cpu_to_le32(0xC0000255) 713 713 - #define STATUS_REGISTRY_QUOTA_LIMIT cpu_to_le32(0xC0000256) 714 714 - #define STATUS_PATH_NOT_COVERED cpu_to_le32(0xC0000257) 715 715 - #define STATUS_NO_CALLBACK_ACTIVE cpu_to_le32(0xC0000258) 716 716 - #define STATUS_LICENSE_QUOTA_EXCEEDED cpu_to_le32(0xC0000259) 717 717 - #define STATUS_PWD_TOO_SHORT cpu_to_le32(0xC000025A) 718 718 - #define STATUS_PWD_TOO_RECENT cpu_to_le32(0xC000025B) 719 719 - #define STATUS_PWD_HISTORY_CONFLICT cpu_to_le32(0xC000025C) 720 720 - #define STATUS_PLUGPLAY_NO_DEVICE cpu_to_le32(0xC000025E) 721 721 - #define STATUS_UNSUPPORTED_COMPRESSION cpu_to_le32(0xC000025F) 722 722 - #define STATUS_INVALID_HW_PROFILE cpu_to_le32(0xC0000260) 723 723 - #define STATUS_INVALID_PLUGPLAY_DEVICE_PATH cpu_to_le32(0xC0000261) 724 724 - #define STATUS_DRIVER_ORDINAL_NOT_FOUND cpu_to_le32(0xC0000262) 725 725 - #define STATUS_DRIVER_ENTRYPOINT_NOT_FOUND cpu_to_le32(0xC0000263) 726 726 - #define STATUS_RESOURCE_NOT_OWNED cpu_to_le32(0xC0000264) 727 727 - #define STATUS_TOO_MANY_LINKS cpu_to_le32(0xC0000265) 728 728 - #define STATUS_QUOTA_LIST_INCONSISTENT cpu_to_le32(0xC0000266) 729 729 - #define STATUS_FILE_IS_OFFLINE cpu_to_le32(0xC0000267) 730 730 - #define STATUS_EVALUATION_EXPIRATION cpu_to_le32(0xC0000268) 731 731 - #define STATUS_ILLEGAL_DLL_RELOCATION cpu_to_le32(0xC0000269) 732 732 - #define STATUS_LICENSE_VIOLATION cpu_to_le32(0xC000026A) 733 733 - #define STATUS_DLL_INIT_FAILED_LOGOFF cpu_to_le32(0xC000026B) 734 734 - #define STATUS_DRIVER_UNABLE_TO_LOAD cpu_to_le32(0xC000026C) 735 735 - #define STATUS_DFS_UNAVAILABLE cpu_to_le32(0xC000026D) 736 736 - #define STATUS_VOLUME_DISMOUNTED cpu_to_le32(0xC000026E) 737 737 - #define STATUS_WX86_INTERNAL_ERROR cpu_to_le32(0xC000026F) 738 738 - #define STATUS_WX86_FLOAT_STACK_CHECK cpu_to_le32(0xC0000270) 739 739 - #define STATUS_VALIDATE_CONTINUE cpu_to_le32(0xC0000271) 740 740 - #define STATUS_NO_MATCH cpu_to_le32(0xC0000272) 741 741 - #define STATUS_NO_MORE_MATCHES cpu_to_le32(0xC0000273) 742 742 - #define STATUS_NOT_A_REPARSE_POINT cpu_to_le32(0xC0000275) 743 743 - #define STATUS_IO_REPARSE_TAG_INVALID cpu_to_le32(0xC0000276) 744 744 - #define STATUS_IO_REPARSE_TAG_MISMATCH cpu_to_le32(0xC0000277) 745 745 - #define STATUS_IO_REPARSE_DATA_INVALID cpu_to_le32(0xC0000278) 746 746 - #define STATUS_IO_REPARSE_TAG_NOT_HANDLED cpu_to_le32(0xC0000279) 747 747 - #define STATUS_REPARSE_POINT_NOT_RESOLVED cpu_to_le32(0xC0000280) 748 748 - #define STATUS_DIRECTORY_IS_A_REPARSE_POINT cpu_to_le32(0xC0000281) 749 749 - #define STATUS_RANGE_LIST_CONFLICT cpu_to_le32(0xC0000282) 750 750 - #define STATUS_SOURCE_ELEMENT_EMPTY cpu_to_le32(0xC0000283) 751 751 - #define STATUS_DESTINATION_ELEMENT_FULL cpu_to_le32(0xC0000284) 752 752 - #define STATUS_ILLEGAL_ELEMENT_ADDRESS cpu_to_le32(0xC0000285) 753 753 - #define STATUS_MAGAZINE_NOT_PRESENT cpu_to_le32(0xC0000286) 754 754 - #define STATUS_REINITIALIZATION_NEEDED cpu_to_le32(0xC0000287) 755 755 - #define STATUS_ENCRYPTION_FAILED cpu_to_le32(0xC000028A) 756 756 - #define STATUS_DECRYPTION_FAILED cpu_to_le32(0xC000028B) 757 757 - #define STATUS_RANGE_NOT_FOUND cpu_to_le32(0xC000028C) 758 758 - #define STATUS_NO_RECOVERY_POLICY cpu_to_le32(0xC000028D) 759 759 - #define STATUS_NO_EFS cpu_to_le32(0xC000028E) 760 760 - #define STATUS_WRONG_EFS cpu_to_le32(0xC000028F) 761 761 - #define STATUS_NO_USER_KEYS cpu_to_le32(0xC0000290) 762 762 - #define STATUS_FILE_NOT_ENCRYPTED cpu_to_le32(0xC0000291) 763 763 - #define STATUS_NOT_EXPORT_FORMAT cpu_to_le32(0xC0000292) 764 764 - #define STATUS_FILE_ENCRYPTED cpu_to_le32(0xC0000293) 765 765 - #define STATUS_WMI_GUID_NOT_FOUND cpu_to_le32(0xC0000295) 766 766 - #define STATUS_WMI_INSTANCE_NOT_FOUND cpu_to_le32(0xC0000296) 767 767 - #define STATUS_WMI_ITEMID_NOT_FOUND cpu_to_le32(0xC0000297) 768 768 - #define STATUS_WMI_TRY_AGAIN cpu_to_le32(0xC0000298) 769 769 - #define STATUS_SHARED_POLICY cpu_to_le32(0xC0000299) 770 770 - #define STATUS_POLICY_OBJECT_NOT_FOUND cpu_to_le32(0xC000029A) 771 771 - #define STATUS_POLICY_ONLY_IN_DS cpu_to_le32(0xC000029B) 772 772 - #define STATUS_VOLUME_NOT_UPGRADED cpu_to_le32(0xC000029C) 773 773 - #define STATUS_REMOTE_STORAGE_NOT_ACTIVE cpu_to_le32(0xC000029D) 774 774 - #define STATUS_REMOTE_STORAGE_MEDIA_ERROR cpu_to_le32(0xC000029E) 775 775 - #define STATUS_NO_TRACKING_SERVICE cpu_to_le32(0xC000029F) 776 776 - #define STATUS_SERVER_SID_MISMATCH cpu_to_le32(0xC00002A0) 777 777 - #define STATUS_DS_NO_ATTRIBUTE_OR_VALUE cpu_to_le32(0xC00002A1) 778 778 - #define STATUS_DS_INVALID_ATTRIBUTE_SYNTAX cpu_to_le32(0xC00002A2) 779 779 - #define STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED cpu_to_le32(0xC00002A3) 780 780 - #define STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS cpu_to_le32(0xC00002A4) 781 781 - #define STATUS_DS_BUSY cpu_to_le32(0xC00002A5) 782 782 - #define STATUS_DS_UNAVAILABLE cpu_to_le32(0xC00002A6) 783 783 - #define STATUS_DS_NO_RIDS_ALLOCATED cpu_to_le32(0xC00002A7) 784 784 - #define STATUS_DS_NO_MORE_RIDS cpu_to_le32(0xC00002A8) 785 785 - #define STATUS_DS_INCORRECT_ROLE_OWNER cpu_to_le32(0xC00002A9) 786 786 - #define STATUS_DS_RIDMGR_INIT_ERROR cpu_to_le32(0xC00002AA) 787 787 - #define STATUS_DS_OBJ_CLASS_VIOLATION cpu_to_le32(0xC00002AB) 788 788 - #define STATUS_DS_CANT_ON_NON_LEAF cpu_to_le32(0xC00002AC) 789 789 - #define STATUS_DS_CANT_ON_RDN cpu_to_le32(0xC00002AD) 790 790 - #define STATUS_DS_CANT_MOD_OBJ_CLASS cpu_to_le32(0xC00002AE) 791 791 - #define STATUS_DS_CROSS_DOM_MOVE_FAILED cpu_to_le32(0xC00002AF) 792 792 - #define STATUS_DS_GC_NOT_AVAILABLE cpu_to_le32(0xC00002B0) 793 793 - #define STATUS_DIRECTORY_SERVICE_REQUIRED cpu_to_le32(0xC00002B1) 794 794 - #define STATUS_REPARSE_ATTRIBUTE_CONFLICT cpu_to_le32(0xC00002B2) 795 795 - #define STATUS_CANT_ENABLE_DENY_ONLY cpu_to_le32(0xC00002B3) 796 796 - #define STATUS_FLOAT_MULTIPLE_FAULTS cpu_to_le32(0xC00002B4) 797 797 - #define STATUS_FLOAT_MULTIPLE_TRAPS cpu_to_le32(0xC00002B5) 798 798 - #define STATUS_DEVICE_REMOVED cpu_to_le32(0xC00002B6) 799 799 - #define STATUS_JOURNAL_DELETE_IN_PROGRESS cpu_to_le32(0xC00002B7) 800 800 - #define STATUS_JOURNAL_NOT_ACTIVE cpu_to_le32(0xC00002B8) 801 801 - #define STATUS_NOINTERFACE cpu_to_le32(0xC00002B9) 802 802 - #define STATUS_DS_ADMIN_LIMIT_EXCEEDED cpu_to_le32(0xC00002C1) 803 803 - #define STATUS_DRIVER_FAILED_SLEEP cpu_to_le32(0xC00002C2) 804 804 - #define STATUS_MUTUAL_AUTHENTICATION_FAILED cpu_to_le32(0xC00002C3) 805 805 - #define STATUS_CORRUPT_SYSTEM_FILE cpu_to_le32(0xC00002C4) 806 806 - #define STATUS_DATATYPE_MISALIGNMENT_ERROR cpu_to_le32(0xC00002C5) 807 807 - #define STATUS_WMI_READ_ONLY cpu_to_le32(0xC00002C6) 808 808 - #define STATUS_WMI_SET_FAILURE cpu_to_le32(0xC00002C7) 809 809 - #define STATUS_COMMITMENT_MINIMUM cpu_to_le32(0xC00002C8) 810 810 - #define STATUS_REG_NAT_CONSUMPTION cpu_to_le32(0xC00002C9) 811 811 - #define STATUS_TRANSPORT_FULL cpu_to_le32(0xC00002CA) 812 812 - #define STATUS_DS_SAM_INIT_FAILURE cpu_to_le32(0xC00002CB) 813 813 - #define STATUS_ONLY_IF_CONNECTED cpu_to_le32(0xC00002CC) 814 814 - #define STATUS_DS_SENSITIVE_GROUP_VIOLATION cpu_to_le32(0xC00002CD) 815 815 - #define STATUS_PNP_RESTART_ENUMERATION cpu_to_le32(0xC00002CE) 816 816 - #define STATUS_JOURNAL_ENTRY_DELETED cpu_to_le32(0xC00002CF) 817 817 - #define STATUS_DS_CANT_MOD_PRIMARYGROUPID cpu_to_le32(0xC00002D0) 818 818 - #define STATUS_SYSTEM_IMAGE_BAD_SIGNATURE cpu_to_le32(0xC00002D1) 819 819 - #define STATUS_PNP_REBOOT_REQUIRED cpu_to_le32(0xC00002D2) 820 820 - #define STATUS_POWER_STATE_INVALID cpu_to_le32(0xC00002D3) 821 821 - #define STATUS_DS_INVALID_GROUP_TYPE cpu_to_le32(0xC00002D4) 822 822 - #define STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D5) 823 823 - #define STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN cpu_to_le32(0xC00002D6) 824 824 - #define STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D7) 825 825 - #define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC00002D8) 826 826 - #define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D9) 827 827 - #define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER cpu_to_le32(0xC00002DA) 828 828 - #define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER cpu_to_le32(0xC00002DB) 829 829 - #define STATUS_DS_HAVE_PRIMARY_MEMBERS cpu_to_le32(0xC00002DC) 830 830 - #define STATUS_WMI_NOT_SUPPORTED cpu_to_le32(0xC00002DD) 831 831 - #define STATUS_INSUFFICIENT_POWER cpu_to_le32(0xC00002DE) 832 832 - #define STATUS_SAM_NEED_BOOTKEY_PASSWORD cpu_to_le32(0xC00002DF) 833 833 - #define STATUS_SAM_NEED_BOOTKEY_FLOPPY cpu_to_le32(0xC00002E0) 834 834 - #define STATUS_DS_CANT_START cpu_to_le32(0xC00002E1) 835 835 - #define STATUS_DS_INIT_FAILURE cpu_to_le32(0xC00002E2) 836 836 - #define STATUS_SAM_INIT_FAILURE cpu_to_le32(0xC00002E3) 837 837 - #define STATUS_DS_GC_REQUIRED cpu_to_le32(0xC00002E4) 838 838 - #define STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY cpu_to_le32(0xC00002E5) 839 839 - #define STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS cpu_to_le32(0xC00002E6) 840 840 - #define STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED cpu_to_le32(0xC00002E7) 841 841 - #define STATUS_MULTIPLE_FAULT_VIOLATION cpu_to_le32(0xC00002E8) 842 842 - #define STATUS_CURRENT_DOMAIN_NOT_ALLOWED cpu_to_le32(0xC00002E9) 843 843 - #define STATUS_CANNOT_MAKE cpu_to_le32(0xC00002EA) 844 844 - #define STATUS_SYSTEM_SHUTDOWN cpu_to_le32(0xC00002EB) 845 845 - #define STATUS_DS_INIT_FAILURE_CONSOLE cpu_to_le32(0xC00002EC) 846 846 - #define STATUS_DS_SAM_INIT_FAILURE_CONSOLE cpu_to_le32(0xC00002ED) 847 847 - #define STATUS_UNFINISHED_CONTEXT_DELETED cpu_to_le32(0xC00002EE) 848 848 - #define STATUS_NO_TGT_REPLY cpu_to_le32(0xC00002EF) 849 849 - #define STATUS_OBJECTID_NOT_FOUND cpu_to_le32(0xC00002F0) 850 850 - #define STATUS_NO_IP_ADDRESSES cpu_to_le32(0xC00002F1) 851 851 - #define STATUS_WRONG_CREDENTIAL_HANDLE cpu_to_le32(0xC00002F2) 852 852 - #define STATUS_CRYPTO_SYSTEM_INVALID cpu_to_le32(0xC00002F3) 853 853 - #define STATUS_MAX_REFERRALS_EXCEEDED cpu_to_le32(0xC00002F4) 854 854 - #define STATUS_MUST_BE_KDC cpu_to_le32(0xC00002F5) 855 855 - #define STATUS_STRONG_CRYPTO_NOT_SUPPORTED cpu_to_le32(0xC00002F6) 856 856 - #define STATUS_TOO_MANY_PRINCIPALS cpu_to_le32(0xC00002F7) 857 857 - #define STATUS_NO_PA_DATA cpu_to_le32(0xC00002F8) 858 858 - #define STATUS_PKINIT_NAME_MISMATCH cpu_to_le32(0xC00002F9) 859 859 - #define STATUS_SMARTCARD_LOGON_REQUIRED cpu_to_le32(0xC00002FA) 860 860 - #define STATUS_KDC_INVALID_REQUEST cpu_to_le32(0xC00002FB) 861 861 - #define STATUS_KDC_UNABLE_TO_REFER cpu_to_le32(0xC00002FC) 862 862 - #define STATUS_KDC_UNKNOWN_ETYPE cpu_to_le32(0xC00002FD) 863 863 - #define STATUS_SHUTDOWN_IN_PROGRESS cpu_to_le32(0xC00002FE) 864 864 - #define STATUS_SERVER_SHUTDOWN_IN_PROGRESS cpu_to_le32(0xC00002FF) 865 865 - #define STATUS_NOT_SUPPORTED_ON_SBS cpu_to_le32(0xC0000300) 866 866 - #define STATUS_WMI_GUID_DISCONNECTED cpu_to_le32(0xC0000301) 867 867 - #define STATUS_WMI_ALREADY_DISABLED cpu_to_le32(0xC0000302) 868 868 - #define STATUS_WMI_ALREADY_ENABLED cpu_to_le32(0xC0000303) 869 869 - #define STATUS_MFT_TOO_FRAGMENTED cpu_to_le32(0xC0000304) 870 870 - #define STATUS_COPY_PROTECTION_FAILURE cpu_to_le32(0xC0000305) 871 871 - #define STATUS_CSS_AUTHENTICATION_FAILURE cpu_to_le32(0xC0000306) 872 872 - #define STATUS_CSS_KEY_NOT_PRESENT cpu_to_le32(0xC0000307) 873 873 - #define STATUS_CSS_KEY_NOT_ESTABLISHED cpu_to_le32(0xC0000308) 874 874 - #define STATUS_CSS_SCRAMBLED_SECTOR cpu_to_le32(0xC0000309) 875 875 - #define STATUS_CSS_REGION_MISMATCH cpu_to_le32(0xC000030A) 876 876 - #define STATUS_CSS_RESETS_EXHAUSTED cpu_to_le32(0xC000030B) 877 877 - #define STATUS_PKINIT_FAILURE cpu_to_le32(0xC0000320) 878 878 - #define STATUS_SMARTCARD_SUBSYSTEM_FAILURE cpu_to_le32(0xC0000321) 879 879 - #define STATUS_NO_KERB_KEY cpu_to_le32(0xC0000322) 880 880 - #define STATUS_HOST_DOWN cpu_to_le32(0xC0000350) 881 881 - #define STATUS_UNSUPPORTED_PREAUTH cpu_to_le32(0xC0000351) 882 882 - #define STATUS_EFS_ALG_BLOB_TOO_BIG cpu_to_le32(0xC0000352) 883 883 - #define STATUS_PORT_NOT_SET cpu_to_le32(0xC0000353) 884 884 - #define STATUS_DEBUGGER_INACTIVE cpu_to_le32(0xC0000354) 885 885 - #define STATUS_DS_VERSION_CHECK_FAILURE cpu_to_le32(0xC0000355) 886 886 - #define STATUS_AUDITING_DISABLED cpu_to_le32(0xC0000356) 887 887 - #define STATUS_PRENT4_MACHINE_ACCOUNT cpu_to_le32(0xC0000357) 888 888 - #define STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC0000358) 889 889 - #define STATUS_INVALID_IMAGE_WIN_32 cpu_to_le32(0xC0000359) 890 890 - #define STATUS_INVALID_IMAGE_WIN_64 cpu_to_le32(0xC000035A) 891 891 - #define STATUS_BAD_BINDINGS cpu_to_le32(0xC000035B) 892 892 - #define STATUS_NETWORK_SESSION_EXPIRED cpu_to_le32(0xC000035C) 893 893 - #define STATUS_APPHELP_BLOCK cpu_to_le32(0xC000035D) 894 894 - #define STATUS_ALL_SIDS_FILTERED cpu_to_le32(0xC000035E) 895 895 - #define STATUS_NOT_SAFE_MODE_DRIVER cpu_to_le32(0xC000035F) 896 896 - #define STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT cpu_to_le32(0xC0000361) 897 897 - #define STATUS_ACCESS_DISABLED_BY_POLICY_PATH cpu_to_le32(0xC0000362) 898 898 - #define STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER cpu_to_le32(0xC0000363) 899 899 - #define STATUS_ACCESS_DISABLED_BY_POLICY_OTHER cpu_to_le32(0xC0000364) 900 900 - #define STATUS_FAILED_DRIVER_ENTRY cpu_to_le32(0xC0000365) 901 901 - #define STATUS_DEVICE_ENUMERATION_ERROR cpu_to_le32(0xC0000366) 902 902 - #define STATUS_MOUNT_POINT_NOT_RESOLVED cpu_to_le32(0xC0000368) 903 903 - #define STATUS_INVALID_DEVICE_OBJECT_PARAMETER cpu_to_le32(0xC0000369) 904 904 - #define STATUS_MCA_OCCURED cpu_to_le32(0xC000036A) 905 905 - #define STATUS_DRIVER_BLOCKED_CRITICAL cpu_to_le32(0xC000036B) 906 906 - #define STATUS_DRIVER_BLOCKED cpu_to_le32(0xC000036C) 907 907 - #define STATUS_DRIVER_DATABASE_ERROR cpu_to_le32(0xC000036D) 908 908 - #define STATUS_SYSTEM_HIVE_TOO_LARGE cpu_to_le32(0xC000036E) 909 909 - #define STATUS_INVALID_IMPORT_OF_NON_DLL cpu_to_le32(0xC000036F) 910 910 - #define STATUS_NO_SECRETS cpu_to_le32(0xC0000371) 911 911 - #define STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY cpu_to_le32(0xC0000372) 912 912 - #define STATUS_FAILED_STACK_SWITCH cpu_to_le32(0xC0000373) 913 913 - #define STATUS_HEAP_CORRUPTION cpu_to_le32(0xC0000374) 914 914 - #define STATUS_SMARTCARD_WRONG_PIN cpu_to_le32(0xC0000380) 915 915 - #define STATUS_SMARTCARD_CARD_BLOCKED cpu_to_le32(0xC0000381) 916 916 - #define STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED cpu_to_le32(0xC0000382) 917 917 - #define STATUS_SMARTCARD_NO_CARD cpu_to_le32(0xC0000383) 918 918 - #define STATUS_SMARTCARD_NO_KEY_CONTAINER cpu_to_le32(0xC0000384) 919 919 - #define STATUS_SMARTCARD_NO_CERTIFICATE cpu_to_le32(0xC0000385) 920 920 - #define STATUS_SMARTCARD_NO_KEYSET cpu_to_le32(0xC0000386) 921 921 - #define STATUS_SMARTCARD_IO_ERROR cpu_to_le32(0xC0000387) 922 922 - #define STATUS_DOWNGRADE_DETECTED cpu_to_le32(0xC0000388) 923 923 - #define STATUS_SMARTCARD_CERT_REVOKED cpu_to_le32(0xC0000389) 924 924 - #define STATUS_ISSUING_CA_UNTRUSTED cpu_to_le32(0xC000038A) 925 925 - #define STATUS_REVOCATION_OFFLINE_C cpu_to_le32(0xC000038B) 926 926 - #define STATUS_PKINIT_CLIENT_FAILURE cpu_to_le32(0xC000038C) 927 927 - #define STATUS_SMARTCARD_CERT_EXPIRED cpu_to_le32(0xC000038D) 928 928 - #define STATUS_DRIVER_FAILED_PRIOR_UNLOAD cpu_to_le32(0xC000038E) 929 929 - #define STATUS_SMARTCARD_SILENT_CONTEXT cpu_to_le32(0xC000038F) 930 930 - #define STATUS_PER_USER_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000401) 931 931 - #define STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000402) 932 932 - #define STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED cpu_to_le32(0xC0000403) 933 933 - #define STATUS_DS_NAME_NOT_UNIQUE cpu_to_le32(0xC0000404) 934 934 - #define STATUS_DS_DUPLICATE_ID_FOUND cpu_to_le32(0xC0000405) 935 935 - #define STATUS_DS_GROUP_CONVERSION_ERROR cpu_to_le32(0xC0000406) 936 936 - #define STATUS_VOLSNAP_PREPARE_HIBERNATE cpu_to_le32(0xC0000407) 937 937 - #define STATUS_USER2USER_REQUIRED cpu_to_le32(0xC0000408) 938 938 - #define STATUS_STACK_BUFFER_OVERRUN cpu_to_le32(0xC0000409) 939 939 - #define STATUS_NO_S4U_PROT_SUPPORT cpu_to_le32(0xC000040A) 940 940 - #define STATUS_CROSSREALM_DELEGATION_FAILURE cpu_to_le32(0xC000040B) 941 941 - #define STATUS_REVOCATION_OFFLINE_KDC cpu_to_le32(0xC000040C) 942 942 - #define STATUS_ISSUING_CA_UNTRUSTED_KDC cpu_to_le32(0xC000040D) 943 943 - #define STATUS_KDC_CERT_EXPIRED cpu_to_le32(0xC000040E) 944 944 - #define STATUS_KDC_CERT_REVOKED cpu_to_le32(0xC000040F) 945 945 - #define STATUS_PARAMETER_QUOTA_EXCEEDED cpu_to_le32(0xC0000410) 946 946 - #define STATUS_HIBERNATION_FAILURE cpu_to_le32(0xC0000411) 947 947 - #define STATUS_DELAY_LOAD_FAILED cpu_to_le32(0xC0000412) 948 948 - #define STATUS_AUTHENTICATION_FIREWALL_FAILED cpu_to_le32(0xC0000413) 949 949 - #define STATUS_VDM_DISALLOWED cpu_to_le32(0xC0000414) 950 950 - #define STATUS_HUNG_DISPLAY_DRIVER_THREAD cpu_to_le32(0xC0000415) 951 951 - #define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE cpu_to_le32(0xC0000416) 952 952 - #define STATUS_INVALID_CRUNTIME_PARAMETER cpu_to_le32(0xC0000417) 953 953 - #define STATUS_NTLM_BLOCKED cpu_to_le32(0xC0000418) 954 954 - #define STATUS_ASSERTION_FAILURE cpu_to_le32(0xC0000420) 955 955 - #define STATUS_VERIFIER_STOP cpu_to_le32(0xC0000421) 956 956 - #define STATUS_CALLBACK_POP_STACK cpu_to_le32(0xC0000423) 957 957 - #define STATUS_INCOMPATIBLE_DRIVER_BLOCKED cpu_to_le32(0xC0000424) 958 958 - #define STATUS_HIVE_UNLOADED cpu_to_le32(0xC0000425) 959 959 - #define STATUS_COMPRESSION_DISABLED cpu_to_le32(0xC0000426) 960 960 - #define STATUS_FILE_SYSTEM_LIMITATION cpu_to_le32(0xC0000427) 961 961 - #define STATUS_INVALID_IMAGE_HASH cpu_to_le32(0xC0000428) 962 962 - #define STATUS_NOT_CAPABLE cpu_to_le32(0xC0000429) 963 963 - #define STATUS_REQUEST_OUT_OF_SEQUENCE cpu_to_le32(0xC000042A) 964 964 - #define STATUS_IMPLEMENTATION_LIMIT cpu_to_le32(0xC000042B) 965 965 - #define STATUS_ELEVATION_REQUIRED cpu_to_le32(0xC000042C) 966 966 - #define STATUS_BEYOND_VDL cpu_to_le32(0xC0000432) 967 967 - #define STATUS_ENCOUNTERED_WRITE_IN_PROGRESS cpu_to_le32(0xC0000433) 968 968 - #define STATUS_PTE_CHANGED cpu_to_le32(0xC0000434) 969 969 - #define STATUS_PURGE_FAILED cpu_to_le32(0xC0000435) 970 970 - #define STATUS_CRED_REQUIRES_CONFIRMATION cpu_to_le32(0xC0000440) 971 971 - #define STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE cpu_to_le32(0xC0000441) 972 972 - #define STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER cpu_to_le32(0xC0000442) 973 973 - #define STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE cpu_to_le32(0xC0000443) 974 974 - #define STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE cpu_to_le32(0xC0000444) 975 975 - #define STATUS_CS_ENCRYPTION_FILE_NOT_CSE cpu_to_le32(0xC0000445) 976 976 - #define STATUS_INVALID_LABEL cpu_to_le32(0xC0000446) 977 977 - #define STATUS_DRIVER_PROCESS_TERMINATED cpu_to_le32(0xC0000450) 978 978 - #define STATUS_AMBIGUOUS_SYSTEM_DEVICE cpu_to_le32(0xC0000451) 979 979 - #define STATUS_SYSTEM_DEVICE_NOT_FOUND cpu_to_le32(0xC0000452) 980 980 - #define STATUS_RESTART_BOOT_APPLICATION cpu_to_le32(0xC0000453) 981 981 - #define STATUS_INVALID_TASK_NAME cpu_to_le32(0xC0000500) 982 982 - #define STATUS_INVALID_TASK_INDEX cpu_to_le32(0xC0000501) 983 983 - #define STATUS_THREAD_ALREADY_IN_TASK cpu_to_le32(0xC0000502) 984 984 - #define STATUS_CALLBACK_BYPASS cpu_to_le32(0xC0000503) 985 985 - #define STATUS_SERVER_UNAVAILABLE cpu_to_le32(0xC0000466) 986 986 - #define STATUS_FILE_NOT_AVAILABLE cpu_to_le32(0xC0000467) 987 987 - #define STATUS_PORT_CLOSED cpu_to_le32(0xC0000700) 988 988 - #define STATUS_MESSAGE_LOST cpu_to_le32(0xC0000701) 989 989 - #define STATUS_INVALID_MESSAGE cpu_to_le32(0xC0000702) 990 990 - #define STATUS_REQUEST_CANCELED cpu_to_le32(0xC0000703) 991 991 - #define STATUS_RECURSIVE_DISPATCH cpu_to_le32(0xC0000704) 992 992 - #define STATUS_LPC_RECEIVE_BUFFER_EXPECTED cpu_to_le32(0xC0000705) 993 993 - #define STATUS_LPC_INVALID_CONNECTION_USAGE cpu_to_le32(0xC0000706) 994 994 - #define STATUS_LPC_REQUESTS_NOT_ALLOWED cpu_to_le32(0xC0000707) 995 995 - #define STATUS_RESOURCE_IN_USE cpu_to_le32(0xC0000708) 996 996 - #define STATUS_HARDWARE_MEMORY_ERROR cpu_to_le32(0xC0000709) 997 997 - #define STATUS_THREADPOOL_HANDLE_EXCEPTION cpu_to_le32(0xC000070A) 998 998 - #define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED cpu_to_le32(0xC000070B) 999 999 - #define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED cpu_to_le32(0xC000070C) 1000 1000 - #define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED cpu_to_le32(0xC000070D) 1001 1001 - #define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED cpu_to_le32(0xC000070E) 1002 1002 - #define STATUS_THREADPOOL_RELEASED_DURING_OPERATION cpu_to_le32(0xC000070F) 1003 1003 - #define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000710) 1004 1004 - #define STATUS_APC_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000711) 1005 1005 - #define STATUS_PROCESS_IS_PROTECTED cpu_to_le32(0xC0000712) 1006 1006 - #define STATUS_MCA_EXCEPTION cpu_to_le32(0xC0000713) 1007 1007 - #define STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE cpu_to_le32(0xC0000714) 1008 1008 - #define STATUS_SYMLINK_CLASS_DISABLED cpu_to_le32(0xC0000715) 1009 1009 - #define STATUS_INVALID_IDN_NORMALIZATION cpu_to_le32(0xC0000716) 1010 1010 - #define STATUS_NO_UNICODE_TRANSLATION cpu_to_le32(0xC0000717) 1011 1011 - #define STATUS_ALREADY_REGISTERED cpu_to_le32(0xC0000718) 1012 1012 - #define STATUS_CONTEXT_MISMATCH cpu_to_le32(0xC0000719) 1013 1013 - #define STATUS_PORT_ALREADY_HAS_COMPLETION_LIST cpu_to_le32(0xC000071A) 1014 1014 - #define STATUS_CALLBACK_RETURNED_THREAD_PRIORITY cpu_to_le32(0xC000071B) 1015 1015 - #define STATUS_INVALID_THREAD cpu_to_le32(0xC000071C) 1016 1016 - #define STATUS_CALLBACK_RETURNED_TRANSACTION cpu_to_le32(0xC000071D) 1017 1017 - #define STATUS_CALLBACK_RETURNED_LDR_LOCK cpu_to_le32(0xC000071E) 1018 1018 - #define STATUS_CALLBACK_RETURNED_LANG cpu_to_le32(0xC000071F) 1019 1019 - #define STATUS_CALLBACK_RETURNED_PRI_BACK cpu_to_le32(0xC0000720) 1020 1020 - #define STATUS_CALLBACK_RETURNED_THREAD_AFFINITY cpu_to_le32(0xC0000721) 1021 1021 - #define STATUS_DISK_REPAIR_DISABLED cpu_to_le32(0xC0000800) 1022 1022 - #define STATUS_DS_DOMAIN_RENAME_IN_PROGRESS cpu_to_le32(0xC0000801) 1023 1023 - #define STATUS_DISK_QUOTA_EXCEEDED cpu_to_le32(0xC0000802) 1024 1024 - #define STATUS_CONTENT_BLOCKED cpu_to_le32(0xC0000804) 1025 1025 - #define STATUS_BAD_CLUSTERS cpu_to_le32(0xC0000805) 1026 1026 - #define STATUS_VOLUME_DIRTY cpu_to_le32(0xC0000806) 1027 1027 - #define STATUS_FILE_CHECKED_OUT cpu_to_le32(0xC0000901) 1028 1028 - #define STATUS_CHECKOUT_REQUIRED cpu_to_le32(0xC0000902) 1029 1029 - #define STATUS_BAD_FILE_TYPE cpu_to_le32(0xC0000903) 1030 1030 - #define STATUS_FILE_TOO_LARGE cpu_to_le32(0xC0000904) 1031 1031 - #define STATUS_FORMS_AUTH_REQUIRED cpu_to_le32(0xC0000905) 1032 1032 - #define STATUS_VIRUS_INFECTED cpu_to_le32(0xC0000906) 1033 1033 - #define STATUS_VIRUS_DELETED cpu_to_le32(0xC0000907) 1034 1034 - #define STATUS_BAD_MCFG_TABLE cpu_to_le32(0xC0000908) 1035 1035 - #define STATUS_WOW_ASSERTION cpu_to_le32(0xC0009898) 1036 1036 - #define STATUS_INVALID_SIGNATURE cpu_to_le32(0xC000A000) 1037 1037 - #define STATUS_HMAC_NOT_SUPPORTED cpu_to_le32(0xC000A001) 1038 1038 - #define STATUS_IPSEC_QUEUE_OVERFLOW cpu_to_le32(0xC000A010) 1039 1039 - #define STATUS_ND_QUEUE_OVERFLOW cpu_to_le32(0xC000A011) 1040 1040 - #define STATUS_HOPLIMIT_EXCEEDED cpu_to_le32(0xC000A012) 1041 1041 - #define STATUS_PROTOCOL_NOT_SUPPORTED cpu_to_le32(0xC000A013) 1042 1042 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED cpu_to_le32(0xC000A080) 1043 1043 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR cpu_to_le32(0xC000A081) 1044 1044 - #define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR cpu_to_le32(0xC000A082) 1045 1045 - #define STATUS_XML_PARSE_ERROR cpu_to_le32(0xC000A083) 1046 1046 - #define STATUS_XMLDSIG_ERROR cpu_to_le32(0xC000A084) 1047 1047 - #define STATUS_WRONG_COMPARTMENT cpu_to_le32(0xC000A085) 1048 1048 - #define STATUS_AUTHIP_FAILURE cpu_to_le32(0xC000A086) 1049 1049 - #define DBG_NO_STATE_CHANGE cpu_to_le32(0xC0010001) 1050 1050 - #define DBG_APP_NOT_IDLE cpu_to_le32(0xC0010002) 1051 1051 - #define RPC_NT_INVALID_STRING_BINDING cpu_to_le32(0xC0020001) 1052 1052 - #define RPC_NT_WRONG_KIND_OF_BINDING cpu_to_le32(0xC0020002) 1053 1053 - #define RPC_NT_INVALID_BINDING cpu_to_le32(0xC0020003) 1054 1054 - #define RPC_NT_PROTSEQ_NOT_SUPPORTED cpu_to_le32(0xC0020004) 1055 1055 - #define RPC_NT_INVALID_RPC_PROTSEQ cpu_to_le32(0xC0020005) 1056 1056 - #define RPC_NT_INVALID_STRING_UUID cpu_to_le32(0xC0020006) 1057 1057 - #define RPC_NT_INVALID_ENDPOINT_FORMAT cpu_to_le32(0xC0020007) 1058 1058 - #define RPC_NT_INVALID_NET_ADDR cpu_to_le32(0xC0020008) 1059 1059 - #define RPC_NT_NO_ENDPOINT_FOUND cpu_to_le32(0xC0020009) 1060 1060 - #define RPC_NT_INVALID_TIMEOUT cpu_to_le32(0xC002000A) 1061 1061 - #define RPC_NT_OBJECT_NOT_FOUND cpu_to_le32(0xC002000B) 1062 1062 - #define RPC_NT_ALREADY_REGISTERED cpu_to_le32(0xC002000C) 1063 1063 - #define RPC_NT_TYPE_ALREADY_REGISTERED cpu_to_le32(0xC002000D) 1064 1064 - #define RPC_NT_ALREADY_LISTENING cpu_to_le32(0xC002000E) 1065 1065 - #define RPC_NT_NO_PROTSEQS_REGISTERED cpu_to_le32(0xC002000F) 1066 1066 - #define RPC_NT_NOT_LISTENING cpu_to_le32(0xC0020010) 1067 1067 - #define RPC_NT_UNKNOWN_MGR_TYPE cpu_to_le32(0xC0020011) 1068 1068 - #define RPC_NT_UNKNOWN_IF cpu_to_le32(0xC0020012) 1069 1069 - #define RPC_NT_NO_BINDINGS cpu_to_le32(0xC0020013) 1070 1070 - #define RPC_NT_NO_PROTSEQS cpu_to_le32(0xC0020014) 1071 1071 - #define RPC_NT_CANT_CREATE_ENDPOINT cpu_to_le32(0xC0020015) 1072 1072 - #define RPC_NT_OUT_OF_RESOURCES cpu_to_le32(0xC0020016) 1073 1073 - #define RPC_NT_SERVER_UNAVAILABLE cpu_to_le32(0xC0020017) 1074 1074 - #define RPC_NT_SERVER_TOO_BUSY cpu_to_le32(0xC0020018) 1075 1075 - #define RPC_NT_INVALID_NETWORK_OPTIONS cpu_to_le32(0xC0020019) 1076 1076 - #define RPC_NT_NO_CALL_ACTIVE cpu_to_le32(0xC002001A) 1077 1077 - #define RPC_NT_CALL_FAILED cpu_to_le32(0xC002001B) 1078 1078 - #define RPC_NT_CALL_FAILED_DNE cpu_to_le32(0xC002001C) 1079 1079 - #define RPC_NT_PROTOCOL_ERROR cpu_to_le32(0xC002001D) 1080 1080 - #define RPC_NT_UNSUPPORTED_TRANS_SYN cpu_to_le32(0xC002001F) 1081 1081 - #define RPC_NT_UNSUPPORTED_TYPE cpu_to_le32(0xC0020021) 1082 1082 - #define RPC_NT_INVALID_TAG cpu_to_le32(0xC0020022) 1083 1083 - #define RPC_NT_INVALID_BOUND cpu_to_le32(0xC0020023) 1084 1084 - #define RPC_NT_NO_ENTRY_NAME cpu_to_le32(0xC0020024) 1085 1085 - #define RPC_NT_INVALID_NAME_SYNTAX cpu_to_le32(0xC0020025) 1086 1086 - #define RPC_NT_UNSUPPORTED_NAME_SYNTAX cpu_to_le32(0xC0020026) 1087 1087 - #define RPC_NT_UUID_NO_ADDRESS cpu_to_le32(0xC0020028) 1088 1088 - #define RPC_NT_DUPLICATE_ENDPOINT cpu_to_le32(0xC0020029) 1089 1089 - #define RPC_NT_UNKNOWN_AUTHN_TYPE cpu_to_le32(0xC002002A) 1090 1090 - #define RPC_NT_MAX_CALLS_TOO_SMALL cpu_to_le32(0xC002002B) 1091 1091 - #define RPC_NT_STRING_TOO_LONG cpu_to_le32(0xC002002C) 1092 1092 - #define RPC_NT_PROTSEQ_NOT_FOUND cpu_to_le32(0xC002002D) 1093 1093 - #define RPC_NT_PROCNUM_OUT_OF_RANGE cpu_to_le32(0xC002002E) 1094 1094 - #define RPC_NT_BINDING_HAS_NO_AUTH cpu_to_le32(0xC002002F) 1095 1095 - #define RPC_NT_UNKNOWN_AUTHN_SERVICE cpu_to_le32(0xC0020030) 1096 1096 - #define RPC_NT_UNKNOWN_AUTHN_LEVEL cpu_to_le32(0xC0020031) 1097 1097 - #define RPC_NT_INVALID_AUTH_IDENTITY cpu_to_le32(0xC0020032) 1098 1098 - #define RPC_NT_UNKNOWN_AUTHZ_SERVICE cpu_to_le32(0xC0020033) 1099 1099 - #define EPT_NT_INVALID_ENTRY cpu_to_le32(0xC0020034) 1100 1100 - #define EPT_NT_CANT_PERFORM_OP cpu_to_le32(0xC0020035) 1101 1101 - #define EPT_NT_NOT_REGISTERED cpu_to_le32(0xC0020036) 1102 1102 - #define RPC_NT_NOTHING_TO_EXPORT cpu_to_le32(0xC0020037) 1103 1103 - #define RPC_NT_INCOMPLETE_NAME cpu_to_le32(0xC0020038) 1104 1104 - #define RPC_NT_INVALID_VERS_OPTION cpu_to_le32(0xC0020039) 1105 1105 - #define RPC_NT_NO_MORE_MEMBERS cpu_to_le32(0xC002003A) 1106 1106 - #define RPC_NT_NOT_ALL_OBJS_UNEXPORTED cpu_to_le32(0xC002003B) 1107 1107 - #define RPC_NT_INTERFACE_NOT_FOUND cpu_to_le32(0xC002003C) 1108 1108 - #define RPC_NT_ENTRY_ALREADY_EXISTS cpu_to_le32(0xC002003D) 1109 1109 - #define RPC_NT_ENTRY_NOT_FOUND cpu_to_le32(0xC002003E) 1110 1110 - #define RPC_NT_NAME_SERVICE_UNAVAILABLE cpu_to_le32(0xC002003F) 1111 1111 - #define RPC_NT_INVALID_NAF_ID cpu_to_le32(0xC0020040) 1112 1112 - #define RPC_NT_CANNOT_SUPPORT cpu_to_le32(0xC0020041) 1113 1113 - #define RPC_NT_NO_CONTEXT_AVAILABLE cpu_to_le32(0xC0020042) 1114 1114 - #define RPC_NT_INTERNAL_ERROR cpu_to_le32(0xC0020043) 1115 1115 - #define RPC_NT_ZERO_DIVIDE cpu_to_le32(0xC0020044) 1116 1116 - #define RPC_NT_ADDRESS_ERROR cpu_to_le32(0xC0020045) 1117 1117 - #define RPC_NT_FP_DIV_ZERO cpu_to_le32(0xC0020046) 1118 1118 - #define RPC_NT_FP_UNDERFLOW cpu_to_le32(0xC0020047) 1119 1119 - #define RPC_NT_FP_OVERFLOW cpu_to_le32(0xC0020048) 1120 1120 - #define RPC_NT_CALL_IN_PROGRESS cpu_to_le32(0xC0020049) 1121 1121 - #define RPC_NT_NO_MORE_BINDINGS cpu_to_le32(0xC002004A) 1122 1122 - #define RPC_NT_GROUP_MEMBER_NOT_FOUND cpu_to_le32(0xC002004B) 1123 1123 - #define EPT_NT_CANT_CREATE cpu_to_le32(0xC002004C) 1124 1124 - #define RPC_NT_INVALID_OBJECT cpu_to_le32(0xC002004D) 1125 1125 - #define RPC_NT_NO_INTERFACES cpu_to_le32(0xC002004F) 1126 1126 - #define RPC_NT_CALL_CANCELLED cpu_to_le32(0xC0020050) 1127 1127 - #define RPC_NT_BINDING_INCOMPLETE cpu_to_le32(0xC0020051) 1128 1128 - #define RPC_NT_COMM_FAILURE cpu_to_le32(0xC0020052) 1129 1129 - #define RPC_NT_UNSUPPORTED_AUTHN_LEVEL cpu_to_le32(0xC0020053) 1130 1130 - #define RPC_NT_NO_PRINC_NAME cpu_to_le32(0xC0020054) 1131 1131 - #define RPC_NT_NOT_RPC_ERROR cpu_to_le32(0xC0020055) 1132 1132 - #define RPC_NT_SEC_PKG_ERROR cpu_to_le32(0xC0020057) 1133 1133 - #define RPC_NT_NOT_CANCELLED cpu_to_le32(0xC0020058) 1134 1134 - #define RPC_NT_INVALID_ASYNC_HANDLE cpu_to_le32(0xC0020062) 1135 1135 - #define RPC_NT_INVALID_ASYNC_CALL cpu_to_le32(0xC0020063) 1136 1136 - #define RPC_NT_PROXY_ACCESS_DENIED cpu_to_le32(0xC0020064) 1137 1137 - #define RPC_NT_NO_MORE_ENTRIES cpu_to_le32(0xC0030001) 1138 1138 - #define RPC_NT_SS_CHAR_TRANS_OPEN_FAIL cpu_to_le32(0xC0030002) 1139 1139 - #define RPC_NT_SS_CHAR_TRANS_SHORT_FILE cpu_to_le32(0xC0030003) 1140 1140 - #define RPC_NT_SS_IN_NULL_CONTEXT cpu_to_le32(0xC0030004) 1141 1141 - #define RPC_NT_SS_CONTEXT_MISMATCH cpu_to_le32(0xC0030005) 1142 1142 - #define RPC_NT_SS_CONTEXT_DAMAGED cpu_to_le32(0xC0030006) 1143 1143 - #define RPC_NT_SS_HANDLES_MISMATCH cpu_to_le32(0xC0030007) 1144 1144 - #define RPC_NT_SS_CANNOT_GET_CALL_HANDLE cpu_to_le32(0xC0030008) 1145 1145 - #define RPC_NT_NULL_REF_POINTER cpu_to_le32(0xC0030009) 1146 1146 - #define RPC_NT_ENUM_VALUE_OUT_OF_RANGE cpu_to_le32(0xC003000A) 1147 1147 - #define RPC_NT_BYTE_COUNT_TOO_SMALL cpu_to_le32(0xC003000B) 1148 1148 - #define RPC_NT_BAD_STUB_DATA cpu_to_le32(0xC003000C) 1149 1149 - #define RPC_NT_INVALID_ES_ACTION cpu_to_le32(0xC0030059) 1150 1150 - #define RPC_NT_WRONG_ES_VERSION cpu_to_le32(0xC003005A) 1151 1151 - #define RPC_NT_WRONG_STUB_VERSION cpu_to_le32(0xC003005B) 1152 1152 - #define RPC_NT_INVALID_PIPE_OBJECT cpu_to_le32(0xC003005C) 1153 1153 - #define RPC_NT_INVALID_PIPE_OPERATION cpu_to_le32(0xC003005D) 1154 1154 - #define RPC_NT_WRONG_PIPE_VERSION cpu_to_le32(0xC003005E) 1155 1155 - #define RPC_NT_PIPE_CLOSED cpu_to_le32(0xC003005F) 1156 1156 - #define RPC_NT_PIPE_DISCIPLINE_ERROR cpu_to_le32(0xC0030060) 1157 1157 - #define RPC_NT_PIPE_EMPTY cpu_to_le32(0xC0030061) 1158 1158 - #define STATUS_PNP_BAD_MPS_TABLE cpu_to_le32(0xC0040035) 1159 1159 - #define STATUS_PNP_TRANSLATION_FAILED cpu_to_le32(0xC0040036) 1160 1160 - #define STATUS_PNP_IRQ_TRANSLATION_FAILED cpu_to_le32(0xC0040037) 1161 1161 - #define STATUS_PNP_INVALID_ID cpu_to_le32(0xC0040038) 1162 1162 - #define STATUS_IO_REISSUE_AS_CACHED cpu_to_le32(0xC0040039) 1163 1163 - #define STATUS_CTX_WINSTATION_NAME_INVALID cpu_to_le32(0xC00A0001) 1164 1164 - #define STATUS_CTX_INVALID_PD cpu_to_le32(0xC00A0002) 1165 1165 - #define STATUS_CTX_PD_NOT_FOUND cpu_to_le32(0xC00A0003) 1166 1166 - #define STATUS_CTX_CLOSE_PENDING cpu_to_le32(0xC00A0006) 1167 1167 - #define STATUS_CTX_NO_OUTBUF cpu_to_le32(0xC00A0007) 1168 1168 - #define STATUS_CTX_MODEM_INF_NOT_FOUND cpu_to_le32(0xC00A0008) 1169 1169 - #define STATUS_CTX_INVALID_MODEMNAME cpu_to_le32(0xC00A0009) 1170 1170 - #define STATUS_CTX_RESPONSE_ERROR cpu_to_le32(0xC00A000A) 1171 1171 - #define STATUS_CTX_MODEM_RESPONSE_TIMEOUT cpu_to_le32(0xC00A000B) 1172 1172 - #define STATUS_CTX_MODEM_RESPONSE_NO_CARRIER cpu_to_le32(0xC00A000C) 1173 1173 - #define STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE cpu_to_le32(0xC00A000D) 1174 1174 - #define STATUS_CTX_MODEM_RESPONSE_BUSY cpu_to_le32(0xC00A000E) 1175 1175 - #define STATUS_CTX_MODEM_RESPONSE_VOICE cpu_to_le32(0xC00A000F) 1176 1176 - #define STATUS_CTX_TD_ERROR cpu_to_le32(0xC00A0010) 1177 1177 - #define STATUS_CTX_LICENSE_CLIENT_INVALID cpu_to_le32(0xC00A0012) 1178 1178 - #define STATUS_CTX_LICENSE_NOT_AVAILABLE cpu_to_le32(0xC00A0013) 1179 1179 - #define STATUS_CTX_LICENSE_EXPIRED cpu_to_le32(0xC00A0014) 1180 1180 - #define STATUS_CTX_WINSTATION_NOT_FOUND cpu_to_le32(0xC00A0015) 1181 1181 - #define STATUS_CTX_WINSTATION_NAME_COLLISION cpu_to_le32(0xC00A0016) 1182 1182 - #define STATUS_CTX_WINSTATION_BUSY cpu_to_le32(0xC00A0017) 1183 1183 - #define STATUS_CTX_BAD_VIDEO_MODE cpu_to_le32(0xC00A0018) 1184 1184 - #define STATUS_CTX_GRAPHICS_INVALID cpu_to_le32(0xC00A0022) 1185 1185 - #define STATUS_CTX_NOT_CONSOLE cpu_to_le32(0xC00A0024) 1186 1186 - #define STATUS_CTX_CLIENT_QUERY_TIMEOUT cpu_to_le32(0xC00A0026) 1187 1187 - #define STATUS_CTX_CONSOLE_DISCONNECT cpu_to_le32(0xC00A0027) 1188 1188 - #define STATUS_CTX_CONSOLE_CONNECT cpu_to_le32(0xC00A0028) 1189 1189 - #define STATUS_CTX_SHADOW_DENIED cpu_to_le32(0xC00A002A) 1190 1190 - #define STATUS_CTX_WINSTATION_ACCESS_DENIED cpu_to_le32(0xC00A002B) 1191 1191 - #define STATUS_CTX_INVALID_WD cpu_to_le32(0xC00A002E) 1192 1192 - #define STATUS_CTX_WD_NOT_FOUND cpu_to_le32(0xC00A002F) 1193 1193 - #define STATUS_CTX_SHADOW_INVALID cpu_to_le32(0xC00A0030) 1194 1194 - #define STATUS_CTX_SHADOW_DISABLED cpu_to_le32(0xC00A0031) 1195 1195 - #define STATUS_RDP_PROTOCOL_ERROR cpu_to_le32(0xC00A0032) 1196 1196 - #define STATUS_CTX_CLIENT_LICENSE_NOT_SET cpu_to_le32(0xC00A0033) 1197 1197 - #define STATUS_CTX_CLIENT_LICENSE_IN_USE cpu_to_le32(0xC00A0034) 1198 1198 - #define STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE cpu_to_le32(0xC00A0035) 1199 1199 - #define STATUS_CTX_SHADOW_NOT_RUNNING cpu_to_le32(0xC00A0036) 1200 1200 - #define STATUS_CTX_LOGON_DISABLED cpu_to_le32(0xC00A0037) 1201 1201 - #define STATUS_CTX_SECURITY_LAYER_ERROR cpu_to_le32(0xC00A0038) 1202 1202 - #define STATUS_TS_INCOMPATIBLE_SESSIONS cpu_to_le32(0xC00A0039) 1203 1203 - #define STATUS_MUI_FILE_NOT_FOUND cpu_to_le32(0xC00B0001) 1204 1204 - #define STATUS_MUI_INVALID_FILE cpu_to_le32(0xC00B0002) 1205 1205 - #define STATUS_MUI_INVALID_RC_CONFIG cpu_to_le32(0xC00B0003) 1206 1206 - #define STATUS_MUI_INVALID_LOCALE_NAME cpu_to_le32(0xC00B0004) 1207 1207 - #define STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME cpu_to_le32(0xC00B0005) 1208 1208 - #define STATUS_MUI_FILE_NOT_LOADED cpu_to_le32(0xC00B0006) 1209 1209 - #define STATUS_RESOURCE_ENUM_USER_STOP cpu_to_le32(0xC00B0007) 1210 1210 - #define STATUS_CLUSTER_INVALID_NODE cpu_to_le32(0xC0130001) 1211 1211 - #define STATUS_CLUSTER_NODE_EXISTS cpu_to_le32(0xC0130002) 1212 1212 - #define STATUS_CLUSTER_JOIN_IN_PROGRESS cpu_to_le32(0xC0130003) 1213 1213 - #define STATUS_CLUSTER_NODE_NOT_FOUND cpu_to_le32(0xC0130004) 1214 1214 - #define STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND cpu_to_le32(0xC0130005) 1215 1215 - #define STATUS_CLUSTER_NETWORK_EXISTS cpu_to_le32(0xC0130006) 1216 1216 - #define STATUS_CLUSTER_NETWORK_NOT_FOUND cpu_to_le32(0xC0130007) 1217 1217 - #define STATUS_CLUSTER_NETINTERFACE_EXISTS cpu_to_le32(0xC0130008) 1218 1218 - #define STATUS_CLUSTER_NETINTERFACE_NOT_FOUND cpu_to_le32(0xC0130009) 1219 1219 - #define STATUS_CLUSTER_INVALID_REQUEST cpu_to_le32(0xC013000A) 1220 1220 - #define STATUS_CLUSTER_INVALID_NETWORK_PROVIDER cpu_to_le32(0xC013000B) 1221 1221 - #define STATUS_CLUSTER_NODE_DOWN cpu_to_le32(0xC013000C) 1222 1222 - #define STATUS_CLUSTER_NODE_UNREACHABLE cpu_to_le32(0xC013000D) 1223 1223 - #define STATUS_CLUSTER_NODE_NOT_MEMBER cpu_to_le32(0xC013000E) 1224 1224 - #define STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS cpu_to_le32(0xC013000F) 1225 1225 - #define STATUS_CLUSTER_INVALID_NETWORK cpu_to_le32(0xC0130010) 1226 1226 - #define STATUS_CLUSTER_NO_NET_ADAPTERS cpu_to_le32(0xC0130011) 1227 1227 - #define STATUS_CLUSTER_NODE_UP cpu_to_le32(0xC0130012) 1228 1228 - #define STATUS_CLUSTER_NODE_PAUSED cpu_to_le32(0xC0130013) 1229 1229 - #define STATUS_CLUSTER_NODE_NOT_PAUSED cpu_to_le32(0xC0130014) 1230 1230 - #define STATUS_CLUSTER_NO_SECURITY_CONTEXT cpu_to_le32(0xC0130015) 1231 1231 - #define STATUS_CLUSTER_NETWORK_NOT_INTERNAL cpu_to_le32(0xC0130016) 1232 1232 - #define STATUS_CLUSTER_POISONED cpu_to_le32(0xC0130017) 1233 1233 - #define STATUS_ACPI_INVALID_OPCODE cpu_to_le32(0xC0140001) 1234 1234 - #define STATUS_ACPI_STACK_OVERFLOW cpu_to_le32(0xC0140002) 1235 1235 - #define STATUS_ACPI_ASSERT_FAILED cpu_to_le32(0xC0140003) 1236 1236 - #define STATUS_ACPI_INVALID_INDEX cpu_to_le32(0xC0140004) 1237 1237 - #define STATUS_ACPI_INVALID_ARGUMENT cpu_to_le32(0xC0140005) 1238 1238 - #define STATUS_ACPI_FATAL cpu_to_le32(0xC0140006) 1239 1239 - #define STATUS_ACPI_INVALID_SUPERNAME cpu_to_le32(0xC0140007) 1240 1240 - #define STATUS_ACPI_INVALID_ARGTYPE cpu_to_le32(0xC0140008) 1241 1241 - #define STATUS_ACPI_INVALID_OBJTYPE cpu_to_le32(0xC0140009) 1242 1242 - #define STATUS_ACPI_INVALID_TARGETTYPE cpu_to_le32(0xC014000A) 1243 1243 - #define STATUS_ACPI_INCORRECT_ARGUMENT_COUNT cpu_to_le32(0xC014000B) 1244 1244 - #define STATUS_ACPI_ADDRESS_NOT_MAPPED cpu_to_le32(0xC014000C) 1245 1245 - #define STATUS_ACPI_INVALID_EVENTTYPE cpu_to_le32(0xC014000D) 1246 1246 - #define STATUS_ACPI_HANDLER_COLLISION cpu_to_le32(0xC014000E) 1247 1247 - #define STATUS_ACPI_INVALID_DATA cpu_to_le32(0xC014000F) 1248 1248 - #define STATUS_ACPI_INVALID_REGION cpu_to_le32(0xC0140010) 1249 1249 - #define STATUS_ACPI_INVALID_ACCESS_SIZE cpu_to_le32(0xC0140011) 1250 1250 - #define STATUS_ACPI_ACQUIRE_GLOBAL_LOCK cpu_to_le32(0xC0140012) 1251 1251 - #define STATUS_ACPI_ALREADY_INITIALIZED cpu_to_le32(0xC0140013) 1252 1252 - #define STATUS_ACPI_NOT_INITIALIZED cpu_to_le32(0xC0140014) 1253 1253 - #define STATUS_ACPI_INVALID_MUTEX_LEVEL cpu_to_le32(0xC0140015) 1254 1254 - #define STATUS_ACPI_MUTEX_NOT_OWNED cpu_to_le32(0xC0140016) 1255 1255 - #define STATUS_ACPI_MUTEX_NOT_OWNER cpu_to_le32(0xC0140017) 1256 1256 - #define STATUS_ACPI_RS_ACCESS cpu_to_le32(0xC0140018) 1257 1257 - #define STATUS_ACPI_INVALID_TABLE cpu_to_le32(0xC0140019) 1258 1258 - #define STATUS_ACPI_REG_HANDLER_FAILED cpu_to_le32(0xC0140020) 1259 1259 - #define STATUS_ACPI_POWER_REQUEST_FAILED cpu_to_le32(0xC0140021) 1260 1260 - #define STATUS_SXS_SECTION_NOT_FOUND cpu_to_le32(0xC0150001) 1261 1261 - #define STATUS_SXS_CANT_GEN_ACTCTX cpu_to_le32(0xC0150002) 1262 1262 - #define STATUS_SXS_INVALID_ACTCTXDATA_FORMAT cpu_to_le32(0xC0150003) 1263 1263 - #define STATUS_SXS_ASSEMBLY_NOT_FOUND cpu_to_le32(0xC0150004) 1264 1264 - #define STATUS_SXS_MANIFEST_FORMAT_ERROR cpu_to_le32(0xC0150005) 1265 1265 - #define STATUS_SXS_MANIFEST_PARSE_ERROR cpu_to_le32(0xC0150006) 1266 1266 - #define STATUS_SXS_ACTIVATION_CONTEXT_DISABLED cpu_to_le32(0xC0150007) 1267 1267 - #define STATUS_SXS_KEY_NOT_FOUND cpu_to_le32(0xC0150008) 1268 1268 - #define STATUS_SXS_VERSION_CONFLICT cpu_to_le32(0xC0150009) 1269 1269 - #define STATUS_SXS_WRONG_SECTION_TYPE cpu_to_le32(0xC015000A) 1270 1270 - #define STATUS_SXS_THREAD_QUERIES_DISABLED cpu_to_le32(0xC015000B) 1271 1271 - #define STATUS_SXS_ASSEMBLY_MISSING cpu_to_le32(0xC015000C) 1272 1272 - #define STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET cpu_to_le32(0xC015000E) 1273 1273 - #define STATUS_SXS_EARLY_DEACTIVATION cpu_to_le32(0xC015000F) 1274 1274 - #define STATUS_SXS_INVALID_DEACTIVATION cpu_to_le32(0xC0150010) 1275 1275 - #define STATUS_SXS_MULTIPLE_DEACTIVATION cpu_to_le32(0xC0150011) 1276 1276 - #define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY cpu_to_le32(0xC0150012) 1277 1277 - #define STATUS_SXS_PROCESS_TERMINATION_REQUESTED cpu_to_le32(0xC0150013) 1278 1278 - #define STATUS_SXS_CORRUPT_ACTIVATION_STACK cpu_to_le32(0xC0150014) 1279 1279 - #define STATUS_SXS_CORRUPTION cpu_to_le32(0xC0150015) 1280 1280 - #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE cpu_to_le32(0xC0150016) 1281 1281 - #define STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME cpu_to_le32(0xC0150017) 1282 1282 - #define STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE cpu_to_le32(0xC0150018) 1283 1283 - #define STATUS_SXS_IDENTITY_PARSE_ERROR cpu_to_le32(0xC0150019) 1284 1284 - #define STATUS_SXS_COMPONENT_STORE_CORRUPT cpu_to_le32(0xC015001A) 1285 1285 - #define STATUS_SXS_FILE_HASH_MISMATCH cpu_to_le32(0xC015001B) 1286 1286 - #define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT cpu_to_le32(0xC015001C) 1287 1287 - #define STATUS_SXS_IDENTITIES_DIFFERENT cpu_to_le32(0xC015001D) 1288 1288 - #define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT cpu_to_le32(0xC015001E) 1289 1289 - #define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY cpu_to_le32(0xC015001F) 1290 1290 - #define STATUS_ADVANCED_INSTALLER_FAILED cpu_to_le32(0xC0150020) 1291 1291 - #define STATUS_XML_ENCODING_MISMATCH cpu_to_le32(0xC0150021) 1292 1292 - #define STATUS_SXS_MANIFEST_TOO_BIG cpu_to_le32(0xC0150022) 1293 1293 - #define STATUS_SXS_SETTING_NOT_REGISTERED cpu_to_le32(0xC0150023) 1294 1294 - #define STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE cpu_to_le32(0xC0150024) 1295 1295 - #define STATUS_SMI_PRIMITIVE_INSTALLER_FAILED cpu_to_le32(0xC0150025) 1296 1296 - #define STATUS_GENERIC_COMMAND_FAILED cpu_to_le32(0xC0150026) 1297 1297 - #define STATUS_SXS_FILE_HASH_MISSING cpu_to_le32(0xC0150027) 1298 1298 - #define STATUS_TRANSACTIONAL_CONFLICT cpu_to_le32(0xC0190001) 1299 1299 - #define STATUS_INVALID_TRANSACTION cpu_to_le32(0xC0190002) 1300 1300 - #define STATUS_TRANSACTION_NOT_ACTIVE cpu_to_le32(0xC0190003) 1301 1301 - #define STATUS_TM_INITIALIZATION_FAILED cpu_to_le32(0xC0190004) 1302 1302 - #define STATUS_RM_NOT_ACTIVE cpu_to_le32(0xC0190005) 1303 1303 - #define STATUS_RM_METADATA_CORRUPT cpu_to_le32(0xC0190006) 1304 1304 - #define STATUS_TRANSACTION_NOT_JOINED cpu_to_le32(0xC0190007) 1305 1305 - #define STATUS_DIRECTORY_NOT_RM cpu_to_le32(0xC0190008) 1306 1306 - #define STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE cpu_to_le32(0xC019000A) 1307 1307 - #define STATUS_LOG_RESIZE_INVALID_SIZE cpu_to_le32(0xC019000B) 1308 1308 - #define STATUS_REMOTE_FILE_VERSION_MISMATCH cpu_to_le32(0xC019000C) 1309 1309 - #define STATUS_CRM_PROTOCOL_ALREADY_EXISTS cpu_to_le32(0xC019000F) 1310 1310 - #define STATUS_TRANSACTION_PROPAGATION_FAILED cpu_to_le32(0xC0190010) 1311 1311 - #define STATUS_CRM_PROTOCOL_NOT_FOUND cpu_to_le32(0xC0190011) 1312 1312 - #define STATUS_TRANSACTION_SUPERIOR_EXISTS cpu_to_le32(0xC0190012) 1313 1313 - #define STATUS_TRANSACTION_REQUEST_NOT_VALID cpu_to_le32(0xC0190013) 1314 1314 - #define STATUS_TRANSACTION_NOT_REQUESTED cpu_to_le32(0xC0190014) 1315 1315 - #define STATUS_TRANSACTION_ALREADY_ABORTED cpu_to_le32(0xC0190015) 1316 1316 - #define STATUS_TRANSACTION_ALREADY_COMMITTED cpu_to_le32(0xC0190016) 1317 1317 - #define STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER cpu_to_le32(0xC0190017) 1318 1318 - #define STATUS_CURRENT_TRANSACTION_NOT_VALID cpu_to_le32(0xC0190018) 1319 1319 - #define STATUS_LOG_GROWTH_FAILED cpu_to_le32(0xC0190019) 1320 1320 - #define STATUS_OBJECT_NO_LONGER_EXISTS cpu_to_le32(0xC0190021) 1321 1321 - #define STATUS_STREAM_MINIVERSION_NOT_FOUND cpu_to_le32(0xC0190022) 1322 1322 - #define STATUS_STREAM_MINIVERSION_NOT_VALID cpu_to_le32(0xC0190023) 1323 1323 - #define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION cpu_to_le32(0xC0190024) 1324 1324 - #define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT cpu_to_le32(0xC0190025) 1325 1325 - #define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS cpu_to_le32(0xC0190026) 1326 1326 - #define STATUS_HANDLE_NO_LONGER_VALID cpu_to_le32(0xC0190028) 1327 1327 - #define STATUS_LOG_CORRUPTION_DETECTED cpu_to_le32(0xC0190030) 1328 1328 - #define STATUS_RM_DISCONNECTED cpu_to_le32(0xC0190032) 1329 1329 - #define STATUS_ENLISTMENT_NOT_SUPERIOR cpu_to_le32(0xC0190033) 1330 1330 - #define STATUS_FILE_IDENTITY_NOT_PERSISTENT cpu_to_le32(0xC0190036) 1331 1331 - #define STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY cpu_to_le32(0xC0190037) 1332 1332 - #define STATUS_CANT_CROSS_RM_BOUNDARY cpu_to_le32(0xC0190038) 1333 1333 - #define STATUS_TXF_DIR_NOT_EMPTY cpu_to_le32(0xC0190039) 1334 1334 - #define STATUS_INDOUBT_TRANSACTIONS_EXIST cpu_to_le32(0xC019003A) 1335 1335 - #define STATUS_TM_VOLATILE cpu_to_le32(0xC019003B) 1336 1336 - #define STATUS_ROLLBACK_TIMER_EXPIRED cpu_to_le32(0xC019003C) 1337 1337 - #define STATUS_TXF_ATTRIBUTE_CORRUPT cpu_to_le32(0xC019003D) 1338 1338 - #define STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC019003E) 1339 1339 - #define STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED cpu_to_le32(0xC019003F) 1340 1340 - #define STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE cpu_to_le32(0xC0190040) 1341 1341 - #define STATUS_TRANSACTION_REQUIRED_PROMOTION cpu_to_le32(0xC0190043) 1342 1342 - #define STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION cpu_to_le32(0xC0190044) 1343 1343 - #define STATUS_TRANSACTIONS_NOT_FROZEN cpu_to_le32(0xC0190045) 1344 1344 - #define STATUS_TRANSACTION_FREEZE_IN_PROGRESS cpu_to_le32(0xC0190046) 1345 1345 - #define STATUS_NOT_SNAPSHOT_VOLUME cpu_to_le32(0xC0190047) 1346 1346 - #define STATUS_NO_SAVEPOINT_WITH_OPEN_FILES cpu_to_le32(0xC0190048) 1347 1347 - #define STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190049) 1348 1348 - #define STATUS_TM_IDENTITY_MISMATCH cpu_to_le32(0xC019004A) 1349 1349 - #define STATUS_FLOATED_SECTION cpu_to_le32(0xC019004B) 1350 1350 - #define STATUS_CANNOT_ACCEPT_TRANSACTED_WORK cpu_to_le32(0xC019004C) 1351 1351 - #define STATUS_CANNOT_ABORT_TRANSACTIONS cpu_to_le32(0xC019004D) 1352 1352 - #define STATUS_TRANSACTION_NOT_FOUND cpu_to_le32(0xC019004E) 1353 1353 - #define STATUS_RESOURCEMANAGER_NOT_FOUND cpu_to_le32(0xC019004F) 1354 1354 - #define STATUS_ENLISTMENT_NOT_FOUND cpu_to_le32(0xC0190050) 1355 1355 - #define STATUS_TRANSACTIONMANAGER_NOT_FOUND cpu_to_le32(0xC0190051) 1356 1356 - #define STATUS_TRANSACTIONMANAGER_NOT_ONLINE cpu_to_le32(0xC0190052) 1357 1357 - #define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION cpu_to_le32(0xC0190053) 1358 1358 - #define STATUS_TRANSACTION_NOT_ROOT cpu_to_le32(0xC0190054) 1359 1359 - #define STATUS_TRANSACTION_OBJECT_EXPIRED cpu_to_le32(0xC0190055) 1360 1360 - #define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190056) 1361 1361 - #define STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED cpu_to_le32(0xC0190057) 1362 1362 - #define STATUS_TRANSACTION_RECORD_TOO_LONG cpu_to_le32(0xC0190058) 1363 1363 - #define STATUS_NO_LINK_TRACKING_IN_TRANSACTION cpu_to_le32(0xC0190059) 1364 1364 - #define STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION cpu_to_le32(0xC019005A) 1365 1365 - #define STATUS_TRANSACTION_INTEGRITY_VIOLATED cpu_to_le32(0xC019005B) 1366 1366 - #define STATUS_LOG_SECTOR_INVALID cpu_to_le32(0xC01A0001) 1367 1367 - #define STATUS_LOG_SECTOR_PARITY_INVALID cpu_to_le32(0xC01A0002) 1368 1368 - #define STATUS_LOG_SECTOR_REMAPPED cpu_to_le32(0xC01A0003) 1369 1369 - #define STATUS_LOG_BLOCK_INCOMPLETE cpu_to_le32(0xC01A0004) 1370 1370 - #define STATUS_LOG_INVALID_RANGE cpu_to_le32(0xC01A0005) 1371 1371 - #define STATUS_LOG_BLOCKS_EXHAUSTED cpu_to_le32(0xC01A0006) 1372 1372 - #define STATUS_LOG_READ_CONTEXT_INVALID cpu_to_le32(0xC01A0007) 1373 1373 - #define STATUS_LOG_RESTART_INVALID cpu_to_le32(0xC01A0008) 1374 1374 - #define STATUS_LOG_BLOCK_VERSION cpu_to_le32(0xC01A0009) 1375 1375 - #define STATUS_LOG_BLOCK_INVALID cpu_to_le32(0xC01A000A) 1376 1376 - #define STATUS_LOG_READ_MODE_INVALID cpu_to_le32(0xC01A000B) 1377 1377 - #define STATUS_LOG_METADATA_CORRUPT cpu_to_le32(0xC01A000D) 1378 1378 - #define STATUS_LOG_METADATA_INVALID cpu_to_le32(0xC01A000E) 1379 1379 - #define STATUS_LOG_METADATA_INCONSISTENT cpu_to_le32(0xC01A000F) 1380 1380 - #define STATUS_LOG_RESERVATION_INVALID cpu_to_le32(0xC01A0010) 1381 1381 - #define STATUS_LOG_CANT_DELETE cpu_to_le32(0xC01A0011) 1382 1382 - #define STATUS_LOG_CONTAINER_LIMIT_EXCEEDED cpu_to_le32(0xC01A0012) 1383 1383 - #define STATUS_LOG_START_OF_LOG cpu_to_le32(0xC01A0013) 1384 1384 - #define STATUS_LOG_POLICY_ALREADY_INSTALLED cpu_to_le32(0xC01A0014) 1385 1385 - #define STATUS_LOG_POLICY_NOT_INSTALLED cpu_to_le32(0xC01A0015) 1386 1386 - #define STATUS_LOG_POLICY_INVALID cpu_to_le32(0xC01A0016) 1387 1387 - #define STATUS_LOG_POLICY_CONFLICT cpu_to_le32(0xC01A0017) 1388 1388 - #define STATUS_LOG_PINNED_ARCHIVE_TAIL cpu_to_le32(0xC01A0018) 1389 1389 - #define STATUS_LOG_RECORD_NONEXISTENT cpu_to_le32(0xC01A0019) 1390 1390 - #define STATUS_LOG_RECORDS_RESERVED_INVALID cpu_to_le32(0xC01A001A) 1391 1391 - #define STATUS_LOG_SPACE_RESERVED_INVALID cpu_to_le32(0xC01A001B) 1392 1392 - #define STATUS_LOG_TAIL_INVALID cpu_to_le32(0xC01A001C) 1393 1393 - #define STATUS_LOG_FULL cpu_to_le32(0xC01A001D) 1394 1394 - #define STATUS_LOG_MULTIPLEXED cpu_to_le32(0xC01A001E) 1395 1395 - #define STATUS_LOG_DEDICATED cpu_to_le32(0xC01A001F) 1396 1396 - #define STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS cpu_to_le32(0xC01A0020) 1397 1397 - #define STATUS_LOG_ARCHIVE_IN_PROGRESS cpu_to_le32(0xC01A0021) 1398 1398 - #define STATUS_LOG_EPHEMERAL cpu_to_le32(0xC01A0022) 1399 1399 - #define STATUS_LOG_NOT_ENOUGH_CONTAINERS cpu_to_le32(0xC01A0023) 1400 1400 - #define STATUS_LOG_CLIENT_ALREADY_REGISTERED cpu_to_le32(0xC01A0024) 1401 1401 - #define STATUS_LOG_CLIENT_NOT_REGISTERED cpu_to_le32(0xC01A0025) 1402 1402 - #define STATUS_LOG_FULL_HANDLER_IN_PROGRESS cpu_to_le32(0xC01A0026) 1403 1403 - #define STATUS_LOG_CONTAINER_READ_FAILED cpu_to_le32(0xC01A0027) 1404 1404 - #define STATUS_LOG_CONTAINER_WRITE_FAILED cpu_to_le32(0xC01A0028) 1405 1405 - #define STATUS_LOG_CONTAINER_OPEN_FAILED cpu_to_le32(0xC01A0029) 1406 1406 - #define STATUS_LOG_CONTAINER_STATE_INVALID cpu_to_le32(0xC01A002A) 1407 1407 - #define STATUS_LOG_STATE_INVALID cpu_to_le32(0xC01A002B) 1408 1408 - #define STATUS_LOG_PINNED cpu_to_le32(0xC01A002C) 1409 1409 - #define STATUS_LOG_METADATA_FLUSH_FAILED cpu_to_le32(0xC01A002D) 1410 1410 - #define STATUS_LOG_INCONSISTENT_SECURITY cpu_to_le32(0xC01A002E) 1411 1411 - #define STATUS_LOG_APPENDED_FLUSH_FAILED cpu_to_le32(0xC01A002F) 1412 1412 - #define STATUS_LOG_PINNED_RESERVATION cpu_to_le32(0xC01A0030) 1413 1413 - #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD cpu_to_le32(0xC01B00EA) 1414 1414 - #define STATUS_FLT_NO_HANDLER_DEFINED cpu_to_le32(0xC01C0001) 1415 1415 - #define STATUS_FLT_CONTEXT_ALREADY_DEFINED cpu_to_le32(0xC01C0002) 1416 1416 - #define STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST cpu_to_le32(0xC01C0003) 1417 1417 - #define STATUS_FLT_DISALLOW_FAST_IO cpu_to_le32(0xC01C0004) 1418 1418 - #define STATUS_FLT_INVALID_NAME_REQUEST cpu_to_le32(0xC01C0005) 1419 1419 - #define STATUS_FLT_NOT_SAFE_TO_POST_OPERATION cpu_to_le32(0xC01C0006) 1420 1420 - #define STATUS_FLT_NOT_INITIALIZED cpu_to_le32(0xC01C0007) 1421 1421 - #define STATUS_FLT_FILTER_NOT_READY cpu_to_le32(0xC01C0008) 1422 1422 - #define STATUS_FLT_POST_OPERATION_CLEANUP cpu_to_le32(0xC01C0009) 1423 1423 - #define STATUS_FLT_INTERNAL_ERROR cpu_to_le32(0xC01C000A) 1424 1424 - #define STATUS_FLT_DELETING_OBJECT cpu_to_le32(0xC01C000B) 1425 1425 - #define STATUS_FLT_MUST_BE_NONPAGED_POOL cpu_to_le32(0xC01C000C) 1426 1426 - #define STATUS_FLT_DUPLICATE_ENTRY cpu_to_le32(0xC01C000D) 1427 1427 - #define STATUS_FLT_CBDQ_DISABLED cpu_to_le32(0xC01C000E) 1428 1428 - #define STATUS_FLT_DO_NOT_ATTACH cpu_to_le32(0xC01C000F) 1429 1429 - #define STATUS_FLT_DO_NOT_DETACH cpu_to_le32(0xC01C0010) 1430 1430 - #define STATUS_FLT_INSTANCE_ALTITUDE_COLLISION cpu_to_le32(0xC01C0011) 1431 1431 - #define STATUS_FLT_INSTANCE_NAME_COLLISION cpu_to_le32(0xC01C0012) 1432 1432 - #define STATUS_FLT_FILTER_NOT_FOUND cpu_to_le32(0xC01C0013) 1433 1433 - #define STATUS_FLT_VOLUME_NOT_FOUND cpu_to_le32(0xC01C0014) 1434 1434 - #define STATUS_FLT_INSTANCE_NOT_FOUND cpu_to_le32(0xC01C0015) 1435 1435 - #define STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND cpu_to_le32(0xC01C0016) 1436 1436 - #define STATUS_FLT_INVALID_CONTEXT_REGISTRATION cpu_to_le32(0xC01C0017) 1437 1437 - #define STATUS_FLT_NAME_CACHE_MISS cpu_to_le32(0xC01C0018) 1438 1438 - #define STATUS_FLT_NO_DEVICE_OBJECT cpu_to_le32(0xC01C0019) 1439 1439 - #define STATUS_FLT_VOLUME_ALREADY_MOUNTED cpu_to_le32(0xC01C001A) 1440 1440 - #define STATUS_FLT_ALREADY_ENLISTED cpu_to_le32(0xC01C001B) 1441 1441 - #define STATUS_FLT_CONTEXT_ALREADY_LINKED cpu_to_le32(0xC01C001C) 1442 1442 - #define STATUS_FLT_NO_WAITER_FOR_REPLY cpu_to_le32(0xC01C0020) 1443 1443 - #define STATUS_MONITOR_NO_DESCRIPTOR cpu_to_le32(0xC01D0001) 1444 1444 - #define STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT cpu_to_le32(0xC01D0002) 1445 1445 - #define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM cpu_to_le32(0xC01D0003) 1446 1446 - #define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK cpu_to_le32(0xC01D0004) 1447 1447 - #define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED cpu_to_le32(0xC01D0005) 1448 1448 - #define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK cpu_to_le32(0xC01D0006) 1449 1449 - #define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK cpu_to_le32(0xC01D0007) 1450 1450 - #define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA cpu_to_le32(0xC01D0008) 1451 1451 - #define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK cpu_to_le32(0xC01D0009) 1452 1452 - #define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER cpu_to_le32(0xC01E0000) 1453 1453 - #define STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER cpu_to_le32(0xC01E0001) 1454 1454 - #define STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER cpu_to_le32(0xC01E0002) 1455 1455 - #define STATUS_GRAPHICS_ADAPTER_WAS_RESET cpu_to_le32(0xC01E0003) 1456 1456 - #define STATUS_GRAPHICS_INVALID_DRIVER_MODEL cpu_to_le32(0xC01E0004) 1457 1457 - #define STATUS_GRAPHICS_PRESENT_MODE_CHANGED cpu_to_le32(0xC01E0005) 1458 1458 - #define STATUS_GRAPHICS_PRESENT_OCCLUDED cpu_to_le32(0xC01E0006) 1459 1459 - #define STATUS_GRAPHICS_PRESENT_DENIED cpu_to_le32(0xC01E0007) 1460 1460 - #define STATUS_GRAPHICS_CANNOTCOLORCONVERT cpu_to_le32(0xC01E0008) 1461 1461 - #define STATUS_GRAPHICS_NO_VIDEO_MEMORY cpu_to_le32(0xC01E0100) 1462 1462 - #define STATUS_GRAPHICS_CANT_LOCK_MEMORY cpu_to_le32(0xC01E0101) 1463 1463 - #define STATUS_GRAPHICS_ALLOCATION_BUSY cpu_to_le32(0xC01E0102) 1464 1464 - #define STATUS_GRAPHICS_TOO_MANY_REFERENCES cpu_to_le32(0xC01E0103) 1465 1465 - #define STATUS_GRAPHICS_TRY_AGAIN_LATER cpu_to_le32(0xC01E0104) 1466 1466 - #define STATUS_GRAPHICS_TRY_AGAIN_NOW cpu_to_le32(0xC01E0105) 1467 1467 - #define STATUS_GRAPHICS_ALLOCATION_INVALID cpu_to_le32(0xC01E0106) 1468 1468 - #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE cpu_to_le32(0xC01E0107) 1469 1469 - #define STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED cpu_to_le32(0xC01E0108) 1470 1470 - #define STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION cpu_to_le32(0xC01E0109) 1471 1471 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE cpu_to_le32(0xC01E0110) 1472 1472 - #define STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION cpu_to_le32(0xC01E0111) 1473 1473 - #define STATUS_GRAPHICS_ALLOCATION_CLOSED cpu_to_le32(0xC01E0112) 1474 1474 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE cpu_to_le32(0xC01E0113) 1475 1475 - #define STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE cpu_to_le32(0xC01E0114) 1476 1476 - #define STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE cpu_to_le32(0xC01E0115) 1477 1477 - #define STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST cpu_to_le32(0xC01E0116) 1478 1478 - #define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE cpu_to_le32(0xC01E0200) 1479 1479 - #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0300) 1480 1480 - #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED cpu_to_le32(0xC01E0301) 1481 1481 - #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED cpu_to_le32(0xC01E0302) 1482 1482 - #define STATUS_GRAPHICS_INVALID_VIDPN cpu_to_le32(0xC01E0303) 1483 1483 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE cpu_to_le32(0xC01E0304) 1484 1484 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET cpu_to_le32(0xC01E0305) 1485 1485 - #define STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED cpu_to_le32(0xC01E0306) 1486 1486 - #define STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET cpu_to_le32(0xC01E0308) 1487 1487 - #define STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET cpu_to_le32(0xC01E0309) 1488 1488 - #define STATUS_GRAPHICS_INVALID_FREQUENCY cpu_to_le32(0xC01E030A) 1489 1489 - #define STATUS_GRAPHICS_INVALID_ACTIVE_REGION cpu_to_le32(0xC01E030B) 1490 1490 - #define STATUS_GRAPHICS_INVALID_TOTAL_REGION cpu_to_le32(0xC01E030C) 1491 1491 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE cpu_to_le32(0xC01E0310) 1492 1492 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE cpu_to_le32(0xC01E0311) 1493 1493 - #define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET cpu_to_le32(0xC01E0312) 1494 1494 - #define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY cpu_to_le32(0xC01E0313) 1495 1495 - #define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET cpu_to_le32(0xC01E0314) 1496 1496 - #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET cpu_to_le32(0xC01E0315) 1497 1497 - #define STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET cpu_to_le32(0xC01E0316) 1498 1498 - #define STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET cpu_to_le32(0xC01E0317) 1499 1499 - #define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET cpu_to_le32(0xC01E0318) 1500 1500 - #define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH cpu_to_le32(0xC01E0319) 1501 1501 - #define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY cpu_to_le32(0xC01E031A) 1502 1502 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET cpu_to_le32(0xC01E031B) 1503 1503 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE cpu_to_le32(0xC01E031C) 1504 1504 - #define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET cpu_to_le32(0xC01E031D) 1505 1505 - #define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET cpu_to_le32(0xC01E031F) 1506 1506 - #define STATUS_GRAPHICS_STALE_MODESET cpu_to_le32(0xC01E0320) 1507 1507 - #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET cpu_to_le32(0xC01E0321) 1508 1508 - #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE cpu_to_le32(0xC01E0322) 1509 1509 - #define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN cpu_to_le32(0xC01E0323) 1510 1510 - #define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0324) 1511 1511 - #define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION cpu_to_le32(0xC01E0325) 1512 1512 - #define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES cpu_to_le32(0xC01E0326) 1513 1513 - #define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0327) 1514 1514 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE cpu_to_le32(0xC01E0328) 1515 1515 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET cpu_to_le32(0xC01E0329) 1516 1516 - #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET cpu_to_le32(0xC01E032A) 1517 1517 - #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR cpu_to_le32(0xC01E032B) 1518 1518 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET cpu_to_le32(0xC01E032C) 1519 1519 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET cpu_to_le32(0xC01E032D) 1520 1520 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E032E) 1521 1521 - #define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE cpu_to_le32(0xC01E032F) 1522 1522 - #define STATUS_GRAPHICS_RESOURCES_NOT_RELATED cpu_to_le32(0xC01E0330) 1523 1523 - #define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0331) 1524 1524 - #define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0332) 1525 1525 - #define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET cpu_to_le32(0xC01E0333) 1526 1526 - #define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER cpu_to_le32(0xC01E0334) 1527 1527 - #define STATUS_GRAPHICS_NO_VIDPNMGR cpu_to_le32(0xC01E0335) 1528 1528 - #define STATUS_GRAPHICS_NO_ACTIVE_VIDPN cpu_to_le32(0xC01E0336) 1529 1529 - #define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0337) 1530 1530 - #define STATUS_GRAPHICS_MONITOR_NOT_CONNECTED cpu_to_le32(0xC01E0338) 1531 1531 - #define STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0339) 1532 1532 - #define STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE cpu_to_le32(0xC01E033A) 1533 1533 - #define STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE cpu_to_le32(0xC01E033B) 1534 1534 - #define STATUS_GRAPHICS_INVALID_STRIDE cpu_to_le32(0xC01E033C) 1535 1535 - #define STATUS_GRAPHICS_INVALID_PIXELFORMAT cpu_to_le32(0xC01E033D) 1536 1536 - #define STATUS_GRAPHICS_INVALID_COLORBASIS cpu_to_le32(0xC01E033E) 1537 1537 - #define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE cpu_to_le32(0xC01E033F) 1538 1538 - #define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0340) 1539 1539 - #define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT cpu_to_le32(0xC01E0341) 1540 1540 - #define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE cpu_to_le32(0xC01E0342) 1541 1541 - #define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN cpu_to_le32(0xC01E0343) 1542 1542 - #define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL cpu_to_le32(0xC01E0344) 1543 1543 - #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION cpu_to_le32(0xC01E0345) 1544 1544 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED cpu_to_le32(0xC01E0346) 1545 1545 - #define STATUS_GRAPHICS_INVALID_GAMMA_RAMP cpu_to_le32(0xC01E0347) 1546 1546 - #define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED cpu_to_le32(0xC01E0348) 1547 1547 - #define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED cpu_to_le32(0xC01E0349) 1548 1548 - #define STATUS_GRAPHICS_MODE_NOT_IN_MODESET cpu_to_le32(0xC01E034A) 1549 1549 - #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON cpu_to_le32(0xC01E034D) 1550 1550 - #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE cpu_to_le32(0xC01E034E) 1551 1551 - #define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE cpu_to_le32(0xC01E034F) 1552 1552 - #define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS cpu_to_le32(0xC01E0350) 1553 1553 - #define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING cpu_to_le32(0xC01E0352) 1554 1554 - #define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED cpu_to_le32(0xC01E0353) 1555 1555 - #define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS cpu_to_le32(0xC01E0354) 1556 1556 - #define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT cpu_to_le32(0xC01E0355) 1557 1557 - #define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM cpu_to_le32(0xC01E0356) 1558 1558 - #define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN cpu_to_le32(0xC01E0357) 1559 1559 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT cpu_to_le32(0xC01E0358) 1560 1560 - #define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED cpu_to_le32(0xC01E0359) 1561 1561 - #define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION cpu_to_le32(0xC01E035A) 1562 1562 - #define STATUS_GRAPHICS_INVALID_CLIENT_TYPE cpu_to_le32(0xC01E035B) 1563 1563 - #define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET cpu_to_le32(0xC01E035C) 1564 1564 - #define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED cpu_to_le32(0xC01E0400) 1565 1565 - #define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED cpu_to_le32(0xC01E0401) 1566 1566 - #define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER cpu_to_le32(0xC01E0430) 1567 1567 - #define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED cpu_to_le32(0xC01E0431) 1568 1568 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED cpu_to_le32(0xC01E0432) 1569 1569 - #define STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY cpu_to_le32(0xC01E0433) 1570 1570 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED cpu_to_le32(0xC01E0434) 1571 1571 - #define STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON cpu_to_le32(0xC01E0435) 1572 1572 - #define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE cpu_to_le32(0xC01E0436) 1573 1573 - #define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER cpu_to_le32(0xC01E0438) 1574 1574 - #define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED cpu_to_le32(0xC01E043B) 1575 1575 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS cpu_to_le32(0xC01E051C) 1576 1576 - #define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST cpu_to_le32(0xC01E051D) 1577 1577 - #define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC01E051E) 1578 1578 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS cpu_to_le32(0xC01E051F) 1579 1579 - #define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED cpu_to_le32(0xC01E0520) 1580 1580 - #define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST cpu_to_le32(0xC01E0521) 1581 1581 - #define STATUS_GRAPHICS_OPM_NOT_SUPPORTED cpu_to_le32(0xC01E0500) 1582 1582 - #define STATUS_GRAPHICS_COPP_NOT_SUPPORTED cpu_to_le32(0xC01E0501) 1583 1583 - #define STATUS_GRAPHICS_UAB_NOT_SUPPORTED cpu_to_le32(0xC01E0502) 1584 1584 - #define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS cpu_to_le32(0xC01E0503) 1585 1585 - #define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E0504) 1586 1586 - #define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST cpu_to_le32(0xC01E0505) 1587 1587 - #define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E0506) 1588 1588 - #define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E0507) 1589 1589 - #define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E0508) 1590 1590 - #define STATUS_GRAPHICS_OPM_INVALID_POINTER cpu_to_le32(0xC01E050A) 1591 1591 - #define STATUS_GRAPHICS_OPM_INTERNAL_ERROR cpu_to_le32(0xC01E050B) 1592 1592 - #define STATUS_GRAPHICS_OPM_INVALID_HANDLE cpu_to_le32(0xC01E050C) 1593 1593 - #define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E050D) 1594 1594 - #define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH cpu_to_le32(0xC01E050E) 1595 1595 - #define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED cpu_to_le32(0xC01E050F) 1596 1596 - #define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED cpu_to_le32(0xC01E0510) 1597 1597 - #define STATUS_GRAPHICS_PVP_HFS_FAILED cpu_to_le32(0xC01E0511) 1598 1598 - #define STATUS_GRAPHICS_OPM_INVALID_SRM cpu_to_le32(0xC01E0512) 1599 1599 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP cpu_to_le32(0xC01E0513) 1600 1600 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP cpu_to_le32(0xC01E0514) 1601 1601 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA cpu_to_le32(0xC01E0515) 1602 1602 - #define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET cpu_to_le32(0xC01E0516) 1603 1603 - #define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH cpu_to_le32(0xC01E0517) 1604 1604 - #define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE cpu_to_le32(0xC01E0518) 1605 1605 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS cpu_to_le32(0xC01E051A) 1606 1606 - #define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E051B) 1607 1607 - #define STATUS_GRAPHICS_I2C_NOT_SUPPORTED cpu_to_le32(0xC01E0580) 1608 1608 - #define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC01E0581) 1609 1609 - #define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA cpu_to_le32(0xC01E0582) 1610 1610 - #define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA cpu_to_le32(0xC01E0583) 1611 1611 - #define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED cpu_to_le32(0xC01E0584) 1612 1612 - #define STATUS_GRAPHICS_DDCCI_INVALID_DATA cpu_to_le32(0xC01E0585) 1613 1613 - #define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE cpu_to_le32(0xC01E0586) 1614 1614 - #define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING cpu_to_le32(0xC01E0587) 1615 1615 - #define STATUS_GRAPHICS_MCA_INTERNAL_ERROR cpu_to_le32(0xC01E0588) 1616 1616 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND cpu_to_le32(0xC01E0589) 1617 1617 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH cpu_to_le32(0xC01E058A) 1618 1618 - #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM cpu_to_le32(0xC01E058B) 1619 1619 - #define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE cpu_to_le32(0xC01E058C) 1620 1620 - #define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS cpu_to_le32(0xC01E058D) 1621 1621 - #define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED cpu_to_le32(0xC01E05E0) 1622 1622 - #define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E05E1) 1623 1623 - #define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E05E2) 1624 1624 - #define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E05E3) 1625 1625 - #define STATUS_GRAPHICS_INVALID_POINTER cpu_to_le32(0xC01E05E4) 1626 1626 - #define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E05E5) 1627 1627 - #define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E05E6) 1628 1628 - #define STATUS_GRAPHICS_INTERNAL_ERROR cpu_to_le32(0xC01E05E7) 1629 1629 - #define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E05E8) 1630 1630 - #define STATUS_FVE_LOCKED_VOLUME cpu_to_le32(0xC0210000) 1631 1631 - #define STATUS_FVE_NOT_ENCRYPTED cpu_to_le32(0xC0210001) 1632 1632 - #define STATUS_FVE_BAD_INFORMATION cpu_to_le32(0xC0210002) 1633 1633 - #define STATUS_FVE_TOO_SMALL cpu_to_le32(0xC0210003) 1634 1634 - #define STATUS_FVE_FAILED_WRONG_FS cpu_to_le32(0xC0210004) 1635 1635 - #define STATUS_FVE_FAILED_BAD_FS cpu_to_le32(0xC0210005) 1636 1636 - #define STATUS_FVE_FS_NOT_EXTENDED cpu_to_le32(0xC0210006) 1637 1637 - #define STATUS_FVE_FS_MOUNTED cpu_to_le32(0xC0210007) 1638 1638 - #define STATUS_FVE_NO_LICENSE cpu_to_le32(0xC0210008) 1639 1639 - #define STATUS_FVE_ACTION_NOT_ALLOWED cpu_to_le32(0xC0210009) 1640 1640 - #define STATUS_FVE_BAD_DATA cpu_to_le32(0xC021000A) 1641 1641 - #define STATUS_FVE_VOLUME_NOT_BOUND cpu_to_le32(0xC021000B) 1642 1642 - #define STATUS_FVE_NOT_DATA_VOLUME cpu_to_le32(0xC021000C) 1643 1643 - #define STATUS_FVE_CONV_READ_ERROR cpu_to_le32(0xC021000D) 1644 1644 - #define STATUS_FVE_CONV_WRITE_ERROR cpu_to_le32(0xC021000E) 1645 1645 - #define STATUS_FVE_OVERLAPPED_UPDATE cpu_to_le32(0xC021000F) 1646 1646 - #define STATUS_FVE_FAILED_SECTOR_SIZE cpu_to_le32(0xC0210010) 1647 1647 - #define STATUS_FVE_FAILED_AUTHENTICATION cpu_to_le32(0xC0210011) 1648 1648 - #define STATUS_FVE_NOT_OS_VOLUME cpu_to_le32(0xC0210012) 1649 1649 - #define STATUS_FVE_KEYFILE_NOT_FOUND cpu_to_le32(0xC0210013) 1650 1650 - #define STATUS_FVE_KEYFILE_INVALID cpu_to_le32(0xC0210014) 1651 1651 - #define STATUS_FVE_KEYFILE_NO_VMK cpu_to_le32(0xC0210015) 1652 1652 - #define STATUS_FVE_TPM_DISABLED cpu_to_le32(0xC0210016) 1653 1653 - #define STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO cpu_to_le32(0xC0210017) 1654 1654 - #define STATUS_FVE_TPM_INVALID_PCR cpu_to_le32(0xC0210018) 1655 1655 - #define STATUS_FVE_TPM_NO_VMK cpu_to_le32(0xC0210019) 1656 1656 - #define STATUS_FVE_PIN_INVALID cpu_to_le32(0xC021001A) 1657 1657 - #define STATUS_FVE_AUTH_INVALID_APPLICATION cpu_to_le32(0xC021001B) 1658 1658 - #define STATUS_FVE_AUTH_INVALID_CONFIG cpu_to_le32(0xC021001C) 1659 1659 - #define STATUS_FVE_DEBUGGER_ENABLED cpu_to_le32(0xC021001D) 1660 1660 - #define STATUS_FVE_DRY_RUN_FAILED cpu_to_le32(0xC021001E) 1661 1661 - #define STATUS_FVE_BAD_METADATA_POINTER cpu_to_le32(0xC021001F) 1662 1662 - #define STATUS_FVE_OLD_METADATA_COPY cpu_to_le32(0xC0210020) 1663 1663 - #define STATUS_FVE_REBOOT_REQUIRED cpu_to_le32(0xC0210021) 1664 1664 - #define STATUS_FVE_RAW_ACCESS cpu_to_le32(0xC0210022) 1665 1665 - #define STATUS_FVE_RAW_BLOCKED cpu_to_le32(0xC0210023) 1666 1666 - #define STATUS_FWP_CALLOUT_NOT_FOUND cpu_to_le32(0xC0220001) 1667 1667 - #define STATUS_FWP_CONDITION_NOT_FOUND cpu_to_le32(0xC0220002) 1668 1668 - #define STATUS_FWP_FILTER_NOT_FOUND cpu_to_le32(0xC0220003) 1669 1669 - #define STATUS_FWP_LAYER_NOT_FOUND cpu_to_le32(0xC0220004) 1670 1670 - #define STATUS_FWP_PROVIDER_NOT_FOUND cpu_to_le32(0xC0220005) 1671 1671 - #define STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND cpu_to_le32(0xC0220006) 1672 1672 - #define STATUS_FWP_SUBLAYER_NOT_FOUND cpu_to_le32(0xC0220007) 1673 1673 - #define STATUS_FWP_NOT_FOUND cpu_to_le32(0xC0220008) 1674 1674 - #define STATUS_FWP_ALREADY_EXISTS cpu_to_le32(0xC0220009) 1675 1675 - #define STATUS_FWP_IN_USE cpu_to_le32(0xC022000A) 1676 1676 - #define STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS cpu_to_le32(0xC022000B) 1677 1677 - #define STATUS_FWP_WRONG_SESSION cpu_to_le32(0xC022000C) 1678 1678 - #define STATUS_FWP_NO_TXN_IN_PROGRESS cpu_to_le32(0xC022000D) 1679 1679 - #define STATUS_FWP_TXN_IN_PROGRESS cpu_to_le32(0xC022000E) 1680 1680 - #define STATUS_FWP_TXN_ABORTED cpu_to_le32(0xC022000F) 1681 1681 - #define STATUS_FWP_SESSION_ABORTED cpu_to_le32(0xC0220010) 1682 1682 - #define STATUS_FWP_INCOMPATIBLE_TXN cpu_to_le32(0xC0220011) 1683 1683 - #define STATUS_FWP_TIMEOUT cpu_to_le32(0xC0220012) 1684 1684 - #define STATUS_FWP_NET_EVENTS_DISABLED cpu_to_le32(0xC0220013) 1685 1685 - #define STATUS_FWP_INCOMPATIBLE_LAYER cpu_to_le32(0xC0220014) 1686 1686 - #define STATUS_FWP_KM_CLIENTS_ONLY cpu_to_le32(0xC0220015) 1687 1687 - #define STATUS_FWP_LIFETIME_MISMATCH cpu_to_le32(0xC0220016) 1688 1688 - #define STATUS_FWP_BUILTIN_OBJECT cpu_to_le32(0xC0220017) 1689 1689 - #define STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS cpu_to_le32(0xC0220018) 1690 1690 - #define STATUS_FWP_TOO_MANY_CALLOUTS cpu_to_le32(0xC0220018) 1691 1691 - #define STATUS_FWP_NOTIFICATION_DROPPED cpu_to_le32(0xC0220019) 1692 1692 - #define STATUS_FWP_TRAFFIC_MISMATCH cpu_to_le32(0xC022001A) 1693 1693 - #define STATUS_FWP_INCOMPATIBLE_SA_STATE cpu_to_le32(0xC022001B) 1694 1694 - #define STATUS_FWP_NULL_POINTER cpu_to_le32(0xC022001C) 1695 1695 - #define STATUS_FWP_INVALID_ENUMERATOR cpu_to_le32(0xC022001D) 1696 1696 - #define STATUS_FWP_INVALID_FLAGS cpu_to_le32(0xC022001E) 1697 1697 - #define STATUS_FWP_INVALID_NET_MASK cpu_to_le32(0xC022001F) 1698 1698 - #define STATUS_FWP_INVALID_RANGE cpu_to_le32(0xC0220020) 1699 1699 - #define STATUS_FWP_INVALID_INTERVAL cpu_to_le32(0xC0220021) 1700 1700 - #define STATUS_FWP_ZERO_LENGTH_ARRAY cpu_to_le32(0xC0220022) 1701 1701 - #define STATUS_FWP_NULL_DISPLAY_NAME cpu_to_le32(0xC0220023) 1702 1702 - #define STATUS_FWP_INVALID_ACTION_TYPE cpu_to_le32(0xC0220024) 1703 1703 - #define STATUS_FWP_INVALID_WEIGHT cpu_to_le32(0xC0220025) 1704 1704 - #define STATUS_FWP_MATCH_TYPE_MISMATCH cpu_to_le32(0xC0220026) 1705 1705 - #define STATUS_FWP_TYPE_MISMATCH cpu_to_le32(0xC0220027) 1706 1706 - #define STATUS_FWP_OUT_OF_BOUNDS cpu_to_le32(0xC0220028) 1707 1707 - #define STATUS_FWP_RESERVED cpu_to_le32(0xC0220029) 1708 1708 - #define STATUS_FWP_DUPLICATE_CONDITION cpu_to_le32(0xC022002A) 1709 1709 - #define STATUS_FWP_DUPLICATE_KEYMOD cpu_to_le32(0xC022002B) 1710 1710 - #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002C) 1711 1711 - #define STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER cpu_to_le32(0xC022002D) 1712 1712 - #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER cpu_to_le32(0xC022002E) 1713 1713 - #define STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT cpu_to_le32(0xC022002F) 1714 1714 - #define STATUS_FWP_INCOMPATIBLE_AUTH_METHOD cpu_to_le32(0xC0220030) 1715 1715 - #define STATUS_FWP_INCOMPATIBLE_DH_GROUP cpu_to_le32(0xC0220031) 1716 1716 - #define STATUS_FWP_EM_NOT_SUPPORTED cpu_to_le32(0xC0220032) 1717 1717 - #define STATUS_FWP_NEVER_MATCH cpu_to_le32(0xC0220033) 1718 1718 - #define STATUS_FWP_PROVIDER_CONTEXT_MISMATCH cpu_to_le32(0xC0220034) 1719 1719 - #define STATUS_FWP_INVALID_PARAMETER cpu_to_le32(0xC0220035) 1720 1720 - #define STATUS_FWP_TOO_MANY_SUBLAYERS cpu_to_le32(0xC0220036) 1721 1721 - #define STATUS_FWP_CALLOUT_NOTIFICATION_FAILED cpu_to_le32(0xC0220037) 1722 1722 - #define STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG cpu_to_le32(0xC0220038) 1723 1723 - #define STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG cpu_to_le32(0xC0220039) 1724 1724 - #define STATUS_FWP_TCPIP_NOT_READY cpu_to_le32(0xC0220100) 1725 1725 - #define STATUS_FWP_INJECT_HANDLE_CLOSING cpu_to_le32(0xC0220101) 1726 1726 - #define STATUS_FWP_INJECT_HANDLE_STALE cpu_to_le32(0xC0220102) 1727 1727 - #define STATUS_FWP_CANNOT_PEND cpu_to_le32(0xC0220103) 1728 1728 - #define STATUS_NDIS_CLOSING cpu_to_le32(0xC0230002) 1729 1729 - #define STATUS_NDIS_BAD_VERSION cpu_to_le32(0xC0230004) 1730 1730 - #define STATUS_NDIS_BAD_CHARACTERISTICS cpu_to_le32(0xC0230005) 1731 1731 - #define STATUS_NDIS_ADAPTER_NOT_FOUND cpu_to_le32(0xC0230006) 1732 1732 - #define STATUS_NDIS_OPEN_FAILED cpu_to_le32(0xC0230007) 1733 1733 - #define STATUS_NDIS_DEVICE_FAILED cpu_to_le32(0xC0230008) 1734 1734 - #define STATUS_NDIS_MULTICAST_FULL cpu_to_le32(0xC0230009) 1735 1735 - #define STATUS_NDIS_MULTICAST_EXISTS cpu_to_le32(0xC023000A) 1736 1736 - #define STATUS_NDIS_MULTICAST_NOT_FOUND cpu_to_le32(0xC023000B) 1737 1737 - #define STATUS_NDIS_REQUEST_ABORTED cpu_to_le32(0xC023000C) 1738 1738 - #define STATUS_NDIS_RESET_IN_PROGRESS cpu_to_le32(0xC023000D) 1739 1739 - #define STATUS_NDIS_INVALID_PACKET cpu_to_le32(0xC023000F) 1740 1740 - #define STATUS_NDIS_INVALID_DEVICE_REQUEST cpu_to_le32(0xC0230010) 1741 1741 - #define STATUS_NDIS_ADAPTER_NOT_READY cpu_to_le32(0xC0230011) 1742 1742 - #define STATUS_NDIS_INVALID_LENGTH cpu_to_le32(0xC0230014) 1743 1743 - #define STATUS_NDIS_INVALID_DATA cpu_to_le32(0xC0230015) 1744 1744 - #define STATUS_NDIS_BUFFER_TOO_SHORT cpu_to_le32(0xC0230016) 1745 1745 - #define STATUS_NDIS_INVALID_OID cpu_to_le32(0xC0230017) 1746 1746 - #define STATUS_NDIS_ADAPTER_REMOVED cpu_to_le32(0xC0230018) 1747 1747 - #define STATUS_NDIS_UNSUPPORTED_MEDIA cpu_to_le32(0xC0230019) 1748 1748 - #define STATUS_NDIS_GROUP_ADDRESS_IN_USE cpu_to_le32(0xC023001A) 1749 1749 - #define STATUS_NDIS_FILE_NOT_FOUND cpu_to_le32(0xC023001B) 1750 1750 - #define STATUS_NDIS_ERROR_READING_FILE cpu_to_le32(0xC023001C) 1751 1751 - #define STATUS_NDIS_ALREADY_MAPPED cpu_to_le32(0xC023001D) 1752 1752 - #define STATUS_NDIS_RESOURCE_CONFLICT cpu_to_le32(0xC023001E) 1753 1753 - #define STATUS_NDIS_MEDIA_DISCONNECTED cpu_to_le32(0xC023001F) 1754 1754 - #define STATUS_NDIS_INVALID_ADDRESS cpu_to_le32(0xC0230022) 1755 1755 - #define STATUS_NDIS_PAUSED cpu_to_le32(0xC023002A) 1756 1756 - #define STATUS_NDIS_INTERFACE_NOT_FOUND cpu_to_le32(0xC023002B) 1757 1757 - #define STATUS_NDIS_UNSUPPORTED_REVISION cpu_to_le32(0xC023002C) 1758 1758 - #define STATUS_NDIS_INVALID_PORT cpu_to_le32(0xC023002D) 1759 1759 - #define STATUS_NDIS_INVALID_PORT_STATE cpu_to_le32(0xC023002E) 1760 1760 - #define STATUS_NDIS_LOW_POWER_STATE cpu_to_le32(0xC023002F) 1761 1761 - #define STATUS_NDIS_NOT_SUPPORTED cpu_to_le32(0xC02300BB) 1762 1762 - #define STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED cpu_to_le32(0xC0232000) 1763 1763 - #define STATUS_NDIS_DOT11_MEDIA_IN_USE cpu_to_le32(0xC0232001) 1764 1764 - #define STATUS_NDIS_DOT11_POWER_STATE_INVALID cpu_to_le32(0xC0232002) 1765 1765 - #define STATUS_IPSEC_BAD_SPI cpu_to_le32(0xC0360001) 1766 1766 - #define STATUS_IPSEC_SA_LIFETIME_EXPIRED cpu_to_le32(0xC0360002) 1767 1767 - #define STATUS_IPSEC_WRONG_SA cpu_to_le32(0xC0360003) 1768 1768 - #define STATUS_IPSEC_REPLAY_CHECK_FAILED cpu_to_le32(0xC0360004) 1769 1769 - #define STATUS_IPSEC_INVALID_PACKET cpu_to_le32(0xC0360005) 1770 1770 - #define STATUS_IPSEC_INTEGRITY_CHECK_FAILED cpu_to_le32(0xC0360006) 1771 1771 - #define STATUS_IPSEC_CLEAR_TEXT_DROP cpu_to_le32(0xC0360007)

+1 -1

fs/smb/client/smb2transport.c

reviewed

··· 23 23 #include "cifsproto.h" 24 24 #include "smb2proto.h" 25 25 #include "cifs_debug.h" 26 26 - #include "smb2status.h" 26 26 + #include "../common/smb2status.h" 27 27 #include "smb2glob.h" 28 28 29 29 static int

+2 -4

fs/smb/client/smbdirect.c

reviewed

··· 1586 1586 conn_param.initiator_depth = 0; 1587 1587 1588 1588 conn_param.responder_resources = 1589 1589 - info->id->device->attrs.max_qp_rd_atom 1590 1590 - < SMBD_CM_RESPONDER_RESOURCES ? 1591 1591 - info->id->device->attrs.max_qp_rd_atom : 1592 1592 - SMBD_CM_RESPONDER_RESOURCES; 1589 1589 + min(info->id->device->attrs.max_qp_rd_atom, 1590 1590 + SMBD_CM_RESPONDER_RESOURCES); 1593 1591 info->responder_resources = conn_param.responder_resources; 1594 1592 log_rdma_mr(INFO, "responder_resources=%d\n", 1595 1593 info->responder_resources);

+4

fs/smb/client/transport.c

reviewed

··· 28 28 #include "cifs_debug.h" 29 29 #include "smb2proto.h" 30 30 #include "smbdirect.h" 31 31 + #include "compress.h" 31 32 32 33 /* Max number of iovectors we can use off the stack when sending requests. */ 33 34 #define CIFS_MAX_IOV_SIZE 8 ··· 432 431 struct smb_rqst *cur_rqst; 433 432 struct kvec *iov; 434 433 int rc; 434 434 + 435 435 + if (flags & CIFS_COMPRESS_REQ) 436 436 + return smb_compress(server, &rqst[0], __smb_send_rqst); 435 437 436 438 if (!(flags & CIFS_TRANSFORM_REQ)) 437 439 return __smb_send_rqst(server, num_rqst, rqst);

+2 -2

fs/smb/client/xattr.c

reviewed

··· 162 162 case XATTR_CIFS_ACL: 163 163 case XATTR_CIFS_NTSD: 164 164 case XATTR_CIFS_NTSD_FULL: { 165 165 - struct cifs_ntsd *pacl; 165 165 + struct smb_ntsd *pacl; 166 166 167 167 if (!value) 168 168 goto out; ··· 315 315 * fetch owner and DACL otherwise 316 316 */ 317 317 u32 acllen, extra_info; 318 318 - struct cifs_ntsd *pacl; 318 318 + struct smb_ntsd *pacl; 319 319 320 320 if (pTcon->ses->server->ops->get_acl == NULL) 321 321 goto out; /* rc already EOPNOTSUPP */

+121

fs/smb/common/smbacl.h

reviewed

··· 1 1 + /* SPDX-License-Identifier: LGPL-2.1+ */ 2 2 + /* 3 3 + * Copyright (c) International Business Machines Corp., 2007 4 4 + * Author(s): Steve French (sfrench@us.ibm.com) 5 5 + * Modified by Namjae Jeon (linkinjeon@kernel.org) 6 6 + */ 7 7 + 8 8 + #ifndef _COMMON_SMBACL_H 9 9 + #define _COMMON_SMBACL_H 10 10 + 11 11 + #define NUM_AUTHS (6) /* number of authority fields */ 12 12 + #define SID_MAX_SUB_AUTHORITIES (15) /* max number of sub authority fields */ 13 13 + 14 14 + /* ACE types - see MS-DTYP 2.4.4.1 */ 15 15 + #define ACCESS_ALLOWED_ACE_TYPE 0x00 16 16 + #define ACCESS_DENIED_ACE_TYPE 0x01 17 17 + #define SYSTEM_AUDIT_ACE_TYPE 0x02 18 18 + #define SYSTEM_ALARM_ACE_TYPE 0x03 19 19 + #define ACCESS_ALLOWED_COMPOUND_ACE_TYPE 0x04 20 20 + #define ACCESS_ALLOWED_OBJECT_ACE_TYPE 0x05 21 21 + #define ACCESS_DENIED_OBJECT_ACE_TYPE 0x06 22 22 + #define SYSTEM_AUDIT_OBJECT_ACE_TYPE 0x07 23 23 + #define SYSTEM_ALARM_OBJECT_ACE_TYPE 0x08 24 24 + #define ACCESS_ALLOWED_CALLBACK_ACE_TYPE 0x09 25 25 + #define ACCESS_DENIED_CALLBACK_ACE_TYPE 0x0A 26 26 + #define ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE 0x0B 27 27 + #define ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE 0x0C 28 28 + #define SYSTEM_AUDIT_CALLBACK_ACE_TYPE 0x0D 29 29 + #define SYSTEM_ALARM_CALLBACK_ACE_TYPE 0x0E /* Reserved */ 30 30 + #define SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE 0x0F 31 31 + #define SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 0x10 /* reserved */ 32 32 + #define SYSTEM_MANDATORY_LABEL_ACE_TYPE 0x11 33 33 + #define SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE 0x12 34 34 + #define SYSTEM_SCOPED_POLICY_ID_ACE_TYPE 0x13 35 35 + 36 36 + /* ACE flags */ 37 37 + #define OBJECT_INHERIT_ACE 0x01 38 38 + #define CONTAINER_INHERIT_ACE 0x02 39 39 + #define NO_PROPAGATE_INHERIT_ACE 0x04 40 40 + #define INHERIT_ONLY_ACE 0x08 41 41 + #define INHERITED_ACE 0x10 42 42 + #define SUCCESSFUL_ACCESS_ACE_FLAG 0x40 43 43 + #define FAILED_ACCESS_ACE_FLAG 0x80 44 44 + 45 45 + /* 46 46 + * Maximum size of a string representation of a SID: 47 47 + * 48 48 + * The fields are unsigned values in decimal. So: 49 49 + * 50 50 + * u8: max 3 bytes in decimal 51 51 + * u32: max 10 bytes in decimal 52 52 + * 53 53 + * "S-" + 3 bytes for version field + 15 for authority field + NULL terminator 54 54 + * 55 55 + * For authority field, max is when all 6 values are non-zero and it must be 56 56 + * represented in hex. So "-0x" + 12 hex digits. 57 57 + * 58 58 + * Add 11 bytes for each subauthority field (10 bytes each + 1 for '-') 59 59 + */ 60 60 + #define SID_STRING_BASE_SIZE (2 + 3 + 15 + 1) 61 61 + #define SID_STRING_SUBAUTH_SIZE (11) /* size of a single subauth string */ 62 62 + 63 63 + #define DOMAIN_USER_RID_LE cpu_to_le32(513) 64 64 + 65 65 + /* 66 66 + * ACE types - see MS-DTYP 2.4.4.1 67 67 + */ 68 68 + enum { 69 69 + ACCESS_ALLOWED, 70 70 + ACCESS_DENIED, 71 71 + }; 72 72 + 73 73 + /* 74 74 + * Security ID types 75 75 + */ 76 76 + enum { 77 77 + SIDOWNER = 1, 78 78 + SIDGROUP, 79 79 + SIDCREATOR_OWNER, 80 80 + SIDCREATOR_GROUP, 81 81 + SIDUNIX_USER, 82 82 + SIDUNIX_GROUP, 83 83 + SIDNFS_USER, 84 84 + SIDNFS_GROUP, 85 85 + SIDNFS_MODE, 86 86 + }; 87 87 + 88 88 + struct smb_ntsd { 89 89 + __le16 revision; /* revision level */ 90 90 + __le16 type; 91 91 + __le32 osidoffset; 92 92 + __le32 gsidoffset; 93 93 + __le32 sacloffset; 94 94 + __le32 dacloffset; 95 95 + } __attribute__((packed)); 96 96 + 97 97 + struct smb_sid { 98 98 + __u8 revision; /* revision level */ 99 99 + __u8 num_subauth; 100 100 + __u8 authority[NUM_AUTHS]; 101 101 + __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */ 102 102 + } __attribute__((packed)); 103 103 + 104 104 + /* size of a struct smb_sid, sans sub_auth array */ 105 105 + #define CIFS_SID_BASE_SIZE (1 + 1 + NUM_AUTHS) 106 106 + 107 107 + struct smb_acl { 108 108 + __le16 revision; /* revision level */ 109 109 + __le16 size; 110 110 + __le32 num_aces; 111 111 + } __attribute__((packed)); 112 112 + 113 113 + struct smb_ace { 114 114 + __u8 type; /* see above and MS-DTYP 2.4.4.1 */ 115 115 + __u8 flags; 116 116 + __le16 size; 117 117 + __le32 access_req; 118 118 + struct smb_sid sid; /* ie UUID of user or group who gets these perms */ 119 119 + } __attribute__((packed)); 120 120 + 121 121 + #endif /* _COMMON_SMBACL_H */

+1 -1

fs/smb/server/oplock.c

reviewed

··· 10 10 #include "oplock.h" 11 11 12 12 #include "smb_common.h" 13 13 - #include "smbstatus.h" 13 13 + #include "../common/smb2status.h" 14 14 #include "connection.h" 15 15 #include "mgmt/user_session.h" 16 16 #include "mgmt/share_config.h"

+1 -1

fs/smb/server/server.c

reviewed

··· 15 15 16 16 #include "server.h" 17 17 #include "smb_common.h" 18 18 - #include "smbstatus.h" 18 18 + #include "../common/smb2status.h" 19 19 #include "connection.h" 20 20 #include "transport_ipc.h" 21 21 #include "mgmt/user_session.h"

+1 -1

fs/smb/server/smb2misc.c

reviewed

··· 7 7 #include "glob.h" 8 8 #include "nterr.h" 9 9 #include "smb_common.h" 10 10 - #include "smbstatus.h" 10 10 + #include "../common/smb2status.h" 11 11 #include "mgmt/user_session.h" 12 12 #include "connection.h" 13 13

+1 -1

fs/smb/server/smb2pdu.c

reviewed

··· 30 30 31 31 #include "server.h" 32 32 #include "smb_common.h" 33 33 - #include "smbstatus.h" 33 33 + #include "../common/smb2status.h" 34 34 #include "ksmbd_work.h" 35 35 #include "mgmt/user_config.h" 36 36 #include "mgmt/share_config.h"

+1 -1

fs/smb/server/smb_common.c

reviewed

··· 9 9 #include "smb_common.h" 10 10 #include "server.h" 11 11 #include "misc.h" 12 12 - #include "smbstatus.h" 12 12 + #include "../common/smb2status.h" 13 13 #include "connection.h" 14 14 #include "ksmbd_work.h" 15 15 #include "mgmt/user_session.h"

+1 -110

fs/smb/server/smbacl.h

reviewed

··· 8 8 #ifndef _SMBACL_H 9 9 #define _SMBACL_H 10 10 11 11 + #include "../common/smbacl.h" 11 12 #include <linux/fs.h> 12 13 #include <linux/namei.h> 13 14 #include <linux/posix_acl.h> 14 15 #include <linux/mnt_idmapping.h> 15 16 16 17 #include "mgmt/tree_connect.h" 17 17 - 18 18 - #define NUM_AUTHS (6) /* number of authority fields */ 19 19 - #define SID_MAX_SUB_AUTHORITIES (15) /* max number of sub authority fields */ 20 20 - 21 21 - /* 22 22 - * ACE types - see MS-DTYP 2.4.4.1 23 23 - */ 24 24 - enum { 25 25 - ACCESS_ALLOWED, 26 26 - ACCESS_DENIED, 27 27 - }; 28 28 - 29 29 - /* 30 30 - * Security ID types 31 31 - */ 32 32 - enum { 33 33 - SIDOWNER = 1, 34 34 - SIDGROUP, 35 35 - SIDCREATOR_OWNER, 36 36 - SIDCREATOR_GROUP, 37 37 - SIDUNIX_USER, 38 38 - SIDUNIX_GROUP, 39 39 - SIDNFS_USER, 40 40 - SIDNFS_GROUP, 41 41 - SIDNFS_MODE, 42 42 - }; 43 18 44 19 /* Revision for ACLs */ 45 20 #define SD_REVISION 1 ··· 37 62 #define RM_CONTROL_VALID 0x4000 38 63 #define SELF_RELATIVE 0x8000 39 64 40 40 - /* ACE types - see MS-DTYP 2.4.4.1 */ 41 41 - #define ACCESS_ALLOWED_ACE_TYPE 0x00 42 42 - #define ACCESS_DENIED_ACE_TYPE 0x01 43 43 - #define SYSTEM_AUDIT_ACE_TYPE 0x02 44 44 - #define SYSTEM_ALARM_ACE_TYPE 0x03 45 45 - #define ACCESS_ALLOWED_COMPOUND_ACE_TYPE 0x04 46 46 - #define ACCESS_ALLOWED_OBJECT_ACE_TYPE 0x05 47 47 - #define ACCESS_DENIED_OBJECT_ACE_TYPE 0x06 48 48 - #define SYSTEM_AUDIT_OBJECT_ACE_TYPE 0x07 49 49 - #define SYSTEM_ALARM_OBJECT_ACE_TYPE 0x08 50 50 - #define ACCESS_ALLOWED_CALLBACK_ACE_TYPE 0x09 51 51 - #define ACCESS_DENIED_CALLBACK_ACE_TYPE 0x0A 52 52 - #define ACCESS_ALLOWED_CALLBACK_OBJECT_ACE_TYPE 0x0B 53 53 - #define ACCESS_DENIED_CALLBACK_OBJECT_ACE_TYPE 0x0C 54 54 - #define SYSTEM_AUDIT_CALLBACK_ACE_TYPE 0x0D 55 55 - #define SYSTEM_ALARM_CALLBACK_ACE_TYPE 0x0E /* Reserved */ 56 56 - #define SYSTEM_AUDIT_CALLBACK_OBJECT_ACE_TYPE 0x0F 57 57 - #define SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE 0x10 /* reserved */ 58 58 - #define SYSTEM_MANDATORY_LABEL_ACE_TYPE 0x11 59 59 - #define SYSTEM_RESOURCE_ATTRIBUTE_ACE_TYPE 0x12 60 60 - #define SYSTEM_SCOPED_POLICY_ID_ACE_TYPE 0x13 61 61 - 62 62 - /* ACE flags */ 63 63 - #define OBJECT_INHERIT_ACE 0x01 64 64 - #define CONTAINER_INHERIT_ACE 0x02 65 65 - #define NO_PROPAGATE_INHERIT_ACE 0x04 66 66 - #define INHERIT_ONLY_ACE 0x08 67 67 - #define INHERITED_ACE 0x10 68 68 - #define SUCCESSFUL_ACCESS_ACE_FLAG 0x40 69 69 - #define FAILED_ACCESS_ACE_FLAG 0x80 70 70 - 71 71 - /* 72 72 - * Maximum size of a string representation of a SID: 73 73 - * 74 74 - * The fields are unsigned values in decimal. So: 75 75 - * 76 76 - * u8: max 3 bytes in decimal 77 77 - * u32: max 10 bytes in decimal 78 78 - * 79 79 - * "S-" + 3 bytes for version field + 15 for authority field + NULL terminator 80 80 - * 81 81 - * For authority field, max is when all 6 values are non-zero and it must be 82 82 - * represented in hex. So "-0x" + 12 hex digits. 83 83 - * 84 84 - * Add 11 bytes for each subauthority field (10 bytes each + 1 for '-') 85 85 - */ 86 86 - #define SID_STRING_BASE_SIZE (2 + 3 + 15 + 1) 87 87 - #define SID_STRING_SUBAUTH_SIZE (11) /* size of a single subauth string */ 88 88 - 89 89 - #define DOMAIN_USER_RID_LE cpu_to_le32(513) 90 90 - 91 65 struct ksmbd_conn; 92 92 - 93 93 - struct smb_ntsd { 94 94 - __le16 revision; /* revision level */ 95 95 - __le16 type; 96 96 - __le32 osidoffset; 97 97 - __le32 gsidoffset; 98 98 - __le32 sacloffset; 99 99 - __le32 dacloffset; 100 100 - } __packed; 101 101 - 102 102 - struct smb_sid { 103 103 - __u8 revision; /* revision level */ 104 104 - __u8 num_subauth; 105 105 - __u8 authority[NUM_AUTHS]; 106 106 - __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */ 107 107 - } __packed; 108 108 - 109 109 - /* size of a struct cifs_sid, sans sub_auth array */ 110 110 - #define CIFS_SID_BASE_SIZE (1 + 1 + NUM_AUTHS) 111 111 - 112 112 - struct smb_acl { 113 113 - __le16 revision; /* revision level */ 114 114 - __le16 size; 115 115 - __le32 num_aces; 116 116 - } __packed; 117 117 - 118 118 - struct smb_ace { 119 119 - __u8 type; 120 120 - __u8 flags; 121 121 - __le16 size; 122 122 - __le32 access_req; 123 123 - struct smb_sid sid; /* ie UUID of user or group who gets these perms */ 124 124 - } __packed; 125 66 126 67 struct smb_fattr { 127 68 kuid_t cf_uid;

+61 -106

fs/smb/server/smbstatus.h fs/smb/common/smb2status.h

reviewed

··· 1 1 - /* SPDX-License-Identifier: LGPL-2.1+ */ 1 1 + /* SPDX-License-Identifier: LGPL-2.1 */ 2 2 /* 3 3 - * fs/server/smb2status.h 4 3 * 5 4 * SMB2 Status code (network error) definitions 6 5 * Definitions are from MS-ERREF 7 6 * 8 7 * Copyright (c) International Business Machines Corp., 2009,2011 9 8 * Author(s): Steve French (sfrench@us.ibm.com) 9 9 + * 10 10 */ 11 11 12 12 /* ··· 16 16 * C is set if "customer defined" error, N bit is reserved and MBZ 17 17 */ 18 18 19 19 - #define STATUS_SEVERITY_SUCCESS cpu_to_le32(0x0000) 19 19 + #define STATUS_SEVERITY_SUCCESS __constant_cpu_to_le32(0x0000) 20 20 #define STATUS_SEVERITY_INFORMATIONAL cpu_to_le32(0x0001) 21 21 #define STATUS_SEVERITY_WARNING cpu_to_le32(0x0002) 22 22 #define STATUS_SEVERITY_ERROR cpu_to_le32(0x0003) ··· 27 27 __le32 Code; 28 28 }; 29 29 30 30 - #define STATUS_SUCCESS 0x00000000 30 30 + #define STATUS_SUCCESS cpu_to_le32(0x00000000) 31 31 #define STATUS_WAIT_0 cpu_to_le32(0x00000000) 32 32 #define STATUS_WAIT_1 cpu_to_le32(0x00000001) 33 33 #define STATUS_WAIT_2 cpu_to_le32(0x00000002) ··· 158 158 #define STATUS_GRAPHICS_NO_PREFERRED_MODE cpu_to_le32(0x401E031E) 159 159 #define STATUS_GRAPHICS_DATASET_IS_EMPTY cpu_to_le32(0x401E034B) 160 160 #define STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET cpu_to_le32(0x401E034C) 161 161 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED \ 162 162 - cpu_to_le32(0x401E0351) 161 161 + #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED cpu_to_le32(0x401E0351) 163 162 #define STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS cpu_to_le32(0x401E042F) 164 163 #define STATUS_GRAPHICS_LEADLINK_START_DEFERRED cpu_to_le32(0x401E0437) 165 164 #define STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY cpu_to_le32(0x401E0439) ··· 220 221 #define STATUS_CANT_RECOVER_WITH_HANDLE_OPEN cpu_to_le32(0x80190031) 221 222 #define STATUS_TXF_METADATA_ALREADY_PRESENT cpu_to_le32(0x80190041) 222 223 #define STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET cpu_to_le32(0x80190042) 223 223 - #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED \ 224 224 - cpu_to_le32(0x801B00EB) 224 224 + #define STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED cpu_to_le32(0x801B00EB) 225 225 #define STATUS_FLT_BUFFER_TOO_SMALL cpu_to_le32(0x801C0001) 226 226 #define STATUS_FVE_PARTIAL_METADATA cpu_to_le32(0x80210001) 227 227 #define STATUS_UNSUCCESSFUL cpu_to_le32(0xC0000001) ··· 825 827 #define STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER cpu_to_le32(0xC00002D8) 826 828 #define STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER cpu_to_le32(0xC00002D9) 827 829 #define STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER cpu_to_le32(0xC00002DA) 828 828 - #define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER \ 829 829 - cpu_to_le32(0xC00002DB) 830 830 + #define STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER cpu_to_le32(0xC00002DB) 830 831 #define STATUS_DS_HAVE_PRIMARY_MEMBERS cpu_to_le32(0xC00002DC) 831 832 #define STATUS_WMI_NOT_SUPPORTED cpu_to_le32(0xC00002DD) 832 833 #define STATUS_INSUFFICIENT_POWER cpu_to_le32(0xC00002DE) ··· 901 904 #define STATUS_DEVICE_ENUMERATION_ERROR cpu_to_le32(0xC0000366) 902 905 #define STATUS_MOUNT_POINT_NOT_RESOLVED cpu_to_le32(0xC0000368) 903 906 #define STATUS_INVALID_DEVICE_OBJECT_PARAMETER cpu_to_le32(0xC0000369) 904 904 - #define STATUS_MCA_OCCURRED cpu_to_le32(0xC000036A) 907 907 + /* 908 908 + * 'OCCURED' is typo in MS-ERREF, it should be 'OCCURRED', 909 909 + * but we'll keep it consistent with MS-ERREF. 910 910 + */ 911 911 + #define STATUS_MCA_OCCURED cpu_to_le32(0xC000036A) 905 912 #define STATUS_DRIVER_BLOCKED_CRITICAL cpu_to_le32(0xC000036B) 906 913 #define STATUS_DRIVER_BLOCKED cpu_to_le32(0xC000036C) 907 914 #define STATUS_DRIVER_DATABASE_ERROR cpu_to_le32(0xC000036D) ··· 952 951 #define STATUS_AUTHENTICATION_FIREWALL_FAILED cpu_to_le32(0xC0000413) 953 952 #define STATUS_VDM_DISALLOWED cpu_to_le32(0xC0000414) 954 953 #define STATUS_HUNG_DISPLAY_DRIVER_THREAD cpu_to_le32(0xC0000415) 955 955 - #define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE \ 956 956 - cpu_to_le32(0xC0000416) 954 954 + #define STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE cpu_to_le32(0xC0000416) 957 955 #define STATUS_INVALID_CRUNTIME_PARAMETER cpu_to_le32(0xC0000417) 958 956 #define STATUS_NTLM_BLOCKED cpu_to_le32(0xC0000418) 959 957 #define STATUS_ASSERTION_FAILURE cpu_to_le32(0xC0000420) ··· 986 986 #define STATUS_INVALID_TASK_INDEX cpu_to_le32(0xC0000501) 987 987 #define STATUS_THREAD_ALREADY_IN_TASK cpu_to_le32(0xC0000502) 988 988 #define STATUS_CALLBACK_BYPASS cpu_to_le32(0xC0000503) 989 989 + #define STATUS_SERVER_UNAVAILABLE cpu_to_le32(0xC0000466) 990 990 + #define STATUS_FILE_NOT_AVAILABLE cpu_to_le32(0xC0000467) 989 991 #define STATUS_PORT_CLOSED cpu_to_le32(0xC0000700) 990 992 #define STATUS_MESSAGE_LOST cpu_to_le32(0xC0000701) 991 993 #define STATUS_INVALID_MESSAGE cpu_to_le32(0xC0000702) ··· 1000 998 #define STATUS_HARDWARE_MEMORY_ERROR cpu_to_le32(0xC0000709) 1001 999 #define STATUS_THREADPOOL_HANDLE_EXCEPTION cpu_to_le32(0xC000070A) 1002 1000 #define STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED cpu_to_le32(0xC000070B) 1003 1003 - #define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED \ 1004 1004 - cpu_to_le32(0xC000070C) 1005 1005 - #define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED \ 1006 1006 - cpu_to_le32(0xC000070D) 1007 1007 - #define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED \ 1008 1008 - cpu_to_le32(0xC000070E) 1001 1001 + #define STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED cpu_to_le32(0xC000070C) 1002 1002 + #define STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED cpu_to_le32(0xC000070D) 1003 1003 + #define STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED cpu_to_le32(0xC000070E) 1009 1004 #define STATUS_THREADPOOL_RELEASED_DURING_OPERATION cpu_to_le32(0xC000070F) 1010 1005 #define STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000710) 1011 1006 #define STATUS_APC_RETURNED_WHILE_IMPERSONATING cpu_to_le32(0xC0000711) ··· 1043 1044 #define STATUS_ND_QUEUE_OVERFLOW cpu_to_le32(0xC000A011) 1044 1045 #define STATUS_HOPLIMIT_EXCEEDED cpu_to_le32(0xC000A012) 1045 1046 #define STATUS_PROTOCOL_NOT_SUPPORTED cpu_to_le32(0xC000A013) 1046 1046 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED \ 1047 1047 - cpu_to_le32(0xC000A080) 1048 1048 - #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR \ 1049 1049 - cpu_to_le32(0xC000A081) 1047 1047 + #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED cpu_to_le32(0xC000A080) 1048 1048 + #define STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR cpu_to_le32(0xC000A081) 1050 1049 #define STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR cpu_to_le32(0xC000A082) 1051 1050 #define STATUS_XML_PARSE_ERROR cpu_to_le32(0xC000A083) 1052 1051 #define STATUS_XMLDSIG_ERROR cpu_to_le32(0xC000A084) ··· 1277 1280 #define STATUS_SXS_EARLY_DEACTIVATION cpu_to_le32(0xC015000F) 1278 1281 #define STATUS_SXS_INVALID_DEACTIVATION cpu_to_le32(0xC0150010) 1279 1282 #define STATUS_SXS_MULTIPLE_DEACTIVATION cpu_to_le32(0xC0150011) 1280 1280 - #define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY \ 1281 1281 - cpu_to_le32(0xC0150012) 1283 1283 + #define STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY cpu_to_le32(0xC0150012) 1282 1284 #define STATUS_SXS_PROCESS_TERMINATION_REQUESTED cpu_to_le32(0xC0150013) 1283 1285 #define STATUS_SXS_CORRUPT_ACTIVATION_STACK cpu_to_le32(0xC0150014) 1284 1286 #define STATUS_SXS_CORRUPTION cpu_to_le32(0xC0150015) ··· 1287 1291 #define STATUS_SXS_IDENTITY_PARSE_ERROR cpu_to_le32(0xC0150019) 1288 1292 #define STATUS_SXS_COMPONENT_STORE_CORRUPT cpu_to_le32(0xC015001A) 1289 1293 #define STATUS_SXS_FILE_HASH_MISMATCH cpu_to_le32(0xC015001B) 1290 1290 - #define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT \ 1291 1291 - cpu_to_le32(0xC015001C) 1294 1294 + #define STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT cpu_to_le32(0xC015001C) 1292 1295 #define STATUS_SXS_IDENTITIES_DIFFERENT cpu_to_le32(0xC015001D) 1293 1296 #define STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT cpu_to_le32(0xC015001E) 1294 1297 #define STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY cpu_to_le32(0xC015001F) ··· 1324 1329 #define STATUS_OBJECT_NO_LONGER_EXISTS cpu_to_le32(0xC0190021) 1325 1330 #define STATUS_STREAM_MINIVERSION_NOT_FOUND cpu_to_le32(0xC0190022) 1326 1331 #define STATUS_STREAM_MINIVERSION_NOT_VALID cpu_to_le32(0xC0190023) 1327 1327 - #define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION \ 1328 1328 - cpu_to_le32(0xC0190024) 1332 1332 + #define STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION cpu_to_le32(0xC0190024) 1329 1333 #define STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT cpu_to_le32(0xC0190025) 1330 1334 #define STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS cpu_to_le32(0xC0190026) 1331 1335 #define STATUS_HANDLE_NO_LONGER_VALID cpu_to_le32(0xC0190028) ··· 1358 1364 #define STATUS_ENLISTMENT_NOT_FOUND cpu_to_le32(0xC0190050) 1359 1365 #define STATUS_TRANSACTIONMANAGER_NOT_FOUND cpu_to_le32(0xC0190051) 1360 1366 #define STATUS_TRANSACTIONMANAGER_NOT_ONLINE cpu_to_le32(0xC0190052) 1361 1361 - #define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION \ 1362 1362 - cpu_to_le32(0xC0190053) 1367 1367 + #define STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION cpu_to_le32(0xC0190053) 1363 1368 #define STATUS_TRANSACTION_NOT_ROOT cpu_to_le32(0xC0190054) 1364 1369 #define STATUS_TRANSACTION_OBJECT_EXPIRED cpu_to_le32(0xC0190055) 1365 1370 #define STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION cpu_to_le32(0xC0190056) ··· 1449 1456 #define STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM cpu_to_le32(0xC01D0003) 1450 1457 #define STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK cpu_to_le32(0xC01D0004) 1451 1458 #define STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED cpu_to_le32(0xC01D0005) 1452 1452 - #define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK \ 1453 1453 - cpu_to_le32(0xC01D0006) 1454 1454 - #define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK \ 1455 1455 - cpu_to_le32(0xC01D0007) 1459 1459 + #define STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK cpu_to_le32(0xC01D0006) 1460 1460 + #define STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK cpu_to_le32(0xC01D0007) 1456 1461 #define STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA cpu_to_le32(0xC01D0008) 1457 1462 #define STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK cpu_to_le32(0xC01D0009) 1458 1463 #define STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER cpu_to_le32(0xC01E0000) ··· 1482 1491 #define STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE cpu_to_le32(0xC01E0200) 1483 1492 #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0300) 1484 1493 #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED cpu_to_le32(0xC01E0301) 1485 1485 - #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED \ 1486 1486 - cpu_to_le32(0xC01E0302) 1494 1494 + #define STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED cpu_to_le32(0xC01E0302) 1487 1495 #define STATUS_GRAPHICS_INVALID_VIDPN cpu_to_le32(0xC01E0303) 1488 1496 #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE cpu_to_le32(0xC01E0304) 1489 1497 #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET cpu_to_le32(0xC01E0305) ··· 1492 1502 #define STATUS_GRAPHICS_INVALID_FREQUENCY cpu_to_le32(0xC01E030A) 1493 1503 #define STATUS_GRAPHICS_INVALID_ACTIVE_REGION cpu_to_le32(0xC01E030B) 1494 1504 #define STATUS_GRAPHICS_INVALID_TOTAL_REGION cpu_to_le32(0xC01E030C) 1495 1495 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE \ 1496 1496 - cpu_to_le32(0xC01E0310) 1497 1497 - #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE \ 1498 1498 - cpu_to_le32(0xC01E0311) 1505 1505 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE cpu_to_le32(0xC01E0310) 1506 1506 + #define STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE cpu_to_le32(0xC01E0311) 1499 1507 #define STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET cpu_to_le32(0xC01E0312) 1500 1508 #define STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY cpu_to_le32(0xC01E0313) 1501 1509 #define STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET cpu_to_le32(0xC01E0314) ··· 1503 1515 #define STATUS_GRAPHICS_TARGET_ALREADY_IN_SET cpu_to_le32(0xC01E0318) 1504 1516 #define STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH cpu_to_le32(0xC01E0319) 1505 1517 #define STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY cpu_to_le32(0xC01E031A) 1506 1506 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET \ 1507 1507 - cpu_to_le32(0xC01E031B) 1518 1518 + #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET cpu_to_le32(0xC01E031B) 1508 1519 #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE cpu_to_le32(0xC01E031C) 1509 1520 #define STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET cpu_to_le32(0xC01E031D) 1510 1521 #define STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET cpu_to_le32(0xC01E031F) ··· 1512 1525 #define STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE cpu_to_le32(0xC01E0322) 1513 1526 #define STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN cpu_to_le32(0xC01E0323) 1514 1527 #define STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0324) 1515 1515 - #define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION \ 1516 1516 - cpu_to_le32(0xC01E0325) 1517 1517 - #define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES \ 1518 1518 - cpu_to_le32(0xC01E0326) 1528 1528 + #define STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION cpu_to_le32(0xC01E0325) 1529 1529 + #define STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES cpu_to_le32(0xC01E0326) 1519 1530 #define STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0327) 1520 1520 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE \ 1521 1521 - cpu_to_le32(0xC01E0328) 1522 1522 - #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET \ 1523 1523 - cpu_to_le32(0xC01E0329) 1531 1531 + #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE cpu_to_le32(0xC01E0328) 1532 1532 + #define STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET cpu_to_le32(0xC01E0329) 1524 1533 #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET cpu_to_le32(0xC01E032A) 1525 1534 #define STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR cpu_to_le32(0xC01E032B) 1526 1535 #define STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET cpu_to_le32(0xC01E032C) 1527 1536 #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET cpu_to_le32(0xC01E032D) 1528 1528 - #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE \ 1529 1529 - cpu_to_le32(0xC01E032E) 1537 1537 + #define STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E032E) 1530 1538 #define STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE cpu_to_le32(0xC01E032F) 1531 1539 #define STATUS_GRAPHICS_RESOURCES_NOT_RELATED cpu_to_le32(0xC01E0330) 1532 1540 #define STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0331) 1533 1541 #define STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE cpu_to_le32(0xC01E0332) 1534 1542 #define STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET cpu_to_le32(0xC01E0333) 1535 1535 - #define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER \ 1536 1536 - cpu_to_le32(0xC01E0334) 1543 1543 + #define STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER cpu_to_le32(0xC01E0334) 1537 1544 #define STATUS_GRAPHICS_NO_VIDPNMGR cpu_to_le32(0xC01E0335) 1538 1545 #define STATUS_GRAPHICS_NO_ACTIVE_VIDPN cpu_to_le32(0xC01E0336) 1539 1546 #define STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY cpu_to_le32(0xC01E0337) ··· 1540 1559 #define STATUS_GRAPHICS_INVALID_COLORBASIS cpu_to_le32(0xC01E033E) 1541 1560 #define STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE cpu_to_le32(0xC01E033F) 1542 1561 #define STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY cpu_to_le32(0xC01E0340) 1543 1543 - #define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT \ 1544 1544 - cpu_to_le32(0xC01E0341) 1562 1562 + #define STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT cpu_to_le32(0xC01E0341) 1545 1563 #define STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE cpu_to_le32(0xC01E0342) 1546 1564 #define STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN cpu_to_le32(0xC01E0343) 1547 1565 #define STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL cpu_to_le32(0xC01E0344) 1548 1548 - #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION \ 1549 1549 - cpu_to_le32(0xC01E0345) 1550 1550 - #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED \ 1551 1551 - cpu_to_le32(0xC01E0346) 1566 1566 + #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION cpu_to_le32(0xC01E0345) 1567 1567 + #define STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED cpu_to_le32(0xC01E0346) 1552 1568 #define STATUS_GRAPHICS_INVALID_GAMMA_RAMP cpu_to_le32(0xC01E0347) 1553 1569 #define STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED cpu_to_le32(0xC01E0348) 1554 1570 #define STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED cpu_to_le32(0xC01E0349) 1555 1571 #define STATUS_GRAPHICS_MODE_NOT_IN_MODESET cpu_to_le32(0xC01E034A) 1556 1556 - #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON \ 1557 1557 - cpu_to_le32(0xC01E034D) 1572 1572 + #define STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON cpu_to_le32(0xC01E034D) 1558 1573 #define STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE cpu_to_le32(0xC01E034E) 1559 1574 #define STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE cpu_to_le32(0xC01E034F) 1560 1560 - #define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS \ 1561 1561 - cpu_to_le32(0xC01E0350) 1575 1575 + #define STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS cpu_to_le32(0xC01E0350) 1562 1576 #define STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING cpu_to_le32(0xC01E0352) 1563 1577 #define STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED cpu_to_le32(0xC01E0353) 1564 1578 #define STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS cpu_to_le32(0xC01E0354) 1565 1579 #define STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT cpu_to_le32(0xC01E0355) 1566 1580 #define STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM cpu_to_le32(0xC01E0356) 1567 1567 - #define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN \ 1568 1568 - cpu_to_le32(0xC01E0357) 1569 1569 - #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT \ 1570 1570 - cpu_to_le32(0xC01E0358) 1581 1581 + #define STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN cpu_to_le32(0xC01E0357) 1582 1582 + #define STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT cpu_to_le32(0xC01E0358) 1571 1583 #define STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED cpu_to_le32(0xC01E0359) 1572 1572 - #define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION \ 1573 1573 - cpu_to_le32(0xC01E035A) 1584 1584 + #define STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION cpu_to_le32(0xC01E035A) 1574 1585 #define STATUS_GRAPHICS_INVALID_CLIENT_TYPE cpu_to_le32(0xC01E035B) 1575 1586 #define STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET cpu_to_le32(0xC01E035C) 1576 1576 - #define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED \ 1577 1577 - cpu_to_le32(0xC01E0400) 1587 1587 + #define STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED cpu_to_le32(0xC01E0400) 1578 1588 #define STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED cpu_to_le32(0xC01E0401) 1579 1589 #define STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER cpu_to_le32(0xC01E0430) 1580 1590 #define STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED cpu_to_le32(0xC01E0431) ··· 1576 1604 #define STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE cpu_to_le32(0xC01E0436) 1577 1605 #define STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER cpu_to_le32(0xC01E0438) 1578 1606 #define STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED cpu_to_le32(0xC01E043B) 1579 1579 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS \ 1580 1580 - cpu_to_le32(0xC01E051C) 1607 1607 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS cpu_to_le32(0xC01E051C) 1581 1608 #define STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST cpu_to_le32(0xC01E051D) 1582 1609 #define STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR cpu_to_le32(0xC01E051E) 1583 1583 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS \ 1584 1584 - cpu_to_le32(0xC01E051F) 1610 1610 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS cpu_to_le32(0xC01E051F) 1585 1611 #define STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED cpu_to_le32(0xC01E0520) 1586 1586 - #define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST \ 1587 1587 - cpu_to_le32(0xC01E0521) 1612 1612 + #define STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST cpu_to_le32(0xC01E0521) 1588 1613 #define STATUS_GRAPHICS_OPM_NOT_SUPPORTED cpu_to_le32(0xC01E0500) 1589 1614 #define STATUS_GRAPHICS_COPP_NOT_SUPPORTED cpu_to_le32(0xC01E0501) 1590 1615 #define STATUS_GRAPHICS_UAB_NOT_SUPPORTED cpu_to_le32(0xC01E0502) 1591 1616 #define STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS cpu_to_le32(0xC01E0503) 1592 1617 #define STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E0504) 1593 1618 #define STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST cpu_to_le32(0xC01E0505) 1594 1594 - #define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME \ 1595 1595 - cpu_to_le32(0xC01E0506) 1596 1596 - #define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP \ 1597 1597 - cpu_to_le32(0xC01E0507) 1598 1598 - #define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED \ 1599 1599 - cpu_to_le32(0xC01E0508) 1619 1619 + #define STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E0506) 1620 1620 + #define STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E0507) 1621 1621 + #define STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E0508) 1600 1622 #define STATUS_GRAPHICS_OPM_INVALID_POINTER cpu_to_le32(0xC01E050A) 1601 1623 #define STATUS_GRAPHICS_OPM_INTERNAL_ERROR cpu_to_le32(0xC01E050B) 1602 1624 #define STATUS_GRAPHICS_OPM_INVALID_HANDLE cpu_to_le32(0xC01E050C) 1603 1603 - #define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE \ 1604 1604 - cpu_to_le32(0xC01E050D) 1625 1625 + #define STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E050D) 1605 1626 #define STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH cpu_to_le32(0xC01E050E) 1606 1627 #define STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED cpu_to_le32(0xC01E050F) 1607 1628 #define STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED cpu_to_le32(0xC01E0510) ··· 1602 1637 #define STATUS_GRAPHICS_OPM_INVALID_SRM cpu_to_le32(0xC01E0512) 1603 1638 #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP cpu_to_le32(0xC01E0513) 1604 1639 #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP cpu_to_le32(0xC01E0514) 1605 1605 - #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA \ 1606 1606 - cpu_to_le32(0xC01E0515) 1640 1640 + #define STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA cpu_to_le32(0xC01E0515) 1607 1641 #define STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET cpu_to_le32(0xC01E0516) 1608 1642 #define STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH cpu_to_le32(0xC01E0517) 1609 1609 - #define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE \ 1610 1610 - cpu_to_le32(0xC01E0518) 1611 1611 - #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS \ 1612 1612 - cpu_to_le32(0xC01E051A) 1613 1613 - #define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS \ 1614 1614 - cpu_to_le32(0xC01E051B) 1643 1643 + #define STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE cpu_to_le32(0xC01E0518) 1644 1644 + #define STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS cpu_to_le32(0xC01E051A) 1645 1645 + #define STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E051B) 1615 1646 #define STATUS_GRAPHICS_I2C_NOT_SUPPORTED cpu_to_le32(0xC01E0580) 1616 1647 #define STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST cpu_to_le32(0xC01E0581) 1617 1648 #define STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA cpu_to_le32(0xC01E0582) 1618 1649 #define STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA cpu_to_le32(0xC01E0583) 1619 1650 #define STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED cpu_to_le32(0xC01E0584) 1620 1651 #define STATUS_GRAPHICS_DDCCI_INVALID_DATA cpu_to_le32(0xC01E0585) 1621 1621 - #define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE \ 1622 1622 - cpu_to_le32(0xC01E0586) 1623 1623 - #define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING \ 1624 1624 - cpu_to_le32(0xC01E0587) 1652 1652 + #define STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE cpu_to_le32(0xC01E0586) 1653 1653 + #define STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING cpu_to_le32(0xC01E0587) 1625 1654 #define STATUS_GRAPHICS_MCA_INTERNAL_ERROR cpu_to_le32(0xC01E0588) 1626 1655 #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND cpu_to_le32(0xC01E0589) 1627 1656 #define STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH cpu_to_le32(0xC01E058A) ··· 1623 1664 #define STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE cpu_to_le32(0xC01E058C) 1624 1665 #define STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS cpu_to_le32(0xC01E058D) 1625 1666 #define STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED cpu_to_le32(0xC01E05E0) 1626 1626 - #define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME \ 1627 1627 - cpu_to_le32(0xC01E05E1) 1628 1628 - #define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP \ 1629 1629 - cpu_to_le32(0xC01E05E2) 1667 1667 + #define STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME cpu_to_le32(0xC01E05E1) 1668 1668 + #define STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP cpu_to_le32(0xC01E05E2) 1630 1669 #define STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED cpu_to_le32(0xC01E05E3) 1631 1670 #define STATUS_GRAPHICS_INVALID_POINTER cpu_to_le32(0xC01E05E4) 1632 1632 - #define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE \ 1633 1633 - cpu_to_le32(0xC01E05E5) 1671 1671 + #define STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE cpu_to_le32(0xC01E05E5) 1634 1672 #define STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL cpu_to_le32(0xC01E05E6) 1635 1673 #define STATUS_GRAPHICS_INTERNAL_ERROR cpu_to_le32(0xC01E05E7) 1636 1674 #define STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS cpu_to_le32(0xC01E05E8) ··· 1773 1817 #define STATUS_IPSEC_INVALID_PACKET cpu_to_le32(0xC0360005) 1774 1818 #define STATUS_IPSEC_INTEGRITY_CHECK_FAILED cpu_to_le32(0xC0360006) 1775 1819 #define STATUS_IPSEC_CLEAR_TEXT_DROP cpu_to_le32(0xC0360007) 1776 1776 - 1777 1820 #define STATUS_NO_PREAUTH_INTEGRITY_HASH_OVERLAP cpu_to_le32(0xC05D0000) 1778 1821 #define STATUS_INVALID_LOCK_RANGE cpu_to_le32(0xC00001a1)

+1 -1

fs/smb/server/transport_rdma.c

reviewed

··· 21 21 #include "glob.h" 22 22 #include "connection.h" 23 23 #include "smb_common.h" 24 24 - #include "smbstatus.h" 24 24 + #include "../common/smb2status.h" 25 25 #include "transport_rdma.h" 26 26 27 27 #define SMB_DIRECT_PORT_IWARP 5445