~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sh/kernel/io_trapped.c

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Trapped io support
  3  *
  4  * Copyright (C) 2008 Magnus Damm
  5  *
  6  * Intercept io operations by trapping.
  7  *
  8  * This file is subject to the terms and conditions of the GNU General Public
  9  * License.  See the file "COPYING" in the main directory of this archive
 10  * for more details.
 11  */
 12 #include <linux/kernel.h>
 13 #include <linux/mm.h>
 14 #include <linux/bitops.h>
 15 #include <linux/vmalloc.h>
 16 #include <linux/module.h>
 17 #include <linux/init.h>
 18 #include <asm/mmu_context.h>
 19 #include <asm/uaccess.h>
 20 #include <asm/io.h>
 21 #include <asm/io_trapped.h>
 22 
 23 #define TRAPPED_PAGES_MAX 16
 24 
 25 #ifdef CONFIG_HAS_IOPORT_MAP
 26 LIST_HEAD(trapped_io);
 27 EXPORT_SYMBOL_GPL(trapped_io);
 28 #endif
 29 #ifdef CONFIG_HAS_IOMEM
 30 LIST_HEAD(trapped_mem);
 31 EXPORT_SYMBOL_GPL(trapped_mem);
 32 #endif
 33 static DEFINE_SPINLOCK(trapped_lock);
 34 
 35 static int trapped_io_disable __read_mostly;
 36 
 37 static int __init trapped_io_setup(char *__unused)
 38 {
 39         trapped_io_disable = 1;
 40         return 1;
 41 }
 42 __setup("noiotrap", trapped_io_setup);
 43 
 44 int register_trapped_io(struct trapped_io *tiop)
 45 {
 46         struct resource *res;
 47         unsigned long len = 0, flags = 0;
 48         struct page *pages[TRAPPED_PAGES_MAX];
 49         int k, n;
 50 
 51         if (unlikely(trapped_io_disable))
 52                 return 0;
 53 
 54         /* structure must be page aligned */
 55         if ((unsigned long)tiop & (PAGE_SIZE - 1))
 56                 goto bad;
 57 
 58         for (k = 0; k < tiop->num_resources; k++) {
 59                 res = tiop->resource + k;
 60                 len += roundup(resource_size(res), PAGE_SIZE);
 61                 flags |= res->flags;
 62         }
 63 
 64         /* support IORESOURCE_IO _or_ MEM, not both */
 65         if (hweight_long(flags) != 1)
 66                 goto bad;
 67 
 68         n = len >> PAGE_SHIFT;
 69 
 70         if (n >= TRAPPED_PAGES_MAX)
 71                 goto bad;
 72 
 73         for (k = 0; k < n; k++)
 74                 pages[k] = virt_to_page(tiop);
 75 
 76         tiop->virt_base = vmap(pages, n, VM_MAP, PAGE_NONE);
 77         if (!tiop->virt_base)
 78                 goto bad;
 79 
 80         len = 0;
 81         for (k = 0; k < tiop->num_resources; k++) {
 82                 res = tiop->resource + k;
 83                 pr_info("trapped io 0x%08lx overrides %s 0x%08lx\n",
 84                        (unsigned long)(tiop->virt_base + len),
 85                        res->flags & IORESOURCE_IO ? "io" : "mmio",
 86                        (unsigned long)res->start);
 87                 len += roundup(resource_size(res), PAGE_SIZE);
 88         }
 89 
 90         tiop->magic = IO_TRAPPED_MAGIC;
 91         INIT_LIST_HEAD(&tiop->list);
 92         spin_lock_irq(&trapped_lock);
 93 #ifdef CONFIG_HAS_IOPORT_MAP
 94         if (flags & IORESOURCE_IO)
 95                 list_add(&tiop->list, &trapped_io);
 96 #endif
 97 #ifdef CONFIG_HAS_IOMEM
 98         if (flags & IORESOURCE_MEM)
 99                 list_add(&tiop->list, &trapped_mem);
100 #endif
101         spin_unlock_irq(&trapped_lock);
102 
103         return 0;
104  bad:
105         pr_warning("unable to install trapped io filter\n");
106         return -1;
107 }
108 EXPORT_SYMBOL_GPL(register_trapped_io);
109 
110 void __iomem *match_trapped_io_handler(struct list_head *list,
111                                        unsigned long offset,
112                                        unsigned long size)
113 {
114         unsigned long voffs;
115         struct trapped_io *tiop;
116         struct resource *res;
117         int k, len;
118         unsigned long flags;
119 
120         spin_lock_irqsave(&trapped_lock, flags);
121         list_for_each_entry(tiop, list, list) {
122                 voffs = 0;
123                 for (k = 0; k < tiop->num_resources; k++) {
124                         res = tiop->resource + k;
125                         if (res->start == offset) {
126                                 spin_unlock_irqrestore(&trapped_lock, flags);
127                                 return tiop->virt_base + voffs;
128                         }
129 
130                         len = resource_size(res);
131                         voffs += roundup(len, PAGE_SIZE);
132                 }
133         }
134         spin_unlock_irqrestore(&trapped_lock, flags);
135         return NULL;
136 }
137 EXPORT_SYMBOL_GPL(match_trapped_io_handler);
138 
139 static struct trapped_io *lookup_tiop(unsigned long address)
140 {
141         pgd_t *pgd_k;
142         pud_t *pud_k;
143         pmd_t *pmd_k;
144         pte_t *pte_k;
145         pte_t entry;
146 
147         pgd_k = swapper_pg_dir + pgd_index(address);
148         if (!pgd_present(*pgd_k))
149                 return NULL;
150 
151         pud_k = pud_offset(pgd_k, address);
152         if (!pud_present(*pud_k))
153                 return NULL;
154 
155         pmd_k = pmd_offset(pud_k, address);
156         if (!pmd_present(*pmd_k))
157                 return NULL;
158 
159         pte_k = pte_offset_kernel(pmd_k, address);
160         entry = *pte_k;
161 
162         return pfn_to_kaddr(pte_pfn(entry));
163 }
164 
165 static unsigned long lookup_address(struct trapped_io *tiop,
166                                     unsigned long address)
167 {
168         struct resource *res;
169         unsigned long vaddr = (unsigned long)tiop->virt_base;
170         unsigned long len;
171         int k;
172 
173         for (k = 0; k < tiop->num_resources; k++) {
174                 res = tiop->resource + k;
175                 len = roundup(resource_size(res), PAGE_SIZE);
176                 if (address < (vaddr + len))
177                         return res->start + (address - vaddr);
178                 vaddr += len;
179         }
180         return 0;
181 }
182 
183 static unsigned long long copy_word(unsigned long src_addr, int src_len,
184                                     unsigned long dst_addr, int dst_len)
185 {
186         unsigned long long tmp = 0;
187 
188         switch (src_len) {
189         case 1:
190                 tmp = __raw_readb(src_addr);
191                 break;
192         case 2:
193                 tmp = __raw_readw(src_addr);
194                 break;
195         case 4:
196                 tmp = __raw_readl(src_addr);
197                 break;
198         case 8:
199                 tmp = __raw_readq(src_addr);
200                 break;
201         }
202 
203         switch (dst_len) {
204         case 1:
205                 __raw_writeb(tmp, dst_addr);
206                 break;
207         case 2:
208                 __raw_writew(tmp, dst_addr);
209                 break;
210         case 4:
211                 __raw_writel(tmp, dst_addr);
212                 break;
213         case 8:
214                 __raw_writeq(tmp, dst_addr);
215                 break;
216         }
217 
218         return tmp;
219 }
220 
221 static unsigned long from_device(void *dst, const void *src, unsigned long cnt)
222 {
223         struct trapped_io *tiop;
224         unsigned long src_addr = (unsigned long)src;
225         unsigned long long tmp;
226 
227         pr_debug("trapped io read 0x%08lx (%ld)\n", src_addr, cnt);
228         tiop = lookup_tiop(src_addr);
229         WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
230 
231         src_addr = lookup_address(tiop, src_addr);
232         if (!src_addr)
233                 return cnt;
234 
235         tmp = copy_word(src_addr,
236                         max_t(unsigned long, cnt,
237                               (tiop->minimum_bus_width / 8)),
238                         (unsigned long)dst, cnt);
239 
240         pr_debug("trapped io read 0x%08lx -> 0x%08llx\n", src_addr, tmp);
241         return 0;
242 }
243 
244 static unsigned long to_device(void *dst, const void *src, unsigned long cnt)
245 {
246         struct trapped_io *tiop;
247         unsigned long dst_addr = (unsigned long)dst;
248         unsigned long long tmp;
249 
250         pr_debug("trapped io write 0x%08lx (%ld)\n", dst_addr, cnt);
251         tiop = lookup_tiop(dst_addr);
252         WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
253 
254         dst_addr = lookup_address(tiop, dst_addr);
255         if (!dst_addr)
256                 return cnt;
257 
258         tmp = copy_word((unsigned long)src, cnt,
259                         dst_addr, max_t(unsigned long, cnt,
260                                         (tiop->minimum_bus_width / 8)));
261 
262         pr_debug("trapped io write 0x%08lx -> 0x%08llx\n", dst_addr, tmp);
263         return 0;
264 }
265 
266 static struct mem_access trapped_io_access = {
267         from_device,
268         to_device,
269 };
270 
271 int handle_trapped_io(struct pt_regs *regs, unsigned long address)
272 {
273         mm_segment_t oldfs;
274         insn_size_t instruction;
275         int tmp;
276 
277         if (trapped_io_disable)
278                 return 0;
279         if (!lookup_tiop(address))
280                 return 0;
281 
282         WARN_ON(user_mode(regs));
283 
284         oldfs = get_fs();
285         set_fs(KERNEL_DS);
286         if (copy_from_user(&instruction, (void *)(regs->pc),
287                            sizeof(instruction))) {
288                 set_fs(oldfs);
289                 return 0;
290         }
291 
292         tmp = handle_unaligned_access(instruction, regs,
293                                       &trapped_io_access, 1, address);
294         set_fs(oldfs);
295         return tmp == 0;
296 }
297 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp