C++ console_lock函数代码示例

static void *c_start(struct seq_file *m, loff_t *pos)
{
	struct console *con;
	loff_t off = 0;

	console_lock();
	for_each_console(con)
		if (off++ == *pos)
			break;

	return con;
}

static int vbox_drm_thaw(struct drm_device *dev)
{
    int error = 0;

    drm_mode_config_reset(dev);
    drm_helper_resume_force_mode(dev);

    console_lock();
    vbox_fbdev_set_suspend(dev, 0);
    console_unlock();
    return error;
}

static void ping_recv_callback(void* arg, void *pdata)
{
	struct ping_resp *pingresp = pdata;

	if(pingresp->seqno == 3 /*LAST PING PACKET*/){
		console_printf("total %d, lost %d, %d bytes, %d ms (%d)\n" , 
			pingresp->total_count, pingresp->timeout_count, pingresp->total_bytes, pingresp->total_time, pingresp->ping_err);
		console_lock(0);
	} else {
		console_printf("recv %d bytes in %d ms, seq %d (%d)\n" , pingresp->bytes, pingresp->resp_time, pingresp->seqno, pingresp->ping_err);
	}
}

static int chipsfb_pci_resume(struct pci_dev *pdev)
{
        struct fb_info *p = pci_get_drvdata(pdev);

	console_lock();
	fb_set_suspend(p, 0);
	chipsfb_blank(0, p);
	console_unlock();

	pdev->dev.power.power_state = PMSG_ON;
	return 0;
}

static int  do_listen_interrupt()
{
	console_printf("BUG: How on earth to properly stop listening???\n");
	espconn_disconnect(&esp_conn);
	
	void *p; 
	bool value = espconn_find_connection(&esp_conn, &p);
	console_printf("===>%d \n", value);
	espconn_tcp_disconnect(p);

//	os_free(linebuffer);
	console_lock(0);
}

void intel_console_resume(struct work_struct *work)
{
#ifndef __NetBSD__		/* XXX fb */
	struct drm_i915_private *dev_priv =
		container_of(work, struct drm_i915_private,
			     console_resume_work);
	struct drm_device *dev = dev_priv->dev;

	console_lock();
	intel_fbdev_set_suspend(dev, 0);
	console_unlock();
#endif
}

static int do_ping(int argc, const char* const* argv)
{
	struct ping_option *pingopts = os_zalloc(sizeof(struct ping_option));
	ip_addr_t ipaddr;
	ipaddr.addr = ipaddr_addr(argv[1]);

	pingopts->ip = ipaddr.addr;
	pingopts->count = 3;
	pingopts->recv_function=ping_recv_callback;
	pingopts->sent_function=NULL;
	ping_start(pingopts);
	console_lock(1);
	return 0;
}

static int __init pdc_console_tty_driver_init(void)
{
	int err;

	/* Check if the console driver is still registered.
	 * It is unregistered if the pdc console was not selected as the
	 * primary console. */

	struct console *tmp;

	console_lock();
	for_each_console(tmp)
		if (tmp == &pdc_cons)
			break;
	console_unlock();

	if (!tmp) {
		printk(KERN_INFO "PDC console driver not registered anymore, not creating %s\n", pdc_cons.name);
		return -ENODEV;
	}

	printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n");
	pdc_cons.flags &= ~CON_BOOT;

	tty_port_init(&tty_port);

	pdc_console_tty_driver = alloc_tty_driver(1);

	if (!pdc_console_tty_driver)
		return -ENOMEM;

	pdc_console_tty_driver->driver_name = "pdc_cons";
	pdc_console_tty_driver->name = "ttyB";
	pdc_console_tty_driver->major = MUX_MAJOR;
	pdc_console_tty_driver->minor_start = 0;
	pdc_console_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM;
	pdc_console_tty_driver->init_termios = tty_std_termios;
	pdc_console_tty_driver->flags = TTY_DRIVER_REAL_RAW |
		TTY_DRIVER_RESET_TERMIOS;
	tty_set_operations(pdc_console_tty_driver, &pdc_console_tty_ops);
	tty_port_link_device(&tty_port, pdc_console_tty_driver, 0);

	err = tty_register_driver(pdc_console_tty_driver);
	if (err) {
		printk(KERN_ERR "Unable to register the PDC console TTY driver\n");
		return err;
	}

	return 0;
}

