NetBSD-5.0.2/share/examples/puffs/dtfs/dtfs_subr.c
/* $NetBSD: dtfs_subr.c,v 1.21 2007/10/11 13:50:42 pooka Exp $ */
/*
* Copyright (c) 2006 Antti Kantee. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/types.h>
#include <sys/time.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <puffs.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>
#include "dtfs.h"
void
dtfs_baseattrs(struct vattr *vap, enum vtype type, ino_t id)
{
struct timeval tv;
struct timespec ts;
gettimeofday(&tv, NULL);
TIMEVAL_TO_TIMESPEC(&tv, &ts);
vap->va_type = type;
if (type == VDIR) {
vap->va_mode = 0777;
vap->va_nlink = 1; /* n + 1 after adding dent */
} else {
vap->va_mode = 0666;
vap->va_nlink = 0; /* n + 1 */
}
vap->va_uid = 0;
vap->va_gid = 0;
vap->va_fileid = id;
vap->va_size = 0;
vap->va_blocksize = getpagesize();
vap->va_gen = random();
vap->va_flags = 0;
vap->va_rdev = PUFFS_VNOVAL;
vap->va_bytes = 0;
vap->va_filerev = 1;
vap->va_vaflags = 0;
vap->va_atime = vap->va_mtime = vap->va_ctime = vap->va_birthtime = ts;
}
/*
* Well, as you can probably see, this interface has the slight problem
* of assuming file creation will always be succesful, or at least not
* giving a reason for the failure. Be sure to do better when you
* implement your own fs.
*/
struct puffs_node *
dtfs_genfile(struct puffs_node *dir, const struct puffs_cn *pcn,
enum vtype type)
{
struct dtfs_file *df_dir, *dff;
struct dtfs_dirent *dfd;
struct dtfs_mount *dtm;
struct puffs_node *newpn;
uid_t uid;
int rv;
assert(dir->pn_va.va_type == VDIR);
assert(dir->pn_mnt != NULL);
uid = 0;
rv = puffs_cred_getuid(pcn->pcn_cred, &uid);
assert(rv == 0);
if (type == VDIR) {
dff = dtfs_newdir();
dff->df_dotdot = dir;
} else
dff = dtfs_newfile();
dtm = puffs_pn_getmntspecific(dir);
newpn = puffs_pn_new(dir->pn_mnt, dff);
if (newpn == NULL)
errx(1, "getnewpnode");
dtfs_baseattrs(&newpn->pn_va, type, dtm->dtm_nextfileid++);
df_dir = dir->pn_data;
dfd = emalloc(sizeof(struct dtfs_dirent));
dfd->dfd_node = newpn;
dfd->dfd_name = estrndup(pcn->pcn_name, pcn->pcn_namelen);
dfd->dfd_namelen = strlen(dfd->dfd_name);
dfd->dfd_parent = dir;
dtfs_adddent(dir, dfd);
newpn->pn_va.va_uid = uid;
newpn->pn_va.va_gid = dir->pn_va.va_gid;
return newpn;
}
struct dtfs_file *
dtfs_newdir()
{
struct dtfs_file *dff;
dff = emalloc(sizeof(struct dtfs_file));
memset(dff, 0, sizeof(struct dtfs_file));
LIST_INIT(&dff->df_dirents);
return dff;
}
struct dtfs_file *
dtfs_newfile()
{
struct dtfs_file *dff;
dff = emalloc(sizeof(struct dtfs_file));
memset(dff, 0, sizeof(struct dtfs_file));
return dff;
}
struct dtfs_dirent *
dtfs_dirgetnth(struct dtfs_file *searchdir, int n)
{
struct dtfs_dirent *dirent;
int i;
i = 0;
LIST_FOREACH(dirent, &searchdir->df_dirents, dfd_entries) {
if (i == n)
return dirent;
i++;
}
return NULL;
}
struct dtfs_dirent *
dtfs_dirgetbyname(struct dtfs_file *searchdir, const char *fname, size_t fnlen)
{
struct dtfs_dirent *dirent;
LIST_FOREACH(dirent, &searchdir->df_dirents, dfd_entries)
if (dirent->dfd_namelen == fnlen
&& strncmp(dirent->dfd_name, fname, fnlen) == 0)
return dirent;
return NULL;
}
/*
* common nuke, kill dirent from parent node
*/
void
dtfs_nukenode(struct puffs_node *nukeme, struct puffs_node *pn_parent,
const char *fname, size_t fnlen)
{
struct dtfs_dirent *dfd;
struct dtfs_mount *dtm;
assert(pn_parent->pn_va.va_type == VDIR);
dfd = dtfs_dirgetbyname(DTFS_PTOF(pn_parent), fname, fnlen);
assert(dfd);
dtm = puffs_pn_getmntspecific(nukeme);
dtm->dtm_nfiles--;
assert(dtm->dtm_nfiles >= 1);
dtfs_removedent(pn_parent, dfd);
free(dfd);
}
/* free lingering information */
void
dtfs_freenode(struct puffs_node *pn)
{
struct dtfs_file *df = DTFS_PTOF(pn);
struct dtfs_mount *dtm;
int i;
assert(pn->pn_va.va_nlink == 0);
dtm = puffs_pn_getmntspecific(pn);
switch (pn->pn_va.va_type) {
case VREG:
assert(dtm->dtm_fsizes >= pn->pn_va.va_size);
dtm->dtm_fsizes -= pn->pn_va.va_size;
for (i = 0; i < BLOCKNUM(df->df_datalen, DTFS_BLOCKSHIFT); i++)
free(df->df_blocks[i]);
if (df->df_datalen > i << DTFS_BLOCKSHIFT)
free(df->df_blocks[i]);
break;
case VLNK:
free(df->df_linktarget);
break;
case VCHR:
case VBLK:
case VDIR:
case VSOCK:
case VFIFO:
break;
default:
assert(0);
break;
}
free(df);
puffs_pn_put(pn);
}
void
dtfs_setsize(struct puffs_node *pn, off_t newsize)
{
struct dtfs_file *df = DTFS_PTOF(pn);
struct dtfs_mount *dtm;
size_t newblocks;
int needalloc, shrinks;
int i;
needalloc = newsize > ROUNDUP(df->df_datalen, DTFS_BLOCKSIZE);
shrinks = newsize < pn->pn_va.va_size;
if (needalloc || shrinks) {
newblocks = BLOCKNUM(newsize, DTFS_BLOCKSHIFT) + 1;
if (shrinks)
for (i = newblocks; i < df->df_numblocks; i++)
free(df->df_blocks[i]);
df->df_blocks = erealloc(df->df_blocks,
newblocks * sizeof(uint8_t *));
/*
* if extended, set storage to zero
* to match correct behaviour
*/
if (!shrinks) {
for (i = df->df_numblocks; i < newblocks; i++) {
df->df_blocks[i] = emalloc(DTFS_BLOCKSIZE);
memset(df->df_blocks[i], 0, DTFS_BLOCKSIZE);
}
}
df->df_datalen = newsize;
df->df_numblocks = newblocks;
}
dtm = puffs_pn_getmntspecific(pn);
if (!shrinks) {
dtm->dtm_fsizes += newsize - pn->pn_va.va_size;
} else {
dtm->dtm_fsizes -= pn->pn_va.va_size - newsize;
}
pn->pn_va.va_size = newsize;
pn->pn_va.va_bytes = BLOCKNUM(newsize,DTFS_BLOCKSHIFT)>>DTFS_BLOCKSHIFT;
}
/* add & bump link count */
void
dtfs_adddent(struct puffs_node *pn_dir, struct dtfs_dirent *dent)
{
struct dtfs_file *dir = DTFS_PTOF(pn_dir);
struct puffs_node *pn_file = dent->dfd_node;
struct dtfs_file *file = DTFS_PTOF(pn_file);
struct dtfs_mount *dtm;
assert(pn_dir->pn_va.va_type == VDIR);
LIST_INSERT_HEAD(&dir->df_dirents, dent, dfd_entries);
pn_file->pn_va.va_nlink++;
dtm = puffs_pn_getmntspecific(pn_file);
dtm->dtm_nfiles++;
dent->dfd_parent = pn_dir;
if (dent->dfd_node->pn_va.va_type == VDIR) {
file->df_dotdot = pn_dir;
pn_dir->pn_va.va_nlink++;
}
dtfs_updatetimes(pn_dir, 0, 1, 1);
}
/* remove & lower link count */
void
dtfs_removedent(struct puffs_node *pn_dir, struct dtfs_dirent *dent)
{
struct puffs_node *pn_file = dent->dfd_node;
assert(pn_dir->pn_va.va_type == VDIR);
LIST_REMOVE(dent, dfd_entries);
if (pn_file->pn_va.va_type == VDIR)
pn_dir->pn_va.va_nlink--;
pn_file->pn_va.va_nlink--;
assert(pn_dir->pn_va.va_nlink >= 2);
dtfs_updatetimes(pn_dir, 0, 1, 1);
}
void
dtfs_updatetimes(struct puffs_node *pn, int doatime, int doctime, int domtime)
{
struct timeval tv;
struct timespec ts;
gettimeofday(&tv, NULL);
TIMEVAL_TO_TIMESPEC(&tv, &ts);
if (doatime)
pn->pn_va.va_atime = ts;
if (doctime)
pn->pn_va.va_ctime = ts;
if (domtime)
pn->pn_va.va_mtime = ts;
}