Commit | Line | Data |
---|---|---|
67207b96 AB |
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 | ||
8b3d6663 AB |
23 | #include <linux/fs.h> |
24 | #include <linux/mm.h> | |
67207b96 | 25 | #include <linux/slab.h> |
60063497 | 26 | #include <linux/atomic.h> |
62fe91bb | 27 | #include <linux/sched.h> |
6e84f315 IM |
28 | #include <linux/sched/mm.h> |
29 | ||
67207b96 | 30 | #include <asm/spu.h> |
5473af04 | 31 | #include <asm/spu_csa.h> |
67207b96 | 32 | #include "spufs.h" |
ae142e0c | 33 | #include "sputrace.h" |
67207b96 | 34 | |
65de66f0 CH |
35 | |
36 | atomic_t nr_spu_contexts = ATOMIC_INIT(0); | |
37 | ||
6263203e | 38 | struct spu_context *alloc_spu_context(struct spu_gang *gang) |
67207b96 AB |
39 | { |
40 | struct spu_context *ctx; | |
8f748aae | 41 | |
c5c45913 | 42 | ctx = kzalloc(sizeof *ctx, GFP_KERNEL); |
67207b96 AB |
43 | if (!ctx) |
44 | goto out; | |
8b3d6663 AB |
45 | /* Binding to physical processor deferred |
46 | * until spu_activate(). | |
5473af04 | 47 | */ |
f1fa74f4 | 48 | if (spu_init_csa(&ctx->csa)) |
5473af04 | 49 | goto out_free; |
67207b96 | 50 | spin_lock_init(&ctx->mmio_lock); |
47d3a5fa | 51 | mutex_init(&ctx->mapping_lock); |
67207b96 | 52 | kref_init(&ctx->kref); |
650f8b02 | 53 | mutex_init(&ctx->state_mutex); |
e45d48a3 | 54 | mutex_init(&ctx->run_mutex); |
8b3d6663 AB |
55 | init_waitqueue_head(&ctx->ibox_wq); |
56 | init_waitqueue_head(&ctx->wbox_wq); | |
5110459f | 57 | init_waitqueue_head(&ctx->stop_wq); |
a33a7d73 | 58 | init_waitqueue_head(&ctx->mfc_wq); |
33bfd7a7 | 59 | init_waitqueue_head(&ctx->run_wq); |
8b3d6663 | 60 | ctx->state = SPU_STATE_SAVED; |
8b3d6663 AB |
61 | ctx->ops = &spu_backing_ops; |
62 | ctx->owner = get_task_mm(current); | |
a475c2f4 | 63 | INIT_LIST_HEAD(&ctx->rq); |
8e68e2f2 | 64 | INIT_LIST_HEAD(&ctx->aff_list); |
6263203e AB |
65 | if (gang) |
66 | spu_gang_add_ctx(gang, ctx); | |
9d78592e CH |
67 | |
68 | __spu_update_sched_info(ctx); | |
fe443ef2 | 69 | spu_set_timeslice(ctx); |
27ec41d3 | 70 | ctx->stats.util_state = SPU_UTIL_IDLE_LOADED; |
f2dec1ea | 71 | ctx->stats.tstamp = ktime_get_ns(); |
65de66f0 CH |
72 | |
73 | atomic_inc(&nr_spu_contexts); | |
67207b96 AB |
74 | goto out; |
75 | out_free: | |
76 | kfree(ctx); | |
77 | ctx = NULL; | |
78 | out: | |
79 | return ctx; | |
80 | } | |
81 | ||
82 | void destroy_spu_context(struct kref *kref) | |
83 | { | |
84 | struct spu_context *ctx; | |
85 | ctx = container_of(kref, struct spu_context, kref); | |
53457881 | 86 | spu_context_nospu_trace(destroy_spu_context__enter, ctx); |
650f8b02 | 87 | mutex_lock(&ctx->state_mutex); |
8b3d6663 | 88 | spu_deactivate(ctx); |
650f8b02 | 89 | mutex_unlock(&ctx->state_mutex); |
5473af04 | 90 | spu_fini_csa(&ctx->csa); |
6263203e AB |
91 | if (ctx->gang) |
92 | spu_gang_remove_ctx(ctx->gang, ctx); | |
1474855d BN |
93 | if (ctx->prof_priv_kref) |
94 | kref_put(ctx->prof_priv_kref, ctx->prof_priv_release); | |
a475c2f4 | 95 | BUG_ON(!list_empty(&ctx->rq)); |
65de66f0 | 96 | atomic_dec(&nr_spu_contexts); |
5158e9b5 | 97 | kfree(ctx->switch_log); |
67207b96 AB |
98 | kfree(ctx); |
99 | } | |
100 | ||
101 | struct spu_context * get_spu_context(struct spu_context *ctx) | |
102 | { | |
103 | kref_get(&ctx->kref); | |
104 | return ctx; | |
105 | } | |
106 | ||
107 | int put_spu_context(struct spu_context *ctx) | |
108 | { | |
109 | return kref_put(&ctx->kref, &destroy_spu_context); | |
110 | } | |
111 | ||
8b3d6663 AB |
112 | /* give up the mm reference when the context is about to be destroyed */ |
113 | void spu_forget(struct spu_context *ctx) | |
114 | { | |
115 | struct mm_struct *mm; | |
c9101bdb CH |
116 | |
117 | /* | |
118 | * This is basically an open-coded spu_acquire_saved, except that | |
0111a701 JK |
119 | * we don't acquire the state mutex interruptible, and we don't |
120 | * want this context to be rescheduled on release. | |
c9101bdb CH |
121 | */ |
122 | mutex_lock(&ctx->state_mutex); | |
0111a701 | 123 | if (ctx->state != SPU_STATE_SAVED) |
c9101bdb | 124 | spu_deactivate(ctx); |
c9101bdb | 125 | |
8b3d6663 AB |
126 | mm = ctx->owner; |
127 | ctx->owner = NULL; | |
128 | mmput(mm); | |
129 | spu_release(ctx); | |
130 | } | |
131 | ||
5110459f | 132 | void spu_unmap_mappings(struct spu_context *ctx) |
8b3d6663 | 133 | { |
47d3a5fa | 134 | mutex_lock(&ctx->mapping_lock); |
6df10a82 MN |
135 | if (ctx->local_store) |
136 | unmap_mapping_range(ctx->local_store, 0, LS_SIZE, 1); | |
137 | if (ctx->mfc) | |
87ff6090 | 138 | unmap_mapping_range(ctx->mfc, 0, SPUFS_MFC_MAP_SIZE, 1); |
6df10a82 | 139 | if (ctx->cntl) |
87ff6090 | 140 | unmap_mapping_range(ctx->cntl, 0, SPUFS_CNTL_MAP_SIZE, 1); |
6df10a82 | 141 | if (ctx->signal1) |
87ff6090 | 142 | unmap_mapping_range(ctx->signal1, 0, SPUFS_SIGNAL_MAP_SIZE, 1); |
6df10a82 | 143 | if (ctx->signal2) |
87ff6090 | 144 | unmap_mapping_range(ctx->signal2, 0, SPUFS_SIGNAL_MAP_SIZE, 1); |
17e0e270 | 145 | if (ctx->mss) |
87ff6090 | 146 | unmap_mapping_range(ctx->mss, 0, SPUFS_MSS_MAP_SIZE, 1); |
17e0e270 | 147 | if (ctx->psmap) |
87ff6090 | 148 | unmap_mapping_range(ctx->psmap, 0, SPUFS_PS_MAP_SIZE, 1); |
47d3a5fa | 149 | mutex_unlock(&ctx->mapping_lock); |
8b3d6663 AB |
150 | } |
151 | ||
6a0641e5 CH |
152 | /** |
153 | * spu_acquire_saved - lock spu contex and make sure it is in saved state | |
154 | * @ctx: spu contex to lock | |
155 | */ | |
c9101bdb | 156 | int spu_acquire_saved(struct spu_context *ctx) |
8b3d6663 | 157 | { |
c9101bdb CH |
158 | int ret; |
159 | ||
3734dfc6 JMV |
160 | spu_context_nospu_trace(spu_acquire_saved__enter, ctx); |
161 | ||
c9101bdb CH |
162 | ret = spu_acquire(ctx); |
163 | if (ret) | |
164 | return ret; | |
165 | ||
27b1ea09 CH |
166 | if (ctx->state != SPU_STATE_SAVED) { |
167 | set_bit(SPU_SCHED_WAS_ACTIVE, &ctx->sched_flags); | |
8b3d6663 | 168 | spu_deactivate(ctx); |
27b1ea09 | 169 | } |
c9101bdb CH |
170 | |
171 | return 0; | |
27b1ea09 CH |
172 | } |
173 | ||
174 | /** | |
175 | * spu_release_saved - unlock spu context and return it to the runqueue | |
176 | * @ctx: context to unlock | |
177 | */ | |
178 | void spu_release_saved(struct spu_context *ctx) | |
179 | { | |
180 | BUG_ON(ctx->state != SPU_STATE_SAVED); | |
181 | ||
c368392a JK |
182 | if (test_and_clear_bit(SPU_SCHED_WAS_ACTIVE, &ctx->sched_flags) && |
183 | test_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags)) | |
27b1ea09 CH |
184 | spu_activate(ctx, 0); |
185 | ||
186 | spu_release(ctx); | |
8b3d6663 | 187 | } |
1474855d | 188 |