/*
* Reclaim an inode so that it can be used for other purposes.
*/
int
ffs_reclaim(void *v)
{
struct vop_reclaim_args *ap = v;
struct vnode *vp = ap->a_vp;
struct inode *ip = VTOI(vp);
int error;
if ((error = ufs_reclaim(vp, ap->a_p)) != 0)
return (error);
if (ip->i_din1 != NULL) {
#ifdef FFS2
if (ip->i_ump->um_fstype == UM_UFS2)
pool_put(&ffs_dinode2_pool, ip->i_din2);
else
#endif
pool_put(&ffs_dinode1_pool, ip->i_din1);
}
pool_put(&ffs_ino_pool, ip);
vp->v_data = NULL;
return (0);
}
int
fusefs_mkdir(void *v)
{
struct vop_mkdir_args *ap = v;
struct vnode *dvp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vattr *vap = ap->a_vap;
struct proc *p = cnp->cn_proc;
struct vnode *tdp = NULL;
struct fusefs_node *ip;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf;
int error = 0;
DPRINTF("fusefs_mkdir %s\n", cnp->cn_nameptr);
ip = VTOI(dvp);
fmp = (struct fusefs_mnt *)ip->ufs_ino.i_ump;
if (!fmp->sess_init || (fmp->undef_op & UNDEF_MKDIR)) {
error = ENOSYS;
goto out;
}
fbuf = fb_setup(FUSEFDSIZE + cnp->cn_namelen + 1, ip->ufs_ino.i_number,
FBT_MKDIR, p);
fbuf->fb_io_mode = MAKEIMODE(vap->va_type, vap->va_mode);
memcpy(fbuf->fb_dat, cnp->cn_nameptr, cnp->cn_namelen);
fbuf->fb_dat[cnp->cn_namelen] = '\0';
error = fb_queue(fmp->dev, fbuf);
if (error) {
if (error == ENOSYS)
fmp->undef_op |= UNDEF_MKDIR;
pool_put(&fusefs_fbuf_pool, fbuf);
goto out;
}
if ((error = VFS_VGET(fmp->mp, fbuf->fb_ino, &tdp))) {
pool_put(&fusefs_fbuf_pool, fbuf);
goto out;
}
tdp->v_type = IFTOVT(fbuf->fb_io_mode);
VTOI(tdp)->vtype = tdp->v_type;
if (dvp != NULL && dvp->v_type == VDIR)
VTOI(tdp)->parent = ip->ufs_ino.i_number;
*vpp = tdp;
VN_KNOTE(ap->a_dvp, NOTE_WRITE | NOTE_LINK);
pool_put(&fusefs_fbuf_pool, fbuf);
out:
vput(dvp);
return (error);
}
static int mysqlfs_chown(const char *path, uid_t uid, gid_t gid)
{
int ret;
long inode;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "mysql_chown(\"%s\", %ld, %ld)\n", path, uid, gid);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if (inode < 0) {
pool_put(dbconn);
return inode;
}
ret = query_chown(dbconn, inode, uid, gid);
if(ret){
log_printf(LOG_ERROR, "Error: query_chown()\n");
pool_put(dbconn);
return -EIO;
}
pool_put(dbconn);
return ret;
}
static int mysqlfs_chmod(const char* path, mode_t mode)
{
int ret;
long inode;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "mysql_chmod(\"%s\", 0%3o)\n", path, mode);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if (inode < 0) {
pool_put(dbconn);
return inode;
}
ret = query_chmod(dbconn, inode, mode);
if(ret){
log_printf(LOG_ERROR, "Error: query_chmod()\n");
pool_put(dbconn);
return -EIO;
}
pool_put(dbconn);
return ret;
}
/*
* Reclaim an inode so that it can be used for other purposes.
*/
int
ext2fs_reclaim(void *v)
{
struct vop_reclaim_args *ap = v;
struct vnode *vp = ap->a_vp;
struct inode *ip;
#ifdef DIAGNOSTIC
extern int prtactive;
if (prtactive && vp->v_usecount != 0)
vprint("ext2fs_reclaim: pushing active", vp);
#endif
/*
* Remove the inode from its hash chain.
*/
ip = VTOI(vp);
ufs_ihashrem(ip);
/*
* Purge old data structures associated with the inode.
*/
cache_purge(vp);
if (ip->i_devvp)
vrele(ip->i_devvp);
if (ip->i_e2din != NULL)
pool_put(&ext2fs_dinode_pool, ip->i_e2din);
pool_put(&ext2fs_inode_pool, ip);
vp->v_data = NULL;
return (0);
}
static int mysqlfs_utime(const char *path, struct utimbuf *time)
{
int ret;
long inode;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "mysql_utime(\"%s\")\n", path);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if (inode < 0) {
pool_put(dbconn);
return inode;
}
ret = query_utime(dbconn, inode, time);
if (ret < 0) {
log_printf(LOG_ERROR, "Error: query_utime()\n");
pool_put(dbconn);
return -EIO;
}
pool_put(dbconn);
return 0;
}
struct mbuf *
m_free(struct mbuf *m)
{
struct mbuf *n;
int s;
s = splvm();
mbstat.m_mtypes[m->m_type]--;
if (m->m_flags & M_PKTHDR)
m_tag_delete_chain(m);
if (m->m_flags & M_EXT) {
if (MCLISREFERENCED(m))
_MCLDEREFERENCE(m);
else if (m->m_flags & M_CLUSTER)
pool_put(&mclpool, m->m_ext.ext_buf);
else if (m->m_ext.ext_free)
(*(m->m_ext.ext_free))(m->m_ext.ext_buf,
m->m_ext.ext_size, m->m_ext.ext_arg);
else
free(m->m_ext.ext_buf,m->m_ext.ext_type);
m->m_ext.ext_size = 0;
}
m->m_flags = 0;
n = m->m_next;
pool_put(&mbpool, m);
splx(s);
return (n);
}
static int mysqlfs_symlink(const char *from, const char *to)
{
int ret;
int inode;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "%s(\"%s\" -> \"%s\")\n", __func__, from, to);
ret = mysqlfs_mknod(to, S_IFLNK | 0755, 0);
if (ret < 0)
return ret;
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, to);
if(inode < 0){
pool_put(dbconn);
return -ENOENT;
}
ret = query_write(dbconn, inode, from, strlen(from), 0);
if (ret > 0) ret = 0;
pool_put(dbconn);
return ret;
}
int
fusefs_write(void *v)
{
struct vop_write_args *ap = v;
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct proc *p = uio->uio_procp;
struct fusefs_node *ip;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf = NULL;
size_t len, diff;
int error=0;
DPRINTF("fusefs_write\n");
ip = VTOI(vp);
fmp = (struct fusefs_mnt *)ip->ufs_ino.i_ump;
DPRINTF("write inode=%i, offset=%llu, resid=%x\n",
ip->ufs_ino.i_number, uio->uio_offset, uio->uio_resid);
if (uio->uio_resid == 0)
return (error);
while (uio->uio_resid > 0) {
len = MIN(uio->uio_resid, FUSELEN);
fbuf = fb_setup(FUSEFDSIZE + len, ip->ufs_ino.i_number,
FBT_WRITE, p);
fbuf->fb_io_fd = fusefs_fd_get(ip, FUFH_WRONLY);
fbuf->fb_io_off = uio->uio_offset;
fbuf->fb_io_len = len;
if ((error = uiomove(fbuf->fb_dat, len, uio))) {
DPRINTF("uio error %i", error);
break;
}
error = fb_queue(fmp->dev, fbuf);
if (error)
break;
diff = len - fbuf->fb_io_len;
if (diff < 0) {
error = EINVAL;
break;
}
uio->uio_resid += diff;
uio->uio_offset -= diff;
pool_put(&fusefs_fbuf_pool, fbuf);
fbuf = NULL;
}
if (fbuf)
pool_put(&fusefs_fbuf_pool, fbuf);
return (error);
}
static int mysqlfs_mkdir(const char *path, mode_t mode){
int ret;
MYSQL *dbconn;
long inode;
char dir_path[PATH_MAX];
log_printf(LOG_D_CALL, "mysqlfs_mkdir(\"%s\", 0%o)\n", path, mode);
if(!(strlen(path) < PATH_MAX)){
log_printf(LOG_ERROR, "Error: Filename too long\n");
return -ENAMETOOLONG;
}
strncpy(dir_path, path, PATH_MAX);
dirname(dir_path);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, dir_path);
if(inode < 0){
pool_put(dbconn);
return -ENOENT;
}
ret = query_mkdir(dbconn, path, mode, inode);
if(ret < 0){
log_printf(LOG_ERROR, "Error: query_mkdir()\n");
pool_put(dbconn);
return ret;
}
pool_put(dbconn);
return 0;
}
static int mysqlfs_readlink(const char *path, char *buf, size_t size)
{
int ret;
long inode;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "%s(\"%s\")\n", __func__, path);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if(inode < 0){
pool_put(dbconn);
return -ENOENT;
}
memset (buf, 0, size);
ret = query_read(dbconn, inode, buf, size, 0);
log_printf(LOG_DEBUG, "readlink(%s): %s [%zd -> %d]\n", path, buf, size, ret);
pool_put(dbconn);
if (ret > 0) ret = 0;
return ret;
}
int
fusefs_symlink(void *v)
{
struct vop_symlink_args *ap = v;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
struct vnode *dvp = ap->a_dvp;
struct proc *p = cnp->cn_proc;
char *target = ap->a_target;
struct fusefs_node *dp;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf;
struct vnode *tdp;
int error = 0;
int len;
DPRINTF("fusefs_symlink\n");
dp = VTOI(dvp);
fmp = (struct fusefs_mnt *)dp->ufs_ino.i_ump;
if (!fmp->sess_init || (fmp->undef_op & UNDEF_SYMLINK)) {
error = ENOSYS;
goto bad;
}
len = strlen(target) + 1;
fbuf = fb_setup(FUSEFDSIZE + len + cnp->cn_namelen + 1,
dp->ufs_ino.i_number, FBT_SYMLINK, p);
memcpy(fbuf->fb_dat, cnp->cn_nameptr, cnp->cn_namelen);
fbuf->fb_dat[cnp->cn_namelen] = '\0';
memcpy(&fbuf->fb_dat[cnp->cn_namelen + 1], target, len);
error = fb_queue(fmp->dev, fbuf);
if (error) {
if (error == ENOSYS)
fmp->undef_op |= UNDEF_SYMLINK;
pool_put(&fusefs_fbuf_pool, fbuf);
goto bad;
}
if ((error = VFS_VGET(fmp->mp, fbuf->fb_ino, &tdp))) {
pool_put(&fusefs_fbuf_pool, fbuf);
goto bad;
}
tdp->v_type = VLNK;
VTOI(tdp)->vtype = tdp->v_type;
VTOI(tdp)->parent = dp->ufs_ino.i_number;
*vpp = tdp;
pool_put(&fusefs_fbuf_pool, fbuf);
vput(tdp);
bad:
vput(dvp);
return (error);
}
/*
* When an attempt at a new connection is noted on a socket
* which accepts connections, sonewconn is called. If the
* connection is possible (subject to space constraints, etc.)
* then we allocate a new structure, properly linked into the
* data structure of the original socket, and return this.
* Connstatus may be 0 or SS_ISCONNECTED.
*
* Must be called at splsoftnet()
*/
struct socket *
sonewconn(struct socket *head, int connstatus)
{
struct socket *so;
int soqueue = connstatus ? 1 : 0;
splsoftassert(IPL_SOFTNET);
if (mclpools[0].pr_nout > mclpools[0].pr_hardlimit * 95 / 100)
return (NULL);
if (head->so_qlen + head->so_q0len > head->so_qlimit * 3)
return (NULL);
so = pool_get(&socket_pool, PR_NOWAIT|PR_ZERO);
if (so == NULL)
return (NULL);
so->so_type = head->so_type;
so->so_options = head->so_options &~ SO_ACCEPTCONN;
so->so_linger = head->so_linger;
so->so_state = head->so_state | SS_NOFDREF;
so->so_proto = head->so_proto;
so->so_timeo = head->so_timeo;
so->so_pgid = head->so_pgid;
so->so_euid = head->so_euid;
so->so_ruid = head->so_ruid;
so->so_egid = head->so_egid;
so->so_rgid = head->so_rgid;
so->so_cpid = head->so_cpid;
so->so_siguid = head->so_siguid;
so->so_sigeuid = head->so_sigeuid;
/*
* Inherit watermarks but those may get clamped in low mem situations.
*/
if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) {
pool_put(&socket_pool, so);
return (NULL);
}
so->so_snd.sb_wat = head->so_snd.sb_wat;
so->so_snd.sb_lowat = head->so_snd.sb_lowat;
so->so_snd.sb_timeo = head->so_snd.sb_timeo;
so->so_rcv.sb_wat = head->so_rcv.sb_wat;
so->so_rcv.sb_lowat = head->so_rcv.sb_lowat;
so->so_rcv.sb_timeo = head->so_rcv.sb_timeo;
soqinsque(head, so, soqueue);
if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH, NULL, NULL, NULL,
curproc)) {
(void) soqremque(so, soqueue);
pool_put(&socket_pool, so);
return (NULL);
}
if (connstatus) {
sorwakeup(head);
wakeup(&head->so_timeo);
so->so_state |= connstatus;
}
return (so);
}
int
fusefs_read(void *v)
{
struct vop_read_args *ap = v;
struct vnode *vp = ap->a_vp;
struct uio *uio = ap->a_uio;
struct proc *p = uio->uio_procp;
struct fusefs_node *ip;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf = NULL;
size_t size;
int error=0;
DPRINTF("fusefs_read\n");
ip = VTOI(vp);
fmp = (struct fusefs_mnt *)ip->ufs_ino.i_ump;
DPRINTF("read inode=%i, offset=%llu, resid=%x\n",
ip->ufs_ino.i_number, uio->uio_offset, uio->uio_resid);
if (uio->uio_resid == 0)
return (error);
if (uio->uio_offset < 0)
return (EINVAL);
while (uio->uio_resid > 0) {
fbuf = fb_setup(FUSEFDSIZE, ip->ufs_ino.i_number, FBT_READ, p);
size = MIN(uio->uio_resid, FUSELEN);
fbuf->fb_io_fd = fusefs_fd_get(ip, FUFH_RDONLY);
fbuf->fb_io_off = uio->uio_offset;
fbuf->fb_io_len = size;
error = fb_queue(fmp->dev, fbuf);
if (error)
break;
error = uiomove(fbuf->fb_dat, MIN(size, fbdatsize(fbuf)), uio);
if (error)
break;
if (fbdatsize(fbuf) < size)
break;
pool_put(&fusefs_fbuf_pool, fbuf);
fbuf = NULL;
}
if (fbuf)
pool_put(&fusefs_fbuf_pool, fbuf);
return (error);
}
static int mysqlfs_open(const char *path, struct fuse_file_info *fi)
{
MYSQL *dbconn;
long inode;
int ret;
log_printf(LOG_D_CALL, "mysqlfs_open(\"%s\")\n", path);
#ifdef STATUSDIR
/* take a short-circuit for the bogus virtual files */
if (0 == strncmp (path, status_pathname, len_status_pathname))
{
char *a = (char *) path + len_status_pathname;
log_printf(LOG_D_CALL, "%s(\"%s\")(@%d)\n", __FUNCTION__, a, __LINE__);
if (0 == strcmp (a, "/txt"))
{
fi->fh = inode_status_txt;
return 0;
}
else if (0 == strcmp (a, "/xml"))
{
fi->fh = inode_status_xml;
return 0;
}
/* otherwise, fall-thru to a inode-lookup failure */
}
#endif
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if(inode < 0){
pool_put(dbconn);
return -ENOENT;
}
/* Save inode for future use. Lets us skip path->inode translation. */
fi->fh = inode;
log_printf(LOG_D_OTHER, "inode(\"%s\") = %d\n", path, fi->fh);
ret = query_inuse_inc(dbconn, inode, 1);
if (ret < 0) {
pool_put(dbconn);
return ret;
}
pool_put(dbconn);
return 0;
}
static int mysqlfs_unlink(const char *path)
{
int ret;
long inode, parent, nlinks;
char name[PATH_MAX];
MYSQL *dbconn;
log_printf(LOG_D_CALL, "mysqlfs_unlink(\"%s\")\n", path);
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
ret = query_inode_full(dbconn, path, name, sizeof(name),
&inode, &parent, &nlinks);
if (ret < 0) {
if (ret != -ENOENT)
log_printf(LOG_ERROR, "Error: query_inode_full(%s): %s\n",
path, strerror(ret));
goto err_out;
}
ret = query_rmdirentry(dbconn, name, parent);
if (ret < 0) {
log_printf(LOG_ERROR, "Error: query_rmdirentry()\n");
goto err_out;
}
/* Only the last unlink() must set deleted flag.
* This is a shortcut - query_set_deleted() wouldn't
* set the flag if there is still an existing direntry
* anyway. But we'll save some DB processing here. */
if (nlinks > 1)
return 0;
ret = query_set_deleted(dbconn, inode);
if (ret < 0) {
log_printf(LOG_ERROR, "Error: query_set_deleted()\n");
goto err_out;
}
ret = query_purge_deleted(dbconn, inode);
if (ret < 0) {
log_printf(LOG_ERROR, "Error: query_purge_deleted()\n");
goto err_out;
}
pool_put(dbconn);
return 0;
err_out:
pool_put(dbconn);
return ret;
}
static int mysqlfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
(void) offset;
(void) fi;
int ret;
MYSQL *dbconn;
long inode;
log_printf(LOG_D_CALL, "mysqlfs_readdir(\"%s\")\n", path);
#ifdef STATUSDIR
if (0 == strcmp (path, status_pathname))
{
/* if printing the bogus "status" directory, dump the content and get out */
log_printf(LOG_D_CALL, "mysqlfs_readdir(\"%s\")(@%d)\n", path, __LINE__);
filler(buf, ".", NULL, 0);
filler(buf, "..", NULL, 0);
filler(buf, "txt", NULL, 0);
filler(buf, "xml", NULL, 0);
return 0;
}
#endif
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
inode = query_inode(dbconn, path);
if(inode < 0){
log_printf(LOG_ERROR, "Error: query_inode()\n");
pool_put(dbconn);
return inode;
}
filler(buf, ".", NULL, 0);
filler(buf, "..", NULL, 0);
#ifdef STATUSDIR
/* stuff in the bogus status subdir */
if (0 == strcmp (path, "/"))
{
log_printf(LOG_D_CALL, "mysqlfs_readdir(\"%s\")(@%d)\n", path, __LINE__);
filler(buf, status_pathname+1, NULL, 0);
}
#endif
ret = query_readdir(dbconn, inode, buf, filler);
pool_put(dbconn);
return 0;
}
void
session_free (session_t * s)
{
if (CLIB_DEBUG)
{
u8 thread_index = s->thread_index;
clib_memset (s, 0xFA, sizeof (*s));
pool_put (session_main.wrk[thread_index].sessions, s);
return;
}
SESSION_EVT_DBG (SESSION_EVT_FREE, s);
pool_put (session_main.wrk[s->thread_index].sessions, s);
}
int
fusefs_remove(void *v)
{
struct vop_remove_args *ap = v;
struct vnode *vp = ap->a_vp;
struct vnode *dvp = ap->a_dvp;
struct componentname *cnp = ap->a_cnp;
struct proc *p = cnp->cn_proc;
struct fusefs_node *ip;
struct fusefs_node *dp;
struct fusefs_mnt *fmp;
struct fusebuf *fbuf;
int error = 0;
DPRINTF("fusefs_remove\n");
ip = VTOI(vp);
dp = VTOI(dvp);
fmp = (struct fusefs_mnt *)ip->ufs_ino.i_ump;
if (!fmp->sess_init || (fmp->undef_op & UNDEF_REMOVE)) {
error = ENOSYS;
goto out;
}
fbuf = fb_setup(FUSEFDSIZE + cnp->cn_namelen + 1, dp->ufs_ino.i_number,
FBT_UNLINK, p);
memcpy(fbuf->fb_dat, cnp->cn_nameptr, cnp->cn_namelen);
fbuf->fb_dat[cnp->cn_namelen] = '\0';
error = fb_queue(fmp->dev, fbuf);
if (error) {
if (error == ENOSYS)
fmp->undef_op |= UNDEF_REMOVE;
pool_put(&fusefs_fbuf_pool, fbuf);
goto out;
}
VN_KNOTE(vp, NOTE_DELETE);
VN_KNOTE(dvp, NOTE_WRITE);
pool_put(&fusefs_fbuf_pool, fbuf);
out:
if (dvp == vp)
vrele(vp);
else
vput(vp);
vput(dvp);
return (error);
}
static int mysqlfs_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
int ret;
MYSQL *dbconn;
log_printf(LOG_D_CALL, "mysqlfs_read(\"%s\" %zu@%llu)\n", path, size, offset);
#ifdef STATUSDIR
/* take a short-circuit for the bogus virtual files */
if (0 == strncmp (path, status_pathname, len_status_pathname))
{
char *a = (char *) path + len_status_pathname;
log_printf(LOG_D_CALL, "%s(\"%s\")(@%d)\n", __FUNCTION__, a, __LINE__);
return mysqlfs_status_read(a, buf, size, offset, fi);
}
#endif
/* see http://www.macosxhints.com/article.php?story=20060814124808745 */
if ( (0 < theopts->osxnospotlight) && (0 == strcmp (path, "/.metadata_never_index")))
{
char *a = PACKAGE_STRING; /* in case I cannot point directly to static content */
int l = MIN(strlen(PACKAGE_STRING)-offset,size); /* tossaway length calc */
strncpy (buf, a+offset, l);
return l;
}
if ((dbconn = pool_get()) == NULL)
return -EMFILE;
ret = query_read(dbconn, fi->fh, buf, size, offset);
pool_put(dbconn);
return ret;
}
void
ata_free_xfer(struct ata_channel *chp, struct ata_xfer *xfer)
{
struct atac_softc *atac = chp->ch_atac;
int s;
if (xfer->c_flags & C_WAITACT) {
/* Someone is waiting for this xfer, so we can't free now */
xfer->c_flags |= C_FREE;
wakeup(xfer);
return;
}
#if NATA_PIOBM /* XXX wdc dependent code */
if (xfer->c_flags & C_PIOBM) {
struct wdc_softc *wdc = CHAN_TO_WDC(chp);
/* finish the busmastering PIO */
(*wdc->piobm_done)(wdc->dma_arg,
chp->ch_channel, xfer->c_drive);
chp->ch_flags &= ~(ATACH_DMA_WAIT | ATACH_PIOBM_WAIT | ATACH_IRQ_WAIT);
}
#endif
if (atac->atac_free_hw)
(*atac->atac_free_hw)(chp);
s = splbio();
pool_put(&ata_xfer_pool, xfer);
splx(s);
}
void
vnet_ldc_reset(struct ldc_conn *lc)
{
struct vnet_softc *sc = lc->lc_sc;
int i;
timeout_del(&sc->sc_handshake_to);
sc->sc_tx_prod = sc->sc_tx_cons = 0;
sc->sc_peer_state = VIO_DP_STOPPED;
sc->sc_vio_state = 0;
vnet_link_state(sc);
sc->sc_lm->lm_next = 1;
sc->sc_lm->lm_count = 1;
for (i = 1; i < sc->sc_lm->lm_nentries; i++)
sc->sc_lm->lm_slot[i].entry = 0;
for (i = 0; i < sc->sc_vd->vd_nentries; i++) {
if (sc->sc_vsd[i].vsd_buf) {
pool_put(&sc->sc_pool, sc->sc_vsd[i].vsd_buf);
sc->sc_vsd[i].vsd_buf = NULL;
}
sc->sc_vd->vd_desc[i].hdr.dstate = VIO_DESC_FREE;
}
}
void bn_clean(bn_t a) {
#if ALLOC == DYNAMIC
if (a != NULL) {
if (a->dp != NULL) {
#if OPSYS == WINDOWS && ALIGN > 1
_aligned_free(a->dp);
#else
free(a->dp);
#endif
a->dp = NULL;
}
a->alloc = 0;
}
#endif
#if ALLOC == STATIC
if (a != NULL && a->dp != NULL) {
pool_put(a->dp);
a->dp = NULL;
}
#endif
if (a != NULL) {
a->used = 0;
a->sign = BN_POS;
}
}
void
rtfree(struct rtentry *rt)
{
struct ifaddr *ifa;
if (rt == NULL)
panic("rtfree");
rt->rt_refcnt--;
if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
panic("rtfree 2");
rttrash--;
if (rt->rt_refcnt < 0) {
printf("rtfree: %p not freed (neg refs)\n", rt);
return;
}
rt_timer_remove_all(rt);
ifa = rt->rt_ifa;
if (ifa)
IFAFREE(ifa);
rtlabel_unref(rt->rt_labelid);
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
}
}
struct mbuf *
m_free(struct mbuf *m)
{
struct mbuf *n;
if (m == NULL)
return (NULL);
mtx_enter(&mbstatmtx);
mbstat.m_mtypes[m->m_type]--;
mtx_leave(&mbstatmtx);
n = m->m_next;
if (m->m_flags & M_ZEROIZE) {
m_zero(m);
/* propagate M_ZEROIZE to the next mbuf in the chain */
if (n)
n->m_flags |= M_ZEROIZE;
}
if (m->m_flags & M_PKTHDR)
m_tag_delete_chain(m);
if (m->m_flags & M_EXT)
m_extfree(m);
pool_put(&mbpool, m);
return (n);
}
void
rtfree(struct rtentry *rt)
{
struct ifaddr *ifa;
if (rt == NULL)
panic("rtfree");
rt->rt_refcnt--;
if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_UP) == 0) {
if (rt->rt_refcnt == 0 && (rt->rt_nodes->rn_flags & RNF_ACTIVE))
return; /* route still active but currently down */
if (rt->rt_nodes->rn_flags & (RNF_ACTIVE | RNF_ROOT))
panic("rtfree 2");
rttrash--;
if (rt->rt_refcnt < 0) {
printf("rtfree: %p not freed (neg refs)\n", rt);
return;
}
rt_timer_remove_all(rt);
ifa = rt->rt_ifa;
if (ifa)
IFAFREE(ifa);
rtlabel_unref(rt->rt_labelid);
#ifdef MPLS
if (rt->rt_flags & RTF_MPLS)
free(rt->rt_llinfo, M_TEMP);
#endif
Free(rt_key(rt));
pool_put(&rtentry_pool, rt);
}
}
static void
bt_freetrim(vmem_t *vm, int freelimit)
{
bt_t *t;
LIST_HEAD(, vmem_btag) tofree;
LIST_INIT(&tofree);
VMEM_LOCK(vm);
while (vm->vm_nfreetags > freelimit) {
bt_t *bt = LIST_FIRST(&vm->vm_freetags);
LIST_REMOVE(bt, bt_freelist);
vm->vm_nfreetags--;
if (bt >= static_bts
&& bt < static_bts + sizeof(static_bts)) {
mutex_enter(&vmem_btag_lock);
LIST_INSERT_HEAD(&vmem_btag_freelist, bt, bt_freelist);
vmem_btag_freelist_count++;
mutex_exit(&vmem_btag_lock);
VMEM_EVCNT_DECR(static_bt_inuse);
} else {
LIST_INSERT_HEAD(&tofree, bt, bt_freelist);
}
}
VMEM_UNLOCK(vm);
while (!LIST_EMPTY(&tofree)) {
t = LIST_FIRST(&tofree);
LIST_REMOVE(t, bt_freelist);
pool_put(&vmem_btag_pool, t);
}
}
void
tmpfs_dirent_put(struct tmpfs_mount *mp, struct tmpfs_dirent *de)
{
tmpfs_mem_decr(mp, sizeof(struct tmpfs_dirent));
pool_put(&tmpfs_dirent_pool, de);
}
void
yodestroy(struct yo *yo) {
struct o *o = (struct o *)yo;
oclear(o);
if (unlikely(!pool_put(o)))
yfree(o);
}
static void
close_netmap_if(netmap_main_t * nm, netmap_if_t * nif)
{
if (nif->unix_file_index != ~0) {
unix_file_del(&unix_main, unix_main.file_pool + nif->unix_file_index);
nif->unix_file_index = ~0;
}
if (nif->fd > -1)
close(nif->fd);
if (nif->mem_region)
{
netmap_mem_region_t * reg = &nm->mem_regions[nif->mem_region];
if (--reg->refcnt == 0)
{
munmap(reg->mem, reg->region_size);
reg->region_size = 0;
}
}
mhash_unset(&nm->if_index_by_host_if_name, nif->host_if_name, &nif->if_index);
vec_free(nif->host_if_name);
vec_free(nif->req);
memset(nif, 0, sizeof(*nif));
pool_put(nm->interfaces, nif);
}
