osdfs

154 lines not on this page · raw message

316 lines not on this page · raw message

180 lines not on this page · raw message

58 lines not on this page · raw message

140 lines not on this page · raw message

index 30472b7..ea20411 100644
@@ -177,4 +177,15 @@ int extract_list_from_req(struct osd_request *req,
 
 void free_osd_req(struct osd_request *req);
 
+/* inode.c               */
+void osdfs_truncate(struct inode *inode);
+int osdfs_setattr(struct dentry *, struct iattr *);
+
+/*********************
+ * operation vectors *
+ *********************/
+/* file.c            */
+extern struct inode_operations osdfs_file_inode_operations;
+extern struct file_operations osdfs_file_operations;
+
 #endif

index ea20411..7610ce3 100644
@@ -188,4 +188,8 @@ int osdfs_setattr(struct dentry *, struct iattr *);
 extern struct inode_operations osdfs_file_inode_operations;
 extern struct file_operations osdfs_file_operations;
 
+/* symlink.c         */
+extern struct inode_operations osdfs_symlink_inode_operations;
+extern struct inode_operations osdfs_fast_symlink_inode_operations;
+
 #endif

54 lines not on this page · raw message

index e009eb0..bfd82b1 100644
@@ -60,6 +60,290 @@ int osdfs_get_block(struct inode *inode, sector_t iblock,
 	return 0;
 }
 
+/*
+ * Callback function when writepage finishes.  Check for errors, unlock, clean
+ * up, etc.
+ */
+void writepage_done(struct osd_request *req, void *p)
+{
+	int ret;
+	struct page *page = (struct page *)p;
+	struct inode *inode = page->mapping->host;
+	struct osdfs_sb_info *sbi = inode->i_sb->s_fs_info;
+
+	ret = check_ok(req);
+	free_osd_req(req);
+	atomic_dec(&sbi->s_curr_pending);
+
+	if (ret) {
+		if (ret == -ENOSPC)
+			set_bit(AS_ENOSPC, &page->mapping->flags);
+		else
+			set_bit(AS_EIO, &page->mapping->flags);
+
+		SetPageError(page);
+	}
+
+	end_page_writeback(page);
+	unlock_page(page);
+}
+
+/*
+ * Write a page to disk.  page->index gives us the page number.  The page is
+ * locked before this function is called.  We write asynchronously and then the
+ * callback function (writepage_done) is called.  We signify that the operation
+ * has completed by unlocking the page and calling end_page_writeback().
+ */
+static int osdfs_writepage(struct page *page, struct writeback_control *wbc)
+{
+	struct inode *inode = page->mapping->host;
+	struct osdfs_i_info *oi = OSDFS_I(inode);
+	loff_t i_size = i_size_read(inode);
+	unsigned long end_index = i_size >> PAGE_CACHE_SHIFT;
+	unsigned offset = 0;
+	struct osd_request *req = NULL;
+	struct osdfs_sb_info *sbi;
+	uint64_t start;
+	uint64_t len = PAGE_CACHE_SIZE;
+	unsigned char *kaddr;
+	int ret = 0;
+
+	if (!PageLocked(page))
+		BUG();
+
+	/* if the object has not been created, and we are not in sync mode,
+	 * just return.  otherwise, wait. */
+	if (!ObjCreated(oi)) {
+		if (!Obj2BCreated(oi))
+			BUG();
+
+		if (wbc->sync_mode == WB_SYNC_NONE) {
+			redirty_page_for_writepage(wbc, page);
+			unlock_page(page);
+			ret = 0;
+			goto out;
+		} else {
+			wait_event(oi->i_wq, ObjCreated(oi));
+		}
+	}
+
+	/* in this case, the page is within the limits of the file */
+	if (page->index < end_index)
+		goto do_it;
+
+	offset = i_size & (PAGE_CACHE_SIZE - 1);
+	len = offset;
+
+	/*in this case, the page is outside the limits (truncate in progress)*/
+	if (page->index >= end_index + 1 || !offset) {
+		unlock_page(page);
+		goto out;
+	}
+
+	/* otherwise, the page straddles i_size.  It must be zeroed out. */
+	kaddr = kmap_atomic(page, KM_USER0);
+	memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
+	flush_dcache_page(page);
+	kunmap_atomic(page, KM_USER0);
+
+do_it:
+	BUG_ON(PageWriteback(page));
+	set_page_writeback(page);
+	start = page->index << PAGE_CACHE_SHIFT;
+	sbi = inode->i_sb->s_fs_info;
+
+	kaddr = page_address(page);
+
+	req = prepare_osd_write(sbi->s_dev, sbi->s_pid,
+			      inode->i_ino + OSDFS_OBJ_OFF, len, start, 0,
+			      kaddr);
+	if (!req) {
+		printk(KERN_ERR "ERROR: writepage failed.\n");
+		ret = -ENOMEM;
+		goto fail;
+	}
+
+	ret = osdfs_async_op(req, writepage_done, (void *)page, oi->i_cred);
+	if (ret) {
+		free_osd_req(req);
+		goto fail;
+	}
+	atomic_inc(&sbi->s_curr_pending);
+out:
+	return ret;
+fail:
+	set_bit(AS_EIO, &page->mapping->flags);
+	end_page_writeback(page);
+	unlock_page(page);
+	goto out;
+}
+
+/*
+ * Callback for readpage
+ */
+void readpage_done(struct osd_request *req, void *p)
+{
+	struct page *page = (struct page *)p;
+	struct inode *inode = page->mapping->host;
+	struct osdfs_sb_info *sbi = inode->i_sb->s_fs_info;
+	char *kaddr;
+	int ret;
+
+	ret = check_ok(req);
+	free_osd_req(req);
+	atomic_dec(&sbi->s_curr_pending);
+
+	if (ret == -EFAULT) {
+
+		/* In this case we were trying to read something that wasn't on
+		 * disk yet - return a page full of zeroes.  This should be OK,
+		 * because the object should be empty (if there was a write
+		 * before this read, the read would be waiting with the page
+		 * locked */
+		kaddr = page_address(page);
+		memset(kaddr, 0, PAGE_CACHE_SIZE);
+
+		SetPageUptodate(page);
+		if (PageError(page))
+			ClearPageError(page);
+	} else if (ret == 0) {
+
+		/* Everything is OK */
+		SetPageUptodate(page);
+		if (PageError(page))
+			ClearPageError(page);
+	} else {
+
+		/* Error */
+		SetPageError(page);
+	}
+
+	unlock_page(page);
+}
+
+/*
+ * Read a page from the OSD
+ */
+static int readpage_filler(struct page *page)
+{
+	struct osd_request *req = NULL;
+	struct inode *inode = page->mapping->host;
+	struct osdfs_i_info *oi = OSDFS_I(inode);
+	ino_t ino = inode->i_ino;
+	loff_t i_size = i_size_read(inode);
+	unsigned long end_index = i_size >> PAGE_CACHE_SHIFT;
+	struct super_block *sb = inode->i_sb;
+	struct osdfs_sb_info *sbi = sb->s_fs_info;
+	uint64_t amount;
+	unsigned char *kaddr;
+	int ret = 0;
+
+	if (!PageLocked(page))
+		BUG();
+
+	if (PageUptodate(page))
+		goto out;
+
+	/* we are before the last page */
+	if (page->index < end_index) {
+		amount = PAGE_CACHE_SIZE;
+		goto do_it;
+	}
+
+	amount = i_size & (PAGE_CACHE_SIZE - 1);
+
+	/* this will be out of bounds, or doesn't exist yet */
+	if ((page->index >= end_index + 1 || !amount) || (!ObjCreated(oi))) {
+		kaddr = kmap_atomic(page, KM_USER0);
+		memset(kaddr, 0, PAGE_CACHE_SIZE);
+		flush_dcache_page(page);
+		kunmap_atomic(page, KM_USER0);
+		SetPageUptodate(page);
+		if (PageError(page))
+			ClearPageError(page);
+		unlock_page(page);
+		goto out;
+	}
+
+do_it:
+	kaddr = page_address(page);
+
+	req = prepare_osd_read(sbi->s_dev, sbi->s_pid, ino + OSDFS_OBJ_OFF,
+			amount, (uint64_t)(page->index << PAGE_CACHE_SHIFT), 0,
+			kaddr);
+	if (!req) {
+		printk(KERN_ERR "ERROR: readpage failed.\n");
+		ret = -ENOMEM;
+		unlock_page(page);
+		goto out;
+	}
+
+	ret = osdfs_async_op(req, readpage_done, (void *)page, oi->i_cred);
+	if (ret) {
+		free_osd_req(req);
+		unlock_page(page);
+		goto out;
+	}
+	atomic_inc(&sbi->s_curr_pending);
+out:
+	return ret;
+}
+
+/*
+ * We don't need the file
+ */
+static int osdfs_readpage(struct file *file, struct page *page)
+{
+	return readpage_filler(page);
+}
+
+/*
+ * We don't need the data
+ */
+static int readpage_strip(void *data, struct page *page)
+{
+	return readpage_filler(page);
+}
+
+/*
+ * read a bunch of pages - usually for readahead
+ */
+static int osdfs_readpages(struct file *file, struct address_space *mapping,
+			   struct list_head *pages, unsigned nr_pages)
+{
+	return read_cache_pages(mapping, pages, readpage_strip, NULL);
+}
+
+/* This was borrowed from fs/libfs.c it used to be exported but now it
+ * is not. FIXME: Is this at all right?
+ */
+static int osdfs_simple_commit_write(struct file *file, struct page *page,
+			       unsigned from, unsigned to)
+{
+	struct inode *inode = page->mapping->host;
+	loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
+
+	if (!PageUptodate(page))
+		SetPageUptodate(page);
+	/*
+	 * No need to use i_size_read() here, the i_size
+	 * cannot change under us because we hold the i_mutex.
+	 */
+	if (pos > inode->i_size)
+		i_size_write(inode, pos);
+	set_page_dirty(page);
+	return 0;
+}
+
+struct address_space_operations osdfs_aops = {
+	.readpage		= osdfs_readpage,
+	.readpages		= osdfs_readpages,
+	.writepage		= osdfs_writepage,
+	.prepare_write		= simple_prepare_write,
+	.commit_write		= osdfs_simple_commit_write,
+	.writepages		= generic_writepages,
+};
+
 /******************************************************************************
  * INODE OPERATIONS
  *****************************************************************************/

index 7610ce3..29e7d7b 100644
@@ -188,6 +188,9 @@ int osdfs_setattr(struct dentry *, struct iattr *);
 extern struct inode_operations osdfs_file_inode_operations;
 extern struct file_operations osdfs_file_operations;
 
+/* inode.c           */
+extern struct address_space_operations osdfs_aops;
+
 /* symlink.c         */
 extern struct inode_operations osdfs_symlink_inode_operations;
 extern struct inode_operations osdfs_fast_symlink_inode_operations;

629 lines not on this page · raw message

276 lines not on this page · raw message

348 lines not on this page · raw message

index 29e7d7b..00c89f7 100644
@@ -106,6 +106,11 @@ static inline struct osdfs_i_info *OSDFS_I(struct inode *inode)
 	return container_of(inode, struct osdfs_i_info, vfs_inode);
 }
 
