#include <tamtypes.h>
#include <kernel.h>
#include <string.h>
#include <sifrpc.h>
#include "slib.h"
#include "smod.h"
#include "common.h"

Include dependency graph for slib.c:

Macros
#define	EXP_LIB_MAX SMEM_BUF_SIZE /* We can even handle CDVDMAN's bloat! */

Functions
slib_exp_lib_list_t *	slib_exp_lib_list (void)

int	slib_get_exp_lib (const char name, slib_exp_lib_t library)

Variables
slib_exp_lib_list_t	_slib_cur_exp_lib_list = {NULL, NULL}

struct smem_buf	smem_buf

Detailed Description

Sub CPU library interface.

Definition in file slib.c.

Macro Definition Documentation

◆ EXP_LIB_MAX

#define EXP_LIB_MAX SMEM_BUF_SIZE /* We can even handle CDVDMAN's bloat! */

Definition at line 99 of file slib.c.

Function Documentation

◆ slib_exp_lib_list()

slib_exp_lib_list_t* slib_exp_lib_list ( )

Find the head and tail of the export library list.

Returns: NULL if the list couldn't be found, and the address of the head and tail pointers if it was located.

This routine will need to be called everytime the IOP is reset.

Definition at line 31 of file slib.c.

 {
         SifRpcReceiveData_t RData;
         slib_exp_lib_t *core_exps;
         slib_exp_lib_list_t *exp_lib_list = NULL;
         u32 i, addr, core_end, NextMod, *exp_func;
         void *pGetLoadcoreInternalData;
         smod_mod_info_t *ModInfo;
  
         /* Read the start of the global module table - this is where we will search.  */
         SyncDCache(&smem_buf, smem_buf.bytes+sizeof(smod_mod_info_t));
         if(SifRpcGetOtherData(&RData, (void*)0x800, &smem_buf, sizeof(smod_mod_info_t), 0)>=0){
                 /* The first entry points to LOADCORE's module info.  We then use the
                    module info to determine the end of LOADCORE's .text segment (just
                    past the export library we're trying to find.  */
                 NextMod = *smem_buf.words;
                 SyncDCache(&smem_buf, smem_buf.bytes+sizeof(smod_mod_info_t));
                 if(SifRpcGetOtherData(&RData, (void*)NextMod, &smem_buf, sizeof(smod_mod_info_t), 0)>=0){
                         ModInfo = &smem_buf.mod_info;
                         core_end = ModInfo->text_start+ModInfo->text_size;
  
                         /* Back up so we position ourselves infront of where the export
                            library will be.  */
                         SyncDCache(&smem_buf, smem_buf.bytes+512);
                         if(SifRpcGetOtherData(&RData, (void*)(core_end - 512), &smem_buf, 512, 0)>=0){
                                 /* Search for LOADCORE's export library.  */
                                 for (i = 0; i < 512; i += 4) {
                                         /* SYSMEM's export library sits at 0x830, so it should appear in
                                            LOADCORE's prev pointer.  */
                                         if (smem_buf.words[i / sizeof(u32)] == 0x830) {
                                                 if (!__memcmp(smem_buf.bytes + i + 12, "loadcore", 8))
                                                         break;
                                         }
                                 }
                                 if (i >= 512)
                                         return NULL;
  
                                 /* Get to the start of the export table, and find the address of the
                                    routine that will get us the export library list info.  */
                                 core_exps = (slib_exp_lib_t *)(smem_buf.bytes + i);
                                 pGetLoadcoreInternalData = core_exps->exports[3];
  
                                 SyncDCache(&smem_buf, smem_buf.bytes+8);
                                 if(SifRpcGetOtherData(&RData, pGetLoadcoreInternalData, &smem_buf, 8, 0)>=0){
                                         exp_func = smem_buf.words;
  
                                         /* Parse the two instructions that hold the address of the table.  */
                                         if ((exp_func[0] & 0xffff0000) != 0x3c020000)   /* lui v0, XXXX */
                                                 return NULL;
                                         if ((exp_func[1] & 0xffff0000) != 0x24420000)   /* addiu v0, v0, XXXX */
                                                 return NULL;
  
                                         addr = ((exp_func[0] & 0xffff) << 16) | (exp_func[1] & 0xffff);
  
                                         SyncDCache(&smem_buf, smem_buf.bytes+8);
                                         if(SifRpcGetOtherData(&RData, (void*)addr, &smem_buf, 8, 0)>=0){
                                                 _slib_cur_exp_lib_list.tail = (slib_exp_lib_t *)(smem_buf.words[0]);
                                                 _slib_cur_exp_lib_list.head = (slib_exp_lib_t *)(smem_buf.words[1]);
                                                 exp_lib_list = &_slib_cur_exp_lib_list;
                                         }
                                 }
                         }
                 }
         }
  
         return exp_lib_list;
 }

References __memcmp(), _slib_cur_exp_lib_list, smem_buf::bytes, slib_exp_lib_t::exports, slib_exp_lib_list_t::head, smem_buf::mod_info, NULL, SifRpcGetOtherData(), SyncDCache(), slib_exp_lib_list_t::tail, smod_mod_info_t::text_size, smod_mod_info_t::text_start, and smem_buf::words.

Referenced by slib_get_exp_lib().

◆ slib_get_exp_lib()

int slib_get_exp_lib	(	const char *	name,
		slib_exp_lib_t *	library
	)

Retrieve an export library by name.

Definition at line 101 of file slib.c.

 {
         SifRpcReceiveData_t RData;
         slib_exp_lib_list_t *exp_lib_list = &_slib_cur_exp_lib_list;
         slib_exp_lib_t *exp_lib = &smem_buf.exp_lib;
         void *cur_lib;
         int len = strlen(name), count = 0;
  
         if (!exp_lib_list->head && !(exp_lib_list = slib_exp_lib_list()))
                 return 0;
  
         /* Read the tail export library to initiate the search.  */
         cur_lib = exp_lib_list->tail;
  
         while (cur_lib) {
                 SyncDCache(&smem_buf, smem_buf.bytes+EXP_LIB_MAX);
                 if(SifRpcGetOtherData(&RData, cur_lib, exp_lib, EXP_LIB_MAX, 0)>=0){
                         if (!__memcmp(exp_lib->name, name, len)) {
                                 while (exp_lib->exports[count] != 0)
                                         count++;
  
                                 if (library)
                                         memcpy(library, exp_lib, sizeof(slib_exp_lib_t) + count * 4);
  
                                 return count;
                         }
  
                         cur_lib = exp_lib->prev;
                 }
         }
  
         return 0;
 }