GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/node_file-inl.h Lines: 149 156 95.5 %
Date: 2020-06-24 22:13:30 Branches: 77 122 63.1 %

Line Branch Exec Source
1
#ifndef SRC_NODE_FILE_INL_H_
2
#define SRC_NODE_FILE_INL_H_
3
4
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6
#include "node_file.h"
7
#include "req_wrap-inl.h"
8
9
namespace node {
10
namespace fs {
11
12
4798
FSContinuationData::FSContinuationData(uv_fs_t* req, int mode, uv_fs_cb done_cb)
13
4798
  : done_cb_(done_cb), req_(req), mode_(mode) {
14
4798
}
15
16
120
void FSContinuationData::PushPath(std::string&& path) {
17
120
  paths_.emplace_back(std::move(path));
18
120
}
19
20
4784
void FSContinuationData::PushPath(const std::string& path) {
21
4784
  paths_.push_back(path);
22
4784
}
23
24
180
void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
25
180
  if (first_path_.empty()) {
26
128
    first_path_ = path;
27
  }
28
180
}
29
30
4904
std::string FSContinuationData::PopPath() {
31
4904
  CHECK_GT(paths_.size(), 0);
32
4904
  std::string path = std::move(paths_.back());
33
4904
  paths_.pop_back();
34
4904
  return path;
35
}
36
37
14
void FSContinuationData::Done(int result) {
38
14
  req_->result = result;
39
14
  done_cb_(req_);
40
14
}
41
42
50521
FSReqBase::FSReqBase(BindingData* binding_data,
43
                     v8::Local<v8::Object> req,
44
                     AsyncWrap::ProviderType type,
45
50521
                     bool use_bigint)
46
  : ReqWrap(binding_data->env(), req, type),
47
    use_bigint_(use_bigint),
48
50521
    binding_data_(binding_data) {
49
50521
}
50
51
50391
void FSReqBase::Init(const char* syscall,
52
                     const char* data,
53
                     size_t len,
54
                     enum encoding encoding) {
55
50391
  syscall_ = syscall;
56
50391
  encoding_ = encoding;
57
58
50391
  if (data != nullptr) {
59
250
    CHECK(!has_data_);
60
250
    buffer_.AllocateSufficientStorage(len + 1);
61
250
    buffer_.SetLengthAndZeroTerminate(len);
62
250
    memcpy(*buffer_, data, len);
63
250
    has_data_ = true;
64
  }
65
50391
}
66
67
FSReqBase::FSReqBuffer&
68
107
FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
69
107
  syscall_ = syscall;
70
107
  encoding_ = encoding;
71
72
107
  buffer_.AllocateSufficientStorage(len + 1);
73
107
  has_data_ = false;  // so that the data does not show up in error messages
74
107
  return buffer_;
75
}
76
77
49206
FSReqCallback::FSReqCallback(BindingData* binding_data,
78
                             v8::Local<v8::Object> req,
79
49206
                             bool use_bigint)
80
  : FSReqBase(binding_data,
81
              req,
82
              AsyncWrap::PROVIDER_FSREQCALLBACK,
83
49206
              use_bigint) {}
84
85
template <typename NativeT, typename V8T>
86
144764
void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
87
                    const uv_stat_t* s,
88
                    const size_t offset) {
89
#define SET_FIELD_WITH_STAT(stat_offset, stat)                               \
90
  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
91
                   static_cast<NativeT>(stat))
92
93
#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                          \
94
  /* NOLINTNEXTLINE(runtime/int) */                                          \
95
  SET_FIELD_WITH_STAT(stat_offset, static_cast<unsigned long>(stat))
96
97
144764
  SET_FIELD_WITH_STAT(kDev, s->st_dev);
98
144769
  SET_FIELD_WITH_STAT(kMode, s->st_mode);
99
144769
  SET_FIELD_WITH_STAT(kNlink, s->st_nlink);
100
144769
  SET_FIELD_WITH_STAT(kUid, s->st_uid);
101
144768
  SET_FIELD_WITH_STAT(kGid, s->st_gid);
102
144768
  SET_FIELD_WITH_STAT(kRdev, s->st_rdev);
103
144769
  SET_FIELD_WITH_STAT(kBlkSize, s->st_blksize);
104
144769
  SET_FIELD_WITH_STAT(kIno, s->st_ino);
105
144769
  SET_FIELD_WITH_STAT(kSize, s->st_size);
