resource_limit.cpp 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
  1. // Copyright 2015 Citra Emulator Project
  2. // Licensed under GPLv2 or any later version
  3. // Refer to the license.txt file included.
  4. #include <cstring>
  5. #include "common/logging/log.h"
  6. #include "core/hle/kernel/resource_limit.h"
  7. namespace Kernel {
  8. static SharedPtr<ResourceLimit> resource_limits[4];
  9. ResourceLimit::ResourceLimit() {}
  10. ResourceLimit::~ResourceLimit() {}
  11. SharedPtr<ResourceLimit> ResourceLimit::Create(std::string name) {
  12. SharedPtr<ResourceLimit> resource_limit(new ResourceLimit);
  13. resource_limit->name = std::move(name);
  14. return resource_limit;
  15. }
  16. SharedPtr<ResourceLimit> ResourceLimit::GetForCategory(ResourceLimitCategory category) {
  17. switch (category) {
  18. case ResourceLimitCategory::APPLICATION:
  19. case ResourceLimitCategory::SYS_APPLET:
  20. case ResourceLimitCategory::LIB_APPLET:
  21. case ResourceLimitCategory::OTHER:
  22. return resource_limits[static_cast<u8>(category)];
  23. default:
  24. LOG_CRITICAL(Kernel, "Unknown resource limit category");
  25. UNREACHABLE();
  26. }
  27. }
  28. s32 ResourceLimit::GetCurrentResourceValue(u32 resource) const {
  29. switch (resource) {
  30. case COMMIT:
  31. return current_commit;
  32. case THREAD:
  33. return current_threads;
  34. case EVENT:
  35. return current_events;
  36. case MUTEX:
  37. return current_mutexes;
  38. case SEMAPHORE:
  39. return current_semaphores;
  40. case TIMER:
  41. return current_timers;
  42. case SHARED_MEMORY:
  43. return current_shared_mems;
  44. case ADDRESS_ARBITER:
  45. return current_address_arbiters;
  46. case CPU_TIME:
  47. return current_cpu_time;
  48. default:
  49. LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
  50. UNIMPLEMENTED();
  51. return 0;
  52. }
  53. }
  54. s32 ResourceLimit::GetMaxResourceValue(u32 resource) const {
  55. switch (resource) {
  56. case COMMIT:
  57. return max_commit;
  58. case THREAD:
  59. return max_threads;
  60. case EVENT:
  61. return max_events;
  62. case MUTEX:
  63. return max_mutexes;
  64. case SEMAPHORE:
  65. return max_semaphores;
  66. case TIMER:
  67. return max_timers;
  68. case SHARED_MEMORY:
  69. return max_shared_mems;
  70. case ADDRESS_ARBITER:
  71. return max_address_arbiters;
  72. case CPU_TIME:
  73. return max_cpu_time;
  74. default:
  75. LOG_ERROR(Kernel, "Unknown resource type=%08X", resource);
  76. UNIMPLEMENTED();
  77. return 0;
  78. }
  79. }
  80. void ResourceLimitsInit() {
  81. // Create the four resource limits that the system uses
  82. // Create the APPLICATION resource limit
  83. SharedPtr<ResourceLimit> resource_limit = ResourceLimit::Create("Applications");
  84. resource_limit->max_priority = 0x18;
  85. resource_limit->max_commit = 0x4000000;
  86. resource_limit->max_threads = 0x20;
  87. resource_limit->max_events = 0x20;
  88. resource_limit->max_mutexes = 0x20;
  89. resource_limit->max_semaphores = 0x8;
  90. resource_limit->max_timers = 0x8;
  91. resource_limit->max_shared_mems = 0x10;
  92. resource_limit->max_address_arbiters = 0x2;
  93. resource_limit->max_cpu_time = 0x1E;
  94. resource_limits[static_cast<u8>(ResourceLimitCategory::APPLICATION)] = resource_limit;
  95. // Create the SYS_APPLET resource limit
  96. resource_limit = ResourceLimit::Create("System Applets");
  97. resource_limit->max_priority = 0x4;
  98. resource_limit->max_commit = 0x5E00000;
  99. resource_limit->max_threads = 0x1D;
  100. resource_limit->max_events = 0xB;
  101. resource_limit->max_mutexes = 0x8;
  102. resource_limit->max_semaphores = 0x4;
  103. resource_limit->max_timers = 0x4;
  104. resource_limit->max_shared_mems = 0x8;
  105. resource_limit->max_address_arbiters = 0x3;
  106. resource_limit->max_cpu_time = 0x2710;
  107. resource_limits[static_cast<u8>(ResourceLimitCategory::SYS_APPLET)] = resource_limit;
  108. // Create the LIB_APPLET resource limit
  109. resource_limit = ResourceLimit::Create("Library Applets");
  110. resource_limit->max_priority = 0x4;
  111. resource_limit->max_commit = 0x600000;
  112. resource_limit->max_threads = 0xE;
  113. resource_limit->max_events = 0x8;
  114. resource_limit->max_mutexes = 0x8;
  115. resource_limit->max_semaphores = 0x4;
  116. resource_limit->max_timers = 0x4;
  117. resource_limit->max_shared_mems = 0x8;
  118. resource_limit->max_address_arbiters = 0x1;
  119. resource_limit->max_cpu_time = 0x2710;
  120. resource_limits[static_cast<u8>(ResourceLimitCategory::LIB_APPLET)] = resource_limit;
  121. // Create the OTHER resource limit
  122. resource_limit = ResourceLimit::Create("Others");
  123. resource_limit->max_priority = 0x4;
  124. resource_limit->max_commit = 0x2180000;
  125. resource_limit->max_threads = 0xE1;
  126. resource_limit->max_events = 0x108;
  127. resource_limit->max_mutexes = 0x25;
  128. resource_limit->max_semaphores = 0x43;
  129. resource_limit->max_timers = 0x2C;
  130. resource_limit->max_shared_mems = 0x1F;
  131. resource_limit->max_address_arbiters = 0x2D;
  132. resource_limit->max_cpu_time = 0x3E8;
  133. resource_limits[static_cast<u8>(ResourceLimitCategory::OTHER)] = resource_limit;
  134. }
  135. void ResourceLimitsShutdown() {}
  136. } // namespace