static int   do_listen(int argc, const char* argv[])
{
	int port = skip_atoi(&argv[1]);
	console_printf("Listening (TCP) on port %d\n", port);
	esp_conn.type = ESPCONN_TCP;
	esp_conn.state = ESPCONN_NONE;
	esp_conn.proto.tcp = &esptcp;
	esp_conn.proto.tcp->local_port = port;
	espconn_regist_connectcb(&esp_conn, webserver_listen);
	espconn_accept(&esp_conn);
	linebuffer = os_malloc(LINEBUFFER_SIZE);
	lineptr = 0;
	console_lock(1);
}

static int bochs_pm_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	struct bochs_device *bochs = drm_dev->dev_private;

	drm_kms_helper_poll_disable(drm_dev);

	if (bochs->fb.initialized) {
		console_lock();
		drm_fb_helper_set_suspend(&bochs->fb.helper, 1);
		console_unlock();
	}

	return 0;
}

static int cirrus_pm_suspend(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	struct cirrus_device *cdev = drm_dev->dev_private;

	drm_kms_helper_poll_disable(drm_dev);

	if (cdev->mode_info.gfbdev) {
		console_lock();
		fb_set_suspend(cdev->mode_info.gfbdev->helper.fbdev, 1);
		console_unlock();
	}

	return 0;
}

static int ast_drm_thaw(struct drm_device *dev)
{
	int error = 0;

	ast_post_gpu(dev);

	drm_mode_config_reset(dev);
	drm_modeset_lock_all(dev);
	drm_helper_resume_force_mode(dev);
	drm_modeset_unlock_all(dev);

	console_lock();
	ast_fbdev_set_suspend(dev, 0);
	console_unlock();
	return error;
}

/* Unblank the screen */
static DC_SUNXI_ERROR DC_SUNXIUnblankDisplay(DC_SUNXI_DEVINFO *psDevInfo)
{
	int res;

	console_lock();
	res = fb_blank(psDevInfo->psLINFBInfo, 0);
	console_unlock();

	if (res != 0 && res != -EINVAL)
	{
		printk(KERN_ERR DRIVER_PREFIX
		": %s: Device %u: fb_blank failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res);
		return (DC_SUNXI_ERROR_GENERIC);
	}

	return (DC_SUNXI_OK);
}

static int bochs_pm_resume(struct device *dev)
{
    struct pci_dev *pdev = to_pci_dev(dev);
    struct drm_device *drm_dev = pci_get_drvdata(pdev);
    struct bochs_device *bochs = drm_dev->dev_private;

    drm_helper_resume_force_mode(drm_dev);

    if (bochs->fb.initialized) {
        console_lock();
        fb_set_suspend(bochs->fb.helper.fbdev, 0);
        console_unlock();
    }

    drm_kms_helper_poll_enable(drm_dev);
    return 0;
}

static int cirrus_pm_resume(struct device *dev)
{
	struct pci_dev *pdev = to_pci_dev(dev);
	struct drm_device *drm_dev = pci_get_drvdata(pdev);
	struct cirrus_device *cdev = drm_dev->dev_private;

	drm_helper_resume_force_mode(drm_dev);

	if (cdev->mode_info.gfbdev) {
		console_lock();
		drm_fb_helper_set_suspend(&cdev->mode_info.gfbdev->helper, 0);
		console_unlock();
	}

	drm_kms_helper_poll_enable(drm_dev);
	return 0;
}