LDD simple中的代码，make 报错

FreeGnu

1. 
   
2. #include <linux/config.h>
   
3. #include <linux/module.h>
   
4. #include <linux/moduleparam.h>
   
5. #include <linux/init.h>
   
6. 
   
7. #include <linux/kernel.h>   /* printk() */
   
8. #include <linux/slab.h>   /* kmalloc() */
   
9. #include <linux/fs.h>       /* everything... */
   
10. #include <linux/errno.h>    /* error codes */
    
11. #include <linux/types.h>    /* size_t */
    
12. #include <linux/mm.h>
    
13. #include <linux/kdev_t.h>
    
14. #include <asm/page.h>
    
15. #include <linux/cdev.h>
    
16. 
    
17. #include <linux/device.h>
    
18. 
    
19. static int simple_major = 0;
    
20. module_param(simple_major, int, 0);
    
21. MODULE_AUTHOR("Jonathan Corbet");
    
22. MODULE_LICENSE("Dual BSD/GPL");
    
23. 
    
24. /*
    
25. * Open the device; in fact, there's nothing to do here.
    
26. */
    
27. static int simple_open (struct inode *inode, struct file *filp)
    
28. {
    
29.         return 0;
    
30. }
    
31. 
    
32. 
    
33. /*
    
34. * Closing is just as simpler.
    
35. */
    
36. static int simple_release(struct inode *inode, struct file *filp)
    
37. {
    
38.         return 0;
    
39. }
    
40. 
    
41. 
    
42. 
    
43. /*
    
44. * Common VMA ops.
    
45. */
    
46. 
    
47. void simple_vma_open(struct vm_area_struct *vma)
    
48. {
    
49.         printk(KERN_NOTICE "Simple VMA open, virt %lx, phys %lx\n",
    
50.                         vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
    
51. }
    
52. 
    
53. void simple_vma_close(struct vm_area_struct *vma)
    
54. {
    
55.         printk(KERN_NOTICE "Simple VMA close.\n");
    
56. }
    
57. 
    
58. 
    
59. /*
    
60. * The remap_pfn_range version of mmap.  This one is heavily borrowed
    
61. * from drivers/char/mem.c.
    
62. */
    
63. 
    
64. static struct vm_operations_struct simple_remap_vm_ops = {
    
65.         .open =  simple_vma_open,
    
66.         .close = simple_vma_close,
    
67. };
    
68. 
    
69. static int simple_remap_mmap(struct file *filp, struct vm_area_struct *vma)
    
70. {
    
71.         if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
    
72.                             vma->vm_end - vma->vm_start,
    
73.                             vma->vm_page_prot))
    
74.                 return -EAGAIN;
    
75. 
    
76.         vma->vm_ops = &simple_remap_vm_ops;
    
77.         simple_vma_open(vma);
    
78.         return 0;
    
79. }
    
80. 
    
81. 
    
82. 
    
83. /*
    
84. * The nopage version.
    
85. */
    
86. struct page *simple_vma_nopage(struct vm_area_struct *vma,
    
87.                 unsigned long address, int *type)
    
88. {
    
89.         struct page *pageptr;
    
90.         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
    
91.         unsigned long physaddr = address - vma->vm_start + offset;
    
92.         unsigned long pageframe = physaddr >> PAGE_SHIFT;
    
93. 
    
94. // Eventually remove these printks
    
95.         printk (KERN_NOTICE "---- Nopage, off %lx phys %lx\n", offset, physaddr);
    
96.         printk (KERN_NOTICE "VA is %p\n", __va (physaddr));
    
97.         printk (KERN_NOTICE "Page at %p\n", virt_to_page (__va (physaddr)));
    
98.         if (!pfn_valid(pageframe))
    
99.                 return NOPAGE_SIGBUS;
    
100.         pageptr = pfn_to_page(pageframe);
     
101.         printk (KERN_NOTICE "page->index = %ld mapping %p\n", pageptr->index, pageptr->mapping);
     
102.         printk (KERN_NOTICE "Page frame %ld\n", pageframe);
     
103.         get_page(pageptr);
     
104.         if (type)
     
105.                 *type = VM_FAULT_MINOR;
     
106.         return pageptr;
     
107. }
     
108. 
     
109. static struct vm_operations_struct simple_nopage_vm_ops = {
     
110.         .open =   simple_vma_open,
     
111.         .close =  simple_vma_close,
     
112.         .nopage = simple_vma_nopage,
     
113. };
     
114. 
     
115. static int simple_nopage_mmap(struct file *filp, struct vm_area_struct *vma)
     
116. {
     
117.         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
     
118. 
     
119.         if (offset >= __pa(high_memory) || (filp->f_flags & O_SYNC))
     
120.                 vma->vm_flags |= VM_IO;
     
121.         vma->vm_flags |= VM_RESERVED;
     
122. 
     
123.         vma->vm_ops = &simple_nopage_vm_ops;
     
124.         simple_vma_open(vma);
     
125.         return 0;
     
126. }
     
127. 
     
128. 
     
129. /*
     
130. * Set up the cdev structure for a device.
     
131. */
     
132. static void simple_setup_cdev(struct cdev *dev, int minor,
     
133.                 struct file_operations *fops)
     
