Mount local FS; get struct pointer so we can modify values

README.md

@@ -80,6 +80,40 @@ gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot
 +-----+----------+---------+-------------+
 </pre></code>
 
+Sort jails  
+----------
+Use -s switch followed by sort criteria. Criteria is a field name, prefixed with + or - for sort order (increase/decrease):  
+<pre><code>
+gocage list -f Config.Boot=1,Running=true -o JID,Name,Running,Config.Boot -s +JID
++=====+==========+=========+=============+
+| JID | Name     | Running | Config.Boot |
++=====+==========+=========+=============+
+| 22  | srv-dns1 | true    | 1           |
++-----+----------+---------+-------------+
+| 29  | bdd-tst  | true    | 1           |
++-----+----------+---------+-------------+
+| 183 | test     | true    | 1           |
++-----+----------+---------+-------------+
+</pre></code>
+
+You can use up to 3 criteria, delimited with comma.  
+As an example, you want to list boot priorities of automatically starting jails:  
+<pre><code>
+gocage list -o JID,Name,Config.Ip4_addr,Config.Priority,Config.Boot,Running -s -Config.Priority,-Config.Boot -f Running=true
++=====+==============+=======================+=================+=============+=========+
+| JID | Name         | Config.Ip4_addr       | Config.Priority | Config.Boot | Running |
++=====+==============+=======================+=================+=============+=========+
+| 1   | srv-dhcp     | vnet0|192.168.1.2/24  | 99              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 8   | srv-dns      | vnet0|192.168.1.1/24  | 80              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 7   | srv-random   | vnet0|192.168.1.12/24 | 20              | 1           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+| 4   | coincoin     | vnet0|192.168.1.9/24  | 20              | 0           | true    |
++-----+--------------+-----------------------+-----------------+-------------+---------+
+</pre></code>
+
+
 Stop jails
 ----------
 `gocage stop test`

cmd/list.go

