/* * 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 * or http://www.opensolaris.org/os/licensing. * 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 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <stdio.h> #include <string.h> #include <dirent.h> #include <fcntl.h> #include <string.h> #include <errno.h> #include <limits.h> #include <unistd.h> #include <sys/mkdev.h> #include <volmgt.h> #include <ctype.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/param.h> #include "volmgt_private.h" /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_running: check to see if volume management is running. * * arguments: * none. * * return value(s): * TRUE if volume management is running, FALSE if not. * * preconditions: * none. */ int volmgt_running(void) { /* vold is dead */ return (FALSE); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_inuse: check to see if volume management is currently * managing a particular device. * * arguments: * path - the name of the device in /dev. For example, * "/dev/rdiskette". * * return value(s): * TRUE if volume management is managing the device, FALSE if not. * * preconditions: * none. */ /* ARGSUSED */ int volmgt_inuse(char *path) { return (FALSE); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_check: have volume management look at its devices to check * for media having arrived. Since volume management can't * automatically check all types of devices, this function is provided * to allow applications to cause the check to happen automatically. * * arguments: * path - the name of the device in /dev. For example, * /dev/rdiskette. If path is NULL, all "checkable" devices are * checked. * * return value(s): * TRUE if media was found in the device, FALSE if not. * * preconditions: * volume management must be running. */ /* ARGSUSED */ int volmgt_check(char *path) { return (FALSE); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_ownspath: check to see if the given path is contained in * the volume management name space. * * arguments: * path - string containing the path. * * return value(s): * TRUE if the path is owned by volume management, FALSE if not. * Will return FALSE if volume management isn't running. * * preconditions: * none. */ /* ARGSUSED */ int volmgt_ownspath(char *path) { return (FALSE); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_root: return the root of where the volume management * name space is mounted. * * arguments: * none. * * return value(s): * Returns a pointer to a static string containing the path to the * volume management root (e.g. "/vol"). * Will return NULL if volume management isn't running. * * preconditions: * none. */ const char * volmgt_root(void) { static const char *vold_root = "/dev"; return (vold_root); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_symname: Returns the volume management symbolic name * for a given device. If an application wants to determine * what the symbolic name (e.g. "floppy0") for the /dev/rdiskette * device would be, this is the function to use. * * arguments: * path - a string containing the /dev device name. For example, * "/dev/diskette" or "/dev/rdiskette". * * Note: must be a block- or char-spcl device, and have a non-zero * st_rdev (real device) stat() value. * * return value(s): * pointer to a string containing the symbolic name. * * NULL indicates that volume management isn't managing that device. * * The string must be free(3)'d. * * preconditions: * none. */ /* ARGSUSED */ char * volmgt_symname(char *path) { return (NULL); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_symdev: Returns the device given the volume management * symbolic name. If an application wants to determine * what the device associated with a particular symbolic name * might be, this is the function to use. * * arguments: * path - a string containing the symbolic device name. For example, * "cdrom0" or "floppy0". * * return value(s): * pointer to a string containing the /dev name. * * NULL indicates that volume management isn't managing that device. * * The string must be free(3)'d. * * preconditions: * none. */ /* ARGSUSED */ char * volmgt_symdev(char *symname) { return (NULL); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * volmgt_feat_enabled: check to see if a volume management feature * is available * * arguments: * feat_str - a string containing the feature to be checked for * * return value(s): * return non-zero if the specified feature is available in * volume management, else return zero * * preconditions: * none. */ /* * the following is a lit of the "feature" available in volmgt * * this list is meant to be updated when new features (that users may * want to use) are added to volmgt * * note: feature strings added should be all lower case, and spaces are * discouraged * * (see psarc/1995/138 for more info) */ static char *volmgt_feat_list[] = { #ifdef DIRECT_DEV_ACCESS_WORKING "direct-dev-access", /* access through /dev co-exists */ #endif "floppy-summit-interfaces", /* volmgt_{acquire,release} */ NULL }; int volmgt_feature_enabled(char *feat_str) { return (0); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * uncommitted * * description: * volmgt_acquire: try to acquire the volmgt advisory device reservation * for a specific device. * * arguments: * dev - a device name to attempt reserving. This string can be: * - a full path name to a device * - a symbolic device name (e.g. floppy0) * * id - a reservation string that hopefully describes the application * making this reservation. * * pid - a pointer to a pid_t type. If this argument is not NULL * and the requested device is already reserved, the process * id of the reservation owner will be returned in this * location. * * ovr - an override indicator. If set to non-zero, the caller requests * that this reservation be made unconditionally. * * err - the address of a pointer to a string which is to receive the * id argument used when the current device was reserved. This * is only used when the current reservation attempt fails due * to an already existing reservation for this device. * * return value(s): * A non-zero indicator if successful. * * A zero indicator if unsuccessful. If errno is EBUSY, then the err * argument will be set to point to the string that the process currently * holding the reservation supplied when reserving the device. It is up * to the caller to release the storage occupied by the string via * free(3C) when no longer needed. * * preconditions: * none */ /* ARGSUSED */ int volmgt_acquire(char *dev, char *id, int ovr, char **err, pid_t *pidp) { return (0); } /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * uncommitted * * description: * volmgt_release: try to release the volmgt advisory device reservation * for a specific device. * * arguments: * dev - a device name to attempt reserving. This string can be: * - a full path name to a device * - a symbolic device name (e.g. floppy0) * * return value(s): * A non-zero indicator if successful * A zero indicator if unsuccessful * * preconditions: * none */ int volmgt_release(char *dev) { return (0); } /* * returns the "value" of the attribute. * If the attribute is boolean and is TRUE, * "true" is returned. If the boolean is * FALSE, NULL is returned. If the attribute * doesn't exist, NULL is returned. The pointer * returned by media_getattr has been malloc'd and * it is the callers responsibility to free it. */ /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * media_getattr: returns the value for an attribute for a piece of * removable media. * * arguments: * path - Path to the media in /vol. Can be the block or character * device. * * attr - name of the attribute. * * return value(s): * returns NULL or a pointer to a string that contains the value for * the requested attribute. * * NULL can mean: * - the media doesn't exist * - there is no more space for malloc(3) * - the attribute doesn't exist for the named media * - the attribute is a boolean and is FALSE * * the pointer to the string must be free'd with free(3). * * preconditions: * volume management (vold) must be running. */ /* ARGSUSED */ char * media_getattr(char *vol_path, char *attr) { return (NULL); } /* * sets the attribute "attr" to value "value". * * If value == "" the flag is * considered to be a TRUE boolean. * * If value == 0, it is considered to be a FALSE boolean. * returns TRUE on success, FALSE on failure. * * Can fail for reasons of permission, or if you * write a read-only attribute. */ /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * media_setattr: set an attribute for a piece of media to a * particular value. * * arguments: * path - Path to the media in /vol. Can be the block or character * device. * * attr - name of the attribute. * * value - value of the attribute. If value == "", the flag is * considered to be a boolean that is TRUE. If value == 0, it * is considered to be a FALSE boolean. * * return value(s): * TRUE on success, FALSE for failure. * * Can fail because: * - don't have permission to set the attribute because caller * is not the owner of the media and attribute is a "system" * attribute. * * - don't have permission to set the attribute because the * attribute is a "system" attribute and is read-only. * * preconditions: * volume management must be running. */ /* ARGSUSED */ int media_setattr(char *vol_path, char *attr, char *value) { return (FALSE); } /* * Returns the "id" of a volume. If the returned value * & VOLID_TMP, the volume is temporary and this value * cannot be relied upon across reboots. */ /* * arc approved interface * - can not be modified without approval from an arc * * committment level: * public * * description: * media_getid: return the "id" of a piece of media. * * arguments: * path - Path to the media in /vol. Can be the block or character * device. * return value(s): * returns a u_longlong_t that is the "id" of the volume. * * preconditions: * volume management must be running. */ u_longlong_t media_getid(char *vol_path) { return (0); } /* * arc approved interface (pending) * - can not be modified without approval from an arc * * committment level: * public * * description: * media_findname: try to come up with the character device when * provided with a starting point. This interface provides the * application programmer to provide "user friendly" names and * easily determine the "/vol" name. * * arguments: * start - a string describing a device. This string can be: * - a full path name to a device (insures it's a * character device by using getfullrawname()). * - a full path name to a volume management media name * with partitions (will return the lowest numbered * raw partition. * - the name of a piece of media (e.g. "fred"). * - a symbolic device name (e.g. floppy0, cdrom0, etc) * - a name like "floppy" or "cdrom". Will pick the lowest * numbered device with media in it. * * return value(s): * A pointer to a string that contains the character device * most appropriate to the "start" argument. * * NULL indicates that we were unable to find media based on "start". * * The string must be free(3)'d. * * preconditions: * none. */ /* ARGSUSED */ char * media_findname(char *start) { /* * Eventually should implement using HAL interfaces. * In the short term however, return NULL for aliases, * and self for absolute pathnames. */ if (start[0] == '/') { return (strdup(start)); } else { return (NULL); } } struct alias { char *alias; char *name; }; /* * "old" aliases -- used to be used when vold wasn't running */ static struct alias device_aliases[] = { { "fd", "/dev/rdiskette" }, { "fd0", "/dev/rdiskette" }, { "fd1", "/dev/rdiskette1" }, { "diskette", "/dev/rdiskette" }, { "diskette0", "/dev/rdiskette0" }, { "diskette1", "/dev/rdiskette1" }, { "rdiskette", "/dev/rdiskette" }, { "rdiskette0", "/dev/rdiskette0" }, { "rdiskette1", "/dev/rdiskette1" }, { "floppy", "/dev/rdiskette" }, { "floppy0", "/dev/rdiskette0" }, { "floppy1", "/dev/rdiskette1" }, { "cd", "cdrom0" }, { "cd0", "cdrom0" }, { "cd1", "cdrom1" }, { NULL, NULL } }; /* * This is an ON Consolidation Private interface. */ /* ARGSUSED */ char * _media_oldaliases(char *start) { struct alias *s; char *p; char *res = NULL; for (s = device_aliases; s->alias != NULL; s++) { if (strcmp(start, s->alias) == 0) { res = strdup(s->name); break; } } return (res); } /* * This is an ON Consolidation Private interface. * * Print out the aliases available to the program user. Changes * depending in whether volume management is running. */ void _media_printaliases(void) { }
