Linux 4.9.x下捕获活动TTY切换事件开发信息面板驱动

Great question! Let's break this down into two practical approaches for your headless Linux 4.9.x system—kernel-level hooks and user-space monitoring—since you want to trigger signals to your info panel driver when switching TTYs with Ctrl+Alt+F#.

Kernel-Level Hook: VT Notifier Chain #

Linux 4.9 includes a VT (Virtual Terminal) notifier chain that fires events whenever a TTY is activated or deactivated. This is the most direct kernel-level way to detect TTY switches, and you can hook into it either directly in your info panel driver or via a small auxiliary kernel module.

How it works: #

• Register a callback function with register_vt_notifier() to listen for VT events.
• The callback will receive events like VT_ACTIVATE (when a TTY becomes active) or VT_DEACTIVATE (when it's switched away from).
• From the callback, you can send signals to your info panel driver using kernel IPC methods like netlink, kobject uevents, or direct function calls if the modules are integrated.

Example Kernel Module Snippet: #

#include <linux/vt.h>
#include <linux/notifier.h>
#include <linux/module.h>

static int vt_switch_handler(struct notifier_block *nb, unsigned long action, void *data) {
    struct vt_notifier_param *param = (struct vt_notifier_param *)data;
    
    if (action == VT_ACTIVATE) {
        // Log the switch (replace with your driver signal logic)
        printk(KERN_INFO "Active TTY changed to: %d\n", param->vt_num);
        
        // Example: Trigger your driver here (e.g., via a custom ioctl or kobject uevent)
        // your_info_panel_driver_signal(param->vt_num);
    }
    
    return NOTIFY_OK;
}

static struct notifier_block vt_notifier = {
    .notifier_call = vt_switch_handler,
};

static int __init vt_monitor_init(void) {
    return register_vt_notifier(&vt_notifier);
}

static void __exit vt_monitor_exit(void) {
    unregister_vt_notifier(&vt_notifier);
}

module_init(vt_monitor_init);
module_exit(vt_monitor_exit);
MODULE_LICENSE("GPL");

This module runs in kernel space and triggers immediately when a TTY switch occurs—no polling required.

User-Space Monitoring Methods #

If you prefer to avoid kernel code, you can detect TTY switches from user space with a few reliable methods. Both require root privileges to access system devices.

1. Monitor /dev/tty0 with VT IOCTLs #

/dev/tty0 is the alias for the currently active VT. You can use the VT_WAITACTIVE ioctl to block until a TTY switch happens, then fetch the new active TTY number.

Example User-Space Daemon: #

#include <stdio.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/vt.h>
#include <unistd.h>
#include <errno.h>

int main() {
    int tty_fd = open("/dev/tty0", O_RDWR);
    if (tty_fd < 0) {
        perror("Failed to open /dev/tty0");
        return 1;
    }

    int current_vt;
    if (ioctl(tty_fd, VT_GETACTIVE, &current_vt) == 0) {
        printf("Initial active TTY: %d\n", current_vt);
    }

    while (1) {
        int new_vt;
        // Block until a TTY switch occurs
        if (ioctl(tty_fd, VT_WAITACTIVE, &new_vt) == 0) {
            printf("Switched to TTY: %d\n", new_vt);
            
            // Send signal to your info panel driver here (e.g., via sysfs, a character device, or socket)
            // send_signal_to_driver(new_vt);
            
            current_vt = new_vt;
        } else if (errno != EINTR) {
            perror("VT_WAITACTIVE failed");
            break;
        }
    }

    close(tty_fd);
    return 0;
}

This method is clean because it listens directly for the system's VT state change, not the raw key presses.

2. Listen for Raw Keyboard Events #

If you need to detect the actual Ctrl+Alt+F# key combination (not just the TTY switch result), you can read raw input events from your keyboard's /dev/input/eventX device.

Steps: #

1. Find your keyboard device path with cat /proc/bus/input/devices (look for the device labeled "Keyboard").
2. Read input events to track when Ctrl, Alt, and F1-F5 keys are pressed together.

Example Code Snippet: #

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/input.h>

int main() {
    // Replace with your keyboard's event path (e.g., /dev/input/event1)
    int input_fd = open("/dev/input/event0", O_RDONLY);
    if (input_fd < 0) {
        perror("Failed to open input device");
        return 1;
    }

    struct input_event ev;
    int ctrl_down = 0, alt_down = 0;

    while (read(input_fd, &ev, sizeof(ev)) == sizeof(ev)) {
        if (ev.type == EV_KEY) {
            switch (ev.code) {
                case KEY_LEFTCTRL:
                case KEY_RIGHTCTRL:
                    ctrl_down = (ev.value == 1);
                    break;
                case KEY_LEFTALT:
                case KEY_RIGHTALT:
                    alt_down = (ev.value == 1);
                    break;
                case KEY_F1 ... KEY_F5:
                    if (ev.value == 1 && ctrl_down && alt_down) {
                        int tty_num = ev.code - KEY_F1 + 1;
                        printf("Ctrl+Alt+F%d pressed — switching to TTY %d\n", tty_num, tty_num);
                        
                        // Send signal to your driver here
                        // send_signal_to_driver(tty_num);
                    }
                    break;
            }
        }
    }

    close(input_fd);
    return 0;
}

Recommendation #

If your info panel driver is a kernel module, go with the VT notifier chain for low-latency, direct integration. For user-space drivers, the /dev/tty0 IOCTL method is simpler and more reliable than raw key detection (since it avoids handling keyboard-specific key codes).

内容的提问来源于stack exchange，提问作者Jebus