+/*
+ * Maximum count of links to a file
+ */
+#define OSDFS_LINK_MAX           32000
+
 /*************************
  * function declarations *
  *************************/

@@ -179,11 +184,28 @@ void free_osd_req(struct osd_request *req);
 
 /* inode.c               */
 void osdfs_truncate(struct inode *inode);
+extern struct inode *osdfs_iget(struct super_block *, unsigned long);
+struct inode *osdfs_new_inode(struct inode *, int);
 int osdfs_setattr(struct dentry *, struct iattr *);
 
+/* dir.c:                */
+int osdfs_add_link(struct dentry *, struct inode *);
+ino_t osdfs_inode_by_name(struct inode *, struct dentry *);
+int osdfs_delete_entry(struct osdfs_dir_entry *, struct page *);
+int osdfs_make_empty(struct inode *, struct inode *);
+struct osdfs_dir_entry *osdfs_find_entry(struct inode *, struct dentry *,
+					 struct page **);
+int osdfs_empty_dir(struct inode *);
+struct osdfs_dir_entry *osdfs_dotdot(struct inode *, struct page **);
+void osdfs_set_link(struct inode *, struct osdfs_dir_entry *, struct page *,
+		    struct inode *);
+
 /*********************
  * operation vectors *
  *********************/
+/* dir.c:            */
+extern struct file_operations osdfs_dir_operations;
+
 /* file.c            */
 extern struct inode_operations osdfs_file_inode_operations;
 extern struct file_operations osdfs_file_operations;

