unsigned long obd_gen_prealloc_quota;
struct list_head obd_gen_clients;
union {
- struct sim_obd sim;
+ struct ext2_obd ext2;
struct raid1_obd raid1;
struct snap_obd snap;
struct rpc_obd rpc;
#ifndef _OBD_SIM
#define _OBD_SIM
-struct sim_obd {
- struct super_block * sim_sb;
+struct ext2_obd {
+ struct super_block * ext2_sb;
};
extern struct file_operations *obd_fso;
/* obd_sim.c */
-extern struct obd_ops sim_obd_ops;
+extern struct obd_ops ext2_obd_ops;
inline long ext2_block_map (struct inode * inode, long block);
/* balloc.c */
#define SNAP_MAX 8 /* must fit in "u" area of struct inode */
struct snap_obd_data {
int snap_dev; /* which device contains the data */
- unsigned int snap_no; /* which snapshot are we accessing */
- unsigned int snap_count; /* how many snapshots exist */
+ unsigned int snap_no; /* which snapshot are we accessing */
+ unsigned int snap_count; /* how many snapshots exist */
time_t snap_times[SNAP_MAX];
};
#include <linux/malloc.h>
#include <linux/vmalloc.h>
-#define SIM_OBD_DEBUG
+#define EXT2_OBD_DEBUG
#define MIN(a,b) (((a)<(b)) ? (a): (b))
/* debugging masks */
#define D_PSDEV 1 /* debug information from psdev.c */
#define D_INODE 2
-#define D_UNUSED2 4
+#define D_SUPER 4
#define D_UNUSED3 8
#define D_UNUSED4 16
#define D_WARNING 32 /* misc warnings */
#define D_BLOCKS 2048 /* ext2 block allocation */
#define D_RPC 4096 /* ext2 block allocation */
-#ifdef SIM_OBD_DEBUG
+#ifdef EXT2_OBD_DEBUG
#define CDEBUG(mask, format, a...) \
do { \
if (obd_debug_level & mask) { \
if (obd_print_entry) \
printk("Process %d leaving %s [%d]\n", current->pid, __FUNCTION__, __LINE__)
-#else /* SIM_OBD_DEBUG */
+#else /* EXT2_OBD_DEBUG */
# define CDEBUG ;
# define ENTRY ;
# define EXIT ;
-#endif /* SIM_OBD_DEBUG */
+#endif /* EXT2_OBD_DEBUG */
#define CMD(cmd) (( cmd == READ ) ? "read" : "write")
struct obd_conn_info osi_conn_info;
struct super_block *osi_super;
struct obd_device *osi_obd;
- struct obd_ops *osi_ops;
+ struct obd_ops *osi_ops;
+ ino_t osi_rootino; /* which root inode */
+ int osi_minor; /* minor of /dev/obdX */
};
void obdfs_sysctl_init(void);
static inline struct obd_ops *iops(struct inode *i)
{
- struct obdfs_sb_info *sbi = (struct obdfs_sb_info *) i->i_sb->u.generic_sbp;
+ struct obdfs_sb_info *sbi = (struct obdfs_sb_info *) &i->i_sb->u.generic_sbp;
return sbi->osi_ops;
}
+static inline int iid(struct inode *i)
+{
+ struct obdfs_sb_info *sbi = (struct obdfs_sb_info *) &i->i_sb->u.generic_sbp;
+ return sbi->osi_conn_info.conn_id;
+}
+
#define NOLOCK 0
#define LOCKED 1
+#ifdef OPS
+#warning "*** WARNING redefining OPS"
+#else
+#define OPS(sb,op) ((struct obdfs_sb_info *)(& ## sb ## ->u.generic_sbp))->osi_ops->o_ ## op
+#define IOPS(inode,op) ((struct obdfs_sb_info *)(& ## inode->i_sb ## ->u.generic_sbp))->osi_ops->o_ ## op
+#endif
+
+#ifdef ID
+#warning "*** WARNING redefining ID"
+#else
+#define ID(sb) (((struct obdfs_sb_info *)( & ## sb ## ->u.generic_sbp))->osi_conn_info.conn_id)
+#define IID(inode) (((struct obdfs_sb_info *)( & ## inode->i_sb ## ->u.generic_sbp))->osi_conn_info.conn_id)
+#endif
#define OBDFS_SUPER_MAGIC 0x4711
if (!obddev->obd_type)
return -ENODEV;
- if (!obddev->u.sim.sim_sb || !obddev->u.sim.sim_sb->s_dev) {
+ if (!obddev->u.ext2.ext2_sb || !obddev->u.ext2.ext2_sb->s_dev) {
CDEBUG(D_IOCTL, "fatal: device not initialized.\n");
err = -EINVAL;
} else {
- if ((err = fsync_dev(obddev->u.sim.sim_sb->s_dev)))
+ if ((err = fsync_dev(obddev->u.ext2.ext2_sb->s_dev)))
CDEBUG(D_IOCTL, "sync: fsync_dev failure\n");
else
CDEBUG(D_IOCTL, "sync: success\n");
return -ENODEV;
- if (!obddev->u.sim.sim_sb) {
+ if (!obddev->u.ext2.ext2_sb) {
CDEBUG(D_IOCTL, "fatal: device not initialized.\n");
return put_user(-EINVAL, (int *) arg);
}
copy_from_user(&prealloc, (int *)arg,
sizeof(struct oic_prealloc_s));
- if (!obddev->u.sim.sim_sb || !obddev->u.sim.sim_sb->s_dev) {
+ if (!obddev->u.ext2.ext2_sb || !obddev->u.ext2.ext2_sb->s_dev) {
CDEBUG(D_IOCTL, "fatal: device not initialized.\n");
return -EINVAL;
}
quit
EOF
-rmmod obdsim
+rmmod obdext2
rmmod obdclass
/*
- * linux/fs/sim_obd/sim_obd.c
+ * linux/fs/ext2_obd/sim_obd.c
*
* These are the only exported functions; they provide the simulated object-
* oriented disk.
use IO::Handle;
-my ($device, $filesystem, $file);
-# startup options (I'll replace these when I have some to replace with)
-GetOptions("f!" => \$file, "device=s" => \$device, "fs=s" => $filesystem) || die "Getoptions";
-
-# genuine new simulated OBD device
-$device = "/dev/obd0" unless $device;
-# object store in the ext2 formatted block device
-$filesystem = "/dev/loop0" unless $filesystem;
+my ($file);
+GetOptions("f!" => \$file, "device=s" => \$::device, "fs=s" => $::filesystem) || die "Getoptions";
# get a console for the app
my $arg;
my %commands =
- ('create' => {func => "Create", doc => "create: creates a new inode"},
+ ('device' => {func => "Device", doc => "device <dev>: open another OBD device"},
+ 'filesystem' => {func => "Filesystem", doc => "filesystem <dev>: partition for direct OBD device"},
+ 'create' => {func => "Create", doc => "create: creates a new inode"},
'attach' => {func => "Attach", doc => "format type [adapter bus tid lun]"},
'format' => {func => "Format", doc => "format type adapter bus tid lun size"},
'partition' => {func => "Partition", doc => "partition type adapter bus tid lun partition size"},
#
my @jcm_cmd_list = keys %commands;
-#------------------------------------------------------------------------------
-# Open the device, as we need an FD for the ioctl
-sysopen(DEV_OBD, $device, 0) || die "Cannot open $device";
+my $term, $attribs;
-if (!defined($::st = stat($filesystem))) {
- die "Unable to stat $filesystem.\n";
-}
-my $term, $attribs;
+# Get going....
+Device($::device);
+Filesystem($::filesystem);
if ( $file ) {
while ( <STDIN> ) {
print $_;
# make sure stdout is not buffered
STDOUT->autoflush(1);
+
# Get on with the show
process_line();
}
return (&{$commands{$cmd}->{func}}(@arg));
}
+# set the object store in the ext2 formatted block device
+sub Filesystem {
+ my $filesystem = shift;
+ $filesystem = "/dev/loop0" unless $filesystem;
+
+ $::filesystem = $filesystem;
+ if (!defined($::st = stat($filesystem))) {
+ die "Unable to stat $filesystem.\n";
+ }
+}
+
+# select the OBD device we talk to
+sub Device {
+ my $device = shift;
+
+ if (! $device ) {
+ $device = "/dev/obd0";
+ }
+ $::device = $device;
+ # Open the device, as we need an FD for the ioctl
+ sysopen(DEV_OBD, $device, 0) || die "Cannot open $device";
+
+}
+
+
sub Attach {
my $err = 0;
my $data;
my $datalen = 0;
- $type = "sim_obd" unless $type;
+ $type = "ext2_obd" unless $type;
- if ( $type eq "sim_obd" ) {
+ if ( $type eq "ext2_obd" ) {
my $dev = shift;
$dev = $::st->rdev() unless $dev;
$data = pack("i", $dev);
insmod loop
losetup /dev/loop0 /tmp/fs
insmod obdclass.o
-insmod obdsim.o
+insmod ../ext2obd/obdext2.o
insmod ../obdfs/obdfs.o
./obdcontrol -f << EOF
-attach sim_obd
+attach ext2_obd
setup
quit
EOF
struct page *page;
struct ext2_dir_entry_2 * de;
int err = -EIO;
- struct obdfs_sb_info *sbi;
ino_t ino;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
/*
* N.B. Several error exits in ext2_new_inode don't set err.
*/
- ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
+ ino = iops(dir)->o_create(iid(dir), 0, &err);
if ( err )
return err;
err = -EIO;
de->inode = cpu_to_le32(inode->i_ino);
ext2_set_de_type(dir->i_sb, de, S_IFREG);
dir->i_version = ++event;
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- dir, page, 0);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
UnlockPage(page);
#if 0
if (IS_SYNC(dir)) {
struct page *page;
struct ext2_dir_entry_2 * de;
int err = -EIO;
- struct obdfs_sb_info *sbi;
ino_t ino;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
/*
* N.B. Several error exits in ext2_new_inode don't set err.
*/
- ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
+ ino = iops(dir)->o_create(iid(dir), 0, &err);
if ( ino == -1 )
return -1;
inode = iget(dir->i_sb, ino);
dir->i_version = ++event;
ext2_set_de_type(dir->i_sb, de, inode->i_mode);
mark_inode_dirty(inode);
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- dir, page, 0);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
UnlockPage(page);
#if 0
struct inode * child;
struct page *page, *child_page;
struct ext2_dir_entry_2 * de;
- struct obdfs_sb_info *sbi;
int err;
ino_t ino;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
err = -EMLINK;
if (dir->i_nlink >= EXT2_LINK_MAX)
goto out;
err = -EIO;
- ino = iops(dir)->o_create(sbi->osi_conn_info.conn_id, 0, &err);
+ ino = iops(dir)->o_create(iid(dir), 0, &err);
if ( ino == -1 )
return -1;
child = iget(dir->i_sb, ino);
strcpy (de->name, "..");
ext2_set_de_type(dir->i_sb, de, S_IFDIR);
- iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, child, child_page, 1);
+ iops(dir)->o_brw(WRITE, iid(dir), child, child_page, 1);
UnlockPage(child_page);
page_cache_release(child_page);
dir->i_nlink++;
dir->u.ext2_i.i_flags &= ~EXT2_BTREE_FL;
mark_inode_dirty(dir);
- iops(dir)->o_brw(WRITE, sbi->osi_conn_info.conn_id, dir, page, 1);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 1);
UnlockPage(page);
page_cache_release(page);
d_instantiate(dentry, child);
struct inode * inode;
struct page *page;
struct ext2_dir_entry_2 * de;
- struct obdfs_sb_info *sbi;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
retval = -ENOENT;
page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, LOCKED);
dir->i_version = ++event;
if (retval)
goto end_rmdir;
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id, dir, page, 0);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
UnlockPage(page);
#if 0
if (IS_SYNC(dir)) {
struct inode * inode;
struct page *page;
struct ext2_dir_entry_2 * de;
- struct obdfs_sb_info *sbi;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
retval = -ENOENT;
page = obdfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &de, LOCKED);
if (retval)
goto end_unlink;
dir->i_version = ++event;
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id, dir, page, 0);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
UnlockPage(page);
#if 0
if (IS_SYNC(dir)) {
char * link;
int i, l, err = -EIO;
char c;
- struct obdfs_sb_info *sbi;
ino_t ino;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
/*
* N.B. Several error exits in ext2_new_inode don't set err.
*/
- ino = sbi->osi_ops->o_create(sbi->osi_conn_info.conn_id, 0, &err);
+ ino = iops(dir)->o_create(iid(dir), 0, &err);
if ( ino == -1 )
return -1;
inode = iget(dir->i_sb, ino);
link[i++] = c;
link[i] = 0;
if (name_page) {
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- inode, name_page, 1);
+ iops(inode)->o_brw(WRITE, iid(inode), inode, name_page, 1);
PDEBUG(name_page, "symlink");
UnlockPage(name_page);
page_cache_release(name_page);
de->inode = cpu_to_le32(inode->i_ino);
ext2_set_de_type(dir->i_sb, de, S_IFLNK);
dir->i_version = ++event;
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- dir, page, 1);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 1);
UnlockPage(page);
#if 0
if (IS_SYNC(dir)) {
struct ext2_dir_entry_2 * de;
struct page *page;
int err;
- struct obdfs_sb_info *sbi;
ENTRY;
- sbi = dir->i_sb->u.generic_sbp;
if (S_ISDIR(inode->i_mode))
return -EPERM;
de->inode = cpu_to_le32(inode->i_ino);
ext2_set_de_type(dir->i_sb, de, inode->i_mode);
dir->i_version = ++event;
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- dir, page, 0);
+ iops(dir)->o_brw(WRITE, iid(dir), dir, page, 0);
UnlockPage(page);
#if 0
struct page * old_page, * new_page, * dir_page;
struct ext2_dir_entry_2 * old_de, * new_de;
int retval;
- struct obdfs_sb_info *sbi;
ENTRY;
- sbi = old_dir->i_sb->u.generic_sbp;
new_page = dir_page = NULL;
mark_inode_dirty(old_dir);
if (dir_page) {
PARENT_INO(page_address(dir_page)) = le32_to_cpu(new_dir->i_ino);
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- old_inode, dir_page, 0);
+ iops(old_inode)->o_brw(WRITE, iid(old_inode), old_inode, dir_page, 0);
old_dir->i_nlink--;
mark_inode_dirty(old_dir);
if (new_inode) {
page_cache_release(old_page);
old_page = obdfs_getpage(old_dir, offset, 0, LOCKED);
CDEBUG(D_INODE, "old_page at %p\n", old_page);
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- old_dir, old_page, 0);
+ iops(old_dir)->o_brw(WRITE, iid(old_dir), old_dir, old_page,0);
}
#if 0
if (IS_SYNC(old_dir)) {
wait_on_buffer (old_bh);
}
#endif
- sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- new_dir, new_page, 0);
+ iops(new_dir)->o_brw(WRITE, iid(new_dir), new_dir, new_page, 0);
#if 0
if (IS_SYNC(new_dir)) {
ll_rw_block (WRITE, 1, &new_bh);
/* returns the page unlocked, but with a reference */
int obdfs_readpage(struct file *file, struct page *page)
{
- struct obdfs_sb_info *sbi;
- struct super_block *sb = file->f_dentry->d_inode->i_sb;
+ struct inode *inode = file->f_dentry->d_inode;
int rc;
ENTRY;
/* XXX flush stuff */
- sbi = sb->u.generic_sbp;
PDEBUG(page, "READ");
- rc = sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id,
- file->f_dentry->d_inode, page, 0);
+ rc = iops(inode)->o_brw(READ, iid(inode),inode, page, 0);
if (rc == PAGE_SIZE ) {
SetPageUptodate(page);
UnlockPage(page);
int obdfs_write_one_page(struct file *file, struct page *page, unsigned long offset, unsigned long bytes, const char * buf)
{
long status;
- struct obdfs_sb_info *sbi = file->f_dentry->d_inode->i_sb->u.generic_sbp;
+ struct inode *inode = file->f_dentry->d_inode;
ENTRY;
if ( !Page_Uptodate(page) ) {
- status = sbi->osi_ops->o_brw(READ,
- sbi->osi_conn_info.conn_id,
- file->f_dentry->d_inode,
- page, 1);
+ status = iops(inode)->o_brw(READ, iid(inode), inode, page, 1);
if (status == PAGE_SIZE ) {
SetPageUptodate(page);
} else {
/* returns the page unlocked, but with a reference */
int obdfs_writepage(struct file *file, struct page *page)
{
- struct obdfs_sb_info *sbi = file->f_dentry->d_inode->i_sb->u.generic_sbp;
+ struct inode *inode = file->f_dentry->d_inode;
int rc;
ENTRY;
PDEBUG(page, "WRITEPAGE");
/* XXX flush stuff */
- rc = sbi->osi_ops->o_brw(WRITE, sbi->osi_conn_info.conn_id,
- file->f_dentry->d_inode, page, 1);
+ rc = iops(inode)->o_brw(WRITE, iid(inode), inode, page, 1);
SetPageUptodate(page);
PDEBUG(page,"WRITEPAGE");
struct page *page_cache;
struct page ** hash;
struct page * page;
- struct obdfs_sb_info *sbi;
- struct super_block *sb = inode->i_sb;
int rc;
ENTRY;
offset = offset & PAGE_CACHE_MASK;
- sbi = sb->u.generic_sbp;
CDEBUG(D_INODE, "\n");
page = NULL;
- rc = sbi->osi_ops->o_brw(READ, sbi->osi_conn_info.conn_id,
- inode, page, create);
+ rc = iops(inode)->o_brw(READ, iid(inode), inode, page, create);
if ( rc != PAGE_SIZE ) {
SetPageError(page);
UnlockPage(page);
struct file_operations obdfs_file_ops = {
NULL, /* lseek - default */
generic_file_read, /* read */
- obdfs_file_write, /* write - bad */
+ obdfs_file_write, /* write - bad */
obdfs_readdir, /* readdir */
NULL, /* poll - default */
NULL, /* ioctl */
#include <linux/obd_support.h>
#include <linux/obd_class.h>
-#include <linux/obd_sim.h> /* XXX for development/debugging only */
#include <linux/obdfs.h>
/* VFS super_block ops */
NULL /* remount_fs */
};
-struct obdfs_sb_info obdfs_super_info;
-int obd_minor = 0;
-int obd_root_ino = 2;
+static char *obdfs_read_opt(const char *opt, char *data)
+{
+ char *value;
+ char *retval;
+
+ CDEBUG(D_SUPER, "option: %s, data %s\n", opt, data);
+ if ( strncmp(opt, data, strlen(opt)) )
+ return NULL;
+
+ if ( (value = strchr(data, '=')) == NULL )
+ return NULL;
+
+ value++;
+ OBD_ALLOC(retval, char *, strlen(value) + 1);
+ if ( !retval ) {
+ printk("OBDFS: Out of memory!\n");
+ return NULL;
+ }
+
+ memcpy(retval, value, strlen(value)+1);
+ CDEBUG(D_SUPER, "Assigned option: %s, value %s\n", opt, retval);
+ return retval;
+}
+
+void obdfs_options(char *options, char **dev, char **vers)
+{
+ char *this_char;
+
+ if (!options)
+ goto out;
+
+ for (this_char = strtok (options, ",");
+ this_char != NULL;
+ this_char = strtok (NULL, ",")) {
+ CDEBUG(D_SUPER, "this_char %s\n", this_char);
+ if ( (!*dev && (*dev = obdfs_read_opt("device", this_char))) ||
+ (!*vers && (*vers = obdfs_read_opt("version", this_char))) )
+ continue;
+
+ }
+
+ out:
+ if (!*dev) {
+ *dev = "/dev/obd0";
+ }
+}
+
+static int obdfs_getdev(char *devpath, int *dev)
+{
+ struct dentry *dentry;
+ kdev_t devno;
+
+ dentry = lookup_dentry(devpath, NULL, 0);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ if (!S_ISCHR(dentry->d_inode->i_mode))
+ return -ENODEV;
+
+ devno = dentry->d_inode->i_rdev;
+ if ( MAJOR(devno) != OBD_PSDEV_MAJOR )
+ return -ENODEV;
+
+ if ( MINOR(devno) >= MAX_OBD_DEVICES )
+ return -ENODEV;
+
+ *dev = devno;
+ return 0;
+}
static struct super_block * obdfs_read_super(struct super_block *sb,
void *data, int silent)
{
struct inode *root = 0;
- struct obdfs_sb_info *sbi = NULL;
+ struct obdfs_sb_info *sbi = (struct obdfs_sb_info *)(&sb->u.generic_sbp);
struct obd_device *obddev;
int error = 0;
+ char *device = NULL;
+ char *version = NULL;
+ int devno;
+ int err;
unsigned long blocksize;
unsigned long blocksize_bits;
unsigned long root_ino;
ENTRY;
MOD_INC_USE_COUNT;
+
+ memset(sbi, 0, sizeof(*sbi));
+
+ obdfs_options(data, &device, &version);
+ if ( !device ) {
+ printk("No device\n");
+ MOD_DEC_USE_COUNT;
+ return NULL;
+ }
- sbi = &obdfs_super_info;
+ if ( (err = obdfs_getdev(device, &devno)) ) {
+ printk("Cannot get devno of %s, error %d\n", device, err);
+ MOD_DEC_USE_COUNT;
+ return NULL;
+ }
- if ( sbi->osi_super ) {
- printk("Already mounted\n");
+ if ( MAJOR(devno) != OBD_PSDEV_MAJOR ) {
+ printk("Wrong major number!\n");
MOD_DEC_USE_COUNT;
return NULL;
}
-
- obddev = &obd_dev[obd_minor];
+
+ if ( MINOR(devno) >= MAX_OBD_DEVICES ) {
+ printk("Minor of %s too high (%d)\n", device, MINOR(devno));
+ MOD_DEC_USE_COUNT;
+ return NULL;
+ }
+
+ obddev = &obd_dev[MINOR(devno)];
if ( ! (obddev->obd_flags & OBD_ATTACHED) ||
- ! (obddev->obd_flags & OBD_SET_UP) )
+ ! (obddev->obd_flags & OBD_SET_UP) ){
+ MOD_DEC_USE_COUNT;
return NULL;
+ }
sbi->osi_obd = obddev;
sbi->osi_ops = sbi->osi_obd->obd_type->typ_ops;
error = sbi->osi_ops->o_connect(sbi->osi_obd, &sbi->osi_conn_info);
if ( error ) {
- printk("OBDFS: cannot connect to 0x%x.\n", obd_minor);
+ printk("OBDFS: cannot connect to %s\n", device);
goto error;
}
+
+
sbi->osi_super = sb;
error = sbi->osi_ops->o_get_info(sbi->osi_conn_info.conn_id,
lock_super(sb);
- sb->u.generic_sbp = sbi;
sb->s_blocksize = blocksize;
sb->s_blocksize_bits = (unsigned char)blocksize_bits;
}
- printk("obdfs_read_super: sbdev %d, rootinode is %ld dev %d, blocksize %ld, "
- "blocksize bits %ld\n",
- sb->s_dev, root->i_ino, root->i_dev, blocksize, blocksize_bits);
+ printk("obdfs_read_super: sbdev %d, rootino: %ld, dev %s, "
+ "minor: %d, blocksize: %ld, blocksize bits %ld\n",
+ sb->s_dev, root->i_ino, device, MINOR(devno),
+ blocksize, blocksize_bits);
sb->s_root = d_alloc_root(root);
unlock_super(sb);
EXIT;
sb->s_dev = 0;
/* XXX flush stuff */
- sbi = sb->u.generic_sbp;
- sb->u.generic_sbp = NULL;
- sbi->osi_ops->o_disconnect(sbi->osi_conn_info.conn_id);
- sbi->osi_super = NULL;
+ sbi = (struct obdfs_sb_info *) &sb->u.generic_sbp;
+
+ OPS(sb,disconnect)(ID(sb));
+ memset(sbi, 0, sizeof(* sbi));
printk("OBDFS: Bye bye.\n");
- memset(sbi, 0, sizeof(* sbi));
MOD_DEC_USE_COUNT;
EXIT;
void obdfs_read_inode(struct inode *inode)
{
int error;
- struct obdfs_sb_info *sbi = inode->i_sb->u.generic_sbp;
ENTRY;
- error = sbi->osi_ops->o_getattr(sbi->osi_conn_info.conn_id,
- inode->i_ino, inode);
+ error = IOPS(inode, getattr)(IID(inode), inode->i_ino, inode);
if (error) {
printk("obdfs_read_inode: obd_getattr fails (%d)\n", error);
return;
static void obdfs_write_inode(struct inode *inode)
{
- struct obdfs_sb_info *sbi;
int error;
- sbi = inode->i_sb->u.generic_sbp;
- error = sbi->osi_ops->o_setattr(sbi->osi_conn_info.conn_id,
- inode->i_ino, inode);
+ error = IOPS(inode, setattr)(IID(inode), inode->i_ino, inode);
if (error) {
printk("obdfs_write_inode: obd_setattr fails (%d)\n", error);
return;
static void obdfs_delete_inode(struct inode *inode)
{
- struct obdfs_sb_info *sbi;
int error;
ENTRY;
- sbi = inode->i_sb->u.generic_sbp;
- error = sbi->osi_ops->o_destroy(sbi->osi_conn_info.conn_id,
- inode->i_ino);
+ error = IOPS(inode, destroy)(IID(inode), inode->i_ino);
if (error) {
printk("obdfs_delete_node: ibd_destroy fails (%d)\n", error);
return;
{
struct inode *inode = de->d_inode;
struct iattr saved_copy;
- struct obdfs_sb_info * sbi;
int error;
ENTRY;
inode_to_iattr(inode, &saved_copy);
- sbi = inode->i_sb->u.generic_sbp;
inode_setattr(inode, iattr);
- error = sbi->osi_ops->o_setattr(sbi->osi_conn_info.conn_id,
- inode->i_ino, inode);
+ error = IOPS(inode, setattr)(IID(inode), inode->i_ino, inode);
if ( error ) {
inode_setattr(inode, &saved_copy);
printk("obdfs_notify_change: obd_setattr fails (%d)\n", error);
int bufsize)
{
struct statfs tmp;
- struct obdfs_sb_info * sbi;
int error;
ENTRY;
- sbi = sb->u.generic_sbp;
- error = sbi->osi_ops->o_statfs(sbi->osi_conn_info.conn_id, &tmp);
+ error = OPS(sb,statfs)(ID(sb), &tmp);
if ( error ) {
printk("obdfs_notify_change: obd_statfs fails (%d)\n", error);
return error;
obdfs_sysctl_init();
- obd_sbi = &obdfs_super_info;
- obd_fso = &obdfs_file_ops;
-
return register_filesystem(&obdfs_fs_type);
}
obdfs_sysctl_clean();
unregister_filesystem(&obdfs_fs_type);
}
-void obdfs_psdev_dec_use_count(void)
-{
- MOD_DEC_USE_COUNT;
-}
-
-EXPORT_SYMBOL(obdfs_psdev_dec_use_count);
#endif
--- /dev/null
+#!/bin/sh
+
+rm -f TAGS ; find . -name '*.h' -or -name '*.c' | xargs etags
git://git.whamcloud.com / fs / lustre-release.git / commitdiff