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 <stdio.h>
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <libintl.h>
31 #include <string.h>
32 #include <fcntl.h>
33 #include <errno.h>
34 #include <syslog.h>
35 #include <alloca.h>
36 #include <sys/vfstab.h>
37 #include <sys/mnttab.h>
38 #include <sys/mntent.h>
39 #include <sys/mount.h>
40 #include <sys/filio.h>
41 #include <sys/fs/ufs_filio.h>
42 #include <sys/stat.h>
43 #include <sys/param.h>
44 #include <zone.h>
45 #include <signal.h>
46 #include <strings.h>
47 #include "fslib.h"
48
49 /* LINTLIBRARY */
50
51 #define BUFLEN 256
52
53 #define TIME_MAX 16
54
55 /*
56 * Reads all of the entries from the in-kernel mnttab, and returns the
57 * linked list of the entries.
58 */
59 mntlist_t *
fsgetmntlist(void)60 fsgetmntlist(void)
61 {
62 FILE *mfp;
63 mntlist_t *mntl;
64 char buf[BUFLEN];
65
66 if ((mfp = fopen(MNTTAB, "r")) == NULL) {
67 (void) snprintf(buf, BUFLEN, "fsgetmntlist: fopen %s", MNTTAB);
68 perror(buf);
69 return (NULL);
70 }
71
72 mntl = fsmkmntlist(mfp);
73
74 (void) fclose(mfp);
75 return (mntl);
76 }
77
78
79 static struct extmnttab zmnttab = { 0 };
80
81 struct extmnttab *
fsdupmnttab(struct extmnttab * mnt)82 fsdupmnttab(struct extmnttab *mnt)
83 {
84 struct extmnttab *new;
85
86 new = (struct extmnttab *)malloc(sizeof (*new));
87 if (new == NULL)
88 goto alloc_failed;
89
90 *new = zmnttab;
91 /*
92 * Allocate an extra byte for the mountpoint
93 * name in case a space needs to be added.
94 */
95 new->mnt_mountp = (char *)malloc(strlen(mnt->mnt_mountp) + 2);
96 if (new->mnt_mountp == NULL)
97 goto alloc_failed;
98 (void) strcpy(new->mnt_mountp, mnt->mnt_mountp);
99
100 if ((new->mnt_special = strdup(mnt->mnt_special)) == NULL)
101 goto alloc_failed;
102
103 if ((new->mnt_fstype = strdup(mnt->mnt_fstype)) == NULL)
104 goto alloc_failed;
105
106 if (mnt->mnt_mntopts != NULL)
107 if ((new->mnt_mntopts = strdup(mnt->mnt_mntopts)) == NULL)
108 goto alloc_failed;
109
110 if (mnt->mnt_time != NULL)
111 if ((new->mnt_time = strdup(mnt->mnt_time)) == NULL)
112 goto alloc_failed;
113
114 new->mnt_major = mnt->mnt_major;
115 new->mnt_minor = mnt->mnt_minor;
116 return (new);
117
118 alloc_failed:
119 (void) fprintf(stderr, gettext("fsdupmnttab: Out of memory\n"));
120 fsfreemnttab(new);
121 return (NULL);
122 }
123
124 /*
125 * Free a single mnttab structure
126 */
127 void
fsfreemnttab(struct extmnttab * mnt)128 fsfreemnttab(struct extmnttab *mnt)
129 {
130
131 if (mnt) {
132 if (mnt->mnt_special)
133 free(mnt->mnt_special);
134 if (mnt->mnt_mountp)
135 free(mnt->mnt_mountp);
136 if (mnt->mnt_fstype)
137 free(mnt->mnt_fstype);
138 if (mnt->mnt_mntopts)
139 free(mnt->mnt_mntopts);
140 if (mnt->mnt_time)
141 free(mnt->mnt_time);
142 free(mnt);
143 }
144 }
145
146 void
fsfreemntlist(mntlist_t * mntl)147 fsfreemntlist(mntlist_t *mntl)
148 {
149 mntlist_t *mntl_tmp;
150
151 while (mntl) {
152 fsfreemnttab(mntl->mntl_mnt);
153 mntl_tmp = mntl;
154 mntl = mntl->mntl_next;
155 free(mntl_tmp);
156 }
157 }
158
159 /*
160 * Read the mnttab file and return it as a list of mnttab structs.
161 * Returns NULL if there was a memory failure.
162 */
163 mntlist_t *
fsmkmntlist(FILE * mfp)164 fsmkmntlist(FILE *mfp)
165 {
166 struct extmnttab mnt;
167 mntlist_t *mhead, *mtail;
168 int ret;
169
170 mhead = mtail = NULL;
171
172 resetmnttab(mfp);
173 while ((ret = getextmntent(mfp, &mnt, sizeof (struct extmnttab)))
174 != -1) {
175 mntlist_t *mp;
176
177 if (ret != 0) /* bad entry */
178 continue;
179
180 mp = (mntlist_t *)malloc(sizeof (*mp));
181 if (mp == NULL)
182 goto alloc_failed;
183 if (mhead == NULL)
184 mhead = mp;
185 else
186 mtail->mntl_next = mp;
187 mtail = mp;
188 mp->mntl_next = NULL;
189 mp->mntl_flags = 0;
190 if ((mp->mntl_mnt = fsdupmnttab(&mnt)) == NULL)
191 goto alloc_failed;
192 }
193 return (mhead);
194
195 alloc_failed:
196 fsfreemntlist(mhead);
197 return (NULL);
198 }
199
200 /*
201 * Return the last entry that matches mntin's special
202 * device and/or mountpt.
203 * Helps to be robust here, so we check for NULL pointers.
204 */
205 mntlist_t *
fsgetmlast(mntlist_t * ml,struct mnttab * mntin)206 fsgetmlast(mntlist_t *ml, struct mnttab *mntin)
207 {
208 mntlist_t *delete = NULL;
209
210 for (; ml; ml = ml->mntl_next) {
211 if (mntin->mnt_mountp && mntin->mnt_special) {
212 /*
213 * match if and only if both are equal.
214 */
215 if ((strcmp(ml->mntl_mnt->mnt_mountp,
216 mntin->mnt_mountp) == 0) &&
217 (strcmp(ml->mntl_mnt->mnt_special,
218 mntin->mnt_special) == 0))
219 delete = ml;
220 } else if (mntin->mnt_mountp) {
221 if (strcmp(ml->mntl_mnt->mnt_mountp,
222 mntin->mnt_mountp) == 0)
223 delete = ml;
224 } else if (mntin->mnt_special) {
225 if (strcmp(ml->mntl_mnt->mnt_special,
226 mntin->mnt_special) == 0)
227 delete = ml;
228 }
229 }
230 return (delete);
231 }
232
233
234 /*
235 * Returns the mountlevel of the pathname in cp. As examples,
236 * / => 1, /bin => 2, /bin/ => 2, ////bin////ls => 3, sdf => 0, etc...
237 */
238 int
fsgetmlevel(char * cp)239 fsgetmlevel(char *cp)
240 {
241 int mlevel;
242 char *cp1;
243
244 if (cp == NULL || *cp == '\0' || *cp != '/')
245 return (0); /* this should never happen */
246
247 mlevel = 1; /* root (/) is the minimal case */
248
249 for (cp1 = cp + 1; *cp1; cp++, cp1++)
250 if (*cp == '/' && *cp1 != '/') /* "///" counts as 1 */
251 mlevel++;
252
253 return (mlevel);
254 }
255
256 /*
257 * Returns non-zero if string s is a member of the strings in ps.
258 */
259 int
fsstrinlist(const char * s,const char ** ps)260 fsstrinlist(const char *s, const char **ps)
261 {
262 const char *cp;
263 cp = *ps;
264 while (cp) {
265 if (strcmp(s, cp) == 0)
266 return (1);
267 ps++;
268 cp = *ps;
269 }
270 return (0);
271 }
272
273 static char *empty_opt_vector[] = {
274 NULL
275 };
276 /*
277 * Compare the mount options that were requested by the caller to
278 * the options actually supported by the file system. If any requested
279 * options are not supported, print a warning message.
280 *
281 * WARNING: this function modifies the string pointed to by
282 * the requested_opts argument.
283 *
284 * Arguments:
285 * requested_opts - the string containing the requested options.
286 * actual_opts - the string returned by mount(2), which lists the
287 * options actually supported. It is normal for this
288 * string to contain more options than the requested options.
289 * (The actual options may contain the default options, which
290 * may not have been included in the requested options.)
291 * special - device being mounted (only used in error messages).
292 * mountp - mount point (only used in error messages).
293 */
294 void
cmp_requested_to_actual_options(char * requested_opts,char * actual_opts,char * special,char * mountp)295 cmp_requested_to_actual_options(char *requested_opts, char *actual_opts,
296 char *special, char *mountp)
297 {
298 char *option_ptr, *actopt, *equalptr;
299 int found;
300 char *actual_opt_hold, *bufp;
301
302 if (requested_opts == NULL)
303 return;
304
305 bufp = alloca(strlen(actual_opts) + 1);
306
307 while (*requested_opts != '\0') {
308 (void) getsubopt(&requested_opts, empty_opt_vector,
309 &option_ptr);
310
311 /*
312 * Truncate any "=<value>" string from the end of
313 * the option.
314 */
315 if ((equalptr = strchr(option_ptr, '=')) != NULL)
316 *equalptr = '\0';
317
318 if (*option_ptr == '\0')
319 continue;
320
321 /*
322 * Whilst we don't need this option to perform a lofi
323 * mount, let's not be mendacious enough to complain
324 * about it.
325 */
326 if (strcmp(option_ptr, "loop") == 0)
327 continue;
328
329 /*
330 * Search for the requested option in the list of options
331 * actually supported.
332 */
333 found = 0;
334
335 /*
336 * Need to use a copy of actual_opts because getsubopt
337 * is destructive and we need to scan the actual_opts
338 * string more than once.
339 *
340 * We also need to reset actual_opt_hold to the
341 * beginning of the buffer because getsubopt changes
342 * actual_opt_hold (the pointer).
343 */
344 actual_opt_hold = bufp;
345 if (actual_opts != NULL)
346 (void) strcpy(actual_opt_hold, actual_opts);
347 else
348 *actual_opt_hold = '\0';
349
350 while (*actual_opt_hold != '\0') {
351 (void) getsubopt(&actual_opt_hold, empty_opt_vector,
352 &actopt);
353
354 /* Truncate the "=<value>", if any. */
355 if ((equalptr = strchr(actopt, '=')) != NULL)
356 *equalptr = '\0';
357
358 if ((strcmp(option_ptr, actopt)) == 0) {
359 found = 1;
360 break;
361 }
362 }
363
364 if (found == 0) {
365 /*
366 * That we're ignoring the option is always
367 * truthful; the old message that the option
368 * was unknown is often not correct.
369 */
370 (void) fprintf(stderr, gettext(
371 "mount: %s on %s - WARNING ignoring option "
372 "\"%s\"\n"), special, mountp, option_ptr);
373 }
374 }
375 }
376 /*
377 * FUNCTION: fsgetmaxphys(int *, int *)
378 *
379 * INPUT: int *maxphys - a pointer to an integer that will hold
380 * the value for the system maxphys value.
381 * int *error - 0 means completed successfully
382 * otherwise this indicates the errno value.
383 *
384 * RETURNS: int - 0 if maxphys not found
385 * - 1 if maxphys is found
386 */
387 int
fsgetmaxphys(int * maxphys,int * error)388 fsgetmaxphys(int *maxphys, int *error) {
389
390 int gotit = 0;
391 int fp = open("/", O_RDONLY);
392
393 *error = 0;
394
395 /*
396 * For some reason cannot open root as read only. Need a valid file
397 * descriptor to call the ufs private ioctl. If this open failes,
398 * just assume we cannot get maxphys in this case.
399 */
400 if (fp == -1) {
401 return (gotit);
402 }
403
404 if (ioctl(fp, _FIOGETMAXPHYS, maxphys) == -1) {
405 *error = errno;
406 (void) close(fp);
407 return (gotit);
408 }
409
410 (void) close(fp);
411 gotit = 1;
412 return (gotit);
413
414 }
415
416 /*
417 * The below is limited support for zone-aware commands.
418 */
419 struct zone_summary {
420 zoneid_t zoneid;
421 char rootpath[MAXPATHLEN];
422 size_t rootpathlen;
423 };
424
425 struct zone_summary *
fs_get_zone_summaries(void)426 fs_get_zone_summaries(void)
427 {
428 uint_t numzones = 0, oldnumzones = 0;
429 uint_t i, j;
430 zoneid_t *ids = NULL;
431 struct zone_summary *summaries;
432 zoneid_t myzoneid = getzoneid();
433
434 for (;;) {
435 if (zone_list(ids, &numzones) < 0) {
436 perror("unable to retrieve list of zones");
437 if (ids != NULL)
438 free(ids);
439 return (NULL);
440 }
441 if (numzones <= oldnumzones)
442 break;
443 if (ids != NULL)
444 free(ids);
445 ids = malloc(numzones * sizeof (*ids));
446 if (ids == NULL) {
447 perror("malloc failed");
448 return (NULL);
449 }
450 oldnumzones = numzones;
451 }
452
453 summaries = malloc((numzones + 1) * sizeof (*summaries));
454 if (summaries == NULL) {
455 free(ids);
456 perror("malloc failed");
457 return (NULL);
458 }
459
460
461 for (i = 0, j = 0; i < numzones; i++) {
462 ssize_t len;
463
464 if (ids[i] == myzoneid)
465 continue;
466 len = zone_getattr(ids[i], ZONE_ATTR_ROOT,
467 summaries[j].rootpath, sizeof (summaries[j].rootpath));
468 if (len < 0) {
469 /*
470 * Zone must have gone away. Skip.
471 */
472 continue;
473 }
474 /*
475 * Adding a trailing '/' to the zone's rootpath allows us to
476 * use strncmp() to see if a given path resides within that
477 * zone.
478 *
479 * As an example, if the zone's rootpath is "/foo/root",
480 * "/foo/root/usr" resides within the zone, while
481 * "/foo/rootpath" doesn't.
482 */
483 (void) strlcat(summaries[j].rootpath, "/",
484 sizeof (summaries[j].rootpath));
485 summaries[j].rootpathlen = len;
486 summaries[j].zoneid = ids[i];
487 j++;
488 }
489 summaries[j].zoneid = -1;
490 free(ids);
491 return (summaries);
492 }
493
494 static zoneid_t
fs_find_zone(const struct zone_summary * summaries,const char * mntpt)495 fs_find_zone(const struct zone_summary *summaries, const char *mntpt)
496 {
497 uint_t i;
498
499 for (i = 0; summaries[i].zoneid != -1; i++) {
500 if (strncmp(mntpt, summaries[i].rootpath,
501 summaries[i].rootpathlen) == 0)
502 return (summaries[i].zoneid);
503 }
504 /*
505 * (-1) is the special token we return to the caller if the mount
506 * wasn't found in any other mounts on the system. This means it's
507 * only visible to our zone.
508 *
509 * Odd choice of constant, I know, but it beats calling getzoneid() a
510 * million times.
511 */
512 return (-1);
513 }
514
515 boolean_t
fs_mount_in_other_zone(const struct zone_summary * summaries,const char * mntpt)516 fs_mount_in_other_zone(const struct zone_summary *summaries, const char *mntpt)
517 {
518 return (fs_find_zone(summaries, mntpt) != -1);
519 }
520
521 /*
522 * List of standard options.
523 */
524 static const char *stdopts[] = {
525 MNTOPT_RO, MNTOPT_RW,
526 MNTOPT_SUID, MNTOPT_NOSUID,
527 MNTOPT_DEVICES, MNTOPT_NODEVICES,
528 MNTOPT_SETUID, MNTOPT_NOSETUID,
529 MNTOPT_NBMAND, MNTOPT_NONBMAND,
530 MNTOPT_EXEC, MNTOPT_NOEXEC,
531 };
532
533 #define NSTDOPT (sizeof (stdopts) / sizeof (stdopts[0]))
534
535 static int
optindx(const char * opt)536 optindx(const char *opt)
537 {
538 int i;
539
540 for (i = 0; i < NSTDOPT; i++) {
541 if (strcmp(opt, stdopts[i]) == 0)
542 return (i);
543 }
544 return (-1);
545 }
546
547 /*
548 * INPUT: filesystem option not recognized by the fs specific option
549 * parsing code.
550 * OUTPUT: True if and only if the option is one of the standard VFS
551 * layer options.
552 */
553 boolean_t
fsisstdopt(const char * opt)554 fsisstdopt(const char *opt)
555 {
556 return (optindx(opt) != -1);
557 }
558