Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 1 | /* |
| 2 | * SPU file system -- SPU context management |
| 3 | * |
| 4 | * (C) Copyright IBM Deutschland Entwicklung GmbH 2005 |
| 5 | * |
| 6 | * Author: Arnd Bergmann <arndb@de.ibm.com> |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License as published by |
| 10 | * the Free Software Foundation; either version 2, or (at your option) |
| 11 | * any later version. |
| 12 | * |
| 13 | * This program is distributed in the hope that it will be useful, |
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 | * GNU General Public License for more details. |
| 17 | * |
| 18 | * You should have received a copy of the GNU General Public License |
| 19 | * along with this program; if not, write to the Free Software |
| 20 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 21 | */ |
| 22 | |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 23 | #include <linux/fs.h> |
| 24 | #include <linux/mm.h> |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 25 | #include <linux/slab.h> |
| 26 | #include <asm/spu.h> |
Mark Nutter | 5473af0 | 2005-11-15 15:53:49 -0500 | [diff] [blame] | 27 | #include <asm/spu_csa.h> |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 28 | #include "spufs.h" |
| 29 | |
Arnd Bergmann | 6263203 | 2006-10-04 17:26:15 +0200 | [diff] [blame] | 30 | struct spu_context *alloc_spu_context(struct spu_gang *gang) |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 31 | { |
| 32 | struct spu_context *ctx; |
Jeremy Kerr | c5c4591 | 2006-04-28 16:37:47 +0800 | [diff] [blame] | 33 | ctx = kzalloc(sizeof *ctx, GFP_KERNEL); |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 34 | if (!ctx) |
| 35 | goto out; |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 36 | /* Binding to physical processor deferred |
| 37 | * until spu_activate(). |
Mark Nutter | 5473af0 | 2005-11-15 15:53:49 -0500 | [diff] [blame] | 38 | */ |
Mark Nutter | 5473af0 | 2005-11-15 15:53:49 -0500 | [diff] [blame] | 39 | spu_init_csa(&ctx->csa); |
| 40 | if (!ctx->csa.lscsa) { |
Mark Nutter | 5473af0 | 2005-11-15 15:53:49 -0500 | [diff] [blame] | 41 | goto out_free; |
| 42 | } |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 43 | spin_lock_init(&ctx->mmio_lock); |
Christoph Hellwig | 43c2bbd | 2007-04-23 21:08:07 +0200 | [diff] [blame^] | 44 | spin_lock_init(&ctx->mapping_lock); |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 45 | kref_init(&ctx->kref); |
Christoph Hellwig | 650f8b0 | 2007-02-13 21:36:50 +0100 | [diff] [blame] | 46 | mutex_init(&ctx->state_mutex); |
Arnd Bergmann | 5ef8224 | 2006-01-04 20:31:24 +0100 | [diff] [blame] | 47 | init_MUTEX(&ctx->run_sema); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 48 | init_waitqueue_head(&ctx->ibox_wq); |
| 49 | init_waitqueue_head(&ctx->wbox_wq); |
Arnd Bergmann | 5110459 | 2005-12-05 22:52:25 -0500 | [diff] [blame] | 50 | init_waitqueue_head(&ctx->stop_wq); |
Arnd Bergmann | a33a7d7 | 2006-03-23 00:00:11 +0100 | [diff] [blame] | 51 | init_waitqueue_head(&ctx->mfc_wq); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 52 | ctx->state = SPU_STATE_SAVED; |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 53 | ctx->ops = &spu_backing_ops; |
| 54 | ctx->owner = get_task_mm(current); |
Arnd Bergmann | 6263203 | 2006-10-04 17:26:15 +0200 | [diff] [blame] | 55 | if (gang) |
| 56 | spu_gang_add_ctx(gang, ctx); |
Christoph Hellwig | 52f04fc | 2007-02-13 21:54:27 +0100 | [diff] [blame] | 57 | ctx->rt_priority = current->rt_priority; |
Christoph Hellwig | 2eb1b12 | 2007-02-13 21:54:29 +0100 | [diff] [blame] | 58 | ctx->policy = current->policy; |
Christoph Hellwig | 8389998 | 2007-02-13 21:54:22 +0100 | [diff] [blame] | 59 | ctx->prio = current->prio; |
Christoph Hellwig | 2eb1b12 | 2007-02-13 21:54:29 +0100 | [diff] [blame] | 60 | INIT_DELAYED_WORK(&ctx->sched_work, spu_sched_tick); |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 61 | goto out; |
| 62 | out_free: |
| 63 | kfree(ctx); |
| 64 | ctx = NULL; |
| 65 | out: |
| 66 | return ctx; |
| 67 | } |
| 68 | |
| 69 | void destroy_spu_context(struct kref *kref) |
| 70 | { |
| 71 | struct spu_context *ctx; |
| 72 | ctx = container_of(kref, struct spu_context, kref); |
Christoph Hellwig | 650f8b0 | 2007-02-13 21:36:50 +0100 | [diff] [blame] | 73 | mutex_lock(&ctx->state_mutex); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 74 | spu_deactivate(ctx); |
Christoph Hellwig | 650f8b0 | 2007-02-13 21:36:50 +0100 | [diff] [blame] | 75 | mutex_unlock(&ctx->state_mutex); |
Mark Nutter | 5473af0 | 2005-11-15 15:53:49 -0500 | [diff] [blame] | 76 | spu_fini_csa(&ctx->csa); |
Arnd Bergmann | 6263203 | 2006-10-04 17:26:15 +0200 | [diff] [blame] | 77 | if (ctx->gang) |
| 78 | spu_gang_remove_ctx(ctx->gang, ctx); |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 79 | kfree(ctx); |
| 80 | } |
| 81 | |
| 82 | struct spu_context * get_spu_context(struct spu_context *ctx) |
| 83 | { |
| 84 | kref_get(&ctx->kref); |
| 85 | return ctx; |
| 86 | } |
| 87 | |
| 88 | int put_spu_context(struct spu_context *ctx) |
| 89 | { |
| 90 | return kref_put(&ctx->kref, &destroy_spu_context); |
| 91 | } |
| 92 | |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 93 | /* give up the mm reference when the context is about to be destroyed */ |
| 94 | void spu_forget(struct spu_context *ctx) |
| 95 | { |
| 96 | struct mm_struct *mm; |
| 97 | spu_acquire_saved(ctx); |
| 98 | mm = ctx->owner; |
| 99 | ctx->owner = NULL; |
| 100 | mmput(mm); |
| 101 | spu_release(ctx); |
| 102 | } |
Arnd Bergmann | 67207b9 | 2005-11-15 15:53:48 -0500 | [diff] [blame] | 103 | |
Arnd Bergmann | 5110459 | 2005-12-05 22:52:25 -0500 | [diff] [blame] | 104 | void spu_unmap_mappings(struct spu_context *ctx) |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 105 | { |
Mark Nutter | 6df10a8 | 2006-03-23 00:00:12 +0100 | [diff] [blame] | 106 | if (ctx->local_store) |
| 107 | unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1); |
| 108 | if (ctx->mfc) |
Benjamin Herrenschmidt | 17e0e27 | 2007-02-13 11:46:08 +1100 | [diff] [blame] | 109 | unmap_mapping_range(ctx->mfc, 0, 0x1000, 1); |
Mark Nutter | 6df10a8 | 2006-03-23 00:00:12 +0100 | [diff] [blame] | 110 | if (ctx->cntl) |
Benjamin Herrenschmidt | 17e0e27 | 2007-02-13 11:46:08 +1100 | [diff] [blame] | 111 | unmap_mapping_range(ctx->cntl, 0, 0x1000, 1); |
Mark Nutter | 6df10a8 | 2006-03-23 00:00:12 +0100 | [diff] [blame] | 112 | if (ctx->signal1) |
Benjamin Herrenschmidt | 17e0e27 | 2007-02-13 11:46:08 +1100 | [diff] [blame] | 113 | unmap_mapping_range(ctx->signal1, 0, PAGE_SIZE, 1); |
Mark Nutter | 6df10a8 | 2006-03-23 00:00:12 +0100 | [diff] [blame] | 114 | if (ctx->signal2) |
Benjamin Herrenschmidt | 17e0e27 | 2007-02-13 11:46:08 +1100 | [diff] [blame] | 115 | unmap_mapping_range(ctx->signal2, 0, PAGE_SIZE, 1); |
| 116 | if (ctx->mss) |
| 117 | unmap_mapping_range(ctx->mss, 0, 0x1000, 1); |
| 118 | if (ctx->psmap) |
| 119 | unmap_mapping_range(ctx->psmap, 0, 0x20000, 1); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 120 | } |
| 121 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 122 | /** |
| 123 | * spu_acquire_exclusive - lock spu contex and protect against userspace access |
| 124 | * @ctx: spu contex to lock |
| 125 | * |
| 126 | * Note: |
| 127 | * Returns 0 and with the context locked on success |
| 128 | * Returns negative error and with the context _unlocked_ on failure. |
| 129 | */ |
Jeremy Kerr | 099814b | 2006-10-24 18:31:19 +0200 | [diff] [blame] | 130 | int spu_acquire_exclusive(struct spu_context *ctx) |
| 131 | { |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 132 | int ret = -EINVAL; |
Jeremy Kerr | 099814b | 2006-10-24 18:31:19 +0200 | [diff] [blame] | 133 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 134 | spu_acquire(ctx); |
| 135 | /* |
| 136 | * Context is about to be freed, so we can't acquire it anymore. |
| 137 | */ |
| 138 | if (!ctx->owner) |
| 139 | goto out_unlock; |
Jeremy Kerr | 099814b | 2006-10-24 18:31:19 +0200 | [diff] [blame] | 140 | |
Arnd Bergmann | ee2d734 | 2006-11-20 18:45:08 +0100 | [diff] [blame] | 141 | if (ctx->state == SPU_STATE_SAVED) { |
| 142 | ret = spu_activate(ctx, 0); |
| 143 | if (ret) |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 144 | goto out_unlock; |
Arnd Bergmann | ee2d734 | 2006-11-20 18:45:08 +0100 | [diff] [blame] | 145 | } else { |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 146 | /* |
| 147 | * We need to exclude userspace access to the context. |
| 148 | * |
| 149 | * To protect against memory access we invalidate all ptes |
| 150 | * and make sure the pagefault handlers block on the mutex. |
| 151 | */ |
Arnd Bergmann | ee2d734 | 2006-11-20 18:45:08 +0100 | [diff] [blame] | 152 | spu_unmap_mappings(ctx); |
| 153 | } |
Jeremy Kerr | 099814b | 2006-10-24 18:31:19 +0200 | [diff] [blame] | 154 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 155 | return 0; |
| 156 | |
| 157 | out_unlock: |
| 158 | spu_release(ctx); |
Arnd Bergmann | ee2d734 | 2006-11-20 18:45:08 +0100 | [diff] [blame] | 159 | return ret; |
Jeremy Kerr | 099814b | 2006-10-24 18:31:19 +0200 | [diff] [blame] | 160 | } |
| 161 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 162 | /** |
| 163 | * spu_acquire_runnable - lock spu contex and make sure it is in runnable state |
| 164 | * @ctx: spu contex to lock |
| 165 | * |
| 166 | * Note: |
| 167 | * Returns 0 and with the context locked on success |
| 168 | * Returns negative error and with the context _unlocked_ on failure. |
| 169 | */ |
Christoph Hellwig | 26bec67 | 2007-02-13 21:54:24 +0100 | [diff] [blame] | 170 | int spu_acquire_runnable(struct spu_context *ctx, unsigned long flags) |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 171 | { |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 172 | int ret = -EINVAL; |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 173 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 174 | spu_acquire(ctx); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 175 | if (ctx->state == SPU_STATE_SAVED) { |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 176 | /* |
| 177 | * Context is about to be freed, so we can't acquire it anymore. |
| 178 | */ |
| 179 | if (!ctx->owner) |
| 180 | goto out_unlock; |
Christoph Hellwig | 26bec67 | 2007-02-13 21:54:24 +0100 | [diff] [blame] | 181 | ret = spu_activate(ctx, flags); |
Arnd Bergmann | 0106246 | 2006-01-04 20:31:25 +0100 | [diff] [blame] | 182 | if (ret) |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 183 | goto out_unlock; |
Christoph Hellwig | 8389998 | 2007-02-13 21:54:22 +0100 | [diff] [blame] | 184 | } |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 185 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 186 | return 0; |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 187 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 188 | out_unlock: |
| 189 | spu_release(ctx); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 190 | return ret; |
| 191 | } |
| 192 | |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 193 | /** |
| 194 | * spu_acquire_saved - lock spu contex and make sure it is in saved state |
| 195 | * @ctx: spu contex to lock |
| 196 | */ |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 197 | void spu_acquire_saved(struct spu_context *ctx) |
| 198 | { |
Christoph Hellwig | 6a0641e5 | 2007-02-13 21:54:21 +0100 | [diff] [blame] | 199 | spu_acquire(ctx); |
| 200 | if (ctx->state != SPU_STATE_SAVED) |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 201 | spu_deactivate(ctx); |
Arnd Bergmann | 8b3d666 | 2005-11-15 15:53:52 -0500 | [diff] [blame] | 202 | } |