github.com/hanwen/go-fuse@v1.0.0/fuse/lockingfs.go (about) 1 // Copyright 2016 the Go-FUSE Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package fuse 6 7 import ( 8 "fmt" 9 "sync" 10 ) 11 12 //////////////////////////////////////////////////////////////// 13 // Locking raw FS. 14 15 type lockingRawFileSystem struct { 16 RawFS RawFileSystem 17 lock sync.Mutex 18 } 19 20 // Returns a Wrap 21 func NewLockingRawFileSystem(fs RawFileSystem) RawFileSystem { 22 return &lockingRawFileSystem{ 23 RawFS: fs, 24 } 25 } 26 27 func (fs *lockingRawFileSystem) FS() RawFileSystem { 28 return fs.RawFS 29 } 30 31 func (fs *lockingRawFileSystem) locked() func() { 32 fs.lock.Lock() 33 return func() { fs.lock.Unlock() } 34 } 35 36 func (fs *lockingRawFileSystem) Lookup(header *InHeader, name string, out *EntryOut) (code Status) { 37 defer fs.locked()() 38 return fs.RawFS.Lookup(header, name, out) 39 } 40 41 func (fs *lockingRawFileSystem) SetDebug(dbg bool) { 42 defer fs.locked()() 43 fs.RawFS.SetDebug(dbg) 44 } 45 46 func (fs *lockingRawFileSystem) Forget(nodeID uint64, nlookup uint64) { 47 defer fs.locked()() 48 fs.RawFS.Forget(nodeID, nlookup) 49 } 50 51 func (fs *lockingRawFileSystem) GetAttr(input *GetAttrIn, out *AttrOut) (code Status) { 52 defer fs.locked()() 53 return fs.RawFS.GetAttr(input, out) 54 } 55 56 func (fs *lockingRawFileSystem) Open(input *OpenIn, out *OpenOut) (status Status) { 57 58 defer fs.locked()() 59 return fs.RawFS.Open(input, out) 60 } 61 62 func (fs *lockingRawFileSystem) SetAttr(input *SetAttrIn, out *AttrOut) (code Status) { 63 defer fs.locked()() 64 return fs.RawFS.SetAttr(input, out) 65 } 66 67 func (fs *lockingRawFileSystem) Readlink(header *InHeader) (out []byte, code Status) { 68 defer fs.locked()() 69 return fs.RawFS.Readlink(header) 70 } 71 72 func (fs *lockingRawFileSystem) Mknod(input *MknodIn, name string, out *EntryOut) (code Status) { 73 defer fs.locked()() 74 return fs.RawFS.Mknod(input, name, out) 75 } 76 77 func (fs *lockingRawFileSystem) Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status) { 78 defer fs.locked()() 79 return fs.RawFS.Mkdir(input, name, out) 80 } 81 82 func (fs *lockingRawFileSystem) Unlink(header *InHeader, name string) (code Status) { 83 defer fs.locked()() 84 return fs.RawFS.Unlink(header, name) 85 } 86 87 func (fs *lockingRawFileSystem) Rmdir(header *InHeader, name string) (code Status) { 88 defer fs.locked()() 89 return fs.RawFS.Rmdir(header, name) 90 } 91 92 func (fs *lockingRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status) { 93 defer fs.locked()() 94 return fs.RawFS.Symlink(header, pointedTo, linkName, out) 95 } 96 97 func (fs *lockingRawFileSystem) Rename(input *RenameIn, oldName string, newName string) (code Status) { 98 defer fs.locked()() 99 return fs.RawFS.Rename(input, oldName, newName) 100 } 101 102 func (fs *lockingRawFileSystem) Link(input *LinkIn, name string, out *EntryOut) (code Status) { 103 defer fs.locked()() 104 return fs.RawFS.Link(input, name, out) 105 } 106 107 func (fs *lockingRawFileSystem) SetXAttr(input *SetXAttrIn, attr string, data []byte) Status { 108 defer fs.locked()() 109 return fs.RawFS.SetXAttr(input, attr, data) 110 } 111 112 func (fs *lockingRawFileSystem) GetXAttrData(header *InHeader, attr string) (data []byte, code Status) { 113 defer fs.locked()() 114 return fs.RawFS.GetXAttrData(header, attr) 115 } 116 117 func (fs *lockingRawFileSystem) GetXAttrSize(header *InHeader, attr string) (sz int, code Status) { 118 defer fs.locked()() 119 return fs.RawFS.GetXAttrSize(header, attr) 120 } 121 122 func (fs *lockingRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) { 123 defer fs.locked()() 124 return fs.RawFS.ListXAttr(header) 125 } 126 127 func (fs *lockingRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status { 128 defer fs.locked()() 129 return fs.RawFS.RemoveXAttr(header, attr) 130 } 131 132 func (fs *lockingRawFileSystem) Access(input *AccessIn) (code Status) { 133 defer fs.locked()() 134 return fs.RawFS.Access(input) 135 } 136 137 func (fs *lockingRawFileSystem) Create(input *CreateIn, name string, out *CreateOut) (code Status) { 138 defer fs.locked()() 139 return fs.RawFS.Create(input, name, out) 140 } 141 142 func (fs *lockingRawFileSystem) OpenDir(input *OpenIn, out *OpenOut) (status Status) { 143 defer fs.locked()() 144 return fs.RawFS.OpenDir(input, out) 145 } 146 147 func (fs *lockingRawFileSystem) Release(input *ReleaseIn) { 148 defer fs.locked()() 149 fs.RawFS.Release(input) 150 } 151 152 func (fs *lockingRawFileSystem) ReleaseDir(input *ReleaseIn) { 153 defer fs.locked()() 154 fs.RawFS.ReleaseDir(input) 155 } 156 157 func (fs *lockingRawFileSystem) Read(input *ReadIn, buf []byte) (ReadResult, Status) { 158 defer fs.locked()() 159 return fs.RawFS.Read(input, buf) 160 } 161 162 func (fs *lockingRawFileSystem) GetLk(in *LkIn, out *LkOut) (code Status) { 163 defer fs.locked()() 164 return fs.RawFS.GetLk(in, out) 165 } 166 167 func (fs *lockingRawFileSystem) SetLk(in *LkIn) (code Status) { 168 defer fs.locked()() 169 return fs.RawFS.SetLk(in) 170 } 171 172 func (fs *lockingRawFileSystem) SetLkw(in *LkIn) (code Status) { 173 defer fs.locked()() 174 return fs.RawFS.SetLkw(in) 175 } 176 177 func (fs *lockingRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) { 178 defer fs.locked()() 179 return fs.RawFS.Write(input, data) 180 } 181 182 func (fs *lockingRawFileSystem) Flush(input *FlushIn) Status { 183 defer fs.locked()() 184 return fs.RawFS.Flush(input) 185 } 186 187 func (fs *lockingRawFileSystem) Fsync(input *FsyncIn) (code Status) { 188 defer fs.locked()() 189 return fs.RawFS.Fsync(input) 190 } 191 192 func (fs *lockingRawFileSystem) ReadDir(input *ReadIn, out *DirEntryList) Status { 193 defer fs.locked()() 194 return fs.RawFS.ReadDir(input, out) 195 } 196 197 func (fs *lockingRawFileSystem) ReadDirPlus(input *ReadIn, out *DirEntryList) Status { 198 defer fs.locked()() 199 return fs.RawFS.ReadDirPlus(input, out) 200 } 201 202 func (fs *lockingRawFileSystem) FsyncDir(input *FsyncIn) (code Status) { 203 defer fs.locked()() 204 return fs.RawFS.FsyncDir(input) 205 } 206 207 func (fs *lockingRawFileSystem) Init(s *Server) { 208 defer fs.locked()() 209 fs.RawFS.Init(s) 210 } 211 212 func (fs *lockingRawFileSystem) StatFs(header *InHeader, out *StatfsOut) (code Status) { 213 defer fs.locked()() 214 return fs.RawFS.StatFs(header, out) 215 } 216 217 func (fs *lockingRawFileSystem) Fallocate(in *FallocateIn) (code Status) { 218 defer fs.locked()() 219 return fs.RawFS.Fallocate(in) 220 } 221 222 func (fs *lockingRawFileSystem) String() string { 223 defer fs.locked()() 224 return fmt.Sprintf("Locked(%s)", fs.RawFS.String()) 225 }