gru: fix bug in allocation of kernel contexts
[linux-2.6.git] / drivers / misc / sgi-gru / grumain.c
1 /*
2  * SN Platform GRU Driver
3  *
4  *            DRIVER TABLE MANAGER + GRU CONTEXT LOAD/UNLOAD
5  *
6  *  Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
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 of the License, or
11  *  (at your option) 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/mm.h>
26 #include <linux/spinlock.h>
27 #include <linux/sched.h>
28 #include <linux/device.h>
29 #include <linux/list.h>
30 #include <linux/err.h>
31 #include <asm/uv/uv_hub.h>
32 #include "gru.h"
33 #include "grutables.h"
34 #include "gruhandles.h"
35
36 unsigned long gru_options __read_mostly;
37
38 static struct device_driver gru_driver = {
39         .name = "gru"
40 };
41
42 static struct device gru_device = {
43         .init_name = "",
44         .driver = &gru_driver,
45 };
46
47 struct device *grudev = &gru_device;
48
49 /*
50  * Select a gru fault map to be used by the current cpu. Note that
51  * multiple cpus may be using the same map.
52  *      ZZZ should be inline but did not work on emulator
53  */
54 int gru_cpu_fault_map_id(void)
55 {
56 #ifdef CONFIG_IA64
57         return uv_blade_processor_id() % GRU_NUM_TFM;
58 #else
59         int cpu = smp_processor_id();
60         int id, core;
61
62         core = uv_cpu_core_number(cpu);
63         id = core + UV_MAX_INT_CORES * uv_cpu_socket_number(cpu);
64         return id;
65 #endif
66 }
67
68 /*--------- ASID Management -------------------------------------------
69  *
70  *  Initially, assign asids sequentially from MIN_ASID .. MAX_ASID.
71  *  Once MAX is reached, flush the TLB & start over. However,
72  *  some asids may still be in use. There won't be many (percentage wise) still
73  *  in use. Search active contexts & determine the value of the first
74  *  asid in use ("x"s below). Set "limit" to this value.
75  *  This defines a block of assignable asids.
76  *
77  *  When "limit" is reached, search forward from limit+1 and determine the
78  *  next block of assignable asids.
79  *
80  *  Repeat until MAX_ASID is reached, then start over again.
81  *
82  *  Each time MAX_ASID is reached, increment the asid generation. Since
83  *  the search for in-use asids only checks contexts with GRUs currently
84  *  assigned, asids in some contexts will be missed. Prior to loading
85  *  a context, the asid generation of the GTS asid is rechecked. If it
86  *  doesn't match the current generation, a new asid will be assigned.
87  *
88  *      0---------------x------------x---------------------x----|
89  *        ^-next        ^-limit                                 ^-MAX_ASID
90  *
91  * All asid manipulation & context loading/unloading is protected by the
92  * gs_lock.
93  */
94
95 /* Hit the asid limit. Start over */
96 static int gru_wrap_asid(struct gru_state *gru)
97 {
98         gru_dbg(grudev, "gid %d\n", gru->gs_gid);
99         STAT(asid_wrap);
100         gru->gs_asid_gen++;
101         return MIN_ASID;
102 }
103
104 /* Find the next chunk of unused asids */
105 static int gru_reset_asid_limit(struct gru_state *gru, int asid)
106 {
107         int i, gid, inuse_asid, limit;
108
109         gru_dbg(grudev, "gid %d, asid 0x%x\n", gru->gs_gid, asid);
110         STAT(asid_next);
111         limit = MAX_ASID;
112         if (asid >= limit)
113                 asid = gru_wrap_asid(gru);
114         gru_flush_all_tlb(gru);
115         gid = gru->gs_gid;
116 again:
117         for (i = 0; i < GRU_NUM_CCH; i++) {
118                 if (!gru->gs_gts[i] || is_kernel_context(gru->gs_gts[i]))
119                         continue;
120                 inuse_asid = gru->gs_gts[i]->ts_gms->ms_asids[gid].mt_asid;
121                 gru_dbg(grudev, "gid %d, gts %p, gms %p, inuse 0x%x, cxt %d\n",
122                         gru->gs_gid, gru->gs_gts[i], gru->gs_gts[i]->ts_gms,
123                         inuse_asid, i);
124                 if (inuse_asid == asid) {
125                         asid += ASID_INC;
126                         if (asid >= limit) {
127                                 /*
128                                  * empty range: reset the range limit and
129                                  * start over
130                                  */
131                                 limit = MAX_ASID;
132                                 if (asid >= MAX_ASID)
133                                         asid = gru_wrap_asid(gru);
134                                 goto again;
135                         }
136                 }
137
138                 if ((inuse_asid > asid) && (inuse_asid < limit))
139                         limit = inuse_asid;
140         }
141         gru->gs_asid_limit = limit;
142         gru->gs_asid = asid;
143         gru_dbg(grudev, "gid %d, new asid 0x%x, new_limit 0x%x\n", gru->gs_gid,
144                                         asid, limit);
145         return asid;
146 }
147
148 /* Assign a new ASID to a thread context.  */
149 static int gru_assign_asid(struct gru_state *gru)
150 {
151         int asid;
152
153         gru->gs_asid += ASID_INC;
154         asid = gru->gs_asid;
155         if (asid >= gru->gs_asid_limit)
156                 asid = gru_reset_asid_limit(gru, asid);
157
158         gru_dbg(grudev, "gid %d, asid 0x%x\n", gru->gs_gid, asid);
159         return asid;
160 }
161
162 /*
163  * Clear n bits in a word. Return a word indicating the bits that were cleared.
164  * Optionally, build an array of chars that contain the bit numbers allocated.
165  */
166 static unsigned long reserve_resources(unsigned long *p, int n, int mmax,
167                                        char *idx)
168 {
169         unsigned long bits = 0;
170         int i;
171
172         while (n--) {
173                 i = find_first_bit(p, mmax);
174                 if (i == mmax)
175                         BUG();
176                 __clear_bit(i, p);
177                 __set_bit(i, &bits);
178                 if (idx)
179                         *idx++ = i;
180         }
181         return bits;
182 }
183
184 unsigned long gru_reserve_cb_resources(struct gru_state *gru, int cbr_au_count,
185                                        char *cbmap)
186 {
187         return reserve_resources(&gru->gs_cbr_map, cbr_au_count, GRU_CBR_AU,
188                                  cbmap);
189 }
190
191 unsigned long gru_reserve_ds_resources(struct gru_state *gru, int dsr_au_count,
192                                        char *dsmap)
193 {
194         return reserve_resources(&gru->gs_dsr_map, dsr_au_count, GRU_DSR_AU,
195                                  dsmap);
196 }
197
198 static void reserve_gru_resources(struct gru_state *gru,
199                                   struct gru_thread_state *gts)
200 {
201         gru->gs_active_contexts++;
202         gts->ts_cbr_map =
203             gru_reserve_cb_resources(gru, gts->ts_cbr_au_count,
204                                      gts->ts_cbr_idx);
205         gts->ts_dsr_map =
206             gru_reserve_ds_resources(gru, gts->ts_dsr_au_count, NULL);
207 }
208
209 static void free_gru_resources(struct gru_state *gru,
210                                struct gru_thread_state *gts)
211 {
212         gru->gs_active_contexts--;
213         gru->gs_cbr_map |= gts->ts_cbr_map;
214         gru->gs_dsr_map |= gts->ts_dsr_map;
215 }
216
217 /*
218  * Check if a GRU has sufficient free resources to satisfy an allocation
219  * request. Note: GRU locks may or may not be held when this is called. If
220  * not held, recheck after acquiring the appropriate locks.
221  *
222  * Returns 1 if sufficient resources, 0 if not
223  */
224 static int check_gru_resources(struct gru_state *gru, int cbr_au_count,
225                                int dsr_au_count, int max_active_contexts)
226 {
227         return hweight64(gru->gs_cbr_map) >= cbr_au_count
228                 && hweight64(gru->gs_dsr_map) >= dsr_au_count
229                 && gru->gs_active_contexts < max_active_contexts;
230 }
231
232 /*
233  * TLB manangment requires tracking all GRU chiplets that have loaded a GSEG
234  * context.
235  */
236 static int gru_load_mm_tracker(struct gru_state *gru,
237                                         struct gru_thread_state *gts)
238 {
239         struct gru_mm_struct *gms = gts->ts_gms;
240         struct gru_mm_tracker *asids = &gms->ms_asids[gru->gs_gid];
241         unsigned short ctxbitmap = (1 << gts->ts_ctxnum);
242         int asid;
243
244         spin_lock(&gms->ms_asid_lock);
245         asid = asids->mt_asid;
246
247         spin_lock(&gru->gs_asid_lock);
248         if (asid == 0 || (asids->mt_ctxbitmap == 0 && asids->mt_asid_gen !=
249                           gru->gs_asid_gen)) {
250                 asid = gru_assign_asid(gru);
251                 asids->mt_asid = asid;
252                 asids->mt_asid_gen = gru->gs_asid_gen;
253                 STAT(asid_new);
254         } else {
255                 STAT(asid_reuse);
256         }
257         spin_unlock(&gru->gs_asid_lock);
258
259         BUG_ON(asids->mt_ctxbitmap & ctxbitmap);
260         asids->mt_ctxbitmap |= ctxbitmap;
261         if (!test_bit(gru->gs_gid, gms->ms_asidmap))
262                 __set_bit(gru->gs_gid, gms->ms_asidmap);
263         spin_unlock(&gms->ms_asid_lock);
264
265         gru_dbg(grudev,
266                 "gid %d, gts %p, gms %p, ctxnum %d, asid 0x%x, asidmap 0x%lx\n",
267                 gru->gs_gid, gts, gms, gts->ts_ctxnum, asid,
268                 gms->ms_asidmap[0]);
269         return asid;
270 }
271
272 static void gru_unload_mm_tracker(struct gru_state *gru,
273                                         struct gru_thread_state *gts)
274 {
275         struct gru_mm_struct *gms = gts->ts_gms;
276         struct gru_mm_tracker *asids;
277         unsigned short ctxbitmap;
278
279         asids = &gms->ms_asids[gru->gs_gid];
280         ctxbitmap = (1 << gts->ts_ctxnum);
281         spin_lock(&gms->ms_asid_lock);
282         spin_lock(&gru->gs_asid_lock);
283         BUG_ON((asids->mt_ctxbitmap & ctxbitmap) != ctxbitmap);
284         asids->mt_ctxbitmap ^= ctxbitmap;
285         gru_dbg(grudev, "gid %d, gts %p, gms %p, ctxnum 0x%d, asidmap 0x%lx\n",
286                 gru->gs_gid, gts, gms, gts->ts_ctxnum, gms->ms_asidmap[0]);
287         spin_unlock(&gru->gs_asid_lock);
288         spin_unlock(&gms->ms_asid_lock);
289 }
290
291 /*
292  * Decrement the reference count on a GTS structure. Free the structure
293  * if the reference count goes to zero.
294  */
295 void gts_drop(struct gru_thread_state *gts)
296 {
297         if (gts && atomic_dec_return(&gts->ts_refcnt) == 0) {
298                 if (gts->ts_gms)
299                         gru_drop_mmu_notifier(gts->ts_gms);
300                 kfree(gts);
301                 STAT(gts_free);
302         }
303 }
304
305 /*
306  * Locate the GTS structure for the current thread.
307  */
308 static struct gru_thread_state *gru_find_current_gts_nolock(struct gru_vma_data
309                             *vdata, int tsid)
310 {
311         struct gru_thread_state *gts;
312
313         list_for_each_entry(gts, &vdata->vd_head, ts_next)
314             if (gts->ts_tsid == tsid)
315                 return gts;
316         return NULL;
317 }
318
319 /*
320  * Allocate a thread state structure.
321  */
322 struct gru_thread_state *gru_alloc_gts(struct vm_area_struct *vma,
323                 int cbr_au_count, int dsr_au_count,
324                 unsigned char tlb_preload_count, int options, int tsid)
325 {
326         struct gru_thread_state *gts;
327         struct gru_mm_struct *gms;
328         int bytes;
329
330         bytes = DSR_BYTES(dsr_au_count) + CBR_BYTES(cbr_au_count);
331         bytes += sizeof(struct gru_thread_state);
332         gts = kmalloc(bytes, GFP_KERNEL);
333         if (!gts)
334                 return ERR_PTR(-ENOMEM);
335
336         STAT(gts_alloc);
337         memset(gts, 0, sizeof(struct gru_thread_state)); /* zero out header */
338         atomic_set(&gts->ts_refcnt, 1);
339         mutex_init(&gts->ts_ctxlock);
340         gts->ts_cbr_au_count = cbr_au_count;
341         gts->ts_dsr_au_count = dsr_au_count;
342         gts->ts_tlb_preload_count = tlb_preload_count;
343         gts->ts_user_options = options;
344         gts->ts_user_blade_id = -1;
345         gts->ts_user_chiplet_id = -1;
346         gts->ts_tsid = tsid;
347         gts->ts_ctxnum = NULLCTX;
348         gts->ts_tlb_int_select = -1;
349         gts->ts_cch_req_slice = -1;
350         gts->ts_sizeavail = GRU_SIZEAVAIL(PAGE_SHIFT);
351         if (vma) {
352                 gts->ts_mm = current->mm;
353                 gts->ts_vma = vma;
354                 gms = gru_register_mmu_notifier();
355                 if (IS_ERR(gms))
356                         goto err;
357                 gts->ts_gms = gms;
358         }
359
360         gru_dbg(grudev, "alloc gts %p\n", gts);
361         return gts;
362
363 err:
364         gts_drop(gts);
365         return ERR_CAST(gms);
366 }
367
368 /*
369  * Allocate a vma private data structure.
370  */
371 struct gru_vma_data *gru_alloc_vma_data(struct vm_area_struct *vma, int tsid)
372 {
373         struct gru_vma_data *vdata = NULL;
374
375         vdata = kmalloc(sizeof(*vdata), GFP_KERNEL);
376         if (!vdata)
377                 return NULL;
378
379         STAT(vdata_alloc);
380         INIT_LIST_HEAD(&vdata->vd_head);
381         spin_lock_init(&vdata->vd_lock);
382         gru_dbg(grudev, "alloc vdata %p\n", vdata);
383         return vdata;
384 }
385
386 /*
387  * Find the thread state structure for the current thread.
388  */
389 struct gru_thread_state *gru_find_thread_state(struct vm_area_struct *vma,
390                                         int tsid)
391 {
392         struct gru_vma_data *vdata = vma->vm_private_data;
393         struct gru_thread_state *gts;
394
395         spin_lock(&vdata->vd_lock);
396         gts = gru_find_current_gts_nolock(vdata, tsid);
397         spin_unlock(&vdata->vd_lock);
398         gru_dbg(grudev, "vma %p, gts %p\n", vma, gts);
399         return gts;
400 }
401
402 /*
403  * Allocate a new thread state for a GSEG. Note that races may allow
404  * another thread to race to create a gts.
405  */
406 struct gru_thread_state *gru_alloc_thread_state(struct vm_area_struct *vma,
407                                         int tsid)
408 {
409         struct gru_vma_data *vdata = vma->vm_private_data;
410         struct gru_thread_state *gts, *ngts;
411
412         gts = gru_alloc_gts(vma, vdata->vd_cbr_au_count,
413                             vdata->vd_dsr_au_count,
414                             vdata->vd_tlb_preload_count,
415                             vdata->vd_user_options, tsid);
416         if (IS_ERR(gts))
417                 return gts;
418
419         spin_lock(&vdata->vd_lock);
420         ngts = gru_find_current_gts_nolock(vdata, tsid);
421         if (ngts) {
422                 gts_drop(gts);
423                 gts = ngts;
424                 STAT(gts_double_allocate);
425         } else {
426                 list_add(&gts->ts_next, &vdata->vd_head);
427         }
428         spin_unlock(&vdata->vd_lock);
429         gru_dbg(grudev, "vma %p, gts %p\n", vma, gts);
430         return gts;
431 }
432
433 /*
434  * Free the GRU context assigned to the thread state.
435  */
436 static void gru_free_gru_context(struct gru_thread_state *gts)
437 {
438         struct gru_state *gru;
439
440         gru = gts->ts_gru;
441         gru_dbg(grudev, "gts %p, gid %d\n", gts, gru->gs_gid);
442
443         spin_lock(&gru->gs_lock);
444         gru->gs_gts[gts->ts_ctxnum] = NULL;
445         free_gru_resources(gru, gts);
446         BUG_ON(test_bit(gts->ts_ctxnum, &gru->gs_context_map) == 0);
447         __clear_bit(gts->ts_ctxnum, &gru->gs_context_map);
448         gts->ts_ctxnum = NULLCTX;
449         gts->ts_gru = NULL;
450         gts->ts_blade = -1;
451         spin_unlock(&gru->gs_lock);
452
453         gts_drop(gts);
454         STAT(free_context);
455 }
456
457 /*
458  * Prefetching cachelines help hardware performance.
459  * (Strictly a performance enhancement. Not functionally required).
460  */
461 static void prefetch_data(void *p, int num, int stride)
462 {
463         while (num-- > 0) {
464                 prefetchw(p);
465                 p += stride;
466         }
467 }
468
469 static inline long gru_copy_handle(void *d, void *s)
470 {
471         memcpy(d, s, GRU_HANDLE_BYTES);
472         return GRU_HANDLE_BYTES;
473 }
474
475 static void gru_prefetch_context(void *gseg, void *cb, void *cbe,
476                                 unsigned long cbrmap, unsigned long length)
477 {
478         int i, scr;
479
480         prefetch_data(gseg + GRU_DS_BASE, length / GRU_CACHE_LINE_BYTES,
481                       GRU_CACHE_LINE_BYTES);
482
483         for_each_cbr_in_allocation_map(i, &cbrmap, scr) {
484                 prefetch_data(cb, 1, GRU_CACHE_LINE_BYTES);
485                 prefetch_data(cbe + i * GRU_HANDLE_STRIDE, 1,
486                               GRU_CACHE_LINE_BYTES);
487                 cb += GRU_HANDLE_STRIDE;
488         }
489 }
490
491 static void gru_load_context_data(void *save, void *grubase, int ctxnum,
492                                   unsigned long cbrmap, unsigned long dsrmap,
493                                   int data_valid)
494 {
495         void *gseg, *cb, *cbe;
496         unsigned long length;
497         int i, scr;
498
499         gseg = grubase + ctxnum * GRU_GSEG_STRIDE;
500         cb = gseg + GRU_CB_BASE;
501         cbe = grubase + GRU_CBE_BASE;
502         length = hweight64(dsrmap) * GRU_DSR_AU_BYTES;
503         gru_prefetch_context(gseg, cb, cbe, cbrmap, length);
504
505         for_each_cbr_in_allocation_map(i, &cbrmap, scr) {
506                 if (data_valid) {
507                         save += gru_copy_handle(cb, save);
508                         save += gru_copy_handle(cbe + i * GRU_HANDLE_STRIDE,
509                                                 save);
510                 } else {
511                         memset(cb, 0, GRU_CACHE_LINE_BYTES);
512                         memset(cbe + i * GRU_HANDLE_STRIDE, 0,
513                                                 GRU_CACHE_LINE_BYTES);
514                 }
515                 /* Flush CBE to hide race in context restart */
516                 mb();
517                 gru_flush_cache(cbe + i * GRU_HANDLE_STRIDE);
518                 cb += GRU_HANDLE_STRIDE;
519         }
520
521         if (data_valid)
522                 memcpy(gseg + GRU_DS_BASE, save, length);
523         else
524                 memset(gseg + GRU_DS_BASE, 0, length);
525 }
526
527 static void gru_unload_context_data(void *save, void *grubase, int ctxnum,
528                                     unsigned long cbrmap, unsigned long dsrmap)
529 {
530         void *gseg, *cb, *cbe;
531         unsigned long length;
532         int i, scr;
533
534         gseg = grubase + ctxnum * GRU_GSEG_STRIDE;
535         cb = gseg + GRU_CB_BASE;
536         cbe = grubase + GRU_CBE_BASE;
537         length = hweight64(dsrmap) * GRU_DSR_AU_BYTES;
538
539         /* CBEs may not be coherent. Flush them from cache */
540         for_each_cbr_in_allocation_map(i, &cbrmap, scr)
541                 gru_flush_cache(cbe + i * GRU_HANDLE_STRIDE);
542         mb();           /* Let the CL flush complete */
543
544         gru_prefetch_context(gseg, cb, cbe, cbrmap, length);
545
546         for_each_cbr_in_allocation_map(i, &cbrmap, scr) {
547                 save += gru_copy_handle(save, cb);
548                 save += gru_copy_handle(save, cbe + i * GRU_HANDLE_STRIDE);
549                 cb += GRU_HANDLE_STRIDE;
550         }
551         memcpy(save, gseg + GRU_DS_BASE, length);
552 }
553
554 void gru_unload_context(struct gru_thread_state *gts, int savestate)
555 {
556         struct gru_state *gru = gts->ts_gru;
557         struct gru_context_configuration_handle *cch;
558         int ctxnum = gts->ts_ctxnum;
559
560         if (!is_kernel_context(gts))
561                 zap_vma_ptes(gts->ts_vma, UGRUADDR(gts), GRU_GSEG_PAGESIZE);
562         cch = get_cch(gru->gs_gru_base_vaddr, ctxnum);
563
564         gru_dbg(grudev, "gts %p, cbrmap 0x%lx, dsrmap 0x%lx\n",
565                 gts, gts->ts_cbr_map, gts->ts_dsr_map);
566         lock_cch_handle(cch);
567         if (cch_interrupt_sync(cch))
568                 BUG();
569
570         if (!is_kernel_context(gts))
571                 gru_unload_mm_tracker(gru, gts);
572         if (savestate) {
573                 gru_unload_context_data(gts->ts_gdata, gru->gs_gru_base_vaddr,
574                                         ctxnum, gts->ts_cbr_map,
575                                         gts->ts_dsr_map);
576                 gts->ts_data_valid = 1;
577         }
578
579         if (cch_deallocate(cch))
580                 BUG();
581         unlock_cch_handle(cch);
582
583         gru_free_gru_context(gts);
584 }
585
586 /*
587  * Load a GRU context by copying it from the thread data structure in memory
588  * to the GRU.
589  */
590 void gru_load_context(struct gru_thread_state *gts)
591 {
592         struct gru_state *gru = gts->ts_gru;
593         struct gru_context_configuration_handle *cch;
594         int i, err, asid, ctxnum = gts->ts_ctxnum;
595
596         cch = get_cch(gru->gs_gru_base_vaddr, ctxnum);
597         lock_cch_handle(cch);
598         cch->tfm_fault_bit_enable =
599             (gts->ts_user_options == GRU_OPT_MISS_FMM_POLL
600              || gts->ts_user_options == GRU_OPT_MISS_FMM_INTR);
601         cch->tlb_int_enable = (gts->ts_user_options == GRU_OPT_MISS_FMM_INTR);
602         if (cch->tlb_int_enable) {
603                 gts->ts_tlb_int_select = gru_cpu_fault_map_id();
604                 cch->tlb_int_select = gts->ts_tlb_int_select;
605         }
606         if (gts->ts_cch_req_slice >= 0) {
607                 cch->req_slice_set_enable = 1;
608                 cch->req_slice = gts->ts_cch_req_slice;
609         } else {
610                 cch->req_slice_set_enable =0;
611         }
612         cch->tfm_done_bit_enable = 0;
613         cch->dsr_allocation_map = gts->ts_dsr_map;
614         cch->cbr_allocation_map = gts->ts_cbr_map;
615
616         if (is_kernel_context(gts)) {
617                 cch->unmap_enable = 1;
618                 cch->tfm_done_bit_enable = 1;
619                 cch->cb_int_enable = 1;
620                 cch->tlb_int_select = 0;        /* For now, ints go to cpu 0 */
621         } else {
622                 cch->unmap_enable = 0;
623                 cch->tfm_done_bit_enable = 0;
624                 cch->cb_int_enable = 0;
625                 asid = gru_load_mm_tracker(gru, gts);
626                 for (i = 0; i < 8; i++) {
627                         cch->asid[i] = asid + i;
628                         cch->sizeavail[i] = gts->ts_sizeavail;
629                 }
630         }
631
632         err = cch_allocate(cch);
633         if (err) {
634                 gru_dbg(grudev,
635                         "err %d: cch %p, gts %p, cbr 0x%lx, dsr 0x%lx\n",
636                         err, cch, gts, gts->ts_cbr_map, gts->ts_dsr_map);
637                 BUG();
638         }
639
640         gru_load_context_data(gts->ts_gdata, gru->gs_gru_base_vaddr, ctxnum,
641                         gts->ts_cbr_map, gts->ts_dsr_map, gts->ts_data_valid);
642
643         if (cch_start(cch))
644                 BUG();
645         unlock_cch_handle(cch);
646
647         gru_dbg(grudev, "gid %d, gts %p, cbrmap 0x%lx, dsrmap 0x%lx, tie %d, tis %d\n",
648                 gts->ts_gru->gs_gid, gts, gts->ts_cbr_map, gts->ts_dsr_map,
649                 (gts->ts_user_options == GRU_OPT_MISS_FMM_INTR), gts->ts_tlb_int_select);
650 }
651
652 /*
653  * Update fields in an active CCH:
654  *      - retarget interrupts on local blade
655  *      - update sizeavail mask
656  */
657 int gru_update_cch(struct gru_thread_state *gts)
658 {
659         struct gru_context_configuration_handle *cch;
660         struct gru_state *gru = gts->ts_gru;
661         int i, ctxnum = gts->ts_ctxnum, ret = 0;
662
663         cch = get_cch(gru->gs_gru_base_vaddr, ctxnum);
664
665         lock_cch_handle(cch);
666         if (cch->state == CCHSTATE_ACTIVE) {
667                 if (gru->gs_gts[gts->ts_ctxnum] != gts)
668                         goto exit;
669                 if (cch_interrupt(cch))
670                         BUG();
671                 for (i = 0; i < 8; i++)
672                         cch->sizeavail[i] = gts->ts_sizeavail;
673                 gts->ts_tlb_int_select = gru_cpu_fault_map_id();
674                 cch->tlb_int_select = gru_cpu_fault_map_id();
675                 cch->tfm_fault_bit_enable =
676                   (gts->ts_user_options == GRU_OPT_MISS_FMM_POLL
677                     || gts->ts_user_options == GRU_OPT_MISS_FMM_INTR);
678                 if (cch_start(cch))
679                         BUG();
680                 ret = 1;
681         }
682 exit:
683         unlock_cch_handle(cch);
684         return ret;
685 }
686
687 /*
688  * Update CCH tlb interrupt select. Required when all the following is true:
689  *      - task's GRU context is loaded into a GRU
690  *      - task is using interrupt notification for TLB faults
691  *      - task has migrated to a different cpu on the same blade where
692  *        it was previously running.
693  */
694 static int gru_retarget_intr(struct gru_thread_state *gts)
695 {
696         if (gts->ts_tlb_int_select < 0
697             || gts->ts_tlb_int_select == gru_cpu_fault_map_id())
698                 return 0;
699
700         gru_dbg(grudev, "retarget from %d to %d\n", gts->ts_tlb_int_select,
701                 gru_cpu_fault_map_id());
702         return gru_update_cch(gts);
703 }
704
705 /*
706  * Check if a GRU context is allowed to use a specific chiplet. By default
707  * a context is assigned to any blade-local chiplet. However, users can
708  * override this.
709  *      Returns 1 if assignment allowed, 0 otherwise
710  */
711 static int gru_check_chiplet_assignment(struct gru_state *gru,
712                                         struct gru_thread_state *gts)
713 {
714         int blade_id;
715         int chiplet_id;
716
717         blade_id = gts->ts_user_blade_id;
718         if (blade_id < 0)
719                 blade_id = uv_numa_blade_id();
720
721         chiplet_id = gts->ts_user_chiplet_id;
722         return gru->gs_blade_id == blade_id &&
723                 (chiplet_id < 0 || chiplet_id == gru->gs_chiplet_id);
724 }
725
726 /*
727  * Unload the gru context if it is not assigned to the correct blade or
728  * chiplet. Misassignment can occur if the process migrates to a different
729  * blade or if the user changes the selected blade/chiplet.
730  */
731 void gru_check_context_placement(struct gru_thread_state *gts)
732 {
733         struct gru_state *gru;
734
735         /*
736          * If the current task is the context owner, verify that the
737          * context is correctly placed. This test is skipped for non-owner
738          * references. Pthread apps use non-owner references to the CBRs.
739          */
740         gru = gts->ts_gru;
741         if (!gru || gts->ts_tgid_owner != current->tgid)
742                 return;
743
744         if (!gru_check_chiplet_assignment(gru, gts)) {
745                 STAT(check_context_unload);
746                 gru_unload_context(gts, 1);
747         } else if (gru_retarget_intr(gts)) {
748                 STAT(check_context_retarget_intr);
749         }
750 }
751
752
753 /*
754  * Insufficient GRU resources available on the local blade. Steal a context from
755  * a process. This is a hack until a _real_ resource scheduler is written....
756  */
757 #define next_ctxnum(n)  ((n) <  GRU_NUM_CCH - 2 ? (n) + 1 : 0)
758 #define next_gru(b, g)  (((g) < &(b)->bs_grus[GRU_CHIPLETS_PER_BLADE - 1]) ?  \
759                                  ((g)+1) : &(b)->bs_grus[0])
760
761 static int is_gts_stealable(struct gru_thread_state *gts,
762                 struct gru_blade_state *bs)
763 {
764         if (is_kernel_context(gts))
765                 return down_write_trylock(&bs->bs_kgts_sema);
766         else
767                 return mutex_trylock(&gts->ts_ctxlock);
768 }
769
770 static void gts_stolen(struct gru_thread_state *gts,
771                 struct gru_blade_state *bs)
772 {
773         if (is_kernel_context(gts)) {
774                 up_write(&bs->bs_kgts_sema);
775                 STAT(steal_kernel_context);
776         } else {
777                 mutex_unlock(&gts->ts_ctxlock);
778                 STAT(steal_user_context);
779         }
780 }
781
782 void gru_steal_context(struct gru_thread_state *gts)
783 {
784         struct gru_blade_state *blade;
785         struct gru_state *gru, *gru0;
786         struct gru_thread_state *ngts = NULL;
787         int ctxnum, ctxnum0, flag = 0, cbr, dsr;
788         int blade_id;
789
790         blade_id = gts->ts_user_blade_id;
791         if (blade_id < 0)
792                 blade_id = uv_numa_blade_id();
793         cbr = gts->ts_cbr_au_count;
794         dsr = gts->ts_dsr_au_count;
795
796         blade = gru_base[blade_id];
797         spin_lock(&blade->bs_lock);
798
799         ctxnum = next_ctxnum(blade->bs_lru_ctxnum);
800         gru = blade->bs_lru_gru;
801         if (ctxnum == 0)
802                 gru = next_gru(blade, gru);
803         blade->bs_lru_gru = gru;
804         blade->bs_lru_ctxnum = ctxnum;
805         ctxnum0 = ctxnum;
806         gru0 = gru;
807         while (1) {
808                 if (gru_check_chiplet_assignment(gru, gts)) {
809                         if (check_gru_resources(gru, cbr, dsr, GRU_NUM_CCH))
810                                 break;
811                         spin_lock(&gru->gs_lock);
812                         for (; ctxnum < GRU_NUM_CCH; ctxnum++) {
813                                 if (flag && gru == gru0 && ctxnum == ctxnum0)
814                                         break;
815                                 ngts = gru->gs_gts[ctxnum];
816                                 /*
817                                 * We are grabbing locks out of order, so trylock is
818                                 * needed. GTSs are usually not locked, so the odds of
819                                 * success are high. If trylock fails, try to steal a
820                                 * different GSEG.
821                                 */
822                                 if (ngts && is_gts_stealable(ngts, blade))
823                                         break;
824                                 ngts = NULL;
825                         }
826                         spin_unlock(&gru->gs_lock);
827                         if (ngts || (flag && gru == gru0 && ctxnum == ctxnum0))
828                                 break;
829                 }
830                 if (flag && gru == gru0)
831                         break;
832                 flag = 1;
833                 ctxnum = 0;
834                 gru = next_gru(blade, gru);
835         }
836         spin_unlock(&blade->bs_lock);
837
838         if (ngts) {
839                 gts->ustats.context_stolen++;
840                 ngts->ts_steal_jiffies = jiffies;
841                 gru_unload_context(ngts, is_kernel_context(ngts) ? 0 : 1);
842                 gts_stolen(ngts, blade);
843         } else {
844                 STAT(steal_context_failed);
845         }
846         gru_dbg(grudev,
847                 "stole gid %d, ctxnum %d from gts %p. Need cb %d, ds %d;"
848                 " avail cb %ld, ds %ld\n",
849                 gru->gs_gid, ctxnum, ngts, cbr, dsr, hweight64(gru->gs_cbr_map),
850                 hweight64(gru->gs_dsr_map));
851 }
852
853 /*
854  * Assign a gru context.
855  */
856 static int gru_assign_context_number(struct gru_state *gru)
857 {
858         int ctxnum;
859
860         ctxnum = find_first_zero_bit(&gru->gs_context_map, GRU_NUM_CCH);
861         __set_bit(ctxnum, &gru->gs_context_map);
862         return ctxnum;
863 }
864
865 /*
866  * Scan the GRUs on the local blade & assign a GRU context.
867  */
868 struct gru_state *gru_assign_gru_context(struct gru_thread_state *gts)
869 {
870         struct gru_state *gru, *grux;
871         int i, max_active_contexts;
872         int blade_id = gts->ts_user_blade_id;
873
874         if (blade_id < 0)
875                 blade_id = uv_numa_blade_id();
876 again:
877         gru = NULL;
878         max_active_contexts = GRU_NUM_CCH;
879         for_each_gru_on_blade(grux, blade_id, i) {
880                 if (!gru_check_chiplet_assignment(grux, gts))
881                         continue;
882                 if (check_gru_resources(grux, gts->ts_cbr_au_count,
883                                         gts->ts_dsr_au_count,
884                                         max_active_contexts)) {
885                         gru = grux;
886                         max_active_contexts = grux->gs_active_contexts;
887                         if (max_active_contexts == 0)
888                                 break;
889                 }
890         }
891
892         if (gru) {
893                 spin_lock(&gru->gs_lock);
894                 if (!check_gru_resources(gru, gts->ts_cbr_au_count,
895                                          gts->ts_dsr_au_count, GRU_NUM_CCH)) {
896                         spin_unlock(&gru->gs_lock);
897                         goto again;
898                 }
899                 reserve_gru_resources(gru, gts);
900                 gts->ts_gru = gru;
901                 gts->ts_blade = gru->gs_blade_id;
902                 gts->ts_ctxnum = gru_assign_context_number(gru);
903                 atomic_inc(&gts->ts_refcnt);
904                 gru->gs_gts[gts->ts_ctxnum] = gts;
905                 spin_unlock(&gru->gs_lock);
906
907                 STAT(assign_context);
908                 gru_dbg(grudev,
909                         "gseg %p, gts %p, gid %d, ctx %d, cbr %d, dsr %d\n",
910                         gseg_virtual_address(gts->ts_gru, gts->ts_ctxnum), gts,
911                         gts->ts_gru->gs_gid, gts->ts_ctxnum,
912                         gts->ts_cbr_au_count, gts->ts_dsr_au_count);
913         } else {
914                 gru_dbg(grudev, "failed to allocate a GTS %s\n", "");
915                 STAT(assign_context_failed);
916         }
917
918         return gru;
919 }
920
921 /*
922  * gru_nopage
923  *
924  * Map the user's GRU segment
925  *
926  *      Note: gru segments alway mmaped on GRU_GSEG_PAGESIZE boundaries.
927  */
928 int gru_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
929 {
930         struct gru_thread_state *gts;
931         unsigned long paddr, vaddr;
932
933         vaddr = (unsigned long)vmf->virtual_address;
934         gru_dbg(grudev, "vma %p, vaddr 0x%lx (0x%lx)\n",
935                 vma, vaddr, GSEG_BASE(vaddr));
936         STAT(nopfn);
937
938         /* The following check ensures vaddr is a valid address in the VMA */
939         gts = gru_find_thread_state(vma, TSID(vaddr, vma));
940         if (!gts)
941                 return VM_FAULT_SIGBUS;
942
943 again:
944         mutex_lock(&gts->ts_ctxlock);
945         preempt_disable();
946
947         gru_check_context_placement(gts);
948
949         if (!gts->ts_gru) {
950                 STAT(load_user_context);
951                 if (!gru_assign_gru_context(gts)) {
952                         preempt_enable();
953                         mutex_unlock(&gts->ts_ctxlock);
954                         set_current_state(TASK_INTERRUPTIBLE);
955                         schedule_timeout(GRU_ASSIGN_DELAY);  /* true hack ZZZ */
956                         if (gts->ts_steal_jiffies + GRU_STEAL_DELAY < jiffies)
957                                 gru_steal_context(gts);
958                         goto again;
959                 }
960                 gru_load_context(gts);
961                 paddr = gseg_physical_address(gts->ts_gru, gts->ts_ctxnum);
962                 remap_pfn_range(vma, vaddr & ~(GRU_GSEG_PAGESIZE - 1),
963                                 paddr >> PAGE_SHIFT, GRU_GSEG_PAGESIZE,
964                                 vma->vm_page_prot);
965         }
966
967         preempt_enable();
968         mutex_unlock(&gts->ts_ctxlock);
969
970         return VM_FAULT_NOPAGE;
971 }
972