Home | History | Annotate | Line # | Download | only in misc 
      1 /*	$NetBSD: lvm-file.c,v 1.1.1.3 2009/12/02 00:26:44 haad Exp $	*/
      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 }
    288