Error Trace
[Home]
Bug # 123
Show/hide error trace| Error trace
-__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() { 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 */} 1107 tmp = nondet_int() { /* Function call is skipped due to function is undefined */} { { { 68 __retres2 = &(&(me_cl)->props)->protocol_name; 66 return __retres2; } { 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; { 28 tmp = memcmp(&(u1), &(u2), 16) { /* Function call is skipped due to function is undefined */} } { 28 tmp = memcmp(&(u1), &(u2), 16) { /* Function call is skipped due to function is undefined */} } 505 match = 1; 516 __retres11 = id; } 583 tmp = *(*(cldrv).probe)(cldev, id) { /* Function call is skipped due to function is undefined */} 583 __retres9 = tmp; } 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 */} } | 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]
»