drm/i915: Fix hangs on some broadwell machines
[dragonfly.git] / contrib / amd / amd / am_ops.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1997-1999 Erez Zadok
3 * Copyright (c) 1989 Jan-Simon Pendry
4 * Copyright (c) 1989 Imperial College of Science, Technology & Medicine
5 * Copyright (c) 1989 The Regents of the University of California.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * Jan-Simon Pendry at Imperial College, London.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgment:
21 * This product includes software developed by the University of
22 * California, Berkeley and its contributors.
23 * 4. Neither the name of the University nor the names of its contributors
24 * may be used to endorse or promote products derived from this software
25 * without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 *
39 * %W% (Berkeley) %G%
40 *
41 * $Id: am_ops.c,v 1.4 1999/03/13 17:03:26 ezk Exp $
42 *
43 */
44
45#ifdef HAVE_CONFIG_H
46# include <config.h>
47#endif /* HAVE_CONFIG_H */
48#include <am_defs.h>
49#include <amd.h>
50
51
52/*
53 * The order of these entries matters, since lookups in this table are done
54 * on a first-match basis. The entries below are a mixture of native
55 * filesystems supported by the OS (HAVE_FS_FOO), and some meta-filesystems
56 * supported by amd (HAVE_AM_FS_FOO). The order is set here in expected
57 * match-hit such that more popular filesystems are listed first (nfs is the
58 * most popular, followed by a symlink F/S)
59 */
60static am_ops *vops[] =
61{
62#ifdef HAVE_FS_NFS
63 &nfs_ops, /* network F/S (version 2) */
64#endif /* HAVE_FS_NFS */
65#ifdef HAVE_AM_FS_LINK
66 &amfs_link_ops, /* symlink F/S */
67#endif /* HAVE_AM_FS_LINK */
68
69 /*
70 * Other amd-supported meta-filesystems.
71 */
72#ifdef HAVE_AM_FS_NFSX
73 &amfs_nfsx_ops, /* multiple-nfs F/S */
74#endif /* HAVE_AM_FS_NFSX */
75#ifdef HAVE_AM_FS_NFSL
76 &amfs_nfsl_ops, /* NFS with local link existence check */
77#endif /* HAVE_AM_FS_NFSL */
78#ifdef HAVE_AM_FS_HOST
79 &amfs_host_ops, /* multiple exported nfs F/S */
80#endif /* HAVE_AM_FS_HOST */
81#ifdef HAVE_AM_FS_LINKX
82 &amfs_linkx_ops, /* symlink F/S with link target verify */
83#endif /* HAVE_AM_FS_LINKX */
84#ifdef HAVE_AM_FS_PROGRAM
85 &amfs_program_ops, /* program F/S */
86#endif /* HAVE_AM_FS_PROGRAM */
87#ifdef HAVE_AM_FS_UNION
88 &amfs_union_ops, /* union F/S */
89#endif /* HAVE_AM_FS_UNION */
90#ifdef HAVE_AM_FS_INHERIT
91 &amfs_inherit_ops, /* inheritance F/S */
92#endif /* HAVE_AM_FS_INHERIT */
93
94 /*
95 * A few more native filesystems.
96 */
97#ifdef HAVE_FS_UFS
98 &ufs_ops, /* Unix F/S */
99#endif /* HAVE_FS_UFS */
100#ifdef HAVE_FS_XFS
101 &xfs_ops, /* Unix (irix) F/S */
102#endif /* HAVE_FS_XFS */
103#ifdef HAVE_FS_EFS
104 &efs_ops, /* Unix (irix) F/S */
105#endif /* HAVE_FS_EFS */
106#ifdef HAVE_FS_LOFS
107 &lofs_ops, /* loopback F/S */
108#endif /* HAVE_FS_LOFS */
109#ifdef HAVE_FS_CDFS
110 &cdfs_ops, /* CDROM/HSFS/ISO9960 F/S */
111#endif /* HAVE_FS_CDFS */
112#ifdef HAVE_FS_PCFS
113 &pcfs_ops, /* Floppy/MSDOS F/S */
114#endif /* HAVE_FS_PCFS */
115#ifdef HAVE_FS_CACHEFS
116 &cachefs_ops, /* caching F/S */
117#endif /* HAVE_FS_CACHEFS */
118#ifdef HAVE_FS_NULLFS
119/* FILL IN */ /* null (loopback) F/S */
120#endif /* HAVE_FS_NULLFS */
121#ifdef HAVE_FS_UNIONFS
122/* FILL IN */ /* union (bsd44) F/S */
123#endif /* HAVE_FS_UNIONFS */
124#ifdef HAVE_FS_UMAPFS
125/* FILL IN */ /* uid/gid mapping F/S */
126#endif /* HAVE_FS_UMAPFS */
127
128 /*
129 * These 5 should be last, in the order:
130 * (1) amfs_auto
131 * (2) amfs_direct
132 * (3) amfs_toplvl
133 * (4) autofs
134 * (5) amfs_error
135 */
136#ifdef HAVE_AM_FS_AUTO
137 &amfs_auto_ops, /* Automounter F/S */
138#endif /* HAVE_AM_FS_AUTO */
139#ifdef HAVE_AM_FS_DIRECT
140 &amfs_direct_ops, /* direct-mount F/S */
141#endif /* HAVE_AM_FS_DIRECT */
142#ifdef HAVE_AM_FS_TOPLVL
143 &amfs_toplvl_ops, /* top-level mount F/S */
144#endif /* HAVE_AM_FS_TOPLVL */
145#ifdef HAVE_FS_AUTOFS
146 &autofs_ops, /* autofs mount F/S */
147#endif /* HAVE_FS_AUTOFS */
148#ifdef HAVE_AM_FS_ERROR
149 &amfs_error_ops, /* error F/S */
150#endif /* HAVE_AM_FS_ERROR */
151 0
152};
153
154
155void
156ops_showamfstypes(char *buf)
157{
158 struct am_ops **ap;
159 int l = 0;
160
161 buf[0] = '\0';
162 for (ap = vops; *ap; ap++) {
163 strcat(buf, (*ap)->fs_type);
164 if (ap[1])
165 strcat(buf, ", ");
166 l += strlen((*ap)->fs_type) + 2;
167 if (l > 62) {
168 l = 0;
169 strcat(buf, "\n ");
170 }
171 }
172}
173
174
175static void
176ops_show1(char *buf, int *lp, const char *name)
177{
178 strcat(buf, name);
179 strcat(buf, ", ");
180 *lp += strlen(name) + 2;
181 if (*lp > 60) {
182 strcat(buf, "\t\n");
183 *lp = 0;
184 }
185}
186
187
188void
189ops_showfstypes(char *buf)
190{
191 int l = 0;
192
193 buf[0] = '\0';
194
195#ifdef MNTTAB_TYPE_AUTOFS
196 ops_show1(buf, &l, MNTTAB_TYPE_AUTOFS);
197#endif /* MNTTAB_TYPE_AUTOFS */
198
199#ifdef MNTTAB_TYPE_CACHEFS
200 ops_show1(buf, &l, MNTTAB_TYPE_CACHEFS);
201#endif /* MNTTAB_TYPE_CACHEFS */
202
203#ifdef MNTTAB_TYPE_CDFS
204 ops_show1(buf, &l, MNTTAB_TYPE_CDFS);
205#endif /* MNTTAB_TYPE_CDFS */
206
207#ifdef MNTTAB_TYPE_CFS
208 ops_show1(buf, &l, MNTTAB_TYPE_CFS);
209#endif /* MNTTAB_TYPE_CFS */
210
211#ifdef MNTTAB_TYPE_LOFS
212 ops_show1(buf, &l, MNTTAB_TYPE_LOFS);
213#endif /* MNTTAB_TYPE_LOFS */
214
215#ifdef MNTTAB_TYPE_EFS
216 ops_show1(buf, &l, MNTTAB_TYPE_EFS);
217#endif /* MNTTAB_TYPE_EFS */
218
219#ifdef MNTTAB_TYPE_MFS
220 ops_show1(buf, &l, MNTTAB_TYPE_MFS);
221#endif /* MNTTAB_TYPE_MFS */
222
223#ifdef MNTTAB_TYPE_NFS
224 ops_show1(buf, &l, MNTTAB_TYPE_NFS);
225#endif /* MNTTAB_TYPE_NFS */
226
227#ifdef MNTTAB_TYPE_NFS3
228 ops_show1(buf, &l, "nfs3"); /* always hard-code as nfs3 */
229#endif /* MNTTAB_TYPE_NFS3 */
230
231#ifdef MNTTAB_TYPE_NULLFS
232 ops_show1(buf, &l, MNTTAB_TYPE_NULLFS);
233#endif /* MNTTAB_TYPE_NULLFS */
234
235#ifdef MNTTAB_TYPE_PCFS
236 ops_show1(buf, &l, MNTTAB_TYPE_PCFS);
237#endif /* MNTTAB_TYPE_PCFS */
238
239#ifdef MNTTAB_TYPE_TFS
240 ops_show1(buf, &l, MNTTAB_TYPE_TFS);
241#endif /* MNTTAB_TYPE_TFS */
242
243#ifdef MNTTAB_TYPE_TMPFS
244 ops_show1(buf, &l, MNTTAB_TYPE_TMPFS);
245#endif /* MNTTAB_TYPE_TMPFS */
246
247#ifdef MNTTAB_TYPE_UFS
248 ops_show1(buf, &l, MNTTAB_TYPE_UFS);
249#endif /* MNTTAB_TYPE_UFS */
250
251#ifdef MNTTAB_TYPE_UMAPFS
252 ops_show1(buf, &l, MNTTAB_TYPE_UMAPFS);
253#endif /* MNTTAB_TYPE_UMAPFS */
254
255#ifdef MNTTAB_TYPE_UNIONFS
256 ops_show1(buf, &l, MNTTAB_TYPE_UNIONFS);
257#endif /* MNTTAB_TYPE_UNIONFS */
258
259#ifdef MNTTAB_TYPE_XFS
260 ops_show1(buf, &l, MNTTAB_TYPE_XFS);
261#endif /* MNTTAB_TYPE_XFS */
262
263 /* terminate with a period, newline, and NULL */
264 if (buf[strlen(buf)-1] == '\n')
265 buf[strlen(buf) - 4] = '\0';
266 else
267 buf[strlen(buf) - 2] = '\0';
268 strcat(buf, ".\n");
269}
270
271
272/*
273 * return string option which is the reverse of opt.
274 * nosuid -> suid
275 * quota -> noquota
276 * ro -> rw
277 * etc.
278 * may return pointer to static buffer or subpointer within opt.
279 */
280static char *
281reverse_option(const char *opt)
282{
283 static char buf[80];
284
285 /* sanity check */
286 if (!opt)
287 return NULL;
288
289 /* check special cases */
290 /* XXX: if this gets too long, rewrite the code more flexibly */
291 if (STREQ(opt, "ro")) return "rw";
292 if (STREQ(opt, "rw")) return "ro";
293 if (STREQ(opt, "bg")) return "fg";
294 if (STREQ(opt, "fg")) return "bg";
295 if (STREQ(opt, "soft")) return "hard";
296 if (STREQ(opt, "hard")) return "soft";
297
298 /* check if string starts with 'no' and chop it */
299 if (NSTREQ(opt, "no", 2)) {
300 strcpy(buf, &opt[2]);
301 } else {
302 /* finally return a string prepended with 'no' */
303 strcpy(buf, "no");
304 strcat(buf, opt);
305 }
306 return buf;
307}
308
309
310/*
311 * start with an empty string. for each opts1 option that is not
312 * in opts2, add it to the string (make sure the reverse of it
313 * isn't in either). finally add opts2. return new string.
314 * Both opts1 and opts2 must not be null!
315 * Caller must eventually free the string being returned.
316 */
317static char *
318merge_opts(const char *opts1, const char *opts2)
319{
320 mntent_t mnt2; /* place holder for opts2 */
321 char *newstr; /* new string to return (malloc'ed) */
322 char *tmpstr; /* temp */
323 char *eq; /* pointer to '=' within temp */
324 char oneopt[80]; /* one option w/o value if any */
325 char *revoneopt; /* reverse of oneopt */
326 int len = strlen(opts1) + strlen(opts2) + 2; /* space for "," and NULL */
327 char *s1 = strdup(opts1); /* copy of opts1 to munge */
328
329 /* initialization */
330 mnt2.mnt_opts = (char *) opts2;
331 newstr = xmalloc(len);
332 newstr[0] = '\0';
333
334 for (tmpstr = strtok(s1, ",");
335 tmpstr;
336 tmpstr = strtok(NULL, ",")) {
337 /* copy option to temp buffer */
338 strncpy(oneopt, tmpstr, 80);
339 oneopt[79] = '\0';
340 /* if option has a value such as rsize=1024, chop the value part */
341 if ((eq = strchr(oneopt, '=')))
342 eq[1] = '\0';
343 /* find reverse option of oneopt */
344 revoneopt = reverse_option(oneopt);
345 /* if option orits reverse exist in opts2, ignore it */
346 if (hasmntopt(&mnt2, oneopt) || hasmntopt(&mnt2, revoneopt))
347 continue;
348 /* add option to returned string */
349 if (newstr && newstr[0]) {
350 strcat(newstr, ",");
351 strcat(newstr, tmpstr);
352 } else {
353 strcpy(newstr, tmpstr);
354 }
355 }
356
357 /* finally, append opts2 itself */
358 if (newstr && newstr[0]) {
359 strcat(newstr, ",");
360 strcat(newstr, opts2);
361 } else {
362 strcpy(newstr, opts2);
363 }
364
365 XFREE(s1);
366 return newstr;
367}
368
369
370am_ops *
371ops_match(am_opts *fo, char *key, char *g_key, char *path, char *keym, char *map)
372{
373 am_ops **vp;
374 am_ops *rop = 0;
375
376 /*
377 * First crack the global opts and the local opts
378 */
379 if (!eval_fs_opts(fo, key, g_key, path, keym, map)) {
380 rop = &amfs_error_ops;
381 } else if (fo->opt_type == 0) {
382 plog(XLOG_USER, "No fs type specified (key = \"%s\", map = \"%s\")", keym, map);
383 rop = &amfs_error_ops;
384 } else {
385 /*
386 * Next find the correct filesystem type
387 */
388 for (vp = vops; (rop = *vp); vp++)
389 if (STREQ(rop->fs_type, fo->opt_type))
390 break;
391 if (!rop) {
392 plog(XLOG_USER, "fs type \"%s\" not recognized", fo->opt_type);
393 rop = &amfs_error_ops;
394 }
395 }
396
397 /*
398 * Make sure we have a default mount option.
399 * Otherwise skip past any leading '-'.
400 */
401 if (fo->opt_opts == 0)
402 fo->opt_opts = strdup("rw,defaults");
403 else if (*fo->opt_opts == '-') {
404 /*
405 * We cannot simply do fo->opt_opts++ here since the opts
406 * module will try to free the pointer fo->opt_opts later.
407 * So just reallocate the thing -- stolcke 11/11/94
408 */
409 char *old = fo->opt_opts;
410 fo->opt_opts = strdup(old + 1);
411 XFREE(old);
412 }
413
414 /*
415 * If addopts option was used, then append it to the
416 * current options and remote mount options.
417 */
418 if (fo->opt_addopts) {
419 if (STREQ(fo->opt_opts, fo->opt_remopts)) {
420 /* optimize things for the common case where opts==remopts */
421 char *mergedstr;
422 mergedstr = merge_opts(fo->opt_opts, fo->opt_addopts);
423 plog(XLOG_USER, "merge rem/opts \"%s\" add \"%s\" => \"%s\"",
424 fo->opt_opts, fo->opt_addopts, mergedstr);
425 XFREE(fo->opt_opts);
426 XFREE(fo->opt_remopts);
427 fo->opt_opts = mergedstr;
428 fo->opt_remopts = strdup(mergedstr);
429 } else {
430 char *mergedstr, *remmergedstr;
431 mergedstr = merge_opts(fo->opt_opts, fo->opt_addopts);
432 plog(XLOG_USER, "merge opts \"%s\" add \"%s\" => \"%s\"",
433 fo->opt_opts, fo->opt_addopts, mergedstr);
434 XFREE(fo->opt_opts);
435 fo->opt_opts = mergedstr;
436 remmergedstr = merge_opts(fo->opt_remopts, fo->opt_addopts);
437 plog(XLOG_USER, "merge remopts \"%s\" add \"%s\" => \"%s\"",
438 fo->opt_remopts, fo->opt_addopts, remmergedstr);
439 XFREE(fo->opt_remopts);
440 fo->opt_remopts = remmergedstr;
441 }
442 }
443
444 /*
445 * Check the filesystem is happy
446 */
447 if (fo->fs_mtab)
448 XFREE(fo->fs_mtab);
449
450 if ((fo->fs_mtab = (*rop->fs_match) (fo)))
451 return rop;
452
453 /*
454 * Return error file system
455 */
456 fo->fs_mtab = (*amfs_error_ops.fs_match) (fo);
457 return &amfs_error_ops;
458}