ood.go

   1 /*
   2 goredo -- djb's redo implementation on pure Go
   3 Copyright (C) 2020-2024 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 // Out-of-date determination
  19
  20 package main
  21
  22 import (
  23         "bytes"
  24         "errors"
  25         "fmt"
  26         "io"
  27         "io/fs"
  28         "log"
  29         "os"
  30         "strings"
  31
  32         "golang.org/x/sys/unix"
  33 )
  34
  35 const (
  36         EnvOODTgtsFd     = "REDO_OOD_TGTS_FD"
  37         EnvOODTgtsLockFd = "REDO_OOD_TGTS_LOCK_FD"
  38 )
  39
  40 var (
  41         OODTgts       map[string]struct{}
  42         FdOODTgts     *os.File
  43         FdOODTgtsLock *os.File
  44
  45         OODCache        = make(map[string]bool)
  46         FileExistsCache = make(map[string]bool)
  47 )
  48
  49 func FileExists(p string) bool {
  50         if exists, known := FileExistsCache[p]; known {
  51                 return exists
  52         }
  53         _, err := os.Stat(p)
  54         if err == nil {
  55                 FileExistsCache[p] = true
  56                 return true
  57         }
  58         if errors.Is(err, fs.ErrNotExist) {
  59                 FileExistsCache[p] = false
  60         }
  61         return false
  62 }
  63
  64 type TgtError struct {
  65         Tgt *Tgt
  66         Err error
  67 }
  68
  69 func (e TgtError) Unwrap() error { return e.Err }
  70
  71 func (e TgtError) Error() string {
  72         return fmt.Sprintf("%s: %s", e.Tgt, e.Err)
  73 }
  74
  75 func isSrc(tgt *Tgt) bool {
  76         if !FileExists(tgt.a) {
  77                 return false
  78         }
  79         if FileExists(tgt.a + ".do") {
  80                 return false
  81         }
  82         if FileExists(tgt.dep) {
  83                 return false
  84         }
  85         return true
  86 }
  87
  88 func isOODByBuildUUID(tgt *Tgt) bool {
  89         build, err := depBuildRead(tgt.dep)
  90         return err != nil || build != BuildUUID
  91 }
  92
  93 func isOOD(tgt *Tgt, level int, seen map[string]*Tgt) (bool, error) {
  94         indent := strings.Repeat(". ", level)
  95         tracef(CDebug, "ood: %s%s checking", indent, tgt)
  96         ood, cached := OODCache[tgt.rel]
  97         if cached {
  98                 tracef(CDebug, "ood: %s%s -> cached: %v", indent, tgt, ood)
  99                 return ood, nil
 100         }
 101         dep := DepCache[tgt.rel]
 102         var err error
 103         if dep == nil {
 104                 dep, err = depRead(tgt)
 105                 if err != nil {
 106                         if errors.Is(err, fs.ErrNotExist) {
 107                                 if isSrc(tgt) {
 108                                         ood = false
 109                                         tracef(CDebug, "ood: %s%s -> is source", indent, tgt)
 110                                 } else {
 111                                         ood = true
 112                                         tracef(CDebug, "ood: %s%s -> no dep: %s", indent, tgt, tgt.dep)
 113                                 }
 114                                 OODCache[tgt.rel] = ood
 115                                 return ood, nil
 116                         }
 117                         if err != nil {
 118                                 return true, TgtError{tgt, ErrLine(err)}
 119                         }
 120                 }
 121                 DepCache[tgt.rel] = dep
 122         }
 123
 124         if dep.build == BuildUUID {
 125                 tracef(CDebug, "ood: %s%s -> already built", indent, tgt)
 126                 OODCache[tgt.rel] = false
 127                 return false, nil
 128         }
 129         if !FileExists(tgt.a) {
 130                 tracef(CDebug, "ood: %s%s -> non-existent", indent, tgt)
 131                 OODCache[tgt.rel] = true
 132                 return true, nil
 133         }
 134
 135         for _, ifcreate := range dep.ifcreates {
 136                 if FileExists(ifcreate.a) {
 137                         tracef(CDebug, "ood: %s%s -> %s created", indent, tgt, ifcreate)
 138                         ood = true
 139                         goto Done
 140                 }
 141         }
 142
 143         for _, ifchange := range dep.ifchanges {
 144                 tracef(CDebug, "ood: %s%s -> %s: checking", indent, tgt, ifchange.tgt)
 145                 ood, cached = OODCache[ifchange.tgt.rel]
 146                 if cached {
 147                         tracef(CDebug, "ood: %s%s -> %s: cached: %v", indent, tgt, ifchange.tgt, ood)
 148                         if ood {
 149                                 goto Done
 150                         }
 151                         continue
 152                 }
 153
 154                 inode, err := inodeFromFileByPath(ifchange.tgt.a)
 155                 if err != nil {
 156                         if errors.Is(err, fs.ErrNotExist) {
 157                                 tracef(CDebug, "ood: %s%s -> %s: not exists", indent, tgt, ifchange.tgt)
 158                                 ood = true
 159                                 OODCache[ifchange.tgt.rel] = ood
 160                                 goto Done
 161                         }
 162                         return ood, TgtError{tgt, ErrLine(err)}
 163                 }
 164
 165                 if !bytes.Equal(inode[:8], ifchange.Inode()[:8]) {
 166                         tracef(CDebug, "ood: %s%s -> %s: size differs", indent, tgt, ifchange.tgt)
 167                         ood = true
 168                         OODCache[ifchange.tgt.rel] = ood
 169                         goto Done
 170                 }
 171                 if InodeTrust != InodeTrustNone && inode.Equals(ifchange.Inode()) {
 172                         tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgt, ifchange.tgt)
 173                 } else {
 174                         tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgt, ifchange.tgt)
 175                         fd, err := os.Open(ifchange.tgt.a)
 176                         if err != nil {
 177                                 return ood, TgtError{tgt, ErrLine(err)}
 178                         }
 179                         hsh, err := fileHash(fd)
 180                         fd.Close()
 181                         if err != nil {
 182                                 return ood, TgtError{tgt, ErrLine(err)}
 183                         }
 184                         if ifchange.Hash() != hsh {
 185                                 tracef(CDebug, "ood: %s%s -> %s: hash differs", indent, tgt, ifchange.tgt)
 186                                 ood = true
 187                                 OODCache[ifchange.tgt.rel] = ood
 188                                 goto Done
 189                         }
 190                         tracef(CDebug, "ood: %s%s -> %s: same hash", indent, tgt, ifchange.tgt)
 191                 }
 192
 193                 if ifchange.tgt.rel == tgt.rel {
 194                         tracef(CDebug, "ood: %s%s -> %s: same target", indent, tgt, ifchange.tgt)
 195                         continue
 196                 }
 197                 if isSrc(ifchange.tgt) {
 198                         tracef(CDebug, "ood: %s%s -> %s: is source", indent, tgt, ifchange.tgt)
 199                         OODCache[ifchange.tgt.rel] = false
 200                         continue
 201                 }
 202
 203                 if _, ok := seen[ifchange.tgt.rel]; ok {
 204                         tracef(CDebug, "ood: %s%s -> %s: was always built", indent, tgt, ifchange.tgt)
 205                         OODCache[ifchange.tgt.rel] = false
 206                         continue
 207                 }
 208
 209                 depOOD, err := isOODWithTrace(ifchange.tgt, level+1, seen)
 210                 if err != nil {
 211                         return ood, TgtError{tgt, err}
 212                 }
 213                 if depOOD {
 214                         tracef(CDebug, "ood: %s%s -> %s: ood", indent, tgt, ifchange.tgt)
 215                         ood = true
 216                         goto Done
 217                 }
 218                 tracef(CDebug, "ood: %s%s -> %s: !ood", indent, tgt, ifchange.tgt)
 219         }
 220
 221 Done:
 222         tracef(CDebug, "ood: %s%s: %v", indent, tgt, ood)
 223         OODCache[tgt.rel] = ood
 224         return ood, nil
 225 }
 226
 227 func isOODWithTrace(tgt *Tgt, level int, seen map[string]*Tgt) (bool, error) {
 228         _, ood := OODTgts[tgt.a]
 229         var err error
 230         if ood {
 231                 if !isOODByBuildUUID(tgt) {
 232                         tracef(CDebug, "ood: %s%s -> already built", strings.Repeat(". ", level), tgt)
 233                         return false, nil
 234                 }
 235                 tracef(CDebug, "ood: %s%s true, external decision", strings.Repeat(". ", level), tgt)
 236                 goto RecordOODTgt
 237         }
 238         ood, err = isOOD(tgt, level, seen)
 239         if !ood {
 240                 return ood, err
 241         }
 242 RecordOODTgt:
 243         flock := unix.Flock_t{
 244                 Type:   unix.F_WRLCK,
 245                 Whence: io.SeekStart,
 246         }
 247         if err = unix.FcntlFlock(FdOODTgtsLock.Fd(), unix.F_SETLKW, &flock); err != nil {
 248                 log.Fatal(err)
 249         }
 250         if _, err = FdOODTgts.Seek(0, io.SeekEnd); err != nil {
 251                 log.Fatal(err)
 252         }
 253         if _, err := FdOODTgts.WriteString(tgt.a + "\x00"); err != nil {
 254                 log.Fatal(err)
 255         }
 256         flock.Type = unix.F_UNLCK
 257         if err = unix.FcntlFlock(FdOODTgtsLock.Fd(), unix.F_SETLK, &flock); err != nil {
 258                 log.Fatal(err)
 259         }
 260         return true, nil
 261 }
 262
 263 func oodTgtsClear() {
 264         var err error
 265         flock := unix.Flock_t{
 266                 Type:   unix.F_WRLCK,
 267                 Whence: io.SeekStart,
 268         }
 269         if err = unix.FcntlFlock(FdOODTgtsLock.Fd(), unix.F_SETLKW, &flock); err != nil {
 270                 log.Fatal(err)
 271         }
 272         if err = FdOODTgts.Truncate(0); err != nil {
 273                 log.Fatal(err)
 274         }
 275         flock.Type = unix.F_UNLCK
 276         if err = unix.FcntlFlock(FdOODTgtsLock.Fd(), unix.F_SETLK, &flock); err != nil {
 277                 log.Fatal(err)
 278         }
 279 }