Everywhere: Rename FB prefix name ioctls => GRAPHICS

Kernel/API/FB.h

@@ -15,13 +15,13 @@ __BEGIN_DECLS
 
 ALWAYS_INLINE int fb_get_properties(int fd, FBProperties* info)
 {
-    return ioctl(fd, FB_IOCTL_GET_PROPERTIES, info);
+    return ioctl(fd, GRAPHICS_IOCTL_GET_PROPERTIES, info);
 }
 
 // FIXME: Remove this once framebuffer devices are removed.
 ALWAYS_INLINE int fb_get_head_properties(int fd, FBHeadProperties* info)
 {
-    return ioctl(fd, FB_IOCTL_GET_HEAD_PROPERTIES, info);
+    return ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_PROPERTIES, info);
 }
 
 // FIXME: Remove this once framebuffer devices are removed.
@@ -29,7 +29,7 @@ ALWAYS_INLINE int fb_get_resolution(int fd, FBHeadResolution* info)
 {
     FBHeadProperties head_properties;
     head_properties.head_index = info->head_index;
-    if (auto rc = ioctl(fd, FB_IOCTL_GET_HEAD_PROPERTIES, &head_properties); rc < 0)
+    if (auto rc = ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_PROPERTIES, &head_properties); rc < 0)
         return rc;
     info->head_index = head_properties.head_index;
     info->pitch = head_properties.pitch;
@@ -41,38 +41,38 @@ ALWAYS_INLINE int fb_get_resolution(int fd, FBHeadResolution* info)
 // FIXME: Remove this once framebuffer devices are removed.
 ALWAYS_INLINE int fb_set_resolution(int fd, FBHeadResolution* info)
 {
-    return ioctl(fd, FB_IOCTL_SET_HEAD_RESOLUTION, info);
+    return ioctl(fd, GRAPHICS_IOCTL_SET_HEAD_RESOLUTION, info);
 }
 
 ALWAYS_INLINE int fb_get_head_edid(int fd, FBHeadEDID* info)
 {
-    return ioctl(fd, FB_IOCTL_GET_HEAD_EDID, info);
+    return ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_EDID, info);
 }
 
 ALWAYS_INLINE int fb_get_head_vertical_offset_buffer(int fd, FBHeadVerticalOffset* vertical_offset)
 {
-    return ioctl(fd, FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER, vertical_offset);
+    return ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER, vertical_offset);
 }
 
 ALWAYS_INLINE int fb_set_head_vertical_offset_buffer(int fd, FBHeadVerticalOffset* vertical_offset)
 {
-    return ioctl(fd, FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER, vertical_offset);
+    return ioctl(fd, GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER, vertical_offset);
 }
 
 ALWAYS_INLINE int fb_set_head_mode_setting(int fd, FBHeadModeSetting* mode_setting)
 {
-    return ioctl(fd, FB_IOCTL_SET_HEAD_MODE_SETTING, mode_setting);
+    return ioctl(fd, GRAPHICS_IOCTL_SET_HEAD_MODE_SETTING, mode_setting);
 }
 
 ALWAYS_INLINE int fb_set_safe_head_mode_setting(int fd)
 {
-    return ioctl(fd, FB_IOCTL_SET_SAFE_HEAD_MODE_SETTING, nullptr);
+    return ioctl(fd, GRAPHICS_IOCTL_SET_SAFE_HEAD_MODE_SETTING, nullptr);
 }
 
 ALWAYS_INLINE int fb_get_head_mode_setting(int fd, FBHeadModeSetting* mode_setting)
 {
     FBHeadModeSetting head_mode_setting;
-    if (auto rc = ioctl(fd, FB_IOCTL_GET_HEAD_MODE_SETTING, &head_mode_setting); rc < 0)
+    if (auto rc = ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_MODE_SETTING, &head_mode_setting); rc < 0)
         return rc;
     mode_setting->horizontal_stride = head_mode_setting.horizontal_stride;
     mode_setting->pixel_clock_in_khz = head_mode_setting.pixel_clock_in_khz;
@@ -95,12 +95,12 @@ ALWAYS_INLINE int fb_flush_buffers(int fd, int index, FBRect const* rects, unsig
     fb_flush_rects.buffer_index = index;
     fb_flush_rects.count = count;
     fb_flush_rects.rects = rects;
-    return ioctl(fd, FB_IOCTL_FLUSH_HEAD_BUFFERS, &fb_flush_rects);
+    return ioctl(fd, GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS, &fb_flush_rects);
 }
 
 ALWAYS_INLINE int fb_flush_head(int fd)
 {
-    return ioctl(fd, FB_IOCTL_FLUSH_HEAD, nullptr);
+    return ioctl(fd, GRAPHICS_IOCTL_FLUSH_HEAD, nullptr);
 }
 
 __END_DECLS

