]> sourceware.org Git - lvm2.git/blob - libdm/libdm-common.c
git://sourceware.org / lvm2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix error message when pvmove LV activation fails with name already in use.
[lvm2.git] / libdm / libdm-common.c
1 /*
2 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
3 * Copyright (C) 2004-2012 Red Hat, Inc. All rights reserved.
4 *
5 * This file is part of the device-mapper userspace tools.
6 *
7 * This copyrighted material is made available to anyone wishing to use,
8 * modify, copy, or redistribute it subject to the terms and conditions
9 * of the GNU Lesser General Public License v.2.1.
10 *
11 * You should have received a copy of the GNU Lesser General Public License
12 * along with this program; if not, write to the Free Software Foundation,
13 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
14 */
15
16 #include "dmlib.h"
17 #include "libdm-targets.h"
18 #include "libdm-common.h"
19 #include "kdev_t.h"
20 #include "dm-ioctl.h"
21
22 #include <stdarg.h>
23 #include <sys/param.h>
24 #include <sys/ioctl.h>
25 #include <fcntl.h>
26 #include <dirent.h>
27
28 #ifdef UDEV_SYNC_SUPPORT
29 # include <sys/types.h>
30 # include <sys/ipc.h>
31 # include <sys/sem.h>
32 # include <libudev.h>
33 #endif
34
35 #ifdef linux
36 # include <linux/fs.h>
37 #endif
38
39 #ifdef HAVE_SELINUX
40 # include <selinux/selinux.h>
41 #endif
42 #ifdef HAVE_SELINUX_LABEL_H
43 # include <selinux/label.h>
44 #endif
45
46 #define DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME "DM_DEFAULT_NAME_MANGLING_MODE"
47
48 #define DEV_DIR "/dev/"
49
50 #ifdef UDEV_SYNC_SUPPORT
51 #ifdef _SEM_SEMUN_UNDEFINED
52 union semun
53 {
54 int val; /* value for SETVAL */
55 struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
56 unsigned short int *array; /* array for GETALL & SETALL */
57 struct seminfo *__buf; /* buffer for IPC_INFO */
58 };
59 #endif
60 #endif
61
62 static char _dm_dir[PATH_MAX] = DEV_DIR DM_DIR;
63 static char _sysfs_dir[PATH_MAX] = "/sys/";
64 static char _path0[PATH_MAX]; /* path buffer, safe 4kB on stack */
65
66 #define DM_MAX_UUID_PREFIX_LEN 15
67 static char _default_uuid_prefix[DM_MAX_UUID_PREFIX_LEN + 1] = "LVM-";
68
69 static int _verbose = 0;
70 static int _suspended_dev_counter = 0;
71 static dm_string_mangling_t _name_mangling_mode = DEFAULT_DM_NAME_MANGLING;
72
73 #ifdef HAVE_SELINUX_LABEL_H
74 static struct selabel_handle *_selabel_handle = NULL;
75 #endif
76
77 #ifdef UDEV_SYNC_SUPPORT
78 static int _semaphore_supported = -1;
79 static int _udev_running = -1;
80 static int _sync_with_udev = 1;
81 static int _udev_checking = 1;
82 #endif
83
84 void dm_lib_init(void)
85 {
86 const char *env;
87
88 env = getenv(DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME);
89 if (env && *env) {
90 if (!strcasecmp(env, "none"))
91 _name_mangling_mode = DM_STRING_MANGLING_NONE;
92 else if (!strcasecmp(env, "auto"))
93 _name_mangling_mode = DM_STRING_MANGLING_AUTO;
94 else if (!strcasecmp(env, "hex"))
95 _name_mangling_mode = DM_STRING_MANGLING_HEX;
96 } else
97 _name_mangling_mode = DEFAULT_DM_NAME_MANGLING;
98 }
99
100 /*
101 * Library users can provide their own logging
102 * function.
103 */
104
105 __attribute__((format(printf, 5, 0)))
106 static void _default_log_line(int level,
107 const char *file __attribute__((unused)),
108 int line __attribute__((unused)), int dm_errno,
109 const char *f, va_list ap)
110 {
111 int use_stderr = level & _LOG_STDERR;
112
113 level &= ~_LOG_STDERR;
114
115 if (level > _LOG_WARN && !_verbose)
116 return;
117
118 if (level < _LOG_WARN)
119 vfprintf(stderr, f, ap);
120 else
121 vfprintf(use_stderr ? stderr : stdout, f, ap);
122
123 if (level < _LOG_WARN)
124 fprintf(stderr, "\n");
125 else
126 fprintf(use_stderr ? stderr : stdout, "\n");
127 }
128
129 __attribute__((format(printf, 5, 6)))
130 static void _default_log_with_errno(int level,
131 const char *file __attribute__((unused)),
132 int line __attribute__((unused)), int dm_errno,
133 const char *f, ...)
134 {
135 va_list ap;
136
137 va_start(ap, f);
138 _default_log_line(level, file, line, dm_errno, f, ap);
139 va_end(ap);
140 }
141
142 __attribute__((format(printf, 4, 5)))
143 static void _default_log(int level, const char *file,
144 int line, const char *f, ...)
145 {
146 va_list ap;
147
148 va_start(ap, f);
149 _default_log_line(level, file, line, 0, f, ap);
150 va_end(ap);
151 }
152
153 dm_log_fn dm_log = _default_log;
154 dm_log_with_errno_fn dm_log_with_errno = _default_log_with_errno;
155
156 void dm_log_init(dm_log_fn fn)
157 {
158 if (fn)
159 dm_log = fn;
160 else
161 dm_log = _default_log;
162
163 dm_log_with_errno = _default_log_with_errno;
164 }
165
166 int dm_log_is_non_default(void)
167 {
168 return (dm_log == _default_log) ? 0 : 1;
169 }
170
171 void dm_log_with_errno_init(dm_log_with_errno_fn fn)
172 {
173 if (fn)
174 dm_log_with_errno = fn;
175 else
176 dm_log_with_errno = _default_log_with_errno;
177
178 dm_log = _default_log;
179 }
180
181 void dm_log_init_verbose(int level)
182 {
183 _verbose = level;
184 }
185
186 static void _build_dev_path(char *buffer, size_t len, const char *dev_name)
187 {
188 /* If there's a /, assume caller knows what they're doing */
189 if (strchr(dev_name, '/'))
190 snprintf(buffer, len, "%s", dev_name);
191 else
192 snprintf(buffer, len, "%s/%s", _dm_dir, dev_name);
193 }
194
195 int dm_get_library_version(char *version, size_t size)
196 {
197 strncpy(version, DM_LIB_VERSION, size);
198 return 1;
199 }
200
201 void inc_suspended(void)
202 {
203 _suspended_dev_counter++;
204 log_debug("Suspended device counter increased to %d", _suspended_dev_counter);
205 }
206
207 void dec_suspended(void)
208 {
209 if (!_suspended_dev_counter) {
210 log_error("Attempted to decrement suspended device counter below zero.");
211 return;
212 }
213
214 _suspended_dev_counter--;
215 log_debug("Suspended device counter reduced to %d", _suspended_dev_counter);
216 }
217
218 int dm_get_suspended_counter(void)
219 {
220 return _suspended_dev_counter;
221 }
222
223 int dm_set_name_mangling_mode(dm_string_mangling_t name_mangling_mode)
224 {
225 _name_mangling_mode = name_mangling_mode;
226
227 return 1;
228 }
229
230 dm_string_mangling_t dm_get_name_mangling_mode(void)
231 {
232 return _name_mangling_mode;
233 }
234
235 struct dm_task *dm_task_create(int type)
236 {
237 struct dm_task *dmt = dm_zalloc(sizeof(*dmt));
238
239 if (!dmt) {
240 log_error("dm_task_create: malloc(%" PRIsize_t ") failed",
241 sizeof(*dmt));
242 return NULL;
243 }
244
245 if (!dm_check_version()) {
246 dm_free(dmt);
247 return_NULL;
248 }
249
250 dmt->type = type;
251 dmt->minor = -1;
252 dmt->major = -1;
253 dmt->allow_default_major_fallback = 1;
254 dmt->uid = DM_DEVICE_UID;
255 dmt->gid = DM_DEVICE_GID;
256 dmt->mode = DM_DEVICE_MODE;
257 dmt->no_open_count = 0;
258 dmt->read_ahead = DM_READ_AHEAD_AUTO;
259 dmt->read_ahead_flags = 0;
260 dmt->event_nr = 0;
261 dmt->cookie_set = 0;
262 dmt->query_inactive_table = 0;
263 dmt->new_uuid = 0;
264 dmt->secure_data = 0;
265
266 return dmt;
267 }
268
269 /*
270 * Find the name associated with a given device number by scanning _dm_dir.
271 */
272 static int _find_dm_name_of_device(dev_t st_rdev, char *buf, size_t buf_len)
273 {
274 const char *name;
275 char path[PATH_MAX];
276 struct dirent *dirent;
277 DIR *d;
278 struct stat st;
279 int r = 0;
280
281 if (!(d = opendir(_dm_dir))) {
282 log_sys_error("opendir", _dm_dir);
283 return 0;
284 }
285
286 while ((dirent = readdir(d))) {
287 name = dirent->d_name;
288
289 if (!strcmp(name, ".") || !strcmp(name, ".."))
290 continue;
291
292 if (dm_snprintf(path, sizeof(path), "%s/%s", _dm_dir,
293 name) == -1) {
294 log_error("Couldn't create path for %s", name);
295 continue;
296 }
297
298 if (stat(path, &st))
299 continue;
300
301 if (st.st_rdev == st_rdev) {
302 strncpy(buf, name, buf_len);
303 r = 1;
304 break;
305 }
306 }
307
308 if (closedir(d))
309 log_sys_error("closedir", _dm_dir);
310
311 return r;
312 }
313
314 static int _is_whitelisted_char(char c)
315 {
316 /*
317 * Actually, DM supports any character in a device name.
318 * This whitelist is just for proper integration with udev.
319 */
320 if ((c >= '0' && c <= '9') ||
321 (c >= 'A' && c <= 'Z') ||
322 (c >= 'a' && c <= 'z') ||
323 strchr("#+-.:=@_", c) != NULL)
324 return 1;
325
326 return 0;
327 }
328
329 int check_multiple_mangled_name_allowed(dm_string_mangling_t mode, const char *name)
330 {
331 if (mode == DM_STRING_MANGLING_AUTO && strstr(name, "\\x5cx")) {
332 log_error("The name \"%s\" seems to be mangled more than once. "
333 "This is not allowed in auto mode.", name);
334 return 0;
335 }
336
337 return 1;
338 }
339
340 /*
341 * Mangle all characters in the input string which are not on a whitelist
342 * with '\xNN' format where NN is the hex value of the character.
343 */
344 int mangle_name(const char *str, size_t len, char *buf,
345 size_t buf_len, dm_string_mangling_t mode)
346 {
347 int need_mangling = -1; /* -1 don't know yet, 0 no, 1 yes */
348 size_t i, j;
349
350 if (!str || !buf)
351 return -1;
352
353 /* Is there anything to do at all? */
354 if (!*str || !len)
355 return 0;
356
357 if (buf_len < DM_NAME_LEN) {
358 log_error(INTERNAL_ERROR "mangle_name: supplied buffer too small");
359 return -1;
360 }
361
362 if (mode == DM_STRING_MANGLING_NONE)
363 mode = DM_STRING_MANGLING_AUTO;
364
365 for (i = 0, j = 0; str[i]; i++) {
366 if (mode == DM_STRING_MANGLING_AUTO) {
367 /*
368 * Detect already mangled part of the string and keep it.
369 * Return error on mixture of mangled/not mangled!
370 */
371 if (str[i] == '\\' && str[i+1] == 'x') {
372 if ((len - i < 4) || (need_mangling == 1))
373 goto bad1;
374 if (buf_len - j < 4)
375 goto bad2;
376
377 memcpy(&buf[j], &str[i], 4);
378 i+=3; j+=4;
379
380 need_mangling = 0;
381 continue;
382 }
383 }
384
385 if (_is_whitelisted_char(str[i])) {
386 /* whitelisted, keep it. */
387 if (buf_len - j < 1)
388 goto bad2;
389 buf[j] = str[i];
390 j++;
391 } else {
392 /*
393 * Not on a whitelist, mangle it.
394 * Return error on mixture of mangled/not mangled
395 * unless a DM_STRING_MANGLING_HEX is used!.
396 */
397 if ((mode != DM_STRING_MANGLING_HEX) && (need_mangling == 0))
398 goto bad1;
399 if (buf_len - j < 4)
400 goto bad2;
401
402 sprintf(&buf[j], "\\x%02x", (unsigned char) str[i]);
403 j+=4;
404
405 need_mangling = 1;
406 }
407 }
408
409 if (buf_len - j < 1)
410 goto bad2;
411 buf[j] = '\0';
412
413 /* All chars in the string whitelisted? */
414 if (need_mangling == -1)
415 need_mangling = 0;
416
417 return need_mangling;
418
419 bad1:
420 log_error("The name \"%s\" contains mixed mangled and unmangled "
421 "characters or it's already mangled improperly.", str);
422 return -1;
423 bad2:
424 log_error("Mangled form of the name too long for \"%s\".", str);
425 return -1;
426 }
427
428 /*
429 * Try to unmangle supplied string.
430 * Return value: -1 on error, 0 when no unmangling needed, 1 when unmangling applied
431 */
432 int unmangle_name(const char *str, size_t len, char *buf,
433 size_t buf_len, dm_string_mangling_t mode)
434 {
435 int strict = mode != DM_STRING_MANGLING_NONE;
436 char str_rest[DM_NAME_LEN];
437 size_t i, j;
438 int code;
439 int r = 0;
440
441 if (!str || !buf)
442 return -1;
443
444 /* Is there anything to do at all? */
445 if (!*str || !len)
446 return 0;
447
448 if (buf_len < DM_NAME_LEN) {
449 log_error(INTERNAL_ERROR "unmangle_name: supplied buffer too small");
450 return -1;
451 }
452
453 for (i = 0, j = 0; str[i]; i++, j++) {
454 if (strict && !(_is_whitelisted_char(str[i]) || str[i]=='\\')) {
455 log_error("The name \"%s\" should be mangled but "
456 "it contains blacklisted characters.", str);
457 j=0; r=-1;
458 goto out;
459 }
460
461 if (str[i] == '\\' && str[i+1] == 'x') {
462 if (!sscanf(&str[i+2], "%2x%s", &code, str_rest)) {
463 log_debug("Hex encoding mismatch detected in \"%s\" "
464 "while trying to unmangle it.", str);
465 goto out;
466 }
467 buf[j] = (unsigned char) code;
468
469 /* skip the encoded part we've just decoded! */
470 i+= 3;
471
472 /* unmangling applied */
473 r = 1;
474 } else
475 buf[j] = str[i];
476 }
477
478 out:
479 buf[j] = '\0';
480 return r;
481 }
482
483 static int _dm_task_set_name(struct dm_task *dmt, const char *name,
484 dm_string_mangling_t mangling_mode)
485 {
486 char mangled_name[DM_NAME_LEN];
487 int r = 0;
488
489 dm_free(dmt->dev_name);
490 dmt->dev_name = NULL;
491 dm_free(dmt->mangled_dev_name);
492 dmt->mangled_dev_name = NULL;
493
494 if (strlen(name) >= DM_NAME_LEN) {
495 log_error("Name \"%s\" too long.", name);
496 return 0;
497 }
498
499 if (!check_multiple_mangled_name_allowed(mangling_mode, name))
500 return_0;
501
502 if (mangling_mode != DM_STRING_MANGLING_NONE &&
503 (r = mangle_name(name, strlen(name), mangled_name,
504 sizeof(mangled_name), mangling_mode)) < 0) {
505 log_error("Failed to mangle device name \"%s\".", name);
506 return 0;
507 }
508
509 /* Store mangled_dev_name only if it differs from dev_name! */
510 if (r) {
511 log_debug("Device name mangled [%s]: %s --> %s",
512 mangling_mode == DM_STRING_MANGLING_AUTO ? "auto" : "hex",
513 name, mangled_name);
514 if (!(dmt->mangled_dev_name = dm_strdup(mangled_name))) {
515 log_error("_dm_task_set_name: dm_strdup(%s) failed", mangled_name);
516 return 0;
517 }
518 }
519
520 if (!(dmt->dev_name = dm_strdup(name))) {
521 log_error("_dm_task_set_name: strdup(%s) failed", name);
522 return 0;
523 }
524
525 return 1;
526 }
527
528 static int _dm_task_set_name_from_path(struct dm_task *dmt, const char *path,
529 const char *name)
530 {
531 char buf[PATH_MAX];
532 struct stat st1, st2;
533 const char *final_name;
534
535 if (dmt->type == DM_DEVICE_CREATE) {
536 log_error("Name \"%s\" invalid. It contains \"/\".", path);
537 return 0;
538 }
539
540 if (stat(path, &st1)) {
541 log_error("Device %s not found", path);
542 return 0;
543 }
544
545 /*
546 * If supplied path points to same device as last component
547 * under /dev/mapper, use that name directly. Otherwise call
548 * _find_dm_name_of_device() to scan _dm_dir for a match.
549 */
550 if (dm_snprintf(buf, sizeof(buf), "%s/%s", _dm_dir, name) == -1) {
551 log_error("Couldn't create path for %s", name);
552 return 0;
553 }
554
555 if (!stat(buf, &st2) && (st1.st_rdev == st2.st_rdev))
556 final_name = name;
557 else if (_find_dm_name_of_device(st1.st_rdev, buf, sizeof(buf)))
558 final_name = buf;
559 else {
560 log_error("Device %s not found", name);
561 return 0;
562 }
563
564 /* This is an already existing path - do not mangle! */
565 return _dm_task_set_name(dmt, final_name, DM_STRING_MANGLING_NONE);
566 }
567
568 int dm_task_set_name(struct dm_task *dmt, const char *name)
569 {
570 char *pos;
571
572 /* Path supplied for existing device? */
573 if ((pos = strrchr(name, '/')))
574 return _dm_task_set_name_from_path(dmt, name, pos + 1);
575
576 return _dm_task_set_name(dmt, name, dm_get_name_mangling_mode());
577 }
578
579 const char *dm_task_get_name(const struct dm_task *dmt)
580 {
581 return (dmt->dmi.v4->name);
582 }
583
584 char *dm_task_get_name_mangled(const struct dm_task *dmt)
585 {
586 const char *s = dm_task_get_name(dmt);
587 char buf[DM_NAME_LEN];
588 char *rs = NULL;
589 int r;
590
591 if ((r = mangle_name(s, strlen(s), buf, sizeof(buf),
592 dm_get_name_mangling_mode())) < 0)
593 log_error("Failed to mangle device name \"%s\".", s);
594 else if (!(rs = r ? dm_strdup(buf) : dm_strdup(s)))
595 log_error("dm_task_get_name_mangled: dm_strdup failed");
596
597 return rs;
598 }
599
600 char *dm_task_get_name_unmangled(const struct dm_task *dmt)
601 {
602 const char *s = dm_task_get_name(dmt);
603 char buf[DM_NAME_LEN];
604 char *rs = NULL;
605 int r = 0;
606
607 /*
608 * Unless the mode used is 'none', the name
609 * is *already* unmangled on ioctl return!
610 */
611 if (dm_get_name_mangling_mode() == DM_STRING_MANGLING_NONE &&
612 (r = unmangle_name(s, strlen(s), buf, sizeof(buf),
613 dm_get_name_mangling_mode())) < 0)
614 log_error("Failed to unmangle device name \"%s\".", s);
615 else if (!(rs = r ? dm_strdup(buf) : dm_strdup(s)))
616 log_error("dm_task_get_name_unmangled: dm_strdup failed");
617
618 return rs;
619 }
620
621 int dm_task_set_newname(struct dm_task *dmt, const char *newname)
622 {
623 dm_string_mangling_t mangling_mode = dm_get_name_mangling_mode();
624 char mangled_name[DM_NAME_LEN];
625 int r = 0;
626
627 if (strchr(newname, '/')) {
628 log_error("Name \"%s\" invalid. It contains \"/\".", newname);
629 return 0;
630 }
631
632 if (strlen(newname) >= DM_NAME_LEN) {
633 log_error("Name \"%s\" too long", newname);
634 return 0;
635 }
636
637 if (!check_multiple_mangled_name_allowed(mangling_mode, newname))
638 return_0;
639
640 if (mangling_mode != DM_STRING_MANGLING_NONE &&
641 (r = mangle_name(newname, strlen(newname), mangled_name,
642 sizeof(mangled_name), mangling_mode)) < 0) {
643 log_error("Failed to mangle new device name \"%s\"", newname);
644 return 0;
645 }
646
647 if (r) {
648 log_debug("New device name mangled [%s]: %s --> %s",
649 mangling_mode == DM_STRING_MANGLING_AUTO ? "auto" : "hex",
650 newname, mangled_name);
651 newname = mangled_name;
652 }
653
654 if (!(dmt->newname = dm_strdup(newname))) {
655 log_error("dm_task_set_newname: strdup(%s) failed", newname);
656 return 0;
657 }
658
659 dmt->new_uuid = 0;
660
661 return 1;
662 }
663
664 int dm_task_set_uuid(struct dm_task *dmt, const char *uuid)
665 {
666 dm_free(dmt->uuid);
667
668 if (!(dmt->uuid = dm_strdup(uuid))) {
669 log_error("dm_task_set_uuid: strdup(%s) failed", uuid);
670 return 0;
671 }
672
673 return 1;
674 }
675
676 int dm_task_set_major(struct dm_task *dmt, int major)
677 {
678 dmt->major = major;
679 dmt->allow_default_major_fallback = 0;
680
681 return 1;
682 }
683
684 int dm_task_set_minor(struct dm_task *dmt, int minor)
685 {
686 dmt->minor = minor;
687
688 return 1;
689 }
690
691 int dm_task_set_major_minor(struct dm_task *dmt, int major, int minor,
692 int allow_default_major_fallback)
693 {
694 dmt->major = major;
695 dmt->minor = minor;
696 dmt->allow_default_major_fallback = allow_default_major_fallback;
697
698 return 1;
699 }
700
701 int dm_task_set_uid(struct dm_task *dmt, uid_t uid)
702 {
703 dmt->uid = uid;
704
705 return 1;
706 }
707
708 int dm_task_set_gid(struct dm_task *dmt, gid_t gid)
709 {
710 dmt->gid = gid;
711
712 return 1;
713 }
714
715 int dm_task_set_mode(struct dm_task *dmt, mode_t mode)
716 {
717 dmt->mode = mode;
718
719 return 1;
720 }
721
722 int dm_task_enable_checks(struct dm_task *dmt)
723 {
724 dmt->enable_checks = 1;
725
726 return 1;
727 }
728
729 int dm_task_add_target(struct dm_task *dmt, uint64_t start, uint64_t size,
730 const char *ttype, const char *params)
731 {
732 struct target *t = create_target(start, size, ttype, params);
733 if (!t)
734 return_0;
735
736 if (!dmt->head)
737 dmt->head = dmt->tail = t;
738 else {
739 dmt->tail->next = t;
740 dmt->tail = t;
741 }
742
743 return 1;
744 }
745
746 #ifdef HAVE_SELINUX
747 static int _selabel_lookup(const char *path, mode_t mode,
748 security_context_t *scontext)
749 {
750 #ifdef HAVE_SELINUX_LABEL_H
751 if (!_selabel_handle &&
752 !(_selabel_handle = selabel_open(SELABEL_CTX_FILE, NULL, 0))) {
753 log_error("selabel_open failed: %s", strerror(errno));
754 return 0;
755 }
756
757 if (selabel_lookup(_selabel_handle, scontext, path, mode)) {
758 log_debug("selabel_lookup failed for %s: %s",
759 path, strerror(errno));
760 return 0;
761 }
762 #else
763 if (matchpathcon(path, mode, scontext)) {
764 log_debug("matchpathcon failed for %s: %s",
765 path, strerror(errno));
766 return 0;
767 }
768 #endif
769 return 1;
770 }
771 #endif
772
773 int dm_prepare_selinux_context(const char *path, mode_t mode)
774 {
775 #ifdef HAVE_SELINUX
776 security_context_t scontext = NULL;
777
778 if (is_selinux_enabled() <= 0)
779 return 1;
780
781 if (path) {
782 if (!_selabel_lookup(path, mode, &scontext))
783 return_0;
784
785 log_debug("Preparing SELinux context for %s to %s.", path, scontext);
786 }
787 else
788 log_debug("Resetting SELinux context to default value.");
789
790 if (setfscreatecon(scontext) < 0) {
791 log_sys_error("setfscreatecon", path);
792 freecon(scontext);
793 return 0;
794 }
795
796 freecon(scontext);
797 #endif
798 return 1;
799 }
800
801 int dm_set_selinux_context(const char *path, mode_t mode)
802 {
803 #ifdef HAVE_SELINUX
804 security_context_t scontext;
805
806 if (is_selinux_enabled() <= 0)
807 return 1;
808
809 if (!_selabel_lookup(path, mode, &scontext))
810 return_0;
811
812 log_debug("Setting SELinux context for %s to %s.", path, scontext);
813
814 if ((lsetfilecon(path, scontext) < 0) && (errno != ENOTSUP)) {
815 log_sys_error("lsetfilecon", path);
816 freecon(scontext);
817 return 0;
818 }
819
820 freecon(scontext);
821 #endif
822 return 1;
823 }
824
825 void selinux_release(void)
826 {
827 #ifdef HAVE_SELINUX_LABEL_H
828 if (_selabel_handle)
829 selabel_close(_selabel_handle);
830 _selabel_handle = NULL;
831 #endif
832 }
833
834 static int _warn_if_op_needed(int warn_if_udev_failed)
835 {
836 return warn_if_udev_failed && dm_udev_get_sync_support() && dm_udev_get_checking();
837 }
838
839 static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
840 uid_t uid, gid_t gid, mode_t mode, int warn_if_udev_failed)
841 {
842 char path[PATH_MAX];
843 struct stat info;
844 dev_t dev = MKDEV(major, minor);
845 mode_t old_mask;
846
847 _build_dev_path(path, sizeof(path), dev_name);
848
849 if (stat(path, &info) >= 0) {
850 if (!S_ISBLK(info.st_mode)) {
851 log_error("A non-block device file at '%s' "
852 "is already present", path);
853 return 0;
854 }
855
856 /* If right inode already exists we don't touch uid etc. */
857 if (info.st_rdev == dev)
858 return 1;
859
860 if (unlink(path) < 0) {
861 log_error("Unable to unlink device node for '%s'",
862 dev_name);
863 return 0;
864 }
865 } else if (_warn_if_op_needed(warn_if_udev_failed))
866 log_warn("%s not set up by udev: Falling back to direct "
867 "node creation.", path);
868
869 (void) dm_prepare_selinux_context(path, S_IFBLK);
870 old_mask = umask(0);
871 if (mknod(path, S_IFBLK | mode, dev) < 0) {
872 log_error("%s: mknod for %s failed: %s", path, dev_name, strerror(errno));
873 umask(old_mask);
874 (void) dm_prepare_selinux_context(NULL, 0);
875 return 0;
876 }
877 umask(old_mask);
878 (void) dm_prepare_selinux_context(NULL, 0);
879
880 if (chown(path, uid, gid) < 0) {
881 log_sys_error("chown", path);
882 return 0;
883 }
884
885 log_debug("Created %s", path);
886
887 return 1;
888 }
889
890 static int _rm_dev_node(const char *dev_name, int warn_if_udev_failed)
891 {
892 char path[PATH_MAX];
893 struct stat info;
894
895 _build_dev_path(path, sizeof(path), dev_name);
896
897 if (stat(path, &info) < 0)
898 return 1;
899 else if (_warn_if_op_needed(warn_if_udev_failed))
900 log_warn("Node %s was not removed by udev. "
901 "Falling back to direct node removal.", path);
902
903 if (unlink(path) < 0) {
904 log_error("Unable to unlink device node for '%s'", dev_name);
905 return 0;
906 }
907
908 log_debug("Removed %s", path);
909
910 return 1;
911 }
912
913 static int _rename_dev_node(const char *old_name, const char *new_name,
914 int warn_if_udev_failed)
915 {
916 char oldpath[PATH_MAX];
917 char newpath[PATH_MAX];
918 struct stat info;
919
920 _build_dev_path(oldpath, sizeof(oldpath), old_name);
921 _build_dev_path(newpath, sizeof(newpath), new_name);
922
923 if (stat(newpath, &info) == 0) {
924 if (!S_ISBLK(info.st_mode)) {
925 log_error("A non-block device file at '%s' "
926 "is already present", newpath);
927 return 0;
928 }
929 else if (_warn_if_op_needed(warn_if_udev_failed)) {
930 if (stat(oldpath, &info) < 0 &&
931 errno == ENOENT)
932 /* assume udev already deleted this */
933 return 1;
934 else {
935 log_warn("The node %s should have been renamed to %s "
936 "by udev but old node is still present. "
937 "Falling back to direct old node removal.",
938 oldpath, newpath);
939 return _rm_dev_node(old_name, 0);
940 }
941 }
942
943 if (unlink(newpath) < 0) {
944 if (errno == EPERM) {
945 /* devfs, entry has already been renamed */
946 return 1;
947 }
948 log_error("Unable to unlink device node for '%s'",
949 new_name);
950 return 0;
951 }
952 }
953 else if (_warn_if_op_needed(warn_if_udev_failed))
954 log_warn("The node %s should have been renamed to %s "
955 "by udev but new node is not present. "
956 "Falling back to direct node rename.",
957 oldpath, newpath);
958
959 if (rename(oldpath, newpath) < 0) {
960 log_error("Unable to rename device node from '%s' to '%s'",
961 old_name, new_name);
962 return 0;
963 }
964
965 log_debug("Renamed %s to %s", oldpath, newpath);
966
967 return 1;
968 }
969
970 #ifdef linux
971 static int _open_dev_node(const char *dev_name)
972 {
973 int fd = -1;
974 char path[PATH_MAX];
975
976 _build_dev_path(path, sizeof(path), dev_name);
977
978 if ((fd = open(path, O_RDONLY, 0)) < 0)
979 log_sys_error("open", path);
980
981 return fd;
982 }
983
984 int get_dev_node_read_ahead(const char *dev_name, uint32_t major, uint32_t minor,
985 uint32_t *read_ahead)
986 {
987 char buf[24];
988 int len;
989 int r = 1;
990 int fd;
991 long read_ahead_long;
992
993 /*
994 * If we know the device number, use sysfs if we can.
995 * Otherwise use BLKRAGET ioctl.
996 */
997 if (*_sysfs_dir && major != 0) {
998 if (dm_snprintf(_path0, sizeof(_path0), "%sdev/block/%" PRIu32
999 ":%" PRIu32 "/bdi/read_ahead_kb", _sysfs_dir,
1000 major, minor) < 0) {
1001 log_error("Failed to build sysfs_path.");
1002 return 0;
1003 }
1004
1005 if ((fd = open(_path0, O_RDONLY, 0)) != -1) {
1006 /* Reading from sysfs, expecting number\n */
1007 if ((len = read(fd, buf, sizeof(buf) - 1)) < 1) {
1008 log_sys_error("read", _path0);
1009 r = 0;
1010 } else {
1011 buf[len] = 0; /* kill \n and ensure \0 */
1012 *read_ahead = atoi(buf) * 2;
1013 log_debug("%s (%d:%d): read ahead is %" PRIu32,
1014 dev_name, major, minor, *read_ahead);
1015 }
1016
1017 if (close(fd))
1018 log_sys_debug("close", _path0);
1019
1020 return r;
1021 }
1022
1023 log_sys_debug("open", _path0);
1024 /* Fall back to use dev_name */
1025 }
1026
1027 /*
1028 * Open/close dev_name may block the process
1029 * (i.e. overfilled thin pool volume)
1030 */
1031 if (!*dev_name) {
1032 log_error("Empty device name passed to BLKRAGET");
1033 return 0;
1034 }
1035
1036 if ((fd = _open_dev_node(dev_name)) < 0)
1037 return_0;
1038
1039 if (ioctl(fd, BLKRAGET, &read_ahead_long)) {
1040 log_sys_error("BLKRAGET", dev_name);
1041 *read_ahead = 0;
1042 r = 0;
1043 } else {
1044 *read_ahead = (uint32_t) read_ahead_long;
1045 log_debug("%s: read ahead is %" PRIu32, dev_name, *read_ahead);
1046 }
1047
1048 if (close(fd))
1049 log_sys_debug("close", dev_name);
1050
1051 return r;
1052 }
1053
1054 static int _set_read_ahead(const char *dev_name, uint32_t major, uint32_t minor,
1055 uint32_t read_ahead)
1056 {
1057 char buf[24];
1058 int len;
1059 int r = 1;
1060 int fd;
1061 long read_ahead_long = (long) read_ahead;
1062
1063 log_debug("%s (%d:%d): Setting read ahead to %" PRIu32, dev_name,
1064 major, minor, read_ahead);
1065
1066 /*
1067 * If we know the device number, use sysfs if we can.
1068 * Otherwise use BLKRASET ioctl. RA is set after resume.
1069 */
1070 if (*_sysfs_dir && major != 0) {
1071 if (dm_snprintf(_path0, sizeof(_path0), "%sdev/block/%" PRIu32
1072 ":%" PRIu32 "/bdi/read_ahead_kb",
1073 _sysfs_dir, major, minor) < 0) {
1074 log_error("Failed to build sysfs_path.");
1075 return 0;
1076 }
1077
1078 /* Sysfs is kB based, round up to kB */
1079 if ((len = dm_snprintf(buf, sizeof(buf), "%" PRIu32,
1080 (read_ahead + 1) / 2)) < 0) {
1081 log_error("Failed to build size in kB.");
1082 return 0;
1083 }
1084
1085 if ((fd = open(_path0, O_WRONLY, 0)) != -1) {
1086 if (write(fd, buf, len) < len) {
1087 log_sys_error("write", _path0);
1088 r = 0;
1089 }
1090
1091 if (close(fd))
1092 log_sys_debug("close", _path0);
1093
1094 return r;
1095 }
1096
1097 log_sys_debug("open", _path0);
1098 /* Fall back to use dev_name */
1099 }
1100
1101 if (!*dev_name) {
1102 log_error("Empty device name passed to BLKRAGET");
1103 return 0;
1104 }
1105
1106 if ((fd = _open_dev_node(dev_name)) < 0)
1107 return_0;
1108
1109 if (ioctl(fd, BLKRASET, read_ahead_long)) {
1110 log_sys_error("BLKRASET", dev_name);
1111 r = 0;
1112 }
1113
1114 if (close(fd))
1115 log_sys_debug("close", dev_name);
1116
1117 return r;
1118 }
1119
1120 static int _set_dev_node_read_ahead(const char *dev_name,
1121 uint32_t major, uint32_t minor,
1122 uint32_t read_ahead, uint32_t read_ahead_flags)
1123 {
1124 uint32_t current_read_ahead;
1125
1126 if (read_ahead == DM_READ_AHEAD_AUTO)
1127 return 1;
1128
1129 if (read_ahead == DM_READ_AHEAD_NONE)
1130 read_ahead = 0;
1131
1132 if (read_ahead_flags & DM_READ_AHEAD_MINIMUM_FLAG) {
1133 if (!get_dev_node_read_ahead(dev_name, major, minor, &current_read_ahead))
1134 return_0;
1135
1136 if (current_read_ahead > read_ahead) {
1137 log_debug("%s: retaining kernel read ahead of %" PRIu32
1138 " (requested %" PRIu32 ")",
1139 dev_name, current_read_ahead, read_ahead);
1140 return 1;
1141 }
1142 }
1143
1144 return _set_read_ahead(dev_name, major, minor, read_ahead);
1145 }
1146
1147 #else
1148
1149 int get_dev_node_read_ahead(const char *dev_name, uint32_t *read_ahead)
1150 {
1151 *read_ahead = 0;
1152
1153 return 1;
1154 }
1155
1156 static int _set_dev_node_read_ahead(const char *dev_name,
1157 uint32_t major, uint32_t minor,
1158 uint32_t read_ahead, uint32_t read_ahead_flags)
1159 {
1160 return 1;
1161 }
1162 #endif
1163
1164 typedef enum {
1165 NODE_ADD,
1166 NODE_DEL,
1167 NODE_RENAME,
1168 NODE_READ_AHEAD,
1169 NUM_NODES
1170 } node_op_t;
1171
1172 static int _do_node_op(node_op_t type, const char *dev_name, uint32_t major,
1173 uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
1174 const char *old_name, uint32_t read_ahead,
1175 uint32_t read_ahead_flags, int warn_if_udev_failed)
1176 {
1177 switch (type) {
1178 case NODE_ADD:
1179 return _add_dev_node(dev_name, major, minor, uid, gid,
1180 mode, warn_if_udev_failed);
1181 case NODE_DEL:
1182 return _rm_dev_node(dev_name, warn_if_udev_failed);
1183 case NODE_RENAME:
1184 return _rename_dev_node(old_name, dev_name, warn_if_udev_failed);
1185 case NODE_READ_AHEAD:
1186 return _set_dev_node_read_ahead(dev_name, major, minor,
1187 read_ahead, read_ahead_flags);
1188 default:
1189 ; /* NOTREACHED */
1190 }
1191
1192 return 1;
1193 }
1194
1195 static DM_LIST_INIT(_node_ops);
1196 static int _count_node_ops[NUM_NODES];
1197
1198 struct node_op_parms {
1199 struct dm_list list;
1200 node_op_t type;
1201 char *dev_name;
1202 uint32_t major;
1203 uint32_t minor;
1204 uid_t uid;
1205 gid_t gid;
1206 mode_t mode;
1207 uint32_t read_ahead;
1208 uint32_t read_ahead_flags;
1209 char *old_name;
1210 int warn_if_udev_failed;
1211 unsigned rely_on_udev;
1212 char names[0];
1213 };
1214
1215 static void _store_str(char **pos, char **ptr, const char *str)
1216 {
1217 strcpy(*pos, str);
1218 *ptr = *pos;
1219 *pos += strlen(*ptr) + 1;
1220 }
1221
1222 static void _del_node_op(struct node_op_parms *nop)
1223 {
1224 _count_node_ops[nop->type]--;
1225 dm_list_del(&nop->list);
1226 dm_free(nop);
1227
1228 }
1229
1230 /* Check if there is other the type of node operation stacked */
1231 static int _other_node_ops(node_op_t type)
1232 {
1233 unsigned i;
1234
1235 for (i = 0; i < NUM_NODES; i++)
1236 if (type != i && _count_node_ops[i])
1237 return 1;
1238 return 0;
1239 }
1240
1241 static void _log_node_op(const char *action_str, struct node_op_parms *nop)
1242 {
1243 const char *rely = nop->rely_on_udev ? " [trust_udev]" : "" ;
1244 const char *verify = nop->warn_if_udev_failed ? " [verify_udev]" : "";
1245
1246 switch (nop->type) {
1247 case NODE_ADD:
1248 log_debug("%s: %s NODE_ADD (%" PRIu32 ",%" PRIu32 ") %u:%u 0%o%s%s",
1249 nop->dev_name, action_str, nop->major, nop->minor, nop->uid, nop->gid, nop->mode,
1250 rely, verify);
1251 break;
1252 case NODE_DEL:
1253 log_debug("%s: %s NODE_DEL%s%s", nop->dev_name, action_str, rely, verify);
1254 break;
1255 case NODE_RENAME:
1256 log_debug("%s: %s NODE_RENAME to %s%s%s", nop->old_name, action_str, nop->dev_name, rely, verify);
1257 break;
1258 case NODE_READ_AHEAD:
1259 log_debug("%s: %s NODE_READ_AHEAD %" PRIu32 " (flags=%" PRIu32 ")%s%s",
1260 nop->dev_name, action_str, nop->read_ahead, nop->read_ahead_flags, rely, verify);
1261 break;
1262 default:
1263 ; /* NOTREACHED */
1264 }
1265 }
1266
1267 static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major,
1268 uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
1269 const char *old_name, uint32_t read_ahead,
1270 uint32_t read_ahead_flags, int warn_if_udev_failed,
1271 unsigned rely_on_udev)
1272 {
1273 struct node_op_parms *nop;
1274 struct dm_list *noph, *nopht;
1275 size_t len = strlen(dev_name) + strlen(old_name) + 2;
1276 char *pos;
1277
1278 /*
1279 * Note: warn_if_udev_failed must have valid content
1280 */
1281 if ((type == NODE_DEL) && _other_node_ops(type))
1282 /*
1283 * Ignore any outstanding operations on the node if deleting it.
1284 */
1285 dm_list_iterate_safe(noph, nopht, &_node_ops) {
1286 nop = dm_list_item(noph, struct node_op_parms);
1287 if (!strcmp(dev_name, nop->dev_name)) {
1288 _log_node_op("Unstacking", nop);
1289 _del_node_op(nop);
1290 if (!_other_node_ops(type))
1291 break; /* no other non DEL ops */
1292 }
1293 }
1294 else if ((type == NODE_ADD) && _count_node_ops[NODE_DEL])
1295 /*
1296 * Ignore previous DEL operation on added node.
1297 * (No other operations for this device then DEL could be stacked here).
1298 */
1299 dm_list_iterate_safe(noph, nopht, &_node_ops) {
1300 nop = dm_list_item(noph, struct node_op_parms);
1301 if ((nop->type == NODE_DEL) &&
1302 !strcmp(dev_name, nop->dev_name)) {
1303 _log_node_op("Unstacking", nop);
1304 _del_node_op(nop);
1305 break; /* no other DEL ops */
1306 }
1307 }
1308 else if (type == NODE_RENAME)
1309 /*
1310 * Ignore any outstanding operations if renaming it.
1311 *
1312 * Currently RENAME operation happens through 'suspend -> resume'.
1313 * On 'resume' device is added with read_ahead settings, so it is
1314 * safe to remove any stacked ADD, RENAME, READ_AHEAD operation
1315 * There cannot be any DEL operation on the renamed device.
1316 */
1317 dm_list_iterate_safe(noph, nopht, &_node_ops) {
1318 nop = dm_list_item(noph, struct node_op_parms);
1319 if (!strcmp(old_name, nop->dev_name)) {
1320 _log_node_op("Unstacking", nop);
1321 _del_node_op(nop);
1322 }
1323 }
1324 else if (type == NODE_READ_AHEAD) {
1325 /* udev doesn't process readahead */
1326 rely_on_udev = 0;
1327 warn_if_udev_failed = 0;
1328 }
1329
1330 if (!(nop = dm_malloc(sizeof(*nop) + len))) {
1331 log_error("Insufficient memory to stack mknod operation");
1332 return 0;
1333 }
1334
1335 pos = nop->names;
1336 nop->type = type;
1337 nop->major = major;
1338 nop->minor = minor;
1339 nop->uid = uid;
1340 nop->gid = gid;
1341 nop->mode = mode;
1342 nop->read_ahead = read_ahead;
1343 nop->read_ahead_flags = read_ahead_flags;
1344 nop->rely_on_udev = rely_on_udev;
1345
1346 /*
1347 * Clear warn_if_udev_failed if rely_on_udev is set. It doesn't get
1348 * checked in this case - this just removes the flag from log messages.
1349 */
1350 nop->warn_if_udev_failed = rely_on_udev ? 0 : warn_if_udev_failed;
1351
1352 _store_str(&pos, &nop->dev_name, dev_name);
1353 _store_str(&pos, &nop->old_name, old_name);
1354
1355 _count_node_ops[type]++;
1356 dm_list_add(&_node_ops, &nop->list);
1357
1358 _log_node_op("Stacking", nop);
1359
1360 return 1;
1361 }
1362
1363 static void _pop_node_ops(void)
1364 {
1365 struct dm_list *noph, *nopht;
1366 struct node_op_parms *nop;
1367
1368 dm_list_iterate_safe(noph, nopht, &_node_ops) {
1369 nop = dm_list_item(noph, struct node_op_parms);
1370 if (!nop->rely_on_udev) {
1371 _log_node_op("Processing", nop);
1372 _do_node_op(nop->type, nop->dev_name, nop->major, nop->minor,
1373 nop->uid, nop->gid, nop->mode, nop->old_name,
1374 nop->read_ahead, nop->read_ahead_flags,
1375 nop->warn_if_udev_failed);
1376 } else
1377 _log_node_op("Skipping", nop);
1378 _del_node_op(nop);
1379 }
1380 }
1381
1382 int add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
1383 uid_t uid, gid_t gid, mode_t mode, int check_udev, unsigned rely_on_udev)
1384 {
1385 return _stack_node_op(NODE_ADD, dev_name, major, minor, uid,
1386 gid, mode, "", 0, 0, check_udev, rely_on_udev);
1387 }
1388
1389 int rename_dev_node(const char *old_name, const char *new_name, int check_udev, unsigned rely_on_udev)
1390 {
1391 return _stack_node_op(NODE_RENAME, new_name, 0, 0, 0,
1392 0, 0, old_name, 0, 0, check_udev, rely_on_udev);
1393 }
1394
1395 int rm_dev_node(const char *dev_name, int check_udev, unsigned rely_on_udev)
1396 {
1397 return _stack_node_op(NODE_DEL, dev_name, 0, 0, 0,
1398 0, 0, "", 0, 0, check_udev, rely_on_udev);
1399 }
1400
1401 int set_dev_node_read_ahead(const char *dev_name,
1402 uint32_t major, uint32_t minor,
1403 uint32_t read_ahead, uint32_t read_ahead_flags)
1404 {
1405 if (read_ahead == DM_READ_AHEAD_AUTO)
1406 return 1;
1407
1408 return _stack_node_op(NODE_READ_AHEAD, dev_name, major, minor, 0, 0,
1409 0, "", read_ahead, read_ahead_flags, 0, 0);
1410 }
1411
1412 void update_devs(void)
1413 {
1414 _pop_node_ops();
1415 }
1416
1417 static int _canonicalize_and_set_dir(const char *src, const char *suffix, size_t max_len, char *dir)
1418 {
1419 size_t len;
1420 const char *slash;
1421
1422 if (*src != '/') {
1423 log_debug("Invalid directory value, %s: "
1424 "not an absolute name.", src);
1425 return 0;
1426 }
1427
1428 len = strlen(src);
1429 slash = src[len-1] == '/' ? "" : "/";
1430
1431 if (dm_snprintf(dir, max_len, "%s%s%s", src, slash, suffix ? suffix : "") < 0) {
1432 log_debug("Invalid directory value, %s: name too long.", src);
1433 return 0;
1434 }
1435
1436 return 1;
1437 }
1438
1439 int dm_set_dev_dir(const char *dev_dir)
1440 {
1441 return _canonicalize_and_set_dir(dev_dir, DM_DIR, sizeof _dm_dir, _dm_dir);
1442 }
1443
1444 const char *dm_dir(void)
1445 {
1446 return _dm_dir;
1447 }
1448
1449 int dm_set_sysfs_dir(const char *sysfs_dir)
1450 {
1451 if (!sysfs_dir || !*sysfs_dir) {
1452 _sysfs_dir[0] = '\0';
1453 return 1;
1454 }
1455 else
1456 return _canonicalize_and_set_dir(sysfs_dir, NULL, sizeof _sysfs_dir, _sysfs_dir);
1457 }
1458
1459 const char *dm_sysfs_dir(void)
1460 {
1461 return _sysfs_dir;
1462 }
1463
1464 /*
1465 * Replace existing uuid_prefix provided it isn't too long.
1466 */
1467 int dm_set_uuid_prefix(const char *uuid_prefix)
1468 {
1469 if (!uuid_prefix)
1470 return_0;
1471
1472 if (strlen(uuid_prefix) > DM_MAX_UUID_PREFIX_LEN) {
1473 log_error("New uuid prefix %s too long.", uuid_prefix);
1474 return 0;
1475 }
1476
1477 strcpy(_default_uuid_prefix, uuid_prefix);
1478
1479 return 1;
1480 }
1481
1482 const char *dm_uuid_prefix(void)
1483 {
1484 return _default_uuid_prefix;
1485 }
1486
1487 static int _sysfs_get_dm_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size)
1488 {
1489 char *sysfs_path, *temp_buf = NULL;
1490 FILE *fp = NULL;
1491 int r = 0;
1492 size_t len;
1493
1494 if (!(sysfs_path = dm_malloc(PATH_MAX)) ||
1495 !(temp_buf = dm_malloc(PATH_MAX))) {
1496 log_error("_sysfs_get_dm_name: failed to allocate temporary buffers");
1497 goto bad;
1498 }
1499
1500 if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32 ":%" PRIu32
1501 "/dm/name", _sysfs_dir, major, minor) < 0) {
1502 log_error("_sysfs_get_dm_name: dm_snprintf failed");
1503 goto bad;
1504 }
1505
1506 if (!(fp = fopen(sysfs_path, "r"))) {
1507 if (errno != ENOENT)
1508 log_sys_error("fopen", sysfs_path);
1509 else
1510 log_sys_debug("fopen", sysfs_path);
1511 goto bad;
1512 }
1513
1514 if (!fgets(temp_buf, PATH_MAX, fp)) {
1515 log_sys_error("fgets", sysfs_path);
1516 goto bad;
1517 }
1518
1519 len = strlen(temp_buf);
1520
1521 if (len > buf_size) {
1522 log_error("_sysfs_get_dm_name: supplied buffer too small");
1523 goto bad;
1524 }
1525
1526 temp_buf[len ? len - 1 : 0] = '\0'; /* \n */
1527 strcpy(buf, temp_buf);
1528 r = 1;
1529 bad:
1530 if (fp && fclose(fp))
1531 log_sys_error("fclose", sysfs_path);
1532
1533 dm_free(temp_buf);
1534 dm_free(sysfs_path);
1535
1536 return r;
1537 }
1538
1539 static int _sysfs_get_kernel_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size)
1540 {
1541 char *name, *sysfs_path, *temp_buf = NULL;
1542 ssize_t size;
1543 size_t len;
1544 int r = 0;
1545
1546 if (!(sysfs_path = dm_malloc(PATH_MAX)) ||
1547 !(temp_buf = dm_malloc(PATH_MAX))) {
1548 log_error("_sysfs_get_kernel_name: failed to allocate temporary buffers");
1549 goto bad;
1550 }
1551
1552 if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32 ":%" PRIu32,
1553 _sysfs_dir, major, minor) < 0) {
1554 log_error("_sysfs_get_kernel_name: dm_snprintf failed");
1555 goto bad;
1556 }
1557
1558 if ((size = readlink(sysfs_path, temp_buf, PATH_MAX - 1)) < 0) {
1559 if (errno != ENOENT)
1560 log_sys_error("readlink", sysfs_path);
1561 else
1562 log_sys_debug("readlink", sysfs_path);
1563 goto bad;
1564 }
1565 temp_buf[size] = '\0';
1566
1567 if (!(name = strrchr(temp_buf, '/'))) {
1568 log_error("Could not locate device kernel name in sysfs path %s", temp_buf);
1569 goto bad;
1570 }
1571 name += 1;
1572 len = size - (name - temp_buf) + 1;
1573
1574 if (len > buf_size) {
1575 log_error("_sysfs_get_kernel_name: output buffer too small");
1576 goto bad;
1577 }
1578
1579 strcpy(buf, name);
1580 r = 1;
1581 bad:
1582 dm_free(temp_buf);
1583 dm_free(sysfs_path);
1584
1585 return r;
1586 }
1587
1588 int dm_device_get_name(uint32_t major, uint32_t minor, int prefer_kernel_name,
1589 char *buf, size_t buf_size)
1590 {
1591 if (!*_sysfs_dir)
1592 return 0;
1593
1594 /*
1595 * device-mapper devices and prefer_kernel_name = 0
1596 * get dm name by reading /sys/dev/block/major:minor/dm/name,
1597 * fallback to _sysfs_get_kernel_name if not successful
1598 */
1599 if (dm_is_dm_major(major) && !prefer_kernel_name) {
1600 if (_sysfs_get_dm_name(major, minor, buf, buf_size))
1601 return 1;
1602 else
1603 stack;
1604 }
1605
1606 /*
1607 * non-device-mapper devices or prefer_kernel_name = 1
1608 * get kernel name using readlink /sys/dev/block/major:minor -> .../dm-X
1609 */
1610 return _sysfs_get_kernel_name(major, minor, buf, buf_size);
1611 }
1612
1613 int dm_device_has_holders(uint32_t major, uint32_t minor)
1614 {
1615 char sysfs_path[PATH_MAX];
1616 struct stat st;
1617
1618 if (!*_sysfs_dir)
1619 return 0;
1620
1621 if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32
1622 ":%" PRIu32 "/holders", _sysfs_dir, major, minor) < 0) {
1623 log_error("sysfs_path dm_snprintf failed");
1624 return 0;
1625 }
1626
1627 if (stat(sysfs_path, &st)) {
1628 log_sys_error("stat", sysfs_path);
1629 return 0;
1630 }
1631
1632 return !dm_is_empty_dir(sysfs_path);
1633 }
1634
1635 static int _mounted_fs_on_device(const char *kernel_dev_name)
1636 {
1637 char sysfs_path[PATH_MAX];
1638 struct dirent *dirent;
1639 DIR *d;
1640 struct stat st;
1641 int r = 0;
1642
1643 if (dm_snprintf(sysfs_path, PATH_MAX, "%sfs", _sysfs_dir) < 0) {
1644 log_error("sysfs_path dm_snprintf failed");
1645 return 0;
1646 }
1647
1648 if (!(d = opendir(sysfs_path))) {
1649 if (errno != ENOENT)
1650 log_sys_error("opendir", sysfs_path);
1651 return 0;
1652 }
1653
1654 while ((dirent = readdir(d))) {
1655 if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, ".."))
1656 continue;
1657
1658 if (dm_snprintf(sysfs_path, PATH_MAX, "%sfs/%s/%s",
1659 _sysfs_dir, dirent->d_name, kernel_dev_name) < 0) {
1660 log_error("sysfs_path dm_snprintf failed");
1661 break;
1662 }
1663
1664 if (!stat(sysfs_path, &st)) {
1665 /* found! */
1666 r = 1;
1667 break;
1668 }
1669 else if (errno != ENOENT) {
1670 log_sys_error("stat", sysfs_path);
1671 break;
1672 }
1673 }
1674
1675 if (closedir(d))
1676 log_error("_fs_present_on_device: %s: closedir failed", kernel_dev_name);
1677
1678 return r;
1679 }
1680
1681 int dm_device_has_mounted_fs(uint32_t major, uint32_t minor)
1682 {
1683 char kernel_dev_name[PATH_MAX];
1684
1685 /* Get kernel device name first */
1686 if (!dm_device_get_name(major, minor, 1, kernel_dev_name, PATH_MAX))
1687 return 0;
1688
1689 /* Check /sys/fs/<fs_name>/<kernel_dev_name> presence */
1690 return _mounted_fs_on_device(kernel_dev_name);
1691 }
1692
1693 int dm_mknodes(const char *name)
1694 {
1695 struct dm_task *dmt;
1696 int r = 0;
1697
1698 if (!(dmt = dm_task_create(DM_DEVICE_MKNODES)))
1699 return 0;
1700
1701 if (name && !dm_task_set_name(dmt, name))
1702 goto out;
1703
1704 if (!dm_task_no_open_count(dmt))
1705 goto out;
1706
1707 r = dm_task_run(dmt);
1708
1709 out:
1710 dm_task_destroy(dmt);
1711 return r;
1712 }
1713
1714 int dm_driver_version(char *version, size_t size)
1715 {
1716 struct dm_task *dmt;
1717 int r = 0;
1718
1719 if (!(dmt = dm_task_create(DM_DEVICE_VERSION)))
1720 return 0;
1721
1722 if (!dm_task_run(dmt))
1723 log_error("Failed to get driver version");
1724
1725 if (!dm_task_get_driver_version(dmt, version, size))
1726 goto out;
1727
1728 r = 1;
1729
1730 out:
1731 dm_task_destroy(dmt);
1732 return r;
1733 }
1734
1735 #ifndef UDEV_SYNC_SUPPORT
1736 void dm_udev_set_sync_support(int sync_with_udev)
1737 {
1738 }
1739
1740 int dm_udev_get_sync_support(void)
1741 {
1742 return 0;
1743 }
1744
1745 void dm_udev_set_checking(int checking)
1746 {
1747 }
1748
1749 int dm_udev_get_checking(void)
1750 {
1751 return 0;
1752 }
1753
1754 int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags)
1755 {
1756 if (dm_cookie_supported())
1757 dmt->event_nr = flags << DM_UDEV_FLAGS_SHIFT;
1758 *cookie = 0;
1759
1760 return 1;
1761 }
1762
1763 int dm_udev_complete(uint32_t cookie)
1764 {
1765 return 1;
1766 }
1767
1768 int dm_udev_wait(uint32_t cookie)
1769 {
1770 update_devs();
1771
1772 return 1;
1773 }
1774
1775 #else /* UDEV_SYNC_SUPPORT */
1776
1777 static int _check_semaphore_is_supported(void)
1778 {
1779 int maxid;
1780 union semun arg;
1781 struct seminfo seminfo;
1782
1783 arg.__buf = &seminfo;
1784 maxid = semctl(0, 0, SEM_INFO, arg);
1785
1786 if (maxid < 0) {
1787 log_warn("Kernel not configured for semaphores (System V IPC). "
1788 "Not using udev synchronisation code.");
1789 return 0;
1790 }
1791
1792 return 1;
1793 }
1794
1795 static int _check_udev_is_running(void)
1796 {
1797 struct udev *udev;
1798 struct udev_queue *udev_queue;
1799 int r;
1800
1801 if (!(udev = udev_new()))
1802 goto_bad;
1803
1804 if (!(udev_queue = udev_queue_new(udev))) {
1805 udev_unref(udev);
1806 goto_bad;
1807 }
1808
1809 if (!(r = udev_queue_get_udev_is_active(udev_queue)))
1810 log_debug("Udev is not running. "
1811 "Not using udev synchronisation code.");
1812
1813 udev_queue_unref(udev_queue);
1814 udev_unref(udev);
1815
1816 return r;
1817
1818 bad:
1819 log_error("Could not get udev state. Assuming udev is not running.");
1820 return 0;
1821 }
1822
1823 static void _check_udev_sync_requirements_once(void)
1824 {
1825 if (_semaphore_supported < 0)
1826 _semaphore_supported = _check_semaphore_is_supported();
1827
1828 if (_udev_running < 0)
1829 _udev_running = _check_udev_is_running();
1830 }
1831
1832 void dm_udev_set_sync_support(int sync_with_udev)
1833 {
1834 _check_udev_sync_requirements_once();
1835 _sync_with_udev = sync_with_udev;
1836 }
1837
1838 int dm_udev_get_sync_support(void)
1839 {
1840 _check_udev_sync_requirements_once();
1841
1842 return _semaphore_supported && dm_cookie_supported() &&
1843 _udev_running && _sync_with_udev;
1844 }
1845
1846 void dm_udev_set_checking(int checking)
1847 {
1848 if ((_udev_checking = checking))
1849 log_debug("DM udev checking enabled");
1850 else
1851 log_debug("DM udev checking disabled");
1852 }
1853
1854 int dm_udev_get_checking(void)
1855 {
1856 return _udev_checking;
1857 }
1858
1859 static int _get_cookie_sem(uint32_t cookie, int *semid)
1860 {
1861 if (cookie >> 16 != DM_COOKIE_MAGIC) {
1862 log_error("Could not continue to access notification "
1863 "semaphore identified by cookie value %"
1864 PRIu32 " (0x%x). Incorrect cookie prefix.",
1865 cookie, cookie);
1866 return 0;
1867 }
1868
1869 if ((*semid = semget((key_t) cookie, 1, 0)) >= 0)
1870 return 1;
1871
1872 switch (errno) {
1873 case ENOENT:
1874 log_error("Could not find notification "
1875 "semaphore identified by cookie "
1876 "value %" PRIu32 " (0x%x)",
1877 cookie, cookie);
1878 break;
1879 case EACCES:
1880 log_error("No permission to access "
1881 "notificaton semaphore identified "
1882 "by cookie value %" PRIu32 " (0x%x)",
1883 cookie, cookie);
1884 break;
1885 default:
1886 log_error("Failed to access notification "
1887 "semaphore identified by cookie "
1888 "value %" PRIu32 " (0x%x): %s",
1889 cookie, cookie, strerror(errno));
1890 break;
1891 }
1892
1893 return 0;
1894 }
1895
1896 static int _udev_notify_sem_inc(uint32_t cookie, int semid)
1897 {
1898 struct sembuf sb = {0, 1, 0};
1899 int val;
1900
1901 if (semop(semid, &sb, 1) < 0) {
1902 log_error("semid %d: semop failed for cookie 0x%" PRIx32 ": %s",
1903 semid, cookie, strerror(errno));
1904 return 0;
1905 }
1906
1907 if ((val = semctl(semid, 0, GETVAL)) < 0) {
1908 log_error("semid %d: sem_ctl GETVAL failed for "
1909 "cookie 0x%" PRIx32 ": %s",
1910 semid, cookie, strerror(errno));
1911 return 0;
1912 }
1913
1914 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) incremented to %d",
1915 cookie, semid, val);
1916
1917 return 1;
1918 }
1919
1920 static int _udev_notify_sem_dec(uint32_t cookie, int semid)
1921 {
1922 struct sembuf sb = {0, -1, IPC_NOWAIT};
1923 int val;
1924
1925 if ((val = semctl(semid, 0, GETVAL)) < 0) {
1926 log_error("semid %d: sem_ctl GETVAL failed for "
1927 "cookie 0x%" PRIx32 ": %s",
1928 semid, cookie, strerror(errno));
1929 return 0;
1930 }
1931
1932 if (semop(semid, &sb, 1) < 0) {
1933 switch (errno) {
1934 case EAGAIN:
1935 log_error("semid %d: semop failed for cookie "
1936 "0x%" PRIx32 ": "
1937 "incorrect semaphore state",
1938 semid, cookie);
1939 break;
1940 default:
1941 log_error("semid %d: semop failed for cookie "
1942 "0x%" PRIx32 ": %s",
1943 semid, cookie, strerror(errno));
1944 break;
1945 }
1946 return 0;
1947 }
1948
1949 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) decremented to %d",
1950 cookie, semid, val - 1);
1951
1952 return 1;
1953 }
1954
1955 static int _udev_notify_sem_destroy(uint32_t cookie, int semid)
1956 {
1957 if (semctl(semid, 0, IPC_RMID, 0) < 0) {
1958 log_error("Could not cleanup notification semaphore "
1959 "identified by cookie value %" PRIu32 " (0x%x): %s",
1960 cookie, cookie, strerror(errno));
1961 return 0;
1962 }
1963
1964 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) destroyed", cookie,
1965 semid);
1966
1967 return 1;
1968 }
1969
1970 static int _udev_notify_sem_create(uint32_t *cookie, int *semid)
1971 {
1972 int fd;
1973 int gen_semid;
1974 int val;
1975 uint16_t base_cookie;
1976 uint32_t gen_cookie;
1977 union semun sem_arg;
1978
1979 if ((fd = open("/dev/urandom", O_RDONLY)) < 0) {
1980 log_error("Failed to open /dev/urandom "
1981 "to create random cookie value");
1982 *cookie = 0;
1983 return 0;
1984 }
1985
1986 /* Generate random cookie value. Be sure it is unique and non-zero. */
1987 do {
1988 /* FIXME Handle non-error returns from read(). Move _io() into libdm? */
1989 if (read(fd, &base_cookie, sizeof(base_cookie)) != sizeof(base_cookie)) {
1990 log_error("Failed to initialize notification cookie");
1991 goto bad;
1992 }
1993
1994 gen_cookie = DM_COOKIE_MAGIC << 16 | base_cookie;
1995
1996 if (base_cookie && (gen_semid = semget((key_t) gen_cookie,
1997 1, 0600 | IPC_CREAT | IPC_EXCL)) < 0) {
1998 switch (errno) {
1999 case EEXIST:
2000 /* if the semaphore key exists, we
2001 * simply generate another random one */
2002 base_cookie = 0;
2003 break;
2004 case ENOMEM:
2005 log_error("Not enough memory to create "
2006 "notification semaphore");
2007 goto bad;
2008 case ENOSPC:
2009 log_error("Limit for the maximum number "
2010 "of semaphores reached. You can "
2011 "check and set the limits in "
2012 "/proc/sys/kernel/sem.");
2013 goto bad;
2014 default:
2015 log_error("Failed to create notification "
2016 "semaphore: %s", strerror(errno));
2017 goto bad;
2018 }
2019 }
2020 } while (!base_cookie);
2021
2022 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) created",
2023 gen_cookie, gen_semid);
2024
2025 sem_arg.val = 1;
2026
2027 if (semctl(gen_semid, 0, SETVAL, sem_arg) < 0) {
2028 log_error("semid %d: semctl failed: %s", gen_semid, strerror(errno));
2029 /* We have to destroy just created semaphore
2030 * so it won't stay in the system. */
2031 (void) _udev_notify_sem_destroy(gen_cookie, gen_semid);
2032 goto bad;
2033 }
2034
2035 if ((val = semctl(gen_semid, 0, GETVAL)) < 0) {
2036 log_error("semid %d: sem_ctl GETVAL failed for "
2037 "cookie 0x%" PRIx32 ": %s",
2038 gen_semid, gen_cookie, strerror(errno));
2039 goto bad;
2040 }
2041
2042 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) incremented to %d",
2043 gen_cookie, gen_semid, val);
2044
2045 if (close(fd))
2046 stack;
2047
2048 *semid = gen_semid;
2049 *cookie = gen_cookie;
2050
2051 return 1;
2052
2053 bad:
2054 if (close(fd))
2055 stack;
2056
2057 *cookie = 0;
2058
2059 return 0;
2060 }
2061
2062 int dm_udev_create_cookie(uint32_t *cookie)
2063 {
2064 int semid;
2065
2066 if (!dm_udev_get_sync_support()) {
2067 *cookie = 0;
2068 return 1;
2069 }
2070
2071 return _udev_notify_sem_create(cookie, &semid);
2072 }
2073
2074 static const char *_task_type_disp(int type)
2075 {
2076 switch(type) {
2077 case DM_DEVICE_CREATE:
2078 return "CREATE";
2079 case DM_DEVICE_RELOAD:
2080 return "RELOAD";
2081 case DM_DEVICE_REMOVE:
2082 return "REMOVE";
2083 case DM_DEVICE_REMOVE_ALL:
2084 return "REMOVE_ALL";
2085 case DM_DEVICE_SUSPEND:
2086 return "SUSPEND";
2087 case DM_DEVICE_RESUME:
2088 return "RESUME";
2089 case DM_DEVICE_INFO:
2090 return "INFO";
2091 case DM_DEVICE_DEPS:
2092 return "DEPS";
2093 case DM_DEVICE_RENAME:
2094 return "RENAME";
2095 case DM_DEVICE_VERSION:
2096 return "VERSION";
2097 case DM_DEVICE_STATUS:
2098 return "STATUS";
2099 case DM_DEVICE_TABLE:
2100 return "TABLE";
2101 case DM_DEVICE_WAITEVENT:
2102 return "WAITEVENT";
2103 case DM_DEVICE_LIST:
2104 return "LIST";
2105 case DM_DEVICE_CLEAR:
2106 return "CLEAR";
2107 case DM_DEVICE_MKNODES:
2108 return "MKNODES";
2109 case DM_DEVICE_LIST_VERSIONS:
2110 return "LIST_VERSIONS";
2111 case DM_DEVICE_TARGET_MSG:
2112 return "TARGET_MSG";
2113 case DM_DEVICE_SET_GEOMETRY:
2114 return "SET_GEOMETRY";
2115 }
2116 return "unknown";
2117 }
2118
2119 int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags)
2120 {
2121 int semid;
2122
2123 if (dm_cookie_supported())
2124 dmt->event_nr = flags << DM_UDEV_FLAGS_SHIFT;
2125
2126 if (!dm_udev_get_sync_support()) {
2127 *cookie = 0;
2128 return 1;
2129 }
2130
2131 if (*cookie) {
2132 if (!_get_cookie_sem(*cookie, &semid))
2133 goto_bad;
2134 } else if (!_udev_notify_sem_create(cookie, &semid))
2135 goto_bad;
2136
2137 if (!_udev_notify_sem_inc(*cookie, semid)) {
2138 log_error("Could not set notification semaphore "
2139 "identified by cookie value %" PRIu32 " (0x%x)",
2140 *cookie, *cookie);
2141 goto bad;
2142 }
2143
2144 dmt->event_nr |= ~DM_UDEV_FLAGS_MASK & *cookie;
2145 dmt->cookie_set = 1;
2146
2147 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) assigned to "
2148 "%s task(%d) with flags%s%s%s%s%s%s%s (0x%" PRIx16 ")", *cookie, semid, _task_type_disp(dmt->type), dmt->type,
2149 (flags & DM_UDEV_DISABLE_DM_RULES_FLAG) ? " DISABLE_DM_RULES" : "",
2150 (flags & DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG) ? " DISABLE_SUBSYSTEM_RULES" : "",
2151 (flags & DM_UDEV_DISABLE_DISK_RULES_FLAG) ? " DISABLE_DISK_RULES" : "",
2152 (flags & DM_UDEV_DISABLE_OTHER_RULES_FLAG) ? " DISABLE_OTHER_RULES" : "",
2153 (flags & DM_UDEV_LOW_PRIORITY_FLAG) ? " LOW_PRIORITY" : "",
2154 (flags & DM_UDEV_DISABLE_LIBRARY_FALLBACK) ? " DISABLE_LIBRARY_FALLBACK" : "",
2155 (flags & DM_UDEV_PRIMARY_SOURCE_FLAG) ? " PRIMARY_SOURCE" : "",
2156 flags);
2157
2158 return 1;
2159
2160 bad:
2161 dmt->event_nr = 0;
2162 return 0;
2163 }
2164
2165 int dm_udev_complete(uint32_t cookie)
2166 {
2167 int semid;
2168
2169 if (!cookie || !dm_udev_get_sync_support())
2170 return 1;
2171
2172 if (!_get_cookie_sem(cookie, &semid))
2173 return_0;
2174
2175 if (!_udev_notify_sem_dec(cookie, semid)) {
2176 log_error("Could not signal waiting process using notification "
2177 "semaphore identified by cookie value %" PRIu32 " (0x%x)",
2178 cookie, cookie);
2179 return 0;
2180 }
2181
2182 return 1;
2183 }
2184
2185 static int _udev_wait(uint32_t cookie)
2186 {
2187 int semid;
2188 struct sembuf sb = {0, 0, 0};
2189
2190 if (!cookie || !dm_udev_get_sync_support())
2191 return 1;
2192
2193 if (!_get_cookie_sem(cookie, &semid))
2194 return_0;
2195
2196 if (!_udev_notify_sem_dec(cookie, semid)) {
2197 log_error("Failed to set a proper state for notification "
2198 "semaphore identified by cookie value %" PRIu32 " (0x%x) "
2199 "to initialize waiting for incoming notifications.",
2200 cookie, cookie);
2201 (void) _udev_notify_sem_destroy(cookie, semid);
2202 return 0;
2203 }
2204
2205 log_debug("Udev cookie 0x%" PRIx32 " (semid %d) waiting for zero",
2206 cookie, semid);
2207
2208 repeat_wait:
2209 if (semop(semid, &sb, 1) < 0) {
2210 if (errno == EINTR)
2211 goto repeat_wait;
2212 else if (errno == EIDRM)
2213 return 1;
2214
2215 log_error("Could not set wait state for notification semaphore "
2216 "identified by cookie value %" PRIu32 " (0x%x): %s",
2217 cookie, cookie, strerror(errno));
2218 (void) _udev_notify_sem_destroy(cookie, semid);
2219 return 0;
2220 }
2221
2222 return _udev_notify_sem_destroy(cookie, semid);
2223 }
2224
2225 int dm_udev_wait(uint32_t cookie)
2226 {
2227 int r = _udev_wait(cookie);
2228
2229 update_devs();
2230
2231 return r;
2232 }
2233
2234 #endif /* UDEV_SYNC_SUPPORT */
LVM2 upstream repository (moved from fedorahosted in Feb 2017)
This page took 0.131855 seconds and 5 git commands to generate.