← Back to branch summary

~ubuntu-branches/debian/experimental/linux-tools/experimental

« back to all changes in this revision

Viewing changes to arch/powerpc/include/asm/kvm_book3s.h

  • Committer: Package Import Robot
  • Author(s): Ben Hutchings
  • Date: 2014-02-02 16:57:49 UTC
  • mfrom: (1.1.10) (0.1.21 sid)
  • Revision ID: package-import@ubuntu.com-20140202165749-tw94o9t1t0a8txk6
Tags: 3.13-1~exp2
Merge changes from sid up to 3.12.6-3

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/powerpc/include/asm/kvm_book3s.h
58
58
        struct hlist_node list_pte_long;
59
59
        struct hlist_node list_vpte;
60
60
        struct hlist_node list_vpte_long;
 
61
#ifdef CONFIG_PPC_BOOK3S_64
 
62
        struct hlist_node list_vpte_64k;
 
63
#endif
61
64
        struct rcu_head rcu_head;
62
65
        u64 host_vpn;
63
66
        u64 pfn;
64
67
        ulong slot;
65
68
        struct kvmppc_pte pte;
 
69
        int pagesize;
66
70
};
67
71
 
68
72
struct kvmppc_vcpu_book3s {
69
 
        struct kvm_vcpu vcpu;
70
 
        struct kvmppc_book3s_shadow_vcpu *shadow_vcpu;
71
73
        struct kvmppc_sid_map sid_map[SID_MAP_NUM];
72
74
        struct {
73
75
                u64 esid;
99
101
        struct hlist_head hpte_hash_pte_long[HPTEG_HASH_NUM_PTE_LONG];
100
102
        struct hlist_head hpte_hash_vpte[HPTEG_HASH_NUM_VPTE];
101
103
        struct hlist_head hpte_hash_vpte_long[HPTEG_HASH_NUM_VPTE_LONG];
 
104
#ifdef CONFIG_PPC_BOOK3S_64
 
105
        struct hlist_head hpte_hash_vpte_64k[HPTEG_HASH_NUM_VPTE_64K];
 
106
#endif
102
107
        int hpte_cache_count;
103
108
        spinlock_t mmu_lock;
104
109
};
107
112
#define CONTEXT_GUEST           1
108
113
#define CONTEXT_GUEST_END       2
109
114
 
110
 
#define VSID_REAL       0x0fffffffffc00000ULL
111
 
#define VSID_BAT        0x0fffffffffb00000ULL
 
115
#define VSID_REAL       0x07ffffffffc00000ULL
 
116
#define VSID_BAT        0x07ffffffffb00000ULL
 
117
#define VSID_64K        0x0800000000000000ULL
112
118
#define VSID_1T         0x1000000000000000ULL
113
119
#define VSID_REAL_DR    0x2000000000000000ULL
114
120
#define VSID_REAL_IR    0x4000000000000000ULL
118
124
extern void kvmppc_mmu_pte_vflush(struct kvm_vcpu *vcpu, u64 vp, u64 vp_mask);
119
125
extern void kvmppc_mmu_pte_pflush(struct kvm_vcpu *vcpu, ulong pa_start, ulong pa_end);
120
126
extern void kvmppc_set_msr(struct kvm_vcpu *vcpu, u64 new_msr);
121
 
extern void kvmppc_set_pvr(struct kvm_vcpu *vcpu, u32 pvr);
122
127
extern void kvmppc_mmu_book3s_64_init(struct kvm_vcpu *vcpu);
123
128
extern void kvmppc_mmu_book3s_32_init(struct kvm_vcpu *vcpu);
124
129
extern void kvmppc_mmu_book3s_hv_init(struct kvm_vcpu *vcpu);
125
 
extern int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte);
 
130
extern int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte,
 
131
                               bool iswrite);
 
132
extern void kvmppc_mmu_unmap_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *pte);
126
133
extern int kvmppc_mmu_map_segment(struct kvm_vcpu *vcpu, ulong eaddr);
127
134
extern void kvmppc_mmu_flush_segment(struct kvm_vcpu *vcpu, ulong eaddr, ulong seg_size);
128
135
extern void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu);
134
141
 
135
142
extern void kvmppc_mmu_hpte_cache_map(struct kvm_vcpu *vcpu, struct hpte_cache *pte);
136
143
extern struct hpte_cache *kvmppc_mmu_hpte_cache_next(struct kvm_vcpu *vcpu);
 
144
extern void kvmppc_mmu_hpte_cache_free(struct hpte_cache *pte);
137
145
extern void kvmppc_mmu_hpte_destroy(struct kvm_vcpu *vcpu);
138
146
extern int kvmppc_mmu_hpte_init(struct kvm_vcpu *vcpu);
139
147
extern void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte);
151
159
                           bool upper, u32 val);
152
160
extern void kvmppc_giveup_ext(struct kvm_vcpu *vcpu, ulong msr);
153
161
extern int kvmppc_emulate_paired_single(struct kvm_run *run, struct kvm_vcpu *vcpu);
154
 
extern pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
 
