blob: c9f656608f82bdd21f2e8d59539e36065bcab517 (
plain)
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
#pragma once
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <experimental/filesystem>
#include <unistd.h>
#include <sdbusplus/bus.hpp>
#include <functional>
#include <sdbusplus/server/object.hpp>
#include <org/open_power/OCC/PassThrough/server.hpp>
#include "config.h"
#include "file.hpp"
namespace sdbusRule = sdbusplus::bus::match::rules;
namespace open_power
{
namespace occ
{
namespace pass_through
{
class PassThrough;
namespace manager
{
/** @class Manager
* @brief Builds and manages OCC pass-through objects
*/
struct Manager
{
public:
Manager() = delete;
Manager(const Manager&) = delete;
Manager& operator=(const Manager&) = delete;
Manager(Manager&&) = default;
Manager& operator=(Manager&&) = default;
~Manager() = default;
/** @brief Ctor - Add OCC pass-through objects on the bus. Create
* OCC objects when corresponding CPU inventory is created.
* @param[in] bus - handle to the bus
*/
Manager(sdbusplus::bus::bus& bus):
bus(bus)
{
for (auto id = 0; id < MAX_CPUS; ++id)
{
auto path = std::string(CPU_PATH) + std::to_string(id);
cpuMatches.emplace_back(
bus,
sdbusRule::interfacesAdded() +
sdbusRule::argNpath(0, path),
std::bind(std::mem_fn(&Manager::cpuCreated),
this, std::placeholders::_1));
}
}
/** @brief Callback that responds to cpu creation in the inventory -
* by creating the occ passthrough object.
*
* @param[in] msg - bus message
*
* @returns 0 to indicate success
*/
int cpuCreated(sdbusplus::message::message& msg)
{
namespace fs = std::experimental::filesystem;
sdbusplus::message::object_path o;
msg.read(o);
fs::path cpuPath(std::string(std::move(o)));
auto cpu = cpuPath.filename();
auto occPath = fs::path(OCC_PASS_THROUGH_ROOT);
std::string name{cpu.c_str()};
auto index = name.find(CPU_NAME);
name.replace(index, std::strlen(CPU_NAME), OCC_NAME);
occPath /= name;
objects.emplace_back(
std::make_unique<PassThrough>(
bus,
occPath.c_str()));
return 0;
}
private:
/** @brief reference to the bus */
sdbusplus::bus::bus& bus;
/** @brief OCC pass-through objects */
std::vector<std::unique_ptr<PassThrough>> objects;
/** @brief sbdbusplus match objects */
std::vector<sdbusplus::bus::match_t> cpuMatches;
};
} // namespace manager
using Iface = sdbusplus::server::object::object<
sdbusplus::org::open_power::OCC::server::PassThrough>;
/** @class PassThrough
* @brief Implements org.open_power.OCC.PassThrough
*/
class PassThrough : public Iface
{
public:
PassThrough() = delete;
~PassThrough() = default;
PassThrough(const PassThrough&) = delete;
PassThrough& operator=(const PassThrough&) = delete;
PassThrough(PassThrough&&) = default;
PassThrough& operator=(PassThrough&&) = default;
/** @brief Ctor to put pass-through d-bus object on the bus
* @param[in] bus - Bus to attach to
* @param[in] path - Path to attach at
*/
PassThrough(sdbusplus::bus::bus& bus,
const char* path);
/** @brief Pass through command to OCC
* @param[in] command - command to pass-through
* @returns OCC response as an array
*/
std::vector<std::int32_t>
send(std::vector<std::int32_t> command) override;
private:
/** @brief Pass-through occ path on the bus */
std::string path;
/** @brief OCC device path
* For now, here is the hard-coded mapping until
* the udev rule is in.
* occ0 --> /dev/occfifo1
* occ1 --> /dev/occfifo2
* ...
*/
std::string devicePath = "/dev/occ";
/** @brief File descriptor manager */
FileDescriptor fd;
/** Opens devicePath and returns file descritor */
int openDevice();
};
} // namespace pass_through
} // namespace occ
} // namespace open_power
|
