OpenSolaris_b135/uts/common/os/devcache.c
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/note.h>
#include <sys/t_lock.h>
#include <sys/cmn_err.h>
#include <sys/instance.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/hwconf.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ndi_impldefs.h>
#include <sys/modctl.h>
#include <sys/dacf.h>
#include <sys/promif.h>
#include <sys/cpuvar.h>
#include <sys/pathname.h>
#include <sys/kobj.h>
#include <sys/devcache.h>
#include <sys/devcache_impl.h>
#include <sys/sysmacros.h>
#include <sys/varargs.h>
#include <sys/callb.h>
/*
* This facility provides interfaces to clients to register,
* read and update cache data in persisted backing store files,
* usually in /etc/devices. The data persisted through this
* mechanism should be stateless data, functioning in the sense
* of a cache. Writes are performed by a background daemon
* thread, permitting a client to schedule an update without
* blocking, then continue updating the data state in
* parallel. The data is only locked by the daemon thread
* to pack the data in preparation for the write.
*
* Data persisted through this mechanism should be capable
* of being regenerated through normal system operation,
* for example attaching all disk devices would cause all
* devids to be registered for those devices. By caching
* a devid-device tuple, the system can operate in a
* more optimal way, directly attaching the device mapped
* to a devid, rather than burdensomely driving attach of
* the entire device tree to discover a single device.
*
* Note that a client should only need to include
* <sys/devcache.h> for the supported interfaces.
*
* The data per client is entirely within the control of
* the client. When reading, data unpacked from the backing
* store should be inserted in the list. The pointer to
* the list can be retrieved via nvf_list(). When writing,
* the data on the list is to be packed and returned to the
* nvpdaemon as an nvlist.
*
* Obvious restrictions are imposed by the limits of the
* nvlist format. The data cannot be read or written
* piecemeal, and large amounts of data aren't recommended.
* However, nvlists do allow that data be named and typed
* and can be size-of-int invariant, and the cached data
* can be versioned conveniently.
*
* The registration involves two steps: a handle is
* allocated by calling the registration function.
* This sets up the data referenced by the handle and
* initializes the lock. Following registration, the
* client must initialize the data list. The list
* interfaces require that the list element with offset
* to the node link be provided. The format of the
* list element is under the control of the client.
*
* Locking: the address of the data list r/w lock provided
* can be accessed with nvf_lock(). The lock must be held
* as reader when traversing the list or checking state,
* such as nvf_is_dirty(). The lock must be held as
* writer when updating the list or marking it dirty.
* The lock must not be held when waking the daemon.
*
* The data r/w lock is held as writer when the pack,
* unpack and free list handlers are called. The
* lock should not be dropped and must be still held
* upon return. The client should also hold the lock
* as reader when checking if the list is dirty, and
* as writer when marking the list dirty or initiating
* a read.
*
* The asynchronous nature of updates allows for the
* possibility that the data may continue to be updated
* once the daemon has been notified that an update is
* desired. The data only needs to be locked against
* updates when packing the data into the form to be
* written. When the write of the packed data has
* completed, the daemon will automatically reschedule
* an update if the data was marked dirty after the
* point at which it was packed. Before beginning an
* update, the daemon attempts to lock the data as
* writer; if the writer lock is already held, it
* backs off and retries later. The model is to give
* priority to the kernel processes generating the
* data, and that the nature of the data is that
* it does not change often, can be re-generated when
* needed, so updates should not happen often and
* can be delayed until the data stops changing.
* The client may update the list or mark it dirty
* any time it is able to acquire the lock as
* writer first.
*
* A failed write will be retried after some delay,
* in the hope that the cause of the error will be
* transient, for example a filesystem with no space
* available. An update on a read-only filesystem
* is failed silently and not retried; this would be
* the case when booted off install media.
*
* There is no unregister mechanism as of yet, as it
* hasn't been needed so far.
*/
/*
* Global list of files registered and updated by the nvpflush
* daemon, protected by the nvf_cache_mutex. While an
* update is taking place, a file is temporarily moved to
* the dirty list to avoid locking the primary list for
* the duration of the update.
*/
list_t nvf_cache_files;
list_t nvf_dirty_files;
kmutex_t nvf_cache_mutex;
/*
* Allow some delay from an update of the data before flushing
* to permit simultaneous updates of multiple changes.
* Changes in the data are expected to be bursty, ie
* reconfig or hot-plug of a new adapter.
*
* kfio_report_error (default 0)
* Set to 1 to enable some error messages related to low-level
* kernel file i/o operations.
*
* nvpflush_delay (default 10)
* The number of seconds after data is marked dirty before the
* flush daemon is triggered to flush the data. A longer period
* of time permits more data updates per write. Note that
* every update resets the timer so no repository write will
* occur while data is being updated continuously.
*
* nvpdaemon_idle_time (default 60)
* The number of seconds the daemon will sleep idle before exiting.
*
*/
#define NVPFLUSH_DELAY 10
#define NVPDAEMON_IDLE_TIME 60
#define TICKS_PER_SECOND (drv_usectohz(1000000))
/*
* Tunables
*/
int kfio_report_error = 0; /* kernel file i/o operations */
int kfio_disable_read = 0; /* disable all reads */
int kfio_disable_write = 0; /* disable all writes */
int nvpflush_delay = NVPFLUSH_DELAY;
int nvpdaemon_idle_time = NVPDAEMON_IDLE_TIME;
static timeout_id_t nvpflush_id = 0;
static int nvpflush_timer_busy = 0;
static int nvpflush_daemon_active = 0;
static kthread_t *nvpflush_thr_id = 0;
static int do_nvpflush = 0;
static int nvpbusy = 0;
static kmutex_t nvpflush_lock;
static kcondvar_t nvpflush_cv;
static kthread_id_t nvpflush_thread;
static clock_t nvpticks;
static void nvpflush_daemon(void);
#ifdef DEBUG
int nvpdaemon_debug = 0;
int kfio_debug = 0;
#endif /* DEBUG */
extern int modrootloaded;
extern void mdi_read_devices_files(void);
extern void mdi_clean_vhcache(void);
extern int sys_shutdown;
/*
* Initialize the overall cache file management
*/
void
i_ddi_devices_init(void)
{
list_create(&nvf_cache_files, sizeof (nvfd_t),
offsetof(nvfd_t, nvf_link));
list_create(&nvf_dirty_files, sizeof (nvfd_t),
offsetof(nvfd_t, nvf_link));
mutex_init(&nvf_cache_mutex, NULL, MUTEX_DEFAULT, NULL);
retire_store_init();
devid_cache_init();
}
/*
* Read cache files
* The files read here should be restricted to those
* that may be required to mount root.
*/
void
i_ddi_read_devices_files(void)
{
/*
* The retire store should be the first file read as it
* may need to offline devices. kfio_disable_read is not
* used for retire. For the rationale see the tunable
* ddi_retire_store_bypass and comments in:
* uts/common/os/retire_store.c
*/
retire_store_read();
if (!kfio_disable_read) {
mdi_read_devices_files();
devid_cache_read();
}
}
void
i_ddi_start_flush_daemon(void)
{
nvfd_t *nvfdp;
ASSERT(i_ddi_io_initialized());
mutex_init(&nvpflush_lock, NULL, MUTEX_DRIVER, NULL);
cv_init(&nvpflush_cv, NULL, CV_DRIVER, NULL);
mutex_enter(&nvf_cache_mutex);
for (nvfdp = list_head(&nvf_cache_files); nvfdp;
nvfdp = list_next(&nvf_cache_files, nvfdp)) {
if (NVF_IS_DIRTY(nvfdp)) {
nvf_wake_daemon();
break;
}
}
mutex_exit(&nvf_cache_mutex);
}
void
i_ddi_clean_devices_files(void)
{
devid_cache_cleanup();
mdi_clean_vhcache();
}
/*
* Register a cache file to be managed and updated by the nvpflush daemon.
* All operations are performed through the returned handle.
* There is no unregister mechanism for now.
*/
nvf_handle_t
nvf_register_file(nvf_ops_t *ops)
{
nvfd_t *nvfdp;
nvfdp = kmem_zalloc(sizeof (*nvfdp), KM_SLEEP);
nvfdp->nvf_ops = ops;
nvfdp->nvf_flags = 0;
rw_init(&nvfdp->nvf_lock, NULL, RW_DRIVER, NULL);
mutex_enter(&nvf_cache_mutex);
list_insert_tail(&nvf_cache_files, nvfdp);
mutex_exit(&nvf_cache_mutex);
return ((nvf_handle_t)nvfdp);
}
/*PRINTFLIKE1*/
void
nvf_error(const char *fmt, ...)
{
va_list ap;
if (kfio_report_error) {
va_start(ap, fmt);
vcmn_err(CE_NOTE, fmt, ap);
va_end(ap);
}
}
/*
* Some operations clients may use to manage the data
* to be persisted in a cache file.
*/
char *
nvf_cache_name(nvf_handle_t handle)
{
return (((nvfd_t *)handle)->nvf_cache_path);
}
krwlock_t *
nvf_lock(nvf_handle_t handle)
{
return (&(((nvfd_t *)handle)->nvf_lock));
}
list_t *
nvf_list(nvf_handle_t handle)
{
return (&(((nvfd_t *)handle)->nvf_data_list));
}
void
nvf_mark_dirty(nvf_handle_t handle)
{
ASSERT(RW_WRITE_HELD(&(((nvfd_t *)handle)->nvf_lock)));
NVF_MARK_DIRTY((nvfd_t *)handle);
}
int
nvf_is_dirty(nvf_handle_t handle)
{
ASSERT(RW_LOCK_HELD(&(((nvfd_t *)handle)->nvf_lock)));
return (NVF_IS_DIRTY((nvfd_t *)handle));
}
static uint16_t
nvp_cksum(uchar_t *buf, int64_t buflen)
{
uint16_t cksum = 0;
uint16_t *p = (uint16_t *)buf;
int64_t n;
if ((buflen & 0x01) != 0) {
buflen--;
cksum = buf[buflen];
}
n = buflen / 2;
while (n-- > 0)
cksum ^= *p++;
return (cksum);
}
int
fread_nvlist(char *filename, nvlist_t **ret_nvlist)
{
struct _buf *file;
nvpf_hdr_t hdr;
char *buf;
nvlist_t *nvl;
int rval;
uint_t offset;
int n;
char c;
uint16_t cksum, hdrsum;
*ret_nvlist = NULL;
file = kobj_open_file(filename);
if (file == (struct _buf *)-1) {
KFDEBUG((CE_CONT, "cannot open file: %s\n", filename));
return (ENOENT);
}
offset = 0;
n = kobj_read_file(file, (char *)&hdr, sizeof (hdr), offset);
if (n != sizeof (hdr)) {
kobj_close_file(file);
if (n < 0) {
nvf_error("error reading header: %s\n", filename);
return (EIO);
} else if (n == 0) {
KFDEBUG((CE_CONT, "file empty: %s\n", filename));
} else {
nvf_error("header size incorrect: %s\n", filename);
}
return (EINVAL);
}
offset += n;
KFDEBUG2((CE_CONT, "nvpf_magic: 0x%x\n", hdr.nvpf_magic));
KFDEBUG2((CE_CONT, "nvpf_version: %d\n", hdr.nvpf_version));
KFDEBUG2((CE_CONT, "nvpf_size: %lld\n",
(longlong_t)hdr.nvpf_size));
KFDEBUG2((CE_CONT, "nvpf_hdr_chksum: 0x%x\n",
hdr.nvpf_hdr_chksum));
KFDEBUG2((CE_CONT, "nvpf_chksum: 0x%x\n", hdr.nvpf_chksum));
cksum = hdr.nvpf_hdr_chksum;
hdr.nvpf_hdr_chksum = 0;
hdrsum = nvp_cksum((uchar_t *)&hdr, sizeof (hdr));
if (hdr.nvpf_magic != NVPF_HDR_MAGIC ||
hdr.nvpf_version != NVPF_HDR_VERSION || hdrsum != cksum) {
kobj_close_file(file);
if (hdrsum != cksum) {
nvf_error("%s: checksum error "
"(actual 0x%x, expected 0x%x)\n",
filename, hdrsum, cksum);
}
nvf_error("%s: header information incorrect", filename);
return (EINVAL);
}
ASSERT(hdr.nvpf_size >= 0);
buf = kmem_alloc(hdr.nvpf_size, KM_SLEEP);
n = kobj_read_file(file, buf, hdr.nvpf_size, offset);
if (n != hdr.nvpf_size) {
kmem_free(buf, hdr.nvpf_size);
kobj_close_file(file);
if (n < 0) {
nvf_error("%s: read error %d", filename, n);
} else {
nvf_error("%s: incomplete read %d/%lld",
filename, n, (longlong_t)hdr.nvpf_size);
}
return (EINVAL);
}
offset += n;
rval = kobj_read_file(file, &c, 1, offset);
kobj_close_file(file);
if (rval > 0) {
nvf_error("%s is larger than %lld\n",
filename, (longlong_t)hdr.nvpf_size);
kmem_free(buf, hdr.nvpf_size);
return (EINVAL);
}
cksum = nvp_cksum((uchar_t *)buf, hdr.nvpf_size);
if (hdr.nvpf_chksum != cksum) {
nvf_error("%s: checksum error (actual 0x%x, expected 0x%x)\n",
filename, hdr.nvpf_chksum, cksum);
kmem_free(buf, hdr.nvpf_size);
return (EINVAL);
}
nvl = NULL;
rval = nvlist_unpack(buf, hdr.nvpf_size, &nvl, 0);
if (rval != 0) {
nvf_error("%s: error %d unpacking nvlist\n",
filename, rval);
kmem_free(buf, hdr.nvpf_size);
return (EINVAL);
}
kmem_free(buf, hdr.nvpf_size);
*ret_nvlist = nvl;
return (0);
}
static int
kfcreate(char *filename, kfile_t **kfilep)
{
kfile_t *fp;
int rval;
ASSERT(modrootloaded);
fp = kmem_alloc(sizeof (kfile_t), KM_SLEEP);
fp->kf_vnflags = FCREAT | FWRITE | FTRUNC;
fp->kf_fname = filename;
fp->kf_fpos = 0;
fp->kf_state = 0;
KFDEBUG((CE_CONT, "create: %s flags 0x%x\n",
filename, fp->kf_vnflags));
rval = vn_open(filename, UIO_SYSSPACE, fp->kf_vnflags,
0444, &fp->kf_vp, CRCREAT, 0);
if (rval != 0) {
kmem_free(fp, sizeof (kfile_t));
KFDEBUG((CE_CONT, "%s: create error %d\n",
filename, rval));
return (rval);
}
*kfilep = fp;
return (0);
}
static int
kfremove(char *filename)
{
int rval;
KFDEBUG((CE_CONT, "remove: %s\n", filename));
rval = vn_remove(filename, UIO_SYSSPACE, RMFILE);
if (rval != 0) {
KFDEBUG((CE_CONT, "%s: remove error %d\n",
filename, rval));
}
return (rval);
}
static int
kfread(kfile_t *fp, char *buf, ssize_t bufsiz, ssize_t *ret_n)
{
ssize_t resid;
int err;
ssize_t n;
ASSERT(modrootloaded);
if (fp->kf_state != 0)
return (fp->kf_state);
err = vn_rdwr(UIO_READ, fp->kf_vp, buf, bufsiz, fp->kf_fpos,
UIO_SYSSPACE, 0, (rlim64_t)0, kcred, &resid);
if (err != 0) {
KFDEBUG((CE_CONT, "%s: read error %d\n",
fp->kf_fname, err));
fp->kf_state = err;
return (err);
}
ASSERT(resid >= 0 && resid <= bufsiz);
n = bufsiz - resid;
KFDEBUG1((CE_CONT, "%s: read %ld bytes ok %ld bufsiz, %ld resid\n",
fp->kf_fname, n, bufsiz, resid));
fp->kf_fpos += n;
*ret_n = n;
return (0);
}
static int
kfwrite(kfile_t *fp, char *buf, ssize_t bufsiz, ssize_t *ret_n)
{
rlim64_t rlimit;
ssize_t resid;
int err;
ssize_t len;
ssize_t n = 0;
ASSERT(modrootloaded);
if (fp->kf_state != 0)
return (fp->kf_state);
len = bufsiz;
rlimit = bufsiz + 1;
for (;;) {
err = vn_rdwr(UIO_WRITE, fp->kf_vp, buf, len, fp->kf_fpos,
UIO_SYSSPACE, FSYNC, rlimit, kcred, &resid);
if (err) {
KFDEBUG((CE_CONT, "%s: write error %d\n",
fp->kf_fname, err));
fp->kf_state = err;
return (err);
}
KFDEBUG1((CE_CONT, "%s: write %ld bytes ok %ld resid\n",
fp->kf_fname, len-resid, resid));
ASSERT(resid >= 0 && resid <= len);
n += (len - resid);
if (resid == 0)
break;
if (resid == len) {
KFDEBUG((CE_CONT, "%s: filesystem full?\n",
fp->kf_fname));
fp->kf_state = ENOSPC;
return (ENOSPC);
}
len -= resid;
buf += len;
fp->kf_fpos += len;
len = resid;
}
ASSERT(n == bufsiz);
KFDEBUG1((CE_CONT, "%s: wrote %ld bytes ok\n", fp->kf_fname, n));
*ret_n = n;
return (0);
}
static int
kfclose(kfile_t *fp)
{
int rval;
KFDEBUG((CE_CONT, "close: %s\n", fp->kf_fname));
if ((fp->kf_vnflags & FWRITE) && fp->kf_state == 0) {
rval = VOP_FSYNC(fp->kf_vp, FSYNC, kcred, NULL);
if (rval != 0) {
nvf_error("%s: sync error %d\n",
fp->kf_fname, rval);
}
KFDEBUG((CE_CONT, "%s: sync ok\n", fp->kf_fname));
}
rval = VOP_CLOSE(fp->kf_vp, fp->kf_vnflags, 1,
(offset_t)0, kcred, NULL);
if (rval != 0) {
if (fp->kf_state == 0) {
nvf_error("%s: close error %d\n",
fp->kf_fname, rval);
}
} else {
if (fp->kf_state == 0)
KFDEBUG((CE_CONT, "%s: close ok\n", fp->kf_fname));
}
VN_RELE(fp->kf_vp);
kmem_free(fp, sizeof (kfile_t));
return (rval);
}
static int
kfrename(char *oldname, char *newname)
{
int rval;
ASSERT(modrootloaded);
KFDEBUG((CE_CONT, "renaming %s to %s\n", oldname, newname));
if ((rval = vn_rename(oldname, newname, UIO_SYSSPACE)) != 0) {
KFDEBUG((CE_CONT, "rename %s to %s: %d\n",
oldname, newname, rval));
}
return (rval);
}
int
fwrite_nvlist(char *filename, nvlist_t *nvl)
{
char *buf;
char *nvbuf;
kfile_t *fp;
char *newname;
int len, err, err1;
size_t buflen;
ssize_t n;
ASSERT(modrootloaded);
nvbuf = NULL;
err = nvlist_pack(nvl, &nvbuf, &buflen, NV_ENCODE_NATIVE, 0);
if (err != 0) {
nvf_error("%s: error %d packing nvlist\n",
filename, err);
return (err);
}
buf = kmem_alloc(sizeof (nvpf_hdr_t) + buflen, KM_SLEEP);
bzero(buf, sizeof (nvpf_hdr_t));
((nvpf_hdr_t *)buf)->nvpf_magic = NVPF_HDR_MAGIC;
((nvpf_hdr_t *)buf)->nvpf_version = NVPF_HDR_VERSION;
((nvpf_hdr_t *)buf)->nvpf_size = buflen;
((nvpf_hdr_t *)buf)->nvpf_chksum = nvp_cksum((uchar_t *)nvbuf, buflen);
((nvpf_hdr_t *)buf)->nvpf_hdr_chksum =
nvp_cksum((uchar_t *)buf, sizeof (nvpf_hdr_t));
bcopy(nvbuf, buf + sizeof (nvpf_hdr_t), buflen);
kmem_free(nvbuf, buflen);
buflen += sizeof (nvpf_hdr_t);
len = strlen(filename) + MAX_SUFFIX_LEN + 2;
newname = kmem_alloc(len, KM_SLEEP);
(void) sprintf(newname, "%s.%s", filename, NEW_FILENAME_SUFFIX);
/*
* To make it unlikely we suffer data loss, write
* data to the new temporary file. Once successful
* complete the transaction by renaming the new file
* to replace the previous.
*/
if ((err = kfcreate(newname, &fp)) == 0) {
err = kfwrite(fp, buf, buflen, &n);
if (err) {
nvf_error("%s: write error - %d\n",
newname, err);
} else {
if (n != buflen) {
nvf_error(
"%s: partial write %ld of %ld bytes\n",
newname, n, buflen);
nvf_error("%s: filesystem may be full?\n",
newname);
err = EIO;
}
}
if ((err1 = kfclose(fp)) != 0) {
nvf_error("%s: close error\n", newname);
if (err == 0)
err = err1;
}
if (err != 0) {
if (kfremove(newname) != 0) {
nvf_error("%s: remove failed\n",
newname);
}
}
} else {
nvf_error("%s: create failed - %d\n", filename, err);
}
if (err == 0) {
if ((err = kfrename(newname, filename)) != 0) {
nvf_error("%s: rename from %s failed\n",
newname, filename);
}
}
kmem_free(newname, len);
kmem_free(buf, buflen);
return (err);
}
static int
e_fwrite_nvlist(nvfd_t *nvfd, nvlist_t *nvl)
{
int err;
if ((err = fwrite_nvlist(nvfd->nvf_cache_path, nvl)) == 0)
return (DDI_SUCCESS);
else {
if (err == EROFS)
NVF_MARK_READONLY(nvfd);
return (DDI_FAILURE);
}
}
static void
nvp_list_free(nvfd_t *nvf)
{
ASSERT(RW_WRITE_HELD(&nvf->nvf_lock));
(nvf->nvf_list_free)((nvf_handle_t)nvf);
ASSERT(RW_WRITE_HELD(&nvf->nvf_lock));
}
/*
* Read a file in the nvlist format
* EIO - i/o error during read
* ENOENT - file not found
* EINVAL - file contents corrupted
*/
static int
fread_nvp_list(nvfd_t *nvfd)
{
nvlist_t *nvl;
nvpair_t *nvp;
char *name;
nvlist_t *sublist;
int rval;
int rv;
ASSERT(RW_WRITE_HELD(&(nvfd->nvf_lock)));
rval = fread_nvlist(nvfd->nvf_cache_path, &nvl);
if (rval != 0)
return (rval);
ASSERT(nvl != NULL);
nvp = NULL;
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
name = nvpair_name(nvp);
ASSERT(strlen(name) > 0);
switch (nvpair_type(nvp)) {
case DATA_TYPE_NVLIST:
rval = nvpair_value_nvlist(nvp, &sublist);
if (rval != 0) {
nvf_error(
"nvpair_value_nvlist error %s %d\n",
name, rval);
goto error;
}
/*
* unpack nvlist for this device and
* add elements to data list.
*/
ASSERT(RW_WRITE_HELD(&(nvfd->nvf_lock)));
rv = (nvfd->nvf_unpack_nvlist)
((nvf_handle_t)nvfd, sublist, name);
ASSERT(RW_WRITE_HELD(&(nvfd->nvf_lock)));
if (rv != 0) {
nvf_error(
"%s: %s invalid list element\n",
nvfd->nvf_cache_path, name);
rval = EINVAL;
goto error;
}
break;
default:
nvf_error("%s: %s unsupported data type %d\n",
nvfd->nvf_cache_path, name, nvpair_type(nvp));
rval = EINVAL;
goto error;
}
}
nvlist_free(nvl);
return (0);
error:
nvlist_free(nvl);
nvp_list_free(nvfd);
return (rval);
}
int
nvf_read_file(nvf_handle_t nvf_handle)
{
nvfd_t *nvfd = (nvfd_t *)nvf_handle;
int rval;
ASSERT(RW_WRITE_HELD(&nvfd->nvf_lock));
if (kfio_disable_read)
return (0);
KFDEBUG((CE_CONT, "reading %s\n", nvfd->nvf_cache_path));
rval = fread_nvp_list(nvfd);
if (rval) {
switch (rval) {
case EIO:
nvfd->nvf_flags |= NVF_F_REBUILD_MSG;
cmn_err(CE_WARN, "%s: I/O error",
nvfd->nvf_cache_path);
break;
case ENOENT:
nvfd->nvf_flags |= NVF_F_CREATE_MSG;
nvf_error("%s: not found\n",
nvfd->nvf_cache_path);
break;
case EINVAL:
default:
nvfd->nvf_flags |= NVF_F_REBUILD_MSG;
cmn_err(CE_WARN, "%s: data file corrupted",
nvfd->nvf_cache_path);
break;
}
}
return (rval);
}
static void
nvf_write_is_complete(nvfd_t *fd)
{
if (fd->nvf_write_complete) {
(fd->nvf_write_complete)((nvf_handle_t)fd);
}
}
/*ARGSUSED*/
static void
nvpflush_timeout(void *arg)
{
clock_t nticks;
mutex_enter(&nvpflush_lock);
nticks = nvpticks - ddi_get_lbolt();
if (nticks > 4) {
nvpflush_timer_busy = 1;
mutex_exit(&nvpflush_lock);
nvpflush_id = timeout(nvpflush_timeout, NULL, nticks);
} else {
do_nvpflush = 1;
NVPDAEMON_DEBUG((CE_CONT, "signal nvpdaemon\n"));
cv_signal(&nvpflush_cv);
nvpflush_id = 0;
nvpflush_timer_busy = 0;
mutex_exit(&nvpflush_lock);
}
}
/*
* After marking a list as dirty, wake the nvpflush daemon
* to perform the update.
*/
void
nvf_wake_daemon(void)
{
clock_t nticks;
/*
* If the system isn't up yet or is shutting down,
* don't even think about starting a flush.
*/
if (!i_ddi_io_initialized() || sys_shutdown)
return;
mutex_enter(&nvpflush_lock);
if (nvpflush_daemon_active == 0) {
nvpflush_daemon_active = 1;
mutex_exit(&nvpflush_lock);
NVPDAEMON_DEBUG((CE_CONT, "starting nvpdaemon thread\n"));
nvpflush_thr_id = thread_create(NULL, 0,
(void (*)())nvpflush_daemon,
NULL, 0, &p0, TS_RUN, minclsyspri);
mutex_enter(&nvpflush_lock);
}
nticks = nvpflush_delay * TICKS_PER_SECOND;
nvpticks = ddi_get_lbolt() + nticks;
if (nvpflush_timer_busy == 0) {
nvpflush_timer_busy = 1;
mutex_exit(&nvpflush_lock);
nvpflush_id = timeout(nvpflush_timeout, NULL, nticks + 4);
} else
mutex_exit(&nvpflush_lock);
}
static int
nvpflush_one(nvfd_t *nvfd)
{
int rval = DDI_SUCCESS;
nvlist_t *nvl;
rw_enter(&nvfd->nvf_lock, RW_READER);
ASSERT((nvfd->nvf_flags & NVF_F_FLUSHING) == 0);
if (!NVF_IS_DIRTY(nvfd) ||
NVF_IS_READONLY(nvfd) || kfio_disable_write || sys_shutdown) {
NVF_CLEAR_DIRTY(nvfd);
rw_exit(&nvfd->nvf_lock);
return (DDI_SUCCESS);
}
if (rw_tryupgrade(&nvfd->nvf_lock) == 0) {
nvf_error("nvpflush: "
"%s rw upgrade failed\n", nvfd->nvf_cache_path);
rw_exit(&nvfd->nvf_lock);
return (DDI_FAILURE);
}
if (((nvfd->nvf_pack_list)
((nvf_handle_t)nvfd, &nvl)) != DDI_SUCCESS) {
nvf_error("nvpflush: "
"%s nvlist construction failed\n", nvfd->nvf_cache_path);
ASSERT(RW_WRITE_HELD(&nvfd->nvf_lock));
rw_exit(&nvfd->nvf_lock);
return (DDI_FAILURE);
}
ASSERT(RW_WRITE_HELD(&nvfd->nvf_lock));
NVF_CLEAR_DIRTY(nvfd);
nvfd->nvf_flags |= NVF_F_FLUSHING;
rw_exit(&nvfd->nvf_lock);
rval = e_fwrite_nvlist(nvfd, nvl);
nvlist_free(nvl);
rw_enter(&nvfd->nvf_lock, RW_WRITER);
nvfd->nvf_flags &= ~NVF_F_FLUSHING;
if (rval == DDI_FAILURE) {
if (NVF_IS_READONLY(nvfd)) {
rval = DDI_SUCCESS;
nvfd->nvf_flags &= ~(NVF_F_ERROR | NVF_F_DIRTY);
} else if ((nvfd->nvf_flags & NVF_F_ERROR) == 0) {
cmn_err(CE_CONT,
"%s: update failed\n", nvfd->nvf_cache_path);
nvfd->nvf_flags |= NVF_F_ERROR | NVF_F_DIRTY;
}
} else {
if (nvfd->nvf_flags & NVF_F_CREATE_MSG) {
cmn_err(CE_CONT,
"!Creating %s\n", nvfd->nvf_cache_path);
nvfd->nvf_flags &= ~NVF_F_CREATE_MSG;
}
if (nvfd->nvf_flags & NVF_F_REBUILD_MSG) {
cmn_err(CE_CONT,
"!Rebuilding %s\n", nvfd->nvf_cache_path);
nvfd->nvf_flags &= ~NVF_F_REBUILD_MSG;
}
if (nvfd->nvf_flags & NVF_F_ERROR) {
cmn_err(CE_CONT,
"%s: update now ok\n", nvfd->nvf_cache_path);
nvfd->nvf_flags &= ~NVF_F_ERROR;
}
/*
* The file may need to be flushed again if the cached
* data was touched while writing the earlier contents.
*/
if (NVF_IS_DIRTY(nvfd))
rval = DDI_FAILURE;
}
rw_exit(&nvfd->nvf_lock);
return (rval);
}
static void
nvpflush_daemon(void)
{
callb_cpr_t cprinfo;
nvfd_t *nvfdp, *nextfdp;
clock_t clk;
int rval;
int want_wakeup;
int is_now_clean;
ASSERT(modrootloaded);
nvpflush_thread = curthread;
NVPDAEMON_DEBUG((CE_CONT, "nvpdaemon: init\n"));
CALLB_CPR_INIT(&cprinfo, &nvpflush_lock, callb_generic_cpr, "nvp");
mutex_enter(&nvpflush_lock);
for (;;) {
CALLB_CPR_SAFE_BEGIN(&cprinfo);
while (do_nvpflush == 0) {
clk = cv_reltimedwait(&nvpflush_cv, &nvpflush_lock,
(nvpdaemon_idle_time * TICKS_PER_SECOND),
TR_CLOCK_TICK);
if ((clk == -1 && do_nvpflush == 0 &&
nvpflush_timer_busy == 0) || sys_shutdown) {
/*
* Note that CALLB_CPR_EXIT calls mutex_exit()
* on the lock passed in to CALLB_CPR_INIT,
* so the lock must be held when invoking it.
*/
CALLB_CPR_SAFE_END(&cprinfo, &nvpflush_lock);
NVPDAEMON_DEBUG((CE_CONT, "nvpdaemon: exit\n"));
ASSERT(mutex_owned(&nvpflush_lock));
nvpflush_thr_id = NULL;
nvpflush_daemon_active = 0;
CALLB_CPR_EXIT(&cprinfo);
thread_exit();
}
}
CALLB_CPR_SAFE_END(&cprinfo, &nvpflush_lock);
nvpbusy = 1;
want_wakeup = 0;
do_nvpflush = 0;
mutex_exit(&nvpflush_lock);
/*
* Try flushing what's dirty, reschedule if there's
* a failure or data gets marked as dirty again.
* First move each file marked dirty to the dirty
* list to avoid locking the list across the write.
*/
mutex_enter(&nvf_cache_mutex);
for (nvfdp = list_head(&nvf_cache_files);
nvfdp; nvfdp = nextfdp) {
nextfdp = list_next(&nvf_cache_files, nvfdp);
rw_enter(&nvfdp->nvf_lock, RW_READER);
if (NVF_IS_DIRTY(nvfdp)) {
list_remove(&nvf_cache_files, nvfdp);
list_insert_tail(&nvf_dirty_files, nvfdp);
rw_exit(&nvfdp->nvf_lock);
} else {
NVPDAEMON_DEBUG((CE_CONT,
"nvpdaemon: not dirty %s\n",
nvfdp->nvf_cache_path));
rw_exit(&nvfdp->nvf_lock);
}
}
mutex_exit(&nvf_cache_mutex);
/*
* Now go through the dirty list
*/
for (nvfdp = list_head(&nvf_dirty_files);
nvfdp; nvfdp = nextfdp) {
nextfdp = list_next(&nvf_dirty_files, nvfdp);
is_now_clean = 0;
rw_enter(&nvfdp->nvf_lock, RW_READER);
if (NVF_IS_DIRTY(nvfdp)) {
NVPDAEMON_DEBUG((CE_CONT,
"nvpdaemon: flush %s\n",
nvfdp->nvf_cache_path));
rw_exit(&nvfdp->nvf_lock);
rval = nvpflush_one(nvfdp);
rw_enter(&nvfdp->nvf_lock, RW_READER);
if (rval != DDI_SUCCESS ||
NVF_IS_DIRTY(nvfdp)) {
rw_exit(&nvfdp->nvf_lock);
NVPDAEMON_DEBUG((CE_CONT,
"nvpdaemon: %s dirty again\n",
nvfdp->nvf_cache_path));
want_wakeup = 1;
} else {
rw_exit(&nvfdp->nvf_lock);
nvf_write_is_complete(nvfdp);
is_now_clean = 1;
}
} else {
NVPDAEMON_DEBUG((CE_CONT,
"nvpdaemon: not dirty %s\n",
nvfdp->nvf_cache_path));
rw_exit(&nvfdp->nvf_lock);
is_now_clean = 1;
}
if (is_now_clean) {
mutex_enter(&nvf_cache_mutex);
list_remove(&nvf_dirty_files, nvfdp);
list_insert_tail(&nvf_cache_files,
nvfdp);
mutex_exit(&nvf_cache_mutex);
}
}
if (want_wakeup)
nvf_wake_daemon();
mutex_enter(&nvpflush_lock);
nvpbusy = 0;
}
}