Example #1
0
func (info DeviceInfo) Load() (Device, error) {

	// Find the appropriate driver.
	driver, ok := drivers[info.Driver]
	if !ok {
		return nil, DriverUnknown(info.Driver)
	}

	// Load the driver.
	device, err := driver(&info)
	if err != nil {
		return nil, err
	}

	if info.Data != nil {
		// Scratch data.
		buffer := bytes.NewBuffer(nil)

		// Encode the original object.
		encoder := utils.NewEncoder(buffer)
		err = encoder.Encode(info.Data)
		if err != nil {
			return nil, err
		}

		// Decode a new object.
		// This will override all the default
		// settings in the initialized object.
		decoder := utils.NewDecoder(buffer)
		log.Printf("Loading %s...", device.Name())
		err = decoder.Decode(device)
		if err != nil {
			return nil, err
		}
	}

	// Save the original device.
	// This will allow us to implement a
	// simple Save() method that serializes
	// the state of this device as it exists.
	info.Data = device

	// We're done.
	return device, nil
}
Example #2
0
func (control *Control) handle(
	conn_fd int,
	server *rpc.Server) {

	control_file := os.NewFile(uintptr(conn_fd), "control")
	defer control_file.Close()

	// Read single header.
	// Our header is exactly 9 characters, and we
	// expect the last character to be a newline.
	// This is a simple plaintext protocol.
	header_buf := make([]byte, 9, 9)
	n, err := control_file.Read(header_buf)
	if n != 9 || header_buf[8] != '\n' {
		if err != nil {
			control_file.Write([]byte(err.Error()))
		} else {
			control_file.Write([]byte("invalid header"))
		}
		return
	}
	header := string(header_buf)

	// We read a special header before diving into RPC
	// mode. This is because for the novmrun case, we turn
	// the socket into a stream of input/output events.
	// These are simply JSON serialized versions of the
	// events for the guest RPC interface.

	if header == "NOVM RUN\n" {

		decoder := utils.NewDecoder(control_file)
		encoder := utils.NewEncoder(control_file)

		var start noguest.StartCommand
		err := decoder.Decode(&start)
		if err != nil {
			// Poorly encoded command.
			encoder.Encode(err.Error())
			return
		}

		// Grab our client.
		client, err := control.Ready()
		if err != nil {
			encoder.Encode(err.Error())
			return
		}

		// Call start.
		result := noguest.StartResult{}
		err = client.Call("Server.Start", &start, &result)
		if err != nil {
			encoder.Encode(err.Error())
			return
		}

		// Save our pid.
		pid := result.Pid
		inputs := make(chan error)
		outputs := make(chan error)
		exitcode := make(chan int)

		// This indicates we're okay.
		encoder.Encode(nil)

		// Wait for the process to exit.
		go func() {
			wait := noguest.WaitCommand{
				Pid: pid,
			}
			var wait_result noguest.WaitResult
			err := client.Call("Server.Wait", &wait, &wait_result)
			if err != nil {
				exitcode <- 1
			} else {
				exitcode <- wait_result.Exitcode
			}
		}()

		// Read from stdout & stderr.
		go func() {
			read := noguest.ReadCommand{
				Pid: pid,
				N:   4096,
			}
			var read_result noguest.ReadResult
			for {
				err := client.Call("Server.Read", &read, &read_result)
				if err != nil {
					inputs <- err
					return
				}
				err = encoder.Encode(read_result.Data)
				if err != nil {
					inputs <- err
					return
				}
			}
		}()

		// Write to stdin.
		go func() {
			write := noguest.WriteCommand{
				Pid: pid,
			}
			var write_result noguest.WriteResult
			for {
				err := decoder.Decode(&write.Data)
				if err != nil {
					outputs <- err
					return
				}
				err = client.Call("Server.Write", &write, &write_result)
				if err != nil {
					outputs <- err
					return
				}
			}
		}()

		// Wait till exit.
		status := <-exitcode
		encoder.Encode(status)

		// Wait till EOF.
		<-inputs

		// Send a notice and close the socket.
		encoder.Encode(nil)

	} else if header == "NOVM RPC\n" {

		// Run as JSON RPC connection.
		codec := jsonrpc.NewServerCodec(control_file)
		server.ServeCodec(codec)
	}
}
Example #3
0
func main() {
	// Start processing signals.
	// Our setup can take a little while, so we
	// want to ensure we aren't using the default
	// handlers from the beginning.
	signals := make(chan os.Signal, 1)
	signal.Notify(
		signals,
		utils.SigShutdown,
		utils.SigRestart,
		utils.SigSpecialRestart)

	// Parse all command line options.
	flag.Parse()

	// Are we doing a special restart?
	// This will STOP the current process, and
	// wait for a CONT signal before resuming.
	// The STOP signal is not maskable, so the
	// runtime isn't capable of preventing this.
	// The whole point of this restart is as follows:
	//   * killall -USR2 novmm
	//   * upgrade kvm
	//   * killall -CONT novmm
	if *stop {
		syscall.Kill(syscall.Getpid(), syscall.SIGSTOP)
	}

	// Create VM.
	vm, err := platform.NewVm()
	if err != nil {
		utils.Die(err)
	}
	defer vm.Dispose()

	// Create the machine model.
	model, err := machine.NewModel(vm)
	if err != nil {
		utils.Die(err)
	}

	// Load our machine state.
	state_file := os.NewFile(uintptr(*statefd), "state")
	decoder := utils.NewDecoder(state_file)
	state := new(control.State)
	err = decoder.Decode(&state)
	if err != nil {
		utils.Die(err)
	}

	// We're done with the state file.
	state_file.Close()

	// Load all devices.
	log.Printf("Creating devices...")
	proxy, err := model.CreateDevices(vm, state.Devices, *debug)
	if err != nil {
		utils.Die(err)
	}

	// Load all vcpus.
	log.Printf("Creating vcpus...")
	vcpus, err := vm.CreateVcpus(state.Vcpus)
	if err != nil {
		utils.Die(err)
	}
	if len(vcpus) == 0 {
		utils.Die(NoVcpus)
	}

	// Load all model state.
	log.Printf("Loading model...")
	err = model.Load(vm)
	if err != nil {
		utils.Die(err)
	}

	// Pause all devices and vcpus if requested.
	if *paused {
		err = model.Pause(true)
		if err != nil {
			utils.Die(err)
		}
		err = vm.Pause(true)
		if err != nil {
			utils.Die(err)
		}
	}

	// Enable stepping if requested.
	if *step {
		for _, vcpu := range vcpus {
			vcpu.SetStepping(true)
		}
	}

	// Remember whether or not this is a load.
	// If it's a load, then we have to sync the
	// control interface. If it's not, then we
	// should skip the control interface sync.
	is_load := false

	// Load given kernel and initrd.
	var sysmap loader.SystemMap
	var convention *loader.Convention

	if *vmlinux != "" {
		log.Printf("Loading linux...")
		sysmap, convention, err = loader.LoadLinux(
			vcpus[0],
			model,
			*boot_params,
			*vmlinux,
			*initrd,
			*cmdline,
			*system_map)
		if err != nil {
			utils.Die(err)
		}

		// This is a fresh boot.
		is_load = true
	}

	// Create our tracer with the map and convention.
	tracer := loader.NewTracer(sysmap, convention)
	if *trace {
		tracer.Enable()
	}

	// Create our RPC server.
	log.Printf("Starting control server...")
	control, err := control.NewControl(
		*control_fd,
		*real_init,
		model,
		vm,
		tracer,
		proxy,
		is_load)
	if err != nil {
		utils.Die(err)
	}
	go control.Serve()

	// Start all VCPUs.
	// None of these will actually come online
	// until the primary VCPU below delivers the
	// appropriate IPI to start them up.
	log.Printf("Starting vcpus...")
	vcpu_err := make(chan error)
	for _, vcpu := range vcpus {
		go func(vcpu *platform.Vcpu) {
			err := Loop(vm, vcpu, model, tracer)
			vcpu_err <- err
		}(vcpu)
	}

	// Wait until we get a TERM signal, or all the VCPUs are dead.
	// If we receive a HUP signal, then we will re-exec with the
	// appropriate device state and vcpu state. This is essentially
	// a live upgrade (i.e. the binary has been replaced, we rerun).
	vcpus_alive := len(vcpus)

	for {
		select {
		case err := <-vcpu_err:
			vcpus_alive -= 1
			if err != nil {
				log.Printf("Vcpu died: %s", err.Error())
			}
		case sig := <-signals:
			switch sig {
			case utils.SigShutdown:
				log.Printf("Shutdown.")
				os.Exit(0)

			case utils.SigRestart:
				fallthrough
			case utils.SigSpecialRestart:

				// Make sure we have control sync'ed.
				_, err := control.Ready()
				if err != nil {
					utils.Die(err)
				}

				// This is a bit of a special case.
				// We don't log a fatal message here,
				// but rather unpause and keep going.
				err = restart(
					model,
					vm,
					tracer.IsEnabled(),
					sig == utils.SigSpecialRestart)
				log.Printf("Restart failed: %s", err.Error())
			}
		}

		// Everything died?
		if vcpus_alive == 0 {
			utils.Die(NoVcpus)
		}
	}
}