blob: baeb8c7ea808c0b67cab0032a8b52b8844908a61 [file] [log] [blame]
AppaRao Puli071f3f22018-05-24 16:45:30 +05301/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16
17#pragma once
18#include "channel_layer.hpp"
19
20#include <boost/interprocess/sync/file_lock.hpp>
21#include <boost/interprocess/sync/named_recursive_mutex.hpp>
22#include <cstdint>
23#include <ctime>
24#include <nlohmann/json.hpp>
25#include <sdbusplus/bus.hpp>
26
27namespace ipmi
28{
29
30using Json = nlohmann::json;
31
AppaRao Puli9613ed72018-09-01 23:46:44 +053032using DbusVariant =
33 sdbusplus::message::variant<std::vector<std::string>, std::string, bool>;
34
35using DbusChObjProperties = std::vector<std::pair<std::string, DbusVariant>>;
36
AppaRao Puli071f3f22018-05-24 16:45:30 +053037static constexpr const char* ipmiChannelMutex = "ipmi_channel_mutex";
38static constexpr const char* ipmiChMutexCleanupLockFile =
39 "/var/lib/ipmi/ipmi_channel_mutex_cleanup";
40
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053041/** @struct ChannelAccessData
42 *
43 * Structure to store both non-volatile and volatile channel access information
44 * as used by IPMI specification (refer spec sec 22.22 to 22.24)
45 */
AppaRao Puli071f3f22018-05-24 16:45:30 +053046struct ChannelAccessData
47{
48 ChannelAccess chNonVolatileData;
49 ChannelAccess chVolatileData;
50};
51
Johnathan Mantey4c0435a2018-12-11 13:17:55 -080052/** @struct ChannelProperties
Richard Marian Thomaiyar6e1ba9e2018-11-29 06:29:21 +053053 *
54 * Structure for channel information - base structure to get all information
55 * about the channel.(refer spec sec 22.22 to 22.24)
56 */
Johnathan Mantey4c0435a2018-12-11 13:17:55 -080057struct ChannelProperties
AppaRao Puli071f3f22018-05-24 16:45:30 +053058{
59 std::string chName;
60 uint8_t chID;
61 bool isChValid;
62 uint8_t activeSessCount;
63 ChannelInfo chInfo;
64 ChannelAccessData chAccess;
Vernon Mauery58317122018-11-28 11:02:43 -080065 size_t maxTransferSize;
AppaRao Puli071f3f22018-05-24 16:45:30 +053066};
67
68class ChannelConfig;
69
70ChannelConfig& getChannelConfigObject();
71
72class ChannelConfig
73{
74 public:
75 ChannelConfig(const ChannelConfig&) = delete;
76 ChannelConfig& operator=(const ChannelConfig&) = delete;
77 ChannelConfig(ChannelConfig&&) = delete;
78 ChannelConfig& operator=(ChannelConfig&&) = delete;
79
AppaRao Puli9613ed72018-09-01 23:46:44 +053080 ~ChannelConfig();
AppaRao Puli071f3f22018-05-24 16:45:30 +053081 ChannelConfig();
82
83 /** @brief determines valid channel
84 *
85 * @param[in] chNum - channel number
86 *
87 * @return true if valid, false otherwise
88 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +053089 bool isValidChannel(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +053090
91 /** @brief determines valid authentication type
92 *
93 * @param[in] chNum - channel number
94 * @param[in] authType - authentication type
95 *
96 * @return true if valid, false otherwise
97 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +053098 bool isValidAuthType(const uint8_t chNum, const EAuthType& authType);
AppaRao Puli071f3f22018-05-24 16:45:30 +053099
Richard Marian Thomaiyar73906b92019-01-04 23:48:02 +0530100 /** @brief function to get channel name from channel number
101 *
102 * @param[in] chNum - channel number index
103 *
104 * @return network channel interface name
105 */
106 std::string getChannelName(const uint8_t chNum);
107
Vernon Mauery735ee952019-02-15 13:38:52 -0800108 /** @brief function to get channel number from channel name
109 *
110 * @param[in] chName - channel name
111 *
112 * @return network channel interface number
113 */
114
115 uint8_t getChannelByName(const std::string& chName)
116 {
117 return convertToChannelNumberFromChannelName(chName);
118 }
119
AppaRao Puli071f3f22018-05-24 16:45:30 +0530120 /** @brief determines supported session type of a channel
121 *
122 * @param[in] chNum - channel number
123 *
124 * @return EChannelSessSupported - supported session type
125 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530126 EChannelSessSupported getChannelSessionSupport(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530127
128 /** @brief determines number of active sessions on a channel
129 *
130 * @param[in] chNum - channel number
131 *
132 * @return numer of active sessions
133 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530134 int getChannelActiveSessions(const uint8_t chNum);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530135
Vernon Mauery58317122018-11-28 11:02:43 -0800136 /** @brief determines maximum transfer size for a channel
137 *
138 * @param[in] chNum - channel number
139 *
140 * @return maximum bytes that can be transferred on this channel
141 */
142 size_t getChannelMaxTransferSize(uint8_t chNum);
143
AppaRao Puli071f3f22018-05-24 16:45:30 +0530144 /** @brief provides channel info details
145 *
146 * @param[in] chNum - channel number
147 * @param[out] chInfo - channel info details
148 *
149 * @return IPMI_CC_OK for success, others for failure.
150 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530151 ipmi_ret_t getChannelInfo(const uint8_t chNum, ChannelInfo& chInfo);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530152
153 /** @brief provides channel access data
154 *
155 * @param[in] chNum - channel number
156 * @param[out] chAccessData - channel access data
157 *
158 * @return IPMI_CC_OK for success, others for failure.
159 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530160 ipmi_ret_t getChannelAccessData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530161 ChannelAccess& chAccessData);
162
163 /** @brief to set channel access data
164 *
165 * @param[in] chNum - channel number
166 * @param[in] chAccessData - channel access data
167 * @param[in] setFlag - flag to indicate updatable fields
168 *
169 * @return IPMI_CC_OK for success, others for failure.
170 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530171 ipmi_ret_t setChannelAccessData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530172 const ChannelAccess& chAccessData,
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530173 const uint8_t setFlag);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530174
175 /** @brief to get channel access data persistent data
176 *
177 * @param[in] chNum - channel number
178 * @param[out] chAccessData - channel access data
179 *
180 * @return IPMI_CC_OK for success, others for failure.
181 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530182 ipmi_ret_t getChannelAccessPersistData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530183 ChannelAccess& chAccessData);
184
185 /** @brief to set channel access data persistent data
186 *
187 * @param[in] chNum - channel number
188 * @param[in] chAccessData - channel access data
189 * @param[in] setFlag - flag to indicate updatable fields
190 *
191 * @return IPMI_CC_OK for success, others for failure.
192 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530193 ipmi_ret_t setChannelAccessPersistData(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530194 const ChannelAccess& chAccessData,
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530195 const uint8_t setFlag);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530196
197 /** @brief provides supported authentication type for the channel
198 *
199 * @param[in] chNum - channel number
200 * @param[out] authTypeSupported - supported authentication type
201 *
202 * @return IPMI_CC_OK for success, others for failure.
203 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530204 ipmi_ret_t getChannelAuthTypeSupported(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530205 uint8_t& authTypeSupported);
206
207 /** @brief provides enabled authentication type for the channel
208 *
209 * @param[in] chNum - channel number
210 * @param[in] priv - privilege
211 * @param[out] authType - enabled authentication type
212 *
213 * @return IPMI_CC_OK for success, others for failure.
214 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530215 ipmi_ret_t getChannelEnabledAuthType(const uint8_t chNum,
216 const uint8_t priv,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530217 EAuthType& authType);
218
AppaRao Puli9613ed72018-09-01 23:46:44 +0530219 /** @brief conver to channel privilege from system privilege
220 *
221 * @param[in] value - privilege value
222 *
223 * @return Channel privilege
224 */
225 CommandPrivilege convertToPrivLimitIndex(const std::string& value);
226
Richard Marian Thomaiyara39208e2018-12-08 17:27:11 +0530227 /** @brief function to convert channel number to channel index
228 *
229 * @param[in] chNum - channel number
230 *
231 * @return channel index
232 */
233 uint8_t convertToChannelIndexNumber(const uint8_t chNum);
234
AppaRao Puli9613ed72018-09-01 23:46:44 +0530235 /** @brief function to write persistent channel configuration to config file
236 *
237 * @return 0 for success, -errno for failure.
238 */
239 int writeChannelPersistData();
240
241 /** @brief function to write volatile channel configuration to config file
242 *
243 * @return 0 for success, -errno for failure.
244 */
245 int writeChannelVolatileData();
246
Johnathan Mantey2dfe7f82018-12-11 13:53:33 -0800247 private:
AppaRao Puli9613ed72018-09-01 23:46:44 +0530248 uint32_t signalFlag = 0;
AppaRao Puli071f3f22018-05-24 16:45:30 +0530249 std::unique_ptr<boost::interprocess::named_recursive_mutex> channelMutex{
250 nullptr};
Johnathan Mantey4c0435a2018-12-11 13:17:55 -0800251 std::array<ChannelProperties, maxIpmiChannels> channelData;
AppaRao Puli071f3f22018-05-24 16:45:30 +0530252 std::time_t nvFileLastUpdatedTime;
253 std::time_t voltFileLastUpdatedTime;
AppaRao Puli071f3f22018-05-24 16:45:30 +0530254 boost::interprocess::file_lock mutexCleanupLock;
255 sdbusplus::bus::bus bus;
AppaRao Puli9613ed72018-09-01 23:46:44 +0530256 bool signalHndlrObjectState = false;
257 boost::interprocess::file_lock sigHndlrLock;
AppaRao Puli071f3f22018-05-24 16:45:30 +0530258
259 /** @brief function to initialize persistent channel configuration
260 *
261 */
262 void initChannelPersistData();
263
264 /** @brief function to set default channel configuration based on channel
265 * number
266 *
267 * @param[in] chNum - channel number
268 * @param[in] chName - channel name
269 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530270 void setDefaultChannelConfig(const uint8_t chNum,
AppaRao Puli071f3f22018-05-24 16:45:30 +0530271 const std::string& chName);
272
273 /** @brief function to load all channel configuration
274 *
275 * @return 0 for success, -errno for failure.
276 */
277 int loadChannelConfig();
278
279 /** @brief function to read persistent channel data
280 *
281 * @return 0 for success, -errno for failure.
282 */
283 int readChannelPersistData();
284
AppaRao Puli071f3f22018-05-24 16:45:30 +0530285 /** @brief function to read volatile channel data
286 *
287 * @return 0 for success, -errno for failure.
288 */
289 int readChannelVolatileData();
290
AppaRao Puli071f3f22018-05-24 16:45:30 +0530291 /** @brief function to check and reload persistent channel data
292 *
293 * @return 0 for success, -errno for failure.
294 */
295 int checkAndReloadNVData();
296
297 /** @brief function to check and reload volatile channel data
298 *
299 * @return 0 for success, -errno for failure.
300 */
301 int checkAndReloadVolatileData();
302
AppaRao Puli9613ed72018-09-01 23:46:44 +0530303 /** @brief function to sync channel privilege with system network channel
304 * privilege
305 *
306 * @return 0 for success, -errno for failure.
307 */
308 int syncNetworkChannelConfig();
309
310 /** @brief function to set D-Bus property value
311 *
AppaRao Puli9613ed72018-09-01 23:46:44 +0530312 * @param[in] service - service name
313 * @param[in] objPath - object path
314 * @param[in] interface - interface
315 * @param[in] property - property name
316 * @param[in] value - property value
317 *
318 * @return 0 for success, -errno for failure.
319 */
Johnathan Manteyf92261d2018-12-10 15:49:34 -0800320 int setDbusProperty(const std::string& service, const std::string& objPath,
AppaRao Puli9613ed72018-09-01 23:46:44 +0530321 const std::string& interface,
322 const std::string& property, const DbusVariant& value);
323
324 /** @brief function to get D-Bus property value
325 *
AppaRao Puli9613ed72018-09-01 23:46:44 +0530326 * @param[in] service - service name
327 * @param[in] objPath - object path
328 * @param[in] interface - interface
329 * @param[in] property - property name
330 * @param[out] value - property value
331 *
332 * @return 0 for success, -errno for failure.
333 */
Johnathan Manteyf92261d2018-12-10 15:49:34 -0800334 int getDbusProperty(const std::string& service, const std::string& objPath,
AppaRao Puli9613ed72018-09-01 23:46:44 +0530335 const std::string& interface,
336 const std::string& property, DbusVariant& value);
337
AppaRao Puli071f3f22018-05-24 16:45:30 +0530338 /** @brief function to read json config file
339 *
340 * @param[in] configFile - configuration file name
341 *
342 * @return Json object
343 */
344 Json readJsonFile(const std::string& configFile);
345
346 /** @brief function to write json config file
347 *
348 * @param[in] configFile - configuration file name
349 * @param[in] jsonData - json object
350 *
351 * @return 0 for success, -errno for failure.
352 */
353 int writeJsonFile(const std::string& configFile, const Json& jsonData);
354
355 /** @brief function to convert system access mode to Channel access mode
356 * type
357 *
358 * @param[in] mode - access mode in string
359 *
360 * @return Channel access mode.
361 */
362 EChannelAccessMode convertToAccessModeIndex(const std::string& mode);
363
364 /** @brief function to convert access mode value to string
365 *
366 * @param[in] value - acess mode value
367 *
368 * @return access mode in string
369 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530370 std::string convertToAccessModeString(const uint8_t value);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530371
AppaRao Puli071f3f22018-05-24 16:45:30 +0530372 /** @brief function to convert privilege value to string
373 *
374 * @param[in] value - privilege value
375 *
376 * @return privilege in string
377 */
Richard Marian Thomaiyara45cb342018-12-03 15:08:59 +0530378 std::string convertToPrivLimitString(const uint8_t value);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530379
380 /** @brief function to convert session support string to value type
381 *
382 * @param[in] value - session support type in string
383 *
384 * @return support session type
385 */
386 EChannelSessSupported
387 convertToSessionSupportIndex(const std::string& value);
388
389 /** @brief function to convert medium type string to value type
390 *
391 * @param[in] value - medium type in string
392 *
393 * @return channel medium type
394 */
395 EChannelMediumType convertToMediumTypeIndex(const std::string& value);
396
397 /** @brief function to convert protocol type string to value type
398 *
399 * @param[in] value - protocol type in string
400 *
401 * @return channel protocol type
402 */
403 EChannelProtocolType convertToProtocolTypeIndex(const std::string& value);
Johnathan Manteye5c4f1d2018-12-10 16:24:26 -0800404
Johnathan Mantey74a21022018-12-13 13:17:56 -0800405 /** @brief function to convert channel name to the IPMI channel number.
Johnathan Manteye5c4f1d2018-12-10 16:24:26 -0800406 *
Johnathan Mantey74a21022018-12-13 13:17:56 -0800407 * @param[in] chName - the channel name defined in the JSON input file
408 * (i.e. LAN1)
Johnathan Manteye5c4f1d2018-12-10 16:24:26 -0800409 *
Johnathan Mantey74a21022018-12-13 13:17:56 -0800410 * @return IPMI channel number
Johnathan Manteye5c4f1d2018-12-10 16:24:26 -0800411 */
Johnathan Mantey74a21022018-12-13 13:17:56 -0800412 int convertToChannelNumberFromChannelName(const std::string& chName);
Johnathan Manteye5c4f1d2018-12-10 16:24:26 -0800413
414 /** @brief function to handle Channel access property update through the
415 * D-Bus handler.
416 *
417 * @param[in] path - D-Bus path to the network element (i.e. eth0)
418 * @param[in] chProperties - D-Bus channel properties
419 */
420 void processChAccessPropChange(const std::string& path,
421 const DbusChObjProperties& chProperties);
Johnathan Mantey2dfe7f82018-12-11 13:53:33 -0800422
423 /** @brief function to retrieve last modification time for the named file
424 *
425 * @param[in] fileName - the name of the file for which to acquire
426 * timestamp data
427 *
428 * @return time the file was last modified
429 */
430 std::time_t getUpdatedFileTime(const std::string& fileName);
Johnathan Mantey74a21022018-12-13 13:17:56 -0800431
432 /** @brief function to convert the DBus path to a network channel name
433 *
434 * @param[in] path - The DBus path to the device
435 *
436 * @return network channel name (i.e. eth0)
437 */
438 std::string getChannelNameFromPath(const std::string& path);
AppaRao Puli071f3f22018-05-24 16:45:30 +0530439};
440
441} // namespace ipmi