LCOV - code coverage report
Current view: top level - avtg/drivers/scsi/scsi_mod.ko/linux:drivers:clk2/weaver - scsi_devinfo.c.aux (source / functions) Hit Total Coverage
Test: coverage.info Lines: 200 202 99.0 %
Date: 2017-01-25 Functions: 15 15 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           1 : 
      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_character_driver_scenario_2(void *);
      52             : extern void ldv_character_driver_scenario_callback_2_22(ssize_t (*)(struct file *, char *, size_t , loff_t *), struct file *, char *, long unsigned int, loff_t *);
      53             : extern void ldv_character_driver_scenario_callback_2_5(loff_t (*)(struct file *, loff_t , int), struct file *, long long int, int);
      54             : int ldv_character_driver_scenario_probe_2_13(int (*)(struct inode *, struct file *), struct inode *, struct file *);
      55             : void ldv_character_driver_scenario_release_2_2(int (*)(struct inode *, struct file *), struct inode *, struct file *);
      56             : void ldv_character_driver_scenario_write_2_4(ssize_t (*)(struct file *, char *, size_t , loff_t *), struct file *, char *, long unsigned int, loff_t *);
      57             : void ldv_dispatch_register_47_1(struct seq_file *, struct seq_operations *);
      58             : int ldv_emg_seq_open(struct file *, struct seq_operations *);
      59             : void ldv_random_containerless_scenario_43(void *);
      60             : void ldv_random_containerless_scenario_44(void *);
      61             : void ldv_random_containerless_scenario_callback_43_10(int (*)(char *, struct kernel_param *), char *, struct kernel_param *);
      62             : void ldv_random_containerless_scenario_callback_43_4(int (*)(char *, struct kernel_param *), char *, struct kernel_param *);
      63             : extern void ldv_random_containerless_scenario_callback_44_10(int (*)(char *, struct kernel_param *), char *, struct kernel_param *);
      64             : extern void ldv_random_containerless_scenario_callback_44_4(int (*)(char *, struct kernel_param *), char *, struct kernel_param *);
      65             : void ldv_traverse_kernel_items_scenario_10(void *);
      66             : void *ldv_traverse_kernel_items_scenario_next_10_7(void *(*)(struct seq_file *, void *, loff_t *), struct seq_file *, void *, loff_t *);
      67             : extern void ldv_traverse_kernel_items_scenario_show_10_6(int (*)(struct seq_file *, void *), struct seq_file *, void *);
      68             : void *ldv_traverse_kernel_items_scenario_start_10_13(void *(*)(struct seq_file *, loff_t *), struct seq_file *, loff_t *);
      69             : void ldv_traverse_kernel_items_scenario_stop_10_2(void (*)(struct seq_file *, void *), struct seq_file *, void *);
      70             : 
      71             : /* EMG variable declarations */
      72           1 : struct ldv_thread ldv_thread_10;
      73           1 : struct ldv_thread ldv_thread_2;
      74           1 : struct ldv_thread ldv_thread_43;
      75           1 : struct ldv_thread ldv_thread_44;
      76             : 
      77             : /* EMG variable initialization */
      78             : 
      79             : /* EMG function definitions */
      80             : /* AUX_FUNC ldv_character_driver_scenario_2 */
      81             : void ldv_character_driver_scenario_2(void *arg0) {
      82             :  /* LDV {"thread": 2, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'character_driver_scenario(file_operations)'", "function": "ldv_character_driver_scenario_2"} */
      83           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
      84           1 :  loff_t (*ldv_2_callback_llseek)(struct file *, loff_t , int);
      85           1 :  ssize_t (*ldv_2_callback_read)(struct file *, char *, size_t , loff_t *);
      86           1 :  struct file_operations *ldv_2_container_file_operations;
      87           1 :  char *ldv_2_ldv_param_22_1_default;
      88           1 :  long long int *ldv_2_ldv_param_22_3_default;
      89           1 :  char *ldv_2_ldv_param_4_1_default;
      90           1 :  long long int *ldv_2_ldv_param_4_3_default;
      91           1 :  long long int ldv_2_ldv_param_5_1_default;
      92           1 :  int ldv_2_ldv_param_5_2_default;
      93           1 :  struct file *ldv_2_resource_file;
      94           1 :  struct inode *ldv_2_resource_inode;
      95           1 :  int ldv_2_ret_default;
      96           1 :  long unsigned int ldv_2_size_cnt_write_size;
      97           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
      98           1 :  /* Initialize automaton variables */
      99           2 :  ldv_2_ret_default = 1;
     100           1 :  /* LDV {"action": "DEFAULT_REGISTER_2", "type": "RECEIVE_BEGIN", "comment": "Begin FILE_OPERATIONS callbacks invocations scenario."} */
     101           3 :  ldv_free(arg0);
     102           1 :  /* LDV {"action": "DEFAULT_REGISTER_2", "type": "RECEIVE_END"} */
     103           1 : 
     104           1 :  /* LDV {"action": "DEFAULT_ALLOC_2", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     105           4 :  ldv_2_container_file_operations = ldv_xmalloc_unknown_size(0);
     106           1 :  /* LDV {"action": "DEFAULT_ALLOC_2", "type": "CONDITION_END"} */
     107           1 : 
     108             :  /* LDV {"action": "INIT", "type": "CONDITION_BEGIN", "comment": "Allocate memory for file and inode structures."} */
     109           3 :  ldv_2_resource_file = ldv_xmalloc(sizeof(struct file));
     110           3 :  ldv_2_resource_inode = ldv_xmalloc(sizeof(struct inode));
     111           3 :  ldv_2_size_cnt_write_size = ldv_undef_int();
     112             :  /* LDV {"action": "INIT", "type": "CONDITION_END"} */
     113             : 
     114             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Device appeared in the system."} */
     115             :  /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     116             : 
     117             :  /* Jump to a subprocess 'main' initial state */
     118           1 :  goto ldv_main_2;
     119             :  /* End of the process */
     120             :  return;
     121           1 : 
     122             :  /* Sbprocess main */
     123             :  ldv_main_2:
     124             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     125             : 
     126           4 :  if (ldv_undef_int()) {
     127             :   /* LDV {"action": "PROBE", "type": "CALL_BEGIN", "callback": true, "comment": "Open the device file. Invoke callback open from file_operations."} */
     128             :   /* LDV {"type": "CALLBACK", "call": "ldv_2_ret_default = ((& proc_scsi_devinfo_open))(ldv_2_resource_inode, ldv_2_resource_file);", "comment": "probe"} */
     129           2 :   ldv_2_ret_default = ldv_character_driver_scenario_probe_2_13(ldv_2_container_file_operations->open, ldv_2_resource_inode, ldv_2_resource_file);
     130             :   /* Callback post-call */
     131           2 :   ldv_2_ret_default = ldv_filter_err_code(ldv_2_ret_default);
     132             :   /* LDV {"action": "PROBE", "type": "CALL_END"} */
     133             : 
     134           4 :   if (ldv_undef_int()) {
     135             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_BEGIN", "comment": "Device file is opened successfully."} */
     136           2 :    ldv_assume(ldv_2_ret_default == 0);
     137             :    /* LDV {"action": "PROBE_SUCCESS", "type": "CONDITION_END"} */
     138             : 
     139             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Device file is opened, ready to read and write."} */
     140             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     141             : 
     142             :    /* Jump to a subprocess 'call' initial state */
     143           1 :    goto ldv_call_2;
     144             :   }
     145             :   else {
     146             :    /* LDV {"action": "PROBE_FAIL", "type": "CONDITION_BEGIN", "comment": "Failed to open devices file."} */
     147           2 :    ldv_assume(ldv_2_ret_default != 0);
     148             :    /* LDV {"action": "PROBE_FAIL", "type": "CONDITION_END"} */
     149             : 
     150             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Device appeared in the system."} */
     151             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     152             : 
     153             :    /* Jump to a subprocess 'main' initial state */
     154           1 :    goto ldv_main_2;
     155             :   }
     156             :  }
     157             :  else {
     158             :   /* LDV {"action": "FREE", "type": "CONDITION_BEGIN", "comment": "Free memory of file and inode structures."} */
     159           2 :   ldv_free(ldv_2_resource_file);
     160           2 :   ldv_free(ldv_2_resource_inode);
     161             :   /* LDV {"action": "FREE", "type": "CONDITION_END"} */
     162             : 
     163             :   /* LDV {"action": "DEFAULT_FREE_2", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     164           2 :   ldv_free(ldv_2_container_file_operations);
     165             :   /* LDV {"action": "DEFAULT_FREE_2", "type": "CONDITION_END"} */
     166             : 
     167             :   /* LDV {"action": "DEFAULT_DEREGISTER_2", "type": "RECEIVE_BEGIN", "comment": "Finish FILE_OPERATIONS callbacks invocations scenario."} */
     168             :   /* Skip a non-replicative signal receiving */
     169             :   /* LDV {"action": "DEFAULT_DEREGISTER_2", "type": "RECEIVE_END"} */
     170             : 
     171             :   /* Exit function at a terminal state */
     172           1 :   return;
     173             :  }
     174             :  /* End of the subprocess 'main' */
     175             :  return;
     176           1 : 
     177             :  /* Sbprocess call */
     178             :  ldv_call_2:
     179             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     180             : 
     181           2 :  switch (ldv_undef_int()) {
     182           3 :   case 1: {
     183             :    /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     184           3 :    ldv_2_ldv_param_4_1_default = ldv_xmalloc_unknown_size(0);
     185           3 :    ldv_2_ldv_param_4_3_default = ldv_xmalloc_unknown_size(0);
     186             :    /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     187             : 
     188             :    /* LDV {"action": "WRITE", "type": "CALL_BEGIN", "callback": true, "comment": "Write data to the device. Invoke callback write from file_operations."} */
     189             :    /* Callback pre-call */
     190           2 :    ldv_assume(ldv_2_size_cnt_write_size <= (INT_MAX & PAGE_CACHE_MASK));
     191             :    /* LDV {"type": "CALLBACK", "call": "((& proc_scsi_devinfo_write))(ldv_2_resource_file, ldv_2_ldv_param_4_1_default, ldv_2_size_cnt_write_size, ldv_2_ldv_param_4_3_default);", "comment": "write"} */
     192           3 :    ldv_character_driver_scenario_write_2_4(ldv_2_container_file_operations->write, ldv_2_resource_file, ldv_2_ldv_param_4_1_default, ldv_2_size_cnt_write_size, ldv_2_ldv_param_4_3_default);
     193             :    /* LDV {"action": "WRITE", "type": "CALL_END"} */
     194             : 
     195             :    /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     196           2 :    ldv_free(ldv_2_ldv_param_4_1_default);
     197           2 :    ldv_free(ldv_2_ldv_param_4_3_default);
     198             :    /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     199             : 
     200             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Device file is opened, ready to read and write."} */
     201             :    /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     202             : 
     203             :    /* Jump to a subprocess 'call' initial state */
     204           1 :    goto ldv_call_2;
     205           1 :    break;
     206             :   }
     207           3 :   case 2: {
     208             :    /* LDV {"action": "RELEASE", "type": "CALL_BEGIN", "callback": true, "comment": "File structure is released. Invoke callback release from file_operations."} */
     209             :    /* LDV {"type": "CALLBACK", "call": "((& seq_release))(ldv_2_resource_inode, ldv_2_resource_file);", "comment": "release"} */
     210           2 :    ldv_character_driver_scenario_release_2_2(ldv_2_container_file_operations->release, ldv_2_resource_inode, ldv_2_resource_file);
     211             :    /* LDV {"action": "RELEASE", "type": "CALL_END"} */
     212             : 
     213             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_BEGIN", "comment": "Device appeared in the system."} */
     214             :    /* LDV {"action": "MAIN", "type": "SUBPROCESS_END"} */
     215             : 
     216             :    /* Jump to a subprocess 'main' initial state */
     217           1 :    goto ldv_main_2;
     218           1 :    break;
     219             :   }
     220           3 :   case 3: {
     221             :    /* LDV {"action": "PRE_CALL_5", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     222             :    /* LDV {"action": "PRE_CALL_5", "type": "CONDITION_END"} */
     223             : 
     224           4 :    if (ldv_undef_int()) {
     225             :     /* LDV {"action": "PRE_CALL_22", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     226           3 :     ldv_2_ldv_param_22_1_default = ldv_xmalloc_unknown_size(0);
     227           3 :     ldv_2_ldv_param_22_3_default = ldv_xmalloc_unknown_size(0);
     228             :     /* LDV {"action": "PRE_CALL_22", "type": "CONDITION_END"} */
     229             : 
     230             :     /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback read from file_operations."} */
     231             :     /* LDV {"type": "CALLBACK", "call": "((& seq_read))(ldv_2_resource_file, ldv_2_ldv_param_22_1_default, ldv_2_size_cnt_write_size, ldv_2_ldv_param_22_3_default);", "comment": "callback"} */
     232           2 :     ldv_character_driver_scenario_callback_2_22(ldv_2_callback_read, ldv_2_resource_file, ldv_2_ldv_param_22_1_default, ldv_2_size_cnt_write_size, ldv_2_ldv_param_22_3_default);
     233             :     /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     234             : 
     235             :     /* LDV {"action": "POST_CALL_22", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     236           2 :     ldv_free(ldv_2_ldv_param_22_1_default);
     237           2 :     ldv_free(ldv_2_ldv_param_22_3_default);
     238             :     /* LDV {"action": "POST_CALL_22", "type": "CONDITION_END"} */
     239             : 
     240             :    }
     241             :    else {
     242             :     /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Invoke callback llseek from file_operations."} */
     243             :     /* LDV {"type": "CALLBACK", "call": "((& seq_lseek))(ldv_2_resource_file, ldv_2_ldv_param_5_1_default, ldv_2_ldv_param_5_2_default);", "comment": "callback"} */
     244           2 :     ldv_character_driver_scenario_callback_2_5(ldv_2_callback_llseek, ldv_2_resource_file, ldv_2_ldv_param_5_1_default, ldv_2_ldv_param_5_2_default);
     245             :     /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     246             : 
     247             :    }
     248           2 :    break;
     249           1 :   }
     250           2 :   default: ldv_stop();
     251           1 :  }
     252           0 :  /* LDV {"action": "POST_CALL_5", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     253             :  /* LDV {"action": "POST_CALL_5", "type": "CONDITION_END"} */
     254           0 : 
     255             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Device file is opened, ready to read and write."} */
     256             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     257             : 
     258             :  /* Jump to a subprocess 'call' initial state */
     259           2 :  goto ldv_call_2;
     260             :  /* Jump to a subprocess 'call' initial state */
     261             :  goto ldv_call_2;
     262             :  /* End of the subprocess 'call' */
     263             :  return;
     264             :  /* LDV {"comment": "End of control function based on process 'character_driver_scenario(file_operations)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_character_driver_scenario_2"} */
     265             : }
     266             : 
     267             : /* AUX_FUNC_CALLBACK ldv_character_driver_scenario_probe_2_13 */
     268             : int ldv_character_driver_scenario_probe_2_13(int (*arg0)(struct inode *, struct file *), struct inode *arg1, struct file *arg2) {
     269           3 :  return ((& proc_scsi_devinfo_open))(arg1, arg2);
     270             : }
     271           1 : 
     272             : /* AUX_FUNC_CALLBACK ldv_character_driver_scenario_release_2_2 */
     273             : void ldv_character_driver_scenario_release_2_2(int (*arg0)(struct inode *, struct file *), struct inode *arg1, struct file *arg2) {
     274           1 :  ((& seq_release))(arg1, arg2);
     275           1 : }
     276             : 
     277             : /* AUX_FUNC_CALLBACK ldv_character_driver_scenario_write_2_4 */
     278             : void ldv_character_driver_scenario_write_2_4(ssize_t (*arg0)(struct file *, char *, size_t , loff_t *), struct file *arg1, char *arg2, long unsigned int arg3, long long int *arg4) {
     279           4 :  ((& proc_scsi_devinfo_write))(arg1, arg2, arg3, arg4);
     280           1 : }
     281             : 
     282             : /* AUX_FUNC ldv_dispatch_register_47_1 */
     283             : void ldv_dispatch_register_47_1(struct seq_file *arg0, struct seq_operations *arg1) {
     284             :  struct ldv_struct_traverse_kernel_items_scenario_10 *cf_arg_10;
     285           4 :  cf_arg_10 = ldv_xmalloc(sizeof(struct ldv_struct_traverse_kernel_items_scenario_10));
     286           2 :  cf_arg_10->arg0 = arg0;
     287           1 :  cf_arg_10->arg1 = arg1;
     288           2 :  ldv_traverse_kernel_items_scenario_10(cf_arg_10);
     289           1 :  return;
     290             : }
     291             : 
     292             : /* AUX_FUNC ldv_emg_seq_open */
     293             : int ldv_emg_seq_open(struct file *arg0, struct seq_operations *arg1) {
     294             :  /* LDV {"comment": "Control function 'seq_open'", "type": "CONTROL_FUNCTION_BEGIN", "function": "ldv_emg_seq_open"} */
     295           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     296           1 :  struct file *ldv_47_file_file;
     297           1 :  struct seq_operations *ldv_47_ops_seq_operations;
     298           1 :  struct seq_file *ldv_47_seq_file_seq_file;
     299             :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     300             :  /* LDV {"action": "ASSIGN", "type": "CONDITION_BEGIN", "comment": "Alloc memory for sequential file structure and initialize it."} */
     301           3 :  ldv_47_seq_file_seq_file = ldv_xmalloc(sizeof(struct seq_file));
     302           1 :  ldv_47_ops_seq_operations = arg1;
     303           1 :  ldv_47_file_file->private_data = ldv_47_seq_file_seq_file;
     304             :  /* LDV {"action": "ASSIGN", "type": "CONDITION_END"} */
     305             : 
     306             :  /* LDV {"action": "REGISTER", "type": "DISPATCH_BEGIN", "comment": "Register SEQ_OPERATIONS callbacks."} */
     307           2 :  ldv_dispatch_register_47_1(ldv_47_seq_file_seq_file, ldv_47_ops_seq_operations);
     308           1 :  /* LDV {"action": "REGISTER", "type": "DISPATCH_END"} */
     309             : 
     310             :  /* Exit function at a terminal state */
     311             :  /* End of the process */
     312             :  /* LDV {"comment": "End of control function based on process 'seq_open'", "type": "CONTROL_FUNCTION_END", "function": "ldv_emg_seq_open"} */
     313             : }
     314             : 
     315             : /* AUX_FUNC ldv_random_containerless_scenario_43 */
     316             : void ldv_random_containerless_scenario_43(void *arg0) {
     317             :  /* LDV {"thread": 43, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_kernel_param)'", "function": "ldv_random_containerless_scenario_43"} */
     318           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     319           1 :  int (*ldv_43_callback_get)(char *, struct kernel_param *);
     320           1 :  int (*ldv_43_callback_set)(char *, struct kernel_param *);
     321           1 :  struct kernel_param *ldv_43_container_struct_kernel_param;
     322           1 :  char *ldv_43_ldv_param_10_0_default;
     323           1 :  char *ldv_43_ldv_param_4_0_default;
     324           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     325           1 :  /* LDV {"action": "DEFAULT_REGISTER_8", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_KERNEL_PARAM callbacks invocations scenario."} */
     326           3 :  ldv_free(arg0);
     327           1 :  /* LDV {"action": "DEFAULT_REGISTER_8", "type": "RECEIVE_END"} */
     328             : 
     329             :  /* LDV {"action": "DEFAULT_ALLOC_8", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     330           3 :  ldv_43_container_struct_kernel_param = ldv_xmalloc_unknown_size(0);
     331             :  /* LDV {"action": "DEFAULT_ALLOC_8", "type": "CONDITION_END"} */
     332             : 
     333             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     334             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     335             : 
     336             :  /* Jump to a subprocess 'call' initial state */
     337           1 :  goto ldv_call_43;
     338             :  /* End of the process */
     339             :  return;
     340           1 : 
     341             :  /* Sbprocess call */
     342             :  ldv_call_43:
     343             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     344             : 
     345           4 :  if (ldv_undef_int()) {
     346             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     347           3 :   ldv_43_ldv_param_4_0_default = ldv_xmalloc_unknown_size(0);
     348             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     349             : 
     350           4 :   if (ldv_undef_int()) {
     351             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     352           3 :    ldv_43_ldv_param_10_0_default = ldv_xmalloc_unknown_size(0);
     353             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     354             : 
     355             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback set from kernel_param."} */
     356             :    /* LDV {"type": "CALLBACK", "call": "((& param_set_int))(ldv_43_ldv_param_10_0_default, ldv_43_container_struct_kernel_param);", "comment": "callback"} */
     357           2 :    ldv_random_containerless_scenario_callback_43_10(ldv_43_callback_set, ldv_43_ldv_param_10_0_default, ldv_43_container_struct_kernel_param);
     358             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     359             : 
     360             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     361           2 :    ldv_free(ldv_43_ldv_param_10_0_default);
     362             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     363             : 
     364             :   }
     365             :   else {
     366             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback get from kernel_param."} */
     367             :    /* LDV {"type": "CALLBACK", "call": "((& param_get_int))(ldv_43_ldv_param_4_0_default, ldv_43_container_struct_kernel_param);", "comment": "callback"} */
     368           2 :    ldv_random_containerless_scenario_callback_43_4(ldv_43_callback_get, ldv_43_ldv_param_4_0_default, ldv_43_container_struct_kernel_param);
     369             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     370             : 
     371             :   }
     372             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     373           4 :   ldv_free(ldv_43_ldv_param_4_0_default);
     374             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     375             : 
     376             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     377             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     378             : 
     379             :   /* Jump to a subprocess 'call' initial state */
     380           1 :   goto ldv_call_43;
     381             :  }
     382             :  else {
     383             :   /* LDV {"action": "DEFAULT_FREE_8", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     384           2 :   ldv_free(ldv_43_container_struct_kernel_param);
     385             :   /* LDV {"action": "DEFAULT_FREE_8", "type": "CONDITION_END"} */
     386             : 
     387             :   /* LDV {"action": "DEFAULT_DEREGISTER_8", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_KERNEL_PARAM callbacks invocations scenario."} */
     388             :   /* Skip a non-replicative signal receiving */
     389             :   /* LDV {"action": "DEFAULT_DEREGISTER_8", "type": "RECEIVE_END"} */
     390             : 
     391             :   /* Exit function at a terminal state */
     392           1 :   return;
     393             :  }
     394             :  /* End of the subprocess 'call' */
     395             :  return;
     396             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_kernel_param)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_43"} */
     397             : }
     398             : 
     399             : /* AUX_FUNC ldv_random_containerless_scenario_44 */
     400             : void ldv_random_containerless_scenario_44(void *arg0) {
     401             :  /* LDV {"thread": 44, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'random_containerless_scenario(struct_kernel_param)'", "function": "ldv_random_containerless_scenario_44"} */
     402           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     403           1 :  int (*ldv_44_callback_get)(char *, struct kernel_param *);
     404           1 :  int (*ldv_44_callback_set)(char *, struct kernel_param *);
     405           1 :  struct kernel_param *ldv_44_container_struct_kernel_param;
     406           1 :  char *ldv_44_ldv_param_10_0_default;
     407           1 :  char *ldv_44_ldv_param_4_0_default;
     408           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     409           1 :  /* LDV {"action": "DEFAULT_REGISTER_8", "type": "RECEIVE_BEGIN", "comment": "Begin STRUCT_KERNEL_PARAM callbacks invocations scenario."} */
     410           3 :  ldv_free(arg0);
     411           1 :  /* LDV {"action": "DEFAULT_REGISTER_8", "type": "RECEIVE_END"} */
     412             : 
     413             :  /* LDV {"action": "DEFAULT_ALLOC_8", "type": "CONDITION_BEGIN", "comment": "Allocate memory after default registration."} */
     414           3 :  ldv_44_container_struct_kernel_param = ldv_xmalloc_unknown_size(0);
     415             :  /* LDV {"action": "DEFAULT_ALLOC_8", "type": "CONDITION_END"} */
     416             : 
     417             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     418             :  /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     419             : 
     420             :  /* Jump to a subprocess 'call' initial state */
     421           1 :  goto ldv_call_44;
     422             :  /* End of the process */
     423             :  return;
     424           1 : 
     425             :  /* Sbprocess call */
     426             :  ldv_call_44:
     427             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     428             : 
     429           4 :  if (ldv_undef_int()) {
     430             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     431           3 :   ldv_44_ldv_param_4_0_default = ldv_xmalloc_unknown_size(0);
     432             :   /* LDV {"action": "PRE_CALL_4", "type": "CONDITION_END"} */
     433             : 
     434           4 :   if (ldv_undef_int()) {
     435             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     436           3 :    ldv_44_ldv_param_10_0_default = ldv_xmalloc_unknown_size(0);
     437             :    /* LDV {"action": "PRE_CALL_10", "type": "CONDITION_END"} */
     438             : 
     439             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback set from kernel_param."} */
     440             :    /* LDV {"type": "CALLBACK", "call": "((& param_set_copystring))(ldv_44_ldv_param_10_0_default, ldv_44_container_struct_kernel_param);", "comment": "callback"} */
     441           2 :    ldv_random_containerless_scenario_callback_44_10(ldv_44_callback_set, ldv_44_ldv_param_10_0_default, ldv_44_container_struct_kernel_param);
     442             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     443             : 
     444             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     445           2 :    ldv_free(ldv_44_ldv_param_10_0_default);
     446             :    /* LDV {"action": "POST_CALL_10", "type": "CONDITION_END"} */
     447             : 
     448             :   }
     449             :   else {
     450             :    /* LDV {"action": "CALLBACK", "type": "CALL_BEGIN", "callback": true, "comment": "Call any random callback. Invoke callback get from kernel_param."} */
     451             :    /* LDV {"type": "CALLBACK", "call": "((& param_get_string))(ldv_44_ldv_param_4_0_default, ldv_44_container_struct_kernel_param);", "comment": "callback"} */
     452           2 :    ldv_random_containerless_scenario_callback_44_4(ldv_44_callback_get, ldv_44_ldv_param_4_0_default, ldv_44_container_struct_kernel_param);
     453             :    /* LDV {"action": "CALLBACK", "type": "CALL_END"} */
     454             : 
     455             :   }
     456             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     457           4 :   ldv_free(ldv_44_ldv_param_4_0_default);
     458             :   /* LDV {"action": "POST_CALL_4", "type": "CONDITION_END"} */
     459             : 
     460             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_BEGIN", "comment": "Prepare to call a random callback or deregister the callbacks."} */
     461             :   /* LDV {"action": "CALL", "type": "SUBPROCESS_END"} */
     462             : 
     463             :   /* Jump to a subprocess 'call' initial state */
     464           1 :   goto ldv_call_44;
     465             :  }
     466             :  else {
     467             :   /* LDV {"action": "DEFAULT_FREE_8", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     468           2 :   ldv_free(ldv_44_container_struct_kernel_param);
     469             :   /* LDV {"action": "DEFAULT_FREE_8", "type": "CONDITION_END"} */
     470             : 
     471             :   /* LDV {"action": "DEFAULT_DEREGISTER_8", "type": "RECEIVE_BEGIN", "comment": "Finish STRUCT_KERNEL_PARAM callbacks invocations scenario."} */
     472             :   /* Skip a non-replicative signal receiving */
     473             :   /* LDV {"action": "DEFAULT_DEREGISTER_8", "type": "RECEIVE_END"} */
     474             : 
     475             :   /* Exit function at a terminal state */
     476           1 :   return;
     477             :  }
     478             :  /* End of the subprocess 'call' */
     479             :  return;
     480             :  /* LDV {"comment": "End of control function based on process 'random_containerless_scenario(struct_kernel_param)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_random_containerless_scenario_44"} */
     481             : }
     482             : 
     483             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_43_10 */
     484             : void ldv_random_containerless_scenario_callback_43_10(int (*arg0)(char *, struct kernel_param *), char *arg1, struct kernel_param *arg2) {
     485           1 :  ((& param_set_int))(arg1, arg2);
     486           1 : }
     487             : 
     488             : /* AUX_FUNC_CALLBACK ldv_random_containerless_scenario_callback_43_4 */
     489             : void ldv_random_containerless_scenario_callback_43_4(int (*arg0)(char *, struct kernel_param *), char *arg1, struct kernel_param *arg2) {
     490           1 :  ((& param_get_int))(arg1, arg2);
     491           1 : }
     492             : 
     493             : /* AUX_FUNC ldv_traverse_kernel_items_scenario_10 */
     494             : void ldv_traverse_kernel_items_scenario_10(void *arg0) {
     495             :  /* LDV {"thread": 10, "type": "CONTROL_FUNCTION_BEGIN", "comment": "Control function 'traverse_kernel_items_scenario(seq_operations)'", "function": "ldv_traverse_kernel_items_scenario_10"} */
     496           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_BEGIN", "comment": "Declare auxiliary variables."} */
     497           1 :  long long int *ldv_10_ldv_param_13_1_default;
     498           1 :  void *ldv_10_ldv_param_2_1_default;
     499           1 :  void *ldv_10_ldv_param_6_1_default;
     500           1 :  void *ldv_10_ldv_param_7_1_default;
     501           1 :  long long int *ldv_10_ldv_param_7_2_default;
     502           1 :  struct seq_operations *ldv_10_ops_seq_operations;
     503           1 :  void *ldv_10_ret_default;
     504           1 :  struct seq_file *ldv_10_seq_file_seq_file;
     505           1 :  /* Received labels */
     506           2 :  struct ldv_struct_traverse_kernel_items_scenario_10 *data = (struct ldv_struct_traverse_kernel_items_scenario_10*) arg0;
     507           1 : 
     508           1 :  /* LDV {"type": "CONTROL_FUNCTION_INIT_END", "comment": "Declare auxiliary variables."} */
     509             :  /* LDV {"action": "REGISTER", "type": "RECEIVE_BEGIN", "comment": "Begin SEQ_OPERATIONS callbacks invocations scenario."} */
     510             :  /* Assign recieved labels */
     511           2 :  if (data) {
     512           1 :   ldv_10_seq_file_seq_file = data->arg0;
     513           1 :   ldv_10_ops_seq_operations = data->arg1;
     514           2 :   ldv_free(data);
     515             :  }
     516             :  /* LDV {"action": "REGISTER", "type": "RECEIVE_END"} */
     517             : 
     518             :  /* LDV {"action": "START_STEP", "type": "SUBPROCESS_BEGIN", "comment": "Start sequence or do nothing."} */
     519             :  /* LDV {"action": "START_STEP", "type": "SUBPROCESS_END"} */
     520             : 
     521             :  /* Jump to a subprocess 'start_step' initial state */
     522           2 :  goto ldv_start_step_10;
     523             :  /* End of the process */
     524             :  return;
     525           1 : 
     526             :  /* Sbprocess start_step */
     527             :  ldv_start_step_10:
     528             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     529             : 
     530             :  /* LDV {"action": "PRE_CALL_13", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     531           3 :  ldv_10_ldv_param_13_1_default = ldv_xmalloc_unknown_size(0);
     532             :  /* LDV {"action": "PRE_CALL_13", "type": "CONDITION_END"} */
     533             : 
     534             :  /* LDV {"action": "START", "type": "CALL_BEGIN", "callback": true, "comment": "Initialize data for walking through a list of kernel items. Invoke callback start from seq_operations."} */
     535             :  /* LDV {"type": "CALLBACK", "call": "ldv_10_ret_default = ((& devinfo_seq_start))(ldv_10_seq_file_seq_file, ldv_10_ldv_param_13_1_default);", "comment": "start"} */
     536           2 :  ldv_10_ret_default = ldv_traverse_kernel_items_scenario_start_10_13(ldv_10_ops_seq_operations->start, ldv_10_seq_file_seq_file, ldv_10_ldv_param_13_1_default);
     537             :  /* LDV {"action": "START", "type": "CALL_END"} */
     538             : 
     539             :  /* LDV {"action": "POST_CALL_13", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     540           2 :  ldv_free(ldv_10_ldv_param_13_1_default);
     541             :  /* LDV {"action": "POST_CALL_13", "type": "CONDITION_END"} */
     542             : 
     543           4 :  if (ldv_undef_int()) {
     544             :   /* LDV {"action": "START_SUCCESS", "type": "CONDITION_BEGIN", "comment": "A new sequence is initialized successfully."} */
     545           2 :   ldv_assume(ldv_10_ret_default != 0);
     546             :   /* LDV {"action": "START_SUCCESS", "type": "CONDITION_END"} */
     547             : 
     548             :   /* LDV {"action": "NEXT_STEP", "type": "SUBPROCESS_BEGIN", "comment": "Continue iteration over kernel items."} */
     549             :   /* LDV {"action": "NEXT_STEP", "type": "SUBPROCESS_END"} */
     550             : 
     551             :   /* Jump to a subprocess 'next_step' initial state */
     552           1 :   goto ldv_next_step_10;
     553             :  }
     554             :  else {
     555             :   /* LDV {"action": "START_FAILED", "type": "CONDITION_BEGIN", "comment": "Failed to initialize a new sequence."} */
     556           2 :   ldv_assume(ldv_10_ret_default == 0);
     557             :   /* LDV {"action": "START_FAILED", "type": "CONDITION_END"} */
     558             : 
     559             :   /* LDV {"action": "DEFAULT_FREE_6", "type": "CONDITION_BEGIN", "comment": "Free memory before default deregistration."} */
     560           2 :   ldv_free(ldv_10_seq_file_seq_file);
     561             :   /* LDV {"action": "DEFAULT_FREE_6", "type": "CONDITION_END"} */
     562             : 
     563             :   /* LDV {"action": "DEFAULT_DEREGISTER_6", "type": "RECEIVE_BEGIN", "comment": "Finish SEQ_OPERATIONS callbacks invocations scenario."} */
     564             :   /* Skip a non-replicative signal receiving */
     565             :   /* LDV {"action": "DEFAULT_DEREGISTER_6", "type": "RECEIVE_END"} */
     566             : 
     567             :   /* Exit function at a terminal state */
     568           1 :   return;
     569             :  }
     570             :  /* End of the subprocess 'start_step' */
     571             :  return;
     572           1 : 
     573             :  /* Sbprocess next_step */
     574             :  ldv_next_step_10:
     575             :  /* LDV {"action": null, "type": "ARTIFICIAL", "comment": "Artificial state in scenario"} */
     576             : 
     577             :  /* LDV {"action": "PRE_CALL_7", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     578           2 :  ldv_10_ldv_param_7_1_default = ldv_xmalloc_unknown_size(0);
     579           3 :  ldv_10_ldv_param_7_2_default = ldv_xmalloc_unknown_size(0);
     580             :  /* LDV {"action": "PRE_CALL_7", "type": "CONDITION_END"} */
     581             : 
     582             :  /* LDV {"action": "NEXT", "type": "CALL_BEGIN", "callback": true, "comment": "Advance to the new item. Invoke callback next from seq_operations."} */
     583             :  /* LDV {"type": "CALLBACK", "call": "ldv_10_ret_default = ((& devinfo_seq_next))(ldv_10_seq_file_seq_file, ldv_10_ldv_param_7_1_default, ldv_10_ldv_param_7_2_default);", "comment": "next"} */
     584           2 :  ldv_10_ret_default = ldv_traverse_kernel_items_scenario_next_10_7(ldv_10_ops_seq_operations->next, ldv_10_seq_file_seq_file, ldv_10_ldv_param_7_1_default, ldv_10_ldv_param_7_2_default);
     585             :  /* LDV {"action": "NEXT", "type": "CALL_END"} */
     586             : 
     587             :  /* LDV {"action": "POST_CALL_7", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     588           2 :  ldv_free(ldv_10_ldv_param_7_1_default);
     589           2 :  ldv_free(ldv_10_ldv_param_7_2_default);
     590             :  /* LDV {"action": "POST_CALL_7", "type": "CONDITION_END"} */
     591             : 
     592             :  /* LDV {"action": "PRE_CALL_6", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     593           2 :  ldv_10_ldv_param_6_1_default = ldv_xmalloc_unknown_size(0);
     594             :  /* LDV {"action": "PRE_CALL_6", "type": "CONDITION_END"} */
     595             : 
     596             :  /* LDV {"action": "SHOW", "type": "CALL_BEGIN", "callback": true, "comment": "Show current item: put data into the seq_file output buffer. Invoke callback show from SEQ_OPERATIONS."} */
     597             :  /* LDV {"type": "CALLBACK", "call": "((proc_scsi_show))(ldv_10_seq_file_seq_file, ldv_10_ldv_param_6_1_default);", "comment": "show"} */
     598           2 :  ldv_traverse_kernel_items_scenario_show_10_6(ldv_10_ops_seq_operations->show, ldv_10_seq_file_seq_file, ldv_10_ldv_param_6_1_default);
     599             :  /* LDV {"action": "SHOW", "type": "CALL_END"} */
     600             : 
     601             :  /* LDV {"action": "POST_CALL_6", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     602           2 :  ldv_free(ldv_10_ldv_param_6_1_default);
     603             :  /* LDV {"action": "POST_CALL_6", "type": "CONDITION_END"} */
     604             : 
     605           4 :  if (ldv_undef_int()) {
     606             :   /* LDV {"action": "NEXT_SUCCESS", "type": "CONDITION_BEGIN", "comment": "More items to show are left."} */
     607           2 :   ldv_assume(ldv_10_ret_default != 0);
     608             :   /* LDV {"action": "NEXT_SUCCESS", "type": "CONDITION_END"} */
     609             : 
     610             :   /* LDV {"action": "NEXT_STEP", "type": "SUBPROCESS_BEGIN", "comment": "Continue iteration over kernel items."} */
     611             :   /* LDV {"action": "NEXT_STEP", "type": "SUBPROCESS_END"} */
     612             : 
     613             :   /* Jump to a subprocess 'next_step' initial state */
     614           1 :   goto ldv_next_step_10;
     615             :  }
     616             :  else {
     617             :   /* LDV {"action": "NEXT_FAIL", "type": "CONDITION_BEGIN", "comment": "The last kernel item is reached."} */
     618           2 :   ldv_assume(ldv_10_ret_default == 0);
     619             :   /* LDV {"action": "NEXT_FAIL", "type": "CONDITION_END"} */
     620             : 
     621             :   /* LDV {"action": "PRE_CALL_2", "type": "CONDITION_BEGIN", "comment": "Allocate memory for adhoc callback parameters."} */
     622           2 :   ldv_10_ldv_param_2_1_default = ldv_xmalloc_unknown_size(0);
     623             :   /* LDV {"action": "PRE_CALL_2", "type": "CONDITION_END"} */
     624             : 
     625             :   /* LDV {"action": "STOP", "type": "CALL_BEGIN", "callback": true, "comment": "End of the sequence is reached, do necessary cleanup. Invoke callback stop from seq_operations."} */
     626             :   /* LDV {"type": "CALLBACK", "call": "((& devinfo_seq_stop))(ldv_10_seq_file_seq_file, ldv_10_ldv_param_2_1_default);", "comment": "stop"} */
     627           2 :   ldv_traverse_kernel_items_scenario_stop_10_2(ldv_10_ops_seq_operations->stop, ldv_10_seq_file_seq_file, ldv_10_ldv_param_2_1_default);
     628             :   /* LDV {"action": "STOP", "type": "CALL_END"} */
     629             : 
     630             :   /* LDV {"action": "POST_CALL_2", "type": "CONDITION_BEGIN", "comment": "Free memory of adhoc callback parameters."} */
     631           2 :   ldv_free(ldv_10_ldv_param_2_1_default);
     632             :   /* LDV {"action": "POST_CALL_2", "type": "CONDITION_END"} */
     633             : 
     634             :   /* LDV {"action": "START_STEP", "type": "SUBPROCESS_BEGIN", "comment": "Start sequence or do nothing."} */
     635             :   /* LDV {"action": "START_STEP", "type": "SUBPROCESS_END"} */
     636             : 
     637             :   /* Jump to a subprocess 'start_step' initial state */
     638           1 :   goto ldv_start_step_10;
     639             :  }
     640             :  /* End of the subprocess 'next_step' */
     641             :  return;
     642             :  /* LDV {"comment": "End of control function based on process 'traverse_kernel_items_scenario(seq_operations)'", "type": "CONTROL_FUNCTION_END", "function": "ldv_traverse_kernel_items_scenario_10"} */
     643             : }
     644             : 
     645             : /* AUX_FUNC_CALLBACK ldv_traverse_kernel_items_scenario_next_10_7 */
     646             : void * ldv_traverse_kernel_items_scenario_next_10_7(void *(*arg0)(struct seq_file *, void *, loff_t *), struct seq_file *arg1, void *arg2, long long int *arg3) {
     647           3 :  return ((& devinfo_seq_next))(arg1, arg2, arg3);
     648             : }
     649             : 
     650             : /* AUX_FUNC_CALLBACK ldv_traverse_kernel_items_scenario_start_10_13 */
     651           1 : void * ldv_traverse_kernel_items_scenario_start_10_13(void *(*arg0)(struct seq_file *, loff_t *), struct seq_file *arg1, long long int *arg2) {
     652           5 :  return ((& devinfo_seq_start))(arg1, arg2);
     653             : }
     654             : 
     655           1 : /* AUX_FUNC_CALLBACK ldv_traverse_kernel_items_scenario_stop_10_2 */
     656             : void ldv_traverse_kernel_items_scenario_stop_10_2(void (*arg0)(struct seq_file *, void *), struct seq_file *arg1, void *arg2) {
     657           2 :  ((& devinfo_seq_stop))(arg1, arg2);
     658           1 : }
     659             : 
     660             : 
     661             : /* AUX_FUNC  ERR_PTR */
     662             : static inline void *ERR_PTR (long int error)
     663             : {
     664             : 
     665             :  return ldv_err_ptr(error);
     666             : }
     667             : 
     668             : /* AUX_FUNC  PTR_ERR */
     669             : static inline long int PTR_ERR (void const *ptr)
     670             : {
     671             : 
     672             :  return ldv_ptr_err(ptr);
     673             : }
     674             : 
     675             : /* AUX_FUNC  IS_ERR */
     676             : static inline long int IS_ERR (void const *ptr)
     677             : {
     678             : 
     679             :  return ldv_is_err(ptr);
     680             : }
     681             : 
     682             : /* AUX_FUNC  IS_ERR_OR_NULL */
     683             : static inline long int IS_ERR_OR_NULL (void const *ptr)
     684             : {
     685             : 
     686             :  return ldv_is_err_or_null(ptr);
     687             : }
     688             : 
     689             : /* AUX_FUNC  kzalloc */
     690             : static inline void *kzalloc (size_t size, gfp_t flags)
     691             : {
     692             : 
     693             :  return ldv_kzalloc(size, flags);
     694             : }
     695             : 
     696             : /* AUX_FUNC  ldv_seq_open_6 */
     697             : int ldv_seq_open_6 (struct file *ldv_func_arg1, struct seq_operations const *ldv_func_arg2)
     698             : {
     699           1 : 
     700             :  /* LDV {"type": "KERNEL_MODEL", "comment": "Perform the model code of the function 'seq_open'"} */
     701           3 :  return ldv_emg_seq_open(ldv_func_arg1, ldv_func_arg2);
     702             : }

Generated by: LCOV version 1.10