wine-devel May 2021

wine-devel@winehq.org

86 participants
705 discussions

[PATCH vkd3d 1/6] vkd3d-shader: Parse SM5.1 register ranges.
by Conor McCarthy 26 May '21

26 May '21

Based on register loading code from Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 121 ++++++++++++++++------- libs/vkd3d-shader/spirv.c | 86 +++++++++++----- libs/vkd3d-shader/vkd3d_shader_main.c | 17 ++-- libs/vkd3d-shader/vkd3d_shader_private.h | 8 +- 4 files changed, 157 insertions(+), 75 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index d2cf87e3..ad1db82a 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -622,12 +622,24 @@ static void shader_sm4_read_shader_data(struct vkd3d_shader_instruction *ins, ins->declaration.icb = &priv->icb; } -static unsigned int shader_sm4_map_resource_idx(struct vkd3d_shader_register *reg, const struct vkd3d_sm4_data *priv) +static void shader_sm4_read_register_indices(struct vkd3d_shader_resource *resource, + struct vkd3d_shader_instruction *ins, struct vkd3d_sm4_data *priv) { if (shader_is_sm_5_1(priv)) - return reg->idx[1].offset; + { + resource->register_first = resource->reg.reg.idx[1].offset; + resource->register_last = resource->reg.reg.idx[2].offset; + if (resource->register_last < resource->register_first) + { + FIXME("Invalid register range [%u:%u].\n", resource->register_first, resource->register_last); + ins->handler_idx = VKD3DSIH_INVALID; + } + } else - return reg->idx[0].offset; + { + resource->register_first = resource->reg.reg.idx[0].offset; + resource->register_last = resource->register_first; + } } static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, @@ -635,6 +647,7 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, struct vkd3d_sm4_data *priv) { struct vkd3d_shader_semantic *semantic = &ins->declaration.semantic; + struct vkd3d_shader_resource *resource = &semantic->resource; enum vkd3d_sm4_resource_type resource_type; const DWORD *end = &tokens[token_count]; enum vkd3d_sm4_data_type data_type; @@ -653,8 +666,7 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, semantic->resource_type = resource_type_table[resource_type]; } reg_data_type = opcode == VKD3D_SM4_OP_DCL_RESOURCE ? VKD3D_DATA_RESOURCE : VKD3D_DATA_UAV; - shader_sm4_read_dst_param(priv, &tokens, end, reg_data_type, &semantic->resource.reg); - semantic->resource.register_index = shader_sm4_map_resource_idx(&semantic->resource.reg.reg, priv); + shader_sm4_read_dst_param(priv, &tokens, end, reg_data_type, &resource->reg); components = *tokens++; for (i = 0; i < VKD3D_VEC4_SIZE; i++) @@ -675,23 +687,21 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, if (reg_data_type == VKD3D_DATA_UAV) ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - shader_sm4_read_register_space(priv, &tokens, end, &semantic->resource.register_space); + shader_sm4_read_register_space(priv, &tokens, end, &resource->register_space); + shader_sm4_read_register_indices(resource, ins, priv); } static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_constant_buffer *cb = &ins->declaration.cb; const DWORD *end = &tokens[token_count]; - shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_FLOAT, &ins->declaration.cb.src); - ins->declaration.cb.register_index = shader_sm4_map_resource_idx(&ins->declaration.cb.src.reg, priv); if (opcode_token & VKD3D_SM4_INDEX_TYPE_MASK) ins->flags |= VKD3DSI_INDEXED_DYNAMIC; - ins->declaration.cb.size = ins->declaration.cb.src.reg.idx[2].offset; - ins->declaration.cb.register_space = 0; - + shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_FLOAT, &cb->src); if (shader_is_sm_5_1(priv)) { if (tokens >= end) @@ -700,8 +710,22 @@ static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction return; } - ins->declaration.cb.size = *tokens++; - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.cb.register_space); + cb->size = *tokens++; + shader_sm4_read_register_space(priv, &tokens, end, &cb->register_space); + cb->register_first = cb->src.reg.idx[1].offset; + cb->register_last = cb->src.reg.idx[2].offset; + if (cb->register_last < cb->register_first) + { + FIXME("Invalid register range [%u:%u].\n", cb->register_first, cb->register_last); + ins->handler_idx = VKD3DSIH_INVALID; + } + } + else + { + cb->size = cb->src.reg.idx[2].offset; + cb->register_space = 0; + cb->register_first = cb->src.reg.idx[0].offset; + cb->register_last = cb->register_first; } } @@ -709,14 +733,31 @@ static void shader_sm4_read_dcl_sampler(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_sampler *sampler = &ins->declaration.sampler; const DWORD *end = &tokens[token_count]; ins->flags = (opcode_token & VKD3D_SM4_SAMPLER_MODE_MASK) >> VKD3D_SM4_SAMPLER_MODE_SHIFT; if (ins->flags & ~VKD3D_SM4_SAMPLER_COMPARISON) FIXME("Unhandled sampler mode %#x.\n", ins->flags); - shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_SAMPLER, &ins->declaration.sampler.src); - ins->declaration.sampler.register_index = shader_sm4_map_resource_idx(&ins->declaration.sampler.src.reg, priv); - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.sampler.register_space); + + shader_sm4_read_src_param(priv, &tokens, end, VKD3D_DATA_SAMPLER, &sampler->src); + if (shader_is_sm_5_1(priv)) + { + shader_sm4_read_register_space(priv, &tokens, end, &sampler->register_space); + sampler->register_first = sampler->src.reg.idx[1].offset; + sampler->register_last = sampler->src.reg.idx[2].offset; + if (sampler->register_last < sampler->register_first) + { + FIXME("Invalid register range [%u:%u].\n", sampler->register_first, sampler->register_last); + ins->handler_idx = VKD3DSIH_INVALID; + } + } + else + { + sampler->register_space = 0; + sampler->register_first = sampler->src.reg.idx[0].offset; + sampler->register_last = sampler->register_first; + } } static void shader_sm4_read_dcl_index_range(struct vkd3d_shader_instruction *ins, @@ -912,29 +953,32 @@ static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { - struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource; + struct vkd3d_shader_resource *resource = &ins->declaration.raw_resource.resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->resource.reg); - resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); + + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->reg); + shader_sm4_read_register_space(priv, &tokens, end, &resource->register_space); + shader_sm4_read_register_indices(resource, ins, priv); } static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { - struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource; + struct vkd3d_shader_structured_resource *structured = &ins->declaration.structured_resource; + struct vkd3d_shader_resource *resource = &structured->resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->resource.reg); - resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - resource->byte_stride = *tokens++; - if (resource->byte_stride % 4) - FIXME("Byte stride %u is not multiple of 4.\n", resource->byte_stride); - shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); + + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->reg); + structured->byte_stride = *tokens++; + if (structured->byte_stride % 4) + FIXME("Byte stride %u is not multiple of 4.\n", structured->byte_stride); + shader_sm4_read_register_space(priv, &tokens, end, &resource->register_space); + shader_sm4_read_register_indices(resource, ins, priv); } static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins, @@ -963,27 +1007,28 @@ static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruct DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { - struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource; + struct vkd3d_shader_structured_resource *structured = &ins->declaration.structured_resource; + struct vkd3d_shader_resource *resource = &structured->resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->resource.reg); - resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); - resource->byte_stride = *tokens++; - if (resource->byte_stride % 4) - FIXME("Byte stride %u is not multiple of 4.\n", resource->byte_stride); - shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->reg); + structured->byte_stride = *tokens++; + if (structured->byte_stride % 4) + FIXME("Byte stride %u is not multiple of 4.\n", structured->byte_stride); + shader_sm4_read_register_space(priv, &tokens, end, &resource->register_space); + shader_sm4_read_register_indices(resource, ins, priv); } static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { - struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource; + struct vkd3d_shader_resource *resource = &ins->declaration.raw_resource.resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->resource.reg); - resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); - shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->reg); + shader_sm4_read_register_space(priv, &tokens, end, &resource->register_space); + shader_sm4_read_register_indices(resource, ins, priv); } static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins, diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d477b384..0342efa3 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -2077,6 +2077,14 @@ static const char *debug_vkd3d_symbol(const struct vkd3d_symbol *symbol) } } +static const char *debug_register_range(unsigned int register_first, unsigned int register_last, bool bounded) +{ + if (bounded) + return vkd3d_dbg_sprintf("[%u:%u]", register_first, register_last); + else + return vkd3d_dbg_sprintf("[%u:*]", register_first); +} + struct vkd3d_if_cf_info { size_t stream_location; @@ -2404,9 +2412,12 @@ static struct vkd3d_push_constant_buffer_binding *vkd3d_dxbc_compiler_find_push_ const struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_constant_buffer *cb) { unsigned int register_space = cb->register_space; - unsigned int reg_idx = cb->register_index; + unsigned int reg_idx = cb->register_first; unsigned int i; + if (cb->register_first != cb->register_last) + return NULL; + for (i = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i) { struct vkd3d_push_constant_buffer_binding *current = &compiler->push_constants[i]; @@ -2431,7 +2442,10 @@ static bool vkd3d_dxbc_compiler_has_combined_sampler(const struct vkd3d_dxbc_com if (!shader_interface->combined_sampler_count) return false; - if (resource && resource->reg.reg.type == VKD3DSPR_UAV) + if (resource && (resource->reg.reg.type == VKD3DSPR_UAV || resource->register_last != resource->register_first)) + return false; + + if (sampler && sampler->register_first != sampler->register_last) return false; for (i = 0; i < shader_interface->combined_sampler_count; ++i) @@ -2442,9 +2456,9 @@ static bool vkd3d_dxbc_compiler_has_combined_sampler(const struct vkd3d_dxbc_com continue; if ((!resource || (combined_sampler->resource_space == resource->register_space - && combined_sampler->resource_index == resource->register_index)) + && combined_sampler->resource_index == resource->register_first)) && (!sampler || (combined_sampler->sampler_space == sampler->register_space - && combined_sampler->sampler_index == sampler->register_index))) + && combined_sampler->sampler_index == sampler->register_first))) return true; } @@ -2464,12 +2478,14 @@ static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_dxbc_compiler_error(struct vkd3d_dxbc_ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor_binding( struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_register *reg, unsigned int register_space, - unsigned int reg_idx, enum vkd3d_shader_resource_type resource_type, bool is_uav_counter) + unsigned int register_first, unsigned int register_last, enum vkd3d_shader_resource_type resource_type, + bool is_uav_counter) { const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface; enum vkd3d_shader_descriptor_type descriptor_type; enum vkd3d_shader_binding_flag resource_type_flag; struct vkd3d_shader_descriptor_binding binding; + bool bounded = true; unsigned int i; if (reg->type == VKD3DSPR_CONSTBUFFER) @@ -2491,6 +2507,12 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor resource_type_flag = resource_type == VKD3D_SHADER_RESOURCE_BUFFER ? VKD3D_SHADER_BINDING_FLAG_BUFFER : VKD3D_SHADER_BINDING_FLAG_IMAGE; + if (register_last == ~0u) + { + bounded = false; + register_last = register_first; + } + if (is_uav_counter) { assert(descriptor_type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV); @@ -2501,15 +2523,17 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor if (!vkd3d_dxbc_compiler_check_shader_visibility(compiler, current->shader_visibility)) continue; - if (current->register_space != register_space || current->register_index != reg_idx) + if (current->register_space != register_space || current->register_index > register_first + || current->register_index + current->binding.count <= register_last) continue; if (current->offset) { FIXME("Atomic counter offsets are not supported yet.\n"); vkd3d_dxbc_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING, - "Descriptor binding for UAV counter %u, space %u has unsupported ‘offset’ %u.", - reg_idx, register_space, current->offset); + "Descriptor binding for UAV counter %s, space %u has unsupported ‘offset’ %u.", + debug_register_range(register_first, register_last, bounded), + register_space, current->offset); } if (current->binding.count != 1) @@ -2517,16 +2541,18 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor FIXME("Descriptor arrays are not supported.\n"); vkd3d_dxbc_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_INVALID_DESCRIPTOR_BINDING, "Descriptor binding for UAV counter %u, space %u has unsupported ‘count’ %u.", - reg_idx, register_space, current->binding.count); + register_first, register_space, current->binding.count); } return current->binding; } if (shader_interface->uav_counter_count) { - FIXME("Could not find descriptor binding for UAV counter %u, space %u.\n", reg_idx, register_space); + FIXME("Could not find descriptor binding for UAV counters %s, space %u.\n", + debug_register_range(register_first, register_last, bounded), register_space); vkd3d_dxbc_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_BINDING_NOT_FOUND, - "Could not find descriptor binding for UAV counter %u, space %u.", reg_idx, register_space); + "Could not find descriptor binding for UAV counters %s, space %u.", + debug_register_range(register_first, register_last, bounded), register_space); } } else @@ -2542,7 +2568,8 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor continue; if (current->type != descriptor_type || current->register_space != register_space - || current->register_index != reg_idx) + || current->register_index > register_first + || current->register_index + current->binding.count <= register_last) continue; if (current->binding.count != 1) @@ -2558,11 +2585,13 @@ static struct vkd3d_shader_descriptor_binding vkd3d_dxbc_compiler_get_descriptor } if (shader_interface->binding_count) { - FIXME("Could not find binding for type %#x, space %u, register %u, shader type %#x.\n", - descriptor_type, register_space, reg_idx, compiler->shader_type); + FIXME("Could not find binding for type %#x, space %u, registers %s, shader type %#x.\n", + descriptor_type, register_space, debug_register_range(register_first, register_last, bounded), + compiler->shader_type); vkd3d_dxbc_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_DESCRIPTOR_BINDING_NOT_FOUND, - "Could not find descriptor binding for type %#x, space %u, register %u, shader type %#x.", - descriptor_type, register_space, reg_idx, compiler->shader_type); + "Could not find descriptor binding for type %#x, space %u, registers %s, shader type %#x.", + descriptor_type, register_space, debug_register_range(register_first, register_last, bounded), + compiler->shader_type); } } @@ -2585,12 +2614,13 @@ static void vkd3d_dxbc_compiler_emit_descriptor_binding(struct vkd3d_dxbc_compil static void vkd3d_dxbc_compiler_emit_descriptor_binding_for_reg(struct vkd3d_dxbc_compiler *compiler, uint32_t variable_id, const struct vkd3d_shader_register *reg, unsigned int register_space, - unsigned int register_index, enum vkd3d_shader_resource_type resource_type, bool is_uav_counter) + unsigned int register_first, unsigned int register_last, enum vkd3d_shader_resource_type resource_type, + bool is_uav_counter) { struct vkd3d_shader_descriptor_binding binding; binding = vkd3d_dxbc_compiler_get_descriptor_binding(compiler, reg, register_space, - register_index, resource_type, is_uav_counter); + register_first, register_last, resource_type, is_uav_counter); vkd3d_dxbc_compiler_emit_descriptor_binding(compiler, variable_id, &binding); } @@ -5365,7 +5395,7 @@ static void vkd3d_dxbc_compiler_emit_dcl_sampler(struct vkd3d_dxbc_compiler *com vkd3d_symbol_make_sampler(&reg_symbol, reg); reg_symbol.info.sampler.register_space = sampler->register_space; - reg_symbol.info.sampler.register_index = sampler->register_index; + reg_symbol.info.sampler.register_index = sampler->register_first; vkd3d_dxbc_compiler_put_symbol(compiler, &reg_symbol); if (vkd3d_dxbc_compiler_has_combined_sampler(compiler, NULL, sampler)) @@ -5435,7 +5465,8 @@ static const struct vkd3d_shader_descriptor_info *vkd3d_dxbc_compiler_get_descri for (i = 0; i < descriptor_info->descriptor_count; ++i) { d = &descriptor_info->descriptors[i]; - if (d->type == type && d->register_space == register_space && d->register_index == register_index) + if (d->type == type && d->register_space == register_space && d->register_index <= register_index + && (d->count == ~0u || d->register_index + d->count > register_index)) return d; } @@ -5556,7 +5587,9 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp const struct vkd3d_shader_register *reg = &resource->reg.reg; const struct vkd3d_spirv_resource_type *resource_type_info; unsigned int register_space = resource->register_space; - unsigned int register_index = resource->register_index; + unsigned int register_first = resource->register_first; + unsigned int register_last = resource->register_last; + struct vkd3d_shader_descriptor_binding binding; enum vkd3d_shader_component_type sampled_type; struct vkd3d_symbol resource_symbol; bool is_uav; @@ -5574,7 +5607,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp if (vkd3d_dxbc_compiler_has_combined_sampler(compiler, resource, NULL)) { vkd3d_dxbc_compiler_emit_combined_sampler_declarations(compiler, reg, register_space, - register_index, resource_type, sampled_type, structure_stride, raw, resource_type_info); + register_first, resource_type, sampled_type, structure_stride, raw, resource_type_info); return; } @@ -5597,7 +5630,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp else { type_id = vkd3d_dxbc_compiler_get_image_type_id(compiler, reg, register_space, - register_index, resource_type_info, sampled_type, structure_stride || raw, 0); + register_first, resource_type_info, sampled_type, structure_stride || raw, 0); } ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id); @@ -5614,7 +5647,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp const struct vkd3d_shader_descriptor_info *d; d = vkd3d_dxbc_compiler_get_descriptor_info(compiler, - VKD3D_SHADER_DESCRIPTOR_TYPE_UAV, register_space, register_index); + VKD3D_SHADER_DESCRIPTOR_TYPE_UAV, register_space, register_first); if (!(d->flags & VKD3D_SHADER_DESCRIPTOR_INFO_FLAG_UAV_READ)) vkd3d_spirv_build_op_decorate(builder, var_id, SpvDecorationNonReadable, NULL, 0); @@ -5650,7 +5683,8 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp ptr_type_id, storage_class, 0); vkd3d_dxbc_compiler_emit_descriptor_binding_for_reg(compiler, - counter_var_id, reg, register_space, register_index, resource_type, true); + counter_var_id, reg, register_space, register_first, register_last, + resource_type, true); vkd3d_spirv_build_op_name(builder, counter_var_id, "u%u_counter", reg->idx[0].offset); } @@ -5659,7 +5693,7 @@ static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_comp vkd3d_symbol_make_resource(&resource_symbol, reg); resource_symbol.id = var_id; resource_symbol.info.resource.register_space = register_space; - resource_symbol.info.resource.register_index = register_index; + resource_symbol.info.resource.register_index = register_first; resource_symbol.info.resource.sampled_type = sampled_type; resource_symbol.info.resource.type_id = type_id; resource_symbol.info.resource.resource_type_info = resource_type_info; diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 2308b894..31029ad9 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -580,9 +580,9 @@ static void vkd3d_shader_scan_record_uav_counter(struct vkd3d_shader_scan_contex } static bool vkd3d_shader_scan_add_descriptor(struct vkd3d_shader_scan_context *context, - enum vkd3d_shader_descriptor_type type, unsigned int register_space, unsigned int register_index, - enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_resource_data_type resource_data_type, - unsigned int flags) + enum vkd3d_shader_descriptor_type type, unsigned int register_space, unsigned int register_first, + unsigned int register_last, enum vkd3d_shader_resource_type resource_type, + enum vkd3d_shader_resource_data_type resource_data_type, unsigned int flags) { struct vkd3d_shader_scan_descriptor_info *info = context->scan_descriptor_info; struct vkd3d_shader_descriptor_info *d; @@ -597,11 +597,11 @@ static bool vkd3d_shader_scan_add_descriptor(struct vkd3d_shader_scan_context *c d = &info->descriptors[info->descriptor_count]; d->type = type; d->register_space = register_space; - d->register_index = register_index; + d->register_index = register_first; d->resource_type = resource_type; d->resource_data_type = resource_data_type; d->flags = flags; - d->count = 1; + d->count = (register_last == ~0u) ? ~0u : register_last - register_first + 1; ++info->descriptor_count; return true; @@ -633,7 +633,7 @@ static void vkd3d_shader_scan_constant_buffer_declaration(struct vkd3d_shader_sc return; vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV, cb->register_space, - cb->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0); + cb->register_first, cb->register_last, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0); } static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_context *context, @@ -650,7 +650,8 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte else flags = 0; vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, sampler->register_space, - sampler->register_index, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT, flags); + sampler->register_first, sampler->register_last, VKD3D_SHADER_RESOURCE_NONE, + VKD3D_SHADER_RESOURCE_DATA_UINT, flags); } static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_context *context, @@ -667,7 +668,7 @@ static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_cont else type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; vkd3d_shader_scan_add_descriptor(context, type, resource->register_space, - resource->register_index, resource_type, resource_data_type, 0); + resource->register_first, resource->register_last, resource_type, resource_data_type, 0); if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) vkd3d_shader_scan_add_uav_range(context, resource->reg.reg.idx[0].offset, context->scan_descriptor_info->descriptor_count - 1); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 6d756e40..54930fa2 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -640,7 +640,7 @@ struct vkd3d_shader_resource { struct vkd3d_shader_dst_param reg; unsigned int register_space; - unsigned int register_index; + unsigned int register_first, register_last; }; enum vkd3d_decl_usage @@ -715,14 +715,16 @@ struct vkd3d_shader_register_semantic struct vkd3d_shader_sampler { struct vkd3d_shader_src_param src; - unsigned int register_space, register_index; + unsigned int register_space; + unsigned int register_first, register_last; }; struct vkd3d_shader_constant_buffer { struct vkd3d_shader_src_param src; unsigned int size; - unsigned int register_space, register_index; + unsigned int register_space; + unsigned int register_first, register_last; }; struct vkd3d_shader_structured_resource -- 2.31.1

