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