162
extern pfn_t kvmppc_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn, bool writing,
 
163
                        bool *writable);
155
164
extern void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev,
156
165
                        unsigned long *rmap, long pte_index, int realmode);
157
166
extern void kvmppc_invalidate_hpte(struct kvm *kvm, unsigned long *hptep,
172
181
                        unsigned long *hpret);
173
182
extern long kvmppc_hv_get_dirty_log(struct kvm *kvm,
174
183
                        struct kvm_memory_slot *memslot, unsigned long *map);
 
184
extern void kvmppc_update_lpcr(struct kvm *kvm, unsigned long lpcr,
 
185
                        unsigned long mask);
175
186
 
176
187
extern void kvmppc_entry_trampoline(void);
177
188
extern void kvmppc_hv_entry_trampoline(void);
181
192
extern u32 kvmppc_alignment_dsisr(struct kvm_vcpu *vcpu, unsigned int inst);
182
193
extern ulong kvmppc_alignment_dar(struct kvm_vcpu *vcpu, unsigned int inst);
183
194
extern int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd);
 
195
extern void kvmppc_copy_to_svcpu(struct kvmppc_book3s_shadow_vcpu *svcpu,
 
196
                                 struct kvm_vcpu *vcpu);
 
197
extern void kvmppc_copy_from_svcpu(struct kvm_vcpu *vcpu,
 
198
                                   struct kvmppc_book3s_shadow_vcpu *svcpu);
184
199
 
185
200
static inline struct kvmppc_vcpu_book3s *to_book3s(struct kvm_vcpu *vcpu)
186
201
{
187
 
        return container_of(vcpu, struct kvmppc_vcpu_book3s, vcpu);
 
202
        return vcpu->arch.book3s;
188
203
}
189
204
 
190
 
extern void kvm_return_point(void);
191
 
 
192
205
/* Also add subarch specific defines */
193
206
 
194
207
#ifdef CONFIG_KVM_BOOK3S_32_HANDLER
198
211
#include <asm/kvm_book3s_64.h>
199
212
#endif
200
213
 
201
 
#ifdef CONFIG_KVM_BOOK3S_PR
202
 
 
203
 
static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu)
204
 
{
205
 
        return to_book3s(vcpu)->hior;
206
 
}
207
 
 
208
 
static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu,
209
 
                        unsigned long pending_now, unsigned long old_pending)
210
 
{
211
 
        if (pending_now)
212
 
                vcpu->arch.shared->int_pending = 1;
213
 
        else if (old_pending)
214
 
                vcpu->arch.shared->int_pending = 0;
215
 
}
216
 
 
217
 
static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val)
218
 
{
219
 
        if ( num < 14 ) {
220
 
                struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
221
 
                svcpu->gpr[num] = val;
222
 
                svcpu_put(svcpu);
223
 
                to_book3s(vcpu)->shadow_vcpu->gpr[num] = val;
224
 
        } else
225
 
                vcpu->arch.gpr[num] = val;
226
 
}
227
 
 
228
 
static inline ulong kvmppc_get_gpr(struct kvm_vcpu *vcpu, int num)
229
 
{
230
 
        if ( num < 14 ) {
231
 
                struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
232
 
                ulong r = svcpu->gpr[num];
233
 
                svcpu_put(svcpu);
234
 
                return r;
235
 
        } else
236
 
                return vcpu->arch.gpr[num];
237
 
}
238
 
 
239
 
static inline void kvmppc_set_cr(struct kvm_vcpu *vcpu, u32 val)
240
 
{
241
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
242
 
        svcpu->cr = val;
243
 
        svcpu_put(svcpu);
244
 
        to_book3s(vcpu)->shadow_vcpu->cr = val;
245
 
}
246
 
 
247
 
static inline u32 kvmppc_get_cr(struct kvm_vcpu *vcpu)
248
 
{
249
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
250
 
        u32 r;
251
 
        r = svcpu->cr;
252
 
        svcpu_put(svcpu);
253
 
        return r;
254
 
}
255
 
 
256
 
static inline void kvmppc_set_xer(struct kvm_vcpu *vcpu, u32 val)
257
 
{
258
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
259
 
        svcpu->xer = val;
260
 
        to_book3s(vcpu)->shadow_vcpu->xer = val;
261
 
        svcpu_put(svcpu);
262
 
}
263
 
 
264
 
static inline u32 kvmppc_get_xer(struct kvm_vcpu *vcpu)
265
 
{
266
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
267
 
        u32 r;
268
 
        r = svcpu->xer;
269
 
        svcpu_put(svcpu);
270
 
        return r;
271
 
}
272
 
 
273
 
static inline void kvmppc_set_ctr(struct kvm_vcpu *vcpu, ulong val)
274
 
{
275
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
276
 
        svcpu->ctr = val;
277
 
        svcpu_put(svcpu);
278
 
}
279
 
 
280
 
static inline ulong kvmppc_get_ctr(struct kvm_vcpu *vcpu)
281
 
{
282
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
283
 
        ulong r;
284
 
        r = svcpu->ctr;
285
 
        svcpu_put(svcpu);
286
 
        return r;
287
 
}
288
 
 
289
 
