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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/fcntl.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <stdlib.h>
31 #include <signal.h>
32 #include <strings.h>
33 #include <unistd.h>
34 #include <stdio.h>
35
36 #include "libnsctl.h"
37 #include <nsctl.h>
38
39
40 static int _nsc_open_path(nsc_fd_t *);
41 static int _nsc_open_check(nsc_fd_t *);
42
43
44 /*
45 * Turn off ckdchk checking of nsc_open()'d volumes since we have no CKD
46 * formatted volumes right now. If/when we come back with CKD volumes,
47 * we could do this more sanely by completing the implementation of the
48 * CKD module, and having nsc_open() prevent any non-NSC_CKD_DISK open
49 * of a CKD volume.
50 * -- Simon, Thu Feb 18 10:49:46 GMT 1999
51 */
52 static int ckdchk = 0;
53
54
55 nsc_fd_t *
56 nsc_open(path, flag, mode)
57 char *path;
58 int flag, mode;
59 {
60 nsc_fd_t *fd;
61
62 if (strlen(path) >= NSC_MAXPATH) {
63 errno = ENAMETOOLONG;
64 return (0);
65 }
66
67 if (!(fd = (nsc_fd_t *)calloc(1, sizeof (nsc_fd_t))))
68 return (0);
69
70 if ((mode & O_ACCMODE) == O_WRONLY) {
71 mode &= ~O_ACCMODE;
72 mode |= O_RDWR;
73 }
74
75 fd->sf_flag = flag;
76 fd->sf_fmode = mode;
77
78 strcpy(fd->sf_path, path);
79
80 if (!_nsc_open_path(fd)) {
81 free(fd);
82 return (0);
83 }
84
85 if (ckdchk && !_nsc_open_check(fd)) {
86 (void) nsc_close(fd);
87 return (0);
88 }
89
90 return (fd);
91 }
92
93
94 nsc_fd_t *
95 nsc_fdopen(id, path, mode)
96 int id, mode;
97 char *path;
98 {
99 struct flock lk;
100 nsc_fd_t *fd;
101 int i;
102
103 if (strlen(path) >= NSC_MAXPATH) {
104 errno = ENAMETOOLONG;
105 return (0);
106 }
107
108 if (!(fd = (nsc_fd_t *)calloc(1, sizeof (nsc_fd_t))))
109 return (0);
110
111 lk.l_type = F_WRLCK;
112 lk.l_whence = SEEK_SET;
113 lk.l_start = 0;
114 lk.l_len = 0;
115
116 if (fcntl(id, F_SETLKW, &lk) < 0)
117 return (0);
118
119 i = fcntl(id, F_GETFL);
120
121 if ((mode & O_ACCMODE) != O_RDONLY) {
122 if ((i & O_ACCMODE) == O_RDONLY) {
123 errno = EBADF;
124 return (0);
125 }
126 }
127
128 if ((mode & O_ACCMODE) != O_WRONLY) {
129 if ((i & O_ACCMODE) == O_WRONLY) {
130 errno = EBADF;
131 return (0);
132 }
133 }
134
135 mode = (i & O_ACCMODE) | (mode & ~O_ACCMODE);
136
137 if (fcntl(id, F_SETFL, mode) < 0)
138 return (0);
139
140 if (lseek(id, 0, SEEK_SET) < 0)
141 return (0);
142
143 fd->sf_fd = id;
144 fd->sf_fmode = mode;
145
146 strcpy(fd->sf_path, path);
147
148 return (fd);
149 }
150
151
152 static int
153 _nsc_open_path(fd)
154 nsc_fd_t *fd;
155 {
156 struct nscioc_open op;
157
158 memset(&op, 0, sizeof (op));
159
160 op.flag = fd->sf_flag;
161 op.mode = fd->sf_fmode;
162 strcpy(op.path, fd->sf_path);
163
164 if ((fd->sf_fd = open(_NSC_DEV_PATH, fd->sf_fmode)) < 0)
165 return (0);
166
167 if (ioctl(fd->sf_fd, NSCIOC_OPEN, &op) == 0)
168 return (1);
169
170 close(fd->sf_fd);
171 return (0);
172 }
173
174
175 static int
176 _nsc_open_check(fd)
177 nsc_fd_t *fd;
178 {
179 struct flock lk;
180 char s[30];
181 pid_t pid;
182 int i;
183
184 if ((fd->sf_fmode & O_ACCMODE) == O_RDONLY)
185 return (1);
186
187 if (access(_NSC_CKDCHK_PATH, X_OK) != 0)
188 return (0);
189
190 lk.l_type = F_WRLCK;
191 lk.l_whence = SEEK_SET;
192 lk.l_start = 0;
193 lk.l_len = 0;
194
195 if (fcntl(fd->sf_fd, F_SETLKW, &lk) < 0)
196 return (0);
197
198 if ((pid = fork()) == 0) {
199 for (i = 1; i <= NSIG; i++)
200 signal(i, SIG_IGN);
201
202 for (i = fd->sf_fd; i <= 2 && (i = dup(i)) != -1; )
203 fd->sf_fd = i;
204
205 for (i = sysconf(_SC_OPEN_MAX); i >= 0; i--)
206 if (i != fd->sf_fd)
207 close(i);
208
209 fcntl(fd->sf_fd, F_SETFD, 0);
210
211 (void) open("/dev/null", 0);
212 (void) open(_NSC_CKDCHK_LOG, O_WRONLY|O_CREAT|O_APPEND, 0666);
213 (void) open(_NSC_CKDCHK_LOG, O_WRONLY|O_CREAT|O_APPEND, 0666);
214
215 (void) sprintf(s, "%d", fd->sf_fd);
216
217 (void) execl(_NSC_CKDCHK_PATH, "ckdchk", "-u", "-F",
218 s, fd->sf_path, 0);
219
220 exit(1);
221 }
222
223 return (pid != -1);
224 }
225
226
227 int
228 nsc_close(fd)
229 nsc_fd_t *fd;
230 {
231 int rc;
232
233 if (!fd)
234 return (0);
235
236 rc = close(fd->sf_fd);
237 free(fd);
238
239 return (rc);
240 }
241
242
243 int
244 nsc_reserve(fd)
245 nsc_fd_t *fd;
246 {
247 return ((fd) ? ioctl(fd->sf_fd, NSCIOC_RESERVE, 0) : 0);
248 }
249
250
251 int
252 nsc_release(fd)
253 nsc_fd_t *fd;
254 {
255 if (!fd)
256 return (0);
257
258 if (ckdchk && (fd->sf_fmode & O_ACCMODE) != O_RDONLY) {
259 errno = EINVAL;
260 return (-1);
261 }
262
263 return (ioctl(fd->sf_fd, NSCIOC_RELEASE, 0));
264 }
265
266
267 int
268 nsc_partsize(nsc_fd_t *fd, nsc_size_t *rvp)
269 {
270 struct nscioc_partsize partsize;
271 int rc;
272
273 if (!fd)
274 return (0);
275
276 rc = ioctl(fd->sf_fd, NSCIOC_PARTSIZE, &partsize);
277 if (rc != 0) {
278 return (rc);
279 }
280
281 *rvp = (nsc_size_t)partsize.partsize;
282 return (0);
283 }
284
285
286 int
287 nsc_fileno(fd)
288 nsc_fd_t *fd;
289 {
290 return ((fd) ? fd->sf_fd : -1);
291 }
292
293
294 void
295 _nsc_nocheck()
296 {
297 ckdchk = 0;
298 }
299
300
301 static int
302 _nsc_do_ioctl(cmd, arg)
303 int cmd;
304 void *arg;
305 {
306 int fd, rc, save_errno;
307
308 fd = open(_NSC_DEV_PATH, O_RDONLY);
309 if (fd < 0)
310 return (-1);
311
312 rc = save_errno = 0;
313 rc = ioctl(fd, cmd, arg);
314 if (rc < 0)
315 save_errno = errno;
316
317 close(fd);
318
319 errno = save_errno;
320 return (rc);
321 }
322
323
324 /*
325 * int
326 * nsc_freeze(char *path)
327 * Freeze a pathname
328 *
329 * Calling/Exit State:
330 * Returns 0 for success, or -1 and sets errno.
331 *
332 * Description:
333 * This is the user level interface to the nsctl freeze operation.
334 * See uts/common/ns/nsctl/nsc_freeze.c for more information.
335 */
336 int
337 nsc_freeze(path)
338 char *path;
339 {
340 if (strlen(path) >= NSC_MAXPATH) {
341 errno = ENAMETOOLONG;
342 return (-1);
343 }
344
345 return (_nsc_do_ioctl(NSCIOC_FREEZE, path));
346 }
347
348 /*
349 * int
350 * nsc_unfreeze(char *path)
351 * Unfreeze a pathname
352 *
353 * Calling/Exit State:
354 * Returns 0 for success, or -1 and sets errno.
355 *
356 * Description:
357 * This is the user level interface to the nsctl unfreeze operation.
358 * See uts/common/ns/nsctl/nsc_freeze.c for more information.
359 */
360 int
361 nsc_unfreeze(path)
362 char *path;
363 {
364 if (strlen(path) >= NSC_MAXPATH) {
365 errno = ENAMETOOLONG;
366 return (-1);
367 }
368
369 return (_nsc_do_ioctl(NSCIOC_UNFREEZE, path));
370 }
371
372
373 /*
374 * int
375 * nsc_isfrozen(char *path)
376 * Test if a pathname is frozen
377 *
378 * Calling/Exit State:
379 * Returns:
380 * 0 path is frozen
381 * 1 path is not frozen
382 * -1 error (errno will be set)
383 *
384 * Description
385 * This is the user level interface to to the nsctl isfrozen operation.
386 * See uts/common/ns/nsctl/nsc_freeze.c for more information.
387 */
388 int
389 nsc_isfrozen(path)
390 char *path;
391 {
392 if (strlen(path) >= NSC_MAXPATH) {
393 errno = ENAMETOOLONG;
394 return (-1);
395 }
396
397 return (_nsc_do_ioctl(NSCIOC_ISFROZEN, path));
398 }
399
400 int
401 nsc_gmem_sizes(int *size)
402 {
403 return (_nsc_do_ioctl(NSCIOC_GLOBAL_SIZES, size));
404 }
405
406 int
407 nsc_gmem_data(char *addr)
408 {
409 return (_nsc_do_ioctl(NSCIOC_GLOBAL_DATA, addr));
410 }
411
412 /*
413 * int
414 * nsc_nvclean()
415 * mark nvmem clean, to prevent a warmstart of the cache on reboot
416 */
417 int
418 nsc_nvclean(int force)
419 {
420 int cmd;
421
422 cmd = force ? NSCIOC_NVMEM_CLEANF : NSCIOC_NVMEM_CLEAN;
423
424 return (_nsc_do_ioctl(cmd, (void *)0));
425 }