@@ -16,13 +16,13 @@ import (
 
 // Recurse into structure, returning reflect.Value of wanted field.
 //  Nested fields are named with a dot (ex "MyStruct.MyField")
-func getStructFieldValue(parentStruct interface{}, fieldName string) (reflect.Value, string, error) {
+func getStructFieldValue(parentStruct interface{}, fieldName string) (*reflect.Value, string, error) {
 	v := reflect.ValueOf(parentStruct)
 
-	if v.Kind() == reflect.Ptr {
+/*	if v.Kind() == reflect.Ptr {
 		v = v.Elem()
 	}
-
+*/
 	if false {
 		for i := 0 ; i < v.NumField(); i++ {
 			f := v.Field(i)
@@ -34,7 +34,8 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (reflect.Va
 
 	if strings.Contains(fieldName, ".") {
 		fs := strings.Split(fieldName, ".")
-		f := v.FieldByName(fs[0])
+		//f := v.FieldByName(fs[0])
+		f := v.Elem().FieldByName(fs[0])
 		if f.Kind() == reflect.Struct {
 			return getStructFieldValue(f.Interface(), strings.Join(fs[1:], "."))
 		} else {
@@ -43,13 +44,13 @@ func getStructFieldValue(parentStruct interface{}, fieldName string) (reflect.Va
 	} else {
 		f := v.FieldByName(fieldName)
 		if f.IsValid() {
-			return f, fieldName, nil
+			return &f, fieldName, nil
 		} else {
-			return v, fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
+			return &v, fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
 		}
 	}
 
-	return v, fieldName, nil
+	return &v, fieldName, nil
 }
 
 
@@ -361,11 +362,11 @@ func ListJails(args []string, display bool) {
 	/   Sort jails
 	/     We support 3 sort criteria max
 	/***********************************************************************************/
-	if len(gSortFields) > 0 {
+	if len(gSortFields) > 0 && gSortFields != "none" {
 		js := initSortStruct()
 
 		// The way we manage criteria quantity is not very elegant...
-		var fct1, fct2, fct3 reflect.Value
+		var fct1, fct2, fct3 *reflect.Value
 		for i, c := range strings.Split(gSortFields, ",") {
 			var fctName string
 			if strings.HasPrefix(c, "-") {

cmd/root.go

@@ -3,14 +3,16 @@ package cmd
 import (
 	"os"
 	"fmt"
+	"strconv"
 	"strings"
+	"encoding/json"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
 const (
-	version = "0.02"
+	gVersion = "0.022a"
 )
 
 var (
@@ -24,6 +26,8 @@ var (
 	gSortFields		string
 	gNoLineSep		bool
 
+	gHostVersion	float64
+
 
 	rootCmd = & cobra.Command{
     	Use:    "gocage",
@@ -33,6 +37,7 @@ It support iocage jails and can coexist with iocage.`,
 
 	    Run: func(cmd *cobra.Command, args []string) {
 	        fmt.Println("Here we are in the Run")
+			cleanAfterRun()
 	    },
 	}
 
@@ -41,7 +46,8 @@ It support iocage jails and can coexist with iocage.`,
 	    Short: "Print the version number of GoCage",
 	    Long:  `Let this show you how much fail I had to get this *cough* perfect`,
 	    Run: func(cmd *cobra.Command, args []string) {
-	        fmt.Printf("GoCage v.%s\n", version)
+	        fmt.Printf("GoCage v.%s on FreeBSD %.1f\n", gVersion, gHostVersion)
+			cleanAfterRun()
 	    },
 	}
 
@@ -53,6 +59,7 @@ Jail list can be restricted by adding name on command line
 ex: gocage list srv-db srv-web`,
 		Run: func(cmd *cobra.Command, args []string) {
 			ListJails(args, true)
+			cleanAfterRun()
 		},
 	}
 	
@@ -64,6 +71,18 @@ ex: gocage list srv-db srv-web`,
 			// Get the inventory
 			ListJails(args, false)
 			StopJail(args)
+			cleanAfterRun()
+		},
+	}
+
+	startCmd = &cobra.Command{
+		Use:   "start",
+		Short: "start jail",
+		Run: func(cmd *cobra.Command, args []string) {
+			// Get the inventory
+			ListJails(args, false)
+			StartJail(args)
+			cleanAfterRun()
 		},
 	}
 )
@@ -87,6 +106,16 @@ func init() {
     rootCmd.AddCommand(versionCmd)
     rootCmd.AddCommand(listCmd)
     rootCmd.AddCommand(stopCmd)
+    rootCmd.AddCommand(startCmd)
+
+	// Get FreeBSD version
+	out, err := executeCommand("freebsd-version")
+	if err != nil {
+		fmt.Printf("Error running \"freebsd-version\": %s", err.Error())
+		os.Exit(1)
+	}
+	gHostVersion, _ = strconv.ParseFloat(strings.Split(out, "-")[0], 32)
+
 }
 
 func initConfig() {
@@ -130,6 +159,21 @@ func initConfig() {
 	}
 }
 
+// Called after execution
+func cleanAfterRun() {
+	for _, j := range gJails {
+		if j.ConfigUpdated {
+			// TODO : Marshall to disk
+			fmt.Printf("Config for jail %s will be updated\n", j.Name)
+			marshaled, err := json.MarshalIndent(j.Config, "", "    ")
+			if err != nil {
+				fmt.Printf("ERROR marshaling config: %s\n", err.Error())
+			}
+			fmt.Printf(string(marshaled))
+		}
+	}
+}
+
 func Execute() {
     if err := rootCmd.Execute(); err != nil {
         fmt.Fprintln(os.Stderr, err)

cmd/start.go

@@ -0,0 +1,421 @@
+package cmd
+
+import (
+	"os"
+	"fmt"
+//	"log"
+	"errors"
+	"regexp"
+//	"os/exec"
+//	"reflect"
+	"strings"
+//	"strconv"
+)
+
+// WIP. Not working now (need to address the real struct field, not a copy of it)
+// setJailProperty takes a string as propValue, whatever the real property type is.
+//  It will be converted.
+func setJailProperty(jail *Jail, propName string, propValue string) error {
+	// First get propName type, to convert propValue
+/*	k, _, err := getStructFieldKind(jail, propName)
+	if err != nil {
+		return err
+	}
+	kind := k.String()
+*/
+
+	for i, j := range gJails {
+		if j.Name == jail.Name {
+			val, _, err := getStructFieldValue(&gJails[i], propName)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Field not found: %s", propName))
+			}
+
+			/*if kind == "string" {
+			// WIll the affectation be done in source object or a copy?
+				val.Set(propValue)
+			} else if kind == "int" {
+				v, err := strconv.Atoi(propValue)
+				if err != nil {
+					return errors.New(fmt.Sprintf("propValue have wrong type: %s\n", err.Error()))
+				}
+				val.Set(v)
+			} else {
+				return errors.New(fmt.Sprintf("Property %s have an unsupported type in setJailProperty!\n", propName))
+			}*/
+
+			// panic: reflect: reflect.Value.Set using unaddressable value
+			//val.Set(reflect.ValueOf(propValue).Elem())
+			// ...Because val settability is false :-(
+			fmt.Printf("settability of val: %v\n", val.CanSet())
+
+			// This is OK, using the index to get the real jail object
+			//gJails[i].Config.Allow_mlock = 1
+			
+
+			// TODO : integrate this function
+			setJailConfigUpdated(jail)
+		}
+	}
+
+	return nil
+}
+
+//  We cant use internalName as the value exist only when jail is running
+func setJailConfigUpdated(jail *Jail) error {
+	if len(jail.ConfigPath) == 0 {
+		return errors.New(fmt.Sprintf("No config path for jail %s", jail.Name))
+	}
+
+	for i, j := range gJails {
+		if jail.ConfigPath == j.ConfigPath {
+			gJails[i].ConfigUpdated = true
+			return nil
+		}
+	}
+
+	return errors.New("Jail not found")
+}
+
+func mountProcFs(jail *Jail) error {
+	cmd = fmt.Sprintf("mount -t procfs proc %s/proc", jail.RootPath)
+	_, err := executeCommand(cmd)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Error mounting procfs on %s/proc: %s", jail.RootPath, err.Error()))
+	}
+	
+	return nil
+}
+
+func mountLinProcFs(jail *Jail) error {
+	ldir := fmt.Sprintf("%s/compat/linux/proc", jail.RootPath)
+	_, err := os.Stat(ldir)
+	if os.IsNotExist(err) {
+		errDir := os.MkdirAll(ldir, 0755)
+		if errDir != nil {
+			return errors.New(fmt.Sprintf("Error creating directory %s: %s", ldir, errDir.Error()))
+		}
+	}
+	cmd = fmt.Sprintf("mount -t linprocfs linproc %s", ldir)
+	_, err = executeCommand(cmd)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Error mounting linprocfs on %s: %s", ldir, err.Error()))
+	}
+	
+	return nil
+}
+
+func mountDevFs(jail *Jail) error {
+	cmd = fmt.Sprintf("mount -t devfs dev %s/dev", jail.RootPath)
+	_, err := executeCommand(cmd)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Error mounting devfs on %s/dev: %s", jail.RootPath, err.Error()))
+	}
+	
+	return nil
+}
+
+func mountFdescFs(jail *Jail) error {
+	// FreeBSD <= 9.3 do not support fdescfs
+	if gHostVersion <= 9.3 {
+		fmt.Printf("    FreeBSD <= 9.3 does not support fdescfs, disabling in config\n")
+		jail.Config.Mount_fdescfs = 0
+		// Tag config so it will be synced on disk
+		jail.ConfigUpdated = true
+	
+		// Should we consider this an error?
+		return nil
+	}
+	
+	cmd = fmt.Sprintf("mount -t fdescfs descfs %s/dev/fd", jail.RootPath)
+	_, err := executeCommand(cmd)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Error mounting fdescfs on %s/dev/fd: %s", jail.RootPath, err.Error()))
+	}
+	
+	return nil
+}
+
+func mountAllJailFsFromHost(jail *Jail) error {
+	procfsFound := false
+	linProcfsFound := false
+	devfsFound := false
+	fdescfsFound := false
+
+    cmd := "mount -p"
+    out, err := executeCommand(cmd)
+    if err != nil {
+        return errors.New(fmt.Sprintf("Error executing mount: %s", err.Error()))
+    }   
+
+	var outclean []string
+    remSpPtrn := regexp.MustCompile(`\s+`)
+    for _, l := range strings.Split(out, "\n") {
+		outclean = append(outclean, remSpPtrn.ReplaceAllString(l, " "))
+	}
+
+	// Check if these FS are already mounted
+	for _, l := range outclean {
+        f := strings.Split(l, " ")
+        if len(f) > 2 {
+
+			if strings.EqualFold(f[1], fmt.Sprintf("%s/proc", jail.RootPath)) {
+				procfsFound = true
+			}
+			if strings.EqualFold(f[1], fmt.Sprintf("%s/compat/linux/proc", jail.RootPath)) {
+				linProcfsFound = true
+			}
+			if strings.EqualFold(f[1], fmt.Sprintf("%s/dev", jail.RootPath)) {
+				devfsFound = true
+			}
+			if strings.EqualFold(f[1], fmt.Sprintf("%s/dev/fd", jail.RootPath)) {
+				fdescfsFound = true
+			}
+		}
+	}
+
+	// Mount wanted FS
+	if jail.Config.Mount_procfs > 0 && procfsFound == false {
+		err := mountProcFs(jail)
+        if err != nil {
+	        return err
+        }   
+	}
+	
+	if jail.Config.Mount_linprocfs > 0 && linProcfsFound == false {
+		err = mountLinProcFs(jail)
+        if err != nil {
+	        return err
+        }
+	}
+	
+	if jail.Config.Mount_devfs > 0 && devfsFound == false {
+		err := mountDevFs(jail)
+		if err != nil {
+	        return err
+		}
+	}
+	if jail.Config.Mount_fdescfs > 0 && fdescfsFound == false {
+		err := mountFdescFs(jail)
+		if err != nil {
+			return err
+		}
+	}
+
+	
+	// Ces montages doivent-ils etre effectués une fois le jail démarré?
+
+	// FreeBSD <= 9.3 do not support fdescfs
+	//if gHostVersion <= 9.3 && jail.Config.Allow_mount_tmpfs > 0 {
+	if gHostVersion <= 9.3 && jail.Config.Allow_mount_tmpfs > 0 {
+		fmt.Printf("    FreeBSD <= 9.3 does not support tmpfs, disabling in config\n")
+		jail.Config.Allow_mount_tmpfs = 0
+		// Tag config so it will be synced on disk
+		jail.ConfigUpdated = true
+		err = setJailConfigUpdated(jail)
+		if err != nil {
+			fmt.Printf(fmt.Sprintf("Error updating config for jail %s: %s", jail.Name, err.Error()))
+			return err
+		}
+	}
+
+	if gHostVersion < 12 {
+		if jail.Config.Allow_mlock > 0 {
+			jail.Config.Allow_mlock = 0		
+			jail.ConfigUpdated = true
+			/* WIP
+			err = setJailProperty(jail, "Config.Allow_mlock", "0")
+			if err != nil {
+				return err
+			}*/
+		}
+		if jail.Config.Allow_mount_fusefs > 0 {
+		}
+		if jail.Config.Allow_vmm > 0 {
+		}
+	}
+
+    return nil 
+}
+
+
+// TODO 
+func prepareJailedZfsDatasets(jail *Jail) error {
+	if jail.Config.Jail_zfs > 0 {
+		// For jail to mount filesystem, enforce_statfs should be 1 or lower (2 is the default)
+		// TODO : Write these changes in jail config file
+		jail.Config.Allow_mount = 1
+		jail.Config.Allow_mount_zfs = 1
+		// TODO : Overload Json Unmarshalling to fix bad typed values, keeping iocage compatibility
+		if jail.Config.Enforce_statfs > "1" {
+			jail.Config.Enforce_statfs = "1"
+		}
+		for _, d := range strings.Split(jail.Config.Jail_zfs_dataset, " ") {
+			// Check if dataset exist, create if necessary
+			cmd := fmt.Sprintf("zfs get -H creation %s/%s", jail.Zpool, d)
+			out, err := executeCommand(cmd)
+			if err != nil {
+				if strings.HasSuffix(out, "dataset does not exist") {
+					cmd = fmt.Sprintf("zfs create -o compression=lz4 -o mountpoint=none %s/%s", jail.Zpool, d)
+					_, err = executeCommand(cmd)
+					if err != nil {
+						return errors.New(fmt.Sprintf("Error creating dataset %s/%s: %s", jail.Zpool, d, err.Error()))
+					}
+				} else {
+					return errors.New(fmt.Sprintf("Error getting zfs dataset %s: %s", d, err.Error()))
+				}
+			}
+
+			cmd = fmt.Sprintf("zfs set jailed=on %s/%s", jail.Zpool, d)
+			out, err = executeCommand(cmd)
+			if err != nil {
+				return errors.New(fmt.Sprintf("Error executing \"zfs set jailed=on %s/%s\": %s", jail.Zpool, d, err.Error()))
+			}
+			// TODO : Execute "zfs jail $jailname $dataset" when jail will be up
+		}
+	}
+	return nil
+}
+
+
+
+/*
+	Start jail:
+		Check jail fstab?
+		Mount procfs
+		Mount linprocfs
+		Mount devfs?
+		Mount fdescfs?
+		If jail_zfs, then check jail_zfs_dataset exist (and create otherwise)
+		TODO : Check NAT settings and compatibility with other jails
+		Generate devfsruleset from configured
+		Write config file in /var/run/jails.ioc-$NAME.conf
+		Execute PreStart (Exec_prestart)
+		Start jail (With ENV VARS for network conf)
+		Start networking
+		Mount jail_zfs_datasets inside jail
+		Generate resolv.Conf
+		Copy /etc/localtime into jail (?)
+		Configure NAT
+		Execute Exec_start into jail
+		Execute Exec_poststart
+		If DHCP, check with ifconfig inside jail
+		Set RCTL Rules
+
+	Use setfib for each jail command
+*/
+func StartJail(args []string) {
+	// jail we have to start
+	var cj *Jail
+
+	for _, j := range args {
+		fmt.Printf("> Starting jail %s\n", j)
+
+		for i, rj := range gJails {
+			if rj.Name == j {
+				// Get jail reference, not a copy of it; So we can modify attributes
+				cj = &gJails[i]
+				break
+			}
+		}
+		if cj == nil {
+			fmt.Printf("Jail not found: %s\n", j)
+			continue
+		}
+
+		if cj.Running == true {
+			fmt.Printf("Jail %s is already running!\n", cj.Name)
+			continue
+		}
+
+		fmt.Printf("  > Mount special filesystems:\n")
+		err := mountAllJailFsFromHost(cj)
+		if err != nil {
+			fmt.Printf("ERROR: %s\n", err.Error())
+		} else {
+			fmt.Printf("  > Mount special filesystems: OK\n")
+		}
+
+		if cj.Config.Jail_zfs > 0 {
+			fmt.Printf("  > Prepare ZFS Datasets:\n")
+			err := prepareJailedZfsDatasets(cj)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Prepare ZFS Datasets: OK\n")
+			}
+		}
+
+
+/*
+		out, err := executeCommand(fmt.Sprintf("rctl jail:%s", cj.InternalName))
+		if err == nil && len(out) > 0 {
+			fmt.Printf("  > Remove RCTL rules:\n")
+			err := removeRctlRules(cj.InternalName, []string{""})
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Remove RCTL rules: OK\n")
+			}
+		}
+
+		if len (cj.Config.Exec_prestop) > 0 {
+			fmt.Printf("  > Execute prestop:\n")
+			_, err := executeCommand(cj.Config.Exec_prestop)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Execute prestop: OK\n")
+			}
+		}
+		
+		if len (cj.Config.Exec_stop) > 0 {
+			fmt.Printf("  > Execute stop:\n")
+			_, err := executeCommandInJail(cj, cj.Config.Exec_stop)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Execute stop: OK\n")
+			}
+		}
+
+		if cj.Config.Jail_zfs > 0 {
+			fmt.Printf("  > Umount jailed ZFS:\n")
+			err := umountAndUnjailZFS(cj)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Umount jailed ZFS: OK\n")
+			}
+		}
+
+		if cj.Config.Vnet > 0 && len(cj.Config.Ip4_addr) > 0 {
+			fmt.Printf("  > Destroy VNet interfaces:\n")
+			err := destroyVNetInterfaces(cj)
+			if err != nil {
+				fmt.Printf("ERROR: %s\n", err.Error())
+			} else {
+				fmt.Printf("  > Destroy VNet interfaces: OK\n")
+			}
+		}
+		
+		fmt.Printf("  > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
+		err = deleteDevfsRuleset(cj)
+		if err != nil {
+			fmt.Printf("ERROR: %s\n", err.Error())
+		} else {
+			fmt.Printf("  > Remove devfsruleset %s: OK\n", cj.Config.Devfs_ruleset)
+		}
+		
+		fmt.Printf("  > Stop jail %s:\n", cj.Name)
+		err = stopJail(cj)
+		if err != nil {
+			fmt.Printf("ERROR: %s\n", err.Error())
+		} else {
+			fmt.Printf("  > Stop jail %s: OK\n", cj.Name)
+		}
+*/
+
+	}
+}
+

cmd/stop.go

@@ -95,7 +95,12 @@ func destroyVNetInterfaces(jail *Jail) error {
 	return nil
 }
 
-
+// Jails copy the ruleset referenced as "devfs_ruleset" when starting, getting a new devsf_ruleset ID.
+// This new ID can be obtained with 'jls -j $JID devfs_ruleset'
+// This is the ID which needs to be removed. Original ID referenced is json should not be deleted
+//  or else it will require a restart of "devfs" service.
+// But, stoppign the jail already removes this >1000 ID.
+// So no need to call this function.
 func deleteDevfsRuleset(jail *Jail) error {
 	cmd := "devfs rule showsets"
 	out, err := executeCommand(cmd)
@@ -256,13 +261,13 @@ func StopJail(args []string) {
 			}
 		}
 		
-		fmt.Printf("  > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
+		/*fmt.Printf("  > Remove devfsruleset %s:\n", cj.Config.Devfs_ruleset)
 		err = deleteDevfsRuleset(cj)
 		if err != nil {
 			fmt.Printf("ERROR: %s\n", err.Error())
 		} else {
 			fmt.Printf("  > Remove devfsruleset %s: OK\n", cj.Config.Devfs_ruleset)
-		}
+		}*/
 		
 		fmt.Printf("  > Stop jail %s:\n", cj.Name)
 		err = stopJail(cj)
@@ -311,6 +316,28 @@ func StopJail(args []string) {
 				fmt.Printf("  > Umount devfs: OK\n")
 			}
 		}
+
+		// Remove local mounts from $JAIL/fstab
+		// The way we get fstab is presumptuous
+		fstab := strings.Replace(cj.ConfigPath, "config.json", "fstab", 1)
+		mounts, err := getFstab(fstab)
+		if err != nil {
+			fmt.Printf("ERROR: %s\n", err.Error())
+		}
+		if len(mounts) > 0 {
+			fmt.Printf("  > Umount mountpoints from %s\n", fstab)
+			errs := 0
+			for _, m := range mounts {
+				err = umountJailFsFromHost(cj, m.Mountpoint)
+				if err != nil {
+					fmt.Printf("ERROR: %s\n", err.Error())
+					errs += 1
+				}
+			}
+			if errs == 0 {
+				fmt.Printf("  > Umount mountpoints from %s: OK\n", fstab)
+			}
+		}
 	}
 }
 

cmd/struct.go

@@ -9,6 +9,7 @@ type Jail struct {
 	Config					JailConfig
 	RootPath				string
 	ConfigPath				string
+	ConfigUpdated			bool
 	Running					bool
 	// No need, Config.Release always represent what is running (plus it know release for non-running jails)
 	//Release					string
@@ -20,6 +21,7 @@ type Jail struct {
 //
 // Fields in this struct are acquired by their name using reflection
 //  So these char are forbidden for field name: -+.
+// Array should be forbidden, or else you'll need to rewrite setJailProperty()
 //
 // To allow sorting, just duplicate fields in JailConfigSort below
 type JailConfig struct {
@@ -162,6 +164,17 @@ type JailConfig struct {
 	Writeiops				string	`json:"writeiops"`
 }
 
+// Represent an fstab line
+type Mount struct {
+	Device		string
+	Mountpoint	string
+	Type		string
+	Options		[]string
+	Fs_Freq		int
+	Fs_Passno	int
+}
+
+
 // This struct hold "sort by jail fields" functions
 type lessFunc func(j1 *Jail, j2 *Jail) bool
 

cmd/utils.go

@@ -1,9 +1,15 @@
 package cmd
 
 import (
+	"os"
+	"fmt"
 	"sort"
+	"bufio"
+	"errors"
 	"os/exec"
+	"reflect"
 	"strings"
+	"strconv"
 )
 
 /*****************************************************************************
@@ -57,6 +63,102 @@ func executeCommandInJail(jail *Jail, cmdline string) (string, error) {
     return string(out), err
 }
 
+/*****************************************************************************
+* Parse an fstab file, returning an array of Mount
+*****************************************************************************/
+func getFstab(path string) ([]Mount, error) {
+	var mounts []Mount
+
+	f, err := os.Open(path)
+	if err != nil {
+		return mounts, err
+	}
+	defer f.Close()
+
+	scan := bufio.NewScanner(f)
+	for scan.Scan() {
+		res := strings.Fields(scan.Text())
+		if len(res) != 6 {
+			return mounts, fmt.Errorf("Incorrect format for fstab line %s", scan.Text())
+		}
+		freq, err := strconv.Atoi(res[4])
+		if err != nil {
+			return mounts, fmt.Errorf("Incorrect format for fstab line %s: Dump is not an integer\n", scan.Text())
+		}
+		pass, err := strconv.Atoi(res[5])
+		if err != nil {
+			return mounts, fmt.Errorf("Incorrect format for fstab line %s: Pass is not an integer\n", scan.Text())
+		}
+		m := Mount{
+			Device     : res[0],
+			Mountpoint : res[1],
+			Type       : res[2],
+			Options    : strings.Split(res[3], ","),
+			Fs_Freq    : freq,
+			Fs_Passno  : pass,
+		}
+		mounts = append(mounts, m)
+	}
+	
+	return mounts, nil
+}
+
+
+/*****************************************************************************
+* Get a specific jail source reference, to update properties after a range loop
+*****************************************************************************/
+func getJailFromArray(internalName string, jarray []Jail) (*Jail, error) {
+	for _, j := range jarray {
+		if internalName == j.InternalName {
+			return &j, nil
+		}
+	}
+	return &Jail{}, errors.New("Jail not found")
+}
+
+/*
+
+*/
+// Recurse into structure, returning reflect.Kind of named field.
+//  Nested fields are named with a dot (ex "MyStruct.MyField")
+func getStructFieldKind(parentStruct interface{}, fieldName string) (reflect.Kind, string, error) {
+    v := reflect.ValueOf(parentStruct)
+
+    if v.Kind() == reflect.Ptr {
+        v = v.Elem()
+    }   
+
+	// For debugging
+    if false {
+        for i := 0 ; i < v.NumField(); i++ {
+            f := v.Field(i)
+            if f.Kind() == reflect.String {
+                fmt.Printf("%v=%v\n", v.Type().Field(i).Name, f.Interface())
+            }   
+        }   
+    }   
+
+    if strings.Contains(fieldName, ".") {
+        fs := strings.Split(fieldName, ".")
+        f := v.FieldByName(fs[0])
+        if f.Kind() == reflect.Struct {
+            return getStructFieldKind(f.Interface(), strings.Join(fs[1:], "."))
+        } else {
+            return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("%s is not a struct: %s\n", fs[0], f.Kind().String()))
+        }   
+    } else {
+        f := v.FieldByName(fieldName)
+        if f.IsValid() {
+            return f.Kind(), fieldName, nil 
+        } else {
+            return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
+        }   
+    }   
+
+    return reflect.Kind(0), fieldName, errors.New(fmt.Sprintf("Field not found: %s", fieldName))
+}
+
+
 
 /*****************************************************************************
 *