2008-10-27 09:27:55 -07:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2005, 2006
|
2009-06-14 07:23:09 -07:00
|
|
|
* Avishay Traeger (avishay@gmail.com)
|
2008-10-27 09:27:55 -07:00
|
|
|
* Copyright (C) 2008, 2009
|
|
|
|
|
* Boaz Harrosh <bharrosh@panasas.com>
|
|
|
|
|
*
|
|
|
|
|
* Copyrights for code taken from ext2:
|
|
|
|
|
* Copyright (C) 1992, 1993, 1994, 1995
|
|
|
|
|
* Remy Card (card@masi.ibp.fr)
|
|
|
|
|
* Laboratoire MASI - Institut Blaise Pascal
|
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
|
* from
|
|
|
|
|
* linux/fs/minix/inode.c
|
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
|
*
|
|
|
|
|
* This file is part of exofs.
|
|
|
|
|
*
|
|
|
|
|
* exofs is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
|
* the Free Software Foundation. Since it is based on ext2, and the only
|
|
|
|
|
* valid version of GPL for the Linux kernel is version 2, the only valid
|
|
|
|
|
* version of GPL for exofs is version 2.
|
|
|
|
|
*
|
|
|
|
|
* exofs is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with exofs; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
|
*/
|
exofs: Move all operations to an io_engine
In anticipation for multi-device operations, we separate osd operations
into an abstract I/O API. Currently only one device is used but later
when adding more devices, we will drive all devices in parallel according
to a "data_map" that describes how data is arranged on multiple devices.
The file system level operates, like before, as if there is one object
(inode-number) and an i_size. The io engine will split this to the same
object-number but on multiple device.
At first we introduce Mirror (raid 1) layout. But at the final outcome
we intend to fully implement the pNFS-Objects data-map, including
raid 0,4,5,6 over mirrored devices, over multiple device-groups. And
more. See: http://tools.ietf.org/html/draft-ietf-nfsv4-pnfs-obj-12
* Define an io_state based API for accessing osd storage devices
in an abstract way.
Usage:
First a caller allocates an io state with:
exofs_get_io_state(struct exofs_sb_info *sbi,
struct exofs_io_state** ios);
Then calles one of:
exofs_sbi_create(struct exofs_io_state *ios);
exofs_sbi_remove(struct exofs_io_state *ios);
exofs_sbi_write(struct exofs_io_state *ios);
exofs_sbi_read(struct exofs_io_state *ios);
exofs_oi_truncate(struct exofs_i_info *oi, u64 new_len);
And when done
exofs_put_io_state(struct exofs_io_state *ios);
* Convert all source files to use this new API
* Convert from bio_alloc to bio_kmalloc
* In io engine we make use of the now fixed osd_req_decode_sense
There are no functional changes or on disk additions after this patch.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2009-11-08 05:54:08 -07:00
|
|
|
#ifndef __EXOFS_H__
|
|
|
|
|
#define __EXOFS_H__
|
2008-10-27 09:27:55 -07:00
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/time.h>
|
2010-04-22 03:26:04 -07:00
|
|
|
#include <linux/backing-dev.h>
|
2011-08-06 19:26:31 -07:00
|
|
|
#include <scsi/osd_ore.h>
|
|
|
|
|
|
2008-10-27 09:27:55 -07:00
|
|
|
#include "common.h"
|
|
|
|
|
|
|
|
|
|
#define EXOFS_ERR(fmt, a...) printk(KERN_ERR "exofs: " fmt, ##a)
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_EXOFS_DEBUG
|
|
|
|
|
#define EXOFS_DBGMSG(fmt, a...) \
|
|
|
|
|
printk(KERN_NOTICE "exofs @%s:%d: " fmt, __func__, __LINE__, ##a)
|
|
|
|
|
#else
|
|
|
|
|
#define EXOFS_DBGMSG(fmt, a...) \
|
|
|
|
|
do { if (0) printk(fmt, ##a); } while (0)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* u64 has problems with printk this will cast it to unsigned long long */
|
|
|
|
|
#define _LLU(x) (unsigned long long)(x)
|
|
|
|
|
|
2011-09-28 04:43:09 -07:00
|
|
|
struct exofs_dev {
|
|
|
|
|
struct ore_dev ored;
|
|
|
|
|
unsigned did;
|
2012-03-14 18:01:45 -07:00
|
|
|
unsigned urilen;
|
|
|
|
|
uint8_t *uri;
|
|
|
|
|
struct kobject ed_kobj;
|
2011-09-28 04:43:09 -07:00
|
|
|
};
|
2008-10-27 09:27:55 -07:00
|
|
|
/*
|
|
|
|
|
* our extension to the in-memory superblock
|
|
|
|
|
*/
|
|
|
|
|
struct exofs_sb_info {
|
2011-07-27 17:51:53 -07:00
|
|
|
struct backing_dev_info bdi; /* register our bdi with VFS */
|
2011-02-03 08:53:25 -07:00
|
|
|
struct exofs_sb_stats s_ess; /* Written often, pre-allocate*/
|
2008-10-27 09:27:55 -07:00
|
|
|
int s_timeout; /* timeout for OSD operations */
|
|
|
|
|
uint64_t s_nextid; /* highest object ID used */
|
|
|
|
|
uint32_t s_numfiles; /* number of files on fs */
|
|
|
|
|
spinlock_t s_next_gen_lock; /* spinlock for gen # update */
|
|
|
|
|
u32 s_next_generation; /* next gen # to use */
|
|
|
|
|
atomic_t s_curr_pending; /* number of pending commands */
|
exofs: Multi-device mirror support
This patch changes on-disk format, it is accompanied with a parallel
patch to mkfs.exofs that enables multi-device capabilities.
After this patch, old exofs will refuse to mount a new formatted FS and
new exofs will refuse an old format. This is done by moving the magic
field offset inside the FSCB. A new FSCB *version* field was added. In
the future, exofs will refuse to mount unmatched FSCB version. To
up-grade or down-grade an exofs one must use mkfs.exofs --upgrade option
before mounting.
Introduced, a new object that contains a *device-table*. This object
contains the default *data-map* and a linear array of devices
information, which identifies the devices used in the filesystem. This
object is only written to offline by mkfs.exofs. This is why it is kept
separate from the FSCB, since the later is written to while mounted.
Same partition number, same object number is used on all devices only
the device varies.
* define the new format, then load the device table on mount time make
sure every thing is supported.
* Change I/O engine to now support Mirror IO, .i.e write same data
to multiple devices, read from a random device to spread the
read-load from multiple clients (TODO: stripe read)
Implementation notes:
A few points introduced in previous patch should be mentioned here:
* Special care was made so absolutlly all operation that have any chance
of failing are done before any osd-request is executed. This is to
minimize the need for a data consistency recovery, to only real IO
errors.
* Each IO state has a kref. It starts at 1, any osd-request executed
will increment the kref, finally when all are executed the first ref
is dropped. At IO-done, each request completion decrements the kref,
the last one to return executes the internal _last_io() routine.
_last_io() will call the registered io_state_done. On sync mode a
caller does not supply a done method, indicating a synchronous
request, the caller is put to sleep and a special io_state_done is
registered that will awaken the caller. Though also in sync mode all
operations are executed in parallel.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2009-11-16 07:03:05 -07:00
|
|
|
|
2011-08-06 19:26:31 -07:00
|
|
|
struct ore_layout layout; /* Default files layout */
|
|
|
|
|
struct ore_comp one_comp; /* id & cred of partition id=0*/
|
2011-09-28 01:39:59 -07:00
|
|
|
struct ore_components oc; /* comps for the partition */
|
2012-03-14 18:01:45 -07:00
|
|
|
struct kobject s_kobj; /* holds per-sbi kobject */
|
2008-10-27 09:27:55 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* our extension to the in-memory inode
|
|
|
|
|
*/
|
|
|
|
|
struct exofs_i_info {
|
2010-01-21 11:00:02 -07:00
|
|
|
struct inode vfs_inode; /* normal in-memory inode */
|
|
|
|
|
wait_queue_head_t i_wq; /* wait queue for inode */
|
2008-10-27 09:27:55 -07:00
|
|
|
unsigned long i_flags; /* various atomic flags */
|
|
|
|
|
uint32_t i_data[EXOFS_IDATA];/*short symlink names and device #s*/
|
|
|
|
|
uint32_t i_dir_start_lookup; /* which page to start lookup */
|
|
|
|
|
uint64_t i_commit_size; /* the object's written length */
|
2011-08-06 19:26:31 -07:00
|
|
|
struct ore_comp one_comp; /* same component for all devices */
|
2011-09-28 01:39:59 -07:00
|
|
|
struct ore_components oc; /* inode view of the device table */
|
2008-10-27 09:27:55 -07:00
|
|
|
};
|
|
|
|
|
|
exofs: Move all operations to an io_engine
In anticipation for multi-device operations, we separate osd operations
into an abstract I/O API. Currently only one device is used but later
when adding more devices, we will drive all devices in parallel according
to a "data_map" that describes how data is arranged on multiple devices.
The file system level operates, like before, as if there is one object
(inode-number) and an i_size. The io engine will split this to the same
object-number but on multiple device.
At first we introduce Mirror (raid 1) layout. But at the final outcome
we intend to fully implement the pNFS-Objects data-map, including
raid 0,4,5,6 over mirrored devices, over multiple device-groups. And
more. See: http://tools.ietf.org/html/draft-ietf-nfsv4-pnfs-obj-12
* Define an io_state based API for accessing osd storage devices
in an abstract way.
Usage:
First a caller allocates an io state with:
exofs_get_io_state(struct exofs_sb_info *sbi,
struct exofs_io_state** ios);
Then calles one of:
exofs_sbi_create(struct exofs_io_state *ios);
exofs_sbi_remove(struct exofs_io_state *ios);
exofs_sbi_write(struct exofs_io_state *ios);
exofs_sbi_read(struct exofs_io_state *ios);
exofs_oi_truncate(struct exofs_i_info *oi, u64 new_len);
And when done
exofs_put_io_state(struct exofs_io_state *ios);
* Convert all source files to use this new API
* Convert from bio_alloc to bio_kmalloc
* In io engine we make use of the now fixed osd_req_decode_sense
There are no functional changes or on disk additions after this patch.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2009-11-08 05:54:08 -07:00
|
|
|
static inline osd_id exofs_oi_objno(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
return oi->vfs_inode.i_ino + EXOFS_OBJ_OFF;
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-27 09:27:55 -07:00
|
|
|
/*
|
|
|
|
|
* our inode flags
|
|
|
|
|
*/
|
|
|
|
|
#define OBJ_2BCREATED 0 /* object will be created soon*/
|
|
|
|
|
#define OBJ_CREATED 1 /* object has been created on the osd*/
|
|
|
|
|
|
|
|
|
|
static inline int obj_2bcreated(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(OBJ_2BCREATED, &oi->i_flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_obj_2bcreated(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
set_bit(OBJ_2BCREATED, &oi->i_flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int obj_created(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
return test_bit(OBJ_CREATED, &oi->i_flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void set_obj_created(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
set_bit(OBJ_CREATED, &oi->i_flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int __exofs_wait_obj_created(struct exofs_i_info *oi);
|
|
|
|
|
static inline int wait_obj_created(struct exofs_i_info *oi)
|
|
|
|
|
{
|
|
|
|
|
if (likely(obj_created(oi)))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return __exofs_wait_obj_created(oi);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* get to our inode from the vfs inode
|
|
|
|
|
*/
|
|
|
|
|
static inline struct exofs_i_info *exofs_i(struct inode *inode)
|
|
|
|
|
{
|
|
|
|
|
return container_of(inode, struct exofs_i_info, vfs_inode);
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-28 06:38:12 -07:00
|
|
|
/*
|
|
|
|
|
* Maximum count of links to a file
|
|
|
|
|
*/
|
|
|
|
|
#define EXOFS_LINK_MAX 32000
|
|
|
|
|
|
2008-10-27 09:37:02 -07:00
|
|
|
/*************************
|
|
|
|
|
* function declarations *
|
|
|
|
|
*************************/
|
exofs: Move all operations to an io_engine
In anticipation for multi-device operations, we separate osd operations
into an abstract I/O API. Currently only one device is used but later
when adding more devices, we will drive all devices in parallel according
to a "data_map" that describes how data is arranged on multiple devices.
The file system level operates, like before, as if there is one object
(inode-number) and an i_size. The io engine will split this to the same
object-number but on multiple device.
At first we introduce Mirror (raid 1) layout. But at the final outcome
we intend to fully implement the pNFS-Objects data-map, including
raid 0,4,5,6 over mirrored devices, over multiple device-groups. And
more. See: http://tools.ietf.org/html/draft-ietf-nfsv4-pnfs-obj-12
* Define an io_state based API for accessing osd storage devices
in an abstract way.
Usage:
First a caller allocates an io state with:
exofs_get_io_state(struct exofs_sb_info *sbi,
struct exofs_io_state** ios);
Then calles one of:
exofs_sbi_create(struct exofs_io_state *ios);
exofs_sbi_remove(struct exofs_io_state *ios);
exofs_sbi_write(struct exofs_io_state *ios);
exofs_sbi_read(struct exofs_io_state *ios);
exofs_oi_truncate(struct exofs_i_info *oi, u64 new_len);
And when done
exofs_put_io_state(struct exofs_io_state *ios);
* Convert all source files to use this new API
* Convert from bio_alloc to bio_kmalloc
* In io engine we make use of the now fixed osd_req_decode_sense
There are no functional changes or on disk additions after this patch.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2009-11-08 05:54:08 -07:00
|
|
|
|
2008-10-27 09:37:02 -07:00
|
|
|
/* inode.c */
|
2011-08-06 19:26:31 -07:00
|
|
|
unsigned exofs_max_io_pages(struct ore_layout *layout,
|
2010-10-07 11:28:18 -07:00
|
|
|
unsigned expected_pages);
|
2008-10-27 09:37:02 -07:00
|
|
|
int exofs_setattr(struct dentry *, struct iattr *);
|
2008-10-27 10:31:34 -07:00
|
|
|
int exofs_write_begin(struct file *file, struct address_space *mapping,
|
|
|
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
|
|
|
struct page **pagep, void **fsdata);
|
2008-10-28 06:38:12 -07:00
|
|
|
extern struct inode *exofs_iget(struct super_block *, unsigned long);
|
2011-07-26 00:07:49 -07:00
|
|
|
struct inode *exofs_new_inode(struct inode *, umode_t);
|
2010-03-05 01:21:37 -07:00
|
|
|
extern int exofs_write_inode(struct inode *, struct writeback_control *wbc);
|
2010-06-07 08:42:26 -07:00
|
|
|
extern void exofs_evict_inode(struct inode *);
|
2008-10-28 06:38:12 -07:00
|
|
|
|
|
|
|
|
/* dir.c: */
|
|
|
|
|
int exofs_add_link(struct dentry *, struct inode *);
|
|
|
|
|
ino_t exofs_inode_by_name(struct inode *, struct dentry *);
|
|
|
|
|
int exofs_delete_entry(struct exofs_dir_entry *, struct page *);
|
|
|
|
|
int exofs_make_empty(struct inode *, struct inode *);
|
|
|
|
|
struct exofs_dir_entry *exofs_find_entry(struct inode *, struct dentry *,
|
|
|
|
|
struct page **);
|
|
|
|
|
int exofs_empty_dir(struct inode *);
|
|
|
|
|
struct exofs_dir_entry *exofs_dotdot(struct inode *, struct page **);
|
2009-03-22 03:47:26 -07:00
|
|
|
ino_t exofs_parent_ino(struct dentry *child);
|
2008-10-28 06:38:12 -07:00
|
|
|
int exofs_set_link(struct inode *, struct exofs_dir_entry *, struct page *,
|
|
|
|
|
struct inode *);
|
2008-10-27 09:37:02 -07:00
|
|
|
|
2009-06-14 06:52:10 -07:00
|
|
|
/* super.c */
|
2011-05-16 05:26:47 -07:00
|
|
|
void exofs_make_credential(u8 cred_a[OSD_CAP_LEN],
|
|
|
|
|
const struct osd_obj_id *obj);
|
2011-02-03 08:53:25 -07:00
|
|
|
int exofs_sbi_write_stats(struct exofs_sb_info *sbi);
|
2009-06-14 06:52:10 -07:00
|
|
|
|
2012-03-14 18:01:45 -07:00
|
|
|
/* sys.c */
|
|
|
|
|
int exofs_sysfs_init(void);
|
|
|
|
|
void exofs_sysfs_uninit(void);
|
|
|
|
|
int exofs_sysfs_sb_add(struct exofs_sb_info *sbi,
|
|
|
|
|
struct exofs_dt_device_info *dt_dev);
|
|
|
|
|
void exofs_sysfs_sb_del(struct exofs_sb_info *sbi);
|
|
|
|
|
int exofs_sysfs_odev_add(struct exofs_dev *edev,
|
|
|
|
|
struct exofs_sb_info *sbi);
|
|
|
|
|
void exofs_sysfs_dbg_print(void);
|
|
|
|
|
|
2008-10-27 09:37:02 -07:00
|
|
|
/*********************
|
|
|
|
|
* operation vectors *
|
|
|
|
|
*********************/
|
2008-10-28 06:38:12 -07:00
|
|
|
/* dir.c: */
|
|
|
|
|
extern const struct file_operations exofs_dir_operations;
|
|
|
|
|
|
2008-10-27 09:37:02 -07:00
|
|
|
/* file.c */
|
|
|
|
|
extern const struct inode_operations exofs_file_inode_operations;
|
|
|
|
|
extern const struct file_operations exofs_file_operations;
|
|
|
|
|
|
2008-10-27 10:31:34 -07:00
|
|
|
/* inode.c */
|
|
|
|
|
extern const struct address_space_operations exofs_aops;
|
|
|
|
|
|
2008-10-28 06:38:12 -07:00
|
|
|
/* namei.c */
|
|
|
|
|
extern const struct inode_operations exofs_dir_inode_operations;
|
|
|
|
|
extern const struct inode_operations exofs_special_inode_operations;
|
|
|
|
|
|
2008-10-27 10:04:34 -07:00
|
|
|
/* symlink.c */
|
|
|
|
|
extern const struct inode_operations exofs_symlink_inode_operations;
|
|
|
|
|
extern const struct inode_operations exofs_fast_symlink_inode_operations;
|
|
|
|
|
|
2011-08-06 19:26:31 -07:00
|
|
|
/* exofs_init_comps will initialize an ore_components device array
|
|
|
|
|
* pointing to a single ore_comp struct, and a round-robin view
|
exofs: ios: Move to a per inode components & device-table
Exofs raid engine was saving on memory space by having a single layout-info,
single pid, and a single device-table, global to the filesystem. Then passing
a credential and object_id info at the io_state level, private for each
inode. It would also devise this contraption of rotating the device table
view for each inode->ino to spread out the device usage.
This is not compatible with the pnfs-objects standard, demanding that
each inode can have it's own layout-info, device-table, and each object
component it's own pid, oid and creds.
So: Bring exofs raid engine to be usable for generic pnfs-objects use by:
* Define an exofs_comp structure that holds obj_id and credential info.
* Break up exofs_layout struct to an exofs_components structure that holds a
possible array of exofs_comp and the array of devices + the size of the
arrays.
* Add a "comps" parameter to get_io_state() that specifies the ids creds
and device array to use for each IO.
This enables to keep the layout global, but the device-table view, creds
and IDs at the inode level. It only adds two 64bit to each inode, since
some of these members already existed in another form.
* ios raid engine now access layout-info and comps-info through the passed
pointers. Everything is pre-prepared by caller for generic access of
these structures and arrays.
At the exofs Level:
* Super block holds an exofs_components struct that holds the device
array, previously in layout. The devices there are in device-table
order. The device-array is twice bigger and repeats the device-table
twice so now each inode's device array can point to a random device
and have a round-robin view of the table, making it compatible to
previous exofs versions.
* Each inode has an exofs_components struct that is initialized at
load time, with it's own view of the device table IDs and creds.
When doing IO this gets passed to the io_state together with the
layout.
While preforming this change. Bugs where found where credentials with the
wrong IDs where used to access the different SB objects (super.c). As well
as some dead code. It was never noticed because the target we use does not
check the credentials.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2011-08-05 15:06:04 -07:00
|
|
|
* of the device table.
|
|
|
|
|
* The first device of each inode is the [inode->ino % num_devices]
|
|
|
|
|
* and the rest of the devices sequentially following where the
|
|
|
|
|
* first device is after the last device.
|
|
|
|
|
* It is assumed that the global device array at @sbi is twice
|
|
|
|
|
* bigger and that the device table repeats twice.
|
|
|
|
|
* See: exofs_read_lookup_dev_table()
|
|
|
|
|
*/
|
2011-09-28 01:39:59 -07:00
|
|
|
static inline void exofs_init_comps(struct ore_components *oc,
|
2011-08-06 19:26:31 -07:00
|
|
|
struct ore_comp *one_comp,
|
exofs: ios: Move to a per inode components & device-table
Exofs raid engine was saving on memory space by having a single layout-info,
single pid, and a single device-table, global to the filesystem. Then passing
a credential and object_id info at the io_state level, private for each
inode. It would also devise this contraption of rotating the device table
view for each inode->ino to spread out the device usage.
This is not compatible with the pnfs-objects standard, demanding that
each inode can have it's own layout-info, device-table, and each object
component it's own pid, oid and creds.
So: Bring exofs raid engine to be usable for generic pnfs-objects use by:
* Define an exofs_comp structure that holds obj_id and credential info.
* Break up exofs_layout struct to an exofs_components structure that holds a
possible array of exofs_comp and the array of devices + the size of the
arrays.
* Add a "comps" parameter to get_io_state() that specifies the ids creds
and device array to use for each IO.
This enables to keep the layout global, but the device-table view, creds
and IDs at the inode level. It only adds two 64bit to each inode, since
some of these members already existed in another form.
* ios raid engine now access layout-info and comps-info through the passed
pointers. Everything is pre-prepared by caller for generic access of
these structures and arrays.
At the exofs Level:
* Super block holds an exofs_components struct that holds the device
array, previously in layout. The devices there are in device-table
order. The device-array is twice bigger and repeats the device-table
twice so now each inode's device array can point to a random device
and have a round-robin view of the table, making it compatible to
previous exofs versions.
* Each inode has an exofs_components struct that is initialized at
load time, with it's own view of the device table IDs and creds.
When doing IO this gets passed to the io_state together with the
layout.
While preforming this change. Bugs where found where credentials with the
wrong IDs where used to access the different SB objects (super.c). As well
as some dead code. It was never noticed because the target we use does not
check the credentials.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2011-08-05 15:06:04 -07:00
|
|
|
struct exofs_sb_info *sbi, osd_id oid)
|
|
|
|
|
{
|
|
|
|
|
unsigned dev_mod = (unsigned)oid, first_dev;
|
|
|
|
|
|
|
|
|
|
one_comp->obj.partition = sbi->one_comp.obj.partition;
|
|
|
|
|
one_comp->obj.id = oid;
|
|
|
|
|
exofs_make_credential(one_comp->cred, &one_comp->obj);
|
|
|
|
|
|
2011-09-28 02:04:23 -07:00
|
|
|
oc->first_dev = 0;
|
2011-09-28 04:43:09 -07:00
|
|
|
oc->numdevs = sbi->layout.group_width * sbi->layout.mirrors_p1 *
|
|
|
|
|
sbi->layout.group_count;
|
2011-09-28 01:39:59 -07:00
|
|
|
oc->single_comp = EC_SINGLE_COMP;
|
|
|
|
|
oc->comps = one_comp;
|
exofs: ios: Move to a per inode components & device-table
Exofs raid engine was saving on memory space by having a single layout-info,
single pid, and a single device-table, global to the filesystem. Then passing
a credential and object_id info at the io_state level, private for each
inode. It would also devise this contraption of rotating the device table
view for each inode->ino to spread out the device usage.
This is not compatible with the pnfs-objects standard, demanding that
each inode can have it's own layout-info, device-table, and each object
component it's own pid, oid and creds.
So: Bring exofs raid engine to be usable for generic pnfs-objects use by:
* Define an exofs_comp structure that holds obj_id and credential info.
* Break up exofs_layout struct to an exofs_components structure that holds a
possible array of exofs_comp and the array of devices + the size of the
arrays.
* Add a "comps" parameter to get_io_state() that specifies the ids creds
and device array to use for each IO.
This enables to keep the layout global, but the device-table view, creds
and IDs at the inode level. It only adds two 64bit to each inode, since
some of these members already existed in another form.
* ios raid engine now access layout-info and comps-info through the passed
pointers. Everything is pre-prepared by caller for generic access of
these structures and arrays.
At the exofs Level:
* Super block holds an exofs_components struct that holds the device
array, previously in layout. The devices there are in device-table
order. The device-array is twice bigger and repeats the device-table
twice so now each inode's device array can point to a random device
and have a round-robin view of the table, making it compatible to
previous exofs versions.
* Each inode has an exofs_components struct that is initialized at
load time, with it's own view of the device table IDs and creds.
When doing IO this gets passed to the io_state together with the
layout.
While preforming this change. Bugs where found where credentials with the
wrong IDs where used to access the different SB objects (super.c). As well
as some dead code. It was never noticed because the target we use does not
check the credentials.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2011-08-05 15:06:04 -07:00
|
|
|
|
|
|
|
|
/* Round robin device view of the table */
|
2011-09-28 01:39:59 -07:00
|
|
|
first_dev = (dev_mod * sbi->layout.mirrors_p1) % sbi->oc.numdevs;
|
2011-09-28 04:43:09 -07:00
|
|
|
oc->ods = &sbi->oc.ods[first_dev];
|
exofs: ios: Move to a per inode components & device-table
Exofs raid engine was saving on memory space by having a single layout-info,
single pid, and a single device-table, global to the filesystem. Then passing
a credential and object_id info at the io_state level, private for each
inode. It would also devise this contraption of rotating the device table
view for each inode->ino to spread out the device usage.
This is not compatible with the pnfs-objects standard, demanding that
each inode can have it's own layout-info, device-table, and each object
component it's own pid, oid and creds.
So: Bring exofs raid engine to be usable for generic pnfs-objects use by:
* Define an exofs_comp structure that holds obj_id and credential info.
* Break up exofs_layout struct to an exofs_components structure that holds a
possible array of exofs_comp and the array of devices + the size of the
arrays.
* Add a "comps" parameter to get_io_state() that specifies the ids creds
and device array to use for each IO.
This enables to keep the layout global, but the device-table view, creds
and IDs at the inode level. It only adds two 64bit to each inode, since
some of these members already existed in another form.
* ios raid engine now access layout-info and comps-info through the passed
pointers. Everything is pre-prepared by caller for generic access of
these structures and arrays.
At the exofs Level:
* Super block holds an exofs_components struct that holds the device
array, previously in layout. The devices there are in device-table
order. The device-array is twice bigger and repeats the device-table
twice so now each inode's device array can point to a random device
and have a round-robin view of the table, making it compatible to
previous exofs versions.
* Each inode has an exofs_components struct that is initialized at
load time, with it's own view of the device table IDs and creds.
When doing IO this gets passed to the io_state together with the
layout.
While preforming this change. Bugs where found where credentials with the
wrong IDs where used to access the different SB objects (super.c). As well
as some dead code. It was never noticed because the target we use does not
check the credentials.
Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
2011-08-05 15:06:04 -07:00
|
|
|
}
|
|
|
|
|
|
2008-10-27 09:27:55 -07:00
|
|
|
#endif
|