1 /**
2  * Copyright 2017 Google Inc.
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 #include <iostream>
18 #include <map>
19 #include <string>
20 
21 /* Configuration. */
22 #include "conf.hpp"
23 #include "dbus/dbuspassive.hpp"
24 #include "dbus/dbuswrite.hpp"
25 #include "errors/exception.hpp"
26 #include "interfaces.hpp"
27 #include "notimpl/readonly.hpp"
28 #include "notimpl/writeonly.hpp"
29 #include "sensors/builder.hpp"
30 #include "sensors/host.hpp"
31 #include "sensors/manager.hpp"
32 #include "sensors/pluggable.hpp"
33 #include "sysfs/sysfsread.hpp"
34 #include "sysfs/sysfswrite.hpp"
35 #include "util.hpp"
36 
37 static constexpr bool deferSignals = true;
38 static DbusHelper helper;
39 
40 SensorManager
41     buildSensors(const std::map<std::string, struct SensorConfig>& config)
42 {
43     SensorManager mgmr;
44     auto& hostSensorBus = mgmr.getHostBus();
45     auto& passiveListeningBus = mgmr.getPassiveBus();
46 
47     for (const auto& it : config)
48     {
49         std::unique_ptr<ReadInterface> ri;
50         std::unique_ptr<WriteInterface> wi;
51 
52         std::string name = it.first;
53         const struct SensorConfig* info = &it.second;
54 
55         std::cerr << "Sensor: " << name << " " << info->type << " ";
56         std::cerr << info->readpath << " " << info->writepath << "\n";
57 
58         IOInterfaceType rtype = getReadInterfaceType(info->readpath);
59         IOInterfaceType wtype = getWriteInterfaceType(info->writepath);
60 
61         // fan sensors can be ready any way and written others.
62         // fan sensors are the only sensors this is designed to write.
63         // Nothing here should be write-only, although, in theory a fan could
64         // be. I'm just not sure how that would fit together.
65         // TODO(venture): It should check with the ObjectMapper to check if
66         // that sensor exists on the Dbus.
67         switch (rtype)
68         {
69             case IOInterfaceType::DBUSPASSIVE:
70                 ri = DbusPassive::createDbusPassive(passiveListeningBus,
71                                                     info->type, name, &helper);
72                 if (ri == nullptr)
73                 {
74                     throw SensorBuildException(
75                         "Failed to create dbus passive sensor: " + name +
76                         " of type: " + info->type);
77                 }
78                 break;
79             case IOInterfaceType::EXTERNAL:
80                 // These are a special case for read-only.
81                 break;
82             case IOInterfaceType::SYSFS:
83                 ri = std::make_unique<SysFsRead>(info->readpath);
84                 break;
85             default:
86                 ri = std::make_unique<WriteOnly>();
87                 break;
88         }
89 
90         if (info->type == "fan")
91         {
92             switch (wtype)
93             {
94                 case IOInterfaceType::SYSFS:
95                     if (info->max > 0)
96                     {
97                         wi = std::make_unique<SysFsWritePercent>(
98                             info->writepath, info->min, info->max);
99                     }
100                     else
101                     {
102                         wi = std::make_unique<SysFsWrite>(info->writepath,
103                                                           info->min, info->max);
104                     }
105 
106                     break;
107                 case IOInterfaceType::DBUSACTIVE:
108                     if (info->max > 0)
109                     {
110                         wi = DbusWritePercent::createDbusWrite(
111                             info->writepath, info->min, info->max, helper);
112                     }
113                     else
114                     {
115                         wi = DbusWrite::createDbusWrite(
116                             info->writepath, info->min, info->max, helper);
117                     }
118 
119                     if (wi == nullptr)
120                     {
121                         throw SensorBuildException(
122                             "Unable to create write dbus interface for path: " +
123                             info->writepath);
124                     }
125 
126                     break;
127                 default:
128                     wi = std::make_unique<ReadOnlyNoExcept>();
129                     break;
130             }
131 
132             auto sensor = std::make_unique<PluggableSensor>(
133                 name, info->timeout, std::move(ri), std::move(wi));
134             mgmr.addSensor(info->type, name, std::move(sensor));
135         }
136         else if (info->type == "temp" || info->type == "margin")
137         {
138             // These sensors are read-only, but only for this application
139             // which only writes to fan sensors.
140             std::cerr << info->type << " readpath: " << info->readpath << "\n";
141 
142             if (IOInterfaceType::EXTERNAL == rtype)
143             {
144                 std::cerr << "Creating HostSensor: " << name
145                           << " path: " << info->readpath << "\n";
146 
147                 /*
148                  * The reason we handle this as a HostSensor is because it's
149                  * not quite pluggable; but maybe it could be.
150                  */
151                 auto sensor = HostSensor::createTemp(
152                     name, info->timeout, hostSensorBus, info->readpath.c_str(),
153                     deferSignals);
154                 mgmr.addSensor(info->type, name, std::move(sensor));
155             }
156             else
157             {
158                 wi = std::make_unique<ReadOnlyNoExcept>();
159                 auto sensor = std::make_unique<PluggableSensor>(
160                     name, info->timeout, std::move(ri), std::move(wi));
161                 mgmr.addSensor(info->type, name, std::move(sensor));
162             }
163         }
164     }
165 
166     return mgmr;
167 }
168