LCOV - code coverage report
Current view: top level - home/alexey/klever/native-scheduler-work-dir/native-scheduler-work-dir/scheduler/jobs/032ed983781f2acce615a4df71b22f31/klever-core-work-dir/fcfcc6e/linux-drivers-clk2/avtg/drivers/i2c/i2c-core.ko/linux:drivers:clk2/weaver - i2c-core.c.aux (source / functions) Hit Total Coverage
Test: coverage.info Lines: 483 491 98.4 %
Date: 2017-01-25 Functions: 60 60 100.0 %

          Line data    Source code
       1             : 
       2             : struct device;
       3             : 
       4             : void *ldv_dev_get_drvdata(const struct device *dev);
       5             : int ldv_dev_set_drvdata(struct device *dev, void *data);
       6             : 
       7             : struct spi_master;
       8             : struct device;
       9             : struct spi_master *ldv_spi_alloc_master(struct device *host, unsigned size);
      10             : 
      11             : #include <linux/ldv/err.h>
      12             : 
      13             : #include <linux/types.h>
      14             : void *ldv_kzalloc(size_t size, gfp_t flags);
      15             : 
      16             : struct clk;
      17             : 
      18             : extern void ldv_clk_disable(struct clk *clk);
      19             : extern int ldv_clk_enable(void);
      20             : 
      21             : #include <linux/ldv/common.h>
      22             : #include <linux/ldv/irq.h>
      23             : #include <verifier/common.h>
      24             : #include <verifier/nondet.h>
      25             : #include <verifier/memory.h>
      26             : #include <verifier/thread.h>
      27             : 
      28             : #include <linux/device.h>
      29             : #include <linux/platform_device.h>
      30             : #include <linux/rtc.h>
      31             : 
      32             : 
      33             : struct ldv_struct_platform_instance_3 {
      34             :  int signal_pending;
      35             : };
      36             : 
      37             : /* EMG Function declarations */
      38             : void ldv_dispatch_default_deregister_1_10_4(void);
      39             : void ldv_dispatch_default_deregister_3_10_5(void);
      40             : void ldv_dispatch_default_deregister_4_10_6(void);
      41             : void ldv_dispatch_default_deregister_5_10_7(void);
      42             : void ldv_dispatch_default_register_1_10_11(void);
      43             : void ldv_dispatch_default_register_3_10_10(void);
      44             : void ldv_dispatch_default_register_4_10_9(void);
      45             : void ldv_dispatch_default_register_5_10_8(void);
      46             : void ldv_dispatch_insmod_deregister_11_2(void);
      47             : void ldv_dispatch_insmod_register_11_3(void);
      48             : void ldv_dispatch_pm_deregister_3_5(void);
      49             : void ldv_dispatch_pm_register_3_6(void);
      50             : void ldv_insmod_10(void *);
      51             : void ldv_insmod_i2c_exit_10_2(void (*)(void));
      52             : int ldv_insmod_i2c_init_10_15(int (*)(void));
      53             : void ldv_main_11(void *);
      54             : void ldv_partially_ordered_scenario_1(void *);
      55             : int ldv_partially_ordered_scenario_probe_1_12(int (*)(struct i2c_client *, struct i2c_device_id *), struct i2c_client *, struct i2c_device_id *);
      56             : void ldv_partially_ordered_scenario_release_1_2(int (*)(struct i2c_client *), struct i2c_client *);
      57             : void ldv_platform_instance_3(void *);
      58             : int ldv_platform_instance_probe_3_15(int (*)(struct platform_device *), struct platform_device *);
      59             : void ldv_platform_instance_release_3_3(int (*)(struct platform_device *), struct platform_device *);
      60             : void ldv_pm_ops_scenario_2(void *);
      61             : void ldv_pm_ops_scenario_complete_2_3(void (*)(struct device *), struct device *);
      62             : void ldv_pm_ops_scenario_freeze_2_13(int (*)(struct device *), struct device *);
      63             : void ldv_pm_ops_scenario_freeze_noirq_2_11(int (*)(struct device *), struct device *);
      64             : void ldv_pm_ops_scenario_poweroff_2_8(int (*)(struct device *), struct device *);
      65             : void ldv_pm_ops_scenario_poweroff_noirq_2_7(int (*)(struct device *), struct device *);
      66             : void ldv_pm_ops_scenario_prepare_2_19(int (*)(struct device *), struct device *);
      67             : void ldv_pm_ops_scenario_restore_2_4(int (*)(struct device *), struct device *);
      68             : void ldv_pm_ops_scenario_restore_noirq_2_6(int (*)(struct device *), struct device *);
      69             : void ldv_pm_ops_scenario_resume_2_14(int (*)(struct device *), struct device *);
      70             : void ldv_pm_ops_scenario_resume_noirq_2_16(int (*)(struct device *), struct device *);
      71             : void ldv_pm_ops_scenario_runtime_idle_2_24(int (*)(struct device *), struct device *);
      72             : void ldv_pm_ops_scenario_runtime_resume_2_21(int (*)(struct device *), struct device *);
      73             : void ldv_pm_ops_scenario_runtime_suspend_2_22(int (*)(struct device *), struct device *);
      74             : void ldv_pm_ops_scenario_suspend_2_18(int (*)(struct device *), struct device *);
      75             : void ldv_pm_ops_scenario_suspend_noirq_2_17(int (*)(struct device *), struct device *);
      76             : void ldv_pm_ops_scenario_thaw_2_9(int (*)(struct device *), struct device *);
      77             : void ldv_pm_ops_scenario_thaw_noirq_2_10(int (*)(struct device *), struct device *);
      78             : void ldv_random_containerless_scenario_6(void *);
      79             : void ldv_random_containerless_scenario_7(void *);
      80             : void ldv_random_containerless_scenario_8(void *);
      81             : void ldv_random_containerless_scenario_9(void *);
      82             : void ldv_random_containerless_scenario_callback_6_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
      83             : void ldv_random_containerless_scenario_callback_6_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
      84             : void ldv_random_containerless_scenario_callback_7_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
      85             : void ldv_random_containerless_scenario_callback_7_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
      86             : void ldv_random_containerless_scenario_callback_8_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
      87             : void ldv_random_containerless_scenario_callback_8_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
      88             : void ldv_random_containerless_scenario_callback_9_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
      89             : void ldv_random_containerless_scenario_callback_9_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
      90             : void ldv_rtc_class_scenario_4(void *);
      91             : void ldv_rtc_class_scenario_5(void *);
      92             : int ldv_rtc_class_scenario_probe_4_11(int (*)(struct device *), struct device *);
      93             : int ldv_rtc_class_scenario_probe_5_11(int (*)(struct device *), struct device *);
      94             : void ldv_rtc_class_scenario_release_4_2(void (*)(struct device *), struct device *);
      95             : void ldv_rtc_class_scenario_release_5_2(void (*)(struct device *), struct device *);
      96             : int main(void);
      97             : 
      98             : /* EMG variable declarations */
      99           1 : struct ldv_thread ldv_thread_1;
     100           1 : struct ldv_thread ldv_thread_10;
     101           1 : struct ldv_thread ldv_thread_11;
     102           1 : struct ldv_thread ldv_thread_2;
     103           1 : struct ldv_thread ldv_thread_3;
     104           1 : struct ldv_thread ldv_thread_4;
     105           1 : struct ldv_thread ldv_thread_5;
     106           1 : struct ldv_thread ldv_thread_6;
     107           1 : struct ldv_thread ldv_thread_7;
     108           1 : struct ldv_thread ldv_thread_8;
     109           1 : struct ldv_thread ldv_thread_9;
     110             : 
     111             : /* EMG variable initialization */
     112             : 
     113             : /* EMG function definitions */
     114             : /* AUX_FUNC ldv_dispatch_default_deregister_1_10_4 */
     115             : void ldv_dispatch_default_deregister_1_10_4() {
     116             :  struct ldv_struct_platform_instance_3 *cf_arg_1;
     117             :  /* Skip thread join call */
     118           1 :  return;
     119             : }
     120             : 
     121             : /* AUX_FUNC ldv_dispatch_default_deregister_3_10_5 */
     122             : void ldv_dispatch_default_deregister_3_10_5() {
     123             :  struct ldv_struct_platform_instance_3 *cf_arg_3;
     124             :  /* Skip thread join call */
     125           1 :  return;
     126             : }
     127             : 
     128             : /* AUX_FUNC ldv_dispatch_default_deregister_4_10_6 */
     129             : void ldv_dispatch_default_deregister_4_10_6() {
     130             :  struct ldv_struct_platform_instance_3 *cf_arg_4;
     131             :  struct ldv_struct_platform_instance_3 *cf_arg_5;
     132             :  /* Skip thread join call */
     133             :  /* Skip thread join call */
     134           1 :  return;
     135             : }
     136             : 
     137             : /* AUX_FUNC ldv_dispatch_default_deregister_5_10_7 */
     138             : void ldv_dispatch_default_deregister_5_10_7() {
     139             :  struct ldv_struct_platform_instance_3 *cf_arg_8;
     140             :  struct ldv_struct_platform_instance_3 *cf_arg_9;
     141             :  struct ldv_struct_platform_instance_3 *cf_arg_6;
     142             :  struct ldv_struct_platform_instance_3 *cf_arg_7;
     143             :  /* Skip thread join call */
     144             :  /* Skip thread join call */
     145             :  /* Skip thread join call */
     146             :  /* Skip thread join call */
     147           1 :  return;
     148             : }
     149             : 
     150             : /* AUX_FUNC ldv_dispatch_default_register_1_10_11 */
     151             : void ldv_dispatch_default_register_1_10_11() {
     152             :  struct ldv_struct_platform_instance_3 *cf_arg_1;
     153           4 :  cf_arg_1 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     154           3 :  ldv_partially_ordered_scenario_1(cf_arg_1);
     155           1 :  return;
     156             : }
     157             : 
     158             : /* AUX_FUNC ldv_dispatch_default_register_3_10_10 */
     159             : void ldv_dispatch_default_register_3_10_10() {
     160             :  struct ldv_struct_platform_instance_3 *cf_arg_3;
     161           4 :  cf_arg_3 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     162           3 :  ldv_platform_instance_3(cf_arg_3);
     163           1 :  return;
     164             : }
     165             : 
     166             : /* AUX_FUNC ldv_dispatch_default_register_4_10_9 */
     167             : void ldv_dispatch_default_register_4_10_9() {
     168             :  struct ldv_struct_platform_instance_3 *cf_arg_4;
     169           1 :  struct ldv_struct_platform_instance_3 *cf_arg_5;
     170           4 :  cf_arg_4 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     171           3 :  ldv_rtc_class_scenario_4(cf_arg_4);
     172           4 :  cf_arg_5 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     173           2 :  ldv_rtc_class_scenario_5(cf_arg_5);
     174           1 :  return;
     175             : }
     176             : 
     177             : /* AUX_FUNC ldv_dispatch_default_register_5_10_8 */
     178             : void ldv_dispatch_default_register_5_10_8() {
     179             :  struct ldv_struct_platform_instance_3 *cf_arg_8;
     180           1 :  struct ldv_struct_platform_instance_3 *cf_arg_9;
     181           1 :  struct ldv_struct_platform_instance_3 *cf_arg_6;
     182           1 :  struct ldv_struct_platform_instance_3 *cf_arg_7;
     183           4 :  cf_arg_8 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     184           3 :  ldv_random_containerless_scenario_8(cf_arg_8);
     185           4 :  cf_arg_9 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     186           3 :  ldv_random_containerless_scenario_9(cf_arg_9);
     187           4 :  cf_arg_6 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     188           2 :  ldv_random_containerless_scenario_6(cf_arg_6);
     189           3 :  cf_arg_7 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     190           2 :  ldv_random_containerless_scenario_7(cf_arg_7);
     191           1 :  return;
     192             : }
     193             : 
     194             : /* AUX_FUNC ldv_dispatch_insmod_deregister_11_2 */
     195             : void ldv_dispatch_insmod_deregister_11_2() {
     196             :  struct ldv_struct_platform_instance_3 *cf_arg_10;
     197             :  /* Skip thread join call */
     198           1 :  return;
     199             : }
     200             : 
     201             : /* AUX_FUNC ldv_dispatch_insmod_register_11_3 */
     202             : void ldv_dispatch_insmod_register_11_3() {
     203             :  struct ldv_struct_platform_instance_3 *cf_arg_10;
     204           4 :  cf_arg_10 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     205           4 :  ldv_insmod_10(cf_arg_10);
     206           1 :  return;
     207             : }
     208             : 
     209             : /* AUX_FUNC ldv_dispatch_pm_deregister_3_5 */
     210             : void ldv_dispatch_pm_deregister_3_5() {
     211             :  struct ldv_struct_platform_instance_3 *cf_arg_2;
     212             :  /* Skip thread join call */
     213           1 :  return;
     214             : }
     215             : 
     216             : /* AUX_FUNC ldv_dispatch_pm_register_3_6 */
     217             : void ldv_dispatch_pm_register_3_6() {
     218             :  struct ldv_struct_platform_instance_3 *cf_arg_2;
     219           4 :  cf_arg_2 = ldv_xmalloc(sizeof(struct ldv_struct_platform_instance_3));
     220           3 :  ldv_pm_ops_scenario_2(cf_arg_2);
     221           1 :  return;
     222             : }
     223             : 
     224             : /* AUX_FUNC ldv_insmod_10 */
     225             : void ldv_insmod_10(void *arg0) {
     226             :  /* LDV {"thread": 10, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'insmod(artificial)'", "function": "ldv_insmod_10"} */
     227           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     228           1 :  void (*ldv_10_i2c_exit_default)(void);
     229           1 :  int (*ldv_10_i2c_init_default)(void);
     230           1 :  int ldv_10_ret_default;
     231           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     232             :  /* LDV {"action": "INSMOD_REGISTER", "type": "RECEIVE_BEGIN", "comment": "Trigger module initialization."} */
     233           2 :  ldv_free(arg0);
     234             :  /* LDV {"action": "INSMOD_REGISTER", "type": "RECEIVE_END"} */
     235             : 
     236             :  /* LDV {"action": "I2C_INIT", "type": "CALL_BEGIN", "callback": true, "comment": "Initialize the module after insmod with 'i2c_init' function. Invoke callback i2c_init from ARTIFICIAL."} */
     237             :  /* LDV {"type": "CALLBACK", "call": "ldv_10_ret_default = (i2c_init)();", "comment": "i2c_init"} */
     238           2 :  ldv_10_ret_default = ldv_insmod_i2c_init_10_15(ldv_10_i2c_init_default);
     239             :  /* Callback post-call */
     240           2 :  ldv_10_ret_default = ldv_post_init(ldv_10_ret_default);
     241             :  /* LDV {"action": "I2C_INIT", "type": "CALL_END"} */
     242             : 
     243           4 :  if (ldv_undef_int()) {
     244             :   /* LDV {"action": "INIT_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to initialize the module."} */
     245           2 :   ldv_assume(ldv_10_ret_default != 0);
     246             :   /* LDV {"action": "INIT_FAILED", "type": "CONDITION_END"} */
     247             : 
     248             :   /* LDV {"action": "INSMOD_DEREGISTER", "type": "RECEIVE_BEGIN", "comment": "Trigger module exit."} */
     249             :   /* Skip a non-replicative signal receiving */
     250             :   /* LDV {"action": "INSMOD_DEREGISTER", "type": "RECEIVE_END"} */
     251             : 
     252             :   /* Exit function at a terminal state */
     253           1 :   return;
     254             :  }
     255             :  else {
     256             :   /* LDV {"action": "INIT_SUCCESS", "type": "CONDITION_BEGIN", "comment": "Module has been initialized."} */
     257           2 :   ldv_assume(ldv_10_ret_default == 0);
     258             :   /* LDV {"action": "INIT_SUCCESS", "type": "CONDITION_END"} */
     259             : 
     260           4 :   if (ldv_undef_int()) {
     261             :    /* LDV {"action": "DEFAULT_REGISTER_1", "type": "DISPATCH_BEGIN", "comment": "Register 'I2C' callbacks with unknown registration function."} */
     262           2 :    ldv_dispatch_default_register_1_10_11();
     263             :    /* LDV {"action": "DEFAULT_REGISTER_1", "type": "DISPATCH_END"} */
     264             : 
     265             :    /* LDV {"action": "DEFAULT_REGISTER_3", "type": "DISPATCH_BEGIN", "comment": "Register 'PM' callbacks with unknown registration function."} */
     266           2 :    ldv_dispatch_default_register_3_10_10();
     267             :    /* LDV {"action": "DEFAULT_REGISTER_3", "type": "DISPATCH_END"} */
     268             : 
     269             :    /* LDV {"action": "DEFAULT_REGISTER_4", "type": "DISPATCH_BEGIN", "comment": "Register 'RTC' callbacks with unknown registration function."} */
     270           2 :    ldv_dispatch_default_register_4_10_9();
     271             :    /* LDV {"action": "DEFAULT_REGISTER_4", "type": "DISPATCH_END"} */
     272             : 
     273             :    /* LDV {"action": "DEFAULT_REGISTER_5", "type": "DISPATCH_BEGIN", "comment": "Register 'STRUCT_DEVICE_ATTRIBUTE' callbacks with unknown registration function."} */
     274           2 :    ldv_dispatch_default_register_5_10_8();
     275             :    /* LDV {"action": "DEFAULT_REGISTER_5", "type": "DISPATCH_END"} */
     276             : 
     277             :    /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "DISPATCH_BEGIN", "comment": "Deregister 'STRUCT_DEVICE_ATTRIBUTE' callbacks with unknown deregistration function."} */
     278           2 :    ldv_dispatch_default_deregister_5_10_7();
     279             :    /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "DISPATCH_END"} */
     280             : 
     281             :    /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "DISPATCH_BEGIN", "comment": "Deregister 'RTC' callbacks with unknown deregistration function."} */
     282           2 :    ldv_dispatch_default_deregister_4_10_6();
     283             :    /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "DISPATCH_END"} */
     284             : 
     285             :    /* LDV {"action": "DEFAULT_DEREGISTER_3", "type": "DISPATCH_BEGIN", "comment": "Deregister 'PM' callbacks with unknown deregistration function."} */
     286           2 :    ldv_dispatch_default_deregister_3_10_5();
     287             :    /* LDV {"action": "DEFAULT_DEREGISTER_3", "type": "DISPATCH_END"} */
     288             : 
     289             :    /* LDV {"action": "DEFAULT_DEREGISTER_1", "type": "DISPATCH_BEGIN", "comment": "Deregister 'I2C' callbacks with unknown deregistration function."} */
     290           2 :    ldv_dispatch_default_deregister_1_10_4();
     291             :    /* LDV {"action": "DEFAULT_DEREGISTER_1", "type": "DISPATCH_END"} */
     292             : 
     293             :   }
     294             :   else {
     295             :    /* LDV {"action": "NONE", "type": "CONDITION_BEGIN", "comment": "Skip default callbacks registrations and deregistrations."} */
     296             :    /* LDV {"action": "NONE", "type": "CONDITION_END"} */
     297             : 
     298             :   }
     299             :   /* LDV {"action": "I2C_EXIT", "type": "CALL_BEGIN", "callback": true, "comment": "Exit the module before its unloading with 'i2c_exit' function. Invoke callback i2c_exit from ARTIFICIAL."} */
     300             :   /* LDV {"type": "CALLBACK", "call": "(i2c_exit)();", "comment": "i2c_exit"} */
     301           4 :   ldv_insmod_i2c_exit_10_2(ldv_10_i2c_exit_default);
     302             :   /* LDV {"action": "I2C_EXIT", "type": "CALL_END"} */
     303             : 
     304             :   /* LDV {"action": "INSMOD_DEREGISTER", "type": "RECEIVE_BEGIN", "comment": "Trigger module exit."} */
     305             :   /* Skip a non-replicative signal receiving */
     306             :   /* LDV {"action": "INSMOD_DEREGISTER", "type": "RECEIVE_END"} */
     307             : 
     308             :   /* Exit function at a terminal state */
     309           1 :   return;
     310             :  }
     311             :  /* End of the process */
     312             :  return;
     313             :  /* LDV {"comment": "End of control function based on process 'insmod(artificial)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_insmod_10"} */
     314             : }
     315             : 
     316             : /* AUX_FUNC_CALLBACK ldv_insmod_i2c_exit_10_2 */
     317             : void ldv_insmod_i2c_exit_10_2(void (*arg0)(void)) {
     318           4 :  (i2c_exit)();
     319           2 : }
     320             : 
     321             : /* AUX_FUNC_CALLBACK ldv_insmod_i2c_init_10_15 */
     322             : int ldv_insmod_i2c_init_10_15(int (*arg0)(void)) {
     323           4 :  return (i2c_init)();
     324           1 : }
     325             : 
     326             : /* AUX_FUNC ldv_main_11 */
     327             : void ldv_main_11(void *arg0) {
     328             :  /* LDV {"thread": 11, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'main(main)'", "function": "ldv_main_11"} */
     329             :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     330             :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     331             :  /* LDV {"action": "INIT", "type": "CONDITION_BEGIN", "comment": "Initialize rule models."} */
     332           1 :  ldv_initialize();
     333             :  /* LDV {"action": "INIT", "type": "CONDITION_END"} */
     334             : 
     335             :  /* LDV {"action": "INSMOD_REGISTER", "type": "DISPATCH_BEGIN", "comment": "Start environment model scenarios."} */
     336           2 :  ldv_dispatch_insmod_register_11_3();
     337             :  /* LDV {"action": "INSMOD_REGISTER", "type": "DISPATCH_END"} */
     338             : 
     339             :  /* LDV {"action": "INSMOD_DEREGISTER", "type": "DISPATCH_BEGIN", "comment": "Stop environment model scenarios."} */
     340           2 :  ldv_dispatch_insmod_deregister_11_2();
     341             :  /* LDV {"action": "INSMOD_DEREGISTER", "type": "DISPATCH_END"} */
     342             : 
     343             :  /* LDV {"action": "FINAL", "type": "CONDITION_BEGIN", "comment": "Check rule model state at the exit."} */
     344           1 :  ldv_check_final_state();
     345           1 :  ldv_stop();
     346             :  /* LDV {"action": "FINAL", "type": "CONDITION_END"} */
     347             : 
     348             :  /* Exit function at a terminal state */
     349           0 :  return;
     350             :  /* End of the process */
     351             :  return;
     352             :  /* LDV {"comment": "End of control function based on process 'main(main)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_main_11"} */
     353             : }
     354             : 
     355             : /* AUX_FUNC ldv_partially_ordered_scenario_1 */
     356             : void ldv_partially_ordered_scenario_1(void *arg0) {
     357             :  /* LDV {"thread": 1, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'partially_ordered_scenario(i2c)'", "function": "ldv_partially_ordered_scenario_1"} */
     358           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     359           1 :  struct i2c_driver *ldv_1_container_i2c_driver;
     360           1 :  struct i2c_client *ldv_1_resource_client;
     361           1 :  struct i2c_device_id *ldv_1_resource_struct_i2c_device_id;
     362           1 :  int ldv_1_ret_default;
     363           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     364           1 :  /* Initialize automaton variables */
     365           2 :  ldv_1_ret_default = 1;
     366           1 :  /* LDV {"action": "DEFAULT_REGISTER_1", "type": "RECEIVE_BEGIN", "comment": "Begin I2C callbacks invocations scenario."} */
     367           3 :  ldv_free(arg0);
     368             :  /* LDV {"action": "DEFAULT_REGISTER_1", "type": "RECEIVE_END"} */
     369             : 
     370             :  /* LDV {"action": "DEFAULT_ALLOC_1", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     371           3 :  ldv_1_container_i2c_driver = ldv_xmalloc_unknown_size(0);
     372             :  /* LDV {"action": "DEFAULT_ALLOC_1", "type": "CONDITION_END"} */
     373             : 
     374             :  /* LDV {"action": "INIT", "type": "CONDITION_BEGIN", "comment": "Alloc memory for common callback arguments."} */
     375           3 :  ldv_1_resource_client = ldv_xmalloc(sizeof(struct i2c_client));
     376           3 :  ldv_1_resource_struct_i2c_device_id = ldv_xmalloc_unknown_size(0);
     377             :  /* LDV {"action": "INIT", "type": "CONDITION_END"} */
     378             : 
     379             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Start with an initialization callback."} */
     380             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     381             : 
     382             :  /* Jump to a subprocess 'main' initial state */
     383           1 :  goto ldv_main_1;
     384             :  /* End of the process */
     385             :  return;
     386           1 : 
     387             :  /* Sbprocess main */
     388             :  ldv_main_1:
     389             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     390             : 
     391           4 :  if (ldv_undef_int()) {
     392             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Call an initialization callback. Invoke callback probe from i2c_driver."} */
     393             :   /* LDV {"type": "CALLBACK", "call": "ldv_1_ret_default = ((& dummy_probe))(ldv_1_resource_client, ldv_1_resource_struct_i2c_device_id);", "comment": "probe"} */
     394           3 :   ldv_1_ret_default = ldv_partially_ordered_scenario_probe_1_12(ldv_1_container_i2c_driver->probe, ldv_1_resource_client, ldv_1_resource_struct_i2c_device_id);
     395             :   /* Callback post-call */
     396           2 :   ldv_1_ret_default = ldv_filter_err_code(ldv_1_ret_default);
     397             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
     398             : 
     399           4 :   if (ldv_undef_int()) {
     400             :    /* LDV {"action": "Y_RET", "type": "CONDITION_BEGIN", "comment": "Initialization has been successful."} */
     401           2 :    ldv_assume(ldv_1_ret_default == 0);
     402             :    /* LDV {"action": "Y_RET", "type": "CONDITION_END"} */
     403             : 
     404             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Initializations are done, proceed to the other callbacks."} */
     405             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     406             : 
     407             :    /* Jump to a subprocess 'call' initial state */
     408           1 :    goto ldv_call_1;
     409             :   }
     410             :   else {
     411             :    /* LDV {"action": "N_RET", "type": "CONDITION_BEGIN", "comment": "Initialization has failed."} */
     412           2 :    ldv_assume(ldv_1_ret_default != 0);
     413             :    /* LDV {"action": "N_RET", "type": "CONDITION_END"} */
     414             : 
     415             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Start with an initialization callback."} */
     416             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     417             : 
     418             :    /* Jump to a subprocess 'main' initial state */
     419           1 :    goto ldv_main_1;
     420             :   }
     421             :  }
     422             :  else {
     423             :   /* LDV {"action": "FREE", "type": "CONDITION_BEGIN", "comment": "Free memory for common callback arguments."} */
     424           2 :   ldv_free(ldv_1_resource_client);
     425           2 :   ldv_free(ldv_1_resource_struct_i2c_device_id);
     426             :   /* LDV {"action": "FREE", "type": "CONDITION_END"} */
     427             : 
     428             :   /* LDV {"action": "DEFAULT_FREE_1", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     429           2 :   ldv_free(ldv_1_container_i2c_driver);
     430             :   /* LDV {"action": "DEFAULT_FREE_1", "type": "CONDITION_END"} */
     431             : 
     432             :   /* LDV {"action": "DEFAULT_DEREGISTER_1", "type": "RECEIVE_BEGIN", "comment": "Finish I2C callbacks invocations scenario."} */
     433             :   /* Skip a non-replicative signal receiving */
     434             :   /* LDV {"action": "DEFAULT_DEREGISTER_1", "type": "RECEIVE_END"} */
     435             : 
     436             :   /* Exit function at a terminal state */
     437           1 :   return;
     438             :  }
     439             :  /* End of the subprocess 'main' */
     440             :  return;
     441           1 : 
     442             :  /* Sbprocess call */
     443             :  ldv_call_1:
     444             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     445             : 
     446           4 :  if (ldv_undef_int()) {
     447             :   /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "comment": "Call callback 'callback' of a process 'partially_ordered_scenario' of an interface category 'i2c'"} */
     448             :   /* Skip callback without implementations */
     449             :   /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     450             : 
     451             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Initializations are done, proceed to the other callbacks."} */
     452             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     453             : 
     454             :   /* Jump to a subprocess 'call' initial state */
     455           1 :   goto ldv_call_1;
     456             :  }
     457             :  else {
     458             :   /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Do uninitializations before deregistration. Invoke callback remove from i2c_driver."} */
     459             :   /* LDV {"type": "CALLBACK", "call": "((& dummy_remove))(ldv_1_resource_client);", "comment": "release"} */
     460           2 :   ldv_partially_ordered_scenario_release_1_2(ldv_1_container_i2c_driver->remove, ldv_1_resource_client);
     461             :   /* LDV {"action": "RELEASE", "type": "CALL_END"} */
     462             : 
     463             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Start with an initialization callback."} */
     464             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     465             : 
     466             :   /* Jump to a subprocess 'main' initial state */
     467           1 :   goto ldv_main_1;
     468             :  }
     469             :  /* End of the subprocess 'call' */
     470             :  return;
     471             :  /* LDV {"comment": "End of control function based on process 'partially_ordered_scenario(i2c)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_partially_ordered_scenario_1"} */
     472             : }
     473             : 
     474             : /* AUX_FUNC_CALLBACK ldv_partially_ordered_scenario_probe_1_12 */
     475             : int ldv_partially_ordered_scenario_probe_1_12(int (*arg0)(struct i2c_client *, struct i2c_device_id *), struct i2c_client *arg1, struct i2c_device_id *arg2) {
     476           3 :  return ((& dummy_probe))(arg1, arg2);
     477             : }
     478           1 : 
     479             : /* AUX_FUNC_CALLBACK ldv_partially_ordered_scenario_release_1_2 */
     480             : void ldv_partially_ordered_scenario_release_1_2(int (*arg0)(struct i2c_client *), struct i2c_client *arg1) {
     481           2 :  ((& dummy_remove))(arg1);
     482           1 : }
     483             : 
     484             : /* AUX_FUNC ldv_platform_instance_3 */
     485             : void ldv_platform_instance_3(void *arg0) {
     486             :  /* LDV {"thread": 3, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'platform_instance(pm)'", "function": "ldv_platform_instance_3"} */
     487           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     488           1 :  struct platform_driver *ldv_3_container_platform_driver;
     489           1 :  struct platform_device *ldv_3_ldv_param_15_0_default;
     490           1 :  struct platform_device *ldv_3_ldv_param_3_0_default;
     491           1 :  int ldv_3_probed_default;
     492           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     493           1 :  /* Initialize automaton variables */
     494           2 :  ldv_3_probed_default = 1;
     495           1 :  /* LDV {"action": "DEFAULT_REGISTER_3", "type": "RECEIVE_BEGIN", "comment": "Register a driver callbacks for platform-level device."} */
     496           3 :  ldv_free(arg0);
     497             :  /* LDV {"action": "DEFAULT_REGISTER_3", "type": "RECEIVE_END"} */
     498             : 
     499             :  /* LDV {"action": "DEFAULT_ALLOC_3", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     500           3 :  ldv_3_container_platform_driver = ldv_xmalloc_unknown_size(0);
     501             :  /* LDV {"action": "DEFAULT_ALLOC_3", "type": "CONDITION_END"} */
     502             : 
     503             :  /* LDV {"action": "INIT", "type": "CONDITION_BEGIN", "comment": "Alloc memory for 'platform_device' structure."} */
     504             :  /* LDV {"action": "INIT", "type": "CONDITION_END"} */
     505             : 
     506             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Check that device is truely in the system and begin callback invocations."} */
     507             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     508             : 
     509             :  /* Jump to a subprocess 'main' initial state */
     510           1 :  goto ldv_main_3;
     511             :  /* End of the process */
     512             :  return;
     513           1 : 
     514             :  /* Sbprocess main */
     515             :  ldv_main_3:
     516             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     517             : 
     518           4 :  if (ldv_undef_int()) {
     519             :   /* LDV {"action": "PRE_CALL_15", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     520           3 :   ldv_3_ldv_param_15_0_default = ldv_xmalloc_unknown_size(0);
     521             :   /* LDV {"action": "PRE_CALL_15", "type": "CONDITION_END"} */
     522             : 
     523             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Check that the device in the system and do driver initializations. Invoke callback probe from PM."} */
     524             :   /* Callback pre-call */
     525           1 :   ldv_pre_probe();
     526           3 :   if (ldv_3_container_platform_driver->probe) {
     527             :   /* LDV {"type": "CALLBACK", "call": "ldv_3_probed_default = (ldv_3_container_platform_driver->probe)(ldv_3_ldv_param_15_0_default);", "comment": "probe"} */
     528           2 :    ldv_3_probed_default = ldv_platform_instance_probe_3_15(ldv_3_container_platform_driver->probe, ldv_3_ldv_param_15_0_default);
     529             :   }
     530             :   /* Callback post-call */
     531           4 :   ldv_3_probed_default = ldv_post_probe(ldv_3_probed_default);
     532             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
     533             : 
     534             :   /* LDV {"action": "POST_CALL_15", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     535           2 :   ldv_free(ldv_3_ldv_param_15_0_default);
     536             :   /* LDV {"action": "POST_CALL_15", "type": "CONDITION_END"} */
     537             : 
     538           4 :   if (ldv_undef_int()) {
     539             :    /* LDV {"action": "POSITIVE_PROBE", "type": "CONDITION_BEGIN", "comment": "Platform device is probed successfully now."} */
     540           2 :    ldv_assume(ldv_3_probed_default == 0);
     541             :    /* LDV {"action": "POSITIVE_PROBE", "type": "CONDITION_END"} */
     542             : 
     543             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Driver is probed. Call power management callbacks or release the device."} */
     544             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     545             : 
     546             :    /* Jump to a subprocess 'call' initial state */
     547           1 :    goto ldv_call_3;
     548             :   }
     549             :   else {
     550             :    /* LDV {"action": "NEGATIVE_PROBE", "type": "CONDITION_BEGIN", "comment": "Failed to probe the device."} */
     551           2 :    ldv_assume(ldv_3_probed_default != 0);
     552             :    /* LDV {"action": "NEGATIVE_PROBE", "type": "CONDITION_END"} */
     553             : 
     554             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Check that device is truely in the system and begin callback invocations."} */
     555             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     556             : 
     557             :    /* Jump to a subprocess 'main' initial state */
     558           1 :    goto ldv_main_3;
     559             :   }
     560             :  }
     561             :  else {
     562             :   /* LDV {"action": "FREE", "type": "CONDITION_BEGIN", "comment": "Free memory for 'platform_device' structure."} */
     563             :   /* LDV {"action": "FREE", "type": "CONDITION_END"} */
     564             : 
     565             :   /* LDV {"action": "DEFAULT_FREE_3", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     566           2 :   ldv_free(ldv_3_container_platform_driver);
     567             :   /* LDV {"action": "DEFAULT_FREE_3", "type": "CONDITION_END"} */
     568             : 
     569             :   /* LDV {"action": "DEFAULT_DEREGISTER_3", "type": "RECEIVE_BEGIN", "comment": "Finish PM callbacks invocations scenario."} */
     570             :   /* Skip a non-replicative signal receiving */
     571             :   /* LDV {"action": "DEFAULT_DEREGISTER_3", "type": "RECEIVE_END"} */
     572             : 
     573             :   /* Exit function at a terminal state */
     574           1 :   return;
     575             :  }
     576             :  /* End of the subprocess 'main' */
     577             :  return;
     578           1 : 
     579             :  /* Sbprocess call */
     580             :  ldv_call_3:
     581             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     582             : 
     583           2 :  switch (ldv_undef_int()) {
     584           3 :   case 1: {
     585             :    /* LDV {"action": "PRE_CALL_3", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     586           3 :    ldv_3_ldv_param_3_0_default = ldv_xmalloc_unknown_size(0);
     587             :    /* LDV {"action": "PRE_CALL_3", "type": "CONDITION_END"} */
     588             : 
     589             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Remove device from the system. Invoke callback release from PM."} */
     590           3 :    if (ldv_3_container_platform_driver->remove) {
     591             :    /* LDV {"type": "CALLBACK", "call": "(ldv_3_container_platform_driver->remove)(ldv_3_ldv_param_3_0_default);", "comment": "release"} */
     592           2 :     ldv_platform_instance_release_3_3(ldv_3_container_platform_driver->remove, ldv_3_ldv_param_3_0_default);
     593             :    }
     594             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
     595             : 
     596             :    /* LDV {"action": "POST_CALL_3", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     597           4 :    ldv_free(ldv_3_ldv_param_3_0_default);
     598             :    /* LDV {"action": "POST_CALL_3", "type": "CONDITION_END"} */
     599             : 
     600             :    /* LDV {"action": "AFTER_RELEASE", "type": "CONDITION_BEGIN", "comment": "Platform device is released now."} */
     601           1 :    ldv_3_probed_default = 1;
     602             :    /* LDV {"action": "AFTER_RELEASE", "type": "CONDITION_END"} */
     603             : 
     604             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Check that device is truely in the system and begin callback invocations."} */
     605             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     606             : 
     607             :    /* Jump to a subprocess 'main' initial state */
     608           1 :    goto ldv_main_3;
     609           1 :    break;
     610             :   }
     611           3 :   case 2: {
     612             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "comment": "Call callback 'callback' of a process 'platform_instance' of an interface category 'pm'"} */
     613             :    /* Skip callback without implementations */
     614             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     615             : 
     616             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Driver is probed. Call power management callbacks or release the device."} */
     617             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     618             : 
     619             :    /* Jump to a subprocess 'call' initial state */
     620           1 :    goto ldv_call_3;
     621           1 :    break;
     622             :   }
     623           3 :   case 3: {
     624             :    /* LDV {"action": "PM_REGISTER", "type": "DISPATCH_BEGIN", "comment": "Proceed to a power management scenario."} */
     625           2 :    ldv_dispatch_pm_register_3_6();
     626             :    /* LDV {"action": "PM_REGISTER", "type": "DISPATCH_END"} */
     627             : 
     628             :    /* LDV {"action": "PM_DEREGISTER", "type": "DISPATCH_BEGIN", "comment": "Finish the power management scenario."} */
     629           2 :    ldv_dispatch_pm_deregister_3_5();
     630             :    /* LDV {"action": "PM_DEREGISTER", "type": "DISPATCH_END"} */
     631             : 
     632             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Driver is probed. Call power management callbacks or release the device."} */
     633             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     634             : 
     635             :    /* Jump to a subprocess 'call' initial state */
     636           1 :    goto ldv_call_3;
     637             :    /* Jump to a subprocess 'call' initial state */
     638             :    goto ldv_call_3;
     639           1 :    break;
     640             :   }
     641           2 :   default: ldv_stop();
     642           1 :  }
     643           0 :  /* End of the subprocess 'call' */
     644           0 :  return;
     645             :  /* LDV {"comment": "End of control function based on process 'platform_instance(pm)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_platform_instance_3"} */
     646             : }
     647             : 
     648             : /* AUX_FUNC_CALLBACK ldv_platform_instance_probe_3_15 */
     649             : int ldv_platform_instance_probe_3_15(int (*arg0)(struct platform_device *), struct platform_device *arg1) {
     650           2 :  return (*arg0)(arg1);
     651           1 : }
     652             : 
     653             : /* AUX_FUNC_CALLBACK ldv_platform_instance_release_3_3 */
     654             : void ldv_platform_instance_release_3_3(int (*arg0)(struct platform_device *), struct platform_device *arg1) {
     655           1 :  (*arg0)(arg1);
     656           1 : }
     657             : 
     658             : /* AUX_FUNC ldv_pm_ops_scenario_2 */
     659             : void ldv_pm_ops_scenario_2(void *arg0) {
     660             :  /* LDV {"thread": 2, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'pm_ops_scenario(pm)'", "function": "ldv_pm_ops_scenario_2"} */
     661           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     662           1 :  struct device *ldv_2_device_device;
     663           1 :  struct dev_pm_ops *ldv_2_pm_ops_dev_pm_ops;
     664           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     665           1 :  /* LDV {"action": "PM_REGISTER", "type": "RECEIVE_BEGIN", "comment": "Ready for a power management scenarios."} */
     666           3 :  ldv_free(arg0);
     667           1 :  /* LDV {"action": "PM_REGISTER", "type": "RECEIVE_END"} */
     668             : 
     669             :  /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     670             :  /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     671             : 
     672             :  /* Jump to a subprocess 'do' initial state */
     673           1 :  goto ldv_do_2;
     674             :  /* End of the process */
     675             :  return;
     676           1 : 
     677             :  /* Sbprocess do */
     678             :  ldv_do_2:
     679             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     680             : 
     681           2 :  switch (ldv_undef_int()) {
     682           3 :   case 1: {
     683             :    /* LDV {"action": "RUNTIME_IDLE", "type": "CALL_BEGIN", "callback": true, "comment": "Device appears to be inactive and it might be put into a low-power state if all of the necessary conditions are satisfied. Invoke callback runtime_idle from PM."} */
     684           3 :    if (ldv_2_pm_ops_dev_pm_ops->runtime_idle) {
     685             :    /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->runtime_idle)(ldv_2_device_device);", "comment": "runtime_idle"} */
     686           2 :     ldv_pm_ops_scenario_runtime_idle_2_24(ldv_2_pm_ops_dev_pm_ops->runtime_idle, ldv_2_device_device);
     687             :    }
     688             :    /* LDV {"action": "RUNTIME_IDLE", "type": "CALL_END"} */
     689             : 
     690             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     691             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     692             : 
     693             :    /* Jump to a subprocess 'do' initial state */
     694           2 :    goto ldv_do_2;
     695           1 :    break;
     696             :   }
     697           3 :   case 2: {
     698             :    /* LDV {"action": "RUNTIME_SUSPEND", "type": "CALL_BEGIN", "callback": true, "comment": "The device should be put into a low-power state to prevent communication of the device with the CPU(s) and RAM. Invoke callback runtime_suspend from PM."} */
     699           3 :    if (ldv_2_pm_ops_dev_pm_ops->runtime_suspend) {
     700             :    /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->runtime_suspend)(ldv_2_device_device);", "comment": "runtime_suspend"} */
     701           2 :     ldv_pm_ops_scenario_runtime_suspend_2_22(ldv_2_pm_ops_dev_pm_ops->runtime_suspend, ldv_2_device_device);
     702             :    }
     703             :    /* LDV {"action": "RUNTIME_SUSPEND", "type": "CALL_END"} */
     704             : 
     705             :    /* LDV {"action": "RUNTIME_RESUME", "type": "CALL_BEGIN", "callback": true, "comment": "Put the device into the fully active state in response to a wakeup event generated by hardware or at the request of software. Invoke callback runtime_resume from PM."} */
     706           6 :    if (ldv_2_pm_ops_dev_pm_ops->runtime_resume) {
     707             :    /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->runtime_resume)(ldv_2_device_device);", "comment": "runtime_resume"} */
     708           4 :     ldv_pm_ops_scenario_runtime_resume_2_21(ldv_2_pm_ops_dev_pm_ops->runtime_resume, ldv_2_device_device);
     709             :    }
     710             :    /* LDV {"action": "RUNTIME_RESUME", "type": "CALL_END"} */
     711             : 
     712             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     713             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     714             : 
     715             :    /* Jump to a subprocess 'do' initial state */
     716           3 :    goto ldv_do_2;
     717           1 :    break;
     718             :   }
     719           3 :   case 3: {
     720             :    /* LDV {"action": "PREPARE", "type": "CALL_BEGIN", "callback": true, "comment": "Prevent new children of the device from being registered. Invoke callback prepare from PM."} */
     721           3 :    if (ldv_2_pm_ops_dev_pm_ops->prepare) {
     722             :    /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->prepare)(ldv_2_device_device);", "comment": "prepare"} */
     723           2 :     ldv_pm_ops_scenario_prepare_2_19(ldv_2_pm_ops_dev_pm_ops->prepare, ldv_2_device_device);
     724             :    }
     725             :    /* LDV {"action": "PREPARE", "type": "CALL_END"} */
     726             : 
     727           4 :    switch (ldv_undef_int()) {
     728           3 :     case 1: {
     729             :      /* LDV {"action": "SUSPEND", "type": "CALL_BEGIN", "callback": true, "comment": "Quiesce subsystem-level device before suspend. Invoke callback suspend from PM."} */
     730           3 :      if (ldv_2_pm_ops_dev_pm_ops->suspend) {
     731             :      /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->suspend)(ldv_2_device_device);", "comment": "suspend"} */
     732           2 :       ldv_pm_ops_scenario_suspend_2_18(ldv_2_pm_ops_dev_pm_ops->suspend, ldv_2_device_device);
     733             :      }
     734             :      /* LDV {"action": "SUSPEND", "type": "CALL_END"} */
     735             : 
     736           6 :      if (ldv_undef_int()) {
     737             :       /* LDV {"action": "SUSPEND_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Expect that the device will be in a low-power state. Invoke callback suspend_noirq from PM."} */
     738           3 :       if (ldv_2_pm_ops_dev_pm_ops->suspend_noirq) {
     739             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->suspend_noirq)(ldv_2_device_device);", "comment": "suspend_noirq"} */
     740           2 :        ldv_pm_ops_scenario_suspend_noirq_2_17(ldv_2_pm_ops_dev_pm_ops->suspend_noirq, ldv_2_device_device);
     741             :       }
     742             :       /* LDV {"action": "SUSPEND_NOIRQ", "type": "CALL_END"} */
     743             : 
     744             :       /* LDV {"action": "RESUME_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Prepare for the #resume() performing actions that might be racing with device's interrupt handler. Invoke callback resume_noirq from PM."} */
     745           6 :       if (ldv_2_pm_ops_dev_pm_ops->resume_noirq) {
     746             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->resume_noirq)(ldv_2_device_device);", "comment": "resume_noirq"} */
     747           4 :        ldv_pm_ops_scenario_resume_noirq_2_16(ldv_2_pm_ops_dev_pm_ops->resume_noirq, ldv_2_device_device);
     748             :       }
     749             :       /* LDV {"action": "RESUME_NOIRQ", "type": "CALL_END"} */
     750             : 
     751             :      }
     752             :      else {
     753             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     754             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     755             : 
     756             :      }
     757             :      /* LDV {"action": "RESUME", "type": "CALL_BEGIN", "callback": true, "comment": "Make the device start working again after resume. Invoke callback resume from dev_pm_ops."} */
     758             :      /* LDV {"type": "CALLBACK", "call": "((& i2c_device_resume))(ldv_2_device_device);", "comment": "resume"} */
     759           6 :      ldv_pm_ops_scenario_resume_2_14(ldv_2_pm_ops_dev_pm_ops->resume, ldv_2_device_device);
     760             :      /* LDV {"action": "RESUME", "type": "CALL_END"} */
     761             : 
     762           1 :      break;
     763           1 :     }
     764           3 :     case 2: {
     765             :      /* LDV {"action": "FREEZE", "type": "CALL_BEGIN", "callback": true, "comment": "Prepare for creating a hibernation image. Invoke callback freeze from PM."} */
     766           3 :      if (ldv_2_pm_ops_dev_pm_ops->freeze) {
     767             :      /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->freeze)(ldv_2_device_device);", "comment": "freeze"} */
     768           2 :       ldv_pm_ops_scenario_freeze_2_13(ldv_2_pm_ops_dev_pm_ops->freeze, ldv_2_device_device);
     769             :      }
     770             :      /* LDV {"action": "FREEZE", "type": "CALL_END"} */
     771             : 
     772           6 :      if (ldv_undef_int()) {
     773             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     774             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     775             : 
     776             :      }
     777             :      else {
     778             :       /* LDV {"action": "FREEZE_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Complete the actions started by #freeze() that might be racing with device's interrupt handler. Invoke callback freeze_noirq from PM."} */
     779           3 :       if (ldv_2_pm_ops_dev_pm_ops->freeze_noirq) {
     780             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->freeze_noirq)(ldv_2_device_device);", "comment": "freeze_noirq"} */
     781           2 :        ldv_pm_ops_scenario_freeze_noirq_2_11(ldv_2_pm_ops_dev_pm_ops->freeze_noirq, ldv_2_device_device);
     782             :       }
     783             :       /* LDV {"action": "FREEZE_NOIRQ", "type": "CALL_END"} */
     784             : 
     785             :       /* LDV {"action": "THAW_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Prepare for the execution of #thaw() performing actions that might be racing with device's interrupt handler. Invoke callback thaw_noirq from PM."} */
     786           6 :       if (ldv_2_pm_ops_dev_pm_ops->thaw_noirq) {
     787             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->thaw_noirq)(ldv_2_device_device);", "comment": "thaw_noirq"} */
     788           4 :        ldv_pm_ops_scenario_thaw_noirq_2_10(ldv_2_pm_ops_dev_pm_ops->thaw_noirq, ldv_2_device_device);
     789             :       }
     790             :       /* LDV {"action": "THAW_NOIRQ", "type": "CALL_END"} */
     791             : 
     792             :      }
     793             :      /* LDV {"action": "THAW", "type": "CALL_BEGIN", "callback": true, "comment": "The hibernation image has created or creation has failed. Invoke callback thaw from PM."} */
     794           9 :      if (ldv_2_pm_ops_dev_pm_ops->thaw) {
     795             :      /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->thaw)(ldv_2_device_device);", "comment": "thaw"} */
     796           6 :       ldv_pm_ops_scenario_thaw_2_9(ldv_2_pm_ops_dev_pm_ops->thaw, ldv_2_device_device);
     797             :      }
     798             :      /* LDV {"action": "THAW", "type": "CALL_END"} */
     799             : 
     800           4 :      break;
     801           1 :     }
     802           3 :     case 3: {
     803             :      /* LDV {"action": "POWEROFF", "type": "CALL_BEGIN", "callback": true, "comment": "Hibernation image has been created. Invoke callback poweroff from PM."} */
     804           3 :      if (ldv_2_pm_ops_dev_pm_ops->poweroff) {
     805             :      /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->poweroff)(ldv_2_device_device);", "comment": "poweroff"} */
     806           2 :       ldv_pm_ops_scenario_poweroff_2_8(ldv_2_pm_ops_dev_pm_ops->poweroff, ldv_2_device_device);
     807             :      }
     808             :      /* LDV {"action": "POWEROFF", "type": "CALL_END"} */
     809             : 
     810           6 :      if (ldv_undef_int()) {
     811             :       /* LDV {"action": "POWEROFF_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Complete the actions started by #poweroff(). Invoke callback poweroff_noirq from PM."} */
     812           3 :       if (ldv_2_pm_ops_dev_pm_ops->poweroff_noirq) {
     813             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->poweroff_noirq)(ldv_2_device_device);", "comment": "poweroff_noirq"} */
     814           2 :        ldv_pm_ops_scenario_poweroff_noirq_2_7(ldv_2_pm_ops_dev_pm_ops->poweroff_noirq, ldv_2_device_device);
     815             :       }
     816             :       /* LDV {"action": "POWEROFF_NOIRQ", "type": "CALL_END"} */
     817             : 
     818             :       /* LDV {"action": "RESTORE_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Prepare for the execution of #restore() performing actions that might be racing with device's interrupt handler. Invoke callback restore_noirq from PM."} */
     819           6 :       if (ldv_2_pm_ops_dev_pm_ops->restore_noirq) {
     820             :       /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->restore_noirq)(ldv_2_device_device);", "comment": "restore_noirq"} */
     821           4 :        ldv_pm_ops_scenario_restore_noirq_2_6(ldv_2_pm_ops_dev_pm_ops->restore_noirq, ldv_2_device_device);
     822             :       }
     823             :       /* LDV {"action": "RESTORE_NOIRQ", "type": "CALL_END"} */
     824             : 
     825             :      }
     826             :      else {
     827             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     828             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     829             : 
     830             :      }
     831             :      /* LDV {"action": "RESTORE", "type": "CALL_BEGIN", "callback": true, "comment": "Restoration of the contents of main memory from a hibernation image has been done. Invoke callback restore from PM."} */
     832           9 :      if (ldv_2_pm_ops_dev_pm_ops->restore) {
     833             :      /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->restore)(ldv_2_device_device);", "comment": "restore"} */
     834           6 :       ldv_pm_ops_scenario_restore_2_4(ldv_2_pm_ops_dev_pm_ops->restore, ldv_2_device_device);
     835             :      }
     836             :      /* LDV {"action": "RESTORE", "type": "CALL_END"} */
     837             : 
     838           4 :      break;
     839           1 :     }
     840           2 :     default: ldv_stop();
     841           1 :    }
     842           0 :    /* LDV {"action": "COMPLETE", "type": "CALL_BEGIN", "callback": true, "comment": "Undo the changes made by #prepare(). Invoke callback complete from PM."} */
     843          27 :    if (ldv_2_pm_ops_dev_pm_ops->complete) {
     844           0 :    /* LDV {"type": "CALLBACK", "call": "(ldv_2_pm_ops_dev_pm_ops->complete)(ldv_2_device_device);", "comment": "complete"} */
     845          18 :     ldv_pm_ops_scenario_complete_2_3(ldv_2_pm_ops_dev_pm_ops->complete, ldv_2_device_device);
     846             :    }
     847             :    /* LDV {"action": "COMPLETE", "type": "CALL_END"} */
     848             : 
     849             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     850             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     851             : 
     852             :    /* Jump to a subprocess 'do' initial state */
     853          10 :    goto ldv_do_2;
     854           1 :    break;
     855             :   }
     856           3 :   case 4: {
     857             :    /* LDV {"action": "PM_DEREGISTER", "type": "RECEIVE_BEGIN", "comment": "Do not expect power management scenarios."} */
     858             :    /* Skip a non-replicative signal receiving */
     859             :    /* LDV {"action": "PM_DEREGISTER", "type": "RECEIVE_END"} */
     860             : 
     861             :    /* Exit function at a terminal state */
     862           1 :    return;
     863           1 :    break;
     864             :   }
     865           2 :   default: ldv_stop();
     866           1 :  }
     867           0 :  /* End of the subprocess 'do' */
     868           0 :  return;
     869             :  /* LDV {"comment": "End of control function based on process 'pm_ops_scenario(pm)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_pm_ops_scenario_2"} */
     870             : }
     871             : 
     872             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_complete_2_3 */
     873             : void ldv_pm_ops_scenario_complete_2_3(void (*arg0)(struct device *), struct device *arg1) {
     874          36 :  (*arg0)(arg1);
     875           9 : }
     876             : 
     877             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_freeze_2_13 */
     878             : void ldv_pm_ops_scenario_freeze_2_13(int (*arg0)(struct device *), struct device *arg1) {
     879           4 :  (*arg0)(arg1);
     880           1 : }
     881             : 
     882             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_freeze_noirq_2_11 */
     883             : void ldv_pm_ops_scenario_freeze_noirq_2_11(int (*arg0)(struct device *), struct device *arg1) {
     884           4 :  (*arg0)(arg1);
     885           1 : }
     886             : 
     887             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_poweroff_2_8 */
     888             : void ldv_pm_ops_scenario_poweroff_2_8(int (*arg0)(struct device *), struct device *arg1) {
     889           4 :  (*arg0)(arg1);
     890           1 : }
     891             : 
     892             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_poweroff_noirq_2_7 */
     893             : void ldv_pm_ops_scenario_poweroff_noirq_2_7(int (*arg0)(struct device *), struct device *arg1) {
     894           4 :  (*arg0)(arg1);
     895           1 : }
     896             : 
     897             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_prepare_2_19 */
     898             : void ldv_pm_ops_scenario_prepare_2_19(int (*arg0)(struct device *), struct device *arg1) {
     899           4 :  (*arg0)(arg1);
     900           1 : }
     901             : 
     902             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_restore_2_4 */
     903             : void ldv_pm_ops_scenario_restore_2_4(int (*arg0)(struct device *), struct device *arg1) {
     904          12 :  (*arg0)(arg1);
     905           3 : }
     906             : 
     907             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_restore_noirq_2_6 */
     908             : void ldv_pm_ops_scenario_restore_noirq_2_6(int (*arg0)(struct device *), struct device *arg1) {
     909           8 :  (*arg0)(arg1);
     910           2 : }
     911             : 
     912             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_resume_2_14 */
     913             : void ldv_pm_ops_scenario_resume_2_14(int (*arg0)(struct device *), struct device *arg1) {
     914           6 :  ((& i2c_device_resume))(arg1);
     915           3 : }
     916             : 
     917             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_resume_noirq_2_16 */
     918             : void ldv_pm_ops_scenario_resume_noirq_2_16(int (*arg0)(struct device *), struct device *arg1) {
     919           8 :  (*arg0)(arg1);
     920           2 : }
     921             : 
     922             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_runtime_idle_2_24 */
     923             : void ldv_pm_ops_scenario_runtime_idle_2_24(int (*arg0)(struct device *), struct device *arg1) {
     924           4 :  (*arg0)(arg1);
     925           1 : }
     926             : 
     927             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_runtime_resume_2_21 */
     928             : void ldv_pm_ops_scenario_runtime_resume_2_21(int (*arg0)(struct device *), struct device *arg1) {
     929           8 :  (*arg0)(arg1);
     930           2 : }
     931             : 
     932             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_runtime_suspend_2_22 */
     933             : void ldv_pm_ops_scenario_runtime_suspend_2_22(int (*arg0)(struct device *), struct device *arg1) {
     934           4 :  (*arg0)(arg1);
     935           1 : }
     936             : 
     937             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_suspend_2_18 */
     938             : void ldv_pm_ops_scenario_suspend_2_18(int (*arg0)(struct device *), struct device *arg1) {
     939           4 :  (*arg0)(arg1);
     940           1 : }
     941             : 
     942             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_suspend_noirq_2_17 */
     943             : void ldv_pm_ops_scenario_suspend_noirq_2_17(int (*arg0)(struct device *), struct device *arg1) {
     944           4 :  (*arg0)(arg1);
     945           1 : }
     946             : 
     947             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_thaw_2_9 */
     948             : void ldv_pm_ops_scenario_thaw_2_9(int (*arg0)(struct device *), struct device *arg1) {
     949          12 :  (*arg0)(arg1);
     950           3 : }
     951             : 
     952             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_thaw_noirq_2_10 */
     953             : void ldv_pm_ops_scenario_thaw_noirq_2_10(int (*arg0)(struct device *), struct device *arg1) {
     954           8 :  (*arg0)(arg1);
     955           2 : }
     956             : 
     957             : /* AUX_FUNC ldv_random_containerless_scenario_6 */
     958             : void ldv_random_containerless_scenario_6(void *arg0) {
     959             :  /* LDV {"thread": 6, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_6"} */
     960           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     961           1 :  ssize_t (*ldv_6_callback_show)(struct device *, struct device_attribute *, char *);
     962             :  ssize_t (*ldv_6_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     963           1 :  struct device_attribute *ldv_6_container_struct_device_attribute;
     964           1 :  struct device *ldv_6_container_struct_device_ptr;
     965           1 :  char *ldv_6_ldv_param_10_2_default;
     966           1 :  long unsigned int ldv_6_ldv_param_10_3_default;
     967           1 :  char *ldv_6_ldv_param_4_2_default;
     968           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     969           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     970           3 :  ldv_free(arg0);
     971           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
     972           1 : 
     973           1 :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     974           3 :  ldv_6_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     975           3 :  ldv_6_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     976             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
     977             : 
     978             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     979             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     980             : 
     981             :  /* Jump to a subprocess 'call' initial state */
     982           1 :  goto ldv_call_6;
     983             :  /* End of the process */
     984             :  return;
     985           1 : 
     986             :  /* Sbprocess call */
     987             :  ldv_call_6:
     988             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     989             : 
     990           4 :  if (ldv_undef_int()) {
     991             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     992           3 :   ldv_6_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     993             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     994             : 
     995           4 :   if (ldv_undef_int()) {
     996             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     997           3 :    ldv_6_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     998             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     999             : 
    1000             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    1001             :    /* LDV {"type": "CALLBACK", "call": "((& i2c_sysfs_delete_device))(ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_10_2_default, ldv_6_ldv_param_10_3_default);", "comment": "callback"} */
    1002           2 :    ldv_random_containerless_scenario_callback_6_10(ldv_6_callback_store, ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_10_2_default, ldv_6_ldv_param_10_3_default);
    1003             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1004             : 
    1005             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1006           2 :    ldv_free(ldv_6_ldv_param_10_2_default);
    1007             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1008             : 
    1009             :   }
    1010             :   else {
    1011             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1012           2 :    if (ldv_6_callback_show) {
    1013             :    /* LDV {"type": "CALLBACK", "call": "(ldv_6_callback_show)(ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_4_2_default);", "comment": "callback"} */
    1014           2 :     ldv_random_containerless_scenario_callback_6_4(ldv_6_callback_show, ldv_6_container_struct_device_ptr, ldv_6_container_struct_device_attribute, ldv_6_ldv_param_4_2_default);
    1015             :    }
    1016             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1017             : 
    1018             :   }
    1019             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1020           6 :   ldv_free(ldv_6_ldv_param_4_2_default);
    1021             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1022             : 
    1023             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1024             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1025             : 
    1026             :   /* Jump to a subprocess 'call' initial state */
    1027           1 :   goto ldv_call_6;
    1028             :  }
    1029             :  else {
    1030             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1031           2 :   ldv_free(ldv_6_container_struct_device_attribute);
    1032           2 :   ldv_free(ldv_6_container_struct_device_ptr);
    1033             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    1034             : 
    1035             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1036             :   /* Skip a non-replicative signal receiving */
    1037             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    1038             : 
    1039             :   /* Exit function at a terminal state */
    1040           1 :   return;
    1041             :  }
    1042             :  /* End of the subprocess 'call' */
    1043             :  return;
    1044             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_6"} */
    1045             : }
    1046             : 
    1047             : /* AUX_FUNC ldv_random_containerless_scenario_7 */
    1048             : void ldv_random_containerless_scenario_7(void *arg0) {
    1049             :  /* LDV {"thread": 7, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_7"} */
    1050           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1051           1 :  ssize_t (*ldv_7_callback_show)(struct device *, struct device_attribute *, char *);
    1052             :  ssize_t (*ldv_7_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1053           1 :  struct device_attribute *ldv_7_container_struct_device_attribute;
    1054           1 :  struct device *ldv_7_container_struct_device_ptr;
    1055           1 :  char *ldv_7_ldv_param_10_2_default;
    1056           1 :  long unsigned int ldv_7_ldv_param_10_3_default;
    1057           1 :  char *ldv_7_ldv_param_4_2_default;
    1058           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1059           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1060           3 :  ldv_free(arg0);
    1061           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    1062           1 : 
    1063           1 :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1064           3 :  ldv_7_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1065           3 :  ldv_7_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1066             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    1067             : 
    1068             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1069             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1070             : 
    1071             :  /* Jump to a subprocess 'call' initial state */
    1072           1 :  goto ldv_call_7;
    1073             :  /* End of the process */
    1074             :  return;
    1075           1 : 
    1076             :  /* Sbprocess call */
    1077             :  ldv_call_7:
    1078             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1079             : 
    1080           4 :  if (ldv_undef_int()) {
    1081             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1082           3 :   ldv_7_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1083             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1084             : 
    1085           4 :   if (ldv_undef_int()) {
    1086             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1087           3 :    ldv_7_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1088             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1089             : 
    1090             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1091           2 :    if (ldv_7_callback_store) {
    1092             :    /* LDV {"type": "CALLBACK", "call": "(ldv_7_callback_store)(ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_10_2_default, ldv_7_ldv_param_10_3_default);", "comment": "callback"} */
    1093           2 :     ldv_random_containerless_scenario_callback_7_10(ldv_7_callback_store, ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_10_2_default, ldv_7_ldv_param_10_3_default);
    1094             :    }
    1095             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1096             : 
    1097             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1098           4 :    ldv_free(ldv_7_ldv_param_10_2_default);
    1099             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1100             : 
    1101             :   }
    1102             :   else {
    1103             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1104             :    /* LDV {"type": "CALLBACK", "call": "((& show_modalias))(ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_4_2_default);", "comment": "callback"} */
    1105           2 :    ldv_random_containerless_scenario_callback_7_4(ldv_7_callback_show, ldv_7_container_struct_device_ptr, ldv_7_container_struct_device_attribute, ldv_7_ldv_param_4_2_default);
    1106             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1107             : 
    1108             :   }
    1109             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1110           4 :   ldv_free(ldv_7_ldv_param_4_2_default);
    1111             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1112             : 
    1113             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1114             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1115             : 
    1116             :   /* Jump to a subprocess 'call' initial state */
    1117           1 :   goto ldv_call_7;
    1118             :  }
    1119             :  else {
    1120             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1121           2 :   ldv_free(ldv_7_container_struct_device_attribute);
    1122           2 :   ldv_free(ldv_7_container_struct_device_ptr);
    1123             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    1124             : 
    1125             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1126             :   /* Skip a non-replicative signal receiving */
    1127             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    1128             : 
    1129             :   /* Exit function at a terminal state */
    1130           1 :   return;
    1131             :  }
    1132             :  /* End of the subprocess 'call' */
    1133             :  return;
    1134             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_7"} */
    1135             : }
    1136             : 
    1137             : /* AUX_FUNC ldv_random_containerless_scenario_8 */
    1138             : void ldv_random_containerless_scenario_8(void *arg0) {
    1139             :  /* LDV {"thread": 8, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_8"} */
    1140           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1141           1 :  ssize_t (*ldv_8_callback_show)(struct device *, struct device_attribute *, char *);
    1142             :  ssize_t (*ldv_8_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1143           1 :  struct device_attribute *ldv_8_container_struct_device_attribute;
    1144           1 :  struct device *ldv_8_container_struct_device_ptr;
    1145           1 :  char *ldv_8_ldv_param_10_2_default;
    1146           1 :  long unsigned int ldv_8_ldv_param_10_3_default;
    1147           1 :  char *ldv_8_ldv_param_4_2_default;
    1148           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1149           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1150           3 :  ldv_free(arg0);
    1151           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    1152           1 : 
    1153           1 :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1154           3 :  ldv_8_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1155           3 :  ldv_8_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1156             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    1157             : 
    1158             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1159             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1160             : 
    1161             :  /* Jump to a subprocess 'call' initial state */
    1162           1 :  goto ldv_call_8;
    1163             :  /* End of the process */
    1164             :  return;
    1165           1 : 
    1166             :  /* Sbprocess call */
    1167             :  ldv_call_8:
    1168             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1169             : 
    1170           4 :  if (ldv_undef_int()) {
    1171             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1172           3 :   ldv_8_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1173             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1174             : 
    1175           4 :   if (ldv_undef_int()) {
    1176             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1177           3 :    ldv_8_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1178             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1179             : 
    1180             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1181           2 :    if (ldv_8_callback_store) {
    1182             :    /* LDV {"type": "CALLBACK", "call": "(ldv_8_callback_store)(ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_10_2_default, ldv_8_ldv_param_10_3_default);", "comment": "callback"} */
    1183           2 :     ldv_random_containerless_scenario_callback_8_10(ldv_8_callback_store, ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_10_2_default, ldv_8_ldv_param_10_3_default);
    1184             :    }
    1185             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1186             : 
    1187             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1188           4 :    ldv_free(ldv_8_ldv_param_10_2_default);
    1189             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1190             : 
    1191             :   }
    1192             :   else {
    1193             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1194             :    /* LDV {"type": "CALLBACK", "call": "((& show_name))(ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_4_2_default);", "comment": "callback"} */
    1195           2 :    ldv_random_containerless_scenario_callback_8_4(ldv_8_callback_show, ldv_8_container_struct_device_ptr, ldv_8_container_struct_device_attribute, ldv_8_ldv_param_4_2_default);
    1196             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1197             : 
    1198             :   }
    1199             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1200           4 :   ldv_free(ldv_8_ldv_param_4_2_default);
    1201             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1202             : 
    1203             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1204             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1205             : 
    1206             :   /* Jump to a subprocess 'call' initial state */
    1207           1 :   goto ldv_call_8;
    1208             :  }
    1209             :  else {
    1210             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1211           2 :   ldv_free(ldv_8_container_struct_device_attribute);
    1212           2 :   ldv_free(ldv_8_container_struct_device_ptr);
    1213             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    1214             : 
    1215             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1216             :   /* Skip a non-replicative signal receiving */
    1217             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    1218             : 
    1219             :   /* Exit function at a terminal state */
    1220           1 :   return;
    1221             :  }
    1222             :  /* End of the subprocess 'call' */
    1223             :  return;
    1224             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_8"} */
    1225             : }
    1226             : 
    1227             : /* AUX_FUNC ldv_random_containerless_scenario_9 */
    1228             : void ldv_random_containerless_scenario_9(void *arg0) {
    1229             :  /* LDV {"thread": 9, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_9"} */
    1230           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1231           1 :  ssize_t (*ldv_9_callback_show)(struct device *, struct device_attribute *, char *);
    1232             :  ssize_t (*ldv_9_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1233           1 :  struct device_attribute *ldv_9_container_struct_device_attribute;
    1234           1 :  struct device *ldv_9_container_struct_device_ptr;
    1235           1 :  char *ldv_9_ldv_param_10_2_default;
    1236           1 :  long unsigned int ldv_9_ldv_param_10_3_default;
    1237           1 :  char *ldv_9_ldv_param_4_2_default;
    1238           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1239           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1240           3 :  ldv_free(arg0);
    1241           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    1242           1 : 
    1243           1 :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1244           3 :  ldv_9_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1245           3 :  ldv_9_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1246             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    1247             : 
    1248             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1249             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1250             : 
    1251             :  /* Jump to a subprocess 'call' initial state */
    1252           1 :  goto ldv_call_9;
    1253             :  /* End of the process */
    1254             :  return;
    1255           1 : 
    1256             :  /* Sbprocess call */
    1257             :  ldv_call_9:
    1258             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1259             : 
    1260           4 :  if (ldv_undef_int()) {
    1261             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1262           3 :   ldv_9_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1263             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1264             : 
    1265           4 :   if (ldv_undef_int()) {
    1266             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1267           3 :    ldv_9_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1268             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1269             : 
    1270             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    1271             :    /* LDV {"type": "CALLBACK", "call": "((& i2c_sysfs_new_device))(ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_10_2_default, ldv_9_ldv_param_10_3_default);", "comment": "callback"} */
    1272           2 :    ldv_random_containerless_scenario_callback_9_10(ldv_9_callback_store, ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_10_2_default, ldv_9_ldv_param_10_3_default);
    1273             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1274             : 
    1275             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1276           2 :    ldv_free(ldv_9_ldv_param_10_2_default);
    1277             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1278             : 
    1279             :   }
    1280             :   else {
    1281             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1282           2 :    if (ldv_9_callback_show) {
    1283             :    /* LDV {"type": "CALLBACK", "call": "(ldv_9_callback_show)(ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_4_2_default);", "comment": "callback"} */
    1284           2 :     ldv_random_containerless_scenario_callback_9_4(ldv_9_callback_show, ldv_9_container_struct_device_ptr, ldv_9_container_struct_device_attribute, ldv_9_ldv_param_4_2_default);
    1285             :    }
    1286             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1287             : 
    1288             :   }
    1289             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1290           6 :   ldv_free(ldv_9_ldv_param_4_2_default);
    1291             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1292             : 
    1293             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1294             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1295             : 
    1296             :   /* Jump to a subprocess 'call' initial state */
    1297           1 :   goto ldv_call_9;
    1298             :  }
    1299             :  else {
    1300             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1301           2 :   ldv_free(ldv_9_container_struct_device_attribute);
    1302           2 :   ldv_free(ldv_9_container_struct_device_ptr);
    1303             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    1304             : 
    1305             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1306             :   /* Skip a non-replicative signal receiving */
    1307             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    1308             : 
    1309             :   /* Exit function at a terminal state */
    1310           1 :   return;
    1311             :  }
    1312             :  /* End of the subprocess 'call' */
    1313             :  return;
    1314             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_9"} */
    1315             : }
    1316             : 
    1317             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_6_10 */
    1318             : void ldv_random_containerless_scenario_callback_6_10(ssize_t (*arg0)(struct device *, struct device_attribute *, char *, size_t ), struct device *arg1, struct device_attribute *arg2, char *arg3, long unsigned int arg4) {
    1319           6 :  ((& i2c_sysfs_delete_device))(arg1, arg2, arg3, arg4);
    1320           1 : }
    1321             : 
    1322             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_6_4 */
    1323             : void ldv_random_containerless_scenario_callback_6_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    1324           3 :  (*arg0)(arg1, arg2, arg3);
    1325           1 : }
    1326             : 
    1327             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_7_10 */
    1328             : void ldv_random_containerless_scenario_callback_7_10(ssize_t (*arg0)(struct device *, struct device_attribute *, char *, size_t ), struct device *arg1, struct device_attribute *arg2, char *arg3, long unsigned int arg4) {
    1329           3 :  (*arg0)(arg1, arg2, arg3, arg4);
    1330           1 : }
    1331             : 
    1332             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_7_4 */
    1333             : void ldv_random_containerless_scenario_callback_7_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    1334           2 :  ((& show_modalias))(arg1, arg2, arg3);
    1335           1 : }
    1336             : 
    1337             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_8_10 */
    1338             : void ldv_random_containerless_scenario_callback_8_10(ssize_t (*arg0)(struct device *, struct device_attribute *, char *, size_t ), struct device *arg1, struct device_attribute *arg2, char *arg3, long unsigned int arg4) {
    1339           3 :  (*arg0)(arg1, arg2, arg3, arg4);
    1340           1 : }
    1341             : 
    1342             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_8_4 */
    1343             : void ldv_random_containerless_scenario_callback_8_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    1344           2 :  ((& show_name))(arg1, arg2, arg3);
    1345           1 : }
    1346             : 
    1347             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_9_10 */
    1348             : void ldv_random_containerless_scenario_callback_9_10(ssize_t (*arg0)(struct device *, struct device_attribute *, char *, size_t ), struct device *arg1, struct device_attribute *arg2, char *arg3, long unsigned int arg4) {
    1349           8 :  ((& i2c_sysfs_new_device))(arg1, arg2, arg3, arg4);
    1350           1 : }
    1351             : 
    1352             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_9_4 */
    1353             : void ldv_random_containerless_scenario_callback_9_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    1354           3 :  (*arg0)(arg1, arg2, arg3);
    1355           1 : }
    1356             : 
    1357             : /* AUX_FUNC ldv_rtc_class_scenario_4 */
    1358             : void ldv_rtc_class_scenario_4(void *arg0) {
    1359             :  /* LDV {"thread": 4, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_4"} */
    1360           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1361           1 :  struct device *ldv_4_device_device;
    1362           1 :  int ldv_4_ret_default;
    1363           1 :  struct rtc_class_ops *ldv_4_rtc_class_ops_rtc_class_ops;
    1364           1 :  struct rtc_device *ldv_4_rtc_device_rtc_device;
    1365           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1366           1 :  /* Initialize automaton variables */
    1367           2 :  ldv_4_ret_default = 1;
    1368           1 :  /* LDV {"action": "DEFAULT_REGISTER_4", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    1369           3 :  ldv_free(arg0);
    1370             :  /* LDV {"action": "DEFAULT_REGISTER_4", "type": "RECEIVE_END"} */
    1371             : 
    1372             :  /* LDV {"action": "DEFAULT_ALLOC_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1373           3 :  ldv_4_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    1374           3 :  ldv_4_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    1375           3 :  ldv_4_device_device = ldv_xmalloc_unknown_size(0);
    1376             :  /* LDV {"action": "DEFAULT_ALLOC_4", "type": "CONDITION_END"} */
    1377             : 
    1378             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1379             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1380             : 
    1381             :  /* Jump to a subprocess 'main' initial state */
    1382           1 :  goto ldv_main_4;
    1383             :  /* End of the process */
    1384             :  return;
    1385           1 : 
    1386             :  /* Sbprocess main */
    1387             :  ldv_main_4:
    1388             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1389             : 
    1390           4 :  if (ldv_undef_int()) {
    1391             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    1392             :   /* Callback pre-call */
    1393           1 :   ldv_pre_probe();
    1394           3 :   if (ldv_4_rtc_class_ops_rtc_class_ops->open) {
    1395             :   /* LDV {"type": "CALLBACK", "call": "ldv_4_ret_default = (ldv_4_rtc_class_ops_rtc_class_ops->open)(ldv_4_device_device);", "comment": "probe"} */
    1396           2 :    ldv_4_ret_default = ldv_rtc_class_scenario_probe_4_11(ldv_4_rtc_class_ops_rtc_class_ops->open, ldv_4_device_device);
    1397             :   }
    1398             :   /* Callback post-call */
    1399           4 :   ldv_4_ret_default = ldv_post_probe(ldv_4_ret_default);
    1400             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    1401             : 
    1402           4 :   if (ldv_undef_int()) {
    1403             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    1404           2 :    ldv_assume(ldv_4_ret_default == 0);
    1405             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    1406             : 
    1407             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    1408             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1409             : 
    1410             :    /* Jump to a subprocess 'call' initial state */
    1411           1 :    goto ldv_call_4;
    1412             :   }
    1413             :   else {
    1414             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    1415           2 :    ldv_assume(ldv_4_ret_default != 0);
    1416             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    1417             : 
    1418             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1419             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1420             : 
    1421             :    /* Jump to a subprocess 'main' initial state */
    1422           1 :    goto ldv_main_4;
    1423             :   }
    1424             :  }
    1425             :  else {
    1426             :   /* LDV {"action": "DEFAULT_FREE_4", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1427           2 :   ldv_free(ldv_4_rtc_device_rtc_device);
    1428             :   /* LDV {"action": "DEFAULT_FREE_4", "type": "CONDITION_END"} */
    1429             : 
    1430             :   /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    1431             :   /* Skip a non-replicative signal receiving */
    1432             :   /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "RECEIVE_END"} */
    1433             : 
    1434             :   /* Exit function at a terminal state */
    1435           1 :   return;
    1436             :  }
    1437             :  /* End of the subprocess 'main' */
    1438             :  return;
    1439           1 : 
    1440             :  /* Sbprocess call */
    1441             :  ldv_call_4:
    1442             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1443             : 
    1444           4 :  if (ldv_undef_int()) {
    1445             :   /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "comment": "Call callback 'callback' of a process 'rtc_class_scenario' of an interface category 'rtc'"} */
    1446             :   /* Skip callback without implementations */
    1447             :   /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1448             : 
    1449             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    1450             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1451             : 
    1452             :   /* Jump to a subprocess 'call' initial state */
    1453           1 :   goto ldv_call_4;
    1454             :  }
    1455             :  else {
    1456             :   /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from rtc_class_ops."} */
    1457             :   /* LDV {"type": "CALLBACK", "call": "((& i2c_adapter_dev_release))(ldv_4_device_device);", "comment": "release"} */
    1458           2 :   ldv_rtc_class_scenario_release_4_2(ldv_4_rtc_class_ops_rtc_class_ops->release, ldv_4_device_device);
    1459             :   /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    1460             : 
    1461             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1462             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1463             : 
    1464             :   /* Jump to a subprocess 'main' initial state */
    1465           1 :   goto ldv_main_4;
    1466             :  }
    1467             :  /* End of the subprocess 'call' */
    1468             :  return;
    1469             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_4"} */
    1470             : }
    1471             : 
    1472             : /* AUX_FUNC ldv_rtc_class_scenario_5 */
    1473             : void ldv_rtc_class_scenario_5(void *arg0) {
    1474             :  /* LDV {"thread": 5, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_5"} */
    1475           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1476           1 :  struct device *ldv_5_device_device;
    1477           1 :  int ldv_5_ret_default;
    1478           1 :  struct rtc_class_ops *ldv_5_rtc_class_ops_rtc_class_ops;
    1479           1 :  struct rtc_device *ldv_5_rtc_device_rtc_device;
    1480           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1481           1 :  /* Initialize automaton variables */
    1482           2 :  ldv_5_ret_default = 1;
    1483           1 :  /* LDV {"action": "DEFAULT_REGISTER_4", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    1484           3 :  ldv_free(arg0);
    1485             :  /* LDV {"action": "DEFAULT_REGISTER_4", "type": "RECEIVE_END"} */
    1486             : 
    1487             :  /* LDV {"action": "DEFAULT_ALLOC_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1488           3 :  ldv_5_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    1489           3 :  ldv_5_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    1490           3 :  ldv_5_device_device = ldv_xmalloc_unknown_size(0);
    1491             :  /* LDV {"action": "DEFAULT_ALLOC_4", "type": "CONDITION_END"} */
    1492             : 
    1493             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1494             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1495             : 
    1496             :  /* Jump to a subprocess 'main' initial state */
    1497           1 :  goto ldv_main_5;
    1498             :  /* End of the process */
    1499             :  return;
    1500           1 : 
    1501             :  /* Sbprocess main */
    1502             :  ldv_main_5:
    1503             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1504             : 
    1505           4 :  if (ldv_undef_int()) {
    1506             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    1507             :   /* Callback pre-call */
    1508           1 :   ldv_pre_probe();
    1509           3 :   if (ldv_5_rtc_class_ops_rtc_class_ops->open) {
    1510             :   /* LDV {"type": "CALLBACK", "call": "ldv_5_ret_default = (ldv_5_rtc_class_ops_rtc_class_ops->open)(ldv_5_device_device);", "comment": "probe"} */
    1511           2 :    ldv_5_ret_default = ldv_rtc_class_scenario_probe_5_11(ldv_5_rtc_class_ops_rtc_class_ops->open, ldv_5_device_device);
    1512             :   }
    1513             :   /* Callback post-call */
    1514           4 :   ldv_5_ret_default = ldv_post_probe(ldv_5_ret_default);
    1515             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    1516             : 
    1517           4 :   if (ldv_undef_int()) {
    1518             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    1519           2 :    ldv_assume(ldv_5_ret_default == 0);
    1520             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    1521             : 
    1522             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    1523             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1524             : 
    1525             :    /* Jump to a subprocess 'call' initial state */
    1526           1 :    goto ldv_call_5;
    1527             :   }
    1528             :   else {
    1529             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    1530           2 :    ldv_assume(ldv_5_ret_default != 0);
    1531             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    1532             : 
    1533             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1534             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1535             : 
    1536             :    /* Jump to a subprocess 'main' initial state */
    1537           1 :    goto ldv_main_5;
    1538             :   }
    1539             :  }
    1540             :  else {
    1541             :   /* LDV {"action": "DEFAULT_FREE_4", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1542           2 :   ldv_free(ldv_5_rtc_device_rtc_device);
    1543             :   /* LDV {"action": "DEFAULT_FREE_4", "type": "CONDITION_END"} */
    1544             : 
    1545             :   /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    1546             :   /* Skip a non-replicative signal receiving */
    1547             :   /* LDV {"action": "DEFAULT_DEREGISTER_4", "type": "RECEIVE_END"} */
    1548             : 
    1549             :   /* Exit function at a terminal state */
    1550           1 :   return;
    1551             :  }
    1552             :  /* End of the subprocess 'main' */
    1553             :  return;
    1554           1 : 
    1555             :  /* Sbprocess call */
    1556             :  ldv_call_5:
    1557             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1558             : 
    1559           4 :  if (ldv_undef_int()) {
    1560             :   /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "comment": "Call callback 'callback' of a process 'rtc_class_scenario' of an interface category 'rtc'"} */
    1561             :   /* Skip callback without implementations */
    1562             :   /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1563             : 
    1564             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    1565             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1566             : 
    1567             :   /* Jump to a subprocess 'call' initial state */
    1568           1 :   goto ldv_call_5;
    1569             :  }
    1570             :  else {
    1571             :   /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from rtc_class_ops."} */
    1572             :   /* LDV {"type": "CALLBACK", "call": "((& i2c_client_dev_release))(ldv_5_device_device);", "comment": "release"} */
    1573           2 :   ldv_rtc_class_scenario_release_5_2(ldv_5_rtc_class_ops_rtc_class_ops->release, ldv_5_device_device);
    1574             :   /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    1575             : 
    1576             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    1577             :   /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    1578             : 
    1579             :   /* Jump to a subprocess 'main' initial state */
    1580           1 :   goto ldv_main_5;
    1581             :  }
    1582             :  /* End of the subprocess 'call' */
    1583             :  return;
    1584             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_5"} */
    1585             : }
    1586             : 
    1587             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_probe_4_11 */
    1588             : int ldv_rtc_class_scenario_probe_4_11(int (*arg0)(struct device *), struct device *arg1) {
    1589           5 :  return (*arg0)(arg1);
    1590           1 : }
    1591             : 
    1592             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_probe_5_11 */
    1593             : int ldv_rtc_class_scenario_probe_5_11(int (*arg0)(struct device *), struct device *arg1) {
    1594           5 :  return (*arg0)(arg1);
    1595           1 : }
    1596             : 
    1597             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_release_4_2 */
    1598             : void ldv_rtc_class_scenario_release_4_2(void (*arg0)(struct device *), struct device *arg1) {
    1599           2 :  ((& i2c_adapter_dev_release))(arg1);
    1600           1 : }
    1601             : 
    1602             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_release_5_2 */
    1603             : void ldv_rtc_class_scenario_release_5_2(void (*arg0)(struct device *), struct device *arg1) {
    1604           2 :  ((& i2c_client_dev_release))(arg1);
    1605           1 : }
    1606             : 
    1607             : /* AUX_FUNC main */
    1608             : int main() {
    1609           1 :  ldv_main_11(0);
    1610           0 :  return 0;
    1611             : }
    1612             : 
    1613             : 
    1614             : /* AUX_FUNC  ERR_PTR */
    1615             : static inline void *ERR_PTR (long int error)
    1616             : {
    1617             : 
    1618             :  return ldv_err_ptr(error);
    1619             : }
    1620             : 
    1621             : /* AUX_FUNC  PTR_ERR */
    1622             : static inline long int PTR_ERR (void const *ptr)
    1623             : {
    1624             : 
    1625             :  return ldv_ptr_err(ptr);
    1626             : }
    1627             : 
    1628             : /* AUX_FUNC  IS_ERR */
    1629             : static inline long int IS_ERR (void const *ptr)
    1630             : {
    1631             : 
    1632             :  return ldv_is_err(ptr);
    1633             : }
    1634             : 
    1635             : /* AUX_FUNC  IS_ERR_OR_NULL */
    1636             : static inline long int IS_ERR_OR_NULL (void const *ptr)
    1637             : {
    1638             : 
    1639             :  return ldv_is_err_or_null(ptr);
    1640             : }
    1641             : 
    1642             : /* AUX_FUNC  kzalloc */
    1643             : static inline void *kzalloc (size_t size, gfp_t flags)
    1644             : {
    1645           1 : 
    1646           3 :  return ldv_kzalloc(size, flags);
    1647             : }
    1648             : 
    1649             : /* AUX_FUNC  ldv_dev_get_drvdata_6 */
    1650             : void *ldv_dev_get_drvdata_6 (struct device const *dev)
    1651             : {
    1652             : 
    1653             :  return ldv_dev_get_drvdata(dev);
    1654             : }
    1655             : 
    1656             : /* AUX_FUNC  ldv_dev_get_drvdata_7 */
    1657             : void *ldv_dev_get_drvdata_7 (struct device const *dev)
    1658             : {
    1659             : 
    1660             :  return ldv_dev_get_drvdata(dev);
    1661             : }

Generated by: LCOV version 1.10