github.com/keybase/client/go@v0.0.0-20241007131713-f10651d043c8/kbfs/libfuse/tlf.go (about) 1 // Copyright 2016 Keybase Inc. All rights reserved. 2 // Use of this source code is governed by a BSD 3 // license that can be found in the LICENSE file. 4 // 5 //go:build !windows 6 // +build !windows 7 8 package libfuse 9 10 import ( 11 "os" 12 "sync" 13 "time" 14 15 "bazil.org/fuse" 16 "bazil.org/fuse/fs" 17 "github.com/keybase/client/go/kbfs/data" 18 "github.com/keybase/client/go/kbfs/libfs" 19 "github.com/keybase/client/go/kbfs/libkbfs" 20 "github.com/keybase/client/go/kbfs/tlf" 21 "github.com/keybase/client/go/kbfs/tlfhandle" 22 "github.com/keybase/client/go/libkb" 23 "github.com/keybase/client/go/logger" 24 "golang.org/x/net/context" 25 ) 26 27 // TLF represents the root directory of a TLF. It wraps a lazy-loaded 28 // Dir. 29 type TLF struct { 30 folder *Folder 31 inode uint64 32 33 dirLock sync.RWMutex 34 dir *Dir 35 36 // We never set quarantine on TLF roots, so don't bother with getting a dir 37 // and calling the method on it. Instead, just use this dumb handler to 38 // always return fuse.ENOTSUP. 39 NoXattrHandler 40 } 41 42 func newTLF(ctx context.Context, fl *FolderList, h *tlfhandle.Handle, 43 name tlf.PreferredName) *TLF { 44 folder := newFolder(ctx, fl, h, name) 45 tlf := &TLF{ 46 folder: folder, 47 inode: fl.fs.assignInode(), 48 } 49 return tlf 50 } 51 52 var _ DirInterface = (*TLF)(nil) 53 54 func (tlf *TLF) getStoredDir() *Dir { 55 tlf.dirLock.RLock() 56 defer tlf.dirLock.RUnlock() 57 return tlf.dir 58 } 59 60 func (tlf *TLF) clearStoredDir() { 61 tlf.dirLock.Lock() 62 defer tlf.dirLock.Unlock() 63 tlf.dir = nil 64 } 65 66 func (tlf *TLF) log() logger.Logger { 67 return tlf.folder.fs.log 68 } 69 70 func (tlf *TLF) vlog() *libkb.VDebugLog { 71 return tlf.folder.fs.vlog 72 } 73 74 func (tlf *TLF) loadDirHelper( 75 ctx context.Context, mode libkbfs.ErrorModeType, branch data.BranchName, 76 filterErr bool) (dir *Dir, exitEarly bool, err error) { 77 dir = tlf.getStoredDir() 78 if dir != nil { 79 return dir, false, nil 80 } 81 82 tlf.dirLock.Lock() 83 defer tlf.dirLock.Unlock() 84 // Need to check for nilness again to avoid racing with other 85 // calls to loadDir(). 86 if tlf.dir != nil { 87 return tlf.dir, false, nil 88 } 89 90 tlf.log().CDebugf(ctx, "Loading root directory for folder %s "+ 91 "(type: %s, filter error: %t)", tlf.folder.name(), 92 tlf.folder.list.tlfType, filterErr) 93 defer func() { 94 if filterErr { 95 exitEarly, err = libfs.FilterTLFEarlyExitError(ctx, err, tlf.log(), tlf.folder.name()) 96 } 97 err = tlf.folder.processError(ctx, mode, err) 98 }() 99 100 handle, err := tlf.folder.resolve(ctx) 101 if err != nil { 102 return nil, false, err 103 } 104 105 if branch == data.MasterBranch { 106 conflictBranch, isLocalConflictBranch := 107 data.MakeConflictBranchName(handle) 108 if isLocalConflictBranch { 109 branch = conflictBranch 110 } 111 } 112 113 var rootNode libkbfs.Node 114 if filterErr { 115 rootNode, _, err = tlf.folder.fs.config.KBFSOps().GetRootNode( 116 ctx, handle, branch) 117 if err != nil { 118 return nil, false, err 119 } 120 // If not fake an empty directory. 121 if rootNode == nil { 122 return nil, false, libfs.TlfDoesNotExist{} 123 } 124 } else { 125 rootNode, _, err = tlf.folder.fs.config.KBFSOps().GetOrCreateRootNode( 126 ctx, handle, branch) 127 if err != nil { 128 return nil, false, err 129 } 130 } 131 132 err = tlf.folder.setFolderBranch(rootNode.GetFolderBranch()) 133 if err != nil { 134 return nil, false, err 135 } 136 137 tlf.folder.nodes[rootNode.GetID()] = tlf 138 tlf.dir = newDirWithInode(tlf.folder, rootNode, tlf.inode) 139 140 return tlf.dir, false, nil 141 } 142 143 func (tlf *TLF) loadDir(ctx context.Context) (*Dir, error) { 144 dir, _, err := tlf.loadDirHelper( 145 ctx, libkbfs.WriteMode, data.MasterBranch, false) 146 return dir, err 147 } 148 149 // loadDirAllowNonexistent loads a TLF if it's not already loaded. If 150 // the TLF doesn't yet exist, it still returns a nil error and 151 // indicates that the calling function should pretend it's an empty 152 // folder. 153 func (tlf *TLF) loadDirAllowNonexistent(ctx context.Context) ( 154 *Dir, bool, error) { 155 return tlf.loadDirHelper(ctx, libkbfs.ReadMode, data.MasterBranch, true) 156 } 157 158 func (tlf *TLF) loadArchivedDir( 159 ctx context.Context, branch data.BranchName) (*Dir, bool, error) { 160 // Always filter errors for archive TLF directories, so that we 161 // don't try to initialize them. 162 return tlf.loadDirHelper(ctx, libkbfs.ReadMode, branch, true) 163 } 164 165 // Access implements the fs.NodeAccesser interface for *TLF. 166 func (tlf *TLF) Access(ctx context.Context, r *fuse.AccessRequest) error { 167 return tlf.folder.access(ctx, r) 168 } 169 170 // Attr implements the fs.Node interface for TLF. 171 func (tlf *TLF) Attr(ctx context.Context, a *fuse.Attr) error { 172 dir := tlf.getStoredDir() 173 a.Inode = tlf.inode 174 if dir == nil { 175 tlf.vlog().CLogf( 176 ctx, libkb.VLog1, "Faking Attr for TLF %s", tlf.folder.name()) 177 // Have a low non-zero value for Valid to avoid being 178 // swamped with requests, while still not showing 179 // stale data for too long if we end up loading the 180 // dir. 181 a.Valid = 1 * time.Second 182 a.Mode = os.ModeDir | 0500 183 a.Uid = uint32(os.Getuid()) 184 return nil 185 } 186 187 return dir.Attr(ctx, a) 188 } 189 190 // tlfLoadAvoidingLookupNames specifies a set of directory entry names 191 // that should NOT cause a TLF to be fully loaded and identified on a 192 // lookup. If the directory is not yet loaded and one of these names 193 // are looked-up, then ENOENT will be returned automatically. This is 194 // to avoid unnecessary loading and tracker popups when listing the 195 // folder list directories. For example, when macOS finder opens 196 // `/keybase/private`, it looks up `.localized` in every TLF 197 // subdirectory to see if it should translate the TLF folder name or 198 // not, which can cause a tracker popup storm (see KBFS-2649). 199 var tlfLoadAvoidingLookupNames = map[string]bool{ 200 ".localized": true, 201 "Contents": true, 202 } 203 204 // Lookup implements the fs.NodeRequestLookuper interface for TLF. 205 func (tlf *TLF) Lookup(ctx context.Context, req *fuse.LookupRequest, resp *fuse.LookupResponse) (fs.Node, error) { 206 if tlfLoadAvoidingLookupNames[req.Name] { 207 dir := tlf.getStoredDir() 208 if dir == nil { 209 tlf.vlog().CLogf( 210 ctx, libkb.VLog1, "Avoiding TLF loading for name %s", req.Name) 211 return nil, fuse.ENOENT 212 } 213 return dir.Lookup(ctx, req, resp) 214 } 215 216 dir, exitEarly, err := tlf.loadDirAllowNonexistent(ctx) 217 if err != nil { 218 return nil, err 219 } 220 if exitEarly { 221 if node := handleTLFSpecialFile( 222 req.Name, tlf.folder, &resp.EntryValid); node != nil { 223 return node, nil 224 } 225 return nil, fuse.ENOENT 226 } 227 228 branch, isArchivedBranch := libfs.BranchNameFromArchiveRefDir(req.Name) 229 if isArchivedBranch { 230 archivedTLF := newTLF(ctx, 231 tlf.folder.list, tlf.folder.h, tlf.folder.hPreferredName) 232 _, _, err := archivedTLF.loadArchivedDir(ctx, branch) 233 if err != nil { 234 return nil, err 235 } 236 return archivedTLF, nil 237 } 238 239 linkTarget, isArchivedTimeLink, err := libfs.LinkTargetFromTimeString( 240 ctx, tlf.folder.fs.config, tlf.folder.h, req.Name) 241 if err != nil { 242 return nil, err 243 } 244 if isArchivedTimeLink { 245 return &Alias{ 246 realPath: linkTarget, 247 inode: 0, 248 }, nil 249 } 250 251 _, isRelTimeLink, err := libfs.FileDataFromRelativeTimeString( 252 ctx, tlf.folder.fs.config, tlf.folder.h, req.Name) 253 if err != nil { 254 return nil, err 255 } 256 if isRelTimeLink { 257 return NewArchiveRelTimeFile( 258 tlf.folder.fs, tlf.folder.h, req.Name, &resp.EntryValid), nil 259 } 260 261 return dir.Lookup(ctx, req, resp) 262 } 263 264 // Create implements the fs.NodeCreater interface for TLF. 265 func (tlf *TLF) Create(ctx context.Context, req *fuse.CreateRequest, resp *fuse.CreateResponse) (fs.Node, fs.Handle, error) { 266 dir, err := tlf.loadDir(ctx) 267 if err != nil { 268 return nil, nil, err 269 } 270 return dir.Create(ctx, req, resp) 271 } 272 273 // Mkdir implements the fs.NodeMkdirer interface for TLF. 274 func (tlf *TLF) Mkdir(ctx context.Context, req *fuse.MkdirRequest) (_ fs.Node, err error) { 275 dir, err := tlf.loadDir(ctx) 276 if err != nil { 277 return nil, err 278 } 279 return dir.Mkdir(ctx, req) 280 } 281 282 // Symlink implements the fs.NodeSymlinker interface for TLF. 283 func (tlf *TLF) Symlink(ctx context.Context, req *fuse.SymlinkRequest) ( 284 fs.Node, error) { 285 dir, err := tlf.loadDir(ctx) 286 if err != nil { 287 return nil, err 288 } 289 return dir.Symlink(ctx, req) 290 } 291 292 var _ fs.NodeLinker = (*TLF)(nil) 293 294 // Link implements the fs.NodeLinker interface for TLF. 295 func (tlf *TLF) Link( 296 _ context.Context, _ *fuse.LinkRequest, _ fs.Node) (fs.Node, error) { 297 return nil, fuse.ENOTSUP 298 } 299 300 // Rename implements the fs.NodeRenamer interface for TLF. 301 func (tlf *TLF) Rename(ctx context.Context, req *fuse.RenameRequest, 302 newDir fs.Node) error { 303 dir, err := tlf.loadDir(ctx) 304 if err != nil { 305 return err 306 } 307 return dir.Rename(ctx, req, newDir) 308 } 309 310 // Remove implements the fs.NodeRemover interface for TLF. 311 func (tlf *TLF) Remove(ctx context.Context, req *fuse.RemoveRequest) error { 312 dir, err := tlf.loadDir(ctx) 313 if err != nil { 314 return err 315 } 316 return dir.Remove(ctx, req) 317 } 318 319 // ReadDirAll implements the fs.NodeReadDirAller interface for TLF. 320 func (tlf *TLF) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) { 321 dir, exitEarly, err := tlf.loadDirAllowNonexistent(ctx) 322 if err != nil || exitEarly { 323 return nil, err 324 } 325 return dir.ReadDirAll(ctx) 326 } 327 328 // Forget kernel reference to this node. 329 func (tlf *TLF) Forget() { 330 dir := tlf.getStoredDir() 331 if dir != nil { 332 dir.Forget() 333 } else { 334 tlf.folder.list.forgetFolder(string(tlf.folder.name())) 335 } 336 } 337 338 // Setattr implements the fs.NodeSetattrer interface for TLF. 339 func (tlf *TLF) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error { 340 dir, err := tlf.loadDir(ctx) 341 if err != nil { 342 return err 343 } 344 return dir.Setattr(ctx, req, resp) 345 } 346 347 // Fsync implements the fs.NodeFsyncer interface for TLF. 348 func (tlf *TLF) Fsync(ctx context.Context, req *fuse.FsyncRequest) (err error) { 349 dir := tlf.getStoredDir() 350 if dir == nil { 351 // The directory hasn't been loaded yet, so there's nothing to do. 352 return nil 353 } 354 355 return dir.Fsync(ctx, req) 356 } 357 358 var _ fs.Handle = (*TLF)(nil) 359 360 var _ fs.NodeOpener = (*TLF)(nil) 361 362 // Open implements the fs.NodeOpener interface for TLF. 363 func (tlf *TLF) Open(ctx context.Context, req *fuse.OpenRequest, 364 resp *fuse.OpenResponse) (fs.Handle, error) { 365 // Explicitly load the directory when a TLF is opened, because 366 // some OSX programs like ls have a bug that doesn't report errors 367 // on a ReadDirAll. 368 _, _, err := tlf.loadDirAllowNonexistent(ctx) 369 if err != nil { 370 return nil, err 371 } 372 return tlf, nil 373 } 374 375 func (tlf *TLF) openFileCount() int64 { 376 return tlf.folder.openFileCount() 377 }