@@ -191,6 +213,10 @@ extern struct file_operations osdfs_file_operations;
 /* inode.c           */
 extern struct address_space_operations osdfs_aops;
 
+/* namei.c           */
+extern struct inode_operations osdfs_dir_inode_operations;
+extern struct inode_operations osdfs_special_inode_operations;
+
 /* symlink.c         */
 extern struct inode_operations osdfs_symlink_inode_operations;
 extern struct inode_operations osdfs_fast_symlink_inode_operations;

227 lines not on this page · raw message

index 00c89f7..af8b998 100644
@@ -49,6 +49,17 @@
 #endif
 
 /*
+ * struct to hold what we get from mount options
+ */
+struct osdfs_mountopt {
+	const char *dev_name;
+	uint64_t pid;
+	int timeout;
+	bool mkfs;
+	int format; /*in Mbyte*/
+};
+
+/*
  * our extension to the in-memory superblock
  */
 struct osdfs_sb_info {

@@ -107,6 +118,14 @@ static inline struct osdfs_i_info *OSDFS_I(struct inode *inode)
 }
 
 /*
+ * ugly struct so that we can pass two arguments to update_inode's callback
+ */
+struct updatei_args {
+	struct osdfs_sb_info	*sbi;
+	struct osdfs_fcb	*fcb;
+};
+
+/*
  * Maximum count of links to a file
  */
 #define OSDFS_LINK_MAX           32000

