ucblinks.c revision 1ca932730d3439e527d5fe4a15444600d0df7e7e
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* ucblinks - create 4.x /dev compatibility names
*
* The basic algorithm is:
*
* find block and character special files in /devices with major
* numbers of devices that need compatibility names
*
* determine compatibility names from minor number, driver name, and
* /devices name
*
* create symlinks for the compatibility names to 5.x /dev
* entries if possible or /devices entries if necessary
*
* The name space that ucblinks creates has a number of problems.
* Unfortunately people have, to an unknown extent, come to depend
* on the broken name space. Fixing ucblinks to be more compatible
* with 4.x would make it less compatible with previous releases of
* 5.x. The places were it is broken are noted throughout the code
* and summarized here:
*
* 1157501 ucblinks creates completely broken 4.x links for IPI
* 1157616 ucblinks does 0 <-> 3 swap for disks when it shouldn't
* 1157970 ucblinks creates incompatible and overlapping links for tapes
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ftw.h>
#include <locale.h>
#include <libdevinfo.h>
static char *progname;
static int debug = 0; /* only print what is right and wrong */
static int depth; /* num descriptors to use for nftw() */
/*
* Each block or character device entry in /devices is
* represented by one of these structures.
*/
struct devices_ent {
char *devicename; /* /devices name */
char *min_comp; /* minor component of name */
int minor; /* minor number */
int israw; /* character device? */
int iscd; /* cdrom? */
int issd; /* simple sd use? */
int csum; /* checksum of name */
};
/*
* There are a set of devices for which we'll create
* compatibility names. Each driver for the devices
* is represented by a drvinfo structure. The rule_func
* field points to a rule function for that driver.
*/
typedef void (rule_func_t)(struct devices_ent *);
struct drvinfo {
char *name; /* driver name from name_to_major */
int major; /* major number */
int index; /* index, for sorting */
};
/*
* The rules for the drivers.
*/
/*
* Below are the devices for which we create compatibility
* links. Some are obsolete as they have no /etc/name_to_major
* entry, but they're here to be compatible with the awk-based
* version of ucblinks. This list should be in alphabetical
* order with the index field set for the position in the array
* (we could compute it at runtime, but we know it so we set
* it here). See dcomp() for more about sort order.
*/
{ NULL },
};
/*
* Each symlink in /dev is represented by a symlink structure.
* We record all of them, not just those that point to interesting
* /devices entries, because when we have determined what a
* compatibility link should point to we want to know if it
* already points to the correct target and it is much cheaper to
* look it up in our list than to make a system call.
*/
struct symlink {
char *linkname; /* name of link */
char *target; /* what the link points to */
int csum; /* checksum of linkname */
int already; /* link already made */
};
/*
* The /devices entries and the /dev symlinks are kept in
* (separate) hash tables. HASHSIZE was pulled out of the
* air although it seems to work ok and we get a good
* distribution. Some theory says this should be prime,
* but I don't understand why and that would make "% HASHSIZE"
* a call to mod routine rather than a simple bit-wise and.
*/
#define HASHSIZE 256
static struct devices_ent **devices_list;
static int num_devices_ents;
/*
* Buffers used by the rule functions to construct link names.
*/
/*
* Handle used for the link database
*/
static di_devlink_handle_t link_handle;
static void exec_script(char **argv);
static void get_major_nums(void);
static void set_depth(void);
static void get_devices(void);
static void get_dev_links(void);
static void call_device_rules(void);
static int is_blank(char *);
/*
* The command-line arguments to ucblinks are:
*
* -r specify a root relative to which ./devices and ./dev
* are used to create links.
*
* -e the awk-based ucblinks had a default rule-base and
* allowed alternate rule-bases with -e. If the user
* specifies a rule-base we run the awk-based ucblinks
* and pass all the args to it.
*
* -d undocumented debug option (like the awk-based version);
* print what would be created, fixed, or is already correct.
*/
int
{
int c;
int err = 0;
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
switch (c) {
case 'r':
break;
case 'e':
/* exec_script doesn't return */
break;
case 'd':
debug = 1;
break;
case '?':
default:
err = 1;
break;
}
}
"[ -e rulebase ]\n"), progname);
exit(1);
}
set_depth();
get_devices();
return (0);
}
/*
* A utility function so we don't have to check the return
* value of malloc for NULL all over the place.
*/
static void *
{
void *p;
if (p != NULL)
return (p);
else {
"out of memory\n"), progname);
exit(1);
#ifdef lint
return (NULL);
#endif
}
}
/*
* A utility function so we don't have to check the return
* value of strdup (which gets space from malloc) for NULL
* all over the place.
*/
static char *
{
char *s2;
return (s2);
else {
"out of memory\n"), progname);
exit(1);
#ifdef lint
return (NULL);
#endif
}
}
/*
* A utility function that prepends the program name to
* perror output.
*/
static void
{
char *msg;
}
/*
* The awk-based ucblinks allowed an alternate rule-base with
* the -e option. Obviously we don't do awk, so pass off all
* our command-line arguments to the awk-based version which
*/
#define SCRIPT "/usr/ucblib/ucblinks.sh"
static void
exec_script(char **argv)
{
exit(1);
}
/*
* Construct a name with the rootdir, if specified with -r,
* prepended. Don't free this because when rootdir isn't
* set we return what was passed in (this is called at most
* four times so it's no big deal to not free it).
*/
static char *
{
char *buf;
return (name);
else {
return (buf);
}
}
/*
* Read /etc/name_to_major to find the major numbers associated
* with the names in the drvinfo array. We silently ignore
* what we don't understand.
*/
static void
get_major_nums(void)
{
int majnum;
"/etc/name_to_major\n"), progname);
exit(1);
}
/* cut off comments starting with '#' */
*cp = '\0';
/* ignore comment or blank lines */
continue;
continue;
continue;
/*
* Compare against our list and set the major
* number it it's a name we care about.
*/
break;
}
}
}
}
/*
* Pick some reasonable number of file descriptors to let nftw()
* have open at a time. The number shouldn't be more than the
* currently available file descriptors but should be at least equal
* to the depth of the trees we're traversing for efficiency. Of
* course we don't know how deep the trees are before hand, so
* just use half the allowable descriptors which usually comes
* out to 32 which is usually more than enough. Using a depth
* smaller than the tree depth doesn't prevent traversal of the tree,
* it just makes it slower. sysconf() can't fail, but if it does
* use a depth of 1.
*/
static void
set_depth(void)
{
long num;
if (num == -1)
depth = 1;
else
}
/*
* Given a major number look it up in our list to see if it
* is associated with a device that needs a compatibility
* link. We cache the last lookup to avoid going through
* the list each time.
*/
static struct drvinfo *
interesting_major(int major)
{
static int last_major = -1;
if (major == last_major)
return (last_result);
last_major = major;
last_result = drp;
return (drp);
}
}
last_result = NULL;
return (NULL);
}
/*
* Find the minor component of the device name which is what
* comes between the ':' and ',' in the last component of
* the pathname; make a copy and return a pointer to it.
*/
static char *
find_min_comp(char *name)
{
int len;
char *buf;
else
cp1++; /* skip '/' */
return ("");
cp1++; /* skip ':' */
cp2++;
if (len == 0)
return ("");
return (buf);
}
/*
* To get an index into the hash table we compute a checksum
* of the string and mod HASHSIZE. The checksum came from
* awk, although we do a shift and subtract to implement
* multiplication by 31. We return the index as well as
* the whole checksum. The checksum is useful for efficient
* symbol lookup because the hash table will contain long strings
* that can be the same for the first 70 characters or more, so
* we compare checksums first before using strcmp().
*/
static int
{
char c;
unsigned int csum = 0;
while ((c = *name++) != '\0')
}
/*
* Insert a /devices entry symbol into the devices entry
* hash table.
*/
static void
{
int hash;
struct devices_ent **pp;
}
/*
* Lookup a symbol in the devices entry hash table. Use
* the checksum to reduce the number of strcmp() calls.
*/
static struct devices_ent *
lookup_devices_sym(char *devicename)
{
int hash;
struct devices_ent *dep;
int csum;
return (dep);
}
}
return (NULL);
}
/*
* This routine is called from nftw() for each /devices entry.
* If it isn't a device special file or doesn't have the major
* number of something we care about, don't do anything.
* Otherwise, allocate a structure for it and put it in the
* hash table.
*/
/* ARGSUSED2 */
static int
{
int type;
struct devices_ent *dep;
return (0);
}
return (0);
}
return (0);
return (0);
return (0);
}
/*
* dcomp is the sort function called from qsort(). When comparing
* two device entries we sort by alphabetical order of the device's
* driver name, then minor number, then block vs. character, then
* the name of the device entry itself.
*/
static int
{
dep2->devicename));
} else {
}
} else {
}
} else {
}
}
/*
* Go to the /devices directory and recursively find all
* the device special files (with the handy library function
* nftw). nftw() will call devices_entry() which will put
* the entry in the hash table. After we find all the
* entries allocate a table and put pointers in it so
* we can sort the entries.
*/
static void
get_devices(void)
{
char *dir;
int i;
exit(1);
}
/*
* Errors related to access permissions are handled
* by devices_entry() and devices_entry doesn't return
* non-zero so the only thing left is some other type
* of error.
*/
xperror("nftw()");
pdep = devices_list;
pht = de_hashtab;
for (i = 0; i < HASHSIZE; i++) {
}
pht++;
}
/*
* After all the /devices entries are put in the hash
* table we sort the entries. We do this for two
* reasons: the rule functions may count on the order of
* devices it is called with (like the cdrom stuff in
* rule_sd) and if the rules create overlapping names the
* links will be made in an order based on sorted entries
* rather than be dependent on the order the entries
* happen to be in in a directory.
*/
sizeof (struct devices_ent *), dcomp);
}
/*
* Like insert_devices_sym, but for link names and symlink
* structures.
*/
static void
{
int hash;
}
/*
* Like lookup_devices_sym, but for link names and symlink
* structures.
*/
static struct symlink *
lookup_link_sym(char *linkname)
{
int hash;
int csum;
return (slp);
}
}
return (NULL);
}
/*
* Check this symlink to see if it points to an interesting
* /devices entry and hang it off the entry if it does.
*/
static void
{
int dirs;
char *cp;
int len;
char *devices = "../devices/";
char *buf;
int i, off;
struct devices_ent *dep;
return;
/*
* Figure out how many directories deep the entry is
* so we can see if its link has the right number of
* ".."s to point to the /devices directory.
*/
dirs = 0;
dirs++;
}
/*
* The correct prefix of the path has been built up
* in "buf", compare it to the link and return
* if it doesn't match.
*/
return;
}
/*
* Look up the /devices path (minus the prefix) and
* return if not found.
*/
return;
/* hang it off the /devices entry */
}
/*
* This routine is called from nftw() for each /dev entry.
* We record all of the symlinks, not just those that point to
* interesting /devices entries, because when we have determined
* what a compatibility link should point to we want to know
* if it already points to the correct target and it is much
* cheaper to look it up in out list than to make a system call.
*/
/* ARGSUSED2 */
static int
{
int type;
int targetlen;
return (0);
}
return (0);
}
return (0);
if (targetlen == -1)
return (0);
}
/*
* Go to the /dev directory and recursively find all the
* symlinks. nftw() will call dev_entry() which will put
* the entry in the hash table.
*/
static void
get_dev_links(void)
{
char *devdir;
exit(1);
}
/*
* Errors related to access permissions are handled
* by dev_entry() and dev_entry doesn't return non-zero
* so the only thing left is some other type of error.
*/
xperror("nftw()");
}
/*
* Spin through our sorted list of /devices entries and call
* the rule function for each.
*/
static void
call_device_rules(void)
{
struct devices_ent **pdep;
struct devices_ent *dep;
int i;
char *root_etc;
pdep = devices_list;
for (i = 0; i < num_devices_ents; i++) {
}
di_devlink_close(&link_handle, 0);
}
static void
{
if (debug) {
(void) printf("adding %s link to database: %s -> %s\n",
} else {
}
}
/*
* Create a symlink called compat_link that points to target.
* If it already exists correctly don't do anything. If it
* exists but is incorrect, delete the link and make it. If
* it doesn't exist just make it.
*/
static void
char *compat_link,
char *target,
struct symlink *compat_slp,
int link_type)
{
if (debug)
(void) printf("already %s -> %s\n",
return;
} else {
if (debug)
(void) printf("remove %s, link wrong (%s)\n",
else {
else
(void) di_devlink_rm_link(link_handle,
}
}
} else
if (debug)
else {
else
}
}
/*
* addlink is called from the rule functions when they want a
* compatibility link made. At this point we only know the
* link name, the /devices entry, and the prefix of a 5.x /dev
* name (that points to the /devices entry) that the rule would
* prefer the compatibility link point to. If a symlink already
* exists with the required prefix that points to the /devices
* entry, make the compatibility link point to that link.
* If a link with the required prefix doesn't exist, make the
* link point directly to the /devices entry. The idea is that
* someone looking at a compatibility link will be reminded of
* the "real" 5.x /dev name. For example, ls -l will show sd0a ->
*
* If the symlink we're creating isn't already in the hash
* table we add it for possible future use by make_link.
* If multiple /devices entries exist with the same major
* and minor numbers this prevents problems with trying to
* make the link twice. Generally, though, there shouldn't
* be multiple /devices entries of the same type, major, and
* minor, except for tape devices. The tape rules pass 1 for
* the unique argument (all others pass 0) so we keep track
* and only create the first link for a particular compatibility
* name.
*/
static void
{
struct symlink *devent_slp;
struct symlink *compat_slp;
if (compat_slp == NULL) {
compat_slp->already = 0;
}
if (unique) {
if (compat_slp->already)
return;
else
}
/*
* Look for a name with the correct prefix.
*/
while (devent_slp != NULL) {
break;
}
}
/*
* If we didn't find one with the prefix, point directly
* to the /devices entry.
*/
}
}
/*
* This is like addlink(), but it doesn't try to find a 5.x
* link to point to. It is used by the rule functions to add
* additional links to links already created with addlink().
*/
static void
{
char *oldtarg;
}
if (unique) {
return;
else
}
/*
* If it didn't exist or pointed to the wrong
* thing we need to duplicate the target and
* note that the symlink now points to it.
*/
}
/*
* The rest of this file is rule functions and support routines
* for the rules. Each rule is passed a pointer to a devices_ent
* struct which should be all it needs to determine what
* compatibility link is needed. The rule functions use
* addlink() and addlink_nolookup() to have the links
* made.
*/
/*
* Rule for Archive tapes. "ar" isn't in name_to_major but
* the awk-based version had a rule so it is here too. The
* rule works the same as the awk rule, but who knows if it
* is correct.
*/
static void
{
if (*min_comp != '\0') {
else
}
}
/*
* Rule for frame buffers.
*/
static void
{
}
/*
* Rule for floppy drivers.
*/
static void
{
int c_slice;
char *link_pfx;
char *targ_pfx;
link_pfx = "r";
targ_pfx = "rdiskette";
} else {
link_pfx = "";
targ_pfx = "diskette";
}
if (c_slice) {
}
}
/*
* Rule for IPI disks. This is hopelessly broken (see bug 1157501)
* but someone may have come to depend on the broken names.
*/
static void
{
char *targ_pfx;
char *link_pfx;
link_pfx = "r";
targ_pfx = "rdsk/";
} else {
link_pfx = "";
targ_pfx = "dsk/";
}
}
/*
* Rule for obsolete mt devices. It works like the awk rule,
* but unknown if correct.
*/
static void
{
} else {
}
}
static int
{
char *path;
char devpath[MAXPATHLEN];
struct devices_ent *dep;
if (*path == '/') {
}
}
return (DI_WALK_CONTINUE);
}
static int
{
char *path;
char devpath[MAXPATHLEN];
struct devices_ent *dep;
if (*path == '/') {
}
}
return (DI_WALK_CONTINUE);
}
/*
* The rule for scsi disks uses this to determine if the /devices
* entry corresponds to a cdrom drive. Use libdevinfo to walk
* the device tree:
* calling find_cd_nodes() for each minor node of type DDI_NT_CD.
* calling find_sd_nodes() for each minor node of type DDI_NT_BLOCK_CHAN.
*/
static void
find_cdsd(void)
{
if (root_node == DI_NODE_NIL) {
return;
}
}
/*
* Rule for scsi disks. If the entry is for a cdrom drive
* we create srN and rsrN where N is logically numbered
* starting at 0 in order of minor number. For regular
* disks we do the 0 <-> 3 swap, i.e., sd0a will point
* to c0t3d0s0 and sd3a will point to c0t0d0s0. This should
* only be done on sun4m machines to be compatible
* with 4.x (see bug 1157616) but we're probably stuck with it
* being done on all machines because people may be used
* to using the swapped names on other machines.
*/
static void
{
static int first = 1;
static int cdnum = -1;
static int last_minor = -1;
char *targ_pfx;
char *link_pfx;
if (first) {
find_cdsd();
first = 0;
}
if (minor != last_minor) {
cdnum++;
last_minor = minor;
}
} else {
}
}
return;
}
return;
link_pfx = "r";
targ_pfx = "rdsk/";
} else {
link_pfx = "";
targ_pfx = "dsk/";
}
if (minor < 8)
else
min_comp);
}
/*
* Rule for PCI cdrom drives.
*/
static void
{
static int last_minor = -1;
static int cdnum = -1;
if (minor != last_minor) {
cdnum++;
last_minor = minor;
}
} else {
}
}
}
/*
* Rule for scsi and xt tapes. The tape name space has several
* problems (see bug 1157970) and the xt names should really appear
* as an "mt" name (see bug 1157617) but, again, we probably shouldn't
* change this now as it will break compatibility with earlier
* 5.x releases.
*/
/*
* MTUNIT() and MT_DENSITY() use getminor(), but we already have
* the minor number and including sysmacros.h to get getminor()
* conflicts with mkdev.h. Barf.
*/
#define getminor(d) (d)
static void
{
char *link_pfx;
return; /* not BSD-style */
link_pfx = "nr";
else
link_pfx = "r";
}
}
/*
* Rule for xd and xy disks. This is broken because it does
* the 0 <-> 3 swap that should only be done for scsi disks
* on sun4m (see bug 1157616). Again, we probably
* can't change this now.
*/
static void
{
char *targ_pfx;
char *link_pfx;
link_pfx = "r";
targ_pfx = "rdsk/";
} else {
link_pfx = "";
targ_pfx = "dsk/";
}
if (minor < 8)
min_comp);
min_comp);
else
}
/*
* Rule for zs (serial) devices. This rule is different from
* the rest because it doesn't create a link based on the
* /devices entry. It just uses the /devices entry to trigger
* entries.
*/
#include <dirent.h>
static void
{
static int beenhere = 0;
int len;
char *termdir;
char *entry;
return;
if (beenhere)
return;
else
beenhere = 1;
return;
}
if (entry[0] == '.')
continue;
}
}
/*
* is_blank() returns 1 (true) if a line specified is composed of
* whitespace characters only. otherwise, it returns 0 (false).
*
* Note. the argument (line) must be null-terminated.
*/
static int
{
return (0);
return (1);
}