taihen-user.c

/* taihen-user.c -- user exports for taiHEN
 *
 * Copyright (C) 2016 Yifan Lu
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */
#include <psp2kern/types.h>
#include <psp2kern/sblacmgr.h>
#include <psp2kern/kernel/cpu.h>
#include <psp2kern/kernel/modulemgr.h>
#include <psp2kern/kernel/sysmem.h>
#include <psp2kern/kernel/threadmgr.h>
#include <psp2/kernel/error.h>
#include "error.h"
#include "hen.h"
#include "module.h"
#include "patches.h"
#include "taihen_internal.h"

#define MAX_NAME_LEN 256

#define MAX_ARGS_SIZE 256

SceUID taiHookFunctionExportForUser(tai_hook_ref_t *p_hook, tai_hook_args_t *args) {
  tai_hook_args_t kargs;
  uint32_t func_nid;
  const void *hook_func;
  uint32_t state;
  char k_module[MAX_NAME_LEN];
  int main_mod;
  tai_hook_ref_t k_ref;
  SceUID kid, ret;
  SceUID pid;

  ENTER_SYSCALL(state);
  kargs.size = 0;
  sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
  if (kargs.size == sizeof(kargs)) {
    pid = sceKernelGetProcessId();
    main_mod = (kargs.module == TAI_MAIN_MODULE);
    if (main_mod || sceKernelStrncpyUserToKernel(k_module, (uintptr_t)kargs.module, MAX_NAME_LEN) < MAX_NAME_LEN) {
      kid = taiHookFunctionExportForKernel(pid, &k_ref, main_mod ? kargs.module : k_module, kargs.library_nid, kargs.func_nid, kargs.hook_func);
      if (kid >= 0) {
        sceKernelMemcpyKernelToUser((uintptr_t)p_hook, &k_ref, sizeof(*p_hook));
        ret = sceKernelCreateUserUid(pid, kid);
        LOG("kernel uid: %x, user uid: %x", kid, ret);
      } else {
        ret = kid;
      }
    } else {
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    LOG("invalid args size: %x", kargs.size);
    ret = TAI_ERROR_USER_MEMORY;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiHookFunctionImportForUser(tai_hook_ref_t *p_hook, tai_hook_args_t *args) {
  tai_hook_args_t kargs;
  uint32_t state;
  char k_module[MAX_NAME_LEN];
  int main_mod;
  tai_hook_ref_t k_ref;
  SceUID kid, ret;
  SceUID pid;

  ENTER_SYSCALL(state);
  sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
  if (kargs.size == sizeof(kargs)) {
    pid = sceKernelGetProcessId();
    main_mod = (kargs.module == TAI_MAIN_MODULE);
    if (main_mod || sceKernelStrncpyUserToKernel(k_module, (uintptr_t)kargs.module, MAX_NAME_LEN) < MAX_NAME_LEN) {
      kid = taiHookFunctionImportForKernel(pid, &k_ref, main_mod ? kargs.module : k_module, kargs.library_nid, kargs.func_nid, kargs.hook_func);
      if (kid >= 0) {
        sceKernelMemcpyKernelToUser((uintptr_t)p_hook, &k_ref, sizeof(*p_hook));
        ret = sceKernelCreateUserUid(pid, kid);
        LOG("kernel uid: %x, user uid: %x", kid, ret);
      } else {
        ret = kid;
      }
    } else {
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    LOG("invalid args size: %x", kargs.size);
    ret = TAI_ERROR_USER_MEMORY;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiHookFunctionOffsetForUser(tai_hook_ref_t *p_hook, tai_offset_args_t *args) {
  tai_offset_args_t kargs;
  uint32_t state;
  tai_hook_ref_t k_ref;
  SceUID ret;
  SceUID pid;
  SceUID kid;

  ENTER_SYSCALL(state);
  kargs.size = 0;
  sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
  if (kargs.size == sizeof(kargs)) {
    pid = sceKernelGetProcessId();
    kid = sceKernelKernelUidForUserUid(pid, kargs.modid);
    if (kid >= 0) {
      ret = taiHookFunctionOffsetForKernel(pid, &k_ref, kid, kargs.segidx, kargs.offset, kargs.thumb, kargs.source);
      if (ret >= 0) {
        sceKernelMemcpyKernelToUser((uintptr_t)p_hook, &k_ref, sizeof(*p_hook));
        ret = sceKernelCreateUserUid(pid, ret);
        LOG("user uid: %x", ret);
      }
    } else {
      LOG("Error getting kernel uid for %x: %x", kargs.modid, kid);
      ret = kid;
    }
  } else {
    LOG("invalid args size: %x", kargs.size);
    ret = TAI_ERROR_USER_MEMORY;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiGetModuleInfo(const char *module, tai_module_info_t *info) {
  int main_mod;
  char k_module[MAX_NAME_LEN];
  uint32_t state;
  SceUID pid;
  tai_module_info_t k_info;
  int ret;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  main_mod = (module == TAI_MAIN_MODULE);
  if (main_mod || sceKernelStrncpyUserToKernel(k_module, (uintptr_t)module, MAX_NAME_LEN) < MAX_NAME_LEN) {
    sceKernelMemcpyUserToKernel(&k_info, (uintptr_t)info, sizeof(size_t));
    if (k_info.size == sizeof(k_info)) {
      ret = taiGetModuleInfoForKernel(pid, main_mod ? module : k_module, &k_info);
      sceKernelMemcpyKernelToUser((uintptr_t)info, &k_info, k_info.size);
    } else {
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_USER_MEMORY;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiHookRelease(SceUID tai_uid, tai_hook_ref_t hook) {
  uint32_t state;
  SceUID pid, kid;
  int ret;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  kid = sceKernelKernelUidForUserUid(pid, tai_uid);
  if (kid >= 0) {
    ret = taiHookReleaseForKernel(kid, hook);
    sceKernelDeleteUserUid(pid, tai_uid);
  } else {
    ret = kid;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiInjectAbs(void *dest, const void *src, size_t size) {
  uint32_t state;
  tai_hook_ref_t k_ref;
  SceUID ret;
  SceUID pid;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  ret = taiInjectAbsForKernel(pid, dest, src, size);
  if (ret >= 0) {
    ret = sceKernelCreateUserUid(pid, ret);
    LOG("user uid: %x", ret);
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiInjectDataForUser(tai_offset_args_t *args) {
  tai_offset_args_t kargs;
  uint32_t state;
  tai_hook_ref_t k_ref;
  SceUID ret;
  SceUID pid;

  ENTER_SYSCALL(state);
  kargs.size = 0;
  sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
  if (kargs.size == sizeof(kargs)) {
    pid = sceKernelGetProcessId();
    ret = sceKernelKernelUidForUserUid(pid, kargs.modid);
    if (ret >= 0) {
      kargs.modid = ret;
      ret = taiInjectDataForKernel(pid, kargs.modid, kargs.segidx, kargs.offset, kargs.source, kargs.source_size);
      if (ret >= 0) {
        ret = sceKernelCreateUserUid(pid, ret);
        LOG("user uid: %x", ret);
      }
    } else {
      LOG("Error getting kernel uid for %x: %x", kargs.modid, ret);
    }
  } else {
    LOG("invalid args size: %x", kargs.size);
    ret = TAI_ERROR_USER_MEMORY;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiInjectRelease(SceUID tai_uid) {
  uint32_t state;
  SceUID pid, kid;
  int ret;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  kid = sceKernelKernelUidForUserUid(pid, tai_uid);
  if (kid >= 0) {
    ret = taiInjectReleaseForKernel(kid);
    sceKernelDeleteUserUid(pid, tai_uid);
  } else {
    ret = kid;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiLoadKernelModule(const char *path, int flags, void *opt) {
  uint32_t state;
  char k_path[MAX_NAME_LEN];
  SceUID pid;
  int ret;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    if (opt == NULL) {
      if (sceKernelStrncpyUserToKernel(k_path, (uintptr_t)path, MAX_NAME_LEN) < MAX_NAME_LEN) {
        ret = sceKernelLoadModuleForDriver(k_path, flags, NULL);
        LOG("loaded %s: %x", k_path, ret);
        if (ret >= 0) {
          ret = sceKernelCreateUserUid(pid, ret);
          LOG("user uid: %x", ret);
        }
      } else {
        ret = TAI_ERROR_USER_MEMORY;
      }
    } else {
      ret = TAI_ERROR_INVALID_ARGS;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiStartKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  uint32_t state;
  int ret;
  int k_res;
  SceUID pid;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE && opt == NULL) {
        ret = sceKernelKernelUidForUserUid(pid, modid);
        if (ret >= 0) {
          modid = ret;
          ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
          if (ret >= 0) {
            k_res = 0;
            ret = sceKernelStartModuleForDriver(modid, kargs.args, buf, kargs.flags, NULL, &k_res);
            if (res) {
              sceKernelMemcpyKernelToUser((uintptr_t)res, &k_res, sizeof(*res));
            }
          }
        } else {
          LOG("Error getting kernel uid for %x: %x", modid, ret);
        }
      } else {
        LOG("invalid args size: %x", kargs.size);
        ret = TAI_ERROR_USER_MEMORY;
      }
    } else {
      ret = TAI_ERROR_INVALID_ARGS;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiLoadStartKernelModuleForUser(const char *path, tai_module_args_t *args) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  char k_path[MAX_NAME_LEN];
  uint32_t state;
  SceUID modid;
  int ret;
  SceUID pid;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE) {
        ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
        if (ret >= 0) {
          if (sceKernelStrncpyUserToKernel(k_path, (uintptr_t)path, MAX_NAME_LEN) < MAX_NAME_LEN) {
            ret = sceKernelLoadStartModuleForDriver(k_path, kargs.args, buf, kargs.flags, NULL, NULL);
            LOG("loaded %s: %x", k_path, ret);
            if (ret >= 0) {
              ret = sceKernelCreateUserUid(pid, ret);
              LOG("user uid: %x", ret);
            }
          } else {
            ret = TAI_ERROR_USER_MEMORY;
          }
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

SceUID taiLoadStartModuleForPidForUser(const char *path, tai_module_args_t *args) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  char k_path[MAX_NAME_LEN];
  uint32_t state;
  SceUID modid;
  int ret;


  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE) {
        ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
        if (ret >= 0) {
          if (sceKernelStrncpyUserToKernel(k_path, (uintptr_t)path, MAX_NAME_LEN) < MAX_NAME_LEN) {
            ret = sceKernelLoadStartModuleForPid(kargs.pid, k_path, kargs.args, buf, kargs.flags, NULL, NULL);
            LOG("loaded %s: %x", k_path, ret);
            if (ret >= 0) {
              ret = sceKernelCreateUserUid(kargs.pid, ret);
              LOG("user uid: %x", ret);
            }
          } else {
            ret = TAI_ERROR_USER_MEMORY;
          }
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiStopKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  uint32_t state;
  int ret;
  int k_res;
  SceUID pid;
  SceUID kid;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE && opt == NULL) {
        kid = sceKernelKernelUidForUserUid(pid, modid);
        if (kid >= 0) {
          ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
          if (ret >= 0) {
            k_res = 0;
            ret = sceKernelStopModuleForDriver(kid, kargs.args, buf, kargs.flags, NULL, &k_res);
            if (res) {
              sceKernelMemcpyKernelToUser((uintptr_t)res, &k_res, sizeof(*res));
            }
            if (ret >= 0) {
              sceKernelDeleteUserUid(pid, modid);
            }
          }
        } else {
          LOG("Error getting kernel uid for %x: %x", modid, kid);
          ret = kid;
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiUnloadKernelModule(SceUID modid, int flags, void *opt) {
  uint32_t state;
  SceUID pid;
  SceUID kid;
  int ret;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    if (opt == NULL) {
      kid = sceKernelKernelUidForUserUid(pid, modid);
      if (kid >= 0) {
        ret = sceKernelUnloadModuleForDriver(kid, flags, NULL);
        if (ret >= 0) {
          sceKernelDeleteUserUid(pid, modid);
        }
      } else {
        LOG("Error getting kernel uid for %x: %x", modid, kid);
        ret = kid;
      }
    } else {
      ret = TAI_ERROR_INVALID_ARGS;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiStopUnloadKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  uint32_t state;
  int ret;
  int k_res;
  SceUID pid;
  SceUID kid;

  ENTER_SYSCALL(state);
  pid = sceKernelGetProcessId();
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE && opt == NULL) {
        kid = sceKernelKernelUidForUserUid(pid, modid);
        if (kid >= 0) {
          ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
          if (ret >= 0) {
            k_res = 0;
            ret = sceKernelStopUnloadModuleForDriver(kid, kargs.args, buf, kargs.flags, NULL, &k_res);
            if (res) {
              sceKernelMemcpyKernelToUser((uintptr_t)res, &k_res, sizeof(*res));
            }
            if (ret >= 0) {
              sceKernelDeleteUserUid(pid, modid);
            }
          }
        } else {
          LOG("Error getting kernel uid for %x: %x", modid, kid);
          ret = kid;
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiStopModuleForPidForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  uint32_t state;
  int ret;
  int k_res;
  SceUID kid;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE && opt == NULL) {
        kid = sceKernelKernelUidForUserUid(kargs.pid, modid);
        if (kid >= 0) {
          ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
          if (ret >= 0) {
            k_res = 0;
            ret = sceKernelStopModuleForPid(kargs.pid, kid, kargs.args, buf, kargs.flags, NULL, &k_res);
            if (res) {
              sceKernelMemcpyKernelToUser((uintptr_t)res, &k_res, sizeof(*res));
            }
            if (ret >= 0) {
              sceKernelDeleteUserUid(kargs.pid, modid);
            }
          }
        } else {
          LOG("Error getting kernel uid for %x: %x", modid, kid);
          ret = kid;
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiUnloadModuleForPid(SceUID pid, SceUID modid, int flags, void *opt) {
  uint32_t state;
  SceUID kid;
  int ret;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    if (opt == NULL) {
      kid = sceKernelKernelUidForUserUid(pid, modid);
      if (kid >= 0) {
        ret = sceKernelUnloadModuleForPid(pid, kid, flags, NULL);
        if (ret >= 0) {
          sceKernelDeleteUserUid(pid, modid);
        }
      } else {
        LOG("Error getting kernel uid for %x: %x", modid, kid);
        ret = kid;
      }
    } else {
      ret = TAI_ERROR_INVALID_ARGS;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiStopUnloadModuleForPidForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res) {
  tai_module_args_t kargs;
  char buf[MAX_ARGS_SIZE];
  uint32_t state;
  int ret;
  int k_res;
  SceUID kid;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    kargs.size = 0;
    sceKernelMemcpyUserToKernel(&kargs, (uintptr_t)args, sizeof(kargs));
    if (kargs.size == sizeof(kargs)) {
      if (kargs.args <= MAX_ARGS_SIZE && opt == NULL) {
        kid = sceKernelKernelUidForUserUid(kargs.pid, modid);
        if (kid >= 0) {
          ret = sceKernelMemcpyUserToKernel(buf, (uintptr_t)kargs.argp, kargs.args);
          if (ret >= 0) {
            k_res = 0;
            ret = sceKernelStopUnloadModuleForPid(kargs.pid, kid, kargs.args, buf, kargs.flags, NULL, &k_res);
            if (res) {
              sceKernelMemcpyKernelToUser((uintptr_t)res, &k_res, sizeof(*res));
            }
            if (ret >= 0) {
              sceKernelDeleteUserUid(kargs.pid, modid);
            }
          }
        } else {
          LOG("Error getting kernel uid for %x: %x", modid, kid);
          ret = kid;
        }
      } else {
        ret = TAI_ERROR_INVALID_ARGS;
      }
    } else {
      LOG("invalid args size: %x", kargs.size);
      ret = TAI_ERROR_USER_MEMORY;
    }
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}

int taiMemcpyUserToKernel(void *kernel_dst, const void *user_src, size_t len) {
  uint32_t state;
  int ret;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    ret = 0;
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  if (ret == 0) {
    return sceKernelMemcpyUserToKernel(kernel_dst, (uintptr_t)user_src, len);
  } else {
    return ret;
  }
}

int taiMemcpyKernelToUser(void *user_dst, const void *kernel_src, size_t len) {
  uint32_t state;
  int ret;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    ret = 0;
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  if (ret == 0) {
    return sceKernelMemcpyKernelToUser((uintptr_t)user_dst, kernel_src, len);
  } else {
    return ret;
  }
}

int taiReloadConfig(void) {
  uint32_t state;
  int ret;

  ENTER_SYSCALL(state);
  if (sceSblACMgrIsShell(0)) {
    ret = hen_load_config();
  } else {
    ret = TAI_ERROR_NOT_ALLOWED;
  }
  EXIT_SYSCALL(state);
  return ret;
}