fpga: move GetAPIVersion call out of NewPort and NewFME

This call is implemented by calling ioctl, which raises
"open /dev/intel-fpga-port.X: operation not permitted" error
when called inside unprivileged container.

This breaks FPGA plugin.

Calling this API from fpga_tool is still OK, so
moving calls there should fix the issue.

Signed-off-by: Ed Bartosh <[email protected]>

Author: bart0sh

cmd/fpga_tool/fpga_tool.go

@@ -181,14 +181,16 @@ func fpgaInfo(fname string, quiet bool) error {
 }
 
 func fmeInfo(fname string, quiet bool) error {
-	var f fpga.FME
-	var err error
-	f, err = fpga.NewFME(fname)
+	fme, err := fpga.NewFME(fname)
 	if err != nil {
 		return err
 	}
-	defer f.Close()
-	return printFpgaFME(f, quiet)
+	defer fme.Close()
+	// check that kernel API is compatible
+	if _, err := fme.GetAPIVersion(); err != nil {
+		return errors.Wrap(err, "kernel API mismatch")
+	}
+	return printFpgaFME(fme, quiet)
 }
 
 func printFpgaFME(f fpga.FME, quiet bool) (err error) {
@@ -218,28 +220,33 @@ func printFpgaFME(f fpga.FME, quiet bool) (err error) {
 }
 
 func portReleaseOrAssign(fname string, port uint, release, quiet bool) error {
-	var f fpga.FME
-	var err error
-	f, err = fpga.NewFME(fname)
+	fme, err := fpga.NewFME(fname)
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer fme.Close()
+	// check that kernel API is compatible
+	if _, err := fme.GetAPIVersion(); err != nil {
+		return errors.Wrap(err, "kernel API mismatch")
+	}
 	if release {
-		return f.PortRelease(uint32(port))
+		return fme.PortRelease(uint32(port))
 	}
-	return f.PortAssign(uint32(port))
+	return fme.PortAssign(uint32(port))
 }
 
 func portInfo(fname string, quiet bool) error {
-	var f fpga.Port
-	var err error
-	f, err = fpga.NewPort(fname)
+	port, err := fpga.NewPort(fname)
 	if err != nil {
 		return err
 	}
-	defer f.Close()
-	return printFpgaPort(f, quiet)
+	defer port.Close()
+	// check that kernel API is compatible
+	if _, err = port.GetAPIVersion(); err != nil {
+		return errors.Wrap(err, "kernel API mismatch")
+	}
+
+	return printFpgaPort(port, quiet)
 }
 
 func printFpgaPort(f fpga.Port, quiet bool) (err error) {
@@ -313,32 +320,37 @@ func printPCIeInfo(pci *fpga.PCIDevice, quiet bool) {
 	}
 }
 
-func doPR(dev, fname string, dryRun, quiet bool) (err error) {
-	fp, err := fpga.NewPort(dev)
+func doPR(dev, fname string, dryRun, quiet bool) error {
+	port, err := fpga.NewPort(dev)
 	if err != nil {
-		return
+		return err
+	}
+	defer port.Close()
+	// check that kernel API is compatible
+	if _, err = port.GetAPIVersion(); err != nil {
+		return errors.Wrap(err, "kernel API mismatch")
 	}
-	defer fp.Close()
+
 	bs, err := bitstream.Open(fname)
 	if err != nil {
-		return
+		return err
 	}
 	defer bs.Close()
 
 	if !quiet {
-		fmt.Printf("Before: Interface ID: %q AFU ID: %q\n", fp.GetInterfaceUUID(), fp.GetAcceleratorTypeUUID())
+		fmt.Printf("Before: Interface ID: %q AFU ID: %q\n", port.GetInterfaceUUID(), port.GetAcceleratorTypeUUID())
 		fmt.Printf("Programming %q to port %q: ", fname, dev)
 	}
-	err = fp.PR(bs, dryRun)
+	err = port.PR(bs, dryRun)
 	if !quiet {
 		if err != nil {
 			fmt.Println("FAILED")
 		} else {
 			fmt.Println("OK")
 		}
-		fmt.Printf("After : Interface ID: %q AFU ID: %q\n", fp.GetInterfaceUUID(), fp.GetAcceleratorTypeUUID())
+		fmt.Printf("After : Interface ID: %q AFU ID: %q\n", port.GetInterfaceUUID(), port.GetAcceleratorTypeUUID())
 	}
-	return
+	return err
 }
 
 func listDevices(listFMEs, listPorts, quiet bool) error {

pkg/fpga/dfl_linux.go

@@ -56,10 +56,6 @@ func (f *DflFME) Close() error {
 // NewDflFME Opens device.
 func NewDflFME(dev string) (FME, error) {
 	fme := &DflFME{DevPath: dev}
-	// check that kernel API is compatible
-	if _, err := fme.GetAPIVersion(); err != nil {
-		return nil, errors.Wrap(err, "kernel API mismatch")
-	}
 	if err := checkVendorAndClass(fme); err != nil {
 		return nil, err
 	}
@@ -96,10 +92,6 @@ func (f *DflPort) Close() error {
 // NewDflPort Opens device.
 func NewDflPort(dev string) (Port, error) {
 	port := &DflPort{DevPath: dev}
-	// check that kernel API is compatible
-	if _, err := port.GetAPIVersion(); err != nil {
-		return nil, errors.Wrap(err, "kernel API mismatch")
-	}
 	if err := checkVendorAndClass(port); err != nil {
 		return nil, err
 	}

pkg/fpga/intel_fpga_linux.go

@@ -53,10 +53,6 @@ func (f *IntelFpgaFME) Close() error {
 // NewIntelFpgaFME Opens device.
 func NewIntelFpgaFME(dev string) (FME, error) {
 	fme := &IntelFpgaFME{DevPath: dev}
-	// check that kernel API is compatible
-	if _, err := fme.GetAPIVersion(); err != nil {
-		return nil, errors.Wrap(err, "kernel API mismatch")
-	}
 	if err := checkVendorAndClass(fme); err != nil {
 		return nil, err
 	}
@@ -90,11 +86,6 @@ func (f *IntelFpgaPort) Close() error {
 // NewIntelFpgaPort Opens device.
 func NewIntelFpgaPort(dev string) (Port, error) {
 	port := &IntelFpgaPort{DevPath: dev}
-	// check that kernel API is compatible
-	if _, err := port.GetAPIVersion(); err != nil {
-		port.Close()
-		return nil, errors.Wrap(err, "kernel API mismatch")
-	}
 	if err := checkVendorAndClass(port); err != nil {
 		port.Close()
 		return nil, err