Bug

[В начало]

Ошибка # 78

Показать/спрятать трассу ошибок
Error trace
Function bodies
Blocks
  • Others...
    Function bodies without model function calls
    Initialization function calls
    Initialization function bodies
    Entry point
    Entry point body
    Function calls
    Skipped function calls
    Formal parameter names
    Declarations
    Assumes
    Assume conditions
    Returns
    Return values
    DEG initialization
    DEG function calls
    Model function calls
    Model function bodies
    Model asserts
    Model state changes
    Model function function calls
    Model function function bodies
    Model returns
    Model others
    Identation
    Line numbers
    Expand signs
-__BLAST_initialize_/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.1-rc1.tar.xz--X--152_1a/linux-4.1-rc1.tar.xz/csd_deg_dscv/12732/dscv_tempdir/dscv/rcv/152_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp/drivers/mcb/mcb-pci.o.i()
{
7 LDV_IO_MEMS = 0;
return ;
}
-__BLAST_initialize_/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.1-rc1.tar.xz--X--152_1a/linux-4.1-rc1.tar.xz/csd_deg_dscv/12732/dscv_tempdir/dscv/rcv/152_1a/main-ldv_main0_sequence_infinite_withcheck_stateful/preprocess/1-cpp//work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.1-rc1.tar.xz--X--152_1a/linux-4.1-rc1.tar.xz/csd_deg_dscv/12732/dscv_tempdir/rule-instrumentor/152_1a/common-model/ldv_common_model.o.i()
{
return ;
}
-entry_point
{
212 -ldv_s_mcb_pci_driver_pci_driver = 0;
LDV_IN_INTERRUPT = 1;
211 ldv_initialize() { /* Function call is skipped due to function is undefined */}
215 tmp___0 = nondet_int() { /* Function call is skipped due to function is undefined */}
215 assume(tmp___0 != 0);
219 tmp = nondet_int() { /* Function call is skipped due to function is undefined */}
221 assume(tmp == 0);
224 assume(ldv_s_mcb_pci_driver_pci_driver == 0);
229 -res_mcb_pci_probe_1 = mcb_pci_probe(var_group1 /* pdev */, var_mcb_pci_probe_1_p1 /* id */)
{
42 -tmp = devm_kzalloc(&(pdev)->dev /* dev */, 24 /* size */, 208 /* gfp */)
{
616 tmp = devm_kmalloc(dev, size, gfp | 32768) { /* Function call is skipped due to function is undefined */}
616 return tmp;
}
42 priv = tmp;
43 assume(priv != 0);
46 ret = pci_enable_device(pdev) { /* Function call is skipped due to function is undefined */}
47 assume(ret == 0);
52 *(priv).mapbase = *(pdev).resource[ 0 ].start;
53 assume(*(priv).mapbase != 0);
58 res = __request_region(&(iomem_resource), *(priv).mapbase, 512, "mcb_pci", 0) { /* Function call is skipped due to function is undefined */}
60 assume(res != 0);
66 -*(priv).base = ldv_ioremap_2(*(priv).mapbase /* offset */, 512 /* size */)
{
42 -tmp = ldv_io_mem_remap(offset /* addr */)
{
14 tmp = ldv_undef_ptr() { /* Function call is skipped due to function is undefined */}
14 ptr = tmp;
15 assume(ptr != 0);
16 LDV_IO_MEMS = LDV_IO_MEMS + 1;
17 __retres4 = ptr;
11 return __retres4;
}
42 return tmp;
}
67 assume(*(priv).base != 0);
73 flags = *(pdev).resource[ 0 ].flags;
74 assume(flags & 256 != 0);
75 ret = -524;
76 dev_err(&(pdev)->dev, "IO mapped PCI devices are not supported\n") { /* Function call is skipped due to function is undefined */}
105 pci_release_region(pdev, 0) { /* Function call is skipped due to function is undefined */}
107 pci_disable_device(pdev) { /* Function call is skipped due to function is undefined */}
108 __retres14 = ret;
34 return __retres14;
}
230 ldv_check_return_value(res_mcb_pci_probe_1) { /* Function call is skipped due to function is undefined */}
231 ldv_check_return_value_probe(res_mcb_pci_probe_1) { /* Function call is skipped due to function is undefined */}
232 assume(res_mcb_pci_probe_1 != 0);
267 -ldv_check_final_state()
{
30 assume(LDV_IO_MEMS != 0);
30 -ldv_error()
{
}
}
}
Source code
1 2 /* 3 * MEN Chameleon Bus. 4 * 5 * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de) 6 * Author: Johannes Thumshirn <johannes.thumshirn@men.de> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the Free 10 * Software Foundation; version 2 of the License. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/pci.h> 15 #include <linux/mcb.h> 16 17 #include "mcb-internal.h" 18 19 struct priv { 20 struct mcb_bus *bus; 21 phys_addr_t mapbase; 22 void __iomem *base; 23 }; 24 25 static int mcb_pci_get_irq(struct mcb_device *mdev) 26 { 27 struct mcb_bus *mbus = mdev->bus; 28 struct device *dev = mbus->carrier; 29 struct pci_dev *pdev = to_pci_dev(dev); 30 31 return pdev->irq; 32 } 33 34 static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 35 { 36 struct resource *res; 37 struct priv *priv; 38 int ret; 39 int num_cells; 40 unsigned long flags; 41 42 priv = devm_kzalloc(&pdev->dev, sizeof(struct priv), GFP_KERNEL); 43 if (!priv) 44 return -ENOMEM; 45 46 ret = pci_enable_device(pdev); 47 if (ret) { 48 dev_err(&pdev->dev, "Failed to enable PCI device\n"); 49 return -ENODEV; 50 } 51 52 priv->mapbase = pci_resource_start(pdev, 0); 53 if (!priv->mapbase) { 54 dev_err(&pdev->dev, "No PCI resource\n"); 55 goto out_disable; 56 } 57 58 res = request_mem_region(priv->mapbase, CHAM_HEADER_SIZE, 59 KBUILD_MODNAME); 60 if (!res) { 61 dev_err(&pdev->dev, "Failed to request PCI memory\n"); 62 ret = -EBUSY; 63 goto out_disable; 64 } 65 66 priv->base = ioremap(priv->mapbase, CHAM_HEADER_SIZE); 67 if (!priv->base) { 68 dev_err(&pdev->dev, "Cannot ioremap\n"); 69 ret = -ENOMEM; 70 goto out_release; 71 } 72 73 flags = pci_resource_flags(pdev, 0); 74 if (flags & IORESOURCE_IO) { 75 ret = -ENOTSUPP; 76 dev_err(&pdev->dev, 77 "IO mapped PCI devices are not supported\n"); 78 goto out_release; 79 } 80 81 pci_set_drvdata(pdev, priv); 82 83 priv->bus = mcb_alloc_bus(&pdev->dev); 84 if (IS_ERR(priv->bus)) { 85 ret = PTR_ERR(priv->bus); 86 goto out_iounmap; 87 } 88 89 priv->bus->get_irq = mcb_pci_get_irq; 90 91 ret = chameleon_parse_cells(priv->bus, priv->mapbase, priv->base); 92 if (ret < 0) 93 goto out_iounmap; 94 num_cells = ret; 95 96 dev_dbg(&pdev->dev, "Found %d cells\n", num_cells); 97 98 mcb_bus_add_devices(priv->bus); 99 100 return 0; 101 102 out_iounmap: 103 iounmap(priv->base); 104 out_release: 105 pci_release_region(pdev, 0); 106 out_disable: 107 pci_disable_device(pdev); 108 return ret; 109 } 110 111 static void mcb_pci_remove(struct pci_dev *pdev) 112 { 113 struct priv *priv = pci_get_drvdata(pdev); 114 115 mcb_release_bus(priv->bus); 116 117 iounmap(priv->base); 118 release_region(priv->mapbase, CHAM_HEADER_SIZE); 119 pci_disable_device(pdev); 120 } 121 122 static const struct pci_device_id mcb_pci_tbl[] = { 123 { PCI_DEVICE(PCI_VENDOR_ID_MEN, PCI_DEVICE_ID_MEN_CHAMELEON) }, 124 { 0 }, 125 }; 126 MODULE_DEVICE_TABLE(pci, mcb_pci_tbl); 127 128 static struct pci_driver mcb_pci_driver = { 129 .name = "mcb-pci", 130 .id_table = mcb_pci_tbl, 131 .probe = mcb_pci_probe, 132 .remove = mcb_pci_remove, 133 }; 134 135 module_pci_driver(mcb_pci_driver); 136 137 MODULE_AUTHOR("Johannes Thumshirn <johannes.thumshirn@men.de>"); 138 MODULE_LICENSE("GPL"); 139 MODULE_DESCRIPTION("MCB over PCI support"); 140 141 142 143 144 145 /* LDV_COMMENT_BEGIN_MAIN */ 146 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 147 148 /*###########################################################################*/ 149 150 /*############## Driver Environment Generator 0.2 output ####################*/ 151 152 /*###########################################################################*/ 153 154 155 156 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 157 void ldv_check_final_state(void); 158 159 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 160 void ldv_check_return_value(int res); 161 162 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 163 void ldv_check_return_value_probe(int res); 164 165 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 166 void ldv_initialize(void); 167 168 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 169 void ldv_handler_precall(void); 170 171 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 172 int nondet_int(void); 173 174 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 175 int LDV_IN_INTERRUPT; 176 177 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 178 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 179 180 181 182 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 183 /*============================= VARIABLE DECLARATION PART =============================*/ 184 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 185 /* content: static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)*/ 186 /* LDV_COMMENT_END_PREP */ 187 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mcb_pci_probe" */ 188 struct pci_dev * var_group1; 189 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mcb_pci_probe" */ 190 const struct pci_device_id * var_mcb_pci_probe_1_p1; 191 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "mcb_pci_probe" */ 192 static int res_mcb_pci_probe_1; 193 /* content: static void mcb_pci_remove(struct pci_dev *pdev)*/ 194 /* LDV_COMMENT_END_PREP */ 195 196 197 198 199 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 200 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 201 /*============================= VARIABLE INITIALIZING PART =============================*/ 202 LDV_IN_INTERRUPT=1; 203 204 205 206 207 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 208 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 209 /*============================= FUNCTION CALL SECTION =============================*/ 210 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 211 ldv_initialize(); 212 int ldv_s_mcb_pci_driver_pci_driver = 0; 213 214 215 while( nondet_int() 216 || !(ldv_s_mcb_pci_driver_pci_driver == 0) 217 ) { 218 219 switch(nondet_int()) { 220 221 case 0: { 222 223 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 224 if(ldv_s_mcb_pci_driver_pci_driver==0) { 225 226 /* content: static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)*/ 227 /* LDV_COMMENT_END_PREP */ 228 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "mcb_pci_driver". Standart function test for correct return result. */ 229 res_mcb_pci_probe_1 = mcb_pci_probe( var_group1, var_mcb_pci_probe_1_p1); 230 ldv_check_return_value(res_mcb_pci_probe_1); 231 ldv_check_return_value_probe(res_mcb_pci_probe_1); 232 if(res_mcb_pci_probe_1) 233 goto ldv_module_exit; 234 ldv_s_mcb_pci_driver_pci_driver++; 235 236 } 237 238 } 239 240 break; 241 case 1: { 242 243 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 244 if(ldv_s_mcb_pci_driver_pci_driver==1) { 245 246 /* content: static void mcb_pci_remove(struct pci_dev *pdev)*/ 247 /* LDV_COMMENT_END_PREP */ 248 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "mcb_pci_driver" */ 249 ldv_handler_precall(); 250 mcb_pci_remove( var_group1); 251 ldv_s_mcb_pci_driver_pci_driver=0; 252 253 } 254 255 } 256 257 break; 258 default: break; 259 260 } 261 262 } 263 264 ldv_module_exit: 265 266 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 267 ldv_final: ldv_check_final_state(); 268 269 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 270 return; 271 272 } 273 #endif 274 275 /* LDV_COMMENT_END_MAIN */
1 2 #include <asm/io.h> 3 #include <verifier/rcv.h> 4 #include <verifier/set.h> 5 6 7 Set LDV_IO_MEMS = 0; 8 9 10 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_io_mem_remap') Create some io-memory map for specified address */ 11 void *ldv_io_mem_remap(void *addr) { 12 ldv_assert(ldv_set_not_contains(LDV_IO_MEMS, addr)); 13 14 void *ptr = ldv_undef_ptr(); 15 if (ptr != NULL) { 16 ldv_set_add(LDV_IO_MEMS, addr); 17 return ptr; 18 } 19 return NULL; 20 } 21 22 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_io_mem_unmap') Delete some io-memory map for specified address */ 23 void ldv_io_mem_unmap(const volatile void *addr) { 24 ldv_assert(ldv_set_contains(LDV_IO_MEMS, addr)); 25 ldv_set_remove(LDV_IO_MEMS, addr); 26 } 27 28 /* LDV_COMMENT_MODEL_FUNCTION_DEFINITION(name='ldv_check_final_state') Check that all io-memory map are unmapped properly */ 29 void ldv_check_final_state(void) { 30 ldv_assert(ldv_set_is_empty(LDV_IO_MEMS)); 31 } 32 #line 1 "/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.1-rc1.tar.xz--X--152_1a/linux-4.1-rc1.tar.xz/csd_deg_dscv/12732/dscv_tempdir/dscv/ri/152_1a/drivers/mcb/mcb-pci.c" 33 34 /* 35 * MEN Chameleon Bus. 36 * 37 * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de) 38 * Author: Johannes Thumshirn <johannes.thumshirn@men.de> 39 * 40 * This program is free software; you can redistribute it and/or modify it 41 * under the terms of the GNU General Public License as published by the Free 42 * Software Foundation; version 2 of the License. 43 */ 44 45 #include <linux/module.h> 46 #include <linux/pci.h> 47 #include <linux/mcb.h> 48 49 #include "mcb-internal.h" 50 51 struct priv { 52 struct mcb_bus *bus; 53 phys_addr_t mapbase; 54 void __iomem *base; 55 }; 56 57 static int mcb_pci_get_irq(struct mcb_device *mdev) 58 { 59 struct mcb_bus *mbus = mdev->bus; 60 struct device *dev = mbus->carrier; 61 struct pci_dev *pdev = to_pci_dev(dev); 62 63 return pdev->irq; 64 } 65 66 static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 67 { 68 struct resource *res; 69 struct priv *priv; 70 int ret; 71 int num_cells; 72 unsigned long flags; 73 74 priv = devm_kzalloc(&pdev->dev, sizeof(struct priv), GFP_KERNEL); 75 if (!priv) 76 return -ENOMEM; 77 78 ret = pci_enable_device(pdev); 79 if (ret) { 80 dev_err(&pdev->dev, "Failed to enable PCI device\n"); 81 return -ENODEV; 82 } 83 84 priv->mapbase = pci_resource_start(pdev, 0); 85 if (!priv->mapbase) { 86 dev_err(&pdev->dev, "No PCI resource\n"); 87 goto out_disable; 88 } 89 90 res = request_mem_region(priv->mapbase, CHAM_HEADER_SIZE, 91 KBUILD_MODNAME); 92 if (!res) { 93 dev_err(&pdev->dev, "Failed to request PCI memory\n"); 94 ret = -EBUSY; 95 goto out_disable; 96 } 97 98 priv->base = ioremap(priv->mapbase, CHAM_HEADER_SIZE); 99 if (!priv->base) { 100 dev_err(&pdev->dev, "Cannot ioremap\n"); 101 ret = -ENOMEM; 102 goto out_release; 103 } 104 105 flags = pci_resource_flags(pdev, 0); 106 if (flags & IORESOURCE_IO) { 107 ret = -ENOTSUPP; 108 dev_err(&pdev->dev, 109 "IO mapped PCI devices are not supported\n"); 110 goto out_release; 111 } 112 113 pci_set_drvdata(pdev, priv); 114 115 priv->bus = mcb_alloc_bus(&pdev->dev); 116 if (IS_ERR(priv->bus)) { 117 ret = PTR_ERR(priv->bus); 118 goto out_iounmap; 119 } 120 121 priv->bus->get_irq = mcb_pci_get_irq; 122 123 ret = chameleon_parse_cells(priv->bus, priv->mapbase, priv->base); 124 if (ret < 0) 125 goto out_iounmap; 126 num_cells = ret; 127 128 dev_dbg(&pdev->dev, "Found %d cells\n", num_cells); 129 130 mcb_bus_add_devices(priv->bus); 131 132 return 0; 133 134 out_iounmap: 135 iounmap(priv->base); 136 out_release: 137 pci_release_region(pdev, 0); 138 out_disable: 139 pci_disable_device(pdev); 140 return ret; 141 } 142 143 static void mcb_pci_remove(struct pci_dev *pdev) 144 { 145 struct priv *priv = pci_get_drvdata(pdev); 146 147 mcb_release_bus(priv->bus); 148 149 iounmap(priv->base); 150 release_region(priv->mapbase, CHAM_HEADER_SIZE); 151 pci_disable_device(pdev); 152 } 153 154 static const struct pci_device_id mcb_pci_tbl[] = { 155 { PCI_DEVICE(PCI_VENDOR_ID_MEN, PCI_DEVICE_ID_MEN_CHAMELEON) }, 156 { 0 }, 157 }; 158 MODULE_DEVICE_TABLE(pci, mcb_pci_tbl); 159 160 static struct pci_driver mcb_pci_driver = { 161 .name = "mcb-pci", 162 .id_table = mcb_pci_tbl, 163 .probe = mcb_pci_probe, 164 .remove = mcb_pci_remove, 165 }; 166 167 module_pci_driver(mcb_pci_driver); 168 169 MODULE_AUTHOR("Johannes Thumshirn <johannes.thumshirn@men.de>"); 170 MODULE_LICENSE("GPL"); 171 MODULE_DESCRIPTION("MCB over PCI support"); 172 173 174 175 176 177 /* LDV_COMMENT_BEGIN_MAIN */ 178 #ifdef LDV_MAIN0_sequence_infinite_withcheck_stateful 179 180 /*###########################################################################*/ 181 182 /*############## Driver Environment Generator 0.2 output ####################*/ 183 184 /*###########################################################################*/ 185 186 187 188 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 189 void ldv_check_final_state(void); 190 191 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 192 void ldv_check_return_value(int res); 193 194 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 195 void ldv_check_return_value_probe(int res); 196 197 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 198 void ldv_initialize(void); 199 200 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 201 void ldv_handler_precall(void); 202 203 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 204 int nondet_int(void); 205 206 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 207 int LDV_IN_INTERRUPT; 208 209 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 210 void ldv_main0_sequence_infinite_withcheck_stateful(void) { 211 212 213 214 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 215 /*============================= VARIABLE DECLARATION PART =============================*/ 216 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 217 /* content: static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)*/ 218 /* LDV_COMMENT_END_PREP */ 219 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mcb_pci_probe" */ 220 struct pci_dev * var_group1; 221 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "mcb_pci_probe" */ 222 const struct pci_device_id * var_mcb_pci_probe_1_p1; 223 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "mcb_pci_probe" */ 224 static int res_mcb_pci_probe_1; 225 /* content: static void mcb_pci_remove(struct pci_dev *pdev)*/ 226 /* LDV_COMMENT_END_PREP */ 227 228 229 230 231 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 232 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 233 /*============================= VARIABLE INITIALIZING PART =============================*/ 234 LDV_IN_INTERRUPT=1; 235 236 237 238 239 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 240 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 241 /*============================= FUNCTION CALL SECTION =============================*/ 242 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 243 ldv_initialize(); 244 int ldv_s_mcb_pci_driver_pci_driver = 0; 245 246 247 while( nondet_int() 248 || !(ldv_s_mcb_pci_driver_pci_driver == 0) 249 ) { 250 251 switch(nondet_int()) { 252 253 case 0: { 254 255 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 256 if(ldv_s_mcb_pci_driver_pci_driver==0) { 257 258 /* content: static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)*/ 259 /* LDV_COMMENT_END_PREP */ 260 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "mcb_pci_driver". Standart function test for correct return result. */ 261 res_mcb_pci_probe_1 = mcb_pci_probe( var_group1, var_mcb_pci_probe_1_p1); 262 ldv_check_return_value(res_mcb_pci_probe_1); 263 ldv_check_return_value_probe(res_mcb_pci_probe_1); 264 if(res_mcb_pci_probe_1) 265 goto ldv_module_exit; 266 ldv_s_mcb_pci_driver_pci_driver++; 267 268 } 269 270 } 271 272 break; 273 case 1: { 274 275 /** STRUCT: struct type: pci_driver, struct name: mcb_pci_driver **/ 276 if(ldv_s_mcb_pci_driver_pci_driver==1) { 277 278 /* content: static void mcb_pci_remove(struct pci_dev *pdev)*/ 279 /* LDV_COMMENT_END_PREP */ 280 /* LDV_COMMENT_FUNCTION_CALL Function from field "remove" from driver structure with callbacks "mcb_pci_driver" */ 281 ldv_handler_precall(); 282 mcb_pci_remove( var_group1); 283 ldv_s_mcb_pci_driver_pci_driver=0; 284 285 } 286 287 } 288 289 break; 290 default: break; 291 292 } 293 294 } 295 296 ldv_module_exit: 297 298 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 299 ldv_final: ldv_check_final_state(); 300 301 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 302 return; 303 304 } 305 #endif 306 307 /* LDV_COMMENT_END_MAIN */ 308 309 #line 32 "/work/ldvuser/ref_launch/work/current--X--drivers--X--defaultlinux-4.1-rc1.tar.xz--X--152_1a/linux-4.1-rc1.tar.xz/csd_deg_dscv/12732/dscv_tempdir/dscv/ri/152_1a/drivers/mcb/mcb-pci.o.c.prepared"
1 /* 2 * device.h - generic, centralized driver model 3 * 4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org> 5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de> 6 * Copyright (c) 2008-2009 Novell Inc. 7 * 8 * This file is released under the GPLv2 9 * 10 * See Documentation/driver-model/ for more information. 11 */ 12 13 #ifndef _DEVICE_H_ 14 #define _DEVICE_H_ 15 16 #include <linux/ioport.h> 17 #include <linux/kobject.h> 18 #include <linux/klist.h> 19 #include <linux/list.h> 20 #include <linux/lockdep.h> 21 #include <linux/compiler.h> 22 #include <linux/types.h> 23 #include <linux/mutex.h> 24 #include <linux/pinctrl/devinfo.h> 25 #include <linux/pm.h> 26 #include <linux/atomic.h> 27 #include <linux/ratelimit.h> 28 #include <linux/uidgid.h> 29 #include <linux/gfp.h> 30 #include <asm/device.h> 31 32 struct device; 33 struct device_private; 34 struct device_driver; 35 struct driver_private; 36 struct module; 37 struct class; 38 struct subsys_private; 39 struct bus_type; 40 struct device_node; 41 struct fwnode_handle; 42 struct iommu_ops; 43 struct iommu_group; 44 45 struct bus_attribute { 46 struct attribute attr; 47 ssize_t (*show)(struct bus_type *bus, char *buf); 48 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); 49 }; 50 51 #define BUS_ATTR(_name, _mode, _show, _store) \ 52 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) 53 #define BUS_ATTR_RW(_name) \ 54 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name) 55 #define BUS_ATTR_RO(_name) \ 56 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name) 57 58 extern int __must_check bus_create_file(struct bus_type *, 59 struct bus_attribute *); 60 extern void bus_remove_file(struct bus_type *, struct bus_attribute *); 61 62 /** 63 * struct bus_type - The bus type of the device 64 * 65 * @name: The name of the bus. 66 * @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id). 67 * @dev_root: Default device to use as the parent. 68 * @dev_attrs: Default attributes of the devices on the bus. 69 * @bus_groups: Default attributes of the bus. 70 * @dev_groups: Default attributes of the devices on the bus. 71 * @drv_groups: Default attributes of the device drivers on the bus. 72 * @match: Called, perhaps multiple times, whenever a new device or driver 73 * is added for this bus. It should return a nonzero value if the 74 * given device can be handled by the given driver. 75 * @uevent: Called when a device is added, removed, or a few other things 76 * that generate uevents to add the environment variables. 77 * @probe: Called when a new device or driver add to this bus, and callback 78 * the specific driver's probe to initial the matched device. 79 * @remove: Called when a device removed from this bus. 80 * @shutdown: Called at shut-down time to quiesce the device. 81 * 82 * @online: Called to put the device back online (after offlining it). 83 * @offline: Called to put the device offline for hot-removal. May fail. 84 * 85 * @suspend: Called when a device on this bus wants to go to sleep mode. 86 * @resume: Called to bring a device on this bus out of sleep mode. 87 * @pm: Power management operations of this bus, callback the specific 88 * device driver's pm-ops. 89 * @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU 90 * driver implementations to a bus and allow the driver to do 91 * bus-specific setup 92 * @p: The private data of the driver core, only the driver core can 93 * touch this. 94 * @lock_key: Lock class key for use by the lock validator 95 * 96 * A bus is a channel between the processor and one or more devices. For the 97 * purposes of the device model, all devices are connected via a bus, even if 98 * it is an internal, virtual, "platform" bus. Buses can plug into each other. 99 * A USB controller is usually a PCI device, for example. The device model 100 * represents the actual connections between buses and the devices they control. 101 * A bus is represented by the bus_type structure. It contains the name, the 102 * default attributes, the bus' methods, PM operations, and the driver core's 103 * private data. 104 */ 105 struct bus_type { 106 const char *name; 107 const char *dev_name; 108 struct device *dev_root; 109 struct device_attribute *dev_attrs; /* use dev_groups instead */ 110 const struct attribute_group **bus_groups; 111 const struct attribute_group **dev_groups; 112 const struct attribute_group **drv_groups; 113 114 int (*match)(struct device *dev, struct device_driver *drv); 115 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 116 int (*probe)(struct device *dev); 117 int (*remove)(struct device *dev); 118 void (*shutdown)(struct device *dev); 119 120 int (*online)(struct device *dev); 121 int (*offline)(struct device *dev); 122 123 int (*suspend)(struct device *dev, pm_message_t state); 124 int (*resume)(struct device *dev); 125 126 const struct dev_pm_ops *pm; 127 128 const struct iommu_ops *iommu_ops; 129 130 struct subsys_private *p; 131 struct lock_class_key lock_key; 132 }; 133 134 extern int __must_check bus_register(struct bus_type *bus); 135 136 extern void bus_unregister(struct bus_type *bus); 137 138 extern int __must_check bus_rescan_devices(struct bus_type *bus); 139 140 /* iterator helpers for buses */ 141 struct subsys_dev_iter { 142 struct klist_iter ki; 143 const struct device_type *type; 144 }; 145 void subsys_dev_iter_init(struct subsys_dev_iter *iter, 146 struct bus_type *subsys, 147 struct device *start, 148 const struct device_type *type); 149 struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter); 150 void subsys_dev_iter_exit(struct subsys_dev_iter *iter); 151 152 int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, 153 int (*fn)(struct device *dev, void *data)); 154 struct device *bus_find_device(struct bus_type *bus, struct device *start, 155 void *data, 156 int (*match)(struct device *dev, void *data)); 157 struct device *bus_find_device_by_name(struct bus_type *bus, 158 struct device *start, 159 const char *name); 160 struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id, 161 struct device *hint); 162 int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, 163 void *data, int (*fn)(struct device_driver *, void *)); 164 void bus_sort_breadthfirst(struct bus_type *bus, 165 int (*compare)(const struct device *a, 166 const struct device *b)); 167 /* 168 * Bus notifiers: Get notified of addition/removal of devices 169 * and binding/unbinding of drivers to devices. 170 * In the long run, it should be a replacement for the platform 171 * notify hooks. 172 */ 173 struct notifier_block; 174 175 extern int bus_register_notifier(struct bus_type *bus, 176 struct notifier_block *nb); 177 extern int bus_unregister_notifier(struct bus_type *bus, 178 struct notifier_block *nb); 179 180 /* All 4 notifers below get called with the target struct device * 181 * as an argument. Note that those functions are likely to be called 182 * with the device lock held in the core, so be careful. 183 */ 184 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ 185 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device to be removed */ 186 #define BUS_NOTIFY_REMOVED_DEVICE 0x00000003 /* device removed */ 187 #define BUS_NOTIFY_BIND_DRIVER 0x00000004 /* driver about to be 188 bound */ 189 #define BUS_NOTIFY_BOUND_DRIVER 0x00000005 /* driver bound to device */ 190 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000006 /* driver about to be 191 unbound */ 192 #define BUS_NOTIFY_UNBOUND_DRIVER 0x00000007 /* driver is unbound 193 from the device */ 194 195 extern struct kset *bus_get_kset(struct bus_type *bus); 196 extern struct klist *bus_get_device_klist(struct bus_type *bus); 197 198 /** 199 * struct device_driver - The basic device driver structure 200 * @name: Name of the device driver. 201 * @bus: The bus which the device of this driver belongs to. 202 * @owner: The module owner. 203 * @mod_name: Used for built-in modules. 204 * @suppress_bind_attrs: Disables bind/unbind via sysfs. 205 * @of_match_table: The open firmware table. 206 * @acpi_match_table: The ACPI match table. 207 * @probe: Called to query the existence of a specific device, 208 * whether this driver can work with it, and bind the driver 209 * to a specific device. 210 * @remove: Called when the device is removed from the system to 211 * unbind a device from this driver. 212 * @shutdown: Called at shut-down time to quiesce the device. 213 * @suspend: Called to put the device to sleep mode. Usually to a 214 * low power state. 215 * @resume: Called to bring a device from sleep mode. 216 * @groups: Default attributes that get created by the driver core 217 * automatically. 218 * @pm: Power management operations of the device which matched 219 * this driver. 220 * @p: Driver core's private data, no one other than the driver 221 * core can touch this. 222 * 223 * The device driver-model tracks all of the drivers known to the system. 224 * The main reason for this tracking is to enable the driver core to match 225 * up drivers with new devices. Once drivers are known objects within the 226 * system, however, a number of other things become possible. Device drivers 227 * can export information and configuration variables that are independent 228 * of any specific device. 229 */ 230 struct device_driver { 231 const char *name; 232 struct bus_type *bus; 233 234 struct module *owner; 235 const char *mod_name; /* used for built-in modules */ 236 237 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ 238 239 const struct of_device_id *of_match_table; 240 const struct acpi_device_id *acpi_match_table; 241 242 int (*probe) (struct device *dev); 243 int (*remove) (struct device *dev); 244 void (*shutdown) (struct device *dev); 245 int (*suspend) (struct device *dev, pm_message_t state); 246 int (*resume) (struct device *dev); 247 const struct attribute_group **groups; 248 249 const struct dev_pm_ops *pm; 250 251 struct driver_private *p; 252 }; 253 254 255 extern int __must_check driver_register(struct device_driver *drv); 256 extern void driver_unregister(struct device_driver *drv); 257 258 extern struct device_driver *driver_find(const char *name, 259 struct bus_type *bus); 260 extern int driver_probe_done(void); 261 extern void wait_for_device_probe(void); 262 263 264 /* sysfs interface for exporting driver attributes */ 265 266 struct driver_attribute { 267 struct attribute attr; 268 ssize_t (*show)(struct device_driver *driver, char *buf); 269 ssize_t (*store)(struct device_driver *driver, const char *buf, 270 size_t count); 271 }; 272 273 #define DRIVER_ATTR(_name, _mode, _show, _store) \ 274 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store) 275 #define DRIVER_ATTR_RW(_name) \ 276 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name) 277 #define DRIVER_ATTR_RO(_name) \ 278 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name) 279 #define DRIVER_ATTR_WO(_name) \ 280 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name) 281 282 extern int __must_check driver_create_file(struct device_driver *driver, 283 const struct driver_attribute *attr); 284 extern void driver_remove_file(struct device_driver *driver, 285 const struct driver_attribute *attr); 286 287 extern int __must_check driver_for_each_device(struct device_driver *drv, 288 struct device *start, 289 void *data, 290 int (*fn)(struct device *dev, 291 void *)); 292 struct device *driver_find_device(struct device_driver *drv, 293 struct device *start, void *data, 294 int (*match)(struct device *dev, void *data)); 295 296 /** 297 * struct subsys_interface - interfaces to device functions 298 * @name: name of the device function 299 * @subsys: subsytem of the devices to attach to 300 * @node: the list of functions registered at the subsystem 301 * @add_dev: device hookup to device function handler 302 * @remove_dev: device hookup to device function handler 303 * 304 * Simple interfaces attached to a subsystem. Multiple interfaces can 305 * attach to a subsystem and its devices. Unlike drivers, they do not 306 * exclusively claim or control devices. Interfaces usually represent 307 * a specific functionality of a subsystem/class of devices. 308 */ 309 struct subsys_interface { 310 const char *name; 311 struct bus_type *subsys; 312 struct list_head node; 313 int (*add_dev)(struct device *dev, struct subsys_interface *sif); 314 int (*remove_dev)(struct device *dev, struct subsys_interface *sif); 315 }; 316 317 int subsys_interface_register(struct subsys_interface *sif); 318 void subsys_interface_unregister(struct subsys_interface *sif); 319 320 int subsys_system_register(struct bus_type *subsys, 321 const struct attribute_group **groups); 322 int subsys_virtual_register(struct bus_type *subsys, 323 const struct attribute_group **groups); 324 325 /** 326 * struct class - device classes 327 * @name: Name of the class. 328 * @owner: The module owner. 329 * @class_attrs: Default attributes of this class. 330 * @dev_groups: Default attributes of the devices that belong to the class. 331 * @dev_kobj: The kobject that represents this class and links it into the hierarchy. 332 * @dev_uevent: Called when a device is added, removed from this class, or a 333 * few other things that generate uevents to add the environment 334 * variables. 335 * @devnode: Callback to provide the devtmpfs. 336 * @class_release: Called to release this class. 337 * @dev_release: Called to release the device. 338 * @suspend: Used to put the device to sleep mode, usually to a low power 339 * state. 340 * @resume: Used to bring the device from the sleep mode. 341 * @ns_type: Callbacks so sysfs can detemine namespaces. 342 * @namespace: Namespace of the device belongs to this class. 343 * @pm: The default device power management operations of this class. 344 * @p: The private data of the driver core, no one other than the 345 * driver core can touch this. 346 * 347 * A class is a higher-level view of a device that abstracts out low-level 348 * implementation details. Drivers may see a SCSI disk or an ATA disk, but, 349 * at the class level, they are all simply disks. Classes allow user space 350 * to work with devices based on what they do, rather than how they are 351 * connected or how they work. 352 */ 353 struct class { 354 const char *name; 355 struct module *owner; 356 357 struct class_attribute *class_attrs; 358 const struct attribute_group **dev_groups; 359 struct kobject *dev_kobj; 360 361 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); 362 char *(*devnode)(struct device *dev, umode_t *mode); 363 364 void (*class_release)(struct class *class); 365 void (*dev_release)(struct device *dev); 366 367 int (*suspend)(struct device *dev, pm_message_t state); 368 int (*resume)(struct device *dev); 369 370 const struct kobj_ns_type_operations *ns_type; 371 const void *(*namespace)(struct device *dev); 372 373 const struct dev_pm_ops *pm; 374 375 struct subsys_private *p; 376 }; 377 378 struct class_dev_iter { 379 struct klist_iter ki; 380 const struct device_type *type; 381 }; 382 383 extern struct kobject *sysfs_dev_block_kobj; 384 extern struct kobject *sysfs_dev_char_kobj; 385 extern int __must_check __class_register(struct class *class, 386 struct lock_class_key *key); 387 extern void class_unregister(struct class *class); 388 389 /* This is a #define to keep the compiler from merging different 390 * instances of the __key variable */ 391 #define class_register(class) \ 392 ({ \ 393 static struct lock_class_key __key; \ 394 __class_register(class, &__key); \ 395 }) 396 397 struct class_compat; 398 struct class_compat *class_compat_register(const char *name); 399 void class_compat_unregister(struct class_compat *cls); 400 int class_compat_create_link(struct class_compat *cls, struct device *dev, 401 struct device *device_link); 402 void class_compat_remove_link(struct class_compat *cls, struct device *dev, 403 struct device *device_link); 404 405 extern void class_dev_iter_init(struct class_dev_iter *iter, 406 struct class *class, 407 struct device *start, 408 const struct device_type *type); 409 extern struct device *class_dev_iter_next(struct class_dev_iter *iter); 410 extern void class_dev_iter_exit(struct class_dev_iter *iter); 411 412 extern int class_for_each_device(struct class *class, struct device *start, 413 void *data, 414 int (*fn)(struct device *dev, void *data)); 415 extern struct device *class_find_device(struct class *class, 416 struct device *start, const void *data, 417 int (*match)(struct device *, const void *)); 418 419 struct class_attribute { 420 struct attribute attr; 421 ssize_t (*show)(struct class *class, struct class_attribute *attr, 422 char *buf); 423 ssize_t (*store)(struct class *class, struct class_attribute *attr, 424 const char *buf, size_t count); 425 }; 426 427 #define CLASS_ATTR(_name, _mode, _show, _store) \ 428 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) 429 #define CLASS_ATTR_RW(_name) \ 430 struct class_attribute class_attr_##_name = __ATTR_RW(_name) 431 #define CLASS_ATTR_RO(_name) \ 432 struct class_attribute class_attr_##_name = __ATTR_RO(_name) 433 434 extern int __must_check class_create_file_ns(struct class *class, 435 const struct class_attribute *attr, 436 const void *ns); 437 extern void class_remove_file_ns(struct class *class, 438 const struct class_attribute *attr, 439 const void *ns); 440 441 static inline int __must_check class_create_file(struct class *class, 442 const struct class_attribute *attr) 443 { 444 return class_create_file_ns(class, attr, NULL); 445 } 446 447 static inline void class_remove_file(struct class *class, 448 const struct class_attribute *attr) 449 { 450 return class_remove_file_ns(class, attr, NULL); 451 } 452 453 /* Simple class attribute that is just a static string */ 454 struct class_attribute_string { 455 struct class_attribute attr; 456 char *str; 457 }; 458 459 /* Currently read-only only */ 460 #define _CLASS_ATTR_STRING(_name, _mode, _str) \ 461 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } 462 #define CLASS_ATTR_STRING(_name, _mode, _str) \ 463 struct class_attribute_string class_attr_##_name = \ 464 _CLASS_ATTR_STRING(_name, _mode, _str) 465 466 extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, 467 char *buf); 468 469 struct class_interface { 470 struct list_head node; 471 struct class *class; 472 473 int (*add_dev) (struct device *, struct class_interface *); 474 void (*remove_dev) (struct device *, struct class_interface *); 475 }; 476 477 extern int __must_check class_interface_register(struct class_interface *); 478 extern void class_interface_unregister(struct class_interface *); 479 480 extern struct class * __must_check __class_create(struct module *owner, 481 const char *name, 482 struct lock_class_key *key); 483 extern void class_destroy(struct class *cls); 484 485 /* This is a #define to keep the compiler from merging different 486 * instances of the __key variable */ 487 #define class_create(owner, name) \ 488 ({ \ 489 static struct lock_class_key __key; \ 490 __class_create(owner, name, &__key); \ 491 }) 492 493 /* 494 * The type of device, "struct device" is embedded in. A class 495 * or bus can contain devices of different types 496 * like "partitions" and "disks", "mouse" and "event". 497 * This identifies the device type and carries type-specific 498 * information, equivalent to the kobj_type of a kobject. 499 * If "name" is specified, the uevent will contain it in 500 * the DEVTYPE variable. 501 */ 502 struct device_type { 503 const char *name; 504 const struct attribute_group **groups; 505 int (*uevent)(struct device *dev, struct kobj_uevent_env *env); 506 char *(*devnode)(struct device *dev, umode_t *mode, 507 kuid_t *uid, kgid_t *gid); 508 void (*release)(struct device *dev); 509 510 const struct dev_pm_ops *pm; 511 }; 512 513 /* interface for exporting device attributes */ 514 struct device_attribute { 515 struct attribute attr; 516 ssize_t (*show)(struct device *dev, struct device_attribute *attr, 517 char *buf); 518 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 519 const char *buf, size_t count); 520 }; 521 522 struct dev_ext_attribute { 523 struct device_attribute attr; 524 void *var; 525 }; 526 527 ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, 528 char *buf); 529 ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, 530 const char *buf, size_t count); 531 ssize_t device_show_int(struct device *dev, struct device_attribute *attr, 532 char *buf); 533 ssize_t device_store_int(struct device *dev, struct device_attribute *attr, 534 const char *buf, size_t count); 535 ssize_t device_show_bool(struct device *dev, struct device_attribute *attr, 536 char *buf); 537 ssize_t device_store_bool(struct device *dev, struct device_attribute *attr, 538 const char *buf, size_t count); 539 540 #define DEVICE_ATTR(_name, _mode, _show, _store) \ 541 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) 542 #define DEVICE_ATTR_RW(_name) \ 543 struct device_attribute dev_attr_##_name = __ATTR_RW(_name) 544 #define DEVICE_ATTR_RO(_name) \ 545 struct device_attribute dev_attr_##_name = __ATTR_RO(_name) 546 #define DEVICE_ATTR_WO(_name) \ 547 struct device_attribute dev_attr_##_name = __ATTR_WO(_name) 548 #define DEVICE_ULONG_ATTR(_name, _mode, _var) \ 549 struct dev_ext_attribute dev_attr_##_name = \ 550 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } 551 #define DEVICE_INT_ATTR(_name, _mode, _var) \ 552 struct dev_ext_attribute dev_attr_##_name = \ 553 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) } 554 #define DEVICE_BOOL_ATTR(_name, _mode, _var) \ 555 struct dev_ext_attribute dev_attr_##_name = \ 556 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) } 557 #define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \ 558 struct device_attribute dev_attr_##_name = \ 559 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) 560 561 extern int device_create_file(struct device *device, 562 const struct device_attribute *entry); 563 extern void device_remove_file(struct device *dev, 564 const struct device_attribute *attr); 565 extern bool device_remove_file_self(struct device *dev, 566 const struct device_attribute *attr); 567 extern int __must_check device_create_bin_file(struct device *dev, 568 const struct bin_attribute *attr); 569 extern void device_remove_bin_file(struct device *dev, 570 const struct bin_attribute *attr); 571 572 /* device resource management */ 573 typedef void (*dr_release_t)(struct device *dev, void *res); 574 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); 575 576 #ifdef CONFIG_DEBUG_DEVRES 577 extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 578 const char *name); 579 #define devres_alloc(release, size, gfp) \ 580 __devres_alloc(release, size, gfp, #release) 581 #else 582 extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 583 #endif 584 extern void devres_for_each_res(struct device *dev, dr_release_t release, 585 dr_match_t match, void *match_data, 586 void (*fn)(struct device *, void *, void *), 587 void *data); 588 extern void devres_free(void *res); 589 extern void devres_add(struct device *dev, void *res); 590 extern void *devres_find(struct device *dev, dr_release_t release, 591 dr_match_t match, void *match_data); 592 extern void *devres_get(struct device *dev, void *new_res, 593 dr_match_t match, void *match_data); 594 extern void *devres_remove(struct device *dev, dr_release_t release, 595 dr_match_t match, void *match_data); 596 extern int devres_destroy(struct device *dev, dr_release_t release, 597 dr_match_t match, void *match_data); 598 extern int devres_release(struct device *dev, dr_release_t release, 599 dr_match_t match, void *match_data); 600 601 /* devres group */ 602 extern void * __must_check devres_open_group(struct device *dev, void *id, 603 gfp_t gfp); 604 extern void devres_close_group(struct device *dev, void *id); 605 extern void devres_remove_group(struct device *dev, void *id); 606 extern int devres_release_group(struct device *dev, void *id); 607 608 /* managed devm_k.alloc/kfree for device drivers */ 609 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp); 610 extern char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, 611 va_list ap); 612 extern __printf(3, 4) 613 char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...); 614 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 615 { 616 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 617 } 618 static inline void *devm_kmalloc_array(struct device *dev, 619 size_t n, size_t size, gfp_t flags) 620 { 621 if (size != 0 && n > SIZE_MAX / size) 622 return NULL; 623 return devm_kmalloc(dev, n * size, flags); 624 } 625 static inline void *devm_kcalloc(struct device *dev, 626 size_t n, size_t size, gfp_t flags) 627 { 628 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 629 } 630 extern void devm_kfree(struct device *dev, void *p); 631 extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp); 632 extern void *devm_kmemdup(struct device *dev, const void *src, size_t len, 633 gfp_t gfp); 634 635 extern unsigned long devm_get_free_pages(struct device *dev, 636 gfp_t gfp_mask, unsigned int order); 637 extern void devm_free_pages(struct device *dev, unsigned long addr); 638 639 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); 640 641 /* allows to add/remove a custom action to devres stack */ 642 int devm_add_action(struct device *dev, void (*action)(void *), void *data); 643 void devm_remove_action(struct device *dev, void (*action)(void *), void *data); 644 645 struct device_dma_parameters { 646 /* 647 * a low level driver may set these to teach IOMMU code about 648 * sg limitations. 649 */ 650 unsigned int max_segment_size; 651 unsigned long segment_boundary_mask; 652 }; 653 654 /** 655 * struct device - The basic device structure 656 * @parent: The device's "parent" device, the device to which it is attached. 657 * In most cases, a parent device is some sort of bus or host 658 * controller. If parent is NULL, the device, is a top-level device, 659 * which is not usually what you want. 660 * @p: Holds the private data of the driver core portions of the device. 661 * See the comment of the struct device_private for detail. 662 * @kobj: A top-level, abstract class from which other classes are derived. 663 * @init_name: Initial name of the device. 664 * @type: The type of device. 665 * This identifies the device type and carries type-specific 666 * information. 667 * @mutex: Mutex to synchronize calls to its driver. 668 * @bus: Type of bus device is on. 669 * @driver: Which driver has allocated this 670 * @platform_data: Platform data specific to the device. 671 * Example: For devices on custom boards, as typical of embedded 672 * and SOC based hardware, Linux often uses platform_data to point 673 * to board-specific structures describing devices and how they 674 * are wired. That can include what ports are available, chip 675 * variants, which GPIO pins act in what additional roles, and so 676 * on. This shrinks the "Board Support Packages" (BSPs) and 677 * minimizes board-specific #ifdefs in drivers. 678 * @driver_data: Private pointer for driver specific info. 679 * @power: For device power management. 680 * See Documentation/power/devices.txt for details. 681 * @pm_domain: Provide callbacks that are executed during system suspend, 682 * hibernation, system resume and during runtime PM transitions 683 * along with subsystem-level and driver-level callbacks. 684 * @pins: For device pin management. 685 * See Documentation/pinctrl.txt for details. 686 * @numa_node: NUMA node this device is close to. 687 * @dma_mask: Dma mask (if dma'ble device). 688 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all 689 * hardware supports 64-bit addresses for consistent allocations 690 * such descriptors. 691 * @dma_pfn_offset: offset of DMA memory range relatively of RAM 692 * @dma_parms: A low level driver may set these to teach IOMMU code about 693 * segment limitations. 694 * @dma_pools: Dma pools (if dma'ble device). 695 * @dma_mem: Internal for coherent mem override. 696 * @cma_area: Contiguous memory area for dma allocations 697 * @archdata: For arch-specific additions. 698 * @of_node: Associated device tree node. 699 * @fwnode: Associated device node supplied by platform firmware. 700 * @devt: For creating the sysfs "dev". 701 * @id: device instance 702 * @devres_lock: Spinlock to protect the resource of the device. 703 * @devres_head: The resources list of the device. 704 * @knode_class: The node used to add the device to the class list. 705 * @class: The class of the device. 706 * @groups: Optional attribute groups. 707 * @release: Callback to free the device after all references have 708 * gone away. This should be set by the allocator of the 709 * device (i.e. the bus driver that discovered the device). 710 * @iommu_group: IOMMU group the device belongs to. 711 * 712 * @offline_disabled: If set, the device is permanently online. 713 * @offline: Set after successful invocation of bus type's .offline(). 714 * 715 * At the lowest level, every device in a Linux system is represented by an 716 * instance of struct device. The device structure contains the information 717 * that the device model core needs to model the system. Most subsystems, 718 * however, track additional information about the devices they host. As a 719 * result, it is rare for devices to be represented by bare device structures; 720 * instead, that structure, like kobject structures, is usually embedded within 721 * a higher-level representation of the device. 722 */ 723 struct device { 724 struct device *parent; 725 726 struct device_private *p; 727 728 struct kobject kobj; 729 const char *init_name; /* initial name of the device */ 730 const struct device_type *type; 731 732 struct mutex mutex; /* mutex to synchronize calls to 733 * its driver. 734 */ 735 736 struct bus_type *bus; /* type of bus device is on */ 737 struct device_driver *driver; /* which driver has allocated this 738 device */ 739 void *platform_data; /* Platform specific data, device 740 core doesn't touch it */ 741 void *driver_data; /* Driver data, set and get with 742 dev_set/get_drvdata */ 743 struct dev_pm_info power; 744 struct dev_pm_domain *pm_domain; 745 746 #ifdef CONFIG_PINCTRL 747 struct dev_pin_info *pins; 748 #endif 749 750 #ifdef CONFIG_NUMA 751 int numa_node; /* NUMA node this device is close to */ 752 #endif 753 u64 *dma_mask; /* dma mask (if dma'able device) */ 754 u64 coherent_dma_mask;/* Like dma_mask, but for 755 alloc_coherent mappings as 756 not all hardware supports 757 64 bit addresses for consistent 758 allocations such descriptors. */ 759 unsigned long dma_pfn_offset; 760 761 struct device_dma_parameters *dma_parms; 762 763 struct list_head dma_pools; /* dma pools (if dma'ble) */ 764 765 struct dma_coherent_mem *dma_mem; /* internal for coherent mem 766 override */ 767 #ifdef CONFIG_DMA_CMA 768 struct cma *cma_area; /* contiguous memory area for dma 769 allocations */ 770 #endif 771 /* arch specific additions */ 772 struct dev_archdata archdata; 773 774 struct device_node *of_node; /* associated device tree node */ 775 struct fwnode_handle *fwnode; /* firmware device node */ 776 777 dev_t devt; /* dev_t, creates the sysfs "dev" */ 778 u32 id; /* device instance */ 779 780 spinlock_t devres_lock; 781 struct list_head devres_head; 782 783 struct klist_node knode_class; 784 struct class *class; 785 const struct attribute_group **groups; /* optional groups */ 786 787 void (*release)(struct device *dev); 788 struct iommu_group *iommu_group; 789 790 bool offline_disabled:1; 791 bool offline:1; 792 }; 793 794 static inline struct device *kobj_to_dev(struct kobject *kobj) 795 { 796 return container_of(kobj, struct device, kobj); 797 } 798 799 /* Get the wakeup routines, which depend on struct device */ 800 #include <linux/pm_wakeup.h> 801 802 static inline const char *dev_name(const struct device *dev) 803 { 804 /* Use the init name until the kobject becomes available */ 805 if (dev->init_name) 806 return dev->init_name; 807 808 return kobject_name(&dev->kobj); 809 } 810 811 extern __printf(2, 3) 812 int dev_set_name(struct device *dev, const char *name, ...); 813 814 #ifdef CONFIG_NUMA 815 static inline int dev_to_node(struct device *dev) 816 { 817 return dev->numa_node; 818 } 819 static inline void set_dev_node(struct device *dev, int node) 820 { 821 dev->numa_node = node; 822 } 823 #else 824 static inline int dev_to_node(struct device *dev) 825 { 826 return -1; 827 } 828 static inline void set_dev_node(struct device *dev, int node) 829 { 830 } 831 #endif 832 833 static inline void *dev_get_drvdata(const struct device *dev) 834 { 835 return dev->driver_data; 836 } 837 838 static inline void dev_set_drvdata(struct device *dev, void *data) 839 { 840 dev->driver_data = data; 841 } 842 843 static inline struct pm_subsys_data *dev_to_psd(struct device *dev) 844 { 845 return dev ? dev->power.subsys_data : NULL; 846 } 847 848 static inline unsigned int dev_get_uevent_suppress(const struct device *dev) 849 { 850 return dev->kobj.uevent_suppress; 851 } 852 853 static inline void dev_set_uevent_suppress(struct device *dev, int val) 854 { 855 dev->kobj.uevent_suppress = val; 856 } 857 858 static inline int device_is_registered(struct device *dev) 859 { 860 return dev->kobj.state_in_sysfs; 861 } 862 863 static inline void device_enable_async_suspend(struct device *dev) 864 { 865 if (!dev->power.is_prepared) 866 dev->power.async_suspend = true; 867 } 868 869 static inline void device_disable_async_suspend(struct device *dev) 870 { 871 if (!dev->power.is_prepared) 872 dev->power.async_suspend = false; 873 } 874 875 static inline bool device_async_suspend_enabled(struct device *dev) 876 { 877 return !!dev->power.async_suspend; 878 } 879 880 static inline void pm_suspend_ignore_children(struct device *dev, bool enable) 881 { 882 dev->power.ignore_children = enable; 883 } 884 885 static inline void dev_pm_syscore_device(struct device *dev, bool val) 886 { 887 #ifdef CONFIG_PM_SLEEP 888 dev->power.syscore = val; 889 #endif 890 } 891 892 static inline void device_lock(struct device *dev) 893 { 894 mutex_lock(&dev->mutex); 895 } 896 897 static inline int device_trylock(struct device *dev) 898 { 899 return mutex_trylock(&dev->mutex); 900 } 901 902 static inline void device_unlock(struct device *dev) 903 { 904 mutex_unlock(&dev->mutex); 905 } 906 907 static inline void device_lock_assert(struct device *dev) 908 { 909 lockdep_assert_held(&dev->mutex); 910 } 911 912 static inline struct device_node *dev_of_node(struct device *dev) 913 { 914 if (!IS_ENABLED(CONFIG_OF)) 915 return NULL; 916 return dev->of_node; 917 } 918 919 void driver_init(void); 920 921 /* 922 * High level routines for use by the bus drivers 923 */ 924 extern int __must_check device_register(struct device *dev); 925 extern void device_unregister(struct device *dev); 926 extern void device_initialize(struct device *dev); 927 extern int __must_check device_add(struct device *dev); 928 extern void device_del(struct device *dev); 929 extern int device_for_each_child(struct device *dev, void *data, 930 int (*fn)(struct device *dev, void *data)); 931 extern struct device *device_find_child(struct device *dev, void *data, 932 int (*match)(struct device *dev, void *data)); 933 extern int device_rename(struct device *dev, const char *new_name); 934 extern int device_move(struct device *dev, struct device *new_parent, 935 enum dpm_order dpm_order); 936 extern const char *device_get_devnode(struct device *dev, 937 umode_t *mode, kuid_t *uid, kgid_t *gid, 938 const char **tmp); 939 940 static inline bool device_supports_offline(struct device *dev) 941 { 942 return dev->bus && dev->bus->offline && dev->bus->online; 943 } 944 945 extern void lock_device_hotplug(void); 946 extern void unlock_device_hotplug(void); 947 extern int lock_device_hotplug_sysfs(void); 948 extern int device_offline(struct device *dev); 949 extern int device_online(struct device *dev); 950 extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 951 extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode); 952 953 /* 954 * Root device objects for grouping under /sys/devices 955 */ 956 extern struct device *__root_device_register(const char *name, 957 struct module *owner); 958 959 /* This is a macro to avoid include problems with THIS_MODULE */ 960 #define root_device_register(name) \ 961 __root_device_register(name, THIS_MODULE) 962 963 extern void root_device_unregister(struct device *root); 964 965 static inline void *dev_get_platdata(const struct device *dev) 966 { 967 return dev->platform_data; 968 } 969 970 /* 971 * Manual binding of a device to driver. See drivers/base/bus.c 972 * for information on use. 973 */ 974 extern int __must_check device_bind_driver(struct device *dev); 975 extern void device_release_driver(struct device *dev); 976 extern int __must_check device_attach(struct device *dev); 977 extern int __must_check driver_attach(struct device_driver *drv); 978 extern int __must_check device_reprobe(struct device *dev); 979 980 /* 981 * Easy functions for dynamically creating devices on the fly 982 */ 983 extern struct device *device_create_vargs(struct class *cls, 984 struct device *parent, 985 dev_t devt, 986 void *drvdata, 987 const char *fmt, 988 va_list vargs); 989 extern __printf(5, 6) 990 struct device *device_create(struct class *cls, struct device *parent, 991 dev_t devt, void *drvdata, 992 const char *fmt, ...); 993 extern __printf(6, 7) 994 struct device *device_create_with_groups(struct class *cls, 995 struct device *parent, dev_t devt, void *drvdata, 996 const struct attribute_group **groups, 997 const char *fmt, ...); 998 extern void device_destroy(struct class *cls, dev_t devt); 999 1000 /* 1001 * Platform "fixup" functions - allow the platform to have their say 1002 * about devices and actions that the general device layer doesn't 1003 * know about. 1004 */ 1005 /* Notify platform of device discovery */ 1006 extern int (*platform_notify)(struct device *dev); 1007 1008 extern int (*platform_notify_remove)(struct device *dev); 1009 1010 1011 /* 1012 * get_device - atomically increment the reference count for the device. 1013 * 1014 */ 1015 extern struct device *get_device(struct device *dev); 1016 extern void put_device(struct device *dev); 1017 1018 #ifdef CONFIG_DEVTMPFS 1019 extern int devtmpfs_create_node(struct device *dev); 1020 extern int devtmpfs_delete_node(struct device *dev); 1021 extern int devtmpfs_mount(const char *mntdir); 1022 #else 1023 static inline int devtmpfs_create_node(struct device *dev) { return 0; } 1024 static inline int devtmpfs_delete_node(struct device *dev) { return 0; } 1025 static inline int devtmpfs_mount(const char *mountpoint) { return 0; } 1026 #endif 1027 1028 /* drivers/base/power/shutdown.c */ 1029 extern void device_shutdown(void); 1030 1031 /* debugging and troubleshooting/diagnostic helpers. */ 1032 extern const char *dev_driver_string(const struct device *dev); 1033 1034 1035 #ifdef CONFIG_PRINTK 1036 1037 extern __printf(3, 0) 1038 int dev_vprintk_emit(int level, const struct device *dev, 1039 const char *fmt, va_list args); 1040 extern __printf(3, 4) 1041 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...); 1042 1043 extern __printf(3, 4) 1044 void dev_printk(const char *level, const struct device *dev, 1045 const char *fmt, ...); 1046 extern __printf(2, 3) 1047 void dev_emerg(const struct device *dev, const char *fmt, ...); 1048 extern __printf(2, 3) 1049 void dev_alert(const struct device *dev, const char *fmt, ...); 1050 extern __printf(2, 3) 1051 void dev_crit(const struct device *dev, const char *fmt, ...); 1052 extern __printf(2, 3) 1053 void dev_err(const struct device *dev, const char *fmt, ...); 1054 extern __printf(2, 3) 1055 void dev_warn(const struct device *dev, const char *fmt, ...); 1056 extern __printf(2, 3) 1057 void dev_notice(const struct device *dev, const char *fmt, ...); 1058 extern __printf(2, 3) 1059 void _dev_info(const struct device *dev, const char *fmt, ...); 1060 1061 #else 1062 1063 static inline __printf(3, 0) 1064 int dev_vprintk_emit(int level, const struct device *dev, 1065 const char *fmt, va_list args) 1066 { return 0; } 1067 static inline __printf(3, 4) 1068 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...) 1069 { return 0; } 1070 1071 static inline void __dev_printk(const char *level, const struct device *dev, 1072 struct va_format *vaf) 1073 {} 1074 static inline __printf(3, 4) 1075 void dev_printk(const char *level, const struct device *dev, 1076 const char *fmt, ...) 1077 {} 1078 1079 static inline __printf(2, 3) 1080 void dev_emerg(const struct device *dev, const char *fmt, ...) 1081 {} 1082 static inline __printf(2, 3) 1083 void dev_crit(const struct device *dev, const char *fmt, ...) 1084 {} 1085 static inline __printf(2, 3) 1086 void dev_alert(const struct device *dev, const char *fmt, ...) 1087 {} 1088 static inline __printf(2, 3) 1089 void dev_err(const struct device *dev, const char *fmt, ...) 1090 {} 1091 static inline __printf(2, 3) 1092 void dev_warn(const struct device *dev, const char *fmt, ...) 1093 {} 1094 static inline __printf(2, 3) 1095 void dev_notice(const struct device *dev, const char *fmt, ...) 1096 {} 1097 static inline __printf(2, 3) 1098 void _dev_info(const struct device *dev, const char *fmt, ...) 1099 {} 1100 1101 #endif 1102 1103 /* 1104 * Stupid hackaround for existing uses of non-printk uses dev_info 1105 * 1106 * Note that the definition of dev_info below is actually _dev_info 1107 * and a macro is used to avoid redefining dev_info 1108 */ 1109 1110 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) 1111 1112 #if defined(CONFIG_DYNAMIC_DEBUG) 1113 #define dev_dbg(dev, format, ...) \ 1114 do { \ 1115 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ 1116 } while (0) 1117 #elif defined(DEBUG) 1118 #define dev_dbg(dev, format, arg...) \ 1119 dev_printk(KERN_DEBUG, dev, format, ##arg) 1120 #else 1121 #define dev_dbg(dev, format, arg...) \ 1122 ({ \ 1123 if (0) \ 1124 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1125 }) 1126 #endif 1127 1128 #ifdef CONFIG_PRINTK 1129 #define dev_level_once(dev_level, dev, fmt, ...) \ 1130 do { \ 1131 static bool __print_once __read_mostly; \ 1132 \ 1133 if (!__print_once) { \ 1134 __print_once = true; \ 1135 dev_level(dev, fmt, ##__VA_ARGS__); \ 1136 } \ 1137 } while (0) 1138 #else 1139 #define dev_level_once(dev_level, dev, fmt, ...) \ 1140 do { \ 1141 if (0) \ 1142 dev_level(dev, fmt, ##__VA_ARGS__); \ 1143 } while (0) 1144 #endif 1145 1146 #define dev_emerg_once(dev, fmt, ...) \ 1147 dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__) 1148 #define dev_alert_once(dev, fmt, ...) \ 1149 dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__) 1150 #define dev_crit_once(dev, fmt, ...) \ 1151 dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__) 1152 #define dev_err_once(dev, fmt, ...) \ 1153 dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__) 1154 #define dev_warn_once(dev, fmt, ...) \ 1155 dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__) 1156 #define dev_notice_once(dev, fmt, ...) \ 1157 dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__) 1158 #define dev_info_once(dev, fmt, ...) \ 1159 dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__) 1160 #define dev_dbg_once(dev, fmt, ...) \ 1161 dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__) 1162 1163 #define dev_level_ratelimited(dev_level, dev, fmt, ...) \ 1164 do { \ 1165 static DEFINE_RATELIMIT_STATE(_rs, \ 1166 DEFAULT_RATELIMIT_INTERVAL, \ 1167 DEFAULT_RATELIMIT_BURST); \ 1168 if (__ratelimit(&_rs)) \ 1169 dev_level(dev, fmt, ##__VA_ARGS__); \ 1170 } while (0) 1171 1172 #define dev_emerg_ratelimited(dev, fmt, ...) \ 1173 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__) 1174 #define dev_alert_ratelimited(dev, fmt, ...) \ 1175 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__) 1176 #define dev_crit_ratelimited(dev, fmt, ...) \ 1177 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__) 1178 #define dev_err_ratelimited(dev, fmt, ...) \ 1179 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__) 1180 #define dev_warn_ratelimited(dev, fmt, ...) \ 1181 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__) 1182 #define dev_notice_ratelimited(dev, fmt, ...) \ 1183 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__) 1184 #define dev_info_ratelimited(dev, fmt, ...) \ 1185 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__) 1186 #if defined(CONFIG_DYNAMIC_DEBUG) 1187 /* descriptor check is first to prevent flooding with "callbacks suppressed" */ 1188 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1189 do { \ 1190 static DEFINE_RATELIMIT_STATE(_rs, \ 1191 DEFAULT_RATELIMIT_INTERVAL, \ 1192 DEFAULT_RATELIMIT_BURST); \ 1193 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ 1194 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \ 1195 __ratelimit(&_rs)) \ 1196 __dynamic_dev_dbg(&descriptor, dev, fmt, \ 1197 ##__VA_ARGS__); \ 1198 } while (0) 1199 #elif defined(DEBUG) 1200 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1201 do { \ 1202 static DEFINE_RATELIMIT_STATE(_rs, \ 1203 DEFAULT_RATELIMIT_INTERVAL, \ 1204 DEFAULT_RATELIMIT_BURST); \ 1205 if (__ratelimit(&_rs)) \ 1206 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \ 1207 } while (0) 1208 #else 1209 #define dev_dbg_ratelimited(dev, fmt, ...) \ 1210 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) 1211 #endif 1212 1213 #ifdef VERBOSE_DEBUG 1214 #define dev_vdbg dev_dbg 1215 #else 1216 #define dev_vdbg(dev, format, arg...) \ 1217 ({ \ 1218 if (0) \ 1219 dev_printk(KERN_DEBUG, dev, format, ##arg); \ 1220 }) 1221 #endif 1222 1223 /* 1224 * dev_WARN*() acts like dev_printk(), but with the key difference of 1225 * using WARN/WARN_ONCE to include file/line information and a backtrace. 1226 */ 1227 #define dev_WARN(dev, format, arg...) \ 1228 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg); 1229 1230 #define dev_WARN_ONCE(dev, condition, format, arg...) \ 1231 WARN_ONCE(condition, "%s %s: " format, \ 1232 dev_driver_string(dev), dev_name(dev), ## arg) 1233 1234 /* Create alias, so I can be autoloaded. */ 1235 #define MODULE_ALIAS_CHARDEV(major,minor) \ 1236 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) 1237 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ 1238 MODULE_ALIAS("char-major-" __stringify(major) "-*") 1239 1240 #ifdef CONFIG_SYSFS_DEPRECATED 1241 extern long sysfs_deprecated; 1242 #else 1243 #define sysfs_deprecated 0 1244 #endif 1245 1246 /** 1247 * module_driver() - Helper macro for drivers that don't do anything 1248 * special in module init/exit. This eliminates a lot of boilerplate. 1249 * Each module may only use this macro once, and calling it replaces 1250 * module_init() and module_exit(). 1251 * 1252 * @__driver: driver name 1253 * @__register: register function for this driver type 1254 * @__unregister: unregister function for this driver type 1255 * @...: Additional arguments to be passed to __register and __unregister. 1256 * 1257 * Use this macro to construct bus specific macros for registering 1258 * drivers, and do not use it on its own. 1259 */ 1260 #define module_driver(__driver, __register, __unregister, ...) \ 1261 static int __init __driver##_init(void) \ 1262 { \ 1263 return __register(&(__driver) , ##__VA_ARGS__); \ 1264 } \ 1265 module_init(__driver##_init); \ 1266 static void __exit __driver##_exit(void) \ 1267 { \ 1268 __unregister(&(__driver) , ##__VA_ARGS__); \ 1269 } \ 1270 module_exit(__driver##_exit); 1271 1272 #endif /* _DEVICE_H_ */

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

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

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

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

Ядро Модуль Правило Верификатор Вердикт Статус Время создания Описание проблемы
linux-4.1-rc1.tar.xz drivers/mcb/mcb-pci.ko 152_1a BLAST Bug Fixed 2015-07-09 00:30:16 L0205

Комментарий

reported: 9 Jul 2015

[В начало]