314 lines
6.7 KiB
Go
314 lines
6.7 KiB
Go
// Copyright 2015 CoreOS, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package system
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"unicode"
|
|
|
|
"github.com/vtolstov/go-ioctl"
|
|
)
|
|
|
|
func rootMount() (string, error) {
|
|
var err error
|
|
var device string
|
|
|
|
f, err := os.Open("/proc/self/mounts")
|
|
if err != nil {
|
|
return device, err
|
|
}
|
|
defer f.Close()
|
|
br := bufio.NewReader(f)
|
|
|
|
for {
|
|
line, err := br.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
fields := strings.Fields(line)
|
|
if fields[1] != "/" || fields[0][0] != '/' {
|
|
continue
|
|
}
|
|
fi, err := os.Stat(fields[0])
|
|
if err != nil {
|
|
return device, err
|
|
}
|
|
|
|
if fi.Mode()&os.ModeSymlink == 0 {
|
|
device, err = filepath.EvalSymlinks(fields[0])
|
|
if err != nil {
|
|
return device, err
|
|
}
|
|
} else {
|
|
device = fields[0]
|
|
}
|
|
}
|
|
return device, nil
|
|
}
|
|
|
|
func rootDevice() (string, error) {
|
|
var device string
|
|
|
|
mountpoint, err := rootMount()
|
|
if err != nil {
|
|
return device, err
|
|
}
|
|
|
|
numstrip := func(r rune) rune {
|
|
if unicode.IsNumber(r) {
|
|
return -1
|
|
}
|
|
return r
|
|
}
|
|
return strings.Map(numstrip, mountpoint), nil
|
|
}
|
|
|
|
func ResizeRootFS() error {
|
|
var err error
|
|
var stdout io.ReadCloser
|
|
var stdin bytes.Buffer
|
|
|
|
partstart := 0
|
|
partnum := 0
|
|
device := "/tmp/resize_dev"
|
|
partition := "/tmp/resize_part"
|
|
active := false
|
|
extended := false
|
|
parttype := "Linux"
|
|
devFs, err := findFs()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
devBlk, err := findBlock("/sys/block", devFs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
os.Remove(device)
|
|
if err = syscall.Mknod(device, uint32(os.ModeDevice|syscall.S_IFBLK|0600), devBlk.Int()); err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(device)
|
|
// mbr := make([]byte, 446)
|
|
|
|
/*
|
|
f, err := os.OpenFile(device, os.O_RDONLY, os.FileMode(0400))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.ReadFull(f, mbr)
|
|
f.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*/
|
|
cmd := exec.Command("fdisk", "-l", "-u", device)
|
|
stdout, err = cmd.StdoutPipe()
|
|
if err != nil {
|
|
log.Printf("failed to open %s via fdisk %s 2\n", device, err.Error())
|
|
return err
|
|
}
|
|
r := bufio.NewReader(stdout)
|
|
|
|
if err = cmd.Start(); err != nil {
|
|
log.Printf("failed to open %s via fdisk %s 3\n", device, err.Error())
|
|
return err
|
|
}
|
|
|
|
for {
|
|
line, err := r.ReadString('\n')
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
if strings.HasPrefix(line, device) {
|
|
partnum += 1
|
|
///test3 * 16384 204799 188416 92M 5 Extended
|
|
ps := strings.Fields(line)
|
|
if ps[1] == "*" {
|
|
active = true
|
|
partstart, _ = strconv.Atoi(ps[2])
|
|
if len(ps) > 7 {
|
|
parttype = ps[6]
|
|
if ps[7] == "Extended" {
|
|
extended = true
|
|
}
|
|
} else {
|
|
parttype = ps[5]
|
|
if ps[6] == "Extended" {
|
|
extended = true
|
|
}
|
|
}
|
|
} else {
|
|
active = false
|
|
partstart, _ = strconv.Atoi(ps[1])
|
|
if len(ps) > 6 {
|
|
parttype = ps[5]
|
|
if ps[6] == "Extended" {
|
|
extended = true
|
|
}
|
|
} else {
|
|
parttype = ps[4]
|
|
if ps[5] == "Extended" {
|
|
extended = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if err = cmd.Wait(); err != nil || partstart == 0 {
|
|
return fmt.Errorf("failed to open %s via fdisk 4\n", device)
|
|
}
|
|
if partnum > 1 {
|
|
stdin.Write([]byte("d\n" + fmt.Sprintf("%d", partnum) + "\n"))
|
|
} else {
|
|
stdin.Write([]byte("d\n"))
|
|
}
|
|
if extended {
|
|
stdin.Write([]byte("n\nl\n" + fmt.Sprintf("%d", partnum) + "\n" + fmt.Sprintf("%d", partstart) + "\n\n"))
|
|
} else {
|
|
stdin.Write([]byte("n\np\n" + fmt.Sprintf("%d", partnum) + "\n" + fmt.Sprintf("%d", partstart) + "\n\n"))
|
|
}
|
|
if active {
|
|
stdin.Write([]byte("a\n" + fmt.Sprintf("%d", partnum) + "\n"))
|
|
}
|
|
if partnum > 1 {
|
|
stdin.Write([]byte("t\n" + fmt.Sprintf("%d", partnum) + "\n" + parttype + "\nw"))
|
|
} else {
|
|
stdin.Write([]byte("t\n" + parttype + "\nw"))
|
|
}
|
|
cmd = exec.Command("fdisk", "-u", device)
|
|
cmd.Stdin = &stdin
|
|
cmd.Run()
|
|
stdin.Reset()
|
|
|
|
w, err := os.OpenFile(device, os.O_WRONLY, 0600)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
/*
|
|
_, err = w.Write(mbr)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = w.Sync()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*/
|
|
blkerr := ioctl.BlkRRPart(w.Fd())
|
|
err = w.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if blkerr != nil {
|
|
args := []string{}
|
|
for _, name := range []string{"partx", "partprobe", "kpartx"} {
|
|
if _, err = exec.LookPath(name); err == nil {
|
|
switch name {
|
|
case "partx":
|
|
args = []string{"-u", device}
|
|
default:
|
|
args = []string{device}
|
|
}
|
|
log.Printf("update partition table via %s %s", name, strings.Join(args, " "))
|
|
if err = exec.Command(name, args...).Run(); err == nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
os.Remove(partition)
|
|
if err = syscall.Mknod(partition, uint32(os.ModeDevice|syscall.S_IFBLK|0600), devFs.Int()); err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(partition)
|
|
log.Printf("resize filesystem via %s %s", "resize2fs", partition)
|
|
buf, err := exec.Command("resize2fs", partition).CombinedOutput()
|
|
if err != nil {
|
|
log.Printf("resize2fs %s", buf)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Dev struct {
|
|
Major uint64
|
|
Minor uint64
|
|
}
|
|
|
|
func (d *Dev) String() string {
|
|
return fmt.Sprintf("%d:%d", d.Major, d.Minor)
|
|
}
|
|
|
|
func (d *Dev) Int() int {
|
|
return int(d.Major*256 + d.Minor)
|
|
}
|
|
|
|
func findFs() (*Dev, error) {
|
|
var st syscall.Stat_t
|
|
|
|
err := syscall.Stat("/", &st)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Dev{Major: uint64(st.Dev / 256), Minor: uint64(st.Dev % 256)}, nil
|
|
}
|
|
|
|
func findBlock(start string, s *Dev) (*Dev, error) {
|
|
var err error
|
|
fis, err := ioutil.ReadDir(start)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, fi := range fis {
|
|
switch fi.Name() {
|
|
case "bdi", "subsystem", "device", "trace":
|
|
continue
|
|
}
|
|
if _, err := os.Stat(filepath.Join(start, "dev")); err == nil {
|
|
if buf, err := ioutil.ReadFile(filepath.Join(start, "dev")); err == nil {
|
|
dev := strings.TrimSpace(string(buf))
|
|
if s.String() == dev {
|
|
if buf, err = ioutil.ReadFile(filepath.Join(filepath.Dir(start), "dev")); err == nil {
|
|
majorminor := strings.Split(strings.TrimSpace(string(buf)), ":")
|
|
major, _ := strconv.Atoi(majorminor[0])
|
|
minor, _ := strconv.Atoi(majorminor[1])
|
|
return &Dev{Major: uint64(major), Minor: uint64(minor)}, nil
|
|
}
|
|
}
|
|
}
|
|
}
|
|
devBlk, err := findBlock(filepath.Join(start, fi.Name()), s)
|
|
if err == nil {
|
|
return devBlk, err
|
|
}
|
|
}
|
|
return nil, errors.New("failed to find dev")
|
|
}
|