@@ -185,9 +204,17 @@ void free_osd_req(struct osd_request *req);
 /* inode.c               */
 void osdfs_truncate(struct inode *inode);
 extern struct inode *osdfs_iget(struct super_block *, unsigned long);
+extern int osdfs_write_inode(struct inode *, int);
+extern void osdfs_delete_inode(struct inode *);
 struct inode *osdfs_new_inode(struct inode *, int);
 int osdfs_setattr(struct dentry *, struct iattr *);
 
+/* super.c:              */
+#ifdef OSDFS_DEBUG
+void osdfs_dprint_internal(char *str, ...);
+#endif
+extern void osdfs_write_super(struct super_block *);
+
 /* dir.c:                */
 int osdfs_add_link(struct dentry *, struct inode *);
 ino_t osdfs_inode_by_name(struct inode *, struct dentry *);

@@ -217,6 +244,9 @@ extern struct address_space_operations osdfs_aops;
 extern struct inode_operations osdfs_dir_inode_operations;
 extern struct inode_operations osdfs_special_inode_operations;
 
+/* super.c           */
+extern struct super_operations osdfs_sops;
+
 /* symlink.c         */
 extern struct inode_operations osdfs_symlink_inode_operations;
 extern struct inode_operations osdfs_fast_symlink_inode_operations;

502 lines not on this page · raw message

605 lines not on this page · raw message

index af8b998..5dd36c7 100644
@@ -201,6 +201,9 @@ int extract_list_from_req(struct osd_request *req,
 
 void free_osd_req(struct osd_request *req);
 
+/* mkosdfs.c             */
+int osdfs_mkfs(struct osd_dev *dev, uint64_t p_id, uint64_t format_size);
+
 /* inode.c               */
 void osdfs_truncate(struct inode *inode);
 extern struct inode *osdfs_iget(struct super_block *, unsigned long);

index 095b960..3f70e78 100644
@@ -55,6 +55,8 @@ enum { Opt_lun, Opt_tid, Opt_pid, Opt_to, Opt_mkfs, Opt_format, Opt_err };
 static match_table_t tokens = {
 	{Opt_pid, "pid=%u"},
 	{Opt_to, "to=%u"},
+	{Opt_mkfs, "mkfs=%u"},
+	{Opt_format, "format=%u"},
 	{Opt_err, NULL}
 };
 

@@ -100,6 +102,16 @@ static int parse_options(char *options, struct osdfs_mountopt *opts)
 			}
 			opts->timeout = option;
 			break;
+		case Opt_mkfs:
+			if (match_int(&args[0], &option))
+				return -EINVAL;
+			opts->mkfs = option != 0;
+			break;
+		case Opt_format:
+			if (match_int(&args[0], &option))
+				return -EINVAL;
+			opts->format = option;
+			break;
 		}
 	}
 

@@ -277,6 +289,12 @@ static int osdfs_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_bdev = NULL;
 	sb->s_dev = 0;
 
+	/* see if we need to make the file system on the obsd */
+	if (opts->mkfs) {
+		OSDFS_DBGMSG("osdfs_mkfs %p\n", sbi->s_dev);
+		osdfs_mkfs(sbi->s_dev, sbi->s_pid, opts->format);
+	}
+
 	/* read data from on-disk superblock object */
 	make_credential(sbi->s_cred, sbi->s_pid, OSDFS_SUPER_ID);