external/gpl2/lvm2/dist/lib/misc/lvm-file.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of LVM2.
   8  *
   9  * This copyrighted material is made available to anyone wishing to use,
  10  * modify, copy, or redistribute it subject to the terms and conditions
  11  * of the GNU Lesser General Public License v.2.1.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 #include "lib.h"
  19 #include "lvm-file.h"
  20 #include "lvm-string.h"
  21
  22 #include <unistd.h>
  23 #include <sys/stat.h>
  24 #include <sys/file.h>
  25 #include <fcntl.h>
  26 #include <dirent.h>
  27
  28 /*
  29  * Creates a temporary filename, and opens a descriptor to the
  30  * file.  Both the filename and descriptor are needed so we can
  31  * rename the file after successfully writing it.  Grab
  32  * NFS-supported exclusive fcntl discretionary lock.
  33  */
  34 int create_temp_name(const char *dir, char *buffer, size_t len, int *fd,
  35                      unsigned *seed)
  36 {
  37         int i, num;
  38         pid_t pid;
  39         char hostname[255];
  40         struct flock lock = {
  41                 .l_type = F_WRLCK,
  42                 .l_whence = 0,
  43                 .l_start = 0,
  44                 .l_len = 0
  45         };
  46
  47         num = rand_r(seed);
  48         pid = getpid();
  49         if (gethostname(hostname, sizeof(hostname)) < 0) {
  50                 log_sys_error("gethostname", "");
  51                 strcpy(hostname, "nohostname");
  52         }
  53
  54         for (i = 0; i < 20; i++, num++) {
  55
  56                 if (dm_snprintf(buffer, len, "%s/.lvm_%s_%d_%d",
  57                                  dir, hostname, pid, num) == -1) {
  58                         log_error("Not enough space to build temporary file "
  59                                   "string.");
  60                         return 0;
  61                 }
  62
  63                 *fd = open(buffer, O_CREAT | O_EXCL | O_WRONLY | O_APPEND,
  64                            S_IRUSR | S_IRGRP | S_IROTH |
  65                            S_IWUSR | S_IWGRP | S_IWOTH);
  66                 if (*fd < 0)
  67                         continue;
  68
  69                 if (!fcntl(*fd, F_SETLK, &lock))
  70                         return 1;
  71
  72                 if (close(*fd))
  73                         log_sys_error("close", buffer);
  74         }
  75
  76         return 0;
  77 }
  78
  79 /*
  80  * NFS-safe rename of a temporary file to a common name, designed
  81  * to avoid race conditions and not overwrite the destination if
  82  * it exists.
  83  *
  84  * Try to create the new filename as a hard link to the original.
  85  * Check the link count of the original file to see if it worked.
  86  * (Assumes nothing else touches our temporary file!)  If it
  87  * worked, unlink the old filename.
  88  */
  89 int lvm_rename(const char *old, const char *new)
  90 {
  91         struct stat buf;
  92
  93         if (link(old, new)) {
  94                 log_error("%s: rename to %s failed: %s", old, new,
  95                           strerror(errno));
  96                 return 0;
  97         }
  98
  99         if (stat(old, &buf)) {
 100                 log_sys_error("stat", old);
 101                 return 0;
 102         }
 103
 104         if (buf.st_nlink != 2) {
 105                 log_error("%s: rename to %s failed", old, new);
 106                 return 0;
 107         }
 108
 109         if (unlink(old)) {
 110                 log_sys_error("unlink", old);
 111                 return 0;
 112         }
 113
 114         return 1;
 115 }
 116
 117 int path_exists(const char *path)
 118 {
 119         struct stat info;
 120
 121         if (!*path)
 122                 return 0;
 123
 124         if (stat(path, &info) < 0)
 125                 return 0;
 126
 127         return 1;
 128 }
 129
 130 int dir_exists(const char *path)
 131 {
 132         struct stat info;
 133
 134         if (!*path)
 135                 return 0;
 136
 137         if (stat(path, &info) < 0)
 138                 return 0;
 139
 140         if (!S_ISDIR(info.st_mode))
 141                 return 0;
 142
 143         return 1;
 144 }
 145
 146 int is_empty_dir(const char *dir)
 147 {
 148         struct dirent *dirent;
 149         DIR *d;
 150
 151         if (!(d = opendir(dir))) {
 152                 log_sys_error("opendir", dir);
 153                 return 0;
 154         }
 155
 156         while ((dirent = readdir(d)))
 157                 if (strcmp(dirent->d_name, ".") && strcmp(dirent->d_name, ".."))
 158                         break;
 159
 160         if (closedir(d)) {
 161                 log_sys_error("closedir", dir);
 162         }
 163
 164         return dirent ? 0 : 1;
 165 }
 166
 167 void sync_dir(const char *file)
 168 {
 169         int fd;
 170         char *dir, *c;
 171
 172         if (!(dir = dm_strdup(file))) {
 173                 log_error("sync_dir failed in strdup");
 174                 return;
 175         }
 176
 177         if (!dir_exists(dir)) {
 178                 c = dir + strlen(dir);
 179                 while (*c != '/' && c > dir)
 180                         c--;
 181
 182                 if (c == dir)
 183                         *c++ = '.';
 184
 185                 *c = '\0';
 186         }
 187
 188         if ((fd = open(dir, O_RDONLY)) == -1) {
 189                 log_sys_error("open", dir);
 190                 goto out;
 191         }
 192
 193         if (fsync(fd) && (errno != EROFS) && (errno != EINVAL))
 194                 log_sys_error("fsync", dir);
 195
 196         if (close(fd))
 197                 log_sys_error("close", dir);
 198
 199       out:
 200         dm_free(dir);
 201 }
 202
 203 /*
 204  * Attempt to obtain fcntl lock on a file, if necessary creating file first
 205  * or waiting.
 206  * Returns file descriptor on success, else -1.
 207  * mode is F_WRLCK or F_RDLCK
 208  */
 209 int fcntl_lock_file(const char *file, short lock_type, int warn_if_read_only)
 210 {
 211         int lockfd;
 212         char *dir;
 213         char *c;
 214         struct flock lock = {
 215                 .l_type = lock_type,
 216                 .l_whence = 0,
 217                 .l_start = 0,
 218                 .l_len = 0
 219         };
 220
 221         if (!(dir = dm_strdup(file))) {
 222                 log_error("fcntl_lock_file failed in strdup.");
 223                 return -1;
 224         }
 225
 226         if ((c = strrchr(dir, '/')))
 227                 *c = '\0';
 228
 229         if (!dm_create_dir(dir)) {
 230                 dm_free(dir);
 231                 return -1;
 232         }
 233
 234         dm_free(dir);
 235
 236         log_very_verbose("Locking %s (%s, %hd)", file,
 237                          (lock_type == F_WRLCK) ? "F_WRLCK" : "F_RDLCK",
 238                          lock_type);
 239         if ((lockfd = open(file, O_RDWR | O_CREAT, 0777)) < 0) {
 240                 /* EACCES has been reported on NFS */
 241                 if (warn_if_read_only || (errno != EROFS && errno != EACCES))
 242                         log_sys_error("open", file);
 243                 else
 244                         stack;
 245
 246                 return -1;
 247         }
 248
 249         if (fcntl(lockfd, F_SETLKW, &lock)) {
 250                 log_sys_error("fcntl", file);
 251                 close(lockfd);
 252                 return -1;
 253         }
 254
 255         return lockfd;
 256 }
 257
 258 void fcntl_unlock_file(int lockfd)
 259 {
 260         struct flock lock = {
 261                 .l_type = F_UNLCK,
 262                 .l_whence = 0,
 263                 .l_start = 0,
 264                 .l_len = 0
 265         };
 266
 267         log_very_verbose("Unlocking fd %d", lockfd);
 268
 269         if (fcntl(lockfd, F_SETLK, &lock) == -1)
 270                 log_error("fcntl unlock failed on fd %d: %s", lockfd,
 271                           strerror(errno));
 272
 273         if (close(lockfd))
 274                 log_error("lock file close failed on fd %d: %s", lockfd,
 275                           strerror(errno));
 276 }
 277
 278 int lvm_fclose(FILE *fp, const char *filename)
 279 {
 280         if (!dm_fclose(fp))
 281                 return 0;
 282         if (errno == 0)
 283                 log_error("%s: write error", filename);
 284         else
 285                 log_sys_error("write error", filename);
 286         return EOF;
 287 }