proc_map.c

/* proc_map.c -- map structure for organizing patches
 *
 * 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/kernel/sysmem.h>
#include <psp2kern/kernel/threadmgr.h>
#include <string.h>
#include "taihen_internal.h"
#include "proc_map.h"
#include "slab.h"

#define MAP_POOL_SIZE 1024

extern const size_t g_exe_slab_item_size;

static SceUID g_map_pool;

int proc_map_init(void) {
  SceKernelMemPoolCreateOpt opt;
  memset(&opt, 0, sizeof(opt));
  opt.size = sizeof(opt);
  opt.uselock = 1;
  g_map_pool = sceKernelMemPoolCreate("tai_maps", MAP_POOL_SIZE, &opt);
  if (g_map_pool < 0) {
    return g_map_pool;
  } else {
    return 0;
  }
}

void proc_map_deinit(void) {
  sceKernelMemPoolDestroy(g_map_pool);
  g_map_pool = 0;
}

tai_proc_map_t *proc_map_alloc(int nbuckets) {
  tai_proc_map_t *map;

  map = sceKernelMemPoolAlloc(g_map_pool, sizeof(tai_proc_map_t) + sizeof(tai_proc_t *) * nbuckets);
  if (map == NULL) {
    return NULL;
  }
  map->nbuckets = nbuckets;
  map->lock = sceKernelCreateMutexForKernel("tai_map", SCE_KERNEL_MUTEX_ATTR_RECURSIVE, 0, NULL);
  for (int i = 0; i < nbuckets; i++) {
    map->buckets[i] = NULL;
  }
  return map;
}

void proc_map_free(tai_proc_map_t *map) {
  sceKernelDeleteMutexForKernel(map->lock);
  sceKernelMemPoolFree(g_map_pool, map);
}

int proc_map_try_insert(tai_proc_map_t *map, tai_patch_t *patch, tai_patch_t **existing) {
  int idx;
  int overlap;
  tai_proc_t **item, *proc;
  tai_patch_t **cur, *tmp;

  idx = patch->pid % map->nbuckets;
  *existing = NULL;

  // get proc structure if found
  sceKernelLockMutexForKernel(map->lock, 1, NULL);
  item = &map->buckets[idx];
  while (*item != NULL && (*item)->pid < patch->pid) {
    item = &(*item)->next;
  }
  if (*item != NULL && (*item)->pid == patch->pid) {
    // existing block
    proc = *item;
  } else {
    // new block
    proc = sceKernelMemPoolAlloc(g_map_pool, sizeof(tai_proc_t));
    proc->pid = patch->pid;
    proc->head = NULL;
    proc->next = *item;
    slab_init(&proc->slab, g_exe_slab_item_size, patch->pid);
    *item = proc;
  }

  // now insert into range if needed
  cur = &proc->head;
  overlap = 0;
  while (*cur != NULL) {
    tmp = *cur;
    if (tmp->addr < patch->addr) {
      if (tmp->addr + tmp->size <= patch->addr) {
        // cur block is completely before our block
        cur = &(*cur)->next;
        continue;
      } else {
        // cur block's end overlaps with our block's start
        overlap = 1;
      }
    } else if (patch->addr < tmp->addr) {
      if (patch->addr + patch->size > tmp->addr) {
        // cur block's start over overlaps with our block's end
        overlap = 1;
      } else {
        // cur block is completely after our block, this is where we insert
      }
    } else { // tmp->addr == patch->addr
      if (patch->size == tmp->size) {
        // completely overlap
        overlap = 1;
        *existing = tmp;
      }
    }
    break;
  }
  if (!overlap) {
    patch->next = *cur;
    patch->slab = &proc->slab;
    *cur = patch;
  }
  sceKernelUnlockMutexForKernel(map->lock, 1);
  return !overlap;
}

int proc_map_remove_all_pid(tai_proc_map_t *map, SceUID pid, tai_patch_t **head) {
  int idx;
  tai_proc_t **cur, *tmp;

  idx = pid % map->nbuckets;
  *head = NULL;
  sceKernelLockMutexForKernel(map->lock, 1, NULL);
  cur = &map->buckets[idx];
  while (*cur != NULL && (*cur)->pid < pid) {
    cur = &(*cur)->next;
  }
  if (*cur != NULL && (*cur)->pid == pid) {
    tmp = *cur;
    *cur = tmp->next;
    *head = tmp->head;
    slab_destroy(&tmp->slab);
    sceKernelMemPoolFree(g_map_pool, tmp);
  }
  sceKernelUnlockMutexForKernel(map->lock, 1);
  return *head != NULL;
}

int proc_map_remove(tai_proc_map_t *map, tai_patch_t *patch) {
  int idx;
  int found;
  tai_proc_t **proc, *next;
  tai_patch_t **cur;

  idx = patch->pid % map->nbuckets;
  found = 0;
  sceKernelLockMutexForKernel(map->lock, 1, NULL);
  proc = &map->buckets[idx];
  while (*proc != NULL && (*proc)->pid < patch->pid) {
    proc = &(*proc)->next;
  }
  if (*proc != NULL && (*proc)->pid == patch->pid) {
    cur = &(*proc)->head;
    while (*cur != NULL && *cur != patch) {
      cur = &(*cur)->next;
    }
    if (*cur != NULL) {
      *cur = patch->next;
      found = 1;
    }
  }
  if (*proc != NULL && (*proc)->head == NULL) { // it's now empty
    patch->slab = NULL; // remove reference
    next = (*proc)->next;
    slab_destroy(&(*proc)->slab);
    sceKernelMemPoolFree(g_map_pool, *proc);
    *proc = next;
  }
  sceKernelUnlockMutexForKernel(map->lock, 1);
  return found;
}