mirror of
https://github.com/FEX-Emu/FEX.git
synced 2026-10-09 21:00:19 +02:00
Ryan Houdek
fe5bc02682
This was brought up by #3831 but I finally got the courage to look at the hard problem. Although I'm only tackling half of the problem with this PR, which is that FEXLoader needs to strip the rootfs path from the executed path if it begins with the rootfs, plus some changes to the surrounding code. The primary concern here is that when an application has been executed under FEX, specifically through binfmt_misc, then FEX needs to prepend the full rootfs path otherwise Linux can't find the program. Additionally execveat with an FD will resolve a full path to the rootfs. So past FEX's initial setup, we need to strip off the rootfs path to provide an "absolute" path that is visible to the guest application later. Which is kind of funny since we have a `RootFSRedirect` function which did the exact opposite. This was due to legacy problems in the original ELFLoader that couldn't handle symlinks correctly, which has since been resolved, so that no longer needs to exist. There was also some weirdness in `GetApplicationNames` where the passed in argument list was modifying Args[0] and then saving the Program as well. Which I just got rid of. Also stopped passing in the arguments by value because....why did I write it like that? In InterpreterHandler we now need to check if we can open the path inside the rootfs or fallback without it. Plus I had to change the shebang handling so it stopped prefixing the rootfs AGAIN. Took the time to change the shebang handling there so it stops creating string copies and instead just generates views. Overall this fixes a fairly major flaw with how we were representing `/proc/self` to the application, which was breaking wine since it would prefix the rootfs multiple times, which was weird. It doesn't address the remaining problem in #3831, which is that applications can still see some of the leaky abstractions with symlinks through the rootfs, but I want to get at least this step in.
100 lines
3.2 KiB
C++
100 lines
3.2 KiB
C++
// SPDX-License-Identifier: MIT
|
|
#pragma once
|
|
#include <FEXCore/Config/Config.h>
|
|
#include <FEXCore/fextl/string.h>
|
|
|
|
namespace FEX::ArgLoader {
|
|
class ArgLoader;
|
|
}
|
|
/**
|
|
* @brief This is a singleton for storing global configuration state
|
|
*/
|
|
namespace FEX::Config {
|
|
class EmptyMapper : public FEXCore::Config::Layer {
|
|
public:
|
|
explicit EmptyMapper()
|
|
: FEXCore::Config::Layer(FEXCore::Config::LayerType::LAYER_MAIN) {}
|
|
void Load() override {}
|
|
|
|
protected:
|
|
};
|
|
|
|
void SaveLayerToJSON(const fextl::string& Filename, FEXCore::Config::Layer* const Layer);
|
|
|
|
struct ApplicationNames {
|
|
// This is the full path to the program (if it exists).
|
|
fextl::string ProgramPath;
|
|
// This is the program executable name (if it exists).
|
|
fextl::string ProgramName;
|
|
};
|
|
|
|
struct PortableInformation {
|
|
bool IsPortable;
|
|
// Path of folder containing FEXInterpreter (including / at the end)
|
|
fextl::string InterpreterPath;
|
|
};
|
|
|
|
/**
|
|
* @param ExecFDInterp If FEX was executed with binfmt_misc FD argument
|
|
* @param ProgramFDFromEnv The execveat FD argument passed through FEX
|
|
*
|
|
* @return The application name and path structure
|
|
*/
|
|
ApplicationNames GetApplicationNames(const fextl::vector<fextl::string>& Args, bool ExecFDInterp, int ProgramFDFromEnv);
|
|
|
|
/**
|
|
* @brief Loads the FEX and application configurations for the application that is getting ready to run.
|
|
*
|
|
* @param ArgLoader Optional argument loader for argument based config options
|
|
* @param ProgramName Optional program name, if non-empty application specific configurations will be loaded
|
|
* @param envp Optional `envp` passed to main(...)
|
|
*/
|
|
void LoadConfig(fextl::unique_ptr<FEX::ArgLoader::ArgLoader> ArgLoader = {}, fextl::string ProgramName = {}, char** const envp = nullptr,
|
|
const PortableInformation& PortableInfo = {});
|
|
|
|
const char* GetHomeDirectory();
|
|
|
|
fextl::string GetDataDirectory(const PortableInformation& PortableInfo);
|
|
fextl::string GetConfigDirectory(bool Global, const PortableInformation& PortableInfo);
|
|
fextl::string GetConfigFileLocation(bool Global, const PortableInformation& PortableInfo);
|
|
|
|
void InitializeConfigs(const PortableInformation& PortableInfo);
|
|
|
|
/**
|
|
* @brief Loads the global FEX config
|
|
*
|
|
* @return unique_ptr for that layer
|
|
*/
|
|
fextl::unique_ptr<FEXCore::Config::Layer> CreateGlobalMainLayer();
|
|
|
|
/**
|
|
* @brief Loads the main application config
|
|
*
|
|
* @param File Optional override to load a specific config file in to the main layer
|
|
* Shouldn't be commonly used
|
|
*
|
|
* @return unique_ptr for that layer
|
|
*/
|
|
fextl::unique_ptr<FEXCore::Config::Layer> CreateMainLayer(const fextl::string* File = nullptr);
|
|
fextl::unique_ptr<FEXCore::Config::Layer> CreateUserOverrideLayer(const char* AppConfig);
|
|
|
|
/**
|
|
* @brief Create an application configuration loader
|
|
*
|
|
* @param Filename Application filename component
|
|
* @param Global Load the global configuration or user accessible file
|
|
*
|
|
* @return unique_ptr for that layer
|
|
*/
|
|
fextl::unique_ptr<FEXCore::Config::Layer> CreateAppLayer(const fextl::string& Filename, FEXCore::Config::LayerType Type);
|
|
|
|
/**
|
|
* @brief iCreate an environment configuration loader
|
|
*
|
|
* @param _envp[] The environment array from main
|
|
*
|
|
* @return unique_ptr for that layer
|
|
*/
|
|
fextl::unique_ptr<FEXCore::Config::Layer> CreateEnvironmentLayer(char* const _envp[]);
|
|
} // namespace FEX::Config
|