Device.cpp 9.95 KB
Newer Older
1
2
3
4
5
6
7
/*
 * @project        The CERN Tape Archive (CTA)
 * @copyright      Copyright(C) 2021 CERN
 * @license        This program is free software: you can redistribute it and/or modify
 *                 it under the terms of the GNU General Public License as published by
 *                 the Free Software Foundation, either version 3 of the License, or
 *                 (at your option) any later version.
8
 *
9
10
11
12
 *                 This program is distributed in the hope that it will be useful,
 *                 but WITHOUT ANY WARRANTY; without even the implied warranty of
 *                 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *                 GNU General Public License for more details.
13
 *
14
15
16
 *                 You should have received a copy of the GNU General Public License
 *                 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
17
18
19
20

#include <cstdlib>
#include <scsi/sg.h>

21
#include "Device.hpp"
22
#include "common/exception/Errnum.hpp"
23

24
25
using namespace castor::tape;

26
27
28
29
30
31
/**
 * Fill up the array that the device list is with all the system's
 * SCSI devices information.
 * 
 * (all code using templates must be in the header file)
 */
32
SCSI::DeviceVector::DeviceVector(System::virtualWrapper& sysWrapper) : m_sysWrapper(sysWrapper) {
33
  std::string sysDevsPath = "/sys/bus/scsi/devices";
Eric Cano's avatar
Eric Cano committed
34
  cta::utils::Regex ifFirstCharIsDigit("^[[:digit:]]");
35
  std::vector<std::string> checkResult;
36
  DIR* dirp;
37
  cta::exception::Errnum::throwOnNull(
38
39
      dirp = m_sysWrapper.opendir(sysDevsPath.c_str()),
      "Error opening sysfs scsi devs");
40
41
42
  while (struct dirent * dent = m_sysWrapper.readdir(dirp)) {
    std::string dn(dent->d_name);
    if ("." == dn || ".." == dn) continue;
43
44
    checkResult = ifFirstCharIsDigit.exec(dn);
    if (0 == checkResult.size()) continue; /* we only use digital names like 6:0:3:0 */
45
46
47
    std::string fullpath = sysDevsPath + "/" + std::string(dent->d_name);
    /* We expect only symbolic links in this directory, */
    char rp[PATH_MAX];
48
    cta::exception::Errnum::throwOnNull(
49
50
        m_sysWrapper.realpath(fullpath.c_str(), rp),
        "Could not find realpath for " + fullpath);
51
52
53
54
55
    this->push_back(getDeviceInfo(rp));
  }
  sysWrapper.closedir(dirp);
}

56
57
SCSI::DeviceInfo & SCSI::DeviceVector::findBySymlink(std::string path) {
  struct stat sbuff;
58
  cta::exception::Errnum::throwOnMinusOne(
59
60
61
62
63
64
65
66
67
68
69
      m_sysWrapper.stat(path.c_str(), &sbuff),
      std::string("Could not stat path: ")+path);
  for(std::vector<DeviceInfo>::iterator i = begin(); i!= end(); i++) {
    if (i->nst == sbuff || i->st == sbuff) {
      return *i;
    }
  }
  throw SCSI::DeviceVector::NotFound(
      std::string("Could not find tape device pointed to by ") + path);
}

70
std::string SCSI::DeviceVector::readfile(std::string path) {
71
  int fd;
72
  cta::exception::Errnum::throwOnMinusOne(
73
74
      fd = m_sysWrapper.open(path.c_str(), 0),
      std::string("Could not open file ") + path);
75
76
77
  char buf[readfileBlockSize];
  std::string ret;
  while (ssize_t sread = m_sysWrapper.read(fd, buf, readfileBlockSize)) {
78
    cta::exception::Errnum::throwOnMinusOne(sread,
79
      std::string("Could not read from open file ") + path);
80
81
    ret.append(buf, sread);
  }
82
  cta::exception::Errnum::throwOnNonZero(
83
84
      m_sysWrapper.close(fd),
      std::string("Error closing file ") + path);
85
86
87
88
89
90
  return ret;
}

SCSI::DeviceInfo::DeviceFile SCSI::DeviceVector::readDeviceFile(std::string path) {
  DeviceInfo::DeviceFile ret;
  std::string file = readfile(path);
91
  if (!::sscanf(file.c_str(), "%u:%u\n", &ret.major, &ret.minor))
92
    throw cta::exception::Exception(std::string("Could not parse file: ") + path);
93
94
95
96
97
  return ret;
}

