+7 -22

src/e9p.erl

··· 4 4 5 5 -module(e9p). 6 6 7 7 - -export([make_qid/4, is_type/2]). 7 7 + -export([make_qid/3, is_type/2]). 8 8 9 9 -export_type([qid/0, fid/0]). 10 10 11 11 -export_type([u8/0, u16/0, u32/0, u64/0]). 12 12 + 13 13 + -include("e9p_internal.hrl"). 12 14 13 15 -type u8() :: 16#00..16#FF. 14 16 -type u16() :: 16#0000..16#FFFF. 15 17 -type u32() :: 16#00000000..16#FFFFFFFF. 16 18 -type u64() :: 16#0000000000000000..16#FFFFFFFFFFFFFFFF. 17 19 18 18 - -type qid() :: #{ 19 19 - type => u8(), 20 20 - version => u16(), 21 21 - path => u64(), 22 22 - state => term() 23 23 - }. 20 20 + -opaque qid() :: #qid{type :: u8(), version :: u32(), path :: u64()}. 24 21 25 22 -type fid() :: 16#00000000..16#FFFFFFFF. 26 23 27 24 %-spec make_qid() 28 28 - make_qid(Type, Version, Path, State) -> 29 29 - #{ 30 30 - type => to_qtype(Type), 31 31 - version => Version, 32 32 - path => Path, 33 33 - state => State 34 34 - }. 25 25 + make_qid(Type, Version, Path) -> 26 26 + #qid{type = to_qtype(Type), version = Version, path = Path}. 35 27 36 36 - is_type(#{type := QType}, Type) -> 28 28 + is_type(#qid{type = QType}, Type) -> 37 29 (to_qtype(Type) band QType) =/= 0. 38 38 - 39 39 - to_qtype(List) when is_list(List) -> 40 40 - lists:foldl( 41 41 - fun(El, Acc) when is_integer(Acc) -> to_qtype(El) bor Acc end, 42 42 - 0, 43 43 - List 44 44 - ); 45 30 46 31 to_qtype(directory) -> 16#80; 47 32 to_qtype(append) -> 16#40;

+98 -63

src/e9p_fs.erl

