forked from openbmc/phosphor-debug-collector
-
Notifications
You must be signed in to change notification settings - Fork 0
/
watch.cpp
128 lines (105 loc) · 3.02 KB
/
watch.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "watch.hpp"
#include "xyz/openbmc_project/Common/error.hpp"
#include <phosphor-logging/elog-errors.hpp>
namespace phosphor
{
namespace dump
{
namespace inotify
{
using namespace std::string_literals;
using namespace phosphor::logging;
using namespace sdbusplus::xyz::openbmc_project::Common::Error;
Watch::~Watch()
{
if ((fd() >= 0) && (wd >= 0))
{
inotify_rm_watch(fd(), wd);
}
}
Watch::Watch(const EventPtr& eventObj, const int flags, const uint32_t mask,
const uint32_t events, const fs::path& path, UserType userFunc) :
flags(flags),
mask(mask), events(events), path(path), fd(inotifyInit()),
userFunc(userFunc)
{
// Check if watch DIR exists.
if (!fs::is_directory(path))
{
log<level::ERR>("Watch directory doesn't exist",
entry("DIR=%s", path.c_str()));
elog<InternalFailure>();
}
wd = inotify_add_watch(fd(), path.c_str(), mask);
if (-1 == wd)
{
auto error = errno;
log<level::ERR>("Error occurred during the inotify_add_watch call",
entry("ERRNO=%d", error));
elog<InternalFailure>();
}
auto rc =
sd_event_add_io(eventObj.get(), nullptr, fd(), events, callback, this);
if (0 > rc)
{
// Failed to add to event loop
log<level::ERR>("Error occurred during the sd_event_add_io call",
entry("RC=%d", rc));
elog<InternalFailure>();
}
}
int Watch::inotifyInit()
{
auto fd = inotify_init1(flags);
if (-1 == fd)
{
auto error = errno;
log<level::ERR>("Error occurred during the inotify_init1",
entry("ERRNO=%d", error));
elog<InternalFailure>();
}
return fd;
}
int Watch::callback(sd_event_source*, int fd, uint32_t revents, void* userdata)
{
auto userData = static_cast<Watch*>(userdata);
if (!(revents & userData->events))
{
return 0;
}
// Maximum inotify events supported in the buffer
constexpr auto maxBytes = sizeof(struct inotify_event) + NAME_MAX + 1;
uint8_t buffer[maxBytes];
auto bytes = read(fd, buffer, maxBytes);
if (0 > bytes)
{
// Failed to read inotify event
// Report error and return
auto error = errno;
log<level::ERR>("Error occurred during the read",
entry("ERRNO=%d", error));
report<InternalFailure>();
return 0;
}
auto offset = 0;
UserMap userMap;
while (offset < bytes)
{
auto event = reinterpret_cast<inotify_event*>(&buffer[offset]);
auto mask = event->mask & userData->mask;
if (mask)
{
userMap.emplace((userData->path / event->name), mask);
}
offset += offsetof(inotify_event, name) + event->len;
}
// Call user call back function in case valid data in the map
if (!userMap.empty())
{
userData->userFunc(userMap);
}
return 0;
}
} // namespace inotify
} // namespace dump
} // namespace phosphor