1 5

[PATCH vkd3d 1/3] vkd3d: Track descriptor heaps to allow size querying by descriptor handle.
by Conor McCarthy 26 May '21

26 May '21

Required for variable Vulkan bindings. The actual size must be specified when creating a Vulkan descriptor set. Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- libs/vkd3d/device.c | 68 ++++++++++++++++++++++++++++++++++++++ libs/vkd3d/resource.c | 14 ++++++++ libs/vkd3d/vkd3d_private.h | 9 +++++ 3 files changed, 91 insertions(+) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 877512e3..a4c8bca8 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2228,6 +2228,7 @@ static ULONG STDMETHODCALLTYPE d3d12_device_Release(ID3D12Device *iface) vkd3d_fence_worker_stop(&device->fence_worker, device); d3d12_device_destroy_pipeline_cache(device); d3d12_device_destroy_vkd3d_queues(device); + vkd3d_free(device->descriptor_heaps); for (i = 0; i < ARRAY_SIZE(device->desc_mutex); ++i) pthread_mutex_destroy(&device->desc_mutex[i]); VK_CALL(vkDestroyDevice(device->vk_device, NULL)); @@ -3727,6 +3728,10 @@ static HRESULT d3d12_device_init(struct d3d12_device *device, if ((device->parent = create_info->parent)) IUnknown_AddRef(device->parent); + device->descriptor_heap_capacity = 0; + device->descriptor_heap_count = 0; + device->descriptor_heaps = NULL; + return S_OK; out_destroy_null_resources: @@ -3782,6 +3787,69 @@ void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason, device->removed_reason = reason; } +void d3d12_device_track_descriptor_heap(struct d3d12_device *device, + const struct d3d12_descriptor_heap *heap) +{ + if (!device->vk_info.EXT_descriptor_indexing) + return; + + if (!vkd3d_array_reserve((void **)&device->descriptor_heaps, &device->descriptor_heap_capacity, + device->descriptor_heap_count + 1, sizeof(*device->descriptor_heaps))) + { + ERR("Cannot track descriptor heap for unbounded arrays. Out of memory.\n"); + return; + } + + device->descriptor_heaps[device->descriptor_heap_count++] = heap; + /* Do not increment the heap reference count. This reference is deleted on heap destruction. */ +} + +void d3d12_device_untrack_descriptor_heap(struct d3d12_device *device, + const struct d3d12_descriptor_heap *heap) +{ + size_t i; + + if (!device->vk_info.EXT_descriptor_indexing) + return; + + for (i = 0; i < device->descriptor_heap_count; ++i) + { + if (device->descriptor_heaps[i] != heap) + continue; + memmove(&device->descriptor_heaps[i], &device->descriptor_heaps[i + 1], + (device->descriptor_heap_count - i - 1) * sizeof(*device->descriptor_heaps)); + --device->descriptor_heap_count; + return; + } + + ERR("Attempted to untrack an already untracked heap.\n"); +} + +/* Return the available size from the specified descriptor to the heap end. */ +uint32_t d3d12_device_descriptor_heap_size_from_descriptor(struct d3d12_device *device, + const struct d3d12_desc *desc) +{ + size_t i; + + for (i = 0; i < device->descriptor_heap_count; ++i) + { + unsigned int size; + + if (device->descriptor_heaps[i]->descriptors > (const BYTE*)desc) + continue; + size = d3d12_device_get_descriptor_handle_increment_size(device, device->descriptor_heaps[i]->desc.Type); + if (device->descriptor_heaps[i]->descriptors + size * device->descriptor_heaps[i]->desc.NumDescriptors + <= (const BYTE*)desc) + continue; + + return device->descriptor_heaps[i]->desc.NumDescriptors + - (uint32_t)(((const BYTE*)desc - device->descriptor_heaps[i]->descriptors) / size); + } + + ERR("Failed to find descriptor heap size from descriptor pointer.\n"); + return 0; +} + HRESULT vkd3d_create_thread(struct vkd3d_instance *instance, PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread) { diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index a9d4d464..f117efc8 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -3327,6 +3327,7 @@ static ULONG STDMETHODCALLTYPE d3d12_descriptor_heap_Release(ID3D12DescriptorHea { struct d3d12_device *device = heap->device; unsigned int i; + int rc; vkd3d_private_store_destroy(&heap->private_store); @@ -3372,6 +3373,12 @@ static ULONG STDMETHODCALLTYPE d3d12_descriptor_heap_Release(ID3D12DescriptorHea vkd3d_free(heap); + if ((rc = pthread_mutex_lock(&device->mutex))) + ERR("Failed to lock mutex, error %d.\n", rc); + d3d12_device_untrack_descriptor_heap(device, heap); + if (!rc) + pthread_mutex_unlock(&device->mutex); + d3d12_device_release(device); } @@ -3504,6 +3511,7 @@ HRESULT d3d12_descriptor_heap_create(struct d3d12_device *device, size_t max_descriptor_count, descriptor_size; struct d3d12_descriptor_heap *object; HRESULT hr; + int rc; if (!(descriptor_size = d3d12_device_get_descriptor_handle_increment_size(device, desc->Type))) { @@ -3537,6 +3545,12 @@ HRESULT d3d12_descriptor_heap_create(struct d3d12_device *device, memset(object->descriptors, 0, descriptor_size * desc->NumDescriptors); + if ((rc = pthread_mutex_lock(&device->mutex))) + ERR("Failed to lock mutex, error %d.\n", rc); + d3d12_device_track_descriptor_heap(device, object); + if (!rc) + pthread_mutex_unlock(&device->mutex); + TRACE("Created descriptor heap %p.\n", object); *descriptor_heap = object; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 02184c87..28742a8b 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -1179,6 +1179,10 @@ struct d3d12_device const struct vkd3d_format_compatibility_list *format_compatibility_lists; struct vkd3d_null_resources null_resources; struct vkd3d_uav_clear_state uav_clear_state; + + size_t descriptor_heap_capacity; + size_t descriptor_heap_count; + const struct d3d12_descriptor_heap **descriptor_heaps; }; HRESULT d3d12_device_create(struct vkd3d_instance *instance, @@ -1190,6 +1194,11 @@ void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason, const char *message, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface) DECLSPEC_HIDDEN; +void d3d12_device_track_descriptor_heap(struct d3d12_device *device, const struct d3d12_descriptor_heap *heap); +void d3d12_device_untrack_descriptor_heap(struct d3d12_device *device, const struct d3d12_descriptor_heap *heap); +uint32_t d3d12_device_descriptor_heap_size_from_descriptor(struct d3d12_device *device, + const struct d3d12_desc *desc); + static inline HRESULT d3d12_device_query_interface(struct d3d12_device *device, REFIID iid, void **object) { return ID3D12Device_QueryInterface(&device->ID3D12Device_iface, iid, object); -- 2.31.1

1 2

[PATCH vkd3d 1/4] vkd3d: Create and track unbounded descriptor set layouts.
by Conor McCarthy 26 May '21

26 May '21

Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- libs/vkd3d/state.c | 124 ++++++++++++++++++++++++++++++------- libs/vkd3d/vkd3d_private.h | 3 + 2 files changed, 106 insertions(+), 21 deletions(-) diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 03684264..18340a07 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -683,6 +683,9 @@ static HRESULT d3d12_root_signature_init_push_constants(struct d3d12_root_signat struct vkd3d_descriptor_set_context { VkDescriptorSetLayoutBinding *current_binding; + VkDescriptorSetLayoutBinding *first_binding; + unsigned int table_index; + bool unbounded; unsigned int descriptor_index; uint32_t descriptor_binding; }; @@ -805,6 +808,62 @@ static unsigned int vk_descriptor_count_from_d3d12_desc_range_type(D3D12_DESCRIP return min(type_max, all_max); } +static unsigned int vkd3d_count_static_descriptor_bindings(struct vkd3d_descriptor_set_context *context) +{ + unsigned int i, binding_count, count = 0; + + binding_count = context->descriptor_binding - !!context->unbounded; + for (i = 0; i < binding_count; ++i) + count += context->first_binding[i].descriptorCount; + + return count; +} + +static HRESULT vkd3d_validate_descriptor_set_count(struct d3d12_device *device, unsigned int set_count) +{ + uint32_t max_count = min(VKD3D_MAX_DESCRIPTOR_SETS, + device->vk_info.device_limits.maxBoundDescriptorSets); + if (set_count > max_count) + { + ERR("Required descriptor set count exceeds maximum allowed count of %u.\n", max_count); + return E_INVALIDARG; + } + return S_OK; +} + +static HRESULT vkd3d_create_descriptor_set_layout(struct d3d12_device *device, + VkDescriptorSetLayoutCreateFlags flags, bool unbounded, unsigned int binding_count, + const VkDescriptorSetLayoutBinding *bindings, VkDescriptorSetLayout *set_layout); + +static HRESULT d3d12_root_signature_append_descriptor_set_layout(struct d3d12_root_signature *root_signature, + struct vkd3d_descriptor_set_context *context, VkDescriptorSetLayoutCreateFlags flags) +{ + HRESULT hr; + + if (!context->descriptor_binding) + return S_OK; + + if (FAILED(hr = vkd3d_validate_descriptor_set_count(root_signature->device, + root_signature->vk_set_count + 1))) + return hr; + + if (FAILED(hr = vkd3d_create_descriptor_set_layout(root_signature->device, + flags, context->unbounded, context->descriptor_binding, + context->first_binding, &root_signature->vk_set_layouts[root_signature->vk_set_count]))) + return hr; + root_signature->vk_unbounded_set_tables[root_signature->vk_set_count] + = context->unbounded ? context->table_index : -1; + root_signature->vk_set_layout_static_counts[root_signature->vk_set_count] + = vkd3d_count_static_descriptor_bindings(context); + ++root_signature->vk_set_count; + + context->current_binding = context->first_binding; + context->descriptor_binding = 0; + context->unbounded = false; + + return S_OK; +} + static HRESULT d3d12_root_signature_init_root_descriptor_tables(struct d3d12_root_signature *root_signature, const D3D12_ROOT_SIGNATURE_DESC *desc, struct vkd3d_descriptor_set_context *context) { @@ -815,6 +874,7 @@ static HRESULT d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo uint32_t vk_binding; root_signature->descriptor_table_mask = 0; + context->unbounded = false; for (i = 0; i < desc->NumParameters; ++i) { @@ -832,6 +892,8 @@ static HRESULT d3d12_root_signature_init_root_descriptor_tables(struct d3d12_roo if (!(table->ranges = vkd3d_calloc(table->range_count, sizeof(*table->ranges)))) return E_OUTOFMEMORY; + context->table_index = i; + for (j = 0; j < range_count; ++j) { range = &p->u.DescriptorTable.pDescriptorRanges[j]; @@ -948,10 +1010,12 @@ static HRESULT d3d12_root_signature_init_static_samplers(struct d3d12_root_signa } static HRESULT vkd3d_create_descriptor_set_layout(struct d3d12_device *device, - VkDescriptorSetLayoutCreateFlags flags, unsigned int binding_count, + VkDescriptorSetLayoutCreateFlags flags, bool unbounded, unsigned int binding_count, const VkDescriptorSetLayoutBinding *bindings, VkDescriptorSetLayout *set_layout) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkDescriptorSetLayoutBindingFlagsCreateInfoEXT flags_info; + VkDescriptorBindingFlagsEXT *set_flags = NULL; VkDescriptorSetLayoutCreateInfo set_desc; VkResult vr; @@ -960,7 +1024,28 @@ static HRESULT vkd3d_create_descriptor_set_layout(struct d3d12_device *device, set_desc.flags = flags; set_desc.bindingCount = binding_count; set_desc.pBindings = bindings; - if ((vr = VK_CALL(vkCreateDescriptorSetLayout(device->vk_device, &set_desc, NULL, set_layout))) < 0) + if (binding_count && device->vk_info.EXT_descriptor_indexing) + { + unsigned int i; + + if (!(set_flags = vkd3d_malloc(binding_count * sizeof(*set_flags)))) + return E_OUTOFMEMORY; + + for (i = 0; i < binding_count; ++i) + set_flags[i] = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT; + + if (unbounded) + set_flags[binding_count - 1] |= VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT; + + set_desc.pNext = &flags_info; + flags_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT; + flags_info.pNext = NULL; + flags_info.bindingCount = binding_count; + flags_info.pBindingFlags = set_flags; + } + vr = VK_CALL(vkCreateDescriptorSetLayout(device->vk_device, &set_desc, NULL, set_layout)); + vkd3d_free(set_flags); + if (vr < 0) { WARN("Failed to create Vulkan descriptor set layout, vr %d.\n", vr); return hresult_from_vk_result(vr); @@ -977,6 +1062,10 @@ static HRESULT vkd3d_create_pipeline_layout(struct d3d12_device *device, const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct VkPipelineLayoutCreateInfo pipeline_layout_info; VkResult vr; + HRESULT hr; + + if (FAILED(hr = vkd3d_validate_descriptor_set_count(device, set_layout_count))) + return hr; pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_info.pNext = NULL; @@ -1017,6 +1106,7 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa root_signature->descriptor_mapping = NULL; root_signature->static_sampler_count = 0; root_signature->static_samplers = NULL; + root_signature->device = device; if (desc->Flags & ~(D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT | D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT)) @@ -1033,6 +1123,7 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa root_signature->mapping_count = info.mapping_count; root_signature->static_sampler_count = desc->NumStaticSamplers; root_signature->root_descriptor_count = info.root_descriptor_count; + root_signature->bindless = device->vk_info.EXT_descriptor_indexing; hr = E_OUTOFMEMORY; root_signature->parameter_count = desc->NumParameters; @@ -1052,22 +1143,18 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa if (!(binding_desc = vkd3d_calloc(info.binding_count, sizeof(*binding_desc)))) goto fail; + context.first_binding = binding_desc; context.current_binding = binding_desc; if (FAILED(hr = d3d12_root_signature_init_root_descriptors(root_signature, desc, &context))) goto fail; /* We use KHR_push_descriptor for root descriptor parameters. */ - if (vk_info->KHR_push_descriptor && context.descriptor_binding) + if (vk_info->KHR_push_descriptor) { - if (FAILED(hr = vkd3d_create_descriptor_set_layout(device, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, - context.descriptor_binding, binding_desc, &root_signature->vk_set_layouts[0]))) + if (FAILED(hr = d3d12_root_signature_append_descriptor_set_layout(root_signature, + &context, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR))) goto fail; - ++root_signature->vk_set_count; - - context.current_binding = binding_desc; - context.descriptor_binding = 0; } if (FAILED(hr = d3d12_root_signature_init_push_constants(root_signature, desc, @@ -1079,14 +1166,9 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa goto fail; root_signature->main_set = root_signature->vk_set_count; - if (context.descriptor_binding) - { - if (FAILED(hr = vkd3d_create_descriptor_set_layout(device, - 0, context.descriptor_binding, binding_desc, - &root_signature->vk_set_layouts[root_signature->vk_set_count]))) - goto fail; - ++root_signature->vk_set_count; - } + if (FAILED(hr = d3d12_root_signature_append_descriptor_set_layout(root_signature, &context, 0))) + goto fail; + vkd3d_free(binding_desc); binding_desc = NULL; @@ -1098,7 +1180,7 @@ static HRESULT d3d12_root_signature_init(struct d3d12_root_signature *root_signa if (FAILED(hr = vkd3d_private_store_init(&root_signature->private_store))) goto fail; - d3d12_device_add_ref(root_signature->device = device); + d3d12_device_add_ref(device); return S_OK; @@ -1708,7 +1790,7 @@ static HRESULT d3d12_pipeline_state_init_compute_uav_counters(struct d3d12_pipel /* Create a descriptor set layout for UAV counters. */ hr = vkd3d_create_descriptor_set_layout(device, - 0, descriptor_binding, binding_desc, &state->vk_set_layout); + 0, false, descriptor_binding, binding_desc, &state->vk_set_layout); vkd3d_free(binding_desc); if (FAILED(hr)) { @@ -3185,7 +3267,7 @@ HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d { set_binding.descriptorType = set_layouts[i].descriptor_type; - if (FAILED(hr = vkd3d_create_descriptor_set_layout(device, 0, 1, &set_binding, set_layouts[i].set_layout))) + if (FAILED(hr = vkd3d_create_descriptor_set_layout(device, 0, false, 1, &set_binding, set_layouts[i].set_layout))) { ERR("Failed to create descriptor set layout %u, hr %#x.\n", i, hr); goto fail; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 79cd3f4f..cc1bf46f 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -702,6 +702,9 @@ struct d3d12_root_signature VkPipelineLayout vk_pipeline_layout; uint32_t vk_set_count; VkDescriptorSetLayout vk_set_layouts[VKD3D_MAX_DESCRIPTOR_SETS]; + unsigned int vk_set_layout_static_counts[VKD3D_MAX_DESCRIPTOR_SETS]; + int vk_unbounded_set_tables[VKD3D_MAX_DESCRIPTOR_SETS]; + bool bindless; struct d3d12_root_parameter *parameters; unsigned int parameter_count; -- 2.31.1

1 3

[PATCH 2/2] wbemprox: Support using record in IWbemClassObject Next
by Alistair Leslie-Hughes 26 May '21

26 May '21

Makes the code the same as class_object_Get. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/wbemprox/class.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/dlls/wbemprox/class.c b/dlls/wbemprox/class.c index 2f7752e8671..3b7bc066aea 100644 --- a/dlls/wbemprox/class.c +++ b/dlls/wbemprox/class.c @@ -546,7 +546,17 @@ static HRESULT WINAPI class_object_Next( if (is_method( table, i )) continue; if (!is_result_prop( view, table->columns[i].name )) continue; if (!(prop = SysAllocString( table->columns[i].name ))) return E_OUTOFMEMORY; - if ((hr = get_propval( view, obj->index, prop, pVal, pType, plFlavor )) != S_OK) + if (obj->record) + { + UINT index; + + if ((hr = get_column_index( table, table->columns[i].name, &index )) == S_OK) + hr = record_get_value( obj->record, index, pVal, pType ); + } + else + hr = get_propval( view, obj->index, prop, pVal, pType, plFlavor ); + + if (FAILED(hr)) { SysFreeString( prop ); return hr; -- 2.30.2

2 1

[PATCH 1/2] wbemprox: Support only getting type in record_get_value
by Alistair Leslie-Hughes 26 May '21

26 May '21

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/wbemprox/class.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/wbemprox/class.c b/dlls/wbemprox/class.c index 2f2d3ef2bfb..2f7752e8671 100644 --- a/dlls/wbemprox/class.c +++ b/dlls/wbemprox/class.c @@ -354,6 +354,7 @@ static HRESULT record_get_value( const struct record *record, UINT index, VARIAN VARTYPE vartype = to_vartype( record->fields[index].type & CIM_TYPE_MASK ); if (type) *type = record->fields[index].type; + if (!var) return S_OK; if (record->fields[index].type & CIM_FLAG_ARRAY) { -- 2.30.2

2 1

[PATCH] wtsapi32: Implement WTSEnumerateProcessesW().
by Zebediah Figura 26 May '21

26 May '21

Based on a patch by Sebastian Lackner. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=29903 Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wtsapi32/tests/Makefile.in | 2 +- dlls/wtsapi32/tests/wtsapi.c | 141 ++++++++++++++++++++++++++----- dlls/wtsapi32/wtsapi32.c | 143 +++++++++++++++++++++++++++++--- include/wtsapi32.h | 1 + 4 files changed, 252 insertions(+), 35 deletions(-) diff --git a/dlls/wtsapi32/tests/Makefile.in b/dlls/wtsapi32/tests/Makefile.in index be0fa8d6772..57014aea938 100644 --- a/dlls/wtsapi32/tests/Makefile.in +++ b/dlls/wtsapi32/tests/Makefile.in @@ -1,5 +1,5 @@ TESTDLL = wtsapi32.dll -IMPORTS = wtsapi32 advapi32 +IMPORTS = wtsapi32 advapi32 psapi C_SRCS = \ wtsapi.c diff --git a/dlls/wtsapi32/tests/wtsapi.c b/dlls/wtsapi32/tests/wtsapi.c index 8ce1dc8bf9c..3eec81d8556 100644 --- a/dlls/wtsapi32/tests/wtsapi.c +++ b/dlls/wtsapi32/tests/wtsapi.c @@ -16,6 +16,8 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <ntstatus.h> +#define WIN32_NO_STATUS #include <stdarg.h> #include <stdlib.h> #include <windef.h> @@ -23,25 +25,93 @@ #include <winternl.h> #include <lmcons.h> #include <wtsapi32.h> +#define PSAPI_VERSION 1 +#include <psapi.h> #include "wine/test.h" +static BOOL (WINAPI *pWTSEnumerateProcessesExW)(HANDLE server, DWORD *level, DWORD session, WCHAR **info, DWORD *count); +static BOOL (WINAPI *pWTSFreeMemoryExW)(WTS_TYPE_CLASS class, void *memory, ULONG count); + +static const SYSTEM_PROCESS_INFORMATION *find_nt_process_info(const SYSTEM_PROCESS_INFORMATION *head, DWORD pid) +{ + for (;;) + { + if ((DWORD)(DWORD_PTR)head->UniqueProcessId == pid) + return head; + if (!head->NextEntryOffset) + break; + head = (SYSTEM_PROCESS_INFORMATION *)((char *)head + head->NextEntryOffset); + } + return NULL; +} + +static void check_wts_process_info(const WTS_PROCESS_INFOW *info, DWORD count) +{ + ULONG nt_length = 1024; + SYSTEM_PROCESS_INFORMATION *nt_info = malloc(nt_length); + WCHAR process_name[MAX_PATH], *process_filepart; + BOOL ret, found = FALSE; + NTSTATUS status; + DWORD i; + + GetModuleFileNameW(NULL, process_name, MAX_PATH); + process_filepart = wcsrchr(process_name, '\\') + 1; + + while ((status = NtQuerySystemInformation(SystemProcessInformation, nt_info, + nt_length, NULL)) == STATUS_INFO_LENGTH_MISMATCH) + { + nt_length *= 2; + nt_info = realloc(nt_info, nt_length); + } + ok(!status, "got %#x\n", status); + + for (i = 0; i < count; i++) + { + char sid_buffer[50]; + SID_AND_ATTRIBUTES *sid = (SID_AND_ATTRIBUTES *)sid_buffer; + const SYSTEM_PROCESS_INFORMATION *nt_process; + HANDLE process, token; + DWORD size; + + nt_process = find_nt_process_info(nt_info, info[i].ProcessId); + ok(!!nt_process, "failed to find pid %#x\n", info[i].ProcessId); + + winetest_push_context("pid %#x", info[i].ProcessId); + + ok(info[i].SessionId == nt_process->SessionId, "expected session id %#x, got %#x\n", + nt_process->SessionId, info[i].SessionId); + + ok(!memcmp(info[i].pProcessName, nt_process->ProcessName.Buffer, nt_process->ProcessName.Length), + "expected process name %s, got %s\n", + debugstr_w(nt_process->ProcessName.Buffer), debugstr_w(info[i].pProcessName)); + + if ((process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, info[i].ProcessId))) + { + ret = OpenProcessToken(process, TOKEN_QUERY, &token); + ok(ret, "failed to open token, error %u\n", GetLastError()); + ret = GetTokenInformation(token, TokenUser, sid_buffer, sizeof(sid_buffer), &size); + ok(ret, "failed to get token user, error %u\n", GetLastError()); + ok(EqualSid(info[i].pUserSid, sid->Sid), "SID did not match\n"); + CloseHandle(token); + CloseHandle(process); + } + + winetest_pop_context(); + + found = found || !wcscmp(info[i].pProcessName, process_filepart); + } + + ok(found, "did not find current process\n"); + + free(nt_info); +} + static void test_WTSEnumerateProcessesW(void) { - BOOL found = FALSE, ret; - DWORD count, i; PWTS_PROCESS_INFOW info; - WCHAR *pname, nameW[MAX_PATH]; - - GetModuleFileNameW(NULL, nameW, MAX_PATH); - for (pname = nameW + lstrlenW(nameW); pname > nameW; pname--) - { - if(*pname == '/' || *pname == '\\') - { - pname++; - break; - } - } + DWORD count, level; + BOOL ret; info = NULL; SetLastError(0xdeadbeef); @@ -80,15 +150,41 @@ static void test_WTSEnumerateProcessesW(void) info = NULL; SetLastError(0xdeadbeef); ret = WTSEnumerateProcessesW(WTS_CURRENT_SERVER_HANDLE, 0, 1, &info, &count); - ok(ret || broken(!ret), /* fails on Win2K with error ERROR_APP_WRONG_OS */ - "expected WTSEnumerateProcessesW to succeed; failed with %d\n", GetLastError()); - for(i = 0; ret && i < count; i++) - { - found = found || !lstrcmpW(pname, info[i].pProcessName); - } - todo_wine - ok(found || broken(!ret), "process name %s not found\n", wine_dbgstr_w(pname)); + ok(ret, "expected success\n"); + ok(!GetLastError(), "got error %u\n", GetLastError()); + check_wts_process_info(info, count); WTSFreeMemory(info); + + if (!pWTSEnumerateProcessesExW) + { + skip("WTSEnumerateProcessesEx is not available\n"); + return; + } + + level = 0; + + SetLastError(0xdeadbeef); + count = 0xdeadbeef; + ret = pWTSEnumerateProcessesExW(WTS_CURRENT_SERVER_HANDLE, &level, WTS_ANY_SESSION, NULL, &count); + ok(!ret, "expected failure\n"); + ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %u\n", GetLastError()); + ok(count == 0xdeadbeef, "got count %u\n", count); + + info = (void *)0xdeadbeef; + SetLastError(0xdeadbeef); + ret = pWTSEnumerateProcessesExW(WTS_CURRENT_SERVER_HANDLE, &level, WTS_ANY_SESSION, (WCHAR **)&info, NULL); + ok(!ret, "expected failure\n"); + ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %u\n", GetLastError()); + ok(info == (void *)0xdeadbeef, "got info %p\n", info); + + info = NULL; + count = 0; + SetLastError(0xdeadbeef); + ret = pWTSEnumerateProcessesExW(WTS_CURRENT_SERVER_HANDLE, &level, WTS_ANY_SESSION, (WCHAR **)&info, &count); + ok(ret, "expected success\n"); + ok(!GetLastError(), "got error %u\n", GetLastError()); + check_wts_process_info(info, count); + pWTSFreeMemoryExW(WTSTypeProcessInfoLevel0, info, count); } static void test_WTSQuerySessionInformation(void) @@ -201,6 +297,9 @@ static void test_WTSQueryUserToken(void) START_TEST (wtsapi) { + pWTSEnumerateProcessesExW = (void *)GetProcAddress(GetModuleHandleA("wtsapi32"), "WTSEnumerateProcessesExW"); + pWTSFreeMemoryExW = (void *)GetProcAddress(GetModuleHandleA("wtsapi32"), "WTSFreeMemoryExW"); + test_WTSEnumerateProcessesW(); test_WTSQuerySessionInformation(); test_WTSQueryUserToken(); diff --git a/dlls/wtsapi32/wtsapi32.c b/dlls/wtsapi32/wtsapi32.c index a5c9bf6519f..d766223df99 100644 --- a/dlls/wtsapi32/wtsapi32.c +++ b/dlls/wtsapi32/wtsapi32.c @@ -15,10 +15,13 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include "ntstatus.h" +#define WIN32_NO_STATUS #include <stdarg.h> #include <stdlib.h> #include "windef.h" #include "winbase.h" +#include "winternl.h" #include "winnls.h" #include "lmcons.h" #include "wtsapi32.h" @@ -76,11 +79,127 @@ BOOL WINAPI WTSEnableChildSessions(BOOL enable) /************************************************************ * WTSEnumerateProcessesExW (WTSAPI32.@) */ -BOOL WINAPI WTSEnumerateProcessesExW(HANDLE server, DWORD *level, DWORD session_id, WCHAR **info, DWORD *count) +BOOL WINAPI WTSEnumerateProcessesExW(HANDLE server, DWORD *level, DWORD session_id, + WCHAR **ret_info, DWORD *ret_count) { - FIXME("Stub %p %p %d %p %p\n", server, level, session_id, info, count); - if (count) *count = 0; - return FALSE; + SYSTEM_PROCESS_INFORMATION *nt_info, *nt_process; + WTS_PROCESS_INFOW *info; + ULONG nt_size = 4096; + DWORD count, size; + NTSTATUS status; + char *p; + + TRACE("server %p, level %u, session_id %#x, ret_info %p, ret_count %p\n", + server, *level, session_id, ret_info, ret_count); + + if (!ret_info || !ret_count) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + if (session_id != WTS_ANY_SESSION) + FIXME("ignoring session id %#x\n", session_id); + + if (*level) + { + FIXME("unhandled level %u\n", *level); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; + } + + if (!(nt_info = malloc(nt_size))) + { + SetLastError(ERROR_OUTOFMEMORY); + return FALSE; + } + + while ((status = NtQuerySystemInformation(SystemProcessInformation, nt_info, + nt_size, NULL)) == STATUS_INFO_LENGTH_MISMATCH) + { + SYSTEM_PROCESS_INFORMATION *new_info; + + nt_size *= 2; + if (!(new_info = realloc(nt_info, nt_size))) + { + free(nt_info); + SetLastError(ERROR_OUTOFMEMORY); + return FALSE; + } + nt_info = new_info; + } + if (status) + { + free(nt_info); + SetLastError(RtlNtStatusToDosError(status)); + return FALSE; + } + + size = 0; + count = 0; + nt_process = nt_info; + for (;;) + { + size += sizeof(WTS_PROCESS_INFOW) + nt_process->ProcessName.Length + sizeof(WCHAR); + size += offsetof(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES]); + ++count; + + if (!nt_process->NextEntryOffset) + break; + nt_process = (SYSTEM_PROCESS_INFORMATION *)((char *)nt_process + nt_process->NextEntryOffset); + } + + if (!(info = heap_alloc(size))) + { + free(nt_info); + SetLastError(ERROR_OUTOFMEMORY); + return FALSE; + } + p = (char *)(info + count); + + count = 0; + nt_process = nt_info; + for (;;) + { + HANDLE process, token; + + info[count].SessionId = nt_process->SessionId; + info[count].ProcessId = (DWORD_PTR)nt_process->UniqueProcessId; + + info[count].pProcessName = (WCHAR *)p; + memcpy(p, nt_process->ProcessName.Buffer, nt_process->ProcessName.Length); + info[count].pProcessName[nt_process->ProcessName.Length / sizeof(WCHAR)] = 0; + p += nt_process->ProcessName.Length + sizeof(WCHAR); + + info[count].pUserSid = NULL; + if ((process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, info[count].ProcessId))) + { + if (OpenProcessToken(process, TOKEN_QUERY, &token)) + { + char buffer[sizeof(TOKEN_USER) + offsetof(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES])]; + TOKEN_USER *user = (TOKEN_USER *)buffer; + DWORD size; + + GetTokenInformation(token, TokenUser, buffer, sizeof(buffer), &size); + info[count].pUserSid = p; + size = GetLengthSid(user->User.Sid); + memcpy(p, user->User.Sid, size); + p += size; + CloseHandle(token); + } + CloseHandle(process); + } + + ++count; + if (!nt_process->NextEntryOffset) + break; + nt_process = (SYSTEM_PROCESS_INFORMATION *)((char *)nt_process + nt_process->NextEntryOffset); + } + + *ret_info = (WCHAR *)info; + *ret_count = count; + SetLastError(0); + return TRUE; } /************************************************************ @@ -113,22 +232,20 @@ BOOL WINAPI WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved, DWORD Version /************************************************************ * WTSEnumerateProcessesW (WTSAPI32.@) */ -BOOL WINAPI WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved, DWORD Version, - PWTS_PROCESS_INFOW* ppProcessInfo, DWORD* pCount) +BOOL WINAPI WTSEnumerateProcessesW(HANDLE server, DWORD reserved, DWORD version, + WTS_PROCESS_INFOW **info, DWORD *count) { - FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version, - ppProcessInfo, pCount); + DWORD level = 0; - if (!ppProcessInfo || !pCount || Reserved != 0 || Version != 1) + TRACE("server %p, reserved %#x, version %u, info %p, count %p\n", server, reserved, version, info, count); + + if (reserved || version != 1) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } - *pCount = 0; - *ppProcessInfo = NULL; - - return TRUE; + return WTSEnumerateProcessesExW(server, &level, WTS_ANY_SESSION, (WCHAR **)info, count); } /************************************************************ diff --git a/include/wtsapi32.h b/include/wtsapi32.h index d9b40ca519c..1bd5b6cd791 100644 --- a/include/wtsapi32.h +++ b/include/wtsapi32.h @@ -171,6 +171,7 @@ DECL_WINELIB_TYPE_AW(PWTS_SERVER_INFO) #define WTS_CURRENT_SERVER_HANDLE ((HANDLE)NULL) #define WTS_CURRENT_SESSION (~0u) +#define WTS_ANY_SESSION ((DWORD)-2) void WINAPI WTSCloseServer(HANDLE); BOOL WINAPI WTSConnectSessionA(ULONG, ULONG, PSTR, BOOL); -- 2.30.2

2 1

[PATCH v11 1/2] mountmgr.sys: Introduce StorageDeviceSeekPenaltyProperty
by David Koolhoven 25 May '21

25 May '21

Allows programs which demand support for StorageDeviceSeekPenaltyProperty to function. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51065 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- v10: Updating compliment test unit. --- dlls/mountmgr.sys/device.c | 17 +++++++++++++++++ include/ntddstor.h | 9 ++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..8e18ed7ff22 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -1894,6 +1894,23 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + FIXME( "Faking StorageDeviceSeekPenaltyProperty data with no penalty\n" ); + if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)) { + status = STATUS_INVALID_PARAMETER; + break; + } + memset( irp->AssociatedIrp.SystemBuffer, 0, sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR) ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->IncursSeekPenalty = FALSE; + status = STATUS_SUCCESS; + irp->IoStatus.Information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.19.1

1 1

[PATCH v10 1/2] mountmgr.sys: Introduce StorageDeviceSeekPenaltyProperty
by David Koolhoven 25 May '21

25 May '21

2 2

[PATCH v9 1/2] mountmgr.sys: Introduce StorageDeviceSeekPenaltyProperty
by David Koolhoven 25 May '21

25 May '21

Allows programs which demand support for StorageDeviceSeekPenaltyProperty to function. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51065 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- v9: Updating compliment test unit. --- dlls/mountmgr.sys/device.c | 17 +++++++++++++++++ include/ntddstor.h | 9 ++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..8e18ed7ff22 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -1894,6 +1894,23 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + FIXME( "Faking StorageDeviceSeekPenaltyProperty data with no penalty\n" ); + if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)) { + status = STATUS_INVALID_PARAMETER; + break; + } + memset( irp->AssociatedIrp.SystemBuffer, 0, sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR) ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->IncursSeekPenalty = FALSE; + status = STATUS_SUCCESS; + irp->IoStatus.Information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.31.1

2 2

[PATCH v8 1/2] mountmgr.sys: Introduce StorageDeviceSeekPenaltyProperty
by David Koolhoven 25 May '21

25 May '21

Allows programs which demand support for StorageDeviceSeekPenaltyProperty to function. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51065 Signed-off-by: David Koolhoven <david(a)koolhoven-home.net> --- v8: Updating compliment test unit. --- dlls/mountmgr.sys/device.c | 17 +++++++++++++++++ include/ntddstor.h | 9 ++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 04e8fe3c0f5..8e18ed7ff22 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -1894,6 +1894,23 @@ static NTSTATUS query_property( struct disk_device *device, IRP *irp ) break; } + case StorageDeviceSeekPenaltyProperty: + { + DEVICE_SEEK_PENALTY_DESCRIPTOR *descriptor; + FIXME( "Faking StorageDeviceSeekPenaltyProperty data with no penalty\n" ); + if (irpsp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)) { + status = STATUS_INVALID_PARAMETER; + break; + } + memset( irp->AssociatedIrp.SystemBuffer, 0, sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR) ); + descriptor = irp->AssociatedIrp.SystemBuffer; + descriptor->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + descriptor->IncursSeekPenalty = FALSE; + status = STATUS_SUCCESS; + irp->IoStatus.Information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR); + break; + } default: FIXME( "Unsupported property %#x\n", query->PropertyId ); status = STATUS_NOT_SUPPORTED; diff --git a/include/ntddstor.h b/include/ntddstor.h index b8c4bb73b0d..836def413fe 100644 --- a/include/ntddstor.h +++ b/include/ntddstor.h @@ -214,7 +214,8 @@ typedef enum _STORAGE_QUERY_TYPE { typedef enum _STORAGE_PROPERTY_ID { StorageDeviceProperty = 0, - StorageAdapterProperty + StorageAdapterProperty = 1, + StorageDeviceSeekPenaltyProperty = 7, } STORAGE_PROPERTY_ID, *PSTORAGE_PROPERTY_ID; typedef struct _STORAGE_PROPERTY_QUERY { @@ -272,6 +273,12 @@ typedef struct _STORAGE_ADAPTER_DESCRIPTOR { USHORT BusMinorVersion; } STORAGE_ADAPTER_DESCRIPTOR, *PSTORAGE_ADAPTER_DESCRIPTOR; +typedef struct _DEVICE_SEEK_PENALTY_DESCRIPTOR { + ULONG Version; + ULONG Size; + BOOLEAN IncursSeekPenalty; +} DEVICE_SEEK_PENALTY_DESCRIPTOR, *PDEVICE_SEEK_PENALTY_DESCRIPTOR; + #ifdef __cplusplus } #endif -- 2.31.1

2 2

← Newer
1
...
13
14
15
16
17
18
19
...
71
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel May 2021