Jeff Dike | 2ea5bc5 | 2007-05-10 22:22:32 -0700 | [diff] [blame] | 1 | /* |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 2 | * Copyright (C) 2017 - Cambridge Greys Ltd |
| 3 | * Copyright (C) 2011 - 2014 Cisco Systems Inc |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 4 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * Licensed under the GPL |
| 6 | * Derived (i.e. mostly copied) from arch/i386/kernel/irq.c: |
| 7 | * Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar |
| 8 | */ |
| 9 | |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 10 | #include <linux/cpumask.h> |
| 11 | #include <linux/hardirq.h> |
| 12 | #include <linux/interrupt.h> |
| 13 | #include <linux/kernel_stat.h> |
| 14 | #include <linux/module.h> |
| 15 | #include <linux/sched.h> |
| 16 | #include <linux/seq_file.h> |
| 17 | #include <linux/slab.h> |
| 18 | #include <as-layout.h> |
| 19 | #include <kern_util.h> |
| 20 | #include <os.h> |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 21 | #include <irq_user.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 23 | |
| 24 | /* When epoll triggers we do not know why it did so |
| 25 | * we can also have different IRQs for read and write. |
| 26 | * This is why we keep a small irq_fd array for each fd - |
| 27 | * one entry per IRQ type |
Jeff Dike | d973a77 | 2007-05-06 14:51:27 -0700 | [diff] [blame] | 28 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 29 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 30 | struct irq_entry { |
| 31 | struct irq_entry *next; |
| 32 | int fd; |
| 33 | struct irq_fd *irq_array[MAX_IRQ_TYPE + 1]; |
| 34 | }; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 35 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 36 | static struct irq_entry *active_fds; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 37 | |
Jeff Dike | bfaafd7 | 2006-07-10 04:45:10 -0700 | [diff] [blame] | 38 | static DEFINE_SPINLOCK(irq_lock); |
| 39 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 40 | static void irq_io_loop(struct irq_fd *irq, struct uml_pt_regs *regs) |
| 41 | { |
| 42 | /* |
| 43 | * irq->active guards against reentry |
| 44 | * irq->pending accumulates pending requests |
| 45 | * if pending is raised the irq_handler is re-run |
| 46 | * until pending is cleared |
| 47 | */ |
| 48 | if (irq->active) { |
| 49 | irq->active = false; |
| 50 | do { |
| 51 | irq->pending = false; |
| 52 | do_IRQ(irq->irq, regs); |
| 53 | } while (irq->pending && (!irq->purge)); |
| 54 | if (!irq->purge) |
| 55 | irq->active = true; |
| 56 | } else { |
| 57 | irq->pending = true; |
| 58 | } |
| 59 | } |
| 60 | |
| 61 | void sigio_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs) |
| 62 | { |
| 63 | struct irq_entry *irq_entry; |
| 64 | struct irq_fd *irq; |
| 65 | |
| 66 | int n, i, j; |
| 67 | |
| 68 | while (1) { |
| 69 | /* This is now lockless - epoll keeps back-referencesto the irqs |
| 70 | * which have trigger it so there is no need to walk the irq |
| 71 | * list and lock it every time. We avoid locking by turning off |
| 72 | * IO for a specific fd by executing os_del_epoll_fd(fd) before |
| 73 | * we do any changes to the actual data structures |
| 74 | */ |
| 75 | n = os_waiting_for_events_epoll(); |
| 76 | |
| 77 | if (n <= 0) { |
| 78 | if (n == -EINTR) |
| 79 | continue; |
| 80 | else |
| 81 | break; |
| 82 | } |
| 83 | |
| 84 | for (i = 0; i < n ; i++) { |
| 85 | /* Epoll back reference is the entry with 3 irq_fd |
| 86 | * leaves - one for each irq type. |
| 87 | */ |
| 88 | irq_entry = (struct irq_entry *) |
| 89 | os_epoll_get_data_pointer(i); |
| 90 | for (j = 0; j < MAX_IRQ_TYPE ; j++) { |
| 91 | irq = irq_entry->irq_array[j]; |
| 92 | if (irq == NULL) |
| 93 | continue; |
| 94 | if (os_epoll_triggered(i, irq->events) > 0) |
| 95 | irq_io_loop(irq, regs); |
| 96 | if (irq->purge) { |
| 97 | irq_entry->irq_array[j] = NULL; |
| 98 | kfree(irq); |
| 99 | } |
| 100 | } |
| 101 | } |
| 102 | } |
| 103 | } |
| 104 | |
| 105 | static int assign_epoll_events_to_irq(struct irq_entry *irq_entry) |
| 106 | { |
| 107 | int i; |
| 108 | int events = 0; |
| 109 | struct irq_fd *irq; |
| 110 | |
| 111 | for (i = 0; i < MAX_IRQ_TYPE ; i++) { |
| 112 | irq = irq_entry->irq_array[i]; |
| 113 | if (irq != NULL) |
| 114 | events = irq->events | events; |
| 115 | } |
| 116 | if (events > 0) { |
| 117 | /* os_add_epoll will call os_mod_epoll if this already exists */ |
| 118 | return os_add_epoll_fd(events, irq_entry->fd, irq_entry); |
| 119 | } |
| 120 | /* No events - delete */ |
| 121 | return os_del_epoll_fd(irq_entry->fd); |
| 122 | } |
| 123 | |
| 124 | |
| 125 | |
WANG Cong | 4c182ae | 2008-07-23 21:28:47 -0700 | [diff] [blame] | 126 | static int activate_fd(int irq, int fd, int type, void *dev_id) |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 127 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 128 | struct irq_fd *new_fd; |
| 129 | struct irq_entry *irq_entry; |
| 130 | int i, err, events; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 131 | unsigned long flags; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 132 | |
Jeff Dike | bf8fde7 | 2008-02-04 22:31:04 -0800 | [diff] [blame] | 133 | err = os_set_fd_async(fd); |
Jesper Juhl | 191ef96 | 2006-05-01 12:15:57 -0700 | [diff] [blame] | 134 | if (err < 0) |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 135 | goto out; |
| 136 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 137 | spin_lock_irqsave(&irq_lock, flags); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 138 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 139 | /* Check if we have an entry for this fd */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 140 | |
Paolo 'Blaisorblade' Giarrusso | 0f97869 | 2007-03-07 20:41:13 -0800 | [diff] [blame] | 141 | err = -EBUSY; |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 142 | for (irq_entry = active_fds; |
| 143 | irq_entry != NULL; irq_entry = irq_entry->next) { |
| 144 | if (irq_entry->fd == fd) |
| 145 | break; |
| 146 | } |
| 147 | |
| 148 | if (irq_entry == NULL) { |
| 149 | /* This needs to be atomic as it may be called from an |
| 150 | * IRQ context. |
| 151 | */ |
| 152 | irq_entry = kmalloc(sizeof(struct irq_entry), GFP_ATOMIC); |
| 153 | if (irq_entry == NULL) { |
| 154 | printk(KERN_ERR |
| 155 | "Failed to allocate new IRQ entry\n"); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 156 | goto out_unlock; |
| 157 | } |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 158 | irq_entry->fd = fd; |
| 159 | for (i = 0; i < MAX_IRQ_TYPE; i++) |
| 160 | irq_entry->irq_array[i] = NULL; |
| 161 | irq_entry->next = active_fds; |
| 162 | active_fds = irq_entry; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 163 | } |
| 164 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 165 | /* Check if we are trying to re-register an interrupt for a |
| 166 | * particular fd |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 167 | */ |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 168 | |
| 169 | if (irq_entry->irq_array[type] != NULL) { |
| 170 | printk(KERN_ERR |
| 171 | "Trying to reregister IRQ %d FD %d TYPE %d ID %p\n", |
| 172 | irq, fd, type, dev_id |
| 173 | ); |
| 174 | goto out_unlock; |
| 175 | } else { |
| 176 | /* New entry for this fd */ |
| 177 | |
| 178 | err = -ENOMEM; |
| 179 | new_fd = kmalloc(sizeof(struct irq_fd), GFP_ATOMIC); |
| 180 | if (new_fd == NULL) |
| 181 | goto out_unlock; |
| 182 | |
| 183 | events = os_event_mask(type); |
| 184 | |
| 185 | *new_fd = ((struct irq_fd) { |
| 186 | .id = dev_id, |
| 187 | .irq = irq, |
| 188 | .type = type, |
| 189 | .events = events, |
| 190 | .active = true, |
| 191 | .pending = false, |
| 192 | .purge = false |
| 193 | }); |
| 194 | /* Turn off any IO on this fd - allows us to |
| 195 | * avoid locking the IRQ loop |
| 196 | */ |
| 197 | os_del_epoll_fd(irq_entry->fd); |
| 198 | irq_entry->irq_array[type] = new_fd; |
| 199 | } |
| 200 | |
| 201 | /* Turn back IO on with the correct (new) IO event mask */ |
| 202 | assign_epoll_events_to_irq(irq_entry); |
| 203 | spin_unlock_irqrestore(&irq_lock, flags); |
| 204 | maybe_sigio_broken(fd, (type != IRQ_NONE)); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 205 | |
Jeff Dike | 19bdf04 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 206 | return 0; |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 207 | out_unlock: |
Jeff Dike | bfaafd7 | 2006-07-10 04:45:10 -0700 | [diff] [blame] | 208 | spin_unlock_irqrestore(&irq_lock, flags); |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 209 | out: |
Jeff Dike | 19bdf04 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 210 | return err; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 211 | } |
| 212 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 213 | /* |
| 214 | * Walk the IRQ list and dispose of any unused entries. |
| 215 | * Should be done under irq_lock. |
| 216 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 217 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 218 | static void garbage_collect_irq_entries(void) |
| 219 | { |
| 220 | int i; |
| 221 | bool reap; |
| 222 | struct irq_entry *walk; |
| 223 | struct irq_entry *previous = NULL; |
| 224 | struct irq_entry *to_free; |
| 225 | |
| 226 | if (active_fds == NULL) |
| 227 | return; |
| 228 | walk = active_fds; |
| 229 | while (walk != NULL) { |
| 230 | reap = true; |
| 231 | for (i = 0; i < MAX_IRQ_TYPE ; i++) { |
| 232 | if (walk->irq_array[i] != NULL) { |
| 233 | reap = false; |
| 234 | break; |
| 235 | } |
| 236 | } |
| 237 | if (reap) { |
| 238 | if (previous == NULL) |
| 239 | active_fds = walk->next; |
| 240 | else |
| 241 | previous->next = walk->next; |
| 242 | to_free = walk; |
| 243 | } else { |
| 244 | to_free = NULL; |
| 245 | } |
| 246 | walk = walk->next; |
YueHaibing | d312a25 | 2018-08-03 14:39:11 +0800 | [diff] [blame^] | 247 | kfree(to_free); |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 248 | } |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 249 | } |
| 250 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 251 | /* |
| 252 | * Walk the IRQ list and get the descriptor for our FD |
| 253 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 254 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 255 | static struct irq_entry *get_irq_entry_by_fd(int fd) |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 256 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 257 | struct irq_entry *walk = active_fds; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 258 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 259 | while (walk != NULL) { |
| 260 | if (walk->fd == fd) |
| 261 | return walk; |
| 262 | walk = walk->next; |
| 263 | } |
| 264 | return NULL; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 265 | } |
| 266 | |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 267 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 268 | /* |
| 269 | * Walk the IRQ list and dispose of an entry for a specific |
| 270 | * device, fd and number. Note - if sharing an IRQ for read |
| 271 | * and writefor the same FD it will be disposed in either case. |
| 272 | * If this behaviour is undesirable use different IRQ ids. |
| 273 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 274 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 275 | #define IGNORE_IRQ 1 |
| 276 | #define IGNORE_DEV (1<<1) |
| 277 | |
| 278 | static void do_free_by_irq_and_dev( |
| 279 | struct irq_entry *irq_entry, |
| 280 | unsigned int irq, |
| 281 | void *dev, |
| 282 | int flags |
| 283 | ) |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 284 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 285 | int i; |
| 286 | struct irq_fd *to_free; |
| 287 | |
| 288 | for (i = 0; i < MAX_IRQ_TYPE ; i++) { |
| 289 | if (irq_entry->irq_array[i] != NULL) { |
| 290 | if ( |
| 291 | ((flags & IGNORE_IRQ) || |
| 292 | (irq_entry->irq_array[i]->irq == irq)) && |
| 293 | ((flags & IGNORE_DEV) || |
| 294 | (irq_entry->irq_array[i]->id == dev)) |
| 295 | ) { |
| 296 | /* Turn off any IO on this fd - allows us to |
| 297 | * avoid locking the IRQ loop |
| 298 | */ |
| 299 | os_del_epoll_fd(irq_entry->fd); |
| 300 | to_free = irq_entry->irq_array[i]; |
| 301 | irq_entry->irq_array[i] = NULL; |
| 302 | assign_epoll_events_to_irq(irq_entry); |
| 303 | if (to_free->active) |
| 304 | to_free->purge = true; |
| 305 | else |
| 306 | kfree(to_free); |
| 307 | } |
| 308 | } |
| 309 | } |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | void free_irq_by_fd(int fd) |
| 313 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 314 | struct irq_entry *to_free; |
| 315 | unsigned long flags; |
| 316 | |
| 317 | spin_lock_irqsave(&irq_lock, flags); |
| 318 | to_free = get_irq_entry_by_fd(fd); |
| 319 | if (to_free != NULL) { |
| 320 | do_free_by_irq_and_dev( |
| 321 | to_free, |
| 322 | -1, |
| 323 | NULL, |
| 324 | IGNORE_IRQ | IGNORE_DEV |
| 325 | ); |
| 326 | } |
| 327 | garbage_collect_irq_entries(); |
| 328 | spin_unlock_irqrestore(&irq_lock, flags); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 329 | } |
Anton Ivanov | f166850 | 2017-11-22 13:49:55 +0000 | [diff] [blame] | 330 | EXPORT_SYMBOL(free_irq_by_fd); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 331 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 332 | static void free_irq_by_irq_and_dev(unsigned int irq, void *dev) |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 333 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 334 | struct irq_entry *to_free; |
| 335 | unsigned long flags; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 336 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 337 | spin_lock_irqsave(&irq_lock, flags); |
| 338 | to_free = active_fds; |
| 339 | while (to_free != NULL) { |
| 340 | do_free_by_irq_and_dev( |
| 341 | to_free, |
| 342 | irq, |
| 343 | dev, |
| 344 | 0 |
| 345 | ); |
| 346 | to_free = to_free->next; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 347 | } |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 348 | garbage_collect_irq_entries(); |
| 349 | spin_unlock_irqrestore(&irq_lock, flags); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 350 | } |
| 351 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 352 | |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 353 | void reactivate_fd(int fd, int irqnum) |
| 354 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 355 | /** NOP - we do auto-EOI now **/ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 356 | } |
| 357 | |
| 358 | void deactivate_fd(int fd, int irqnum) |
| 359 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 360 | struct irq_entry *to_free; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 361 | unsigned long flags; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 362 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 363 | os_del_epoll_fd(fd); |
Jeff Dike | bfaafd7 | 2006-07-10 04:45:10 -0700 | [diff] [blame] | 364 | spin_lock_irqsave(&irq_lock, flags); |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 365 | to_free = get_irq_entry_by_fd(fd); |
| 366 | if (to_free != NULL) { |
| 367 | do_free_by_irq_and_dev( |
| 368 | to_free, |
| 369 | irqnum, |
| 370 | NULL, |
| 371 | IGNORE_DEV |
| 372 | ); |
Jeff Dike | 19bdf04 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 373 | } |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 374 | garbage_collect_irq_entries(); |
Jeff Dike | bfaafd7 | 2006-07-10 04:45:10 -0700 | [diff] [blame] | 375 | spin_unlock_irqrestore(&irq_lock, flags); |
Jeff Dike | 19bdf04 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 376 | ignore_sigio_fd(fd); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 377 | } |
Al Viro | 73395a0 | 2011-08-18 20:14:10 +0100 | [diff] [blame] | 378 | EXPORT_SYMBOL(deactivate_fd); |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 379 | |
Jeff Dike | d973a77 | 2007-05-06 14:51:27 -0700 | [diff] [blame] | 380 | /* |
| 381 | * Called just before shutdown in order to provide a clean exec |
| 382 | * environment in case the system is rebooting. No locking because |
| 383 | * that would cause a pointless shutdown hang if something hadn't |
| 384 | * released the lock. |
| 385 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 386 | int deactivate_all_fds(void) |
| 387 | { |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 388 | unsigned long flags; |
| 389 | struct irq_entry *to_free; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 390 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 391 | spin_lock_irqsave(&irq_lock, flags); |
| 392 | /* Stop IO. The IRQ loop has no lock so this is our |
| 393 | * only way of making sure we are safe to dispose |
| 394 | * of all IRQ handlers |
| 395 | */ |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 396 | os_set_ioignore(); |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 397 | to_free = active_fds; |
| 398 | while (to_free != NULL) { |
| 399 | do_free_by_irq_and_dev( |
| 400 | to_free, |
| 401 | -1, |
| 402 | NULL, |
| 403 | IGNORE_IRQ | IGNORE_DEV |
| 404 | ); |
| 405 | to_free = to_free->next; |
| 406 | } |
| 407 | garbage_collect_irq_entries(); |
| 408 | spin_unlock_irqrestore(&irq_lock, flags); |
| 409 | os_close_epoll_fd(); |
Jesper Juhl | 191ef96 | 2006-05-01 12:15:57 -0700 | [diff] [blame] | 410 | return 0; |
Jeff Dike | 9b4f018 | 2006-03-27 01:14:31 -0800 | [diff] [blame] | 411 | } |
| 412 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | /* |
Simon Arlott | b60745b | 2007-10-20 01:23:03 +0200 | [diff] [blame] | 414 | * do_IRQ handles all normal device IRQs (the special |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | * SMP cross-CPU interrupts have their own specific |
| 416 | * handlers). |
| 417 | */ |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 418 | unsigned int do_IRQ(int irq, struct uml_pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | { |
Al Viro | 7bea96f | 2006-10-08 22:49:34 +0100 | [diff] [blame] | 420 | struct pt_regs *old_regs = set_irq_regs((struct pt_regs *)regs); |
| 421 | irq_enter(); |
Richard Weinberger | be76d81 | 2010-10-26 14:22:20 -0700 | [diff] [blame] | 422 | generic_handle_irq(irq); |
Al Viro | 7bea96f | 2006-10-08 22:49:34 +0100 | [diff] [blame] | 423 | irq_exit(); |
| 424 | set_irq_regs(old_regs); |
| 425 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 426 | } |
| 427 | |
Richard Weinberger | fa7a044 | 2012-04-17 22:37:13 +0200 | [diff] [blame] | 428 | void um_free_irq(unsigned int irq, void *dev) |
| 429 | { |
| 430 | free_irq_by_irq_and_dev(irq, dev); |
| 431 | free_irq(irq, dev); |
| 432 | } |
| 433 | EXPORT_SYMBOL(um_free_irq); |
| 434 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | int um_request_irq(unsigned int irq, int fd, int type, |
David Howells | 40220c1 | 2006-10-09 12:19:47 +0100 | [diff] [blame] | 436 | irq_handler_t handler, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | unsigned long irqflags, const char * devname, |
| 438 | void *dev_id) |
| 439 | { |
| 440 | int err; |
| 441 | |
Jeff Dike | 9ac625a | 2007-11-14 17:00:23 -0800 | [diff] [blame] | 442 | if (fd != -1) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | err = activate_fd(irq, fd, type, dev_id); |
Jeff Dike | 9ac625a | 2007-11-14 17:00:23 -0800 | [diff] [blame] | 444 | if (err) |
| 445 | return err; |
| 446 | } |
| 447 | |
| 448 | return request_irq(irq, handler, irqflags, devname, dev_id); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | } |
Jeff Dike | 9ac625a | 2007-11-14 17:00:23 -0800 | [diff] [blame] | 450 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | EXPORT_SYMBOL(um_request_irq); |
| 452 | EXPORT_SYMBOL(reactivate_fd); |
| 453 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 454 | /* |
Thomas Gleixner | 1d119aa | 2011-02-06 22:45:34 +0000 | [diff] [blame] | 455 | * irq_chip must define at least enable/disable and ack when |
| 456 | * the edge handler is used. |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 457 | */ |
Thomas Gleixner | 1d119aa | 2011-02-06 22:45:34 +0000 | [diff] [blame] | 458 | static void dummy(struct irq_data *d) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 459 | { |
| 460 | } |
| 461 | |
Paolo 'Blaisorblade' Giarrusso | dbce706 | 2005-06-21 17:16:19 -0700 | [diff] [blame] | 462 | /* This is used for everything else than the timer. */ |
Thomas Gleixner | 6fa851c | 2009-06-16 15:33:29 -0700 | [diff] [blame] | 463 | static struct irq_chip normal_irq_type = { |
Thomas Gleixner | d1ea13c | 2010-09-23 18:40:07 +0200 | [diff] [blame] | 464 | .name = "SIGIO", |
Thomas Gleixner | 1d119aa | 2011-02-06 22:45:34 +0000 | [diff] [blame] | 465 | .irq_disable = dummy, |
| 466 | .irq_enable = dummy, |
| 467 | .irq_ack = dummy, |
Richard Weinberger | 81bab4c | 2013-09-02 22:49:22 +0200 | [diff] [blame] | 468 | .irq_mask = dummy, |
| 469 | .irq_unmask = dummy, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | }; |
| 471 | |
Thomas Gleixner | 6fa851c | 2009-06-16 15:33:29 -0700 | [diff] [blame] | 472 | static struct irq_chip SIGVTALRM_irq_type = { |
Thomas Gleixner | d1ea13c | 2010-09-23 18:40:07 +0200 | [diff] [blame] | 473 | .name = "SIGVTALRM", |
Thomas Gleixner | 1d119aa | 2011-02-06 22:45:34 +0000 | [diff] [blame] | 474 | .irq_disable = dummy, |
| 475 | .irq_enable = dummy, |
| 476 | .irq_ack = dummy, |
Richard Weinberger | 81bab4c | 2013-09-02 22:49:22 +0200 | [diff] [blame] | 477 | .irq_mask = dummy, |
| 478 | .irq_unmask = dummy, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | }; |
| 480 | |
| 481 | void __init init_IRQ(void) |
| 482 | { |
| 483 | int i; |
| 484 | |
Thomas Gleixner | 0ebec35 | 2011-03-24 18:24:42 +0100 | [diff] [blame] | 485 | irq_set_chip_and_handler(TIMER_IRQ, &SIGVTALRM_irq_type, handle_edge_irq); |
Richard Weinberger | be76d81 | 2010-10-26 14:22:20 -0700 | [diff] [blame] | 486 | |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 487 | |
Thomas Gleixner | 0ebec35 | 2011-03-24 18:24:42 +0100 | [diff] [blame] | 488 | for (i = 1; i < NR_IRQS; i++) |
| 489 | irq_set_chip_and_handler(i, &normal_irq_type, handle_edge_irq); |
Anton Ivanov | ff6a179 | 2017-11-20 21:17:58 +0000 | [diff] [blame] | 490 | /* Initialize EPOLL Loop */ |
| 491 | os_setup_epoll(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 492 | } |
| 493 | |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 494 | /* |
| 495 | * IRQ stack entry and exit: |
| 496 | * |
| 497 | * Unlike i386, UML doesn't receive IRQs on the normal kernel stack |
| 498 | * and switch over to the IRQ stack after some preparation. We use |
| 499 | * sigaltstack to receive signals on a separate stack from the start. |
| 500 | * These two functions make sure the rest of the kernel won't be too |
| 501 | * upset by being on a different stack. The IRQ stack has a |
| 502 | * thread_info structure at the bottom so that current et al continue |
| 503 | * to work. |
| 504 | * |
| 505 | * to_irq_stack copies the current task's thread_info to the IRQ stack |
| 506 | * thread_info and sets the tasks's stack to point to the IRQ stack. |
| 507 | * |
| 508 | * from_irq_stack copies the thread_info struct back (flags may have |
| 509 | * been modified) and resets the task's stack pointer. |
| 510 | * |
| 511 | * Tricky bits - |
| 512 | * |
| 513 | * What happens when two signals race each other? UML doesn't block |
| 514 | * signals with sigprocmask, SA_DEFER, or sa_mask, so a second signal |
| 515 | * could arrive while a previous one is still setting up the |
| 516 | * thread_info. |
| 517 | * |
| 518 | * There are three cases - |
| 519 | * The first interrupt on the stack - sets up the thread_info and |
| 520 | * handles the interrupt |
| 521 | * A nested interrupt interrupting the copying of the thread_info - |
| 522 | * can't handle the interrupt, as the stack is in an unknown state |
| 523 | * A nested interrupt not interrupting the copying of the |
| 524 | * thread_info - doesn't do any setup, just handles the interrupt |
| 525 | * |
| 526 | * The first job is to figure out whether we interrupted stack setup. |
| 527 | * This is done by xchging the signal mask with thread_info->pending. |
| 528 | * If the value that comes back is zero, then there is no setup in |
| 529 | * progress, and the interrupt can be handled. If the value is |
| 530 | * non-zero, then there is stack setup in progress. In order to have |
| 531 | * the interrupt handled, we leave our signal in the mask, and it will |
| 532 | * be handled by the upper handler after it has set up the stack. |
| 533 | * |
| 534 | * Next is to figure out whether we are the outer handler or a nested |
| 535 | * one. As part of setting up the stack, thread_info->real_thread is |
| 536 | * set to non-NULL (and is reset to NULL on exit). This is the |
| 537 | * nesting indicator. If it is non-NULL, then the stack is already |
| 538 | * set up and the handler can run. |
| 539 | */ |
| 540 | |
| 541 | static unsigned long pending_mask; |
| 542 | |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 543 | unsigned long to_irq_stack(unsigned long *mask_out) |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 544 | { |
| 545 | struct thread_info *ti; |
| 546 | unsigned long mask, old; |
| 547 | int nested; |
| 548 | |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 549 | mask = xchg(&pending_mask, *mask_out); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 550 | if (mask != 0) { |
| 551 | /* |
| 552 | * If any interrupts come in at this point, we want to |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 553 | * make sure that their bits aren't lost by our |
| 554 | * putting our bit in. So, this loop accumulates bits |
| 555 | * until xchg returns the same value that we put in. |
| 556 | * When that happens, there were no new interrupts, |
| 557 | * and pending_mask contains a bit for each interrupt |
| 558 | * that came in. |
| 559 | */ |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 560 | old = *mask_out; |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 561 | do { |
| 562 | old |= mask; |
| 563 | mask = xchg(&pending_mask, old); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 564 | } while (mask != old); |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 565 | return 1; |
| 566 | } |
| 567 | |
| 568 | ti = current_thread_info(); |
| 569 | nested = (ti->real_thread != NULL); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 570 | if (!nested) { |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 571 | struct task_struct *task; |
| 572 | struct thread_info *tti; |
| 573 | |
| 574 | task = cpu_tasks[ti->cpu].task; |
| 575 | tti = task_thread_info(task); |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 576 | |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 577 | *ti = *tti; |
| 578 | ti->real_thread = tti; |
| 579 | task->stack = ti; |
| 580 | } |
| 581 | |
| 582 | mask = xchg(&pending_mask, 0); |
| 583 | *mask_out |= mask | nested; |
| 584 | return 0; |
| 585 | } |
| 586 | |
| 587 | unsigned long from_irq_stack(int nested) |
| 588 | { |
| 589 | struct thread_info *ti, *to; |
| 590 | unsigned long mask; |
| 591 | |
| 592 | ti = current_thread_info(); |
| 593 | |
| 594 | pending_mask = 1; |
| 595 | |
| 596 | to = ti->real_thread; |
| 597 | current->stack = to; |
| 598 | ti->real_thread = NULL; |
| 599 | *to = *ti; |
| 600 | |
| 601 | mask = xchg(&pending_mask, 0); |
| 602 | return mask & ~1; |
| 603 | } |
| 604 | |