106
144769
  SET_FIELD_WITH_STAT(kBlocks, s->st_blocks);
107
108
144769
  SET_FIELD_WITH_TIME_STAT(kATimeSec, s->st_atim.tv_sec);
109
144769
  SET_FIELD_WITH_TIME_STAT(kATimeNsec, s->st_atim.tv_nsec);
110
144768
  SET_FIELD_WITH_TIME_STAT(kMTimeSec, s->st_mtim.tv_sec);
111
144768
  SET_FIELD_WITH_TIME_STAT(kMTimeNsec, s->st_mtim.tv_nsec);
112
144769
  SET_FIELD_WITH_TIME_STAT(kCTimeSec, s->st_ctim.tv_sec);
113
144769
  SET_FIELD_WITH_TIME_STAT(kCTimeNsec, s->st_ctim.tv_nsec);
114
144769
  SET_FIELD_WITH_TIME_STAT(kBirthTimeSec, s->st_birthtim.tv_sec);
115
144768
  SET_FIELD_WITH_TIME_STAT(kBirthTimeNsec, s->st_birthtim.tv_nsec);
116
117
#undef SET_FIELD_WITH_TIME_STAT
118
#undef SET_FIELD_WITH_STAT
119
144769
}
120
121
144427
v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
122
                                          const bool use_bigint,
123
                                          const uv_stat_t* s,
124
                                          const bool second) {
125
  const ptrdiff_t offset =
126
144427
      second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
127
144427
  if (use_bigint) {
128
91315
    auto* const arr = &binding_data->stats_field_bigint_array;
129
91315
    FillStatsArray(arr, s, offset);
130
182630
    return arr->GetJSArray();
131
  } else {
132
53112
    auto* const arr = &binding_data->stats_field_array;
133
53112
    FillStatsArray(arr, s, offset);
134
106225
    return arr->GetJSArray();
135
  }
136
}
137
138
template <typename AliasedBufferT>
139
FSReqPromise<AliasedBufferT>*
140
1315
FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
141
                                  bool use_bigint) {
142
1315
  Environment* env = binding_data->env();
143
  v8::Local<v8::Object> obj;
144

3945
  if (!env->fsreqpromise_constructor_template()
145
3945
           ->NewInstance(env->context())
146
1315
           .ToLocal(&obj)) {
147
    return nullptr;
148
  }
149
  v8::Local<v8::Promise::Resolver> resolver;
150



5260
  if (!v8::Promise::Resolver::New(env->context()).ToLocal(&resolver) ||
151
6575
      obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
152
    return nullptr;
153
  }
154
1315
  return new FSReqPromise(binding_data, obj, use_bigint);
155
}
156
157
template <typename AliasedBufferT>
158
2630
FSReqPromise<AliasedBufferT>::~FSReqPromise() {
159
  // Validate that the promise was explicitly resolved or rejected.
160

1315
  CHECK(finished_);
161
3945
}
162
163
template <typename AliasedBufferT>
164
1315
FSReqPromise<AliasedBufferT>::FSReqPromise(
165
    BindingData* binding_data,
166
    v8::Local<v8::Object> obj,
167
    bool use_bigint)
168
  : FSReqBase(binding_data,
169
              obj,
170
              AsyncWrap::PROVIDER_FSREQPROMISE,
171
              use_bigint),
172
    stats_field_array_(
173
        env()->isolate(),
174
1315
        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
175
176
template <typename AliasedBufferT>
177
48
void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
178
48
  finished_ = true;
179
96
  v8::HandleScope scope(env()->isolate());
180
96
  InternalCallbackScope callback_scope(this);
181
  v8::Local<v8::Value> value =
182
96
      object()->Get(env()->context(),
183
240
                    env()->promise_string()).ToLocalChecked();
184
48
  v8::Local<v8::Promise::Resolver> resolver = value.As<v8::Promise::Resolver>();
185
144
  USE(resolver->Reject(env()->context(), reject).FromJust());
186
48
}
187
188
template <typename AliasedBufferT>
189
1267
void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {
190
1267
  finished_ = true;
191
2534
  v8::HandleScope scope(env()->isolate());
192
2534
  InternalCallbackScope callback_scope(this);
193
  v8::Local<v8::Value> val =
194
2534
      object()->Get(env()->context(),
195
6335
                    env()->promise_string()).ToLocalChecked();
196
1267
  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
197
3801
  USE(resolver->Resolve(env()->context(), value).FromJust());
198
1267
}
199
200
template <typename AliasedBufferT>
201
341
void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
202
341
  FillStatsArray(&stats_field_array_, stat);
