diff options
author | Andrea Bastoni <bastoni@cs.unc.edu> | 2010-05-30 19:16:45 -0400 |
---|---|---|
committer | Andrea Bastoni <bastoni@cs.unc.edu> | 2010-05-30 19:16:45 -0400 |
commit | ada47b5fe13d89735805b566185f4885f5a3f750 (patch) | |
tree | 644b88f8a71896307d71438e9b3af49126ffb22b /arch/alpha/kernel | |
parent | 43e98717ad40a4ae64545b5ba047c7b86aa44f4f (diff) | |
parent | 3280f21d43ee541f97f8cda5792150d2dbec20d5 (diff) |
Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master
Diffstat (limited to 'arch/alpha/kernel')
-rw-r--r-- | arch/alpha/kernel/core_t2.c | 2 | ||||
-rw-r--r-- | arch/alpha/kernel/irq.c | 5 | ||||
-rw-r--r-- | arch/alpha/kernel/osf_sys.c | 24 | ||||
-rw-r--r-- | arch/alpha/kernel/pci-noop.c | 102 | ||||
-rw-r--r-- | arch/alpha/kernel/pci-sysfs.c | 1 | ||||
-rw-r--r-- | arch/alpha/kernel/pci.c | 6 | ||||
-rw-r--r-- | arch/alpha/kernel/pci_iommu.c | 203 | ||||
-rw-r--r-- | arch/alpha/kernel/process.c | 2 | ||||
-rw-r--r-- | arch/alpha/kernel/ptrace.c | 60 | ||||
-rw-r--r-- | arch/alpha/kernel/smc37c669.c | 1 | ||||
-rw-r--r-- | arch/alpha/kernel/smc37c93x.c | 1 | ||||
-rw-r--r-- | arch/alpha/kernel/srm_env.c | 66 | ||||
-rw-r--r-- | arch/alpha/kernel/sys_dp264.c | 2 | ||||
-rw-r--r-- | arch/alpha/kernel/sys_titan.c | 2 | ||||
-rw-r--r-- | arch/alpha/kernel/systbls.S | 17 | ||||
-rw-r--r-- | arch/alpha/kernel/traps.c | 10 |
16 files changed, 218 insertions, 286 deletions
diff --git a/arch/alpha/kernel/core_t2.c b/arch/alpha/kernel/core_t2.c index d9980d47ab81..e6d90568b65d 100644 --- a/arch/alpha/kernel/core_t2.c +++ b/arch/alpha/kernel/core_t2.c | |||
@@ -74,7 +74,7 @@ | |||
74 | # define DBG(args) | 74 | # define DBG(args) |
75 | #endif | 75 | #endif |
76 | 76 | ||
77 | DEFINE_SPINLOCK(t2_hae_lock); | 77 | DEFINE_RAW_SPINLOCK(t2_hae_lock); |
78 | 78 | ||
79 | static volatile unsigned int t2_mcheck_any_expected; | 79 | static volatile unsigned int t2_mcheck_any_expected; |
80 | static volatile unsigned int t2_mcheck_last_taken; | 80 | static volatile unsigned int t2_mcheck_last_taken; |
diff --git a/arch/alpha/kernel/irq.c b/arch/alpha/kernel/irq.c index c0de072b8305..7f912ba3d9ad 100644 --- a/arch/alpha/kernel/irq.c +++ b/arch/alpha/kernel/irq.c | |||
@@ -18,7 +18,6 @@ | |||
18 | #include <linux/sched.h> | 18 | #include <linux/sched.h> |
19 | #include <linux/ptrace.h> | 19 | #include <linux/ptrace.h> |
20 | #include <linux/interrupt.h> | 20 | #include <linux/interrupt.h> |
21 | #include <linux/slab.h> | ||
22 | #include <linux/random.h> | 21 | #include <linux/random.h> |
23 | #include <linux/init.h> | 22 | #include <linux/init.h> |
24 | #include <linux/irq.h> | 23 | #include <linux/irq.h> |
@@ -81,7 +80,7 @@ show_interrupts(struct seq_file *p, void *v) | |||
81 | #endif | 80 | #endif |
82 | 81 | ||
83 | if (irq < ACTUAL_NR_IRQS) { | 82 | if (irq < ACTUAL_NR_IRQS) { |
84 | spin_lock_irqsave(&irq_desc[irq].lock, flags); | 83 | raw_spin_lock_irqsave(&irq_desc[irq].lock, flags); |
85 | action = irq_desc[irq].action; | 84 | action = irq_desc[irq].action; |
86 | if (!action) | 85 | if (!action) |
87 | goto unlock; | 86 | goto unlock; |
@@ -105,7 +104,7 @@ show_interrupts(struct seq_file *p, void *v) | |||
105 | 104 | ||
106 | seq_putc(p, '\n'); | 105 | seq_putc(p, '\n'); |
107 | unlock: | 106 | unlock: |
108 | spin_unlock_irqrestore(&irq_desc[irq].lock, flags); | 107 | raw_spin_unlock_irqrestore(&irq_desc[irq].lock, flags); |
109 | } else if (irq == ACTUAL_NR_IRQS) { | 108 | } else if (irq == ACTUAL_NR_IRQS) { |
110 | #ifdef CONFIG_SMP | 109 | #ifdef CONFIG_SMP |
111 | seq_puts(p, "IPI: "); | 110 | seq_puts(p, "IPI: "); |
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c index 9a3334ae282e..de9d39717808 100644 --- a/arch/alpha/kernel/osf_sys.c +++ b/arch/alpha/kernel/osf_sys.c | |||
@@ -20,7 +20,6 @@ | |||
20 | #include <linux/syscalls.h> | 20 | #include <linux/syscalls.h> |
21 | #include <linux/unistd.h> | 21 | #include <linux/unistd.h> |
22 | #include <linux/ptrace.h> | 22 | #include <linux/ptrace.h> |
23 | #include <linux/slab.h> | ||
24 | #include <linux/user.h> | 23 | #include <linux/user.h> |
25 | #include <linux/utsname.h> | 24 | #include <linux/utsname.h> |
26 | #include <linux/time.h> | 25 | #include <linux/time.h> |
@@ -37,6 +36,7 @@ | |||
37 | #include <linux/uio.h> | 36 | #include <linux/uio.h> |
38 | #include <linux/vfs.h> | 37 | #include <linux/vfs.h> |
39 | #include <linux/rcupdate.h> | 38 | #include <linux/rcupdate.h> |
39 | #include <linux/slab.h> | ||
40 | 40 | ||
41 | #include <asm/fpu.h> | 41 | #include <asm/fpu.h> |
42 | #include <asm/io.h> | 42 | #include <asm/io.h> |
@@ -178,25 +178,18 @@ SYSCALL_DEFINE6(osf_mmap, unsigned long, addr, unsigned long, len, | |||
178 | unsigned long, prot, unsigned long, flags, unsigned long, fd, | 178 | unsigned long, prot, unsigned long, flags, unsigned long, fd, |
179 | unsigned long, off) | 179 | unsigned long, off) |
180 | { | 180 | { |
181 | struct file *file = NULL; | 181 | unsigned long ret = -EINVAL; |
182 | unsigned long ret = -EBADF; | ||
183 | 182 | ||
184 | #if 0 | 183 | #if 0 |
185 | if (flags & (_MAP_HASSEMAPHORE | _MAP_INHERIT | _MAP_UNALIGNED)) | 184 | if (flags & (_MAP_HASSEMAPHORE | _MAP_INHERIT | _MAP_UNALIGNED)) |
186 | printk("%s: unimplemented OSF mmap flags %04lx\n", | 185 | printk("%s: unimplemented OSF mmap flags %04lx\n", |
187 | current->comm, flags); | 186 | current->comm, flags); |
188 | #endif | 187 | #endif |
189 | if (!(flags & MAP_ANONYMOUS)) { | 188 | if ((off + PAGE_ALIGN(len)) < off) |
190 | file = fget(fd); | 189 | goto out; |
191 | if (!file) | 190 | if (off & ~PAGE_MASK) |
192 | goto out; | 191 | goto out; |
193 | } | 192 | ret = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT); |
194 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); | ||
195 | down_write(¤t->mm->mmap_sem); | ||
196 | ret = do_mmap(file, addr, len, prot, flags, off); | ||
197 | up_write(¤t->mm->mmap_sem); | ||
198 | if (file) | ||
199 | fput(file); | ||
200 | out: | 193 | out: |
201 | return ret; | 194 | return ret; |
202 | } | 195 | } |
@@ -368,7 +361,7 @@ osf_procfs_mount(char *dirname, struct procfs_args __user *args, int flags) | |||
368 | SYSCALL_DEFINE4(osf_mount, unsigned long, typenr, char __user *, path, | 361 | SYSCALL_DEFINE4(osf_mount, unsigned long, typenr, char __user *, path, |
369 | int, flag, void __user *, data) | 362 | int, flag, void __user *, data) |
370 | { | 363 | { |
371 | int retval = -EINVAL; | 364 | int retval; |
372 | char *name; | 365 | char *name; |
373 | 366 | ||
374 | name = getname(path); | 367 | name = getname(path); |
@@ -386,6 +379,7 @@ SYSCALL_DEFINE4(osf_mount, unsigned long, typenr, char __user *, path, | |||
386 | retval = osf_procfs_mount(name, data, flag); | 379 | retval = osf_procfs_mount(name, data, flag); |
387 | break; | 380 | break; |
388 | default: | 381 | default: |
382 | retval = -EINVAL; | ||
389 | printk("osf_mount(%ld, %x)\n", typenr, flag); | 383 | printk("osf_mount(%ld, %x)\n", typenr, flag); |
390 | } | 384 | } |
391 | putname(name); | 385 | putname(name); |
diff --git a/arch/alpha/kernel/pci-noop.c b/arch/alpha/kernel/pci-noop.c index c19a376520f4..246100ef07c2 100644 --- a/arch/alpha/kernel/pci-noop.c +++ b/arch/alpha/kernel/pci-noop.c | |||
@@ -7,6 +7,7 @@ | |||
7 | #include <linux/pci.h> | 7 | #include <linux/pci.h> |
8 | #include <linux/init.h> | 8 | #include <linux/init.h> |
9 | #include <linux/bootmem.h> | 9 | #include <linux/bootmem.h> |
10 | #include <linux/gfp.h> | ||
10 | #include <linux/capability.h> | 11 | #include <linux/capability.h> |
11 | #include <linux/mm.h> | 12 | #include <linux/mm.h> |
12 | #include <linux/errno.h> | 13 | #include <linux/errno.h> |
@@ -106,58 +107,8 @@ sys_pciconfig_write(unsigned long bus, unsigned long dfn, | |||
106 | return -ENODEV; | 107 | return -ENODEV; |
107 | } | 108 | } |
108 | 109 | ||
109 | /* Stubs for the routines in pci_iommu.c: */ | 110 | static void *alpha_noop_alloc_coherent(struct device *dev, size_t size, |
110 | 111 | dma_addr_t *dma_handle, gfp_t gfp) | |
111 | void * | ||
112 | __pci_alloc_consistent(struct pci_dev *pdev, size_t size, | ||
113 | dma_addr_t *dma_addrp, gfp_t gfp) | ||
114 | { | ||
115 | return NULL; | ||
116 | } | ||
117 | |||
118 | void | ||
119 | pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr, | ||
120 | dma_addr_t dma_addr) | ||
121 | { | ||
122 | } | ||
123 | |||
124 | dma_addr_t | ||
125 | pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, | ||
126 | int direction) | ||
127 | { | ||
128 | return (dma_addr_t) 0; | ||
129 | } | ||
130 | |||
131 | void | ||
132 | pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size, | ||
133 | int direction) | ||
134 | { | ||
135 | } | ||
136 | |||
137 | int | ||
138 | pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | ||
139 | int direction) | ||
140 | { | ||
141 | return 0; | ||
142 | } | ||
143 | |||
144 | void | ||
145 | pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | ||
146 | int direction) | ||
147 | { | ||
148 | } | ||
149 | |||
150 | int | ||
151 | pci_dma_supported(struct pci_dev *hwdev, dma_addr_t mask) | ||
152 | { | ||
153 | return 0; | ||
154 | } | ||
155 | |||
156 | /* Generic DMA mapping functions: */ | ||
157 | |||
158 | void * | ||
159 | dma_alloc_coherent(struct device *dev, size_t size, | ||
160 | dma_addr_t *dma_handle, gfp_t gfp) | ||
161 | { | 112 | { |
162 | void *ret; | 113 | void *ret; |
163 | 114 | ||
@@ -171,11 +122,22 @@ dma_alloc_coherent(struct device *dev, size_t size, | |||
171 | return ret; | 122 | return ret; |
172 | } | 123 | } |
173 | 124 | ||
174 | EXPORT_SYMBOL(dma_alloc_coherent); | 125 | static void alpha_noop_free_coherent(struct device *dev, size_t size, |
126 | void *cpu_addr, dma_addr_t dma_addr) | ||
127 | { | ||
128 | free_pages((unsigned long)cpu_addr, get_order(size)); | ||
129 | } | ||
130 | |||
131 | static dma_addr_t alpha_noop_map_page(struct device *dev, struct page *page, | ||
132 | unsigned long offset, size_t size, | ||
133 | enum dma_data_direction dir, | ||
134 | struct dma_attrs *attrs) | ||
135 | { | ||
136 | return page_to_pa(page) + offset; | ||
137 | } | ||
175 | 138 | ||
176 | int | 139 | static int alpha_noop_map_sg(struct device *dev, struct scatterlist *sgl, int nents, |
177 | dma_map_sg(struct device *dev, struct scatterlist *sgl, int nents, | 140 | enum dma_data_direction dir, struct dma_attrs *attrs) |
178 | enum dma_data_direction direction) | ||
179 | { | 141 | { |
180 | int i; | 142 | int i; |
181 | struct scatterlist *sg; | 143 | struct scatterlist *sg; |
@@ -192,19 +154,37 @@ dma_map_sg(struct device *dev, struct scatterlist *sgl, int nents, | |||
192 | return nents; | 154 | return nents; |
193 | } | 155 | } |
194 | 156 | ||
195 | EXPORT_SYMBOL(dma_map_sg); | 157 | static int alpha_noop_mapping_error(struct device *dev, dma_addr_t dma_addr) |
158 | { | ||
159 | return 0; | ||
160 | } | ||
161 | |||
162 | static int alpha_noop_supported(struct device *dev, u64 mask) | ||
163 | { | ||
164 | return mask < 0x00ffffffUL ? 0 : 1; | ||
165 | } | ||
196 | 166 | ||
197 | int | 167 | static int alpha_noop_set_mask(struct device *dev, u64 mask) |
198 | dma_set_mask(struct device *dev, u64 mask) | ||
199 | { | 168 | { |
200 | if (!dev->dma_mask || !dma_supported(dev, mask)) | 169 | if (!dev->dma_mask || !dma_supported(dev, mask)) |
201 | return -EIO; | 170 | return -EIO; |
202 | 171 | ||
203 | *dev->dma_mask = mask; | 172 | *dev->dma_mask = mask; |
204 | |||
205 | return 0; | 173 | return 0; |
206 | } | 174 | } |
207 | EXPORT_SYMBOL(dma_set_mask); | 175 | |
176 | struct dma_map_ops alpha_noop_ops = { | ||
177 | .alloc_coherent = alpha_noop_alloc_coherent, | ||
178 | .free_coherent = alpha_noop_free_coherent, | ||
179 | .map_page = alpha_noop_map_page, | ||
180 | .map_sg = alpha_noop_map_sg, | ||
181 | .mapping_error = alpha_noop_mapping_error, | ||
182 | .dma_supported = alpha_noop_supported, | ||
183 | .set_dma_mask = alpha_noop_set_mask, | ||
184 | }; | ||
185 | |||
186 | struct dma_map_ops *dma_ops = &alpha_noop_ops; | ||
187 | EXPORT_SYMBOL(dma_ops); | ||
208 | 188 | ||
209 | void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) | 189 | void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) |
210 | { | 190 | { |
diff --git a/arch/alpha/kernel/pci-sysfs.c b/arch/alpha/kernel/pci-sysfs.c index 6ea822e7f724..d979e7c7bc4b 100644 --- a/arch/alpha/kernel/pci-sysfs.c +++ b/arch/alpha/kernel/pci-sysfs.c | |||
@@ -10,6 +10,7 @@ | |||
10 | */ | 10 | */ |
11 | 11 | ||
12 | #include <linux/sched.h> | 12 | #include <linux/sched.h> |
13 | #include <linux/slab.h> | ||
13 | #include <linux/pci.h> | 14 | #include <linux/pci.h> |
14 | 15 | ||
15 | static int hose_mmap_page_range(struct pci_controller *hose, | 16 | static int hose_mmap_page_range(struct pci_controller *hose, |
diff --git a/arch/alpha/kernel/pci.c b/arch/alpha/kernel/pci.c index a91ba28999b5..c9ab94ee1ca8 100644 --- a/arch/alpha/kernel/pci.c +++ b/arch/alpha/kernel/pci.c | |||
@@ -126,8 +126,8 @@ DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final); | |||
126 | #define MB (1024*KB) | 126 | #define MB (1024*KB) |
127 | #define GB (1024*MB) | 127 | #define GB (1024*MB) |
128 | 128 | ||
129 | void | 129 | resource_size_t |
130 | pcibios_align_resource(void *data, struct resource *res, | 130 | pcibios_align_resource(void *data, const struct resource *res, |
131 | resource_size_t size, resource_size_t align) | 131 | resource_size_t size, resource_size_t align) |
132 | { | 132 | { |
133 | struct pci_dev *dev = data; | 133 | struct pci_dev *dev = data; |
@@ -184,7 +184,7 @@ pcibios_align_resource(void *data, struct resource *res, | |||
184 | } | 184 | } |
185 | } | 185 | } |
186 | 186 | ||
187 | res->start = start; | 187 | return start; |
188 | } | 188 | } |
189 | #undef KB | 189 | #undef KB |
190 | #undef MB | 190 | #undef MB |
diff --git a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c index 8449504f5e0b..d1dbd9acd1df 100644 --- a/arch/alpha/kernel/pci_iommu.c +++ b/arch/alpha/kernel/pci_iommu.c | |||
@@ -5,7 +5,7 @@ | |||
5 | #include <linux/kernel.h> | 5 | #include <linux/kernel.h> |
6 | #include <linux/mm.h> | 6 | #include <linux/mm.h> |
7 | #include <linux/pci.h> | 7 | #include <linux/pci.h> |
8 | #include <linux/slab.h> | 8 | #include <linux/gfp.h> |
9 | #include <linux/bootmem.h> | 9 | #include <linux/bootmem.h> |
10 | #include <linux/scatterlist.h> | 10 | #include <linux/scatterlist.h> |
11 | #include <linux/log2.h> | 11 | #include <linux/log2.h> |
@@ -216,10 +216,30 @@ iommu_arena_free(struct pci_iommu_arena *arena, long ofs, long n) | |||
216 | for (i = 0; i < n; ++i) | 216 | for (i = 0; i < n; ++i) |
217 | p[i] = 0; | 217 | p[i] = 0; |
218 | } | 218 | } |
219 | 219 | ||
220 | /* True if the machine supports DAC addressing, and DEV can | 220 | /* |
221 | make use of it given MASK. */ | 221 | * True if the machine supports DAC addressing, and DEV can |
222 | static int pci_dac_dma_supported(struct pci_dev *hwdev, u64 mask); | 222 | * make use of it given MASK. |
223 | */ | ||
224 | static int pci_dac_dma_supported(struct pci_dev *dev, u64 mask) | ||
225 | { | ||
226 | dma64_addr_t dac_offset = alpha_mv.pci_dac_offset; | ||
227 | int ok = 1; | ||
228 | |||
229 | /* If this is not set, the machine doesn't support DAC at all. */ | ||
230 | if (dac_offset == 0) | ||
231 | ok = 0; | ||
232 | |||
233 | /* The device has to be able to address our DAC bit. */ | ||
234 | if ((dac_offset & dev->dma_mask) != dac_offset) | ||
235 | ok = 0; | ||
236 | |||
237 | /* If both conditions above are met, we are fine. */ | ||
238 | DBGA("pci_dac_dma_supported %s from %p\n", | ||
239 | ok ? "yes" : "no", __builtin_return_address(0)); | ||
240 | |||
241 | return ok; | ||
242 | } | ||
223 | 243 | ||
224 | /* Map a single buffer of the indicated size for PCI DMA in streaming | 244 | /* Map a single buffer of the indicated size for PCI DMA in streaming |
225 | mode. The 32-bit PCI bus mastering address to use is returned. | 245 | mode. The 32-bit PCI bus mastering address to use is returned. |
@@ -301,23 +321,36 @@ pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size, | |||
301 | return ret; | 321 | return ret; |
302 | } | 322 | } |
303 | 323 | ||
304 | dma_addr_t | 324 | /* Helper for generic DMA-mapping functions. */ |
305 | pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, int dir) | 325 | static struct pci_dev *alpha_gendev_to_pci(struct device *dev) |
306 | { | 326 | { |
307 | int dac_allowed; | 327 | if (dev && dev->bus == &pci_bus_type) |
328 | return to_pci_dev(dev); | ||
308 | 329 | ||
309 | if (dir == PCI_DMA_NONE) | 330 | /* Assume that non-PCI devices asking for DMA are either ISA or EISA, |
310 | BUG(); | 331 | BUG() otherwise. */ |
332 | BUG_ON(!isa_bridge); | ||
311 | 333 | ||
312 | dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; | 334 | /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA |
313 | return pci_map_single_1(pdev, cpu_addr, size, dac_allowed); | 335 | bridge is bus master then). */ |
336 | if (!dev || !dev->dma_mask || !*dev->dma_mask) | ||
337 | return isa_bridge; | ||
338 | |||
339 | /* For EISA bus masters, return isa_bridge (it might have smaller | ||
340 | dma_mask due to wiring limitations). */ | ||
341 | if (*dev->dma_mask >= isa_bridge->dma_mask) | ||
342 | return isa_bridge; | ||
343 | |||
344 | /* This assumes ISA bus master with dma_mask 0xffffff. */ | ||
345 | return NULL; | ||
314 | } | 346 | } |
315 | EXPORT_SYMBOL(pci_map_single); | ||
316 | 347 | ||
317 | dma_addr_t | 348 | static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page, |
318 | pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset, | 349 | unsigned long offset, size_t size, |
319 | size_t size, int dir) | 350 | enum dma_data_direction dir, |
351 | struct dma_attrs *attrs) | ||
320 | { | 352 | { |
353 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
321 | int dac_allowed; | 354 | int dac_allowed; |
322 | 355 | ||
323 | if (dir == PCI_DMA_NONE) | 356 | if (dir == PCI_DMA_NONE) |
@@ -327,7 +360,6 @@ pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset, | |||
327 | return pci_map_single_1(pdev, (char *)page_address(page) + offset, | 360 | return pci_map_single_1(pdev, (char *)page_address(page) + offset, |
328 | size, dac_allowed); | 361 | size, dac_allowed); |
329 | } | 362 | } |
330 | EXPORT_SYMBOL(pci_map_page); | ||
331 | 363 | ||
332 | /* Unmap a single streaming mode DMA translation. The DMA_ADDR and | 364 | /* Unmap a single streaming mode DMA translation. The DMA_ADDR and |
333 | SIZE must match what was provided for in a previous pci_map_single | 365 | SIZE must match what was provided for in a previous pci_map_single |
@@ -335,16 +367,17 @@ EXPORT_SYMBOL(pci_map_page); | |||
335 | the cpu to the buffer are guaranteed to see whatever the device | 367 | the cpu to the buffer are guaranteed to see whatever the device |
336 | wrote there. */ | 368 | wrote there. */ |
337 | 369 | ||
338 | void | 370 | static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr, |
339 | pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size, | 371 | size_t size, enum dma_data_direction dir, |
340 | int direction) | 372 | struct dma_attrs *attrs) |
341 | { | 373 | { |
342 | unsigned long flags; | 374 | unsigned long flags; |
375 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
343 | struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose; | 376 | struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose; |
344 | struct pci_iommu_arena *arena; | 377 | struct pci_iommu_arena *arena; |
345 | long dma_ofs, npages; | 378 | long dma_ofs, npages; |
346 | 379 | ||
347 | if (direction == PCI_DMA_NONE) | 380 | if (dir == PCI_DMA_NONE) |
348 | BUG(); | 381 | BUG(); |
349 | 382 | ||
350 | if (dma_addr >= __direct_map_base | 383 | if (dma_addr >= __direct_map_base |
@@ -393,25 +426,16 @@ pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size, | |||
393 | DBGA2("pci_unmap_single: sg [%llx,%zx] np %ld from %p\n", | 426 | DBGA2("pci_unmap_single: sg [%llx,%zx] np %ld from %p\n", |
394 | dma_addr, size, npages, __builtin_return_address(0)); | 427 | dma_addr, size, npages, __builtin_return_address(0)); |
395 | } | 428 | } |
396 | EXPORT_SYMBOL(pci_unmap_single); | ||
397 | |||
398 | void | ||
399 | pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr, | ||
400 | size_t size, int direction) | ||
401 | { | ||
402 | pci_unmap_single(pdev, dma_addr, size, direction); | ||
403 | } | ||
404 | EXPORT_SYMBOL(pci_unmap_page); | ||
405 | 429 | ||
406 | /* Allocate and map kernel buffer using consistent mode DMA for PCI | 430 | /* Allocate and map kernel buffer using consistent mode DMA for PCI |
407 | device. Returns non-NULL cpu-view pointer to the buffer if | 431 | device. Returns non-NULL cpu-view pointer to the buffer if |
408 | successful and sets *DMA_ADDRP to the pci side dma address as well, | 432 | successful and sets *DMA_ADDRP to the pci side dma address as well, |
409 | else DMA_ADDRP is undefined. */ | 433 | else DMA_ADDRP is undefined. */ |
410 | 434 | ||
411 | void * | 435 | static void *alpha_pci_alloc_coherent(struct device *dev, size_t size, |
412 | __pci_alloc_consistent(struct pci_dev *pdev, size_t size, | 436 | dma_addr_t *dma_addrp, gfp_t gfp) |
413 | dma_addr_t *dma_addrp, gfp_t gfp) | ||
414 | { | 437 | { |
438 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
415 | void *cpu_addr; | 439 | void *cpu_addr; |
416 | long order = get_order(size); | 440 | long order = get_order(size); |
417 | 441 | ||
@@ -439,13 +463,12 @@ try_again: | |||
439 | gfp |= GFP_DMA; | 463 | gfp |= GFP_DMA; |
440 | goto try_again; | 464 | goto try_again; |
441 | } | 465 | } |
442 | 466 | ||
443 | DBGA2("pci_alloc_consistent: %zx -> [%p,%llx] from %p\n", | 467 | DBGA2("pci_alloc_consistent: %zx -> [%p,%llx] from %p\n", |
444 | size, cpu_addr, *dma_addrp, __builtin_return_address(0)); | 468 | size, cpu_addr, *dma_addrp, __builtin_return_address(0)); |
445 | 469 | ||
446 | return cpu_addr; | 470 | return cpu_addr; |
447 | } | 471 | } |
448 | EXPORT_SYMBOL(__pci_alloc_consistent); | ||
449 | 472 | ||
450 | /* Free and unmap a consistent DMA buffer. CPU_ADDR and DMA_ADDR must | 473 | /* Free and unmap a consistent DMA buffer. CPU_ADDR and DMA_ADDR must |
451 | be values that were returned from pci_alloc_consistent. SIZE must | 474 | be values that were returned from pci_alloc_consistent. SIZE must |
@@ -453,17 +476,16 @@ EXPORT_SYMBOL(__pci_alloc_consistent); | |||
453 | References to the memory and mappings associated with CPU_ADDR or | 476 | References to the memory and mappings associated with CPU_ADDR or |
454 | DMA_ADDR past this call are illegal. */ | 477 | DMA_ADDR past this call are illegal. */ |
455 | 478 | ||
456 | void | 479 | static void alpha_pci_free_coherent(struct device *dev, size_t size, |
457 | pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr, | 480 | void *cpu_addr, dma_addr_t dma_addr) |
458 | dma_addr_t dma_addr) | ||
459 | { | 481 | { |
482 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
460 | pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL); | 483 | pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL); |
461 | free_pages((unsigned long)cpu_addr, get_order(size)); | 484 | free_pages((unsigned long)cpu_addr, get_order(size)); |
462 | 485 | ||
463 | DBGA2("pci_free_consistent: [%llx,%zx] from %p\n", | 486 | DBGA2("pci_free_consistent: [%llx,%zx] from %p\n", |
464 | dma_addr, size, __builtin_return_address(0)); | 487 | dma_addr, size, __builtin_return_address(0)); |
465 | } | 488 | } |
466 | EXPORT_SYMBOL(pci_free_consistent); | ||
467 | 489 | ||
468 | /* Classify the elements of the scatterlist. Write dma_address | 490 | /* Classify the elements of the scatterlist. Write dma_address |
469 | of each element with: | 491 | of each element with: |
@@ -626,23 +648,21 @@ sg_fill(struct device *dev, struct scatterlist *leader, struct scatterlist *end, | |||
626 | return 1; | 648 | return 1; |
627 | } | 649 | } |
628 | 650 | ||
629 | int | 651 | static int alpha_pci_map_sg(struct device *dev, struct scatterlist *sg, |
630 | pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | 652 | int nents, enum dma_data_direction dir, |
631 | int direction) | 653 | struct dma_attrs *attrs) |
632 | { | 654 | { |
655 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
633 | struct scatterlist *start, *end, *out; | 656 | struct scatterlist *start, *end, *out; |
634 | struct pci_controller *hose; | 657 | struct pci_controller *hose; |
635 | struct pci_iommu_arena *arena; | 658 | struct pci_iommu_arena *arena; |
636 | dma_addr_t max_dma; | 659 | dma_addr_t max_dma; |
637 | int dac_allowed; | 660 | int dac_allowed; |
638 | struct device *dev; | ||
639 | 661 | ||
640 | if (direction == PCI_DMA_NONE) | 662 | if (dir == PCI_DMA_NONE) |
641 | BUG(); | 663 | BUG(); |
642 | 664 | ||
643 | dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; | 665 | dac_allowed = dev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0; |
644 | |||
645 | dev = pdev ? &pdev->dev : NULL; | ||
646 | 666 | ||
647 | /* Fast path single entry scatterlists. */ | 667 | /* Fast path single entry scatterlists. */ |
648 | if (nents == 1) { | 668 | if (nents == 1) { |
@@ -699,19 +719,19 @@ pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | |||
699 | /* Some allocation failed while mapping the scatterlist | 719 | /* Some allocation failed while mapping the scatterlist |
700 | entries. Unmap them now. */ | 720 | entries. Unmap them now. */ |
701 | if (out > start) | 721 | if (out > start) |
702 | pci_unmap_sg(pdev, start, out - start, direction); | 722 | pci_unmap_sg(pdev, start, out - start, dir); |
703 | return 0; | 723 | return 0; |
704 | } | 724 | } |
705 | EXPORT_SYMBOL(pci_map_sg); | ||
706 | 725 | ||
707 | /* Unmap a set of streaming mode DMA translations. Again, cpu read | 726 | /* Unmap a set of streaming mode DMA translations. Again, cpu read |
708 | rules concerning calls here are the same as for pci_unmap_single() | 727 | rules concerning calls here are the same as for pci_unmap_single() |
709 | above. */ | 728 | above. */ |
710 | 729 | ||
711 | void | 730 | static void alpha_pci_unmap_sg(struct device *dev, struct scatterlist *sg, |
712 | pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | 731 | int nents, enum dma_data_direction dir, |
713 | int direction) | 732 | struct dma_attrs *attrs) |
714 | { | 733 | { |
734 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
715 | unsigned long flags; | 735 | unsigned long flags; |
716 | struct pci_controller *hose; | 736 | struct pci_controller *hose; |
717 | struct pci_iommu_arena *arena; | 737 | struct pci_iommu_arena *arena; |
@@ -719,7 +739,7 @@ pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | |||
719 | dma_addr_t max_dma; | 739 | dma_addr_t max_dma; |
720 | dma_addr_t fbeg, fend; | 740 | dma_addr_t fbeg, fend; |
721 | 741 | ||
722 | if (direction == PCI_DMA_NONE) | 742 | if (dir == PCI_DMA_NONE) |
723 | BUG(); | 743 | BUG(); |
724 | 744 | ||
725 | if (! alpha_mv.mv_pci_tbi) | 745 | if (! alpha_mv.mv_pci_tbi) |
@@ -783,15 +803,13 @@ pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents, | |||
783 | 803 | ||
784 | DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg)); | 804 | DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg)); |
785 | } | 805 | } |
786 | EXPORT_SYMBOL(pci_unmap_sg); | ||
787 | |||
788 | 806 | ||
789 | /* Return whether the given PCI device DMA address mask can be | 807 | /* Return whether the given PCI device DMA address mask can be |
790 | supported properly. */ | 808 | supported properly. */ |
791 | 809 | ||
792 | int | 810 | static int alpha_pci_supported(struct device *dev, u64 mask) |
793 | pci_dma_supported(struct pci_dev *pdev, u64 mask) | ||
794 | { | 811 | { |
812 | struct pci_dev *pdev = alpha_gendev_to_pci(dev); | ||
795 | struct pci_controller *hose; | 813 | struct pci_controller *hose; |
796 | struct pci_iommu_arena *arena; | 814 | struct pci_iommu_arena *arena; |
797 | 815 | ||
@@ -818,7 +836,6 @@ pci_dma_supported(struct pci_dev *pdev, u64 mask) | |||
818 | 836 | ||
819 | return 0; | 837 | return 0; |
820 | } | 838 | } |
821 | EXPORT_SYMBOL(pci_dma_supported); | ||
822 | 839 | ||
823 | 840 | ||
824 | /* | 841 | /* |
@@ -918,66 +935,32 @@ iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count) | |||
918 | return 0; | 935 | return 0; |
919 | } | 936 | } |
920 | 937 | ||
921 | /* True if the machine supports DAC addressing, and DEV can | 938 | static int alpha_pci_mapping_error(struct device *dev, dma_addr_t dma_addr) |
922 | make use of it given MASK. */ | ||
923 | |||
924 | static int | ||
925 | pci_dac_dma_supported(struct pci_dev *dev, u64 mask) | ||
926 | { | ||
927 | dma64_addr_t dac_offset = alpha_mv.pci_dac_offset; | ||
928 | int ok = 1; | ||
929 | |||
930 | /* If this is not set, the machine doesn't support DAC at all. */ | ||
931 | if (dac_offset == 0) | ||
932 | ok = 0; | ||
933 | |||
934 | /* The device has to be able to address our DAC bit. */ | ||
935 | if ((dac_offset & dev->dma_mask) != dac_offset) | ||
936 | ok = 0; | ||
937 | |||
938 | /* If both conditions above are met, we are fine. */ | ||
939 | DBGA("pci_dac_dma_supported %s from %p\n", | ||
940 | ok ? "yes" : "no", __builtin_return_address(0)); | ||
941 | |||
942 | return ok; | ||
943 | } | ||
944 | |||
945 | /* Helper for generic DMA-mapping functions. */ | ||
946 | |||
947 | struct pci_dev * | ||
948 | alpha_gendev_to_pci(struct device *dev) | ||
949 | { | 939 | { |
950 | if (dev && dev->bus == &pci_bus_type) | 940 | return dma_addr == 0; |
951 | return to_pci_dev(dev); | ||
952 | |||
953 | /* Assume that non-PCI devices asking for DMA are either ISA or EISA, | ||
954 | BUG() otherwise. */ | ||
955 | BUG_ON(!isa_bridge); | ||
956 | |||
957 | /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA | ||
958 | bridge is bus master then). */ | ||
959 | if (!dev || !dev->dma_mask || !*dev->dma_mask) | ||
960 | return isa_bridge; | ||
961 | |||
962 | /* For EISA bus masters, return isa_bridge (it might have smaller | ||
963 | dma_mask due to wiring limitations). */ | ||
964 | if (*dev->dma_mask >= isa_bridge->dma_mask) | ||
965 | return isa_bridge; | ||
966 | |||
967 | /* This assumes ISA bus master with dma_mask 0xffffff. */ | ||
968 | return NULL; | ||
969 | } | 941 | } |
970 | EXPORT_SYMBOL(alpha_gendev_to_pci); | ||
971 | 942 | ||
972 | int | 943 | static int alpha_pci_set_mask(struct device *dev, u64 mask) |
973 | dma_set_mask(struct device *dev, u64 mask) | ||
974 | { | 944 | { |
975 | if (!dev->dma_mask || | 945 | if (!dev->dma_mask || |
976 | !pci_dma_supported(alpha_gendev_to_pci(dev), mask)) | 946 | !pci_dma_supported(alpha_gendev_to_pci(dev), mask)) |
977 | return -EIO; | 947 | return -EIO; |
978 | 948 | ||
979 | *dev->dma_mask = mask; | 949 | *dev->dma_mask = mask; |
980 | |||
981 | return 0; | 950 | return 0; |
982 | } | 951 | } |
983 | EXPORT_SYMBOL(dma_set_mask); | 952 | |
953 | struct dma_map_ops alpha_pci_ops = { | ||
954 | .alloc_coherent = alpha_pci_alloc_coherent, | ||
955 | .free_coherent = alpha_pci_free_coherent, | ||
956 | .map_page = alpha_pci_map_page, | ||
957 | .unmap_page = alpha_pci_unmap_page, | ||
958 | .map_sg = alpha_pci_map_sg, | ||
959 | .unmap_sg = alpha_pci_unmap_sg, | ||
960 | .mapping_error = alpha_pci_mapping_error, | ||
961 | .dma_supported = alpha_pci_supported, | ||
962 | .set_dma_mask = alpha_pci_set_mask, | ||
963 | }; | ||
964 | |||
965 | struct dma_map_ops *dma_ops = &alpha_pci_ops; | ||
966 | EXPORT_SYMBOL(dma_ops); | ||
diff --git a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c index 289039bb6bb2..395a464353b8 100644 --- a/arch/alpha/kernel/process.c +++ b/arch/alpha/kernel/process.c | |||
@@ -17,7 +17,6 @@ | |||
17 | #include <linux/stddef.h> | 17 | #include <linux/stddef.h> |
18 | #include <linux/unistd.h> | 18 | #include <linux/unistd.h> |
19 | #include <linux/ptrace.h> | 19 | #include <linux/ptrace.h> |
20 | #include <linux/slab.h> | ||
21 | #include <linux/user.h> | 20 | #include <linux/user.h> |
22 | #include <linux/time.h> | 21 | #include <linux/time.h> |
23 | #include <linux/major.h> | 22 | #include <linux/major.h> |
@@ -28,6 +27,7 @@ | |||
28 | #include <linux/reboot.h> | 27 | #include <linux/reboot.h> |
29 | #include <linux/tty.h> | 28 | #include <linux/tty.h> |
30 | #include <linux/console.h> | 29 | #include <linux/console.h> |
30 | #include <linux/slab.h> | ||
31 | 31 | ||
32 | #include <asm/reg.h> | 32 | #include <asm/reg.h> |
33 | #include <asm/uaccess.h> | 33 | #include <asm/uaccess.h> |
diff --git a/arch/alpha/kernel/ptrace.c b/arch/alpha/kernel/ptrace.c index e072041d19f8..baa903602f6a 100644 --- a/arch/alpha/kernel/ptrace.c +++ b/arch/alpha/kernel/ptrace.c | |||
@@ -11,7 +11,6 @@ | |||
11 | #include <linux/errno.h> | 11 | #include <linux/errno.h> |
12 | #include <linux/ptrace.h> | 12 | #include <linux/ptrace.h> |
13 | #include <linux/user.h> | 13 | #include <linux/user.h> |
14 | #include <linux/slab.h> | ||
15 | #include <linux/security.h> | 14 | #include <linux/security.h> |
16 | #include <linux/signal.h> | 15 | #include <linux/signal.h> |
17 | 16 | ||
@@ -249,6 +248,17 @@ ptrace_cancel_bpt(struct task_struct * child) | |||
249 | return (nsaved != 0); | 248 | return (nsaved != 0); |
250 | } | 249 | } |
251 | 250 | ||
251 | void user_enable_single_step(struct task_struct *child) | ||
252 | { | ||
253 | /* Mark single stepping. */ | ||
254 | task_thread_info(child)->bpt_nsaved = -1; | ||
255 | } | ||
256 | |||
257 | void user_disable_single_step(struct task_struct *child) | ||
258 | { | ||
259 | ptrace_cancel_bpt(child); | ||
260 | } | ||
261 | |||
252 | /* | 262 | /* |
253 | * Called by kernel/ptrace.c when detaching.. | 263 | * Called by kernel/ptrace.c when detaching.. |
254 | * | 264 | * |
@@ -256,7 +266,7 @@ ptrace_cancel_bpt(struct task_struct * child) | |||
256 | */ | 266 | */ |
257 | void ptrace_disable(struct task_struct *child) | 267 | void ptrace_disable(struct task_struct *child) |
258 | { | 268 | { |
259 | ptrace_cancel_bpt(child); | 269 | user_disable_single_step(child); |
260 | } | 270 | } |
261 | 271 | ||
262 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) | 272 | long arch_ptrace(struct task_struct *child, long request, long addr, long data) |
@@ -295,52 +305,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data) | |||
295 | DBG(DBG_MEM, ("poke $%ld<-%#lx\n", addr, data)); | 305 | DBG(DBG_MEM, ("poke $%ld<-%#lx\n", addr, data)); |
296 | ret = put_reg(child, addr, data); | 306 | ret = put_reg(child, addr, data); |
297 | break; | 307 | break; |
298 | |||
299 | case PTRACE_SYSCALL: | ||
300 | /* continue and stop at next (return from) syscall */ | ||
301 | case PTRACE_CONT: /* restart after signal. */ | ||
302 | ret = -EIO; | ||
303 | if (!valid_signal(data)) | ||
304 | break; | ||
305 | if (request == PTRACE_SYSCALL) | ||
306 | set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | ||
307 | else | ||
308 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | ||
309 | child->exit_code = data; | ||
310 | /* make sure single-step breakpoint is gone. */ | ||
311 | ptrace_cancel_bpt(child); | ||
312 | wake_up_process(child); | ||
313 | ret = 0; | ||
314 | break; | ||
315 | |||
316 | /* | ||
317 | * Make the child exit. Best I can do is send it a sigkill. | ||
318 | * perhaps it should be put in the status that it wants to | ||
319 | * exit. | ||
320 | */ | ||
321 | case PTRACE_KILL: | ||
322 | ret = 0; | ||
323 | if (child->exit_state == EXIT_ZOMBIE) | ||
324 | break; | ||
325 | child->exit_code = SIGKILL; | ||
326 | /* make sure single-step breakpoint is gone. */ | ||
327 | ptrace_cancel_bpt(child); | ||
328 | wake_up_process(child); | ||
329 | break; | ||
330 | |||
331 | case PTRACE_SINGLESTEP: /* execute single instruction. */ | ||
332 | ret = -EIO; | ||
333 | if (!valid_signal(data)) | ||
334 | break; | ||
335 | /* Mark single stepping. */ | ||
336 | task_thread_info(child)->bpt_nsaved = -1; | ||
337 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); | ||
338 | child->exit_code = data; | ||
339 | wake_up_process(child); | ||
340 | /* give it a chance to run. */ | ||
341 | ret = 0; | ||
342 | break; | ||
343 | |||
344 | default: | 308 | default: |
345 | ret = ptrace_request(child, request, addr, data); | 309 | ret = ptrace_request(child, request, addr, data); |
346 | break; | 310 | break; |
diff --git a/arch/alpha/kernel/smc37c669.c b/arch/alpha/kernel/smc37c669.c index bca5bda90cde..0435921d41c6 100644 --- a/arch/alpha/kernel/smc37c669.c +++ b/arch/alpha/kernel/smc37c669.c | |||
@@ -3,7 +3,6 @@ | |||
3 | */ | 3 | */ |
4 | #include <linux/kernel.h> | 4 | #include <linux/kernel.h> |
5 | 5 | ||
6 | #include <linux/slab.h> | ||
7 | #include <linux/mm.h> | 6 | #include <linux/mm.h> |
8 | #include <linux/init.h> | 7 | #include <linux/init.h> |
9 | #include <linux/delay.h> | 8 | #include <linux/delay.h> |
diff --git a/arch/alpha/kernel/smc37c93x.c b/arch/alpha/kernel/smc37c93x.c index 2636cc028d06..3e6a2893af9f 100644 --- a/arch/alpha/kernel/smc37c93x.c +++ b/arch/alpha/kernel/smc37c93x.c | |||
@@ -4,7 +4,6 @@ | |||
4 | 4 | ||
5 | #include <linux/kernel.h> | 5 | #include <linux/kernel.h> |
6 | 6 | ||
7 | #include <linux/slab.h> | ||
8 | #include <linux/mm.h> | 7 | #include <linux/mm.h> |
9 | #include <linux/init.h> | 8 | #include <linux/init.h> |
10 | #include <linux/delay.h> | 9 | #include <linux/delay.h> |
diff --git a/arch/alpha/kernel/srm_env.c b/arch/alpha/kernel/srm_env.c index d12af472e1c0..4afc1a1e2e5a 100644 --- a/arch/alpha/kernel/srm_env.c +++ b/arch/alpha/kernel/srm_env.c | |||
@@ -30,9 +30,11 @@ | |||
30 | */ | 30 | */ |
31 | 31 | ||
32 | #include <linux/kernel.h> | 32 | #include <linux/kernel.h> |
33 | #include <linux/gfp.h> | ||
33 | #include <linux/module.h> | 34 | #include <linux/module.h> |
34 | #include <linux/init.h> | 35 | #include <linux/init.h> |
35 | #include <linux/proc_fs.h> | 36 | #include <linux/proc_fs.h> |
37 | #include <linux/seq_file.h> | ||
36 | #include <asm/console.h> | 38 | #include <asm/console.h> |
37 | #include <asm/uaccess.h> | 39 | #include <asm/uaccess.h> |
38 | #include <asm/machvec.h> | 40 | #include <asm/machvec.h> |
@@ -79,42 +81,41 @@ static srm_env_t srm_named_entries[] = { | |||
79 | static srm_env_t srm_numbered_entries[256]; | 81 | static srm_env_t srm_numbered_entries[256]; |
80 | 82 | ||
81 | 83 | ||
82 | static int | 84 | static int srm_env_proc_show(struct seq_file *m, void *v) |
83 | srm_env_read(char *page, char **start, off_t off, int count, int *eof, | ||
84 | void *data) | ||
85 | { | 85 | { |
86 | int nbytes; | ||
87 | unsigned long ret; | 86 | unsigned long ret; |
88 | srm_env_t *entry; | 87 | srm_env_t *entry; |
88 | char *page; | ||
89 | 89 | ||
90 | if (off != 0) { | 90 | entry = (srm_env_t *)m->private; |
91 | *eof = 1; | 91 | page = (char *)__get_free_page(GFP_USER); |
92 | return 0; | 92 | if (!page) |
93 | } | 93 | return -ENOMEM; |
94 | 94 | ||
95 | entry = (srm_env_t *) data; | 95 | ret = callback_getenv(entry->id, page, PAGE_SIZE); |
96 | ret = callback_getenv(entry->id, page, count); | ||
97 | 96 | ||
98 | if ((ret >> 61) == 0) { | 97 | if ((ret >> 61) == 0) { |
99 | nbytes = (int) ret; | 98 | seq_write(m, page, ret); |
100 | *eof = 1; | 99 | ret = 0; |
101 | } else | 100 | } else |
102 | nbytes = -EFAULT; | 101 | ret = -EFAULT; |
102 | free_page((unsigned long)page); | ||
103 | return ret; | ||
104 | } | ||
103 | 105 | ||
104 | return nbytes; | 106 | static int srm_env_proc_open(struct inode *inode, struct file *file) |
107 | { | ||
108 | return single_open(file, srm_env_proc_show, PDE(inode)->data); | ||
105 | } | 109 | } |
106 | 110 | ||
107 | static int | 111 | static ssize_t srm_env_proc_write(struct file *file, const char __user *buffer, |
108 | srm_env_write(struct file *file, const char __user *buffer, unsigned long count, | 112 | size_t count, loff_t *pos) |
109 | void *data) | ||
110 | { | 113 | { |
111 | int res; | 114 | int res; |
112 | srm_env_t *entry; | 115 | srm_env_t *entry = PDE(file->f_path.dentry->d_inode)->data; |
113 | char *buf = (char *) __get_free_page(GFP_USER); | 116 | char *buf = (char *) __get_free_page(GFP_USER); |
114 | unsigned long ret1, ret2; | 117 | unsigned long ret1, ret2; |
115 | 118 | ||
116 | entry = (srm_env_t *) data; | ||
117 | |||
118 | if (!buf) | 119 | if (!buf) |
119 | return -ENOMEM; | 120 | return -ENOMEM; |
120 | 121 | ||
@@ -140,6 +141,15 @@ srm_env_write(struct file *file, const char __user *buffer, unsigned long count, | |||
140 | return res; | 141 | return res; |
141 | } | 142 | } |
142 | 143 | ||
144 | static const struct file_operations srm_env_proc_fops = { | ||
145 | .owner = THIS_MODULE, | ||
146 | .open = srm_env_proc_open, | ||
147 | .read = seq_read, | ||
148 | .llseek = seq_lseek, | ||
149 | .release = single_release, | ||
150 | .write = srm_env_proc_write, | ||
151 | }; | ||
152 | |||
143 | static void | 153 | static void |
144 | srm_env_cleanup(void) | 154 | srm_env_cleanup(void) |
145 | { | 155 | { |
@@ -245,15 +255,10 @@ srm_env_init(void) | |||
245 | */ | 255 | */ |
246 | entry = srm_named_entries; | 256 | entry = srm_named_entries; |
247 | while (entry->name && entry->id) { | 257 | while (entry->name && entry->id) { |
248 | entry->proc_entry = create_proc_entry(entry->name, | 258 | entry->proc_entry = proc_create_data(entry->name, 0644, named_dir, |
249 | 0644, named_dir); | 259 | &srm_env_proc_fops, entry); |
250 | if (!entry->proc_entry) | 260 | if (!entry->proc_entry) |
251 | goto cleanup; | 261 | goto cleanup; |
252 | |||
253 | entry->proc_entry->data = (void *) entry; | ||
254 | entry->proc_entry->read_proc = srm_env_read; | ||
255 | entry->proc_entry->write_proc = srm_env_write; | ||
256 | |||
257 | entry++; | 262 | entry++; |
258 | } | 263 | } |
259 | 264 | ||
@@ -264,15 +269,12 @@ srm_env_init(void) | |||
264 | entry = &srm_numbered_entries[var_num]; | 269 | entry = &srm_numbered_entries[var_num]; |
265 | entry->name = number[var_num]; | 270 | entry->name = number[var_num]; |
266 | 271 | ||
267 | entry->proc_entry = create_proc_entry(entry->name, | 272 | entry->proc_entry = proc_create_data(entry->name, 0644, numbered_dir, |
268 | 0644, numbered_dir); | 273 | &srm_env_proc_fops, entry); |
269 | if (!entry->proc_entry) | 274 | if (!entry->proc_entry) |
270 | goto cleanup; | 275 | goto cleanup; |
271 | 276 | ||
272 | entry->id = var_num; | 277 | entry->id = var_num; |
273 | entry->proc_entry->data = (void *) entry; | ||
274 | entry->proc_entry->read_proc = srm_env_read; | ||
275 | entry->proc_entry->write_proc = srm_env_write; | ||
276 | } | 278 | } |
277 | 279 | ||
278 | printk(KERN_INFO "%s: version %s loaded successfully\n", NAME, | 280 | printk(KERN_INFO "%s: version %s loaded successfully\n", NAME, |
diff --git a/arch/alpha/kernel/sys_dp264.c b/arch/alpha/kernel/sys_dp264.c index d64e1e497e76..4026502ab707 100644 --- a/arch/alpha/kernel/sys_dp264.c +++ b/arch/alpha/kernel/sys_dp264.c | |||
@@ -224,7 +224,7 @@ static void | |||
224 | dp264_device_interrupt(unsigned long vector) | 224 | dp264_device_interrupt(unsigned long vector) |
225 | { | 225 | { |
226 | #if 1 | 226 | #if 1 |
227 | printk("dp264_device_interrupt: NOT IMPLEMENTED YET!! \n"); | 227 | printk("dp264_device_interrupt: NOT IMPLEMENTED YET!!\n"); |
228 | #else | 228 | #else |
229 | unsigned long pld; | 229 | unsigned long pld; |
230 | unsigned int i; | 230 | unsigned int i; |
diff --git a/arch/alpha/kernel/sys_titan.c b/arch/alpha/kernel/sys_titan.c index 288053342c83..9008d0f20c53 100644 --- a/arch/alpha/kernel/sys_titan.c +++ b/arch/alpha/kernel/sys_titan.c | |||
@@ -171,7 +171,7 @@ titan_set_irq_affinity(unsigned int irq, const struct cpumask *affinity) | |||
171 | static void | 171 | static void |
172 | titan_device_interrupt(unsigned long vector) | 172 | titan_device_interrupt(unsigned long vector) |
173 | { | 173 | { |
174 | printk("titan_device_interrupt: NOT IMPLEMENTED YET!! \n"); | 174 | printk("titan_device_interrupt: NOT IMPLEMENTED YET!!\n"); |
175 | } | 175 | } |
176 | 176 | ||
177 | static void | 177 | static void |
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S index 95c9aef1c106..09acb786e72b 100644 --- a/arch/alpha/kernel/systbls.S +++ b/arch/alpha/kernel/systbls.S | |||
@@ -495,8 +495,23 @@ sys_call_table: | |||
495 | .quad sys_epoll_pwait | 495 | .quad sys_epoll_pwait |
496 | .quad sys_utimensat /* 475 */ | 496 | .quad sys_utimensat /* 475 */ |
497 | .quad sys_signalfd | 497 | .quad sys_signalfd |
498 | .quad sys_ni_syscall | 498 | .quad sys_ni_syscall /* sys_timerfd */ |
499 | .quad sys_eventfd | 499 | .quad sys_eventfd |
500 | .quad sys_recvmmsg | ||
501 | .quad sys_fallocate /* 480 */ | ||
502 | .quad sys_timerfd_create | ||
503 | .quad sys_timerfd_settime | ||
504 | .quad sys_timerfd_gettime | ||
505 | .quad sys_signalfd4 | ||
506 | .quad sys_eventfd2 /* 485 */ | ||
507 | .quad sys_epoll_create1 | ||
508 | .quad sys_dup3 | ||
509 | .quad sys_pipe2 | ||
510 | .quad sys_inotify_init1 | ||
511 | .quad sys_preadv /* 490 */ | ||
512 | .quad sys_pwritev | ||
513 | .quad sys_rt_tgsigqueueinfo | ||
514 | .quad sys_perf_event_open | ||
500 | 515 | ||
501 | .size sys_call_table, . - sys_call_table | 516 | .size sys_call_table, . - sys_call_table |
502 | .type sys_call_table, @object | 517 | .type sys_call_table, @object |
diff --git a/arch/alpha/kernel/traps.c b/arch/alpha/kernel/traps.c index 6ee7655b7568..b14f015008ad 100644 --- a/arch/alpha/kernel/traps.c +++ b/arch/alpha/kernel/traps.c | |||
@@ -17,6 +17,7 @@ | |||
17 | #include <linux/module.h> | 17 | #include <linux/module.h> |
18 | #include <linux/init.h> | 18 | #include <linux/init.h> |
19 | #include <linux/kallsyms.h> | 19 | #include <linux/kallsyms.h> |
20 | #include <linux/ratelimit.h> | ||
20 | 21 | ||
21 | #include <asm/gentrap.h> | 22 | #include <asm/gentrap.h> |
22 | #include <asm/uaccess.h> | 23 | #include <asm/uaccess.h> |
@@ -771,8 +772,7 @@ asmlinkage void | |||
771 | do_entUnaUser(void __user * va, unsigned long opcode, | 772 | do_entUnaUser(void __user * va, unsigned long opcode, |
772 | unsigned long reg, struct pt_regs *regs) | 773 | unsigned long reg, struct pt_regs *regs) |
773 | { | 774 | { |
774 | static int cnt = 0; | 775 | static DEFINE_RATELIMIT_STATE(ratelimit, 5 * HZ, 5); |
775 | static unsigned long last_time; | ||
776 | 776 | ||
777 | unsigned long tmp1, tmp2, tmp3, tmp4; | 777 | unsigned long tmp1, tmp2, tmp3, tmp4; |
778 | unsigned long fake_reg, *reg_addr = &fake_reg; | 778 | unsigned long fake_reg, *reg_addr = &fake_reg; |
@@ -783,15 +783,11 @@ do_entUnaUser(void __user * va, unsigned long opcode, | |||
783 | with the unaliged access. */ | 783 | with the unaliged access. */ |
784 | 784 | ||
785 | if (!test_thread_flag (TIF_UAC_NOPRINT)) { | 785 | if (!test_thread_flag (TIF_UAC_NOPRINT)) { |
786 | if (cnt >= 5 && time_after(jiffies, last_time + 5 * HZ)) { | 786 | if (__ratelimit(&ratelimit)) { |
787 | cnt = 0; | ||
788 | } | ||
789 | if (++cnt < 5) { | ||
790 | printk("%s(%d): unaligned trap at %016lx: %p %lx %ld\n", | 787 | printk("%s(%d): unaligned trap at %016lx: %p %lx %ld\n", |
791 | current->comm, task_pid_nr(current), | 788 | current->comm, task_pid_nr(current), |
792 | regs->pc - 4, va, opcode, reg); | 789 | regs->pc - 4, va, opcode, reg); |
793 | } | 790 | } |
794 | last_time = jiffies; | ||
795 | } | 791 | } |
796 | if (test_thread_flag (TIF_UAC_SIGBUS)) | 792 | if (test_thread_flag (TIF_UAC_SIGBUS)) |
797 | goto give_sigbus; | 793 | goto give_sigbus; |