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