xref: /illumos-gate/usr/src/lib/libnsl/dial/ulockf.c (revision e8031f0a)
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 /*
24  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 #include "mt.h"
34 #include "uucp.h"
35 
36 static void	stlock(char *);
37 static int	onelock(char *, char *, char *);
38 
39 /*
40  * make a lock file with given 'name'
41  * If one already exists, send a signal 0 to the process--if
42  * it fails, then unlink it and make a new one.
43  *
44  * input:
45  *	name - name of the lock file to make
46  *
47  * return:
48  *	0	-> success
49  *	FAIL	-> failure
50  */
51 
52 static int
mklock(char * name)53 mklock(char *name)
54 {
55 	static	char pid[SIZEOFPID+2] = { '\0' }; /* +2 for '\n' and NULL */
56 	static char *tempfile;
57 
58 	if (pid[0] == '\0') {
59 		tempfile = malloc(MAXNAMESIZE);
60 		if (tempfile == NULL)
61 			return (FAIL);
62 		(void) sprintf(pid, "%*ld\n", SIZEOFPID, (long)getpid());
63 		(void) snprintf(tempfile, MAXNAMESIZE, "%s/LTMP.%ld", X_LOCKDIR,
64 							(long)getpid());
65 	}
66 
67 	if (onelock(pid, tempfile, name) == -1) {
68 		(void) unlink(tempfile);
69 		if (cklock(name))
70 			return (FAIL);
71 		else {
72 			if (onelock(pid, tempfile, name)) {
73 			(void) unlink(tempfile);
74 			DEBUG(4, "ulockf failed in onelock()\n%s", "");
75 			return (FAIL);
76 			}
77 		}
78 	}
79 	stlock(name);
80 	return (0);
81 }
82 
83 /*
84  * check to see if the lock file exists and is still active
85  * - use kill(pid, 0)
86  *
87  * return:
88  *	0	-> success (lock file removed - no longer active
89  *	FAIL	-> lock file still active
90  */
91 static int
cklock(char * name)92 cklock(char *name)
93 {
94 	int ret;
95 	pid_t lpid = -1;
96 	char alpid[SIZEOFPID+2];	/* +2 for '\n' and NULL */
97 	int fd;
98 
99 	fd = open(name, O_RDONLY);
100 	DEBUG(4, "ulockf name %s\n", name);
101 	if (fd == -1) {
102 		if (errno == ENOENT) {	/* file does not exist -- OK */
103 			return (0);
104 		}
105 		DEBUG(4, "Lock File--can't read (errno %d) --remove it!\n",
106 									errno);
107 		goto unlk;
108 	}
109 	ret = read(fd, (char *)alpid, SIZEOFPID + 1); /* +1 for '\n' */
110 	(void) close(fd);
111 	if (ret != (SIZEOFPID+1)) {
112 
113 		DEBUG(4, "Lock File--bad format--remove it!\n%s", "");
114 		goto unlk;
115 	}
116 	lpid = (pid_t)strtol(alpid, NULL, 10);
117 	if ((ret = kill(lpid, 0)) == 0 || errno == EPERM) {
118 		DEBUG(4, "Lock File--process still active--not removed\n%s",
119 									"");
120 		return (FAIL);
121 	}
122 	/* process no longer active */
123 	DEBUG(4, "kill pid (%ld), ", (long)lpid);
124 	DEBUG(4, "returned %d", ret);
125 	DEBUG(4, "--ok to remove lock file (%s)\n", name);
126 unlk:
127 
128 	if (unlink(name) != 0) {
129 		DEBUG(4, "ulockf failed in unlink()\n%s", "");
130 		return (FAIL);
131 	}
132 	return (0);
133 }
134 
135 #define	MAXLOCKS	10	/* maximum number of lock files */
136 static char *Lockfile[MAXLOCKS];
137 static int Nlocks = 0;
138 
139 /*
140  * put name in list of lock files
141  * return:
142  *	none
143  */
144 static void
stlock(char * name)145 stlock(char *name)
146 {
147 	int i;
148 	char *p;
149 
150 	for (i = 0; i < Nlocks; i++) {
151 		if (Lockfile[i] == NULL)
152 			break;
153 	}
154 	ASSERT(i < MAXLOCKS, "TOO MANY LOCKS", "", i);
155 	if (i >= Nlocks)
156 		i = Nlocks++;
157 	p = calloc((unsigned)strlen(name) + 1, sizeof (char));
158 	ASSERT(p != NULL, "CAN NOT ALLOCATE FOR", name, 0);
159 	(void) strcpy(p, name);
160 	Lockfile[i] = p;
161 }
162 
163 /*
164  * remove the named lock. If named lock is NULL,
165  *	then remove all locks currently in list.
166  * return:
167  *	none
168  */
169 static void
rmlock(char * name)170 rmlock(char *name)
171 {
172 	int i;
173 
174 	for (i = 0; i < Nlocks; i++) {
175 		if (Lockfile[i] == NULL)
176 			continue;
177 		if (name == NULL || EQUALS(name, Lockfile[i])) {
178 			(void) unlink(Lockfile[i]);
179 			free(Lockfile[i]);
180 			Lockfile[i] = NULL;
181 		}
182 	}
183 }
184 
185 /*
186  * makes a lock on behalf of pid.
187  * input:
188  *	pid - process id
189  *	tempfile - name of a temporary in the same file system
190  *	name - lock file name (full path name)
191  * return:
192  *	-1 - failed
193  *	0  - lock made successfully
194  */
195 static int
onelock(char * pid,char * tempfile,char * name)196 onelock(char *pid, char *tempfile, char *name)
197 {
198 	int fd;
199 	char	cb[100];
200 
201 	fd = creat(tempfile, (mode_t)0444);
202 	if (fd < 0) {
203 		(void) snprintf(cb, sizeof (cb),
204 					"%s %s %d", tempfile, name, errno);
205 		logent("ULOCKC", cb);
206 		if ((errno == EMFILE) || (errno == ENFILE))
207 			(void) unlink(tempfile);
208 		return (-1);
209 	}
210 	/* +1 for '\n' */
211 	if (write(fd, pid, SIZEOFPID+1) != (SIZEOFPID+1)) {
212 		(void) snprintf(cb, sizeof (cb),
213 					"%s %s %d", tempfile, name, errno);
214 		logent("ULOCKW", cb);
215 		(void) unlink(tempfile);
216 		return (-1);
217 	}
218 	(void) chmod(tempfile, (mode_t)0444);
219 	(void) chown(tempfile, UUCPUID, UUCPGID);
220 	(void) close(fd);
221 	if (link(tempfile, name) < 0) {
222 		DEBUG(4, "%s: ", strerror(errno));
223 		DEBUG(4, "link(%s, ", tempfile);
224 		DEBUG(4, "%s)\n", name);
225 		if (unlink(tempfile) <  0) {
226 			(void) snprintf(cb, sizeof (cb),
227 					"ULK err %s %d", tempfile,  errno);
228 			logent("ULOCKLNK", cb);
229 		}
230 		return (-1);
231 	}
232 	if (unlink(tempfile) < 0) {
233 		(void) snprintf(cb, sizeof (cb), "%s %d", tempfile, errno);
234 		logent("ULOCKF", cb);
235 	}
236 	return (0);
237 }
238 
239 /*
240  * fd_mklock(fd) - lock the device indicated by fd is possible
241  *
242  * return -
243  *	SUCCESS - this process now has the fd locked
244  *	FAIL - this process was not able to lock the fd
245  */
246 
247 static int
fd_mklock(int fd)248 fd_mklock(int fd)
249 {
250 	int tries = 0;
251 	struct stat64 _st_buf;
252 	char lockname[BUFSIZ];
253 
254 	if (fstat64(fd, &_st_buf) != 0)
255 		return (FAIL);
256 
257 	(void) snprintf(lockname, sizeof (lockname),
258 		"%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
259 		(unsigned long)major(_st_buf.st_dev),
260 		(unsigned long)major(_st_buf.st_rdev),
261 		(unsigned long)minor(_st_buf.st_rdev));
262 
263 	if (mklock(lockname) == FAIL)
264 		return (FAIL);
265 
266 	while (lockf(fd, F_TLOCK, 0L) != 0) {
267 		DEBUG(7, "fd_mklock: lockf returns %d\n", errno);
268 		if ((++tries >= MAX_LOCKTRY) || (errno != EAGAIN)) {
269 			rmlock(lockname);
270 			logent("fd_mklock", "lockf failed");
271 			return (FAIL);
272 		}
273 		(void) sleep(2);
274 	}
275 	DEBUG(7, "fd_mklock: ok\n%s", "");
276 	return (SUCCESS);
277 }
278 
279 /*
280  * remove the locks associated with the device file descriptor
281  *
282  * return -
283  *	SUCCESS - both BNU lock file and advisory locks removed
284  *	FAIL -
285  */
286 
287 static void
fd_rmlock(int fd)288 fd_rmlock(int fd)
289 {
290 	struct stat64 _st_buf;
291 	char lockname[BUFSIZ];
292 
293 	if (fstat64(fd, &_st_buf) == 0) {
294 		(void) snprintf(lockname, sizeof (lockname),
295 			"%s.%3.3lu.%3.3lu.%3.3lu", L_LOCK,
296 			(unsigned long)major(_st_buf.st_dev),
297 			(unsigned long)major(_st_buf.st_rdev),
298 			(unsigned long)minor(_st_buf.st_rdev));
299 		rmlock(lockname);
300 	}
301 	(void) lockf(fd, F_ULOCK, 0L);
302 }
303