Ejemplo n.º 1
0
 /// <summary>
 /// Initializes a new <see cref="BiosFunction"/> instance in the case of a missing function.
 /// </summary>
 /// <param name="module">Module containing the function.</param>
 /// <param name="nid">Unique ID of the function.</param>
 public BiosFunction(BiosModule module, uint nid)
 {
     this.Module      = module;
     this.NID         = nid;
     this.IsMissing   = true;
     this.IsStateless = true;
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Initializes a new <see cref="BiosFunction"/> instance with the given parameters.
        /// </summary>
        /// <param name="module">Module containing the function.</param>
        /// <param name="moduleInstance">Current instance of the module containing the function.</param>
        /// <param name="nid">Unique ID of the function.</param>
        /// <param name="name">Human-friendly name of the function.</param>
        /// <param name="isImplemented"><c>true</c> if the function is implemented.</param>
        /// <param name="isStateless"><c>true</c> if the function does not change the BIOS state.</param>
        /// <param name="nativeImplementationSuggested"><c>true</c> if a native implementation is suggested.</param>
        /// <param name="dontTrace"><c>true</c> to not write this function to the trace.</param>
        /// <param name="methodInfo"><see cref="MethodInfo"/> of the managed implementation of the function.</param>
        /// <param name="nativePointer">Pointer to the native implementation of the function.</param>
        public BiosFunction(BiosModule module, IModule moduleInstance, uint nid, string name, bool isImplemented, bool isStateless, bool nativeImplementationSuggested, bool dontTrace, MethodInfo methodInfo, IntPtr nativePointer)
        {
            this.Module         = module;
            this.ModuleInstance = moduleInstance;
            this.NID            = nid;
            this.Name           = name;
            this.IsImplemented  = isImplemented;
            this.IsStateless    = isStateless;
            this.NativeImplementationSuggested = nativeImplementationSuggested;
            this.DontTrace = dontTrace;

            this.MethodInfo   = methodInfo;
            this.NativeMethod = nativePointer;

            ParameterInfo[] ps = methodInfo.GetParameters();
            if (ps.Length > 0)
            {
                this.ParameterCount = ps.Length;
                if (ps[0].ParameterType == typeof(IMemory))
                {
                    this.ParameterCount--;
                    this.UsesMemorySystem = true;
                }

                this.ParameterWidths = new BitArray(this.ParameterCount);
                int offset = (this.UsesMemorySystem == true) ? 1 : 0;
                for (int n = 0; n < (ps.Length - offset); n++)
                {
                    ParameterWidths[n] = (ps[n + offset].ParameterType == typeof(long));
                }
#if DEBUG
                // Sanity check to make sure IMemory is always the first argument
                if (this.UsesMemorySystem == false)
                {
                    for (int n = 0; n < ps.Length; n++)
                    {
                        Debug.Assert(ps[n].ParameterType != typeof(IMemory));
                    }
                }
#endif
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Initializes a new <see cref="BiosFunction"/> instance with the given parameters.
        /// </summary>
        /// <param name="module">Module containing the function.</param>
        /// <param name="moduleInstance">Current instance of the module containing the function.</param>
        /// <param name="nid">Unique ID of the function.</param>
        /// <param name="name">Human-friendly name of the function.</param>
        /// <param name="isImplemented"><c>true</c> if the function is implemented.</param>
        /// <param name="isStateless"><c>true</c> if the function does not change the BIOS state.</param>
        /// <param name="nativeImplementationSuggested"><c>true</c> if a native implementation is suggested.</param>
        /// <param name="dontTrace"><c>true</c> to not write this function to the trace.</param>
        /// <param name="methodInfo"><see cref="MethodInfo"/> of the managed implementation of the function.</param>
        /// <param name="nativePointer">Pointer to the native implementation of the function.</param>
        public BiosFunction( BiosModule module, IModule moduleInstance, uint nid, string name, bool isImplemented, bool isStateless, bool nativeImplementationSuggested, bool dontTrace, MethodInfo methodInfo, IntPtr nativePointer )
        {
            this.Module = module;
            this.ModuleInstance = moduleInstance;
            this.NID = nid;
            this.Name = name;
            this.IsImplemented = isImplemented;
            this.IsStateless = isStateless;
            this.NativeImplementationSuggested = nativeImplementationSuggested;
            this.DontTrace = dontTrace;

            this.MethodInfo = methodInfo;
            this.NativeMethod = nativePointer;

            ParameterInfo[] ps = methodInfo.GetParameters();
            if( ps.Length > 0 )
            {
                this.ParameterCount = ps.Length;
                if( ps[ 0 ].ParameterType == typeof( IMemory ) )
                {
                    this.ParameterCount--;
                    this.UsesMemorySystem = true;
                }

                this.ParameterWidths = new BitArray( this.ParameterCount );
                int offset = ( this.UsesMemorySystem == true ) ? 1 : 0;
                for( int n = 0; n < ( ps.Length - offset ); n++ )
                    ParameterWidths[ n ] = ( ps[ n + offset ].ParameterType == typeof( long ) );
            #if DEBUG
                // Sanity check to make sure IMemory is always the first argument
                if( this.UsesMemorySystem == false )
                {
                    for( int n = 0; n < ps.Length; n++ )
                        Debug.Assert( ps[ n ].ParameterType != typeof( IMemory ) );
                }
            #endif
            }
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Initializes a new <see cref="BiosFunction"/> instance in the case of a missing function.
 /// </summary>
 /// <param name="module">Module containing the function.</param>
 /// <param name="nid">Unique ID of the function.</param>
 public BiosFunction( BiosModule module, uint nid )
 {
     this.Module = module;
     this.NID = nid;
     this.IsMissing = true;
     this.IsStateless = true;
 }
Ejemplo n.º 5
0
        private int LoadModule( IMediaFile file, Stream stream, int flags, int option )
        {
            // Load!
            LoadParameters loadParams = new LoadParameters();
            if( file != null )
            {
                loadParams.Path = file.Parent;
                loadParams.FilePath = file.AbsolutePath;
                string fileName = file.Name.ToLowerInvariant();
                foreach( string blacklisted in _moduleBlacklist )
                {
                    if( fileName == blacklisted )
                    {
                        // Module is blacklisted - ignore
                        Log.WriteLine( Verbosity.Normal, Feature.Bios, "LoadModule: module is blacklisted, ignoring" );
                        return FakeModuleUID;
                    }
                }
            }
            #if DEBUG
            loadParams.AppendDatabase = true;
            #endif

            // Check to see if it's one we have a decoded version of
            string kernelLocation = Path.GetDirectoryName( Assembly.GetExecutingAssembly().Location );
            string prxLocation = Path.Combine( kernelLocation, "PRX" );
            string lookasidePrx = Path.Combine( prxLocation, file.Name );
            if( File.Exists( lookasidePrx ) == true )
            {
                // Load ours instead
                Log.WriteLine( Verbosity.Normal, Feature.Bios, "LoadModule: lookaside prx found at {0}", lookasidePrx );
                stream = File.OpenRead( lookasidePrx );
            }

            Debug.Assert( stream != null );
            if( stream == null )
            {
                Log.WriteLine( Verbosity.Critical, Feature.Bios, "LoadModule: unable to load module {0}", file.Name );
                return -1;
            }

            // Quick check to make sure it isn't encrypted before sending off to loader
            byte[] magicBytes = new byte[ 4 ];
            stream.Read( magicBytes, 0, 4 );
            stream.Seek( -4, SeekOrigin.Current );
            // 0x7E, 0x50, 0x53, 0x50 = ~PSP
            bool encrypted = (
                ( magicBytes[ 0 ] == 0x7E ) &&
                ( magicBytes[ 1 ] == 0x50 ) &&
                ( magicBytes[ 2 ] == 0x53 ) &&
                ( magicBytes[ 3 ] == 0x50 ) );
            //Debug::Assert( encrypted == false );
            if( encrypted == true )
            {
                Log.WriteLine( Verbosity.Critical, Feature.Bios, "LoadModule: module {0} is encrypted - unable to load", file.Name );

                // We spoof the caller in to thinking we worked right... by just returning 0 ^_^
                KModule fakemod = new KModule( _kernel, null );
                fakemod.LoadParameters = loadParams;
                _kernel.AddHandle( fakemod );

                if( Diag.IsAttached == true )
                    Diag.Instance.Client.OnModuleLoaded();

                return ( int )fakemod.UID;
            }

            LoadResults results = _kernel.Bios._loader.LoadModule( ModuleType.Prx, stream, loadParams );
            //Debug.Assert( results.Successful == true );
            if( results.Successful == false )
            {
                Log.WriteLine( Verbosity.Critical, Feature.Bios, "LoadModule: loader failed" );
                return FakeModuleUID;
            }
            if( results.Ignored == true )
            {
                // Faked
                Log.WriteLine( Verbosity.Normal, Feature.Bios, "LoadModule: ignoring module" );
                return FakeModuleUID;
            }

            // Create a local representation of the module
            BiosModule module = new BiosModule( results.Name, results.Exports.ToArray() );
            _kernel.Bios._metaModules.Add( module );
            _kernel.Bios._metaModuleLookup.Add( module.Name, module );

            KModule kmod = new KModule( _kernel, module );
            kmod.UID = results.ModuleID;
            kmod.LoadParameters = loadParams;
            kmod.LoadResults = results;
            _kernel.UserModules.Add( kmod );
            _kernel.AddHandle( kmod );

            if( Diag.IsAttached == true )
                Diag.Instance.Client.OnModuleLoaded();

            return ( int )kmod.UID;
        }