LDD simple中的代码，make 报错

Question

2. #include <linux/config.h>
3. #include <linux/module.h>
4. #include <linux/moduleparam.h>
5. #include <linux/init.h>
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>
17. #include <linux/device.h>
19. static int simple_major = 0;
20. module_param(simple_major, int, 0);
21. MODULE_AUTHOR("Jonathan Corbet");
22. MODULE_LICENSE("Dual BSD/GPL");
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. }
33. /*
34. * Closing is just as simpler.
35. */
36. static int simple_release(struct inode *inode, struct file *filp)
37. {
38.         return 0;
39. }
43. /*
44. * Common VMA ops.
45. */
47. void simple_vma_open(struct vm_area_struct *vma)
48. {
49.         printk(KERN_NOTICE "Simple VMA open, virt %lx, phys %lxn",
50.                         vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
51. }
53. void simple_vma_close(struct vm_area_struct *vma)
54. {
55.         printk(KERN_NOTICE "Simple VMA close.n");
56. }
59. /*
60. * The remap_pfn_range version of mmap.  This one is heavily borrowed
61. * from drivers/char/mem.c.
62. */
64. static struct vm_operations_struct simple_remap_vm_ops = {
65.         .open =  simple_vma_open,
66.         .close = simple_vma_close,
67. };
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;
76.         vma->vm_ops = &simple_remap_vm_ops;
77.         simple_vma_open(vma);
78.         return 0;
79. }
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;
94. // Eventually remove these printks
95.         printk (KERN_NOTICE "---- Nopage, off %lx phys %lxn", offset, physaddr);
96.         printk (KERN_NOTICE "VA is %pn", __va (physaddr));
97.         printk (KERN_NOTICE "Page at %pn", 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 %pn", pageptr->index, pageptr->mapping);
102.         printk (KERN_NOTICE "Page frame %ldn", pageframe);
103.         get_page(pageptr);
104.         if (type)
105.                 *type = VM_FAULT_MINOR;
106.         return pageptr;
107. }
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. };
115. static int simple_nopage_mmap(struct file *filp, struct vm_area_struct *vma)
116. {
117.         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
119.         if (offset >= __pa(high_memory) || (filp->f_flags & O_SYNC))
120.                 vma->vm_flags |= VM_IO;
121.         vma->vm_flags |= VM_RESERVED;
123.         vma->vm_ops = &simple_nopage_vm_ops;
124.         simple_vma_open(vma);
125.         return 0;
126. }
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. }
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. };
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. };
166. #define MAX_SIMPLE_DEV 2
168. #if 0
169. static struct file_operations *simple_fops[MAX_SIMPLE_DEV] = {
170.         &simple_remap_ops,
171.         &simple_nopage_ops,
172. };
173. #endif
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];
181. /*
182. * Module housekeeping.
183. */
184. static int simple_init(void)
185. {
186.         int result;
187.         dev_t dev = MKDEV(simple_major, 0);
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 %dn", simple_major);
198.                 return result;
199.         }
200.         if (simple_major == 0)
201.                 simple_major = result;
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. }
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. }
218. module_init(simple_init);
219. module_exit(simple_cleanup);

复制代码

2. # Comment/uncomment the following line to disable/enable debugging
3. #DEBUG = y
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
12. CFLAGS += $(DEBFLAGS) -I$(LDDINCDIR)
14. ifneq ($(KERNELRELEASE),)
15. # call from kernel build system
17. obj-m        := simple.o
19. else
21. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
22. PWD       := $(shell pwd)
24. default:
25.         $(MAKE) -C $(KERNELDIR) M=$(PWD) LDDINCDIR=$(PWD)/../include modules
27. endif
31. clean:
32.         rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
34. depend .depend dep:
35.         $(CC) $(CFLAGS) -M *.c > .depend
38. ifeq (.depend,$(wildcard .depend))
39. include .depend
40. endif

复制代码

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

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'
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.
9. make[1]: *** [modules] Error 1
10. make[1]: Leaving directory `/usr/src/linux-2.4.20-8'
11. make: *** [default] Error

复制代码