Error Trace

[Home]

Bug # 123

Show/hide error trace
Error trace
Function bodies
Blocks
  • Others...
    Function bodies without model function calls
    Initialization function calls
    Initialization function bodies
    Entry point
    Entry point body
    Function calls
    Skipped function calls
    Formal parameter names
    Declarations
    Assumes
    Assume conditions
    Returns
    Return values
    DEG initialization
    DEG function calls
    Model function calls
    Model function bodies
    Model asserts
    Model state changes
    Model function function calls
    Model function function bodies
    Model returns
    Model others
    Identation
    Line numbers
    Expand signs
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/init.o.i()
{
85 -__kstrtab_mei_fw_status2str[ 0 ] = 109;
__kstrtab_mei_fw_status2str[ 1 ] = 101;
__kstrtab_mei_fw_status2str[ 2 ] = 105;
__kstrtab_mei_fw_status2str[ 3 ] = 95;
__kstrtab_mei_fw_status2str[ 4 ] = 102;
__kstrtab_mei_fw_status2str[ 5 ] = 119;
__kstrtab_mei_fw_status2str[ 6 ] = 95;
__kstrtab_mei_fw_status2str[ 7 ] = 115;
__kstrtab_mei_fw_status2str[ 8 ] = 116;
__kstrtab_mei_fw_status2str[ 9 ] = 97;
__kstrtab_mei_fw_status2str[ 10 ] = 116;
__kstrtab_mei_fw_status2str[ 11 ] = 117;
__kstrtab_mei_fw_status2str[ 12 ] = 115;
__kstrtab_mei_fw_status2str[ 13 ] = 50;
__kstrtab_mei_fw_status2str[ 14 ] = 115;
__kstrtab_mei_fw_status2str[ 15 ] = 116;
__kstrtab_mei_fw_status2str[ 16 ] = 114;
__kstrtab_mei_fw_status2str[ 17 ] = 0;
__ksymtab_mei_fw_status2str.value = &(mei_fw_status2str);
__ksymtab_mei_fw_status2str.name = &(__kstrtab_mei_fw_status2str);
__kstrtab_mei_cancel_work[ 0 ] = 109;
__kstrtab_mei_cancel_work[ 1 ] = 101;
__kstrtab_mei_cancel_work[ 2 ] = 105;
__kstrtab_mei_cancel_work[ 3 ] = 95;
__kstrtab_mei_cancel_work[ 4 ] = 99;
__kstrtab_mei_cancel_work[ 5 ] = 97;
__kstrtab_mei_cancel_work[ 6 ] = 110;
__kstrtab_mei_cancel_work[ 7 ] = 99;
__kstrtab_mei_cancel_work[ 8 ] = 101;
__kstrtab_mei_cancel_work[ 9 ] = 108;
__kstrtab_mei_cancel_work[ 10 ] = 95;
__kstrtab_mei_cancel_work[ 11 ] = 119;
__kstrtab_mei_cancel_work[ 12 ] = 111;
__kstrtab_mei_cancel_work[ 13 ] = 114;
__kstrtab_mei_cancel_work[ 14 ] = 107;
__kstrtab_mei_cancel_work[ 15 ] = 0;
__ksymtab_mei_cancel_work.value = &(mei_cancel_work);
__ksymtab_mei_cancel_work.name = &(__kstrtab_mei_cancel_work);
__kstrtab_mei_reset[ 0 ] = 109;
__kstrtab_mei_reset[ 1 ] = 101;
__kstrtab_mei_reset[ 2 ] = 105;
__kstrtab_mei_reset[ 3 ] = 95;
__kstrtab_mei_reset[ 4 ] = 114;
__kstrtab_mei_reset[ 5 ] = 101;
__kstrtab_mei_reset[ 6 ] = 115;
__kstrtab_mei_reset[ 7 ] = 101;
__kstrtab_mei_reset[ 8 ] = 116;
__kstrtab_mei_reset[ 9 ] = 0;
__ksymtab_mei_reset.value = &(mei_reset);
__ksymtab_mei_reset.name = &(__kstrtab_mei_reset);
__kstrtab_mei_start[ 0 ] = 109;
__kstrtab_mei_start[ 1 ] = 101;
__kstrtab_mei_start[ 2 ] = 105;
__kstrtab_mei_start[ 3 ] = 95;
__kstrtab_mei_start[ 4 ] = 115;
__kstrtab_mei_start[ 5 ] = 116;
__kstrtab_mei_start[ 6 ] = 97;
__kstrtab_mei_start[ 7 ] = 114;
__kstrtab_mei_start[ 8 ] = 116;
__kstrtab_mei_start[ 9 ] = 0;
__ksymtab_mei_start.value = &(mei_start);
__ksymtab_mei_start.name = &(__kstrtab_mei_start);
__kstrtab_mei_restart[ 0 ] = 109;
__kstrtab_mei_restart[ 1 ] = 101;
__kstrtab_mei_restart[ 2 ] = 105;
__kstrtab_mei_restart[ 3 ] = 95;
__kstrtab_mei_restart[ 4 ] = 114;
__kstrtab_mei_restart[ 5 ] = 101;
__kstrtab_mei_restart[ 6 ] = 115;
__kstrtab_mei_restart[ 7 ] = 116;
__kstrtab_mei_restart[ 8 ] = 97;
__kstrtab_mei_restart[ 9 ] = 114;
__kstrtab_mei_restart[ 10 ] = 116;
__kstrtab_mei_restart[ 11 ] = 0;
__ksymtab_mei_restart.value = &(mei_restart);
__ksymtab_mei_restart.name = &(__kstrtab_mei_restart);
__kstrtab_mei_stop[ 0 ] = 109;
__kstrtab_mei_stop[ 1 ] = 101;
__kstrtab_mei_stop[ 2 ] = 105;
__kstrtab_mei_stop[ 3 ] = 95;
__kstrtab_mei_stop[ 4 ] = 115;
__kstrtab_mei_stop[ 5 ] = 116;
__kstrtab_mei_stop[ 6 ] = 111;
__kstrtab_mei_stop[ 7 ] = 112;
__kstrtab_mei_stop[ 8 ] = 0;
__ksymtab_mei_stop.value = &(mei_stop);
__ksymtab_mei_stop.name = &(__kstrtab_mei_stop);
__kstrtab_mei_write_is_idle[ 0 ] = 109;
__kstrtab_mei_write_is_idle[ 1 ] = 101;
__kstrtab_mei_write_is_idle[ 2 ] = 105;
__kstrtab_mei_write_is_idle[ 3 ] = 95;
__kstrtab_mei_write_is_idle[ 4 ] = 119;
__kstrtab_mei_write_is_idle[ 5 ] = 114;
__kstrtab_mei_write_is_idle[ 6 ] = 105;
__kstrtab_mei_write_is_idle[ 7 ] = 116;
__kstrtab_mei_write_is_idle[ 8 ] = 101;
__kstrtab_mei_write_is_idle[ 9 ] = 95;
__kstrtab_mei_write_is_idle[ 10 ] = 105;
__kstrtab_mei_write_is_idle[ 11 ] = 115;
__kstrtab_mei_write_is_idle[ 12 ] = 95;
__kstrtab_mei_write_is_idle[ 13 ] = 105;
__kstrtab_mei_write_is_idle[ 14 ] = 100;
__kstrtab_mei_write_is_idle[ 15 ] = 108;
__kstrtab_mei_write_is_idle[ 16 ] = 101;
__kstrtab_mei_write_is_idle[ 17 ] = 0;
__ksymtab_mei_write_is_idle.value = &(mei_write_is_idle);
__ksymtab_mei_write_is_idle.name = &(__kstrtab_mei_write_is_idle);
__kstrtab_mei_device_init[ 0 ] = 109;
__kstrtab_mei_device_init[ 1 ] = 101;
__kstrtab_mei_device_init[ 2 ] = 105;
__kstrtab_mei_device_init[ 3 ] = 95;
__kstrtab_mei_device_init[ 4 ] = 100;
__kstrtab_mei_device_init[ 5 ] = 101;
__kstrtab_mei_device_init[ 6 ] = 118;
__kstrtab_mei_device_init[ 7 ] = 105;
__kstrtab_mei_device_init[ 8 ] = 99;
__kstrtab_mei_device_init[ 9 ] = 101;
__kstrtab_mei_device_init[ 10 ] = 95;
__kstrtab_mei_device_init[ 11 ] = 105;
__kstrtab_mei_device_init[ 12 ] = 110;
__kstrtab_mei_device_init[ 13 ] = 105;
__kstrtab_mei_device_init[ 14 ] = 116;
__kstrtab_mei_device_init[ 15 ] = 0;
__ksymtab_mei_device_init.value = &(mei_device_init);
__ksymtab_mei_device_init.name = &(__kstrtab_mei_device_init);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/hbm.o.i()
{
602 -__kstrtab_mei_hbm_pg[ 0 ] = 109;
__kstrtab_mei_hbm_pg[ 1 ] = 101;
__kstrtab_mei_hbm_pg[ 2 ] = 105;
__kstrtab_mei_hbm_pg[ 3 ] = 95;
__kstrtab_mei_hbm_pg[ 4 ] = 104;
__kstrtab_mei_hbm_pg[ 5 ] = 98;
__kstrtab_mei_hbm_pg[ 6 ] = 109;
__kstrtab_mei_hbm_pg[ 7 ] = 95;
__kstrtab_mei_hbm_pg[ 8 ] = 112;
__kstrtab_mei_hbm_pg[ 9 ] = 103;
__kstrtab_mei_hbm_pg[ 10 ] = 0;
__ksymtab_mei_hbm_pg.value = &(mei_hbm_pg);
__ksymtab_mei_hbm_pg.name = &(__kstrtab_mei_hbm_pg);
__kstrtab_mei_hbm_pg_resume[ 0 ] = 109;
__kstrtab_mei_hbm_pg_resume[ 1 ] = 101;
__kstrtab_mei_hbm_pg_resume[ 2 ] = 105;
__kstrtab_mei_hbm_pg_resume[ 3 ] = 95;
__kstrtab_mei_hbm_pg_resume[ 4 ] = 104;
__kstrtab_mei_hbm_pg_resume[ 5 ] = 98;
__kstrtab_mei_hbm_pg_resume[ 6 ] = 109;
__kstrtab_mei_hbm_pg_resume[ 7 ] = 95;
__kstrtab_mei_hbm_pg_resume[ 8 ] = 112;
__kstrtab_mei_hbm_pg_resume[ 9 ] = 103;
__kstrtab_mei_hbm_pg_resume[ 10 ] = 95;
__kstrtab_mei_hbm_pg_resume[ 11 ] = 114;
__kstrtab_mei_hbm_pg_resume[ 12 ] = 101;
__kstrtab_mei_hbm_pg_resume[ 13 ] = 115;
__kstrtab_mei_hbm_pg_resume[ 14 ] = 117;
__kstrtab_mei_hbm_pg_resume[ 15 ] = 109;
__kstrtab_mei_hbm_pg_resume[ 16 ] = 101;
__kstrtab_mei_hbm_pg_resume[ 17 ] = 0;
__ksymtab_mei_hbm_pg_resume.value = &(mei_hbm_pg_resume);
__ksymtab_mei_hbm_pg_resume.name = &(__kstrtab_mei_hbm_pg_resume);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/interrupt.o.i()
{
56 -__kstrtab_mei_irq_compl_handler[ 0 ] = 109;
__kstrtab_mei_irq_compl_handler[ 1 ] = 101;
__kstrtab_mei_irq_compl_handler[ 2 ] = 105;
__kstrtab_mei_irq_compl_handler[ 3 ] = 95;
__kstrtab_mei_irq_compl_handler[ 4 ] = 105;
__kstrtab_mei_irq_compl_handler[ 5 ] = 114;
__kstrtab_mei_irq_compl_handler[ 6 ] = 113;
__kstrtab_mei_irq_compl_handler[ 7 ] = 95;
__kstrtab_mei_irq_compl_handler[ 8 ] = 99;
__kstrtab_mei_irq_compl_handler[ 9 ] = 111;
__kstrtab_mei_irq_compl_handler[ 10 ] = 109;
__kstrtab_mei_irq_compl_handler[ 11 ] = 112;
__kstrtab_mei_irq_compl_handler[ 12 ] = 108;
__kstrtab_mei_irq_compl_handler[ 13 ] = 95;
__kstrtab_mei_irq_compl_handler[ 14 ] = 104;
__kstrtab_mei_irq_compl_handler[ 15 ] = 97;
__kstrtab_mei_irq_compl_handler[ 16 ] = 110;
__kstrtab_mei_irq_compl_handler[ 17 ] = 100;
__kstrtab_mei_irq_compl_handler[ 18 ] = 108;
__kstrtab_mei_irq_compl_handler[ 19 ] = 101;
__kstrtab_mei_irq_compl_handler[ 20 ] = 114;
__kstrtab_mei_irq_compl_handler[ 21 ] = 0;
__ksymtab_mei_irq_compl_handler.value = &(mei_irq_compl_handler);
__ksymtab_mei_irq_compl_handler.name = &(__kstrtab_mei_irq_compl_handler);
__kstrtab_mei_irq_read_handler[ 0 ] = 109;
__kstrtab_mei_irq_read_handler[ 1 ] = 101;
__kstrtab_mei_irq_read_handler[ 2 ] = 105;
__kstrtab_mei_irq_read_handler[ 3 ] = 95;
__kstrtab_mei_irq_read_handler[ 4 ] = 105;
__kstrtab_mei_irq_read_handler[ 5 ] = 114;
__kstrtab_mei_irq_read_handler[ 6 ] = 113;
__kstrtab_mei_irq_read_handler[ 7 ] = 95;
__kstrtab_mei_irq_read_handler[ 8 ] = 114;
__kstrtab_mei_irq_read_handler[ 9 ] = 101;
__kstrtab_mei_irq_read_handler[ 10 ] = 97;
__kstrtab_mei_irq_read_handler[ 11 ] = 100;
__kstrtab_mei_irq_read_handler[ 12 ] = 95;
__kstrtab_mei_irq_read_handler[ 13 ] = 104;
__kstrtab_mei_irq_read_handler[ 14 ] = 97;
__kstrtab_mei_irq_read_handler[ 15 ] = 110;
__kstrtab_mei_irq_read_handler[ 16 ] = 100;
__kstrtab_mei_irq_read_handler[ 17 ] = 108;
__kstrtab_mei_irq_read_handler[ 18 ] = 101;
__kstrtab_mei_irq_read_handler[ 19 ] = 114;
__kstrtab_mei_irq_read_handler[ 20 ] = 0;
__ksymtab_mei_irq_read_handler.value = &(mei_irq_read_handler);
__ksymtab_mei_irq_read_handler.name = &(__kstrtab_mei_irq_read_handler);
__kstrtab_mei_irq_write_handler[ 0 ] = 109;
__kstrtab_mei_irq_write_handler[ 1 ] = 101;
__kstrtab_mei_irq_write_handler[ 2 ] = 105;
__kstrtab_mei_irq_write_handler[ 3 ] = 95;
__kstrtab_mei_irq_write_handler[ 4 ] = 105;
__kstrtab_mei_irq_write_handler[ 5 ] = 114;
__kstrtab_mei_irq_write_handler[ 6 ] = 113;
__kstrtab_mei_irq_write_handler[ 7 ] = 95;
__kstrtab_mei_irq_write_handler[ 8 ] = 119;
__kstrtab_mei_irq_write_handler[ 9 ] = 114;
__kstrtab_mei_irq_write_handler[ 10 ] = 105;
__kstrtab_mei_irq_write_handler[ 11 ] = 116;
__kstrtab_mei_irq_write_handler[ 12 ] = 101;
__kstrtab_mei_irq_write_handler[ 13 ] = 95;
__kstrtab_mei_irq_write_handler[ 14 ] = 104;
__kstrtab_mei_irq_write_handler[ 15 ] = 97;
__kstrtab_mei_irq_write_handler[ 16 ] = 110;
__kstrtab_mei_irq_write_handler[ 17 ] = 100;
__kstrtab_mei_irq_write_handler[ 18 ] = 108;
__kstrtab_mei_irq_write_handler[ 19 ] = 101;
__kstrtab_mei_irq_write_handler[ 20 ] = 114;
__kstrtab_mei_irq_write_handler[ 21 ] = 0;
__ksymtab_mei_irq_write_handler.value = &(mei_irq_write_handler);
__ksymtab_mei_irq_write_handler.name = &(__kstrtab_mei_irq_write_handler);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/client.o.i()
{
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/main.o.i()
{
704 -dev_attr_fw_status.attr.name = "fw_status";
dev_attr_fw_status.attr.mode = 292;
dev_attr_fw_status.attr.ignore_lockdep = 0;
dev_attr_fw_status.attr.key = 0;
dev_attr_fw_status.attr.skey.subkeys[ 0 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 1 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 2 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 3 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 4 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 5 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 6 ].__one_byte = 0;
dev_attr_fw_status.attr.skey.subkeys[ 7 ].__one_byte = 0;
dev_attr_fw_status.show = &(fw_status_show);
dev_attr_fw_status.store = 0;
mei_attrs[ 0 ] = &(&(dev_attr_fw_status))->attr;
mei_attrs[ 1 ] = 0;
mei_group.name = 0;
mei_group.is_visible = 0;
mei_group.is_bin_visible = 0;
mei_group.attrs = &(mei_attrs);
mei_group.bin_attrs = 0;
mei_groups[ 0 ] = &(mei_group);
mei_groups[ 1 ] = 0;
mei_fops.owner = &(__this_module);
mei_fops.llseek = &(no_llseek);
mei_fops.read = &(mei_read);
mei_fops.write = &(mei_write);
mei_fops.read_iter = 0;
mei_fops.write_iter = 0;
mei_fops.iterate = 0;
mei_fops.poll = &(mei_poll);
mei_fops.unlocked_ioctl = &(mei_ioctl);
mei_fops.compat_ioctl = &(mei_compat_ioctl);
mei_fops.mmap = 0;
mei_fops.open = &(mei_open);
mei_fops.flush = 0;
mei_fops.release = &(mei_release);
mei_fops.fsync = 0;
mei_fops.aio_fsync = 0;
mei_fops.fasync = &(mei_fasync);
mei_fops.lock = 0;
mei_fops.sendpage = 0;
mei_fops.get_unmapped_area = 0;
mei_fops.check_flags = 0;
mei_fops.flock = 0;
mei_fops.splice_write = 0;
mei_fops.splice_read = 0;
mei_fops.setlease = 0;
mei_fops.fallocate = 0;
mei_fops.show_fdinfo = 0;
mei_minor_lock.count.counter = 1;
mei_minor_lock.wait_lock.__annonCompField20.rlock.raw_lock.val.counter = 0;
mei_minor_lock.wait_lock.__annonCompField20.rlock.magic = 3735899821;
mei_minor_lock.wait_lock.__annonCompField20.rlock.owner_cpu = 4294967295;
mei_minor_lock.wait_lock.__annonCompField20.rlock.owner = -1;
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.key = 0;
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.class_cache[ 0 ] = 0;
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.class_cache[ 1 ] = 0;
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.name = "mei_minor_lock.wait_lock";
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.cpu = 0;
mei_minor_lock.wait_lock.__annonCompField20.rlock.dep_map.ip = 0;
mei_minor_lock.wait_list.next = &(&(mei_minor_lock))->wait_list;
mei_minor_lock.wait_list.prev = &(&(mei_minor_lock))->wait_list;
mei_minor_lock.owner = 0;
mei_minor_lock.magic = &(mei_minor_lock);
mei_minor_lock.dep_map.key = 0;
mei_minor_lock.dep_map.class_cache[ 0 ] = 0;
mei_minor_lock.dep_map.class_cache[ 1 ] = 0;
mei_minor_lock.dep_map.name = "mei_minor_lock";
mei_minor_lock.dep_map.cpu = 0;
mei_minor_lock.dep_map.ip = 0;
mei_idr.hint = 0;
mei_idr.top = 0;
mei_idr.layers = 0;
mei_idr.cur = 0;
mei_idr.lock.__annonCompField20.rlock.raw_lock.val.counter = 0;
mei_idr.lock.__annonCompField20.rlock.magic = 3735899821;
mei_idr.lock.__annonCompField20.rlock.owner_cpu = 4294967295;
mei_idr.lock.__annonCompField20.rlock.owner = -1;
mei_idr.lock.__annonCompField20.rlock.dep_map.key = 0;
mei_idr.lock.__annonCompField20.rlock.dep_map.class_cache[ 0 ] = 0;
mei_idr.lock.__annonCompField20.rlock.dep_map.class_cache[ 1 ] = 0;
mei_idr.lock.__annonCompField20.rlock.dep_map.name = "mei_idr.lock";
mei_idr.lock.__annonCompField20.rlock.dep_map.cpu = 0;
mei_idr.lock.__annonCompField20.rlock.dep_map.ip = 0;
mei_idr.id_free_cnt = 0;
mei_idr.id_free = 0;
__kstrtab_mei_register[ 0 ] = 109;
__kstrtab_mei_register[ 1 ] = 101;
__kstrtab_mei_register[ 2 ] = 105;
__kstrtab_mei_register[ 3 ] = 95;
__kstrtab_mei_register[ 4 ] = 114;
__kstrtab_mei_register[ 5 ] = 101;
__kstrtab_mei_register[ 6 ] = 103;
__kstrtab_mei_register[ 7 ] = 105;
__kstrtab_mei_register[ 8 ] = 115;
__kstrtab_mei_register[ 9 ] = 116;
__kstrtab_mei_register[ 10 ] = 101;
__kstrtab_mei_register[ 11 ] = 114;
__kstrtab_mei_register[ 12 ] = 0;
__ksymtab_mei_register.value = &(mei_register);
__ksymtab_mei_register.name = &(__kstrtab_mei_register);
__kstrtab_mei_deregister[ 0 ] = 109;
__kstrtab_mei_deregister[ 1 ] = 101;
__kstrtab_mei_deregister[ 2 ] = 105;
__kstrtab_mei_deregister[ 3 ] = 95;
__kstrtab_mei_deregister[ 4 ] = 100;
__kstrtab_mei_deregister[ 5 ] = 101;
__kstrtab_mei_deregister[ 6 ] = 114;
__kstrtab_mei_deregister[ 7 ] = 101;
__kstrtab_mei_deregister[ 8 ] = 103;
__kstrtab_mei_deregister[ 9 ] = 105;
__kstrtab_mei_deregister[ 10 ] = 115;
__kstrtab_mei_deregister[ 11 ] = 116;
__kstrtab_mei_deregister[ 12 ] = 101;
__kstrtab_mei_deregister[ 13 ] = 114;
__kstrtab_mei_deregister[ 14 ] = 0;
__ksymtab_mei_deregister.value = &(mei_deregister);
__ksymtab_mei_deregister.name = &(__kstrtab_mei_deregister);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/amthif.o.i()
{
38 -mei_amthif_guid.b[ 0 ] = 40;
mei_amthif_guid.b[ 1 ] = 0;
mei_amthif_guid.b[ 2 ] = 248;
mei_amthif_guid.b[ 3 ] = 18;
mei_amthif_guid.b[ 4 ] = 183;
mei_amthif_guid.b[ 5 ] = 180;
mei_amthif_guid.b[ 6 ] = 45;
mei_amthif_guid.b[ 7 ] = 75;
mei_amthif_guid.b[ 8 ] = 172;
mei_amthif_guid.b[ 9 ] = 168;
mei_amthif_guid.b[ 10 ] = 70;
mei_amthif_guid.b[ 11 ] = 224;
mei_amthif_guid.b[ 12 ] = 255;
mei_amthif_guid.b[ 13 ] = 101;
mei_amthif_guid.b[ 14 ] = 129;
mei_amthif_guid.b[ 15 ] = 76;
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/wd.o.i()
{
30 -mei_start_wd_params[ 0 ] = 2;
mei_start_wd_params[ 1 ] = 18;
mei_start_wd_params[ 2 ] = 19;
mei_start_wd_params[ 3 ] = 16;
mei_stop_wd_params[ 0 ] = 2;
mei_stop_wd_params[ 1 ] = 2;
mei_stop_wd_params[ 2 ] = 20;
mei_stop_wd_params[ 3 ] = 16;
mei_wd_guid.b[ 0 ] = 111;
mei_wd_guid.b[ 1 ] = 154;
mei_wd_guid.b[ 2 ] = 183;
mei_wd_guid.b[ 3 ] = 5;
mei_wd_guid.b[ 4 ] = 40;
mei_wd_guid.b[ 5 ] = 70;
mei_wd_guid.b[ 6 ] = 127;
mei_wd_guid.b[ 7 ] = 77;
mei_wd_guid.b[ 8 ] = 137;
mei_wd_guid.b[ 9 ] = 157;
mei_wd_guid.b[ 10 ] = 169;
mei_wd_guid.b[ 11 ] = 21;
mei_wd_guid.b[ 12 ] = 20;
mei_wd_guid.b[ 13 ] = 203;
mei_wd_guid.b[ 14 ] = 50;
mei_wd_guid.b[ 15 ] = 171;
wd_ops.owner = &(__this_module);
wd_ops.start = &(mei_wd_ops_start);
wd_ops.stop = &(mei_wd_ops_stop);
wd_ops.ping = &(mei_wd_ops_ping);
wd_ops.status = 0;
wd_ops.set_timeout = &(mei_wd_ops_set_timeout);
wd_ops.get_timeleft = 0;
wd_ops.ref = 0;
wd_ops.unref = 0;
wd_ops.ioctl = 0;
wd_info.options = 33920;
wd_info.firmware_version = 0;
wd_info.identity[ 0 ] = 73;
wd_info.identity[ 1 ] = 78;
wd_info.identity[ 2 ] = 84;
wd_info.identity[ 3 ] = 67;
wd_info.identity[ 4 ] = 65;
wd_info.identity[ 5 ] = 77;
wd_info.identity[ 6 ] = 84;
wd_info.identity[ 7 ] = 0;
amt_wd_dev.id = 0;
amt_wd_dev.cdev.kobj.name = 0;
amt_wd_dev.cdev.kobj.entry.next = 0;
amt_wd_dev.cdev.kobj.entry.prev = 0;
amt_wd_dev.cdev.kobj.parent = 0;
amt_wd_dev.cdev.kobj.kset = 0;
amt_wd_dev.cdev.kobj.ktype = 0;
amt_wd_dev.cdev.kobj.sd = 0;
amt_wd_dev.cdev.kobj.kref.refcount.counter = 0;
amt_wd_dev.cdev.kobj.release.work.data.counter = 0;
amt_wd_dev.cdev.kobj.release.work.entry.next = 0;
amt_wd_dev.cdev.kobj.release.work.entry.prev = 0;
amt_wd_dev.cdev.kobj.release.work.func = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.key = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.class_cache[ 0 ] = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.class_cache[ 1 ] = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.name = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.cpu = 0;
amt_wd_dev.cdev.kobj.release.work.lockdep_map.ip = 0;
amt_wd_dev.cdev.kobj.release.timer.entry.next = 0;
amt_wd_dev.cdev.kobj.release.timer.entry.pprev = 0;
amt_wd_dev.cdev.kobj.release.timer.expires = 0;
amt_wd_dev.cdev.kobj.release.timer.function = 0;
amt_wd_dev.cdev.kobj.release.timer.data = 0;
amt_wd_dev.cdev.kobj.release.timer.flags = 0;
amt_wd_dev.cdev.kobj.release.timer.slack = 0;
amt_wd_dev.cdev.kobj.release.timer.start_pid = 0;
amt_wd_dev.cdev.kobj.release.timer.start_site = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 0 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 1 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 2 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 3 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 4 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 5 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 6 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 7 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 8 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 9 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 10 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 11 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 12 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 13 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 14 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.start_comm[ 15 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.key = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.class_cache[ 0 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.class_cache[ 1 ] = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.name = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.cpu = 0;
amt_wd_dev.cdev.kobj.release.timer.lockdep_map.ip = 0;
amt_wd_dev.cdev.kobj.release.wq = 0;
amt_wd_dev.cdev.kobj.release.cpu = 0;
amt_wd_dev.cdev.kobj.state_initialized = 0;
amt_wd_dev.cdev.kobj.state_in_sysfs = 0;
amt_wd_dev.cdev.kobj.state_add_uevent_sent = 0;
amt_wd_dev.cdev.kobj.state_remove_uevent_sent = 0;
amt_wd_dev.cdev.kobj.uevent_suppress = 0;
amt_wd_dev.cdev.owner = 0;
amt_wd_dev.cdev.ops = 0;
amt_wd_dev.cdev.list.next = 0;
amt_wd_dev.cdev.list.prev = 0;
amt_wd_dev.cdev.dev = 0;
amt_wd_dev.cdev.count = 0;
amt_wd_dev.dev = 0;
amt_wd_dev.parent = 0;
amt_wd_dev.info = &(wd_info);
amt_wd_dev.ops = &(wd_ops);
amt_wd_dev.bootstatus = 0;
amt_wd_dev.timeout = 120;
amt_wd_dev.min_timeout = 120;
amt_wd_dev.max_timeout = 65535;
amt_wd_dev.driver_data = 0;
amt_wd_dev.lock.count.counter = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.raw_lock.val.counter = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.magic = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.owner_cpu = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.owner = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.key = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.class_cache[ 0 ] = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.class_cache[ 1 ] = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.name = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.cpu = 0;
amt_wd_dev.lock.wait_lock.__annonCompField20.rlock.dep_map.ip = 0;
amt_wd_dev.lock.wait_list.next = 0;
amt_wd_dev.lock.wait_list.prev = 0;
amt_wd_dev.lock.owner = 0;
amt_wd_dev.lock.magic = 0;
amt_wd_dev.lock.dep_map.key = 0;
amt_wd_dev.lock.dep_map.class_cache[ 0 ] = 0;
amt_wd_dev.lock.dep_map.class_cache[ 1 ] = 0;
amt_wd_dev.lock.dep_map.name = 0;
amt_wd_dev.lock.dep_map.cpu = 0;
amt_wd_dev.lock.dep_map.ip = 0;
amt_wd_dev.status = 0;
amt_wd_dev.deferred.next = 0;
amt_wd_dev.deferred.prev = 0;
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/bus.o.i()
{
186 -__kstrtab_mei_cldev_send[ 0 ] = 109;
__kstrtab_mei_cldev_send[ 1 ] = 101;
__kstrtab_mei_cldev_send[ 2 ] = 105;
__kstrtab_mei_cldev_send[ 3 ] = 95;
__kstrtab_mei_cldev_send[ 4 ] = 99;
__kstrtab_mei_cldev_send[ 5 ] = 108;
__kstrtab_mei_cldev_send[ 6 ] = 100;
__kstrtab_mei_cldev_send[ 7 ] = 101;
__kstrtab_mei_cldev_send[ 8 ] = 118;
__kstrtab_mei_cldev_send[ 9 ] = 95;
__kstrtab_mei_cldev_send[ 10 ] = 115;
__kstrtab_mei_cldev_send[ 11 ] = 101;
__kstrtab_mei_cldev_send[ 12 ] = 110;
__kstrtab_mei_cldev_send[ 13 ] = 100;
__kstrtab_mei_cldev_send[ 14 ] = 0;
__ksymtab_mei_cldev_send.value = &(mei_cldev_send);
__ksymtab_mei_cldev_send.name = &(__kstrtab_mei_cldev_send);
__kstrtab_mei_cldev_recv[ 0 ] = 109;
__kstrtab_mei_cldev_recv[ 1 ] = 101;
__kstrtab_mei_cldev_recv[ 2 ] = 105;
__kstrtab_mei_cldev_recv[ 3 ] = 95;
__kstrtab_mei_cldev_recv[ 4 ] = 99;
__kstrtab_mei_cldev_recv[ 5 ] = 108;
__kstrtab_mei_cldev_recv[ 6 ] = 100;
__kstrtab_mei_cldev_recv[ 7 ] = 101;
__kstrtab_mei_cldev_recv[ 8 ] = 118;
__kstrtab_mei_cldev_recv[ 9 ] = 95;
__kstrtab_mei_cldev_recv[ 10 ] = 114;
__kstrtab_mei_cldev_recv[ 11 ] = 101;
__kstrtab_mei_cldev_recv[ 12 ] = 99;
__kstrtab_mei_cldev_recv[ 13 ] = 118;
__kstrtab_mei_cldev_recv[ 14 ] = 0;
__ksymtab_mei_cldev_recv.value = &(mei_cldev_recv);
__ksymtab_mei_cldev_recv.name = &(__kstrtab_mei_cldev_recv);
__kstrtab_mei_cldev_register_event_cb[ 0 ] = 109;
__kstrtab_mei_cldev_register_event_cb[ 1 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 2 ] = 105;
__kstrtab_mei_cldev_register_event_cb[ 3 ] = 95;
__kstrtab_mei_cldev_register_event_cb[ 4 ] = 99;
__kstrtab_mei_cldev_register_event_cb[ 5 ] = 108;
__kstrtab_mei_cldev_register_event_cb[ 6 ] = 100;
__kstrtab_mei_cldev_register_event_cb[ 7 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 8 ] = 118;
__kstrtab_mei_cldev_register_event_cb[ 9 ] = 95;
__kstrtab_mei_cldev_register_event_cb[ 10 ] = 114;
__kstrtab_mei_cldev_register_event_cb[ 11 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 12 ] = 103;
__kstrtab_mei_cldev_register_event_cb[ 13 ] = 105;
__kstrtab_mei_cldev_register_event_cb[ 14 ] = 115;
__kstrtab_mei_cldev_register_event_cb[ 15 ] = 116;
__kstrtab_mei_cldev_register_event_cb[ 16 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 17 ] = 114;
__kstrtab_mei_cldev_register_event_cb[ 18 ] = 95;
__kstrtab_mei_cldev_register_event_cb[ 19 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 20 ] = 118;
__kstrtab_mei_cldev_register_event_cb[ 21 ] = 101;
__kstrtab_mei_cldev_register_event_cb[ 22 ] = 110;
__kstrtab_mei_cldev_register_event_cb[ 23 ] = 116;
__kstrtab_mei_cldev_register_event_cb[ 24 ] = 95;
__kstrtab_mei_cldev_register_event_cb[ 25 ] = 99;
__kstrtab_mei_cldev_register_event_cb[ 26 ] = 98;
__kstrtab_mei_cldev_register_event_cb[ 27 ] = 0;
__ksymtab_mei_cldev_register_event_cb.value = &(mei_cldev_register_event_cb);
__ksymtab_mei_cldev_register_event_cb.name = &(__kstrtab_mei_cldev_register_event_cb);
__kstrtab_mei_cldev_get_drvdata[ 0 ] = 109;
__kstrtab_mei_cldev_get_drvdata[ 1 ] = 101;
__kstrtab_mei_cldev_get_drvdata[ 2 ] = 105;
__kstrtab_mei_cldev_get_drvdata[ 3 ] = 95;
__kstrtab_mei_cldev_get_drvdata[ 4 ] = 99;
__kstrtab_mei_cldev_get_drvdata[ 5 ] = 108;
__kstrtab_mei_cldev_get_drvdata[ 6 ] = 100;
__kstrtab_mei_cldev_get_drvdata[ 7 ] = 101;
__kstrtab_mei_cldev_get_drvdata[ 8 ] = 118;
__kstrtab_mei_cldev_get_drvdata[ 9 ] = 95;
__kstrtab_mei_cldev_get_drvdata[ 10 ] = 103;
__kstrtab_mei_cldev_get_drvdata[ 11 ] = 101;
__kstrtab_mei_cldev_get_drvdata[ 12 ] = 116;
__kstrtab_mei_cldev_get_drvdata[ 13 ] = 95;
__kstrtab_mei_cldev_get_drvdata[ 14 ] = 100;
__kstrtab_mei_cldev_get_drvdata[ 15 ] = 114;
__kstrtab_mei_cldev_get_drvdata[ 16 ] = 118;
__kstrtab_mei_cldev_get_drvdata[ 17 ] = 100;
__kstrtab_mei_cldev_get_drvdata[ 18 ] = 97;
__kstrtab_mei_cldev_get_drvdata[ 19 ] = 116;
__kstrtab_mei_cldev_get_drvdata[ 20 ] = 97;
__kstrtab_mei_cldev_get_drvdata[ 21 ] = 0;
__ksymtab_mei_cldev_get_drvdata.value = &(mei_cldev_get_drvdata);
__ksymtab_mei_cldev_get_drvdata.name = &(__kstrtab_mei_cldev_get_drvdata);
__kstrtab_mei_cldev_set_drvdata[ 0 ] = 109;
__kstrtab_mei_cldev_set_drvdata[ 1 ] = 101;
__kstrtab_mei_cldev_set_drvdata[ 2 ] = 105;
__kstrtab_mei_cldev_set_drvdata[ 3 ] = 95;
__kstrtab_mei_cldev_set_drvdata[ 4 ] = 99;
__kstrtab_mei_cldev_set_drvdata[ 5 ] = 108;
__kstrtab_mei_cldev_set_drvdata[ 6 ] = 100;
__kstrtab_mei_cldev_set_drvdata[ 7 ] = 101;
__kstrtab_mei_cldev_set_drvdata[ 8 ] = 118;
__kstrtab_mei_cldev_set_drvdata[ 9 ] = 95;
__kstrtab_mei_cldev_set_drvdata[ 10 ] = 115;
__kstrtab_mei_cldev_set_drvdata[ 11 ] = 101;
__kstrtab_mei_cldev_set_drvdata[ 12 ] = 116;
__kstrtab_mei_cldev_set_drvdata[ 13 ] = 95;
__kstrtab_mei_cldev_set_drvdata[ 14 ] = 100;
__kstrtab_mei_cldev_set_drvdata[ 15 ] = 114;
__kstrtab_mei_cldev_set_drvdata[ 16 ] = 118;
__kstrtab_mei_cldev_set_drvdata[ 17 ] = 100;
__kstrtab_mei_cldev_set_drvdata[ 18 ] = 97;
__kstrtab_mei_cldev_set_drvdata[ 19 ] = 116;
__kstrtab_mei_cldev_set_drvdata[ 20 ] = 97;
__kstrtab_mei_cldev_set_drvdata[ 21 ] = 0;
__ksymtab_mei_cldev_set_drvdata.value = &(mei_cldev_set_drvdata);
__ksymtab_mei_cldev_set_drvdata.name = &(__kstrtab_mei_cldev_set_drvdata);
__kstrtab_mei_cldev_uuid[ 0 ] = 109;
__kstrtab_mei_cldev_uuid[ 1 ] = 101;
__kstrtab_mei_cldev_uuid[ 2 ] = 105;
__kstrtab_mei_cldev_uuid[ 3 ] = 95;
__kstrtab_mei_cldev_uuid[ 4 ] = 99;
__kstrtab_mei_cldev_uuid[ 5 ] = 108;
__kstrtab_mei_cldev_uuid[ 6 ] = 100;
__kstrtab_mei_cldev_uuid[ 7 ] = 101;
__kstrtab_mei_cldev_uuid[ 8 ] = 118;
__kstrtab_mei_cldev_uuid[ 9 ] = 95;
__kstrtab_mei_cldev_uuid[ 10 ] = 117;
__kstrtab_mei_cldev_uuid[ 11 ] = 117;
__kstrtab_mei_cldev_uuid[ 12 ] = 105;
__kstrtab_mei_cldev_uuid[ 13 ] = 100;
__kstrtab_mei_cldev_uuid[ 14 ] = 0;
__ksymtab_mei_cldev_uuid.value = &(mei_cldev_uuid);
__ksymtab_mei_cldev_uuid.name = &(__kstrtab_mei_cldev_uuid);
__kstrtab_mei_cldev_ver[ 0 ] = 109;
__kstrtab_mei_cldev_ver[ 1 ] = 101;
__kstrtab_mei_cldev_ver[ 2 ] = 105;
__kstrtab_mei_cldev_ver[ 3 ] = 95;
__kstrtab_mei_cldev_ver[ 4 ] = 99;
__kstrtab_mei_cldev_ver[ 5 ] = 108;
__kstrtab_mei_cldev_ver[ 6 ] = 100;
__kstrtab_mei_cldev_ver[ 7 ] = 101;
__kstrtab_mei_cldev_ver[ 8 ] = 118;
__kstrtab_mei_cldev_ver[ 9 ] = 95;
__kstrtab_mei_cldev_ver[ 10 ] = 118;
__kstrtab_mei_cldev_ver[ 11 ] = 101;
__kstrtab_mei_cldev_ver[ 12 ] = 114;
__kstrtab_mei_cldev_ver[ 13 ] = 0;
__ksymtab_mei_cldev_ver.value = &(mei_cldev_ver);
__ksymtab_mei_cldev_ver.name = &(__kstrtab_mei_cldev_ver);
__kstrtab_mei_cldev_enabled[ 0 ] = 109;
__kstrtab_mei_cldev_enabled[ 1 ] = 101;
__kstrtab_mei_cldev_enabled[ 2 ] = 105;
__kstrtab_mei_cldev_enabled[ 3 ] = 95;
__kstrtab_mei_cldev_enabled[ 4 ] = 99;
__kstrtab_mei_cldev_enabled[ 5 ] = 108;
__kstrtab_mei_cldev_enabled[ 6 ] = 100;
__kstrtab_mei_cldev_enabled[ 7 ] = 101;
__kstrtab_mei_cldev_enabled[ 8 ] = 118;
__kstrtab_mei_cldev_enabled[ 9 ] = 95;
__kstrtab_mei_cldev_enabled[ 10 ] = 101;
__kstrtab_mei_cldev_enabled[ 11 ] = 110;
__kstrtab_mei_cldev_enabled[ 12 ] = 97;
__kstrtab_mei_cldev_enabled[ 13 ] = 98;
__kstrtab_mei_cldev_enabled[ 14 ] = 108;
__kstrtab_mei_cldev_enabled[ 15 ] = 101;
__kstrtab_mei_cldev_enabled[ 16 ] = 100;
__kstrtab_mei_cldev_enabled[ 17 ] = 0;
__ksymtab_mei_cldev_enabled.value = &(mei_cldev_enabled);
__ksymtab_mei_cldev_enabled.name = &(__kstrtab_mei_cldev_enabled);
__kstrtab_mei_cldev_enable[ 0 ] = 109;
__kstrtab_mei_cldev_enable[ 1 ] = 101;
__kstrtab_mei_cldev_enable[ 2 ] = 105;
__kstrtab_mei_cldev_enable[ 3 ] = 95;
__kstrtab_mei_cldev_enable[ 4 ] = 99;
__kstrtab_mei_cldev_enable[ 5 ] = 108;
__kstrtab_mei_cldev_enable[ 6 ] = 100;
__kstrtab_mei_cldev_enable[ 7 ] = 101;
__kstrtab_mei_cldev_enable[ 8 ] = 118;
__kstrtab_mei_cldev_enable[ 9 ] = 95;
__kstrtab_mei_cldev_enable[ 10 ] = 101;
__kstrtab_mei_cldev_enable[ 11 ] = 110;
__kstrtab_mei_cldev_enable[ 12 ] = 97;
__kstrtab_mei_cldev_enable[ 13 ] = 98;
__kstrtab_mei_cldev_enable[ 14 ] = 108;
__kstrtab_mei_cldev_enable[ 15 ] = 101;
__kstrtab_mei_cldev_enable[ 16 ] = 0;
__ksymtab_mei_cldev_enable.value = &(mei_cldev_enable);
__ksymtab_mei_cldev_enable.name = &(__kstrtab_mei_cldev_enable);
__kstrtab_mei_cldev_disable[ 0 ] = 109;
__kstrtab_mei_cldev_disable[ 1 ] = 101;
__kstrtab_mei_cldev_disable[ 2 ] = 105;
__kstrtab_mei_cldev_disable[ 3 ] = 95;
__kstrtab_mei_cldev_disable[ 4 ] = 99;
__kstrtab_mei_cldev_disable[ 5 ] = 108;
__kstrtab_mei_cldev_disable[ 6 ] = 100;
__kstrtab_mei_cldev_disable[ 7 ] = 101;
__kstrtab_mei_cldev_disable[ 8 ] = 118;
__kstrtab_mei_cldev_disable[ 9 ] = 95;
__kstrtab_mei_cldev_disable[ 10 ] = 100;
__kstrtab_mei_cldev_disable[ 11 ] = 105;
__kstrtab_mei_cldev_disable[ 12 ] = 115;
__kstrtab_mei_cldev_disable[ 13 ] = 97;
__kstrtab_mei_cldev_disable[ 14 ] = 98;
__kstrtab_mei_cldev_disable[ 15 ] = 108;
__kstrtab_mei_cldev_disable[ 16 ] = 101;
__kstrtab_mei_cldev_disable[ 17 ] = 0;
__ksymtab_mei_cldev_disable.value = &(mei_cldev_disable);
__ksymtab_mei_cldev_disable.name = &(__kstrtab_mei_cldev_disable);
dev_attr_name.attr.name = "name";
dev_attr_name.attr.mode = 292;
dev_attr_name.attr.ignore_lockdep = 0;
dev_attr_name.attr.key = 0;
dev_attr_name.attr.skey.subkeys[ 0 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 1 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 2 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 3 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 4 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 5 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 6 ].__one_byte = 0;
dev_attr_name.attr.skey.subkeys[ 7 ].__one_byte = 0;
dev_attr_name.show = &(name_show);
dev_attr_name.store = 0;
dev_attr_uuid.attr.name = "uuid";
dev_attr_uuid.attr.mode = 292;
dev_attr_uuid.attr.ignore_lockdep = 0;
dev_attr_uuid.attr.key = 0;
dev_attr_uuid.attr.skey.subkeys[ 0 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 1 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 2 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 3 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 4 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 5 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 6 ].__one_byte = 0;
dev_attr_uuid.attr.skey.subkeys[ 7 ].__one_byte = 0;
dev_attr_uuid.show = &(uuid_show);
dev_attr_uuid.store = 0;
dev_attr_version.attr.name = "version";
dev_attr_version.attr.mode = 292;
dev_attr_version.attr.ignore_lockdep = 0;
dev_attr_version.attr.key = 0;
dev_attr_version.attr.skey.subkeys[ 0 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 1 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 2 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 3 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 4 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 5 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 6 ].__one_byte = 0;
dev_attr_version.attr.skey.subkeys[ 7 ].__one_byte = 0;
dev_attr_version.show = &(version_show);
dev_attr_version.store = 0;
dev_attr_modalias.attr.name = "modalias";
dev_attr_modalias.attr.mode = 292;
dev_attr_modalias.attr.ignore_lockdep = 0;
dev_attr_modalias.attr.key = 0;
dev_attr_modalias.attr.skey.subkeys[ 0 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 1 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 2 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 3 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 4 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 5 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 6 ].__one_byte = 0;
dev_attr_modalias.attr.skey.subkeys[ 7 ].__one_byte = 0;
dev_attr_modalias.show = &(modalias_show);
dev_attr_modalias.store = 0;
mei_cldev_attrs[ 0 ] = &(&(dev_attr_name))->attr;
mei_cldev_attrs[ 1 ] = &(&(dev_attr_uuid))->attr;
mei_cldev_attrs[ 2 ] = &(&(dev_attr_version))->attr;
mei_cldev_attrs[ 3 ] = &(&(dev_attr_modalias))->attr;
mei_cldev_attrs[ 4 ] = 0;
mei_cldev_group.name = 0;
mei_cldev_group.is_visible = 0;
mei_cldev_group.is_bin_visible = 0;
mei_cldev_group.attrs = &(mei_cldev_attrs);
mei_cldev_group.bin_attrs = 0;
mei_cldev_groups[ 0 ] = &(mei_cldev_group);
mei_cldev_groups[ 1 ] = 0;
mei_cl_bus_type.name = "mei";
mei_cl_bus_type.dev_name = 0;
mei_cl_bus_type.dev_root = 0;
mei_cl_bus_type.dev_attrs = 0;
mei_cl_bus_type.bus_groups = 0;
mei_cl_bus_type.dev_groups = &(mei_cldev_groups);
mei_cl_bus_type.drv_groups = 0;
mei_cl_bus_type.match = &(mei_cl_device_match);
mei_cl_bus_type.uevent = &(mei_cl_device_uevent);
mei_cl_bus_type.probe = &(mei_cl_device_probe);
mei_cl_bus_type.remove = &(mei_cl_device_remove);
mei_cl_bus_type.shutdown = 0;
mei_cl_bus_type.online = 0;
mei_cl_bus_type.offline = 0;
mei_cl_bus_type.suspend = 0;
mei_cl_bus_type.resume = 0;
mei_cl_bus_type.pm = 0;
mei_cl_bus_type.iommu_ops = 0;
mei_cl_bus_type.p = 0;
mei_cl_bus_type.lock_key.subkeys[ 0 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 1 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 2 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 3 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 4 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 5 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 6 ].__one_byte = 0;
mei_cl_bus_type.lock_key.subkeys[ 7 ].__one_byte = 0;
mei_cl_device_type.name = 0;
mei_cl_device_type.groups = 0;
mei_cl_device_type.uevent = 0;
mei_cl_device_type.devnode = 0;
mei_cl_device_type.release = &(mei_cl_bus_dev_release);
mei_cl_device_type.pm = 0;
__kstrtab___mei_cldev_driver_register[ 0 ] = 95;
__kstrtab___mei_cldev_driver_register[ 1 ] = 95;
__kstrtab___mei_cldev_driver_register[ 2 ] = 109;
__kstrtab___mei_cldev_driver_register[ 3 ] = 101;
__kstrtab___mei_cldev_driver_register[ 4 ] = 105;
__kstrtab___mei_cldev_driver_register[ 5 ] = 95;
__kstrtab___mei_cldev_driver_register[ 6 ] = 99;
__kstrtab___mei_cldev_driver_register[ 7 ] = 108;
__kstrtab___mei_cldev_driver_register[ 8 ] = 100;
__kstrtab___mei_cldev_driver_register[ 9 ] = 101;
__kstrtab___mei_cldev_driver_register[ 10 ] = 118;
__kstrtab___mei_cldev_driver_register[ 11 ] = 95;
__kstrtab___mei_cldev_driver_register[ 12 ] = 100;
__kstrtab___mei_cldev_driver_register[ 13 ] = 114;
__kstrtab___mei_cldev_driver_register[ 14 ] = 105;
__kstrtab___mei_cldev_driver_register[ 15 ] = 118;
__kstrtab___mei_cldev_driver_register[ 16 ] = 101;
__kstrtab___mei_cldev_driver_register[ 17 ] = 114;
__kstrtab___mei_cldev_driver_register[ 18 ] = 95;
__kstrtab___mei_cldev_driver_register[ 19 ] = 114;
__kstrtab___mei_cldev_driver_register[ 20 ] = 101;
__kstrtab___mei_cldev_driver_register[ 21 ] = 103;
__kstrtab___mei_cldev_driver_register[ 22 ] = 105;
__kstrtab___mei_cldev_driver_register[ 23 ] = 115;
__kstrtab___mei_cldev_driver_register[ 24 ] = 116;
__kstrtab___mei_cldev_driver_register[ 25 ] = 101;
__kstrtab___mei_cldev_driver_register[ 26 ] = 114;
__kstrtab___mei_cldev_driver_register[ 27 ] = 0;
__ksymtab___mei_cldev_driver_register.value = &(__mei_cldev_driver_register);
__ksymtab___mei_cldev_driver_register.name = &(__kstrtab___mei_cldev_driver_register);
__kstrtab_mei_cldev_driver_unregister[ 0 ] = 109;
__kstrtab_mei_cldev_driver_unregister[ 1 ] = 101;
__kstrtab_mei_cldev_driver_unregister[ 2 ] = 105;
__kstrtab_mei_cldev_driver_unregister[ 3 ] = 95;
__kstrtab_mei_cldev_driver_unregister[ 4 ] = 99;
__kstrtab_mei_cldev_driver_unregister[ 5 ] = 108;
__kstrtab_mei_cldev_driver_unregister[ 6 ] = 100;
__kstrtab_mei_cldev_driver_unregister[ 7 ] = 101;
__kstrtab_mei_cldev_driver_unregister[ 8 ] = 118;
__kstrtab_mei_cldev_driver_unregister[ 9 ] = 95;
__kstrtab_mei_cldev_driver_unregister[ 10 ] = 100;
__kstrtab_mei_cldev_driver_unregister[ 11 ] = 114;
__kstrtab_mei_cldev_driver_unregister[ 12 ] = 105;
__kstrtab_mei_cldev_driver_unregister[ 13 ] = 118;
__kstrtab_mei_cldev_driver_unregister[ 14 ] = 101;
__kstrtab_mei_cldev_driver_unregister[ 15 ] = 114;
__kstrtab_mei_cldev_driver_unregister[ 16 ] = 95;
__kstrtab_mei_cldev_driver_unregister[ 17 ] = 117;
__kstrtab_mei_cldev_driver_unregister[ 18 ] = 110;
__kstrtab_mei_cldev_driver_unregister[ 19 ] = 114;
__kstrtab_mei_cldev_driver_unregister[ 20 ] = 101;
__kstrtab_mei_cldev_driver_unregister[ 21 ] = 103;
__kstrtab_mei_cldev_driver_unregister[ 22 ] = 105;
__kstrtab_mei_cldev_driver_unregister[ 23 ] = 115;
__kstrtab_mei_cldev_driver_unregister[ 24 ] = 116;
__kstrtab_mei_cldev_driver_unregister[ 25 ] = 101;
__kstrtab_mei_cldev_driver_unregister[ 26 ] = 114;
__kstrtab_mei_cldev_driver_unregister[ 27 ] = 0;
__ksymtab_mei_cldev_driver_unregister.value = &(mei_cldev_driver_unregister);
__ksymtab_mei_cldev_driver_unregister.name = &(__kstrtab_mei_cldev_driver_unregister);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/bus-fixup.o.i()
{
34 -mei_nfc_info_guid.b[ 0 ] = 37;
mei_nfc_info_guid.b[ 1 ] = 22;
mei_nfc_info_guid.b[ 2 ] = 222;
mei_nfc_info_guid.b[ 3 ] = 210;
mei_nfc_info_guid.b[ 4 ] = 45;
mei_nfc_info_guid.b[ 5 ] = 56;
mei_nfc_info_guid.b[ 6 ] = 125;
mei_nfc_info_guid.b[ 7 ] = 65;
mei_nfc_info_guid.b[ 8 ] = 72;
mei_nfc_info_guid.b[ 9 ] = 164;
mei_nfc_info_guid.b[ 10 ] = 239;
mei_nfc_info_guid.b[ 11 ] = 171;
mei_nfc_info_guid.b[ 12 ] = 186;
mei_nfc_info_guid.b[ 13 ] = 138;
mei_nfc_info_guid.b[ 14 ] = 18;
mei_nfc_info_guid.b[ 15 ] = 6;
mei_fixups[ 0 ].uuid.b[ 0 ] = 0;
mei_fixups[ 0 ].uuid.b[ 1 ] = 0;
mei_fixups[ 0 ].uuid.b[ 2 ] = 0;
mei_fixups[ 0 ].uuid.b[ 3 ] = 0;
mei_fixups[ 0 ].uuid.b[ 4 ] = 0;
mei_fixups[ 0 ].uuid.b[ 5 ] = 0;
mei_fixups[ 0 ].uuid.b[ 6 ] = 0;
mei_fixups[ 0 ].uuid.b[ 7 ] = 0;
mei_fixups[ 0 ].uuid.b[ 8 ] = 0;
mei_fixups[ 0 ].uuid.b[ 9 ] = 0;
mei_fixups[ 0 ].uuid.b[ 10 ] = 0;
mei_fixups[ 0 ].uuid.b[ 11 ] = 0;
mei_fixups[ 0 ].uuid.b[ 12 ] = 0;
mei_fixups[ 0 ].uuid.b[ 13 ] = 0;
mei_fixups[ 0 ].uuid.b[ 14 ] = 0;
mei_fixups[ 0 ].uuid.b[ 15 ] = 0;
mei_fixups[ 0 ].hook = &(number_of_connections);
mei_fixups[ 1 ].uuid.b[ 0 ] = 37;
mei_fixups[ 1 ].uuid.b[ 1 ] = 22;
mei_fixups[ 1 ].uuid.b[ 2 ] = 222;
mei_fixups[ 1 ].uuid.b[ 3 ] = 210;
mei_fixups[ 1 ].uuid.b[ 4 ] = 45;
mei_fixups[ 1 ].uuid.b[ 5 ] = 56;
mei_fixups[ 1 ].uuid.b[ 6 ] = 125;
mei_fixups[ 1 ].uuid.b[ 7 ] = 65;
mei_fixups[ 1 ].uuid.b[ 8 ] = 72;
mei_fixups[ 1 ].uuid.b[ 9 ] = 164;
mei_fixups[ 1 ].uuid.b[ 10 ] = 239;
mei_fixups[ 1 ].uuid.b[ 11 ] = 171;
mei_fixups[ 1 ].uuid.b[ 12 ] = 186;
mei_fixups[ 1 ].uuid.b[ 13 ] = 138;
mei_fixups[ 1 ].uuid.b[ 14 ] = 18;
mei_fixups[ 1 ].uuid.b[ 15 ] = 6;
mei_fixups[ 1 ].hook = &(blacklist);
mei_fixups[ 2 ].uuid.b[ 0 ] = 120;
mei_fixups[ 2 ].uuid.b[ 1 ] = 122;
mei_fixups[ 2 ].uuid.b[ 2 ] = 177;
mei_fixups[ 2 ].uuid.b[ 3 ] = 11;
mei_fixups[ 2 ].uuid.b[ 4 ] = 142;
mei_fixups[ 2 ].uuid.b[ 5 ] = 42;
mei_fixups[ 2 ].uuid.b[ 6 ] = 80;
mei_fixups[ 2 ].uuid.b[ 7 ] = 76;
mei_fixups[ 2 ].uuid.b[ 8 ] = 148;
mei_fixups[ 2 ].uuid.b[ 9 ] = 212;
mei_fixups[ 2 ].uuid.b[ 10 ] = 80;
mei_fixups[ 2 ].uuid.b[ 11 ] = 38;
mei_fixups[ 2 ].uuid.b[ 12 ] = 103;
mei_fixups[ 2 ].uuid.b[ 13 ] = 35;
mei_fixups[ 2 ].uuid.b[ 14 ] = 119;
mei_fixups[ 2 ].uuid.b[ 15 ] = 92;
mei_fixups[ 2 ].hook = &(mei_nfc);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/debugfs.o.i()
{
83 -mei_dbgfs_fops_meclients.owner = 0;
mei_dbgfs_fops_meclients.llseek = &(generic_file_llseek);
mei_dbgfs_fops_meclients.read = &(mei_dbgfs_read_meclients);
mei_dbgfs_fops_meclients.write = 0;
mei_dbgfs_fops_meclients.read_iter = 0;
mei_dbgfs_fops_meclients.write_iter = 0;
mei_dbgfs_fops_meclients.iterate = 0;
mei_dbgfs_fops_meclients.poll = 0;
mei_dbgfs_fops_meclients.unlocked_ioctl = 0;
mei_dbgfs_fops_meclients.compat_ioctl = 0;
mei_dbgfs_fops_meclients.mmap = 0;
mei_dbgfs_fops_meclients.open = &(simple_open);
mei_dbgfs_fops_meclients.flush = 0;
mei_dbgfs_fops_meclients.release = 0;
mei_dbgfs_fops_meclients.fsync = 0;
mei_dbgfs_fops_meclients.aio_fsync = 0;
mei_dbgfs_fops_meclients.fasync = 0;
mei_dbgfs_fops_meclients.lock = 0;
mei_dbgfs_fops_meclients.sendpage = 0;
mei_dbgfs_fops_meclients.get_unmapped_area = 0;
mei_dbgfs_fops_meclients.check_flags = 0;
mei_dbgfs_fops_meclients.flock = 0;
mei_dbgfs_fops_meclients.splice_write = 0;
mei_dbgfs_fops_meclients.splice_read = 0;
mei_dbgfs_fops_meclients.setlease = 0;
mei_dbgfs_fops_meclients.fallocate = 0;
mei_dbgfs_fops_meclients.show_fdinfo = 0;
mei_dbgfs_fops_active.owner = 0;
mei_dbgfs_fops_active.llseek = &(generic_file_llseek);
mei_dbgfs_fops_active.read = &(mei_dbgfs_read_active);
mei_dbgfs_fops_active.write = 0;
mei_dbgfs_fops_active.read_iter = 0;
mei_dbgfs_fops_active.write_iter = 0;
mei_dbgfs_fops_active.iterate = 0;
mei_dbgfs_fops_active.poll = 0;
mei_dbgfs_fops_active.unlocked_ioctl = 0;
mei_dbgfs_fops_active.compat_ioctl = 0;
mei_dbgfs_fops_active.mmap = 0;
mei_dbgfs_fops_active.open = &(simple_open);
mei_dbgfs_fops_active.flush = 0;
mei_dbgfs_fops_active.release = 0;
mei_dbgfs_fops_active.fsync = 0;
mei_dbgfs_fops_active.aio_fsync = 0;
mei_dbgfs_fops_active.fasync = 0;
mei_dbgfs_fops_active.lock = 0;
mei_dbgfs_fops_active.sendpage = 0;
mei_dbgfs_fops_active.get_unmapped_area = 0;
mei_dbgfs_fops_active.check_flags = 0;
mei_dbgfs_fops_active.flock = 0;
mei_dbgfs_fops_active.splice_write = 0;
mei_dbgfs_fops_active.splice_read = 0;
mei_dbgfs_fops_active.setlease = 0;
mei_dbgfs_fops_active.fallocate = 0;
mei_dbgfs_fops_active.show_fdinfo = 0;
mei_dbgfs_fops_devstate.owner = 0;
mei_dbgfs_fops_devstate.llseek = &(generic_file_llseek);
mei_dbgfs_fops_devstate.read = &(mei_dbgfs_read_devstate);
mei_dbgfs_fops_devstate.write = 0;
mei_dbgfs_fops_devstate.read_iter = 0;
mei_dbgfs_fops_devstate.write_iter = 0;
mei_dbgfs_fops_devstate.iterate = 0;
mei_dbgfs_fops_devstate.poll = 0;
mei_dbgfs_fops_devstate.unlocked_ioctl = 0;
mei_dbgfs_fops_devstate.compat_ioctl = 0;
mei_dbgfs_fops_devstate.mmap = 0;
mei_dbgfs_fops_devstate.open = &(simple_open);
mei_dbgfs_fops_devstate.flush = 0;
mei_dbgfs_fops_devstate.release = 0;
mei_dbgfs_fops_devstate.fsync = 0;
mei_dbgfs_fops_devstate.aio_fsync = 0;
mei_dbgfs_fops_devstate.fasync = 0;
mei_dbgfs_fops_devstate.lock = 0;
mei_dbgfs_fops_devstate.sendpage = 0;
mei_dbgfs_fops_devstate.get_unmapped_area = 0;
mei_dbgfs_fops_devstate.check_flags = 0;
mei_dbgfs_fops_devstate.flock = 0;
mei_dbgfs_fops_devstate.splice_write = 0;
mei_dbgfs_fops_devstate.splice_read = 0;
mei_dbgfs_fops_devstate.setlease = 0;
mei_dbgfs_fops_devstate.fallocate = 0;
mei_dbgfs_fops_devstate.show_fdinfo = 0;
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/misc/mei/mei-trace.o.i()
{
46 -__tpstrtab_mei_reg_read[ 0 ] = 109;
__tpstrtab_mei_reg_read[ 1 ] = 101;
__tpstrtab_mei_reg_read[ 2 ] = 105;
__tpstrtab_mei_reg_read[ 3 ] = 95;
__tpstrtab_mei_reg_read[ 4 ] = 114;
__tpstrtab_mei_reg_read[ 5 ] = 101;
__tpstrtab_mei_reg_read[ 6 ] = 103;
__tpstrtab_mei_reg_read[ 7 ] = 95;
__tpstrtab_mei_reg_read[ 8 ] = 114;
__tpstrtab_mei_reg_read[ 9 ] = 101;
__tpstrtab_mei_reg_read[ 10 ] = 97;
__tpstrtab_mei_reg_read[ 11 ] = 100;
__tpstrtab_mei_reg_read[ 12 ] = 0;
__tracepoint_mei_reg_read.name = &(__tpstrtab_mei_reg_read);
__tracepoint_mei_reg_read.key.enabled.counter = 0;
__tracepoint_mei_reg_read.regfunc = 0;
__tracepoint_mei_reg_read.unregfunc = 0;
__tracepoint_mei_reg_read.funcs = 0;
__tpstrtab_mei_reg_write[ 0 ] = 109;
__tpstrtab_mei_reg_write[ 1 ] = 101;
__tpstrtab_mei_reg_write[ 2 ] = 105;
__tpstrtab_mei_reg_write[ 3 ] = 95;
__tpstrtab_mei_reg_write[ 4 ] = 114;
__tpstrtab_mei_reg_write[ 5 ] = 101;
__tpstrtab_mei_reg_write[ 6 ] = 103;
__tpstrtab_mei_reg_write[ 7 ] = 95;
__tpstrtab_mei_reg_write[ 8 ] = 119;
__tpstrtab_mei_reg_write[ 9 ] = 114;
__tpstrtab_mei_reg_write[ 10 ] = 105;
__tpstrtab_mei_reg_write[ 11 ] = 116;
__tpstrtab_mei_reg_write[ 12 ] = 101;
__tpstrtab_mei_reg_write[ 13 ] = 0;
__tracepoint_mei_reg_write.name = &(__tpstrtab_mei_reg_write);
__tracepoint_mei_reg_write.key.enabled.counter = 0;
__tracepoint_mei_reg_write.regfunc = 0;
__tracepoint_mei_reg_write.unregfunc = 0;
__tracepoint_mei_reg_write.funcs = 0;
__kstrtab___tracepoint_mei_reg_read[ 0 ] = 95;
__kstrtab___tracepoint_mei_reg_read[ 1 ] = 95;
__kstrtab___tracepoint_mei_reg_read[ 2 ] = 116;
__kstrtab___tracepoint_mei_reg_read[ 3 ] = 114;
__kstrtab___tracepoint_mei_reg_read[ 4 ] = 97;
__kstrtab___tracepoint_mei_reg_read[ 5 ] = 99;
__kstrtab___tracepoint_mei_reg_read[ 6 ] = 101;
__kstrtab___tracepoint_mei_reg_read[ 7 ] = 112;
__kstrtab___tracepoint_mei_reg_read[ 8 ] = 111;
__kstrtab___tracepoint_mei_reg_read[ 9 ] = 105;
__kstrtab___tracepoint_mei_reg_read[ 10 ] = 110;
__kstrtab___tracepoint_mei_reg_read[ 11 ] = 116;
__kstrtab___tracepoint_mei_reg_read[ 12 ] = 95;
__kstrtab___tracepoint_mei_reg_read[ 13 ] = 109;
__kstrtab___tracepoint_mei_reg_read[ 14 ] = 101;
__kstrtab___tracepoint_mei_reg_read[ 15 ] = 105;
__kstrtab___tracepoint_mei_reg_read[ 16 ] = 95;
__kstrtab___tracepoint_mei_reg_read[ 17 ] = 114;
__kstrtab___tracepoint_mei_reg_read[ 18 ] = 101;
__kstrtab___tracepoint_mei_reg_read[ 19 ] = 103;
__kstrtab___tracepoint_mei_reg_read[ 20 ] = 95;
__kstrtab___tracepoint_mei_reg_read[ 21 ] = 114;
__kstrtab___tracepoint_mei_reg_read[ 22 ] = 101;
__kstrtab___tracepoint_mei_reg_read[ 23 ] = 97;
__kstrtab___tracepoint_mei_reg_read[ 24 ] = 100;
__kstrtab___tracepoint_mei_reg_read[ 25 ] = 0;
__ksymtab___tracepoint_mei_reg_read.value = &(__tracepoint_mei_reg_read);
__ksymtab___tracepoint_mei_reg_read.name = &(__kstrtab___tracepoint_mei_reg_read);
__kstrtab___tracepoint_mei_reg_write[ 0 ] = 95;
__kstrtab___tracepoint_mei_reg_write[ 1 ] = 95;
__kstrtab___tracepoint_mei_reg_write[ 2 ] = 116;
__kstrtab___tracepoint_mei_reg_write[ 3 ] = 114;
__kstrtab___tracepoint_mei_reg_write[ 4 ] = 97;
__kstrtab___tracepoint_mei_reg_write[ 5 ] = 99;
__kstrtab___tracepoint_mei_reg_write[ 6 ] = 101;
__kstrtab___tracepoint_mei_reg_write[ 7 ] = 112;
__kstrtab___tracepoint_mei_reg_write[ 8 ] = 111;
__kstrtab___tracepoint_mei_reg_write[ 9 ] = 105;
__kstrtab___tracepoint_mei_reg_write[ 10 ] = 110;
__kstrtab___tracepoint_mei_reg_write[ 11 ] = 116;
__kstrtab___tracepoint_mei_reg_write[ 12 ] = 95;
__kstrtab___tracepoint_mei_reg_write[ 13 ] = 109;
__kstrtab___tracepoint_mei_reg_write[ 14 ] = 101;
__kstrtab___tracepoint_mei_reg_write[ 15 ] = 105;
__kstrtab___tracepoint_mei_reg_write[ 16 ] = 95;
__kstrtab___tracepoint_mei_reg_write[ 17 ] = 114;
__kstrtab___tracepoint_mei_reg_write[ 18 ] = 101;
__kstrtab___tracepoint_mei_reg_write[ 19 ] = 103;
__kstrtab___tracepoint_mei_reg_write[ 20 ] = 95;
__kstrtab___tracepoint_mei_reg_write[ 21 ] = 119;
__kstrtab___tracepoint_mei_reg_write[ 22 ] = 114;
__kstrtab___tracepoint_mei_reg_write[ 23 ] = 105;
__kstrtab___tracepoint_mei_reg_write[ 24 ] = 116;
__kstrtab___tracepoint_mei_reg_write[ 25 ] = 101;
__kstrtab___tracepoint_mei_reg_write[ 26 ] = 0;
__ksymtab___tracepoint_mei_reg_write.value = &(__tracepoint_mei_reg_write);
__ksymtab___tracepoint_mei_reg_write.name = &(__kstrtab___tracepoint_mei_reg_write);
return ;
}
-__BLAST_initialize_/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/rcv/08_1a/main-ldv_main7_sequence_infinite_withcheck_stateful/preprocess/1-cpp//home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/rule-instrumentor/08_1a/common-model/ldv_common_model.o.i()
{
7 ldv_module_refcounter = 1;
return ;
}
-entry_point
{
1096 -ldv_s_mei_cl_bus_type_bus_type = 0;
ldv_s_mei_cl_device_type_device_type = 0;
LDV_IN_INTERRUPT = 1;
1095 ldv_initialize() { /* Function call is skipped due to function is undefined */}
1102 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */}
1102 assume(tmp___0 != 0);
1107 tmp = nondet_int() { /* Function call is skipped due to function is undefined */}
1109 assume(tmp == 0);
1112 assume(ldv_s_mei_cl_bus_type_bus_type == 0);
1120 -res_mei_cl_device_probe_17 = mei_cl_device_probe(var_group1 /* dev */)
{
568 -__mptr = dev;
cldev = __mptr + -24;
__mptr___0 = *(dev).driver;
cldrv = __mptr___0;
571 assume(cldev != 0);
574 assume(cldrv != 0);
574 assume(*(cldrv).probe != 0);
577 -id = mei_cl_device_find(cldev /* cldev */, cldrv /* cldrv */)
{
499 -uuid = mei_me_cl_uuid(*(cldev).me_cl /* me_cl */)
{
68 __retres2 = &(&(me_cl)->props)->protocol_name;
66 return __retres2;
}
500 -version = mei_me_cl_ver(*(cldev).me_cl /* me_cl */)
{
80 __retres2 = *(me_cl).props.protocol_version;
78 return __retres2;
}
502 id = *(cldrv).id_table;
503 -__constr_expr_0.b[ 0 ] = 0;
__constr_expr_0.b[ 1 ] = 0;
__constr_expr_0.b[ 2 ] = 0;
__constr_expr_0.b[ 3 ] = 0;
__constr_expr_0.b[ 4 ] = 0;
__constr_expr_0.b[ 5 ] = 0;
__constr_expr_0.b[ 6 ] = 0;
__constr_expr_0.b[ 7 ] = 0;
__constr_expr_0.b[ 8 ] = 0;
__constr_expr_0.b[ 9 ] = 0;
__constr_expr_0.b[ 10 ] = 0;
__constr_expr_0.b[ 11 ] = 0;
__constr_expr_0.b[ 12 ] = 0;
__constr_expr_0.b[ 13 ] = 0;
__constr_expr_0.b[ 14 ] = 0;
__constr_expr_0.b[ 15 ] = 0;
503 -tmp___1 = uuid_le_cmp(__constr_expr_0 /* u1 */, *(id).uuid /* u2 */)
{
28 tmp = memcmp(&(u1), &(u2), 16) { /* Function call is skipped due to function is undefined */}
28 return tmp;
}
503 assume(tmp___1 != 0);
504 -tmp___0 = uuid_le_cmp(*(uuid) /* u1 */, *(id).uuid /* u2 */)
{
28 tmp = memcmp(&(u1), &(u2), 16) { /* Function call is skipped due to function is undefined */}
28 return tmp;
}
504 assume(tmp___0 == 0);
505 match = 1;
507 assume(*(cldev).name[ 0 ] == 0);
512 assume(*(id).version == 255);
515 assume(match != 0);
516 __retres11 = id;
491 return __retres11;
}
578 assume(id != 0);
581 -ldv___module_get_34(&(__this_module) /* ldv_func_arg1 */)
{
42 -ldv_module_get(ldv_func_arg1 /* module */)
{
13 assume(module != 0);
15 ldv_module_refcounter = ldv_module_refcounter + 1;
10 return ;
}
39 return ;
}
583 tmp = *(*(cldrv).probe)(cldev, id) { /* Function call is skipped due to function is undefined */}
583 __retres9 = tmp;
562 return __retres9;
}
1121 ldv_check_return_value(res_mei_cl_device_probe_17) { /* Function call is skipped due to function is undefined */}
1122 ldv_check_return_value_probe(res_mei_cl_device_probe_17) { /* Function call is skipped due to function is undefined */}
1123 assume(res_mei_cl_device_probe_17 != 0);
1221 -ldv_check_final_state()
{
75 assume(ldv_module_refcounter != 1);
75 -ldv_error()
{
}
}
}
Source code
1 2 /* 3 * Intel Management Engine Interface (Intel MEI) Linux driver 4 * Copyright (c) 2012-2013, Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 */ 16 17 #include <linux/module.h> 18 #include <linux/device.h> 19 #include <linux/kernel.h> 20 #include <linux/sched.h> 21 #include <linux/init.h> 22 #include <linux/errno.h> 23 #include <linux/slab.h> 24 #include <linux/mutex.h> 25 #include <linux/interrupt.h> 26 #include <linux/mei_cl_bus.h> 27 28 #include "mei_dev.h" 29 #include "client.h" 30 31 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 32 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 33 34 /** 35 * __mei_cl_send - internal client send (write) 36 * 37 * @cl: host client 38 * @buf: buffer to send 39 * @length: buffer length 40 * @blocking: wait for write completion 41 * 42 * Return: written size bytes or < 0 on error 43 */ 44 ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length, 45 bool blocking) 46 { 47 struct mei_device *bus; 48 struct mei_cl_cb *cb = NULL; 49 ssize_t rets; 50 51 if (WARN_ON(!cl || !cl->dev)) 52 return -ENODEV; 53 54 bus = cl->dev; 55 56 mutex_lock(&bus->device_lock); 57 if (!mei_cl_is_connected(cl)) { 58 rets = -ENODEV; 59 goto out; 60 } 61 62 /* Check if we have an ME client device */ 63 if (!mei_me_cl_is_active(cl->me_cl)) { 64 rets = -ENOTTY; 65 goto out; 66 } 67 68 if (length > mei_cl_mtu(cl)) { 69 rets = -EFBIG; 70 goto out; 71 } 72 73 cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL); 74 if (!cb) { 75 rets = -ENOMEM; 76 goto out; 77 } 78 79 memcpy(cb->buf.data, buf, length); 80 81 rets = mei_cl_write(cl, cb, blocking); 82 83 out: 84 mutex_unlock(&bus->device_lock); 85 if (rets < 0) 86 mei_io_cb_free(cb); 87 88 return rets; 89 } 90 91 /** 92 * __mei_cl_recv - internal client receive (read) 93 * 94 * @cl: host client 95 * @buf: buffer to receive 96 * @length: buffer length 97 * 98 * Return: read size in bytes of < 0 on error 99 */ 100 ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length) 101 { 102 struct mei_device *bus; 103 struct mei_cl_cb *cb; 104 size_t r_length; 105 ssize_t rets; 106 107 if (WARN_ON(!cl || !cl->dev)) 108 return -ENODEV; 109 110 bus = cl->dev; 111 112 mutex_lock(&bus->device_lock); 113 114 cb = mei_cl_read_cb(cl, NULL); 115 if (cb) 116 goto copy; 117 118 rets = mei_cl_read_start(cl, length, NULL); 119 if (rets && rets != -EBUSY) 120 goto out; 121 122 /* wait on event only if there is no other waiter */ 123 if (list_empty(&cl->rd_completed) && !waitqueue_active(&cl->rx_wait)) { 124 125 mutex_unlock(&bus->device_lock); 126 127 if (wait_event_interruptible(cl->rx_wait, 128 (!list_empty(&cl->rd_completed)) || 129 (!mei_cl_is_connected(cl)))) { 130 131 if (signal_pending(current)) 132 return -EINTR; 133 return -ERESTARTSYS; 134 } 135 136 mutex_lock(&bus->device_lock); 137 138 if (!mei_cl_is_connected(cl)) { 139 rets = -EBUSY; 140 goto out; 141 } 142 } 143 144 cb = mei_cl_read_cb(cl, NULL); 145 if (!cb) { 146 rets = 0; 147 goto out; 148 } 149 150 copy: 151 if (cb->status) { 152 rets = cb->status; 153 goto free; 154 } 155 156 r_length = min_t(size_t, length, cb->buf_idx); 157 memcpy(buf, cb->buf.data, r_length); 158 rets = r_length; 159 160 free: 161 mei_io_cb_free(cb); 162 out: 163 mutex_unlock(&bus->device_lock); 164 165 return rets; 166 } 167 168 /** 169 * mei_cldev_send - me device send (write) 170 * 171 * @cldev: me client device 172 * @buf: buffer to send 173 * @length: buffer length 174 * 175 * Return: written size in bytes or < 0 on error 176 */ 177 ssize_t mei_cldev_send(struct mei_cl_device *cldev, u8 *buf, size_t length) 178 { 179 struct mei_cl *cl = cldev->cl; 180 181 if (cl == NULL) 182 return -ENODEV; 183 184 return __mei_cl_send(cl, buf, length, 1); 185 } 186 EXPORT_SYMBOL_GPL(mei_cldev_send); 187 188 /** 189 * mei_cldev_recv - client receive (read) 190 * 191 * @cldev: me client device 192 * @buf: buffer to receive 193 * @length: buffer length 194 * 195 * Return: read size in bytes of < 0 on error 196 */ 197 ssize_t mei_cldev_recv(struct mei_cl_device *cldev, u8 *buf, size_t length) 198 { 199 struct mei_cl *cl = cldev->cl; 200 201 if (cl == NULL) 202 return -ENODEV; 203 204 return __mei_cl_recv(cl, buf, length); 205 } 206 EXPORT_SYMBOL_GPL(mei_cldev_recv); 207 208 /** 209 * mei_cl_bus_event_work - dispatch rx event for a bus device 210 * and schedule new work 211 * 212 * @work: work 213 */ 214 static void mei_cl_bus_event_work(struct work_struct *work) 215 { 216 struct mei_cl_device *cldev; 217 218 cldev = container_of(work, struct mei_cl_device, event_work); 219 220 if (cldev->event_cb) 221 cldev->event_cb(cldev, cldev->events, cldev->event_context); 222 223 cldev->events = 0; 224 225 /* Prepare for the next read */ 226 if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) 227 mei_cl_read_start(cldev->cl, 0, NULL); 228 } 229 230 /** 231 * mei_cl_bus_notify_event - schedule notify cb on bus client 232 * 233 * @cl: host client 234 */ 235 void mei_cl_bus_notify_event(struct mei_cl *cl) 236 { 237 struct mei_cl_device *cldev = cl->cldev; 238 239 if (!cldev || !cldev->event_cb) 240 return; 241 242 if (!(cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF))) 243 return; 244 245 if (!cl->notify_ev) 246 return; 247 248 set_bit(MEI_CL_EVENT_NOTIF, &cldev->events); 249 250 schedule_work(&cldev->event_work); 251 252 cl->notify_ev = false; 253 } 254 255 /** 256 * mei_cl_bus_rx_event - schedule rx evenet 257 * 258 * @cl: host client 259 */ 260 void mei_cl_bus_rx_event(struct mei_cl *cl) 261 { 262 struct mei_cl_device *cldev = cl->cldev; 263 264 if (!cldev || !cldev->event_cb) 265 return; 266 267 if (!(cldev->events_mask & BIT(MEI_CL_EVENT_RX))) 268 return; 269 270 set_bit(MEI_CL_EVENT_RX, &cldev->events); 271 272 schedule_work(&cldev->event_work); 273 } 274 275 /** 276 * mei_cldev_register_event_cb - register event callback 277 * 278 * @cldev: me client devices 279 * @event_cb: callback function 280 * @events_mask: requested events bitmask 281 * @context: driver context data 282 * 283 * Return: 0 on success 284 * -EALREADY if an callback is already registered 285 * <0 on other errors 286 */ 287 int mei_cldev_register_event_cb(struct mei_cl_device *cldev, 288 unsigned long events_mask, 289 mei_cldev_event_cb_t event_cb, void *context) 290 { 291 int ret; 292 293 if (cldev->event_cb) 294 return -EALREADY; 295 296 cldev->events = 0; 297 cldev->events_mask = events_mask; 298 cldev->event_cb = event_cb; 299 cldev->event_context = context; 300 INIT_WORK(&cldev->event_work, mei_cl_bus_event_work); 301 302 if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) { 303 ret = mei_cl_read_start(cldev->cl, 0, NULL); 304 if (ret && ret != -EBUSY) 305 return ret; 306 } 307 308 if (cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)) { 309 mutex_lock(&cldev->cl->dev->device_lock); 310 ret = mei_cl_notify_request(cldev->cl, NULL, event_cb ? 1 : 0); 311 mutex_unlock(&cldev->cl->dev->device_lock); 312 if (ret) 313 return ret; 314 } 315 316 return 0; 317 } 318 EXPORT_SYMBOL_GPL(mei_cldev_register_event_cb); 319 320 /** 321 * mei_cldev_get_drvdata - driver data getter 322 * 323 * @cldev: mei client device 324 * 325 * Return: driver private data 326 */ 327 void *mei_cldev_get_drvdata(const struct mei_cl_device *cldev) 328 { 329 return dev_get_drvdata(&cldev->dev); 330 } 331 EXPORT_SYMBOL_GPL(mei_cldev_get_drvdata); 332 333 /** 334 * mei_cldev_set_drvdata - driver data setter 335 * 336 * @cldev: mei client device 337 * @data: data to store 338 */ 339 void mei_cldev_set_drvdata(struct mei_cl_device *cldev, void *data) 340 { 341 dev_set_drvdata(&cldev->dev, data); 342 } 343 EXPORT_SYMBOL_GPL(mei_cldev_set_drvdata); 344 345 /** 346 * mei_cldev_uuid - return uuid of the underlying me client 347 * 348 * @cldev: mei client device 349 * 350 * Return: me client uuid 351 */ 352 const uuid_le *mei_cldev_uuid(const struct mei_cl_device *cldev) 353 { 354 return mei_me_cl_uuid(cldev->me_cl); 355 } 356 EXPORT_SYMBOL_GPL(mei_cldev_uuid); 357 358 /** 359 * mei_cldev_ver - return protocol version of the underlying me client 360 * 361 * @cldev: mei client device 362 * 363 * Return: me client protocol version 364 */ 365 u8 mei_cldev_ver(const struct mei_cl_device *cldev) 366 { 367 return mei_me_cl_ver(cldev->me_cl); 368 } 369 EXPORT_SYMBOL_GPL(mei_cldev_ver); 370 371 /** 372 * mei_cldev_enabled - check whether the device is enabled 373 * 374 * @cldev: mei client device 375 * 376 * Return: true if me client is initialized and connected 377 */ 378 bool mei_cldev_enabled(struct mei_cl_device *cldev) 379 { 380 return cldev->cl && mei_cl_is_connected(cldev->cl); 381 } 382 EXPORT_SYMBOL_GPL(mei_cldev_enabled); 383 384 /** 385 * mei_cldev_enable_device - enable me client device 386 * create connection with me client 387 * 388 * @cldev: me client device 389 * 390 * Return: 0 on success and < 0 on error 391 */ 392 int mei_cldev_enable(struct mei_cl_device *cldev) 393 { 394 struct mei_device *bus = cldev->bus; 395 struct mei_cl *cl; 396 int ret; 397 398 cl = cldev->cl; 399 400 if (!cl) { 401 mutex_lock(&bus->device_lock); 402 cl = mei_cl_alloc_linked(bus, MEI_HOST_CLIENT_ID_ANY); 403 mutex_unlock(&bus->device_lock); 404 if (IS_ERR(cl)) 405 return PTR_ERR(cl); 406 /* update pointers */ 407 cldev->cl = cl; 408 cl->cldev = cldev; 409 } 410 411 mutex_lock(&bus->device_lock); 412 if (mei_cl_is_connected(cl)) { 413 ret = 0; 414 goto out; 415 } 416 417 if (!mei_me_cl_is_active(cldev->me_cl)) { 418 dev_err(&cldev->dev, "me client is not active\n"); 419 ret = -ENOTTY; 420 goto out; 421 } 422 423 ret = mei_cl_connect(cl, cldev->me_cl, NULL); 424 if (ret < 0) 425 dev_err(&cldev->dev, "cannot connect\n"); 426 427 out: 428 mutex_unlock(&bus->device_lock); 429 430 return ret; 431 } 432 EXPORT_SYMBOL_GPL(mei_cldev_enable); 433 434 /** 435 * mei_cldev_disable - disable me client device 436 * disconnect form the me client 437 * 438 * @cldev: me client device 439 * 440 * Return: 0 on success and < 0 on error 441 */ 442 int mei_cldev_disable(struct mei_cl_device *cldev) 443 { 444 struct mei_device *bus; 445 struct mei_cl *cl; 446 int err; 447 448 if (!cldev || !cldev->cl) 449 return -ENODEV; 450 451 cl = cldev->cl; 452 453 bus = cldev->bus; 454 455 cldev->event_cb = NULL; 456 457 mutex_lock(&bus->device_lock); 458 459 if (!mei_cl_is_connected(cl)) { 460 dev_err(bus->dev, "Already disconnected"); 461 err = 0; 462 goto out; 463 } 464 465 err = mei_cl_disconnect(cl); 466 if (err < 0) 467 dev_err(bus->dev, "Could not disconnect from the ME client"); 468 469 out: 470 /* Flush queues and remove any pending read */ 471 mei_cl_flush_queues(cl, NULL); 472 mei_cl_unlink(cl); 473 474 kfree(cl); 475 cldev->cl = NULL; 476 477 mutex_unlock(&bus->device_lock); 478 return err; 479 } 480 EXPORT_SYMBOL_GPL(mei_cldev_disable); 481 482 /** 483 * mei_cl_device_find - find matching entry in the driver id table 484 * 485 * @cldev: me client device 486 * @cldrv: me client driver 487 * 488 * Return: id on success; NULL if no id is matching 489 */ 490 static const 491 struct mei_cl_device_id *mei_cl_device_find(struct mei_cl_device *cldev, 492 struct mei_cl_driver *cldrv) 493 { 494 const struct mei_cl_device_id *id; 495 const uuid_le *uuid; 496 u8 version; 497 bool match; 498 499 uuid = mei_me_cl_uuid(cldev->me_cl); 500 version = mei_me_cl_ver(cldev->me_cl); 501 502 id = cldrv->id_table; 503 while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) { 504 if (!uuid_le_cmp(*uuid, id->uuid)) { 505 match = true; 506 507 if (cldev->name[0]) 508 if (strncmp(cldev->name, id->name, 509 sizeof(id->name))) 510 match = false; 511 512 if (id->version != MEI_CL_VERSION_ANY) 513 if (id->version != version) 514 match = false; 515 if (match) 516 return id; 517 } 518 519 id++; 520 } 521 522 return NULL; 523 } 524 525 /** 526 * mei_cl_device_match - device match function 527 * 528 * @dev: device 529 * @drv: driver 530 * 531 * Return: 1 if matching device was found 0 otherwise 532 */ 533 static int mei_cl_device_match(struct device *dev, struct device_driver *drv) 534 { 535 struct mei_cl_device *cldev = to_mei_cl_device(dev); 536 struct mei_cl_driver *cldrv = to_mei_cl_driver(drv); 537 const struct mei_cl_device_id *found_id; 538 539 if (!cldev) 540 return 0; 541 542 if (!cldev->do_match) 543 return 0; 544 545 if (!cldrv || !cldrv->id_table) 546 return 0; 547 548 found_id = mei_cl_device_find(cldev, cldrv); 549 if (found_id) 550 return 1; 551 552 return 0; 553 } 554 555 /** 556 * mei_cl_device_probe - bus probe function 557 * 558 * @dev: device 559 * 560 * Return: 0 on success; < 0 otherwise 561 */ 562 static int mei_cl_device_probe(struct device *dev) 563 { 564 struct mei_cl_device *cldev; 565 struct mei_cl_driver *cldrv; 566 const struct mei_cl_device_id *id; 567 568 cldev = to_mei_cl_device(dev); 569 cldrv = to_mei_cl_driver(dev->driver); 570 571 if (!cldev) 572 return 0; 573 574 if (!cldrv || !cldrv->probe) 575 return -ENODEV; 576 577 id = mei_cl_device_find(cldev, cldrv); 578 if (!id) 579 return -ENODEV; 580 581 __module_get(THIS_MODULE); 582 583 return cldrv->probe(cldev, id); 584 } 585 586 /** 587 * mei_cl_device_remove - remove device from the bus 588 * 589 * @dev: device 590 * 591 * Return: 0 on success; < 0 otherwise 592 */ 593 static int mei_cl_device_remove(struct device *dev) 594 { 595 struct mei_cl_device *cldev = to_mei_cl_device(dev); 596 struct mei_cl_driver *cldrv; 597 int ret = 0; 598 599 if (!cldev || !dev->driver) 600 return 0; 601 602 if (cldev->event_cb) { 603 cldev->event_cb = NULL; 604 cancel_work_sync(&cldev->event_work); 605 } 606 607 cldrv = to_mei_cl_driver(dev->driver); 608 if (cldrv->remove) 609 ret = cldrv->remove(cldev); 610 611 module_put(THIS_MODULE); 612 dev->driver = NULL; 613 return ret; 614 615 } 616 617 static ssize_t name_show(struct device *dev, struct device_attribute *a, 618 char *buf) 619 { 620 struct mei_cl_device *cldev = to_mei_cl_device(dev); 621 size_t len; 622 623 len = snprintf(buf, PAGE_SIZE, "%s", cldev->name); 624 625 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 626 } 627 static DEVICE_ATTR_RO(name); 628 629 static ssize_t uuid_show(struct device *dev, struct device_attribute *a, 630 char *buf) 631 { 632 struct mei_cl_device *cldev = to_mei_cl_device(dev); 633 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 634 size_t len; 635 636 len = snprintf(buf, PAGE_SIZE, "%pUl", uuid); 637 638 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 639 } 640 static DEVICE_ATTR_RO(uuid); 641 642 static ssize_t version_show(struct device *dev, struct device_attribute *a, 643 char *buf) 644 { 645 struct mei_cl_device *cldev = to_mei_cl_device(dev); 646 u8 version = mei_me_cl_ver(cldev->me_cl); 647 size_t len; 648 649 len = snprintf(buf, PAGE_SIZE, "%02X", version); 650 651 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 652 } 653 static DEVICE_ATTR_RO(version); 654 655 static ssize_t modalias_show(struct device *dev, struct device_attribute *a, 656 char *buf) 657 { 658 struct mei_cl_device *cldev = to_mei_cl_device(dev); 659 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 660 size_t len; 661 662 len = snprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid); 663 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 664 } 665 static DEVICE_ATTR_RO(modalias); 666 667 static struct attribute *mei_cldev_attrs[] = { 668 &dev_attr_name.attr, 669 &dev_attr_uuid.attr, 670 &dev_attr_version.attr, 671 &dev_attr_modalias.attr, 672 NULL, 673 }; 674 ATTRIBUTE_GROUPS(mei_cldev); 675 676 /** 677 * mei_cl_device_uevent - me client bus uevent handler 678 * 679 * @dev: device 680 * @env: uevent kobject 681 * 682 * Return: 0 on success -ENOMEM on when add_uevent_var fails 683 */ 684 static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env) 685 { 686 struct mei_cl_device *cldev = to_mei_cl_device(dev); 687 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 688 u8 version = mei_me_cl_ver(cldev->me_cl); 689 690 if (add_uevent_var(env, "MEI_CL_VERSION=%d", version)) 691 return -ENOMEM; 692 693 if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid)) 694 return -ENOMEM; 695 696 if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name)) 697 return -ENOMEM; 698 699 if (add_uevent_var(env, "MODALIAS=mei:%s:%pUl:%02X:", 700 cldev->name, uuid, version)) 701 return -ENOMEM; 702 703 return 0; 704 } 705 706 static struct bus_type mei_cl_bus_type = { 707 .name = "mei", 708 .dev_groups = mei_cldev_groups, 709 .match = mei_cl_device_match, 710 .probe = mei_cl_device_probe, 711 .remove = mei_cl_device_remove, 712 .uevent = mei_cl_device_uevent, 713 }; 714 715 static struct mei_device *mei_dev_bus_get(struct mei_device *bus) 716 { 717 if (bus) 718 get_device(bus->dev); 719 720 return bus; 721 } 722 723 static void mei_dev_bus_put(struct mei_device *bus) 724 { 725 if (bus) 726 put_device(bus->dev); 727 } 728 729 static void mei_cl_bus_dev_release(struct device *dev) 730 { 731 struct mei_cl_device *cldev = to_mei_cl_device(dev); 732 733 if (!cldev) 734 return; 735 736 mei_me_cl_put(cldev->me_cl); 737 mei_dev_bus_put(cldev->bus); 738 kfree(cldev); 739 } 740 741 static struct device_type mei_cl_device_type = { 742 .release = mei_cl_bus_dev_release, 743 }; 744 745 /** 746 * mei_cl_bus_set_name - set device name for me client device 747 * 748 * @cldev: me client device 749 */ 750 static inline void mei_cl_bus_set_name(struct mei_cl_device *cldev) 751 { 752 dev_set_name(&cldev->dev, "mei:%s:%pUl:%02X", 753 cldev->name, 754 mei_me_cl_uuid(cldev->me_cl), 755 mei_me_cl_ver(cldev->me_cl)); 756 } 757 758 /** 759 * mei_cl_bus_dev_alloc - initialize and allocate mei client device 760 * 761 * @bus: mei device 762 * @me_cl: me client 763 * 764 * Return: allocated device structur or NULL on allocation failure 765 */ 766 static struct mei_cl_device *mei_cl_bus_dev_alloc(struct mei_device *bus, 767 struct mei_me_client *me_cl) 768 { 769 struct mei_cl_device *cldev; 770 771 cldev = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL); 772 if (!cldev) 773 return NULL; 774 775 device_initialize(&cldev->dev); 776 cldev->dev.parent = bus->dev; 777 cldev->dev.bus = &mei_cl_bus_type; 778 cldev->dev.type = &mei_cl_device_type; 779 cldev->bus = mei_dev_bus_get(bus); 780 cldev->me_cl = mei_me_cl_get(me_cl); 781 mei_cl_bus_set_name(cldev); 782 cldev->is_added = 0; 783 INIT_LIST_HEAD(&cldev->bus_list); 784 785 return cldev; 786 } 787 788 /** 789 * mei_cl_dev_setup - setup me client device 790 * run fix up routines and set the device name 791 * 792 * @bus: mei device 793 * @cldev: me client device 794 * 795 * Return: true if the device is eligible for enumeration 796 */ 797 static bool mei_cl_bus_dev_setup(struct mei_device *bus, 798 struct mei_cl_device *cldev) 799 { 800 cldev->do_match = 1; 801 mei_cl_bus_dev_fixup(cldev); 802 803 /* the device name can change during fix up */ 804 if (cldev->do_match) 805 mei_cl_bus_set_name(cldev); 806 807 return cldev->do_match == 1; 808 } 809 810 /** 811 * mei_cl_bus_dev_add - add me client devices 812 * 813 * @cldev: me client device 814 * 815 * Return: 0 on success; < 0 on failre 816 */ 817 static int mei_cl_bus_dev_add(struct mei_cl_device *cldev) 818 { 819 int ret; 820 821 dev_dbg(cldev->bus->dev, "adding %pUL:%02X\n", 822 mei_me_cl_uuid(cldev->me_cl), 823 mei_me_cl_ver(cldev->me_cl)); 824 ret = device_add(&cldev->dev); 825 if (!ret) 826 cldev->is_added = 1; 827 828 return ret; 829 } 830 831 /** 832 * mei_cl_bus_dev_stop - stop the driver 833 * 834 * @cldev: me client device 835 */ 836 static void mei_cl_bus_dev_stop(struct mei_cl_device *cldev) 837 { 838 if (cldev->is_added) 839 device_release_driver(&cldev->dev); 840 } 841 842 /** 843 * mei_cl_bus_dev_destroy - destroy me client devices object 844 * 845 * @cldev: me client device 846 * 847 * Locking: called under "dev->cl_bus_lock" lock 848 */ 849 static void mei_cl_bus_dev_destroy(struct mei_cl_device *cldev) 850 { 851 852 WARN_ON(!mutex_is_locked(&cldev->bus->cl_bus_lock)); 853 854 if (!cldev->is_added) 855 return; 856 857 device_del(&cldev->dev); 858 859 list_del_init(&cldev->bus_list); 860 861 cldev->is_added = 0; 862 put_device(&cldev->dev); 863 } 864 865 /** 866 * mei_cl_bus_remove_device - remove a devices form the bus 867 * 868 * @cldev: me client device 869 */ 870 static void mei_cl_bus_remove_device(struct mei_cl_device *cldev) 871 { 872 mei_cl_bus_dev_stop(cldev); 873 mei_cl_bus_dev_destroy(cldev); 874 } 875 876 /** 877 * mei_cl_bus_remove_devices - remove all devices form the bus 878 * 879 * @bus: mei device 880 */ 881 void mei_cl_bus_remove_devices(struct mei_device *bus) 882 { 883 struct mei_cl_device *cldev, *next; 884 885 mutex_lock(&bus->cl_bus_lock); 886 list_for_each_entry_safe(cldev, next, &bus->device_list, bus_list) 887 mei_cl_bus_remove_device(cldev); 888 mutex_unlock(&bus->cl_bus_lock); 889 } 890 891 892 /** 893 * mei_cl_bus_dev_init - allocate and initializes an mei client devices 894 * based on me client 895 * 896 * @bus: mei device 897 * @me_cl: me client 898 * 899 * Locking: called under "dev->cl_bus_lock" lock 900 */ 901 static void mei_cl_bus_dev_init(struct mei_device *bus, 902 struct mei_me_client *me_cl) 903 { 904 struct mei_cl_device *cldev; 905 906 WARN_ON(!mutex_is_locked(&bus->cl_bus_lock)); 907 908 dev_dbg(bus->dev, "initializing %pUl", mei_me_cl_uuid(me_cl)); 909 910 if (me_cl->bus_added) 911 return; 912 913 cldev = mei_cl_bus_dev_alloc(bus, me_cl); 914 if (!cldev) 915 return; 916 917 me_cl->bus_added = true; 918 list_add_tail(&cldev->bus_list, &bus->device_list); 919 920 } 921 922 /** 923 * mei_cl_bus_rescan - scan me clients list and add create 924 * devices for eligible clients 925 * 926 * @bus: mei device 927 */ 928 void mei_cl_bus_rescan(struct mei_device *bus) 929 { 930 struct mei_cl_device *cldev, *n; 931 struct mei_me_client *me_cl; 932 933 mutex_lock(&bus->cl_bus_lock); 934 935 down_read(&bus->me_clients_rwsem); 936 list_for_each_entry(me_cl, &bus->me_clients, list) 937 mei_cl_bus_dev_init(bus, me_cl); 938 up_read(&bus->me_clients_rwsem); 939 940 list_for_each_entry_safe(cldev, n, &bus->device_list, bus_list) { 941 942 if (!mei_me_cl_is_active(cldev->me_cl)) { 943 mei_cl_bus_remove_device(cldev); 944 continue; 945 } 946 947 if (cldev->is_added) 948 continue; 949 950 if (mei_cl_bus_dev_setup(bus, cldev)) 951 mei_cl_bus_dev_add(cldev); 952 else { 953 list_del_init(&cldev->bus_list); 954 put_device(&cldev->dev); 955 } 956 } 957 mutex_unlock(&bus->cl_bus_lock); 958 959 dev_dbg(bus->dev, "rescan end"); 960 } 961 962 int __mei_cldev_driver_register(struct mei_cl_driver *cldrv, 963 struct module *owner) 964 { 965 int err; 966 967 cldrv->driver.name = cldrv->name; 968 cldrv->driver.owner = owner; 969 cldrv->driver.bus = &mei_cl_bus_type; 970 971 err = driver_register(&cldrv->driver); 972 if (err) 973 return err; 974 975 pr_debug("mei: driver [%s] registered\n", cldrv->driver.name); 976 977 return 0; 978 } 979 EXPORT_SYMBOL_GPL(__mei_cldev_driver_register); 980 981 void mei_cldev_driver_unregister(struct mei_cl_driver *cldrv) 982 { 983 driver_unregister(&cldrv->driver); 984 985 pr_debug("mei: driver [%s] unregistered\n", cldrv->driver.name); 986 } 987 EXPORT_SYMBOL_GPL(mei_cldev_driver_unregister); 988 989 990 int __init mei_cl_bus_init(void) 991 { 992 return bus_register(&mei_cl_bus_type); 993 } 994 995 void __exit mei_cl_bus_exit(void) 996 { 997 bus_unregister(&mei_cl_bus_type); 998 } 999 1000 1001 1002 1003 1004 /* LDV_COMMENT_BEGIN_MAIN */ 1005 #ifdef LDV_MAIN7_sequence_infinite_withcheck_stateful 1006 1007 /*###########################################################################*/ 1008 1009 /*############## Driver Environment Generator 0.2 output ####################*/ 1010 1011 /*###########################################################################*/ 1012 1013 1014 1015 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 1016 void ldv_check_final_state(void); 1017 1018 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 1019 void ldv_check_return_value(int res); 1020 1021 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 1022 void ldv_check_return_value_probe(int res); 1023 1024 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 1025 void ldv_initialize(void); 1026 1027 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 1028 void ldv_handler_precall(void); 1029 1030 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 1031 int nondet_int(void); 1032 1033 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 1034 int LDV_IN_INTERRUPT; 1035 1036 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 1037 void ldv_main7_sequence_infinite_withcheck_stateful(void) { 1038 1039 1040 1041 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 1042 /*============================= VARIABLE DECLARATION PART =============================*/ 1043 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1044 /* content: static int mei_cl_device_match(struct device *dev, struct device_driver *drv)*/ 1045 /* LDV_COMMENT_BEGIN_PREP */ 1046 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1047 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1048 /* LDV_COMMENT_END_PREP */ 1049 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_match" */ 1050 struct device * var_group1; 1051 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_match" */ 1052 struct device_driver * var_group2; 1053 /* content: static int mei_cl_device_probe(struct device *dev)*/ 1054 /* LDV_COMMENT_BEGIN_PREP */ 1055 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1056 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1057 /* LDV_COMMENT_END_PREP */ 1058 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "mei_cl_device_probe" */ 1059 static int res_mei_cl_device_probe_17; 1060 /* content: static int mei_cl_device_remove(struct device *dev)*/ 1061 /* LDV_COMMENT_BEGIN_PREP */ 1062 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1063 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1064 /* LDV_COMMENT_END_PREP */ 1065 /* content: static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env)*/ 1066 /* LDV_COMMENT_BEGIN_PREP */ 1067 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1068 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1069 /* LDV_COMMENT_END_PREP */ 1070 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_uevent" */ 1071 struct kobj_uevent_env * var_group3; 1072 1073 /** STRUCT: struct type: device_type, struct name: mei_cl_device_type **/ 1074 /* content: static void mei_cl_bus_dev_release(struct device *dev)*/ 1075 /* LDV_COMMENT_BEGIN_PREP */ 1076 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1077 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1078 /* LDV_COMMENT_END_PREP */ 1079 1080 1081 1082 1083 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 1084 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 1085 /*============================= VARIABLE INITIALIZING PART =============================*/ 1086 LDV_IN_INTERRUPT=1; 1087 1088 1089 1090 1091 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 1092 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 1093 /*============================= FUNCTION CALL SECTION =============================*/ 1094 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 1095 ldv_initialize(); 1096 int ldv_s_mei_cl_bus_type_bus_type = 0; 1097 1098 1099 int ldv_s_mei_cl_device_type_device_type = 0; 1100 1101 1102 while( nondet_int() 1103 || !(ldv_s_mei_cl_bus_type_bus_type == 0) 1104 || !(ldv_s_mei_cl_device_type_device_type == 0) 1105 ) { 1106 1107 switch(nondet_int()) { 1108 1109 case 0: { 1110 1111 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1112 if(ldv_s_mei_cl_bus_type_bus_type==0) { 1113 1114 /* content: static int mei_cl_device_probe(struct device *dev)*/ 1115 /* LDV_COMMENT_BEGIN_PREP */ 1116 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1117 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1118 /* LDV_COMMENT_END_PREP */ 1119 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "mei_cl_bus_type". Standart function test for correct return result. */ 1120 res_mei_cl_device_probe_17 = mei_cl_device_probe( var_group1); 1121 ldv_check_return_value(res_mei_cl_device_probe_17); 1122 ldv_check_return_value_probe(res_mei_cl_device_probe_17); 1123 if(res_mei_cl_device_probe_17) 1124 goto ldv_module_exit; 1125 ldv_s_mei_cl_bus_type_bus_type++; 1126 1127 } 1128 1129 } 1130 1131 break; 1132 case 1: { 1133 1134 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1135 if(ldv_s_mei_cl_bus_type_bus_type==1) { 1136 1137 /* content: static int mei_cl_device_remove(struct device *dev)*/ 1138 /* LDV_COMMENT_BEGIN_PREP */ 1139 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1140 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1141 /* LDV_COMMENT_END_PREP */ 1142 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "mei_cl_bus_type" */ 1143 ldv_handler_precall(); 1144 mei_cl_device_remove( var_group1); 1145 ldv_s_mei_cl_bus_type_bus_type=0; 1146 1147 } 1148 1149 } 1150 1151 break; 1152 case 2: { 1153 1154 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1155 1156 1157 /* content: static int mei_cl_device_match(struct device *dev, struct device_driver *drv)*/ 1158 /* LDV_COMMENT_BEGIN_PREP */ 1159 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1160 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1161 /* LDV_COMMENT_END_PREP */ 1162 /* LDV_COMMENT_FUNCTION_CALL Function from field "match" from driver structure with callbacks "mei_cl_bus_type" */ 1163 ldv_handler_precall(); 1164 mei_cl_device_match( var_group1, var_group2); 1165 1166 1167 1168 1169 } 1170 1171 break; 1172 case 3: { 1173 1174 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1175 1176 1177 /* content: static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env)*/ 1178 /* LDV_COMMENT_BEGIN_PREP */ 1179 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1180 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1181 /* LDV_COMMENT_END_PREP */ 1182 /* LDV_COMMENT_FUNCTION_CALL Function from field "uevent" from driver structure with callbacks "mei_cl_bus_type" */ 1183 ldv_handler_precall(); 1184 mei_cl_device_uevent( var_group1, var_group3); 1185 1186 1187 1188 1189 } 1190 1191 break; 1192 case 4: { 1193 1194 /** STRUCT: struct type: device_type, struct name: mei_cl_device_type **/ 1195 if(ldv_s_mei_cl_device_type_device_type==0) { 1196 1197 /* content: static void mei_cl_bus_dev_release(struct device *dev)*/ 1198 /* LDV_COMMENT_BEGIN_PREP */ 1199 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1200 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1201 /* LDV_COMMENT_END_PREP */ 1202 /* LDV_COMMENT_FUNCTION_CALL Function from field "release" from driver structure with callbacks "mei_cl_device_type" */ 1203 ldv_handler_precall(); 1204 mei_cl_bus_dev_release( var_group1); 1205 ldv_s_mei_cl_device_type_device_type=0; 1206 1207 } 1208 1209 } 1210 1211 break; 1212 default: break; 1213 1214 } 1215 1216 } 1217 1218 ldv_module_exit: 1219 1220 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 1221 ldv_final: ldv_check_final_state(); 1222 1223 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 1224 return; 1225 1226 } 1227 #endif 1228 1229 /* LDV_COMMENT_END_MAIN */
1 2 #include <linux/kernel.h> 3 bool ldv_is_err(const void *ptr); 4 bool ldv_is_err_or_null(const void *ptr); 5 void* ldv_err_ptr(long error); 6 long ldv_ptr_err(const void *ptr); 7 8 #include <linux/module.h> 9 extern int ldv_try_module_get(struct module*); 10 extern void ldv_module_get(struct module*); 11 extern void ldv_module_put(struct module*); 12 extern unsigned int ldv_module_refcount(void); 13 extern void ldv_module_put_and_exit(void); 14 #line 1 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/ri/08_1a/drivers/misc/mei/bus.c" 15 16 /* 17 * Intel Management Engine Interface (Intel MEI) Linux driver 18 * Copyright (c) 2012-2013, Intel Corporation. 19 * 20 * This program is free software; you can redistribute it and/or modify it 21 * under the terms and conditions of the GNU General Public License, 22 * version 2, as published by the Free Software Foundation. 23 * 24 * This program is distributed in the hope it will be useful, but WITHOUT 25 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 26 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 27 * more details. 28 * 29 */ 30 31 #include <linux/module.h> 32 #include <linux/device.h> 33 #include <linux/kernel.h> 34 #include <linux/sched.h> 35 #include <linux/init.h> 36 #include <linux/errno.h> 37 #include <linux/slab.h> 38 #include <linux/mutex.h> 39 #include <linux/interrupt.h> 40 #include <linux/mei_cl_bus.h> 41 42 #include "mei_dev.h" 43 #include "client.h" 44 45 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 46 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 47 48 /** 49 * __mei_cl_send - internal client send (write) 50 * 51 * @cl: host client 52 * @buf: buffer to send 53 * @length: buffer length 54 * @blocking: wait for write completion 55 * 56 * Return: written size bytes or < 0 on error 57 */ 58 ssize_t __mei_cl_send(struct mei_cl *cl, u8 *buf, size_t length, 59 bool blocking) 60 { 61 struct mei_device *bus; 62 struct mei_cl_cb *cb = NULL; 63 ssize_t rets; 64 65 if (WARN_ON(!cl || !cl->dev)) 66 return -ENODEV; 67 68 bus = cl->dev; 69 70 mutex_lock(&bus->device_lock); 71 if (!mei_cl_is_connected(cl)) { 72 rets = -ENODEV; 73 goto out; 74 } 75 76 /* Check if we have an ME client device */ 77 if (!mei_me_cl_is_active(cl->me_cl)) { 78 rets = -ENOTTY; 79 goto out; 80 } 81 82 if (length > mei_cl_mtu(cl)) { 83 rets = -EFBIG; 84 goto out; 85 } 86 87 cb = mei_cl_alloc_cb(cl, length, MEI_FOP_WRITE, NULL); 88 if (!cb) { 89 rets = -ENOMEM; 90 goto out; 91 } 92 93 memcpy(cb->buf.data, buf, length); 94 95 rets = mei_cl_write(cl, cb, blocking); 96 97 out: 98 mutex_unlock(&bus->device_lock); 99 if (rets < 0) 100 mei_io_cb_free(cb); 101 102 return rets; 103 } 104 105 /** 106 * __mei_cl_recv - internal client receive (read) 107 * 108 * @cl: host client 109 * @buf: buffer to receive 110 * @length: buffer length 111 * 112 * Return: read size in bytes of < 0 on error 113 */ 114 ssize_t __mei_cl_recv(struct mei_cl *cl, u8 *buf, size_t length) 115 { 116 struct mei_device *bus; 117 struct mei_cl_cb *cb; 118 size_t r_length; 119 ssize_t rets; 120 121 if (WARN_ON(!cl || !cl->dev)) 122 return -ENODEV; 123 124 bus = cl->dev; 125 126 mutex_lock(&bus->device_lock); 127 128 cb = mei_cl_read_cb(cl, NULL); 129 if (cb) 130 goto copy; 131 132 rets = mei_cl_read_start(cl, length, NULL); 133 if (rets && rets != -EBUSY) 134 goto out; 135 136 /* wait on event only if there is no other waiter */ 137 if (list_empty(&cl->rd_completed) && !waitqueue_active(&cl->rx_wait)) { 138 139 mutex_unlock(&bus->device_lock); 140 141 if (wait_event_interruptible(cl->rx_wait, 142 (!list_empty(&cl->rd_completed)) || 143 (!mei_cl_is_connected(cl)))) { 144 145 if (signal_pending(current)) 146 return -EINTR; 147 return -ERESTARTSYS; 148 } 149 150 mutex_lock(&bus->device_lock); 151 152 if (!mei_cl_is_connected(cl)) { 153 rets = -EBUSY; 154 goto out; 155 } 156 } 157 158 cb = mei_cl_read_cb(cl, NULL); 159 if (!cb) { 160 rets = 0; 161 goto out; 162 } 163 164 copy: 165 if (cb->status) { 166 rets = cb->status; 167 goto free; 168 } 169 170 r_length = min_t(size_t, length, cb->buf_idx); 171 memcpy(buf, cb->buf.data, r_length); 172 rets = r_length; 173 174 free: 175 mei_io_cb_free(cb); 176 out: 177 mutex_unlock(&bus->device_lock); 178 179 return rets; 180 } 181 182 /** 183 * mei_cldev_send - me device send (write) 184 * 185 * @cldev: me client device 186 * @buf: buffer to send 187 * @length: buffer length 188 * 189 * Return: written size in bytes or < 0 on error 190 */ 191 ssize_t mei_cldev_send(struct mei_cl_device *cldev, u8 *buf, size_t length) 192 { 193 struct mei_cl *cl = cldev->cl; 194 195 if (cl == NULL) 196 return -ENODEV; 197 198 return __mei_cl_send(cl, buf, length, 1); 199 } 200 EXPORT_SYMBOL_GPL(mei_cldev_send); 201 202 /** 203 * mei_cldev_recv - client receive (read) 204 * 205 * @cldev: me client device 206 * @buf: buffer to receive 207 * @length: buffer length 208 * 209 * Return: read size in bytes of < 0 on error 210 */ 211 ssize_t mei_cldev_recv(struct mei_cl_device *cldev, u8 *buf, size_t length) 212 { 213 struct mei_cl *cl = cldev->cl; 214 215 if (cl == NULL) 216 return -ENODEV; 217 218 return __mei_cl_recv(cl, buf, length); 219 } 220 EXPORT_SYMBOL_GPL(mei_cldev_recv); 221 222 /** 223 * mei_cl_bus_event_work - dispatch rx event for a bus device 224 * and schedule new work 225 * 226 * @work: work 227 */ 228 static void mei_cl_bus_event_work(struct work_struct *work) 229 { 230 struct mei_cl_device *cldev; 231 232 cldev = container_of(work, struct mei_cl_device, event_work); 233 234 if (cldev->event_cb) 235 cldev->event_cb(cldev, cldev->events, cldev->event_context); 236 237 cldev->events = 0; 238 239 /* Prepare for the next read */ 240 if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) 241 mei_cl_read_start(cldev->cl, 0, NULL); 242 } 243 244 /** 245 * mei_cl_bus_notify_event - schedule notify cb on bus client 246 * 247 * @cl: host client 248 */ 249 void mei_cl_bus_notify_event(struct mei_cl *cl) 250 { 251 struct mei_cl_device *cldev = cl->cldev; 252 253 if (!cldev || !cldev->event_cb) 254 return; 255 256 if (!(cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF))) 257 return; 258 259 if (!cl->notify_ev) 260 return; 261 262 set_bit(MEI_CL_EVENT_NOTIF, &cldev->events); 263 264 schedule_work(&cldev->event_work); 265 266 cl->notify_ev = false; 267 } 268 269 /** 270 * mei_cl_bus_rx_event - schedule rx evenet 271 * 272 * @cl: host client 273 */ 274 void mei_cl_bus_rx_event(struct mei_cl *cl) 275 { 276 struct mei_cl_device *cldev = cl->cldev; 277 278 if (!cldev || !cldev->event_cb) 279 return; 280 281 if (!(cldev->events_mask & BIT(MEI_CL_EVENT_RX))) 282 return; 283 284 set_bit(MEI_CL_EVENT_RX, &cldev->events); 285 286 schedule_work(&cldev->event_work); 287 } 288 289 /** 290 * mei_cldev_register_event_cb - register event callback 291 * 292 * @cldev: me client devices 293 * @event_cb: callback function 294 * @events_mask: requested events bitmask 295 * @context: driver context data 296 * 297 * Return: 0 on success 298 * -EALREADY if an callback is already registered 299 * <0 on other errors 300 */ 301 int mei_cldev_register_event_cb(struct mei_cl_device *cldev, 302 unsigned long events_mask, 303 mei_cldev_event_cb_t event_cb, void *context) 304 { 305 int ret; 306 307 if (cldev->event_cb) 308 return -EALREADY; 309 310 cldev->events = 0; 311 cldev->events_mask = events_mask; 312 cldev->event_cb = event_cb; 313 cldev->event_context = context; 314 INIT_WORK(&cldev->event_work, mei_cl_bus_event_work); 315 316 if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) { 317 ret = mei_cl_read_start(cldev->cl, 0, NULL); 318 if (ret && ret != -EBUSY) 319 return ret; 320 } 321 322 if (cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)) { 323 mutex_lock(&cldev->cl->dev->device_lock); 324 ret = mei_cl_notify_request(cldev->cl, NULL, event_cb ? 1 : 0); 325 mutex_unlock(&cldev->cl->dev->device_lock); 326 if (ret) 327 return ret; 328 } 329 330 return 0; 331 } 332 EXPORT_SYMBOL_GPL(mei_cldev_register_event_cb); 333 334 /** 335 * mei_cldev_get_drvdata - driver data getter 336 * 337 * @cldev: mei client device 338 * 339 * Return: driver private data 340 */ 341 void *mei_cldev_get_drvdata(const struct mei_cl_device *cldev) 342 { 343 return dev_get_drvdata(&cldev->dev); 344 } 345 EXPORT_SYMBOL_GPL(mei_cldev_get_drvdata); 346 347 /** 348 * mei_cldev_set_drvdata - driver data setter 349 * 350 * @cldev: mei client device 351 * @data: data to store 352 */ 353 void mei_cldev_set_drvdata(struct mei_cl_device *cldev, void *data) 354 { 355 dev_set_drvdata(&cldev->dev, data); 356 } 357 EXPORT_SYMBOL_GPL(mei_cldev_set_drvdata); 358 359 /** 360 * mei_cldev_uuid - return uuid of the underlying me client 361 * 362 * @cldev: mei client device 363 * 364 * Return: me client uuid 365 */ 366 const uuid_le *mei_cldev_uuid(const struct mei_cl_device *cldev) 367 { 368 return mei_me_cl_uuid(cldev->me_cl); 369 } 370 EXPORT_SYMBOL_GPL(mei_cldev_uuid); 371 372 /** 373 * mei_cldev_ver - return protocol version of the underlying me client 374 * 375 * @cldev: mei client device 376 * 377 * Return: me client protocol version 378 */ 379 u8 mei_cldev_ver(const struct mei_cl_device *cldev) 380 { 381 return mei_me_cl_ver(cldev->me_cl); 382 } 383 EXPORT_SYMBOL_GPL(mei_cldev_ver); 384 385 /** 386 * mei_cldev_enabled - check whether the device is enabled 387 * 388 * @cldev: mei client device 389 * 390 * Return: true if me client is initialized and connected 391 */ 392 bool mei_cldev_enabled(struct mei_cl_device *cldev) 393 { 394 return cldev->cl && mei_cl_is_connected(cldev->cl); 395 } 396 EXPORT_SYMBOL_GPL(mei_cldev_enabled); 397 398 /** 399 * mei_cldev_enable_device - enable me client device 400 * create connection with me client 401 * 402 * @cldev: me client device 403 * 404 * Return: 0 on success and < 0 on error 405 */ 406 int mei_cldev_enable(struct mei_cl_device *cldev) 407 { 408 struct mei_device *bus = cldev->bus; 409 struct mei_cl *cl; 410 int ret; 411 412 cl = cldev->cl; 413 414 if (!cl) { 415 mutex_lock(&bus->device_lock); 416 cl = mei_cl_alloc_linked(bus, MEI_HOST_CLIENT_ID_ANY); 417 mutex_unlock(&bus->device_lock); 418 if (IS_ERR(cl)) 419 return PTR_ERR(cl); 420 /* update pointers */ 421 cldev->cl = cl; 422 cl->cldev = cldev; 423 } 424 425 mutex_lock(&bus->device_lock); 426 if (mei_cl_is_connected(cl)) { 427 ret = 0; 428 goto out; 429 } 430 431 if (!mei_me_cl_is_active(cldev->me_cl)) { 432 dev_err(&cldev->dev, "me client is not active\n"); 433 ret = -ENOTTY; 434 goto out; 435 } 436 437 ret = mei_cl_connect(cl, cldev->me_cl, NULL); 438 if (ret < 0) 439 dev_err(&cldev->dev, "cannot connect\n"); 440 441 out: 442 mutex_unlock(&bus->device_lock); 443 444 return ret; 445 } 446 EXPORT_SYMBOL_GPL(mei_cldev_enable); 447 448 /** 449 * mei_cldev_disable - disable me client device 450 * disconnect form the me client 451 * 452 * @cldev: me client device 453 * 454 * Return: 0 on success and < 0 on error 455 */ 456 int mei_cldev_disable(struct mei_cl_device *cldev) 457 { 458 struct mei_device *bus; 459 struct mei_cl *cl; 460 int err; 461 462 if (!cldev || !cldev->cl) 463 return -ENODEV; 464 465 cl = cldev->cl; 466 467 bus = cldev->bus; 468 469 cldev->event_cb = NULL; 470 471 mutex_lock(&bus->device_lock); 472 473 if (!mei_cl_is_connected(cl)) { 474 dev_err(bus->dev, "Already disconnected"); 475 err = 0; 476 goto out; 477 } 478 479 err = mei_cl_disconnect(cl); 480 if (err < 0) 481 dev_err(bus->dev, "Could not disconnect from the ME client"); 482 483 out: 484 /* Flush queues and remove any pending read */ 485 mei_cl_flush_queues(cl, NULL); 486 mei_cl_unlink(cl); 487 488 kfree(cl); 489 cldev->cl = NULL; 490 491 mutex_unlock(&bus->device_lock); 492 return err; 493 } 494 EXPORT_SYMBOL_GPL(mei_cldev_disable); 495 496 /** 497 * mei_cl_device_find - find matching entry in the driver id table 498 * 499 * @cldev: me client device 500 * @cldrv: me client driver 501 * 502 * Return: id on success; NULL if no id is matching 503 */ 504 static const 505 struct mei_cl_device_id *mei_cl_device_find(struct mei_cl_device *cldev, 506 struct mei_cl_driver *cldrv) 507 { 508 const struct mei_cl_device_id *id; 509 const uuid_le *uuid; 510 u8 version; 511 bool match; 512 513 uuid = mei_me_cl_uuid(cldev->me_cl); 514 version = mei_me_cl_ver(cldev->me_cl); 515 516 id = cldrv->id_table; 517 while (uuid_le_cmp(NULL_UUID_LE, id->uuid)) { 518 if (!uuid_le_cmp(*uuid, id->uuid)) { 519 match = true; 520 521 if (cldev->name[0]) 522 if (strncmp(cldev->name, id->name, 523 sizeof(id->name))) 524 match = false; 525 526 if (id->version != MEI_CL_VERSION_ANY) 527 if (id->version != version) 528 match = false; 529 if (match) 530 return id; 531 } 532 533 id++; 534 } 535 536 return NULL; 537 } 538 539 /** 540 * mei_cl_device_match - device match function 541 * 542 * @dev: device 543 * @drv: driver 544 * 545 * Return: 1 if matching device was found 0 otherwise 546 */ 547 static int mei_cl_device_match(struct device *dev, struct device_driver *drv) 548 { 549 struct mei_cl_device *cldev = to_mei_cl_device(dev); 550 struct mei_cl_driver *cldrv = to_mei_cl_driver(drv); 551 const struct mei_cl_device_id *found_id; 552 553 if (!cldev) 554 return 0; 555 556 if (!cldev->do_match) 557 return 0; 558 559 if (!cldrv || !cldrv->id_table) 560 return 0; 561 562 found_id = mei_cl_device_find(cldev, cldrv); 563 if (found_id) 564 return 1; 565 566 return 0; 567 } 568 569 /** 570 * mei_cl_device_probe - bus probe function 571 * 572 * @dev: device 573 * 574 * Return: 0 on success; < 0 otherwise 575 */ 576 static int mei_cl_device_probe(struct device *dev) 577 { 578 struct mei_cl_device *cldev; 579 struct mei_cl_driver *cldrv; 580 const struct mei_cl_device_id *id; 581 582 cldev = to_mei_cl_device(dev); 583 cldrv = to_mei_cl_driver(dev->driver); 584 585 if (!cldev) 586 return 0; 587 588 if (!cldrv || !cldrv->probe) 589 return -ENODEV; 590 591 id = mei_cl_device_find(cldev, cldrv); 592 if (!id) 593 return -ENODEV; 594 595 __module_get(THIS_MODULE); 596 597 return cldrv->probe(cldev, id); 598 } 599 600 /** 601 * mei_cl_device_remove - remove device from the bus 602 * 603 * @dev: device 604 * 605 * Return: 0 on success; < 0 otherwise 606 */ 607 static int mei_cl_device_remove(struct device *dev) 608 { 609 struct mei_cl_device *cldev = to_mei_cl_device(dev); 610 struct mei_cl_driver *cldrv; 611 int ret = 0; 612 613 if (!cldev || !dev->driver) 614 return 0; 615 616 if (cldev->event_cb) { 617 cldev->event_cb = NULL; 618 cancel_work_sync(&cldev->event_work); 619 } 620 621 cldrv = to_mei_cl_driver(dev->driver); 622 if (cldrv->remove) 623 ret = cldrv->remove(cldev); 624 625 module_put(THIS_MODULE); 626 dev->driver = NULL; 627 return ret; 628 629 } 630 631 static ssize_t name_show(struct device *dev, struct device_attribute *a, 632 char *buf) 633 { 634 struct mei_cl_device *cldev = to_mei_cl_device(dev); 635 size_t len; 636 637 len = snprintf(buf, PAGE_SIZE, "%s", cldev->name); 638 639 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 640 } 641 static DEVICE_ATTR_RO(name); 642 643 static ssize_t uuid_show(struct device *dev, struct device_attribute *a, 644 char *buf) 645 { 646 struct mei_cl_device *cldev = to_mei_cl_device(dev); 647 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 648 size_t len; 649 650 len = snprintf(buf, PAGE_SIZE, "%pUl", uuid); 651 652 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 653 } 654 static DEVICE_ATTR_RO(uuid); 655 656 static ssize_t version_show(struct device *dev, struct device_attribute *a, 657 char *buf) 658 { 659 struct mei_cl_device *cldev = to_mei_cl_device(dev); 660 u8 version = mei_me_cl_ver(cldev->me_cl); 661 size_t len; 662 663 len = snprintf(buf, PAGE_SIZE, "%02X", version); 664 665 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 666 } 667 static DEVICE_ATTR_RO(version); 668 669 static ssize_t modalias_show(struct device *dev, struct device_attribute *a, 670 char *buf) 671 { 672 struct mei_cl_device *cldev = to_mei_cl_device(dev); 673 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 674 size_t len; 675 676 len = snprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid); 677 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 678 } 679 static DEVICE_ATTR_RO(modalias); 680 681 static struct attribute *mei_cldev_attrs[] = { 682 &dev_attr_name.attr, 683 &dev_attr_uuid.attr, 684 &dev_attr_version.attr, 685 &dev_attr_modalias.attr, 686 NULL, 687 }; 688 ATTRIBUTE_GROUPS(mei_cldev); 689 690 /** 691 * mei_cl_device_uevent - me client bus uevent handler 692 * 693 * @dev: device 694 * @env: uevent kobject 695 * 696 * Return: 0 on success -ENOMEM on when add_uevent_var fails 697 */ 698 static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env) 699 { 700 struct mei_cl_device *cldev = to_mei_cl_device(dev); 701 const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl); 702 u8 version = mei_me_cl_ver(cldev->me_cl); 703 704 if (add_uevent_var(env, "MEI_CL_VERSION=%d", version)) 705 return -ENOMEM; 706 707 if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid)) 708 return -ENOMEM; 709 710 if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name)) 711 return -ENOMEM; 712 713 if (add_uevent_var(env, "MODALIAS=mei:%s:%pUl:%02X:", 714 cldev->name, uuid, version)) 715 return -ENOMEM; 716 717 return 0; 718 } 719 720 static struct bus_type mei_cl_bus_type = { 721 .name = "mei", 722 .dev_groups = mei_cldev_groups, 723 .match = mei_cl_device_match, 724 .probe = mei_cl_device_probe, 725 .remove = mei_cl_device_remove, 726 .uevent = mei_cl_device_uevent, 727 }; 728 729 static struct mei_device *mei_dev_bus_get(struct mei_device *bus) 730 { 731 if (bus) 732 get_device(bus->dev); 733 734 return bus; 735 } 736 737 static void mei_dev_bus_put(struct mei_device *bus) 738 { 739 if (bus) 740 put_device(bus->dev); 741 } 742 743 static void mei_cl_bus_dev_release(struct device *dev) 744 { 745 struct mei_cl_device *cldev = to_mei_cl_device(dev); 746 747 if (!cldev) 748 return; 749 750 mei_me_cl_put(cldev->me_cl); 751 mei_dev_bus_put(cldev->bus); 752 kfree(cldev); 753 } 754 755 static struct device_type mei_cl_device_type = { 756 .release = mei_cl_bus_dev_release, 757 }; 758 759 /** 760 * mei_cl_bus_set_name - set device name for me client device 761 * 762 * @cldev: me client device 763 */ 764 static inline void mei_cl_bus_set_name(struct mei_cl_device *cldev) 765 { 766 dev_set_name(&cldev->dev, "mei:%s:%pUl:%02X", 767 cldev->name, 768 mei_me_cl_uuid(cldev->me_cl), 769 mei_me_cl_ver(cldev->me_cl)); 770 } 771 772 /** 773 * mei_cl_bus_dev_alloc - initialize and allocate mei client device 774 * 775 * @bus: mei device 776 * @me_cl: me client 777 * 778 * Return: allocated device structur or NULL on allocation failure 779 */ 780 static struct mei_cl_device *mei_cl_bus_dev_alloc(struct mei_device *bus, 781 struct mei_me_client *me_cl) 782 { 783 struct mei_cl_device *cldev; 784 785 cldev = kzalloc(sizeof(struct mei_cl_device), GFP_KERNEL); 786 if (!cldev) 787 return NULL; 788 789 device_initialize(&cldev->dev); 790 cldev->dev.parent = bus->dev; 791 cldev->dev.bus = &mei_cl_bus_type; 792 cldev->dev.type = &mei_cl_device_type; 793 cldev->bus = mei_dev_bus_get(bus); 794 cldev->me_cl = mei_me_cl_get(me_cl); 795 mei_cl_bus_set_name(cldev); 796 cldev->is_added = 0; 797 INIT_LIST_HEAD(&cldev->bus_list); 798 799 return cldev; 800 } 801 802 /** 803 * mei_cl_dev_setup - setup me client device 804 * run fix up routines and set the device name 805 * 806 * @bus: mei device 807 * @cldev: me client device 808 * 809 * Return: true if the device is eligible for enumeration 810 */ 811 static bool mei_cl_bus_dev_setup(struct mei_device *bus, 812 struct mei_cl_device *cldev) 813 { 814 cldev->do_match = 1; 815 mei_cl_bus_dev_fixup(cldev); 816 817 /* the device name can change during fix up */ 818 if (cldev->do_match) 819 mei_cl_bus_set_name(cldev); 820 821 return cldev->do_match == 1; 822 } 823 824 /** 825 * mei_cl_bus_dev_add - add me client devices 826 * 827 * @cldev: me client device 828 * 829 * Return: 0 on success; < 0 on failre 830 */ 831 static int mei_cl_bus_dev_add(struct mei_cl_device *cldev) 832 { 833 int ret; 834 835 dev_dbg(cldev->bus->dev, "adding %pUL:%02X\n", 836 mei_me_cl_uuid(cldev->me_cl), 837 mei_me_cl_ver(cldev->me_cl)); 838 ret = device_add(&cldev->dev); 839 if (!ret) 840 cldev->is_added = 1; 841 842 return ret; 843 } 844 845 /** 846 * mei_cl_bus_dev_stop - stop the driver 847 * 848 * @cldev: me client device 849 */ 850 static void mei_cl_bus_dev_stop(struct mei_cl_device *cldev) 851 { 852 if (cldev->is_added) 853 device_release_driver(&cldev->dev); 854 } 855 856 /** 857 * mei_cl_bus_dev_destroy - destroy me client devices object 858 * 859 * @cldev: me client device 860 * 861 * Locking: called under "dev->cl_bus_lock" lock 862 */ 863 static void mei_cl_bus_dev_destroy(struct mei_cl_device *cldev) 864 { 865 866 WARN_ON(!mutex_is_locked(&cldev->bus->cl_bus_lock)); 867 868 if (!cldev->is_added) 869 return; 870 871 device_del(&cldev->dev); 872 873 list_del_init(&cldev->bus_list); 874 875 cldev->is_added = 0; 876 put_device(&cldev->dev); 877 } 878 879 /** 880 * mei_cl_bus_remove_device - remove a devices form the bus 881 * 882 * @cldev: me client device 883 */ 884 static void mei_cl_bus_remove_device(struct mei_cl_device *cldev) 885 { 886 mei_cl_bus_dev_stop(cldev); 887 mei_cl_bus_dev_destroy(cldev); 888 } 889 890 /** 891 * mei_cl_bus_remove_devices - remove all devices form the bus 892 * 893 * @bus: mei device 894 */ 895 void mei_cl_bus_remove_devices(struct mei_device *bus) 896 { 897 struct mei_cl_device *cldev, *next; 898 899 mutex_lock(&bus->cl_bus_lock); 900 list_for_each_entry_safe(cldev, next, &bus->device_list, bus_list) 901 mei_cl_bus_remove_device(cldev); 902 mutex_unlock(&bus->cl_bus_lock); 903 } 904 905 906 /** 907 * mei_cl_bus_dev_init - allocate and initializes an mei client devices 908 * based on me client 909 * 910 * @bus: mei device 911 * @me_cl: me client 912 * 913 * Locking: called under "dev->cl_bus_lock" lock 914 */ 915 static void mei_cl_bus_dev_init(struct mei_device *bus, 916 struct mei_me_client *me_cl) 917 { 918 struct mei_cl_device *cldev; 919 920 WARN_ON(!mutex_is_locked(&bus->cl_bus_lock)); 921 922 dev_dbg(bus->dev, "initializing %pUl", mei_me_cl_uuid(me_cl)); 923 924 if (me_cl->bus_added) 925 return; 926 927 cldev = mei_cl_bus_dev_alloc(bus, me_cl); 928 if (!cldev) 929 return; 930 931 me_cl->bus_added = true; 932 list_add_tail(&cldev->bus_list, &bus->device_list); 933 934 } 935 936 /** 937 * mei_cl_bus_rescan - scan me clients list and add create 938 * devices for eligible clients 939 * 940 * @bus: mei device 941 */ 942 void mei_cl_bus_rescan(struct mei_device *bus) 943 { 944 struct mei_cl_device *cldev, *n; 945 struct mei_me_client *me_cl; 946 947 mutex_lock(&bus->cl_bus_lock); 948 949 down_read(&bus->me_clients_rwsem); 950 list_for_each_entry(me_cl, &bus->me_clients, list) 951 mei_cl_bus_dev_init(bus, me_cl); 952 up_read(&bus->me_clients_rwsem); 953 954 list_for_each_entry_safe(cldev, n, &bus->device_list, bus_list) { 955 956 if (!mei_me_cl_is_active(cldev->me_cl)) { 957 mei_cl_bus_remove_device(cldev); 958 continue; 959 } 960 961 if (cldev->is_added) 962 continue; 963 964 if (mei_cl_bus_dev_setup(bus, cldev)) 965 mei_cl_bus_dev_add(cldev); 966 else { 967 list_del_init(&cldev->bus_list); 968 put_device(&cldev->dev); 969 } 970 } 971 mutex_unlock(&bus->cl_bus_lock); 972 973 dev_dbg(bus->dev, "rescan end"); 974 } 975 976 int __mei_cldev_driver_register(struct mei_cl_driver *cldrv, 977 struct module *owner) 978 { 979 int err; 980 981 cldrv->driver.name = cldrv->name; 982 cldrv->driver.owner = owner; 983 cldrv->driver.bus = &mei_cl_bus_type; 984 985 err = driver_register(&cldrv->driver); 986 if (err) 987 return err; 988 989 pr_debug("mei: driver [%s] registered\n", cldrv->driver.name); 990 991 return 0; 992 } 993 EXPORT_SYMBOL_GPL(__mei_cldev_driver_register); 994 995 void mei_cldev_driver_unregister(struct mei_cl_driver *cldrv) 996 { 997 driver_unregister(&cldrv->driver); 998 999 pr_debug("mei: driver [%s] unregistered\n", cldrv->driver.name); 1000 } 1001 EXPORT_SYMBOL_GPL(mei_cldev_driver_unregister); 1002 1003 1004 int __init mei_cl_bus_init(void) 1005 { 1006 return bus_register(&mei_cl_bus_type); 1007 } 1008 1009 void __exit mei_cl_bus_exit(void) 1010 { 1011 bus_unregister(&mei_cl_bus_type); 1012 } 1013 1014 1015 1016 1017 1018 /* LDV_COMMENT_BEGIN_MAIN */ 1019 #ifdef LDV_MAIN7_sequence_infinite_withcheck_stateful 1020 1021 /*###########################################################################*/ 1022 1023 /*############## Driver Environment Generator 0.2 output ####################*/ 1024 1025 /*###########################################################################*/ 1026 1027 1028 1029 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 1030 void ldv_check_final_state(void); 1031 1032 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 1033 void ldv_check_return_value(int res); 1034 1035 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 1036 void ldv_check_return_value_probe(int res); 1037 1038 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 1039 void ldv_initialize(void); 1040 1041 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 1042 void ldv_handler_precall(void); 1043 1044 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 1045 int nondet_int(void); 1046 1047 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 1048 int LDV_IN_INTERRUPT; 1049 1050 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 1051 void ldv_main7_sequence_infinite_withcheck_stateful(void) { 1052 1053 1054 1055 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 1056 /*============================= VARIABLE DECLARATION PART =============================*/ 1057 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1058 /* content: static int mei_cl_device_match(struct device *dev, struct device_driver *drv)*/ 1059 /* LDV_COMMENT_BEGIN_PREP */ 1060 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1061 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1062 /* LDV_COMMENT_END_PREP */ 1063 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_match" */ 1064 struct device * var_group1; 1065 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_match" */ 1066 struct device_driver * var_group2; 1067 /* content: static int mei_cl_device_probe(struct device *dev)*/ 1068 /* LDV_COMMENT_BEGIN_PREP */ 1069 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1070 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1071 /* LDV_COMMENT_END_PREP */ 1072 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "mei_cl_device_probe" */ 1073 static int res_mei_cl_device_probe_17; 1074 /* content: static int mei_cl_device_remove(struct device *dev)*/ 1075 /* LDV_COMMENT_BEGIN_PREP */ 1076 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1077 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1078 /* LDV_COMMENT_END_PREP */ 1079 /* content: static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env)*/ 1080 /* LDV_COMMENT_BEGIN_PREP */ 1081 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1082 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1083 /* LDV_COMMENT_END_PREP */ 1084 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mei_cl_device_uevent" */ 1085 struct kobj_uevent_env * var_group3; 1086 1087 /** STRUCT: struct type: device_type, struct name: mei_cl_device_type **/ 1088 /* content: static void mei_cl_bus_dev_release(struct device *dev)*/ 1089 /* LDV_COMMENT_BEGIN_PREP */ 1090 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1091 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1092 /* LDV_COMMENT_END_PREP */ 1093 1094 1095 1096 1097 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 1098 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 1099 /*============================= VARIABLE INITIALIZING PART =============================*/ 1100 LDV_IN_INTERRUPT=1; 1101 1102 1103 1104 1105 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 1106 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 1107 /*============================= FUNCTION CALL SECTION =============================*/ 1108 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 1109 ldv_initialize(); 1110 int ldv_s_mei_cl_bus_type_bus_type = 0; 1111 1112 1113 int ldv_s_mei_cl_device_type_device_type = 0; 1114 1115 1116 while( nondet_int() 1117 || !(ldv_s_mei_cl_bus_type_bus_type == 0) 1118 || !(ldv_s_mei_cl_device_type_device_type == 0) 1119 ) { 1120 1121 switch(nondet_int()) { 1122 1123 case 0: { 1124 1125 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1126 if(ldv_s_mei_cl_bus_type_bus_type==0) { 1127 1128 /* content: static int mei_cl_device_probe(struct device *dev)*/ 1129 /* LDV_COMMENT_BEGIN_PREP */ 1130 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1131 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1132 /* LDV_COMMENT_END_PREP */ 1133 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "mei_cl_bus_type". Standart function test for correct return result. */ 1134 res_mei_cl_device_probe_17 = mei_cl_device_probe( var_group1); 1135 ldv_check_return_value(res_mei_cl_device_probe_17); 1136 ldv_check_return_value_probe(res_mei_cl_device_probe_17); 1137 if(res_mei_cl_device_probe_17) 1138 goto ldv_module_exit; 1139 ldv_s_mei_cl_bus_type_bus_type++; 1140 1141 } 1142 1143 } 1144 1145 break; 1146 case 1: { 1147 1148 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1149 if(ldv_s_mei_cl_bus_type_bus_type==1) { 1150 1151 /* content: static int mei_cl_device_remove(struct device *dev)*/ 1152 /* LDV_COMMENT_BEGIN_PREP */ 1153 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1154 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1155 /* LDV_COMMENT_END_PREP */ 1156 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "mei_cl_bus_type" */ 1157 ldv_handler_precall(); 1158 mei_cl_device_remove( var_group1); 1159 ldv_s_mei_cl_bus_type_bus_type=0; 1160 1161 } 1162 1163 } 1164 1165 break; 1166 case 2: { 1167 1168 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1169 1170 1171 /* content: static int mei_cl_device_match(struct device *dev, struct device_driver *drv)*/ 1172 /* LDV_COMMENT_BEGIN_PREP */ 1173 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1174 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1175 /* LDV_COMMENT_END_PREP */ 1176 /* LDV_COMMENT_FUNCTION_CALL Function from field "match" from driver structure with callbacks "mei_cl_bus_type" */ 1177 ldv_handler_precall(); 1178 mei_cl_device_match( var_group1, var_group2); 1179 1180 1181 1182 1183 } 1184 1185 break; 1186 case 3: { 1187 1188 /** STRUCT: struct type: bus_type, struct name: mei_cl_bus_type **/ 1189 1190 1191 /* content: static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env)*/ 1192 /* LDV_COMMENT_BEGIN_PREP */ 1193 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1194 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1195 /* LDV_COMMENT_END_PREP */ 1196 /* LDV_COMMENT_FUNCTION_CALL Function from field "uevent" from driver structure with callbacks "mei_cl_bus_type" */ 1197 ldv_handler_precall(); 1198 mei_cl_device_uevent( var_group1, var_group3); 1199 1200 1201 1202 1203 } 1204 1205 break; 1206 case 4: { 1207 1208 /** STRUCT: struct type: device_type, struct name: mei_cl_device_type **/ 1209 if(ldv_s_mei_cl_device_type_device_type==0) { 1210 1211 /* content: static void mei_cl_bus_dev_release(struct device *dev)*/ 1212 /* LDV_COMMENT_BEGIN_PREP */ 1213 #define to_mei_cl_driver(d) container_of(d, struct mei_cl_driver, driver) 1214 #define to_mei_cl_device(d) container_of(d, struct mei_cl_device, dev) 1215 /* LDV_COMMENT_END_PREP */ 1216 /* LDV_COMMENT_FUNCTION_CALL Function from field "release" from driver structure with callbacks "mei_cl_device_type" */ 1217 ldv_handler_precall(); 1218 mei_cl_bus_dev_release( var_group1); 1219 ldv_s_mei_cl_device_type_device_type=0; 1220 1221 } 1222 1223 } 1224 1225 break; 1226 default: break; 1227 1228 } 1229 1230 } 1231 1232 ldv_module_exit: 1233 1234 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 1235 ldv_final: ldv_check_final_state(); 1236 1237 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 1238 return; 1239 1240 } 1241 #endif 1242 1243 /* LDV_COMMENT_END_MAIN */ 1244 1245 #line 14 "/home/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.4-rc1.tar.xz--X--08_1a/linux-4.4-rc1.tar.xz/csd_deg_dscv/3928/dscv_tempdir/dscv/ri/08_1a/drivers/misc/mei/bus.o.c.prepared"
1 2 3 #include <verifier/rcv.h> 4 #include <kernel-model/ERR.inc> 5 6 /* Module locks counter (1 is the initial state; it shouldn't go lower). We do not distinguish different modules. */ 7 int ldv_module_refcounter = 1; 8 9 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_module_get') Increment module reference counter (unless the module pointer is NULL). */ 10 void ldv_module_get(struct module *module) 11 { 12 /* LDV_COMMENT_OTHER Do nothing if the module pointer is NULL */ 13 if (module){ 14 /* LDV_COMMENT_CHANGE_STATE Increment module reference counter. */ 15 ldv_module_refcounter++; 16 } 17 } 18 19 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_try_module_get') Try to get module. The operation may succeed and return 1, or fail and return 0. */ 20 int ldv_try_module_get(struct module *module) 21 { 22 int module_get_succeeded; 23 24 /* LDV_COMMENT_OTHER Do nothing if the module pointer is NULL */ 25 if (module){ 26 27 /* LDV_COMMENT_OTHER Model success or failure of getting the module. */ 28 module_get_succeeded = ldv_undef_int(); 29 30 if (module_get_succeeded == 1) { 31 /* LDV_COMMENT_CHANGE_STATE Increment module reference counter. */ 32 ldv_module_refcounter++; 33 /* LDV_COMMENT_RETURN Return 1 telling about success. */ 34 return 1; 35 } 36 else 37 { 38 /* LDV_COMMENT_RETURN Return 0 telling that module get has failed.. */ 39 return 0; 40 } 41 } 42 } 43 44 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_module_put') Put module (unless module pointer is zero). Check if the module reference counter was greater than zero. */ 45 void ldv_module_put(struct module *module) 46 { 47 /* LDV_COMMENT_OTHER Do nothing if the module pointer is NULL */ 48 if (module){ 49 /* LDV_COMMENT_ASSERT This assertion fails if the module was put more times than it was got */ 50 ldv_assert(ldv_module_refcounter > 1); 51 /* LDV_COMMENT_CHANGE_STATE Decrease reference counter thus putting the module. */ 52 ldv_module_refcounter--; 53 } 54 } 55 56 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_module_put_and_exit') Put the module and stop execution. */ 57 void ldv_module_put_and_exit(void) 58 { 59 ldv_module_put((struct module*)1); 60 /* LDV_COMMENT_OTHER Stop execution. */ 61 LDV_STOP: goto LDV_STOP; 62 } 63 64 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_module_refcount') Get the reference counter of the module. */ 65 unsigned int ldv_module_refcount(void) 66 { 67 /* LDV_COMMENT_RETURN Return reference counter */ 68 return ldv_module_refcounter - 1; 69 } 70 71 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_final_state') At the end of execution, module reference counter must be the same as at the beginning. */ 72 void ldv_check_final_state(void) 73 { 74 /* LDV_COMMENT_ASSERT If this assertion is violated, then the module was put somewhere duiring the execution, and wasn't got! */ 75 ldv_assert(ldv_module_refcounter == 1); 76 }
1 /* 2 * UUID/GUID definition 3 * 4 * Copyright (C) 2010, Intel Corp. 5 * Huang Ying <ying.huang@intel.com> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License version 9 * 2 as published by the Free Software Foundation; 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 #ifndef _LINUX_UUID_H_ 21 #define _LINUX_UUID_H_ 22 23 #include <uapi/linux/uuid.h> 24 25 26 static inline int uuid_le_cmp(const uuid_le u1, const uuid_le u2) 27 { 28 return memcmp(&u1, &u2, sizeof(uuid_le)); 29 } 30 31 static inline int uuid_be_cmp(const uuid_be u1, const uuid_be u2) 32 { 33 return memcmp(&u1, &u2, sizeof(uuid_be)); 34 } 35 36 extern void uuid_le_gen(uuid_le *u); 37 extern void uuid_be_gen(uuid_be *u); 38 39 #endif

Here is an explanation of a rule violation arisen while checking your driver against a corresponding kernel.

Note that it may be false positive, i.e. there isn't a real error indeed. Please analyze a given error trace and related source code to understand whether there is an error in your driver.

Error trace column contains a path on which the given rule is violated. You can expand/collapse some entity classes by clicking on corresponding checkboxes in a main menu or in an advanced Others menu. Also you can expand/collapse each particular entity by clicking on +/-. In hovering on some entities you can see some tips. Also the error trace is bound with related source code. Line numbers may be shown as links on the left. You can click on them to open corresponding lines in source code.

Source code column contains a content of files related with the error trace. There is source code of your driver (note that there are some LDV modifications at the end), kernel headers and rule model. Tabs show a currently opened file and other available files. In hovering on them you can see full file names. On clicking a corresponding file content will be shown.

Kernel Module Rule Verifier Verdict Status Timestamp Bug report
linux-4.4-rc1.tar.xz drivers/misc/mei/mei.ko 08_1a BLAST Bug Fixed 2016-03-18 19:03:05 L0226

Comment

if cldrv->probe fails module should be put

[Home]