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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <stdio.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <sys/errno.h> 30 #include <sys/param.h> 31 #include <sys/stat.h> 32 #include <sys/types.h> 33 #include <unistd.h> 34 #include <vroot/vroot.h> 35 #include <signal.h> 36 #include <errno.h> /* errno */ 37 #include <libintl.h> 38 39 extern char *sys_errlist[]; 40 extern int sys_nerr; 41 42 static void file_lock_error(char *msg, char *file, char *str, int arg1, int arg2); 43 44 #define BLOCK_INTERUPTS sigfillset(&newset) ; \ 45 sigprocmask(SIG_SETMASK, &newset, &oldset) 46 47 #define UNBLOCK_INTERUPTS \ 48 sigprocmask(SIG_SETMASK, &oldset, &newset) 49 50 /* 51 * This code stolen from the NSE library and changed to not depend 52 * upon any NSE routines or header files. 53 * 54 * Simple file locking. 55 * Create a symlink to a file. The "test and set" will be 56 * atomic as creating the symlink provides both functions. 57 * 58 * The timeout value specifies how long to wait for stale locks 59 * to disappear. If the lock is more than 'timeout' seconds old 60 * then it is ok to blow it away. This part has a small window 61 * of vunerability as the operations of testing the time, 62 * removing the lock and creating a new one are not atomic. 63 * It would be possible for two processes to both decide to blow 64 * away the lock and then have process A remove the lock and establish 65 * its own, and then then have process B remove the lock which accidentily 66 * removes A's lock rather than the stale one. 67 * 68 * A further complication is with the NFS. If the file in question is 69 * being served by an NFS server, then its time is set by that server. 70 * We can not use the time on the client machine to check for a stale 71 * lock. Therefore, a temp file on the server is created to get 72 * the servers current time. 73 * 74 * Returns an error message. NULL return means the lock was obtained. 75 * 76 * 12/6/91 Added the parameter "file_locked". Before this parameter 77 * was added, the calling procedure would have to wait for file_lock() 78 * to return before it sets the flag. If the user interrupted "make" 79 * between the time the lock was acquired and the time file_lock() 80 * returns, make wouldn't know that the file has been locked, and therefore 81 * it wouldn' remove the lock. Setting the flag right after locking the file 82 * makes this window much smaller. 83 */ 84 85 int 86 file_lock(char *name, char *lockname, int *file_locked, int timeout) 87 { 88 int counter = 0; 89 static char msg[MAXPATHLEN+1]; 90 int printed_warning = 0; 91 int r; 92 struct stat statb; 93 sigset_t newset; 94 sigset_t oldset; 95 96 *file_locked = 0; 97 if (timeout <= 0) { 98 timeout = 120; 99 } 100 for (;;) { 101 BLOCK_INTERUPTS; 102 r = symlink(name, lockname); 103 if (r == 0) { 104 *file_locked = 1; 105 UNBLOCK_INTERUPTS; 106 return 0; /* success */ 107 } 108 UNBLOCK_INTERUPTS; 109 110 if (errno != EEXIST) { 111 file_lock_error(msg, name, (char *)"symlink(%s, %s)", 112 (int) name, (int) lockname); 113 fprintf(stderr, "%s", msg); 114 return errno; 115 } 116 117 counter = 0; 118 for (;;) { 119 sleep(1); 120 r = lstat(lockname, &statb); 121 if (r == -1) { 122 /* 123 * The lock must have just gone away - try 124 * again. 125 */ 126 break; 127 } 128 129 if ((counter > 5) && (!printed_warning)) { 130 /* Print waiting message after 5 secs */ 131 (void) getcwd(msg, MAXPATHLEN); 132 fprintf(stderr, 133 gettext("file_lock: file %s is already locked.\n"), 134 name); 135 fprintf(stderr, 136 gettext("file_lock: will periodically check the lockfile %s for two minutes.\n"), 137 lockname); 138 fprintf(stderr, 139 gettext("Current working directory %s\n"), 140 msg); 141 142 printed_warning = 1; 143 } 144 145 if (++counter > timeout ) { 146 /* 147 * Waited enough - return an error.. 148 */ 149 return EEXIST; 150 } 151 } 152 } 153 /* NOTREACHED */ 154 } 155 156 /* 157 * Format a message telling why the lock could not be created. 158 */ 159 static void 160 file_lock_error(char *msg, char *file, char *str, int arg1, int arg2) 161 { 162 int len; 163 164 sprintf(msg, gettext("Could not lock file `%s'; "), file); 165 len = strlen(msg); 166 sprintf(&msg[len], str, arg1, arg2); 167 strcat(msg, gettext(" failed - ")); 168 if (errno < sys_nerr) { 169 strcat(msg, strerror(errno)); 170 } else { 171 len = strlen(msg); 172 sprintf(&msg[len], "errno %d", errno); 173 } 174 } 175 176