203
682
  Resolve(stats_field_array_.GetJSArray());
204
341
}
205
206
template <typename AliasedBufferT>
207
1315
void FSReqPromise<AliasedBufferT>::SetReturnValue(
208
    const v8::FunctionCallbackInfo<v8::Value>& args) {
209
  v8::Local<v8::Value> val =
210
2630
      object()->Get(env()->context(),
211
6575
                    env()->promise_string()).ToLocalChecked();
212
1315
  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
213
3945
  args.GetReturnValue().Set(resolver->GetPromise());
214
1315
}
215
216
template <typename AliasedBufferT>
217
1
void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
218
1
  FSReqBase::MemoryInfo(tracker);
219
1
  tracker->TrackField("stats_field_array", stats_field_array_);
220
1
}
221
222
366187
FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
223
                      int index,
224
                      bool use_bigint) {
225
366187
  v8::Local<v8::Value> value = args[index];
226
366187
  if (value->IsObject()) {
227
49183
    return Unwrap<FSReqBase>(value.As<v8::Object>());
228
  }
229
230
317003
  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
231
317004
  Environment* env = binding_data->env();
232
634007
  if (value->StrictEquals(env->fs_use_promises_symbol())) {
233
1315
    if (use_bigint) {
234
3
      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
235
    } else {
236
1312
      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
237
    }
238
  }
239
315685
  return nullptr;
240
}
241
242
// Returns nullptr if the operation fails from the start.
243
template <typename Func, typename... Args>
244
50391
FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,
245
                         const v8::FunctionCallbackInfo<v8::Value>& args,
246
                         const char* syscall, const char* dest,
247
                         size_t len, enum encoding enc, uv_fs_cb after,
248
                         Func fn, Args... fn_args) {
249







50391
  CHECK_NOT_NULL(req_wrap);
250
50391
  req_wrap->Init(syscall, dest, len, enc);
251
50391
  int err = req_wrap->Dispatch(fn, fn_args..., after);
252







50391
  if (err < 0) {
253
    uv_fs_t* uv_req = req_wrap->req();
254
    uv_req->result = err;
255
    uv_req->path = nullptr;
256
    after(uv_req);  // after may delete req_wrap if there is an error
257
    req_wrap = nullptr;
258
  } else {
259
50391
    req_wrap->SetReturnValue(args);
260
  }
261
262
50391
  return req_wrap;
263
}
264
265
// Returns nullptr if the operation fails from the start.
266
template <typename Func, typename... Args>
267
50141
FSReqBase* AsyncCall(Environment* env,
268
                     FSReqBase* req_wrap,
269
                     const v8::FunctionCallbackInfo<v8::Value>& args,
270
                     const char* syscall, enum encoding enc,
271
                     uv_fs_cb after, Func fn, Args... fn_args) {
272
  return AsyncDestCall(env, req_wrap, args,
273
                       syscall, nullptr, 0, enc,
274
50141
                       after, fn, fn_args...);
275
}
276
277
// Template counterpart of SYNC_CALL, except that it only puts
278
// the error number and the syscall in the context instead of
279
// creating an error in the C++ land.
280
// ctx must be checked using value->IsObject() before being passed.
281
template <typename Func, typename... Args>
282
315574
int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
283
             FSReqWrapSync* req_wrap, const char* syscall,
284
             Func fn, Args... args) {
285
315574
  env->PrintSyncTrace();
286
315579
  int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);
287







315571
  if (err < 0) {
288
1347
    v8::Local<v8::Context> context = env->context();
289
1347
    v8::Local<v8::Object> ctx_obj = ctx.As<v8::Object>();
290
1347
    v8::Isolate* isolate = env->isolate();
291
5388
    ctx_obj->Set(context,
292
                 env->errno_string(),
293
                 v8::Integer::New(isolate, err)).Check();
294
5388
    ctx_obj->Set(context,
295
                 env->syscall_string(),
296
                 OneByteString(isolate, syscall)).Check();
297
  }
298
315571
  return err;
299
}
300
301
}  // namespace fs
302
}  // namespace node
303
304
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
305
306
#endif  // SRC_NODE_FILE_INL_H_