LCOV - code coverage report
Current view: top level - avtg/drivers/scsi/scsi_mod.ko/linux:drivers:clk2/weaver - scsi_sysfs.c.aux (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1393 1406 99.1 %
Date: 2017-01-25 Functions: 91 91 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/cdev.h>
      30             : #include <linux/miscdevice.h>
      31             : #include <linux/platform_device.h>
      32             : #include <linux/pm.h>
      33             : #include <linux/rtc.h>
      34             : #include <scsi/scsi_host.h>
      35             : #include <linux/fs.h>
      36             : #include <linux/seq_file.h>
      37             : #include <linux/pagemap.h>
      38             : 
      39             : 
      40             : struct ldv_struct_platform_instance_4 {
      41             :  int signal_pending;
      42             : };
      43             : 
      44             : struct ldv_struct_traverse_kernel_items_scenario_10 {
      45             :  struct seq_file *arg0;
      46             :  struct seq_operations *arg1;
      47             :  int signal_pending;
      48             : };
      49             : 
      50             : /* EMG Function declarations */
      51             : void ldv_pm_ops_scenario_3(void *);
      52             : void ldv_pm_ops_scenario_complete_3_3(void (*)(struct device *), struct device *);
      53             : extern void ldv_pm_ops_scenario_freeze_3_13(int (*)(struct device *), struct device *);
      54             : extern void ldv_pm_ops_scenario_freeze_noirq_3_11(int (*)(struct device *), struct device *);
      55             : extern void ldv_pm_ops_scenario_poweroff_3_8(int (*)(struct device *), struct device *);
      56             : extern void ldv_pm_ops_scenario_poweroff_noirq_3_7(int (*)(struct device *), struct device *);
      57             : extern void ldv_pm_ops_scenario_prepare_3_19(int (*)(struct device *), struct device *);
      58             : extern void ldv_pm_ops_scenario_restore_3_4(int (*)(struct device *), struct device *);
      59             : extern void ldv_pm_ops_scenario_restore_noirq_3_6(int (*)(struct device *), struct device *);
      60             : void ldv_pm_ops_scenario_resume_3_14(int (*)(struct device *), struct device *);
      61             : extern void ldv_pm_ops_scenario_resume_noirq_3_16(int (*)(struct device *), struct device *);
      62             : extern void ldv_pm_ops_scenario_runtime_idle_3_24(int (*)(struct device *), struct device *);
      63             : extern void ldv_pm_ops_scenario_runtime_resume_3_21(int (*)(struct device *), struct device *);
      64             : extern void ldv_pm_ops_scenario_runtime_suspend_3_22(int (*)(struct device *), struct device *);
      65             : extern void ldv_pm_ops_scenario_suspend_3_18(int (*)(struct device *), struct device *);
      66             : extern void ldv_pm_ops_scenario_suspend_noirq_3_17(int (*)(struct device *), struct device *);
      67             : extern void ldv_pm_ops_scenario_thaw_3_9(int (*)(struct device *), struct device *);
      68             : extern void ldv_pm_ops_scenario_thaw_noirq_3_10(int (*)(struct device *), struct device *);
      69             : void ldv_random_containerless_scenario_11(void *);
      70             : void ldv_random_containerless_scenario_12(void *);
      71             : void ldv_random_containerless_scenario_13(void *);
      72             : void ldv_random_containerless_scenario_14(void *);
      73             : void ldv_random_containerless_scenario_15(void *);
      74             : void ldv_random_containerless_scenario_16(void *);
      75             : void ldv_random_containerless_scenario_17(void *);
      76             : void ldv_random_containerless_scenario_18(void *);
      77             : void ldv_random_containerless_scenario_19(void *);
      78             : void ldv_random_containerless_scenario_20(void *);
      79             : void ldv_random_containerless_scenario_21(void *);
      80             : void ldv_random_containerless_scenario_22(void *);
      81             : void ldv_random_containerless_scenario_23(void *);
      82             : void ldv_random_containerless_scenario_24(void *);
      83             : void ldv_random_containerless_scenario_25(void *);
      84             : void ldv_random_containerless_scenario_26(void *);
      85             : void ldv_random_containerless_scenario_27(void *);
      86             : void ldv_random_containerless_scenario_28(void *);
      87             : void ldv_random_containerless_scenario_29(void *);
      88             : void ldv_random_containerless_scenario_30(void *);
      89             : void ldv_random_containerless_scenario_31(void *);
      90             : void ldv_random_containerless_scenario_32(void *);
      91             : void ldv_random_containerless_scenario_33(void *);
      92             : void ldv_random_containerless_scenario_34(void *);
      93             : void ldv_random_containerless_scenario_35(void *);
      94             : void ldv_random_containerless_scenario_36(void *);
      95             : void ldv_random_containerless_scenario_37(void *);
      96             : void ldv_random_containerless_scenario_38(void *);
      97             : void ldv_random_containerless_scenario_39(void *);
      98             : void ldv_random_containerless_scenario_40(void *);
      99             : void ldv_random_containerless_scenario_41(void *);
     100             : void ldv_random_containerless_scenario_42(void *);
     101             : extern void ldv_random_containerless_scenario_callback_11_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     102             : void ldv_random_containerless_scenario_callback_11_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     103             : extern void ldv_random_containerless_scenario_callback_12_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     104             : void ldv_random_containerless_scenario_callback_12_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     105             : extern void ldv_random_containerless_scenario_callback_13_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     106             : void ldv_random_containerless_scenario_callback_13_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     107             : void ldv_random_containerless_scenario_callback_14_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     108             : extern void ldv_random_containerless_scenario_callback_14_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     109             : extern void ldv_random_containerless_scenario_callback_15_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     110             : void ldv_random_containerless_scenario_callback_15_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     111             : void ldv_random_containerless_scenario_callback_16_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     112             : void ldv_random_containerless_scenario_callback_16_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     113             : extern void ldv_random_containerless_scenario_callback_17_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     114             : void ldv_random_containerless_scenario_callback_17_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     115             : void ldv_random_containerless_scenario_callback_18_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     116             : void ldv_random_containerless_scenario_callback_18_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     117             : extern void ldv_random_containerless_scenario_callback_19_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     118             : void ldv_random_containerless_scenario_callback_19_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     119             : extern void ldv_random_containerless_scenario_callback_20_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     120             : void ldv_random_containerless_scenario_callback_20_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     121             : extern void ldv_random_containerless_scenario_callback_21_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     122             : void ldv_random_containerless_scenario_callback_21_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     123             : extern void ldv_random_containerless_scenario_callback_22_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     124             : void ldv_random_containerless_scenario_callback_22_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     125             : extern void ldv_random_containerless_scenario_callback_23_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     126             : void ldv_random_containerless_scenario_callback_23_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     127             : extern void ldv_random_containerless_scenario_callback_24_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     128             : void ldv_random_containerless_scenario_callback_24_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     129             : extern void ldv_random_containerless_scenario_callback_25_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     130             : void ldv_random_containerless_scenario_callback_25_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     131             : extern void ldv_random_containerless_scenario_callback_26_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     132             : void ldv_random_containerless_scenario_callback_26_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     133             : extern void ldv_random_containerless_scenario_callback_27_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     134             : void ldv_random_containerless_scenario_callback_27_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     135             : void ldv_random_containerless_scenario_callback_28_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     136             : extern void ldv_random_containerless_scenario_callback_28_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     137             : extern void ldv_random_containerless_scenario_callback_29_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     138             : void ldv_random_containerless_scenario_callback_29_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     139             : void ldv_random_containerless_scenario_callback_30_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     140             : extern void ldv_random_containerless_scenario_callback_30_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     141             : extern void ldv_random_containerless_scenario_callback_31_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     142             : void ldv_random_containerless_scenario_callback_31_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     143             : extern void ldv_random_containerless_scenario_callback_32_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     144             : void ldv_random_containerless_scenario_callback_32_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     145             : void ldv_random_containerless_scenario_callback_33_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     146             : void ldv_random_containerless_scenario_callback_33_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     147             : extern void ldv_random_containerless_scenario_callback_34_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     148             : void ldv_random_containerless_scenario_callback_34_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     149             : void ldv_random_containerless_scenario_callback_35_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     150             : void ldv_random_containerless_scenario_callback_35_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     151             : extern void ldv_random_containerless_scenario_callback_36_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     152             : void ldv_random_containerless_scenario_callback_36_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     153             : extern void ldv_random_containerless_scenario_callback_37_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     154             : void ldv_random_containerless_scenario_callback_37_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     155             : extern void ldv_random_containerless_scenario_callback_38_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     156             : void ldv_random_containerless_scenario_callback_38_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     157             : extern void ldv_random_containerless_scenario_callback_39_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     158             : void ldv_random_containerless_scenario_callback_39_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     159             : void ldv_random_containerless_scenario_callback_40_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     160             : void ldv_random_containerless_scenario_callback_40_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     161             : void ldv_random_containerless_scenario_callback_41_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     162             : void ldv_random_containerless_scenario_callback_41_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     163             : void ldv_random_containerless_scenario_callback_42_10(ssize_t (*)(struct device *, struct device_attribute *, char *, size_t ), struct device *, struct device_attribute *, char *, long unsigned int);
     164             : void ldv_random_containerless_scenario_callback_42_4(ssize_t (*)(struct device *, struct device_attribute *, char *), struct device *, struct device_attribute *, char *);
     165             : void ldv_rtc_class_scenario_5(void *);
     166             : void ldv_rtc_class_scenario_6(void *);
     167             : void ldv_rtc_class_scenario_7(void *);
     168             : void ldv_rtc_class_scenario_8(void *);
     169             : void ldv_rtc_class_scenario_9(void *);
     170             : void ldv_rtc_class_scenario_callback_5_15(void (*)(struct device *), struct device *);
     171             : void ldv_rtc_class_scenario_callback_5_4(void (*)(struct device *), struct device *);
     172             : void ldv_rtc_class_scenario_callback_6_15(void (*)(struct device *), struct device *);
     173             : extern void ldv_rtc_class_scenario_callback_6_4(void (*)(struct device *), struct device *);
     174             : void ldv_rtc_class_scenario_callback_7_15(void (*)(struct device *), struct device *);
     175             : void ldv_rtc_class_scenario_callback_7_4(void (*)(struct device *), struct device *);
     176             : void ldv_rtc_class_scenario_callback_8_15(void (*)(struct device *), struct device *);
     177             : void ldv_rtc_class_scenario_callback_8_4(void (*)(struct device *), struct device *);
     178             : void ldv_rtc_class_scenario_callback_9_15(void (*)(struct device *), struct device *);
     179             : void ldv_rtc_class_scenario_callback_9_4(void (*)(struct device *), struct device *);
     180             : extern int ldv_rtc_class_scenario_probe_5_11(int (*)(struct device *), struct device *);
     181             : extern int ldv_rtc_class_scenario_probe_6_11(int (*)(struct device *), struct device *);
     182             : extern int ldv_rtc_class_scenario_probe_7_11(int (*)(struct device *), struct device *);
     183             : extern int ldv_rtc_class_scenario_probe_8_11(int (*)(struct device *), struct device *);
     184             : extern int ldv_rtc_class_scenario_probe_9_11(int (*)(struct device *), struct device *);
     185             : void ldv_rtc_class_scenario_release_5_2(void (*)(struct device *), struct device *);
     186             : void ldv_rtc_class_scenario_release_6_2(void (*)(struct device *), struct device *);
     187             : void ldv_rtc_class_scenario_release_7_2(void (*)(struct device *), struct device *);
     188             : extern void ldv_rtc_class_scenario_release_8_2(void (*)(struct device *), struct device *);
     189             : extern void ldv_rtc_class_scenario_release_9_2(void (*)(struct device *), struct device *);
     190             : 
     191             : /* EMG variable declarations */
     192           1 : struct ldv_thread ldv_thread_11;
     193           1 : struct ldv_thread ldv_thread_12;
     194           1 : struct ldv_thread ldv_thread_13;
     195           1 : struct ldv_thread ldv_thread_14;
     196           1 : struct ldv_thread ldv_thread_15;
     197           1 : struct ldv_thread ldv_thread_16;
     198           1 : struct ldv_thread ldv_thread_17;
     199           1 : struct ldv_thread ldv_thread_18;
     200           1 : struct ldv_thread ldv_thread_19;
     201           1 : struct ldv_thread ldv_thread_20;
     202           1 : struct ldv_thread ldv_thread_21;
     203           1 : struct ldv_thread ldv_thread_22;
     204           1 : struct ldv_thread ldv_thread_23;
     205           1 : struct ldv_thread ldv_thread_24;
     206           1 : struct ldv_thread ldv_thread_25;
     207           1 : struct ldv_thread ldv_thread_26;
     208           1 : struct ldv_thread ldv_thread_27;
     209           1 : struct ldv_thread ldv_thread_28;
     210           1 : struct ldv_thread ldv_thread_29;
     211           1 : struct ldv_thread ldv_thread_3;
     212           1 : struct ldv_thread ldv_thread_30;
     213           1 : struct ldv_thread ldv_thread_31;
     214           1 : struct ldv_thread ldv_thread_32;
     215           1 : struct ldv_thread ldv_thread_33;
     216           1 : struct ldv_thread ldv_thread_34;
     217           1 : struct ldv_thread ldv_thread_35;
     218           1 : struct ldv_thread ldv_thread_36;
     219           1 : struct ldv_thread ldv_thread_37;
     220           1 : struct ldv_thread ldv_thread_38;
     221           1 : struct ldv_thread ldv_thread_39;
     222           1 : struct ldv_thread ldv_thread_40;
     223           1 : struct ldv_thread ldv_thread_41;
     224           1 : struct ldv_thread ldv_thread_42;
     225           1 : struct ldv_thread ldv_thread_5;
     226           1 : struct ldv_thread ldv_thread_6;
     227           1 : struct ldv_thread ldv_thread_7;
     228           1 : struct ldv_thread ldv_thread_8;
     229           1 : struct ldv_thread ldv_thread_9;
     230             : 
     231             : /* EMG variable initialization */
     232             : 
     233             : /* EMG function definitions */
     234             : /* AUX_FUNC ldv_pm_ops_scenario_3 */
     235             : void ldv_pm_ops_scenario_3(void *arg0) {
     236             :  /* LDV {"thread": 3, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'pm_ops_scenario(pm)'", "function": "ldv_pm_ops_scenario_3"} */
     237           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     238           1 :  struct device *ldv_3_device_device;
     239           1 :  struct dev_pm_ops *ldv_3_pm_ops_dev_pm_ops;
     240           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     241           1 :  /* LDV {"action": "PM_REGISTER", "type": "RECEIVE_BEGIN", "comment": "Ready for a power management scenarios."} */
     242           3 :  ldv_free(arg0);
     243           1 :  /* LDV {"action": "PM_REGISTER", "type": "RECEIVE_END"} */
     244             : 
     245             :  /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     246             :  /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     247             : 
     248             :  /* Jump to a subprocess 'do' initial state */
     249           1 :  goto ldv_do_3;
     250             :  /* End of the process */
     251             :  return;
     252           1 : 
     253             :  /* Sbprocess do */
     254             :  ldv_do_3:
     255             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     256             : 
     257           2 :  switch (ldv_undef_int()) {
     258           3 :   case 1: {
     259             :    /* 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."} */
     260           3 :    if (ldv_3_pm_ops_dev_pm_ops->runtime_idle) {
     261             :    /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->runtime_idle)(ldv_3_device_device);", "comment": "runtime_idle"} */
     262           2 :     ldv_pm_ops_scenario_runtime_idle_3_24(ldv_3_pm_ops_dev_pm_ops->runtime_idle, ldv_3_device_device);
     263             :    }
     264             :    /* LDV {"action": "RUNTIME_IDLE", "type": "CALL_END"} */
     265             : 
     266             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     267             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     268             : 
     269             :    /* Jump to a subprocess 'do' initial state */
     270           2 :    goto ldv_do_3;
     271           1 :    break;
     272             :   }
     273           3 :   case 2: {
     274             :    /* 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."} */
     275           3 :    if (ldv_3_pm_ops_dev_pm_ops->runtime_suspend) {
     276             :    /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->runtime_suspend)(ldv_3_device_device);", "comment": "runtime_suspend"} */
     277           2 :     ldv_pm_ops_scenario_runtime_suspend_3_22(ldv_3_pm_ops_dev_pm_ops->runtime_suspend, ldv_3_device_device);
     278             :    }
     279             :    /* LDV {"action": "RUNTIME_SUSPEND", "type": "CALL_END"} */
     280             : 
     281             :    /* 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."} */
     282           6 :    if (ldv_3_pm_ops_dev_pm_ops->runtime_resume) {
     283             :    /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->runtime_resume)(ldv_3_device_device);", "comment": "runtime_resume"} */
     284           4 :     ldv_pm_ops_scenario_runtime_resume_3_21(ldv_3_pm_ops_dev_pm_ops->runtime_resume, ldv_3_device_device);
     285             :    }
     286             :    /* LDV {"action": "RUNTIME_RESUME", "type": "CALL_END"} */
     287             : 
     288             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     289             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     290             : 
     291             :    /* Jump to a subprocess 'do' initial state */
     292           3 :    goto ldv_do_3;
     293           1 :    break;
     294             :   }
     295           3 :   case 3: {
     296             :    /* LDV {"action": "PREPARE", "type": "CALL_BEGIN", "callback": true, "comment": "Prevent new children of the device from being registered. Invoke callback prepare from PM."} */
     297           3 :    if (ldv_3_pm_ops_dev_pm_ops->prepare) {
     298             :    /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->prepare)(ldv_3_device_device);", "comment": "prepare"} */
     299           2 :     ldv_pm_ops_scenario_prepare_3_19(ldv_3_pm_ops_dev_pm_ops->prepare, ldv_3_device_device);
     300             :    }
     301             :    /* LDV {"action": "PREPARE", "type": "CALL_END"} */
     302             : 
     303           4 :    switch (ldv_undef_int()) {
     304           3 :     case 1: {
     305             :      /* LDV {"action": "SUSPEND", "type": "CALL_BEGIN", "callback": true, "comment": "Quiesce subsystem-level device before suspend. Invoke callback suspend from PM."} */
     306           3 :      if (ldv_3_pm_ops_dev_pm_ops->suspend) {
     307             :      /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->suspend)(ldv_3_device_device);", "comment": "suspend"} */
     308           2 :       ldv_pm_ops_scenario_suspend_3_18(ldv_3_pm_ops_dev_pm_ops->suspend, ldv_3_device_device);
     309             :      }
     310             :      /* LDV {"action": "SUSPEND", "type": "CALL_END"} */
     311             : 
     312           6 :      if (ldv_undef_int()) {
     313             :       /* 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."} */
     314           3 :       if (ldv_3_pm_ops_dev_pm_ops->suspend_noirq) {
     315             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->suspend_noirq)(ldv_3_device_device);", "comment": "suspend_noirq"} */
     316           2 :        ldv_pm_ops_scenario_suspend_noirq_3_17(ldv_3_pm_ops_dev_pm_ops->suspend_noirq, ldv_3_device_device);
     317             :       }
     318             :       /* LDV {"action": "SUSPEND_NOIRQ", "type": "CALL_END"} */
     319             : 
     320             :       /* 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."} */
     321           6 :       if (ldv_3_pm_ops_dev_pm_ops->resume_noirq) {
     322             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->resume_noirq)(ldv_3_device_device);", "comment": "resume_noirq"} */
     323           4 :        ldv_pm_ops_scenario_resume_noirq_3_16(ldv_3_pm_ops_dev_pm_ops->resume_noirq, ldv_3_device_device);
     324             :       }
     325             :       /* LDV {"action": "RESUME_NOIRQ", "type": "CALL_END"} */
     326             : 
     327             :      }
     328             :      else {
     329             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     330             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     331             : 
     332             :      }
     333             :      /* LDV {"action": "RESUME", "type": "CALL_BEGIN", "callback": true, "comment": "Make the device start working again after resume. Invoke callback resume from dev_pm_ops."} */
     334             :      /* LDV {"type": "CALLBACK", "call": "((& scsi_bus_resume))(ldv_3_device_device);", "comment": "resume"} */
     335           6 :      ldv_pm_ops_scenario_resume_3_14(ldv_3_pm_ops_dev_pm_ops->resume, ldv_3_device_device);
     336             :      /* LDV {"action": "RESUME", "type": "CALL_END"} */
     337             : 
     338           1 :      break;
     339           1 :     }
     340           3 :     case 2: {
     341             :      /* LDV {"action": "FREEZE", "type": "CALL_BEGIN", "callback": true, "comment": "Prepare for creating a hibernation image. Invoke callback freeze from PM."} */
     342           3 :      if (ldv_3_pm_ops_dev_pm_ops->freeze) {
     343             :      /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->freeze)(ldv_3_device_device);", "comment": "freeze"} */
     344           2 :       ldv_pm_ops_scenario_freeze_3_13(ldv_3_pm_ops_dev_pm_ops->freeze, ldv_3_device_device);
     345             :      }
     346             :      /* LDV {"action": "FREEZE", "type": "CALL_END"} */
     347             : 
     348           6 :      if (ldv_undef_int()) {
     349             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     350             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     351             : 
     352             :      }
     353             :      else {
     354             :       /* 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."} */
     355           3 :       if (ldv_3_pm_ops_dev_pm_ops->freeze_noirq) {
     356             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->freeze_noirq)(ldv_3_device_device);", "comment": "freeze_noirq"} */
     357           2 :        ldv_pm_ops_scenario_freeze_noirq_3_11(ldv_3_pm_ops_dev_pm_ops->freeze_noirq, ldv_3_device_device);
     358             :       }
     359             :       /* LDV {"action": "FREEZE_NOIRQ", "type": "CALL_END"} */
     360             : 
     361             :       /* 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."} */
     362           6 :       if (ldv_3_pm_ops_dev_pm_ops->thaw_noirq) {
     363             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->thaw_noirq)(ldv_3_device_device);", "comment": "thaw_noirq"} */
     364           4 :        ldv_pm_ops_scenario_thaw_noirq_3_10(ldv_3_pm_ops_dev_pm_ops->thaw_noirq, ldv_3_device_device);
     365             :       }
     366             :       /* LDV {"action": "THAW_NOIRQ", "type": "CALL_END"} */
     367             : 
     368             :      }
     369             :      /* LDV {"action": "THAW", "type": "CALL_BEGIN", "callback": true, "comment": "The hibernation image has created or creation has failed. Invoke callback thaw from PM."} */
     370           9 :      if (ldv_3_pm_ops_dev_pm_ops->thaw) {
     371             :      /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->thaw)(ldv_3_device_device);", "comment": "thaw"} */
     372           6 :       ldv_pm_ops_scenario_thaw_3_9(ldv_3_pm_ops_dev_pm_ops->thaw, ldv_3_device_device);
     373             :      }
     374             :      /* LDV {"action": "THAW", "type": "CALL_END"} */
     375             : 
     376           4 :      break;
     377           1 :     }
     378           3 :     case 3: {
     379             :      /* LDV {"action": "POWEROFF", "type": "CALL_BEGIN", "callback": true, "comment": "Hibernation image has been created. Invoke callback poweroff from PM."} */
     380           3 :      if (ldv_3_pm_ops_dev_pm_ops->poweroff) {
     381             :      /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->poweroff)(ldv_3_device_device);", "comment": "poweroff"} */
     382           2 :       ldv_pm_ops_scenario_poweroff_3_8(ldv_3_pm_ops_dev_pm_ops->poweroff, ldv_3_device_device);
     383             :      }
     384             :      /* LDV {"action": "POWEROFF", "type": "CALL_END"} */
     385             : 
     386           6 :      if (ldv_undef_int()) {
     387             :       /* LDV {"action": "POWEROFF_NOIRQ", "type": "CALL_BEGIN", "callback": true, "comment": "Complete the actions started by #poweroff(). Invoke callback poweroff_noirq from PM."} */
     388           3 :       if (ldv_3_pm_ops_dev_pm_ops->poweroff_noirq) {
     389             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->poweroff_noirq)(ldv_3_device_device);", "comment": "poweroff_noirq"} */
     390           2 :        ldv_pm_ops_scenario_poweroff_noirq_3_7(ldv_3_pm_ops_dev_pm_ops->poweroff_noirq, ldv_3_device_device);
     391             :       }
     392             :       /* LDV {"action": "POWEROFF_NOIRQ", "type": "CALL_END"} */
     393             : 
     394             :       /* 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."} */
     395           6 :       if (ldv_3_pm_ops_dev_pm_ops->restore_noirq) {
     396             :       /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->restore_noirq)(ldv_3_device_device);", "comment": "restore_noirq"} */
     397           4 :        ldv_pm_ops_scenario_restore_noirq_3_6(ldv_3_pm_ops_dev_pm_ops->restore_noirq, ldv_3_device_device);
     398             :       }
     399             :       /* LDV {"action": "RESTORE_NOIRQ", "type": "CALL_END"} */
     400             : 
     401             :      }
     402             :      else {
     403             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_BEGIN", "comment": "Skip noirq callbacks"} */
     404             :       /* LDV {"action": "SKIP_NOIRQ", "type": "CONDITION_END"} */
     405             : 
     406             :      }
     407             :      /* 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."} */
     408           9 :      if (ldv_3_pm_ops_dev_pm_ops->restore) {
     409             :      /* LDV {"type": "CALLBACK", "call": "(ldv_3_pm_ops_dev_pm_ops->restore)(ldv_3_device_device);", "comment": "restore"} */
     410           6 :       ldv_pm_ops_scenario_restore_3_4(ldv_3_pm_ops_dev_pm_ops->restore, ldv_3_device_device);
     411             :      }
     412             :      /* LDV {"action": "RESTORE", "type": "CALL_END"} */
     413             : 
     414           4 :      break;
     415           1 :     }
     416           2 :     default: ldv_stop();
     417           1 :    }
     418           0 :    /* LDV {"action": "COMPLETE", "type": "CALL_BEGIN", "callback": true, "comment": "Undo the changes made by #prepare(). Invoke callback complete from PM."} */
     419             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_3_device_device);", "comment": "complete"} */
     420          18 :    ldv_pm_ops_scenario_complete_3_3(ldv_3_pm_ops_dev_pm_ops->complete, ldv_3_device_device);
     421             :    /* LDV {"action": "COMPLETE", "type": "CALL_END"} */
     422             : 
     423             :    /* LDV {"action": "DO", "type": "SUBPROCESS_BEGIN", "comment": "Begin a power management scenario."} */
     424             :    /* LDV {"action": "DO", "type": "SUBPROCESS_END"} */
     425             : 
     426             :    /* Jump to a subprocess 'do' initial state */
     427           1 :    goto ldv_do_3;
     428           1 :    break;
     429             :   }
     430           3 :   case 4: {
     431             :    /* LDV {"action": "PM_DEREGISTER", "type": "RECEIVE_BEGIN", "comment": "Do not expect power management scenarios."} */
     432             :    /* Skip a non-replicative signal receiving */
     433             :    /* LDV {"action": "PM_DEREGISTER", "type": "RECEIVE_END"} */
     434             : 
     435             :    /* Exit function at a terminal state */
     436           1 :    return;
     437           1 :    break;
     438             :   }
     439           2 :   default: ldv_stop();
     440           1 :  }
     441           0 :  /* End of the subprocess 'do' */
     442           0 :  return;
     443             :  /* LDV {"comment": "End of control function based on process 'pm_ops_scenario(pm)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_pm_ops_scenario_3"} */
     444             : }
     445             : 
     446             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_complete_3_3 */
     447             : void ldv_pm_ops_scenario_complete_3_3(void (*arg0)(struct device *), struct device *arg1) {
     448          18 :  ((sdev_store_delete_callback))(arg1);
     449           9 : }
     450             : 
     451             : /* AUX_FUNC_CALLBACK ldv_pm_ops_scenario_resume_3_14 */
     452             : void ldv_pm_ops_scenario_resume_3_14(int (*arg0)(struct device *), struct device *arg1) {
     453           9 :  ((& scsi_bus_resume))(arg1);
     454           3 : }
     455             : 
     456             : /* AUX_FUNC ldv_random_containerless_scenario_11 */
     457             : void ldv_random_containerless_scenario_11(void *arg0) {
     458             :  /* LDV {"thread": 11, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_11"} */
     459           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     460           1 :  ssize_t (*ldv_11_callback_show)(struct device *, struct device_attribute *, char *);
     461             :  ssize_t (*ldv_11_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     462           1 :  struct device_attribute *ldv_11_container_struct_device_attribute;
     463           1 :  struct device *ldv_11_container_struct_device_ptr;
     464           1 :  char *ldv_11_ldv_param_10_2_default;
     465           1 :  long unsigned int ldv_11_ldv_param_10_3_default;
     466           1 :  char *ldv_11_ldv_param_4_2_default;
     467           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     468           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     469           3 :  ldv_free(arg0);
     470           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     471           1 : 
     472           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     473           3 :  ldv_11_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     474           3 :  ldv_11_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     475             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     476             : 
     477             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     478             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     479             : 
     480             :  /* Jump to a subprocess 'call' initial state */
     481           1 :  goto ldv_call_11;
     482             :  /* End of the process */
     483             :  return;
     484           1 : 
     485             :  /* Sbprocess call */
     486             :  ldv_call_11:
     487             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     488             : 
     489           4 :  if (ldv_undef_int()) {
     490             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     491           3 :   ldv_11_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     492             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     493             : 
     494           4 :   if (ldv_undef_int()) {
     495             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     496           3 :    ldv_11_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     497             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     498             : 
     499             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
     500           2 :    if (ldv_11_callback_store) {
     501             :    /* LDV {"type": "CALLBACK", "call": "(ldv_11_callback_store)(ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_10_2_default, ldv_11_ldv_param_10_3_default);", "comment": "callback"} */
     502           2 :     ldv_random_containerless_scenario_callback_11_10(ldv_11_callback_store, ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_10_2_default, ldv_11_ldv_param_10_3_default);
     503             :    }
     504             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     505             : 
     506             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     507           4 :    ldv_free(ldv_11_ldv_param_10_2_default);
     508             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     509             : 
     510             :   }
     511             :   else {
     512             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
     513             :    /* LDV {"type": "CALLBACK", "call": "((& show_shost_active_mode))(ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_4_2_default);", "comment": "callback"} */
     514           2 :    ldv_random_containerless_scenario_callback_11_4(ldv_11_callback_show, ldv_11_container_struct_device_ptr, ldv_11_container_struct_device_attribute, ldv_11_ldv_param_4_2_default);
     515             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     516             : 
     517             :   }
     518             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     519           4 :   ldv_free(ldv_11_ldv_param_4_2_default);
     520             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     521             : 
     522             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     523             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     524             : 
     525             :   /* Jump to a subprocess 'call' initial state */
     526           1 :   goto ldv_call_11;
     527             :  }
     528             :  else {
     529             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     530           2 :   ldv_free(ldv_11_container_struct_device_attribute);
     531           2 :   ldv_free(ldv_11_container_struct_device_ptr);
     532             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     533             : 
     534             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     535             :   /* Skip a non-replicative signal receiving */
     536             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     537             : 
     538             :   /* Exit function at a terminal state */
     539           1 :   return;
     540             :  }
     541             :  /* End of the subprocess 'call' */
     542             :  return;
     543             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_11"} */
     544             : }
     545             : 
     546             : /* AUX_FUNC ldv_random_containerless_scenario_12 */
     547             : void ldv_random_containerless_scenario_12(void *arg0) {
     548             :  /* LDV {"thread": 12, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_12"} */
     549           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     550           1 :  ssize_t (*ldv_12_callback_show)(struct device *, struct device_attribute *, char *);
     551             :  ssize_t (*ldv_12_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     552           1 :  struct device_attribute *ldv_12_container_struct_device_attribute;
     553           1 :  struct device *ldv_12_container_struct_device_ptr;
     554           1 :  char *ldv_12_ldv_param_10_2_default;
     555           1 :  long unsigned int ldv_12_ldv_param_10_3_default;
     556           1 :  char *ldv_12_ldv_param_4_2_default;
     557           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     558           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     559           3 :  ldv_free(arg0);
     560           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     561           1 : 
     562           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     563           3 :  ldv_12_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     564           3 :  ldv_12_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     565             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     566             : 
     567             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     568             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     569             : 
     570             :  /* Jump to a subprocess 'call' initial state */
     571           1 :  goto ldv_call_12;
     572             :  /* End of the process */
     573             :  return;
     574           1 : 
     575             :  /* Sbprocess call */
     576             :  ldv_call_12:
     577             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     578             : 
     579           4 :  if (ldv_undef_int()) {
     580             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     581           3 :   ldv_12_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     582             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     583             : 
     584           4 :   if (ldv_undef_int()) {
     585             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     586           3 :    ldv_12_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     587             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     588             : 
     589             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
     590           2 :    if (ldv_12_callback_store) {
     591             :    /* LDV {"type": "CALLBACK", "call": "(ldv_12_callback_store)(ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_10_2_default, ldv_12_ldv_param_10_3_default);", "comment": "callback"} */
     592           2 :     ldv_random_containerless_scenario_callback_12_10(ldv_12_callback_store, ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_10_2_default, ldv_12_ldv_param_10_3_default);
     593             :    }
     594             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     595             : 
     596             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     597           4 :    ldv_free(ldv_12_ldv_param_10_2_default);
     598             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     599             : 
     600             :   }
     601             :   else {
     602             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
     603             :    /* LDV {"type": "CALLBACK", "call": "((& show_can_queue))(ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_4_2_default);", "comment": "callback"} */
     604           2 :    ldv_random_containerless_scenario_callback_12_4(ldv_12_callback_show, ldv_12_container_struct_device_ptr, ldv_12_container_struct_device_attribute, ldv_12_ldv_param_4_2_default);
     605             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     606             : 
     607             :   }
     608             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     609           4 :   ldv_free(ldv_12_ldv_param_4_2_default);
     610             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     611             : 
     612             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     613             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     614             : 
     615             :   /* Jump to a subprocess 'call' initial state */
     616           1 :   goto ldv_call_12;
     617             :  }
     618             :  else {
     619             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     620           2 :   ldv_free(ldv_12_container_struct_device_attribute);
     621           2 :   ldv_free(ldv_12_container_struct_device_ptr);
     622             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     623             : 
     624             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     625             :   /* Skip a non-replicative signal receiving */
     626             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     627             : 
     628             :   /* Exit function at a terminal state */
     629           1 :   return;
     630             :  }
     631             :  /* End of the subprocess 'call' */
     632             :  return;
     633             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_12"} */
     634             : }
     635             : 
     636             : /* AUX_FUNC ldv_random_containerless_scenario_13 */
     637             : void ldv_random_containerless_scenario_13(void *arg0) {
     638             :  /* LDV {"thread": 13, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_13"} */
     639           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     640           1 :  ssize_t (*ldv_13_callback_show)(struct device *, struct device_attribute *, char *);
     641             :  ssize_t (*ldv_13_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     642           1 :  struct device_attribute *ldv_13_container_struct_device_attribute;
     643           1 :  struct device *ldv_13_container_struct_device_ptr;
     644           1 :  char *ldv_13_ldv_param_10_2_default;
     645           1 :  long unsigned int ldv_13_ldv_param_10_3_default;
     646           1 :  char *ldv_13_ldv_param_4_2_default;
     647           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     648           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     649           3 :  ldv_free(arg0);
     650           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     651           1 : 
     652           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     653           3 :  ldv_13_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     654           3 :  ldv_13_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     655             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     656             : 
     657             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     658             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     659             : 
     660             :  /* Jump to a subprocess 'call' initial state */
     661           1 :  goto ldv_call_13;
     662             :  /* End of the process */
     663             :  return;
     664           1 : 
     665             :  /* Sbprocess call */
     666             :  ldv_call_13:
     667             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     668             : 
     669           4 :  if (ldv_undef_int()) {
     670             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     671           3 :   ldv_13_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     672             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     673             : 
     674           4 :   if (ldv_undef_int()) {
     675             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     676           3 :    ldv_13_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     677             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     678             : 
     679             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
     680           2 :    if (ldv_13_callback_store) {
     681             :    /* LDV {"type": "CALLBACK", "call": "(ldv_13_callback_store)(ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_10_2_default, ldv_13_ldv_param_10_3_default);", "comment": "callback"} */
     682           2 :     ldv_random_containerless_scenario_callback_13_10(ldv_13_callback_store, ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_10_2_default, ldv_13_ldv_param_10_3_default);
     683             :    }
     684             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     685             : 
     686             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     687           4 :    ldv_free(ldv_13_ldv_param_10_2_default);
     688             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     689             : 
     690             :   }
     691             :   else {
     692             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
     693             :    /* LDV {"type": "CALLBACK", "call": "((& show_cmd_per_lun))(ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_4_2_default);", "comment": "callback"} */
     694           2 :    ldv_random_containerless_scenario_callback_13_4(ldv_13_callback_show, ldv_13_container_struct_device_ptr, ldv_13_container_struct_device_attribute, ldv_13_ldv_param_4_2_default);
     695             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     696             : 
     697             :   }
     698             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     699           4 :   ldv_free(ldv_13_ldv_param_4_2_default);
     700             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     701             : 
     702             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     703             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     704             : 
     705             :   /* Jump to a subprocess 'call' initial state */
     706           1 :   goto ldv_call_13;
     707             :  }
     708             :  else {
     709             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     710           2 :   ldv_free(ldv_13_container_struct_device_attribute);
     711           2 :   ldv_free(ldv_13_container_struct_device_ptr);
     712             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     713             : 
     714             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     715             :   /* Skip a non-replicative signal receiving */
     716             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     717             : 
     718             :   /* Exit function at a terminal state */
     719           1 :   return;
     720             :  }
     721             :  /* End of the subprocess 'call' */
     722             :  return;
     723             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_13"} */
     724             : }
     725             : 
     726             : /* AUX_FUNC ldv_random_containerless_scenario_14 */
     727             : void ldv_random_containerless_scenario_14(void *arg0) {
     728             :  /* LDV {"thread": 14, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_14"} */
     729           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     730           1 :  ssize_t (*ldv_14_callback_show)(struct device *, struct device_attribute *, char *);
     731             :  ssize_t (*ldv_14_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     732           1 :  struct device_attribute *ldv_14_container_struct_device_attribute;
     733           1 :  struct device *ldv_14_container_struct_device_ptr;
     734           1 :  char *ldv_14_ldv_param_10_2_default;
     735           1 :  long unsigned int ldv_14_ldv_param_10_3_default;
     736           1 :  char *ldv_14_ldv_param_4_2_default;
     737           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     738           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     739           3 :  ldv_free(arg0);
     740           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     741           1 : 
     742           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     743           3 :  ldv_14_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     744           3 :  ldv_14_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     745             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     746             : 
     747             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     748             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     749             : 
     750             :  /* Jump to a subprocess 'call' initial state */
     751           1 :  goto ldv_call_14;
     752             :  /* End of the process */
     753             :  return;
     754           1 : 
     755             :  /* Sbprocess call */
     756             :  ldv_call_14:
     757             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     758             : 
     759           4 :  if (ldv_undef_int()) {
     760             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     761           3 :   ldv_14_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     762             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     763             : 
     764           4 :   if (ldv_undef_int()) {
     765             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     766           3 :    ldv_14_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     767             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     768             : 
     769             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
     770             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_delete))(ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_10_2_default, ldv_14_ldv_param_10_3_default);", "comment": "callback"} */
     771           2 :    ldv_random_containerless_scenario_callback_14_10(ldv_14_callback_store, ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_10_2_default, ldv_14_ldv_param_10_3_default);
     772             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     773             : 
     774             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     775           2 :    ldv_free(ldv_14_ldv_param_10_2_default);
     776             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     777             : 
     778             :   }
     779             :   else {
     780             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
     781           2 :    if (ldv_14_callback_show) {
     782             :    /* LDV {"type": "CALLBACK", "call": "(ldv_14_callback_show)(ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_4_2_default);", "comment": "callback"} */
     783           2 :     ldv_random_containerless_scenario_callback_14_4(ldv_14_callback_show, ldv_14_container_struct_device_ptr, ldv_14_container_struct_device_attribute, ldv_14_ldv_param_4_2_default);
     784             :    }
     785             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     786             : 
     787             :   }
     788             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     789           6 :   ldv_free(ldv_14_ldv_param_4_2_default);
     790             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     791             : 
     792             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     793             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     794             : 
     795             :   /* Jump to a subprocess 'call' initial state */
     796           1 :   goto ldv_call_14;
     797             :  }
     798             :  else {
     799             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     800           2 :   ldv_free(ldv_14_container_struct_device_attribute);
     801           2 :   ldv_free(ldv_14_container_struct_device_ptr);
     802             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     803             : 
     804             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     805             :   /* Skip a non-replicative signal receiving */
     806             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     807             : 
     808             :   /* Exit function at a terminal state */
     809           1 :   return;
     810             :  }
     811             :  /* End of the subprocess 'call' */
     812             :  return;
     813             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_14"} */
     814             : }
     815             : 
     816             : /* AUX_FUNC ldv_random_containerless_scenario_15 */
     817             : void ldv_random_containerless_scenario_15(void *arg0) {
     818             :  /* LDV {"thread": 15, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_15"} */
     819           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     820           1 :  ssize_t (*ldv_15_callback_show)(struct device *, struct device_attribute *, char *);
     821             :  ssize_t (*ldv_15_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     822           1 :  struct device_attribute *ldv_15_container_struct_device_attribute;
     823           1 :  struct device *ldv_15_container_struct_device_ptr;
     824           1 :  char *ldv_15_ldv_param_10_2_default;
     825           1 :  long unsigned int ldv_15_ldv_param_10_3_default;
     826           1 :  char *ldv_15_ldv_param_4_2_default;
     827           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     828           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     829           3 :  ldv_free(arg0);
     830           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     831           1 : 
     832           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     833           3 :  ldv_15_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     834           3 :  ldv_15_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     835             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     836             : 
     837             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     838             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     839             : 
     840             :  /* Jump to a subprocess 'call' initial state */
     841           1 :  goto ldv_call_15;
     842             :  /* End of the process */
     843             :  return;
     844           1 : 
     845             :  /* Sbprocess call */
     846             :  ldv_call_15:
     847             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     848             : 
     849           4 :  if (ldv_undef_int()) {
     850             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     851           3 :   ldv_15_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     852             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     853             : 
     854           4 :   if (ldv_undef_int()) {
     855             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     856           3 :    ldv_15_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     857             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     858             : 
     859             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
     860           2 :    if (ldv_15_callback_store) {
     861             :    /* LDV {"type": "CALLBACK", "call": "(ldv_15_callback_store)(ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_10_2_default, ldv_15_ldv_param_10_3_default);", "comment": "callback"} */
     862           2 :     ldv_random_containerless_scenario_callback_15_10(ldv_15_callback_store, ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_10_2_default, ldv_15_ldv_param_10_3_default);
     863             :    }
     864             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     865             : 
     866             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     867           4 :    ldv_free(ldv_15_ldv_param_10_2_default);
     868             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     869             : 
     870             :   }
     871             :   else {
     872             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
     873             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_device_blocked))(ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_4_2_default);", "comment": "callback"} */
     874           2 :    ldv_random_containerless_scenario_callback_15_4(ldv_15_callback_show, ldv_15_container_struct_device_ptr, ldv_15_container_struct_device_attribute, ldv_15_ldv_param_4_2_default);
     875             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     876             : 
     877             :   }
     878             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     879           4 :   ldv_free(ldv_15_ldv_param_4_2_default);
     880             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     881             : 
     882             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     883             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     884             : 
     885             :   /* Jump to a subprocess 'call' initial state */
     886           1 :   goto ldv_call_15;
     887             :  }
     888             :  else {
     889             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     890           2 :   ldv_free(ldv_15_container_struct_device_attribute);
     891           2 :   ldv_free(ldv_15_container_struct_device_ptr);
     892             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     893             : 
     894             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     895             :   /* Skip a non-replicative signal receiving */
     896             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     897             : 
     898             :   /* Exit function at a terminal state */
     899           1 :   return;
     900             :  }
     901             :  /* End of the subprocess 'call' */
     902             :  return;
     903             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_15"} */
     904             : }
     905             : 
     906             : /* AUX_FUNC ldv_random_containerless_scenario_16 */
     907             : void ldv_random_containerless_scenario_16(void *arg0) {
     908             :  /* LDV {"thread": 16, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_16"} */
     909           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     910           1 :  ssize_t (*ldv_16_callback_show)(struct device *, struct device_attribute *, char *);
     911             :  ssize_t (*ldv_16_callback_store)(struct device *, struct device_attribute *, char *, size_t );
     912           1 :  struct device_attribute *ldv_16_container_struct_device_attribute;
     913           1 :  struct device *ldv_16_container_struct_device_ptr;
     914           1 :  char *ldv_16_ldv_param_10_2_default;
     915           1 :  long unsigned int ldv_16_ldv_param_10_3_default;
     916           1 :  char *ldv_16_ldv_param_4_2_default;
     917           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     918           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     919           3 :  ldv_free(arg0);
     920           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
     921           1 : 
     922           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     923           3 :  ldv_16_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
     924           3 :  ldv_16_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
     925             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
     926             : 
     927             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     928             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     929             : 
     930             :  /* Jump to a subprocess 'call' initial state */
     931           1 :  goto ldv_call_16;
     932             :  /* End of the process */
     933             :  return;
     934           1 : 
     935             :  /* Sbprocess call */
     936             :  ldv_call_16:
     937             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     938             : 
     939           4 :  if (ldv_undef_int()) {
     940             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     941           3 :   ldv_16_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
     942             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     943             : 
     944           4 :   if (ldv_undef_int()) {
     945             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     946           3 :    ldv_16_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
     947             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     948             : 
     949             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
     950             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_evt_media_change))(ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_10_2_default, ldv_16_ldv_param_10_3_default);", "comment": "callback"} */
     951           2 :    ldv_random_containerless_scenario_callback_16_10(ldv_16_callback_store, ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_10_2_default, ldv_16_ldv_param_10_3_default);
     952             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     953             : 
     954             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     955           2 :    ldv_free(ldv_16_ldv_param_10_2_default);
     956             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     957             : 
     958             :   }
     959             :   else {
     960             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
     961             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_evt_media_change))(ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_4_2_default);", "comment": "callback"} */
     962           2 :    ldv_random_containerless_scenario_callback_16_4(ldv_16_callback_show, ldv_16_container_struct_device_ptr, ldv_16_container_struct_device_attribute, ldv_16_ldv_param_4_2_default);
     963             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     964             : 
     965             :   }
     966             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     967           4 :   ldv_free(ldv_16_ldv_param_4_2_default);
     968             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     969             : 
     970             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     971             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     972             : 
     973             :   /* Jump to a subprocess 'call' initial state */
     974           1 :   goto ldv_call_16;
     975             :  }
     976             :  else {
     977             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     978           2 :   ldv_free(ldv_16_container_struct_device_attribute);
     979           2 :   ldv_free(ldv_16_container_struct_device_ptr);
     980             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
     981             : 
     982             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
     983             :   /* Skip a non-replicative signal receiving */
     984             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
     985             : 
     986             :   /* Exit function at a terminal state */
     987           1 :   return;
     988             :  }
     989             :  /* End of the subprocess 'call' */
     990             :  return;
     991             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_16"} */
     992             : }
     993             : 
     994             : /* AUX_FUNC ldv_random_containerless_scenario_17 */
     995             : void ldv_random_containerless_scenario_17(void *arg0) {
     996             :  /* LDV {"thread": 17, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_17"} */
     997           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     998           1 :  ssize_t (*ldv_17_callback_show)(struct device *, struct device_attribute *, char *);
     999             :  ssize_t (*ldv_17_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1000           1 :  struct device_attribute *ldv_17_container_struct_device_attribute;
    1001           1 :  struct device *ldv_17_container_struct_device_ptr;
    1002           1 :  char *ldv_17_ldv_param_10_2_default;
    1003           1 :  long unsigned int ldv_17_ldv_param_10_3_default;
    1004           1 :  char *ldv_17_ldv_param_4_2_default;
    1005           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1006           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1007           3 :  ldv_free(arg0);
    1008           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1009           1 : 
    1010           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1011           3 :  ldv_17_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1012           3 :  ldv_17_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1013             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1014             : 
    1015             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1016             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1017             : 
    1018             :  /* Jump to a subprocess 'call' initial state */
    1019           1 :  goto ldv_call_17;
    1020             :  /* End of the process */
    1021             :  return;
    1022           1 : 
    1023             :  /* Sbprocess call */
    1024             :  ldv_call_17:
    1025             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1026             : 
    1027           4 :  if (ldv_undef_int()) {
    1028             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1029           3 :   ldv_17_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1030             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1031             : 
    1032           4 :   if (ldv_undef_int()) {
    1033             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1034           3 :    ldv_17_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1035             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1036             : 
    1037             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1038           2 :    if (ldv_17_callback_store) {
    1039             :    /* LDV {"type": "CALLBACK", "call": "(ldv_17_callback_store)(ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_10_2_default, ldv_17_ldv_param_10_3_default);", "comment": "callback"} */
    1040           2 :     ldv_random_containerless_scenario_callback_17_10(ldv_17_callback_store, ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_10_2_default, ldv_17_ldv_param_10_3_default);
    1041             :    }
    1042             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1043             : 
    1044             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1045           4 :    ldv_free(ldv_17_ldv_param_10_2_default);
    1046             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1047             : 
    1048             :   }
    1049             :   else {
    1050             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1051             :    /* LDV {"type": "CALLBACK", "call": "((& show_host_busy))(ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_4_2_default);", "comment": "callback"} */
    1052           2 :    ldv_random_containerless_scenario_callback_17_4(ldv_17_callback_show, ldv_17_container_struct_device_ptr, ldv_17_container_struct_device_attribute, ldv_17_ldv_param_4_2_default);
    1053             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1054             : 
    1055             :   }
    1056             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1057           4 :   ldv_free(ldv_17_ldv_param_4_2_default);
    1058             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1059             : 
    1060             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1061             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1062             : 
    1063             :   /* Jump to a subprocess 'call' initial state */
    1064           1 :   goto ldv_call_17;
    1065             :  }
    1066             :  else {
    1067             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1068           2 :   ldv_free(ldv_17_container_struct_device_attribute);
    1069           2 :   ldv_free(ldv_17_container_struct_device_ptr);
    1070             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1071             : 
    1072             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1073             :   /* Skip a non-replicative signal receiving */
    1074             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1075             : 
    1076             :   /* Exit function at a terminal state */
    1077           1 :   return;
    1078             :  }
    1079             :  /* End of the subprocess 'call' */
    1080             :  return;
    1081             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_17"} */
    1082             : }
    1083             : 
    1084             : /* AUX_FUNC ldv_random_containerless_scenario_18 */
    1085             : void ldv_random_containerless_scenario_18(void *arg0) {
    1086             :  /* LDV {"thread": 18, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_18"} */
    1087           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1088           1 :  ssize_t (*ldv_18_callback_show)(struct device *, struct device_attribute *, char *);
    1089             :  ssize_t (*ldv_18_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1090           1 :  struct device_attribute *ldv_18_container_struct_device_attribute;
    1091           1 :  struct device *ldv_18_container_struct_device_ptr;
    1092           1 :  char *ldv_18_ldv_param_10_2_default;
    1093           1 :  long unsigned int ldv_18_ldv_param_10_3_default;
    1094           1 :  char *ldv_18_ldv_param_4_2_default;
    1095           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1096           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1097           3 :  ldv_free(arg0);
    1098           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1099           1 : 
    1100           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1101           3 :  ldv_18_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1102           3 :  ldv_18_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1103             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1104             : 
    1105             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1106             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1107             : 
    1108             :  /* Jump to a subprocess 'call' initial state */
    1109           1 :  goto ldv_call_18;
    1110             :  /* End of the process */
    1111             :  return;
    1112           1 : 
    1113             :  /* Sbprocess call */
    1114             :  ldv_call_18:
    1115             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1116             : 
    1117           4 :  if (ldv_undef_int()) {
    1118             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1119           3 :   ldv_18_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1120             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1121             : 
    1122           4 :   if (ldv_undef_int()) {
    1123             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1124           3 :    ldv_18_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1125             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1126             : 
    1127             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    1128             :    /* LDV {"type": "CALLBACK", "call": "((& store_shost_state))(ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_10_2_default, ldv_18_ldv_param_10_3_default);", "comment": "callback"} */
    1129           2 :    ldv_random_containerless_scenario_callback_18_10(ldv_18_callback_store, ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_10_2_default, ldv_18_ldv_param_10_3_default);
    1130             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1131             : 
    1132             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1133           2 :    ldv_free(ldv_18_ldv_param_10_2_default);
    1134             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1135             : 
    1136             :   }
    1137             :   else {
    1138             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1139             :    /* LDV {"type": "CALLBACK", "call": "((& show_shost_state))(ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_4_2_default);", "comment": "callback"} */
    1140           2 :    ldv_random_containerless_scenario_callback_18_4(ldv_18_callback_show, ldv_18_container_struct_device_ptr, ldv_18_container_struct_device_attribute, ldv_18_ldv_param_4_2_default);
    1141             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1142             : 
    1143             :   }
    1144             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1145           4 :   ldv_free(ldv_18_ldv_param_4_2_default);
    1146             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1147             : 
    1148             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1149             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1150             : 
    1151             :   /* Jump to a subprocess 'call' initial state */
    1152           1 :   goto ldv_call_18;
    1153             :  }
    1154             :  else {
    1155             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1156           2 :   ldv_free(ldv_18_container_struct_device_attribute);
    1157           2 :   ldv_free(ldv_18_container_struct_device_ptr);
    1158             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1159             : 
    1160             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1161             :   /* Skip a non-replicative signal receiving */
    1162             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1163             : 
    1164             :   /* Exit function at a terminal state */
    1165           1 :   return;
    1166             :  }
    1167             :  /* End of the subprocess 'call' */
    1168             :  return;
    1169             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_18"} */
    1170             : }
    1171             : 
    1172             : /* AUX_FUNC ldv_random_containerless_scenario_19 */
    1173             : void ldv_random_containerless_scenario_19(void *arg0) {
    1174             :  /* LDV {"thread": 19, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_19"} */
    1175           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1176           1 :  ssize_t (*ldv_19_callback_show)(struct device *, struct device_attribute *, char *);
    1177             :  ssize_t (*ldv_19_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1178           1 :  struct device_attribute *ldv_19_container_struct_device_attribute;
    1179           1 :  struct device *ldv_19_container_struct_device_ptr;
    1180           1 :  char *ldv_19_ldv_param_10_2_default;
    1181           1 :  long unsigned int ldv_19_ldv_param_10_3_default;
    1182           1 :  char *ldv_19_ldv_param_4_2_default;
    1183           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1184           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1185           3 :  ldv_free(arg0);
    1186           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1187           1 : 
    1188           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1189           3 :  ldv_19_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1190           3 :  ldv_19_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1191             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1192             : 
    1193             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1194             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1195             : 
    1196             :  /* Jump to a subprocess 'call' initial state */
    1197           1 :  goto ldv_call_19;
    1198             :  /* End of the process */
    1199             :  return;
    1200           1 : 
    1201             :  /* Sbprocess call */
    1202             :  ldv_call_19:
    1203             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1204             : 
    1205           4 :  if (ldv_undef_int()) {
    1206             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1207           3 :   ldv_19_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1208             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1209             : 
    1210           4 :   if (ldv_undef_int()) {
    1211             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1212           3 :    ldv_19_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1213             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1214             : 
    1215             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1216           2 :    if (ldv_19_callback_store) {
    1217             :    /* LDV {"type": "CALLBACK", "call": "(ldv_19_callback_store)(ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_10_2_default, ldv_19_ldv_param_10_3_default);", "comment": "callback"} */
    1218           2 :     ldv_random_containerless_scenario_callback_19_10(ldv_19_callback_store, ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_10_2_default, ldv_19_ldv_param_10_3_default);
    1219             :    }
    1220             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1221             : 
    1222             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1223           4 :    ldv_free(ldv_19_ldv_param_10_2_default);
    1224             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1225             : 
    1226             :   }
    1227             :   else {
    1228             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1229             :    /* LDV {"type": "CALLBACK", "call": "((& show_iostat_counterbits))(ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_4_2_default);", "comment": "callback"} */
    1230           2 :    ldv_random_containerless_scenario_callback_19_4(ldv_19_callback_show, ldv_19_container_struct_device_ptr, ldv_19_container_struct_device_attribute, ldv_19_ldv_param_4_2_default);
    1231             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1232             : 
    1233             :   }
    1234             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1235           4 :   ldv_free(ldv_19_ldv_param_4_2_default);
    1236             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1237             : 
    1238             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1239             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1240             : 
    1241             :   /* Jump to a subprocess 'call' initial state */
    1242           1 :   goto ldv_call_19;
    1243             :  }
    1244             :  else {
    1245             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1246           2 :   ldv_free(ldv_19_container_struct_device_attribute);
    1247           2 :   ldv_free(ldv_19_container_struct_device_ptr);
    1248             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1249             : 
    1250             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1251             :   /* Skip a non-replicative signal receiving */
    1252             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1253             : 
    1254             :   /* Exit function at a terminal state */
    1255           1 :   return;
    1256             :  }
    1257             :  /* End of the subprocess 'call' */
    1258             :  return;
    1259             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_19"} */
    1260             : }
    1261             : 
    1262             : /* AUX_FUNC ldv_random_containerless_scenario_20 */
    1263             : void ldv_random_containerless_scenario_20(void *arg0) {
    1264             :  /* LDV {"thread": 20, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_20"} */
    1265           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1266           1 :  ssize_t (*ldv_20_callback_show)(struct device *, struct device_attribute *, char *);
    1267             :  ssize_t (*ldv_20_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1268           1 :  struct device_attribute *ldv_20_container_struct_device_attribute;
    1269           1 :  struct device *ldv_20_container_struct_device_ptr;
    1270           1 :  char *ldv_20_ldv_param_10_2_default;
    1271           1 :  long unsigned int ldv_20_ldv_param_10_3_default;
    1272           1 :  char *ldv_20_ldv_param_4_2_default;
    1273           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1274           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1275           3 :  ldv_free(arg0);
    1276           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1277           1 : 
    1278           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1279           3 :  ldv_20_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1280           3 :  ldv_20_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1281             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1282             : 
    1283             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1284             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1285             : 
    1286             :  /* Jump to a subprocess 'call' initial state */
    1287           1 :  goto ldv_call_20;
    1288             :  /* End of the process */
    1289             :  return;
    1290           1 : 
    1291             :  /* Sbprocess call */
    1292             :  ldv_call_20:
    1293             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1294             : 
    1295           4 :  if (ldv_undef_int()) {
    1296             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1297           3 :   ldv_20_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1298             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1299             : 
    1300           4 :   if (ldv_undef_int()) {
    1301             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1302           3 :    ldv_20_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1303             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1304             : 
    1305             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1306           2 :    if (ldv_20_callback_store) {
    1307             :    /* LDV {"type": "CALLBACK", "call": "(ldv_20_callback_store)(ldv_20_container_struct_device_ptr, ldv_20_container_struct_device_attribute, ldv_20_ldv_param_10_2_default, ldv_20_ldv_param_10_3_default);", "comment": "callback"} */
    1308           2 :     ldv_random_containerless_scenario_callback_20_10(ldv_20_callback_store, ldv_20_container_struct_device_ptr, ldv_20_container_struct_device_attribute, ldv_20_ldv_param_10_2_default, ldv_20_ldv_param_10_3_default);
    1309             :    }
    1310             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1311             : 
    1312             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1313           4 :    ldv_free(ldv_20_ldv_param_10_2_default);
    1314             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1315             : 
    1316             :   }
    1317             :   else {
    1318             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1319             :    /* LDV {"type": "CALLBACK", "call": "((& show_iostat_iodone_cnt))(ldv_20_container_struct_device_ptr, ldv_20_container_struct_device_attribute, ldv_20_ldv_param_4_2_default);", "comment": "callback"} */
    1320           2 :    ldv_random_containerless_scenario_callback_20_4(ldv_20_callback_show, ldv_20_container_struct_device_ptr, ldv_20_container_struct_device_attribute, ldv_20_ldv_param_4_2_default);
    1321             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1322             : 
    1323             :   }
    1324             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1325           4 :   ldv_free(ldv_20_ldv_param_4_2_default);
    1326             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1327             : 
    1328             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1329             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1330             : 
    1331             :   /* Jump to a subprocess 'call' initial state */
    1332           1 :   goto ldv_call_20;
    1333             :  }
    1334             :  else {
    1335             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1336           2 :   ldv_free(ldv_20_container_struct_device_attribute);
    1337           2 :   ldv_free(ldv_20_container_struct_device_ptr);
    1338             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1339             : 
    1340             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1341             :   /* Skip a non-replicative signal receiving */
    1342             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1343             : 
    1344             :   /* Exit function at a terminal state */
    1345           1 :   return;
    1346             :  }
    1347             :  /* End of the subprocess 'call' */
    1348             :  return;
    1349             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_20"} */
    1350             : }
    1351             : 
    1352             : /* AUX_FUNC ldv_random_containerless_scenario_21 */
    1353             : void ldv_random_containerless_scenario_21(void *arg0) {
    1354             :  /* LDV {"thread": 21, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_21"} */
    1355           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1356           1 :  ssize_t (*ldv_21_callback_show)(struct device *, struct device_attribute *, char *);
    1357             :  ssize_t (*ldv_21_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1358           1 :  struct device_attribute *ldv_21_container_struct_device_attribute;
    1359           1 :  struct device *ldv_21_container_struct_device_ptr;
    1360           1 :  char *ldv_21_ldv_param_10_2_default;
    1361           1 :  long unsigned int ldv_21_ldv_param_10_3_default;
    1362           1 :  char *ldv_21_ldv_param_4_2_default;
    1363           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1364           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1365           3 :  ldv_free(arg0);
    1366           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1367           1 : 
    1368           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1369           3 :  ldv_21_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1370           3 :  ldv_21_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1371             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1372             : 
    1373             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1374             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1375             : 
    1376             :  /* Jump to a subprocess 'call' initial state */
    1377           1 :  goto ldv_call_21;
    1378             :  /* End of the process */
    1379             :  return;
    1380           1 : 
    1381             :  /* Sbprocess call */
    1382             :  ldv_call_21:
    1383             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1384             : 
    1385           4 :  if (ldv_undef_int()) {
    1386             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1387           3 :   ldv_21_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1388             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1389             : 
    1390           4 :   if (ldv_undef_int()) {
    1391             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1392           3 :    ldv_21_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1393             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1394             : 
    1395             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1396           2 :    if (ldv_21_callback_store) {
    1397             :    /* LDV {"type": "CALLBACK", "call": "(ldv_21_callback_store)(ldv_21_container_struct_device_ptr, ldv_21_container_struct_device_attribute, ldv_21_ldv_param_10_2_default, ldv_21_ldv_param_10_3_default);", "comment": "callback"} */
    1398           2 :     ldv_random_containerless_scenario_callback_21_10(ldv_21_callback_store, ldv_21_container_struct_device_ptr, ldv_21_container_struct_device_attribute, ldv_21_ldv_param_10_2_default, ldv_21_ldv_param_10_3_default);
    1399             :    }
    1400             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1401             : 
    1402             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1403           4 :    ldv_free(ldv_21_ldv_param_10_2_default);
    1404             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1405             : 
    1406             :   }
    1407             :   else {
    1408             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1409             :    /* LDV {"type": "CALLBACK", "call": "((& show_iostat_ioerr_cnt))(ldv_21_container_struct_device_ptr, ldv_21_container_struct_device_attribute, ldv_21_ldv_param_4_2_default);", "comment": "callback"} */
    1410           2 :    ldv_random_containerless_scenario_callback_21_4(ldv_21_callback_show, ldv_21_container_struct_device_ptr, ldv_21_container_struct_device_attribute, ldv_21_ldv_param_4_2_default);
    1411             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1412             : 
    1413             :   }
    1414             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1415           4 :   ldv_free(ldv_21_ldv_param_4_2_default);
    1416             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1417             : 
    1418             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1419             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1420             : 
    1421             :   /* Jump to a subprocess 'call' initial state */
    1422           1 :   goto ldv_call_21;
    1423             :  }
    1424             :  else {
    1425             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1426           2 :   ldv_free(ldv_21_container_struct_device_attribute);
    1427           2 :   ldv_free(ldv_21_container_struct_device_ptr);
    1428             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1429             : 
    1430             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1431             :   /* Skip a non-replicative signal receiving */
    1432             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1433             : 
    1434             :   /* Exit function at a terminal state */
    1435           1 :   return;
    1436             :  }
    1437             :  /* End of the subprocess 'call' */
    1438             :  return;
    1439             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_21"} */
    1440             : }
    1441             : 
    1442             : /* AUX_FUNC ldv_random_containerless_scenario_22 */
    1443             : void ldv_random_containerless_scenario_22(void *arg0) {
    1444             :  /* LDV {"thread": 22, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_22"} */
    1445           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1446           1 :  ssize_t (*ldv_22_callback_show)(struct device *, struct device_attribute *, char *);
    1447             :  ssize_t (*ldv_22_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1448           1 :  struct device_attribute *ldv_22_container_struct_device_attribute;
    1449           1 :  struct device *ldv_22_container_struct_device_ptr;
    1450           1 :  char *ldv_22_ldv_param_10_2_default;
    1451           1 :  long unsigned int ldv_22_ldv_param_10_3_default;
    1452           1 :  char *ldv_22_ldv_param_4_2_default;
    1453           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1454           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1455           3 :  ldv_free(arg0);
    1456           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1457           1 : 
    1458           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1459           3 :  ldv_22_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1460           3 :  ldv_22_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1461             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1462             : 
    1463             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1464             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1465             : 
    1466             :  /* Jump to a subprocess 'call' initial state */
    1467           1 :  goto ldv_call_22;
    1468             :  /* End of the process */
    1469             :  return;
    1470           1 : 
    1471             :  /* Sbprocess call */
    1472             :  ldv_call_22:
    1473             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1474             : 
    1475           4 :  if (ldv_undef_int()) {
    1476             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1477           3 :   ldv_22_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1478             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1479             : 
    1480           4 :   if (ldv_undef_int()) {
    1481             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1482           3 :    ldv_22_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1483             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1484             : 
    1485             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1486           2 :    if (ldv_22_callback_store) {
    1487             :    /* LDV {"type": "CALLBACK", "call": "(ldv_22_callback_store)(ldv_22_container_struct_device_ptr, ldv_22_container_struct_device_attribute, ldv_22_ldv_param_10_2_default, ldv_22_ldv_param_10_3_default);", "comment": "callback"} */
    1488           2 :     ldv_random_containerless_scenario_callback_22_10(ldv_22_callback_store, ldv_22_container_struct_device_ptr, ldv_22_container_struct_device_attribute, ldv_22_ldv_param_10_2_default, ldv_22_ldv_param_10_3_default);
    1489             :    }
    1490             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1491             : 
    1492             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1493           4 :    ldv_free(ldv_22_ldv_param_10_2_default);
    1494             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1495             : 
    1496             :   }
    1497             :   else {
    1498             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1499             :    /* LDV {"type": "CALLBACK", "call": "((& show_iostat_iorequest_cnt))(ldv_22_container_struct_device_ptr, ldv_22_container_struct_device_attribute, ldv_22_ldv_param_4_2_default);", "comment": "callback"} */
    1500           2 :    ldv_random_containerless_scenario_callback_22_4(ldv_22_callback_show, ldv_22_container_struct_device_ptr, ldv_22_container_struct_device_attribute, ldv_22_ldv_param_4_2_default);
    1501             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1502             : 
    1503             :   }
    1504             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1505           4 :   ldv_free(ldv_22_ldv_param_4_2_default);
    1506             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1507             : 
    1508             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1509             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1510             : 
    1511             :   /* Jump to a subprocess 'call' initial state */
    1512           1 :   goto ldv_call_22;
    1513             :  }
    1514             :  else {
    1515             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1516           2 :   ldv_free(ldv_22_container_struct_device_attribute);
    1517           2 :   ldv_free(ldv_22_container_struct_device_ptr);
    1518             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1519             : 
    1520             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1521             :   /* Skip a non-replicative signal receiving */
    1522             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1523             : 
    1524             :   /* Exit function at a terminal state */
    1525           1 :   return;
    1526             :  }
    1527             :  /* End of the subprocess 'call' */
    1528             :  return;
    1529             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_22"} */
    1530             : }
    1531             : 
    1532             : /* AUX_FUNC ldv_random_containerless_scenario_23 */
    1533             : void ldv_random_containerless_scenario_23(void *arg0) {
    1534             :  /* LDV {"thread": 23, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_23"} */
    1535           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1536           1 :  ssize_t (*ldv_23_callback_show)(struct device *, struct device_attribute *, char *);
    1537             :  ssize_t (*ldv_23_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1538           1 :  struct device_attribute *ldv_23_container_struct_device_attribute;
    1539           1 :  struct device *ldv_23_container_struct_device_ptr;
    1540           1 :  char *ldv_23_ldv_param_10_2_default;
    1541           1 :  long unsigned int ldv_23_ldv_param_10_3_default;
    1542           1 :  char *ldv_23_ldv_param_4_2_default;
    1543           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1544           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1545           3 :  ldv_free(arg0);
    1546           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1547           1 : 
    1548           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1549           3 :  ldv_23_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1550           3 :  ldv_23_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1551             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1552             : 
    1553             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1554             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1555             : 
    1556             :  /* Jump to a subprocess 'call' initial state */
    1557           1 :  goto ldv_call_23;
    1558             :  /* End of the process */
    1559             :  return;
    1560           1 : 
    1561             :  /* Sbprocess call */
    1562             :  ldv_call_23:
    1563             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1564             : 
    1565           4 :  if (ldv_undef_int()) {
    1566             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1567           3 :   ldv_23_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1568             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1569             : 
    1570           4 :   if (ldv_undef_int()) {
    1571             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1572           3 :    ldv_23_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1573             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1574             : 
    1575             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1576           2 :    if (ldv_23_callback_store) {
    1577             :    /* LDV {"type": "CALLBACK", "call": "(ldv_23_callback_store)(ldv_23_container_struct_device_ptr, ldv_23_container_struct_device_attribute, ldv_23_ldv_param_10_2_default, ldv_23_ldv_param_10_3_default);", "comment": "callback"} */
    1578           2 :     ldv_random_containerless_scenario_callback_23_10(ldv_23_callback_store, ldv_23_container_struct_device_ptr, ldv_23_container_struct_device_attribute, ldv_23_ldv_param_10_2_default, ldv_23_ldv_param_10_3_default);
    1579             :    }
    1580             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1581             : 
    1582             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1583           4 :    ldv_free(ldv_23_ldv_param_10_2_default);
    1584             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1585             : 
    1586             :   }
    1587             :   else {
    1588             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1589             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_modalias))(ldv_23_container_struct_device_ptr, ldv_23_container_struct_device_attribute, ldv_23_ldv_param_4_2_default);", "comment": "callback"} */
    1590           2 :    ldv_random_containerless_scenario_callback_23_4(ldv_23_callback_show, ldv_23_container_struct_device_ptr, ldv_23_container_struct_device_attribute, ldv_23_ldv_param_4_2_default);
    1591             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1592             : 
    1593             :   }
    1594             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1595           4 :   ldv_free(ldv_23_ldv_param_4_2_default);
    1596             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1597             : 
    1598             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1599             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1600             : 
    1601             :   /* Jump to a subprocess 'call' initial state */
    1602           1 :   goto ldv_call_23;
    1603             :  }
    1604             :  else {
    1605             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1606           2 :   ldv_free(ldv_23_container_struct_device_attribute);
    1607           2 :   ldv_free(ldv_23_container_struct_device_ptr);
    1608             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1609             : 
    1610             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1611             :   /* Skip a non-replicative signal receiving */
    1612             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1613             : 
    1614             :   /* Exit function at a terminal state */
    1615           1 :   return;
    1616             :  }
    1617             :  /* End of the subprocess 'call' */
    1618             :  return;
    1619             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_23"} */
    1620             : }
    1621             : 
    1622             : /* AUX_FUNC ldv_random_containerless_scenario_24 */
    1623             : void ldv_random_containerless_scenario_24(void *arg0) {
    1624             :  /* LDV {"thread": 24, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_24"} */
    1625           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1626           1 :  ssize_t (*ldv_24_callback_show)(struct device *, struct device_attribute *, char *);
    1627             :  ssize_t (*ldv_24_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1628           1 :  struct device_attribute *ldv_24_container_struct_device_attribute;
    1629           1 :  struct device *ldv_24_container_struct_device_ptr;
    1630           1 :  char *ldv_24_ldv_param_10_2_default;
    1631           1 :  long unsigned int ldv_24_ldv_param_10_3_default;
    1632           1 :  char *ldv_24_ldv_param_4_2_default;
    1633           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1634           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1635           3 :  ldv_free(arg0);
    1636           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1637           1 : 
    1638           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1639           3 :  ldv_24_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1640           3 :  ldv_24_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1641             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1642             : 
    1643             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1644             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1645             : 
    1646             :  /* Jump to a subprocess 'call' initial state */
    1647           1 :  goto ldv_call_24;
    1648             :  /* End of the process */
    1649             :  return;
    1650           1 : 
    1651             :  /* Sbprocess call */
    1652             :  ldv_call_24:
    1653             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1654             : 
    1655           4 :  if (ldv_undef_int()) {
    1656             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1657           3 :   ldv_24_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1658             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1659             : 
    1660           4 :   if (ldv_undef_int()) {
    1661             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1662           3 :    ldv_24_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1663             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1664             : 
    1665             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1666           2 :    if (ldv_24_callback_store) {
    1667             :    /* LDV {"type": "CALLBACK", "call": "(ldv_24_callback_store)(ldv_24_container_struct_device_ptr, ldv_24_container_struct_device_attribute, ldv_24_ldv_param_10_2_default, ldv_24_ldv_param_10_3_default);", "comment": "callback"} */
    1668           2 :     ldv_random_containerless_scenario_callback_24_10(ldv_24_callback_store, ldv_24_container_struct_device_ptr, ldv_24_container_struct_device_attribute, ldv_24_ldv_param_10_2_default, ldv_24_ldv_param_10_3_default);
    1669             :    }
    1670             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1671             : 
    1672             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1673           4 :    ldv_free(ldv_24_ldv_param_10_2_default);
    1674             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1675             : 
    1676             :   }
    1677             :   else {
    1678             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1679             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_model))(ldv_24_container_struct_device_ptr, ldv_24_container_struct_device_attribute, ldv_24_ldv_param_4_2_default);", "comment": "callback"} */
    1680           2 :    ldv_random_containerless_scenario_callback_24_4(ldv_24_callback_show, ldv_24_container_struct_device_ptr, ldv_24_container_struct_device_attribute, ldv_24_ldv_param_4_2_default);
    1681             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1682             : 
    1683             :   }
    1684             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1685           4 :   ldv_free(ldv_24_ldv_param_4_2_default);
    1686             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1687             : 
    1688             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1689             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1690             : 
    1691             :   /* Jump to a subprocess 'call' initial state */
    1692           1 :   goto ldv_call_24;
    1693             :  }
    1694             :  else {
    1695             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1696           2 :   ldv_free(ldv_24_container_struct_device_attribute);
    1697           2 :   ldv_free(ldv_24_container_struct_device_ptr);
    1698             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1699             : 
    1700             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1701             :   /* Skip a non-replicative signal receiving */
    1702             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1703             : 
    1704             :   /* Exit function at a terminal state */
    1705           1 :   return;
    1706             :  }
    1707             :  /* End of the subprocess 'call' */
    1708             :  return;
    1709             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_24"} */
    1710             : }
    1711             : 
    1712             : /* AUX_FUNC ldv_random_containerless_scenario_25 */
    1713             : void ldv_random_containerless_scenario_25(void *arg0) {
    1714             :  /* LDV {"thread": 25, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_25"} */
    1715           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1716           1 :  ssize_t (*ldv_25_callback_show)(struct device *, struct device_attribute *, char *);
    1717             :  ssize_t (*ldv_25_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1718           1 :  struct device_attribute *ldv_25_container_struct_device_attribute;
    1719           1 :  struct device *ldv_25_container_struct_device_ptr;
    1720           1 :  char *ldv_25_ldv_param_10_2_default;
    1721           1 :  long unsigned int ldv_25_ldv_param_10_3_default;
    1722           1 :  char *ldv_25_ldv_param_4_2_default;
    1723           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1724           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1725           3 :  ldv_free(arg0);
    1726           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1727           1 : 
    1728           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1729           3 :  ldv_25_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1730           3 :  ldv_25_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1731             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1732             : 
    1733             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1734             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1735             : 
    1736             :  /* Jump to a subprocess 'call' initial state */
    1737           1 :  goto ldv_call_25;
    1738             :  /* End of the process */
    1739             :  return;
    1740           1 : 
    1741             :  /* Sbprocess call */
    1742             :  ldv_call_25:
    1743             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1744             : 
    1745           4 :  if (ldv_undef_int()) {
    1746             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1747           3 :   ldv_25_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1748             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1749             : 
    1750           4 :   if (ldv_undef_int()) {
    1751             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1752           3 :    ldv_25_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1753             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1754             : 
    1755             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1756           2 :    if (ldv_25_callback_store) {
    1757             :    /* LDV {"type": "CALLBACK", "call": "(ldv_25_callback_store)(ldv_25_container_struct_device_ptr, ldv_25_container_struct_device_attribute, ldv_25_ldv_param_10_2_default, ldv_25_ldv_param_10_3_default);", "comment": "callback"} */
    1758           2 :     ldv_random_containerless_scenario_callback_25_10(ldv_25_callback_store, ldv_25_container_struct_device_ptr, ldv_25_container_struct_device_attribute, ldv_25_ldv_param_10_2_default, ldv_25_ldv_param_10_3_default);
    1759             :    }
    1760             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1761             : 
    1762             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1763           4 :    ldv_free(ldv_25_ldv_param_10_2_default);
    1764             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1765             : 
    1766             :   }
    1767             :   else {
    1768             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1769             :    /* LDV {"type": "CALLBACK", "call": "((& show_proc_name))(ldv_25_container_struct_device_ptr, ldv_25_container_struct_device_attribute, ldv_25_ldv_param_4_2_default);", "comment": "callback"} */
    1770           2 :    ldv_random_containerless_scenario_callback_25_4(ldv_25_callback_show, ldv_25_container_struct_device_ptr, ldv_25_container_struct_device_attribute, ldv_25_ldv_param_4_2_default);
    1771             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1772             : 
    1773             :   }
    1774             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1775           4 :   ldv_free(ldv_25_ldv_param_4_2_default);
    1776             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1777             : 
    1778             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1779             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1780             : 
    1781             :   /* Jump to a subprocess 'call' initial state */
    1782           1 :   goto ldv_call_25;
    1783             :  }
    1784             :  else {
    1785             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1786           2 :   ldv_free(ldv_25_container_struct_device_attribute);
    1787           2 :   ldv_free(ldv_25_container_struct_device_ptr);
    1788             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1789             : 
    1790             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1791             :   /* Skip a non-replicative signal receiving */
    1792             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1793             : 
    1794             :   /* Exit function at a terminal state */
    1795           1 :   return;
    1796             :  }
    1797             :  /* End of the subprocess 'call' */
    1798             :  return;
    1799             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_25"} */
    1800             : }
    1801             : 
    1802             : /* AUX_FUNC ldv_random_containerless_scenario_26 */
    1803             : void ldv_random_containerless_scenario_26(void *arg0) {
    1804             :  /* LDV {"thread": 26, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_26"} */
    1805           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1806           1 :  ssize_t (*ldv_26_callback_show)(struct device *, struct device_attribute *, char *);
    1807             :  ssize_t (*ldv_26_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1808           1 :  struct device_attribute *ldv_26_container_struct_device_attribute;
    1809           1 :  struct device *ldv_26_container_struct_device_ptr;
    1810           1 :  char *ldv_26_ldv_param_10_2_default;
    1811           1 :  long unsigned int ldv_26_ldv_param_10_3_default;
    1812           1 :  char *ldv_26_ldv_param_4_2_default;
    1813           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1814           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1815           3 :  ldv_free(arg0);
    1816           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1817           1 : 
    1818           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1819           3 :  ldv_26_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1820           3 :  ldv_26_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1821             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1822             : 
    1823             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1824             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1825             : 
    1826             :  /* Jump to a subprocess 'call' initial state */
    1827           1 :  goto ldv_call_26;
    1828             :  /* End of the process */
    1829             :  return;
    1830           1 : 
    1831             :  /* Sbprocess call */
    1832             :  ldv_call_26:
    1833             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1834             : 
    1835           4 :  if (ldv_undef_int()) {
    1836             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1837           3 :   ldv_26_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1838             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1839             : 
    1840           4 :   if (ldv_undef_int()) {
    1841             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1842           3 :    ldv_26_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1843             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1844             : 
    1845             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1846           2 :    if (ldv_26_callback_store) {
    1847             :    /* LDV {"type": "CALLBACK", "call": "(ldv_26_callback_store)(ldv_26_container_struct_device_ptr, ldv_26_container_struct_device_attribute, ldv_26_ldv_param_10_2_default, ldv_26_ldv_param_10_3_default);", "comment": "callback"} */
    1848           2 :     ldv_random_containerless_scenario_callback_26_10(ldv_26_callback_store, ldv_26_container_struct_device_ptr, ldv_26_container_struct_device_attribute, ldv_26_ldv_param_10_2_default, ldv_26_ldv_param_10_3_default);
    1849             :    }
    1850             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1851             : 
    1852             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1853           4 :    ldv_free(ldv_26_ldv_param_10_2_default);
    1854             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1855             : 
    1856             :   }
    1857             :   else {
    1858             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1859             :    /* LDV {"type": "CALLBACK", "call": "((& show_prot_capabilities))(ldv_26_container_struct_device_ptr, ldv_26_container_struct_device_attribute, ldv_26_ldv_param_4_2_default);", "comment": "callback"} */
    1860           2 :    ldv_random_containerless_scenario_callback_26_4(ldv_26_callback_show, ldv_26_container_struct_device_ptr, ldv_26_container_struct_device_attribute, ldv_26_ldv_param_4_2_default);
    1861             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1862             : 
    1863             :   }
    1864             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1865           4 :   ldv_free(ldv_26_ldv_param_4_2_default);
    1866             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1867             : 
    1868             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1869             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1870             : 
    1871             :   /* Jump to a subprocess 'call' initial state */
    1872           1 :   goto ldv_call_26;
    1873             :  }
    1874             :  else {
    1875             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1876           2 :   ldv_free(ldv_26_container_struct_device_attribute);
    1877           2 :   ldv_free(ldv_26_container_struct_device_ptr);
    1878             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1879             : 
    1880             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1881             :   /* Skip a non-replicative signal receiving */
    1882             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1883             : 
    1884             :   /* Exit function at a terminal state */
    1885           1 :   return;
    1886             :  }
    1887             :  /* End of the subprocess 'call' */
    1888             :  return;
    1889             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_26"} */
    1890             : }
    1891             : 
    1892             : /* AUX_FUNC ldv_random_containerless_scenario_27 */
    1893             : void ldv_random_containerless_scenario_27(void *arg0) {
    1894             :  /* LDV {"thread": 27, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_27"} */
    1895           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1896           1 :  ssize_t (*ldv_27_callback_show)(struct device *, struct device_attribute *, char *);
    1897             :  ssize_t (*ldv_27_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1898           1 :  struct device_attribute *ldv_27_container_struct_device_attribute;
    1899           1 :  struct device *ldv_27_container_struct_device_ptr;
    1900           1 :  char *ldv_27_ldv_param_10_2_default;
    1901           1 :  long unsigned int ldv_27_ldv_param_10_3_default;
    1902           1 :  char *ldv_27_ldv_param_4_2_default;
    1903           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1904           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1905           3 :  ldv_free(arg0);
    1906           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1907           1 : 
    1908           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1909           3 :  ldv_27_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    1910           3 :  ldv_27_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    1911             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    1912             : 
    1913             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1914             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1915             : 
    1916             :  /* Jump to a subprocess 'call' initial state */
    1917           1 :  goto ldv_call_27;
    1918             :  /* End of the process */
    1919             :  return;
    1920           1 : 
    1921             :  /* Sbprocess call */
    1922             :  ldv_call_27:
    1923             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    1924             : 
    1925           4 :  if (ldv_undef_int()) {
    1926             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1927           3 :   ldv_27_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    1928             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    1929             : 
    1930           4 :   if (ldv_undef_int()) {
    1931             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    1932           3 :    ldv_27_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    1933             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    1934             : 
    1935             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    1936           2 :    if (ldv_27_callback_store) {
    1937             :    /* LDV {"type": "CALLBACK", "call": "(ldv_27_callback_store)(ldv_27_container_struct_device_ptr, ldv_27_container_struct_device_attribute, ldv_27_ldv_param_10_2_default, ldv_27_ldv_param_10_3_default);", "comment": "callback"} */
    1938           2 :     ldv_random_containerless_scenario_callback_27_10(ldv_27_callback_store, ldv_27_container_struct_device_ptr, ldv_27_container_struct_device_attribute, ldv_27_ldv_param_10_2_default, ldv_27_ldv_param_10_3_default);
    1939             :    }
    1940             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1941             : 
    1942             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1943           4 :    ldv_free(ldv_27_ldv_param_10_2_default);
    1944             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    1945             : 
    1946             :   }
    1947             :   else {
    1948             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    1949             :    /* LDV {"type": "CALLBACK", "call": "((& show_prot_guard_type))(ldv_27_container_struct_device_ptr, ldv_27_container_struct_device_attribute, ldv_27_ldv_param_4_2_default);", "comment": "callback"} */
    1950           2 :    ldv_random_containerless_scenario_callback_27_4(ldv_27_callback_show, ldv_27_container_struct_device_ptr, ldv_27_container_struct_device_attribute, ldv_27_ldv_param_4_2_default);
    1951             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    1952             : 
    1953             :   }
    1954             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    1955           4 :   ldv_free(ldv_27_ldv_param_4_2_default);
    1956             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    1957             : 
    1958             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    1959             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    1960             : 
    1961             :   /* Jump to a subprocess 'call' initial state */
    1962           1 :   goto ldv_call_27;
    1963             :  }
    1964             :  else {
    1965             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    1966           2 :   ldv_free(ldv_27_container_struct_device_attribute);
    1967           2 :   ldv_free(ldv_27_container_struct_device_ptr);
    1968             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    1969             : 
    1970             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1971             :   /* Skip a non-replicative signal receiving */
    1972             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    1973             : 
    1974             :   /* Exit function at a terminal state */
    1975           1 :   return;
    1976             :  }
    1977             :  /* End of the subprocess 'call' */
    1978             :  return;
    1979             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_27"} */
    1980             : }
    1981             : 
    1982             : /* AUX_FUNC ldv_random_containerless_scenario_28 */
    1983             : void ldv_random_containerless_scenario_28(void *arg0) {
    1984             :  /* LDV {"thread": 28, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_28"} */
    1985           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    1986           1 :  ssize_t (*ldv_28_callback_show)(struct device *, struct device_attribute *, char *);
    1987             :  ssize_t (*ldv_28_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    1988           1 :  struct device_attribute *ldv_28_container_struct_device_attribute;
    1989           1 :  struct device *ldv_28_container_struct_device_ptr;
    1990           1 :  char *ldv_28_ldv_param_10_2_default;
    1991           1 :  long unsigned int ldv_28_ldv_param_10_3_default;
    1992           1 :  char *ldv_28_ldv_param_4_2_default;
    1993           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    1994           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    1995           3 :  ldv_free(arg0);
    1996           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    1997           1 : 
    1998           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    1999           3 :  ldv_28_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2000           3 :  ldv_28_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2001             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2002             : 
    2003             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2004             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2005             : 
    2006             :  /* Jump to a subprocess 'call' initial state */
    2007           1 :  goto ldv_call_28;
    2008             :  /* End of the process */
    2009             :  return;
    2010           1 : 
    2011             :  /* Sbprocess call */
    2012             :  ldv_call_28:
    2013             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2014             : 
    2015           4 :  if (ldv_undef_int()) {
    2016             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2017           3 :   ldv_28_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2018             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2019             : 
    2020           4 :   if (ldv_undef_int()) {
    2021             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2022           3 :    ldv_28_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2023             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2024             : 
    2025             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    2026             :    /* LDV {"type": "CALLBACK", "call": "((& store_rescan_field))(ldv_28_container_struct_device_ptr, ldv_28_container_struct_device_attribute, ldv_28_ldv_param_10_2_default, ldv_28_ldv_param_10_3_default);", "comment": "callback"} */
    2027           2 :    ldv_random_containerless_scenario_callback_28_10(ldv_28_callback_store, ldv_28_container_struct_device_ptr, ldv_28_container_struct_device_attribute, ldv_28_ldv_param_10_2_default, ldv_28_ldv_param_10_3_default);
    2028             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2029             : 
    2030             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2031           2 :    ldv_free(ldv_28_ldv_param_10_2_default);
    2032             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2033             : 
    2034             :   }
    2035             :   else {
    2036             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2037           2 :    if (ldv_28_callback_show) {
    2038             :    /* LDV {"type": "CALLBACK", "call": "(ldv_28_callback_show)(ldv_28_container_struct_device_ptr, ldv_28_container_struct_device_attribute, ldv_28_ldv_param_4_2_default);", "comment": "callback"} */
    2039           2 :     ldv_random_containerless_scenario_callback_28_4(ldv_28_callback_show, ldv_28_container_struct_device_ptr, ldv_28_container_struct_device_attribute, ldv_28_ldv_param_4_2_default);
    2040             :    }
    2041             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2042             : 
    2043             :   }
    2044             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2045           6 :   ldv_free(ldv_28_ldv_param_4_2_default);
    2046             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2047             : 
    2048             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2049             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2050             : 
    2051             :   /* Jump to a subprocess 'call' initial state */
    2052           1 :   goto ldv_call_28;
    2053             :  }
    2054             :  else {
    2055             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2056           2 :   ldv_free(ldv_28_container_struct_device_attribute);
    2057           2 :   ldv_free(ldv_28_container_struct_device_ptr);
    2058             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2059             : 
    2060             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2061             :   /* Skip a non-replicative signal receiving */
    2062             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2063             : 
    2064             :   /* Exit function at a terminal state */
    2065           1 :   return;
    2066             :  }
    2067             :  /* End of the subprocess 'call' */
    2068             :  return;
    2069             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_28"} */
    2070             : }
    2071             : 
    2072             : /* AUX_FUNC ldv_random_containerless_scenario_29 */
    2073             : void ldv_random_containerless_scenario_29(void *arg0) {
    2074             :  /* LDV {"thread": 29, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_29"} */
    2075           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2076           1 :  ssize_t (*ldv_29_callback_show)(struct device *, struct device_attribute *, char *);
    2077             :  ssize_t (*ldv_29_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2078           1 :  struct device_attribute *ldv_29_container_struct_device_attribute;
    2079           1 :  struct device *ldv_29_container_struct_device_ptr;
    2080           1 :  char *ldv_29_ldv_param_10_2_default;
    2081           1 :  long unsigned int ldv_29_ldv_param_10_3_default;
    2082           1 :  char *ldv_29_ldv_param_4_2_default;
    2083           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2084           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2085           3 :  ldv_free(arg0);
    2086           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2087           1 : 
    2088           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2089           3 :  ldv_29_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2090           3 :  ldv_29_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2091             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2092             : 
    2093             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2094             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2095             : 
    2096             :  /* Jump to a subprocess 'call' initial state */
    2097           1 :  goto ldv_call_29;
    2098             :  /* End of the process */
    2099             :  return;
    2100           1 : 
    2101             :  /* Sbprocess call */
    2102             :  ldv_call_29:
    2103             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2104             : 
    2105           4 :  if (ldv_undef_int()) {
    2106             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2107           3 :   ldv_29_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2108             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2109             : 
    2110           4 :   if (ldv_undef_int()) {
    2111             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2112           3 :    ldv_29_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2113             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2114             : 
    2115             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2116           2 :    if (ldv_29_callback_store) {
    2117             :    /* LDV {"type": "CALLBACK", "call": "(ldv_29_callback_store)(ldv_29_container_struct_device_ptr, ldv_29_container_struct_device_attribute, ldv_29_ldv_param_10_2_default, ldv_29_ldv_param_10_3_default);", "comment": "callback"} */
    2118           2 :     ldv_random_containerless_scenario_callback_29_10(ldv_29_callback_store, ldv_29_container_struct_device_ptr, ldv_29_container_struct_device_attribute, ldv_29_ldv_param_10_2_default, ldv_29_ldv_param_10_3_default);
    2119             :    }
    2120             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2121             : 
    2122             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2123           4 :    ldv_free(ldv_29_ldv_param_10_2_default);
    2124             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2125             : 
    2126             :   }
    2127             :   else {
    2128             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2129             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_rev))(ldv_29_container_struct_device_ptr, ldv_29_container_struct_device_attribute, ldv_29_ldv_param_4_2_default);", "comment": "callback"} */
    2130           2 :    ldv_random_containerless_scenario_callback_29_4(ldv_29_callback_show, ldv_29_container_struct_device_ptr, ldv_29_container_struct_device_attribute, ldv_29_ldv_param_4_2_default);
    2131             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2132             : 
    2133             :   }
    2134             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2135           4 :   ldv_free(ldv_29_ldv_param_4_2_default);
    2136             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2137             : 
    2138             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2139             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2140             : 
    2141             :   /* Jump to a subprocess 'call' initial state */
    2142           1 :   goto ldv_call_29;
    2143             :  }
    2144             :  else {
    2145             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2146           2 :   ldv_free(ldv_29_container_struct_device_attribute);
    2147           2 :   ldv_free(ldv_29_container_struct_device_ptr);
    2148             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2149             : 
    2150             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2151             :   /* Skip a non-replicative signal receiving */
    2152             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2153             : 
    2154             :   /* Exit function at a terminal state */
    2155           1 :   return;
    2156             :  }
    2157             :  /* End of the subprocess 'call' */
    2158             :  return;
    2159             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_29"} */
    2160             : }
    2161             : 
    2162             : /* AUX_FUNC ldv_random_containerless_scenario_30 */
    2163             : void ldv_random_containerless_scenario_30(void *arg0) {
    2164             :  /* LDV {"thread": 30, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_30"} */
    2165           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2166           1 :  ssize_t (*ldv_30_callback_show)(struct device *, struct device_attribute *, char *);
    2167             :  ssize_t (*ldv_30_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2168           1 :  struct device_attribute *ldv_30_container_struct_device_attribute;
    2169           1 :  struct device *ldv_30_container_struct_device_ptr;
    2170           1 :  char *ldv_30_ldv_param_10_2_default;
    2171           1 :  long unsigned int ldv_30_ldv_param_10_3_default;
    2172           1 :  char *ldv_30_ldv_param_4_2_default;
    2173           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2174           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2175           3 :  ldv_free(arg0);
    2176           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2177           1 : 
    2178           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2179           3 :  ldv_30_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2180           3 :  ldv_30_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2181             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2182             : 
    2183             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2184             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2185             : 
    2186             :  /* Jump to a subprocess 'call' initial state */
    2187           1 :  goto ldv_call_30;
    2188             :  /* End of the process */
    2189             :  return;
    2190           1 : 
    2191             :  /* Sbprocess call */
    2192             :  ldv_call_30:
    2193             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2194             : 
    2195           4 :  if (ldv_undef_int()) {
    2196             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2197           3 :   ldv_30_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2198             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2199             : 
    2200           4 :   if (ldv_undef_int()) {
    2201             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2202           3 :    ldv_30_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2203             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2204             : 
    2205             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    2206             :    /* LDV {"type": "CALLBACK", "call": "((& store_scan))(ldv_30_container_struct_device_ptr, ldv_30_container_struct_device_attribute, ldv_30_ldv_param_10_2_default, ldv_30_ldv_param_10_3_default);", "comment": "callback"} */
    2207           2 :    ldv_random_containerless_scenario_callback_30_10(ldv_30_callback_store, ldv_30_container_struct_device_ptr, ldv_30_container_struct_device_attribute, ldv_30_ldv_param_10_2_default, ldv_30_ldv_param_10_3_default);
    2208             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2209             : 
    2210             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2211           2 :    ldv_free(ldv_30_ldv_param_10_2_default);
    2212             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2213             : 
    2214             :   }
    2215             :   else {
    2216             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2217           2 :    if (ldv_30_callback_show) {
    2218             :    /* LDV {"type": "CALLBACK", "call": "(ldv_30_callback_show)(ldv_30_container_struct_device_ptr, ldv_30_container_struct_device_attribute, ldv_30_ldv_param_4_2_default);", "comment": "callback"} */
    2219           2 :     ldv_random_containerless_scenario_callback_30_4(ldv_30_callback_show, ldv_30_container_struct_device_ptr, ldv_30_container_struct_device_attribute, ldv_30_ldv_param_4_2_default);
    2220             :    }
    2221             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2222             : 
    2223             :   }
    2224             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2225           6 :   ldv_free(ldv_30_ldv_param_4_2_default);
    2226             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2227             : 
    2228             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2229             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2230             : 
    2231             :   /* Jump to a subprocess 'call' initial state */
    2232           1 :   goto ldv_call_30;
    2233             :  }
    2234             :  else {
    2235             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2236           2 :   ldv_free(ldv_30_container_struct_device_attribute);
    2237           2 :   ldv_free(ldv_30_container_struct_device_ptr);
    2238             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2239             : 
    2240             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2241             :   /* Skip a non-replicative signal receiving */
    2242             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2243             : 
    2244             :   /* Exit function at a terminal state */
    2245           1 :   return;
    2246             :  }
    2247             :  /* End of the subprocess 'call' */
    2248             :  return;
    2249             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_30"} */
    2250             : }
    2251             : 
    2252             : /* AUX_FUNC ldv_random_containerless_scenario_31 */
    2253             : void ldv_random_containerless_scenario_31(void *arg0) {
    2254             :  /* LDV {"thread": 31, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_31"} */
    2255           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2256           1 :  ssize_t (*ldv_31_callback_show)(struct device *, struct device_attribute *, char *);
    2257             :  ssize_t (*ldv_31_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2258           1 :  struct device_attribute *ldv_31_container_struct_device_attribute;
    2259           1 :  struct device *ldv_31_container_struct_device_ptr;
    2260           1 :  char *ldv_31_ldv_param_10_2_default;
    2261           1 :  long unsigned int ldv_31_ldv_param_10_3_default;
    2262           1 :  char *ldv_31_ldv_param_4_2_default;
    2263           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2264           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2265           3 :  ldv_free(arg0);
    2266           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2267           1 : 
    2268           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2269           3 :  ldv_31_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2270           3 :  ldv_31_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2271             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2272             : 
    2273             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2274             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2275             : 
    2276             :  /* Jump to a subprocess 'call' initial state */
    2277           1 :  goto ldv_call_31;
    2278             :  /* End of the process */
    2279             :  return;
    2280           1 : 
    2281             :  /* Sbprocess call */
    2282             :  ldv_call_31:
    2283             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2284             : 
    2285           4 :  if (ldv_undef_int()) {
    2286             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2287           3 :   ldv_31_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2288             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2289             : 
    2290           4 :   if (ldv_undef_int()) {
    2291             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2292           3 :    ldv_31_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2293             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2294             : 
    2295             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2296           2 :    if (ldv_31_callback_store) {
    2297             :    /* LDV {"type": "CALLBACK", "call": "(ldv_31_callback_store)(ldv_31_container_struct_device_ptr, ldv_31_container_struct_device_attribute, ldv_31_ldv_param_10_2_default, ldv_31_ldv_param_10_3_default);", "comment": "callback"} */
    2298           2 :     ldv_random_containerless_scenario_callback_31_10(ldv_31_callback_store, ldv_31_container_struct_device_ptr, ldv_31_container_struct_device_attribute, ldv_31_ldv_param_10_2_default, ldv_31_ldv_param_10_3_default);
    2299             :    }
    2300             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2301             : 
    2302             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2303           4 :    ldv_free(ldv_31_ldv_param_10_2_default);
    2304             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2305             : 
    2306             :   }
    2307             :   else {
    2308             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2309             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_scsi_level))(ldv_31_container_struct_device_ptr, ldv_31_container_struct_device_attribute, ldv_31_ldv_param_4_2_default);", "comment": "callback"} */
    2310           2 :    ldv_random_containerless_scenario_callback_31_4(ldv_31_callback_show, ldv_31_container_struct_device_ptr, ldv_31_container_struct_device_attribute, ldv_31_ldv_param_4_2_default);
    2311             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2312             : 
    2313             :   }
    2314             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2315           4 :   ldv_free(ldv_31_ldv_param_4_2_default);
    2316             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2317             : 
    2318             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2319             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2320             : 
    2321             :   /* Jump to a subprocess 'call' initial state */
    2322           1 :   goto ldv_call_31;
    2323             :  }
    2324             :  else {
    2325             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2326           2 :   ldv_free(ldv_31_container_struct_device_attribute);
    2327           2 :   ldv_free(ldv_31_container_struct_device_ptr);
    2328             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2329             : 
    2330             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2331             :   /* Skip a non-replicative signal receiving */
    2332             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2333             : 
    2334             :   /* Exit function at a terminal state */
    2335           1 :   return;
    2336             :  }
    2337             :  /* End of the subprocess 'call' */
    2338             :  return;
    2339             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_31"} */
    2340             : }
    2341             : 
    2342             : /* AUX_FUNC ldv_random_containerless_scenario_32 */
    2343             : void ldv_random_containerless_scenario_32(void *arg0) {
    2344             :  /* LDV {"thread": 32, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_32"} */
    2345           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2346           1 :  ssize_t (*ldv_32_callback_show)(struct device *, struct device_attribute *, char *);
    2347             :  ssize_t (*ldv_32_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2348           1 :  struct device_attribute *ldv_32_container_struct_device_attribute;
    2349           1 :  struct device *ldv_32_container_struct_device_ptr;
    2350           1 :  char *ldv_32_ldv_param_10_2_default;
    2351           1 :  long unsigned int ldv_32_ldv_param_10_3_default;
    2352           1 :  char *ldv_32_ldv_param_4_2_default;
    2353           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2354           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2355           3 :  ldv_free(arg0);
    2356           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2357           1 : 
    2358           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2359           3 :  ldv_32_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2360           3 :  ldv_32_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2361             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2362             : 
    2363             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2364             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2365             : 
    2366             :  /* Jump to a subprocess 'call' initial state */
    2367           1 :  goto ldv_call_32;
    2368             :  /* End of the process */
    2369             :  return;
    2370           1 : 
    2371             :  /* Sbprocess call */
    2372             :  ldv_call_32:
    2373             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2374             : 
    2375           4 :  if (ldv_undef_int()) {
    2376             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2377           3 :   ldv_32_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2378             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2379             : 
    2380           4 :   if (ldv_undef_int()) {
    2381             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2382           3 :    ldv_32_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2383             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2384             : 
    2385             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2386           2 :    if (ldv_32_callback_store) {
    2387             :    /* LDV {"type": "CALLBACK", "call": "(ldv_32_callback_store)(ldv_32_container_struct_device_ptr, ldv_32_container_struct_device_attribute, ldv_32_ldv_param_10_2_default, ldv_32_ldv_param_10_3_default);", "comment": "callback"} */
    2388           2 :     ldv_random_containerless_scenario_callback_32_10(ldv_32_callback_store, ldv_32_container_struct_device_ptr, ldv_32_container_struct_device_attribute, ldv_32_ldv_param_10_2_default, ldv_32_ldv_param_10_3_default);
    2389             :    }
    2390             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2391             : 
    2392             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2393           4 :    ldv_free(ldv_32_ldv_param_10_2_default);
    2394             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2395             : 
    2396             :   }
    2397             :   else {
    2398             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2399             :    /* LDV {"type": "CALLBACK", "call": "((& show_sg_tablesize))(ldv_32_container_struct_device_ptr, ldv_32_container_struct_device_attribute, ldv_32_ldv_param_4_2_default);", "comment": "callback"} */
    2400           2 :    ldv_random_containerless_scenario_callback_32_4(ldv_32_callback_show, ldv_32_container_struct_device_ptr, ldv_32_container_struct_device_attribute, ldv_32_ldv_param_4_2_default);
    2401             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2402             : 
    2403             :   }
    2404             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2405           4 :   ldv_free(ldv_32_ldv_param_4_2_default);
    2406             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2407             : 
    2408             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2409             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2410             : 
    2411             :   /* Jump to a subprocess 'call' initial state */
    2412           1 :   goto ldv_call_32;
    2413             :  }
    2414             :  else {
    2415             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2416           2 :   ldv_free(ldv_32_container_struct_device_attribute);
    2417           2 :   ldv_free(ldv_32_container_struct_device_ptr);
    2418             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2419             : 
    2420             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2421             :   /* Skip a non-replicative signal receiving */
    2422             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2423             : 
    2424             :   /* Exit function at a terminal state */
    2425           1 :   return;
    2426             :  }
    2427             :  /* End of the subprocess 'call' */
    2428             :  return;
    2429             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_32"} */
    2430             : }
    2431             : 
    2432             : /* AUX_FUNC ldv_random_containerless_scenario_33 */
    2433             : void ldv_random_containerless_scenario_33(void *arg0) {
    2434             :  /* LDV {"thread": 33, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_33"} */
    2435           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2436           1 :  ssize_t (*ldv_33_callback_show)(struct device *, struct device_attribute *, char *);
    2437             :  ssize_t (*ldv_33_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2438           1 :  struct device_attribute *ldv_33_container_struct_device_attribute;
    2439           1 :  struct device *ldv_33_container_struct_device_ptr;
    2440           1 :  char *ldv_33_ldv_param_10_2_default;
    2441           1 :  long unsigned int ldv_33_ldv_param_10_3_default;
    2442           1 :  char *ldv_33_ldv_param_4_2_default;
    2443           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2444           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2445           3 :  ldv_free(arg0);
    2446           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2447           1 : 
    2448           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2449           3 :  ldv_33_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2450           3 :  ldv_33_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2451             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2452             : 
    2453             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2454             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2455             : 
    2456             :  /* Jump to a subprocess 'call' initial state */
    2457           1 :  goto ldv_call_33;
    2458             :  /* End of the process */
    2459             :  return;
    2460           1 : 
    2461             :  /* Sbprocess call */
    2462             :  ldv_call_33:
    2463             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2464             : 
    2465           4 :  if (ldv_undef_int()) {
    2466             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2467           3 :   ldv_33_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2468             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2469             : 
    2470           4 :   if (ldv_undef_int()) {
    2471             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2472           3 :    ldv_33_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2473             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2474             : 
    2475             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    2476             :    /* LDV {"type": "CALLBACK", "call": "((& store_state_field))(ldv_33_container_struct_device_ptr, ldv_33_container_struct_device_attribute, ldv_33_ldv_param_10_2_default, ldv_33_ldv_param_10_3_default);", "comment": "callback"} */
    2477           2 :    ldv_random_containerless_scenario_callback_33_10(ldv_33_callback_store, ldv_33_container_struct_device_ptr, ldv_33_container_struct_device_attribute, ldv_33_ldv_param_10_2_default, ldv_33_ldv_param_10_3_default);
    2478             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2479             : 
    2480             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2481           2 :    ldv_free(ldv_33_ldv_param_10_2_default);
    2482             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2483             : 
    2484             :   }
    2485             :   else {
    2486             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2487             :    /* LDV {"type": "CALLBACK", "call": "((& show_state_field))(ldv_33_container_struct_device_ptr, ldv_33_container_struct_device_attribute, ldv_33_ldv_param_4_2_default);", "comment": "callback"} */
    2488           2 :    ldv_random_containerless_scenario_callback_33_4(ldv_33_callback_show, ldv_33_container_struct_device_ptr, ldv_33_container_struct_device_attribute, ldv_33_ldv_param_4_2_default);
    2489             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2490             : 
    2491             :   }
    2492             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2493           4 :   ldv_free(ldv_33_ldv_param_4_2_default);
    2494             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2495             : 
    2496             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2497             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2498             : 
    2499             :   /* Jump to a subprocess 'call' initial state */
    2500           1 :   goto ldv_call_33;
    2501             :  }
    2502             :  else {
    2503             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2504           2 :   ldv_free(ldv_33_container_struct_device_attribute);
    2505           2 :   ldv_free(ldv_33_container_struct_device_ptr);
    2506             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2507             : 
    2508             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2509             :   /* Skip a non-replicative signal receiving */
    2510             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2511             : 
    2512             :   /* Exit function at a terminal state */
    2513           1 :   return;
    2514             :  }
    2515             :  /* End of the subprocess 'call' */
    2516             :  return;
    2517             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_33"} */
    2518             : }
    2519             : 
    2520             : /* AUX_FUNC ldv_random_containerless_scenario_34 */
    2521             : void ldv_random_containerless_scenario_34(void *arg0) {
    2522             :  /* LDV {"thread": 34, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_34"} */
    2523           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2524           1 :  ssize_t (*ldv_34_callback_show)(struct device *, struct device_attribute *, char *);
    2525             :  ssize_t (*ldv_34_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2526           1 :  struct device_attribute *ldv_34_container_struct_device_attribute;
    2527           1 :  struct device *ldv_34_container_struct_device_ptr;
    2528           1 :  char *ldv_34_ldv_param_10_2_default;
    2529           1 :  long unsigned int ldv_34_ldv_param_10_3_default;
    2530           1 :  char *ldv_34_ldv_param_4_2_default;
    2531           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2532           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2533           3 :  ldv_free(arg0);
    2534           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2535           1 : 
    2536           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2537           3 :  ldv_34_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2538           3 :  ldv_34_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2539             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2540             : 
    2541             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2542             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2543             : 
    2544             :  /* Jump to a subprocess 'call' initial state */
    2545           1 :  goto ldv_call_34;
    2546             :  /* End of the process */
    2547             :  return;
    2548           1 : 
    2549             :  /* Sbprocess call */
    2550             :  ldv_call_34:
    2551             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2552             : 
    2553           4 :  if (ldv_undef_int()) {
    2554             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2555           3 :   ldv_34_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2556             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2557             : 
    2558           4 :   if (ldv_undef_int()) {
    2559             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2560           3 :    ldv_34_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2561             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2562             : 
    2563             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2564           2 :    if (ldv_34_callback_store) {
    2565             :    /* LDV {"type": "CALLBACK", "call": "(ldv_34_callback_store)(ldv_34_container_struct_device_ptr, ldv_34_container_struct_device_attribute, ldv_34_ldv_param_10_2_default, ldv_34_ldv_param_10_3_default);", "comment": "callback"} */
    2566           2 :     ldv_random_containerless_scenario_callback_34_10(ldv_34_callback_store, ldv_34_container_struct_device_ptr, ldv_34_container_struct_device_attribute, ldv_34_ldv_param_10_2_default, ldv_34_ldv_param_10_3_default);
    2567             :    }
    2568             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2569             : 
    2570             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2571           4 :    ldv_free(ldv_34_ldv_param_10_2_default);
    2572             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2573             : 
    2574             :   }
    2575             :   else {
    2576             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2577             :    /* LDV {"type": "CALLBACK", "call": "((& show_shost_supported_mode))(ldv_34_container_struct_device_ptr, ldv_34_container_struct_device_attribute, ldv_34_ldv_param_4_2_default);", "comment": "callback"} */
    2578           2 :    ldv_random_containerless_scenario_callback_34_4(ldv_34_callback_show, ldv_34_container_struct_device_ptr, ldv_34_container_struct_device_attribute, ldv_34_ldv_param_4_2_default);
    2579             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2580             : 
    2581             :   }
    2582             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2583           4 :   ldv_free(ldv_34_ldv_param_4_2_default);
    2584             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2585             : 
    2586             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2587             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2588             : 
    2589             :   /* Jump to a subprocess 'call' initial state */
    2590           1 :   goto ldv_call_34;
    2591             :  }
    2592             :  else {
    2593             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2594           2 :   ldv_free(ldv_34_container_struct_device_attribute);
    2595           2 :   ldv_free(ldv_34_container_struct_device_ptr);
    2596             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2597             : 
    2598             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2599             :   /* Skip a non-replicative signal receiving */
    2600             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2601             : 
    2602             :   /* Exit function at a terminal state */
    2603           1 :   return;
    2604             :  }
    2605             :  /* End of the subprocess 'call' */
    2606             :  return;
    2607             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_34"} */
    2608             : }
    2609             : 
    2610             : /* AUX_FUNC ldv_random_containerless_scenario_35 */
    2611             : void ldv_random_containerless_scenario_35(void *arg0) {
    2612             :  /* LDV {"thread": 35, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_35"} */
    2613           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2614           1 :  ssize_t (*ldv_35_callback_show)(struct device *, struct device_attribute *, char *);
    2615             :  ssize_t (*ldv_35_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2616           1 :  struct device_attribute *ldv_35_container_struct_device_attribute;
    2617           1 :  struct device *ldv_35_container_struct_device_ptr;
    2618           1 :  char *ldv_35_ldv_param_10_2_default;
    2619           1 :  long unsigned int ldv_35_ldv_param_10_3_default;
    2620           1 :  char *ldv_35_ldv_param_4_2_default;
    2621           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2622           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2623           3 :  ldv_free(arg0);
    2624           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2625           1 : 
    2626           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2627           3 :  ldv_35_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2628           3 :  ldv_35_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2629             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2630             : 
    2631             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2632             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2633             : 
    2634             :  /* Jump to a subprocess 'call' initial state */
    2635           1 :  goto ldv_call_35;
    2636             :  /* End of the process */
    2637             :  return;
    2638           1 : 
    2639             :  /* Sbprocess call */
    2640             :  ldv_call_35:
    2641             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2642             : 
    2643           4 :  if (ldv_undef_int()) {
    2644             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2645           3 :   ldv_35_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2646             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2647             : 
    2648           4 :   if (ldv_undef_int()) {
    2649             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2650           3 :    ldv_35_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2651             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2652             : 
    2653             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    2654             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_timeout))(ldv_35_container_struct_device_ptr, ldv_35_container_struct_device_attribute, ldv_35_ldv_param_10_2_default, ldv_35_ldv_param_10_3_default);", "comment": "callback"} */
    2655           2 :    ldv_random_containerless_scenario_callback_35_10(ldv_35_callback_store, ldv_35_container_struct_device_ptr, ldv_35_container_struct_device_attribute, ldv_35_ldv_param_10_2_default, ldv_35_ldv_param_10_3_default);
    2656             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2657             : 
    2658             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2659           2 :    ldv_free(ldv_35_ldv_param_10_2_default);
    2660             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2661             : 
    2662             :   }
    2663             :   else {
    2664             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2665             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_timeout))(ldv_35_container_struct_device_ptr, ldv_35_container_struct_device_attribute, ldv_35_ldv_param_4_2_default);", "comment": "callback"} */
    2666           2 :    ldv_random_containerless_scenario_callback_35_4(ldv_35_callback_show, ldv_35_container_struct_device_ptr, ldv_35_container_struct_device_attribute, ldv_35_ldv_param_4_2_default);
    2667             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2668             : 
    2669             :   }
    2670             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2671           4 :   ldv_free(ldv_35_ldv_param_4_2_default);
    2672             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2673             : 
    2674             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2675             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2676             : 
    2677             :   /* Jump to a subprocess 'call' initial state */
    2678           1 :   goto ldv_call_35;
    2679             :  }
    2680             :  else {
    2681             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2682           2 :   ldv_free(ldv_35_container_struct_device_attribute);
    2683           2 :   ldv_free(ldv_35_container_struct_device_ptr);
    2684             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2685             : 
    2686             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2687             :   /* Skip a non-replicative signal receiving */
    2688             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2689             : 
    2690             :   /* Exit function at a terminal state */
    2691           1 :   return;
    2692             :  }
    2693             :  /* End of the subprocess 'call' */
    2694             :  return;
    2695             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_35"} */
    2696             : }
    2697             : 
    2698             : /* AUX_FUNC ldv_random_containerless_scenario_36 */
    2699             : void ldv_random_containerless_scenario_36(void *arg0) {
    2700             :  /* LDV {"thread": 36, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_36"} */
    2701           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2702           1 :  ssize_t (*ldv_36_callback_show)(struct device *, struct device_attribute *, char *);
    2703             :  ssize_t (*ldv_36_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2704           1 :  struct device_attribute *ldv_36_container_struct_device_attribute;
    2705           1 :  struct device *ldv_36_container_struct_device_ptr;
    2706           1 :  char *ldv_36_ldv_param_10_2_default;
    2707           1 :  long unsigned int ldv_36_ldv_param_10_3_default;
    2708           1 :  char *ldv_36_ldv_param_4_2_default;
    2709           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2710           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2711           3 :  ldv_free(arg0);
    2712           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2713           1 : 
    2714           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2715           3 :  ldv_36_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2716           3 :  ldv_36_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2717             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2718             : 
    2719             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2720             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2721             : 
    2722             :  /* Jump to a subprocess 'call' initial state */
    2723           1 :  goto ldv_call_36;
    2724             :  /* End of the process */
    2725             :  return;
    2726           1 : 
    2727             :  /* Sbprocess call */
    2728             :  ldv_call_36:
    2729             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2730             : 
    2731           4 :  if (ldv_undef_int()) {
    2732             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2733           3 :   ldv_36_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2734             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2735             : 
    2736           4 :   if (ldv_undef_int()) {
    2737             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2738           3 :    ldv_36_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2739             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2740             : 
    2741             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2742           2 :    if (ldv_36_callback_store) {
    2743             :    /* LDV {"type": "CALLBACK", "call": "(ldv_36_callback_store)(ldv_36_container_struct_device_ptr, ldv_36_container_struct_device_attribute, ldv_36_ldv_param_10_2_default, ldv_36_ldv_param_10_3_default);", "comment": "callback"} */
    2744           2 :     ldv_random_containerless_scenario_callback_36_10(ldv_36_callback_store, ldv_36_container_struct_device_ptr, ldv_36_container_struct_device_attribute, ldv_36_ldv_param_10_2_default, ldv_36_ldv_param_10_3_default);
    2745             :    }
    2746             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2747             : 
    2748             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2749           4 :    ldv_free(ldv_36_ldv_param_10_2_default);
    2750             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2751             : 
    2752             :   }
    2753             :   else {
    2754             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2755             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_type))(ldv_36_container_struct_device_ptr, ldv_36_container_struct_device_attribute, ldv_36_ldv_param_4_2_default);", "comment": "callback"} */
    2756           2 :    ldv_random_containerless_scenario_callback_36_4(ldv_36_callback_show, ldv_36_container_struct_device_ptr, ldv_36_container_struct_device_attribute, ldv_36_ldv_param_4_2_default);
    2757             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2758             : 
    2759             :   }
    2760             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2761           4 :   ldv_free(ldv_36_ldv_param_4_2_default);
    2762             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2763             : 
    2764             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2765             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2766             : 
    2767             :   /* Jump to a subprocess 'call' initial state */
    2768           1 :   goto ldv_call_36;
    2769             :  }
    2770             :  else {
    2771             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2772           2 :   ldv_free(ldv_36_container_struct_device_attribute);
    2773           2 :   ldv_free(ldv_36_container_struct_device_ptr);
    2774             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2775             : 
    2776             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2777             :   /* Skip a non-replicative signal receiving */
    2778             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2779             : 
    2780             :   /* Exit function at a terminal state */
    2781           1 :   return;
    2782             :  }
    2783             :  /* End of the subprocess 'call' */
    2784             :  return;
    2785             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_36"} */
    2786             : }
    2787             : 
    2788             : /* AUX_FUNC ldv_random_containerless_scenario_37 */
    2789             : void ldv_random_containerless_scenario_37(void *arg0) {
    2790             :  /* LDV {"thread": 37, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_37"} */
    2791           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2792           1 :  ssize_t (*ldv_37_callback_show)(struct device *, struct device_attribute *, char *);
    2793             :  ssize_t (*ldv_37_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2794           1 :  struct device_attribute *ldv_37_container_struct_device_attribute;
    2795           1 :  struct device *ldv_37_container_struct_device_ptr;
    2796           1 :  char *ldv_37_ldv_param_10_2_default;
    2797           1 :  long unsigned int ldv_37_ldv_param_10_3_default;
    2798           1 :  char *ldv_37_ldv_param_4_2_default;
    2799           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2800           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2801           3 :  ldv_free(arg0);
    2802           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2803           1 : 
    2804           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2805           3 :  ldv_37_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2806           3 :  ldv_37_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2807             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2808             : 
    2809             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2810             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2811             : 
    2812             :  /* Jump to a subprocess 'call' initial state */
    2813           1 :  goto ldv_call_37;
    2814             :  /* End of the process */
    2815             :  return;
    2816           1 : 
    2817             :  /* Sbprocess call */
    2818             :  ldv_call_37:
    2819             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2820             : 
    2821           4 :  if (ldv_undef_int()) {
    2822             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2823           3 :   ldv_37_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2824             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2825             : 
    2826           4 :   if (ldv_undef_int()) {
    2827             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2828           3 :    ldv_37_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2829             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2830             : 
    2831             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2832           2 :    if (ldv_37_callback_store) {
    2833             :    /* LDV {"type": "CALLBACK", "call": "(ldv_37_callback_store)(ldv_37_container_struct_device_ptr, ldv_37_container_struct_device_attribute, ldv_37_ldv_param_10_2_default, ldv_37_ldv_param_10_3_default);", "comment": "callback"} */
    2834           2 :     ldv_random_containerless_scenario_callback_37_10(ldv_37_callback_store, ldv_37_container_struct_device_ptr, ldv_37_container_struct_device_attribute, ldv_37_ldv_param_10_2_default, ldv_37_ldv_param_10_3_default);
    2835             :    }
    2836             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2837             : 
    2838             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2839           4 :    ldv_free(ldv_37_ldv_param_10_2_default);
    2840             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2841             : 
    2842             :   }
    2843             :   else {
    2844             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2845             :    /* LDV {"type": "CALLBACK", "call": "((& show_unchecked_isa_dma))(ldv_37_container_struct_device_ptr, ldv_37_container_struct_device_attribute, ldv_37_ldv_param_4_2_default);", "comment": "callback"} */
    2846           2 :    ldv_random_containerless_scenario_callback_37_4(ldv_37_callback_show, ldv_37_container_struct_device_ptr, ldv_37_container_struct_device_attribute, ldv_37_ldv_param_4_2_default);
    2847             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2848             : 
    2849             :   }
    2850             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2851           4 :   ldv_free(ldv_37_ldv_param_4_2_default);
    2852             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2853             : 
    2854             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2855             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2856             : 
    2857             :   /* Jump to a subprocess 'call' initial state */
    2858           1 :   goto ldv_call_37;
    2859             :  }
    2860             :  else {
    2861             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2862           2 :   ldv_free(ldv_37_container_struct_device_attribute);
    2863           2 :   ldv_free(ldv_37_container_struct_device_ptr);
    2864             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2865             : 
    2866             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2867             :   /* Skip a non-replicative signal receiving */
    2868             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2869             : 
    2870             :   /* Exit function at a terminal state */
    2871           1 :   return;
    2872             :  }
    2873             :  /* End of the subprocess 'call' */
    2874             :  return;
    2875             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_37"} */
    2876             : }
    2877             : 
    2878             : /* AUX_FUNC ldv_random_containerless_scenario_38 */
    2879             : void ldv_random_containerless_scenario_38(void *arg0) {
    2880             :  /* LDV {"thread": 38, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_38"} */
    2881           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2882           1 :  ssize_t (*ldv_38_callback_show)(struct device *, struct device_attribute *, char *);
    2883             :  ssize_t (*ldv_38_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2884           1 :  struct device_attribute *ldv_38_container_struct_device_attribute;
    2885           1 :  struct device *ldv_38_container_struct_device_ptr;
    2886           1 :  char *ldv_38_ldv_param_10_2_default;
    2887           1 :  long unsigned int ldv_38_ldv_param_10_3_default;
    2888           1 :  char *ldv_38_ldv_param_4_2_default;
    2889           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2890           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2891           3 :  ldv_free(arg0);
    2892           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2893           1 : 
    2894           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2895           3 :  ldv_38_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2896           3 :  ldv_38_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2897             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2898             : 
    2899             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2900             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2901             : 
    2902             :  /* Jump to a subprocess 'call' initial state */
    2903           1 :  goto ldv_call_38;
    2904             :  /* End of the process */
    2905             :  return;
    2906           1 : 
    2907             :  /* Sbprocess call */
    2908             :  ldv_call_38:
    2909             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    2910             : 
    2911           4 :  if (ldv_undef_int()) {
    2912             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2913           3 :   ldv_38_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    2914             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    2915             : 
    2916           4 :   if (ldv_undef_int()) {
    2917             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    2918           3 :    ldv_38_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    2919             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    2920             : 
    2921             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    2922           2 :    if (ldv_38_callback_store) {
    2923             :    /* LDV {"type": "CALLBACK", "call": "(ldv_38_callback_store)(ldv_38_container_struct_device_ptr, ldv_38_container_struct_device_attribute, ldv_38_ldv_param_10_2_default, ldv_38_ldv_param_10_3_default);", "comment": "callback"} */
    2924           2 :     ldv_random_containerless_scenario_callback_38_10(ldv_38_callback_store, ldv_38_container_struct_device_ptr, ldv_38_container_struct_device_attribute, ldv_38_ldv_param_10_2_default, ldv_38_ldv_param_10_3_default);
    2925             :    }
    2926             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2927             : 
    2928             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2929           4 :    ldv_free(ldv_38_ldv_param_10_2_default);
    2930             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    2931             : 
    2932             :   }
    2933             :   else {
    2934             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    2935             :    /* LDV {"type": "CALLBACK", "call": "((& show_unique_id))(ldv_38_container_struct_device_ptr, ldv_38_container_struct_device_attribute, ldv_38_ldv_param_4_2_default);", "comment": "callback"} */
    2936           2 :    ldv_random_containerless_scenario_callback_38_4(ldv_38_callback_show, ldv_38_container_struct_device_ptr, ldv_38_container_struct_device_attribute, ldv_38_ldv_param_4_2_default);
    2937             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    2938             : 
    2939             :   }
    2940             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    2941           4 :   ldv_free(ldv_38_ldv_param_4_2_default);
    2942             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    2943             : 
    2944             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2945             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2946             : 
    2947             :   /* Jump to a subprocess 'call' initial state */
    2948           1 :   goto ldv_call_38;
    2949             :  }
    2950             :  else {
    2951             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    2952           2 :   ldv_free(ldv_38_container_struct_device_attribute);
    2953           2 :   ldv_free(ldv_38_container_struct_device_ptr);
    2954             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    2955             : 
    2956             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2957             :   /* Skip a non-replicative signal receiving */
    2958             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    2959             : 
    2960             :   /* Exit function at a terminal state */
    2961           1 :   return;
    2962             :  }
    2963             :  /* End of the subprocess 'call' */
    2964             :  return;
    2965             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_38"} */
    2966             : }
    2967             : 
    2968             : /* AUX_FUNC ldv_random_containerless_scenario_39 */
    2969             : void ldv_random_containerless_scenario_39(void *arg0) {
    2970             :  /* LDV {"thread": 39, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_39"} */
    2971           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    2972           1 :  ssize_t (*ldv_39_callback_show)(struct device *, struct device_attribute *, char *);
    2973             :  ssize_t (*ldv_39_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    2974           1 :  struct device_attribute *ldv_39_container_struct_device_attribute;
    2975           1 :  struct device *ldv_39_container_struct_device_ptr;
    2976           1 :  char *ldv_39_ldv_param_10_2_default;
    2977           1 :  long unsigned int ldv_39_ldv_param_10_3_default;
    2978           1 :  char *ldv_39_ldv_param_4_2_default;
    2979           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    2980           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    2981           3 :  ldv_free(arg0);
    2982           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    2983           1 : 
    2984           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    2985           3 :  ldv_39_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    2986           3 :  ldv_39_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    2987             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    2988             : 
    2989             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    2990             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    2991             : 
    2992             :  /* Jump to a subprocess 'call' initial state */
    2993           1 :  goto ldv_call_39;
    2994             :  /* End of the process */
    2995             :  return;
    2996           1 : 
    2997             :  /* Sbprocess call */
    2998             :  ldv_call_39:
    2999             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3000             : 
    3001           4 :  if (ldv_undef_int()) {
    3002             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3003           3 :   ldv_39_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    3004             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    3005             : 
    3006           4 :   if (ldv_undef_int()) {
    3007             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3008           3 :    ldv_39_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    3009             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    3010             : 
    3011             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback callback from STRUCT_DEVICE_ATTRIBUTE."} */
    3012           2 :    if (ldv_39_callback_store) {
    3013             :    /* LDV {"type": "CALLBACK", "call": "(ldv_39_callback_store)(ldv_39_container_struct_device_ptr, ldv_39_container_struct_device_attribute, ldv_39_ldv_param_10_2_default, ldv_39_ldv_param_10_3_default);", "comment": "callback"} */
    3014           2 :     ldv_random_containerless_scenario_callback_39_10(ldv_39_callback_store, ldv_39_container_struct_device_ptr, ldv_39_container_struct_device_attribute, ldv_39_ldv_param_10_2_default, ldv_39_ldv_param_10_3_default);
    3015             :    }
    3016             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3017             : 
    3018             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3019           4 :    ldv_free(ldv_39_ldv_param_10_2_default);
    3020             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    3021             : 
    3022             :   }
    3023             :   else {
    3024             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    3025             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_vendor))(ldv_39_container_struct_device_ptr, ldv_39_container_struct_device_attribute, ldv_39_ldv_param_4_2_default);", "comment": "callback"} */
    3026           2 :    ldv_random_containerless_scenario_callback_39_4(ldv_39_callback_show, ldv_39_container_struct_device_ptr, ldv_39_container_struct_device_attribute, ldv_39_ldv_param_4_2_default);
    3027             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3028             : 
    3029             :   }
    3030             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3031           4 :   ldv_free(ldv_39_ldv_param_4_2_default);
    3032             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    3033             : 
    3034             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3035             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3036             : 
    3037             :   /* Jump to a subprocess 'call' initial state */
    3038           1 :   goto ldv_call_39;
    3039             :  }
    3040             :  else {
    3041             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3042           2 :   ldv_free(ldv_39_container_struct_device_attribute);
    3043           2 :   ldv_free(ldv_39_container_struct_device_ptr);
    3044             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    3045             : 
    3046             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3047             :   /* Skip a non-replicative signal receiving */
    3048             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    3049             : 
    3050             :   /* Exit function at a terminal state */
    3051           1 :   return;
    3052             :  }
    3053             :  /* End of the subprocess 'call' */
    3054             :  return;
    3055             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_39"} */
    3056             : }
    3057             : 
    3058             : /* AUX_FUNC ldv_random_containerless_scenario_40 */
    3059             : void ldv_random_containerless_scenario_40(void *arg0) {
    3060             :  /* LDV {"thread": 40, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_40"} */
    3061           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3062           1 :  ssize_t (*ldv_40_callback_show)(struct device *, struct device_attribute *, char *);
    3063             :  ssize_t (*ldv_40_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    3064           1 :  struct device_attribute *ldv_40_container_struct_device_attribute;
    3065           1 :  struct device *ldv_40_container_struct_device_ptr;
    3066           1 :  char *ldv_40_ldv_param_10_2_default;
    3067           1 :  long unsigned int ldv_40_ldv_param_10_3_default;
    3068           1 :  char *ldv_40_ldv_param_4_2_default;
    3069           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3070           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3071           3 :  ldv_free(arg0);
    3072           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    3073           1 : 
    3074           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3075           3 :  ldv_40_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    3076           3 :  ldv_40_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    3077             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    3078             : 
    3079             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3080             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3081             : 
    3082             :  /* Jump to a subprocess 'call' initial state */
    3083           1 :  goto ldv_call_40;
    3084             :  /* End of the process */
    3085             :  return;
    3086           1 : 
    3087             :  /* Sbprocess call */
    3088             :  ldv_call_40:
    3089             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3090             : 
    3091           4 :  if (ldv_undef_int()) {
    3092             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3093           3 :   ldv_40_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    3094             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    3095             : 
    3096           4 :   if (ldv_undef_int()) {
    3097             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3098           3 :    ldv_40_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    3099             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    3100             : 
    3101             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    3102             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_queue_depth_rw))(ldv_40_container_struct_device_ptr, ldv_40_container_struct_device_attribute, ldv_40_ldv_param_10_2_default, ldv_40_ldv_param_10_3_default);", "comment": "callback"} */
    3103           2 :    ldv_random_containerless_scenario_callback_40_10(ldv_40_callback_store, ldv_40_container_struct_device_ptr, ldv_40_container_struct_device_attribute, ldv_40_ldv_param_10_2_default, ldv_40_ldv_param_10_3_default);
    3104             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3105             : 
    3106             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3107           2 :    ldv_free(ldv_40_ldv_param_10_2_default);
    3108             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    3109             : 
    3110             :   }
    3111             :   else {
    3112             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    3113             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_queue_depth))(ldv_40_container_struct_device_ptr, ldv_40_container_struct_device_attribute, ldv_40_ldv_param_4_2_default);", "comment": "callback"} */
    3114           2 :    ldv_random_containerless_scenario_callback_40_4(ldv_40_callback_show, ldv_40_container_struct_device_ptr, ldv_40_container_struct_device_attribute, ldv_40_ldv_param_4_2_default);
    3115             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3116             : 
    3117             :   }
    3118             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3119           4 :   ldv_free(ldv_40_ldv_param_4_2_default);
    3120             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    3121             : 
    3122             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3123             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3124             : 
    3125             :   /* Jump to a subprocess 'call' initial state */
    3126           1 :   goto ldv_call_40;
    3127             :  }
    3128             :  else {
    3129             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3130           2 :   ldv_free(ldv_40_container_struct_device_attribute);
    3131           2 :   ldv_free(ldv_40_container_struct_device_ptr);
    3132             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    3133             : 
    3134             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3135             :   /* Skip a non-replicative signal receiving */
    3136             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    3137             : 
    3138             :   /* Exit function at a terminal state */
    3139           1 :   return;
    3140             :  }
    3141             :  /* End of the subprocess 'call' */
    3142             :  return;
    3143             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_40"} */
    3144             : }
    3145             : 
    3146             : /* AUX_FUNC ldv_random_containerless_scenario_41 */
    3147             : void ldv_random_containerless_scenario_41(void *arg0) {
    3148             :  /* LDV {"thread": 41, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_41"} */
    3149           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3150           1 :  ssize_t (*ldv_41_callback_show)(struct device *, struct device_attribute *, char *);
    3151             :  ssize_t (*ldv_41_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    3152           1 :  struct device_attribute *ldv_41_container_struct_device_attribute;
    3153           1 :  struct device *ldv_41_container_struct_device_ptr;
    3154           1 :  char *ldv_41_ldv_param_10_2_default;
    3155           1 :  long unsigned int ldv_41_ldv_param_10_3_default;
    3156           1 :  char *ldv_41_ldv_param_4_2_default;
    3157           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3158           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3159           3 :  ldv_free(arg0);
    3160           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    3161           1 : 
    3162           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3163           3 :  ldv_41_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    3164           3 :  ldv_41_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    3165             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    3166             : 
    3167             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3168             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3169             : 
    3170             :  /* Jump to a subprocess 'call' initial state */
    3171           1 :  goto ldv_call_41;
    3172             :  /* End of the process */
    3173             :  return;
    3174           1 : 
    3175             :  /* Sbprocess call */
    3176             :  ldv_call_41:
    3177             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3178             : 
    3179           4 :  if (ldv_undef_int()) {
    3180             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3181           3 :   ldv_41_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    3182             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    3183             : 
    3184           4 :   if (ldv_undef_int()) {
    3185             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3186           3 :    ldv_41_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    3187             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    3188             : 
    3189             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    3190             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_queue_ramp_up_period))(ldv_41_container_struct_device_ptr, ldv_41_container_struct_device_attribute, ldv_41_ldv_param_10_2_default, ldv_41_ldv_param_10_3_default);", "comment": "callback"} */
    3191           2 :    ldv_random_containerless_scenario_callback_41_10(ldv_41_callback_store, ldv_41_container_struct_device_ptr, ldv_41_container_struct_device_attribute, ldv_41_ldv_param_10_2_default, ldv_41_ldv_param_10_3_default);
    3192             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3193             : 
    3194             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3195           2 :    ldv_free(ldv_41_ldv_param_10_2_default);
    3196             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    3197             : 
    3198             :   }
    3199             :   else {
    3200             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    3201             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_show_queue_ramp_up_period))(ldv_41_container_struct_device_ptr, ldv_41_container_struct_device_attribute, ldv_41_ldv_param_4_2_default);", "comment": "callback"} */
    3202           2 :    ldv_random_containerless_scenario_callback_41_4(ldv_41_callback_show, ldv_41_container_struct_device_ptr, ldv_41_container_struct_device_attribute, ldv_41_ldv_param_4_2_default);
    3203             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3204             : 
    3205             :   }
    3206             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3207           4 :   ldv_free(ldv_41_ldv_param_4_2_default);
    3208             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    3209             : 
    3210             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3211             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3212             : 
    3213             :   /* Jump to a subprocess 'call' initial state */
    3214           1 :   goto ldv_call_41;
    3215             :  }
    3216             :  else {
    3217             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3218           2 :   ldv_free(ldv_41_container_struct_device_attribute);
    3219           2 :   ldv_free(ldv_41_container_struct_device_ptr);
    3220             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    3221             : 
    3222             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3223             :   /* Skip a non-replicative signal receiving */
    3224             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    3225             : 
    3226             :   /* Exit function at a terminal state */
    3227           1 :   return;
    3228             :  }
    3229             :  /* End of the subprocess 'call' */
    3230             :  return;
    3231             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_41"} */
    3232             : }
    3233             : 
    3234             : /* AUX_FUNC ldv_random_containerless_scenario_42 */
    3235             : void ldv_random_containerless_scenario_42(void *arg0) {
    3236             :  /* LDV {"thread": 42, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_device_attribute)'", "function": "ldv_random_containerless_scenario_42"} */
    3237           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3238           1 :  ssize_t (*ldv_42_callback_show)(struct device *, struct device_attribute *, char *);
    3239             :  ssize_t (*ldv_42_callback_store)(struct device *, struct device_attribute *, char *, size_t );
    3240           1 :  struct device_attribute *ldv_42_container_struct_device_attribute;
    3241           1 :  struct device *ldv_42_container_struct_device_ptr;
    3242           1 :  char *ldv_42_ldv_param_10_2_default;
    3243           1 :  long unsigned int ldv_42_ldv_param_10_3_default;
    3244           1 :  char *ldv_42_ldv_param_4_2_default;
    3245           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3246           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3247           3 :  ldv_free(arg0);
    3248           1 :  /* LDV {"action": "DEFAULT_REGISTER_7", "type": "RECEIVE_END"} */
    3249           1 : 
    3250           1 :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3251           3 :  ldv_42_container_struct_device_attribute = ldv_xmalloc_unknown_size(0);
    3252           3 :  ldv_42_container_struct_device_ptr = ldv_xmalloc_unknown_size(0);
    3253             :  /* LDV {"action": "DEFAULT_ALLOC_7", "type": "CONDITION_END"} */
    3254             : 
    3255             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3256             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3257             : 
    3258             :  /* Jump to a subprocess 'call' initial state */
    3259           1 :  goto ldv_call_42;
    3260             :  /* End of the process */
    3261             :  return;
    3262           1 : 
    3263             :  /* Sbprocess call */
    3264             :  ldv_call_42:
    3265             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3266             : 
    3267           4 :  if (ldv_undef_int()) {
    3268             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3269           3 :   ldv_42_ldv_param_4_2_default = ldv_xmalloc_unknown_size(0);
    3270             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
    3271             : 
    3272           4 :   if (ldv_undef_int()) {
    3273             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
    3274           3 :    ldv_42_ldv_param_10_2_default = ldv_xmalloc_unknown_size(0);
    3275             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
    3276             : 
    3277             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback store from device_attribute."} */
    3278             :    /* LDV {"type": "CALLBACK", "call": "((& sdev_store_queue_type_rw))(ldv_42_container_struct_device_ptr, ldv_42_container_struct_device_attribute, ldv_42_ldv_param_10_2_default, ldv_42_ldv_param_10_3_default);", "comment": "callback"} */
    3279           2 :    ldv_random_containerless_scenario_callback_42_10(ldv_42_callback_store, ldv_42_container_struct_device_ptr, ldv_42_container_struct_device_attribute, ldv_42_ldv_param_10_2_default, ldv_42_ldv_param_10_3_default);
    3280             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3281             : 
    3282             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3283           2 :    ldv_free(ldv_42_ldv_param_10_2_default);
    3284             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
    3285             : 
    3286             :   }
    3287             :   else {
    3288             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback show from device_attribute."} */
    3289             :    /* LDV {"type": "CALLBACK", "call": "((& show_queue_type_field))(ldv_42_container_struct_device_ptr, ldv_42_container_struct_device_attribute, ldv_42_ldv_param_4_2_default);", "comment": "callback"} */
    3290           2 :    ldv_random_containerless_scenario_callback_42_4(ldv_42_callback_show, ldv_42_container_struct_device_ptr, ldv_42_container_struct_device_attribute, ldv_42_ldv_param_4_2_default);
    3291             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3292             : 
    3293             :   }
    3294             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
    3295           4 :   ldv_free(ldv_42_ldv_param_4_2_default);
    3296             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
    3297             : 
    3298             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
    3299             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3300             : 
    3301             :   /* Jump to a subprocess 'call' initial state */
    3302           1 :   goto ldv_call_42;
    3303             :  }
    3304             :  else {
    3305             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3306           2 :   ldv_free(ldv_42_container_struct_device_attribute);
    3307           2 :   ldv_free(ldv_42_container_struct_device_ptr);
    3308             :   /* LDV {"action": "DEFAULT_FREE_7", "type": "CONDITION_END"} */
    3309             : 
    3310             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_DEVICE_ATTRIBUTE callbacks invocations scenario."} */
    3311             :   /* Skip a non-replicative signal receiving */
    3312             :   /* LDV {"action": "DEFAULT_DEREGISTER_7", "type": "RECEIVE_END"} */
    3313             : 
    3314             :   /* Exit function at a terminal state */
    3315           1 :   return;
    3316             :  }
    3317             :  /* End of the subprocess 'call' */
    3318             :  return;
    3319             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_device_attribute)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_42"} */
    3320             : }
    3321             : 
    3322             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_11_4 */
    3323             : void ldv_random_containerless_scenario_callback_11_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3324           3 :  ((& show_shost_active_mode))(arg1, arg2, arg3);
    3325           1 : }
    3326             : 
    3327             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_12_4 */
    3328             : void ldv_random_containerless_scenario_callback_12_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3329           2 :  ((& show_can_queue))(arg1, arg2, arg3);
    3330           1 : }
    3331             : 
    3332             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_13_4 */
    3333             : void ldv_random_containerless_scenario_callback_13_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3334           2 :  ((& show_cmd_per_lun))(arg1, arg2, arg3);
    3335           1 : }
    3336             : 
    3337             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_14_10 */
    3338             : void ldv_random_containerless_scenario_callback_14_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) {
    3339           2 :  ((& sdev_store_delete))(arg1, arg2, arg3, arg4);
    3340           1 : }
    3341             : 
    3342             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_15_4 */
    3343             : void ldv_random_containerless_scenario_callback_15_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3344           2 :  ((& sdev_show_device_blocked))(arg1, arg2, arg3);
    3345           1 : }
    3346             : 
    3347             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_16_10 */
    3348             : void ldv_random_containerless_scenario_callback_16_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) {
    3349           4 :  ((& sdev_store_evt_media_change))(arg1, arg2, arg3, arg4);
    3350           1 : }
    3351             : 
    3352             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_16_4 */
    3353             : void ldv_random_containerless_scenario_callback_16_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3354           2 :  ((& sdev_show_evt_media_change))(arg1, arg2, arg3);
    3355           1 : }
    3356             : 
    3357             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_17_4 */
    3358             : void ldv_random_containerless_scenario_callback_17_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3359           2 :  ((& show_host_busy))(arg1, arg2, arg3);
    3360           1 : }
    3361             : 
    3362             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_18_10 */
    3363             : void ldv_random_containerless_scenario_callback_18_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) {
    3364           3 :  ((& store_shost_state))(arg1, arg2, arg3, arg4);
    3365           1 : }
    3366             : 
    3367             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_18_4 */
    3368             : void ldv_random_containerless_scenario_callback_18_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3369           2 :  ((& show_shost_state))(arg1, arg2, arg3);
    3370           1 : }
    3371             : 
    3372             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_19_4 */
    3373             : void ldv_random_containerless_scenario_callback_19_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3374           2 :  ((& show_iostat_counterbits))(arg1, arg2, arg3);
    3375           1 : }
    3376             : 
    3377             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_20_4 */
    3378             : void ldv_random_containerless_scenario_callback_20_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3379           2 :  ((& show_iostat_iodone_cnt))(arg1, arg2, arg3);
    3380           1 : }
    3381             : 
    3382             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_21_4 */
    3383             : void ldv_random_containerless_scenario_callback_21_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3384           2 :  ((& show_iostat_ioerr_cnt))(arg1, arg2, arg3);
    3385           1 : }
    3386             : 
    3387             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_22_4 */
    3388             : void ldv_random_containerless_scenario_callback_22_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3389           2 :  ((& show_iostat_iorequest_cnt))(arg1, arg2, arg3);
    3390           1 : }
    3391             : 
    3392             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_23_4 */
    3393             : void ldv_random_containerless_scenario_callback_23_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3394           2 :  ((& sdev_show_modalias))(arg1, arg2, arg3);
    3395           1 : }
    3396             : 
    3397             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_24_4 */
    3398             : void ldv_random_containerless_scenario_callback_24_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3399           2 :  ((& sdev_show_model))(arg1, arg2, arg3);
    3400           1 : }
    3401             : 
    3402             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_25_4 */
    3403             : void ldv_random_containerless_scenario_callback_25_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3404           2 :  ((& show_proc_name))(arg1, arg2, arg3);
    3405           1 : }
    3406             : 
    3407             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_26_4 */
    3408             : void ldv_random_containerless_scenario_callback_26_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3409           2 :  ((& show_prot_capabilities))(arg1, arg2, arg3);
    3410           1 : }
    3411             : 
    3412             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_27_4 */
    3413             : void ldv_random_containerless_scenario_callback_27_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3414           2 :  ((& show_prot_guard_type))(arg1, arg2, arg3);
    3415           1 : }
    3416             : 
    3417             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_28_10 */
    3418             : void ldv_random_containerless_scenario_callback_28_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) {
    3419           2 :  ((& store_rescan_field))(arg1, arg2, arg3, arg4);
    3420           1 : }
    3421             : 
    3422             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_29_4 */
    3423             : void ldv_random_containerless_scenario_callback_29_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3424           2 :  ((& sdev_show_rev))(arg1, arg2, arg3);
    3425           1 : }
    3426             : 
    3427             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_30_10 */
    3428             : void ldv_random_containerless_scenario_callback_30_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) {
    3429           2 :  ((& store_scan))(arg1, arg2, arg3, arg4);
    3430           1 : }
    3431             : 
    3432             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_31_4 */
    3433             : void ldv_random_containerless_scenario_callback_31_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3434           2 :  ((& sdev_show_scsi_level))(arg1, arg2, arg3);
    3435           1 : }
    3436             : 
    3437             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_32_4 */
    3438             : void ldv_random_containerless_scenario_callback_32_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3439           2 :  ((& show_sg_tablesize))(arg1, arg2, arg3);
    3440           1 : }
    3441             : 
    3442             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_33_10 */
    3443             : void ldv_random_containerless_scenario_callback_33_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) {
    3444           3 :  ((& store_state_field))(arg1, arg2, arg3, arg4);
    3445           1 : }
    3446             : 
    3447             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_33_4 */
    3448             : void ldv_random_containerless_scenario_callback_33_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3449           2 :  ((& show_state_field))(arg1, arg2, arg3);
    3450           1 : }
    3451             : 
    3452             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_34_4 */
    3453             : void ldv_random_containerless_scenario_callback_34_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3454           2 :  ((& show_shost_supported_mode))(arg1, arg2, arg3);
    3455           1 : }
    3456             : 
    3457             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_35_10 */
    3458             : void ldv_random_containerless_scenario_callback_35_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) {
    3459           2 :  ((& sdev_store_timeout))(arg1, arg2, arg3, arg4);
    3460           1 : }
    3461             : 
    3462             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_35_4 */
    3463             : void ldv_random_containerless_scenario_callback_35_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3464           2 :  ((& sdev_show_timeout))(arg1, arg2, arg3);
    3465           1 : }
    3466             : 
    3467             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_36_4 */
    3468             : void ldv_random_containerless_scenario_callback_36_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3469           2 :  ((& sdev_show_type))(arg1, arg2, arg3);
    3470           1 : }
    3471             : 
    3472             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_37_4 */
    3473             : void ldv_random_containerless_scenario_callback_37_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3474           2 :  ((& show_unchecked_isa_dma))(arg1, arg2, arg3);
    3475           1 : }
    3476             : 
    3477             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_38_4 */
    3478             : void ldv_random_containerless_scenario_callback_38_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3479           2 :  ((& show_unique_id))(arg1, arg2, arg3);
    3480           1 : }
    3481             : 
    3482             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_39_4 */
    3483             : void ldv_random_containerless_scenario_callback_39_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3484           2 :  ((& sdev_show_vendor))(arg1, arg2, arg3);
    3485           1 : }
    3486             : 
    3487             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_40_10 */
    3488             : void ldv_random_containerless_scenario_callback_40_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) {
    3489           2 :  ((& sdev_store_queue_depth_rw))(arg1, arg2, arg3, arg4);
    3490           1 : }
    3491             : 
    3492             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_40_4 */
    3493             : void ldv_random_containerless_scenario_callback_40_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3494           2 :  ((& sdev_show_queue_depth))(arg1, arg2, arg3);
    3495           1 : }
    3496             : 
    3497             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_41_10 */
    3498             : void ldv_random_containerless_scenario_callback_41_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) {
    3499           2 :  ((& sdev_store_queue_ramp_up_period))(arg1, arg2, arg3, arg4);
    3500           1 : }
    3501             : 
    3502             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_41_4 */
    3503             : void ldv_random_containerless_scenario_callback_41_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3504           2 :  ((& sdev_show_queue_ramp_up_period))(arg1, arg2, arg3);
    3505           1 : }
    3506             : 
    3507             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_42_10 */
    3508             : void ldv_random_containerless_scenario_callback_42_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) {
    3509           2 :  ((& sdev_store_queue_type_rw))(arg1, arg2, arg3, arg4);
    3510           1 : }
    3511             : 
    3512             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_42_4 */
    3513             : void ldv_random_containerless_scenario_callback_42_4(ssize_t (*arg0)(struct device *, struct device_attribute *, char *), struct device *arg1, struct device_attribute *arg2, char *arg3) {
    3514           2 :  ((& show_queue_type_field))(arg1, arg2, arg3);
    3515           1 : }
    3516             : 
    3517             : /* AUX_FUNC ldv_rtc_class_scenario_5 */
    3518             : void ldv_rtc_class_scenario_5(void *arg0) {
    3519             :  /* LDV {"thread": 5, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_5"} */
    3520           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3521           1 :  void (*ldv_5_callback_dev_release)(struct device *);
    3522           1 :  void (*ldv_5_callback_func_1_ptr)(struct device *);
    3523           1 :  struct device *ldv_5_device_device;
    3524           1 :  int ldv_5_ret_default;
    3525           1 :  struct rtc_class_ops *ldv_5_rtc_class_ops_rtc_class_ops;
    3526           1 :  struct rtc_device *ldv_5_rtc_device_rtc_device;
    3527           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3528           1 :  /* Initialize automaton variables */
    3529           2 :  ldv_5_ret_default = 1;
    3530           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    3531           3 :  ldv_free(arg0);
    3532             :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    3533             : 
    3534             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3535           3 :  ldv_5_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    3536           3 :  ldv_5_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    3537           3 :  ldv_5_device_device = ldv_xmalloc_unknown_size(0);
    3538             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    3539             : 
    3540             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3541             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3542             : 
    3543             :  /* Jump to a subprocess 'main' initial state */
    3544           1 :  goto ldv_main_5;
    3545             :  /* End of the process */
    3546             :  return;
    3547           1 : 
    3548             :  /* Sbprocess main */
    3549             :  ldv_main_5:
    3550             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3551             : 
    3552           4 :  if (ldv_undef_int()) {
    3553             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    3554             :   /* Callback pre-call */
    3555           1 :   ldv_pre_probe();
    3556           3 :   if (ldv_5_rtc_class_ops_rtc_class_ops->open) {
    3557             :   /* LDV {"type": "CALLBACK", "call": "ldv_5_ret_default = (ldv_5_rtc_class_ops_rtc_class_ops->open)(ldv_5_device_device);", "comment": "probe"} */
    3558           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);
    3559             :   }
    3560             :   /* Callback post-call */
    3561           4 :   ldv_5_ret_default = ldv_post_probe(ldv_5_ret_default);
    3562             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    3563             : 
    3564           4 :   if (ldv_undef_int()) {
    3565             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    3566           2 :    ldv_assume(ldv_5_ret_default == 0);
    3567             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    3568             : 
    3569             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3570             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3571             : 
    3572             :    /* Jump to a subprocess 'call' initial state */
    3573           1 :    goto ldv_call_5;
    3574             :   }
    3575             :   else {
    3576             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    3577           2 :    ldv_assume(ldv_5_ret_default != 0);
    3578             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    3579             : 
    3580             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3581             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3582             : 
    3583             :    /* Jump to a subprocess 'main' initial state */
    3584           1 :    goto ldv_main_5;
    3585             :   }
    3586             :  }
    3587             :  else {
    3588             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3589           2 :   ldv_free(ldv_5_rtc_device_rtc_device);
    3590             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    3591             : 
    3592             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    3593             :   /* Skip a non-replicative signal receiving */
    3594             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    3595             : 
    3596             :   /* Exit function at a terminal state */
    3597           1 :   return;
    3598             :  }
    3599             :  /* End of the subprocess 'main' */
    3600             :  return;
    3601           1 : 
    3602             :  /* Sbprocess call */
    3603             :  ldv_call_5:
    3604             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3605             : 
    3606           2 :  switch (ldv_undef_int()) {
    3607           3 :   case 1: {
    3608             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    3609             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_5_device_device);", "comment": "callback"} */
    3610           2 :    ldv_rtc_class_scenario_callback_5_15(ldv_5_callback_func_1_ptr, ldv_5_device_device);
    3611             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3612             : 
    3613             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3614             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3615             : 
    3616             :    /* Jump to a subprocess 'call' initial state */
    3617           1 :    goto ldv_call_5;
    3618           1 :    break;
    3619             :   }
    3620           3 :   case 2: {
    3621             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback dev_release from class."} */
    3622             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_device_cls_release))(ldv_5_device_device);", "comment": "callback"} */
    3623           2 :    ldv_rtc_class_scenario_callback_5_4(ldv_5_callback_dev_release, ldv_5_device_device);
    3624             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3625             : 
    3626             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3627             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3628             : 
    3629             :    /* Jump to a subprocess 'call' initial state */
    3630           1 :    goto ldv_call_5;
    3631             :    /* Jump to a subprocess 'call' initial state */
    3632             :    goto ldv_call_5;
    3633           1 :    break;
    3634             :   }
    3635           3 :   case 3: {
    3636             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from rtc_class_ops."} */
    3637             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_device_dev_release))(ldv_5_device_device);", "comment": "release"} */
    3638           2 :    ldv_rtc_class_scenario_release_5_2(ldv_5_rtc_class_ops_rtc_class_ops->release, ldv_5_device_device);
    3639             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    3640             : 
    3641             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3642             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3643             : 
    3644             :    /* Jump to a subprocess 'main' initial state */
    3645           1 :    goto ldv_main_5;
    3646           1 :    break;
    3647             :   }
    3648           2 :   default: ldv_stop();
    3649           1 :  }
    3650           0 :  /* End of the subprocess 'call' */
    3651           0 :  return;
    3652             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_5"} */
    3653             : }
    3654             : 
    3655             : /* AUX_FUNC ldv_rtc_class_scenario_6 */
    3656             : void ldv_rtc_class_scenario_6(void *arg0) {
    3657             :  /* LDV {"thread": 6, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_6"} */
    3658           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3659           1 :  void (*ldv_6_callback_dev_release)(struct device *);
    3660           1 :  void (*ldv_6_callback_func_1_ptr)(struct device *);
    3661           1 :  struct device *ldv_6_device_device;
    3662           1 :  int ldv_6_ret_default;
    3663           1 :  struct rtc_class_ops *ldv_6_rtc_class_ops_rtc_class_ops;
    3664           1 :  struct rtc_device *ldv_6_rtc_device_rtc_device;
    3665           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3666           1 :  /* Initialize automaton variables */
    3667           2 :  ldv_6_ret_default = 1;
    3668           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    3669           3 :  ldv_free(arg0);
    3670             :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    3671             : 
    3672             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3673           3 :  ldv_6_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    3674           3 :  ldv_6_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    3675           3 :  ldv_6_device_device = ldv_xmalloc_unknown_size(0);
    3676             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    3677             : 
    3678             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3679             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3680             : 
    3681             :  /* Jump to a subprocess 'main' initial state */
    3682           1 :  goto ldv_main_6;
    3683             :  /* End of the process */
    3684             :  return;
    3685           1 : 
    3686             :  /* Sbprocess main */
    3687             :  ldv_main_6:
    3688             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3689             : 
    3690           4 :  if (ldv_undef_int()) {
    3691             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    3692             :   /* Callback pre-call */
    3693           1 :   ldv_pre_probe();
    3694           3 :   if (ldv_6_rtc_class_ops_rtc_class_ops->open) {
    3695             :   /* LDV {"type": "CALLBACK", "call": "ldv_6_ret_default = (ldv_6_rtc_class_ops_rtc_class_ops->open)(ldv_6_device_device);", "comment": "probe"} */
    3696           2 :    ldv_6_ret_default = ldv_rtc_class_scenario_probe_6_11(ldv_6_rtc_class_ops_rtc_class_ops->open, ldv_6_device_device);
    3697             :   }
    3698             :   /* Callback post-call */
    3699           4 :   ldv_6_ret_default = ldv_post_probe(ldv_6_ret_default);
    3700             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    3701             : 
    3702           4 :   if (ldv_undef_int()) {
    3703             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    3704           2 :    ldv_assume(ldv_6_ret_default == 0);
    3705             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    3706             : 
    3707             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3708             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3709             : 
    3710             :    /* Jump to a subprocess 'call' initial state */
    3711           1 :    goto ldv_call_6;
    3712             :   }
    3713             :   else {
    3714             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    3715           2 :    ldv_assume(ldv_6_ret_default != 0);
    3716             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    3717             : 
    3718             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3719             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3720             : 
    3721             :    /* Jump to a subprocess 'main' initial state */
    3722           1 :    goto ldv_main_6;
    3723             :   }
    3724             :  }
    3725             :  else {
    3726             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3727           2 :   ldv_free(ldv_6_rtc_device_rtc_device);
    3728             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    3729             : 
    3730             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    3731             :   /* Skip a non-replicative signal receiving */
    3732             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    3733             : 
    3734             :   /* Exit function at a terminal state */
    3735           1 :   return;
    3736             :  }
    3737             :  /* End of the subprocess 'main' */
    3738             :  return;
    3739           1 : 
    3740             :  /* Sbprocess call */
    3741             :  ldv_call_6:
    3742             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3743             : 
    3744           2 :  switch (ldv_undef_int()) {
    3745           3 :   case 1: {
    3746             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    3747             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_6_device_device);", "comment": "callback"} */
    3748           2 :    ldv_rtc_class_scenario_callback_6_15(ldv_6_callback_func_1_ptr, ldv_6_device_device);
    3749             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3750             : 
    3751             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3752             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3753             : 
    3754             :    /* Jump to a subprocess 'call' initial state */
    3755           1 :    goto ldv_call_6;
    3756           1 :    break;
    3757             :   }
    3758           3 :   case 2: {
    3759             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback dev_release from class."} */
    3760             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_host_cls_release))(ldv_6_device_device);", "comment": "callback"} */
    3761           2 :    ldv_rtc_class_scenario_callback_6_4(ldv_6_callback_dev_release, ldv_6_device_device);
    3762             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3763             : 
    3764             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3765             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3766             : 
    3767             :    /* Jump to a subprocess 'call' initial state */
    3768           1 :    goto ldv_call_6;
    3769             :    /* Jump to a subprocess 'call' initial state */
    3770             :    goto ldv_call_6;
    3771           1 :    break;
    3772             :   }
    3773           3 :   case 3: {
    3774             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from RTC."} */
    3775             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_6_device_device);", "comment": "release"} */
    3776           2 :    ldv_rtc_class_scenario_release_6_2(ldv_6_rtc_class_ops_rtc_class_ops->release, ldv_6_device_device);
    3777             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    3778             : 
    3779             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3780             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3781             : 
    3782             :    /* Jump to a subprocess 'main' initial state */
    3783           1 :    goto ldv_main_6;
    3784           1 :    break;
    3785             :   }
    3786           2 :   default: ldv_stop();
    3787           1 :  }
    3788           0 :  /* End of the subprocess 'call' */
    3789           0 :  return;
    3790             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_6"} */
    3791             : }
    3792             : 
    3793             : /* AUX_FUNC ldv_rtc_class_scenario_7 */
    3794             : void ldv_rtc_class_scenario_7(void *arg0) {
    3795             :  /* LDV {"thread": 7, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_7"} */
    3796           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3797           1 :  void (*ldv_7_callback_dev_release)(struct device *);
    3798           1 :  void (*ldv_7_callback_func_1_ptr)(struct device *);
    3799           1 :  struct device *ldv_7_device_device;
    3800           1 :  int ldv_7_ret_default;
    3801           1 :  struct rtc_class_ops *ldv_7_rtc_class_ops_rtc_class_ops;
    3802           1 :  struct rtc_device *ldv_7_rtc_device_rtc_device;
    3803           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3804           1 :  /* Initialize automaton variables */
    3805           2 :  ldv_7_ret_default = 1;
    3806           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    3807           3 :  ldv_free(arg0);
    3808             :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    3809             : 
    3810             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3811           3 :  ldv_7_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    3812           3 :  ldv_7_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    3813           3 :  ldv_7_device_device = ldv_xmalloc_unknown_size(0);
    3814             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    3815             : 
    3816             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3817             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3818             : 
    3819             :  /* Jump to a subprocess 'main' initial state */
    3820           1 :  goto ldv_main_7;
    3821             :  /* End of the process */
    3822             :  return;
    3823           1 : 
    3824             :  /* Sbprocess main */
    3825             :  ldv_main_7:
    3826             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3827             : 
    3828           4 :  if (ldv_undef_int()) {
    3829             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    3830             :   /* Callback pre-call */
    3831           1 :   ldv_pre_probe();
    3832           3 :   if (ldv_7_rtc_class_ops_rtc_class_ops->open) {
    3833             :   /* LDV {"type": "CALLBACK", "call": "ldv_7_ret_default = (ldv_7_rtc_class_ops_rtc_class_ops->open)(ldv_7_device_device);", "comment": "probe"} */
    3834           2 :    ldv_7_ret_default = ldv_rtc_class_scenario_probe_7_11(ldv_7_rtc_class_ops_rtc_class_ops->open, ldv_7_device_device);
    3835             :   }
    3836             :   /* Callback post-call */
    3837           4 :   ldv_7_ret_default = ldv_post_probe(ldv_7_ret_default);
    3838             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    3839             : 
    3840           4 :   if (ldv_undef_int()) {
    3841             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    3842           2 :    ldv_assume(ldv_7_ret_default == 0);
    3843             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    3844             : 
    3845             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3846             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3847             : 
    3848             :    /* Jump to a subprocess 'call' initial state */
    3849           1 :    goto ldv_call_7;
    3850             :   }
    3851             :   else {
    3852             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    3853           2 :    ldv_assume(ldv_7_ret_default != 0);
    3854             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    3855             : 
    3856             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3857             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3858             : 
    3859             :    /* Jump to a subprocess 'main' initial state */
    3860           1 :    goto ldv_main_7;
    3861             :   }
    3862             :  }
    3863             :  else {
    3864             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    3865           2 :   ldv_free(ldv_7_rtc_device_rtc_device);
    3866             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    3867             : 
    3868             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    3869             :   /* Skip a non-replicative signal receiving */
    3870             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    3871             : 
    3872             :   /* Exit function at a terminal state */
    3873           1 :   return;
    3874             :  }
    3875             :  /* End of the subprocess 'main' */
    3876             :  return;
    3877           1 : 
    3878             :  /* Sbprocess call */
    3879             :  ldv_call_7:
    3880             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3881             : 
    3882           2 :  switch (ldv_undef_int()) {
    3883           3 :   case 1: {
    3884             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    3885             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_7_device_device);", "comment": "callback"} */
    3886           2 :    ldv_rtc_class_scenario_callback_7_15(ldv_7_callback_func_1_ptr, ldv_7_device_device);
    3887             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3888             : 
    3889             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3890             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3891             : 
    3892             :    /* Jump to a subprocess 'call' initial state */
    3893           1 :    goto ldv_call_7;
    3894           1 :    break;
    3895             :   }
    3896           3 :   case 2: {
    3897             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    3898             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_7_device_device);", "comment": "callback"} */
    3899           2 :    ldv_rtc_class_scenario_callback_7_4(ldv_7_callback_dev_release, ldv_7_device_device);
    3900             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    3901             : 
    3902             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3903             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3904             : 
    3905             :    /* Jump to a subprocess 'call' initial state */
    3906           1 :    goto ldv_call_7;
    3907             :    /* Jump to a subprocess 'call' initial state */
    3908             :    goto ldv_call_7;
    3909           1 :    break;
    3910             :   }
    3911           3 :   case 3: {
    3912             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from RTC."} */
    3913             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_7_device_device);", "comment": "release"} */
    3914           2 :    ldv_rtc_class_scenario_release_7_2(ldv_7_rtc_class_ops_rtc_class_ops->release, ldv_7_device_device);
    3915             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    3916             : 
    3917             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3918             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3919             : 
    3920             :    /* Jump to a subprocess 'main' initial state */
    3921           1 :    goto ldv_main_7;
    3922           1 :    break;
    3923             :   }
    3924           2 :   default: ldv_stop();
    3925           1 :  }
    3926           0 :  /* End of the subprocess 'call' */
    3927           0 :  return;
    3928             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_7"} */
    3929             : }
    3930             : 
    3931             : /* AUX_FUNC ldv_rtc_class_scenario_8 */
    3932             : void ldv_rtc_class_scenario_8(void *arg0) {
    3933             :  /* LDV {"thread": 8, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_8"} */
    3934           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    3935           1 :  void (*ldv_8_callback_dev_release)(struct device *);
    3936           1 :  void (*ldv_8_callback_func_1_ptr)(struct device *);
    3937           1 :  struct device *ldv_8_device_device;
    3938           1 :  int ldv_8_ret_default;
    3939           1 :  struct rtc_class_ops *ldv_8_rtc_class_ops_rtc_class_ops;
    3940           1 :  struct rtc_device *ldv_8_rtc_device_rtc_device;
    3941           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    3942           1 :  /* Initialize automaton variables */
    3943           2 :  ldv_8_ret_default = 1;
    3944           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    3945           3 :  ldv_free(arg0);
    3946             :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    3947             : 
    3948             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    3949           3 :  ldv_8_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    3950           3 :  ldv_8_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    3951           3 :  ldv_8_device_device = ldv_xmalloc_unknown_size(0);
    3952             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    3953             : 
    3954             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3955             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3956             : 
    3957             :  /* Jump to a subprocess 'main' initial state */
    3958           1 :  goto ldv_main_8;
    3959             :  /* End of the process */
    3960             :  return;
    3961           1 : 
    3962             :  /* Sbprocess main */
    3963             :  ldv_main_8:
    3964             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    3965             : 
    3966           4 :  if (ldv_undef_int()) {
    3967             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    3968             :   /* Callback pre-call */
    3969           1 :   ldv_pre_probe();
    3970           3 :   if (ldv_8_rtc_class_ops_rtc_class_ops->open) {
    3971             :   /* LDV {"type": "CALLBACK", "call": "ldv_8_ret_default = (ldv_8_rtc_class_ops_rtc_class_ops->open)(ldv_8_device_device);", "comment": "probe"} */
    3972           2 :    ldv_8_ret_default = ldv_rtc_class_scenario_probe_8_11(ldv_8_rtc_class_ops_rtc_class_ops->open, ldv_8_device_device);
    3973             :   }
    3974             :   /* Callback post-call */
    3975           4 :   ldv_8_ret_default = ldv_post_probe(ldv_8_ret_default);
    3976             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    3977             : 
    3978           4 :   if (ldv_undef_int()) {
    3979             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    3980           2 :    ldv_assume(ldv_8_ret_default == 0);
    3981             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    3982             : 
    3983             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    3984             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    3985             : 
    3986             :    /* Jump to a subprocess 'call' initial state */
    3987           1 :    goto ldv_call_8;
    3988             :   }
    3989             :   else {
    3990             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    3991           2 :    ldv_assume(ldv_8_ret_default != 0);
    3992             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    3993             : 
    3994             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    3995             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    3996             : 
    3997             :    /* Jump to a subprocess 'main' initial state */
    3998           1 :    goto ldv_main_8;
    3999             :   }
    4000             :  }
    4001             :  else {
    4002             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    4003           2 :   ldv_free(ldv_8_rtc_device_rtc_device);
    4004             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    4005             : 
    4006             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    4007             :   /* Skip a non-replicative signal receiving */
    4008             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    4009             : 
    4010             :   /* Exit function at a terminal state */
    4011           1 :   return;
    4012             :  }
    4013             :  /* End of the subprocess 'main' */
    4014             :  return;
    4015           1 : 
    4016             :  /* Sbprocess call */
    4017             :  ldv_call_8:
    4018             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    4019             : 
    4020           2 :  switch (ldv_undef_int()) {
    4021           3 :   case 1: {
    4022             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    4023             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_8_device_device);", "comment": "callback"} */
    4024           2 :    ldv_rtc_class_scenario_callback_8_15(ldv_8_callback_func_1_ptr, ldv_8_device_device);
    4025             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    4026             : 
    4027             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    4028             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    4029             : 
    4030             :    /* Jump to a subprocess 'call' initial state */
    4031           1 :    goto ldv_call_8;
    4032           1 :    break;
    4033             :   }
    4034           3 :   case 2: {
    4035             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback dev_release from class."} */
    4036             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_device_cls_release))(ldv_8_device_device);", "comment": "callback"} */
    4037           2 :    ldv_rtc_class_scenario_callback_8_4(ldv_8_callback_dev_release, ldv_8_device_device);
    4038             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    4039             : 
    4040             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    4041             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    4042             : 
    4043             :    /* Jump to a subprocess 'call' initial state */
    4044           1 :    goto ldv_call_8;
    4045             :    /* Jump to a subprocess 'call' initial state */
    4046             :    goto ldv_call_8;
    4047           1 :    break;
    4048             :   }
    4049           3 :   case 3: {
    4050             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from rtc_class_ops."} */
    4051             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_host_dev_release))(ldv_8_device_device);", "comment": "release"} */
    4052           2 :    ldv_rtc_class_scenario_release_8_2(ldv_8_rtc_class_ops_rtc_class_ops->release, ldv_8_device_device);
    4053             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    4054             : 
    4055             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    4056             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    4057             : 
    4058             :    /* Jump to a subprocess 'main' initial state */
    4059           1 :    goto ldv_main_8;
    4060           1 :    break;
    4061             :   }
    4062           2 :   default: ldv_stop();
    4063           1 :  }
    4064           0 :  /* End of the subprocess 'call' */
    4065           0 :  return;
    4066             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_8"} */
    4067             : }
    4068             : 
    4069             : /* AUX_FUNC ldv_rtc_class_scenario_9 */
    4070             : void ldv_rtc_class_scenario_9(void *arg0) {
    4071             :  /* LDV {"thread": 9, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'rtc_class_scenario(rtc)'", "function": "ldv_rtc_class_scenario_9"} */
    4072           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
    4073           1 :  void (*ldv_9_callback_dev_release)(struct device *);
    4074           1 :  void (*ldv_9_callback_func_1_ptr)(struct device *);
    4075           1 :  struct device *ldv_9_device_device;
    4076           1 :  int ldv_9_ret_default;
    4077           1 :  struct rtc_class_ops *ldv_9_rtc_class_ops_rtc_class_ops;
    4078           1 :  struct rtc_device *ldv_9_rtc_device_rtc_device;
    4079           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
    4080           1 :  /* Initialize automaton variables */
    4081           2 :  ldv_9_ret_default = 1;
    4082           1 :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Begin RTC callbacks invocations scenario."} */
    4083           3 :  ldv_free(arg0);
    4084             :  /* LDV {"action": "DEFAULT_REGISTER_5", "type": "RECEIVE_END"} */
    4085             : 
    4086             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
    4087           3 :  ldv_9_rtc_device_rtc_device = ldv_xmalloc_unknown_size(0);
    4088           3 :  ldv_9_rtc_class_ops_rtc_class_ops = ldv_xmalloc_unknown_size(0);
    4089           3 :  ldv_9_device_device = ldv_xmalloc_unknown_size(0);
    4090             :  /* LDV {"action": "DEFAULT_ALLOC_5", "type": "CONDITION_END"} */
    4091             : 
    4092             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    4093             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    4094             : 
    4095             :  /* Jump to a subprocess 'main' initial state */
    4096           1 :  goto ldv_main_9;
    4097             :  /* End of the process */
    4098             :  return;
    4099           1 : 
    4100             :  /* Sbprocess main */
    4101             :  ldv_main_9:
    4102             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    4103             : 
    4104           4 :  if (ldv_undef_int()) {
    4105             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Probe a new RTC device. Invoke callback probe from RTC."} */
    4106             :   /* Callback pre-call */
    4107           1 :   ldv_pre_probe();
    4108           3 :   if (ldv_9_rtc_class_ops_rtc_class_ops->open) {
    4109             :   /* LDV {"type": "CALLBACK", "call": "ldv_9_ret_default = (ldv_9_rtc_class_ops_rtc_class_ops->open)(ldv_9_device_device);", "comment": "probe"} */
    4110           2 :    ldv_9_ret_default = ldv_rtc_class_scenario_probe_9_11(ldv_9_rtc_class_ops_rtc_class_ops->open, ldv_9_device_device);
    4111             :   }
    4112             :   /* Callback post-call */
    4113           4 :   ldv_9_ret_default = ldv_post_probe(ldv_9_ret_default);
    4114             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
    4115             : 
    4116           4 :   if (ldv_undef_int()) {
    4117             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "The RTC device has been successfully probed."} */
    4118           2 :    ldv_assume(ldv_9_ret_default == 0);
    4119             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
    4120             : 
    4121             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    4122             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    4123             : 
    4124             :    /* Jump to a subprocess 'call' initial state */
    4125           1 :    goto ldv_call_9;
    4126             :   }
    4127             :   else {
    4128             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to probe the RTC device."} */
    4129           2 :    ldv_assume(ldv_9_ret_default != 0);
    4130             :    /* LDV {"action": "PROBE_FAILED", "type": "CONDITION_END"} */
    4131             : 
    4132             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    4133             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    4134             : 
    4135             :    /* Jump to a subprocess 'main' initial state */
    4136           1 :    goto ldv_main_9;
    4137             :   }
    4138             :  }
    4139             :  else {
    4140             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
    4141           2 :   ldv_free(ldv_9_rtc_device_rtc_device);
    4142             :   /* LDV {"action": "DEFAULT_FREE_5", "type": "CONDITION_END"} */
    4143             : 
    4144             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_BEGIN", "comment": "Finish RTC callbacks invocations scenario."} */
    4145             :   /* Skip a non-replicative signal receiving */
    4146             :   /* LDV {"action": "DEFAULT_DEREGISTER_5", "type": "RECEIVE_END"} */
    4147             : 
    4148             :   /* Exit function at a terminal state */
    4149           1 :   return;
    4150             :  }
    4151             :  /* End of the subprocess 'main' */
    4152             :  return;
    4153           1 : 
    4154             :  /* Sbprocess call */
    4155             :  ldv_call_9:
    4156             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
    4157             : 
    4158           2 :  switch (ldv_undef_int()) {
    4159           3 :   case 1: {
    4160             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback callback from RTC."} */
    4161             :    /* LDV {"type": "CALLBACK", "call": "((sdev_store_delete_callback))(ldv_9_device_device);", "comment": "callback"} */
    4162           2 :    ldv_rtc_class_scenario_callback_9_15(ldv_9_callback_func_1_ptr, ldv_9_device_device);
    4163             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    4164             : 
    4165             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    4166             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    4167             : 
    4168             :    /* Jump to a subprocess 'call' initial state */
    4169           1 :    goto ldv_call_9;
    4170           1 :    break;
    4171             :   }
    4172           3 :   case 2: {
    4173             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback dev_release from class."} */
    4174             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_device_cls_release))(ldv_9_device_device);", "comment": "callback"} */
    4175           2 :    ldv_rtc_class_scenario_callback_9_4(ldv_9_callback_dev_release, ldv_9_device_device);
    4176             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
    4177             : 
    4178             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is probed."} */
    4179             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
    4180             : 
    4181             :    /* Jump to a subprocess 'call' initial state */
    4182           1 :    goto ldv_call_9;
    4183             :    /* Jump to a subprocess 'call' initial state */
    4184             :    goto ldv_call_9;
    4185           1 :    break;
    4186             :   }
    4187           3 :   case 3: {
    4188             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback release from rtc_class_ops."} */
    4189             :    /* LDV {"type": "CALLBACK", "call": "((& scsi_target_dev_release))(ldv_9_device_device);", "comment": "release"} */
    4190           2 :    ldv_rtc_class_scenario_release_9_2(ldv_9_rtc_class_ops_rtc_class_ops->release, ldv_9_device_device);
    4191             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
    4192             : 
    4193             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "The RTC device is inserted in the system."} */
    4194             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
    4195             : 
    4196             :    /* Jump to a subprocess 'main' initial state */
    4197           1 :    goto ldv_main_9;
    4198           1 :    break;
    4199             :   }
    4200           2 :   default: ldv_stop();
    4201           1 :  }
    4202           0 :  /* End of the subprocess 'call' */
    4203           0 :  return;
    4204             :  /* LDV {"comment": "End of control function based on process 'rtc_class_scenario(rtc)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_rtc_class_scenario_9"} */
    4205             : }
    4206             : 
    4207             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_5_15 */
    4208             : void ldv_rtc_class_scenario_callback_5_15(void (*arg0)(struct device *), struct device *arg1) {
    4209           2 :  ((sdev_store_delete_callback))(arg1);
    4210           1 : }
    4211             : 
    4212             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_5_4 */
    4213             : void ldv_rtc_class_scenario_callback_5_4(void (*arg0)(struct device *), struct device *arg1) {
    4214           2 :  ((& scsi_device_cls_release))(arg1);
    4215           1 : }
    4216             : 
    4217             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_6_15 */
    4218             : void ldv_rtc_class_scenario_callback_6_15(void (*arg0)(struct device *), struct device *arg1) {
    4219           2 :  ((sdev_store_delete_callback))(arg1);
    4220           1 : }
    4221             : 
    4222             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_7_15 */
    4223             : void ldv_rtc_class_scenario_callback_7_15(void (*arg0)(struct device *), struct device *arg1) {
    4224           2 :  ((sdev_store_delete_callback))(arg1);
    4225           1 : }
    4226             : 
    4227             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_7_4 */
    4228             : void ldv_rtc_class_scenario_callback_7_4(void (*arg0)(struct device *), struct device *arg1) {
    4229           2 :  ((sdev_store_delete_callback))(arg1);
    4230           1 : }
    4231             : 
    4232             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_8_15 */
    4233             : void ldv_rtc_class_scenario_callback_8_15(void (*arg0)(struct device *), struct device *arg1) {
    4234           2 :  ((sdev_store_delete_callback))(arg1);
    4235           1 : }
    4236             : 
    4237             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_8_4 */
    4238             : void ldv_rtc_class_scenario_callback_8_4(void (*arg0)(struct device *), struct device *arg1) {
    4239           2 :  ((& scsi_device_cls_release))(arg1);
    4240           1 : }
    4241             : 
    4242             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_9_15 */
    4243             : void ldv_rtc_class_scenario_callback_9_15(void (*arg0)(struct device *), struct device *arg1) {
    4244           2 :  ((sdev_store_delete_callback))(arg1);
    4245           1 : }
    4246             : 
    4247             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_callback_9_4 */
    4248             : void ldv_rtc_class_scenario_callback_9_4(void (*arg0)(struct device *), struct device *arg1) {
    4249           2 :  ((& scsi_device_cls_release))(arg1);
    4250           1 : }
    4251             : 
    4252             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_release_5_2 */
    4253             : void ldv_rtc_class_scenario_release_5_2(void (*arg0)(struct device *), struct device *arg1) {
    4254           2 :  ((& scsi_device_dev_release))(arg1);
    4255           1 : }
    4256             : 
    4257             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_release_6_2 */
    4258             : void ldv_rtc_class_scenario_release_6_2(void (*arg0)(struct device *), struct device *arg1) {
    4259           2 :  ((sdev_store_delete_callback))(arg1);
    4260           1 : }
    4261             : 
    4262             : /* AUX_FUNC_CALLBACK ldv_rtc_class_scenario_release_7_2 */
    4263             : void ldv_rtc_class_scenario_release_7_2(void (*arg0)(struct device *), struct device *arg1) {
    4264           2 :  ((sdev_store_delete_callback))(arg1);
    4265           1 : }
    4266             : 
    4267             : 
    4268             : /* AUX_FUNC  ERR_PTR */
    4269             : static inline void *ERR_PTR (long int error)
    4270             : {
    4271             : 
    4272             :  return ldv_err_ptr(error);
    4273             : }
    4274             : 
    4275             : /* AUX_FUNC  PTR_ERR */
    4276             : static inline long int PTR_ERR (void const *ptr)
    4277             : {
    4278             : 
    4279             :  return ldv_ptr_err(ptr);
    4280             : }
    4281             : 
    4282             : /* AUX_FUNC  IS_ERR */
    4283             : static inline long int IS_ERR (void const *ptr)
    4284             : {
    4285             : 
    4286             :  return ldv_is_err(ptr);
    4287             : }
    4288             : 
    4289             : /* AUX_FUNC  IS_ERR_OR_NULL */
    4290             : static inline long int IS_ERR_OR_NULL (void const *ptr)
    4291             : {
    4292             : 
    4293             :  return ldv_is_err_or_null(ptr);
    4294             : }
    4295             : 
    4296             : /* AUX_FUNC  kzalloc */
    4297             : static inline void *kzalloc (size_t size, gfp_t flags)
    4298             : {
    4299             : 
    4300             :  return ldv_kzalloc(size, flags);
    4301             : }

Generated by: LCOV version 1.10