SCSI::DeviceInfo::DeviceFile SCSI::DeviceVector::statDeviceFile(std::string path) {
  struct stat sbuf;
98
  cta::exception::Errnum::throwOnNonZero(
99
100
     m_sysWrapper.stat(path.c_str(), &sbuf),
     std::string("Could not stat file ") + path);
101
  if (!S_ISCHR(sbuf.st_mode))
102
    throw cta::exception::Exception("Device file " + path + " is not a character device");
103
104
105
106
107
108
109
110
111
112
113
114
115
  DeviceInfo::DeviceFile ret;
  ret.major = major(sbuf.st_rdev);
  ret.minor = minor(sbuf.st_rdev);
  return ret;
}

/**
 * Part factored out of getDeviceInfo: get the tape specifics
 * from sysfs.
 * @param devinfo
 */
void SCSI::DeviceVector::getTapeInfo(DeviceInfo & devinfo) {
  /* Find the st and nst devices for this SCSI device */
116
117
118
119
120
121
122
123
124
125
126
127
128
129
  DIR * dirp; 
  /* SLC6 default tapeDir and scsiPrefix */
  std::string tapeDir="/scsi_tape"; /* The name of the tape dir inside of
                                     * devinfo.sysfs_entry. /scsi_tape/ on SLC6.
                                     */
  std::string scsiPrefix="^";        /* The prefix for the name for the tape 
                                      * device name for the regexp.
                                      * scsi_tape: on SLC5.
                                      */ 
  /* we try to open /scsi_tape first for SLC6 */
  dirp = m_sysWrapper.opendir((devinfo.sysfs_entry+tapeDir).c_str());
  
  if (!dirp) {
    /* here we open sysfs_entry for SLC5 */
130
    cta::exception::Errnum::throwOnNull(
131
132
133
134
135
136
        dirp = m_sysWrapper.opendir(devinfo.sysfs_entry.c_str()),
        std::string("Error opening tape device directory ") +
            devinfo.sysfs_entry + tapeDir+" or "+devinfo.sysfs_entry);
    /* we are not on SLC6 */
    scsiPrefix="^scsi_tape:"; 
    tapeDir ="";
137
138
  } 
  
Eric Cano's avatar
Eric Cano committed
139
140
  cta::utils::Regex st_re((scsiPrefix+"(st[[:digit:]]+)$").c_str());
  cta::utils::Regex nst_re((scsiPrefix+"(nst[[:digit:]]+)$").c_str());
141
  
142
143
144
  while (struct dirent * dent = m_sysWrapper.readdir(dirp)) {
    std::vector<std::string> res;
    /* Check if it's the st information */
145
    res = st_re.exec(dent->d_name);
146
147
    if (res.size()) {
      if (!devinfo.st_dev.size()) {
148
        devinfo.st_dev = std::string("/dev/") + res[1];     
149
      } else
150
        throw cta::exception::Exception("Matched st device several times!");
151
      /* Read the major and major number */
152
      devinfo.st = readDeviceFile(devinfo.sysfs_entry + tapeDir+ "/"
153
154
155
156
157
158
159
160
161
162
          + std::string(dent->d_name) + "/dev");
      /* Check the actual device file */
      DeviceInfo::DeviceFile realFile = statDeviceFile(devinfo.st_dev);
      if (devinfo.st != realFile) {
        std::stringstream err;
        err << "Mismatch between sysfs info and actual device file: "
            << devinfo.sysfs_entry + "/" + dent->d_name << " indicates "
            << devinfo.st.major << ":" << devinfo.st.minor
            << " while " << devinfo.st_dev << " is: "
            << realFile.major << ":" << realFile.minor;
163
        throw cta::exception::Exception(err.str());
164
165
166
      }
    }
    /* Check if it's the nst information */
167
    res = nst_re.exec(dent->d_name);
168
169
170
171
    if (res.size()) {
      if (!devinfo.nst_dev.size()) {
        devinfo.nst_dev = std::string("/dev/") + res[1];
      } else
172
        throw cta::exception::Exception("Matched nst device several times!");
173
      /* Read the major and major number */
174
      devinfo.nst = readDeviceFile(devinfo.sysfs_entry + tapeDir + "/"
175
176
177
178
179
180
181
182
183
184
          + std::string(dent->d_name) + "/dev");
      /* Check the actual device file */
      DeviceInfo::DeviceFile realFile = statDeviceFile(devinfo.nst_dev);
      if (devinfo.nst != realFile) {
        std::stringstream err;
        err << "Mismatch between sysfs info and actual device file: "
            << devinfo.sysfs_entry + "/" + dent->d_name << " indicates "
            << devinfo.nst.major << ":" << devinfo.nst.minor
            << " while " << devinfo.st_dev << " is: "
            << realFile.major << ":" << realFile.minor;
185
        throw cta::exception::Exception(err.str());
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
      }
    }
  }
  m_sysWrapper.closedir(dirp);
}