Kernel/Graphics/DisplayConnector.cpp

@@ -149,7 +149,7 @@ ErrorOr<ByteBuffer> DisplayConnector::get_edid() const
 
 ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
-    if (request != FB_IOCTL_GET_HEAD_EDID) {
+    if (request != GRAPHICS_IOCTL_GET_HEAD_EDID) {
         // Allow anyone to query the EDID. Eventually we'll publish the current EDID on /sys
         // so it doesn't really make sense to require the video pledge to query it.
         TRY(Process::current().require_promise(Pledge::video));
@@ -157,7 +157,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
 
     // TODO: We really should have ioctls for destroying resources as well
     switch (request) {
-    case FB_IOCTL_GET_PROPERTIES: {
+    case GRAPHICS_IOCTL_GET_PROPERTIES: {
         auto user_properties = static_ptr_cast<FBProperties*>(arg);
         FBProperties properties {};
         properties.flushing_support = flush_support();
@@ -167,7 +167,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
 
         return copy_to_user(user_properties, &properties);
     }
-    case FB_IOCTL_GET_HEAD_MODE_SETTING: {
+    case GRAPHICS_IOCTL_GET_HEAD_MODE_SETTING: {
         auto user_head_mode_setting = static_ptr_cast<FBHeadModeSetting*>(arg);
         FBHeadModeSetting head_mode_setting {};
         TRY(copy_from_user(&head_mode_setting, user_head_mode_setting));
@@ -188,7 +188,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
         }
         return copy_to_user(user_head_mode_setting, &head_mode_setting);
     }
-    case FB_IOCTL_GET_HEAD_EDID: {
+    case GRAPHICS_IOCTL_GET_HEAD_EDID: {
         auto user_head_edid = static_ptr_cast<FBHeadEDID*>(arg);
         FBHeadEDID head_edid {};
         TRY(copy_from_user(&head_edid, user_head_edid));
@@ -207,7 +207,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
         head_edid.bytes_size = edid_bytes.size();
         return copy_to_user(user_head_edid, &head_edid);
     }
-    case FB_IOCTL_SET_HEAD_MODE_SETTING: {
+    case GRAPHICS_IOCTL_SET_HEAD_MODE_SETTING: {
         auto user_mode_setting = static_ptr_cast<FBHeadModeSetting const*>(arg);
         auto head_mode_setting = TRY(copy_typed_from_user(user_mode_setting));
 
@@ -256,13 +256,13 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
         return {};
     }
 
-    case FB_IOCTL_SET_SAFE_HEAD_MODE_SETTING: {
+    case GRAPHICS_IOCTL_SET_SAFE_HEAD_MODE_SETTING: {
         SpinlockLocker control_locker(m_control_lock);
         TRY(set_safe_mode_setting());
         return {};
     }
 
-    case FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER: {
+    case GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER: {
         // FIXME: We silently ignore the request if we are in console mode.
         // WindowServer is not ready yet to handle errors such as EBUSY currently.
         SpinlockLocker control_locker(m_control_lock);
@@ -284,7 +284,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
             m_vertical_offsetted = true;
         return {};
     }
-    case FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER: {
+    case GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER: {
         auto user_head_vertical_buffer_offset = static_ptr_cast<FBHeadVerticalOffset*>(arg);
         FBHeadVerticalOffset head_vertical_buffer_offset {};
         TRY(copy_from_user(&head_vertical_buffer_offset, user_head_vertical_buffer_offset));
@@ -292,7 +292,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
         head_vertical_buffer_offset.offsetted = m_vertical_offsetted;
         return copy_to_user(user_head_vertical_buffer_offset, &head_vertical_buffer_offset);
     }
-    case FB_IOCTL_FLUSH_HEAD_BUFFERS: {
+    case GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS: {
         if (!partial_flush_support())
             return Error::from_errno(ENOTSUP);
         MutexLocker locker(m_flushing_lock);
@@ -315,7 +315,7 @@ ErrorOr<void> DisplayConnector::ioctl(OpenFileDescription&, unsigned request, Us
         }
         return {};
     };
-    case FB_IOCTL_FLUSH_HEAD: {
+    case GRAPHICS_IOCTL_FLUSH_HEAD: {
         // FIXME: We silently ignore the request if we are in console mode.
         // WindowServer is not ready yet to handle errors such as EBUSY currently.
         MutexLocker locker(m_flushing_lock);

Kernel/Graphics/GenericFramebufferDevice.cpp

@@ -33,13 +33,13 @@ ErrorOr<void> GenericFramebufferDevice::verify_head_index(int head_index) const
 
 ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
-    if (request != FB_IOCTL_GET_HEAD_EDID) {
+    if (request != GRAPHICS_IOCTL_GET_HEAD_EDID) {
         // Allow anyone to query the EDID. Eventually we'll publish the current EDID on /sys
         // so it doesn't really make sense to require the video pledge to query it.
         TRY(Process::current().require_promise(Pledge::video));
     }
     switch (request) {
-    case FB_IOCTL_GET_PROPERTIES: {
+    case GRAPHICS_IOCTL_GET_PROPERTIES: {
         auto user_properties = static_ptr_cast<FBProperties*>(arg);
         FBProperties properties {};
         auto adapter = m_graphics_adapter.strong_ref();
@@ -51,7 +51,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         properties.partial_flushing_support = partial_flushing_support();
         return copy_to_user(user_properties, &properties);
     }
-    case FB_IOCTL_GET_HEAD_PROPERTIES: {
+    case GRAPHICS_IOCTL_GET_HEAD_PROPERTIES: {
         auto user_head_properties = static_ptr_cast<FBHeadProperties*>(arg);
         FBHeadProperties head_properties {};
         TRY(copy_from_user(&head_properties, user_head_properties));
@@ -64,7 +64,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         head_properties.offset = TRY(vertical_offset(head_properties.head_index));
         return copy_to_user(user_head_properties, &head_properties);
     }
-    case FB_IOCTL_GET_HEAD_EDID: {
+    case GRAPHICS_IOCTL_GET_HEAD_EDID: {
         auto user_head_edid = static_ptr_cast<FBHeadEDID*>(arg);
         FBHeadEDID head_edid {};
         TRY(copy_from_user(&head_edid, user_head_edid));
@@ -84,7 +84,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         head_edid.bytes_size = edid_bytes.size();
         return copy_to_user(user_head_edid, &head_edid);
     }
-    case FB_IOCTL_SET_HEAD_RESOLUTION: {
+    case GRAPHICS_IOCTL_SET_HEAD_RESOLUTION: {
         auto user_head_resolution = static_ptr_cast<FBHeadResolution const*>(arg);
         auto head_resolution = TRY(copy_typed_from_user(user_head_resolution));
         TRY(verify_head_index(head_resolution.head_index));
@@ -98,7 +98,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         TRY(set_head_resolution(head_resolution.head_index, head_resolution.width, head_resolution.height, head_resolution.pitch));
         return {};
     }
-    case FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER: {
+    case GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER: {
         auto user_head_vertical_buffer_offset = static_ptr_cast<FBHeadVerticalOffset const*>(arg);
         auto head_vertical_buffer_offset = TRY(copy_typed_from_user(user_head_vertical_buffer_offset));
         TRY(verify_head_index(head_vertical_buffer_offset.head_index));
@@ -108,7 +108,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         TRY(set_head_buffer(head_vertical_buffer_offset.head_index, head_vertical_buffer_offset.offsetted));
         return {};
     }
-    case FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER: {
+    case GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER: {
         auto user_head_vertical_buffer_offset = static_ptr_cast<FBHeadVerticalOffset*>(arg);
         FBHeadVerticalOffset head_vertical_buffer_offset {};
         TRY(copy_from_user(&head_vertical_buffer_offset, user_head_vertical_buffer_offset));
@@ -117,7 +117,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         head_vertical_buffer_offset.offsetted = TRY(vertical_offsetted(head_vertical_buffer_offset.head_index));
         return copy_to_user(user_head_vertical_buffer_offset, &head_vertical_buffer_offset);
     }
-    case FB_IOCTL_FLUSH_HEAD_BUFFERS: {
+    case GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS: {
         if (!partial_flushing_support())
             return Error::from_errno(ENOTSUP);
         auto user_flush_rects = static_ptr_cast<FBFlushRects const*>(arg);
@@ -134,7 +134,7 @@ ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned req
         }
         return {};
     };
-    case FB_IOCTL_FLUSH_HEAD: {
+    case GRAPHICS_IOCTL_FLUSH_HEAD: {
         if (!flushing_support())
             return Error::from_errno(ENOTSUP);
         // Note: We accept a FBRect, but we only really care about the head_index value.

Tests/Kernel/bxvga-mmap-kernel-into-userspace.cpp

@@ -27,7 +27,7 @@ int main()
 
     FBHeadProperties original_properties;
     original_properties.head_index = 0;
-    if (ioctl(fd, FB_IOCTL_GET_HEAD_PROPERTIES, &original_properties) < 0) {
+    if (ioctl(fd, GRAPHICS_IOCTL_GET_HEAD_PROPERTIES, &original_properties) < 0) {
         perror("ioctl");
         return 1;
     }
@@ -38,7 +38,7 @@ int main()
     resolution.height = height;
     resolution.pitch = pitch;
 
-    if (ioctl(fd, FB_IOCTL_SET_HEAD_RESOLUTION, &resolution) < 0) {
+    if (ioctl(fd, GRAPHICS_IOCTL_SET_HEAD_RESOLUTION, &resolution) < 0) {
         perror("ioctl");
         return 1;
     }
@@ -94,7 +94,7 @@ int main()
     original_resolution.width = original_properties.width;
     original_resolution.height = original_properties.height;
     original_resolution.pitch = original_properties.pitch;
-    if (ioctl(fd, FB_IOCTL_SET_HEAD_RESOLUTION, &original_resolution) < 0) {
+    if (ioctl(fd, GRAPHICS_IOCTL_SET_HEAD_RESOLUTION, &original_resolution) < 0) {
         perror("ioctl");
         return 1;
     }

Userland/DevTools/UserspaceEmulator/Emulator_syscalls.cpp

@@ -1159,20 +1159,20 @@ int Emulator::virt$ioctl([[maybe_unused]] int fd, unsigned request, [[maybe_unus
         return syscall(SC_ioctl, fd, request, 0);
     case TIOCSTI:
         return -EIO;
-    case FB_IOCTL_GET_PROPERTIES: {
+    case GRAPHICS_IOCTL_GET_PROPERTIES: {
         size_t size = 0;
         auto rc = syscall(SC_ioctl, fd, request, &size);
         mmu().copy_to_vm(arg, &size, sizeof(size));
         return rc;
     }
-    case FB_IOCTL_SET_HEAD_RESOLUTION: {
+    case GRAPHICS_IOCTL_SET_HEAD_RESOLUTION: {
         FBHeadResolution user_resolution;
         mmu().copy_from_vm(&user_resolution, arg, sizeof(user_resolution));
         auto rc = syscall(SC_ioctl, fd, request, &user_resolution);
         mmu().copy_to_vm(arg, &user_resolution, sizeof(user_resolution));
         return rc;
     }
-    case FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER:
+    case GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER:
         return syscall(SC_ioctl, fd, request, arg);
     case FIONBIO: {
         int enabled;

Userland/Libraries/LibC/sys/ioctl_numbers.h

@@ -113,17 +113,17 @@ enum IOCtlNumber {
     TIOCNOTTY,
     TIOCSWINSZ,
     TIOCGPTN,
-    FB_IOCTL_GET_PROPERTIES,
-    FB_IOCTL_GET_HEAD_PROPERTIES,
-    FB_IOCTL_SET_HEAD_RESOLUTION,
-    FB_IOCTL_GET_HEAD_EDID,
-    FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER,
-    FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER,
-    FB_IOCTL_FLUSH_HEAD_BUFFERS,
-    FB_IOCTL_FLUSH_HEAD,
-    FB_IOCTL_SET_HEAD_MODE_SETTING,
-    FB_IOCTL_GET_HEAD_MODE_SETTING,
-    FB_IOCTL_SET_SAFE_HEAD_MODE_SETTING,
+    GRAPHICS_IOCTL_GET_PROPERTIES,
+    GRAPHICS_IOCTL_GET_HEAD_PROPERTIES,
+    GRAPHICS_IOCTL_SET_HEAD_RESOLUTION,
+    GRAPHICS_IOCTL_GET_HEAD_EDID,
+    GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER,
+    GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER,
+    GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS,
+    GRAPHICS_IOCTL_FLUSH_HEAD,
+    GRAPHICS_IOCTL_SET_HEAD_MODE_SETTING,
+    GRAPHICS_IOCTL_GET_HEAD_MODE_SETTING,
+    GRAPHICS_IOCTL_SET_SAFE_HEAD_MODE_SETTING,
     KEYBOARD_IOCTL_GET_NUM_LOCK,
     KEYBOARD_IOCTL_SET_NUM_LOCK,
     KEYBOARD_IOCTL_GET_CAPS_LOCK,
@@ -175,17 +175,17 @@ enum IOCtlNumber {
 #define TIOCNOTTY TIOCNOTTY
 #define TIOCSWINSZ TIOCSWINSZ
 #define TIOCGPTN TIOCGPTN
-#define FB_IOCTL_GET_PROPERTIES FB_IOCTL_GET_PROPERTIES
-#define FB_IOCTL_GET_HEAD_PROPERTIES FB_IOCTL_GET_HEAD_PROPERTIES
-#define FB_IOCTL_GET_HEAD_EDID FB_IOCTL_GET_HEAD_EDID
-#define FB_IOCTL_SET_HEAD_RESOLUTION FB_IOCTL_SET_HEAD_RESOLUTION
-#define FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER
-#define FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER
-#define FB_IOCTL_FLUSH_HEAD_BUFFERS FB_IOCTL_FLUSH_HEAD_BUFFERS
-#define FB_IOCTL_FLUSH_HEAD FB_IOCTL_FLUSH_HEAD
-#define FB_IOCTL_SET_HEAD_MODE_SETTING FB_IOCTL_SET_HEAD_MODE_SETTING
-#define FB_IOCTL_GET_HEAD_MODE_SETTING FB_IOCTL_GET_HEAD_MODE_SETTING
-#define FB_IOCTL_SET_SAFE_HEAD_MODE_SETTING FB_IOCTL_SET_SAFE_HEAD_MODE_SETTING
+#define GRAPHICS_IOCTL_GET_PROPERTIES GRAPHICS_IOCTL_GET_PROPERTIES
+#define GRAPHICS_IOCTL_GET_HEAD_PROPERTIES GRAPHICS_IOCTL_GET_HEAD_PROPERTIES
+#define GRAPHICS_IOCTL_GET_HEAD_EDID GRAPHICS_IOCTL_GET_HEAD_EDID
+#define GRAPHICS_IOCTL_SET_HEAD_RESOLUTION GRAPHICS_IOCTL_SET_HEAD_RESOLUTION
+#define GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER
+#define GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER
+#define GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS
+#define GRAPHICS_IOCTL_FLUSH_HEAD GRAPHICS_IOCTL_FLUSH_HEAD
+#define GRAPHICS_IOCTL_SET_HEAD_MODE_SETTING GRAPHICS_IOCTL_SET_HEAD_MODE_SETTING
+#define GRAPHICS_IOCTL_GET_HEAD_MODE_SETTING GRAPHICS_IOCTL_GET_HEAD_MODE_SETTING
+#define GRAPHICS_IOCTL_SET_SAFE_HEAD_MODE_SETTING GRAPHICS_IOCTL_SET_SAFE_HEAD_MODE_SETTING
 #define KEYBOARD_IOCTL_GET_NUM_LOCK KEYBOARD_IOCTL_GET_NUM_LOCK
 #define KEYBOARD_IOCTL_SET_NUM_LOCK KEYBOARD_IOCTL_SET_NUM_LOCK
 #define KEYBOARD_IOCTL_GET_CAPS_LOCK KEYBOARD_IOCTL_GET_CAPS_LOCK

Userland/Utilities/strace.cpp

@@ -143,13 +143,13 @@ HANDLE(TIOCSCTTY)
 HANDLE(TIOCSTI)
 HANDLE(TIOCNOTTY)
 HANDLE(TIOCSWINSZ)
-HANDLE(FB_IOCTL_GET_PROPERTIES)
-HANDLE(FB_IOCTL_GET_HEAD_PROPERTIES)
-HANDLE(FB_IOCTL_SET_HEAD_RESOLUTION)
-HANDLE(FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER)
-HANDLE(FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER)
-HANDLE(FB_IOCTL_FLUSH_HEAD_BUFFERS)
-HANDLE(FB_IOCTL_FLUSH_HEAD)
+HANDLE(GRAPHICS_IOCTL_GET_PROPERTIES)
+HANDLE(GRAPHICS_IOCTL_GET_HEAD_PROPERTIES)
+HANDLE(GRAPHICS_IOCTL_SET_HEAD_RESOLUTION)
+HANDLE(GRAPHICS_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER)
+HANDLE(GRAPHICS_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER)
+HANDLE(GRAPHICS_IOCTL_FLUSH_HEAD_BUFFERS)
+HANDLE(GRAPHICS_IOCTL_FLUSH_HEAD)
 HANDLE(KEYBOARD_IOCTL_GET_NUM_LOCK)
 HANDLE(KEYBOARD_IOCTL_SET_NUM_LOCK)
 HANDLE(KEYBOARD_IOCTL_GET_CAPS_LOCK)