134. {
     
135.         int err, devno = MKDEV(simple_major, minor);
     
136.    
     
137.         cdev_init(dev, fops);
     
138.         dev->owner = THIS_MODULE;
     
139.         dev->ops = fops;
     
140.         err = cdev_add (dev, devno, 1);
     
141.         /* Fail gracefully if need be */
     
142.         if (err)
     
143.                 printk (KERN_NOTICE "Error %d adding simple%d", err, minor);
     
144. }
     
145. 
     
146. 
     
147. /*
     
148. * Our various sub-devices.
     
149. */
     
150. /* Device 0 uses remap_pfn_range */
     
151. static struct file_operations simple_remap_ops = {
     
152.         .owner   = THIS_MODULE,
     
153.         .open    = simple_open,
     
154.         .release = simple_release,
     
155.         .mmap    = simple_remap_mmap,
     
156. };
     
157. 
     
158. /* Device 1 uses nopage */
     
159. static struct file_operations simple_nopage_ops = {
     
160.         .owner   = THIS_MODULE,
     
161.         .open    = simple_open,
     
162.         .release = simple_release,
     
163.         .mmap    = simple_nopage_mmap,
     
164. };
     
165. 
     
166. #define MAX_SIMPLE_DEV 2
     
167. 
     
168. #if 0
     
169. static struct file_operations *simple_fops[MAX_SIMPLE_DEV] = {
     
170.         &simple_remap_ops,
     
171.         &simple_nopage_ops,
     
172. };
     
173. #endif
     
174. 
     
175. /*
     
176. * We export two simple devices.  There's no need for us to maintain any
     
177. * special housekeeping info, so we just deal with raw cdevs.
     
178. */
     
179. static struct cdev SimpleDevs[MAX_SIMPLE_DEV];
     
180. 
     
181. /*
     
182. * Module housekeeping.
     
183. */
     
184. static int simple_init(void)
     
185. {
     
186.         int result;
     
187.         dev_t dev = MKDEV(simple_major, 0);
     
188. 
     
189.         /* Figure out our device number. */
     
190.         if (simple_major)
     
191.                 result = register_chrdev_region(dev, 2, "simple");
     
192.         else {
     
193.                 result = alloc_chrdev_region(&dev, 0, 2, "simple");
     
194.                 simple_major = MAJOR(dev);
     
195.         }
     
196.         if (result < 0) {
     
197.                 printk(KERN_WARNING "simple: unable to get major %d\n", simple_major);
     
198.                 return result;
     
199.         }
     
200.         if (simple_major == 0)
     
201.                 simple_major = result;
     
202. 
     
203.         /* Now set up two cdevs. */
     
204.         simple_setup_cdev(SimpleDevs, 0, &simple_remap_ops);
     
205.         simple_setup_cdev(SimpleDevs + 1, 1, &simple_nopage_ops);
     
206.         return 0;
     
207. }
     
208. 
     
209. 
     
210. static void simple_cleanup(void)
     
211. {
     
212.         cdev_del(SimpleDevs);
     
213.         cdev_del(SimpleDevs + 1);
     
214.         unregister_chrdev_region(MKDEV(simple_major, 0), 2);
     
215. }
     
216. 
     
217. 
     
218. module_init(simple_init);
     
219. module_exit(simple_cleanup);
     

复制代码

1. 
   
2. # Comment/uncomment the following line to disable/enable debugging
   
3. #DEBUG = y
   
4. 
   
5. # Add your debugging flag (or not) to CFLAGS
   
6. ifeq ($(DEBUG),y)
   
7.   DEBFLAGS = -O -g # "-O" is needed to expand inlines
   
8. else
   
9.   DEBFLAGS = -O2
   
10. endif
    
11. 
    
12. CFLAGS += $(DEBFLAGS) -I$(LDDINCDIR)
    
13. 
    
14. ifneq ($(KERNELRELEASE),)
    
15. # call from kernel build system
    
16. 
    
17. obj-m        := simple.o
    
18. 
    
19. else
    
20. 
    
21. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
    
22. PWD       := $(shell pwd)
    
23. 
    
24. default:
    
25.         $(MAKE) -C $(KERNELDIR) M=$(PWD) LDDINCDIR=$(PWD)/../include modules
    
26. 
    
27. endif
    
28. 
    
29. 
    
30. 
    
31. clean:
    
32.         rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
    
33. 
    
34. depend .depend dep:
    
35.         $(CC) $(CFLAGS) -M *.c > .depend
    
36. 
    
37. 
    
38. ifeq (.depend,$(wildcard .depend))
    
39. include .depend
    
40. endif
    
41. 
    

复制代码

OS是redhat9.0, 用make xconfig在kenerl配置选项中看到enable loadable module 是打开的，
但make是却提示modules disabled

1. 
   
2. make -C /lib/modules/2.4.20-8smp/build M=/home/qiang/video/test/examples/simple LDDINCDIR=/home/qiang/video/test/examples/simple/../include modules
   
3. make[1]: Entering directory `/usr/src/linux-2.4.20-8'
   
4. 
   
5. The present kernel configuration has modules disabled.
   
6. Type 'make config' and enable loadable module support.
   
7. Then build a kernel with module support enabled.
   
8. 
   
9. make[1]: *** [modules] Error 1
   
10. make[1]: Leaving directory `/usr/src/linux-2.4.20-8'
    
11. make: *** [default] Error
    

复制代码