Whamcloud - gitweb
LU-16367 misc: remove deprecated code
[fs/lustre-release.git] / lustre / utils / liblustreapi_util.c
1 /*
2  * LGPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * (C) Copyright (c) 2015, Cray Inc, all rights reserved.
7  *
8  * Copyright (c) 2016, 2017, Intel Corporation.
9  *
10  * All rights reserved. This program and the accompanying materials
11  * are made available under the terms of the GNU Lesser General Public License
12  * LGPL version 2.1 or (at your discretion) any later version.
13  * LGPL version 2.1 accompanies this distribution, and is available at
14  * http://www.gnu.org/licenses/lgpl-2.1.html
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * LGPL HEADER END
22  */
23 /*
24  * lustre/utils/liblustreapi_util.c
25  *
26  * Misc LGPL-licenced utility functions for liblustreapi.
27  *
28  * Author: Frank Zago <fzago@cray.com>
29  */
30
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdbool.h>
34 #include <stddef.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <sys/ioctl.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <sys/time.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <sys/syscall.h>
44 #include <libgen.h> /* for dirname() */
45 #include <lustre/lustreapi.h>
46 #include <linux/lustre/lustre_ver.h>    /* only until LUSTRE_VERSION_CODE is gone */
47 #include "lustreapi_internal.h"
48
49 /*
50  * Indicate whether the liblustreapi_init() constructor below has run or not.
51  *
52  * This can be used by external programs to ensure that the initialization
53  * mechanism has actually worked.
54  */
55 bool liblustreapi_initialized;
56
57 /**
58  * Initialize the library once at startup.
59  *
60  * Initializes the random number generator (random()). Get
61  * data from different places in case one of them fails. This
62  * is enough to get reasonably random numbers, but is not
63  * strong enough to be used for cryptography.
64  */
65 static __attribute__ ((constructor)) void liblustreapi_init(void)
66 {
67         unsigned int    seed;
68         struct timeval  tv;
69         int             fd;
70
71         seed = syscall(SYS_gettid);
72
73         if (gettimeofday(&tv, NULL) == 0) {
74                 seed ^= tv.tv_sec;
75                 seed ^= tv.tv_usec;
76         }
77
78         fd = open("/dev/urandom", O_RDONLY | O_NOFOLLOW);
79         if (fd >= 0) {
80                 unsigned int rnumber;
81                 ssize_t ret;
82
83                 ret = read(fd, &rnumber, sizeof(rnumber));
84                 seed ^= rnumber ^ ret;
85                 close(fd);
86         }
87
88         srandom(seed);
89         liblustreapi_initialized = true;
90 }
91
92 /**
93  * Return the release version for the Lustre modules, e.g. 2.6.92.
94  *
95  * The "version" file in /proc currently returns only the line:
96  * lustre: 2.8.52
97  *
98  * but in the past it also returned more lines that should be ignored:
99  * kernel: patchless_client
100  * build: v2_6_92_0-gadb3ee4-2.6.32-431.29.2.el6_lustre.g36cd22b.x86_64
101  *
102  * \param version[in,out]       buffer to store build version string
103  * \param version_size[in]      size of \a version
104  *
105  * \retval                      0 on success
106  * \retval                      -1 on failure, errno set
107  */
108 int llapi_get_version_string(char *version, unsigned int version_size)
109 {
110         char buffer[4096];
111         char *ptr;
112         int rc;
113
114         if (version == NULL || version_size == 0) {
115                 errno = EINVAL;
116                 return -1;
117         }
118
119         rc = get_lustre_param_value(NULL, NULL, FILTER_BY_NONE, "version",
120                                     buffer, sizeof(buffer));
121         if (rc < 0) {
122                 errno = -rc;
123                 return -1;
124         }
125
126         ptr = strstr(buffer, "lustre:");
127         if (ptr) {
128                 ptr += strlen("lustre:");
129                 while (*ptr == ' ' || *ptr == '\t')
130                         ptr++;
131         } else {
132                 ptr = buffer;
133         }
134         llapi_chomp_string(ptr);
135
136         if (ptr[0] == '\0') {
137                 errno = ENODATA;
138                 return -1;
139         }
140
141         if (snprintf(version, version_size, "%s", ptr) >= version_size) {
142                 errno = EOVERFLOW;
143                 return -1;
144         }
145         return 0;
146 }
147
148 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 4, 53, 0)
149 /**
150  * Return the build version of the Lustre code.
151  *
152  * The **version argument is pointless, so llapi_get_version_string() is
153  * better to use in the future, but give users a few versions to fix * it.
154  *
155  * \param buffer[in]            temporary buffer to hold version string
156  * \param buffer_size[in]       length of the \a buffer
157  * \param version[out]          pointer to the start of build version string
158  *
159  * \retval                      0 on success
160  * \retval                      -ve errno on failure
161  */
162 int llapi_get_version(char *buffer, int buffer_size, char **version)
163 {
164         static bool printed;
165         int rc;
166
167         if (!printed) {
168                 fprintf(stderr,
169                         "%s deprecated, use llapi_get_version_string()\n",
170                         __func__);
171                 printed = true;
172         }
173
174         rc = llapi_get_version_string(buffer, buffer_size);
175         /* keep old return style for this legacy function */
176         if (rc == -1)
177                 rc = -errno;
178         else
179                 *version = buffer;
180
181         return rc;
182 }
183 #endif /* LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 4, 53, 0) */
184
185 /*
186  * fsname must be specified
187  * if poolname is NULL, search tgtname in fsname
188  * if poolname is not NULL:
189  *  if poolname not found returns errno < 0
190  *  if tgtname is NULL, returns 1 if pool is not empty and 0 if pool empty
191  *  if tgtname is not NULL, returns 1 if target is in pool and 0 if not
192  */
193 int llapi_search_tgt(const char *fsname, const char *poolname,
194                      const char *tgtname, bool is_mdt)
195 {
196         char buffer[PATH_MAX];
197         size_t len = 0;
198         glob_t param;
199         FILE *fd;
200         int rc;
201
202         if (fsname && fsname[0] == '\0')
203                 fsname = NULL;
204         if (!fsname) {
205                 rc = -EINVAL;
206                 goto out;
207         }
208
209         if (poolname && poolname[0] == '\0')
210                 poolname = NULL;
211         if (tgtname) {
212                 if (tgtname[0] == '\0')
213                         tgtname = NULL;
214                 else
215                         len = strlen(tgtname);
216         }
217
218         /* You need one or the other to have something in it */
219         if (!poolname && !tgtname) {
220                 rc = -EINVAL;
221                 goto out;
222         }
223
224         if (poolname) {
225                 rc = poolpath(&param, fsname, NULL);
226                 if (!rc) {
227                         snprintf(buffer, sizeof(buffer) - 1, "%s/%s",
228                                  param.gl_pathv[0], poolname);
229                         buffer[sizeof(buffer) - 1] = '\0';
230                 }
231         } else {
232                 rc = get_lustre_param_path(is_mdt ? "lmv" : "lov", fsname,
233                                            FILTER_BY_FS_NAME,
234                                            "target_obd", &param);
235                 if (!rc) {
236                         strncpy(buffer, param.gl_pathv[0],
237                                 sizeof(buffer) - 1);
238                         buffer[sizeof(buffer) - 1] = '\0';
239                 }
240         }
241         cfs_free_param_data(&param);
242         if (rc)
243                 goto out;
244
245         fd = fopen(buffer, "r");
246         if (!fd) {
247                 rc = -errno;
248                 goto out;
249         }
250
251         while (fgets(buffer, sizeof(buffer), fd)) {
252                 if (!poolname) {
253                         char *ptr;
254                         /* Search for an tgtname in the list of all targets
255                          * Line format is IDX: fsname-OST/MDTxxxx_UUID STATUS */
256                         ptr = strchr(buffer, ' ');
257                         if (ptr && strncmp(ptr + 1, tgtname, len) == 0) {
258                                 rc = 1;
259                                 goto out_close;
260                         }
261                 } else {
262                         /* Search for an tgtname in a pool,
263                          * (or an existing non-empty pool if no tgtname) */
264                         if (!tgtname || strncmp(buffer, tgtname, len) == 0) {
265                                 rc = 1;
266                                 goto out_close;
267                         }
268                 }
269         }
270 out_close:
271         fclose(fd);
272 out:
273         if (rc < 0)
274                 errno = -rc;
275         return rc;
276 }
277
278 int llapi_search_mdt(const char *fsname, const char *poolname,
279                      const char *mdtname)
280 {
281         return llapi_search_tgt(fsname, poolname, mdtname, true);
282 }
283
284 int llapi_search_ost(const char *fsname, const char *poolname,
285                      const char *ostname)
286 {
287         return llapi_search_tgt(fsname, poolname, ostname, false);
288 }
289
290 int llapi_rmfid(const char *path, struct fid_array *fa)
291 {
292         char rootpath[PATH_MAX];
293         int fd, rc;
294
295 retry_open:
296         fd = open(path, O_RDONLY | O_NONBLOCK | O_NOFOLLOW);
297         if (fd < 0) {
298                 if (errno == ENOENT && path != rootpath) {
299                         rc = llapi_search_rootpath(rootpath, path);
300                         if (!rc) {
301                                 path = rootpath;
302                                 goto retry_open;
303                         }
304                 } else {
305                         return -errno;
306                 }
307         }
308
309         rc = ioctl(fd, LL_IOC_RMFID, fa);
310         close(fd);
311
312         return rc ? -errno : 0;
313 }
314
315 int llapi_direntry_remove(char *dname)
316 {
317 #ifdef LL_IOC_REMOVE_ENTRY
318         char *dirpath = NULL;
319         char *namepath = NULL;
320         char *dir;
321         char *filename;
322         int fd = -1;
323         int rc = 0;
324
325         dirpath = strdup(dname);
326         namepath = strdup(dname);
327         if (!dirpath || !namepath)
328                 return -ENOMEM;
329
330         filename = basename(namepath);
331
332         dir = dirname(dirpath);
333
334         fd = open(dir, O_DIRECTORY | O_RDONLY);
335         if (fd < 0) {
336                 rc = -errno;
337                 llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'",
338                             filename);
339                 goto out;
340         }
341
342         if (ioctl(fd, LL_IOC_REMOVE_ENTRY, filename))
343                 llapi_error(LLAPI_MSG_ERROR, errno,
344                             "error on ioctl %#lx for '%s' (%d)",
345                             (long)LL_IOC_LMV_SETSTRIPE, filename, fd);
346 out:
347         free(dirpath);
348         free(namepath);
349         if (fd != -1)
350                 close(fd);
351         return rc;
352 #else
353         return -EOPNOTSUPP;
354 #endif
355 }
356
357 int llapi_unlink_foreign(char *name)
358 {
359         int fd = -1;
360         int rc = 0;
361
362         fd = open(name, O_DIRECTORY | O_RDONLY | O_NOFOLLOW);
363         if (fd < 0 && errno != ENOTDIR) {
364                 rc = -errno;
365                 llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'", name);
366                 goto out;
367         } else if (errno == ENOTDIR) {
368                 fd = open(name, O_RDONLY | O_NOFOLLOW);
369                 if (fd < 0) {
370                         rc = -errno;
371                         llapi_error(LLAPI_MSG_ERROR, rc, "unable to open '%s'",
372                                     name);
373                         goto out;
374                 }
375         }
376
377         /* allow foreign symlink file/dir to be unlinked */
378         if (ioctl(fd, LL_IOC_UNLOCK_FOREIGN)) {
379                 llapi_error(LLAPI_MSG_ERROR, errno,
380                             "error on ioctl %#lx for '%s' (%d)",
381                             (long)LL_IOC_UNLOCK_FOREIGN, name, fd);
382                 rc = -errno;
383         }
384
385         /* XXX do not set AT_REMOVEDIR in flags even for a dir, as due to the
386          * hack for foreign symlink it will fail the directory check in
387          * Kernel's syscall code and return ENOTDIR, so treat all as files
388          */
389         rc = unlinkat(AT_FDCWD, name, 0);
390         if (rc == -1 && errno == EISDIR)
391                 rc = unlinkat(AT_FDCWD, name, AT_REMOVEDIR);
392
393         if (rc == -1) {
394                 llapi_error(LLAPI_MSG_ERROR, errno,
395                             "error on unlinkat for '%s' (%d)", name, fd);
396                 rc = -errno;
397         }
398
399 out:
400         if (fd != -1)
401                 close(fd);
402         return rc;
403 }
404
405 int llapi_get_fsname_instance(const char *path, char *fsname, size_t fsname_len,
406                               char *instance, size_t instance_len)
407 {
408         struct obd_uuid uuid_buf;
409         char *uuid = uuid_buf.uuid;
410         char *ptr;
411         int rc;
412
413         memset(&uuid_buf, 0, sizeof(uuid_buf));
414         rc = llapi_file_get_lov_uuid(path, &uuid_buf);
415         if (rc)
416                 return rc;
417
418         /*
419          * We want to turn fs-foo-clilov-ffff88002738bc00 into 'fs-foo' and
420          * 'ffff88002738bc00' in a portable way that doesn't depend on what is
421          * after "-clilov-" as it may change to a UUID string in the future.
422          * Unfortunately, the "fsname" part may contain a dash, so we can't
423          * just skip to the first dash, and if the "instance" is a UUID in the
424          * future we can't necessarily go to the last dash either.
425          */
426         ptr = strstr(uuid, "-clilov-");
427         if (!ptr || (!fsname && !instance)) {
428                 rc = -EINVAL;
429                 goto out;
430         }
431
432         *ptr = '\0';
433         ptr += strlen("-clilov-");
434         if (instance) {
435                 snprintf(instance, instance_len, "%s", ptr);
436                 if (strlen(ptr) >= instance_len)
437                         rc = -ENAMETOOLONG;
438         }
439
440         if (fsname) {
441                 snprintf(fsname, fsname_len, "%s", uuid);
442                 if (strlen(uuid) >= fsname_len)
443                         rc = -ENAMETOOLONG;
444         }
445
446 out:
447         errno = -rc;
448         return rc;
449 }
450
451 int llapi_getname(const char *path, char *name, size_t namelen)
452 {
453         char fsname[16];
454         char instance[40];
455         int rc;
456
457         rc = llapi_get_fsname_instance(path, fsname, sizeof(fsname),
458                                        instance, sizeof(instance));
459         if (rc)
460                 return rc;
461
462         snprintf(name, namelen, "%s-%s", fsname, instance);
463         if (strlen(fsname) + 1 + strlen(instance) >= namelen) {
464                 rc = -ENAMETOOLONG;
465                 errno = -rc;
466         }
467
468         return rc;
469 }
470
471 int llapi_get_instance(const char *path, char *instance, size_t instance_len)
472 {
473         return llapi_get_fsname_instance(path, NULL, 0, instance, instance_len);
474 }
475
476 int llapi_get_fsname(const char *path, char *fsname, size_t fsname_len)
477 {
478         return llapi_get_fsname_instance(path, fsname, fsname_len, NULL, 0);
479 }