1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <unistd.h> 31 #include <string.h> 32 #include <fcntl.h> 33 #include <sys/types.h> 34 #include <sys/param.h> 35 #include <sys/stat.h> 36 #include <errno.h> 37 38 39 /* 40 * Format a message telling why the lock could not be created. 41 */ 42 /* VARARGS5 */ 43 static void 44 file_lock_error(char *msg, char *file, int err, const char *str, 45 char *arg1, char *arg2, size_t mlen) 46 { 47 size_t len; 48 char *errstr; 49 50 (void) snprintf(msg, mlen, "Could not lock file `%s'; ", file); 51 len = strlen(msg); 52 (void) snprintf(&msg[len], (mlen - len), str, arg1, arg2); 53 (void) strcat(msg, " failed - "); 54 if ((errstr = strerror(err)) != NULL) { 55 (void) strlcat(msg, errstr, mlen); 56 } else { 57 len = strlen(msg); 58 (void) sprintf(&msg[len], "errno %d", err); 59 } 60 } 61 62 /* 63 * This code stolen from the NSE library and changed to not depend 64 * upon any NSE routines or header files. 65 * 66 * Simple file locking. 67 * Create a symlink to a file. The "test and set" will be 68 * atomic as creating the symlink provides both functions. 69 * 70 * The timeout value specifies how long to wait for stale locks 71 * to disappear. If the lock is more than 'timeout' seconds old 72 * then it is ok to blow it away. This part has a small window 73 * of vunerability as the operations of testing the time, 74 * removing the lock and creating a new one are not atomic. 75 * It would be possible for two processes to both decide to blow 76 * away the lock and then have process A remove the lock and establish 77 * its own, and then then have process B remove the lock which accidentily 78 * removes A's lock rather than the stale one. 79 * 80 * A further complication is with the NFS. If the file in question is 81 * being served by an NFS server, then its time is set by that server. 82 * We can not use the time on the client machine to check for a stale 83 * lock. Therefore, a temp file on the server is created to get 84 * the servers current time. 85 * 86 * Returns an error message. NULL return means the lock was obtained. 87 * 88 */ 89 char * 90 file_lock(char *name, char *lockname, int timeout) 91 { 92 int r; 93 int fd; 94 struct stat statb; 95 struct stat fs_statb; 96 char tmpname[MAXPATHLEN]; 97 static char msg[MAXPATHLEN]; 98 99 if (timeout <= 0) { 100 timeout = 15; 101 } 102 for (;;) { 103 r = symlink(name, lockname); 104 if (r == 0) { 105 return (NULL); 106 } 107 if (errno != EEXIST) { 108 file_lock_error(msg, name, errno, 109 (const char *)"symlink(%s, %s)", name, lockname, 110 sizeof (msg)); 111 return (msg); 112 } 113 for (;;) { 114 (void) sleep(1); 115 r = lstat(lockname, &statb); 116 if (r == -1) { 117 /* 118 * The lock must have just gone away - try 119 * again. 120 */ 121 break; 122 } 123 124 /* 125 * With the NFS the time given a file is the time on 126 * the file server. This time may vary from the 127 * client's time. Therefore, we create a tmpfile in 128 * the same directory to establish the time on the 129 * server and use this time to see if the lock has 130 * expired. 131 */ 132 (void) snprintf(tmpname, MAXPATHLEN, "%s.XXXXXX", 133 lockname); 134 (void) mktemp(tmpname); 135 fd = creat(tmpname, 0666); 136 if (fd != -1) { 137 (void) close(fd); 138 } else { 139 file_lock_error(msg, name, errno, 140 (const char *)"creat(%s)", tmpname, 0, 141 sizeof (msg)); 142 return (msg); 143 } 144 if (stat(tmpname, &fs_statb) == -1) { 145 file_lock_error(msg, name, errno, 146 (const char *)"stat(%s)", tmpname, 0, 147 sizeof (msg)); 148 return (msg); 149 } 150 (void) unlink(tmpname); 151 if (statb.st_mtime + timeout < fs_statb.st_mtime) { 152 /* 153 * The lock has expired - blow it away. 154 */ 155 (void) unlink(lockname); 156 break; 157 } 158 } 159 } 160 /* NOTREACHED */ 161 } 162