spin_unlock(&inode->i_lock);
/* now adjust page */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
spin_lock_irq(&mapping->tree_lock);
-#else
- write_lock_irq(&mapping->tree_lock);
-#endif
if (page->mapping) { /* Race with truncate? */
WARN_ON_ONCE(!PageUptodate(page));
undo = 1;
}
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
spin_unlock_irq(&mapping->tree_lock);
-#else
- write_unlock_irq(&mapping->tree_lock);
-#endif
if (undo)
ceph_put_wrbuffer_cap_refs(ci, 1, snapc);
SetPageUptodate(page);
unlock_page(page);
if (pagevec_add(&pvec, page) == 0)
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
pagevec_lru_add_file(&pvec); /* add to lru */
-#else
- pagevec_lru_add(&pvec); /* add to lru */
-#endif
}
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
pagevec_lru_add_file(&pvec);
-#else
- pagevec_lru_add(&pvec);
-#endif
rc = 0;
out:
dout(20, "? %p idx %lu\n", page, page->index);
if (locked_pages == 0)
lock_page(page); /* first page */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
else if (!trylock_page(page))
-#else
- else if (TestSetPageLocked(page))
-#endif
break;
/* only dirty pages, or our accounting breaks */
/* get a page*/
retry:
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
page = grab_cache_page_write_begin(mapping, index, 0);
-#else
- page = __grab_cache_page(mapping, index);
-#endif
if (!page)
return -ENOMEM;
*pagep = page;
end_in_page - pos_in_page != PAGE_CACHE_SIZE)) {
dout(20, " zeroing %p 0 - %d and %d - %d\n",
page, pos_in_page, end_in_page, (int)PAGE_CACHE_SIZE);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
zero_user_segments(page,
0, pos_in_page,
end_in_page, PAGE_CACHE_SIZE);
-#else
- simple_prepare_write(file, page, pos_in_page, end_in_page);
-#endif
return 0;
}
inode, page, (int)pos, (int)copied, (int)len);
/* zero the stale part of the page if we did a short copy */
- if (copied < len) {
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
+ if (copied < len)
zero_user_segment(page, from+copied, len);
-#else
- zero_user_page(page, from+copied, len-copied, KM_USER0);
-#endif
- }
/* did file size increase? */
/* (no need for i_size_read(); we caller holds i_mutex */
/*
* Reuse write_{begin,end} here for simplicity.
*/
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
static int ceph_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
-#else
-static int ceph_page_mkwrite(struct vm_area_struct *vma, struct page *page)
-#endif
{
struct inode *inode = vma->vm_file->f_dentry->d_inode;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
struct page *page = vmf->page;
struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc;
-#endif
loff_t off = page->index << PAGE_CACHE_SHIFT;
loff_t size, len;
struct page *locked_page = NULL;
ret = ceph_write_begin(vma->vm_file, inode->i_mapping, off, len, 0,
&locked_page, &fsdata);
WARN_ON(page != locked_page);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
if (!ret) {
/*
* doing the following, instead of calling
} else {
ret = VM_FAULT_SIGBUS;
}
-#else
- if (!ret)
- ceph_write_end(vma->vm_file, inode->i_mapping, off, len, len,
- locked_page, fsdata);
-#endif
dout(10, "page_mkwrite %p %llu~%llu = %d\n", inode, off, len, ret);
return ret;
}
return ERR_PTR(err ? err : -ESTALE);
}
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
dentry = d_obtain_alias(inode);
-#else
- dentry = d_alloc_anon(inode);
-#endif
if (!dentry) {
derr(10, "fh_to_dentry %llx.%x -- inode %p but ENOMEM\n",
git cherry-pick 5556036065d8b04b2f7dd439fbf0d710e295cd44
git add Documentation/filesystems/ceph.txt
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: documentation
Mount options, syntax.
git add $target/ceph/ceph_fs.h
git add $target/ceph/msgr.h
git add $target/ceph/rados.h
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: on-wire types
These headers describe the types used to exchange messages between the
git add $target/ceph/types.h
git add $target/ceph/super.h
git add $target/ceph/ceph_ver.h
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: client types
We first define constants, types, and prototypes for the kernel client
EOF
git add $target/ceph/super.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: super.c
Mount option parsing, client setup and teardown, and a few odds and
git add $target/ceph/inode.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: inode operations
Inode cache and inode operations. We also include routines to
EOF
git add $target/ceph/dir.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: directory operations
Directory operations, including lookup, are defined here. We take
EOF
git add $target/ceph/file.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: file operations
File open and close operations, and read and write methods that ensure
EOF
git add $target/ceph/addr.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: address space operations
The ceph address space methods are concerned primarily with managing
git add $target/ceph/mds_client.c
git add $target/ceph/mdsmap.h
git add $target/ceph/mdsmap.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: MDS client
The MDS client is responsible for submitting requests to the MDS
git add $target/ceph/osd_client.c
git add $target/ceph/osdmap.h
git add $target/ceph/osdmap.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: OSD client
The OSD client is responsible for reading and writing data from/to the
git add $target/ceph/crush/mapper.h
git add $target/ceph/crush/mapper.c
git add $target/ceph/crush/hash.h
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: CRUSH mapping algorithm
CRUSH is a fancy hash function designed to map inputs onto a dynamic
git add $target/ceph/mon_client.h
git add $target/ceph/mon_client.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: monitor client
The monitor cluster is responsible for managing cluster membership
EOF
git add $target/ceph/caps.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: capability management
The Ceph metadata servers control client access to data by issuing
EOF
git add $target/ceph/snap.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: snapshot management
Ceph snapshots rely on client cooperation in determining which
git add $target/ceph/decode.h
git add $target/ceph/messenger.h
git add $target/ceph/messenger.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: messenger library
A generic message passing library is used to communicate with all
EOF
git add $target/ceph/export.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: nfs re-export support
Basic NFS re-export support is included. This mostly works. However,
git add $target/ceph/ioctl.h
git add $target/ceph/ioctl.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: ioctls
A few Ceph ioctls for getting and setting file layout (striping)
EOF
git add $target/ceph/ceph_debug.h
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: debugging
Some debugging infrastructure, including the ability to adjust the
EOF
git add $target/ceph/debugfs.c
-git commit -F - <<EOF
+git commit -s -F - <<EOF
ceph: debugfs
Basic state information is available via /debug/ceph, including
git apply $cephtree/src/kernel/kbuild.staging.patch
git add $target/ceph/Makefile
git add $target/ceph/Kconfig
-git commit -F - <<EOF $target/Kconfig $target/ceph/Kconfig $target/Makefile $target/ceph/Makefile
+git commit -s -F - <<EOF $target/Kconfig $target/ceph/Kconfig $target/Makefile $target/ceph/Makefile
ceph: Kconfig, Makefile
Kconfig options and Makefile.
dout(10, "__do_pending_vmtruncate %p flushing snaps first\n",
inode);
spin_unlock(&inode->i_lock);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
filemap_write_and_wait_range(&inode->i_data, 0,
CEPH_FILE_MAX_SIZE);
-#else
-# warning i may not flush all data after a snapshot + truncate.. i export need 2.6.30
- filemap_write_and_wait(&inode->i_data);
-#endif
goto retry;
}
head->mdsmap_epoch = cpu_to_le32(mdsc->mdsmap->m_epoch);
head->op = cpu_to_le32(req->r_op);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
head->caller_uid = cpu_to_le32(current_fsuid());
head->caller_gid = cpu_to_le32(current_fsgid());
-#else
- head->caller_uid = cpu_to_le32(current->fsuid);
- head->caller_gid = cpu_to_le32(current->fsgid);
-#endif
head->args = req->r_args;
ceph_encode_filepath(&p, end, ino1, path1);
page = pages[i];
dout(20, "readpages zeroing %d %p from %d\n", i, page,
(int)(read & ~PAGE_CACHE_MASK));
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
zero_user_segment(page, read & ~PAGE_CACHE_MASK,
PAGE_CACHE_SIZE);
-#else
- zero_user_page(page, read & ~PAGE_CACHE_MASK,
- PAGE_CACHE_SIZE - (read & ~PAGE_CACHE_MASK),
- KM_USER0);
-#endif
read += PAGE_CACHE_SIZE;
}
for (i = read >> PAGE_CACHE_SHIFT; i < num_pages; i++) {
page = req->r_pages[i];
dout(20, "readpages zeroing %d %p\n", i, page);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
-#else
- zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
-#endif
}
}
struct kmem_cache *ceph_inode_cachep;
struct kmem_cache *ceph_cap_cachep;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
static void ceph_inode_init_once(void *foo)
-#else
-static void ceph_inode_init_once(struct kmem_cache *cachep, void *foo)
-#endif
{
struct ceph_inode_info *ci = foo;
inode_init_once(&ci->vfs_inode);
kmem_cache_destroy(ceph_cap_cachep);
}
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
-static void ceph_umount_begin(struct vfsmount *vfsmnt, int flags)
-#else
static void ceph_umount_begin(struct super_block *sb)
-#endif
{
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
- struct ceph_client *client = ceph_sb_to_client(vfsmnt->mnt_sb);
-#else
struct ceph_client *client = ceph_sb_to_client(sb);
-#endif
dout(30, "ceph_umount_begin\n");
-
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26)
- if (!(flags & MNT_FORCE))
- return;
-#endif
-
if (!client)
return;
-
client->mount_state = CEPH_MOUNT_SHUTDOWN;
return;
}
client->sb->s_root == NULL)
root = d_alloc_root(req->r_target_inode);
else
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28)
root = d_obtain_alias(req->r_target_inode);
-#else
- root = d_alloc_anon(req->r_target_inode);
-#endif
req->r_target_inode = NULL;
dout(30, "open_root_inode success, root dentry is %p\n", root);
} else {
err = bdi_init(&client->backing_dev_info);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
if (err < 0)
return err;
err = bdi_register_dev(&client->backing_dev_info, sb->s_dev);
-#endif
-
return err;
}
struct ceph_client *client = ceph_sb_to_client(s);
dout(1, "kill_sb %p\n", s);
ceph_mdsc_pre_umount(&client->mdsc);
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
bdi_unregister(&client->backing_dev_info);
-#endif
kill_anon_super(s); /* will call put_super after sb is r/o */
bdi_destroy(&client->backing_dev_info);
ceph_destroy_client(client);
projects / ceph.git / commitdiff