··· 20 20 wstat/3 21 21 ]). 22 22 23 23 - -export_type([state/0]). 23 23 + -include("e9p_internal.hrl"). 24 24 + -include_lib("kernel/include/logger.hrl"). 25 25 + 26 26 + -export_type([state/0, fid/0, path/0, result/0, result/1]). 24 27 25 28 -type state() :: term(). 29 29 + -type fid() :: {QID :: e9p:qid(), State :: fid_state()}. 30 30 + -type path() :: [unicode:chardata()]. 31 31 + -type fid_state() :: term(). 26 32 -type result() :: {ok, state()} | {error, term(), state()}. 27 33 -type result(T) :: {ok, T, state()} | {error, term(), state()}. 28 34 ··· 48 54 %% If implementation provides multiple trees then the `AName' will be set to the 49 55 %% tree defined by the client. It is left to the implementation to ensure the 50 56 %% constraints of the file root (aka `walk(Root, "..", State0) =:= {Root, State1}'. 51 51 - -callback root(UName :: unicode:chardata(), AName :: unicode:chardata(), state()) -> {ok, e9p:qid(), state()}. 57 57 + -callback root(UName :: unicode:chardata(), AName :: unicode:chardata(), state()) -> 58 58 + {ok, fid_state(), state()}. 52 59 53 53 - -callback flush(state()) -> {ok, state()} | {error, term(), state()}. 60 60 + -callback flush(state()) -> result(). 54 61 55 62 %% Walk through the given path starting at the `QID' 56 56 - -callback walk(QID :: e9p:qid(), unicode:chardata(), state()) -> 57 57 - {e9p:qid() | false, state()}. 63 63 + -callback walk(fid(), File :: unicode:chardata(), unicode:chardata(), state()) -> 64 64 + {fid() | false, state()}. 58 65 59 59 - -callback open(QID :: e9p:qid(), Mode :: integer(), state()) -> result({e9p:qid(), e9p:u32()}). 66 66 + -callback open(fid(), path(), Mode :: integer(), state()) -> result({fid_state(), e9p:u32()}). 60 67 61 61 - -callback create(QID :: e9p:qid(), 68 68 + -callback create(fid(), 69 69 + path(), 62 70 Name :: unicode:chardata(), 63 71 Perm :: e9p:u32(), 64 72 Mode :: e9p:u8(), 65 65 - state()) -> result({e9p:qid(), e9p:u32()}). 73 73 + state()) -> result({fid(), IOUnit :: e9p:u32()}). 66 74 67 75 %% Read data from file indicated by `QID' 68 68 - -callback read(QID :: e9p:qid(), 76 76 + -callback read(fid(), 77 77 + path(), 69 78 Offset :: non_neg_integer(), 70 79 Length :: non_neg_integer(), 71 71 - state()) -> result({e9p:qid(), iodata()}). 80 80 + state()) -> result({fid_state(), iodata()}). 72 81 73 82 %% Write data to file indicated by `QID' 74 74 - -callback write(QID :: e9p:qid(), 83 83 + -callback write(fid(), 84 84 + path(), 75 85 Offset :: non_neg_integer(), 76 86 Data :: iodata(), 77 77 - state()) -> result({e9p:qid(), non_neg_integer()}). 87 87 + state()) -> result({fid_state(), non_neg_integer()}). 78 88 79 79 - -callback clunk(QID :: e9p:qid(), state()) -> result(). 89 89 + -callback clunk(fid(), path(), state()) -> result(). 80 90 81 81 - -callback remove(QID :: e9p:qid(), state()) -> result(). 91 91 + -callback remove(fid(), path(), state()) -> result(). 82 92 83 93 %% Return stat data for file indicated by `QID' 84 84 - -callback stat(QID :: e9p:qid(), state()) -> result(map()). 94 94 + -callback stat(fid(), path(), state()) -> result(map()). 85 95 86 96 %% Write stat data for file indicated by `QID' 87 87 - -callback wstat(QID :: e9p:qid(), map(), state()) -> result(). 97 97 + -callback wstat(fid(), path(), map(), state()) -> result(). 88 98 89 99 -optional_callbacks([ 90 100 flush/1, 91 91 - walk/3, 92 92 - open/3, 93 93 - create/5, 94 94 - read/4, 95 95 - write/4, 96 96 - clunk/2, 97 97 - remove/2, 98 98 - stat/2, 99 99 - wstat/3 101 101 + clunk/3 100 102 ]). 101 103 102 104 init({Mod, State}) -> ··· 107 109 108 110 root({Mod, State}, UName, AName) -> 109 111 case Mod:root(UName, AName, State) of 110 110 - {ok, QID, NewState} -> 111 111 - {ok, QID, {Mod, NewState}} 112 112 + {ok, {QID, FState}, NewState} -> 113 113 + {ok, #fid{qid = QID, path = [], state = FState}, {Mod, NewState}} 112 114 end. 113 115 114 116 -doc """ 115 117 Walk through paths starting at QID. 116 118 """. 117 117 - walk({Mod, State}, QID, Paths) when is_atom(Mod) -> 118 118 - ?if_supported(do_walk(Mod, QID, Paths, State, [])). 119 119 + walk({Mod, State0}, FID0, Paths) when is_atom(Mod) -> 120 120 + case do_walk(Mod, FID0, Paths, State0, []) of 121 121 + {ok, {FID, QIDs}, State} -> {ok, {FID, QIDs}, {Mod, State}}; 122 122 + {error, Reason, State} -> {error, Reason, {Mod, State}} 123 123 + end. 124 124 + 125 125 + do_walk(_Mod, FID, [], State, Acc) -> 126 126 + {ok, {FID, lists:reverse(Acc)}, State}; 127 127 + do_walk(Mod, #fid{qid = QID0, path = Path, state = FState0} = FID0, [P | Rest], State0, Acc) -> 128 128 + case e9p:is_type(QID0, directory) of 129 129 + true -> 130 130 + case Mod:walk({QID0, FState0}, Path, P, State0) of 131 131 + {false, State} when Acc =:= [] -> 132 132 + % Per specification walk to first entry in name list must succeed 133 133 + % (if any) otherwise return error. In subsequent steps we return 134 134 + % successful list and last succeeded QID 135 135 + {error, io_lib:format("Failed walk to ~p", [P]), State}; 136 136 + {false, State} -> 137 137 + {ok, {FID0, lists:reverse(Acc)}, State}; 138 138 + {{QID, FState}, State} -> 139 139 + FID = #fid{qid = QID, state = FState, path = Path ++ [P]}, 140 140 + do_walk(Mod, FID, Rest, State, [QID | Acc]) 141 141 + end; 142 142 + false -> 143 143 + {error, io_lib:format("Not directory ~p", [Path]), State0} 144 144 + end. 119 145 120 120 - do_walk(_Mod, QID, [], State, Acc) -> 121 121 - {ok, {QID, lists:reverse(Acc)}, State}; 122 122 - do_walk(Mod, QID0, [P | Rest], State0, Acc) -> 123 123 - case Mod:walk(QID0, P, State0) of 124 124 - {false, State} when Acc =:= [] -> 125 125 - % Per specification walk to first entry in name list must succeed 126 126 - % (if any) otherwise return error. In subsequent steps we return 127 127 - % successful list and last succeeded QID 128 128 - {error, io_lib:format("Failed walk to ~p", [P]), State}; 129 129 - {false, State} -> 130 130 - {ok, {QID0, lists:reverse(Acc)}, State}; 131 131 - {QID, State} -> 132 132 - do_walk(Mod, QID, Rest, State, [QID | Acc]) 146 146 + open({Mod, State0}, #fid{qid = QID, path = Path, state = FState0} = FID, Mode) -> 147 147 + EMode = translate_mode(Mode), 148 148 + case Mod:open({QID, FState0}, Path, EMode, State0) of 149 149 + {ok, {FState, IOUnit}, State} -> 150 150 + {ok, {FID#fid{state = FState}, IOUnit}, {Mod, State}}; 151 151 + {error, Reason, StateE} -> {error, Reason, {Mod, StateE}} 133 152 end. 134 153 135 135 - open({Mod, State}, QID, Mode) -> 136 136 - ?if_supported(Mod:open(QID, Mode, State)). 154 154 + translate_mode(Mode) when Mode >= 16#10 -> 155 155 + [trunc | translate_mode(Mode band 16#EF)]; 156 156 + translate_mode(0) -> [read]; 157 157 + translate_mode(1) -> [write]; 158 158 + translate_mode(2) -> [append]; 159 159 + translate_mode(3) -> [exec]. 137 160 138 138 - create({Mod, State}, QID, Name, Perm, Mode) -> 139 139 - ?if_supported(Mod:create(QID, Name, Perm, Mode, State)). 161 161 + create({Mod, State}, #fid{qid = QID, path = Path, state = FState}, Name, Perm, Mode) -> 162 162 + ?if_supported(Mod:create({QID, FState}, Path, Name, Perm, Mode, State)). 140 163 141 141 - read({Mod, State}, QID, Offset, Length) -> 142 142 - ?if_supported(Mod:read(QID, Offset, Length, State)). 164 164 + read({Mod, State0}, #fid{qid = QID, path = Path, state = FState0} = FID, Offset, Length) -> 165 165 + case Mod:read({QID, FState0}, Path, Offset, Length, State0) of 166 166 + {ok, {FState, Data}, State} -> {ok, {FID#fid{state = FState}, Data}, {Mod, State}}; 167 167 + {error, Reason, StateE} -> {error, Reason, {Mod, StateE}} 168 168 + end. 143 169 144 144 - write({Mod, State}, QID, Offset, Data) -> 145 145 - ?if_supported(Mod:write(QID, Offset, Data, State)). 170 170 + write({Mod, State0}, #fid{qid = QID, path = Path, state = FState0} = FID, Offset, Data) -> 171 171 + case Mod:write({QID, FState0}, Path, Offset, Data, State0) of 172 172 + {ok, {FState, Len}, State} -> {ok, {FID#fid{state = FState}, Len}, {Mod, State}}; 173 173 + {error, Reason, StateE} -> {error, Reason, {Mod, StateE}} 174 174 + end. 146 175 147 147 - clunk({Mod, State0}, QID) -> 176 176 + clunk({Mod, State0}, #fid{qid = QID, path = Path, state = FState}) -> 148 177 case erlang:function_exported(Mod, clunk, 3) of 149 178 true -> 150 150 - maybe 151 151 - {ok, State} ?= Mod:clunk(QID, State0), 152 152 - {ok, {Mod, State}} 153 153 - else 154 154 - {error, Reason, StateE} -> 155 155 - {error, Reason, {Mod, StateE}} 179 179 + case Mod:clunk({QID, FState}, Path, State0) of 180 180 + {ok, State} -> {ok, {Mod, State}}; 181 181 + {error, Reason, StateE} -> {error, Reason, {Mod, StateE}} 156 182 end; 157 183 false -> {ok, {Mod, State0}} 158 184 end. 159 185 160 160 - remove({Mod, State}, QID) -> 161 161 - ?if_supported(Mod:remove(QID, State)). 186 186 + remove({Mod, State0}, #fid{qid = QID, path = Path, state = FState}) -> 187 187 + case Mod:remove({QID, FState}, Path, State0) of 188 188 + {ok, State} -> {ok, {Mod, State}}; 189 189 + {error, Reason, State} -> {error, Reason, {Mod, State}} 190 190 + end. 162 191 163 163 - stat({Mod, State}, QID) -> 164 164 - ?if_supported(Mod:stat(QID, State)). 192 192 + stat({Mod, State0}, #fid{qid = QID, path = Path, state = FState0}) -> 193 193 + case Mod:stat({QID, FState0}, Path, State0) of 194 194 + {ok, Stat, State} -> {ok, Stat, {Mod, State}}; 195 195 + {error, Reason, StateE} -> {error, Reason, {Mod, StateE}} 196 196 + end. 165 197 166 166 - wstat({Mod, State}, QID, Stat) -> 167 167 - ?if_supported(Mod:wstat(QID, Stat, State)). 198 198 + wstat({Mod, State0}, #fid{qid = QID, path = Path, state = FState}, Stat) -> 199 199 + case Mod:wstat({QID, FState}, Path, Stat, State0) of 200 200 + {ok, State} -> {ok, {Mod, State}}; 201 201 + {error, Reason, State} -> {error, Reason, {Mod, State}} 202 202 + end.

+3

src/e9p_internal.hrl

··· 53 53 -define(Twstat, 126). 54 54 -define(Rwstat, 127). 55 55 56 56 + -record(qid, {type, version, path}). 57 57 + -record(fid, {qid, path, state}). 58 58 + 56 59 -record(tversion, {max_packet_size, version}). 57 60 -record(rversion, {max_packet_size, version}). 58 61

+12 -3

src/e9p_msg.erl

··· 162 162 {ok, #tread{fid = FID, offset = Offset, len = Len}}; 163 163 do_parse(?Rread, <<Count:4/?int, Data:Count/?int>>) -> 164 164 {ok, #rread{data = Data}}; 165 165 + do_parse(?Twrite, <<FID:4/?int, Offset:8/?int, Len:4/?int, Data:Len/binary>>) -> 166 166 + {ok, #twrite{fid = FID, offset = Offset, data = Data}}; 167 167 + do_parse(?Rwrite, <<Len:4/?int>>) -> 168 168 + {ok, #rwrite{len = Len}}; 165 169 166 170 do_parse(Type, Data) -> 167 171 {error, {invalid_message, Type, Data}}. ··· 273 277 {?Tread, <<FID:4/?int, Offset:8/?int, Len:4/?int>>}; 274 278 do_encode(#rread{data = Data}) -> 275 279 Len = iolist_size(Data), 276 276 - {?Rread, [<<Len:4/?int>> | Data]}. 280 280 + {?Rread, [<<Len:4/?int>> | Data]}; 281 281 + do_encode(#twrite{fid = FID, offset = Offset, data = Data}) -> 282 282 + Len = iolist_size(Data), 283 283 + {?Twrite, [<<FID:4/?int, Offset:8/?int, Len:4/?int>>, Data]}; 284 284 + do_encode(#rwrite{len = Len}) -> 285 285 + {?Rwrite, [<<Len:4/?int>>]}. 277 286 278 287 encode_stat(Stat) -> 279 288 #{ ··· 326 335 [<<Len:?len>>, Data]. 327 336 328 337 binary_to_qid(<<Type:1/?int, Version:4/?int, Path:8/?int>>) -> 329 329 - #{type => Type, version => Version, path => Path, state => []}. 338 338 + #qid{type = Type, version = Version, path = Path}. 330 339 331 331 - qid_to_binary(#{type := Type, version := Version, path := Path}) -> 340 340 + qid_to_binary(#qid{type = Type, version = Version, path = Path}) -> 332 341 <<Type:1/?int, Version:4/?int, Path:8/?int>>. 333 342 334 343 time_to_encoded_sec(Sec) when is_integer(Sec) -> <<Sec:4/?int>>;

+5 -8

src/e9p_server.erl

··· 22 22 handler 23 23 }). 24 24 25 25 - -record(fid, {qid, path, state}). 26 26 - 27 25 start_link(Port, Handler) -> 28 26 proc_lib:start_link(?MODULE, setup_acceptor, [self(), Port, Handler]). 29 27 ··· 60 58 loop(#state{socket = Sock} = State) -> 61 59 case e9p_transport:read(Sock) of 62 60 {ok, Tag, Data} -> 63 63 - ?LOG_DEBUG(#{msg => Data}), 64 61 try handle_message(Data, State#state.fids, State#state.handler) of 65 62 {ok, Reply, FIDs, Handler} -> 66 63 e9p_transport:send(Sock, Tag, Reply), ··· 92 89 maybe 93 90 {ok, QID, Handler} ?= e9p_fs:root(Handler0, UName, AName), 94 91 NFIDs = FIDs#{FID => QID}, 95 95 - {ok, #rattach{qid = QID}, NFIDs, Handler} 92 92 + {ok, #rattach{qid = QID#fid.qid}, NFIDs, Handler} 96 93 end; 97 94 98 95 handle_message(#twalk{fid = FID, new_fid = NewFID, names = Paths}, FIDs, Handler0) -> ··· 106 103 maybe 107 104 {ok, QID} ?= get_qid(FIDs, FID), 108 105 {ok, {NewQID, IOUnit}, Handler} ?= e9p_fs:open(Handler0, QID, Mode), 109 109 - {ok, #ropen{qid = QID, io_unit = IOUnit}, FIDs#{FID => NewQID}, Handler} 106 106 + {ok, #ropen{qid = QID#fid.qid, io_unit = IOUnit}, FIDs#{FID => NewQID}, Handler} 110 107 end; 111 108 handle_message(#tcreate{fid = FID, name = Name, perm = Perm, mode = Mode}, FIDs, Handler0) -> 112 109 maybe 113 110 {ok, QID} ?= get_qid(FIDs, FID), 114 111 {ok, {NewQID, IOUnit}, Handler} ?= e9p_fs:create(Handler0, QID, Name, Perm, Mode), 115 115 - {ok, #rcreate{qid = NewQID, io_unit = IOUnit}, FIDs, Handler} 112 112 + {ok, #rcreate{qid = NewQID#fid.qid, io_unit = IOUnit}, FIDs, Handler} 116 113 end; 117 114 118 115 handle_message(#tread{fid = FID, offset = Offset, len = Len}, FIDs, Handler0) -> ··· 124 121 handle_message(#twrite{fid = FID, offset = Offset, data = Data}, FIDs, Handler0) -> 125 122 maybe 126 123 {ok, QID} ?= get_qid(FIDs, FID), 127 127 - {ok, {NQID, Data}, Handler} ?= e9p_fs:write(Handler0, QID, Offset, Data), 128 128 - {ok, #rread{data = Data}, FIDs#{FID => NQID}, Handler} 124 124 + {ok, {NQID, Len}, Handler} ?= e9p_fs:write(Handler0, QID, Offset, Data), 125 125 + {ok, #rwrite{len = Len}, FIDs#{FID => NQID}, Handler} 129 126 end; 130 127 131 128 handle_message(#tclunk{fid = FID}, FIDs, Handler0) ->

+91 -47

src/e9p_unfs.erl

··· 9 9 -include_lib("kernel/include/logger.hrl"). 10 10 -include_lib("kernel/include/file.hrl"). 11 11 12 12 - -export([init/1, root/3, walk/3, stat/2, open/3, read/4, clunk/2]). 13 13 - 14 14 - -doc """ 15 15 - Create QID for given path. 16 16 - """. 17 17 - qid(Path) -> 18 18 - case file:read_file_info(Path, [{time, posix}]) of 19 19 - {ok, #file_info{type = Type, inode = Inode}} -> 20 20 - NQid = e9p:make_qid(Type, 0, Inode, {Path, []}), 21 21 - {ok, NQid}; 22 22 - {error, _} = Error -> Error 23 23 - end. 12 12 + -export([init/1, root/3, walk/4, stat/3, open/4, read/5, clunk/2, create/6, 13 13 + write/5, remove/3, wstat/4]). 24 14 25 15 -doc """ 26 16 Create QID and Stat data for given path. 27 17 """. 28 28 - qid_stat(Root, Path) -> 29 29 - case file:read_file_info(Path, [{time, posix}]) of 18 18 + qid(Root, Path) -> 19 19 + FullPath = filename:join([Root] ++ Path), 20 20 + case file:read_file_info(FullPath, [{time, posix}]) of 30 21 {ok, #file_info{type = Type, inode = Inode} = FI} -> 31 31 - NQid = e9p:make_qid(Type, 0, Inode, {Path, []}), 32 32 - Stat = file_info_to_stat(Root, NQid, FI), 33 33 - {ok, NQid, Stat}; 22 22 + QID = e9p:make_qid(Type, 0, Inode), 23 23 + Stat = file_info_to_stat(Path, QID, FI), 24 24 + {ok, QID, Stat}; 34 25 {error, _} = Error -> Error 35 26 end. 36 27 ··· 40 31 root(UName, AName, #{root := Root} = State) -> 41 32 ?LOG_INFO(#{uname => UName, aname => AName}), 42 33 maybe 43 43 - {ok, Qid} ?= qid(Root), 44 44 - {ok, Qid, State} 34 34 + {ok, Qid, _Stat} ?= qid(Root, []), 35 35 + {ok, {Qid, []}, State} 45 36 end. 46 37 47 47 - walk(#{state := {Root, _}}, ~"..", #{root := Root} = State) -> 38 38 + walk(_QID, [], ~"..", State) -> 48 39 {false, State}; 49 49 - walk(#{state := {Path, _}}, ~"..", State) -> 50 50 - Next = filename:dirname(Path), 51 51 - case qid(Next) of 52 52 - {ok, NQid} -> {NQid, State}; 40 40 + walk(_QID, Path, ~"..", #{root := Root} = State) -> 41 41 + case qid(Root, lists:droplast(Path)) of 42 42 + {ok, NQid, _Stat} -> {{NQid, []}, State}; 53 43 {error, _} -> {false, State} 54 44 end; 55 55 - walk(#{state := {Path, _}}, File, State) -> 56 56 - Next = filename:join(Path, File), 57 57 - case qid(Next) of 58 58 - {ok, NQid} -> {NQid, State}; 45 45 + walk(_QID, Path, File, #{root := Root} = State) -> 46 46 + case qid(Root, Path ++ [File]) of 47 47 + {ok, NQid, _Stat} -> {{NQid, []}, State}; 59 48 {error, _} -> {false, State} 60 49 end. 61 50 62 62 - stat(#{state := {Path, _}} = QID, #{root := Root} = State) -> 63 63 - case file:read_file_info(Path, [{time, posix}]) of 51 51 + stat({QID, _}, Path, #{root := Root} = State) -> 52 52 + FullPath = filename:join([Root] ++ Path), 53 53 + case file:read_file_info(FullPath, [{time, posix}]) of 64 54 {ok, FileInfo} -> 65 65 - Stat = file_info_to_stat(Root, QID, FileInfo), 55 55 + Stat = file_info_to_stat(Path, QID, FileInfo), 66 56 {ok, Stat, State}; 67 57 {error, Error} -> 68 58 {error, Error, State} 69 59 end. 70 60 71 71 - open(#{state := {Path, []}} = QID, _Mode, State) -> 61 61 + open({QID, []}, Path, Mode, #{root := Root} = State) -> 62 62 + FullPath = filename:join([Root] ++ Path), 72 63 QS = case e9p:is_type(QID, directory) of 73 64 true -> 74 74 - {ok, List} = file:list_dir(Path), 65 65 + {ok, List} = file:list_dir(FullPath), 75 66 {dir, List}; 76 67 false -> 77 77 - {ok, FD} = file:open(Path, [raw, read, binary]), 68 68 + {Trunc, Opts} = translate_mode(Mode), 69 69 + {ok, FD} = file:open(FullPath, [raw, binary | Opts]), 70 70 + if Trunc -> file:truncate(FD); true -> ok end, 78 71 {regular, FD} 79 72 end, 80 80 - NQID = QID#{state => {Path, QS}}, 81 81 - {ok, {NQID, 0}, State}. 73 73 + {ok, {QS, 0}, State}. 82 74 83 83 - read(#{state := {_, {regular, FD}}} = QID, Offset, Len, State) -> 75 75 + create(_QID, _Path, _Name, _Perm, _Mode, State) -> 76 76 + {error, "Unsupported", State}. 77 77 + 78 78 + remove({QID, _} = FID, Path, #{root := Root} = State0) -> 79 79 + FullPath = filename:join([Root] ++ Path), 80 80 + {ok, State} = clunk(FID, State0), 81 81 + case case e9p:is_type(QID, directory) of 82 82 + true -> file:del_dir(FullPath); 83 83 + false -> file:delete(FullPath) 84 84 + end of 85 85 + ok -> {ok, State}; 86 86 + {error, Reason} -> 87 87 + {error, io_lib:format("Failed to remove path: ~p", [Reason]), State} 88 88 + end. 89 89 + 90 90 + translate_mode([trunc | Rest]) -> 91 91 + {_, Mode} = translate_mode(Rest), 92 92 + {true, Mode}; 93 93 + translate_mode([read]) -> {false, [read]}; 94 94 + translate_mode([write]) -> {false, [read, write]}; 95 95 + translate_mode([append]) -> {false, [read, write]}; 96 96 + translate_mode([exec]) -> {false, [read]}. 97 97 + 98 98 + read({_QID, {regular, FD}}, _Path, Offset, Len, State) -> 84 99 case file:pread(FD, Offset, Len) of 85 85 - {ok, Data} -> {ok, {QID, Data}, State}; 86 86 - eof -> {ok, {QID, []}, State}; 100 100 + {ok, Data} -> {ok, {{regular, FD}, Data}, State}; 101 101 + eof -> {ok, {{regular, FD}, []}, State}; 87 102 {error, Err} -> {error, Err, State} 88 103 end; 89 89 - read(#{state := {Path, {dir, List}}} = QID, _Offset, Len, #{root := Root} = State) -> 104 104 + read({_QID, {dir, List}}, Path, _Offset, Len, #{root := Root} = State) -> 90 105 {Remaining, Data} = readdir(Root, Path, List, Len, []), 91 91 - {ok, {QID#{state => {Path, {dir, Remaining}}}, Data}, State}. 106 106 + {ok, {{dir, Remaining}, Data}, State}. 92 107 93 108 readdir(_Root, _Path, List, 0, Acc) -> {List, Acc}; 94 109 readdir(_Root, _Path, [], _Len, Acc) -> {[], Acc}; 95 110 readdir(Root, Path, [Next | Rest], Len, Acc) -> 96 96 - {ok, _QID, Stat} = qid_stat(Root, filename:join(Path, Next)), 111 111 + {ok, _QID, Stat} = qid(Root, Path ++ [Next]), 97 112 Encoded = e9p_msg:encode_stat(Stat), 98 113 Size = iolist_size(Encoded), 99 114 if ··· 101 116 true -> readdir(Root, Path, Rest, Len - Size, [Encoded | Acc]) 102 117 end. 103 118 104 104 - clunk(#{state := {_Path, {refular, FD}}}, State) -> 119 119 + write({_QID, {regular, FD}}, _Path, Offset, Data, State) -> 120 120 + case file:pwrite(FD, Offset, Data) of 121 121 + ok -> {ok, {{regular, FD}, iolist_size(Data)}, State}; 122 122 + {error, Err} -> {error, io_lib:format("Write error ~p", [Err]), State} 123 123 + end. 124 124 + 125 125 + clunk({_, {regular, FD}}, State) -> 105 126 ok = file:close(FD), 106 127 {ok, State}; 107 128 clunk(_QID, State) -> 108 129 {ok, State}. 109 130 131 131 + wstat(_QID, Path, Stat, #{root := Root} = State) -> 132 132 + FileInfo = stat_to_file_info(Stat), 133 133 + FullPath = filename:join([Root] ++ Path), 134 134 + 135 135 + case file:write_file_info(FullPath, FileInfo, [{time, posix}]) of 136 136 + ok -> {ok, State}; 137 137 + {error, Reason} -> 138 138 + {error, io_lib:format("Couldn't write file stat: ~p", [Reason]), 139 139 + State} 140 140 + end. 141 141 + 110 142 file_info_to_stat( 111 111 - Root, 112 112 - #{state := {Path, _}} = QID, 143 143 + Path, 144 144 + QID, 113 145 #file_info{ 114 146 size = Len, 115 147 atime = Atime, ··· 117 149 mode = Mode 118 150 }) -> 119 151 Name = if 120 120 - Root == Path -> ~"/"; 121 121 - true -> filename:basename(Path) 152 152 + Path == [] -> ~"/"; 153 153 + true -> lists:last(Path) 122 154 end, 123 155 #{ 124 156 qid => QID, ··· 128 160 length => Len, 129 161 name => Name 130 162 }. 163 163 + 164 164 + stat_to_file_info(Stat) -> 165 165 + #{ 166 166 + mode := Mode, 167 167 + atime := Atime, 168 168 + mtime := Mtime 169 169 + } = Stat, 170 170 + #file_info{ 171 171 + mode = Mode, 172 172 + atime = Atime, 173 173 + mtime = Mtime 174 174 + }.