← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-s390x/kvm.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-01-14 23:22:51 UTC
  • mfrom: (1.6.7) (11.1.12 experimental)
  • Revision ID: package-import@ubuntu.com-20130114232251-zuuixzxdshv9uu7s
Tags: 1.3.0+dfsg-1~exp3ubuntu1
* Merge 1.3.0+dfsg-1~exp3.  Remaining ubuntu delta:
  - debian/control:
    * update maintainer
    * remove vde2 recommends
    * build-deps: remove libusbredir, libvdeplug2-dev,
      libspice-server-dev, libspice-protocol-dev, libiscsi-dev,
      and libxen-dev.
    * qemu-keymaps: break/replace qemu-common
    * qemu-system:
      - break/replace qemu-common
      - depend on udev
      - remove openbios-ppc, openbios-sparc, and openhackware from
        Depends.  (Intend to add them back once we can build them.)
      - provides: qemu-kvm
    * qemu-utils: break/replace qemu-kvm
    * set up transitional packages for qemu-kvm, qemu-common, and kvm.
  - qemu-kvm.upstart:
    - add qemu-system.qemu-kvm.upstart
    - debian/rules: add dh_installinit to get qemu-system.upstart installed.
    - take the defaults from the old qemu-kvm.defaults, and move them into
      the upstart job
  - debian/patches:
    - apply gridcentric patches from lp:~amscanne/+junk/gridcentric-qemu-patches
    - apply arm patches from git://git.linaro.org/qemu/qemu-linaro.git
  - ifup/down:
    - copy Debian qemu-kvm's kvm-ifup/down into debian/
    - fix dh_install for kvm-ifup/down in debian/rules
    - add links for qemu-ifup/down in qemu-system.links
    - remove (debian's original) qemu-ifup from qemu-system.install
  - debian/qemu-system.postinst
    - udevadm trigger to fix up /dev/kvm perms
    - make the 'qemu' symlink point to qemu-system-x86_64, not -i386.
  - debian/qemu-system.links:
    - point 'kvm' to qemu-system-x86_64
    - remove pxe-virtio, pxe-e1000 and pxe-rtl8139 links (which conflict
      with ones from kvm-ipxe).  We may want to move the links from kvm-ipxe
      back to qemu-system at some point.
* Add note about kvm to qemu-system.README.debian.
* Copy kvm-ifup and kvm-ifdown from debian's qemu-kvm
* Remove TAPBR from qemu-kvm.conf.
* Make sure /dev/kvm gets its acls cleared:
  - Add acl to qemu-system.depends
  - update qemu-system.udev to run setfacl to set g::rw acl
* qemu-system.qemu-kvm.conf: don't rmmod at stop
* Remove vnc-jpeg, libiscsi-dev, and vde from debian/configure-opts
* Remove hugepages sysctl file - qemu now supports transparent hugepages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-s390x/kvm.c
60
60
#define SIGP_STORE_STATUS_ADDR          0x0e
61
61
#define SIGP_SET_ARCH                   0x12
62
62
 
63
 
#define SCLP_CMDW_READ_SCP_INFO         0x00020001
64
 
#define SCLP_CMDW_READ_SCP_INFO_FORCED  0x00120001
65
 
 
66
63
const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
67
64
    KVM_CAP_LAST_INFO
68
65
};
69
66
 
 
67
static int cap_sync_regs;
 
68
 
70
69
int kvm_arch_init(KVMState *s)
71
70
{
 
71
    cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);
72
72
    return 0;
73
73
}
74
74
 
90
90
 
