StdLib.h 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #pragma once
  7. #include <AK/Checked.h>
  8. #include <AK/Error.h>
  9. #include <AK/Forward.h>
  10. #include <AK/Time.h>
  11. #include <AK/Userspace.h>
  12. #include <Kernel/KString.h>
  13. #include <Kernel/UnixTypes.h>
  14. ErrorOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<const char*>, size_t);
  15. ErrorOr<Time> copy_time_from_user(timespec const*);
  16. ErrorOr<Time> copy_time_from_user(timeval const*);
  17. template<typename T>
  18. ErrorOr<Time> copy_time_from_user(Userspace<T*>);
  19. [[nodiscard]] Optional<u32> user_atomic_fetch_add_relaxed(volatile u32* var, u32 val);
  20. [[nodiscard]] Optional<u32> user_atomic_exchange_relaxed(volatile u32* var, u32 val);
  21. [[nodiscard]] Optional<u32> user_atomic_load_relaxed(volatile u32* var);
  22. [[nodiscard]] bool user_atomic_store_relaxed(volatile u32* var, u32 val);
  23. [[nodiscard]] Optional<bool> user_atomic_compare_exchange_relaxed(volatile u32* var, u32& expected, u32 val);
  24. [[nodiscard]] Optional<u32> user_atomic_fetch_and_relaxed(volatile u32* var, u32 val);
  25. [[nodiscard]] Optional<u32> user_atomic_fetch_and_not_relaxed(volatile u32* var, u32 val);
  26. [[nodiscard]] Optional<u32> user_atomic_fetch_or_relaxed(volatile u32* var, u32 val);
  27. [[nodiscard]] Optional<u32> user_atomic_fetch_xor_relaxed(volatile u32* var, u32 val);
  28. ErrorOr<void> copy_to_user(void*, const void*, size_t);
  29. ErrorOr<void> copy_from_user(void*, const void*, size_t);
  30. ErrorOr<void> memset_user(void*, int, size_t);
  31. extern "C" {
  32. void* memcpy(void*, const void*, size_t);
  33. [[nodiscard]] int strncmp(const char* s1, const char* s2, size_t n);
  34. [[nodiscard]] char* strstr(const char* haystack, const char* needle);
  35. [[nodiscard]] int strcmp(char const*, const char*);
  36. [[nodiscard]] size_t strlen(const char*);
  37. [[nodiscard]] size_t strnlen(const char*, size_t);
  38. void* memset(void*, int, size_t);
  39. [[nodiscard]] int memcmp(const void*, const void*, size_t);
  40. void* memmove(void* dest, const void* src, size_t n);
  41. const void* memmem(const void* haystack, size_t, const void* needle, size_t);
  42. [[nodiscard]] inline u16 ntohs(u16 w) { return (w & 0xff) << 8 | ((w >> 8) & 0xff); }
  43. [[nodiscard]] inline u16 htons(u16 w) { return (w & 0xff) << 8 | ((w >> 8) & 0xff); }
  44. }
  45. template<typename T>
  46. [[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, const T* src)
  47. {
  48. static_assert(IsTriviallyCopyable<T>);
  49. return copy_from_user(dest, src, sizeof(T));
  50. }
  51. template<typename T>
  52. [[nodiscard]] inline ErrorOr<void> copy_to_user(T* dest, const T* src)
  53. {
  54. static_assert(IsTriviallyCopyable<T>);
  55. return copy_to_user(dest, src, sizeof(T));
  56. }
  57. template<typename T>
  58. [[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, Userspace<const T*> src)
  59. {
  60. static_assert(IsTriviallyCopyable<T>);
  61. return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
  62. }
  63. template<typename T>
  64. [[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, Userspace<T*> src)
  65. {
  66. static_assert(IsTriviallyCopyable<T>);
  67. return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
  68. }
  69. #define DEPRECATE_COPY_FROM_USER_TYPE(T, REPLACEMENT) \
  70. template<> \
  71. [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, const T*) \
  72. { \
  73. VERIFY_NOT_REACHED(); \
  74. } \
  75. template<> \
  76. [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, Userspace<const T*>) \
  77. { \
  78. VERIFY_NOT_REACHED(); \
  79. } \
  80. template<> \
  81. [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, Userspace<T*>) \
  82. { \
  83. VERIFY_NOT_REACHED(); \
  84. }
  85. DEPRECATE_COPY_FROM_USER_TYPE(timespec, copy_time_from_user)
  86. DEPRECATE_COPY_FROM_USER_TYPE(timeval, copy_time_from_user)
  87. template<typename T>
  88. [[nodiscard]] inline ErrorOr<void> copy_to_user(Userspace<T*> dest, const T* src)
  89. {
  90. static_assert(IsTriviallyCopyable<T>);
  91. return copy_to_user(dest.unsafe_userspace_ptr(), src, sizeof(T));
  92. }
  93. template<typename T>
  94. [[nodiscard]] inline ErrorOr<void> copy_to_user(Userspace<T*> dest, const void* src, size_t size)
  95. {
  96. static_assert(IsTriviallyCopyable<T>);
  97. return copy_to_user(dest.unsafe_userspace_ptr(), src, size);
  98. }
  99. template<typename T>
  100. [[nodiscard]] inline ErrorOr<void> copy_from_user(void* dest, Userspace<const T*> src, size_t size)
  101. {
  102. static_assert(IsTriviallyCopyable<T>);
  103. return copy_from_user(dest, src.unsafe_userspace_ptr(), size);
  104. }
  105. template<typename T>
  106. [[nodiscard]] inline ErrorOr<void> copy_n_from_user(T* dest, const T* src, size_t count)
  107. {
  108. static_assert(IsTriviallyCopyable<T>);
  109. Checked<size_t> size = sizeof(T);
  110. size *= count;
  111. if (size.has_overflow())
  112. return EOVERFLOW;
  113. return copy_from_user(dest, src, size.value());
  114. }
  115. template<typename T>
  116. [[nodiscard]] inline ErrorOr<void> copy_n_to_user(T* dest, const T* src, size_t count)
  117. {
  118. static_assert(IsTriviallyCopyable<T>);
  119. Checked<size_t> size = sizeof(T);
  120. size *= count;
  121. if (size.has_overflow())
  122. return EOVERFLOW;
  123. return copy_to_user(dest, src, size.value());
  124. }
  125. template<typename T>
  126. [[nodiscard]] inline ErrorOr<void> copy_n_from_user(T* dest, Userspace<const T*> src, size_t count)
  127. {
  128. static_assert(IsTriviallyCopyable<T>);
  129. Checked<size_t> size = sizeof(T);
  130. size *= count;
  131. if (size.has_overflow())
  132. return EOVERFLOW;
  133. return copy_from_user(dest, src.unsafe_userspace_ptr(), size.value());
  134. }
  135. template<typename T>
  136. [[nodiscard]] inline ErrorOr<void> try_copy_n_to_user(Userspace<T*> dest, const T* src, size_t count)
  137. {
  138. static_assert(IsTriviallyCopyable<T>);
  139. Checked<size_t> size = sizeof(T);
  140. size *= count;
  141. if (size.has_overflow())
  142. return EOVERFLOW;
  143. return copy_to_user(dest.unsafe_userspace_ptr(), src, size.value());
  144. }
  145. template<typename T>
  146. inline ErrorOr<T> copy_typed_from_user(Userspace<T const*> user_data)
  147. {
  148. T data {};
  149. TRY(copy_from_user(&data, user_data));
  150. return data;
  151. }