utils.c revision 2c629013fe1cccb4e0ca8586ece54320dfe849a2
/** @file
*
* vboxsf -- VirtualBox Guest Additions for Linux:
* Utility functions.
* Mainly conversion from/to VirtualBox/Linux data structures
*/
/*
* Copyright (C) 2006-2007 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "vfsmod.h"
#include <linux/nfs_fs.h>
#include <linux/vfs.h>
/* #define USE_VMALLOC */
/*
* sf_reg_aops and sf_backing_dev_info are just quick implementations to make
* sendfile work. For more information have a look at
*
* http://us1.samba.org/samba/ftp/cifs-cvs/ols2006-fs-tutorial-smf.odp
*
* and the sample implementation
*
* http://pserver.samba.org/samba/ftp/cifs-cvs/samplefs.tar.gz
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
static void
sf_ftime_from_timespec (time_t *time, RTTIMESPEC *ts)
{
int64_t t = RTTimeSpecGetNano (ts);
do_div (t, 1000000000);
*time = t;
}
static void
sf_timespec_from_ftime (RTTIMESPEC *ts, time_t *time)
{
int64_t t = 1000000000 * *time;
RTTimeSpecSetNano (ts, t);
}
#else /* >= 2.6.0 */
static void
sf_ftime_from_timespec (struct timespec *tv, RTTIMESPEC *ts)
{
int64_t t = RTTimeSpecGetNano (ts);
int64_t nsec;
nsec = do_div (t, 1000000000);
tv->tv_sec = t;
tv->tv_nsec = nsec;
}
static void
sf_timespec_from_ftime (RTTIMESPEC *ts, struct timespec *tv)
{
int64_t t = (int64_t)tv->tv_nsec + (int64_t)tv->tv_sec * 1000000000;
RTTimeSpecSetNano (ts, t);
}
#endif /* >= 2.6.0 */
/* set [inode] attributes based on [info], uid/gid based on [sf_g] */
void
sf_init_inode (struct sf_glob_info *sf_g, struct inode *inode,
RTFSOBJINFO *info)
{
int is_dir;
RTFSOBJATTR *attr;
int mode;
TRACE ();
attr = &info->Attr;
is_dir = RTFS_IS_DIRECTORY (attr->fMode);
#define mode_set(r) attr->fMode & (RTFS_UNIX_##r) ? (S_##r) : 0;
mode = mode_set (ISUID);
mode |= mode_set (ISGID);
mode |= mode_set (IRUSR);
mode |= mode_set (IWUSR);
mode |= mode_set (IXUSR);
mode |= mode_set (IRGRP);
mode |= mode_set (IWGRP);
mode |= mode_set (IXGRP);
mode |= mode_set (IROTH);
mode |= mode_set (IWOTH);
mode |= mode_set (IXOTH);
#undef mode_set
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
inode->i_mapping->a_ops = &sf_reg_aops;
inode->i_mapping->backing_dev_info = &sf_g->bdi;
#endif
if (is_dir) {
inode->i_mode = sf_g->dmode != ~0 ? (sf_g->dmode & 0777) : mode;
inode->i_mode &= ~sf_g->dmask;
inode->i_mode |= S_IFDIR;
inode->i_op = &sf_dir_iops;
inode->i_fop = &sf_dir_fops;
/* XXX: this probably should be set to the number of entries
in the directory plus two (. ..) */
inode->i_nlink = 1;
}
else {
inode->i_mode = sf_g->fmode != ~0 ? (sf_g->fmode & 0777): mode;
inode->i_mode &= ~sf_g->fmask;
inode->i_mode |= S_IFREG;
inode->i_op = &sf_reg_iops;
inode->i_fop = &sf_reg_fops;
inode->i_nlink = 1;
}
inode->i_uid = sf_g->uid;
inode->i_gid = sf_g->gid;
inode->i_size = info->cbObject;
#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 19) && !defined(KERNEL_FC6)
inode->i_blksize = 4096;
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 4, 11)
inode->i_blkbits = 12;
#endif
/* i_blocks always in units of 512 bytes! */
inode->i_blocks = (info->cbAllocated + 511) / 512;
sf_ftime_from_timespec (&inode->i_atime, &info->AccessTime);
sf_ftime_from_timespec (&inode->i_ctime, &info->ChangeTime);
sf_ftime_from_timespec (&inode->i_mtime, &info->ModificationTime);
}
int
sf_stat (const char *caller, struct sf_glob_info *sf_g,
SHFLSTRING *path, RTFSOBJINFO *result, int ok_to_fail)
{
int rc;
SHFLCREATEPARMS params;
TRACE ();
RT_ZERO(params);
params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
LogFunc(("sf_stat: calling vboxCallCreate, file %s, flags %#x\n",
path->String.utf8, params.CreateFlags));
rc = vboxCallCreate (&client_handle, &sf_g->map, path, &params);
if (RT_FAILURE (rc)) {
LogFunc(("vboxCallCreate(%s) failed. caller=%s, rc=%Rrc\n",
path->String.utf8, rc, caller));
return -EPROTO;
}
if (params.Result != SHFL_FILE_EXISTS) {
if (!ok_to_fail) {
LogFunc(("vboxCallCreate(%s) file does not exist. caller=%s, result=%d\n",
path->String.utf8, params.Result, caller));
}
return -ENOENT;
}
*result = params.Info;
return 0;
}
/* this is called directly as iop on 2.4, indirectly as dop
[sf_dentry_revalidate] on 2.4/2.6, indirectly as iop through
[sf_getattr] on 2.6. the job is to find out whether dentry/inode is
still valid. the test is failed if [dentry] does not have an inode
or [sf_stat] is unsuccessful, otherwise we return success and
update inode attributes */
int
sf_inode_revalidate (struct dentry *dentry)
{
int err;
struct sf_glob_info *sf_g;
struct sf_inode_info *sf_i;
RTFSOBJINFO info;
TRACE ();
if (!dentry || !dentry->d_inode) {
LogFunc(("no dentry(%p) or inode(%p)\n", dentry, dentry->d_inode));
return -EINVAL;
}
sf_g = GET_GLOB_INFO (dentry->d_inode->i_sb);
sf_i = GET_INODE_INFO (dentry->d_inode);
#if 0
printk ("%s called by %p:%p\n",
sf_i->path->String.utf8,
__builtin_return_address (0),
__builtin_return_address (1));
#endif
BUG_ON (!sf_g);
BUG_ON (!sf_i);
if (!sf_i->force_restat) {
if (jiffies - dentry->d_time < sf_g->ttl) {
return 0;
}
}
err = sf_stat (__func__, sf_g, sf_i->path, &info, 1);
if (err) {
return err;
}
dentry->d_time = jiffies;
sf_init_inode (sf_g, dentry->d_inode, &info);
return 0;
}
/* this is called during name resolution/lookup to check if the
[dentry] in the cache is still valid. the job is handled by
[sf_inode_revalidate] */
static int
#if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
sf_dentry_revalidate (struct dentry *dentry, int flags)
#else
sf_dentry_revalidate (struct dentry *dentry, struct nameidata *nd)
#endif
{
TRACE ();
if (sf_inode_revalidate (dentry)) {
return 0;
}
return 1;
}
/* on 2.6 this is a proxy for [sf_inode_revalidate] which (as a side
effect) updates inode attributes for [dentry] (given that [dentry]
has inode at all) from these new attributes we derive [kstat] via
[generic_fillattr] */
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
int
sf_getattr (struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat)
{
int err;
TRACE ();
err = sf_inode_revalidate (dentry);
if (err) {
return err;
}
generic_fillattr (dentry->d_inode, kstat);
return 0;
}
int
sf_setattr (struct dentry *dentry, struct iattr *iattr)
{
struct sf_glob_info *sf_g;
struct sf_inode_info *sf_i;
SHFLCREATEPARMS params;
RTFSOBJINFO info;
uint32_t cbBuffer;
int rc, err;
TRACE ();
sf_g = GET_GLOB_INFO (dentry->d_inode->i_sb);
sf_i = GET_INODE_INFO (dentry->d_inode);
err = 0;
RT_ZERO(params);
params.CreateFlags = SHFL_CF_ACT_OPEN_IF_EXISTS
| SHFL_CF_ACT_FAIL_IF_NEW
| SHFL_CF_ACCESS_ATTR_WRITE;
/* this is at least required for Posix hosts */
if (iattr->ia_valid & ATTR_SIZE)
params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
if (RT_FAILURE (rc)) {
LogFunc(("vboxCallCreate(%s) failed rc=%Rrc\n",
sf_i->path->String.utf8, rc));
err = -RTErrConvertToErrno(rc);
goto fail2;
}
if (params.Result != SHFL_FILE_EXISTS) {
LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
err = -ENOENT;
goto fail1;
}
/* Setting the file size and setting the other attributes has to be
* handled separately, see implementation of vbsfSetFSInfo() in
* vbsf.cpp */
if (iattr->ia_valid & (ATTR_MODE | ATTR_ATIME | ATTR_MTIME))
{
#define mode_set(r) ((iattr->ia_mode & (S_##r)) ? RTFS_UNIX_##r : 0)
RT_ZERO(info);
if (iattr->ia_valid & ATTR_MODE)
{
info.Attr.fMode = mode_set (ISUID);
info.Attr.fMode |= mode_set (ISGID);
info.Attr.fMode |= mode_set (IRUSR);
info.Attr.fMode |= mode_set (IWUSR);
info.Attr.fMode |= mode_set (IXUSR);
info.Attr.fMode |= mode_set (IRGRP);
info.Attr.fMode |= mode_set (IWGRP);
info.Attr.fMode |= mode_set (IXGRP);
info.Attr.fMode |= mode_set (IROTH);
info.Attr.fMode |= mode_set (IWOTH);
info.Attr.fMode |= mode_set (IXOTH);
if (iattr->ia_mode & S_IFDIR)
info.Attr.fMode |= RTFS_TYPE_DIRECTORY;
else
info.Attr.fMode |= RTFS_TYPE_FILE;
}
if (iattr->ia_valid & ATTR_ATIME)
sf_timespec_from_ftime (&info.AccessTime, &iattr->ia_atime);
if (iattr->ia_valid & ATTR_MTIME)
sf_timespec_from_ftime (&info.ModificationTime, &iattr->ia_mtime);
/* ignore ctime (inode change time) as it can't be set from userland anyway */
cbBuffer = sizeof(info);
rc = vboxCallFSInfo(&client_handle, &sf_g->map, params.Handle,
SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer,
(PSHFLDIRINFO)&info);
if (RT_FAILURE (rc)) {
LogFunc(("vboxCallFSInfo(%s, FILE) failed rc=%Rrc\n",
sf_i->path->String.utf8, rc));
err = -RTErrConvertToErrno(rc);
goto fail1;
}
}
if (iattr->ia_valid & ATTR_SIZE)
{
RT_ZERO(info);
info.cbObject = iattr->ia_size;
cbBuffer = sizeof(info);
rc = vboxCallFSInfo(&client_handle, &sf_g->map, params.Handle,
SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer,
(PSHFLDIRINFO)&info);
if (RT_FAILURE (rc)) {
LogFunc(("vboxCallFSInfo(%s, SIZE) failed rc=%Rrc\n",
sf_i->path->String.utf8, rc));
err = -RTErrConvertToErrno(rc);
goto fail1;
}
}
rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
if (RT_FAILURE (rc))
{
LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
sf_i->path->String.utf8, rc));
}
return sf_inode_revalidate (dentry);
fail1:
rc = vboxCallClose (&client_handle, &sf_g->map, params.Handle);
if (RT_FAILURE (rc))
{
LogFunc(("vboxCallClose(%s) failed rc=%Rrc\n",
sf_i->path->String.utf8, rc));
}
fail2:
return err;
}
#endif /* >= 2.6.0 */
static int
sf_make_path (const char *caller, struct sf_inode_info *sf_i,
const char *d_name, size_t d_len, SHFLSTRING **result)
{
size_t path_len, shflstring_len;
SHFLSTRING *tmp;
uint16_t p_len;
uint8_t *p_name;
uint8_t *dst;
int is_root = 0;
TRACE ();
p_len = sf_i->path->u16Length;
p_name = sf_i->path->String.utf8;
if (p_len == 1 && *p_name == '/') {
path_len = d_len + 1;
is_root = 1;
}
else {
/* lengths of constituents plus terminating zero plus slash */
path_len = p_len + d_len + 2;
if (path_len > 0xffff) {
LogFunc(("path too long. caller=%s, path_len=%zu\n", caller, path_len));
return -ENAMETOOLONG;
}
}
shflstring_len = offsetof (SHFLSTRING, String.utf8) + path_len;
tmp = kmalloc (shflstring_len, GFP_KERNEL);
if (!tmp) {
LogRelFunc(("kmalloc failed, caller=%s\n", caller));
return -ENOMEM;
}
tmp->u16Length = path_len - 1;
tmp->u16Size = path_len;
if (is_root) {
memcpy (tmp->String.utf8, d_name, d_len + 1);
}
else {
dst = tmp->String.utf8;
memcpy (dst, p_name, p_len);
dst += p_len; *dst++ = '/';
memcpy (dst, d_name, d_len);
dst[d_len] = 0;
}
*result = tmp;
return 0;
}
/* [dentry] contains string encoded in coding system that corresponds
to [sf_g]->nls, we must convert it to UTF8 here and pass down to
[sf_make_path] which will allocate SHFLSTRING and fill it in */
int
sf_path_from_dentry (const char *caller, struct sf_glob_info *sf_g,
struct sf_inode_info *sf_i, struct dentry *dentry,
SHFLSTRING **result)
{
int err;
const char *d_name;
size_t d_len;
const char *name;
size_t len = 0;
TRACE ();
d_name = dentry->d_name.name;
d_len = dentry->d_name.len;
if (sf_g->nls) {
size_t in_len, i, out_bound_len;
const char *in;
char *out;
in = d_name;
in_len = d_len;
out_bound_len = PATH_MAX;
out = kmalloc (out_bound_len, GFP_KERNEL);
name = out;
for (i = 0; i < d_len; ++i) {
/* We renamed the linux kernel wchar_t type to linux_wchar_t in
the-linux-kernel.h, as it conflicts with the C++ type of that name. */
linux_wchar_t uni;
int nb;
nb = sf_g->nls->char2uni (in, in_len, &uni);
if (nb < 0) {
LogFunc(("nls->char2uni failed %x %d\n",
*in, in_len));
err = -EINVAL;
goto fail1;
}
in_len -= nb;
in += nb;
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 31)
nb = utf32_to_utf8 (uni, out, out_bound_len);
#else
nb = utf8_wctomb (out, uni, out_bound_len);
#endif
if (nb < 0) {
LogFunc(("nls->uni2char failed %x %d\n",
uni, out_bound_len));
err = -EINVAL;
goto fail1;
}
out_bound_len -= nb;
out += nb;
len += nb;
}
if (len >= PATH_MAX - 1) {
err = -ENAMETOOLONG;
goto fail1;
}
LogFunc(("result(%d) = %.*s\n", len, len, name));
*out = 0;
}
else {
name = d_name;
len = d_len;
}
err = sf_make_path (caller, sf_i, name, len, result);
if (name != d_name) {
kfree (name);
}
return err;
fail1:
kfree (name);
return err;
}
int
sf_nlscpy (struct sf_glob_info *sf_g,
char *name, size_t name_bound_len,
const unsigned char *utf8_name, size_t utf8_len)
{
if (sf_g->nls) {
const char *in;
char *out;
size_t out_len;
size_t out_bound_len;
size_t in_bound_len;
in = utf8_name;
in_bound_len = utf8_len;
out = name;
out_len = 0;
out_bound_len = name_bound_len;
while (in_bound_len) {
int nb;
wchar_t uni;
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 31)
nb = utf8_to_utf32 (in, in_bound_len, &uni);
#else
nb = utf8_mbtowc (&uni, in, in_bound_len);
#endif
if (nb < 0) {
LogFunc(("utf8_mbtowc failed(%s) %x:%d\n",
(const char *) utf8_name, *in, in_bound_len));
return -EINVAL;
}
in += nb;
in_bound_len -= nb;
nb = sf_g->nls->uni2char (uni, out, out_bound_len);
if (nb < 0) {
LogFunc(("nls->uni2char failed(%s) %x:%d\n",
utf8_name, uni, out_bound_len));
return nb;
}
out += nb;
out_bound_len -= nb;
out_len += nb;
}
*out = 0;
return 0;
}
else {
if (utf8_len + 1 > name_bound_len) {
return -ENAMETOOLONG;
}
else {
memcpy (name, utf8_name, utf8_len + 1);
}
return 0;
}
}
static struct sf_dir_buf *
sf_dir_buf_alloc (void)
{
struct sf_dir_buf *b;
TRACE ();
b = kmalloc (sizeof (*b), GFP_KERNEL);
if (!b) {
LogRelFunc(("could not alloc directory buffer\n"));
return NULL;
}
#ifdef USE_VMALLOC
b->buf = vmalloc (16384);
#else
b->buf = kmalloc (16384, GFP_KERNEL);
#endif
if (!b->buf) {
kfree (b);
LogRelFunc(("could not alloc directory buffer storage\n"));
return NULL;
}
INIT_LIST_HEAD (&b->head);
b->nb_entries = 0;
b->used_bytes = 0;
b->free_bytes = 16384;
return b;
}
static void
sf_dir_buf_free (struct sf_dir_buf *b)
{
BUG_ON (!b || !b->buf);
TRACE ();
list_del (&b->head);
#ifdef USE_VMALLOC
vfree (b->buf);
#else
kfree (b->buf);
#endif
kfree (b);
}
void
sf_dir_info_free (struct sf_dir_info *p)
{
struct list_head *list, *pos, *tmp;
TRACE ();
list = &p->info_list;
list_for_each_safe (pos, tmp, list) {
struct sf_dir_buf *b;
b = list_entry (pos, struct sf_dir_buf, head);
sf_dir_buf_free (b);
}
kfree (p);
}
void
sf_dir_info_empty(struct sf_dir_info *p)
{
struct list_head *list, *pos, *tmp;
TRACE ();
list = &p->info_list;
list_for_each_safe (pos, tmp, list) {
struct sf_dir_buf *b;
b = list_entry (pos, struct sf_dir_buf, head);
b->nb_entries = 0;
b->used_bytes = 0;
b->free_bytes = 16384;
}
}
struct sf_dir_info *
sf_dir_info_alloc (void)
{
struct sf_dir_info *p;
TRACE ();
p = kmalloc (sizeof (*p), GFP_KERNEL);
if (!p) {
LogRelFunc(("could not alloc directory info\n"));
return NULL;
}
INIT_LIST_HEAD (&p->info_list);
return p;
}
static struct sf_dir_buf *
sf_get_empty_dir_buf (struct sf_dir_info *sf_d)
{
struct list_head *list, *pos;
list = &sf_d->info_list;
list_for_each (pos, list) {
struct sf_dir_buf *b;
b = list_entry (pos, struct sf_dir_buf, head);
if (!b) {
return NULL;
}
else {
if (b->used_bytes == 0) {
return b;
}
}
}
return NULL;
}
int
sf_dir_read_all (struct sf_glob_info *sf_g, struct sf_inode_info *sf_i,
struct sf_dir_info *sf_d, SHFLHANDLE handle)
{
int err;
SHFLSTRING *mask;
struct sf_dir_buf *b;
TRACE ();
err = sf_make_path (__func__, sf_i, "*", 1, &mask);
if (err) {
goto fail0;
}
for (;;) {
int rc;
void *buf;
uint32_t buf_size;
uint32_t nb_ents;
b = sf_get_empty_dir_buf (sf_d);
if (!b) {
b = sf_dir_buf_alloc ();
if (!b) {
err = -ENOMEM;
LogRelFunc(("could not alloc directory buffer\n"));
goto fail1;
}
list_add (&b->head, &sf_d->info_list);
}
buf = b->buf;
buf_size = b->free_bytes;
rc = vboxCallDirInfo (
&client_handle,
&sf_g->map,
handle,
mask,
0,
0,
&buf_size,
buf,
&nb_ents
);
switch (rc) {
case VINF_SUCCESS:
/* fallthrough */
case VERR_NO_MORE_FILES:
break;
case VERR_NO_TRANSLATION:
LogFunc(("host could not translate entry\n"));
/* XXX */
break;
default:
err = -RTErrConvertToErrno (rc);
LogFunc(("vboxCallDirInfo failed rc=%Rrc\n", rc));
goto fail1;
}
b->nb_entries += nb_ents;
b->free_bytes -= buf_size;
b->used_bytes += buf_size;
if (RT_FAILURE (rc))
break;
}
return 0;
fail1:
kfree (mask);
fail0:
return err;
}
int sf_get_volume_info(struct super_block *sb, STRUCT_STATFS *stat)
{
struct sf_glob_info *sf_g;
SHFLVOLINFO SHFLVolumeInfo;
uint32_t cbBuffer;
int rc;
sf_g = GET_GLOB_INFO (sb);
cbBuffer = sizeof(SHFLVolumeInfo);
rc = vboxCallFSInfo(&client_handle, &sf_g->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
&cbBuffer, (PSHFLDIRINFO)&SHFLVolumeInfo);
if (RT_FAILURE(rc))
return -RTErrConvertToErrno(rc);
stat->f_type = NFS_SUPER_MAGIC; /* XXX vboxsf type? */
stat->f_bsize = SHFLVolumeInfo.ulBytesPerAllocationUnit;
stat->f_blocks = SHFLVolumeInfo.ullTotalAllocationBytes
/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
stat->f_bfree = SHFLVolumeInfo.ullAvailableAllocationBytes
/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
stat->f_bavail = SHFLVolumeInfo.ullAvailableAllocationBytes
/ SHFLVolumeInfo.ulBytesPerAllocationUnit;
stat->f_files = 1000;
stat->f_ffree = 1000; /* don't return 0 here since the guest may think
* that it is not possible to create any more files */
stat->f_fsid.val[0] = 0;
stat->f_fsid.val[1] = 0;
stat->f_namelen = 255;
return 0;
}
struct dentry_operations sf_dentry_ops = {
.d_revalidate = sf_dentry_revalidate
};
int sf_init_backing_dev(struct sf_glob_info *sf_g, const char *name)
{
int rc = 0;
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
sf_g->bdi.ra_pages = 0; /* No readahead */
# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 12)
sf_g->bdi.capabilities = BDI_CAP_MAP_DIRECT /* MAP_SHARED */
| BDI_CAP_MAP_COPY /* MAP_PRIVATE */
| BDI_CAP_READ_MAP /* can be mapped for reading */
| BDI_CAP_WRITE_MAP /* can be mapped for writing */
| BDI_CAP_EXEC_MAP; /* can be mapped for execution */
# endif /* >= 2.6.12 */
# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
rc = bdi_init(&sf_g->bdi);
# if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 26)
if (!rc)
rc = bdi_register(&sf_g->bdi, NULL, "vboxsf-%s", name);
# endif /* >= 2.6.26 */
# endif /* >= 2.6.24 */
#endif /* >= 2.6.0 */
return rc;
}
void sf_done_backing_dev(struct sf_glob_info *sf_g)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
bdi_destroy(&sf_g->bdi); /* includes bdi_unregister() */
#endif
}