91
91
int kvm_arch_put_registers(CPUS390XState *env, int level)
92
92
{
 
93
    struct kvm_sregs sregs;
93
94
    struct kvm_regs regs;
94
95
    int ret;
95
96
    int i;
96
97
 
97
 
    ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
98
 
    if (ret < 0) {
99
 
        return ret;
100
 
    }
101
 
 
102
 
    for (i = 0; i < 16; i++) {
103
 
        regs.gprs[i] = env->regs[i];
104
 
    }
105
 
 
106
 
    ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
107
 
    if (ret < 0) {
108
 
        return ret;
109
 
    }
110
 
 
 
98
    /* always save the PSW  and the GPRS*/
111
99
    env->kvm_run->psw_addr = env->psw.addr;
112
100
    env->kvm_run->psw_mask = env->psw.mask;
113
101
 
114
 
    return ret;
 
102
    if (cap_sync_regs && env->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
 
103
        for (i = 0; i < 16; i++) {
 
104
            env->kvm_run->s.regs.gprs[i] = env->regs[i];
 
105
            env->kvm_run->kvm_dirty_regs |= KVM_SYNC_GPRS;
 
106
        }
 
107
    } else {
 
108
        for (i = 0; i < 16; i++) {
 
109
            regs.gprs[i] = env->regs[i];
 
110
        }
 
111
        ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
 
112
        if (ret < 0) {
 
113
            return ret;
 
114
        }
 
115
    }
 
116
 
 
117
    /* Do we need to save more than that? */
 
118
    if (level == KVM_PUT_RUNTIME_STATE) {
 
119
        return 0;
 
120
    }
 
121
 
 
122
    if (cap_sync_regs &&
 
123
        env->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
 
124
        env->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
 
125
        for (i = 0; i < 16; i++) {
 
126
            env->kvm_run->s.regs.acrs[i] = env->aregs[i];
 
127
            env->kvm_run->s.regs.crs[i] = env->cregs[i];
 
128
        }
 
129
        env->kvm_run->kvm_dirty_regs |= KVM_SYNC_ACRS;
 
130
        env->kvm_run->kvm_dirty_regs |= KVM_SYNC_CRS;
 
131
    } else {
 
132
        for (i = 0; i < 16; i++) {
 
133
            sregs.acrs[i] = env->aregs[i];
 
134
            sregs.crs[i] = env->cregs[i];
 
135
        }
 
136
        ret = kvm_vcpu_ioctl(env, KVM_SET_SREGS, &sregs);
 
137
        if (ret < 0) {
 
138
            return ret;
 
139
        }
 
140
    }
 
141
 
 
142
    /* Finally the prefix */
 
143
    if (cap_sync_regs && env->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
 
144
        env->kvm_run->s.regs.prefix = env->psa;
 
145
        env->kvm_run->kvm_dirty_regs |= KVM_SYNC_PREFIX;
 
146
    } else {
 
147
        /* prefix is only supported via sync regs */
 
148
    }
 
149
    return 0;
115
150
}
116
151
 
117
152
int kvm_arch_get_registers(CPUS390XState *env)
118
153
{
 
154
    struct kvm_sregs sregs;
 
155
    struct kvm_regs regs;
119
156
    int ret;
120
 
    struct kvm_regs regs;
121
157
    int i;
122
158
 
123
 
    ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
124
 
    if (ret < 0) {
125
 
        return ret;
126
 
    }
127
 
 
128
 
    for (i = 0; i < 16; i++) {
129
 
        env->regs[i] = regs.gprs[i];
130
 
    }
131
 
 
 
159
    /* get the PSW */
132
160
    env->psw.addr = env->kvm_run->psw_addr;
133
161
    env->psw.mask = env->kvm_run->psw_mask;
134
162
 
 
163
    /* the GPRS */
 
164
    if (cap_sync_regs && env->kvm_run->kvm_valid_regs & KVM_SYNC_GPRS) {
 
165
        for (i = 0; i < 16; i++) {
 
166
            env->regs[i] = env->kvm_run->s.regs.gprs[i];
 
167
        }
 
168
    } else {
 
169
        ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
 
170
        if (ret < 0) {
 
171
            return ret;
 
172
        }
 
173
         for (i = 0; i < 16; i++) {
 
174
            env->regs[i] = regs.gprs[i];
 
175
        }
 
176
    }
 
177
 
 
178
    /* The ACRS and CRS */
 
179
    if (cap_sync_regs &&
 
180
        env->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
 
181
        env->kvm_run->kvm_valid_regs & KVM_SYNC_CRS) {
 
182
        for (i = 0; i < 16; i++) {
 
183
            env->aregs[i] = env->kvm_run->s.regs.acrs[i];
 
184
            env->cregs[i] = env->kvm_run->s.regs.crs[i];
 
185
        }
 
186
    } else {
 
187
        ret = kvm_vcpu_ioctl(env, KVM_GET_SREGS, &sregs);
 
188
        if (ret < 0) {
 
189
            return ret;
 
190
        }
 
191
         for (i = 0; i < 16; i++) {
 
192
            env->aregs[i] = sregs.acrs[i];
 
193
            env->cregs[i] = sregs.crs[i];
 
194
        }
 
195
    }
 
196
 
 
197
    /* Finally the prefix */
 
198
    if (cap_sync_regs && env->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
 
199
        env->psa = env->kvm_run->s.regs.prefix;
 
200
    } else {
 
201
        /* no prefix without sync regs */
 
202
    }
 
203
 
135
204
    return 0;
136
205
}
137
206
 
272
341
    sccb = env->regs[ipbh0 & 0xf];
273
342
    code = env->regs[(ipbh0 & 0xf0) >> 4];
274
343
 
275
 
    r = sclp_service_call(env, sccb, code);
 
344
    r = sclp_service_call(sccb, code);
276
345
    if (r < 0) {
277
346
        enter_pgmcheck(env, -r);
278
347
    }
334
403
 
335
404
    kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
336
405
    s390_add_running_cpu(env);
337
 
    qemu_cpu_kick(env);
 
406
    qemu_cpu_kick(CPU(cpu));
338
407
    dprintf("DONE: SIGP cpu restart: %p\n", env);
339
408
    return 0;
340
409
}