static inline void kvmppc_set_lr(struct kvm_vcpu *vcpu, ulong val)
290
 
{
291
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
292
 
        svcpu->lr = val;
293
 
        svcpu_put(svcpu);
294
 
}
295
 
 
296
 
static inline ulong kvmppc_get_lr(struct kvm_vcpu *vcpu)
297
 
{
298
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
299
 
        ulong r;
300
 
        r = svcpu->lr;
301
 
        svcpu_put(svcpu);
302
 
        return r;
303
 
}
304
 
 
305
 
static inline void kvmppc_set_pc(struct kvm_vcpu *vcpu, ulong val)
306
 
{
307
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
308
 
        svcpu->pc = val;
309
 
        svcpu_put(svcpu);
310
 
}
311
 
 
312
 
static inline ulong kvmppc_get_pc(struct kvm_vcpu *vcpu)
313
 
{
314
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
315
 
        ulong r;
316
 
        r = svcpu->pc;
317
 
        svcpu_put(svcpu);
318
 
        return r;
319
 
}
320
 
 
321
 
static inline u32 kvmppc_get_last_inst(struct kvm_vcpu *vcpu)
322
 
{
323
 
        ulong pc = kvmppc_get_pc(vcpu);
324
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
325
 
        u32 r;
326
 
 
327
 
        /* Load the instruction manually if it failed to do so in the
328
 
         * exit path */
329
 
        if (svcpu->last_inst == KVM_INST_FETCH_FAILED)
330
 
                kvmppc_ld(vcpu, &pc, sizeof(u32), &svcpu->last_inst, false);
331
 
 
332
 
        r = svcpu->last_inst;
333
 
        svcpu_put(svcpu);
334
 
        return r;
335
 
}
336
 
 
337
 
/*
338
 
 * Like kvmppc_get_last_inst(), but for fetching a sc instruction.
339
 
 * Because the sc instruction sets SRR0 to point to the following
340
 
 * instruction, we have to fetch from pc - 4.
341
 
 */
342
 
static inline u32 kvmppc_get_last_sc(struct kvm_vcpu *vcpu)
343
 
{
344
 
        ulong pc = kvmppc_get_pc(vcpu) - 4;
345
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
346
 
        u32 r;
347
 
 
348
 
        /* Load the instruction manually if it failed to do so in the
349
 
         * exit path */
350
 
        if (svcpu->last_inst == KVM_INST_FETCH_FAILED)
351
 
                kvmppc_ld(vcpu, &pc, sizeof(u32), &svcpu->last_inst, false);
352
 
 
353
 
        r = svcpu->last_inst;
354
 
        svcpu_put(svcpu);
355
 
        return r;
356
 
}
357
 
 
358
 
static inline ulong kvmppc_get_fault_dar(struct kvm_vcpu *vcpu)
359
 
{
360
 
        struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
361
 
        ulong r;
362
 
        r = svcpu->fault_dar;
363
 
        svcpu_put(svcpu);
364
 
        return r;
365
 
}
366
 
 
367
 
static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu)
368
 
{
369
 
        ulong crit_raw = vcpu->arch.shared->critical;
370
 
        ulong crit_r1 = kvmppc_get_gpr(vcpu, 1);
371
 
        bool crit;
372
 
 
373
 
        /* Truncate crit indicators in 32 bit mode */
374
 
        if (!(vcpu->arch.shared->msr & MSR_SF)) {
375
 
                crit_raw &= 0xffffffff;
376
 
                crit_r1 &= 0xffffffff;
377
 
        }
378
 
 
379
 
        /* Critical section when crit == r1 */
380
 
        crit = (crit_raw == crit_r1);
381
 
        /* ... and we're in supervisor mode */
382
 
        crit = crit && !(vcpu->arch.shared->msr & MSR_PR);
383
 
 
384
 
        return crit;
385
 
}
386
 
#else /* CONFIG_KVM_BOOK3S_PR */
387
 
 
388
 
static inline unsigned long kvmppc_interrupt_offset(struct kvm_vcpu *vcpu)
389
 
{
390
 
        return 0;
391
 
}
392
 
 
393
 
static inline void kvmppc_update_int_pending(struct kvm_vcpu *vcpu,
394
 
                        unsigned long pending_now, unsigned long old_pending)
395
 
{
396
 
}
397
 
 
398
214
static inline void kvmppc_set_gpr(struct kvm_vcpu *vcpu, int num, ulong val)
399
215
{
400
216
        vcpu->arch.gpr[num] = val;
489
305
        return vcpu->arch.fault_dar;
490
306
}
491
307
 
492
 
static inline bool kvmppc_critical_section(struct kvm_vcpu *vcpu)
493
 
{
494
 
        return false;
495
 
}
496
 
#endif
497
 
 
498
308
/* Magic register values loaded into r3 and r4 before the 'sc' assembly
499
309
 * instruction for the OSI hypercalls */
500
310
#define OSI_SC_MAGIC_R3                 0x113724FA