libnsctl/common/cache.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/fcntl.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <strings.h>
#include <unistd.h>
#include <stdio.h>

#include "libnsctl.h"
#include <nsctl.h>


static int _nsc_open_path(nsc_fd_t *);
static int _nsc_open_check(nsc_fd_t *);


/*
 * Turn off ckdchk checking of nsc_open()'d volumes since we have no CKD
 * formatted volumes right now.  If/when we come back with CKD volumes,
 * we could do this more sanely by completing the implementation of the
 * CKD module, and having nsc_open() prevent any non-NSC_CKD_DISK open
 * of a CKD volume.
 * -- Simon, Thu Feb 18 10:49:46 GMT 1999
 */
static int ckdchk = 0;


nsc_fd_t *
nsc_open(path, flag, mode)
char *path;
int flag, mode;
{
    nsc_fd_t *fd;

    if (strlen(path) >= NSC_MAXPATH) {
        errno = ENAMETOOLONG;
        return (0);
    }

    if (!(fd = (nsc_fd_t *)calloc(1, sizeof (nsc_fd_t))))
        return (0);

    if ((mode & O_ACCMODE) == O_WRONLY) {
        mode &= ~O_ACCMODE;
        mode |= O_RDWR;
    }

    fd->sf_flag = flag;
    fd->sf_fmode = mode;

    strcpy(fd->sf_path, path);

    if (!_nsc_open_path(fd)) {
        free(fd);
        return (0);
    }

    if (ckdchk && !_nsc_open_check(fd)) {
        (void) nsc_close(fd);
        return (0);
    }

    return (fd);
}


nsc_fd_t *
nsc_fdopen(id, path, mode)
int id, mode;
char *path;
{
    struct flock lk;
    nsc_fd_t *fd;
    int i;

    if (strlen(path) >= NSC_MAXPATH) {
        errno = ENAMETOOLONG;
        return (0);
    }

    if (!(fd = (nsc_fd_t *)calloc(1, sizeof (nsc_fd_t))))
        return (0);

    lk.l_type = F_WRLCK;
    lk.l_whence = SEEK_SET;
    lk.l_start = 0;
    lk.l_len = 0;

    if (fcntl(id, F_SETLKW, &lk) < 0)
        return (0);

    i = fcntl(id, F_GETFL);

    if ((mode & O_ACCMODE) != O_RDONLY) {
        if ((i & O_ACCMODE) == O_RDONLY) {
            errno = EBADF;
            return (0);
        }
    }

    if ((mode & O_ACCMODE) != O_WRONLY) {
        if ((i & O_ACCMODE) == O_WRONLY) {
            errno = EBADF;
            return (0);
        }
    }

    mode = (i & O_ACCMODE) | (mode & ~O_ACCMODE);

    if (fcntl(id, F_SETFL, mode) < 0)
        return (0);

    if (lseek(id, 0, SEEK_SET) < 0)
        return (0);

    fd->sf_fd = id;
    fd->sf_fmode = mode;

    strcpy(fd->sf_path, path);

    return (fd);
}


static int
_nsc_open_path(fd)
nsc_fd_t *fd;
{
    struct nscioc_open op;

    memset(&op, 0, sizeof (op));

    op.flag = fd->sf_flag;
    op.mode = fd->sf_fmode;
    strcpy(op.path, fd->sf_path);

    if ((fd->sf_fd = open(_NSC_DEV_PATH, fd->sf_fmode)) < 0)
        return (0);

    if (ioctl(fd->sf_fd, NSCIOC_OPEN, &op) == 0)
        return (1);

    close(fd->sf_fd);
    return (0);
}


static int
_nsc_open_check(fd)
nsc_fd_t *fd;
{
    struct flock lk;
    char s[30];
    pid_t pid;
    int i;

    if ((fd->sf_fmode & O_ACCMODE) == O_RDONLY)
        return (1);

    if (access(_NSC_CKDCHK_PATH, X_OK) != 0)
        return (0);

    lk.l_type = F_WRLCK;
    lk.l_whence = SEEK_SET;
    lk.l_start = 0;
    lk.l_len = 0;

    if (fcntl(fd->sf_fd, F_SETLKW, &lk) < 0)
        return (0);

    if ((pid = fork()) == 0) {
        for (i = 1; i <= NSIG; i++)
            signal(i, SIG_IGN);

        for (i = fd->sf_fd; i <= 2 && (i = dup(i)) != -1; )
            fd->sf_fd = i;

        for (i = sysconf(_SC_OPEN_MAX); i >= 0; i--)
            if (i != fd->sf_fd)
                close(i);

        fcntl(fd->sf_fd, F_SETFD, 0);

        (void) open("/dev/null", 0);
        (void) open(_NSC_CKDCHK_LOG, O_WRONLY|O_CREAT|O_APPEND, 0666);
        (void) open(_NSC_CKDCHK_LOG, O_WRONLY|O_CREAT|O_APPEND, 0666);

        (void) sprintf(s, "%d", fd->sf_fd);

        (void) execl(_NSC_CKDCHK_PATH, "ckdchk", "-u", "-F",
            s, fd->sf_path, 0);

        exit(1);
    }

    return (pid != -1);
}