/**
 * Extract information from sysfs about a SCSI device.
 * @param path Path to the directory with information about 
 * @return 
 */
SCSI::DeviceInfo SCSI::DeviceVector::getDeviceInfo(const char * path) {
  DeviceInfo ret;
  ret.sysfs_entry = path;
  std::string buf;
  /* Get device type */
  {
    buf = readfile(ret.sysfs_entry + "/type");
    if (!sscanf(buf.c_str(), "%d", &ret.type))
205
      throw cta::exception::Exception(std::string("Could not parse file: ") + ret.sysfs_entry + "/type");
206
  }
Eric Cano's avatar
Eric Cano committed
207
208
209
  /* Get vendor (trimmed of trailing newline, not of spaces) */
  {
    buf = readfile(ret.sysfs_entry + "/vendor");
210
    size_t endpos  = buf.find_first_of("\n ");
Eric Cano's avatar
Eric Cano committed
211
212
213
214
215
    ret.vendor = buf.substr(0, endpos);
  }
  /* Get model (trimmed of trailing newline, not of spaces) */
  {
    buf = readfile(ret.sysfs_entry + "/model");
216
    size_t endpos  = buf.find_first_of("\n ");
Eric Cano's avatar
Eric Cano committed
217
218
219
220
221
    ret.product = buf.substr(0, endpos);
  }
  /* Get revision (trimmed of trailing newline, not of spaces) */
  {
    buf = readfile(ret.sysfs_entry + "/rev");
222
    size_t endpos  = buf.find_first_of("\n ");
Eric Cano's avatar
Eric Cano committed
223
224
    ret.productRevisionLevel = buf.substr(0, endpos);
  }
225
226
227
228
  /* Get name of sg device */
  {
    char rl[PATH_MAX];
    std::string lp = ret.sysfs_entry + "/generic";
229
    ssize_t rlSize;
230
    cta::exception::Errnum::throwOnMinusOne(
231
232
        rlSize = m_sysWrapper.readlink(lp.c_str(), rl, sizeof (rl) - 1),
        std::string("Could not read link ") + lp);
233
    rl[rlSize] = '\0';
234
235
236
    std::string gl(rl);
    size_t pos = gl.find_last_of("/");
    if (pos == std::string::npos)
237
      throw cta::exception::Exception(std::string("Could not find last / in link: ") + gl +
238
239
240
241
242
243
244
245
246
247
248
249
250
251
        " read from " + ret.sysfs_entry + "/generic");
    ret.sg_dev = std::string("/dev/") + gl.substr(pos + 1);
  }
  /* Get the major and minor number of the device file */
  ret.sg = readDeviceFile(ret.sysfs_entry + "/generic/dev");
  /* Check that we have an agreement with the actual device file */
  DeviceInfo::DeviceFile realFile = statDeviceFile(ret.sg_dev);
  if (ret.sg != realFile) {
    std::stringstream err;
    err << "Mismatch between sysfs info and actual device file: "
        << ret.sysfs_entry + "/generic/dev" << " indicates "
        << ret.sg.major << ":" << ret.sg.minor
        << " while " << ret.sg_dev << " is: "
        << realFile.major << ":" << realFile.minor;
252
    throw cta::exception::Exception(err.str());
253
254
255
256
257
258
  }
  /* Handle more if we have a tape device */
  if (Types::tape == ret.type)
    getTapeInfo(ret);
  return ret;
}