int
nsc_close(fd)
nsc_fd_t *fd;
{
    int rc;

    if (!fd)
        return (0);

    rc = close(fd->sf_fd);
    free(fd);

    return (rc);
}


int
nsc_reserve(fd)
nsc_fd_t *fd;
{
    return ((fd) ? ioctl(fd->sf_fd, NSCIOC_RESERVE, 0) : 0);
}


int
nsc_release(fd)
nsc_fd_t *fd;
{
    if (!fd)
        return (0);

    if (ckdchk && (fd->sf_fmode & O_ACCMODE) != O_RDONLY) {
        errno = EINVAL;
        return (-1);
    }

    return (ioctl(fd->sf_fd, NSCIOC_RELEASE, 0));
}


int
nsc_partsize(nsc_fd_t *fd, nsc_size_t *rvp)
{
    struct nscioc_partsize partsize;
    int rc;

    if (!fd)
        return (0);

    rc = ioctl(fd->sf_fd, NSCIOC_PARTSIZE, &partsize);
    if (rc != 0) {
        return (rc);
    }

    *rvp = (nsc_size_t)partsize.partsize;
    return (0);
}


int
nsc_fileno(fd)
nsc_fd_t *fd;
{
    return ((fd) ? fd->sf_fd : -1);
}


void
_nsc_nocheck()
{
    ckdchk = 0;
}


static int
_nsc_do_ioctl(cmd, arg)
int cmd;
void *arg;
{
    int fd, rc, save_errno;

    fd = open(_NSC_DEV_PATH, O_RDONLY);
    if (fd < 0)
        return (-1);

    rc = save_errno = 0;
    rc = ioctl(fd, cmd, arg);
    if (rc < 0)
        save_errno = errno;

    close(fd);

    errno = save_errno;
    return (rc);
}


/*
 * int
 * nsc_freeze(char *path)
 *  Freeze a pathname
 *
 * Calling/Exit State:
 *  Returns 0 for success, or -1 and sets errno.
 *
 * Description:
 *  This is the user level interface to the nsctl freeze operation.
 *  See uts/common/ns/nsctl/nsc_freeze.c for more information.
 */
int
nsc_freeze(path)
char *path;
{
    if (strlen(path) >= NSC_MAXPATH) {
        errno = ENAMETOOLONG;
        return (-1);
    }

    return (_nsc_do_ioctl(NSCIOC_FREEZE, path));
}

/*
 * int
 * nsc_unfreeze(char *path)
 *  Unfreeze a pathname
 *
 * Calling/Exit State:
 *  Returns 0 for success, or -1 and sets errno.
 *
 * Description:
 *  This is the user level interface to the nsctl unfreeze operation.
 *  See uts/common/ns/nsctl/nsc_freeze.c for more information.
 */
int
nsc_unfreeze(path)
char *path;
{
    if (strlen(path) >= NSC_MAXPATH) {
        errno = ENAMETOOLONG;
        return (-1);
    }

    return (_nsc_do_ioctl(NSCIOC_UNFREEZE, path));
}


/*
 * int
 * nsc_isfrozen(char *path)
 *  Test if a pathname is frozen
 *
 * Calling/Exit State:
 *  Returns:
 *      0   path is frozen
 *      1   path is not frozen
 *      -1  error (errno will be set)
 *
 * Description
 *  This is the user level interface to to the nsctl isfrozen operation.
 *  See uts/common/ns/nsctl/nsc_freeze.c for more information.
 */
int
nsc_isfrozen(path)
char *path;
{
    if (strlen(path) >= NSC_MAXPATH) {
        errno = ENAMETOOLONG;
        return (-1);
    }

    return (_nsc_do_ioctl(NSCIOC_ISFROZEN, path));
}

int
nsc_gmem_sizes(int *size)
{
    return (_nsc_do_ioctl(NSCIOC_GLOBAL_SIZES, size));
}

int
nsc_gmem_data(char *addr)
{
    return (_nsc_do_ioctl(NSCIOC_GLOBAL_DATA, addr));
}

/*
 * int
 * nsc_nvclean()
 *  mark nvmem clean, to prevent a warmstart of the cache on reboot
 */
int
nsc_nvclean(int force)
{
    int cmd;

    cmd = force ? NSCIOC_NVMEM_CLEANF : NSCIOC_NVMEM_CLEAN;

    return (_nsc_do_ioctl(cmd, (void *)0));
}