* [PATCH 00/19] ceph: Ceph distributed file system client
@ 2008-11-14 0:55 Sage Weil
2008-11-14 0:56 ` [PATCH 01/19] ceph: documentation Sage Weil
0 siblings, 1 reply; 20+ messages in thread
From: Sage Weil @ 2008-11-14 0:55 UTC (permalink / raw)
To: linux-fsdevel; +Cc: linux-kernel, Sage Weil
This is a patch series for the client portion of the Ceph distributed
file system (against v2.6.28-rc2). Ceph releases have been announced
here in the past, but no code has yet been posted for review. My hope
is for the client to eventually make it to mainline, but I have held off
on posting anything until now because the network protocols and disk
format are still changing, and the overall system is not ready for real
usage (beyond testing and benchmarking). However, the client itself is
relatively complete and stable, and the earlier this is seen the better,
so at Andrew's suggestion I'm sending this out now. Please let me know
what you think!
There are a few caveats attached to this patch series:
* This is the client only. The corresponding user space daemons need to
be built in order to test it. Instructions for getting a test setup
running on a single node are at
http://ceph.newdream.net/wiki/Small_test_cluster
* There is some #ifdef kernel version compatibility cruft that will
obviously be removed down the line.
* Some of the IO error paths need a bit of work. (Should pages be
left dirty after a write error? Should we try the write again?
Etc.)
Any review or comments are appreciated.
Thanks-
sage
---
Ceph is a distributed file system designed for reliability,
scalability, and performance. The storage system consists of some
(potentially large) number of storage servers (bricks, OSDs), a
smaller set of metadata server daemons, and a few monitor daemons for
managing cluster membership and state. The storage daemons rely on
btrfs for storing data (and take advantage of btrfs' internal
transactions to keep the local data set in a consistent state). This
makes the storage cluster simple to deploy, while providing
scalability not typically available from block-based cluster file
systems.
Additionaly, Ceph brings a few new things to Linux. Directory
granularity snapshots allow users to create a read-only snapshot of any
directory (and its nested contents) with 'mkdir .snap/my_snapshot' [1].
Deletion is similarly trivial ('rmdir .snap/old_snapshot'). Ceph also
maintains recursive accounting statistics on the number of nested files,
directories, and file sizes for each directory, making it much easier
for an administrator to manage usage [2].
Basic features include:
* Strong data and metadata consistency between clients
* High availability and reliability. No single points of failure.
* N-way replication of all data across storage nodes
* Scalability from 1 to potentially many thousands of nodes
* Fast recovery from node failures
* Automatic rebalancing of data on node addition/removal
* Easy deployment: most FS components are userspace daemons
In contrast to cluster filesystems like GFS2 and OCFS2 that rely on
symmetric access by all clients to shared block devices, Ceph
separates data and metadata management into independent server
clusters, similar to Lustre. Unlike Lustre, however, metadata and
object storage services run entirely as user space daemons. The
storage daemon utilizes btrfs to store data objects, leveraging its
advanced features (transactions, checksumming, metadata replication,
etc.). File data is striped across storage nodes in large chunks to
distribute workload and facilitate high throughputs. When storage
nodes fail, data is re-replicated in a distributed fashion by the
storage nodes themselves (with some minimal coordination from the
cluster monitor), making the system extremely efficient and scalable.
Metadata servers effectively form a large, consistent, distributed
in-memory cache above the storage cluster that is scalable, dynamically
redistributes metadata in response to workload changes, and can tolerate
arbitrary (well, non-Byzantine) node failures. The metadata server
takes a somewhat unconventional approach to metadata storage to
significantly improve performance for common workloads. In particular,
inodes with only a single link are embedded in directories, allowing
entire directories of dentries and inodes to be loaded into its cache
with a single I/O operation. The contents of large directories can be
fragmented and managed by independent metadata servers, allowing
scalable concurrent access.
The system offers automatic data rebalancing/migration when scaling from
a small cluster of just a few nodes to many hundreds, without requiring
an administrator to carve the data set into static volumes or go through
the tedious process of migrating data between servers. When the file
system approaches full, new storage nodes can be easily added and things
will "just work."
A git tree containing just the client (and this patch series) is at
git://ceph.newdream.net/linux-ceph-client.git
The source for the full system is at
git://ceph.newdream.net/ceph.git
The Ceph home page is at
http://ceph.newdream.net
[1] Snapshots
http://marc.info/?l=linux-fsdevel&m=122341525709480&w=2
[2] Recursive accounting
http://marc.info/?l=linux-fsdevel&m=121614651204667&w=2
---
Documentation/filesystems/ceph.txt | 173 +++
fs/Kconfig | 20 +
fs/Makefile | 1 +
fs/ceph/Makefile | 35 +
fs/ceph/addr.c | 1010 ++++++++++++++++
fs/ceph/caps.c | 1464 +++++++++++++++++++++++
fs/ceph/ceph_debug.h | 130 ++
fs/ceph/ceph_fs.h | 1225 +++++++++++++++++++
fs/ceph/ceph_tools.c | 125 ++
fs/ceph/ceph_tools.h | 19 +
fs/ceph/crush/crush.c | 139 +++
fs/ceph/crush/crush.h | 176 +++
fs/ceph/crush/hash.h | 80 ++
fs/ceph/crush/mapper.c | 507 ++++++++
fs/ceph/crush/mapper.h | 19 +
fs/ceph/decode.h | 151 +++
fs/ceph/dir.c | 891 ++++++++++++++
fs/ceph/export.c | 145 +++
fs/ceph/file.c | 446 +++++++
fs/ceph/inode.c | 2070 ++++++++++++++++++++++++++++++++
fs/ceph/ioctl.c | 72 ++
fs/ceph/ioctl.h | 12 +
fs/ceph/mds_client.c | 2261 +++++++++++++++++++++++++++++++++++
fs/ceph/mds_client.h | 255 ++++
fs/ceph/mdsmap.c | 123 ++
fs/ceph/mdsmap.h | 41 +
fs/ceph/messenger.c | 2304 ++++++++++++++++++++++++++++++++++++
fs/ceph/messenger.h | 269 +++++
fs/ceph/mon_client.c | 385 ++++++
fs/ceph/mon_client.h | 100 ++
fs/ceph/osd_client.c | 1125 ++++++++++++++++++
fs/ceph/osd_client.h | 135 +++
fs/ceph/osdmap.c | 664 +++++++++++
fs/ceph/osdmap.h | 82 ++
fs/ceph/proc.c | 186 +++
fs/ceph/snap.c | 753 ++++++++++++
fs/ceph/super.c | 1165 ++++++++++++++++++
fs/ceph/super.h | 687 +++++++++++
fs/ceph/types.h | 20 +
39 files changed, 19465 insertions(+), 0 deletions(-)
^ permalink raw reply [flat|nested] 20+ messages in thread* [PATCH 01/19] ceph: documentation 2008-11-14 0:55 [PATCH 00/19] ceph: Ceph distributed file system client Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 02/19] ceph: on-wire types Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Mount options, syntax. Signed-off-by: Sage Weil <sage@newdream.net> --- Documentation/filesystems/ceph.txt | 173 ++++++++++++++++++++++++++++++++++++ 1 files changed, 173 insertions(+), 0 deletions(-) create mode 100644 Documentation/filesystems/ceph.txt diff --git a/Documentation/filesystems/ceph.txt b/Documentation/filesystems/ceph.txt new file mode 100644 index 0000000..ec7dbc2 --- /dev/null +++ b/Documentation/filesystems/ceph.txt @@ -0,0 +1,173 @@ +Ceph Distributed File System +============================ + +Ceph is a distributed network file system designed to provide good +performance, reliability, and scalability. + +Basic features include: + + * POSIX semantics + * Seamless scaling from 1 to many thousands of nodes + * High availability and reliability. No single points of failure. + * N-way replication of data across storage nodes + * Fast recovery from node failures + * Automatic rebalancing of data on node addition/removal + * Easy deployment: most FS components are userspace daemons + +Also, + * Flexible snapshots (on any directory) + * Recursive accounting (nested files, directories, bytes) + +In contrast to cluster filesystems like GFS, OCFS2, and GPFS that rely +on symmetric access by all clients to shared block devices, Ceph +separates data and metadata management into independent server +clusters, similar to Lustre. Unlike Lustre, however, metadata and +storage nodes run entirely as user space daemons. Storage nodes +utilize btrfs to store data objects, leveraging its advanced features +(checksumming, metadata replication, etc.). File data is striped +across storage nodes in large chunks to distribute workload and +facilitate high throughputs. When storage nodes fail, data is +re-replicated in a distributed fashion by the storage nodes themselves +(with some minimal coordination from a cluster monitor), making the +system extremely efficient and scalable. + +Metadata servers effectively form a large, consistent, distributed +in-memory cache above the storage cluster that is extremely scalable, +dynamically redistributes metadata in response to workload changes, +and can tolerate arbitrary (well, non-Byzantine) node failures. The +metadata server takes a somewhat unconventional approach to metadata +storage to significantly improve performance for common workloads. In +particular, inodes with only a single link are embedded in +directories, allowing entire directories of dentries and inodes to be +loaded into its cache with a single I/O operation. The contents of +extremely large directories can be fragmented and managed by +independent metadata servers, allowing scalable concurrent access. + +The system offers automatic data rebalancing/migration when scaling +from a small cluster of just a few nodes to many hundreds, without +requiring an administrator carve the data set into static volumes or +go through the tedious process of migrating data between servers. +When the file system approaches full, new nodes can be easily added +and things will "just work." + +Ceph includes flexible snapshot mechanism that allows a user to create +a snapshot on any subdirectory (and its nested contents) in the +system. Snapshot creation and deletion are as simple as 'mkdir +.snap/foo' and 'rmdir .snap/foo'. + +Ceph also provides some recursive accounting on directories for nested +files and bytes. That is, a 'getfattr -d foo' on any directory in the +system will reveal the total number of nested regular files and +subdirectories, and a summation of all nested file sizes. This makes +the identification of large disk space consumers relatively quick, as +no 'du' or similar recursive scan of the file system is required. + + +Mount Syntax +============ + +The basic mount syntax is: + + # mount -t ceph monip[:port][,monip2[:port]...]:/[subdir] mnt + +You only need to specify a single monitor, as the client will get the +full list when it connects. (However, if the monitor you specify +happens to be down, the mount won't succeed.) The port can be left +off if the monitor is using the default. So if the monitor is at +1.2.3.4, + + # mount -t ceph 1.2.3.4:/ /mnt/ceph + +is sufficient. + + +Mount Options +============= + + ip=A.B.C.D[:N] + port=N + Specify the IP and/or port the client should bind to locally. + There is normally not much reason to do this. If the IP is not + specified, the client's IP address is determined by looking at the + address it's connection to the monitor originates from. + + wsize=X + Specify the maximum write size in bytes. By default there is no + maximu. Ceph will normally size writes based on the file stripe + size. + + rsize=X + Specify the maximum readahead. + + mount_timeout=X + Specify the timeout value for mount (in seconds), in the case + of a non-responsive Ceph file system. The default is 30 + seconds. + + rbytes + When stat() is called on a directory, set st_size to 'rbytes', + the summation of file sizes over all files nested beneath that + directory. This is the default. + + norbytes + When stat() is called on a directory, set st_size to the + number of entries in that directory. + + nocrc + Disable CRC32C calculation for data writes. If set, the OSD + must rely on TCP's error correction to detect data corruption + in the data payload. + + +Debugging options: + + debug=N + Specify the level of debug output for the Ceph client. Larger + values mean more output, and range from 0 to 50. The default + is 1 (high-level informational messages only). + + debug_console=N + If non-zero, debug messages will be printk'ed with KERN_ERR, + causing them to appear on the system console. Otherwise, + messages will be printed with KERN_DEBUG and will appear in + the system log. + + debug_msgr=N + Debug level for the messaging/communications layer, if >= 0. + Default is -1. + + debug_mdsc=N + Debug level for the MDS client, if >= 0. + + debug_osdc=N + Debug level for the OSD client, if >= 0. + + debug_addr=N + Debug level for address space operations, if >= 0. + + debug_file=N + Debug level for file operations, if >= 0. + + debug_inode=N + Debug level for inode operations, if >= 0. + + debug_caps=N + Debug level for file capability operations, if >= 0. + + debug_snap=N + Debug level for snapshot operations, if >= 0. + + + + +More Information +================ + +For more information on Ceph, see the home page at + http://ceph.newdream.net/ + +The Linux kernel client source tree is available at + git://ceph.newdream.net/linux-ceph-client.git + +and the source for the full system is at + git://ceph.newdream.net/ceph.git -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 02/19] ceph: on-wire types 2008-11-14 0:56 ` [PATCH 01/19] ceph: documentation Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 03/19] ceph: client types Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil This header describes the types used to exchange messages between the Ceph client and various servers. All types are little-endian and packed. Additionally, we define a few magic values to identify the current version of the protocol(s) in use, so that discrepancies to be detected on mount. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/ceph_fs.h | 1225 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1225 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/ceph_fs.h diff --git a/fs/ceph/ceph_fs.h b/fs/ceph/ceph_fs.h new file mode 100644 index 0000000..16b9d50 --- /dev/null +++ b/fs/ceph/ceph_fs.h @@ -0,0 +1,1225 @@ +/* + * ceph_fs.h - Ceph constants and data types to share between kernel and + * user space. + * + * LGPL2 + */ + +#ifndef _FS_CEPH_CEPH_FS_H +#define _FS_CEPH_CEPH_FS_H + + +#define CEPH_MON_PORT 12345 + +/* + * Max file size is a policy choice; in reality we are limited + * by 2^64. + */ +#define CEPH_FILE_MAX_SIZE (1ULL << 40) /* 1 TB */ + +/* + * tcp connection banner. include a protocol version. and adjust + * whenever the wire protocol changes. try to keep this string length + * constant. + */ +#define CEPH_BANNER "ceph 007\n" +#define CEPH_BANNER_MAX_LEN 30 + +/* + * subprotocol versions. when specific messages types or high-level + * protocols change, bump the affected components. + */ +#define CEPH_OSD_PROTOCOL 3 +#define CEPH_MDS_PROTOCOL 2 +#define CEPH_MON_PROTOCOL 2 +#define CEPH_CLIENT_PROTOCOL 1 +#define CEPH_ONDISK_FORMAT 1 + +/* + * types in this file are defined as little-endian, and are + * primarily intended to describe data structures that pass + * over the wire or that are stored on disk. + */ + +/* + * some basics + */ +typedef __le64 ceph_version_t; +typedef __le64 ceph_tid_t; /* transaction id */ +typedef __le32 ceph_epoch_t; + + +/* + * fs id + */ +struct ceph_fsid { + __le64 major; + __le64 minor; +} __attribute__ ((packed)); + +static inline int ceph_fsid_equal(const struct ceph_fsid *a, + const struct ceph_fsid *b) +{ + return a->major == b->major && a->minor == b->minor; +} + + +/* + * ino, object, etc. + */ +#define CEPH_INO_ROOT 1 + +typedef __le64 ceph_snapid_t; +#define CEPH_MAXSNAP ((__u64)(-3)) +#define CEPH_SNAPDIR ((__u64)(-1)) +#define CEPH_NOSNAP ((__u64)(-2)) + +struct ceph_object { + union { + __u8 raw[20]; /* fits a sha1 hash */ + struct { + __le64 ino; /* inode "file" identifier */ + __le32 bno; /* "block" (object) in that "file" */ + __le64 snap; /* snapshot id. usually NOSNAP. */ + } __attribute__ ((packed)); + }; +} __attribute__ ((packed)); + +struct ceph_timespec { + __le32 tv_sec; + __le32 tv_nsec; +} __attribute__ ((packed)); + + +/* + * "Frags" are a way to describe a subset of a 32-bit number space, + * using a mask and a value to match against that mask. Any given frag + * (subset of the number space) can be partitioned into 2^n sub-frags. + * + * Frags are encoded into a 32-bit word: + * 8 upper bits = "bits" + * 24 lower bits = "value" + * (We could go to 5+27 bits, but who cares.) + * + * We use the _most_ significant bits of the 24 bit value. This makes + * values logically sort. + * + * Unfortunately, because the "bits" field is still in the high bits, we + * can't sort encoded frags numerically. However, it does allow you + * to feed encoded frags as values into frag_contains_value. + */ +static inline __u32 frag_make(__u32 b, __u32 v) +{ + return (b << 24) | + (v & (0xffffffu << (24-b)) & 0xffffffu); +} +static inline __u32 frag_bits(__u32 f) +{ + return f >> 24; +} +static inline __u32 frag_value(__u32 f) +{ + return f & 0xffffffu; +} +static inline __u32 frag_mask(__u32 f) +{ + return (0xffffffu << (24-frag_bits(f))) & 0xffffffu; +} +static inline __u32 frag_mask_shift(__u32 f) +{ + return 24 - frag_bits(f); +} + +static inline int frag_contains_value(__u32 f, __u32 v) +{ + return (v & frag_mask(f)) == frag_value(f); +} +static inline int frag_contains_frag(__u32 f, __u32 sub) +{ + /* is sub as specific as us, and contained by us? */ + return frag_bits(sub) >= frag_bits(f) && + (frag_value(sub) & frag_mask(f)) == frag_value(f); +} + +static inline __u32 frag_parent(__u32 f) +{ + return frag_make(frag_bits(f) - 1, + frag_value(f) & (frag_mask(f) << 1)); +} +static inline int frag_is_left_child(__u32 f) +{ + return frag_bits(f) > 0 && + (frag_value(f) & (0x1000000 >> frag_bits(f))) == 0; +} +static inline int frag_is_right_child(__u32 f) +{ + return frag_bits(f) > 0 && + (frag_value(f) & (0x1000000 >> frag_bits(f))) == 1; +} +static inline __u32 frag_sibling(__u32 f) +{ + return frag_make(frag_bits(f), + frag_value(f) ^ (0x1000000 >> frag_bits(f))); +} +static inline __u32 frag_left_child(__u32 f) +{ + return frag_make(frag_bits(f)+1, frag_value(f)); +} +static inline __u32 frag_right_child(__u32 f) +{ + return frag_make(frag_bits(f)+1, + frag_value(f) | (0x1000000 >> (1+frag_bits(f)))); +} +static inline __u32 frag_make_child(__u32 f, int by, int i) +{ + int newbits = frag_bits(f) + by; + return frag_make(newbits, + frag_value(f) | (i << (24 - newbits))); +} +static inline int frag_is_leftmost(__u32 f) +{ + return frag_value(f) == 0; +} +static inline int frag_is_rightmost(__u32 f) +{ + return frag_value(f) == frag_mask(f); +} +static inline __u32 frag_next(__u32 f) +{ + return frag_make(frag_bits(f), + frag_value(f) + (0x1000000 >> frag_bits(f))); +} + +/* + * comparator to sort frags logically, as when traversing the + * number space in ascending order... + */ +static inline int frag_compare(__u32 a, __u32 b) +{ + unsigned va = frag_value(a); + unsigned vb = frag_value(b); + if (va < vb) + return -1; + if (va > vb) + return 1; + va = frag_bits(a); + vb = frag_bits(b); + if (va < vb) + return -1; + if (va > vb) + return 1; + return 0; +} + +/* + * object layout - how objects are mapped into PGs + */ +#define CEPH_OBJECT_LAYOUT_HASH 1 +#define CEPH_OBJECT_LAYOUT_LINEAR 2 +#define CEPH_OBJECT_LAYOUT_HASHINO 3 + +/* + * pg layout -- how PGs are mapped onto (sets of) OSDs + */ +#define CEPH_PG_LAYOUT_CRUSH 0 +#define CEPH_PG_LAYOUT_HASH 1 +#define CEPH_PG_LAYOUT_LINEAR 2 +#define CEPH_PG_LAYOUT_HYBRID 3 + +/* + * ceph_file_layout - describe data layout for a file/inode + */ +struct ceph_file_layout { + /* file -> object mapping */ + __le32 fl_stripe_unit; /* stripe unit, in bytes. must be multiple + of page size. */ + __le32 fl_stripe_count; /* over this many objects */ + __le32 fl_object_size; /* until objects are this big, then move to + new objects */ + __le32 fl_cas_hash; /* 0 = none; 1 = sha256 */ + + /* pg -> disk layout */ + __le32 fl_object_stripe_unit; /* for per-object parity, if any */ + + /* object -> pg layout */ + __le32 fl_pg_preferred; /* preferred primary for pg (-1 for none) */ + __u8 fl_pg_type; /* pg type; see PG_TYPE_* */ + __u8 fl_pg_size; /* pg size (num replicas, etc.) */ + __u8 fl_pg_pool; /* implies crush ruleset AND object namespace */ +} __attribute__ ((packed)); + +#define ceph_file_layout_su(l) ((__s32)le32_to_cpu((l).fl_stripe_unit)) +#define ceph_file_layout_stripe_count(l) \ + ((__s32)le32_to_cpu((l).fl_stripe_count)) +#define ceph_file_layout_object_size(l) ((__s32)le32_to_cpu((l).fl_object_size)) +#define ceph_file_layout_cas_hash(l) ((__s32)le32_to_cpu((l).fl_cas_hash)) +#define ceph_file_layout_object_su(l) \ + ((__s32)le32_to_cpu((l).fl_object_stripe_unit)) +#define ceph_file_layout_pg_preferred(l) \ + ((__s32)le32_to_cpu((l).fl_pg_preferred)) + +#define ceph_file_layout_stripe_width(l) (le32_to_cpu((l).fl_stripe_unit) * \ + le32_to_cpu((l).fl_stripe_count)) + +/* "period" == bytes before i start on a new set of objects */ +#define ceph_file_layout_period(l) (le32_to_cpu((l).fl_object_size) * \ + le32_to_cpu((l).fl_stripe_count)) + +/* + * placement group. + * we encode this into one __le64. + */ +#define CEPH_PG_TYPE_REP 1 +#define CEPH_PG_TYPE_RAID4 2 +union ceph_pg { + __u64 pg64; + struct { + __s16 preferred; /* preferred primary osd */ + __u16 ps; /* placement seed */ + __u8 __pad; + __u8 size; + __u8 pool; /* implies crush ruleset */ + __u8 type; + } pg; +} __attribute__ ((packed)); + +#define ceph_pg_is_rep(pg) ((pg).pg.type == CEPH_PG_TYPE_REP) +#define ceph_pg_is_raid4(pg) ((pg).pg.type == CEPH_PG_TYPE_RAID4) + +/* + * stable_mod func is used to control number of placement groups. + * similar to straight-up modulo, but produces a stable mapping as b + * increases over time. b is the number of bins, and bmask is the + * containing power of 2 minus 1. + * + * b <= bmask and bmask=(2**n)-1 + * e.g., b=12 -> bmask=15, b=123 -> bmask=127 + */ +static inline int ceph_stable_mod(int x, int b, int bmask) +{ + if ((x & bmask) < b) + return x & bmask; + else + return x & (bmask >> 1); +} + +/* + * object layout - how a given object should be stored. + */ +struct ceph_object_layout { + __le64 ol_pgid; /* raw pg, with _full_ ps precision. */ + __le32 ol_stripe_unit; +} __attribute__ ((packed)); + +/* + * compound epoch+version, used by storage layer to serialize mutations + */ +struct ceph_eversion { + ceph_epoch_t epoch; + __le64 version; +} __attribute__ ((packed)); + +/* + * osd map bits + */ + +/* status bits */ +#define CEPH_OSD_EXISTS 1 +#define CEPH_OSD_UP 2 +#define CEPH_OSD_CLEAN 4 /* as in, clean shutdown */ + +/* osd weights. fixed point value: 0x10000 == 1.0 ("in"), 0 == "out" */ +#define CEPH_OSD_IN 0x10000 +#define CEPH_OSD_OUT 0 + + +/* + * string hash. + * + * taken from Linux, tho we should probably take care to use this one + * in case the upstream hash changes. + */ + +/* Name hashing routines. Initial hash value */ +/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */ +#define ceph_init_name_hash() 0 + +/* partial hash update function. Assume roughly 4 bits per character */ +static inline unsigned long +ceph_partial_name_hash(unsigned long c, unsigned long prevhash) +{ + return (prevhash + (c << 4) + (c >> 4)) * 11; +} + +/* + * Finally: cut down the number of bits to a int value (and try to avoid + * losing bits) + */ +static inline unsigned long ceph_end_name_hash(unsigned long hash) +{ + return (unsigned int) hash; +} + +/* Compute the hash for a name string. */ +static inline unsigned int +ceph_full_name_hash(const char *name, unsigned int len) +{ + unsigned long hash = ceph_init_name_hash(); + while (len--) + hash = ceph_partial_name_hash(*name++, hash); + return ceph_end_name_hash(hash); +} + + + +/********************************************* + * message layer + */ + +/* + * entity_name + */ +struct ceph_entity_name { + __le32 type; + __le32 num; +} __attribute__ ((packed)); + +#define CEPH_ENTITY_TYPE_MON 1 +#define CEPH_ENTITY_TYPE_MDS 2 +#define CEPH_ENTITY_TYPE_OSD 3 +#define CEPH_ENTITY_TYPE_CLIENT 4 +#define CEPH_ENTITY_TYPE_ADMIN 5 + +/* used by message exchange protocol */ +#define CEPH_MSGR_TAG_READY 1 /* server->client: ready for messages */ +#define CEPH_MSGR_TAG_RESETSESSION 2 /* server->client: reset, try again */ +#define CEPH_MSGR_TAG_WAIT 3 /* server->client: wait for racing + incoming connection */ +#define CEPH_MSGR_TAG_RETRY_SESSION 4 /* server->client + cseq: try again + with higher cseq */ +#define CEPH_MSGR_TAG_RETRY_GLOBAL 5 /* server->client + gseq: try again + with higher gseq */ +#define CEPH_MSGR_TAG_CLOSE 6 /* closing pipe */ +#define CEPH_MSGR_TAG_MSG 10 /* message */ +#define CEPH_MSGR_TAG_ACK 11 /* message ack */ + + +/* + * entity_addr -- network address + */ +struct ceph_entity_addr { + __le32 erank; /* entity's rank in process */ + __le32 nonce; /* unique id for process (e.g. pid) */ + struct sockaddr_in ipaddr; +} __attribute__ ((packed)); + +static inline bool ceph_entity_addr_is_local(const struct ceph_entity_addr *a, + const struct ceph_entity_addr *b) +{ + return le32_to_cpu(a->nonce) == le32_to_cpu(b->nonce) && + a->ipaddr.sin_addr.s_addr == b->ipaddr.sin_addr.s_addr; +} + +static inline bool ceph_entity_addr_equal(const struct ceph_entity_addr *a, + const struct ceph_entity_addr *b) +{ + return memcmp(a, b, sizeof(*a)) == 0; +} + +struct ceph_entity_inst { + struct ceph_entity_name name; + struct ceph_entity_addr addr; +} __attribute__ ((packed)); + + +/* + * connection negotiation + */ +struct ceph_msg_connect { + __le32 host_type; /* CEPH_ENTITY_TYPE_* */ + __le32 global_seq; + __le32 connect_seq; + __u8 flags; +} __attribute__ ((packed)); + +struct ceph_msg_connect_reply { + __u8 tag; + __le32 global_seq; + __le32 connect_seq; + __u8 flags; +} __attribute__ ((packed)); + +#define CEPH_MSG_CONNECT_LOSSY 1 /* messages i send may be safely dropped */ + + +/* + * message header + */ +struct ceph_msg_header { + __le64 seq; /* message seq# for this session */ + __le16 type; /* message type */ + __le16 priority; /* priority. higher value == higher priority */ + __le16 mon_protocol, osd_protocol, mds_protocol, + client_protocol; /* protocol versions */ + __le32 front_len; /* bytes in main payload */ + __le32 data_off; /* sender: include full offset; + receiver: mask against ~PAGE_MASK */ + __le32 data_len; /* bytes of data payload */ + struct ceph_entity_inst src, orig_src, dst; + __le32 crc; /* header crc32c */ +} __attribute__ ((packed)); + +#define CEPH_MSG_PRIO_LOW 64 +#define CEPH_MSG_PRIO_DEFAULT 127 +#define CEPH_MSG_PRIO_HIGH 196 +#define CEPH_MSG_PRIO_HIGHEST 255 + +/* + * follows data payload + */ +struct ceph_msg_footer { + __le32 flags; + __le32 front_crc; + __le32 data_crc; +} __attribute__ ((packed)); + +#define CEPH_MSG_FOOTER_ABORTED (1<<0) /* drop this message */ +#define CEPH_MSG_FOOTER_NOCRC (1<<1) /* no data crc */ + + +/* + * message types + */ + +/* misc */ +#define CEPH_MSG_SHUTDOWN 1 +#define CEPH_MSG_PING 2 + +/* client <-> monitor */ +#define CEPH_MSG_MON_MAP 4 +#define CEPH_MSG_MON_GET_MAP 5 +#define CEPH_MSG_CLIENT_MOUNT 10 +#define CEPH_MSG_CLIENT_UNMOUNT 11 +#define CEPH_MSG_STATFS 12 +#define CEPH_MSG_STATFS_REPLY 13 + +/* client <-> mds */ +#define CEPH_MSG_MDS_GETMAP 20 +#define CEPH_MSG_MDS_MAP 21 + +#define CEPH_MSG_CLIENT_SESSION 22 +#define CEPH_MSG_CLIENT_RECONNECT 23 + +#define CEPH_MSG_CLIENT_REQUEST 24 +#define CEPH_MSG_CLIENT_REQUEST_FORWARD 25 +#define CEPH_MSG_CLIENT_REPLY 26 +#define CEPH_MSG_CLIENT_CAPS 0x310 +#define CEPH_MSG_CLIENT_LEASE 0x311 +#define CEPH_MSG_CLIENT_SNAP 0x312 + +/* osd */ +#define CEPH_MSG_OSD_GETMAP 40 +#define CEPH_MSG_OSD_MAP 41 +#define CEPH_MSG_OSD_OP 42 +#define CEPH_MSG_OSD_OPREPLY 43 + + +struct ceph_mon_statfs { + struct ceph_fsid fsid; + __le64 tid; +}; + +struct ceph_statfs { + __le64 f_total; + __le64 f_free; /* used = total - free (KB) */ + __le64 f_avail; /* usable */ + __le64 f_objects; +}; + +struct ceph_mon_statfs_reply { + struct ceph_fsid fsid; + __le64 tid; + struct ceph_statfs st; +}; + +struct ceph_osd_getmap { + struct ceph_fsid fsid; + __le32 start; +} __attribute__ ((packed)); + +struct ceph_mds_getmap { + struct ceph_fsid fsid; + __le32 want; +} __attribute__ ((packed)); + + +/* + * mds states + * > 0 -> in + * <= 0 -> out + */ +#define CEPH_MDS_STATE_DNE 0 /* down, does not exist. */ +#define CEPH_MDS_STATE_STOPPED -1 /* down, once existed, but no subtrees. + empty log. */ +#define CEPH_MDS_STATE_DESTROYING -2 /* down, existing, semi-destroyed. */ +#define CEPH_MDS_STATE_FAILED 3 /* down, needs to be recovered. */ + +#define CEPH_MDS_STATE_BOOT -4 /* up, boot announcement. */ +#define CEPH_MDS_STATE_STANDBY -5 /* up, idle. waiting for assignment. */ +#define CEPH_MDS_STATE_CREATING -6 /* up, creating MDS instance. */ +#define CEPH_MDS_STATE_STARTING -7 /* up, starting previously stopped mds. */ + +#define CEPH_MDS_STATE_REPLAY 8 /* up, replaying journal. */ +#define CEPH_MDS_STATE_RESOLVE 9 /* up, disambiguating distributed + operations (import, rename, etc.) */ +#define CEPH_MDS_STATE_RECONNECT 10 /* up, reconnect to clients */ +#define CEPH_MDS_STATE_REJOIN 11 /* up, rejoining distributed cache */ +#define CEPH_MDS_STATE_ACTIVE 12 /* up, active */ +#define CEPH_MDS_STATE_STOPPING 13 /* up, but exporting metadata */ + + +/* + * metadata lock types. + * - these are bitmasks.. we can compose them + * - they also define the lock ordering by the MDS + * - a few of these are internal to the mds + */ +#define CEPH_LOCK_DN 1 +#define CEPH_LOCK_ISNAP 2 +#define CEPH_LOCK_IVERSION 4 /* mds internal */ +#define CEPH_LOCK_IFILE 8 /* mds internal */ +#define CEPH_LOCK_IDIR 16 /* mds internal */ +#define CEPH_LOCK_IAUTH 32 +#define CEPH_LOCK_ILINK 64 +#define CEPH_LOCK_IDFT 128 /* dir frag tree */ +#define CEPH_LOCK_INEST 256 /* mds internal */ +#define CEPH_LOCK_IXATTR 512 +#define CEPH_LOCK_INO 2048 /* immutable inode bits; not a lock */ + +/* alias for either filelock or dirlock */ +#define CEPH_LOCK_ICONTENT (CEPH_LOCK_IFILE|CEPH_LOCK_IDIR) + +/* + * stat masks are defined in terms of the locks that cover inode fields. + */ +#define CEPH_STAT_MASK_INODE CEPH_LOCK_INO +#define CEPH_STAT_MASK_TYPE CEPH_LOCK_INO /* mode >> 12 */ +#define CEPH_STAT_MASK_SYMLINK CEPH_LOCK_INO +#define CEPH_STAT_MASK_UID CEPH_LOCK_IAUTH +#define CEPH_STAT_MASK_GID CEPH_LOCK_IAUTH +#define CEPH_STAT_MASK_MODE CEPH_LOCK_IAUTH +#define CEPH_STAT_MASK_NLINK CEPH_LOCK_ILINK +#define CEPH_STAT_MASK_LAYOUT CEPH_LOCK_ICONTENT +#define CEPH_STAT_MASK_MTIME CEPH_LOCK_ICONTENT +#define CEPH_STAT_MASK_SIZE CEPH_LOCK_ICONTENT +#define CEPH_STAT_MASK_ATIME CEPH_LOCK_ICONTENT /* fixme */ +#define CEPH_STAT_MASK_XATTR CEPH_LOCK_IXATTR +#define CEPH_STAT_MASK_INODE_ALL (CEPH_LOCK_ICONTENT | CEPH_LOCK_IAUTH | \ + CEPH_LOCK_ILINK | CEPH_LOCK_INO) + +/* client_session ops */ +enum { + CEPH_SESSION_REQUEST_OPEN, + CEPH_SESSION_OPEN, + CEPH_SESSION_REQUEST_CLOSE, + CEPH_SESSION_CLOSE, + CEPH_SESSION_REQUEST_RENEWCAPS, + CEPH_SESSION_RENEWCAPS, + CEPH_SESSION_STALE, +}; + +static inline const char *ceph_session_op_name(int op) +{ + switch (op) { + case CEPH_SESSION_REQUEST_OPEN: return "request_open"; + case CEPH_SESSION_OPEN: return "open"; + case CEPH_SESSION_REQUEST_CLOSE: return "request_close"; + case CEPH_SESSION_CLOSE: return "close"; + case CEPH_SESSION_REQUEST_RENEWCAPS: return "request_renewcaps"; + case CEPH_SESSION_RENEWCAPS: return "renewcaps"; + case CEPH_SESSION_STALE: return "stale"; + default: return "???"; + } +} + +struct ceph_mds_session_head { + __le32 op; + __le64 seq; + struct ceph_timespec stamp; +} __attribute__ ((packed)); + +/* client_request */ +/* + * metadata ops. + * & 0x001000 -> write op + * & 0x010000 -> follow symlink (e.g. stat(), not lstat()). + & & 0x100000 -> use weird ino/path trace + */ +#define CEPH_MDS_OP_WRITE 0x001000 +#define CEPH_MDS_OP_FOLLOW_LINK 0x010000 +#define CEPH_MDS_OP_INO_PATH 0x100000 +enum { + CEPH_MDS_OP_FINDINODE = 0x100100, + + CEPH_MDS_OP_LSTAT = 0x00100, + CEPH_MDS_OP_LUTIME = 0x01101, + CEPH_MDS_OP_LCHMOD = 0x01102, + CEPH_MDS_OP_LCHOWN = 0x01103, + CEPH_MDS_OP_LSETXATTR = 0x01104, + CEPH_MDS_OP_LRMXATTR = 0x01105, + CEPH_MDS_OP_LSETLAYOUT = 0x01106, + + CEPH_MDS_OP_STAT = 0x10100, + CEPH_MDS_OP_UTIME = 0x11101, + CEPH_MDS_OP_CHMOD = 0x11102, + CEPH_MDS_OP_CHOWN = 0x11103, + CEPH_MDS_OP_SETXATTR = 0x11104, + CEPH_MDS_OP_RMXATTR = 0x11105, + + CEPH_MDS_OP_MKNOD = 0x01201, + CEPH_MDS_OP_LINK = 0x01202, + CEPH_MDS_OP_UNLINK = 0x01203, + CEPH_MDS_OP_RENAME = 0x01204, + CEPH_MDS_OP_MKDIR = 0x01220, + CEPH_MDS_OP_RMDIR = 0x01221, + CEPH_MDS_OP_SYMLINK = 0x01222, + + CEPH_MDS_OP_OPEN = 0x10302, + CEPH_MDS_OP_TRUNCATE = 0x11303, + CEPH_MDS_OP_LTRUNCATE = 0x01303, + CEPH_MDS_OP_FSYNC = 0x00304, + CEPH_MDS_OP_READDIR = 0x00305, + + CEPH_MDS_OP_MKSNAP = 0x01400, + CEPH_MDS_OP_RMSNAP = 0x01401, + CEPH_MDS_OP_LSSNAP = 0x00402, +}; + +static inline const char *ceph_mds_op_name(int op) +{ + switch (op) { + case CEPH_MDS_OP_FINDINODE: return "findinode"; + case CEPH_MDS_OP_STAT: return "stat"; + case CEPH_MDS_OP_LSTAT: return "lstat"; + case CEPH_MDS_OP_UTIME: return "utime"; + case CEPH_MDS_OP_LUTIME: return "lutime"; + case CEPH_MDS_OP_CHMOD: return "chmod"; + case CEPH_MDS_OP_LCHMOD: return "lchmod"; + case CEPH_MDS_OP_CHOWN: return "chown"; + case CEPH_MDS_OP_LCHOWN: return "lchown"; + case CEPH_MDS_OP_LSETLAYOUT: return "lsetlayout"; + case CEPH_MDS_OP_SETXATTR: return "setxattr"; + case CEPH_MDS_OP_LSETXATTR: return "lsetxattr"; + case CEPH_MDS_OP_RMXATTR: return "rmxattr"; + case CEPH_MDS_OP_LRMXATTR: return "lrmxattr"; + case CEPH_MDS_OP_READDIR: return "readdir"; + case CEPH_MDS_OP_MKNOD: return "mknod"; + case CEPH_MDS_OP_LINK: return "link"; + case CEPH_MDS_OP_UNLINK: return "unlink"; + case CEPH_MDS_OP_RENAME: return "rename"; + case CEPH_MDS_OP_MKDIR: return "mkdir"; + case CEPH_MDS_OP_RMDIR: return "rmdir"; + case CEPH_MDS_OP_SYMLINK: return "symlink"; + case CEPH_MDS_OP_OPEN: return "open"; + case CEPH_MDS_OP_TRUNCATE: return "truncate"; + case CEPH_MDS_OP_LTRUNCATE: return "ltruncate"; + case CEPH_MDS_OP_FSYNC: return "fsync"; + case CEPH_MDS_OP_LSSNAP: return "lssnap"; + case CEPH_MDS_OP_MKSNAP: return "mksnap"; + case CEPH_MDS_OP_RMSNAP: return "rmsnap"; + default: return "???"; + } +} + +struct ceph_mds_request_head { + ceph_tid_t tid, oldest_client_tid; + ceph_epoch_t mdsmap_epoch; /* on client */ + __le32 num_fwd; + __le32 retry_attempt; + __le64 mds_wants_replica_in_dirino; + __le32 op; + __le32 caller_uid, caller_gid; + + union { + struct { + __le32 mask; + } __attribute__ ((packed)) stat; + struct { + __le32 mask; + } __attribute__ ((packed)) fstat; + struct { + __le32 frag; + } __attribute__ ((packed)) readdir; + struct { + struct ceph_timespec mtime; + struct ceph_timespec atime; + struct ceph_timespec ctime; + __le32 mask; + } __attribute__ ((packed)) utime; + struct { + __le32 mode; + } __attribute__ ((packed)) chmod; + struct { + __le32 uid; + __le32 gid; + __le32 mask; + } __attribute__ ((packed)) chown; + struct { + __le32 mode; + __le32 rdev; + } __attribute__ ((packed)) mknod; + struct { + __le32 mode; + } __attribute__ ((packed)) mkdir; + struct { + __le32 flags; + __le32 mode; + } __attribute__ ((packed)) open; + struct { + __le64 length; + } __attribute__ ((packed)) truncate; + struct { + __le32 flags; + } __attribute__ ((packed)) setxattr; + struct { + struct ceph_file_layout layout; + } __attribute__ ((packed)) setlayout; + } __attribute__ ((packed)) args; +} __attribute__ ((packed)); + +/* masks for utimes() */ +#define CEPH_UTIME_ATIME 1 +#define CEPH_UTIME_MTIME 2 +#define CEPH_UTIME_CTIME 4 + +/* masks for chown */ +#define CEPH_CHOWN_UID 1 +#define CEPH_CHOWN_GID 2 + +struct ceph_inopath_item { + __le64 ino; + __le32 dname_hash; +} __attribute__ ((packed)); + +/* client reply */ +struct ceph_mds_reply_head { + ceph_tid_t tid; + __le32 op; + __le32 result; + __le32 file_caps; + __le32 file_caps_seq; + __le32 file_caps_mseq; + __le32 mdsmap_epoch; +} __attribute__ ((packed)); + +/* one for each node split */ +struct ceph_frag_tree_split { + __le32 frag; /* this frag splits... */ + __le32 by; /* ...by this many bits */ +} __attribute__ ((packed)); + +struct ceph_frag_tree_head { + __le32 nsplits; + struct ceph_frag_tree_split splits[]; +} __attribute__ ((packed)); + +struct ceph_mds_reply_inode { + __le64 ino; + __le64 snapid; + __le64 version; + struct ceph_file_layout layout; + struct ceph_timespec ctime, mtime, atime; + __le64 time_warp_seq; + __le32 rdev; + __le32 mode, uid, gid; + __le32 nlink; + __le64 size, max_size, truncate_seq; + __le64 files, subdirs, rbytes, rfiles, rsubdirs; /* dir stats */ + struct ceph_timespec rctime; + struct ceph_frag_tree_head fragtree; +} __attribute__ ((packed)); +/* followed by frag array, then symlink string, then xattr blob */ + +/* reply_lease follows dname, and reply_inode */ +struct ceph_mds_reply_lease { + __le16 mask; + __le32 duration_ms; +} __attribute__ ((packed)); + +struct ceph_mds_reply_dirfrag { + __le32 frag; /* fragment */ + __le32 auth; /* auth mds, if this is a delegation point */ + __le32 ndist; /* number of mds' this is replicated on */ + __le32 dist[]; +} __attribute__ ((packed)); + +/* file access modes */ +#define CEPH_FILE_MODE_PIN 0 +#define CEPH_FILE_MODE_RD 1 +#define CEPH_FILE_MODE_WR 2 +#define CEPH_FILE_MODE_RDWR 3 /* RD | WR */ +#define CEPH_FILE_MODE_LAZY 4 /* lazy io */ +#define CEPH_FILE_MODE_NUM 8 /* bc these are bit fields.. mostly */ + +static inline int ceph_flags_to_mode(int flags) +{ +#ifdef O_DIRECTORY /* fixme */ + if ((flags & O_DIRECTORY) == O_DIRECTORY) + return CEPH_FILE_MODE_PIN; +#endif +#ifdef O_LAZY + if (flags & O_LAZY) + return CEPH_FILE_MODE_LAZY; +#endif + if ((flags & O_APPEND) == O_APPEND) + flags |= O_WRONLY; + + flags &= O_ACCMODE; + if ((flags & O_RDWR) == O_RDWR) + return CEPH_FILE_MODE_RDWR; + if ((flags & O_WRONLY) == O_WRONLY) + return CEPH_FILE_MODE_WR; + return CEPH_FILE_MODE_RD; +} + +/* client file caps */ +#define CEPH_CAP_PIN 1 /* no specific capabilities beyond the pin */ +#define CEPH_CAP_RDCACHE 2 /* client can cache reads */ +#define CEPH_CAP_RD 4 /* client can read */ +#define CEPH_CAP_WR 8 /* client can write */ +#define CEPH_CAP_WRBUFFER 16 /* client can buffer writes */ +#define CEPH_CAP_WREXTEND 32 /* client can extend EOF */ +#define CEPH_CAP_LAZYIO 64 /* client can perform lazy io */ +#define CEPH_CAP_EXCL 128 /* exclusive/loner access */ + +static inline int ceph_caps_for_mode(int mode) +{ + switch (mode) { + case CEPH_FILE_MODE_PIN: + return CEPH_CAP_PIN; + case CEPH_FILE_MODE_RD: + return CEPH_CAP_PIN | + CEPH_CAP_RD | CEPH_CAP_RDCACHE; + case CEPH_FILE_MODE_RDWR: + return CEPH_CAP_PIN | + CEPH_CAP_RD | CEPH_CAP_RDCACHE | + CEPH_CAP_WR | CEPH_CAP_WRBUFFER | + CEPH_CAP_EXCL; + case CEPH_FILE_MODE_WR: + return CEPH_CAP_PIN | + CEPH_CAP_WR | CEPH_CAP_WRBUFFER | + CEPH_CAP_EXCL; + } + return 0; +} + +enum { + CEPH_CAP_OP_GRANT, /* mds->client grant */ + CEPH_CAP_OP_TRUNC, /* mds->client trunc notify */ + CEPH_CAP_OP_EXPORT, /* mds has exported the cap */ + CEPH_CAP_OP_IMPORT, /* mds has imported the cap from specified mds */ + CEPH_CAP_OP_RELEASED, /* mds->client close out cap */ + CEPH_CAP_OP_FLUSHEDSNAP, /* mds->client flushed snap */ + CEPH_CAP_OP_ACK, /* client->mds ack (if prior grant was recall) */ + CEPH_CAP_OP_REQUEST, /* client->mds request (update wanted bits) */ + CEPH_CAP_OP_FLUSHSNAP, /* client->mds flush snapped metadata */ + CEPH_CAP_OP_RELEASE, /* client->mds request release cap */ +}; + +static inline const char *ceph_cap_op_name(int op) +{ + switch (op) { + case CEPH_CAP_OP_GRANT: return "grant"; + case CEPH_CAP_OP_TRUNC: return "trunc"; + case CEPH_CAP_OP_EXPORT: return "export"; + case CEPH_CAP_OP_IMPORT: return "import"; + case CEPH_CAP_OP_RELEASED: return "released"; + case CEPH_CAP_OP_FLUSHEDSNAP: return "flushedsnap"; + case CEPH_CAP_OP_ACK: return "ack"; + case CEPH_CAP_OP_REQUEST: return "request"; + case CEPH_CAP_OP_FLUSHSNAP: return "flushsnap"; + case CEPH_CAP_OP_RELEASE: return "release"; + default: return "???"; + } +} + +/* + * caps message, used for capability callbacks, acks, requests, etc. + */ +struct ceph_mds_caps { + __le32 op; + __le64 ino; + __le32 seq; + __le32 caps, wanted; + __le64 size, max_size; + __le64 truncate_seq; + __le32 migrate_seq; + struct ceph_timespec mtime, atime, ctime; + struct ceph_file_layout layout; + __le64 time_warp_seq; + __le64 snap_follows; + __le32 snap_trace_len; +} __attribute__ ((packed)); + + +#define CEPH_MDS_LEASE_REVOKE 1 /* mds -> client */ +#define CEPH_MDS_LEASE_RELEASE 2 /* client -> mds */ +#define CEPH_MDS_LEASE_RENEW 3 /* client <-> mds */ + +struct ceph_mds_lease { + __u8 action; + __le16 mask; + __le64 ino; + __le64 first, last; +} __attribute__ ((packed)); +/* followed by a __le32+string for dname */ + + +/* client reconnect */ +struct ceph_mds_cap_reconnect { + __le32 wanted; + __le32 issued; + __le64 size; + struct ceph_timespec mtime, atime; + __le64 snaprealm; +} __attribute__ ((packed)); +/* followed by encoded string */ + +struct ceph_mds_snaprealm_reconnect { + __le64 ino; + __le64 seq; + __le64 parent; /* parent realm */ +} __attribute__ ((packed)); + +/* + * snaps + */ +enum { + CEPH_SNAP_OP_UPDATE, /* CREATE or DESTROY */ + CEPH_SNAP_OP_CREATE, + CEPH_SNAP_OP_DESTROY, + CEPH_SNAP_OP_SPLIT, +}; + +static inline const char *ceph_snap_op_name(int o) +{ + switch (o) { + case CEPH_SNAP_OP_UPDATE: return "update"; + case CEPH_SNAP_OP_CREATE: return "create"; + case CEPH_SNAP_OP_DESTROY: return "destroy"; + case CEPH_SNAP_OP_SPLIT: return "split"; + default: return "???"; + } +} + +struct ceph_mds_snap_head { + __le32 op; + __le64 split; + __le32 num_split_inos; + __le32 num_split_realms; + __le32 trace_len; +} __attribute__ ((packed)); +/* followed by split ino list, then split realms, then the trace blob */ + +/* + * encode info about a snaprealm, as viewed by a client + */ +struct ceph_mds_snap_realm { + __le64 ino; /* ino */ + __le64 created; /* snap: when created */ + __le64 parent; /* ino: parent realm */ + __le64 parent_since; /* snap: same parent since */ + __le64 seq; /* snap: version */ + __le32 num_snaps; + __le32 num_prior_parent_snaps; +} __attribute__ ((packed)); +/* followed by my snap list, then prior parent snap list */ + +/* + * osd map flag bits + */ +#define CEPH_OSDMAP_NEARFULL (1<<0) /* sync writes (near ENOSPC) */ +#define CEPH_OSDMAP_FULL (1<<1) /* no data writes (ENOSPC) */ + +/* + * osd ops + */ +#define CEPH_OSD_OP_MODE 0xf000 +#define CEPH_OSD_OP_MODE_RD 0x1000 +#define CEPH_OSD_OP_MODE_WR 0x2000 +#define CEPH_OSD_OP_MODE_SUB 0x4000 + +#define CEPH_OSD_OP_TYPE 0x0f00 +#define CEPH_OSD_OP_TYPE_LOCK 0x0100 +#define CEPH_OSD_OP_TYPE_DATA 0x0200 +#define CEPH_OSD_OP_TYPE_ATTR 0x0300 + +enum { + /* read */ + CEPH_OSD_OP_READ = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 1, + CEPH_OSD_OP_STAT = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 2, + + CEPH_OSD_OP_GETXATTR = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 1, + CEPH_OSD_OP_GETXATTRS = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 2, + + /* subop */ + CEPH_OSD_OP_PULL = CEPH_OSD_OP_MODE_SUB | 1, + CEPH_OSD_OP_PUSH = CEPH_OSD_OP_MODE_SUB | 2, + CEPH_OSD_OP_BALANCEREADS = CEPH_OSD_OP_MODE_SUB | 3, + CEPH_OSD_OP_UNBALANCEREADS = CEPH_OSD_OP_MODE_SUB | 4, + + /* object data */ + CEPH_OSD_OP_WRITE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 1, + CEPH_OSD_OP_WRITEFULL = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 2, + CEPH_OSD_OP_TRUNCATE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 3, + CEPH_OSD_OP_ZERO = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 4, + CEPH_OSD_OP_DELETE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 5, + + /* object attrs */ + CEPH_OSD_OP_SETXATTR = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 1, + CEPH_OSD_OP_SETXATTRS = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 2, + CEPH_OSD_OP_RESETXATTRS= CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 3, + CEPH_OSD_OP_RMXATTR = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 4, + + /* lock */ + CEPH_OSD_OP_WRLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 1, + CEPH_OSD_OP_WRUNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 2, + CEPH_OSD_OP_RDLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 3, + CEPH_OSD_OP_RDUNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 4, + CEPH_OSD_OP_UPLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 5, + CEPH_OSD_OP_DNLOCK = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 6, + + /* fancy read */ + CEPH_OSD_OP_GREP = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 3, + + /* fancy write */ + CEPH_OSD_OP_APPEND = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 6, +}; + +static inline int ceph_osd_op_type_lock(int op) +{ + return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_LOCK; +} +static inline int ceph_osd_op_type_data(int op) +{ + return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_DATA; +} +static inline int ceph_osd_op_type_attr(int op) +{ + return (op & CEPH_OSD_OP_TYPE) == CEPH_OSD_OP_TYPE_ATTR; +} + +static inline int ceph_osd_op_mode_subop(int op) +{ + return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_SUB; +} +static inline int ceph_osd_op_mode_read(int op) +{ + return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_RD; +} +static inline int ceph_osd_op_mode_modify(int op) +{ + return (op & CEPH_OSD_OP_MODE) == CEPH_OSD_OP_MODE_WR; +} + +static inline const char *ceph_osd_op_name(int op) +{ + switch (op) { + case CEPH_OSD_OP_READ: return "read"; + case CEPH_OSD_OP_STAT: return "stat"; + + case CEPH_OSD_OP_WRITE: return "write"; + case CEPH_OSD_OP_DELETE: return "delete"; + case CEPH_OSD_OP_TRUNCATE: return "truncate"; + case CEPH_OSD_OP_ZERO: return "zero"; + case CEPH_OSD_OP_WRITEFULL: return "writefull"; + + case CEPH_OSD_OP_SETXATTR: return "setxattr"; + case CEPH_OSD_OP_SETXATTRS: return "setxattrs"; + case CEPH_OSD_OP_RESETXATTRS: return "resetxattrs"; + case CEPH_OSD_OP_RMXATTR: return "rmxattr"; + + case CEPH_OSD_OP_WRLOCK: return "wrlock"; + case CEPH_OSD_OP_WRUNLOCK: return "wrunlock"; + case CEPH_OSD_OP_RDLOCK: return "rdlock"; + case CEPH_OSD_OP_RDUNLOCK: return "rdunlock"; + case CEPH_OSD_OP_UPLOCK: return "uplock"; + case CEPH_OSD_OP_DNLOCK: return "dnlock"; + + case CEPH_OSD_OP_PULL: return "pull"; + case CEPH_OSD_OP_PUSH: return "push"; + case CEPH_OSD_OP_BALANCEREADS: return "balance-reads"; + case CEPH_OSD_OP_UNBALANCEREADS: return "unbalance-reads"; + + default: return "???"; + } +} + + +/* + * osd op flags + */ +enum { + CEPH_OSD_OP_ACK = 1, /* want (or is) "ack" ack */ + CEPH_OSD_OP_SAFE = 2, /* want (or is) "safe" ack */ + CEPH_OSD_OP_RETRY = 4, /* resend attempt */ + CEPH_OSD_OP_INCLOCK_FAIL = 8, /* fail on inclock collision */ + CEPH_OSD_OP_MODIFY = 16, /* op is/was a mutation */ + CEPH_OSD_OP_ACKNVRAM = 32, /* ACK when stable in NVRAM, not RAM */ + CEPH_OSD_OP_ORDERSNAP = 64, /* EOLDSNAP if snapc is out of order */ + CEPH_OSD_OP_PEERSTAT = 128, /* msg includes osd_peer_stat */ + CEPH_OSD_OP_BALANCE_READS = 256, +}; + +#define EOLDSNAPC 44 /* ORDERSNAP flag set and writer has old snap context*/ + +struct ceph_osd_op { + __le16 op; + union { + struct { + __le64 offset, length; + }; + struct { + __le32 name_len; + __le32 value_len; + }; + }; +} __attribute__ ((packed)); + +struct ceph_osd_request_head { + ceph_tid_t tid; + __le32 client_inc; + struct ceph_object oid; + struct ceph_object_layout layout; + ceph_epoch_t osdmap_epoch; + + __le32 flags; + __le32 inc_lock; + + struct ceph_eversion reassert_version; + + /* writer's snap context */ + __le64 snap_seq; + __le32 num_snaps; + + /* read or mutation */ + __le16 num_ops; + __u16 object_type; + struct ceph_osd_op ops[]; /* followed by snaps */ +} __attribute__ ((packed)); + +struct ceph_osd_reply_head { + ceph_tid_t tid; + __le32 flags; + struct ceph_object oid; + struct ceph_object_layout layout; + ceph_epoch_t osdmap_epoch; + struct ceph_eversion reassert_version; + + __le32 result; + + __le32 num_ops; + struct ceph_osd_op ops[0]; +} __attribute__ ((packed)); + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 03/19] ceph: client types 2008-11-14 0:56 ` [PATCH 02/19] ceph: on-wire types Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 04/19] ceph: super.c Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil We first define constants, types, and prototypes for the kernel client proper. A few subsystems are defined separately later: the MDS, OSD, and monitor clients, and the messaging layer. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/super.h | 687 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/types.h | 20 ++ 2 files changed, 707 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/super.h create mode 100644 fs/ceph/types.h diff --git a/fs/ceph/super.h b/fs/ceph/super.h new file mode 100644 index 0000000..bdf45d1 --- /dev/null +++ b/fs/ceph/super.h @@ -0,0 +1,687 @@ +#ifndef _FS_CEPH_SUPER_H +#define _FS_CEPH_SUPER_H + +#include <linux/fs.h> +#include <linux/wait.h> +#include <linux/completion.h> +#include <linux/pagemap.h> +#include <linux/exportfs.h> +#include <linux/sysfs.h> +#include <linux/sysfs.h> +#include <linux/backing-dev.h> + +#include "types.h" +#include "ceph_debug.h" +#include "messenger.h" +#include "mon_client.h" +#include "mds_client.h" +#include "osd_client.h" + +/* f_type in struct statfs */ +#define CEPH_SUPER_MAGIC 0x00c36400 + +/* large granularity for statfs utilization stats to facilitate + * large volume sizes on 32-bit machines. */ +#define CEPH_BLOCK_SHIFT 20 /* 1 MB */ +#define CEPH_BLOCK (1 << CEPH_BLOCK_SHIFT) + +/* + * subtract jiffies + */ +static inline unsigned long time_sub(unsigned long a, unsigned long b) +{ + BUG_ON(time_after(b, a)); + return (long)a - (long)b; +} + +/* + * mount options + */ +#define CEPH_MOUNT_FSID (1<<0) +#define CEPH_MOUNT_NOSHARE (1<<1) /* don't share client with other sbs */ +#define CEPH_MOUNT_MYIP (1<<2) /* specified my ip */ +#define CEPH_MOUNT_UNSAFE_WRITEBACK (1<<3) +#define CEPH_MOUNT_DIRSTAT (1<<4) /* funky `cat dirname` for stats */ +#define CEPH_MOUNT_RBYTES (1<<5) /* dir st_bytes = rbytes */ +#define CEPH_MOUNT_NOCRC (1<<6) /* no data crc on writes */ + +#define CEPH_MOUNT_DEFAULT (CEPH_MOUNT_RBYTES) + +#define CEPH_DEFAULT_READ_SIZE (128*1024) /* readahead */ + +#define MAX_MON_MOUNT_ADDR 5 + +struct ceph_mount_args { + int sb_flags; + int flags; + int mount_timeout; + struct ceph_fsid fsid; + struct ceph_entity_addr my_addr; + int num_mon; + struct ceph_entity_addr mon_addr[MAX_MON_MOUNT_ADDR]; + int wsize; + int rsize; /* max readahead */ + int osd_timeout; + char *snapdir_name; /* default ".snap" */ +}; + +enum { + CEPH_MOUNT_MOUNTING, + CEPH_MOUNT_MOUNTED, + CEPH_MOUNT_UNMOUNTING, + CEPH_MOUNT_UNMOUNTED, + CEPH_MOUNT_SHUTDOWN, +}; + + +extern struct kobject *ceph_kobj; + +/* + * per-filesystem client state + * + * possibly shared by multiple mount points, if they are + * mounting the same ceph filesystem/cluster. + */ +struct ceph_client { + u32 whoami; /* my client number */ + + struct mutex mount_mutex; /* serialize mount attempts */ + struct ceph_mount_args mount_args; + struct ceph_fsid fsid; + + struct super_block *sb; + + unsigned long mount_state; + wait_queue_head_t mount_wq; + + struct ceph_messenger *msgr; /* messenger instance */ + struct ceph_mon_client monc; + struct ceph_mds_client mdsc; + struct ceph_osd_client osdc; + + /* writeback */ + struct workqueue_struct *wb_wq; + struct workqueue_struct *pg_inv_wq; + struct workqueue_struct *trunc_wq; + + struct kobject *client_kobj; + + struct backing_dev_info backing_dev_info; +}; + +static inline struct ceph_client *ceph_client(struct super_block *sb) +{ + return sb->s_fs_info; +} + +/* + * File i/o capability. This tracks shared state with the metadata + * server that allows us to read and write data to this file. For any + * given inode, we may have multiple capabilities, one issued by each + * metadata server, and our cumulative access is the OR of all issued + * capabilities. + * + * Each cap is referenced by the inode's i_caps tree and by a per-mds + * session capability list. + */ +struct ceph_cap { + struct ceph_inode_info *ci; + struct rb_node ci_node; /* per-ci cap tree */ + struct ceph_mds_session *session; + struct list_head session_caps; /* per-session caplist */ + int mds; + int issued; /* latest, from the mds */ + int implemented; /* what we've implemented (for tracking revocation) */ + u32 seq, mseq, gen; +}; + +/* + * Snapped cap state that is pending flush to mds. When a snapshot occurs, + * we first complete any in-process sync writes and writeback any dirty + * data before flushing the snapped state (tracked here) back to the MDS. + */ +struct ceph_cap_snap { + struct list_head ci_item; + u64 follows; + int issued; + u64 size; + struct timespec mtime, atime, ctime; + u64 time_warp_seq; + struct ceph_snap_context *context; + int writing; /* a sync write is still in progress */ + int dirty; /* dirty pages awaiting writeback */ +}; + +/* + * The frag tree describes how a directory is fragmented, potentially across + * multiple metadata servers. It is also used to indicate points where + * metadata authority is delegated, and whether/where metadata is replicated. + * + * A _leaf_ frag will be present in the i_fragtree IFF there is + * delegation info. That is, if mds >= 0 || ndist > 0. + */ +#define MAX_DIRFRAG_REP 4 + +struct ceph_inode_frag { + struct rb_node node; + + /* fragtree state */ + u32 frag; + int split_by; /* i.e. 2^(split_by) children */ + + /* delegation info */ + int mds; /* -1 if same authority as parent */ + int ndist; /* >0 if replicated */ + int dist[MAX_DIRFRAG_REP]; +}; + + +/* + * Ceph inode. + */ +struct ceph_inode_info { + struct ceph_vino i_vino; /* ceph ino + snap */ + + u64 i_version; + u64 i_truncate_seq, i_time_warp_seq; + + struct ceph_file_layout i_layout; + char *i_symlink; + + /* for dirs */ + struct timespec i_rctime; + u64 i_rbytes, i_rfiles, i_rsubdirs; + u64 i_files, i_subdirs; + + + struct rb_root i_fragtree; + struct mutex i_fragtree_mutex; + + /* (still encoded) xattr blob. we avoid the overhead of parsing + * this until someone actually called getxattr, etc. */ + int i_xattr_len; + char *i_xattr_data; + + /* inode lease. protected _both_ by i_lock and i_lease_session's + * s_mutex. */ + int i_lease_mask; + struct ceph_mds_session *i_lease_session; + long unsigned i_lease_ttl; /* jiffies */ + u32 i_lease_gen; + struct list_head i_lease_item; /* mds session list */ + + /* capabilities. protected _both_ by i_lock and cap->session's + * s_mutex. */ + struct rb_root i_caps; /* cap list */ + wait_queue_head_t i_cap_wq; /* threads waiting on a capability */ + unsigned long i_hold_caps_until; /* jiffies */ + struct list_head i_cap_delay_list; /* for delayed cap release to mds */ + int i_cap_exporting_mds; /* to handle cap migration between */ + unsigned i_cap_exporting_mseq; /* mds's. */ + unsigned i_cap_exporting_issued; + struct list_head i_cap_snaps; /* snapped state pending flush to mds */ + struct ceph_snap_context *i_head_snapc; /* set if wr_buffer_head > 0 */ + unsigned i_snap_caps; /* cap bits for snapped files */ + + int i_nr_by_mode[CEPH_FILE_MODE_NUM]; /* open file counts */ + + loff_t i_max_size; /* max file size authorized by mds */ + loff_t i_reported_size; /* (max_)size reported to or requested of mds */ + loff_t i_wanted_max_size; /* offset we'd like to write too */ + loff_t i_requested_max_size; /* max_size we've requested */ + + struct timespec i_old_atime; + + /* held references to caps */ + int i_rd_ref, i_rdcache_ref, i_wr_ref; + int i_wrbuffer_ref, i_wrbuffer_ref_head; + u32 i_rdcache_gen; /* we increment this each time we get RDCACHE. + If it's non-zero, we _may_ have cached + pages. */ + u32 i_rdcache_revoking; /* RDCACHE gen to async invalidate, if any */ + + struct ceph_snap_realm *i_snap_realm; /* snap realm (if caps) */ + struct list_head i_snap_realm_item; + struct list_head i_snap_flush_item; + + struct work_struct i_wb_work; /* writeback work */ + struct work_struct i_pg_inv_work; /* page invalidation work */ + + loff_t i_vmtruncate_to; /* delayed truncate work */ + struct work_struct i_vmtruncate_work; + + struct inode vfs_inode; /* at end */ +}; + +static inline struct ceph_inode_info *ceph_inode(struct inode *inode) +{ + return list_entry(inode, struct ceph_inode_info, vfs_inode); +} + +/* find a specific frag @f */ +static inline struct ceph_inode_frag * +__ceph_find_frag(struct ceph_inode_info *ci, u32 f) +{ + struct rb_node *n = ci->i_fragtree.rb_node; + + while (n) { + struct ceph_inode_frag *frag = + rb_entry(n, struct ceph_inode_frag, node); + int c = frag_compare(f, frag->frag); + if (c < 0) + n = n->rb_left; + else if (c > 0) + n = n->rb_right; + else + return frag; + } + return NULL; +} + +/* + * choose fragment for value @v. copy frag content to pfrag, if leaf + * exists + */ +extern u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v, + struct ceph_inode_frag *pfrag, + int *found); + +/* + * Ceph dentry state + */ +struct ceph_dentry_info { + struct dentry *dentry; + struct ceph_mds_session *lease_session; + u32 lease_gen; + struct list_head lease_item; /* mds session list */ +}; + +static inline struct ceph_dentry_info *ceph_dentry(struct dentry *dentry) +{ + return (struct ceph_dentry_info *)dentry->d_fsdata; +} + + +/* + * ino_t is <64 bits on many architectures, blech. + * + * don't include snap in ino hash, at leaset for now. + */ +static inline ino_t ceph_vino_to_ino(struct ceph_vino vino) +{ + ino_t ino = (ino_t)vino.ino; /* ^ (vino.snap << 20); */ +#if BITS_PER_LONG == 32 + ino ^= vino.ino >> (sizeof(u64)-sizeof(ino_t)) * 8; +#endif + return ino; +} + +static inline int ceph_set_ino_cb(struct inode *inode, void *data) +{ + ceph_inode(inode)->i_vino = *(struct ceph_vino *)data; + inode->i_ino = ceph_vino_to_ino(*(struct ceph_vino *)data); + return 0; +} + +static inline struct ceph_vino ceph_vino(struct inode *inode) +{ + return ceph_inode(inode)->i_vino; +} + +/* for printf-style formatting */ +#define ceph_vinop(i) ceph_inode(i)->i_vino.ino, ceph_inode(i)->i_vino.snap + +static inline u64 ceph_ino(struct inode *inode) +{ + return ceph_inode(inode)->i_vino.ino; +} +static inline u64 ceph_snap(struct inode *inode) +{ + return ceph_inode(inode)->i_vino.snap; +} + +static inline int ceph_ino_compare(struct inode *inode, void *data) +{ + struct ceph_vino *pvino = (struct ceph_vino *)data; + struct ceph_inode_info *ci = ceph_inode(inode); + return ci->i_vino.ino == pvino->ino && + ci->i_vino.snap == pvino->snap; +} + +static inline struct inode *ceph_find_inode(struct super_block *sb, + struct ceph_vino vino) +{ + ino_t t = ceph_vino_to_ino(vino); + return ilookup5(sb, t, ceph_ino_compare, &vino); +} + + +/* + * caps helpers + */ +extern int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented); + +static inline int ceph_caps_issued(struct ceph_inode_info *ci) +{ + int issued; + spin_lock(&ci->vfs_inode.i_lock); + issued = __ceph_caps_issued(ci, NULL); + spin_unlock(&ci->vfs_inode.i_lock); + return issued; +} + +static inline int __ceph_caps_used(struct ceph_inode_info *ci) +{ + int used = 0; + if (ci->i_rd_ref) + used |= CEPH_CAP_RD; + if (ci->i_rdcache_ref || ci->i_rdcache_gen) + used |= CEPH_CAP_RDCACHE; + if (ci->i_wr_ref) + used |= CEPH_CAP_WR; + if (ci->i_wrbuffer_ref) + used |= CEPH_CAP_WRBUFFER; + return used; +} + +/* + * wanted, by virtue of open file modes + */ +static inline int __ceph_caps_file_wanted(struct ceph_inode_info *ci) +{ + int want = 0; + int mode; + for (mode = 0; mode < 4; mode++) + if (ci->i_nr_by_mode[mode]) + want |= ceph_caps_for_mode(mode); + return want; +} + +/* + * wanted, by virtual of open file modes AND cap refs (buffered/cached data) + */ +static inline int __ceph_caps_wanted(struct ceph_inode_info *ci) +{ + int w = __ceph_caps_file_wanted(ci) | __ceph_caps_used(ci); + if (w & CEPH_CAP_WRBUFFER) + w |= CEPH_CAP_EXCL; /* we want EXCL if we have dirty data */ + return w; +} + +/* for counting open files by mode */ +static inline void __ceph_get_fmode(struct ceph_inode_info *ci, int mode) +{ + ci->i_nr_by_mode[mode]++; +} +extern void ceph_put_fmode(struct ceph_inode_info *ci, int mode); + +static inline struct ceph_client *ceph_inode_to_client(struct inode *inode) +{ + return (struct ceph_client *)inode->i_sb->s_fs_info; +} + +static inline struct ceph_client *ceph_sb_to_client(struct super_block *sb) +{ + return (struct ceph_client *)sb->s_fs_info; +} + +static inline int ceph_queue_writeback(struct inode *inode) +{ + return queue_work(ceph_inode_to_client(inode)->wb_wq, + &ceph_inode(inode)->i_wb_work); +} + +static inline int ceph_queue_page_invalidation(struct inode *inode) +{ + return queue_work(ceph_inode_to_client(inode)->pg_inv_wq, + &ceph_inode(inode)->i_pg_inv_work); +} + + +/* + * keep readdir buffers attached to file->private_data + */ +struct ceph_file_info { + int mode; /* initialized on open */ + u32 frag; /* one frag at a time; screw seek_dir() on large dirs */ + struct ceph_mds_request *last_readdir; + + /* used for -o dirstat read() on directory thing */ + char *dir_info; + int dir_info_len; +}; + + + +/* + * snapshots + */ + +/* + * A "snap context" is the set of existing snapshots when we + * write data. It is used by the OSD to guide its COW behavior. + * + * The ceph_snap_context is refcounted, and attached to each dirty + * page, indicating which context the dirty data belonged when it was + * dirtied. + */ +struct ceph_snap_context { + atomic_t nref; + u64 seq; + int num_snaps; + u64 snaps[]; +}; + +static inline struct ceph_snap_context * +ceph_get_snap_context(struct ceph_snap_context *sc) +{ + /* + printk("get_snap_context %p %d -> %d\n", sc, atomic_read(&sc->nref), + atomic_read(&sc->nref)+1); + */ + if (sc) + atomic_inc(&sc->nref); + return sc; +} + +static inline void ceph_put_snap_context(struct ceph_snap_context *sc) +{ + if (!sc) + return; + /* + printk("put_snap_context %p %d -> %d\n", sc, atomic_read(&sc->nref), + atomic_read(&sc->nref)-1); + */ + if (atomic_dec_and_test(&sc->nref)) { + /*printk(" deleting snap_context %p\n", sc);*/ + kfree(sc); + } +} + +/* + * A "snap realm" describes a subset of the file hierarchy sharing + * the same set of snapshots that apply to it. The realms themselves + * are organized into a hierarchy, such that children inherit (some of) + * the snapshots of their parents. + * + * All inodes within the realm that have capabilities are linked into a + * per-realm list. + */ +struct ceph_snap_realm { + u64 ino; + int nref; + u64 created, seq; + u64 parent_ino; + u64 parent_since; /* snapid when our current parent became so */ + + u64 *prior_parent_snaps; /* snaps inherited from any parents we */ + int num_prior_parent_snaps; /* had prior to parent_since */ + u64 *snaps; /* snaps specific to this realm */ + int num_snaps; + + struct ceph_snap_realm *parent; + struct list_head children; /* list of child realms */ + struct list_head child_item; + + /* the current set of snaps for this realm */ + struct ceph_snap_context *cached_context; + + struct list_head inodes_with_caps; +}; + + + +/* + * calculate the number of pages a given length and offset map onto, + * if we align the data. + */ +static inline int calc_pages_for(u64 off, u64 len) +{ + return ((off+len+PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT) - + (off >> PAGE_CACHE_SHIFT); +} + + + +/* snap.c */ +extern void ceph_put_snap_realm(struct ceph_mds_client *mdsc, + struct ceph_snap_realm *realm); +extern struct ceph_snap_realm *ceph_update_snap_trace(struct ceph_mds_client *m, + void *p, void *e, + bool deletion); +extern void ceph_handle_snap(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); +extern void ceph_queue_cap_snap(struct ceph_inode_info *ci, + struct ceph_snap_context *snapc); +extern int __ceph_finish_cap_snap(struct ceph_inode_info *ci, + struct ceph_cap_snap *capsnap); + +/* + * a cap_snap is "pending" if it is still awaiting an in-progress + * sync write (that may/may not still update size, mtime, etc.). + */ +static inline bool __ceph_have_pending_cap_snap(struct ceph_inode_info *ci) +{ + return !list_empty(&ci->i_cap_snaps) && + list_entry(ci->i_cap_snaps.prev, struct ceph_cap_snap, + ci_item)->writing; +} + + +/* super.c */ +extern const char *ceph_msg_type_name(int type); + +/* inode.c */ +extern const struct inode_operations ceph_file_iops; +extern struct kmem_cache *ceph_inode_cachep; + +extern struct inode *ceph_alloc_inode(struct super_block *sb); +extern void ceph_destroy_inode(struct inode *inode); + +extern struct inode *ceph_get_inode(struct super_block *sb, + struct ceph_vino vino); +extern struct inode *ceph_get_snapdir(struct inode *parent); +extern int ceph_fill_inode(struct inode *inode, + struct ceph_mds_reply_info_in *iinfo, + struct ceph_mds_reply_dirfrag *dirinfo); +extern void ceph_fill_file_bits(struct inode *inode, int issued, + u64 truncate_seq, u64 size, + u64 time_warp_seq, struct timespec *ctime, + struct timespec *mtime, struct timespec *atime); +extern int ceph_fill_trace(struct super_block *sb, + struct ceph_mds_request *req, + struct ceph_mds_session *session); +extern int ceph_readdir_prepopulate(struct ceph_mds_request *req); + +extern int ceph_inode_lease_valid(struct inode *inode, int mask); +extern int ceph_dentry_lease_valid(struct dentry *dentry); + +extern void ceph_inode_set_size(struct inode *inode, loff_t size); +extern void ceph_inode_writeback(struct work_struct *work); +extern void ceph_vmtruncate_work(struct work_struct *work); +extern void __ceph_do_pending_vmtruncate(struct inode *inode); + +extern int ceph_do_getattr(struct dentry *dentry, int mask); +extern int ceph_setattr(struct dentry *dentry, struct iattr *attr); +extern int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry, + struct kstat *stat); +extern int ceph_setxattr(struct dentry *, const char *, const void *, + size_t, int); +extern ssize_t ceph_getxattr(struct dentry *, const char *, void *, size_t); +extern ssize_t ceph_listxattr(struct dentry *, char *, size_t); +extern int ceph_removexattr(struct dentry *, const char *); + +/* caps.c */ +extern void ceph_handle_caps(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); +extern int ceph_add_cap(struct inode *inode, + struct ceph_mds_session *session, + int fmode, unsigned issued, + unsigned cap, unsigned seq, + void *snapblob, int snapblob_len, + struct ceph_cap *new_cap); +extern void ceph_remove_cap(struct ceph_cap *cap); +extern int ceph_get_cap_mds(struct inode *inode); +extern int ceph_get_cap_refs(struct ceph_inode_info *ci, int need, int want, + int *got, loff_t offset); +extern void ceph_put_cap_refs(struct ceph_inode_info *ci, int had); +extern void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr, + struct ceph_snap_context *snapc); +extern void __ceph_flush_snaps(struct ceph_inode_info *ci, + struct ceph_mds_session **psession); +extern void ceph_check_caps(struct ceph_inode_info *ci, int delayed); +extern void ceph_check_delayed_caps(struct ceph_mds_client *mdsc); + +/* addr.c */ +extern const struct address_space_operations ceph_aops; +extern int ceph_mmap(struct file *file, struct vm_area_struct *vma); + +/* file.c */ +extern const struct file_operations ceph_file_fops; +extern const struct address_space_operations ceph_aops; +extern int ceph_open(struct inode *inode, struct file *file); +extern struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry, + struct nameidata *nd, int mode, + int locked_dir); +extern int ceph_release(struct inode *inode, struct file *filp); + + +/* dir.c */ +extern const struct file_operations ceph_dir_fops; +extern const struct inode_operations ceph_dir_iops; +extern struct dentry_operations ceph_dentry_ops, ceph_snap_dentry_ops, + ceph_snapdir_dentry_ops; + +extern char *ceph_build_path(struct dentry *dn, int *len, u64 *base, int min); +extern struct dentry *ceph_do_lookup(struct super_block *sb, + struct dentry *dentry, + int mask, int on_inode, int locked_dir); +extern struct dentry *ceph_finish_lookup(struct ceph_mds_request *req, + struct dentry *dentry, int err); + +/* + * our d_ops vary depending on whether the inode is live, + * snapshotted (read-only), or a virtual ".snap" directory. + */ +static inline void ceph_init_dentry(struct dentry *dentry) +{ + if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP) + dentry->d_op = &ceph_dentry_ops; + else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR) + dentry->d_op = &ceph_snapdir_dentry_ops; + else + dentry->d_op = &ceph_snap_dentry_ops; + dentry->d_time = 0; +} + +/* ioctl.c */ +extern long ceph_ioctl(struct file *file, unsigned int cmd, unsigned long arg); + +/* export.c */ +extern const struct export_operations ceph_export_ops; + +/* proc.c */ +extern int ceph_proc_init(void); +extern void ceph_proc_cleanup(void); + +#endif /* _FS_CEPH_SUPER_H */ diff --git a/fs/ceph/types.h b/fs/ceph/types.h new file mode 100644 index 0000000..3c874b7 --- /dev/null +++ b/fs/ceph/types.h @@ -0,0 +1,20 @@ +#ifndef _FS_CEPH_TYPES_H +#define _FS_CEPH_TYPES_H + +/* needed before including ceph_fs.h */ +#include <linux/in.h> +#include <linux/types.h> +#include <linux/fcntl.h> +#include <linux/string.h> + +#include "ceph_fs.h" + +/* + * Identify inodes by both their ino and snapshot id (a u64). + */ +struct ceph_vino { + u64 ino; + u64 snap; +}; + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 04/19] ceph: super.c 2008-11-14 0:56 ` [PATCH 03/19] ceph: client types Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 05/19] ceph: inode operations Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Mount option parsing, client setup and teardown, and a few odds and ends (e.g., statfs). Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/super.c | 1165 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1165 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/super.c diff --git a/fs/ceph/super.c b/fs/ceph/super.c new file mode 100644 index 0000000..235c091 --- /dev/null +++ b/fs/ceph/super.c @@ -0,0 +1,1165 @@ +#include <linux/module.h> +#include <linux/parser.h> +#include <linux/fs.h> +#include <linux/mount.h> +#include <linux/rwsem.h> +#include <linux/seq_file.h> +#include <linux/sched.h> +#include <linux/string.h> +#include <linux/version.h> +#include <linux/backing-dev.h> +#include <linux/statfs.h> + +/* debug levels; defined in super.h */ + +#include "ceph_debug.h" + +/* + * global debug value. + * 0 = quiet. + * + * if the per-file debug level >= 0, then that overrides this global + * debug level. + */ +int ceph_debug = 1; +int ceph_debug_mask = 0xffffffff; +/* if true, send output to KERN_INFO (console) instead of KERN_DEBUG. */ +int ceph_debug_console; +int ceph_debug_super = -1; /* for this file */ + +#define DOUT_MASK DOUT_MASK_SUPER +#define DOUT_VAR ceph_debug_super +#define DOUT_PREFIX "super: " +#include "super.h" + +#include "mon_client.h" + +void ceph_dispatch(void *p, struct ceph_msg *msg); +void ceph_peer_reset(void *p, struct ceph_entity_addr *peer_addr, + struct ceph_entity_name *peer_name); + + +/* + * super ops + */ +static int ceph_write_inode(struct inode *inode, int unused) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + + if (memcmp(&ci->i_old_atime, &inode->i_atime, sizeof(struct timeval))) { + dout(30, "ceph_write_inode %llx.%llx .. atime updated\n", + ceph_vinop(inode)); + /* maybe someday we will push this async to mds? */ + } + return 0; +} + +static void ceph_put_super(struct super_block *s) +{ + struct ceph_client *cl = ceph_client(s); + int rc; + int seconds = 15; + + dout(30, "put_super\n"); + ceph_mdsc_close_sessions(&cl->mdsc); + ceph_monc_request_umount(&cl->monc); + + if (cl->mount_state != CEPH_MOUNT_SHUTDOWN) { + rc = wait_event_timeout(cl->mount_wq, + (cl->mount_state == CEPH_MOUNT_UNMOUNTED), + seconds*HZ); + if (rc == 0) + derr(0, "umount timed out after %d seconds\n", seconds); + } + + return; +} + +static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf) +{ + struct ceph_client *client = ceph_inode_to_client(dentry->d_inode); + struct ceph_monmap *monmap = client->monc.monmap; + struct ceph_statfs st; + __le64 fsid; + int err; + + dout(30, "statfs\n"); + err = ceph_monc_do_statfs(&client->monc, &st); + if (err < 0) + return err; + + /* fill in kstatfs */ + buf->f_type = CEPH_SUPER_MAGIC; /* ?? */ + + /* + * express utilization in terms of large blocks to avoid + * overflow on 32-bit machines. + */ + buf->f_bsize = 1 << CEPH_BLOCK_SHIFT; /* 1 MB */ + buf->f_blocks = le64_to_cpu(st.f_total) >> (CEPH_BLOCK_SHIFT-10); + buf->f_bfree = le64_to_cpu(st.f_free) >> (CEPH_BLOCK_SHIFT-10); + buf->f_bavail = le64_to_cpu(st.f_avail) >> (CEPH_BLOCK_SHIFT-10); + + buf->f_files = le64_to_cpu(st.f_objects); + buf->f_ffree = -1; + buf->f_namelen = PATH_MAX; + buf->f_frsize = PAGE_CACHE_SIZE; + + /* leave in little-endian, regardless of host endianness */ + fsid = monmap->fsid.major ^ monmap->fsid.minor; + buf->f_fsid.val[0] = le64_to_cpu(fsid) & 0xffffffff; + buf->f_fsid.val[1] = le64_to_cpu(fsid) >> 32; + + return 0; +} + + +static int ceph_syncfs(struct super_block *sb, int wait) +{ + dout(10, "sync_fs %d\n", wait); + return 0; +} + + +/** + * ceph_show_options - Show mount options in /proc/mounts + * @m: seq_file to write to + * @mnt: mount descriptor + */ +static int ceph_show_options(struct seq_file *m, struct vfsmount *mnt) +{ + struct ceph_client *client = ceph_sb_to_client(mnt->mnt_sb); + struct ceph_mount_args *args = &client->mount_args; + + if (ceph_debug != 0) + seq_printf(m, ",debug=%d", ceph_debug); + if (args->flags & CEPH_MOUNT_FSID) + seq_printf(m, ",fsidmajor=%llu,fsidminor%llu", + args->fsid.major, args->fsid.minor); + if (args->flags & CEPH_MOUNT_NOSHARE) + seq_puts(m, ",noshare"); + if (args->flags & CEPH_MOUNT_UNSAFE_WRITEBACK) + seq_puts(m, ",unsafewriteback"); + if (args->flags & CEPH_MOUNT_DIRSTAT) + seq_puts(m, ",dirstat"); + else + seq_puts(m, ",nodirstat"); + if (args->flags & CEPH_MOUNT_RBYTES) + seq_puts(m, ",rbytes"); + else + seq_puts(m, ",norbytes"); + if (args->flags & CEPH_MOUNT_NOCRC) + seq_puts(m, ",nocrc"); + return 0; +} + + +/* + * inode cache + */ +struct kmem_cache *ceph_inode_cachep; + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) +static void init_once(void *foo) +#else +static void init_once(struct kmem_cache *cachep, void *foo) +#endif +{ + struct ceph_inode_info *ci = foo; + inode_init_once(&ci->vfs_inode); +} + +static int init_inodecache(void) +{ + ceph_inode_cachep = kmem_cache_create("ceph_inode_cache", + sizeof(struct ceph_inode_info), + 0, (SLAB_RECLAIM_ACCOUNT| + SLAB_MEM_SPREAD), + init_once); + if (ceph_inode_cachep == NULL) + return -ENOMEM; + return 0; +} + +static void destroy_inodecache(void) +{ + kmem_cache_destroy(ceph_inode_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; +} + + +static const struct super_operations ceph_super_ops = { + .alloc_inode = ceph_alloc_inode, + .destroy_inode = ceph_destroy_inode, + .write_inode = ceph_write_inode, + .sync_fs = ceph_syncfs, + .put_super = ceph_put_super, + .show_options = ceph_show_options, + .statfs = ceph_statfs, + .umount_begin = ceph_umount_begin, +}; + + + +/* + * the monitor responds with monmap to indicate mount success. + * (or, someday, to indicate a change in the monitor cluster) + */ +static void handle_monmap(struct ceph_client *client, struct ceph_msg *msg) +{ + int err; + int first = (client->monc.monmap->epoch == 0); + struct ceph_monmap *new, *old = client->monc.monmap; + + dout(2, "handle_monmap had epoch %d\n", client->monc.monmap->epoch); + new = ceph_monmap_decode(msg->front.iov_base, + msg->front.iov_base + msg->front.iov_len); + if (IS_ERR(new)) { + err = PTR_ERR(new); + derr(0, "problem decoding monmap, %d\n", err); + return; + } + client->monc.monmap = new; + kfree(old); + + if (first) { + char name[10]; + client->whoami = le32_to_cpu(msg->hdr.dst.name.num); + client->msgr->inst.name = msg->hdr.dst.name; + sprintf(name, "client%d", client->whoami); + dout(1, "i am %s, fsid is %llx.%llx\n", name, + le64_to_cpu(client->monc.monmap->fsid.major), + le64_to_cpu(client->monc.monmap->fsid.minor)); + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) + client->client_kobj = kobject_create_and_add(name, ceph_kobj); + /* + client->fsid_kobj = kobject_create_and_add("fsid", + client->client_kobj); + */ +#endif + } +} + +const char *ceph_msg_type_name(int type) +{ + switch (type) { + case CEPH_MSG_SHUTDOWN: return "shutdown"; + case CEPH_MSG_PING: return "ping"; + case CEPH_MSG_MON_MAP: return "mon_map"; + case CEPH_MSG_MON_GET_MAP: return "mon_get_map"; + case CEPH_MSG_CLIENT_MOUNT: return "client_mount"; + case CEPH_MSG_CLIENT_UNMOUNT: return "client_unmount"; + case CEPH_MSG_STATFS: return "statfs"; + case CEPH_MSG_STATFS_REPLY: return "statfs_reply"; + case CEPH_MSG_MDS_GETMAP: return "mds_getmap"; + case CEPH_MSG_MDS_MAP: return "mds_map"; + case CEPH_MSG_CLIENT_SESSION: return "client_session"; + case CEPH_MSG_CLIENT_RECONNECT: return "client_reconnect"; + case CEPH_MSG_CLIENT_REQUEST: return "client_request"; + case CEPH_MSG_CLIENT_REQUEST_FORWARD: return "client_request_forward"; + case CEPH_MSG_CLIENT_REPLY: return "client_reply"; + case CEPH_MSG_CLIENT_CAPS: return "client_caps"; + case CEPH_MSG_CLIENT_SNAP: return "client_snap"; + case CEPH_MSG_CLIENT_LEASE: return "client_lease"; + case CEPH_MSG_OSD_GETMAP: return "osd_getmap"; + case CEPH_MSG_OSD_MAP: return "osd_map"; + case CEPH_MSG_OSD_OP: return "osd_op"; + case CEPH_MSG_OSD_OPREPLY: return "osd_opreply"; + default: return "unknown"; + } +} + +/* + * Called when a message socket is explicitly reset by a peer. + */ +void ceph_peer_reset(void *p, struct ceph_entity_addr *peer_addr, + struct ceph_entity_name *peer_name) +{ + struct ceph_client *client = p; + + dout(30, "ceph_peer_reset %s%d\n", ENTITY_NAME(*peer_name)); + switch (le32_to_cpu(peer_name->type)) { + case CEPH_ENTITY_TYPE_MDS: + ceph_mdsc_handle_reset(&client->mdsc, + le32_to_cpu(peer_name->num)); + break; + case CEPH_ENTITY_TYPE_OSD: + ceph_osdc_handle_reset(&client->osdc, peer_addr); + break; + } +} + + +/* + * mount options + */ +enum { + Opt_fsidmajor, + Opt_fsidminor, + Opt_debug, + Opt_debug_console, + Opt_debug_msgr, + Opt_debug_mdsc, + Opt_debug_osdc, + Opt_debug_addr, + Opt_debug_inode, + Opt_debug_snap, + Opt_debug_ioctl, + Opt_debug_caps, + Opt_monport, + Opt_port, + Opt_wsize, + Opt_rsize, + Opt_osdtimeout, + Opt_mount_timeout, + /* int args above */ + Opt_ip, + Opt_noshare, + Opt_unsafewriteback, + Opt_safewriteback, + Opt_dirstat, + Opt_nodirstat, + Opt_rbytes, + Opt_norbytes, + Opt_nocrc, +}; + +static match_table_t arg_tokens = { + {Opt_fsidmajor, "fsidmajor=%ld"}, + {Opt_fsidminor, "fsidminor=%ld"}, + {Opt_debug, "debug=%d"}, + {Opt_debug_msgr, "debug_msgr=%d"}, + {Opt_debug_mdsc, "debug_mdsc=%d"}, + {Opt_debug_osdc, "debug_osdc=%d"}, + {Opt_debug_addr, "debug_addr=%d"}, + {Opt_debug_inode, "debug_inode=%d"}, + {Opt_debug_snap, "debug_snap=%d"}, + {Opt_debug_ioctl, "debug_ioctl=%d"}, + {Opt_debug_caps, "debug_caps=%d"}, + {Opt_monport, "monport=%d"}, + {Opt_port, "port=%d"}, + {Opt_wsize, "wsize=%d"}, + {Opt_rsize, "rsize=%d"}, + {Opt_osdtimeout, "osdtimeout=%d"}, + {Opt_mount_timeout, "mount_timeout=%d"}, + /* int args above */ + {Opt_ip, "ip=%s"}, + {Opt_debug_console, "debug_console"}, + {Opt_noshare, "noshare"}, + {Opt_unsafewriteback, "unsafewriteback"}, + {Opt_safewriteback, "safewriteback"}, + {Opt_dirstat, "dirstat"}, + {Opt_nodirstat, "nodirstat"}, + {Opt_rbytes, "rbytes"}, + {Opt_norbytes, "norbytes"}, + {Opt_nocrc, "nocrc"}, + {-1, NULL} +}; + +#define ADDR_DELIM(c) ((!c) || (c == ':') || (c == ',')) + +/* + * FIXME: add error checking to ip parsing + */ +static int parse_ip(const char *c, int len, struct ceph_entity_addr *addr, + int max_count, int *count) +{ + int i; + int v; + int mon_count; + unsigned ip = 0; + const char *p = c, *numstart; + + dout(15, "parse_ip on '%s' len %d\n", c, len); + for (mon_count = 0; mon_count < max_count; mon_count++) { + for (i = 0; !ADDR_DELIM(*p) && i < 4; i++) { + v = 0; + numstart = p; + while (!ADDR_DELIM(*p) && *p != '.' && p < c+len) { + if (*p < '0' || *p > '9') + goto bad; + v = (v * 10) + (*p - '0'); + p++; + } + if (v > 255 || numstart == p) + goto bad; + ip = (ip << 8) + v; + + if (*p == '.') + p++; + } + if (i != 4) + goto bad; + *(__be32 *)&addr[mon_count].ipaddr.sin_addr.s_addr = htonl(ip); + + /* port? */ + if (*p == ':') { + p++; + numstart = p; + v = 0; + while (!ADDR_DELIM(*p) && *p != '.' && p < c+len) { + if (*p < '0' || *p > '9') + goto bad; + v = (v * 10) + (*p - '0'); + p++; + } + if (v > 65535 || numstart == p) + goto bad; + addr[mon_count].ipaddr.sin_port = htons(v); + } else + addr[mon_count].ipaddr.sin_port = htons(CEPH_MON_PORT); + + dout(15, "parse_ip got %u.%u.%u.%u:%u\n", + IPQUADPORT(addr[mon_count].ipaddr)); + + if (*p != ',') + break; + p++; + } + + if (p < c+len) + goto bad; + + if (count) + *count = mon_count + 1; + + return 0; + +bad: + derr(1, "parse_ip bad ip '%s'\n", c); + return -EINVAL; +} + +static int parse_mount_args(int flags, char *options, const char *dev_name, + struct ceph_mount_args *args, const char **path) +{ + char *c; + int len, err; + substring_t argstr[MAX_OPT_ARGS]; + int i; + + dout(15, "parse_mount_args dev_name '%s'\n", dev_name); + memset(args, 0, sizeof(*args)); + + /* defaults */ + args->sb_flags = flags; + args->flags = CEPH_MOUNT_DEFAULT; + args->osd_timeout = 5; /* seconds */ + args->mount_timeout = 30; /* seconds */ + args->snapdir_name = ".snap"; + + /* ip1[:port1][,ip2[:port2]...]:/subdir/in/fs */ + c = strstr(dev_name, ":/"); + if (c == NULL) + return -EINVAL; + *c = 0; + + /* get mon ip(s) */ + len = c - dev_name; + err = parse_ip(dev_name, len, args->mon_addr, MAX_MON_MOUNT_ADDR, + &args->num_mon); + if (err < 0) + return err; + + for (i = 0; i < args->num_mon; i++) { + args->mon_addr[i].ipaddr.sin_family = AF_INET; + args->mon_addr[i].erank = 0; + args->mon_addr[i].nonce = 0; + } + args->my_addr.ipaddr.sin_family = AF_INET; + args->my_addr.ipaddr.sin_addr.s_addr = htonl(0); + args->my_addr.ipaddr.sin_port = htons(0); + + /* path on server */ + c++; + while (*c == '/') + c++; /* remove leading '/'(s) */ + *path = c; + dout(15, "server path '%s'\n", *path); + + /* parse mount options */ + while ((c = strsep(&options, ",")) != NULL) { + int token, intval, ret; + if (!*c) + continue; + token = match_token(c, arg_tokens, argstr); + if (token < 0) { + derr(0, "bad mount option at '%s'\n", c); + return -EINVAL; + + } + if (token < Opt_ip) { + ret = match_int(&argstr[0], &intval); + if (ret < 0) { + dout(0, "bad mount arg, not int\n"); + continue; + } + dout(30, "got token %d intval %d\n", token, intval); + } + switch (token) { + case Opt_fsidmajor: + args->fsid.major = cpu_to_le64(intval); + break; + case Opt_fsidminor: + args->fsid.minor = cpu_to_le64(intval); + break; + case Opt_port: + args->my_addr.ipaddr.sin_port = htons(intval); + break; + case Opt_ip: + err = parse_ip(argstr[0].from, + argstr[0].to-argstr[0].from, + &args->my_addr, + 1, NULL); + if (err < 0) + return err; + args->flags |= CEPH_MOUNT_MYIP; + break; + + /* debug levels */ + case Opt_debug: + ceph_debug = intval; + break; + case Opt_debug_msgr: + ceph_debug_msgr = intval; + break; + case Opt_debug_mdsc: + ceph_debug_mdsc = intval; + break; + case Opt_debug_osdc: + ceph_debug_osdc = intval; + break; + case Opt_debug_addr: + ceph_debug_addr = intval; + break; + case Opt_debug_inode: + ceph_debug_inode = intval; + break; + case Opt_debug_snap: + ceph_debug_snap = intval; + break; + case Opt_debug_ioctl: + ceph_debug_ioctl = intval; + break; + case Opt_debug_caps: + ceph_debug_caps = intval; + break; + case Opt_debug_console: + ceph_debug_console = 1; + break; + + /* misc */ + case Opt_wsize: + args->wsize = intval; + break; + case Opt_rsize: + args->rsize = intval; + break; + case Opt_osdtimeout: + args->osd_timeout = intval; + break; + case Opt_mount_timeout: + args->mount_timeout = intval; + break; + + case Opt_noshare: + args->flags |= CEPH_MOUNT_NOSHARE; + break; + case Opt_unsafewriteback: + args->flags |= CEPH_MOUNT_UNSAFE_WRITEBACK; + break; + case Opt_safewriteback: + args->flags &= ~CEPH_MOUNT_UNSAFE_WRITEBACK; + break; + + case Opt_dirstat: + args->flags |= CEPH_MOUNT_DIRSTAT; + break; + case Opt_nodirstat: + args->flags &= ~CEPH_MOUNT_DIRSTAT; + break; + case Opt_rbytes: + args->flags |= CEPH_MOUNT_RBYTES; + break; + case Opt_norbytes: + args->flags &= ~CEPH_MOUNT_RBYTES; + break; + case Opt_nocrc: + args->flags |= CEPH_MOUNT_NOCRC; + break; + + default: + BUG_ON(token); + } + } + + return 0; +} + +/* + * create a fresh client instance + */ +static struct ceph_client *ceph_create_client(void) +{ + struct ceph_client *client; + int err = -ENOMEM; + + client = kzalloc(sizeof(*client), GFP_KERNEL); + if (client == NULL) + return ERR_PTR(-ENOMEM); + + mutex_init(&client->mount_mutex); + + init_waitqueue_head(&client->mount_wq); + + client->sb = NULL; + client->mount_state = CEPH_MOUNT_MOUNTING; + client->whoami = -1; + + client->msgr = NULL; + + client->wb_wq = create_workqueue("ceph-writeback"); + if (client->wb_wq == NULL) + goto fail; + client->pg_inv_wq = create_workqueue("ceph-pg-invalid"); + if (client->pg_inv_wq == NULL) + goto fail; + client->trunc_wq = create_workqueue("ceph-trunc"); + if (client->trunc_wq == NULL) + goto fail; + + /* subsystems */ + err = ceph_monc_init(&client->monc, client); + if (err < 0) + return ERR_PTR(err); + ceph_mdsc_init(&client->mdsc, client); + ceph_osdc_init(&client->osdc, client); + + return client; + +fail: + return ERR_PTR(-ENOMEM); +} + +static void ceph_destroy_client(struct ceph_client *client) +{ + dout(10, "destroy_client %p\n", client); + + /* unmount */ + ceph_mdsc_stop(&client->mdsc); + ceph_monc_stop(&client->monc); + ceph_osdc_stop(&client->osdc); + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) + if (client->client_kobj) + kobject_put(client->client_kobj); +#endif + if (client->wb_wq) + destroy_workqueue(client->wb_wq); + if (client->pg_inv_wq) + destroy_workqueue(client->pg_inv_wq); + if (client->trunc_wq) + destroy_workqueue(client->trunc_wq); + if (client->msgr) + ceph_messenger_destroy(client->msgr); + kfree(client); + dout(10, "destroy_client %p done\n", client); +} + +/* + * true if we have the mon, osd, and mds maps, and are thus + * fully "mounted". + */ +static int have_all_maps(struct ceph_client *client) +{ + return client->osdc.osdmap && client->osdc.osdmap->epoch && + client->monc.monmap && client->monc.monmap->epoch && + client->mdsc.mdsmap && client->mdsc.mdsmap->m_epoch; +} + +/* + * Bootstrap mount by opening the root directory. Note the mount + * @started time from caller, and time out if this takes too long. + */ +static struct dentry *open_root_dentry(struct ceph_client *client, + const char *path, + unsigned long started) +{ + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req = NULL; + struct ceph_mds_request_head *reqhead; + int err; + struct dentry *root; + + /* open dir */ + dout(30, "open_root_inode opening '%s'\n", path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_OPEN, + 1, path, 0, NULL, + NULL, USE_ANY_MDS); + if (IS_ERR(req)) + return ERR_PTR(PTR_ERR(req)); + req->r_started = started; + req->r_timeout = client->mount_args.mount_timeout * HZ; + req->r_expected_cap = kmalloc(sizeof(struct ceph_cap), GFP_NOFS); + if (!req->r_expected_cap) { + root = ERR_PTR(-ENOMEM); + goto out; + } + reqhead = req->r_request->front.iov_base; + reqhead->args.open.flags = cpu_to_le32(O_DIRECTORY); + reqhead->args.open.mode = 0; + err = ceph_mdsc_do_request(mdsc, req); + if (err == 0) { + root = req->r_last_dentry; + dget(root); + dout(30, "open_root_inode success, root dentry is %p\n", root); + } else + root = ERR_PTR(err); +out: + ceph_mdsc_put_request(req); + return root; +} + +/* + * mount: join the ceph cluster. + */ +static int ceph_mount(struct ceph_client *client, struct vfsmount *mnt, + const char *path) +{ + struct ceph_entity_addr *myaddr = NULL; + struct ceph_msg *mount_msg; + struct dentry *root; + int err; + int request_interval = 5 * HZ; + unsigned long timeout = client->mount_args.mount_timeout * HZ; + unsigned long started = jiffies; /* note the start time */ + int which; + unsigned char r; + + dout(10, "mount start\n"); + mutex_lock(&client->mount_mutex); + + /* initialize the messenger */ + if (client->msgr == NULL) { + if (client->mount_args.flags & CEPH_MOUNT_MYIP) + myaddr = &client->mount_args.my_addr; + client->msgr = ceph_messenger_create(myaddr); + if (IS_ERR(client->msgr)) { + err = PTR_ERR(client->msgr); + client->msgr = NULL; + goto out; + } + client->msgr->parent = client; + client->msgr->dispatch = ceph_dispatch; + client->msgr->prepare_pages = ceph_osdc_prepare_pages; + client->msgr->peer_reset = ceph_peer_reset; + } + + /* send mount request, and wait for mon, mds, and osd maps */ + while (!have_all_maps(client)) { + err = -EIO; + if (timeout && time_after_eq(jiffies, started + timeout)) + goto out; + dout(10, "mount sending mount request\n"); + get_random_bytes(&r, 1); + which = r % client->mount_args.num_mon; + mount_msg = ceph_msg_new(CEPH_MSG_CLIENT_MOUNT, 0, 0, 0, NULL); + if (IS_ERR(mount_msg)) { + err = PTR_ERR(mount_msg); + goto out; + } + mount_msg->hdr.dst.name.type = + cpu_to_le32(CEPH_ENTITY_TYPE_MON); + mount_msg->hdr.dst.name.num = cpu_to_le32(which); + mount_msg->hdr.dst.addr = client->mount_args.mon_addr[which]; + + ceph_msg_send(client->msgr, mount_msg, 0); + + /* wait */ + dout(10, "mount sent to mon%d, waiting for maps\n", which); + err = wait_event_interruptible_timeout(client->mount_wq, + have_all_maps(client), + request_interval); + if (err == -EINTR) + goto out; + } + + dout(30, "mount opening base mountpoint\n"); + root = open_root_dentry(client, path, started); + if (IS_ERR(root)) { + err = PTR_ERR(root); + goto out; + } + + /* + * Drop the reference we just got, since the VFS doesn't give + * us a reliable way to drop it later when a particular + * vfsmount goes away. If the directory we just mounted on is + * renamed on the server, we are screwed. + */ + ceph_put_fmode(ceph_inode(root->d_inode), CEPH_FILE_MODE_PIN); + + mnt->mnt_root = root; + mnt->mnt_sb = client->sb; + client->mount_state = CEPH_MOUNT_MOUNTED; + dout(10, "mount success\n"); + err = 0; + +out: + mutex_unlock(&client->mount_mutex); + return err; +} + + +/* + * Process an incoming message. + * + * This should be relatively fast and must not do any work that waits + * on other messages to be received. + */ +void ceph_dispatch(void *p, struct ceph_msg *msg) +{ + struct ceph_client *client = p; + int had; + int type = le16_to_cpu(msg->hdr.type); + + switch (type) { + case CEPH_MSG_MON_MAP: + had = client->monc.monmap->epoch ? 1 : 0; + handle_monmap(client, msg); + if (!had && client->monc.monmap->epoch && have_all_maps(client)) + wake_up(&client->mount_wq); + break; + + /* mon client */ + case CEPH_MSG_STATFS_REPLY: + ceph_monc_handle_statfs_reply(&client->monc, msg); + break; + case CEPH_MSG_CLIENT_UNMOUNT: + ceph_monc_handle_umount(&client->monc, msg); + break; + + /* mds client */ + case CEPH_MSG_MDS_MAP: + had = client->mdsc.mdsmap ? 1 : 0; + ceph_mdsc_handle_map(&client->mdsc, msg); + if (!had && client->mdsc.mdsmap && have_all_maps(client)) + wake_up(&client->mount_wq); + break; + case CEPH_MSG_CLIENT_SESSION: + ceph_mdsc_handle_session(&client->mdsc, msg); + break; + case CEPH_MSG_CLIENT_REPLY: + ceph_mdsc_handle_reply(&client->mdsc, msg); + break; + case CEPH_MSG_CLIENT_REQUEST_FORWARD: + ceph_mdsc_handle_forward(&client->mdsc, msg); + break; + case CEPH_MSG_CLIENT_CAPS: + ceph_handle_caps(&client->mdsc, msg); + break; + case CEPH_MSG_CLIENT_SNAP: + ceph_handle_snap(&client->mdsc, msg); + break; + case CEPH_MSG_CLIENT_LEASE: + ceph_mdsc_handle_lease(&client->mdsc, msg); + break; + + /* osd client */ + case CEPH_MSG_OSD_MAP: + had = client->osdc.osdmap ? 1 : 0; + ceph_osdc_handle_map(&client->osdc, msg); + if (!had && client->osdc.osdmap && have_all_maps(client)) + wake_up(&client->mount_wq); + break; + case CEPH_MSG_OSD_OPREPLY: + ceph_osdc_handle_reply(&client->osdc, msg); + break; + + default: + derr(0, "received unknown message type %d %s\n", type, + ceph_msg_type_name(type)); + } + + ceph_msg_put(msg); +} + + +static int ceph_set_super(struct super_block *s, void *data) +{ + struct ceph_client *client = data; + int ret; + + dout(10, "set_super %p data %p\n", s, data); + + s->s_flags = client->mount_args.sb_flags; + s->s_maxbytes = min((u64)MAX_LFS_FILESIZE, CEPH_FILE_MAX_SIZE); + + s->s_fs_info = client; + client->sb = s; + + s->s_op = &ceph_super_ops; + s->s_export_op = &ceph_export_ops; + + s->s_time_gran = 1000; /* 1000 ns == 1 us */ + + ret = set_anon_super(s, NULL); /* what is that second arg for? */ + if (ret != 0) + goto fail; + + return ret; + +fail: + s->s_fs_info = NULL; + client->sb = NULL; + return ret; +} + +/* + * share superblock if same fs AND options + */ +static int ceph_compare_super(struct super_block *sb, void *data) +{ + struct ceph_client *new = data; + struct ceph_mount_args *args = &new->mount_args; + struct ceph_client *other = ceph_sb_to_client(sb); + int i; + dout(10, "ceph_compare_super %p\n", sb); + + /* either compare fsid, or specified mon_hostname */ + if (args->flags & CEPH_MOUNT_FSID) { + if (!ceph_fsid_equal(&args->fsid, &other->fsid)) { + dout(30, "fsid doesn't match\n"); + return 0; + } + } else { + /* do we share (a) monitor? */ + for (i = 0; i < args->num_mon; i++) + if (ceph_monmap_contains(other->monc.monmap, + &args->mon_addr[i])) + break; + if (i == args->num_mon) { + dout(30, "mon ip not part of monmap\n"); + return 0; + } + dout(10, "mon ip matches existing sb %p\n", sb); + } + if (args->sb_flags != other->mount_args.sb_flags) { + dout(30, "flags differ\n"); + return 0; + } + return 1; +} + +/* + * construct our own bdi so we can control readahead + */ +static int ceph_init_bdi(struct super_block *sb, struct ceph_client *client) +{ + int err; + + if (client->mount_args.rsize) + client->backing_dev_info.ra_pages = + (client->mount_args.rsize + PAGE_CACHE_SIZE - 1) + >> PAGE_SHIFT; + + if (client->backing_dev_info.ra_pages < (PAGE_CACHE_SIZE >> PAGE_SHIFT)) + client->backing_dev_info.ra_pages = + CEPH_DEFAULT_READ_SIZE >> PAGE_SHIFT; + + 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; +} + +static int ceph_get_sb(struct file_system_type *fs_type, + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) +{ + struct super_block *sb; + struct ceph_client *client; + int err; + int (*compare_super)(struct super_block *, void *) = ceph_compare_super; + const char *path; + + dout(25, "ceph_get_sb\n"); + + /* create client (which we may/may not use) */ + client = ceph_create_client(); + if (IS_ERR(client)) + return PTR_ERR(client); + + err = parse_mount_args(flags, data, dev_name, + &client->mount_args, &path); + if (err < 0) + goto out; + + if (client->mount_args.flags & CEPH_MOUNT_NOSHARE) + compare_super = NULL; + + sb = sget(fs_type, compare_super, ceph_set_super, client); + if (IS_ERR(sb)) { + err = PTR_ERR(sb); + goto out; + } + + if (ceph_client(sb) != client) { + ceph_destroy_client(client); + client = ceph_client(sb); + dout(20, "get_sb got existing client %p\n", client); + } else { + dout(20, "get_sb using new client %p\n", client); + + err = ceph_init_bdi(sb, client); + if (err < 0) + goto out_splat; + } + + err = ceph_mount(client, mnt, path); + if (err < 0) + goto out_splat; + dout(22, "root ino %llx.%llx\n", ceph_vinop(mnt->mnt_root->d_inode)); + return 0; + +out_splat: + up_write(&sb->s_umount); + deactivate_super(sb); + goto out_final; +out: + ceph_destroy_client(client); +out_final: + dout(25, "ceph_get_sb fail %d\n", err); + return err; +} + +static void ceph_kill_sb(struct super_block *s) +{ + 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); +} + + +/************************************/ + +static struct file_system_type ceph_fs_type = { + .owner = THIS_MODULE, + .name = "ceph", + .get_sb = ceph_get_sb, + .kill_sb = ceph_kill_sb, + .fs_flags = FS_RENAME_DOES_D_MOVE, +}; + +struct kobject *ceph_kobj; + +static int __init init_ceph(void) +{ + int ret = 0; + + dout(1, "init_ceph\n"); + +#ifdef CONFIG_CEPH_BOOKKEEPER + ceph_bookkeeper_init(); +#endif + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) + ret = -ENOMEM; + ceph_kobj = kobject_create_and_add("ceph", fs_kobj); + if (!ceph_kobj) + goto out; +#endif + + ret = ceph_proc_init(); + if (ret < 0) + goto out_kobj; + + ret = ceph_msgr_init(); + if (ret < 0) + goto out_proc; + + ret = init_inodecache(); + if (ret) + goto out_msgr; + + ret = register_filesystem(&ceph_fs_type); + if (ret) + goto out_icache; + return 0; + +out_icache: + destroy_inodecache(); +out_msgr: + ceph_msgr_exit(); +out_proc: + ceph_proc_cleanup(); +out_kobj: +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) + kobject_put(ceph_kobj); + ceph_kobj = NULL; +out: +#endif + return ret; +} + +static void __exit exit_ceph(void) +{ + dout(1, "exit_ceph\n"); + unregister_filesystem(&ceph_fs_type); + destroy_inodecache(); + ceph_msgr_exit(); + ceph_proc_cleanup(); +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25) + kobject_put(ceph_kobj); + ceph_kobj = NULL; +#endif +#ifdef CONFIG_CEPH_BOOKKEEPER + ceph_bookkeeper_finalize(); +#endif +} + +module_init(init_ceph); +module_exit(exit_ceph); + +MODULE_AUTHOR("Patience Warnick <patience@newdream.net>"); +MODULE_AUTHOR("Sage Weil <sage@newdream.net>"); +MODULE_DESCRIPTION("Ceph filesystem for Linux"); +MODULE_LICENSE("GPL"); -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 05/19] ceph: inode operations 2008-11-14 0:56 ` [PATCH 04/19] ceph: super.c Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 06/19] ceph: directory operations Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Inode cache and inode operations. We also include routines to incorporate metadata structures returned by the MDS into the client cache, and some helpers to deal with file capabilities and metadata leases. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/inode.c | 2070 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 2070 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/inode.c diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c new file mode 100644 index 0000000..c1d2286 --- /dev/null +++ b/fs/ceph/inode.c @@ -0,0 +1,2070 @@ +#include <linux/module.h> +#include <linux/fs.h> +#include <linux/smp_lock.h> +#include <linux/slab.h> +#include <linux/string.h> +#include <linux/uaccess.h> +#include <linux/kernel.h> +#include <linux/namei.h> +#include <linux/writeback.h> + +#include "ceph_debug.h" + +int ceph_debug_inode = -1; +#define DOUT_MASK DOUT_MASK_INODE +#define DOUT_VAR ceph_debug_inode +#define DOUT_PREFIX "inode: " +#include "super.h" +#include "decode.h" + +static const struct inode_operations ceph_symlink_iops; + +static void ceph_inode_invalidate_pages(struct work_struct *work); + + +/* + * find or create an inode, given the ceph ino number + */ +struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino) +{ + struct inode *inode; + ino_t t = ceph_vino_to_ino(vino); + + inode = iget5_locked(sb, t, ceph_ino_compare, ceph_set_ino_cb, &vino); + if (inode == NULL) + return ERR_PTR(-ENOMEM); + if (inode->i_state & I_NEW) { + dout(40, "get_inode created new inode %p %llx.%llx ino %llx\n", + inode, ceph_vinop(inode), (u64)inode->i_ino); + unlock_new_inode(inode); + } + + dout(30, "get_inode on %lu=%llx.%llx got %p\n", inode->i_ino, vino.ino, + vino.snap, inode); + return inode; +} + +/* + * get/constuct snapdir inode for a given directory + */ +struct inode *ceph_get_snapdir(struct inode *parent) +{ + struct ceph_vino vino = { + .ino = ceph_ino(parent), + .snap = CEPH_SNAPDIR, + }; + struct inode *inode = ceph_get_inode(parent->i_sb, vino); + if (IS_ERR(inode)) + return ERR_PTR(PTR_ERR(inode)); + inode->i_mode = parent->i_mode; + inode->i_uid = parent->i_uid; + inode->i_gid = parent->i_gid; + inode->i_op = &ceph_dir_iops; + inode->i_fop = &ceph_dir_fops; + ceph_inode(inode)->i_snap_caps = CEPH_CAP_PIN; /* so we can open */ + return inode; +} + + +const struct inode_operations ceph_file_iops = { + .setattr = ceph_setattr, + .getattr = ceph_getattr, + .setxattr = ceph_setxattr, + .getxattr = ceph_getxattr, + .listxattr = ceph_listxattr, + .removexattr = ceph_removexattr, +}; + + +/* + * find/create a frag in the tree + */ +static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci, + u32 f) +{ + struct rb_node **p; + struct rb_node *parent = NULL; + struct ceph_inode_frag *frag; + int c; + + p = &ci->i_fragtree.rb_node; + while (*p) { + parent = *p; + frag = rb_entry(parent, struct ceph_inode_frag, node); + c = frag_compare(f, frag->frag); + if (c < 0) + p = &(*p)->rb_left; + else if (c > 0) + p = &(*p)->rb_right; + else + return frag; + } + + frag = kmalloc(sizeof(*frag), GFP_NOFS); + if (!frag) { + derr(0, "ENOMEM on %p %llx.%llx frag %x\n", &ci->vfs_inode, + ceph_vinop(&ci->vfs_inode), f); + return ERR_PTR(-ENOMEM); + } + frag->frag = f; + frag->split_by = 0; + frag->mds = -1; + frag->ndist = 0; + + rb_link_node(&frag->node, parent, p); + rb_insert_color(&frag->node, &ci->i_fragtree); + + dout(20, "get_or_create_frag added %llx.%llx frag %x\n", + ceph_vinop(&ci->vfs_inode), f); + + return frag; +} + +/* + * Choose frag containing the given value @v. If @pfrag is + * specified, copy the frag delegation info to the caller if + * it is present. + */ +u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v, + struct ceph_inode_frag *pfrag, + int *found) +{ + u32 t = frag_make(0, 0); + struct ceph_inode_frag *frag; + unsigned nway, i; + u32 n; + + if (found) + *found = 0; + + mutex_lock(&ci->i_fragtree_mutex); + while (1) { + WARN_ON(!frag_contains_value(t, v)); + frag = __ceph_find_frag(ci, t); + if (!frag) + break; /* t is a leaf */ + if (frag->split_by == 0) { + if (pfrag) + memcpy(pfrag, frag, sizeof(*pfrag)); + if (found) + *found = 1; + break; + } + + /* choose child */ + nway = 1 << frag->split_by; + dout(30, "choose_frag(%x) %x splits by %d (%d ways)\n", v, t, + frag->split_by, nway); + for (i = 0; i < nway; i++) { + n = frag_make_child(t, frag->split_by, i); + if (frag_contains_value(n, v)) { + t = n; + break; + } + } + BUG_ON(i == nway); + } + dout(30, "choose_frag(%x) = %x\n", v, t); + + mutex_unlock(&ci->i_fragtree_mutex); + return t; +} + +/* + * Process dirfrag (delegation) info from the mds. Include leaf + * fragment in tree ONLY if mds >= 0 || ndist > 0. Otherwise, only + * branches/splits are included in i_fragtree) + */ +static int ceph_fill_dirfrag(struct inode *inode, + struct ceph_mds_reply_dirfrag *dirinfo) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_inode_frag *frag; + u32 id = le32_to_cpu(dirinfo->frag); + int mds = le32_to_cpu(dirinfo->auth); + int ndist = le32_to_cpu(dirinfo->ndist); + int i; + int err = 0; + + mutex_lock(&ci->i_fragtree_mutex); + if (mds < 0 && ndist == 0) { + /* no delegation info needed. */ + frag = __ceph_find_frag(ci, id); + if (!frag) + goto out; + if (frag->split_by == 0) { + /* tree leaf, remove */ + dout(20, "fill_dirfrag removed %llx.%llx frag %x" + " (no ref)\n", ceph_vinop(inode), id); + rb_erase(&frag->node, &ci->i_fragtree); + kfree(frag); + } else { + /* tree branch, keep and clear */ + dout(20, "fill_dirfrag cleared %llx.%llx frag %x" + " referral\n", ceph_vinop(inode), id); + frag->mds = -1; + frag->ndist = 0; + } + goto out; + } + + + /* find/add this frag to store mds delegation info */ + frag = __get_or_create_frag(ci, id); + if (IS_ERR(frag)) { + /* this is not the end of the world; we can continue + with bad/inaccurate delegation info */ + derr(0, "fill_dirfrag ENOMEM on mds ref %llx.%llx frag %x\n", + ceph_vinop(inode), le32_to_cpu(dirinfo->frag)); + err = -ENOMEM; + goto out; + } + + frag->mds = mds; + frag->ndist = min_t(u32, ndist, MAX_DIRFRAG_REP); + for (i = 0; i < frag->ndist; i++) + frag->dist[i] = le32_to_cpu(dirinfo->dist[i]); + dout(20, "fill_dirfrag %llx.%llx frag %x referral mds %d ndist=%d\n", + ceph_vinop(inode), frag->frag, frag->mds, frag->ndist); + +out: + mutex_unlock(&ci->i_fragtree_mutex); + return err; +} + + +/* + * initialize a newly allocated inode. + */ +struct inode *ceph_alloc_inode(struct super_block *sb) +{ + struct ceph_inode_info *ci; + int i; + + ci = kmem_cache_alloc(ceph_inode_cachep, GFP_NOFS); + if (!ci) + return NULL; + + dout(10, "alloc_inode %p\n", &ci->vfs_inode); + + ci->i_version = 0; + ci->i_truncate_seq = 0; + ci->i_time_warp_seq = 0; + ci->i_symlink = NULL; + + ci->i_lease_session = NULL; + ci->i_lease_mask = 0; + ci->i_lease_ttl = 0; + INIT_LIST_HEAD(&ci->i_lease_item); + + ci->i_fragtree = RB_ROOT; + mutex_init(&ci->i_fragtree_mutex); + + ci->i_xattr_len = 0; + ci->i_xattr_data = NULL; + + ci->i_caps = RB_ROOT; + for (i = 0; i < CEPH_FILE_MODE_NUM; i++) + ci->i_nr_by_mode[i] = 0; + init_waitqueue_head(&ci->i_cap_wq); + INIT_LIST_HEAD(&ci->i_cap_snaps); + ci->i_snap_caps = 0; + ci->i_head_snapc = NULL; + + ci->i_wanted_max_size = 0; + ci->i_requested_max_size = 0; + + ci->i_cap_exporting_mds = 0; + ci->i_cap_exporting_mseq = 0; + ci->i_cap_exporting_issued = 0; + + ci->i_rd_ref = 0; + ci->i_rdcache_ref = 0; + ci->i_wr_ref = 0; + ci->i_wrbuffer_ref = 0; + ci->i_wrbuffer_ref_head = 0; + ci->i_rdcache_gen = 0; + ci->i_rdcache_revoking = 0; + ci->i_hold_caps_until = 0; + INIT_LIST_HEAD(&ci->i_cap_delay_list); + + ci->i_snap_realm = NULL; + INIT_LIST_HEAD(&ci->i_snap_realm_item); + INIT_LIST_HEAD(&ci->i_snap_flush_item); + + INIT_WORK(&ci->i_wb_work, ceph_inode_writeback); + INIT_WORK(&ci->i_pg_inv_work, ceph_inode_invalidate_pages); + + ci->i_vmtruncate_to = -1; + INIT_WORK(&ci->i_vmtruncate_work, ceph_vmtruncate_work); + + return &ci->vfs_inode; +} + +void ceph_destroy_inode(struct inode *inode) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_inode_frag *frag; + struct rb_node *n; + + dout(30, "destroy_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode)); + kfree(ci->i_symlink); + while ((n = rb_first(&ci->i_fragtree)) != NULL) { + frag = rb_entry(n, struct ceph_inode_frag, node); + rb_erase(n, &ci->i_fragtree); + kfree(frag); + } + kfree(ci->i_xattr_data); + kmem_cache_free(ceph_inode_cachep, ci); +} + + +/* + * Helper to fill in size, ctime, mtime, and atime. We have to be + * careful because either the client or MDS may have more up to date + * info, depending on which capabilities are held, and whether + * time_warp_seq or truncate_seq have increased. Ordinarily, mtime + * and size are monotonically increasing, except when utimes() or + * truncate() increments the corresponding _seq values on the MDS. + */ +void ceph_fill_file_bits(struct inode *inode, int issued, + u64 truncate_seq, u64 size, + u64 time_warp_seq, struct timespec *ctime, + struct timespec *mtime, struct timespec *atime) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int warn = 0; + + if (truncate_seq > ci->i_truncate_seq || + (truncate_seq == ci->i_truncate_seq && size > inode->i_size)) { + dout(10, "size %lld -> %llu\n", inode->i_size, size); + inode->i_size = size; + inode->i_blocks = (size + (1<<9) - 1) >> 9; + ci->i_reported_size = size; + ci->i_truncate_seq = truncate_seq; + } + + if (issued & CEPH_CAP_EXCL) { + /* + * if we hold EXCL cap, we have the most up to date + * values for everything except possibly ctime. + */ + if (timespec_compare(ctime, &inode->i_ctime) > 0) + inode->i_ctime = *ctime; + if (time_warp_seq > ci->i_time_warp_seq) + derr(0, "WARNING: %p mds time_warp_seq %llu > %llu\n", + inode, time_warp_seq, ci->i_time_warp_seq); + } else if (issued & (CEPH_CAP_WR|CEPH_CAP_WRBUFFER)) { + if (time_warp_seq > ci->i_time_warp_seq) { + /* the MDS did a utimes() */ + inode->i_ctime = *ctime; + inode->i_mtime = *mtime; + inode->i_atime = *atime; + ci->i_time_warp_seq = time_warp_seq; + } else if (time_warp_seq == ci->i_time_warp_seq) { + if (timespec_compare(ctime, &inode->i_ctime) > 0) + inode->i_ctime = *ctime; + if (timespec_compare(mtime, &inode->i_mtime) > 0) + inode->i_mtime = *mtime; + if (timespec_compare(atime, &inode->i_atime) > 0) + inode->i_atime = *atime; + } else { + warn = 1; + } + } else { + /* we have no write caps; whatever the MDS says is true */ + if (time_warp_seq >= ci->i_time_warp_seq) { + inode->i_ctime = *ctime; + inode->i_mtime = *mtime; + inode->i_atime = *atime; + ci->i_time_warp_seq = time_warp_seq; + } else { + warn = 1; + } + } + if (warn) /* time_warp_seq shouldn't go backwards */ + dout(10, "%p mds time_warp_seq %llu < %llu\n", + inode, time_warp_seq, ci->i_time_warp_seq); +} + +/* + * populate an inode based on info from mds. + * may be called on new or existing inodes. + */ +int ceph_fill_inode(struct inode *inode, + struct ceph_mds_reply_info_in *iinfo, + struct ceph_mds_reply_dirfrag *dirinfo) +{ + struct ceph_mds_reply_inode *info = iinfo->in; + struct ceph_inode_info *ci = ceph_inode(inode); + int i; + int issued; + struct timespec mtime, atime, ctime; + u32 nsplits; + void *xattr_data = NULL; + int err = 0; + + dout(30, "fill_inode %p ino %llx.%llx v %llu had %llu\n", + inode, ceph_vinop(inode), le64_to_cpu(info->version), + ci->i_version); + + /* prealloc xattr data, if it looks like we'll need it */ + if (iinfo->xattr_len && iinfo->xattr_len != ci->i_xattr_len) { + xattr_data = kmalloc(iinfo->xattr_len, GFP_NOFS); + if (!xattr_data) + derr(10, "ENOMEM on xattr blob %d bytes\n", + ci->i_xattr_len); + } + + spin_lock(&inode->i_lock); + + if (le64_to_cpu(info->version) > 0 && + ci->i_version == le64_to_cpu(info->version)) + goto no_change; + + /* update inode */ + ci->i_version = le64_to_cpu(info->version); + inode->i_version++; + inode->i_mode = le32_to_cpu(info->mode); + inode->i_uid = le32_to_cpu(info->uid); + inode->i_gid = le32_to_cpu(info->gid); + inode->i_nlink = le32_to_cpu(info->nlink); + inode->i_rdev = le32_to_cpu(info->rdev); + + /* be careful with mtime, atime, size */ + ceph_decode_timespec(&atime, &info->atime); + ceph_decode_timespec(&mtime, &info->mtime); + ceph_decode_timespec(&ctime, &info->ctime); + issued = __ceph_caps_issued(ci, NULL); + ceph_fill_file_bits(inode, issued, + le64_to_cpu(info->truncate_seq), + le64_to_cpu(info->size), + le64_to_cpu(info->time_warp_seq), + &ctime, &mtime, &atime); + + ci->i_max_size = le64_to_cpu(info->max_size); + ci->i_layout = info->layout; + inode->i_blkbits = fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1; + + /* xattrs */ + if (iinfo->xattr_len) { + if (ci->i_xattr_len != iinfo->xattr_len) { + kfree(ci->i_xattr_data); + ci->i_xattr_len = iinfo->xattr_len; + ci->i_xattr_data = xattr_data; + xattr_data = NULL; + } + if (ci->i_xattr_len) + memcpy(ci->i_xattr_data, iinfo->xattr_data, + ci->i_xattr_len); + } + + ci->i_old_atime = inode->i_atime; + + inode->i_mapping->a_ops = &ceph_aops; + inode->i_mapping->backing_dev_info = + &ceph_client(inode->i_sb)->backing_dev_info; + +no_change: + spin_unlock(&inode->i_lock); + + /* populate frag tree */ + /* FIXME: move me up, if/when version reflects fragtree changes */ + nsplits = le32_to_cpu(info->fragtree.nsplits); + mutex_lock(&ci->i_fragtree_mutex); + for (i = 0; i < nsplits; i++) { + u32 id = le32_to_cpu(info->fragtree.splits[i].frag); + struct ceph_inode_frag *frag = __get_or_create_frag(ci, id); + + if (IS_ERR(frag)) + continue; + frag->split_by = le32_to_cpu(info->fragtree.splits[i].by); + dout(20, " frag %x split by %d\n", frag->frag, frag->split_by); + } + mutex_unlock(&ci->i_fragtree_mutex); + + /* update delegation info? */ + if (dirinfo) + ceph_fill_dirfrag(inode, dirinfo); + + switch (inode->i_mode & S_IFMT) { + case S_IFIFO: + case S_IFBLK: + case S_IFCHR: + case S_IFSOCK: + init_special_inode(inode, inode->i_mode, inode->i_rdev); + inode->i_op = &ceph_file_iops; + break; + case S_IFREG: + inode->i_op = &ceph_file_iops; + inode->i_fop = &ceph_file_fops; + break; + case S_IFLNK: + inode->i_op = &ceph_symlink_iops; + if (!ci->i_symlink) { + int symlen = iinfo->symlink_len; + + BUG_ON(symlen != inode->i_size); + err = -ENOMEM; + ci->i_symlink = kmalloc(symlen+1, GFP_NOFS); + if (!ci->i_symlink) + goto out; + memcpy(ci->i_symlink, iinfo->symlink, symlen); + ci->i_symlink[symlen] = 0; + } + break; + case S_IFDIR: + inode->i_op = &ceph_dir_iops; + inode->i_fop = &ceph_dir_fops; + + ci->i_files = le64_to_cpu(info->files); + ci->i_subdirs = le64_to_cpu(info->subdirs); + ci->i_rbytes = le64_to_cpu(info->rbytes); + ci->i_rfiles = le64_to_cpu(info->rfiles); + ci->i_rsubdirs = le64_to_cpu(info->rsubdirs); + ceph_decode_timespec(&ci->i_rctime, &info->rctime); + + /* it may be better to set st_size in getattr instead? */ + if (ceph_client(inode->i_sb)->mount_args.flags & + CEPH_MOUNT_RBYTES) + inode->i_size = ci->i_rbytes; + break; + default: + derr(0, "BAD mode 0%o S_IFMT 0%o\n", inode->i_mode, + inode->i_mode & S_IFMT); + err = -EINVAL; + goto out; + } + err = 0; + +out: + kfree(xattr_data); + return err; +} + + + +/* + * caller must hold session s_mutex. + */ +static int update_inode_lease(struct inode *inode, + struct ceph_mds_reply_lease *lease, + struct ceph_mds_session *session, + unsigned long from_time) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int is_new = 0; + int mask = le16_to_cpu(lease->mask); + long unsigned duration = le32_to_cpu(lease->duration_ms); + long unsigned ttl = from_time + (duration * HZ) / 1000; + + dout(10, "update_inode_lease %p mask %d duration %lu ms ttl %lu\n", + inode, mask, duration, ttl); + + if (mask == 0) + return 0; + + spin_lock(&inode->i_lock); + /* + * be careful: we can't remove a lease from a different session + * without holding the other session's s_mutex. and we only + * remember one lease per object. so if one already exists, + * don't touch it. + */ + if ((ci->i_lease_ttl == 0 || !time_before(ttl, ci->i_lease_ttl) || + ci->i_lease_gen != session->s_cap_gen) && + (!ci->i_lease_session || ci->i_lease_session == session)) { + ci->i_lease_ttl = ttl; + ci->i_lease_gen = session->s_cap_gen; + ci->i_lease_mask = mask; + if (!ci->i_lease_session) { + ci->i_lease_session = session; + is_new = 1; + } + list_move_tail(&ci->i_lease_item, &session->s_inode_leases); + } else { + mask = 0; + } + spin_unlock(&inode->i_lock); + if (is_new) + igrab(inode); + return mask; +} + +/* + * check if inode lease is valid for a given mask + */ +int ceph_inode_lease_valid(struct inode *inode, int mask) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int havemask; + int valid = 0; + int ret = 0; + + spin_lock(&inode->i_lock); + havemask = ci->i_lease_mask; + + /* EXCL cap counts for an ICONTENT lease... check caps? */ + if ((mask & CEPH_LOCK_ICONTENT) && + __ceph_caps_issued(ci, NULL) & CEPH_CAP_EXCL) { + dout(20, "lease_valid inode %p EXCL cap -> ICONTENT\n", inode); + havemask |= CEPH_LOCK_ICONTENT; + } + /* any ICONTENT bits imply all ICONTENT bits */ + if (havemask & CEPH_LOCK_ICONTENT) + havemask |= CEPH_LOCK_ICONTENT; + + if (ci->i_lease_session) { + struct ceph_mds_session *s = ci->i_lease_session; + spin_lock(&s->s_cap_lock); + if (s->s_cap_gen == ci->i_lease_gen && + time_before(jiffies, s->s_cap_ttl) && + time_before(jiffies, ci->i_lease_ttl)) + valid = 1; + spin_unlock(&s->s_cap_lock); + } + spin_unlock(&inode->i_lock); + + if (valid && (havemask & mask) == mask) + ret = 1; + + dout(10, "lease_valid inode %p have %d want %d valid %d = %d\n", inode, + havemask, mask, valid, ret); + return ret; +} + + +/* + * caller should hold session s_mutex. + */ +static void update_dentry_lease(struct dentry *dentry, + struct ceph_mds_reply_lease *lease, + struct ceph_mds_session *session, + unsigned long from_time) +{ + struct ceph_dentry_info *di; + int is_new = 0; + long unsigned duration = le32_to_cpu(lease->duration_ms); + long unsigned ttl = from_time + (duration * HZ) / 1000; + + dout(10, "update_dentry_lease %p mask %d duration %lu ms ttl %lu\n", + dentry, le16_to_cpu(lease->mask), duration, ttl); + if (lease->mask == 0) { + /* + * no per-dentry lease. so, set d_time to match + * parent directory version. if/when we get an + * ICONTENT cap (implicit directory-wide lease), we'll + * know whether it covers this dentry. + */ + struct inode *dir = dentry->d_parent->d_inode; + dentry->d_time = ceph_inode(dir)->i_version; + dout(20, " no lease, setting d_time to %lu\n", dentry->d_time); + return; + } + + spin_lock(&dentry->d_lock); + di = ceph_dentry(dentry); + if (dentry->d_time != 0 && + di && di->lease_gen == session->s_cap_gen && + time_before(ttl, dentry->d_time)) + goto fail_unlock; /* we already have a newer lease. */ + + if (!di) { + spin_unlock(&dentry->d_lock); + di = kmalloc(sizeof(struct ceph_dentry_info), + GFP_NOFS); + if (!di) + return; /* oh well */ + spin_lock(&dentry->d_lock); + if (dentry->d_fsdata) { + kfree(di); /* lost a race! */ + goto fail_unlock; + } + di->dentry = dentry; + dentry->d_fsdata = di; + di->lease_session = session; + di->lease_gen = session->s_cap_gen; + list_add(&di->lease_item, &session->s_dentry_leases); + is_new = 1; + } else { + /* touch existing */ + if (di->lease_session != session) + goto fail_unlock; + list_move_tail(&di->lease_item, &session->s_dentry_leases); + } + dentry->d_time = ttl; + spin_unlock(&dentry->d_lock); + if (is_new) { + dout(10, "lease dget on %p\n", dentry); + dget(dentry); + } + return; + +fail_unlock: + spin_unlock(&dentry->d_lock); +} + +/* + * check if dentry lease is valid + */ +int ceph_dentry_lease_valid(struct dentry *dentry) +{ + struct ceph_dentry_info *di; + struct ceph_mds_session *s; + int valid = 0; + u32 gen; + unsigned long ttl; + + spin_lock(&dentry->d_lock); + di = ceph_dentry(dentry); + if (di) { + s = di->lease_session; + spin_lock(&s->s_cap_lock); + gen = s->s_cap_gen; + ttl = s->s_cap_ttl; + spin_unlock(&s->s_cap_lock); + + if (di->lease_gen == gen && + time_before(jiffies, dentry->d_time) && + time_before(jiffies, ttl)) + valid = 1; + } + spin_unlock(&dentry->d_lock); + dout(20, "dentry_lease_valid - dentry %p = %d\n", dentry, valid); + return valid; +} + + +/* + * splice a dentry to an inode. + * caller must hold directory i_mutex for this to be safe. + * + * we will only rehash the resulting dentry if @prehash is + * true; @prehash will be set to false (for the benefit of + * the caller) if we fail. + */ +static struct dentry *splice_dentry(struct dentry *dn, struct inode *in, + bool *prehash) +{ + struct dentry *realdn; + + /* dn must be unhashed */ + if (!d_unhashed(dn)) + d_drop(dn); + realdn = d_materialise_unique(dn, in); + if (IS_ERR(realdn)) { + derr(0, "error splicing %p (%d) inode %p ino %llx.%llx\n", + dn, atomic_read(&dn->d_count), in, ceph_vinop(in)); + if (prehash) + *prehash = false; /* don't rehash on error */ + goto out; + } else if (realdn) { + dout(10, "dn %p (%d) spliced with %p (%d) " + "inode %p ino %llx.%llx\n", + dn, atomic_read(&dn->d_count), + realdn, atomic_read(&realdn->d_count), + realdn->d_inode, ceph_vinop(realdn->d_inode)); + dput(dn); + dn = realdn; + ceph_init_dentry(dn); + } else { + dout(10, "dn %p attached to %p ino %llx.%llx\n", + dn, dn->d_inode, ceph_vinop(dn->d_inode)); + } + if ((!prehash || *prehash) && d_unhashed(dn)) + d_rehash(dn); +out: + return dn; +} + +/* + * Assimilate a full trace of inodes and dentries, from the root to + * the item relevant for this reply, into our cache. Make any dcache + * changes needed to properly reflect the completed operation (e.g., + * call d_move). Make note of the distribution of metadata across the + * mds cluster. + * + * Care is taken to (attempt to) take i_mutex before adjusting dentry + * linkages or leases. + * + * FIXME: we should check inode.version to avoid races between traces + * from multiple MDSs after, say, a ancestor directory is renamed. + */ +int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req, + struct ceph_mds_session *session) +{ + struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; + int err = 0, mask; + struct qstr dname; + struct dentry *dn = sb->s_root; + struct dentry *parent = NULL; + struct dentry *existing; + struct inode *in; + struct ceph_mds_reply_inode *ininfo; + int d = 0; + struct ceph_vino vino; + int have_icontent; + bool have_lease; + + if (rinfo->trace_numi == 0) { + dout(10, "fill_trace reply has empty trace!\n"); + return 0; + } + +#if 0 + /* + * if we resend completed ops to a recovering mds, we get no + * trace. pretend this is the case to ensure the 'no trace' + * handlers in the callers behave. + */ + if (rinfo->head->op & CEPH_MDS_OP_WRITE) { + dout(0, "fill_trace faking empty trace on %d %s\n", + rinfo->head->op, + ceph_mds_op_name(rinfo->head->op)); + rinfo->trace_numi = 0; + rinfo->trace_numd = 0; + return 0; + } +#endif + + vino.ino = le64_to_cpu(rinfo->trace_in[0].in->ino); + vino.snap = le64_to_cpu(rinfo->trace_in[0].in->snapid); + if (likely(dn)) { + in = dn->d_inode; + /* trace should start at root, or have only 1 dentry + * (if it is in an mds stray dir) */ + WARN_ON(vino.ino != 1 && rinfo->trace_numd != 1); + } else { + /* first reply (i.e. we just mounted) */ + in = ceph_get_inode(sb, vino); + if (IS_ERR(in)) + return PTR_ERR(in); + dn = d_alloc_root(in); + if (dn == NULL) { + derr(0, "d_alloc_root ENOMEM badness on root dentry\n"); + return -ENOMEM; + } + } + + if (vino.ino == 1) { + err = ceph_fill_inode(in, &rinfo->trace_in[0], + rinfo->trace_numd ? + rinfo->trace_dir[0] : NULL); + if (err < 0) + return err; + if (rinfo->trace_numd == 0) + update_inode_lease(in, rinfo->trace_ilease[0], + session, req->r_request_started); + if (unlikely(sb->s_root == NULL)) + sb->s_root = dn; + } + + have_icontent = 0; + have_lease = 0; + dget(dn); + for (d = 0; d < rinfo->trace_numd; d++) { + dname.name = rinfo->trace_dname[d]; + dname.len = rinfo->trace_dname_len[d]; + parent = dn; + dn = NULL; + + dout(10, "fill_trace %d/%d parent %p inode %p: '%.*s'" + " ic %d dmask %d\n", + (d+1), rinfo->trace_numd, parent, parent->d_inode, + (int)dname.len, dname.name, + have_icontent, rinfo->trace_dlease[d]->mask); + + /* try to take dir i_mutex */ + if (req->r_locked_dir != parent->d_inode && + mutex_trylock(&parent->d_inode->i_mutex) == 0) { + dout(10, "fill_trace FAILED to take %p i_mutex\n", + parent->d_inode); + goto no_dir_mutex; + } + + /* update inode lease */ + mask = update_inode_lease(in, rinfo->trace_ilease[d], + session, req->r_request_started); + have_icontent = mask & CEPH_LOCK_ICONTENT; + + /* do we have a dn lease? */ + have_lease = have_icontent || + (le16_to_cpu(rinfo->trace_dlease[d]->mask) & + CEPH_LOCK_DN); + if (!have_lease) + dout(10, "fill_trace no icontent|dentry lease\n"); + + dout(10, "fill_trace took %p i_mutex\n", parent->d_inode); + + dname.hash = full_name_hash(dname.name, dname.len); + retry_lookup: + /* existing dentry? */ + dn = d_lookup(parent, &dname); + dout(10, "fill_trace d_lookup of '%.*s' got %p\n", + (int)dname.len, dname.name, dn); + + /* use caller provided dentry? for simplicity, + * - only if there is no existing dn, and + * - only if parent is correct + */ + if (d == rinfo->trace_numd-1 && req->r_last_dentry) { + if (!dn && req->r_last_dentry->d_parent == parent) { + dn = req->r_last_dentry; + dout(10, "fill_trace provided dn %p '%.*s'\n", + dn, dn->d_name.len, dn->d_name.name); + ceph_init_dentry(dn); /* just in case */ + } else if (dn == req->r_last_dentry) { + dout(10, "fill_trace matches provided dn %p\n", + dn); + dput(req->r_last_dentry); + } else { + dout(10, "fill_trace NOT using provided dn %p " + "(parent %p)\n", req->r_last_dentry, + req->r_last_dentry->d_parent); + dput(req->r_last_dentry); + } + req->r_last_dentry = NULL; + } + + if (!dn) { + dn = d_alloc(parent, &dname); + if (!dn) { + derr(0, "d_alloc ENOMEM\n"); + err = -ENOMEM; + goto out_dir_no_inode; + } + dout(10, "fill_trace d_alloc %p '%.*s'\n", dn, + dn->d_name.len, dn->d_name.name); + ceph_init_dentry(dn); + } + BUG_ON(!dn); + + /* null dentry? */ + if (d+1 == rinfo->trace_numi) { + dout(10, "fill_trace null dentry\n"); + if (dn->d_inode) { + dout(20, "d_delete %p\n", dn); + d_delete(dn); + dput(dn); + goto retry_lookup; + } + dout(20, "d_instantiate %p NULL\n", dn); + d_instantiate(dn, NULL); + if (have_lease && d_unhashed(dn)) + d_rehash(dn); + update_dentry_lease(dn, rinfo->trace_dlease[d], + session, req->r_request_started); + goto out_dir_no_inode; + } + + /* rename? */ + if (d == rinfo->trace_numd-1 && req->r_old_dentry) { + dout(10, " src %p '%.*s' dst %p '%.*s'\n", + req->r_old_dentry, + req->r_old_dentry->d_name.len, + req->r_old_dentry->d_name.name, + dn, dn->d_name.len, dn->d_name.name); + dout(10, "fill_trace doing d_move %p -> %p\n", + req->r_old_dentry, dn); + d_move(req->r_old_dentry, dn); + dout(10, " src %p '%.*s' dst %p '%.*s'\n", + req->r_old_dentry, + req->r_old_dentry->d_name.len, + req->r_old_dentry->d_name.name, + dn, dn->d_name.len, dn->d_name.name); + dput(dn); /* dn is dropped */ + dn = req->r_old_dentry; /* use old_dentry */ + req->r_old_dentry = NULL; + } + + /* attach proper inode */ + ininfo = rinfo->trace_in[d+1].in; + vino.ino = le64_to_cpu(ininfo->ino); + vino.snap = le64_to_cpu(ininfo->snapid); + if (dn->d_inode) { + if (ceph_ino(dn->d_inode) != vino.ino || + ceph_snap(dn->d_inode) != vino.snap) { + dout(10, "dn %p wrong inode %p ino %llx.%llx\n", + dn, dn->d_inode, ceph_vinop(dn->d_inode)); + d_delete(dn); + dput(dn); + goto retry_lookup; + } + dout(10, "dn %p correct %p ino %llx.%llx\n", + dn, dn->d_inode, ceph_vinop(dn->d_inode)); + in = dn->d_inode; + } else { + in = ceph_get_inode(dn->d_sb, vino); + if (IS_ERR(in)) { + derr(30, "get_inode badness\n"); + err = PTR_ERR(in); + d_delete(dn); + dn = NULL; + goto out_dir_no_inode; + } + dn = splice_dentry(dn, in, &have_lease); + } + + if (have_lease) + update_dentry_lease(dn, rinfo->trace_dlease[d], + session, req->r_request_started); + + /* done with dn update */ + if (req->r_locked_dir != parent->d_inode) + mutex_unlock(&parent->d_inode->i_mutex); + + update_inode: + BUG_ON(dn->d_inode != in); + err = ceph_fill_inode(in, + &rinfo->trace_in[d+1], + rinfo->trace_numd <= d ? + rinfo->trace_dir[d+1] : NULL); + if (err < 0) { + derr(30, "ceph_fill_inode badness\n"); + d_delete(dn); + dn = NULL; + in = NULL; + break; + } + + dput(parent); + parent = NULL; + + /* do we diverge into a snap dir at this point in the trace? */ + if (d == rinfo->trace_numi - rinfo->trace_snapdirpos - 1) { + struct inode *snapdir = ceph_get_snapdir(in); + dput(dn); + dn = d_find_alias(snapdir); + if (!dn) { + struct ceph_client *client = + ceph_sb_to_client(parent->d_sb); + + dname.name = client->mount_args.snapdir_name, + dname.len = strlen(dname.name); + dname.hash = full_name_hash(dname.name, + dname.len); + dn = d_alloc(parent, &dname); + if (!dn) { + err = -ENOMEM; + iput(snapdir); + break; + } + d_add(dn, snapdir); + } + iput(snapdir); + dout(10, " snapdir dentry is %p\n", dn); + } + continue; + + + out_dir_no_inode: + /* drop i_mutex */ + if (req->r_locked_dir != parent->d_inode) + mutex_unlock(&parent->d_inode->i_mutex); + in = NULL; + break; + + + no_dir_mutex: + /* + * we couldn't take i_mutex for this dir, so do not + * lookup or relink any existing dentry. + */ + if (d == rinfo->trace_numd-1 && req->r_last_dentry) { + dn = req->r_last_dentry; + dout(10, "fill_trace using provided dn %p\n", dn); + ceph_init_dentry(dn); + req->r_last_dentry = NULL; + } + + /* null dentry? */ + if (d+1 == rinfo->trace_numi) { + if (dn && dn->d_inode) + d_delete(dn); + in = NULL; + break; + } + + /* find existing inode */ + ininfo = rinfo->trace_in[d+1].in; + vino.ino = le64_to_cpu(ininfo->ino); + vino.snap = le64_to_cpu(ininfo->snapid); + in = ceph_get_inode(parent->d_sb, vino); + if (IS_ERR(in)) { + derr(30, "ceph_get_inode badness\n"); + err = PTR_ERR(in); + in = NULL; + break; + } + existing = d_find_alias(in); + if (existing) { + if (dn) + dput(dn); + iput(in); + dn = existing; + dout(10, " using existing %p alias %p\n", in, dn); + } else { + if (dn && dn->d_inode == NULL) { + dout(10, " instantiating provided %p\n", dn); + d_instantiate(dn, in); + } else { + if (dn) { + dout(10, " ignoring provided dn %p\n", + dn); + dput(dn); + } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 28) + dn = d_obtain_alias(in); +#else + dn = d_alloc_anon(in); +#endif + iput(in); + dout(10, " d_alloc_anon new dn %p\n", dn); + } + } + goto update_inode; + } + if (parent) + dput(parent); + + if (in) + update_inode_lease(dn->d_inode, + rinfo->trace_ilease[d], + session, req->r_request_started); + + dout(10, "fill_trace done err=%d, last dn %p in %p\n", err, dn, in); + if (req->r_last_dentry) + dput(req->r_last_dentry); + req->r_last_dentry = dn; + if (req->r_last_inode) + iput(req->r_last_inode); + req->r_last_inode = in; + if (in) + igrab(in); + return err; +} + +/* + * prepopulate cache with readdir results, leases, etc. + */ +int ceph_readdir_prepopulate(struct ceph_mds_request *req) +{ + struct dentry *parent = req->r_last_dentry; + struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; + struct qstr dname; + struct dentry *dn; + struct inode *in; + int err = 0, i; + struct inode *snapdir = NULL; + + if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) { + snapdir = ceph_get_snapdir(parent->d_inode); + parent = d_find_alias(snapdir); + dout(10, "readdir_prepopulate %d items under SNAPDIR dn %p\n", + rinfo->dir_nr, parent); + } else { + dout(10, "readdir_prepopulate %d items under dn %p\n", + rinfo->dir_nr, parent); + if (rinfo->dir_dir) + ceph_fill_dirfrag(parent->d_inode, rinfo->dir_dir); + } + + for (i = 0; i < rinfo->dir_nr; i++) { + struct ceph_vino vino; + + dname.name = rinfo->dir_dname[i]; + dname.len = rinfo->dir_dname_len[i]; + dname.hash = full_name_hash(dname.name, dname.len); + + vino.ino = le64_to_cpu(rinfo->dir_in[i].in->ino); + vino.snap = le64_to_cpu(rinfo->dir_in[i].in->snapid); + +retry_lookup: + dn = d_lookup(parent, &dname); + dout(30, "d_lookup on parent=%p name=%.*s got %p\n", + parent, dname.len, dname.name, dn); + + if (!dn) { + dn = d_alloc(parent, &dname); + dout(40, "d_alloc %p '%.*s' = %p\n", parent, + dname.len, dname.name, dn); + if (dn == NULL) { + dout(30, "d_alloc badness\n"); + err = -ENOMEM; + goto out; + } + ceph_init_dentry(dn); + } else if (dn->d_inode && + (ceph_ino(dn->d_inode) != vino.ino || + ceph_snap(dn->d_inode) != vino.snap)) { + dout(10, " dn %p points to wrong inode %p\n", + dn, dn->d_inode); + d_delete(dn); + dput(dn); + goto retry_lookup; + } + + /* inode */ + if (dn->d_inode) { + in = dn->d_inode; + } else { + in = ceph_get_inode(parent->d_sb, vino); + if (in == NULL) { + dout(30, "new_inode badness\n"); + d_delete(dn); + dput(dn); + err = -ENOMEM; + goto out; + } + dn = splice_dentry(dn, in, NULL); + } + + if (ceph_fill_inode(in, &rinfo->dir_in[i], NULL) < 0) { + dout(0, "ceph_fill_inode badness on %p\n", in); + dput(dn); + continue; + } + update_dentry_lease(dn, rinfo->dir_dlease[i], + req->r_session, req->r_request_started); + update_inode_lease(in, rinfo->dir_ilease[i], + req->r_session, req->r_request_started); + dput(dn); + } + +out: + if (snapdir) { + iput(snapdir); + dput(parent); + } + dout(10, "readdir_prepopulate done\n"); + return err; +} + + +void ceph_inode_set_size(struct inode *inode, loff_t size) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + + spin_lock(&inode->i_lock); + dout(30, "set_size %p %llu -> %llu\n", inode, inode->i_size, size); + inode->i_size = size; + inode->i_blocks = (size + (1 << 9) - 1) >> 9; + + /* tell the MDS if we are approaching max_size */ + if ((size << 1) >= ci->i_max_size && + (ci->i_reported_size << 1) < ci->i_max_size) { + spin_unlock(&inode->i_lock); + ceph_check_caps(ci, 0); + } else { + spin_unlock(&inode->i_lock); + } +} + +/* + * Drop open file reference. If we were the last open file, + * we may need to release capabilities to the MDS (or schedule + * their delayed release). + */ +void ceph_put_fmode(struct ceph_inode_info *ci, int fmode) +{ + int last = 0; + + spin_lock(&ci->vfs_inode.i_lock); + dout(20, "put_mode %p fmode %d %d -> %d\n", &ci->vfs_inode, fmode, + ci->i_nr_by_mode[fmode], ci->i_nr_by_mode[fmode]-1); + if (--ci->i_nr_by_mode[fmode] == 0) + last++; + spin_unlock(&ci->vfs_inode.i_lock); + + if (last && ci->i_vino.snap == CEPH_NOSNAP) + ceph_check_caps(ci, 0); +} + + +/* + * Write back inode data in a worker thread. (This can't be done + * in the message handler context.) + */ +void ceph_inode_writeback(struct work_struct *work) +{ + struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, + i_wb_work); + struct inode *inode = &ci->vfs_inode; + + dout(10, "writeback %p\n", inode); + filemap_write_and_wait(&inode->i_data); + iput(inode); +} + +/* + * Invalidate inode pages in a worker thread. (This can't be done + * in the message handler context.) + */ +static void ceph_inode_invalidate_pages(struct work_struct *work) +{ + struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, + i_pg_inv_work); + struct inode *inode = &ci->vfs_inode; + u32 orig_gen; + int check = 0; + + spin_lock(&inode->i_lock); + dout(10, "invalidate_pages %p gen %d revoking %d\n", inode, + ci->i_rdcache_gen, ci->i_rdcache_revoking); + if (ci->i_rdcache_gen == 0 || + ci->i_rdcache_revoking != ci->i_rdcache_gen) { + BUG_ON(ci->i_rdcache_revoking > ci->i_rdcache_gen); + /* nevermind! */ + ci->i_rdcache_revoking = 0; + spin_unlock(&inode->i_lock); + goto out; + } + orig_gen = ci->i_rdcache_gen; + spin_unlock(&inode->i_lock); + + truncate_inode_pages(&inode->i_data, 0); + + spin_lock(&inode->i_lock); + if (orig_gen == ci->i_rdcache_gen) { + dout(10, "invalidate_pages %p gen %d successful\n", inode, + ci->i_rdcache_gen); + ci->i_rdcache_gen = 0; + ci->i_rdcache_revoking = 0; + check = 1; + } else { + dout(10, "invalidate_pages %p gen %d raced, gen now %d\n", + inode, orig_gen, ci->i_rdcache_gen); + } + spin_unlock(&inode->i_lock); + + if (check) + ceph_check_caps(ci, 0); +out: + iput(inode); +} + + +/* + * called by trunc_wq; take i_mutex ourselves + * + * We also truncation in a separate thread as well. + */ +void ceph_vmtruncate_work(struct work_struct *work) +{ + struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, + i_vmtruncate_work); + struct inode *inode = &ci->vfs_inode; + + dout(10, "vmtruncate_work %p\n", inode); + mutex_lock(&inode->i_mutex); + __ceph_do_pending_vmtruncate(inode); + mutex_unlock(&inode->i_mutex); + iput(inode); +} + +/* + * called with i_mutex held. + * + * Make sure any pending truncation is applied before doing anything + * that may depend on it. + */ +void __ceph_do_pending_vmtruncate(struct inode *inode) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + loff_t to; + int wrbuffer_refs; + + spin_lock(&inode->i_lock); + to = ci->i_vmtruncate_to; + ci->i_vmtruncate_to = -1; + wrbuffer_refs = ci->i_wrbuffer_ref; + spin_unlock(&inode->i_lock); + + if (to >= 0) { + dout(10, "__do_pending_vmtruncate %p to %lld\n", inode, to); + truncate_inode_pages(inode->i_mapping, to); + if (wrbuffer_refs == 0) + ceph_check_caps(ci, 0); + } else { + dout(10, "__do_pending_vmtruncate %p nothing to do\n", inode); + } +} + +/* + * symlinks + */ +static void *ceph_sym_follow_link(struct dentry *dentry, struct nameidata *nd) +{ + struct ceph_inode_info *ci = ceph_inode(dentry->d_inode); + nd_set_link(nd, ci->i_symlink); + return NULL; +} + +static const struct inode_operations ceph_symlink_iops = { + .readlink = generic_readlink, + .follow_link = ceph_sym_follow_link, +}; + + +/* + * Prepare a setattr request. If we know we have the file open (and + * thus hold at lease a PIN capability), generate the request without + * a path name. + */ +static struct ceph_mds_request *prepare_setattr(struct ceph_mds_client *mdsc, + struct dentry *dentry, + int ia_valid, int op) +{ + char *path; + int pathlen; + struct ceph_mds_request *req; + u64 pathbase; + + if (ia_valid & ATTR_FILE) { + dout(5, "prepare_setattr dentry %p (inode %llx.%llx)\n", dentry, + ceph_vinop(dentry->d_inode)); + req = ceph_mdsc_create_request(mdsc, op, + ceph_ino(dentry->d_inode), + "", 0, NULL, + dentry, USE_CAP_MDS); + } else { + dout(5, "prepare_setattr dentry %p (full path)\n", dentry); + path = ceph_build_path(dentry, &pathlen, &pathbase, 0); + if (IS_ERR(path)) + return ERR_PTR(PTR_ERR(path)); + req = ceph_mdsc_create_request(mdsc, op, pathbase, path, 0, + NULL, dentry, USE_ANY_MDS); + kfree(path); + } + return req; +} + +static int ceph_setattr_chown(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + struct ceph_client *client = ceph_sb_to_client(inode->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + const unsigned int ia_valid = attr->ia_valid; + struct ceph_mds_request *req; + struct ceph_mds_request_head *reqh; + int err; + int mask = 0; + + req = prepare_setattr(mdsc, dentry, ia_valid, CEPH_MDS_OP_LCHOWN); + if (IS_ERR(req)) + return PTR_ERR(req); + reqh = req->r_request->front.iov_base; + if (ia_valid & ATTR_UID) { + reqh->args.chown.uid = cpu_to_le32(attr->ia_uid); + mask |= CEPH_CHOWN_UID; + } + if (ia_valid & ATTR_GID) { + reqh->args.chown.gid = cpu_to_le32(attr->ia_gid); + mask |= CEPH_CHOWN_GID; + } + reqh->args.chown.mask = cpu_to_le32(mask); + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_IAUTH); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + dout(10, "chown result %d\n", err); + return err; +} + +static int ceph_setattr_chmod(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + struct ceph_client *client = ceph_sb_to_client(inode->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + struct ceph_mds_request_head *reqh; + int err; + + req = prepare_setattr(mdsc, dentry, attr->ia_valid, CEPH_MDS_OP_LCHMOD); + if (IS_ERR(req)) + return PTR_ERR(req); + reqh = req->r_request->front.iov_base; + reqh->args.chmod.mode = cpu_to_le32(attr->ia_mode); + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_IAUTH); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + dout(10, "chmod result %d\n", err); + return err; +} + +static int ceph_setattr_time(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_sb_to_client(inode->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + const unsigned int ia_valid = attr->ia_valid; + struct ceph_mds_request *req; + struct ceph_mds_request_head *reqh; + int err; + + /* if i hold CAP_EXCL, i can change [am]time any way i like */ + if (ceph_caps_issued(ci) & CEPH_CAP_EXCL) { + dout(10, "utime holding EXCL, doing locally\n"); + ci->i_time_warp_seq++; + if (ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + inode->i_ctime = CURRENT_TIME; + return 0; + } + + /* if i hold CAP_WR, i can _increase_ [am]time safely */ + if ((ceph_caps_issued(ci) & CEPH_CAP_WR) && + ((ia_valid & ATTR_MTIME) == 0 || + timespec_compare(&inode->i_mtime, &attr->ia_mtime) < 0) && + ((ia_valid & ATTR_ATIME) == 0 || + timespec_compare(&inode->i_atime, &attr->ia_atime) < 0)) { + dout(10, "utime holding WR, doing [am]time increase locally\n"); + if (ia_valid & ATTR_ATIME) + inode->i_atime = attr->ia_atime; + if (ia_valid & ATTR_MTIME) + inode->i_mtime = attr->ia_mtime; + inode->i_ctime = CURRENT_TIME; + return 0; + } + + /* if i have valid values, this may be a no-op */ + if (ceph_inode_lease_valid(inode, CEPH_LOCK_ICONTENT) && + !(((ia_valid & ATTR_ATIME) && + !timespec_equal(&inode->i_atime, &attr->ia_atime)) || + ((ia_valid & ATTR_MTIME) && + !timespec_equal(&inode->i_mtime, &attr->ia_mtime)))) { + dout(10, "lease indicates utimes is a no-op\n"); + return 0; + } + + req = prepare_setattr(mdsc, dentry, ia_valid, CEPH_MDS_OP_LUTIME); + if (IS_ERR(req)) + return PTR_ERR(req); + reqh = req->r_request->front.iov_base; + ceph_encode_timespec(&reqh->args.utime.mtime, &attr->ia_mtime); + ceph_encode_timespec(&reqh->args.utime.atime, &attr->ia_atime); + + reqh->args.utime.mask = 0; + if (ia_valid & ATTR_ATIME) + reqh->args.utime.mask |= cpu_to_le32(CEPH_UTIME_ATIME); + if (ia_valid & ATTR_MTIME) + reqh->args.utime.mask |= cpu_to_le32(CEPH_UTIME_MTIME); + + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + dout(10, "utime result %d\n", err); + return err; +} + +static int ceph_setattr_size(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_sb_to_client(inode->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + const unsigned int ia_valid = attr->ia_valid; + struct ceph_mds_request *req; + struct ceph_mds_request_head *reqh; + int err; + + dout(10, "truncate: ia_size %d i_size %d\n", + (int)attr->ia_size, (int)inode->i_size); + if (ceph_caps_issued(ci) & CEPH_CAP_EXCL && + attr->ia_size > inode->i_size) { + dout(10, "holding EXCL, doing truncate (fwd) locally\n"); + err = vmtruncate(inode, attr->ia_size); + if (err) + return err; + spin_lock(&inode->i_lock); + inode->i_size = attr->ia_size; + inode->i_ctime = attr->ia_ctime; + ci->i_reported_size = attr->ia_size; + spin_unlock(&inode->i_lock); + return 0; + } + if (ceph_inode_lease_valid(inode, CEPH_LOCK_ICONTENT) && + attr->ia_size == inode->i_size) { + dout(10, "lease indicates truncate is a no-op\n"); + return 0; + } + req = prepare_setattr(mdsc, dentry, ia_valid, CEPH_MDS_OP_LTRUNCATE); + if (IS_ERR(req)) + return PTR_ERR(req); + reqh = req->r_request->front.iov_base; + reqh->args.truncate.length = cpu_to_le64(attr->ia_size); + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + dout(10, "truncate result %d\n", err); + __ceph_do_pending_vmtruncate(inode); + return err; +} + + +int ceph_setattr(struct dentry *dentry, struct iattr *attr) +{ + struct inode *inode = dentry->d_inode; + const unsigned int ia_valid = attr->ia_valid; + int err; + + if (ceph_snap(inode) != CEPH_NOSNAP) + return -EROFS; + + __ceph_do_pending_vmtruncate(inode); + + err = inode_change_ok(inode, attr); + if (err != 0) + return err; + + /* gratuitous debug output */ + if (ia_valid & ATTR_UID) + dout(10, "setattr: %p uid %d -> %d\n", inode, + inode->i_uid, attr->ia_uid); + if (ia_valid & ATTR_GID) + dout(10, "setattr: %p gid %d -> %d\n", inode, + inode->i_uid, attr->ia_uid); + if (ia_valid & ATTR_MODE) + dout(10, "setattr: %p mode 0%o -> 0%o\n", inode, inode->i_mode, + attr->ia_mode); + if (ia_valid & ATTR_SIZE) + dout(10, "setattr: %p size %lld -> %lld\n", inode, + inode->i_size, attr->ia_size); + if (ia_valid & ATTR_ATIME) + dout(10, "setattr: %p atime %ld.%ld -> %ld.%ld\n", inode, + inode->i_atime.tv_sec, inode->i_atime.tv_nsec, + attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec); + if (ia_valid & ATTR_MTIME) + dout(10, "setattr: %p mtime %ld.%ld -> %ld.%ld\n", inode, + inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, + attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec); + if (ia_valid & ATTR_MTIME) + dout(10, "setattr: %p ctime %ld.%ld -> %ld.%ld\n", inode, + inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec, + attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec); + if (ia_valid & ATTR_FILE) + dout(10, "setattr: %p ATTR_FILE ... hrm!\n", inode); + + if (ia_valid & (ATTR_UID|ATTR_GID)) + err = ceph_setattr_chown(dentry, attr); + if (ia_valid & ATTR_MODE) + err = ceph_setattr_chmod(dentry, attr); + if (ia_valid & (ATTR_ATIME|ATTR_MTIME)) + err = ceph_setattr_time(dentry, attr); + if (ia_valid & ATTR_SIZE) + err = ceph_setattr_size(dentry, attr); + return err; +} + +/* + * Verify that we have a lease on the given mask. If not, + * do a getattr against an mds. + */ +int ceph_do_getattr(struct dentry *dentry, int mask) +{ + int on_inode = 0; + struct dentry *ret; + + if (ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) { + dout(30, "getattr dentry %p inode %p SNAPDIR\n", dentry, + dentry->d_inode); + return 0; + } + + dout(30, "getattr dentry %p inode %p mask %d\n", dentry, + dentry->d_inode, mask); + if (ceph_inode_lease_valid(dentry->d_inode, mask)) + return 0; + + /* + * if the dentry is unhashed AND we have a cap, stat + * the ino directly. (if its unhashed and we don't have a + * cap, we may be screwed anyway.) + */ + if (d_unhashed(dentry)) { + if (ceph_get_cap_mds(dentry->d_inode) >= 0) + on_inode = 1; + else + derr(0, "WARNING: getattr on unhashed cap-less" + " dentry %p %.*s\n", dentry, + dentry->d_name.len, dentry->d_name.name); + } + ret = ceph_do_lookup(dentry->d_inode->i_sb, dentry, mask, + on_inode, 0); + if (IS_ERR(ret)) + return PTR_ERR(ret); + if (ret) + dentry = ret; + if (!dentry->d_inode) + return -ENOENT; + if (ret) + dput(dentry); /* do_lookup spliced.. drop new dentry */ + return 0; +} + +/* + * Get all attributes. Hopefully somedata we'll have a statlite() + * and can limit the fields we require to be accurate. + */ +int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry, + struct kstat *stat) +{ + int err; + + err = ceph_do_getattr(dentry, CEPH_STAT_MASK_INODE_ALL); + dout(30, "getattr returned %d\n", err); + if (!err) { + generic_fillattr(dentry->d_inode, stat); + stat->ino = ceph_ino(dentry->d_inode); + if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP) + stat->dev = ceph_snap(dentry->d_inode); + else + stat->dev = 0; + } + return err; +} + +/* + * (virtual) xattrs + * + * These define virtual xattrs exposing the recursive directory statistics. + */ +struct _ceph_vir_xattr_cb { + char *name; + size_t (*getxattr_cb)(struct ceph_inode_info *ci, char *val, + size_t size); +}; + +static size_t _ceph_vir_xattrcb_entries(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_files + ci->i_subdirs); +} + +static size_t _ceph_vir_xattrcb_files(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_files); +} + +static size_t _ceph_vir_xattrcb_subdirs(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_subdirs); +} + +static size_t _ceph_vir_xattrcb_rentries(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_rfiles + ci->i_rsubdirs); +} + +static size_t _ceph_vir_xattrcb_rfiles(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_rfiles); +} + +static size_t _ceph_vir_xattrcb_rsubdirs(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_rsubdirs); +} + +static size_t _ceph_vir_xattrcb_rbytes(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%lld", ci->i_rbytes); +} + +static size_t _ceph_vir_xattrcb_rctime(struct ceph_inode_info *ci, char *val, + size_t size) +{ + return snprintf(val, size, "%ld.%ld", (long)ci->i_rctime.tv_sec, + (long)ci->i_rctime.tv_nsec); +} + +static struct _ceph_vir_xattr_cb _ceph_vir_xattr_recs[] = { + { "user.ceph.dir.entries", _ceph_vir_xattrcb_entries}, + { "user.ceph.dir.files", _ceph_vir_xattrcb_files}, + { "user.ceph.dir.subdirs", _ceph_vir_xattrcb_subdirs}, + { "user.ceph.dir.rentries", _ceph_vir_xattrcb_rentries}, + { "user.ceph.dir.rfiles", _ceph_vir_xattrcb_rfiles}, + { "user.ceph.dir.rsubdirs", _ceph_vir_xattrcb_rsubdirs}, + { "user.ceph.dir.rbytes", _ceph_vir_xattrcb_rbytes}, + { "user.ceph.dir.rctime", _ceph_vir_xattrcb_rctime}, + { NULL, NULL } +}; + +static struct _ceph_vir_xattr_cb *_ceph_match_vir_xattr(const char *name) +{ + struct _ceph_vir_xattr_cb *xattr_rec = _ceph_vir_xattr_recs; + + do { + if (strcmp(xattr_rec->name, name) == 0) + return xattr_rec; + xattr_rec++; + } while (xattr_rec->name); + + return NULL; +} + +ssize_t ceph_getxattr(struct dentry *dentry, const char *name, void *value, + size_t size) +{ + struct inode *inode = dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + int namelen = strlen(name); + u32 numattr; + int err; + void *p, *end; + struct _ceph_vir_xattr_cb *vir_xattr; + + /* let's see if a virtual xattr was requested */ + vir_xattr = _ceph_match_vir_xattr(name); + if (vir_xattr) + return (vir_xattr->getxattr_cb)(ci, value, size); + + /* get xattrs from mds (if we don't already have them) */ + err = ceph_do_getattr(dentry, CEPH_STAT_MASK_XATTR); + if (err) + return err; + + spin_lock(&inode->i_lock); + + err = -ENODATA; /* == ENOATTR */ + if (!ci->i_xattr_len) + goto out; + + /* find attr name */ + p = ci->i_xattr_data; + end = p + ci->i_xattr_len; + ceph_decode_32_safe(&p, end, numattr, bad); + while (numattr--) { + u32 len; + int match; + ceph_decode_32_safe(&p, end, len, bad); + match = (len == namelen && strncmp(name, p, len) == 0); + p += len; + ceph_decode_32_safe(&p, end, len, bad); + if (match) { + err = -ERANGE; + if (size && size < len) + goto out; + err = len; + if (size == 0) + goto out; + memcpy(value, p, len); + goto out; + } + p += len; + } + +out: + spin_unlock(&inode->i_lock); + return err; + +bad: + derr(10, "corrupt xattr info on %p %llx.%llx\n", dentry->d_inode, + ceph_vinop(dentry->d_inode)); + err = -EIO; + goto out; +} + +ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) +{ + struct inode *inode = dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + int namelen = 0; + u32 numattr = 0; + void *p, *end; + int err; + u32 len; + int i; + + err = ceph_do_getattr(dentry, CEPH_STAT_MASK_XATTR); + if (err) + return err; + + spin_lock(&inode->i_lock); + + /* measure len of names */ + if (ci->i_xattr_len) { + p = ci->i_xattr_data; + end = p + ci->i_xattr_len; + ceph_decode_32_safe(&p, end, numattr, bad); + while (numattr--) { + ceph_decode_32_safe(&p, end, len, bad); + namelen += len + 1; + p += len; + ceph_decode_32_safe(&p, end, len, bad); + p += len; + } + } else { + namelen = 0; + } + + /* include virtual dir xattrs */ + if ((inode->i_mode & S_IFMT) == S_IFDIR) + for (i = 0; _ceph_vir_xattr_recs[i].name; i++) + namelen += strlen(_ceph_vir_xattr_recs[i].name) + 1; + + err = -ERANGE; + if (size && namelen > size) + goto out; + err = namelen; + if (size == 0) + goto out; + + /* copy names */ + if (ci->i_xattr_len) { + p = ci->i_xattr_data; + ceph_decode_32(&p, numattr); + while (numattr--) { + ceph_decode_32(&p, len); + memcpy(names, p, len); + names[len] = '\0'; + names += len + 1; + p += len; + ceph_decode_32(&p, len); + p += len; + } + } else { + names[0] = 0; + } + + /* virtual xattr names, too */ + if ((inode->i_mode & S_IFMT) == S_IFDIR) + for (i = 0; _ceph_vir_xattr_recs[i].name; i++) { + len = sprintf(names, "%s", + _ceph_vir_xattr_recs[i].name); + names += len + 1; + } + +out: + spin_unlock(&inode->i_lock); + return err; + +bad: + derr(10, "corrupt xattr info on %p %llx.%llx\n", dentry->d_inode, + ceph_vinop(dentry->d_inode)); + err = -EIO; + goto out; +} + +int ceph_setxattr(struct dentry *dentry, const char *name, + const void *value, size_t size, int flags) +{ + struct ceph_client *client = ceph_client(dentry->d_sb); + struct inode *inode = dentry->d_inode; + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + char *path; + int pathlen; + u64 pathbase; + int err; + int i, nr_pages; + struct page **pages = NULL; + void *kaddr; + + if (ceph_snap(inode) != CEPH_NOSNAP) + return -EROFS; + + /* only support user.* xattrs, for now */ + if (strncmp(name, "user.", 5) != 0) + return -EOPNOTSUPP; + + if (_ceph_match_vir_xattr(name) != NULL) + return -EOPNOTSUPP; + + /* copy value into some pages */ + nr_pages = calc_pages_for(0, size); + if (nr_pages) { + pages = kmalloc(sizeof(pages)*nr_pages, GFP_NOFS); + if (!pages) + return -ENOMEM; + err = -ENOMEM; + for (i = 0; i < nr_pages; i++) { + pages[i] = alloc_page(GFP_NOFS); + if (!pages[i]) { + nr_pages = i; + goto out; + } + kaddr = kmap(pages[i]); + memcpy(kaddr, value + i*PAGE_CACHE_SIZE, + min(PAGE_CACHE_SIZE, size-i*PAGE_CACHE_SIZE)); + } + } + + /* do request */ + path = ceph_build_path(dentry, &pathlen, &pathbase, 0); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LSETXATTR, + pathbase, path, 0, name, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) + return PTR_ERR(req); + + rhead = req->r_request->front.iov_base; + rhead->args.setxattr.flags = cpu_to_le32(flags); + + req->r_request->pages = pages; + req->r_request->nr_pages = nr_pages; + req->r_request->hdr.data_len = cpu_to_le32(size); + req->r_request->hdr.data_off = cpu_to_le32(0); + + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_IXATTR); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + +out: + if (pages) { + for (i = 0; i < nr_pages; i++) + __free_page(pages[i]); + kfree(pages); + } + return err; +} + +int ceph_removexattr(struct dentry *dentry, const char *name) +{ + struct ceph_client *client = ceph_client(dentry->d_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct inode *inode = dentry->d_inode; + struct ceph_mds_request *req; + char *path; + int pathlen; + u64 pathbase; + int err; + + if (ceph_snap(inode) != CEPH_NOSNAP) + return -EROFS; + + /* only support user.* xattrs, for now */ + if (strncmp(name, "user.", 5) != 0) + return -EOPNOTSUPP; + + if (_ceph_match_vir_xattr(name) != NULL) + return -EOPNOTSUPP; + + path = ceph_build_path(dentry, &pathlen, &pathbase, 0); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LRMXATTR, + pathbase, path, 0, name, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) + return PTR_ERR(req); + + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_IXATTR); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + return err; +} + -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 06/19] ceph: directory operations 2008-11-14 0:56 ` [PATCH 05/19] ceph: inode operations Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 07/19] ceph: file operations Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Directory operations, including lookup, are defined here. We take advantage of lookup intents when possible. For the most part, we just need to build the proper requests for the metadata server(s) and pass things off to the mds_client. The results of most operations are normally incorporated into the client's cache when the reply is parsed by ceph_fill_trace(). However, if the MDS replies without a trace (e.g., when retrying an update after an MDS failure recovery), some operation-specific cleanup may be needed. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/dir.c | 891 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 891 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/dir.c diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c new file mode 100644 index 0000000..04c1064 --- /dev/null +++ b/fs/ceph/dir.c @@ -0,0 +1,891 @@ +#include <linux/namei.h> +#include <linux/sched.h> + +#include "ceph_debug.h" + +int ceph_debug_dir = -1; +#define DOUT_MASK DOUT_MASK_DIR +#define DOUT_VAR ceph_debug_dir +#define DOUT_PREFIX "dir: " +#include "super.h" + +/* + * Ceph MDS operations are specified in terms of a base ino and + * relative path. Thus, the client can specify an operation on a + * specific inode (e.g., a getattr due to fstat(2)), or as a path + * relative to, say, the root directory. + * + * Because the MDS does not statefully track which inodes the client + * has in its cache, the client has to take care to only specify + * operations relative to inodes it knows the MDS has cached. (The + * MDS cannot do a lookup by ino.) + * + * So, in general, we try to specify operations in terms of generate + * path names relative to the root. + */ + +const struct inode_operations ceph_dir_iops; +const struct file_operations ceph_dir_fops; +struct dentry_operations ceph_dentry_ops; + +static int ceph_dentry_revalidate(struct dentry *dentry, struct nameidata *nd); + +/* + * build a dentry's path. allocate on heap; caller must kfree. based + * on build_path_from_dentry in fs/cifs/dir.c. + * + * encode hidden .snap dirs as a double /, i.e. + * foo/.snap/bar -> foo//bar + */ +char *ceph_build_path(struct dentry *dentry, int *plen, u64 *base, int min) +{ + struct dentry *temp; + char *path; + int len, pos; + + if (dentry == NULL) + return ERR_PTR(-EINVAL); + +retry: + len = 0; + for (temp = dentry; !IS_ROOT(temp);) { + struct inode *inode = temp->d_inode; + if (inode && ceph_snap(inode) == CEPH_SNAPDIR) + len++; /* slash only */ + else + len += 1 + temp->d_name.len; + temp = temp->d_parent; + if (temp == NULL) { + derr(1, "corrupt dentry %p\n", dentry); + return ERR_PTR(-EINVAL); + } + } + if (len) + len--; /* no leading '/' */ + + path = kmalloc(len+1, GFP_NOFS); + if (path == NULL) + return ERR_PTR(-ENOMEM); + pos = len; + path[pos] = 0; /* trailing null */ + for (temp = dentry; !IS_ROOT(temp) && pos != 0; ) { + if (temp->d_inode && + ceph_snap(temp->d_inode) == CEPH_SNAPDIR) { + dout(50, "build_path_dentry path+%d: %p SNAPDIR\n", + pos, temp); + } else { + pos -= temp->d_name.len; + if (pos < 0) + break; + strncpy(path + pos, temp->d_name.name, + temp->d_name.len); + dout(50, "build_path_dentry path+%d: %p '%.*s'\n", + pos, temp, temp->d_name.len, path + pos); + } + if (pos) + path[--pos] = '/'; + temp = temp->d_parent; + if (temp == NULL) { + derr(1, "corrupt dentry\n"); + kfree(path); + return ERR_PTR(-EINVAL); + } + } + if (pos != 0) { + derr(1, "did not end path lookup where expected, " + "namelen is %d, pos is %d\n", len, pos); + /* presumably this is only possible if racing with a + rename of one of the parent directories (we can not + lock the dentries above us to prevent this, but + retrying should be harmless) */ + kfree(path); + goto retry; + } + + *base = ceph_ino(temp->d_inode); + *plen = len; + dout(10, "build_path_dentry on %p %d built %llx '%.*s'\n", + dentry, atomic_read(&dentry->d_count), *base, len, path); + return path; +} + + +/* + * for readdir, encoding the directory frag and offset within that frag + * into f_pos. + */ +static loff_t make_fpos(unsigned frag, unsigned off) +{ + return ((loff_t)frag << 32) | (loff_t)off; +} +static unsigned fpos_frag(loff_t p) +{ + return p >> 32; +} +static unsigned fpos_off(loff_t p) +{ + return p & 0xffffffff; +} + +static int ceph_readdir(struct file *filp, void *dirent, filldir_t filldir) +{ + struct ceph_file_info *fi = filp->private_data; + struct inode *inode = filp->f_dentry->d_inode; + struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc; + unsigned frag = fpos_frag(filp->f_pos); + unsigned off = fpos_off(filp->f_pos); + unsigned skew; + int err; + u32 ftype; + struct ceph_mds_reply_info_parsed *rinfo; + +nextfrag: + dout(5, "readdir filp %p at frag %u off %u\n", filp, frag, off); + + /* do we have the correct frag content buffered? */ + if (fi->frag != frag || fi->last_readdir == NULL) { + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + char *path; + int pathlen; + u64 pathbase; + int op = ceph_snap(inode) == CEPH_SNAPDIR ? + CEPH_MDS_OP_LSSNAP : CEPH_MDS_OP_READDIR; + + /* discard old result, if any */ + if (fi->last_readdir) + ceph_mdsc_put_request(fi->last_readdir); + + /* requery frag tree, as the frag topology may have changed */ + frag = ceph_choose_frag(ceph_inode(inode), frag, NULL, NULL); + + dout(10, "readdir querying mds for ino %llx.%llx frag %x\n", + ceph_vinop(inode), frag); + path = ceph_build_path(filp->f_dentry, &pathlen, &pathbase, 1); + req = ceph_mdsc_create_request(mdsc, op, + pathbase, path, 0, NULL, + filp->f_dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) + return PTR_ERR(req); + /* hints to request -> mds selection code */ + req->r_direct_mode = USE_AUTH_MDS; + req->r_direct_hash = frag_value(frag); + req->r_direct_is_hash = true; + rhead = req->r_request->front.iov_base; + rhead->args.readdir.frag = cpu_to_le32(frag); + err = ceph_mdsc_do_request(mdsc, req); + if (err < 0) { + ceph_mdsc_put_request(req); + return err; + } + dout(10, "readdir got and parsed readdir result=%d" + " on frag %x\n", err, frag); + fi->last_readdir = req; + } + + /* include . and .. with first fragment */ + if (frag_is_leftmost(frag)) { + switch (off) { + case 0: + dout(10, "readdir off 0 -> '.'\n"); + if (filldir(dirent, ".", 1, make_fpos(0, 0), + inode->i_ino, inode->i_mode >> 12) < 0) + return 0; + off++; + filp->f_pos++; + case 1: + dout(10, "readdir off 1 -> '..'\n"); + if (filp->f_dentry->d_parent != NULL && + filldir(dirent, "..", 2, make_fpos(0, 1), + filp->f_dentry->d_parent->d_inode->i_ino, + inode->i_mode >> 12) < 0) + return 0; + off++; + filp->f_pos++; + } + skew = -2; /* compensate for . and .. */ + } else { + skew = 0; + } + + rinfo = &fi->last_readdir->r_reply_info; + dout(10, "readdir frag %x num %d off %d skew %d\n", frag, + rinfo->dir_nr, off, skew); + while (off+skew < rinfo->dir_nr) { + dout(10, "readdir off %d -> %d / %d name '%.*s'\n", + off, off+skew, + rinfo->dir_nr, rinfo->dir_dname_len[off+skew], + rinfo->dir_dname[off+skew]); + ftype = le32_to_cpu(rinfo->dir_in[off+skew].in->mode) >> 12; + if (filldir(dirent, + rinfo->dir_dname[off+skew], + rinfo->dir_dname_len[off+skew], + make_fpos(frag, off), + le64_to_cpu(rinfo->dir_in[off+skew].in->ino), + ftype) < 0) { + dout(20, "filldir stopping us...\n"); + return 0; + } + off++; + filp->f_pos++; + } + + /* more frags? */ + if (!frag_is_rightmost(frag)) { + frag = frag_next(frag); + off = 0; + filp->f_pos = make_fpos(frag, off); + dout(10, "readdir next frag is %x\n", frag); + goto nextfrag; + } + + dout(20, "readdir done.\n"); + return 0; +} + +static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int origin) +{ + struct ceph_file_info *fi = file->private_data; + struct inode *inode = file->f_mapping->host; + loff_t retval; + + mutex_lock(&inode->i_mutex); + switch (origin) { + case SEEK_END: + offset += inode->i_size; + break; + case SEEK_CUR: + offset += file->f_pos; + } + retval = -EINVAL; + if (offset >= 0 && offset <= inode->i_sb->s_maxbytes) { + if (offset != file->f_pos) { + file->f_pos = offset; + file->f_version = 0; + } + retval = offset; + /* + * discard buffered readdir content on seekdir(0) + */ + if (offset == 0 && fi->last_readdir) { + dout(10, "dir_llseek dropping %p content\n", file); + ceph_mdsc_put_request(fi->last_readdir); + fi->last_readdir = NULL; + } + } + mutex_unlock(&inode->i_mutex); + return retval; +} + + +/* + * Process result of a lookup/open request. + * + * Mainly, make sure that return r_last_dentry (the dentry + * the MDS trace ended on) in place of the original VFS-provided + * dentry, if they differ. + * + * Gracefully handle the case where the MDS replies with -ENOENT and + * no trace (which it may do, at its discretion, e.g., if it doesn't + * care to issue a lease on the negative dentry). + */ +struct dentry *ceph_finish_lookup(struct ceph_mds_request *req, + struct dentry *dentry, int err) +{ + struct ceph_client *client = ceph_client(dentry->d_sb); + struct inode *parent = dentry->d_parent->d_inode; + + /* snap dir? */ + if (err == -ENOENT && + ceph_vino(parent).ino != 1 && /* no .snap in root dir */ + strcmp(dentry->d_name.name, client->mount_args.snapdir_name) == 0) { + struct inode *inode = ceph_get_snapdir(parent); + dout(10, "ENOENT on snapdir %p '%.*s', linking to snapdir %p\n", + dentry, dentry->d_name.len, dentry->d_name.name, inode); + d_add(dentry, inode); + err = 0; + } + + if (err == -ENOENT) { + /* no trace? */ + if (req->r_reply_info.trace_numd == 0) { + dout(20, "ENOENT and no trace, dentry %p inode %p\n", + dentry, dentry->d_inode); + ceph_init_dentry(dentry); + if (dentry->d_inode) { + d_drop(dentry); + req->r_last_dentry = d_alloc(dentry->d_parent, + &dentry->d_name); + d_rehash(req->r_last_dentry); + } else { + d_add(dentry, NULL); + } + } + err = 0; + } + if (err) + dentry = ERR_PTR(err); + else if (dentry != req->r_last_dentry) + dentry = dget(req->r_last_dentry); /* we got spliced */ + else + dentry = NULL; + return dentry; +} + +/* + * Do a lookup / lstat (same thing, modulo the metadata @mask). + * @on_inode indicates that we should stat the ino directly, and not a + * path built from @dentry. + */ +struct dentry *ceph_do_lookup(struct super_block *sb, struct dentry *dentry, + int mask, int on_inode, int locked_dir) +{ + struct ceph_client *client = ceph_sb_to_client(sb); + struct ceph_mds_client *mdsc = &client->mdsc; + char *path; + int pathlen; + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + int err; + + if (dentry->d_name.len > NAME_MAX) + return ERR_PTR(-ENAMETOOLONG); + + dout(10, "do_lookup %p mask %d\n", dentry, mask); + if (on_inode) { + /* stat ino directly */ + WARN_ON(ceph_snap(dentry->d_inode) != CEPH_NOSNAP); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LSTAT, + ceph_ino(dentry->d_inode), NULL, + 0, NULL, + dentry, USE_CAP_MDS); + } else { + /* build path */ + u64 pathbase; + path = ceph_build_path(dentry, &pathlen, &pathbase, 1); + if (IS_ERR(path)) + return ERR_PTR(PTR_ERR(path)); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LSTAT, + pathbase, path, 0, NULL, + dentry, USE_ANY_MDS); + kfree(path); + } + if (IS_ERR(req)) + return ERR_PTR(PTR_ERR(req)); + rhead = req->r_request->front.iov_base; + rhead->args.stat.mask = cpu_to_le32(mask); + req->r_last_dentry = dget(dentry); /* try to use this in fill_trace */ + req->r_locked_dir = dentry->d_parent->d_inode; /* by the VFS */ + err = ceph_mdsc_do_request(mdsc, req); + dentry = ceph_finish_lookup(req, dentry, err); + ceph_mdsc_put_request(req); /* will dput(dentry) */ + dout(20, "do_lookup result=%p\n", dentry); + return dentry; +} + +/* + * Try to do a lookup+open, if possible. + */ +static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry, + struct nameidata *nd) +{ + dout(5, "lookup in dir %p dentry %p '%.*s'\n", + dir, dentry, dentry->d_name.len, dentry->d_name.name); + + /* open (but not create!) intent? */ + if (nd && + (nd->flags & LOOKUP_OPEN) && + (nd->flags & LOOKUP_CONTINUE) == 0 && /* only open last component */ + !(nd->intent.open.flags & O_CREAT)) { + int mode = nd->intent.open.create_mode & ~current->fs->umask; + return ceph_lookup_open(dir, dentry, nd, mode, 1); + } + + return ceph_do_lookup(dir->i_sb, dentry, CEPH_STAT_MASK_INODE_ALL, + 0, 1); +} + +static int ceph_mknod(struct inode *dir, struct dentry *dentry, + int mode, dev_t rdev) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + char *path; + int pathlen; + u64 pathbase; + int err; + + if (ceph_snap(dir) != CEPH_NOSNAP) + return -EROFS; + + dout(5, "mknod in dir %p dentry %p mode 0%o rdev %d\n", + dir, dentry, mode, rdev); + path = ceph_build_path(dentry, &pathlen, &pathbase, 1); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, + pathbase, path, 0, NULL, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) { + d_drop(dentry); + return PTR_ERR(req); + } + req->r_locked_dir = dir; + rhead = req->r_request->front.iov_base; + rhead->args.mknod.mode = cpu_to_le32(mode); + rhead->args.mknod.rdev = cpu_to_le32(rdev); + ceph_mdsc_lease_release(mdsc, dir, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + if (!err && req->r_reply_info.trace_numd == 0) { + /* + * no trace. do lookup, in case we are called from create + * and the VFS needs a valid dentry. + */ + struct dentry *d; + d = ceph_do_lookup(dir->i_sb, dentry, CEPH_STAT_MASK_INODE_ALL, + 0, 0); + if (d) { + /* ick. this is untested, and inherently racey... i + suppose we _did_ create the file, but it has since + been deleted? hrm. */ + dput(d); + err = -ESTALE; + dentry = NULL; + } + } + ceph_mdsc_put_request(req); + if (err) + d_drop(dentry); + return err; +} + +static int ceph_create(struct inode *dir, struct dentry *dentry, int mode, + struct nameidata *nd) +{ + dout(5, "create in dir %p dentry %p name '%.*s'\n", + dir, dentry, dentry->d_name.len, dentry->d_name.name); + + if (ceph_snap(dir) != CEPH_NOSNAP) + return -EROFS; + + if (nd) { + BUG_ON((nd->flags & LOOKUP_OPEN) == 0); + dentry = ceph_lookup_open(dir, dentry, nd, mode, 0); + /* hrm, what should i do here if we get aliased? */ + if (IS_ERR(dentry)) + return PTR_ERR(dentry); + return 0; + } + + /* fall back to mknod */ + return ceph_mknod(dir, dentry, (mode & ~S_IFMT) | S_IFREG, 0); +} + +static int ceph_symlink(struct inode *dir, struct dentry *dentry, + const char *dest) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + char *path; + int pathlen; + u64 pathbase; + int err; + + if (ceph_snap(dir) != CEPH_NOSNAP) + return -EROFS; + + dout(5, "symlink in dir %p dentry %p to '%s'\n", dir, dentry, dest); + path = ceph_build_path(dentry, &pathlen, &pathbase, 1); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, + pathbase, path, 0, dest, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) { + d_drop(dentry); + return PTR_ERR(req); + } + req->r_locked_dir = dir; + ceph_mdsc_lease_release(mdsc, dir, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + if (err) + d_drop(dentry); + return err; +} + +static int ceph_mkdir(struct inode *dir, struct dentry *dentry, int mode) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + char *path; + int pathlen; + u64 pathbase; + int err; + char *snap = NULL; + int snaplen; + struct dentry *pathdentry = dentry; + int op = CEPH_MDS_OP_MKDIR; + + if (ceph_snap(dir) == CEPH_SNAPDIR) { + /* mkdir .snap/foo is a MKSNAP */ + op = CEPH_MDS_OP_MKSNAP; + snaplen = dentry->d_name.len; + snap = kmalloc(snaplen + 1, GFP_NOFS); + memcpy(snap, dentry->d_name.name, snaplen); + snap[snaplen] = 0; + pathdentry = d_find_alias(dir); + dout(5, "mksnap dir %p snap '%s' dn %p\n", dir, snap, dentry); + } else if (ceph_snap(dir) != CEPH_NOSNAP) { + return -EROFS; + } else { + dout(5, "mkdir dir %p dn %p mode 0%o\n", dir, dentry, mode); + } + path = ceph_build_path(pathdentry, &pathlen, &pathbase, 1); + if (pathdentry != dentry) + dput(pathdentry); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, op, + pathbase, path, 0, snap, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) { + d_drop(dentry); + return PTR_ERR(req); + } + + req->r_last_dentry = dget(dentry); /* use this dentry in fill_trace */ + req->r_locked_dir = dir; + rhead = req->r_request->front.iov_base; + rhead->args.mkdir.mode = cpu_to_le32(mode); + + ceph_mdsc_lease_release(mdsc, dir, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + if (err < 0) + d_drop(dentry); + return err; +} + +static int ceph_link(struct dentry *old_dentry, struct inode *dir, + struct dentry *dentry) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + char *oldpath, *path; + int oldpathlen, pathlen; + u64 oldpathbase, pathbase; + int err; + + if (ceph_snap(dir) != CEPH_NOSNAP) + return -EROFS; + + dout(5, "link in dir %p old_dentry %p dentry %p\n", dir, + old_dentry, dentry); + oldpath = ceph_build_path(old_dentry, &oldpathlen, &oldpathbase, 1); + if (IS_ERR(oldpath)) + return PTR_ERR(oldpath); + path = ceph_build_path(dentry, &pathlen, &pathbase, 1); + if (IS_ERR(path)) { + kfree(oldpath); + return PTR_ERR(path); + } + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LINK, + pathbase, path, + oldpathbase, oldpath, + dentry, USE_AUTH_MDS); + kfree(oldpath); + kfree(path); + if (IS_ERR(req)) { + d_drop(dentry); + return PTR_ERR(req); + } + + req->r_last_dentry = dget(dentry); /* use this dentry in fill_trace */ + req->r_locked_dir = old_dentry->d_inode; + + ceph_mdsc_lease_release(mdsc, dir, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + if (err) { + d_drop(dentry); + } else if (req->r_reply_info.trace_numd == 0) { + /* no trace */ + struct inode *inode = old_dentry->d_inode; + inc_nlink(inode); + atomic_inc(&inode->i_count); + dget(dentry); + d_instantiate(dentry, inode); + } + ceph_mdsc_put_request(req); + return err; +} + +/* + * rmdir and unlink are differ only by the metadata op code + */ +static int ceph_unlink(struct inode *dir, struct dentry *dentry) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct inode *inode = dentry->d_inode; + struct ceph_mds_request *req; + char *path; + int pathlen; + u64 pathbase; + char *snap = NULL; + int snaplen; + int err; + int op = ((dentry->d_inode->i_mode & S_IFMT) == S_IFDIR) ? + CEPH_MDS_OP_RMDIR : CEPH_MDS_OP_UNLINK; + struct dentry *pathdentry = dentry; + + if (ceph_snap(dir) == CEPH_SNAPDIR) { + /* rmdir .snap/foo is RMSNAP */ + op = CEPH_MDS_OP_RMSNAP; + snaplen = dentry->d_name.len; + snap = kmalloc(snaplen + 1, GFP_NOFS); + memcpy(snap, dentry->d_name.name, snaplen); + snap[snaplen] = 0; + pathdentry = d_find_alias(dir); + dout(5, "rmsnap dir %p '%s' dn %p\n", dir, snap, dentry); + } else if (ceph_snap(dir) != CEPH_NOSNAP) { + return -EROFS; + } else { + dout(5, "unlink/rmdir dir %p dn %p inode %p\n", + dir, dentry, inode); + } + path = ceph_build_path(pathdentry, &pathlen, &pathbase, 1); + if (pathdentry != dentry) + dput(pathdentry); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, op, + pathbase, path, 0, snap, + dentry, USE_AUTH_MDS); + kfree(path); + if (IS_ERR(req)) + return PTR_ERR(req); + + req->r_locked_dir = dir; /* by VFS */ + + ceph_mdsc_lease_release(mdsc, dir, dentry, + CEPH_LOCK_DN|CEPH_LOCK_ICONTENT); + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_ILINK); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + + return err; +} + +static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry, + struct inode *new_dir, struct dentry *new_dentry) +{ + struct ceph_client *client = ceph_sb_to_client(old_dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct ceph_mds_request *req; + char *oldpath, *newpath; + int oldpathlen, newpathlen; + u64 oldpathbase, newpathbase; + int err; + + if (ceph_snap(old_dir) != ceph_snap(new_dir)) + return -EXDEV; + if (ceph_snap(old_dir) != CEPH_NOSNAP || + ceph_snap(new_dir) != CEPH_NOSNAP) + return -EROFS; + + dout(5, "dir_rename in dir %p dentry %p to dir %p dentry %p\n", + old_dir, old_dentry, new_dir, new_dentry); + oldpath = ceph_build_path(old_dentry, &oldpathlen, &oldpathbase, 1); + if (IS_ERR(oldpath)) + return PTR_ERR(oldpath); + newpath = ceph_build_path(new_dentry, &newpathlen, &newpathbase, 1); + if (IS_ERR(newpath)) { + kfree(oldpath); + return PTR_ERR(newpath); + } + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RENAME, + oldpathbase, oldpath, + newpathbase, newpath, + new_dentry, USE_AUTH_MDS); + kfree(oldpath); + kfree(newpath); + if (IS_ERR(req)) + return PTR_ERR(req); + req->r_old_dentry = dget(old_dentry); + req->r_last_dentry = dget(new_dentry); + req->r_locked_dir = new_dir; + ceph_mdsc_lease_release(mdsc, old_dir, old_dentry, + CEPH_LOCK_DN|CEPH_LOCK_ICONTENT); + if (new_dentry->d_inode) + ceph_mdsc_lease_release(mdsc, new_dentry->d_inode, NULL, + CEPH_LOCK_ILINK); + err = ceph_mdsc_do_request(mdsc, req); + if (!err && req->r_reply_info.trace_numd == 0) { + /* + * no trace + * + * Normally d_move() is done by fill_trace (called by + * do_request, above). If there is no trace, we need + * to do it here. + */ + if (new_dentry->d_inode) + dput(new_dentry); + d_move(old_dentry, new_dentry); + } + ceph_mdsc_put_request(req); + return err; +} + + + +/* + * check if dentry lease, or parent directory inode lease/cap says + * this dentry is still valid + */ +static int ceph_dentry_revalidate(struct dentry *dentry, struct nameidata *nd) +{ + struct inode *dir = dentry->d_parent->d_inode; + + /* always trust cached snapped metadata... for now */ + if (ceph_snap(dir) != CEPH_NOSNAP) { + dout(10, "d_revalidate %p '%.*s' inode %p is SNAPPED\n", dentry, + dentry->d_name.len, dentry->d_name.name, dentry->d_inode); + return 1; + } + + dout(10, "d_revalidate %p '%.*s' inode %p\n", dentry, + dentry->d_name.len, dentry->d_name.name, dentry->d_inode); + + if (ceph_ino(dir) != 1 && /* ICONTENT is meaningless on root inode */ + ceph_inode(dir)->i_version == dentry->d_time && + ceph_inode_lease_valid(dir, CEPH_LOCK_ICONTENT)) { + dout(20, "dentry_revalidate %p %lu ICONTENT on dir %p %llu\n", + dentry, dentry->d_time, dir, ceph_inode(dir)->i_version); + return 1; + } + if (ceph_dentry_lease_valid(dentry)) { + dout(20, "dentry_revalidate %p lease valid\n", dentry); + return 1; + } + + dout(20, "dentry_revalidate %p no lease\n", dentry); + d_drop(dentry); + return 0; +} + +static void ceph_dentry_release(struct dentry *dentry) +{ + BUG_ON(dentry->d_fsdata); +} + +static int ceph_snapdir_dentry_revalidate(struct dentry *dentry, + struct nameidata *nd) +{ + /* + * Eventually, we'll want to revalidate snapped metadata + * too... probably. + */ + return 1; +} + + + +/* + * read() on a dir. This weird interface hack only works if mounted + * with '-o dirstat'. + */ +static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size, + loff_t *ppos) +{ + struct ceph_file_info *cf = file->private_data; + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + int left; + + if (!(ceph_client(inode->i_sb)->mount_args.flags & CEPH_MOUNT_DIRSTAT)) + return -EISDIR; + + if (!cf->dir_info) { + cf->dir_info = kmalloc(1024, GFP_NOFS); + if (!cf->dir_info) + return -ENOMEM; + cf->dir_info_len = + sprintf(cf->dir_info, + "entries: %20lld\n" + " files: %20lld\n" + " subdirs: %20lld\n" + "rentries: %20lld\n" + " rfiles: %20lld\n" + " rsubdirs: %20lld\n" + "rbytes: %20lld\n" + "rctime: %10ld.%09ld\n", + ci->i_files + ci->i_subdirs, + ci->i_files, + ci->i_subdirs, + ci->i_rfiles + ci->i_rsubdirs, + ci->i_rfiles, + ci->i_rsubdirs, + ci->i_rbytes, + (long)ci->i_rctime.tv_sec, + (long)ci->i_rctime.tv_nsec); + } + + if (*ppos >= cf->dir_info_len) + return 0; + size = min_t(unsigned, size, cf->dir_info_len-*ppos); + left = copy_to_user(buf, cf->dir_info + *ppos, size); + if (left == size) + return -EFAULT; + *ppos += (size - left); + return size - left; +} + +const struct file_operations ceph_dir_fops = { + .read = ceph_read_dir, + .readdir = ceph_readdir, + .llseek = ceph_dir_llseek, + .open = ceph_open, + .release = ceph_release, + .unlocked_ioctl = ceph_ioctl, +}; + +const struct inode_operations ceph_dir_iops = { + .lookup = ceph_lookup, + .getattr = ceph_getattr, + .setattr = ceph_setattr, + .setxattr = ceph_setxattr, + .getxattr = ceph_getxattr, + .listxattr = ceph_listxattr, + .removexattr = ceph_removexattr, + .mknod = ceph_mknod, + .symlink = ceph_symlink, + .mkdir = ceph_mkdir, + .link = ceph_link, + .unlink = ceph_unlink, + .rmdir = ceph_unlink, + .rename = ceph_rename, + .create = ceph_create, +}; + +struct dentry_operations ceph_dentry_ops = { + .d_revalidate = ceph_dentry_revalidate, + .d_release = ceph_dentry_release, +}; + +struct dentry_operations ceph_snapdir_dentry_ops = { + .d_revalidate = ceph_snapdir_dentry_revalidate, +}; + +struct dentry_operations ceph_snap_dentry_ops = { +}; -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 07/19] ceph: file operations 2008-11-14 0:56 ` [PATCH 06/19] ceph: directory operations Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 08/19] ceph: address space operations Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil File open and close operations, and read and write methods that ensure we have obtained the proper capabilities from the MDS cluster before performing IO on a file. We take references on held capabilities for the duration of the read/write to avoid prematurely releasing them back to the MDS. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/file.c | 446 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 446 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/file.c diff --git a/fs/ceph/file.c b/fs/ceph/file.c new file mode 100644 index 0000000..19e93f2 --- /dev/null +++ b/fs/ceph/file.c @@ -0,0 +1,446 @@ + +#include <linux/sched.h> +#include <linux/file.h> + +#include "ceph_debug.h" + +int ceph_debug_file = -1; +#define DOUT_MASK DOUT_MASK_FILE +#define DOUT_VAR ceph_debug_file +#define DOUT_PREFIX "file: " +#include "super.h" + +#include "mds_client.h" + +#include <linux/namei.h> + + +/* + * Prepare an open request. Preallocate ceph_cap to avoid an + * inopportune ENOMEM later. + */ +static struct ceph_mds_request * +prepare_open_request(struct super_block *sb, struct dentry *dentry, + int flags, int create_mode) +{ + struct ceph_client *client = ceph_sb_to_client(sb); + struct ceph_mds_client *mdsc = &client->mdsc; + u64 pathbase; + char *path; + int pathlen; + struct ceph_mds_request *req; + struct ceph_mds_request_head *rhead; + int want_auth = USE_ANY_MDS; + + if (flags & (O_WRONLY|O_RDWR|O_CREAT|O_TRUNC)) + want_auth = USE_AUTH_MDS; + + dout(5, "prepare_open_request dentry %p name '%s' flags %d\n", dentry, + dentry->d_name.name, flags); + path = ceph_build_path(dentry, &pathlen, &pathbase, 0); + if (IS_ERR(path)) + return ERR_PTR(PTR_ERR(path)); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_OPEN, pathbase, path, + 0, NULL, + dentry, want_auth); + kfree(path); + if (IS_ERR(req)) + goto out; + req->r_expected_cap = kmalloc(sizeof(struct ceph_cap), GFP_NOFS); + if (!req->r_expected_cap) { + ceph_mdsc_put_request(req); + return ERR_PTR(-ENOMEM); + } + req->r_fmode = ceph_flags_to_mode(flags); + + rhead = req->r_request->front.iov_base; + rhead->args.open.flags = cpu_to_le32(flags); + rhead->args.open.mode = cpu_to_le32(create_mode); +out: + return req; +} + +/* + * initialize private struct file data. + * if we fail, clean up by dropping fmode reference on the ceph_inode + */ +static int ceph_init_file(struct inode *inode, struct file *file, int fmode) +{ + struct ceph_file_info *cf; + + cf = kzalloc(sizeof(*cf), GFP_NOFS); + if (cf == NULL) { + ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */ + return -ENOMEM; + } + cf->mode = fmode; + file->private_data = cf; + return 0; +} + +/* + * If the filp already has private_data, that means the file was + * already opened by intent during lookup, and we do nothing. + * + * If we already have the requisite capabilities, we can satisfy + * the open request locally (no need to request new caps from the + * MDS). + */ +int ceph_open(struct inode *inode, struct file *file) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_sb_to_client(inode->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct dentry *dentry; + struct ceph_mds_request *req; + struct ceph_file_info *cf = file->private_data; + int err; + int flags, fmode, wantcaps; + + if (ceph_snap(inode) != CEPH_NOSNAP && (file->f_mode & FMODE_WRITE)) + return -EROFS; + + if (cf) { + dout(5, "open file %p is already opened\n", file); + return 0; + } + + /* filter out O_CREAT|O_EXCL; vfs did that already. yuck. */ + flags = file->f_flags & ~(O_CREAT|O_EXCL); + if (S_ISDIR(inode->i_mode)) + flags = O_DIRECTORY; /* mds likes to know */ + + dout(5, "open inode %p ino %llx.%llx file %p flags %d (%d)\n", inode, + ceph_vinop(inode), file, flags, file->f_flags); + fmode = ceph_flags_to_mode(flags); + wantcaps = ceph_caps_for_mode(fmode); + + /* can we re-use existing caps? */ + spin_lock(&inode->i_lock); + if ((__ceph_caps_issued(ci, NULL) & wantcaps) == wantcaps) { + dout(10, "open fmode %d caps %d using existing on %p\n", + fmode, wantcaps, inode); + __ceph_get_fmode(ci, fmode); + spin_unlock(&inode->i_lock); + return ceph_init_file(inode, file, fmode); + } + spin_unlock(&inode->i_lock); + dout(10, "open fmode %d, don't have caps %d\n", fmode, wantcaps); + + dentry = d_find_alias(inode); + if (!dentry) + return -ESTALE; /* yuck */ + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_ICONTENT); + req = prepare_open_request(inode->i_sb, dentry, flags, 0); + if (IS_ERR(req)) { + err = PTR_ERR(req); + goto out; + } + err = ceph_mdsc_do_request(mdsc, req); + if (!err) + err = ceph_init_file(inode, file, req->r_fmode); + ceph_mdsc_put_request(req); + dout(5, "open result=%d on %llx.%llx\n", err, ceph_vinop(inode)); +out: + dput(dentry); + return err; +} + + +/* + * Do a lookup + open with a single request. + * + * If this succeeds, but some subsequent check in the vfs + * may_open() fails, the struct *file gets cleaned up (i.e. + * ceph_release gets called). So fear not! + */ +/* + * flags + * path_lookup_open -> LOOKUP_OPEN + * path_lookup_create -> LOOKUP_OPEN|LOOKUP_CREATE + */ +struct dentry *ceph_lookup_open(struct inode *dir, struct dentry *dentry, + struct nameidata *nd, int mode, + int locked_dir) +{ + struct ceph_client *client = ceph_sb_to_client(dir->i_sb); + struct ceph_mds_client *mdsc = &client->mdsc; + struct file *file = nd->intent.open.file; + struct ceph_mds_request *req; + int err; + int flags = nd->intent.open.flags - 1; /* silly vfs! */ + + dout(5, "ceph_lookup_open dentry %p '%.*s' flags %d mode 0%o\n", + dentry, dentry->d_name.len, dentry->d_name.name, flags, mode); + + /* do the open */ + req = prepare_open_request(dir->i_sb, dentry, flags, mode); + if (IS_ERR(req)) + return ERR_PTR(PTR_ERR(req)); + if (flags & O_CREAT) + ceph_mdsc_lease_release(mdsc, dir, NULL, CEPH_LOCK_ICONTENT); + req->r_last_dentry = dget(dentry); /* use this dentry in fill_trace */ + req->r_locked_dir = dir; /* caller holds dir->i_mutex */ + err = ceph_mdsc_do_request(mdsc, req); + dentry = ceph_finish_lookup(req, dentry, err); + if (!err) + err = ceph_init_file(req->r_last_inode, file, req->r_fmode); + ceph_mdsc_put_request(req); + dout(5, "ceph_lookup_open result=%p\n", dentry); + return dentry; +} + +int ceph_release(struct inode *inode, struct file *file) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_file_info *cf = file->private_data; + + dout(5, "release inode %p file %p\n", inode, file); + + /* + * MYSTERY: why is file->f_flags now different than + * file->f_flags (actually, nd->intent.open.flags) on + * open? e.g., on ceph_lookup_open, + * ceph_file: opened 000000006fa3ebd0 flags 0101102 mode 2 nr now 1.\ + * wanted 0 -> 30 + * and on release, + * ceph_file: released 000000006fa3ebd0 flags 0100001 mode 3 nr now \ + * -1. wanted 30 was 30 + * + * Huh. Well, for now, store the open mode in ceph_file_info. + */ + + ceph_put_fmode(ci, cf->mode); + if (cf->last_readdir) + ceph_mdsc_put_request(cf->last_readdir); + kfree(cf->dir_info); + kfree(cf); + return 0; +} + +/* + * Completely synchronous read and write methods. Direct from __user + * buffer to osd. + */ +static ssize_t ceph_sync_read(struct file *file, char __user *data, + size_t count, loff_t *offset) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_inode_to_client(inode); + int ret = 0; + off_t pos = *offset; + + dout(10, "sync_read on file %p %lld~%u\n", file, *offset, + (unsigned)count); + + ret = ceph_osdc_sync_read(&client->osdc, ceph_vino(inode), + &ci->i_layout, + pos, count, data); + if (ret > 0) + *offset = pos + ret; + return ret; +} + +static ssize_t ceph_sync_write(struct file *file, const char __user *data, + size_t count, loff_t *offset) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_inode_to_client(inode); + int ret = 0; + off_t pos = *offset; + + if (ceph_snap(file->f_dentry->d_inode) != CEPH_NOSNAP) + return -EROFS; + + dout(10, "sync_write on file %p %lld~%u\n", file, *offset, + (unsigned)count); + + if (file->f_flags & O_APPEND) + pos = i_size_read(inode); + + ret = ceph_osdc_sync_write(&client->osdc, ceph_vino(inode), + &ci->i_layout, + ci->i_snap_realm->cached_context, + pos, count, data); + if (ret > 0) { + pos += ret; + *offset = pos; + if (pos > i_size_read(inode)) + ceph_inode_set_size(inode, pos); + } + + return ret; +} + +/* + * Wrap generic_file_aio_read with checks for cap bits on the inode. + * Atomically grab references, so that those bits are not released + * back to the MDS mid-read. + * + * Hmm, the sync reach case isn't actually async... should it be? + */ +static ssize_t ceph_aio_read(struct kiocb *iocb, const struct iovec *iov, + unsigned long nr_segs, loff_t pos) +{ + struct file *filp = iocb->ki_filp; + loff_t *ppos = &iocb->ki_pos; + size_t len = iov->iov_len; + struct inode *inode = filp->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + ssize_t ret; + int got = 0; + + __ceph_do_pending_vmtruncate(inode); + + dout(10, "aio_read %llx.%llx %llu~%u trying to get caps on %p\n", + ceph_vinop(inode), pos, (unsigned)len, inode); + ret = wait_event_interruptible(ci->i_cap_wq, + ceph_get_cap_refs(ci, CEPH_CAP_RD, + CEPH_CAP_RDCACHE, + &got, -1)); + if (ret < 0) + goto out; + dout(10, "aio_read %llx.%llx %llu~%u got cap refs %d\n", + ceph_vinop(inode), pos, (unsigned)len, got); + + if ((got & CEPH_CAP_RDCACHE) == 0 || + (inode->i_sb->s_flags & MS_SYNCHRONOUS)) + /* hmm, this isn't really async... */ + ret = ceph_sync_read(filp, iov->iov_base, len, ppos); + else + ret = generic_file_aio_read(iocb, iov, nr_segs, pos); + +out: + dout(10, "aio_read %llx.%llx dropping cap refs on %d\n", + ceph_vinop(inode), got); + ceph_put_cap_refs(ci, got); + return ret; +} + +/* + * Check the offset we are writing up to against our current + * max_size. If necessary, tell the MDS we want to write to + * a larger offset. + */ +static void check_max_size(struct inode *inode, loff_t endoff) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int check = 0; + + /* do we need to explicitly request a larger max_size? */ + spin_lock(&inode->i_lock); + if ((endoff >= ci->i_max_size || + endoff > (inode->i_size << 1)) && + endoff > ci->i_wanted_max_size) { + dout(10, "write %p at large endoff %llu, req max_size\n", + inode, endoff); + ci->i_wanted_max_size = endoff; + check = 1; + } + spin_unlock(&inode->i_lock); + if (check) + ceph_check_caps(ci, 0); +} + +/* + * Take cap references to avoid releasing caps to MDS mid-write. + * + * If we are synchronous, and write with an old snap context, the OSD + * may return EOLDSNAPC. In that case, retry the write.. _after_ + * dropping our cap refs and allowing the pending snap to logically + * complete _before_ this write occurs. + * + * If we are near ENOSPC, write synchronously. + */ +static ssize_t ceph_aio_write(struct kiocb *iocb, const struct iovec *iov, + unsigned long nr_segs, loff_t pos) +{ + struct file *file = iocb->ki_filp; + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_osd_client *osdc = &ceph_client(inode->i_sb)->osdc; + loff_t endoff = pos + iov->iov_len; + int got = 0; + int ret; + + if (ceph_snap(inode) != CEPH_NOSNAP) + return -EROFS; + +retry_snap: + if (ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_FULL)) + return -ENOSPC; + __ceph_do_pending_vmtruncate(inode); + check_max_size(inode, endoff); + dout(10, "aio_write %p %llu~%u getting caps. i_size %llu\n", + inode, pos, (unsigned)iov->iov_len, inode->i_size); + ret = wait_event_interruptible(ci->i_cap_wq, + ceph_get_cap_refs(ci, CEPH_CAP_WR, + CEPH_CAP_WRBUFFER, + &got, endoff)); + if (ret < 0) + goto out; + + dout(10, "aio_write %p %llu~%u got cap refs on %d\n", + inode, pos, (unsigned)iov->iov_len, got); + + if ((got & CEPH_CAP_WRBUFFER) == 0 || + ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_NEARFULL) || + (inode->i_sb->s_flags & MS_SYNCHRONOUS)) + /* fixme, this isn't actually async! */ + ret = ceph_sync_write(file, iov->iov_base, iov->iov_len, + &iocb->ki_pos); + else + ret = generic_file_aio_write(iocb, iov, nr_segs, pos); + +out: + dout(10, "aio_write %p %llu~%u dropping cap refs on %d\n", + inode, pos, (unsigned)iov->iov_len, got); + ceph_put_cap_refs(ci, got); + + if (ret == -EOLDSNAPC) { + dout(10, "aio_write %p %llu~%u got EOLDSNAPC, retrying\n", + inode, pos, (unsigned)iov->iov_len); + goto retry_snap; + } + + return ret; +} + +static int ceph_fsync(struct file *file, struct dentry *dentry, int datasync) +{ + struct inode *inode = dentry->d_inode; + int ret; + + dout(10, "fsync on inode %p\n", inode); + ret = write_inode_now(inode, 1); + if (ret < 0) + return ret; + + /* + * HMM: should we also ensure that caps are flushed to mds? + * It's not strictly necessary, since with the data on the + * osds the mds can/will always reconstruct the file size. + * Not mtime, though. + */ + + return 0; +} + +const struct file_operations ceph_file_fops = { + .open = ceph_open, + .release = ceph_release, + .llseek = generic_file_llseek, + .read = do_sync_read, + .write = do_sync_write, + .aio_read = ceph_aio_read, + .aio_write = ceph_aio_write, + .mmap = ceph_mmap, + .fsync = ceph_fsync, + .splice_read = generic_file_splice_read, + .splice_write = generic_file_splice_write, + .unlocked_ioctl = ceph_ioctl, +}; + + -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 08/19] ceph: address space operations 2008-11-14 0:56 ` [PATCH 07/19] ceph: file operations Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 09/19] ceph: MDS client Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil The ceph address space methods are concerned primarily with managing the dirty page accounting in the inode, which (among other things) must keep track of which snapshot context each page was dirtied in, and ensure that dirty data is written out to the OSDs in snapshort order. A writepage() on a page that is not currently writeable due to snapshot writeback ordering (presumably called from kswapd) is ignored. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/addr.c | 1010 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1010 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/addr.c diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c new file mode 100644 index 0000000..817fd61 --- /dev/null +++ b/fs/ceph/addr.c @@ -0,0 +1,1010 @@ + +#include <linux/backing-dev.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/pagemap.h> +#include <linux/writeback.h> /* generic_writepages */ +#include <linux/pagevec.h> +#include <linux/task_io_accounting_ops.h> + +#include "ceph_debug.h" +int ceph_debug_addr = -1; +#define DOUT_MASK DOUT_MASK_ADDR +#define DOUT_VAR ceph_debug_addr +#define DOUT_PREFIX "addr: " +#include "super.h" + +#include "osd_client.h" + +/* + * There are a few funny things going on here. + * + * The page->private field is used to reference a struct + * ceph_snap_context for _every_ dirty page. This indicates which + * snapshot the page was logically dirtied in, and thus which snap + * context needs to be associated with the osd write during writeback. + * + * Similarly, struct ceph_inode_info maintains a set of counters to + * count dirty pages on the inode. In the absense of snapshots, + * i_wrbuffer_ref == i_wrbuffer_ref_head == the dirty page count. + * + * A snapshot is taken (that is, when the client receives notification + * that a snapshot was taken), each inode with caps and with dirty + * pages (dirty pages implies there is a cap) gets a new ceph_cap_snap + * in the i_cap_snaps (which is sorted in ascending order, new snaps + * go to the tail). The i_wrbuffer_ref_head count is moved to + * capsnap->dirty. (Unless a sync write is currently in progress. In + * that case, the capsnap is said to be "pending", new writes cannot + * start, and the capsnap isn't "finalized" until the write completes + * (or fails) and a final size/mtime for the inode for that snap can + * be settled upon.) i_wrbuffer_ref_head is reset to 0. + * + * On writeback, we must submit writes to the osd IN SNAP ORDER. So, + * we look for the first capsnap in i_cap_snaps and write out pages in + * that snap context _only_. Then we move on to the next capsnap, + * eventually reachings the "live" or "head" context (i.e., pages that + * are not yet snapped) and are writing the most recently dirtied + * pages. + * + * Invalidate and so forth must take care to ensure the dirty page + * accounting is preserved. + */ + +/* + * Dirty a page. If @snapc is NULL, use the current snap context for + * i_snap_realm. Otherwise, redirty a page within the context of + * the given *snapc. + * + * Note that the caller (e.g., write_begin) _should_ be holding + * a read lock on mdsc->snap_rwsem. + */ +static int ceph_set_page_dirty(struct page *page, + struct ceph_snap_context *snapc) +{ + struct address_space *mapping = page->mapping; + struct inode *inode; + struct ceph_inode_info *ci; + int undo = 0; + + if (unlikely(!mapping)) + return !TestSetPageDirty(page); + + if (TestSetPageDirty(page)) { + dout(20, "%p set_page_dirty %p -- already dirty\n", + mapping->host, page); + return 0; + } + + /* + * optimistically adjust accounting, on the assumption that + * we won't race with invalidate. + */ + inode = mapping->host; + ci = ceph_inode(inode); + + spin_lock(&inode->i_lock); + ++ci->i_wrbuffer_ref; + if (!snapc || snapc == ci->i_snap_realm->cached_context) { + /* dirty the head */ + snapc = ceph_get_snap_context(ci->i_snap_realm->cached_context); + if (ci->i_wrbuffer_ref_head == 0) + ci->i_head_snapc = ceph_get_snap_context(snapc); + ++ci->i_wrbuffer_ref_head; + dout(20, "%p set_page_dirty %p head %d/%d -> %d/%d " + "snapc %p seq %lld (%d snaps)\n", + mapping->host, page, + ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1, + ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head, + snapc, snapc->seq, snapc->num_snaps); + } else { + struct list_head *p; + struct ceph_cap_snap *capsnap = NULL; + + list_for_each(p, &ci->i_cap_snaps) { + capsnap = list_entry(p, struct ceph_cap_snap, + ci_item); + if (capsnap->context == snapc) + break; + } + BUG_ON(!capsnap); + BUG_ON(capsnap->context != snapc); + capsnap->dirty++; + dout(20, "%p set_page_dirty %p snap %lld %d/%d -> %d/%d" + " snapc %p seq %lld (%d snaps)\n", + mapping->host, page, capsnap->follows, + ci->i_wrbuffer_ref-1, capsnap->dirty-1, + ci->i_wrbuffer_ref, capsnap->dirty, + snapc, snapc->seq, snapc->num_snaps); + } + 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)); + + if (mapping_cap_account_dirty(mapping)) { + __inc_zone_page_state(page, NR_FILE_DIRTY); + __inc_bdi_stat(mapping->backing_dev_info, + BDI_RECLAIMABLE); + task_io_account_write(PAGE_CACHE_SIZE); + } + radix_tree_tag_set(&mapping->page_tree, + page_index(page), PAGECACHE_TAG_DIRTY); + + /* + * Reference snap context in page->private. Also set + * PagePrivate so that we get invalidatepage callback. + */ + ceph_put_snap_context((void *)page->private); + page->private = (unsigned long)snapc; + SetPagePrivate(page); + } else { + dout(20, "ANON set_page_dirty %p (raced truncate?)\n", 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); + + __mark_inode_dirty(mapping->host, I_DIRTY_PAGES); + + return 1; +} + +static int ceph_set_page_dirty_vfs(struct page *page) +{ + return ceph_set_page_dirty(page, NULL); +} + +/* + * If we are truncating the full page (i.e. offset == 0), adjust the + * dirty page counters appropriately. + */ +static void ceph_invalidatepage(struct page *page, unsigned long offset) +{ + struct inode *inode; + struct ceph_inode_info *ci; + struct ceph_snap_context *snapc = (void *)page->private; + + BUG_ON(!PageLocked(page)); + if (offset == 0) + ClearPageChecked(page); + if (!PageDirty(page)) { + BUG_ON(snapc); + dout(20, "invalidatepage %p idx %lu clean\n", page, + page->index); + return; + } + if (!page->mapping) { + BUG_ON(snapc); + dout(20, "invalidatepage %p idx %lu unmapped\n", page, + page->index); + return; + } + inode = page->mapping->host; + ci = ceph_inode(inode); + if (offset == 0) { + dout(20, "%p invalidatepage %p idx %lu full dirty page %lu\n", + &ci->vfs_inode, page, page->index, offset); + ceph_put_wrbuffer_cap_refs(ci, 1, snapc); + ceph_put_snap_context(snapc); + page->private = 0; + ClearPagePrivate(page); + } else { + dout(20, "%p invalidatepage %p idx %lu partial dirty page\n", + &ci->vfs_inode, page, page->index); + } +} + +/* just a sanity check */ +static int ceph_releasepage(struct page *page, gfp_t g) +{ + struct inode *inode = page->mapping ? page->mapping->host : NULL; + dout(20, "%p releasepage %p idx %lu\n", inode, page, page->index); + WARN_ON(PageDirty(page)); + WARN_ON(page->private); + WARN_ON(PagePrivate(page)); + return 0; +} + +/* + * read a single page, without unlocking it. + */ +static int readpage_nounlock(struct file *filp, struct page *page) +{ + struct inode *inode = filp->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_osd_client *osdc = &ceph_inode_to_client(inode)->osdc; + int err = 0; + + dout(10, "readpage inode %p file %p page %p index %lu\n", + inode, filp, page, page->index); + err = ceph_osdc_readpage(osdc, ceph_vino(inode), &ci->i_layout, + page->index << PAGE_SHIFT, PAGE_SIZE, page); + if (unlikely(err < 0)) { + SetPageError(page); + goto out; + } + if (unlikely(err < PAGE_CACHE_SIZE)) { + void *kaddr = kmap_atomic(page, KM_USER0); + dout(10, "readpage zeroing tail %d bytes of page %p\n", + (int)PAGE_CACHE_SIZE - err, page); + memset(kaddr + err, 0, PAGE_CACHE_SIZE - err); + kunmap_atomic(kaddr, KM_USER0); + } + SetPageUptodate(page); + +out: + return err; +} + +static int ceph_readpage(struct file *filp, struct page *page) +{ + int r = readpage_nounlock(filp, page); + unlock_page(page); + return r; +} + +/* + * Read multiple pages. Most of the work is done in the osd_client. + */ +static int ceph_readpages(struct file *file, struct address_space *mapping, + struct list_head *page_list, unsigned nr_pages) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_osd_client *osdc = &ceph_inode_to_client(inode)->osdc; + int rc = 0; + struct page *page; + struct pagevec pvec; + loff_t offset; + + dout(10, "readpages inode %p file %p nr_pages %d\n", + inode, file, nr_pages); + + /* guess read extent */ + BUG_ON(list_empty(page_list)); + page = list_entry(page_list->prev, struct page, lru); + offset = page->index << PAGE_CACHE_SHIFT; + rc = ceph_osdc_readpages(osdc, mapping, ceph_vino(inode), &ci->i_layout, + offset, nr_pages << PAGE_CACHE_SHIFT, + page_list, nr_pages); + if (rc < 0) + return rc; + + /* set uptodate and add to lru in pagevec-sized chunks */ + pagevec_init(&pvec, 0); + if (rc > 0) + rc += offset & ~PAGE_CACHE_MASK; + for (; rc > 0; rc -= PAGE_CACHE_SIZE) { + if (list_empty(page_list)) + break; /* WTF */ + page = list_entry(page_list->prev, struct page, lru); + list_del(&page->lru); + + if (add_to_page_cache(page, mapping, page->index, GFP_NOFS)) { + page_cache_release(page); + dout(20, "readpages add_to_page_cache failed on %p\n", + page); + continue; + } + dout(10, "readpages adding page %p\n", page); + flush_dcache_page(page); + 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 + return 0; +} + +/* + * Get ref for the oldest snapc for an inode with dirty data... that is, the + * only snap context we are allowed to write back. + * + * Caller holds i_lock. + */ +static struct ceph_snap_context *__get_oldest_context(struct inode *inode) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_snap_context *snapc = NULL; + struct list_head *p; + struct ceph_cap_snap *capsnap = NULL; + + list_for_each(p, &ci->i_cap_snaps) { + capsnap = list_entry(p, struct ceph_cap_snap, ci_item); + dout(20, " cap_snap %p snapc %p has %d dirty pages\n", capsnap, + capsnap->context, capsnap->dirty); + if (capsnap->dirty) + break; + } + if (capsnap && capsnap->dirty) { + snapc = ceph_get_snap_context(capsnap->context); + } else if (ci->i_snap_realm) { + snapc = ceph_get_snap_context(ci->i_snap_realm->cached_context); + dout(20, " head snapc %p has %d dirty pages\n", + snapc, ci->i_wrbuffer_ref_head); + } + return snapc; +} + +static struct ceph_snap_context *get_oldest_context(struct inode *inode) +{ + struct ceph_snap_context *snapc = NULL; + + spin_lock(&inode->i_lock); + snapc = __get_oldest_context(inode); + spin_unlock(&inode->i_lock); + return snapc; +} + +/* + * Write a single page, but leave the page locked. + * + * If we get a write error, set the page error bit, but still adjust the + * dirty page accounting (i.e., page is no longer dirty). + * + * FIXME: Is that the right thing to do? + */ +static int writepage_nounlock(struct page *page, struct writeback_control *wbc) +{ + struct inode *inode; + struct ceph_inode_info *ci; + struct ceph_osd_client *osdc; + loff_t page_off = page->index << PAGE_CACHE_SHIFT; + int len = PAGE_CACHE_SIZE; + loff_t i_size; + int err = 0; + struct ceph_snap_context *snapc; + + dout(10, "writepage %p idx %lu\n", page, page->index); + + if (!page->mapping || !page->mapping->host) { + dout(10, "writepage %p - no mapping\n", page); + return -EFAULT; + } + inode = page->mapping->host; + ci = ceph_inode(inode); + osdc = &ceph_inode_to_client(inode)->osdc; + + /* is this a partial page at end of file? */ + i_size = i_size_read(inode); + if (i_size < page_off + len) + len = i_size - page_off; + dout(10, "writepage %p page %p index %lu on %llu~%u\n", + inode, page, page->index, page_off, len); + + /* verify this is a writeable snap context */ + snapc = (void *)page->private; + if (snapc == NULL) { + dout(20, "writepage %p page %p not dirty?\n", inode, page); + goto out; + } + if (snapc != get_oldest_context(inode)) { + dout(10, "writepage %p page %p snapc %p not writeable - noop\n", + inode, page, (void *)page->private); + /* we should only noop if called by kswapd */ + WARN_ON((current->flags & PF_MEMALLOC) == 0); + goto out; + } + + set_page_writeback(page); + err = ceph_osdc_writepages(osdc, ceph_vino(inode), + &ci->i_layout, snapc, + page_off, len, &page, 1); + if (err < 0) { + dout(20, "writepage setting page error %p\n", page); + SetPageError(page); + if (wbc) + wbc->pages_skipped++; + } else { + dout(20, "writepage cleaned page %p\n", page); + err = 0; /* vfs expects us to return 0 */ + } + page->private = 0; + ClearPagePrivate(page); + end_page_writeback(page); + ceph_put_wrbuffer_cap_refs(ci, 1, snapc); + ceph_put_snap_context(snapc); +out: + return err; +} + +static int ceph_writepage(struct page *page, struct writeback_control *wbc) +{ + int err = writepage_nounlock(page, wbc); + unlock_page(page); + return err; +} + + +/* + * lame release_pages helper. release_pages() isn't exported to + * modules. + */ +static void ceph_release_pages(struct page **pages, int num) +{ + struct pagevec pvec; + int i; + pagevec_init(&pvec, 0); + for (i = 0; i < num; i++) { + if (pagevec_add(&pvec, pages[i]) == 0) + pagevec_release(&pvec); + } + pagevec_release(&pvec); +} + + +/* + * async writeback completion handler. + * + * If we get an error, set the mapping error bit, but not the individual + * page error bits. + * + * FIXME: What should we be doing here? + */ +static void writepages_finish(struct ceph_osd_request *req) +{ + struct inode *inode = req->r_inode; + struct ceph_osd_reply_head *replyhead; + struct ceph_osd_op *op; + struct ceph_inode_info *ci = ceph_inode(inode); + unsigned wrote; + loff_t offset = req->r_pages[0]->index << PAGE_CACHE_SHIFT; + struct page *page; + int i; + struct ceph_snap_context *snapc = req->r_snapc; + struct address_space *mapping = inode->i_mapping; + struct writeback_control *wbc = req->r_wbc; + __s32 rc = -EIO; + u64 bytes = 0; + + /* parse reply */ + if (req->r_reply) { + replyhead = req->r_reply->front.iov_base; + op = (void *)(replyhead + 1); + rc = le32_to_cpu(replyhead->result); + bytes = le64_to_cpu(op->length); + } + + if (rc >= 0) { + wrote = (bytes + (offset & ~PAGE_CACHE_MASK) + ~PAGE_CACHE_MASK) + >> PAGE_CACHE_SHIFT; + BUG_ON(wrote != req->r_num_pages); + } else { + wrote = 0; + mapping_set_error(mapping, rc); + } + dout(10, "writepages_finish rc %d bytes %llu wrote %d (pages)\n", rc, + bytes, wrote); + + /* clean all pages */ + for (i = 0; i < req->r_num_pages; i++) { + page = req->r_pages[i]; + BUG_ON(!page); + WARN_ON(!PageUptodate(page)); + + if (i >= wrote) { + dout(20, "inode %p skipping page %p\n", inode, page); + wbc->pages_skipped++; + } + page->private = 0; + ClearPagePrivate(page); + ceph_put_snap_context(snapc); + dout(50, "unlocking %d %p\n", i, page); + end_page_writeback(page); + unlock_page(page); + } + dout(20, "%p wrote+cleaned %d pages\n", inode, wrote); + ceph_put_wrbuffer_cap_refs(ci, req->r_num_pages, snapc); + + ceph_release_pages(req->r_pages, req->r_num_pages); + ceph_osdc_put_request(req); +} + +/* + * initiate async writeback + */ +static int ceph_writepages_start(struct address_space *mapping, + struct writeback_control *wbc) +{ + struct inode *inode = mapping->host; + struct backing_dev_info *bdi = mapping->backing_dev_info; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_client *client = ceph_inode_to_client(inode); + pgoff_t index, start, end; + int range_whole = 0; + int should_loop = 1; + struct page **pages = NULL; + pgoff_t max_pages = 0, max_pages_ever = 0; + struct ceph_snap_context *snapc = NULL, *last_snapc = NULL; + struct pagevec pvec; + int done = 0; + int rc = 0; + unsigned wsize = 1 << inode->i_blkbits; + struct ceph_osd_request *req = NULL; + + client = ceph_inode_to_client(inode); + if (client->mount_state == CEPH_MOUNT_SHUTDOWN) { + dout(1, "writepage on forced umount\n"); + return -EIO; /* we're in a forced umount, don't write! */ + } + if (client->mount_args.wsize && client->mount_args.wsize < wsize) + wsize = client->mount_args.wsize; + if (wsize < PAGE_CACHE_SIZE) + wsize = PAGE_CACHE_SIZE; + max_pages_ever = wsize >> PAGE_CACHE_SHIFT; + dout(10, "writepages on %p, wsize %u\n", inode, wsize); + + pagevec_init(&pvec, 0); + + /* ?? */ + if (wbc->nonblocking && bdi_write_congested(bdi)) { + dout(10, "writepages congested\n"); + wbc->encountered_congestion = 1; + return 0; + } + + /* where to start/end? */ + if (wbc->range_cyclic) { + start = mapping->writeback_index; /* Start from prev offset */ + end = -1; + dout(10, "cyclic, start at %lu\n", start); + } else { + start = wbc->range_start >> PAGE_CACHE_SHIFT; + end = wbc->range_end >> PAGE_CACHE_SHIFT; + if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) + range_whole = 1; + should_loop = 0; + dout(10, "not cyclic, %lu to %lu\n", start, end); + } + index = start; + +retry: + /* find oldest snap context with dirty data */ + ceph_put_snap_context(snapc); + snapc = get_oldest_context(inode); + if (!snapc) { + /* hmm, why does writepages get called when there + is no dirty data? */ + dout(20, " no snap context with dirty data?\n"); + goto out; + } + dout(20, " oldest snapc is %p seq %lld (%d snaps)\n", + snapc, snapc->seq, snapc->num_snaps); + if (last_snapc && snapc != last_snapc) { + /* if we switched to a newer snapc, restart our scan at the + * start of the original file range. */ + dout(20, " snapc differs from last pass, restarting at %lu\n", + index); + index = start; + } + last_snapc = snapc; + + while (!done && index <= end) { + unsigned i; + int first; + pgoff_t next; + int pvec_pages, locked_pages; + struct page *page; + int want; + u64 offset, len; + + next = 0; + locked_pages = 0; + max_pages = max_pages_ever; + +get_more_pages: + first = -1; + want = min(end - index, + min((pgoff_t)PAGEVEC_SIZE, + max_pages - (pgoff_t)locked_pages) - 1) + + 1; + pvec_pages = pagevec_lookup_tag(&pvec, mapping, &index, + PAGECACHE_TAG_DIRTY, + want); + dout(20, "pagevec_lookup_tag got %d\n", pvec_pages); + if (!pvec_pages && !locked_pages) + break; + for (i = 0; i < pvec_pages && locked_pages < max_pages; i++) { + page = pvec.pages[i]; + 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 */ + if (unlikely(!PageDirty(page)) || + unlikely(page->mapping != mapping)) { + dout(20, "!dirty or !mapping %p\n", page); + unlock_page(page); + break; + } + if (!wbc->range_cyclic && page->index > end) { + dout(20, "end of range %p\n", page); + done = 1; + unlock_page(page); + break; + } + if (next && (page->index != next)) { + dout(20, "not consecutive %p\n", page); + unlock_page(page); + break; + } + if (wbc->sync_mode != WB_SYNC_NONE) { + dout(20, "waiting on writeback %p\n", page); + wait_on_page_writeback(page); + } + if (page_offset(page) >= i_size_read(inode)) { + dout(20, "%p past eof %llu\n", page, + i_size_read(inode)); + done = 1; + unlock_page(page); + break; + } + if (PageWriteback(page)) { + dout(20, "%p under writeback\n", page); + unlock_page(page); + break; + } + + /* only if matching snap context */ + if (snapc != (void *)page->private) { + dout(20, "page snapc %p != oldest %p\n", + (void *)page->private, snapc); + unlock_page(page); + if (!locked_pages) + continue; /* keep looking for snap */ + break; + } + + if (!clear_page_dirty_for_io(page)) { + dout(20, "%p !clear_page_dirty_for_io\n", page); + unlock_page(page); + break; + } + + /* ok */ + if (locked_pages == 0) { + /* prepare async write request */ + offset = page->index << PAGE_CACHE_SHIFT; + len = wsize; + req = ceph_osdc_new_request(&client->osdc, + &ci->i_layout, + ceph_vino(inode), + offset, &len, + CEPH_OSD_OP_WRITE, + snapc); + max_pages = req->r_num_pages; + pages = req->r_pages; + req->r_callback = writepages_finish; + req->r_inode = inode; + req->r_wbc = wbc; + } + + /* note position of first page in pvec */ + if (first < 0) + first = i; + dout(20, "%p will write page %p idx %lu\n", + inode, page, page->index); + set_page_writeback(page); + pages[locked_pages] = page; + locked_pages++; + next = page->index + 1; + } + + /* did we get anything? */ + if (!locked_pages) + goto release_pvec_pages; + if (i) { + int j; + BUG_ON(!locked_pages || first < 0); + + if (pvec_pages && i == pvec_pages && + locked_pages < max_pages) { + dout(50, "reached end pvec, trying for more\n"); + pagevec_reinit(&pvec); + goto get_more_pages; + } + + /* shift unused pages over in the pvec... we + * will need to release them below. */ + for (j = i; j < pvec_pages; j++) { + dout(50, " pvec leftover page %p\n", + pvec.pages[j]); + pvec.pages[j-i+first] = pvec.pages[j]; + } + pvec.nr -= i-first; + } + + /* submit the write */ + offset = pages[0]->index << PAGE_CACHE_SHIFT; + len = min(i_size_read(inode) - offset, + (u64)locked_pages << PAGE_CACHE_SHIFT); + dout(10, "writepages got %d pages at %llu~%llu\n", + locked_pages, offset, len); + rc = ceph_osdc_writepages_start(&client->osdc, req, + len, locked_pages); + req = NULL; + /* + * FIXME: if writepages_start fails (ENOMEM?) we should + * really redirty all those pages and release req.. + */ + + /* continue? */ + index = next; + wbc->nr_to_write -= locked_pages; + if (wbc->nr_to_write <= 0) + done = 1; + + release_pvec_pages: + dout(50, "pagevec_release on %d pages (%p)\n", (int)pvec.nr, + pvec.nr ? pvec.pages[0] : NULL); + pagevec_release(&pvec); + + if (locked_pages && !done) + goto retry; + } + + if (should_loop && !done) { + /* more to do; loop back to beginning of file */ + dout(40, "writepages looping back to beginning of file\n"); + should_loop = 0; + index = 0; + goto retry; + } + + if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) + mapping->writeback_index = index; + +out: + if (req) + ceph_osdc_put_request(req); + if (rc > 0) + rc = 0; /* vfs expects us to return 0 */ + ceph_put_snap_context(snapc); + dout(10, "writepages done, rc = %d\n", rc); + return rc; +} + + + +/* + * See if a given @snapc is either writeable, or already written. + */ +static int context_is_writeable_or_written(struct inode *inode, + struct ceph_snap_context *snapc) +{ + struct ceph_snap_context *oldest = get_oldest_context(inode); + return !oldest || snapc->seq <= oldest->seq; +} + +/* + * We are only allowed to write into/dirty the page if the page is + * clean, or already dirty within the same snap context. + */ +static int ceph_write_begin(struct file *file, struct address_space *mapping, + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc; + struct page *page; + pgoff_t index = pos >> PAGE_CACHE_SHIFT; + loff_t page_off = pos & PAGE_MASK; + int pos_in_page = pos & ~PAGE_MASK; + int end_in_page = pos_in_page + len; + loff_t i_size; + struct ceph_snap_context *snapc; + int r; + + /* get a page*/ +retry: + page = __grab_cache_page(mapping, index); + if (!page) + return -ENOMEM; + *pagep = page; + + dout(10, "write_begin file %p inode %p page %p %d~%d\n", file, + inode, page, (int)pos, (int)len); + +retry_locked: + /* writepages currently holds page lock, but if we change that later, */ + wait_on_page_writeback(page); + + /* check snap context */ + BUG_ON(!ci->i_snap_realm); + down_read(&mdsc->snap_rwsem); + BUG_ON(!ci->i_snap_realm->cached_context); + if (page->private && + (void *)page->private != ci->i_snap_realm->cached_context) { + /* this page is already dirty in another (older) snap + * context! is it writeable now? */ + snapc = get_oldest_context(inode); + up_read(&mdsc->snap_rwsem); + + if (snapc != (void *)page->private) { + dout(10, " page %p snapc %p not current or oldest\n", + page, (void *)page->private); + /* queue for writeback, and wait for snapc + * to be writeable or written */ + snapc = ceph_get_snap_context((void *)page->private); + unlock_page(page); + if (ceph_queue_writeback(inode)) + igrab(inode); + wait_event_interruptible(ci->i_cap_wq, + context_is_writeable_or_written(inode, snapc)); + ceph_put_snap_context(snapc); + goto retry; + } + + /* yay, writeable, do it now (without dropping page lock) */ + dout(10, " page %p snapc %p not current, but oldest\n", + page, snapc); + if (!clear_page_dirty_for_io(page)) + goto retry_locked; + r = writepage_nounlock(page, NULL); + if (r < 0) + goto fail_nosnap; + goto retry_locked; + } + + if (PageUptodate(page)) + return 0; + + /* full page? */ + if (pos_in_page == 0 && len == PAGE_SIZE) + return 0; + + /* past end of file? */ + i_size = inode->i_size; /* caller holds i_mutex */ + if (page_off >= i_size || + (pos_in_page == 0 && (pos+len) >= i_size)) { + simple_prepare_write(file, page, pos_in_page, end_in_page); + return 0; + } + + /* we need to read it. */ + up_read(&mdsc->snap_rwsem); + r = readpage_nounlock(file, page); + if (r < 0) + goto fail; + goto retry_locked; + +fail: + up_read(&mdsc->snap_rwsem); +fail_nosnap: + unlock_page(page); + return r; +} + +/* + * we don't do anything in here that simple_write_end doesn't do + * except adjust dirty page accounting and drop read lock on + * mdsc->snap_rwsem. + */ +static int ceph_write_end(struct file *file, struct address_space *mapping, + loff_t pos, unsigned len, unsigned copied, + struct page *page, void *fsdata) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc; + unsigned from = pos & (PAGE_CACHE_SIZE - 1); + + dout(10, "write_end file %p inode %p page %p %d~%d (%d)\n", file, + inode, page, (int)pos, (int)copied, (int)len); + + /* zero the stale part of the page if we did a short copy */ + if (copied < len) { + void *kaddr = kmap_atomic(page, KM_USER0); + memset(kaddr + from + copied, 0, len - copied); + flush_dcache_page(page); + kunmap_atomic(kaddr, KM_USER0); + } + + /* did file size increase? */ + /* (no need for i_size_read(); we caller holds i_mutex */ + if (pos+copied > inode->i_size) + ceph_inode_set_size(inode, pos+copied); + + if (!PageUptodate(page)) + SetPageUptodate(page); + + set_page_dirty(page); + + unlock_page(page); + up_read(&mdsc->snap_rwsem); + page_cache_release(page); + + return copied; +} + + +const struct address_space_operations ceph_aops = { + .readpage = ceph_readpage, + .readpages = ceph_readpages, + .writepage = ceph_writepage, + .writepages = ceph_writepages_start, + .write_begin = ceph_write_begin, + .write_end = ceph_write_end, + .set_page_dirty = ceph_set_page_dirty_vfs, + .invalidatepage = ceph_invalidatepage, + .releasepage = ceph_releasepage, +}; + + +/* + * vm ops + */ + +/* + * Reuse write_{begin,end} here for simplicity. + */ +static int ceph_page_mkwrite(struct vm_area_struct *vma, struct page *page) +{ + struct inode *inode = vma->vm_file->f_dentry->d_inode; + loff_t off = page->index << PAGE_CACHE_SHIFT; + loff_t size, len; + struct page *locked_page = NULL; + void *fsdata = NULL; + int ret; + + size = i_size_read(inode); + if (off + PAGE_CACHE_SIZE <= size) + len = PAGE_CACHE_SIZE; + else + len = size & ~PAGE_CACHE_MASK; + + dout(10, "page_mkwrite %p %llu~%llu (page %p offset %lu)\n", inode, + off, len, page, page->index); + ret = ceph_write_begin(vma->vm_file, inode->i_mapping, off, len, 0, + &locked_page, &fsdata); + if (!ret) + ceph_write_end(vma->vm_file, inode->i_mapping, off, len, len, + locked_page, fsdata); + dout(10, "page_mkwrite %p %llu~%llu = %d\n", inode, off, len, ret); + return ret; +} + +static struct vm_operations_struct ceph_vmops = { + .fault = filemap_fault, + .page_mkwrite = ceph_page_mkwrite, +}; + +int ceph_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct address_space *mapping = file->f_mapping; + + if (!mapping->a_ops->readpage) + return -ENOEXEC; + file_accessed(file); + vma->vm_ops = &ceph_vmops; + vma->vm_flags |= VM_CAN_NONLINEAR; + return 0; +} -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 09/19] ceph: MDS client 2008-11-14 0:56 ` [PATCH 08/19] ceph: address space operations Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 10/19] ceph: OSD client Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil The MDS client is responsible for submitting requests to the MDS cluster and parsing the response. We decide which MDS to submit each request to based on cached information about the current partition of the directory hierarchy across the cluster. A stateful session is opened with each MDS before we submit requests to it. If a MDS fails and/or recovers, we resubmit (potentially) affected requests as needed. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/mds_client.c | 2261 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/mds_client.h | 255 ++++++ fs/ceph/mdsmap.c | 123 +++ fs/ceph/mdsmap.h | 41 + 4 files changed, 2680 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/mds_client.c create mode 100644 fs/ceph/mds_client.h create mode 100644 fs/ceph/mdsmap.c create mode 100644 fs/ceph/mdsmap.h diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c new file mode 100644 index 0000000..f27156b --- /dev/null +++ b/fs/ceph/mds_client.c @@ -0,0 +1,2261 @@ + +#include <linux/wait.h> +#include <linux/sched.h> +#include "mds_client.h" +#include "mon_client.h" + +#include "ceph_debug.h" + +int ceph_debug_mdsc = -1; +#define DOUT_VAR ceph_debug_mdsc +#define DOUT_MASK DOUT_MASK_MDSC +#define DOUT_PREFIX "mds: " +#include "super.h" +#include "messenger.h" +#include "decode.h" + + +/* + * address and send message to a given mds + */ +void ceph_send_msg_mds(struct ceph_mds_client *mdsc, struct ceph_msg *msg, + int mds) +{ + msg->hdr.dst.addr = *ceph_mdsmap_get_addr(mdsc->mdsmap, mds); + msg->hdr.dst.name.type = cpu_to_le32(CEPH_ENTITY_TYPE_MDS); + msg->hdr.dst.name.num = cpu_to_le32(mds); + ceph_msg_send(mdsc->client->msgr, msg, BASE_DELAY_INTERVAL); +} + + +/* + * mds reply parsing + */ + +/* + * parse individual inode info + */ +static int parse_reply_info_in(void **p, void *end, + struct ceph_mds_reply_info_in *info) +{ + int err = -EINVAL; + + info->in = *p; + *p += sizeof(struct ceph_mds_reply_inode) + + sizeof(*info->in->fragtree.splits) * + le32_to_cpu(info->in->fragtree.nsplits); + + ceph_decode_32_safe(p, end, info->symlink_len, bad); + ceph_decode_need(p, end, info->symlink_len, bad); + info->symlink = *p; + *p += info->symlink_len; + + ceph_decode_32_safe(p, end, info->xattr_len, bad); + ceph_decode_need(p, end, info->xattr_len, bad); + info->xattr_data = *p; + *p += info->xattr_len; + return 0; +bad: + return err; +} + +/* + * parse a full metadata trace from the mds: inode, dirinfo, dentry, inode... + * sequence. + */ +static int parse_reply_info_trace(void **p, void *end, + struct ceph_mds_reply_info_parsed *info) +{ + u16 numi, numd, snapdirpos; + int err; + + ceph_decode_need(p, end, 3*sizeof(u16), bad); + ceph_decode_16(p, numi); + ceph_decode_16(p, numd); + ceph_decode_16(p, snapdirpos); + info->trace_numi = numi; + info->trace_numd = numd; + info->trace_snapdirpos = snapdirpos; + if (numi == 0) { + info->trace_in = NULL; + goto done; /* hrm, this shouldn't actually happen, but.. */ + } + + /* alloc one big block of memory for all of these arrays */ + info->trace_in = kmalloc(numi * (sizeof(*info->trace_in) + + 2*sizeof(*info->trace_ilease) + + sizeof(*info->trace_dir) + + sizeof(*info->trace_dname) + + sizeof(*info->trace_dname_len)), + GFP_NOFS); + if (info->trace_in == NULL) { + err = -ENOMEM; + goto out_bad; + } + info->trace_ilease = (void *)(info->trace_in + numi); + info->trace_dir = (void *)(info->trace_ilease + numi); + info->trace_dname = (void *)(info->trace_dir + numd); + info->trace_dname_len = (void *)(info->trace_dname + numd); + info->trace_dlease = (void *)(info->trace_dname_len + numd); + + /* + * the trace starts at the deepest point, and works up toward + * the root inode. + */ + if (numi == numd) + goto dentry; +inode: + if (!numi) + goto done; + numi--; + err = parse_reply_info_in(p, end, &info->trace_in[numi]); + if (err < 0) + goto out_bad; + info->trace_ilease[numi] = *p; + *p += sizeof(struct ceph_mds_reply_lease); + +dentry: + if (!numd) + goto done; + numd--; + ceph_decode_32_safe(p, end, info->trace_dname_len[numd], bad); + ceph_decode_need(p, end, info->trace_dname_len[numd], bad); + info->trace_dname[numd] = *p; + *p += info->trace_dname_len[numd]; + info->trace_dlease[numd] = *p; + *p += sizeof(struct ceph_mds_reply_lease); + + /* dir frag info */ + if (unlikely(*p + sizeof(struct ceph_mds_reply_dirfrag) > end)) + goto bad; + info->trace_dir[numd] = *p; + *p += sizeof(struct ceph_mds_reply_dirfrag) + + sizeof(u32)*le32_to_cpu(info->trace_dir[numd]->ndist); + if (unlikely(*p > end)) + goto bad; + goto inode; + +done: + if (unlikely(*p != end)) + goto bad; + return 0; + +bad: + err = -EINVAL; +out_bad: + derr(1, "problem parsing trace %d\n", err); + return err; +} + +/* + * parse readdir results + */ +static int parse_reply_info_dir(void **p, void *end, + struct ceph_mds_reply_info_parsed *info) +{ + u32 num, i = 0; + int err; + + info->dir_dir = *p; + if (*p + sizeof(*info->dir_dir) > end) + goto bad; + *p += sizeof(*info->dir_dir) + + sizeof(u32)*le32_to_cpu(info->dir_dir->ndist); + if (*p > end) + goto bad; + + ceph_decode_32_safe(p, end, num, bad); + if (num == 0) + goto done; + + /* alloc large array */ + info->dir_nr = num; + info->dir_in = kmalloc(num * (sizeof(*info->dir_in) + + sizeof(*info->dir_ilease) + + sizeof(*info->dir_dname) + + sizeof(*info->dir_dname_len) + + sizeof(*info->dir_dlease)), + GFP_NOFS); + if (info->dir_in == NULL) { + err = -ENOMEM; + goto out_bad; + } + info->dir_ilease = (void *)(info->dir_in + num); + info->dir_dname = (void *)(info->dir_ilease + num); + info->dir_dname_len = (void *)(info->dir_dname + num); + info->dir_dlease = (void *)(info->dir_dname_len + num); + + while (num) { + /* dentry */ + ceph_decode_32_safe(p, end, info->dir_dname_len[i], bad); + ceph_decode_need(p, end, info->dir_dname_len[i], bad); + info->dir_dname[i] = *p; + *p += info->dir_dname_len[i]; + dout(20, "parsed dir dname '%.*s'\n", info->dir_dname_len[i], + info->dir_dname[i]); + info->dir_dlease[i] = *p; + *p += sizeof(struct ceph_mds_reply_lease); + + /* inode */ + err = parse_reply_info_in(p, end, &info->dir_in[i]); + if (err < 0) + goto out_bad; + info->dir_ilease[i] = *p; + *p += sizeof(struct ceph_mds_reply_lease); + i++; + num--; + } + +done: + return 0; + +bad: + err = -EINVAL; +out_bad: + derr(1, "problem parsing dir contents %d\n", err); + return err; +} + +/* + * parse entire mds reply + */ +static int parse_reply_info(struct ceph_msg *msg, + struct ceph_mds_reply_info_parsed *info) +{ + void *p, *end; + u32 len; + int err; + + info->head = msg->front.iov_base; + p = msg->front.iov_base + sizeof(struct ceph_mds_reply_head); + end = p + msg->front.iov_len - sizeof(struct ceph_mds_reply_head); + + /* trace */ + ceph_decode_32_safe(&p, end, len, bad); + if (len > 0) { + err = parse_reply_info_trace(&p, p+len, info); + if (err < 0) + goto out_bad; + } + + /* dir content */ + ceph_decode_32_safe(&p, end, len, bad); + if (len > 0) { + err = parse_reply_info_dir(&p, p+len, info); + if (err < 0) + goto out_bad; + } + + /* snap blob */ + ceph_decode_32_safe(&p, end, len, bad); + info->snapblob_len = len; + info->snapblob = p; + p += len; + + if (p != end) + goto bad; + return 0; + +bad: + err = -EINVAL; +out_bad: + derr(1, "parse_reply err %d\n", err); + return err; +} + +static void destroy_reply_info(struct ceph_mds_reply_info_parsed *info) +{ + kfree(info->trace_in); + kfree(info->dir_in); +} + + +/* + * sessions + */ +static const char *session_state_name(int s) +{ + switch (s) { + case CEPH_MDS_SESSION_NEW: return "new"; + case CEPH_MDS_SESSION_OPENING: return "opening"; + case CEPH_MDS_SESSION_OPEN: return "open"; + case CEPH_MDS_SESSION_FLUSHING: return "flushing"; + case CEPH_MDS_SESSION_CLOSING: return "closing"; + case CEPH_MDS_SESSION_RECONNECTING: return "reconnecting"; + default: return "???"; + } +} + +/* + * called under mdsc->mutex + */ +struct ceph_mds_session *__ceph_get_mds_session(struct ceph_mds_client *mdsc, + int mds) +{ + struct ceph_mds_session *session; + + if (mds >= mdsc->max_sessions || mdsc->sessions[mds] == NULL) + return NULL; + session = mdsc->sessions[mds]; + dout(30, "get_mds_session %p %d -> %d\n", session, + atomic_read(&session->s_ref), atomic_read(&session->s_ref)+1); + atomic_inc(&session->s_ref); + return session; +} + +void ceph_put_mds_session(struct ceph_mds_session *s) +{ + dout(30, "put_mds_session %p %d -> %d\n", s, + atomic_read(&s->s_ref), atomic_read(&s->s_ref)-1); + if (atomic_dec_and_test(&s->s_ref)) + kfree(s); +} + +/* + * create+register a new session for given mds. + * called under mdsc->mutex. + */ +static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc, + int mds) +{ + struct ceph_mds_session *s; + + s = kmalloc(sizeof(*s), GFP_NOFS); + s->s_mds = mds; + s->s_state = CEPH_MDS_SESSION_NEW; + s->s_ttl = 0; + s->s_seq = 0; + mutex_init(&s->s_mutex); + spin_lock_init(&s->s_cap_lock); + s->s_cap_gen = 0; + s->s_cap_ttl = 0; + s->s_renew_requested = 0; + INIT_LIST_HEAD(&s->s_caps); + s->s_nr_caps = 0; + INIT_LIST_HEAD(&s->s_inode_leases); + INIT_LIST_HEAD(&s->s_dentry_leases); + atomic_set(&s->s_ref, 1); + init_completion(&s->s_completion); + + dout(10, "register_session mds%d\n", mds); + if (mds >= mdsc->max_sessions) { + int newmax = 1 << get_count_order(mds+1); + struct ceph_mds_session **sa; + + dout(50, "register_session realloc to %d\n", newmax); + sa = kzalloc(newmax * sizeof(void *), GFP_NOFS); + if (sa == NULL) + return ERR_PTR(-ENOMEM); + if (mdsc->sessions) { + memcpy(sa, mdsc->sessions, + mdsc->max_sessions * sizeof(void *)); + kfree(mdsc->sessions); + } + mdsc->sessions = sa; + mdsc->max_sessions = newmax; + } + mdsc->sessions[mds] = s; + atomic_inc(&s->s_ref); /* one ref to sessions[], one to caller */ + return s; +} + +/* + * called under mdsc->mutex + */ +static void unregister_session(struct ceph_mds_client *mdsc, int mds) +{ + dout(10, "unregister_session mds%d %p\n", mds, mdsc->sessions[mds]); + ceph_put_mds_session(mdsc->sessions[mds]); + mdsc->sessions[mds] = NULL; +} + + +/* + * requests + */ +static void get_request(struct ceph_mds_request *req) +{ + atomic_inc(&req->r_ref); +} + +/* drop session refs in request */ +static void put_request_sessions(struct ceph_mds_request *req) +{ + if (req->r_session) { + ceph_put_mds_session(req->r_session); + req->r_session = NULL; + } + if (req->r_fwd_session) { + ceph_put_mds_session(req->r_fwd_session); + req->r_fwd_session = NULL; + } +} + +void ceph_mdsc_put_request(struct ceph_mds_request *req) +{ + dout(10, "put_request %p %d -> %d\n", req, + atomic_read(&req->r_ref), atomic_read(&req->r_ref)-1); + if (atomic_dec_and_test(&req->r_ref)) { + if (req->r_request) + ceph_msg_put(req->r_request); + if (req->r_reply) { + ceph_msg_put(req->r_reply); + destroy_reply_info(&req->r_reply_info); + } + if (req->r_direct_dentry) + dput(req->r_direct_dentry); + if (req->r_last_inode) + iput(req->r_last_inode); + if (req->r_last_dentry) + dput(req->r_last_dentry); + if (req->r_old_dentry) + dput(req->r_old_dentry); + kfree(req->r_expected_cap); + put_request_sessions(req); + kfree(req); + } +} + +/* + * lookup session, bump ref if found. + * + * called under mdsc->mutex. + */ +static struct ceph_mds_request *__get_request(struct ceph_mds_client *mdsc, + u64 tid) +{ + struct ceph_mds_request *req; + req = radix_tree_lookup(&mdsc->request_tree, tid); + if (req) + get_request(req); + return req; +} + +/* + * allocate and initialize a new request. mostly zeroed. + */ +static struct ceph_mds_request *new_request(struct ceph_msg *msg) +{ + struct ceph_mds_request *req; + + req = kzalloc(sizeof(*req), GFP_NOFS); + req->r_request = msg; + req->r_started = jiffies; + req->r_resend_mds = -1; + atomic_set(&req->r_ref, 1); /* one for request_tree, one for caller */ + init_completion(&req->r_completion); + return req; +} + +/* + * Register an in-flight request, and assign a tid in msg request header. + * + * Called under mdsc->mutex. + */ +static void __register_request(struct ceph_mds_client *mdsc, + struct ceph_mds_request *req) +{ + struct ceph_mds_request_head *head = req->r_request->front.iov_base; + req->r_tid = ++mdsc->last_tid; + head->tid = cpu_to_le64(req->r_tid); + dout(30, "__register_request %p tid %lld\n", req, req->r_tid); + get_request(req); + radix_tree_insert(&mdsc->request_tree, req->r_tid, (void *)req); +} + +static void __unregister_request(struct ceph_mds_client *mdsc, + struct ceph_mds_request *req) +{ + dout(30, "__unregister_request %p tid %lld\n", req, req->r_tid); + radix_tree_delete(&mdsc->request_tree, req->r_tid); + ceph_mdsc_put_request(req); +} + +static bool __have_session(struct ceph_mds_client *mdsc, int mds) +{ + if (mds >= mdsc->max_sessions) + return false; + return mdsc->sessions[mds]; +} + + +/* + * Choose mds to send request to next. If there is a hint set in + * the request (e.g., due to a prior forward hint from the mds), use + * that. + * + * Called under mdsc->mutex. + */ +static int __choose_mds(struct ceph_mds_client *mdsc, + struct ceph_mds_request *req) +{ + int mds = -1; + u32 hash = req->r_direct_hash; + bool is_hash = req->r_direct_is_hash; + struct dentry *dentry = req->r_direct_dentry; + struct ceph_inode_info *ci; + int mode = req->r_direct_mode; + + /* + * is there a specific mds we should try? ignore hint if we have + * no session and the mds is not up (active or recovering). + */ + if (req->r_resend_mds >= 0 && + (__have_session(mdsc, req->r_resend_mds) || + ceph_mdsmap_get_state(mdsc->mdsmap, req->r_resend_mds) > 0)) { + dout(20, "choose_mds using resend_mds mds%d\n", + req->r_resend_mds); + return req->r_resend_mds; + } + + if (mode == USE_CAP_MDS) { + mds = ceph_get_cap_mds(dentry->d_inode); + if (mds >= 0) { + dout(20, "choose_mds %p %llx.%llx mds%d (cap)\n", + dentry->d_inode, ceph_vinop(dentry->d_inode), mds); + return mds; + } + derr(0, "choose_mds %p %llx.%llx has NO CAPS, using auth\n", + dentry->d_inode, ceph_vinop(dentry->d_inode)); + WARN_ON(1); + mode = USE_AUTH_MDS; + } + + if (mode == USE_RANDOM_MDS) + goto random; + + /* + * try to find an appropriate mds to contact based on the + * given dentry. walk up the tree until we find delegation info + * in the i_fragtree. + * + * if is_hash is true, direct request at the appropriate directory + * fragment (as with a readdir on a fragmented directory). + */ + while (dentry) { + if (is_hash && dentry->d_inode && + S_ISDIR(dentry->d_inode->i_mode)) { + struct ceph_inode_frag frag; + int found; + + ci = ceph_inode(dentry->d_inode); + ceph_choose_frag(ci, hash, &frag, &found); + if (found) { + if (mode == USE_ANY_MDS && frag.ndist > 0) { + u8 r; + + /* choose a random replica */ + get_random_bytes(&r, 1); + r %= frag.ndist; + mds = frag.dist[r]; + dout(20, "choose_mds %p %llx.%llx " + "frag %u mds%d (%d/%d)\n", + dentry->d_inode, + ceph_vinop(&ci->vfs_inode), + frag.frag, frag.mds, + (int)r, frag.ndist); + return mds; + } + /* since the more deeply nested item wasn't + * known to be replicated, then we want to + * look for the authoritative mds. */ + mode = USE_AUTH_MDS; + if (frag.mds >= 0) { + /* choose auth mds */ + mds = frag.mds; + dout(20, "choose_mds %p %llx.%llx " + "frag %u mds%d (auth)\n", + dentry->d_inode, + ceph_vinop(&ci->vfs_inode), + frag.frag, mds); + return mds; + } + } + } + if (IS_ROOT(dentry)) + break; + + /* move up the hierarchy, but direct request based on the hash + * for the child's dentry name */ + hash = dentry->d_name.hash; + is_hash = true; + dentry = dentry->d_parent; + } + + /* ok, just pick one at random */ +random: + mds = ceph_mdsmap_get_random_mds(mdsc->mdsmap); + dout(20, "choose_mds chose random mds%d\n", mds); + return mds; +} + + +/* + * session messages + */ +static struct ceph_msg *create_session_msg(u32 op, u64 seq) +{ + struct ceph_msg *msg; + struct ceph_mds_session_head *h; + + msg = ceph_msg_new(CEPH_MSG_CLIENT_SESSION, sizeof(*h), 0, 0, NULL); + if (IS_ERR(msg)) { + derr("ENOMEM creating session msg\n"); + return ERR_PTR(PTR_ERR(msg)); + } + h = msg->front.iov_base; + h->op = cpu_to_le32(op); + h->seq = cpu_to_le64(seq); + return msg; +} + +/* + * Register request with mon_client for a new mds map. Wait until + * we get one (or time out). + * + * called under mdsc->mutex (dropped while we wait) + */ +static int wait_for_new_map(struct ceph_mds_client *mdsc, + unsigned long timeout) +{ + u32 have; + int err = 0; + + dout(30, "wait_for_new_map enter\n"); + have = mdsc->mdsmap->m_epoch; + mutex_unlock(&mdsc->mutex); + ceph_monc_request_mdsmap(&mdsc->client->monc, have+1); + if (timeout) { + err = wait_for_completion_timeout(&mdsc->map_waiters, timeout); + if (err > 0) + err = 0; + else if (err == 0) + err = -EIO; + } else { + wait_for_completion(&mdsc->map_waiters); + } + mutex_lock(&mdsc->mutex); + dout(30, "wait_for_new_map err %d\n", err); + return err; +} + +/* + * open a new session with the given mds, and wait for mds ack. the + * timeout is optional. + * + * called under mdsc->mutex + */ +static int open_session(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session, unsigned long timeout) +{ + struct ceph_msg *msg; + int mstate; + int mds = session->s_mds; + int err = 0; + + /* wait for mds to go active? */ + mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds); + dout(10, "open_session to mds%d, state %d\n", mds, mstate); + if (mstate < CEPH_MDS_STATE_ACTIVE) { + err = wait_for_new_map(mdsc, timeout); + if (err) + return err; + mstate = ceph_mdsmap_get_state(mdsc->mdsmap, mds); + if (mstate < CEPH_MDS_STATE_ACTIVE) { + dout(30, "open_session mds%d now %d still not active\n", + mds, mstate); + return -EAGAIN; /* hrm, try again? */ + } + } + + session->s_state = CEPH_MDS_SESSION_OPENING; + session->s_renew_requested = jiffies; + mutex_unlock(&mdsc->mutex); + + /* send connect message */ + msg = create_session_msg(CEPH_SESSION_REQUEST_OPEN, session->s_seq); + if (IS_ERR(msg)) + return PTR_ERR(msg); + ceph_send_msg_mds(mdsc, msg, mds); + + /* wait for session to open (or fail, or close) */ + dout(30, "open_session waiting on session %p\n", session); + if (timeout) { + err = wait_for_completion_timeout(&session->s_completion, + timeout); + if (err > 0) + err = 0; + else if (err == 0) + err = -EIO; + } else { + wait_for_completion(&session->s_completion); + } + dout(30, "open_session done waiting on session %p, state %d\n", + session, session->s_state); + + mutex_lock(&mdsc->mutex); + return err; +} + +/* + * caller must hold session s_mutex + */ +static void remove_session_caps(struct ceph_mds_session *session) +{ + struct ceph_cap *cap; + struct ceph_inode_info *ci; + + dout(10, "remove_session_caps on %p\n", session); + while (session->s_nr_caps > 0) { + cap = list_entry(session->s_caps.next, struct ceph_cap, + session_caps); + ci = cap->ci; + dout(10, "removing cap %p, ci is %p, inode is %p\n", + cap, ci, &ci->vfs_inode); + ceph_remove_cap(cap); + } + BUG_ON(session->s_nr_caps > 0); +} + +/* + * caller must hold session s_mutex + */ +static void revoke_dentry_lease(struct dentry *dentry) +{ + struct ceph_dentry_info *di; + + spin_lock(&dentry->d_lock); + di = ceph_dentry(dentry); + if (di) { + list_del(&di->lease_item); + kfree(di); + dentry->d_fsdata = NULL; + } + spin_unlock(&dentry->d_lock); + if (di) + dput(dentry); +} + +/* + * caller must hold session s_mutex + */ +static void revoke_inode_lease(struct ceph_inode_info *ci, int mask) +{ + struct inode *inode = &ci->vfs_inode; + int drop = 0; + + spin_lock(&inode->i_lock); + dout(10, "revoke_inode_lease on inode %p, mask %d -> %d\n", + inode, ci->i_lease_mask, ci->i_lease_mask & ~mask); + if (ci->i_lease_mask & mask) { + ci->i_lease_mask &= ~mask; + if (ci->i_lease_mask == 0) { + list_del_init(&ci->i_lease_item); + ci->i_lease_session = NULL; + drop = 1; + } + } + spin_unlock(&inode->i_lock); + if (drop) + iput(inode); +} + +/* + * remove old/expired leases for this session. unpin parent + * inode/dentries, so that [di]cache can prune them. + * + * caller must hold session s_mutex + */ +static void trim_session_leases(struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci; + struct ceph_dentry_info *di; + struct dentry *dentry; + struct inode *inode; + + dout(20, "trim_session_leases on session %p\n", session); + + /* inodes */ + while (!list_empty(&session->s_inode_leases)) { + ci = list_first_entry(&session->s_inode_leases, + struct ceph_inode_info, i_lease_item); + inode = &ci->vfs_inode; + spin_lock(&inode->i_lock); + if (time_before(jiffies, ci->i_lease_ttl)) { + spin_unlock(&inode->i_lock); + break; + } + dout(20, "trim_session_leases inode %p mask %d\n", + inode, ci->i_lease_mask); + ci->i_lease_session = NULL; + ci->i_lease_mask = 0; + list_del_init(&ci->i_lease_item); + spin_unlock(&inode->i_lock); + iput(inode); + } + + /* dentries */ + while (!list_empty(&session->s_dentry_leases)) { + di = list_first_entry(&session->s_dentry_leases, + struct ceph_dentry_info, lease_item); + dentry = di->dentry; + spin_lock(&dentry->d_lock); + if (time_before(jiffies, dentry->d_time)) { + spin_unlock(&dentry->d_lock); + break; + } + dout(20, "trim_session_leases dentry %p\n", dentry); + list_del(&di->lease_item); + kfree(di); + dentry->d_fsdata = NULL; + spin_unlock(&dentry->d_lock); + dput(dentry); + } +} + +/* + * caller must hold session s_mutex + */ +static void remove_session_leases(struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci; + struct ceph_dentry_info *di; + + dout(10, "remove_session_leases on %p\n", session); + + /* inodes */ + while (!list_empty(&session->s_inode_leases)) { + ci = list_entry(session->s_inode_leases.next, + struct ceph_inode_info, i_lease_item); + dout(10, "removing lease from inode %p\n", &ci->vfs_inode); + revoke_inode_lease(ci, ci->i_lease_mask); + } + + /* dentries */ + while (!list_empty(&session->s_dentry_leases)) { + di = list_entry(session->s_dentry_leases.next, + struct ceph_dentry_info, lease_item); + dout(10, "removing lease from dentry %p\n", di->dentry); + revoke_dentry_lease(di->dentry); + } +} + +/* + * wake up any threads waiting on this session's caps + * + * caller must hold s_mutex. + */ +static void wake_up_session_caps(struct ceph_mds_session *session) +{ + struct list_head *p; + struct ceph_cap *cap; + + dout(10, "wake_up_session_caps %p mds%d\n", session, session->s_mds); + list_for_each(p, &session->s_caps) { + cap = list_entry(p, struct ceph_cap, session_caps); + wake_up(&cap->ci->i_cap_wq); + } +} + +/* + * Wake up threads with requests pending for @mds, so that they can + * resubmit their requests to a possibly different mds. If @all is set, + * wake up if their requests has been forwarded to @mds, too. + */ +static void kick_requests(struct ceph_mds_client *mdsc, int mds, int all) +{ + struct ceph_mds_request *reqs[10]; + u64 nexttid = 0; + int i, got; + + dout(20, "kick_requests mds%d\n", mds); + while (nexttid < mdsc->last_tid) { + got = radix_tree_gang_lookup(&mdsc->request_tree, + (void **)&reqs, nexttid, 10); + if (got == 0) + break; + nexttid = reqs[got-1]->r_tid + 1; + for (i = 0; i < got; i++) { + if ((reqs[i]->r_session && + reqs[i]->r_session->s_mds == mds) || + (all && reqs[i]->r_fwd_session && + reqs[i]->r_fwd_session->s_mds == mds)) { + dout(10, " kicking tid %llu\n", reqs[i]->r_tid); + put_request_sessions(reqs[i]); + complete(&reqs[i]->r_completion); + } + } + } +} + +/* + * Send periodic message to MDS renewing all currently held caps. The + * ack will reset the expiration for all caps from this session. + * + * caller holds s_mutex + */ +static int send_renew_caps(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session) +{ + struct ceph_msg *msg; + + if (time_after_eq(jiffies, session->s_cap_ttl) && + time_after_eq(session->s_cap_ttl, session->s_renew_requested)) + dout(1, "mds%d session caps stale\n", session->s_mds); + + /* do not try to renew caps until a recovering mds has reconnected + * with its clients. */ + if (ceph_mdsmap_get_state(mdsc->mdsmap, session->s_mds) < + CEPH_MDS_STATE_RECONNECT) { + dout(10, "send_renew_caps ignoring mds%d\n", session->s_mds); + return 0; + } + + dout(10, "send_renew_caps to mds%d\n", session->s_mds); + session->s_renew_requested = jiffies; + msg = create_session_msg(CEPH_SESSION_REQUEST_RENEWCAPS, 0); + if (IS_ERR(msg)) + return PTR_ERR(msg); + ceph_send_msg_mds(mdsc, msg, session->s_mds); + return 0; +} + +/* + * Note new cap ttl, and any transition from stale -> not stale (fresh?). + */ +static void renewed_caps(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session, int is_renew) +{ + int was_stale; + int wake = 0; + + spin_lock(&session->s_cap_lock); + was_stale = is_renew && (session->s_cap_ttl == 0 || + time_after_eq(jiffies, session->s_cap_ttl)); + + session->s_cap_ttl = session->s_renew_requested + + mdsc->mdsmap->m_session_timeout*HZ; + + if (was_stale) { + if (time_before(jiffies, session->s_cap_ttl)) { + dout(1, "mds%d caps renewed\n", session->s_mds); + wake = 1; + } else { + dout(1, "mds%d caps still stale\n", session->s_mds); + } + } + dout(10, "renewed_caps mds%d ttl now %lu, was %s, now %s\n", + session->s_mds, session->s_cap_ttl, was_stale ? "stale" : "fresh", + time_before(jiffies, session->s_cap_ttl) ? "stale" : "fresh"); + spin_unlock(&session->s_cap_lock); + + if (wake) + wake_up_session_caps(session); +} + + + +static int request_close_session(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session) +{ + struct ceph_msg *msg; + int err = 0; + + msg = create_session_msg(CEPH_SESSION_REQUEST_CLOSE, + session->s_seq); + if (IS_ERR(msg)) + err = PTR_ERR(msg); + else + ceph_send_msg_mds(mdsc, msg, session->s_mds); + return err; +} + +/* + * check all caps on a session, without allowing release to + * be delayed. + */ +static void check_all_caps(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session) +{ + struct list_head *p, *n; + + list_for_each_safe(p, n, &session->s_caps) { + struct ceph_cap *cap = + list_entry(p, struct ceph_cap, session_caps); + struct inode *inode = &cap->ci->vfs_inode; + + igrab(inode); + mutex_unlock(&session->s_mutex); + ceph_check_caps(ceph_inode(inode), 1); + mutex_lock(&session->s_mutex); + iput(inode); + } +} + +/* + * Called with s_mutex held. + */ +static int __close_session(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session) +{ + int mds = session->s_mds; + int err = 0; + + dout(10, "close_session mds%d state=%s\n", mds, + session_state_name(session->s_state)); + if (session->s_state >= CEPH_MDS_SESSION_CLOSING) + return 0; + + check_all_caps(mdsc, session); + + if (list_empty(&session->s_caps)) { + session->s_state = CEPH_MDS_SESSION_CLOSING; + err = request_close_session(mdsc, session); + } else { + session->s_state = CEPH_MDS_SESSION_FLUSHING; + } + return err; +} + +/* + * Called when the last cap for a session has been flushed or + * exported. + */ +void ceph_mdsc_flushed_all_caps(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session) +{ + dout(10, "flushed_all_caps for mds%d state %s\n", session->s_mds, + session_state_name(session->s_state)); + if (session->s_state == CEPH_MDS_SESSION_FLUSHING) { + session->s_state = CEPH_MDS_SESSION_CLOSING; + request_close_session(mdsc, session); + } +} + + +/* + * handle a mds session control message + */ +void ceph_mdsc_handle_session(struct ceph_mds_client *mdsc, + struct ceph_msg *msg) +{ + u32 op; + u64 seq; + struct ceph_mds_session *session = NULL; + int mds; + struct ceph_mds_session_head *h = msg->front.iov_base; + + if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS) + return; + mds = le32_to_cpu(msg->hdr.src.name.num); + + /* decode */ + if (msg->front.iov_len != sizeof(*h)) + goto bad; + op = le32_to_cpu(h->op); + seq = le64_to_cpu(h->seq); + + mutex_lock(&mdsc->mutex); + session = __ceph_get_mds_session(mdsc, mds); + if (session && mdsc->mdsmap) + /* FIXME: this ttl calculation is generous */ + session->s_ttl = jiffies + HZ*mdsc->mdsmap->m_session_autoclose; + mutex_unlock(&mdsc->mutex); + + if (!session) { + dout(10, "handle_session no session for mds%d\n", mds); + return; + } + + mutex_lock(&session->s_mutex); + + dout(2, "handle_session mds%d %s %p state %s seq %llu\n", + mds, ceph_session_op_name(op), session, + session_state_name(session->s_state), seq); + switch (op) { + case CEPH_SESSION_OPEN: + session->s_state = CEPH_MDS_SESSION_OPEN; + renewed_caps(mdsc, session, 0); + complete(&session->s_completion); + if (mdsc->stopping) + __close_session(mdsc, session); + break; + + case CEPH_SESSION_RENEWCAPS: + renewed_caps(mdsc, session, 1); + break; + + case CEPH_SESSION_CLOSE: + unregister_session(mdsc, mds); + remove_session_caps(session); + remove_session_leases(session); + complete(&session->s_completion); /* for good measure */ + complete(&mdsc->session_close_waiters); + kick_requests(mdsc, mds, 0); /* cur only */ + break; + + case CEPH_SESSION_STALE: + dout(1, "mds%d caps went stale, renewing\n", session->s_mds); + spin_lock(&session->s_cap_lock); + session->s_cap_gen++; + session->s_cap_ttl = 0; + spin_unlock(&session->s_cap_lock); + send_renew_caps(mdsc, session); + break; + + default: + derr(0, "bad session op %d from mds%d\n", op, mds); + WARN_ON(1); + } + + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + return; + +bad: + derr(1, "corrupt mds%d session message, len %d, expected %d\n", mds, + (int)msg->front.iov_len, (int)sizeof(*h)); + return; +} + + +/* + * create an mds request and message. + * + * slight hacky weirdness: if op is a FINDINODE, ino1 is the _length_ + * of path1, and path1 isn't null terminated (it's an nfs filehandle + * fragment). path2 is not used in that case. + */ +struct ceph_mds_request * +ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op, + u64 ino1, const char *path1, + u64 ino2, const char *path2, + struct dentry *ref, int mode) +{ + struct ceph_msg *msg; + struct ceph_mds_request *req; + struct ceph_mds_request_head *head; + void *p, *end; + int pathlen; + + if (op == CEPH_MDS_OP_FINDINODE) { + pathlen = sizeof(u32) + ino1*sizeof(struct ceph_inopath_item); + } else { + pathlen = 2*(sizeof(ino1) + sizeof(u32)); + if (path1) + pathlen += strlen(path1); + if (path2) + pathlen += strlen(path2); + } + + msg = ceph_msg_new(CEPH_MSG_CLIENT_REQUEST, + sizeof(struct ceph_mds_request_head) + pathlen, + 0, 0, NULL); + if (IS_ERR(msg)) + return ERR_PTR(PTR_ERR(msg)); + req = new_request(msg); + if (IS_ERR(req)) { + ceph_msg_put(msg); + return req; + } + head = msg->front.iov_base; + p = msg->front.iov_base + sizeof(*head); + end = msg->front.iov_base + msg->front.iov_len; + + /* dentry used to direct mds request? */ + req->r_direct_dentry = dget(ref); + req->r_direct_mode = mode; + + /* tid, oldest_client_tid, retry_attempt set later. */ + head->mdsmap_epoch = cpu_to_le32(mdsc->mdsmap->m_epoch); + head->num_fwd = 0; + head->mds_wants_replica_in_dirino = 0; + head->op = cpu_to_le32(op); + head->caller_uid = cpu_to_le32(current->fsuid); + head->caller_gid = cpu_to_le32(current->fsgid); + + /* encode paths */ + if (op == CEPH_MDS_OP_FINDINODE) { + ceph_encode_32(&p, ino1); + memcpy(p, path1, ino1 * sizeof(struct ceph_inopath_item)); + p += ino1 * sizeof(struct ceph_inopath_item); + } else { + ceph_encode_filepath(&p, end, ino1, path1); + ceph_encode_filepath(&p, end, ino2, path2); + if (path1) + dout(10, "create_request path1 %llx/%s\n", + ino1, path1); + if (path2) + dout(10, "create_request path2 %llx/%s\n", + ino2, path2); + } + dout_flag(10, DOUT_MASK_PROTOCOL, "create_request op %d=%s -> %p\n", op, + ceph_mds_op_name(op), req); + + BUG_ON(p != end); + return req; +} + +/* + * return oldest (lowest) tid in request tree, 0 if none. + * + * called under mdsc->mutex. + */ +static u64 __get_oldest_tid(struct ceph_mds_client *mdsc) +{ + struct ceph_mds_request *first; + if (radix_tree_gang_lookup(&mdsc->request_tree, + (void **)&first, 0, 1) <= 0) + return 0; + return first->r_tid; +} + +/* + * Synchrously perform an mds request. Take care of all of the + * session setup, forwarding, retry details. + */ +int ceph_mdsc_do_request(struct ceph_mds_client *mdsc, + struct ceph_mds_request *req) +{ + struct ceph_mds_session *session = NULL; + struct ceph_mds_request_head *rhead = req->r_request->front.iov_base; + int err; + int mds = -1; + + dout(30, "do_request on %p\n", req); + + mutex_lock(&mdsc->mutex); + __register_request(mdsc, req); +retry: + if (req->r_timeout && + time_after_eq(jiffies, req->r_started + req->r_timeout)) { + if (session && session->s_state == CEPH_MDS_SESSION_OPENING) + unregister_session(mdsc, mds); + dout(10, "do_request timed out\n"); + err = -EIO; + goto finish; + } + + mds = __choose_mds(mdsc, req); + if (mds < 0 || + ceph_mdsmap_get_state(mdsc->mdsmap, mds) < CEPH_MDS_STATE_ACTIVE) { + dout(30, "do_request no mds or not active, waiting for map\n"); + err = wait_for_new_map(mdsc, req->r_timeout); + if (err) + goto finish; + goto retry; + } + + /* get session */ + session = __ceph_get_mds_session(mdsc, mds); + if (!session) + session = register_session(mdsc, mds); + dout(30, "do_request mds%d session %p state %s\n", mds, session, + session_state_name(session->s_state)); + + /* open? */ + err = 0; + if (session->s_state == CEPH_MDS_SESSION_NEW || + session->s_state == CEPH_MDS_SESSION_CLOSING) + err = open_session(mdsc, session, req->r_timeout); + if (session->s_state != CEPH_MDS_SESSION_OPEN || + err == -EAGAIN) { + dout(30, "do_request session %p not open, state=%s\n", + session, session_state_name(session->s_state)); + ceph_put_mds_session(session); + goto retry; + } + + BUG_ON(req->r_session); + req->r_session = session; /* request now owns the session ref */ + req->r_resend_mds = -1; /* forget any previous mds hint */ + req->r_attempts++; + + if (req->r_request_started == 0) /* note request start time */ + req->r_request_started = jiffies; + + rhead->retry_attempt = cpu_to_le32(req->r_attempts - 1); + rhead->oldest_client_tid = cpu_to_le64(__get_oldest_tid(mdsc)); + + /* send and wait */ + mutex_unlock(&mdsc->mutex); + dout(10, "do_request %p %lld r_expected_cap=%p\n", req, req->r_tid, + req->r_expected_cap); + + /* if there are other references on this message, e.g., if we are + * told to forward it and the previous copy is still in flight, dup + * it. */ + req->r_request = ceph_msg_maybe_dup(req->r_request); + + ceph_msg_get(req->r_request); + ceph_send_msg_mds(mdsc, req->r_request, mds); + + if (req->r_timeout) { + err = wait_for_completion_timeout(&req->r_completion, + req->r_timeout); + if (err > 0) + err = 0; + else if (err == 0) + err = -EIO; /* timed out */ + } else { + err = 0; + wait_for_completion(&req->r_completion); + } + mutex_lock(&mdsc->mutex); + if (req->r_reply == NULL && !err) { + put_request_sessions(req); + goto retry; + } + if (IS_ERR(req->r_reply)) { + err = PTR_ERR(req->r_reply); + req->r_reply = NULL; + } + if (!err) + /* all is well, reply has been parsed. */ + err = le32_to_cpu(req->r_reply_info.head->result); +finish: + __unregister_request(mdsc, req); + mutex_unlock(&mdsc->mutex); + + ceph_msg_put(req->r_request); + req->r_request = NULL; + + dout(30, "do_request %p done, result %d\n", req, err); + return err; +} + +/* + * Handle mds reply. + * + * We take the session mutex and parse and process the reply immediately. + * This preserves the logical ordering of replies, capabilities, etc., sent + * by the MDS as they are applied to our local cache. + */ +void ceph_mdsc_handle_reply(struct ceph_mds_client *mdsc, struct ceph_msg *msg) +{ + struct ceph_mds_request *req; + struct ceph_mds_reply_head *head = msg->front.iov_base; + struct ceph_mds_reply_info_parsed *rinfo; /* parsed reply info */ + u64 tid; + int err, result; + int mds; + u32 cap, capseq, mseq; + int took_snap_sem = 0; + + if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS) + return; + if (msg->front.iov_len < sizeof(*head)) { + derr(1, "handle_reply got corrupt (short) reply\n"); + return; + } + + /* get request, session */ + tid = le64_to_cpu(head->tid); + mutex_lock(&mdsc->mutex); + req = __get_request(mdsc, tid); + if (!req) { + dout(1, "handle_reply on unknown tid %llu\n", tid); + mutex_unlock(&mdsc->mutex); + return; + } + dout(10, "handle_reply %p expected_cap=%p\n", req, req->r_expected_cap); + mds = le32_to_cpu(msg->hdr.src.name.num); + if (req->r_got_reply) { + derr(1, "got reply on %llu, mds%d got more than one reply\n", + tid, mds); + mutex_unlock(&mdsc->mutex); + return; + } + if (req->r_session && req->r_session->s_mds != mds) { + ceph_put_mds_session(req->r_session); + req->r_session = __ceph_get_mds_session(mdsc, mds); + } + if (req->r_session == NULL) { + derr(1, "got reply on %llu, but no session for mds%d\n", + tid, mds); + mutex_unlock(&mdsc->mutex); + ceph_mdsc_put_request(req); + return; + } + BUG_ON(req->r_reply); + req->r_got_reply = 1; + + /* take the snap sem if we are adding a cap here */ + if (req->r_expected_cap) { + down_write(&mdsc->snap_rwsem); + took_snap_sem = 1; + } + mutex_unlock(&mdsc->mutex); + + mutex_lock(&req->r_session->s_mutex); + + /* parse */ + rinfo = &req->r_reply_info; + err = parse_reply_info(msg, rinfo); + if (err < 0) { + derr(0, "handle_reply got corrupt reply\n"); + goto done; + } + result = le32_to_cpu(rinfo->head->result); + dout(10, "handle_reply tid %lld result %d\n", tid, result); + + /* insert trace into our cache */ + err = ceph_fill_trace(mdsc->client->sb, req, req->r_session); + if (err) + goto done; + if (result == 0) { + /* caps? (i.e. this is an open) */ + if (req->r_expected_cap && req->r_last_inode) { + cap = le32_to_cpu(rinfo->head->file_caps); + capseq = le32_to_cpu(rinfo->head->file_caps_seq); + mseq = le32_to_cpu(rinfo->head->file_caps_mseq); + if (ceph_snap(req->r_last_inode) == CEPH_NOSNAP) { + /* use our preallocated struct ceph_cap */ + err = ceph_add_cap(req->r_last_inode, + req->r_session, + req->r_fmode, + cap, capseq, mseq, + rinfo->snapblob, + rinfo->snapblob_len, + req->r_expected_cap); + req->r_expected_cap = NULL; + if (err) + goto done; + } else { + /* don't bother with full blown caps on snapped + * metadata, since its read-only and won't + * change anyway. */ + struct ceph_inode_info *ci = + ceph_inode(req->r_last_inode); + + spin_lock(&req->r_last_inode->i_lock); + ci->i_snap_caps |= cap; + __ceph_get_fmode(ci, req->r_fmode); + spin_unlock(&req->r_last_inode->i_lock); + } + } + + /* readdir result? */ + if (rinfo->dir_nr) + ceph_readdir_prepopulate(req); + } + +done: + if (took_snap_sem) + up_write(&mdsc->snap_rwsem); + + if (err) { + req->r_err = err; + } else { + req->r_reply = msg; + ceph_msg_get(msg); + } + + mutex_unlock(&req->r_session->s_mutex); + + /* kick calling process */ + complete(&req->r_completion); + ceph_mdsc_put_request(req); + return; +} + + + +/* + * handle mds notification that our request has been forwarded. + */ +void ceph_mdsc_handle_forward(struct ceph_mds_client *mdsc, + struct ceph_msg *msg) +{ + struct ceph_mds_request *req; + u64 tid; + u32 next_mds; + u32 fwd_seq; + u8 must_resend; + int err = -EINVAL; + void *p = msg->front.iov_base; + void *end = p + msg->front.iov_len; + int from_mds; + + if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS) + goto bad; + from_mds = le32_to_cpu(msg->hdr.src.name.num); + + ceph_decode_need(&p, end, sizeof(u64)+2*sizeof(u32), bad); + ceph_decode_64(&p, tid); + ceph_decode_32(&p, next_mds); + ceph_decode_32(&p, fwd_seq); + ceph_decode_8(&p, must_resend); + + mutex_lock(&mdsc->mutex); + req = __get_request(mdsc, tid); + if (!req) { + dout(10, "forward %llu dne\n", tid); + goto out; /* dup reply? */ + } + + if (fwd_seq <= req->r_num_fwd) { + dout(10, "forward %llu to mds%d - old seq %d <= %d\n", + tid, next_mds, req->r_num_fwd, fwd_seq); + } else if (!must_resend && + __have_session(mdsc, next_mds) && + mdsc->sessions[next_mds]->s_state == CEPH_MDS_SESSION_OPEN) { + /* yes. adjust our sessions, but that's all; the old mds + * forwarded our message for us. */ + dout(10, "forward %llu to mds%d (mds%d fwded)\n", tid, next_mds, + from_mds); + req->r_num_fwd = fwd_seq; + put_request_sessions(req); + req->r_session = __ceph_get_mds_session(mdsc, next_mds); + req->r_fwd_session = __ceph_get_mds_session(mdsc, from_mds); + } else { + /* no, resend. */ + /* forward race not possible; mds would drop */ + dout(10, "forward %llu to mds%d (we resend)\n", tid, next_mds); + req->r_num_fwd = fwd_seq; + req->r_resend_mds = next_mds; + put_request_sessions(req); + complete(&req->r_completion); /* wake up do_request */ + } + ceph_mdsc_put_request(req); +out: + mutex_unlock(&mdsc->mutex); + return; + +bad: + derr(0, "problem decoding message, err=%d\n", err); +} + + + +/* + * If an MDS fails and recovers, it needs to reconnect with clients in order + * to reestablish shared state. This includes all caps issued through this + * session _and_ the snap_realm hierarchy. Because it's not clear which + * snap realms the mds cares about, we send everything we know about.. that + * ensures we'll then get any new info the recovering MDS might have. + * + * This is a relatively heavyweight operation, but it's rare. + * + * called with mdsc->mutex held. + */ +static void send_mds_reconnect(struct ceph_mds_client *mdsc, int mds) +{ + struct ceph_mds_session *session; + struct ceph_msg *reply; + int newlen, len = 4 + 1; + void *p, *end; + struct list_head *cp; + struct ceph_cap *cap; + char *path; + int pathlen, err; + u64 pathbase; + struct dentry *dentry; + struct ceph_inode_info *ci; + int num_caps, num_realms = 0; + int got; + u64 next_snap_ino = 0; + __le32 *pnum_realms; + + dout(1, "reconnect to recovering mds%d\n", mds); + + /* find session */ + session = __ceph_get_mds_session(mdsc, mds); + if (session) { + session->s_state = CEPH_MDS_SESSION_RECONNECTING; + session->s_seq = 0; + + /* estimate needed space */ + len += session->s_nr_caps * + sizeof(struct ceph_mds_cap_reconnect); + len += session->s_nr_caps * (100); /* guess! */ + dout(40, "estimating i need %d bytes for %d caps\n", + len, session->s_nr_caps); + } else { + dout(20, "no session for mds%d, will send short reconnect\n", + mds); + } + + down_read(&mdsc->snap_rwsem); + mutex_unlock(&mdsc->mutex); /* drop lock for duration */ + if (session) + mutex_lock(&session->s_mutex); + +retry: + /* build reply */ + reply = ceph_msg_new(CEPH_MSG_CLIENT_RECONNECT, len, 0, 0, NULL); + if (IS_ERR(reply)) { + err = PTR_ERR(reply); + derr(0, "ENOMEM trying to send mds reconnect to mds%d\n", mds); + goto out; + } + p = reply->front.iov_base; + end = p + len; + + if (!session) { + ceph_encode_8(&p, 1); /* session was closed */ + ceph_encode_32(&p, 0); + goto send; + } + dout(10, "session %p state %s\n", session, + session_state_name(session->s_state)); + + /* traverse this session's caps */ + ceph_encode_8(&p, 0); + ceph_encode_32(&p, session->s_nr_caps); + num_caps = 0; + list_for_each(cp, &session->s_caps) { + struct inode *inode; + struct ceph_mds_cap_reconnect *rec; + + cap = list_entry(cp, struct ceph_cap, session_caps); + ci = cap->ci; + inode = &ci->vfs_inode; + + dout(10, " adding cap %p on ino %llx.%llx inode %p\n", cap, + ceph_vinop(inode), inode); + ceph_decode_need(&p, end, sizeof(u64), needmore); + ceph_encode_64(&p, ceph_ino(inode)); + + dentry = d_find_alias(inode); + if (dentry) { + path = ceph_build_path(dentry, &pathlen, + &pathbase, 9999); + if (IS_ERR(path)) { + err = PTR_ERR(path); + BUG_ON(err); + } + } else { + path = NULL; + pathlen = 0; + } + ceph_decode_need(&p, end, pathlen+4, needmore); + ceph_encode_string(&p, end, path, pathlen); + + ceph_decode_need(&p, end, sizeof(*rec), needmore); + rec = p; + p += sizeof(*rec); + BUG_ON(p > end); + spin_lock(&inode->i_lock); + cap->seq = 0; /* reset cap seq */ + rec->wanted = cpu_to_le32(__ceph_caps_wanted(ci)); + rec->issued = cpu_to_le32(__ceph_caps_issued(ci, NULL)); + rec->size = cpu_to_le64(inode->i_size); + ceph_encode_timespec(&rec->mtime, &inode->i_mtime); + ceph_encode_timespec(&rec->atime, &inode->i_atime); + rec->snaprealm = cpu_to_le64(ci->i_snap_realm->ino); + spin_unlock(&inode->i_lock); + + kfree(path); + dput(dentry); + num_caps++; + } + + /* + * snaprealms. we provide mds with the ino, seq (version), and + * parent for all of our realms. If the mds has any newer info, + * it will tell us. + */ + next_snap_ino = 0; + /* save some space for the snaprealm count */ + pnum_realms = p; + ceph_decode_need(&p, end, sizeof(*pnum_realms), needmore); + p += sizeof(*pnum_realms); + num_realms = 0; + while (1) { + struct ceph_snap_realm *realm; + struct ceph_mds_snaprealm_reconnect *sr_rec; + got = radix_tree_gang_lookup(&mdsc->snap_realms, + (void **)&realm, next_snap_ino, 1); + if (!got) + break; + + dout(10, " adding snap realm %llx seq %lld parent %llx\n", + realm->ino, realm->seq, realm->parent_ino); + ceph_decode_need(&p, end, sizeof(*sr_rec), needmore); + sr_rec = p; + sr_rec->ino = cpu_to_le64(realm->ino); + sr_rec->seq = cpu_to_le64(realm->seq); + sr_rec->parent = cpu_to_le64(realm->parent_ino); + p += sizeof(*sr_rec); + num_realms++; + next_snap_ino = realm->ino + 1; + } + *pnum_realms = cpu_to_le32(num_realms); + +send: + reply->front.iov_len = p - reply->front.iov_base; + reply->hdr.front_len = cpu_to_le32(reply->front.iov_len); + dout(10, "final len was %u (guessed %d)\n", + (unsigned)reply->front.iov_len, len); + ceph_send_msg_mds(mdsc, reply, mds); + + if (session) { + session->s_state = CEPH_MDS_SESSION_OPEN; + complete(&session->s_completion); + } + +out: + if (session) { + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + } + up_read(&mdsc->snap_rwsem); + mutex_lock(&mdsc->mutex); + return; + +needmore: + /* + * we need a larger buffer. this doesn't very accurately + * factor in snap realms, but it's safe. + */ + num_caps += num_realms; + newlen = (len * (session->s_nr_caps+3)) / (num_caps + 1); + dout(30, "i guessed %d, and did %d of %d caps, retrying with %d\n", + len, num_caps, session->s_nr_caps, newlen); + len = newlen; + ceph_msg_put(reply); + goto retry; +} + + +/* + * if the client is unresponsive for long enough, the mds will kill + * the session entirely. + */ +void ceph_mdsc_handle_reset(struct ceph_mds_client *mdsc, int mds) +{ + derr(1, "mds%d gave us the boot. IMPLEMENT RECONNECT.\n", mds); +} + + + +/* + * compare old and new mdsmaps, kicking requests + * and closing out old connections as necessary + * + * called under mdsc->mutex. + */ +static void check_new_map(struct ceph_mds_client *mdsc, + struct ceph_mdsmap *newmap, + struct ceph_mdsmap *oldmap) +{ + int i; + int oldstate, newstate; + struct ceph_mds_session *s; + + dout(20, "check_new_map new %u old %u\n", + newmap->m_epoch, oldmap->m_epoch); + + for (i = 0; i < oldmap->m_max_mds && i < mdsc->max_sessions; i++) { + if (mdsc->sessions[i] == NULL) + continue; + s = mdsc->sessions[i]; + oldstate = ceph_mdsmap_get_state(oldmap, i); + newstate = ceph_mdsmap_get_state(newmap, i); + + dout(20, "check_new_map mds%d state %d -> %d (session %s)\n", + i, oldstate, newstate, session_state_name(s->s_state)); + if (newstate < oldstate) { + /* if the state moved backwards, that means + * the old mds failed and/or a new mds is + * recovering in its place. */ + /* notify messenger to close out old messages, + * socket. */ + ceph_messenger_mark_down(mdsc->client->msgr, + &oldmap->m_addr[i]); + + if (s->s_state == CEPH_MDS_SESSION_OPENING) { + /* the session never opened, just close it + * out now */ + complete(&s->s_completion); + unregister_session(mdsc, i); + } + + /* kick any requests waiting on the recovering mds */ + kick_requests(mdsc, i, 1); + continue; + } + + /* + * kick requests on any mds that has gone active. + * + * kick requests on cur or forwarder: we may have sent + * the request to mds1, mds1 told us it forwarded it + * to mds2, but then we learn mds1 failed and can't be + * sure it successfully forwarded our request before + * it died. + */ + if (oldstate < CEPH_MDS_STATE_ACTIVE && + newstate >= CEPH_MDS_STATE_ACTIVE) + kick_requests(mdsc, i, 1); + } +} + + + +/* + * leases + */ + +void ceph_mdsc_handle_lease(struct ceph_mds_client *mdsc, struct ceph_msg *msg) +{ + struct super_block *sb = mdsc->client->sb; + struct inode *inode; + struct ceph_mds_session *session; + struct ceph_inode_info *ci; + struct dentry *parent, *dentry; + int mds; + struct ceph_mds_lease *h = msg->front.iov_base; + struct ceph_vino vino; + int mask; + struct qstr dname; + + if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS) + return; + mds = le32_to_cpu(msg->hdr.src.name.num); + dout(10, "handle_lease from mds%d\n", mds); + + /* decode */ + if (msg->front.iov_len < sizeof(*h) + sizeof(u32)) + goto bad; + vino.ino = le64_to_cpu(h->ino); + vino.snap = CEPH_NOSNAP; + mask = le16_to_cpu(h->mask); + dname.name = (void *)h + sizeof(*h) + sizeof(u32); + dname.len = msg->front.iov_len - sizeof(*h) - sizeof(u32); + if (dname.len != le32_to_cpu(*(__le32 *)(h+1))) + goto bad; + + /* find session */ + mutex_lock(&mdsc->mutex); + session = __ceph_get_mds_session(mdsc, mds); + mutex_unlock(&mdsc->mutex); + if (!session) { + derr(0, "WTF, got lease but no session for mds%d\n", mds); + return; + } + + mutex_lock(&session->s_mutex); + session->s_seq++; + + /* lookup inode */ + inode = ceph_find_inode(sb, vino); + dout(20, "handle_lease action is %d, mask %d, ino %llx %p\n", h->action, + mask, vino.ino, inode); + if (inode == NULL) { + dout(10, "handle_lease no inode %llx\n", vino.ino); + goto release; + } + + BUG_ON(h->action != CEPH_MDS_LEASE_REVOKE); /* for now */ + + /* inode */ + ci = ceph_inode(inode); + revoke_inode_lease(ci, mask); + + /* dentry */ + if (mask & CEPH_LOCK_DN) { + parent = d_find_alias(inode); + if (!parent) { + dout(10, "no parent dentry on inode %p\n", inode); + WARN_ON(1); + goto release; /* hrm... */ + } + dname.hash = full_name_hash(dname.name, dname.len); + dentry = d_lookup(parent, &dname); + dput(parent); + if (!dentry) + goto release; + revoke_dentry_lease(dentry); + dput(dentry); + } + +release: + iput(inode); + /* let's just reuse the same message */ + h->action = CEPH_MDS_LEASE_RELEASE; + ceph_msg_get(msg); + ceph_send_msg_mds(mdsc, msg, mds); + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + return; + +bad: + dout(0, "corrupt lease message\n"); +} + + +/* + * Preemptively release a lease we expect to invalidate anyway. + * Pass @inode always, @dentry is optional. + */ +void ceph_mdsc_lease_release(struct ceph_mds_client *mdsc, struct inode *inode, + struct dentry *dentry, int mask) +{ + struct ceph_msg *msg; + struct ceph_mds_lease *lease; + struct ceph_inode_info *ci; + struct ceph_dentry_info *di; + int origmask = mask; + int mds = -1; + int len = sizeof(*lease) + sizeof(u32); + int dnamelen = 0; + + BUG_ON(inode == NULL); + + /* + * NOTE: if the inode and dentry leases come from different + * mds's, we only release the inode lease. That's rare, so + * it's no big deal: the dentry lease will just get revoked + * explicitly. + */ + + /* is dentry lease valid? */ + if ((mask & CEPH_LOCK_DN) && dentry) { + spin_lock(&dentry->d_lock); + di = ceph_dentry(dentry); + if (di && + di->lease_session->s_mds >= 0 && + di->lease_gen == di->lease_session->s_cap_gen && + time_before(jiffies, dentry->d_time)) { + /* we do have a lease on this dentry; note mds */ + mds = di->lease_session->s_mds; + dnamelen = dentry->d_name.len; + len += dentry->d_name.len; + } else { + mask &= ~CEPH_LOCK_DN; /* no lease; clear DN bit */ + } + spin_unlock(&dentry->d_lock); + } else { + mask &= ~CEPH_LOCK_DN; /* no lease; clear DN bit */ + } + + /* inode lease? */ + ci = ceph_inode(inode); + spin_lock(&inode->i_lock); + if (ci->i_lease_session && + ci->i_lease_session->s_mds >= 0 && + ci->i_lease_gen == ci->i_lease_session->s_cap_gen && + time_before(jiffies, ci->i_lease_ttl)) { + mds = ci->i_lease_session->s_mds; + mask &= CEPH_LOCK_DN | ci->i_lease_mask; /* lease is valid */ + ci->i_lease_mask &= ~mask; + } else { + mask &= CEPH_LOCK_DN; /* no lease; clear all but DN bits */ + } + spin_unlock(&inode->i_lock); + + if (mask == 0) { + dout(10, "lease_release inode %p (%d) dentry %p -- " + "no lease on %d\n", + inode, ci->i_lease_mask, dentry, origmask); + return; /* nothing to drop */ + } + BUG_ON(mds < 0); + + dout(10, "lease_release inode %p dentry %p %d mask %d to mds%d\n", + inode, dentry, dnamelen, mask, mds); + msg = ceph_msg_new(CEPH_MSG_CLIENT_LEASE, len, 0, 0, NULL); + if (IS_ERR(msg)) + return; + lease = msg->front.iov_base; + lease->action = CEPH_MDS_LEASE_RELEASE; + lease->mask = cpu_to_le16(mask); + lease->ino = cpu_to_le64(ceph_vino(inode).ino); + lease->first = lease->last = cpu_to_le64(ceph_vino(inode).snap); + *(__le32 *)((void *)lease + sizeof(*lease)) = cpu_to_le32(dnamelen); + if (dentry) + memcpy((void *)lease + sizeof(*lease) + 4, dentry->d_name.name, + dnamelen); + ceph_send_msg_mds(mdsc, msg, mds); +} + + +/* + * delayed work -- periodically trim expired leases, renew caps with mds + */ +static void schedule_delayed(struct ceph_mds_client *mdsc) +{ + int delay = 5; + unsigned hz = round_jiffies_relative(HZ * delay); + schedule_delayed_work(&mdsc->delayed_work, hz); +} + +static void delayed_work(struct work_struct *work) +{ + int i; + struct ceph_mds_client *mdsc = + container_of(work, struct ceph_mds_client, delayed_work.work); + int renew_interval; + int renew_caps; + u32 want_map = 0; + + dout(30, "delayed_work\n"); + ceph_check_delayed_caps(mdsc); + + mutex_lock(&mdsc->mutex); + renew_interval = mdsc->mdsmap->m_session_timeout >> 2; + renew_caps = time_after_eq(jiffies, HZ*renew_interval + + mdsc->last_renew_caps); + if (renew_caps) + mdsc->last_renew_caps = jiffies; + + for (i = 0; i < mdsc->max_sessions; i++) { + struct ceph_mds_session *s = __ceph_get_mds_session(mdsc, i); + if (s == NULL) + continue; + if (s->s_state == CEPH_MDS_SESSION_CLOSING) { + dout(10, "resending session close request for mds%d\n", + s->s_mds); + request_close_session(mdsc, s); + continue; + } + if (s->s_ttl && time_after(jiffies, s->s_ttl)) { + derr(1, "mds%d session probably timed out, " + "requesting mds map\n", s->s_mds); + want_map = mdsc->mdsmap->m_epoch; + } + if (s->s_state < CEPH_MDS_SESSION_OPEN) { + /* this mds is failed or recovering, just wait */ + ceph_put_mds_session(s); + continue; + } + mutex_unlock(&mdsc->mutex); + + mutex_lock(&s->s_mutex); + if (renew_caps) + send_renew_caps(mdsc, s); + trim_session_leases(s); + mutex_unlock(&s->s_mutex); + ceph_put_mds_session(s); + + mutex_lock(&mdsc->mutex); + } + mutex_unlock(&mdsc->mutex); + + if (want_map) + ceph_monc_request_mdsmap(&mdsc->client->monc, want_map); + + schedule_delayed(mdsc); +} + + +void ceph_mdsc_init(struct ceph_mds_client *mdsc, struct ceph_client *client) +{ + mdsc->client = client; + mutex_init(&mdsc->mutex); + mdsc->mdsmap = NULL; /* none yet */ + init_completion(&mdsc->map_waiters); + init_completion(&mdsc->session_close_waiters); + mdsc->sessions = NULL; + mdsc->max_sessions = 0; + mdsc->stopping = 0; + init_rwsem(&mdsc->snap_rwsem); + INIT_RADIX_TREE(&mdsc->snap_realms, GFP_NOFS); + mdsc->last_tid = 0; + INIT_RADIX_TREE(&mdsc->request_tree, GFP_NOFS); + INIT_DELAYED_WORK(&mdsc->delayed_work, delayed_work); + mdsc->last_renew_caps = jiffies; + INIT_LIST_HEAD(&mdsc->cap_delay_list); + spin_lock_init(&mdsc->cap_delay_lock); + INIT_LIST_HEAD(&mdsc->snap_flush_list); + spin_lock_init(&mdsc->snap_flush_lock); +} + +/* + * drop all leases (and dentry refs) in preparation for umount + */ +static void drop_leases(struct ceph_mds_client *mdsc) +{ + int i; + + dout(10, "drop_leases\n"); + mutex_lock(&mdsc->mutex); + for (i = 0; i < mdsc->max_sessions; i++) { + struct ceph_mds_session *s = __ceph_get_mds_session(mdsc, i); + if (!s) + continue; + mutex_unlock(&mdsc->mutex); + mutex_lock(&s->s_mutex); + remove_session_leases(s); + mutex_unlock(&s->s_mutex); + ceph_put_mds_session(s); + mutex_lock(&mdsc->mutex); + } + mutex_unlock(&mdsc->mutex); +} + +/* + * called before mount is ro, and before dentries are torn down. + * (hmm, does this still race with new lookups?) + */ +void ceph_mdsc_pre_umount(struct ceph_mds_client *mdsc) +{ + drop_leases(mdsc); + ceph_check_delayed_caps(mdsc); +} + +/* + * called after sb is ro. + */ +void ceph_mdsc_close_sessions(struct ceph_mds_client *mdsc) +{ + struct ceph_mds_session *session; + int i; + int n; + unsigned long started, timeout = 60 * HZ; + struct ceph_client *client = mdsc->client; + + dout(10, "close_sessions\n"); + mdsc->stopping = 1; + + /* + * clean out the delayed cap list; we will flush everything + * explicitly below. + */ + spin_lock(&mdsc->cap_delay_lock); + while (!list_empty(&mdsc->cap_delay_list)) { + struct ceph_inode_info *ci; + ci = list_first_entry(&mdsc->cap_delay_list, + struct ceph_inode_info, + i_cap_delay_list); + list_del_init(&ci->i_cap_delay_list); + spin_unlock(&mdsc->cap_delay_lock); + iput(&ci->vfs_inode); + spin_lock(&mdsc->cap_delay_lock); + } + spin_unlock(&mdsc->cap_delay_lock); + + mutex_lock(&mdsc->mutex); + + /* close sessions, caps. + * + * WARNING the session close timeout (and forced unmount in + * general) is somewhat broken.. we'll leaved inodes pinned + * and other nastyness. + */ + started = jiffies; + while (time_before(jiffies, started + timeout)) { + dout(10, "closing sessions\n"); + n = 0; + for (i = 0; i < mdsc->max_sessions; i++) { + session = __ceph_get_mds_session(mdsc, i); + if (!session) + continue; + mutex_unlock(&mdsc->mutex); + mutex_lock(&session->s_mutex); + __close_session(mdsc, session); + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + mutex_lock(&mdsc->mutex); + n++; + } + if (n == 0) + break; + + if (client->mount_state == CEPH_MOUNT_SHUTDOWN) + break; + + dout(10, "waiting for sessions to close\n"); + mutex_unlock(&mdsc->mutex); + wait_for_completion_timeout(&mdsc->session_close_waiters, + timeout); + mutex_lock(&mdsc->mutex); + } + + WARN_ON(!list_empty(&mdsc->cap_delay_list)); + + mutex_unlock(&mdsc->mutex); + + cancel_delayed_work_sync(&mdsc->delayed_work); /* cancel timer */ + + dout(10, "stopped\n"); +} + +void ceph_mdsc_stop(struct ceph_mds_client *mdsc) +{ + dout(10, "stop\n"); + cancel_delayed_work_sync(&mdsc->delayed_work); /* cancel timer */ + if (mdsc->mdsmap) + ceph_mdsmap_destroy(mdsc->mdsmap); + kfree(mdsc->sessions); +} + + +/* + * handle mds map update. + */ +void ceph_mdsc_handle_map(struct ceph_mds_client *mdsc, struct ceph_msg *msg) +{ + u32 epoch; + u32 maplen; + void *p = msg->front.iov_base; + void *end = p + msg->front.iov_len; + struct ceph_mdsmap *newmap, *oldmap; + struct ceph_fsid fsid; + int err = -EINVAL; + int from; + + if (le32_to_cpu(msg->hdr.src.name.type) == CEPH_ENTITY_TYPE_MDS) + from = le32_to_cpu(msg->hdr.src.name.num); + else + from = -1; + + ceph_decode_need(&p, end, sizeof(fsid)+2*sizeof(u32), bad); + ceph_decode_64_le(&p, fsid.major); + ceph_decode_64_le(&p, fsid.minor); + if (!ceph_fsid_equal(&fsid, &mdsc->client->monc.monmap->fsid)) { + derr(0, "got mdsmap with wrong fsid\n"); + return; + } + ceph_decode_32(&p, epoch); + ceph_decode_32(&p, maplen); + dout(2, "handle_map epoch %u len %d\n", epoch, (int)maplen); + + /* do we need it? */ + ceph_monc_got_mdsmap(&mdsc->client->monc, epoch); + mutex_lock(&mdsc->mutex); + if (mdsc->mdsmap && epoch <= mdsc->mdsmap->m_epoch) { + dout(2, "handle_map epoch %u <= our %u\n", + epoch, mdsc->mdsmap->m_epoch); + mutex_unlock(&mdsc->mutex); + return; + } + + newmap = ceph_mdsmap_decode(&p, end); + if (IS_ERR(newmap)) { + err = PTR_ERR(newmap); + goto bad; + } + + /* swap into place */ + if (mdsc->mdsmap) { + oldmap = mdsc->mdsmap; + mdsc->mdsmap = newmap; + check_new_map(mdsc, newmap, oldmap); + ceph_mdsmap_destroy(oldmap); + + /* reconnect? a recovering mds will send us an mdsmap, + * indicating their state is RECONNECTING, if it wants us + * to reconnect. */ + if (from >= 0 && from < newmap->m_max_mds && + ceph_mdsmap_get_state(newmap, from) == + CEPH_MDS_STATE_RECONNECT) + send_mds_reconnect(mdsc, from); + } else { + mdsc->mdsmap = newmap; /* first mds map */ + } + + mutex_unlock(&mdsc->mutex); + schedule_delayed(mdsc); + complete(&mdsc->map_waiters); + return; + +bad: + derr(1, "problem with mdsmap %d\n", err); + return; +} + + +/* eof */ diff --git a/fs/ceph/mds_client.h b/fs/ceph/mds_client.h new file mode 100644 index 0000000..ab13c6b --- /dev/null +++ b/fs/ceph/mds_client.h @@ -0,0 +1,255 @@ +#ifndef _FS_CEPH_MDS_CLIENT_H +#define _FS_CEPH_MDS_CLIENT_H + +#include <linux/completion.h> +#include <linux/list.h> +#include <linux/mutex.h> +#include <linux/radix-tree.h> +#include <linux/spinlock.h> + +#include "types.h" +#include "messenger.h" +#include "mdsmap.h" + +/* + * A cluster of MDS (metadata server) daemons is responsible for + * managing the file system namespace (the directory hierarchy and + * inodes) and for coordinating shared access to storage. Metadata is + * partitioning hierarchically across a number of servers, and that + * partition varies over time as the cluster adjusts the distribution + * in order to balance load. + * + * The MDS client is primarily responsible to managing synchronous + * metadata requests for operations like open, unlink, and so forth. + * If there is a MDS failure, we find out about it when we (possibly + * request and) receive a new MDS map, and can resubmit affected + * requests. + * + * For the most part, though, we take advantage of a lossless + * communications channel to the MDS, and do not need to worry about + * timing out or resubmitting requests. + * + * We maintain a stateful "session" with each MDS we interact with. + * Within each session, we sent periodic heartbeat messages to ensure + * any capabilities or leases we have been issues remain valid. If + * the session times out and goes stale, our leases and capabilities + * are no longer valid. + */ + +/* + * Some lock dependencies: + * + * session->s_mutex + * mdsc->mutex + * mdsc->snap_rwsem + * + * inode->i_lock + * mdsc->snap_flush_lock + * mdsc->cap_delay_lock + * + */ + +struct ceph_client; +struct ceph_cap; + +/* + * parsed info about a single inode. pointers are into the encoded + * on-wire structures within the mds reply message payload. + */ +struct ceph_mds_reply_info_in { + struct ceph_mds_reply_inode *in; + u32 symlink_len; + char *symlink; + u32 xattr_len; + char *xattr_data; +}; + +/* + * parsed info about an mds reply, including a "trace" from + * the referenced inode, through its parents up to the root + * directory, and directory contents (for readdir results). + */ +struct ceph_mds_reply_info_parsed { + struct ceph_mds_reply_head *head; + + int trace_numi, trace_numd, trace_snapdirpos; + struct ceph_mds_reply_info_in *trace_in; + struct ceph_mds_reply_lease **trace_ilease; + struct ceph_mds_reply_dirfrag **trace_dir; + char **trace_dname; + u32 *trace_dname_len; + struct ceph_mds_reply_lease **trace_dlease; + + struct ceph_mds_reply_dirfrag *dir_dir; + int dir_nr; + struct ceph_mds_reply_lease **dir_ilease; + char **dir_dname; + u32 *dir_dname_len; + struct ceph_mds_reply_lease **dir_dlease; + struct ceph_mds_reply_info_in *dir_in; + + /* encoded blob describing snapshot contexts for certain + operations (e.g., open) */ + void *snapblob; + int snapblob_len; +}; + +/* + * state associated with each MDS<->client session + */ +enum { + CEPH_MDS_SESSION_NEW = 1, + CEPH_MDS_SESSION_OPENING = 2, + CEPH_MDS_SESSION_OPEN = 3, + CEPH_MDS_SESSION_FLUSHING = 4, + CEPH_MDS_SESSION_CLOSING = 5, + CEPH_MDS_SESSION_RECONNECTING = 6 +}; + +struct ceph_mds_session { + int s_mds; + int s_state; + unsigned long s_ttl; /* time until mds kills us */ + u64 s_seq; /* incoming msg seq # */ + struct mutex s_mutex; /* serialize session messages */ + spinlock_t s_cap_lock; /* protects s_cap_gen, s_cap_ttl */ + u32 s_cap_gen; /* inc each time we get mds stale msg */ + unsigned long s_cap_ttl; /* when session caps expire */ + unsigned long s_renew_requested; /* last time we sent a renew req */ + struct list_head s_caps; /* all caps issued by this session */ + int s_nr_caps; + struct list_head s_inode_leases, s_dentry_leases; /* and leases */ + atomic_t s_ref; + struct completion s_completion; +}; + +/* + * modes of choosing which MDS to send a request to + */ +enum { + USE_ANY_MDS, + USE_RANDOM_MDS, + USE_CAP_MDS, /* prefer mds we hold caps from */ + USE_AUTH_MDS, /* prefer authoritative mds for this metadata item */ +}; + +/* + * an in-flight mds request + */ +struct ceph_mds_request { + u64 r_tid; /* transaction id */ + struct ceph_msg *r_request; /* original request */ + struct ceph_msg *r_reply; + struct ceph_mds_reply_info_parsed r_reply_info; + int r_err; + unsigned long r_timeout; /* optional. jiffies */ + + unsigned long r_started; /* start time to measure timeout against */ + unsigned long r_request_started; /* start time for mds request only, + used to measure lease durations */ + + /* for choosing which mds to send this request to */ + struct dentry *r_direct_dentry; + int r_direct_mode; + u32 r_direct_hash; /* choose dir frag based on this dentry hash */ + bool r_direct_is_hash; /* true if r_direct_hash is valid */ + + /* references to the trailing dentry and inode from parsing the + * mds response. also used to feed a VFS-provided dentry into + * the reply handler */ + struct inode *r_last_inode; + struct dentry *r_last_dentry; + struct dentry *r_old_dentry; /* for rename */ + struct ceph_cap *r_expected_cap; /* preallocate cap if we expect one */ + int r_fmode; /* file mode, if expecting cap */ + struct ceph_mds_session *r_session; + struct ceph_mds_session *r_fwd_session; /* forwarded from */ + struct inode *r_locked_dir; /* dir (if any) i_mutex locked by vfs */ + + int r_attempts; /* resend attempts */ + int r_num_fwd; /* number of forward attempts */ + int r_resend_mds; /* mds to resend to next, if any*/ + + atomic_t r_ref; + struct completion r_completion; + int r_got_reply; +}; + +/* + * mds client state + */ +struct ceph_mds_client { + struct ceph_client *client; + struct mutex mutex; /* all nested structures */ + + struct ceph_mdsmap *mdsmap; + struct completion map_waiters, session_close_waiters; + + struct ceph_mds_session **sessions; /* NULL for mds if no session */ + int max_sessions; /* len of s_mds_sessions */ + int stopping; /* true if shutting down */ + + /* + * snap_rwsem will cover cap linkage into snaprealms, and realm + * snap contexts. (later, we can do per-realm snap contexts locks..) + */ + struct rw_semaphore snap_rwsem; + struct radix_tree_root snap_realms; + + u64 last_tid; /* most recent mds request */ + struct radix_tree_root request_tree; /* pending mds requests */ + struct delayed_work delayed_work; /* delayed work */ + unsigned long last_renew_caps; /* last time we renewed our caps */ + struct list_head cap_delay_list; /* caps with delayed release */ + spinlock_t cap_delay_lock; /* protects cap_delay_list */ + struct list_head snap_flush_list; /* cap_snaps ready to flush */ + spinlock_t snap_flush_lock; +}; + +extern const char *ceph_mds_op_name(int op); + +extern struct ceph_mds_session *__ceph_get_mds_session(struct ceph_mds_client *, + int mds); +extern void ceph_put_mds_session(struct ceph_mds_session *s); + +extern void ceph_send_msg_mds(struct ceph_mds_client *mdsc, + struct ceph_msg *msg, int mds); + +extern void ceph_mdsc_init(struct ceph_mds_client *mdsc, + struct ceph_client *client); +extern void ceph_mdsc_close_sessions(struct ceph_mds_client *mdsc); +extern void ceph_mdsc_stop(struct ceph_mds_client *mdsc); + +extern void ceph_mdsc_handle_map(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); +extern void ceph_mdsc_handle_session(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); +extern void ceph_mdsc_handle_reply(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); +extern void ceph_mdsc_handle_forward(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); + +extern void ceph_mdsc_handle_lease(struct ceph_mds_client *mdsc, + struct ceph_msg *msg); + +extern void ceph_mdsc_lease_release(struct ceph_mds_client *mdsc, + struct inode *inode, + struct dentry *dn, int mask); + +extern struct ceph_mds_request * +ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op, + u64 ino1, const char *path1, + u64 ino2, const char *path2, + struct dentry *ref, int want_auth); +extern int ceph_mdsc_do_request(struct ceph_mds_client *mdsc, + struct ceph_mds_request *req); +extern void ceph_mdsc_put_request(struct ceph_mds_request *req); + +extern void ceph_mdsc_pre_umount(struct ceph_mds_client *mdsc); + +extern void ceph_mdsc_handle_reset(struct ceph_mds_client *mdsc, int mds); + +extern void ceph_mdsc_flushed_all_caps(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session); + +#endif diff --git a/fs/ceph/mdsmap.c b/fs/ceph/mdsmap.c new file mode 100644 index 0000000..7d00456 --- /dev/null +++ b/fs/ceph/mdsmap.c @@ -0,0 +1,123 @@ +#include <linux/bug.h> +#include <linux/err.h> +#include <linux/random.h> +#include <linux/slab.h> +#include <linux/types.h> + +#include "mdsmap.h" +#include "messenger.h" +#include "decode.h" + +#include "ceph_debug.h" + +int ceph_debug_mdsmap = -1; +#define DOUT_MASK DOUT_MASK_MDSMAP +#define DOUT_VAR ceph_debug_mdsmap +#define DOUT_PREFIX "mdsmap: " +#include "super.h" + + +/* + * choose a random mds that is "up" (i.e. has a state > 0), or -1. + */ +int ceph_mdsmap_get_random_mds(struct ceph_mdsmap *m) +{ + int n = 0; + int i; + char r; + + /* count */ + for (i = 0; i < m->m_max_mds; i++) + if (m->m_state[i] > 0) + n++; + if (n == 0) + return -1; + + /* pick */ + get_random_bytes(&r, 1); + n = r % n; + i = 0; + for (i = 0; n > 0; i++, n--) + while (m->m_state[i] <= 0) + i++; + + return i; +} + +/* + * Ignore any fields we don't care about in the MDS map (there are quite + * a few of them). + */ +struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end) +{ + struct ceph_mdsmap *m; + int i, n; + u32 mds; + int err = -EINVAL; + + m = kzalloc(sizeof(*m), GFP_NOFS); + if (m == NULL) + return ERR_PTR(-ENOMEM); + + ceph_decode_need(p, end, 10*sizeof(u32), bad); + ceph_decode_32(p, m->m_epoch); + ceph_decode_32(p, m->m_client_epoch); + ceph_decode_32(p, m->m_last_failure); + *p += sizeof(struct ceph_timespec); /* ignore map timestamp */ + *p += sizeof(u32); /* skip anchortable */ + ceph_decode_32(p, m->m_root); + ceph_decode_32(p, m->m_session_timeout); + ceph_decode_32(p, m->m_session_autoclose); + ceph_decode_32(p, m->m_max_mds); + + m->m_addr = kmalloc(m->m_max_mds*sizeof(*m->m_addr), GFP_NOFS); + m->m_state = kzalloc(m->m_max_mds*sizeof(*m->m_state), GFP_NOFS); + if (m->m_addr == NULL || m->m_state == NULL) + goto badmem; + + /* state */ + ceph_decode_32(p, n); + ceph_decode_need(p, end, n*2*sizeof(u32), bad); + for (i = 0; i < n; i++) { + ceph_decode_32(p, mds); + if (mds >= m->m_max_mds) + goto bad; + ceph_decode_32(p, m->m_state[mds]); + } + + /* state_seq */ + ceph_decode_32_safe(p, end, n, bad); + *p += n*(sizeof(u32)+sizeof(u64)); + + /* mds_inst */ + ceph_decode_32_safe(p, end, n, bad); + ceph_decode_need(p, end, + n*(sizeof(u32)+sizeof(struct ceph_entity_name)+ + sizeof(struct ceph_entity_addr)), + bad); + for (i = 0; i < n; i++) { + ceph_decode_32(p, mds); + if (mds >= m->m_max_mds) + goto bad; + *p += sizeof(struct ceph_entity_name); + ceph_decode_copy(p, &m->m_addr[mds], sizeof(*m->m_addr)); + } + + /* ok, we don't care about the rest. */ + dout(30, "mdsmap_decode success epoch %u\n", m->m_epoch); + return m; + +badmem: + err = -ENOMEM; +bad: + derr(0, "corrupt mdsmap"); + ceph_mdsmap_destroy(m); + return ERR_PTR(-EINVAL); +} + +void ceph_mdsmap_destroy(struct ceph_mdsmap *m) +{ + kfree(m->m_addr); + kfree(m->m_state); + kfree(m); +} diff --git a/fs/ceph/mdsmap.h b/fs/ceph/mdsmap.h new file mode 100644 index 0000000..8defb0c --- /dev/null +++ b/fs/ceph/mdsmap.h @@ -0,0 +1,41 @@ +#ifndef _FS_CEPH_MDSMAP_H +#define _FS_CEPH_MDSMAP_H + +#include "types.h" + +/* + * mds map + * + * fields limited to those the client cares about + */ +struct ceph_mdsmap { + u32 m_epoch, m_client_epoch, m_last_failure; + u32 m_root; + u32 m_session_timeout; /* seconds */ + u32 m_session_autoclose; /* seconds */ + u32 m_max_mds; /* size of m_addr, m_state arrays */ + struct ceph_entity_addr *m_addr; /* mds addrs */ + s32 *m_state; /* states */ +}; + +static inline struct ceph_entity_addr * +ceph_mdsmap_get_addr(struct ceph_mdsmap *m, int w) +{ + if (w >= m->m_max_mds) + return NULL; + return &m->m_addr[w]; +} + +static inline int ceph_mdsmap_get_state(struct ceph_mdsmap *m, int w) +{ + BUG_ON(w < 0); + if (w >= m->m_max_mds) + return CEPH_MDS_STATE_DNE; + return m->m_state[w]; +} + +extern int ceph_mdsmap_get_random_mds(struct ceph_mdsmap *m); +extern struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end); +extern void ceph_mdsmap_destroy(struct ceph_mdsmap *m); + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 10/19] ceph: OSD client 2008-11-14 0:56 ` [PATCH 09/19] ceph: MDS client Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 11/19] ceph: CRUSH mapping algorithm Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil The OSD client is responsible for reading and writing data from/to the object storage pool. This includes determining where objects are stored in the cluster, and ensuring that requests are retried or redirected in the event of a node failure or data migration. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/osd_client.c | 1125 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/osd_client.h | 135 ++++++ fs/ceph/osdmap.c | 664 +++++++++++++++++++++++++++++ fs/ceph/osdmap.h | 82 ++++ 4 files changed, 2006 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/osd_client.c create mode 100644 fs/ceph/osd_client.h create mode 100644 fs/ceph/osdmap.c create mode 100644 fs/ceph/osdmap.h diff --git a/fs/ceph/osd_client.c b/fs/ceph/osd_client.c new file mode 100644 index 0000000..c25c9c7 --- /dev/null +++ b/fs/ceph/osd_client.c @@ -0,0 +1,1125 @@ +#include <linux/err.h> +#include <linux/highmem.h> +#include <linux/mm.h> +#include <linux/pagemap.h> +#include <linux/slab.h> +#include <linux/uaccess.h> + +#include "ceph_debug.h" + +int ceph_debug_osdc = -1; +#define DOUT_MASK DOUT_MASK_OSDC +#define DOUT_VAR ceph_debug_osdc +#define DOUT_PREFIX "osdc: " +#include "super.h" + +#include "osd_client.h" +#include "messenger.h" +#include "crush/mapper.h" +#include "decode.h" + + +static void reschedule_timeout(struct ceph_osd_client *osdc, + unsigned long base_time); + + + +/* + * calculate the mapping of a file extent onto an object, and fill out the + * request accordingly. shorten extent as necessary if it crosses an + * object boundary. + */ +static void calc_layout(struct ceph_osd_client *osdc, + struct ceph_vino vino, struct ceph_file_layout *layout, + u64 off, u64 *plen, + struct ceph_osd_request *req) +{ + struct ceph_osd_request_head *reqhead = req->r_request->front.iov_base; + struct ceph_osd_op *op = (void *)(reqhead + 1); + u64 orig_len = *plen; + u64 objoff, objlen; /* extent in object */ + + /* object extent? */ + reqhead->oid.ino = cpu_to_le64(vino.ino); + reqhead->oid.snap = cpu_to_le64(vino.snap); + + calc_file_object_mapping(layout, off, plen, &reqhead->oid, + &objoff, &objlen); + if (*plen < orig_len) + dout(10, " skipping last %llu, final file extent %llu~%llu\n", + orig_len - *plen, off, *plen); + op->offset = cpu_to_le64(objoff); + op->length = cpu_to_le64(objlen); + req->r_num_pages = calc_pages_for(off, *plen); + + /* pgid? */ + calc_object_layout(&reqhead->layout, &reqhead->oid, layout, + osdc->osdmap); + + dout(10, "calc_layout %llx.%08x %llu~%llu pgid %llx (%d pages)\n", + le64_to_cpu(reqhead->oid.ino), le32_to_cpu(reqhead->oid.bno), + objoff, objlen, le64_to_cpu(reqhead->layout.ol_pgid), + req->r_num_pages); +} + + +/* + * requests + */ +static void get_request(struct ceph_osd_request *req) +{ + atomic_inc(&req->r_ref); +} + +void ceph_osdc_put_request(struct ceph_osd_request *req) +{ + dout(10, "put_request %p %d -> %d\n", req, atomic_read(&req->r_ref), + atomic_read(&req->r_ref)-1); + BUG_ON(atomic_read(&req->r_ref) <= 0); + if (atomic_dec_and_test(&req->r_ref)) { + if (req->r_request) + ceph_msg_put(req->r_request); + if (req->r_reply) + ceph_msg_put(req->r_reply); + ceph_put_snap_context(req->r_snapc); + kfree(req); + } +} + +/* + * build osd request message only. + */ +static struct ceph_msg *new_request_msg(struct ceph_osd_client *osdc, short opc, + struct ceph_snap_context *snapc) +{ + struct ceph_msg *req; + struct ceph_osd_request_head *head; + struct ceph_osd_op *op; + __le64 *snaps; + size_t size = sizeof(*head) + sizeof(*op); + int i; + + if (snapc) + size += sizeof(u64) * snapc->num_snaps; + req = ceph_msg_new(CEPH_MSG_OSD_OP, size, 0, 0, NULL); + if (IS_ERR(req)) + return req; + memset(req->front.iov_base, 0, req->front.iov_len); + head = req->front.iov_base; + op = (void *)(head + 1); + snaps = (void *)(op + 1); + + /* encode head */ + head->client_inc = cpu_to_le32(1); /* always, for now. */ + head->flags = 0; + head->num_ops = cpu_to_le16(1); + op->op = cpu_to_le16(opc); + + if (snapc) { + head->snap_seq = cpu_to_le64(snapc->seq); + head->num_snaps = cpu_to_le32(snapc->num_snaps); + for (i = 0; i < snapc->num_snaps; i++) + snaps[i] = cpu_to_le64(snapc->snaps[i]); + } + return req; +} + +/* + * build new request AND message, calculate layout, and adjust file + * extent as needed. + */ +struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc, + struct ceph_file_layout *layout, + struct ceph_vino vino, + u64 off, u64 *plen, int op, + struct ceph_snap_context *snapc) +{ + struct ceph_osd_request *req; + struct ceph_msg *msg; + int num_pages = calc_pages_for(off, *plen); + struct ceph_osd_request_head *head; + + /* we may overallocate here, if our write extent is shortened below */ + req = kzalloc(sizeof(*req) + num_pages*sizeof(void *), GFP_NOFS); + if (req == NULL) + return ERR_PTR(-ENOMEM); + + msg = new_request_msg(osdc, op, snapc); + if (IS_ERR(msg)) { + kfree(req); + return ERR_PTR(PTR_ERR(msg)); + } + req->r_request = msg; + req->r_snapc = ceph_get_snap_context(snapc); + + /* calculate max write size, pgid */ + calc_layout(osdc, vino, layout, off, plen, req); + + head = msg->front.iov_base; + req->r_pgid.pg64 = le64_to_cpu(head->layout.ol_pgid); + + atomic_set(&req->r_ref, 1); + init_completion(&req->r_completion); + return req; +} + + +/* + * register request, assign tid. + */ +static int register_request(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + struct ceph_osd_request_head *head = req->r_request->front.iov_base; + int rc; + + mutex_lock(&osdc->request_mutex); + req->r_tid = ++osdc->last_tid; + head->tid = cpu_to_le64(req->r_tid); + + dout(30, "register_request %p tid %lld\n", req, req->r_tid); + rc = radix_tree_insert(&osdc->request_tree, req->r_tid, (void *)req); + if (rc < 0) + goto out; + + get_request(req); + if (osdc->num_requests == 0) { + osdc->timeout_tid = req->r_tid; + dout(10, "setting timeout_tid=%lld\n", osdc->timeout_tid); + reschedule_timeout(osdc, 0); + } + osdc->num_requests++; + +out: + mutex_unlock(&osdc->request_mutex); + return rc; +} + + +static void __register_next_request_timeout(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + struct ceph_osd_request *next_req; + int ret; + + ret = radix_tree_gang_lookup(&osdc->request_tree, (void **)&next_req, + req->r_tid+1, 1); + if (!ret || (next_req->r_tid == osdc->timeout_tid)) + ret = radix_tree_gang_lookup(&osdc->request_tree, + (void **)&next_req, 0, 1); + + if (ret == 1) { + dout(10, "replacing timeout_tid: %lld-> %lld\n", + osdc->timeout_tid, next_req->r_tid); + osdc->timeout_tid = next_req->r_tid; + reschedule_timeout(osdc, req->r_last_stamp); + } +} + +/* + * called under osdc->request_mutex + */ +static void __unregister_request(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + dout(30, "__unregister_request %p tid %lld\n", req, req->r_tid); + radix_tree_delete(&osdc->request_tree, req->r_tid); + + osdc->num_requests--; + if (req->r_tid == osdc->timeout_tid) { + cancel_delayed_work(&osdc->timeout_work); + if (osdc->num_requests) + __register_next_request_timeout(osdc, req); + } + + ceph_osdc_put_request(req); +} + +/* + * pick an osd. the first up osd in the pg. or -1. + * caller should hold map_sem for read. + */ +static int pick_osd(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + int ruleno; + unsigned pps; /* placement ps */ + int osds[10]; + int i, num; + + ruleno = crush_find_rule(osdc->osdmap->crush, req->r_pgid.pg.pool, + req->r_pgid.pg.type, req->r_pgid.pg.size); + if (ruleno < 0) { + derr(0, "pick_osd no crush rule for pool %d type %d size %d\n", + req->r_pgid.pg.pool, req->r_pgid.pg.type, + req->r_pgid.pg.size); + return -1; + } + + if (req->r_pgid.pg.preferred >= 0) + pps = ceph_stable_mod(req->r_pgid.pg.ps, + osdc->osdmap->lpgp_num, + osdc->osdmap->lpgp_num_mask); + else + pps = ceph_stable_mod(req->r_pgid.pg.ps, + osdc->osdmap->pgp_num, + osdc->osdmap->pgp_num_mask); + num = crush_do_rule(osdc->osdmap->crush, ruleno, pps, osds, + min_t(int, req->r_pgid.pg.size, ARRAY_SIZE(osds)), + req->r_pgid.pg.preferred, osdc->osdmap->osd_weight); + + for (i = 0; i < num; i++) + if (ceph_osd_is_up(osdc->osdmap, osds[i])) + return osds[i]; + return -1; +} + +/* + * caller should hold map_sem (for read) + */ +static int send_request(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + struct ceph_osd_request_head *reqhead; + int osd; + + osd = pick_osd(osdc, req); + if (osd < 0) { + dout(10, "send_request %p no up osds in pg\n", req); + ceph_monc_request_osdmap(&osdc->client->monc, + osdc->osdmap->epoch+1); + return 0; + } + + dout(10, "send_request %p tid %llu to osd%d flags %d\n", + req, req->r_tid, osd, req->r_flags); + + reqhead = req->r_request->front.iov_base; + reqhead->osdmap_epoch = cpu_to_le32(osdc->osdmap->epoch); + reqhead->flags |= cpu_to_le32(req->r_flags); /* e.g., RETRY */ + + req->r_request->hdr.dst.name.type = + cpu_to_le32(CEPH_ENTITY_TYPE_OSD); + req->r_request->hdr.dst.name.num = cpu_to_le32(osd); + req->r_request->hdr.dst.addr = osdc->osdmap->osd_addr[osd]; + + req->r_last_osd = osd; + req->r_last_osd_addr = req->r_request->hdr.dst.addr; + req->r_last_stamp = jiffies; + + ceph_msg_get(req->r_request); /* send consumes a ref */ + return ceph_msg_send(osdc->client->msgr, req->r_request, + BASE_DELAY_INTERVAL); +} + +/* + * handle osd op reply. either call the callback if it is specified, + * or do the completion to wake up the waiting thread. + */ +void ceph_osdc_handle_reply(struct ceph_osd_client *osdc, struct ceph_msg *msg) +{ + struct ceph_osd_reply_head *rhead = msg->front.iov_base; + struct ceph_osd_request *req; + u64 tid; + int numops; + + if (msg->front.iov_len < sizeof(*rhead)) + goto bad; + tid = le64_to_cpu(rhead->tid); + numops = le32_to_cpu(rhead->num_ops); + if (msg->front.iov_len != sizeof(*rhead) + + numops * sizeof(struct ceph_osd_op)) + goto bad; + dout(10, "handle_reply %p tid %llu\n", msg, tid); + + /* lookup */ + mutex_lock(&osdc->request_mutex); + req = radix_tree_lookup(&osdc->request_tree, tid); + if (req == NULL) { + dout(10, "handle_reply tid %llu dne\n", tid); + mutex_unlock(&osdc->request_mutex); + return; + } + get_request(req); + if (req->r_reply == NULL) { + /* no data payload, or r_reply would have been set by + prepare_pages. */ + ceph_msg_get(msg); + req->r_reply = msg; + } else if (req->r_reply == msg) { + /* r_reply was set by prepare_pages; now it's fully read. */ + } else { + dout(10, "handle_reply tid %llu already had reply?\n", tid); + goto done; + } + dout(10, "handle_reply tid %llu flags %d\n", tid, + le32_to_cpu(rhead->flags)); + __unregister_request(osdc, req); + mutex_unlock(&osdc->request_mutex); + + if (req->r_callback) + req->r_callback(req); + else + complete(&req->r_completion); /* see do_sync_request */ +done: + ceph_osdc_put_request(req); + return; + +bad: + derr(0, "got corrupt osd_op_reply got %d %d expected %d\n", + (int)msg->front.iov_len, le32_to_cpu(msg->hdr.front_len), + (int)sizeof(*rhead)); +} + + +/* + * Resubmit osd requests whose osd or osd address has changed. Request + * a new osd map if osds are down, or we are otherwise unable to determine + * how to direct a request. + * + * If @who is specified, resubmit requests for that specific osd. + * + * Caller should hold map_sem for read. + */ +static void kick_requests(struct ceph_osd_client *osdc, + struct ceph_entity_addr *who) +{ + struct ceph_osd_request *req; + u64 next_tid = 0; + int got; + int osd; + int needmap = 0; + + mutex_lock(&osdc->request_mutex); + while (1) { + got = radix_tree_gang_lookup(&osdc->request_tree, (void **)&req, + next_tid, 1); + if (got == 0) + break; + next_tid = req->r_tid + 1; + osd = pick_osd(osdc, req); + if (osd < 0 || osd >= osdc->osdmap->max_osd) { + dout(20, "tid %llu maps to no valid osd\n", req->r_tid); + needmap++; /* request a newer map */ + req->r_last_osd = -1; + memset(&req->r_last_osd_addr, 0, + sizeof(req->r_last_osd_addr)); + continue; + } + if (!ceph_entity_addr_equal(&req->r_last_osd_addr, + &osdc->osdmap->osd_addr[osd]) || + (who && ceph_entity_addr_equal(&req->r_last_osd_addr, + who))) { + dout(20, "kicking tid %llu osd%d\n", req->r_tid, osd); + get_request(req); + mutex_unlock(&osdc->request_mutex); + req->r_request = ceph_msg_maybe_dup(req->r_request); + if (!req->r_aborted) { + req->r_flags |= CEPH_OSD_OP_RETRY; + send_request(osdc, req); + } + ceph_osdc_put_request(req); + mutex_lock(&osdc->request_mutex); + } + } + mutex_unlock(&osdc->request_mutex); + + if (needmap) { + dout(10, "%d requests for down osds, need new map\n", needmap); + ceph_monc_request_osdmap(&osdc->client->monc, + osdc->osdmap->epoch+1); + } +} + +/* + * Process updated osd map. + * + * The message contains any number of incremental and full maps. + */ +void ceph_osdc_handle_map(struct ceph_osd_client *osdc, struct ceph_msg *msg) +{ + void *p, *end, *next; + u32 nr_maps, maplen; + u32 epoch; + struct ceph_osdmap *newmap = NULL, *oldmap; + int err; + struct ceph_fsid fsid; + + dout(2, "handle_map have %u\n", osdc->osdmap ? osdc->osdmap->epoch : 0); + p = msg->front.iov_base; + end = p + msg->front.iov_len; + + /* verify fsid */ + ceph_decode_need(&p, end, sizeof(fsid), bad); + ceph_decode_64_le(&p, fsid.major); + ceph_decode_64_le(&p, fsid.minor); + if (!ceph_fsid_equal(&fsid, &osdc->client->monc.monmap->fsid)) { + derr(0, "got map with wrong fsid, ignoring\n"); + return; + } + + down_write(&osdc->map_sem); + + /* incremental maps */ + ceph_decode_32_safe(&p, end, nr_maps, bad); + dout(10, " %d inc maps\n", nr_maps); + while (nr_maps > 0) { + ceph_decode_need(&p, end, 2*sizeof(u32), bad); + ceph_decode_32(&p, epoch); + ceph_decode_32(&p, maplen); + ceph_decode_need(&p, end, maplen, bad); + next = p + maplen; + if (osdc->osdmap && osdc->osdmap->epoch+1 == epoch) { + dout(10, "applying incremental map %u len %d\n", + epoch, maplen); + newmap = apply_incremental(&p, next, osdc->osdmap, + osdc->client->msgr); + if (IS_ERR(newmap)) { + err = PTR_ERR(newmap); + goto bad; + } + if (newmap != osdc->osdmap) { + osdmap_destroy(osdc->osdmap); + osdc->osdmap = newmap; + } + } else { + dout(10, "ignoring incremental map %u len %d\n", + epoch, maplen); + } + p = next; + nr_maps--; + } + if (newmap) + goto done; + + /* full maps */ + ceph_decode_32_safe(&p, end, nr_maps, bad); + dout(30, " %d full maps\n", nr_maps); + while (nr_maps) { + ceph_decode_need(&p, end, 2*sizeof(u32), bad); + ceph_decode_32(&p, epoch); + ceph_decode_32(&p, maplen); + ceph_decode_need(&p, end, maplen, bad); + if (nr_maps > 1) { + dout(5, "skipping non-latest full map %u len %d\n", + epoch, maplen); + } else if (osdc->osdmap && osdc->osdmap->epoch >= epoch) { + dout(10, "skipping full map %u len %d, " + "older than our %u\n", epoch, maplen, + osdc->osdmap->epoch); + } else { + dout(10, "taking full map %u len %d\n", epoch, maplen); + newmap = osdmap_decode(&p, p+maplen); + if (IS_ERR(newmap)) { + err = PTR_ERR(newmap); + goto bad; + } + oldmap = osdc->osdmap; + osdc->osdmap = newmap; + if (oldmap) + osdmap_destroy(oldmap); + } + p += maplen; + nr_maps--; + } + +done: + downgrade_write(&osdc->map_sem); + ceph_monc_got_osdmap(&osdc->client->monc, osdc->osdmap->epoch); + if (newmap) + kick_requests(osdc, NULL); + up_read(&osdc->map_sem); + return; + +bad: + derr(1, "handle_map corrupt msg\n"); + up_write(&osdc->map_sem); + return; +} + +/* + * If we detect that a tcp connection to an osd resets, we need to + * resubmit all requests for that osd. That's because although we reliably + * deliver our requests, the osd doesn't not try as hard to deliver the + * reply (because it does not get notification when clients, mds' leave + * the cluster). + */ +void ceph_osdc_handle_reset(struct ceph_osd_client *osdc, + struct ceph_entity_addr *addr) +{ + down_read(&osdc->map_sem); + kick_requests(osdc, addr); + up_read(&osdc->map_sem); +} + + +/* + * A read request prepares specific pages that data is to be read into. + * When a message is being read off the wire, we call prepare_pages to + * find those pages. + * 0 = success, -1 failure. + */ +int ceph_osdc_prepare_pages(void *p, struct ceph_msg *m, int want) +{ + struct ceph_client *client = p; + struct ceph_osd_client *osdc = &client->osdc; + struct ceph_osd_reply_head *rhead = m->front.iov_base; + struct ceph_osd_request *req; + u64 tid; + int ret = -1; + int type = le16_to_cpu(m->hdr.type); + + dout(10, "prepare_pages on msg %p want %d\n", m, want); + if (unlikely(type != CEPH_MSG_OSD_OPREPLY)) + return -1; /* hmm! */ + + tid = le64_to_cpu(rhead->tid); + mutex_lock(&osdc->request_mutex); + req = radix_tree_lookup(&osdc->request_tree, tid); + if (!req) { + dout(10, "prepare_pages unknown tid %llu\n", tid); + goto out; + } + dout(10, "prepare_pages tid %llu has %d pages, want %d\n", + tid, req->r_num_pages, want); + if (likely(req->r_num_pages >= want && req->r_reply == NULL)) { + m->pages = req->r_pages; + m->nr_pages = req->r_num_pages; + ceph_msg_get(m); + req->r_reply = m; + ret = 0; /* success */ + } +out: + mutex_unlock(&osdc->request_mutex); + return ret; +} + +/* + * Register request, send initial attempt. + */ +static int start_request(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + int rc; + + rc = register_request(osdc, req); + if (rc < 0) + return rc; + down_read(&osdc->map_sem); + rc = send_request(osdc, req); + up_read(&osdc->map_sem); + return rc; +} + +/* + * synchronously do an osd request. + * + * If we are interrupted, take our pages away from any previous sent + * request message that may still be being written to the socket. + */ +static int do_sync_request(struct ceph_osd_client *osdc, + struct ceph_osd_request *req) +{ + struct ceph_osd_reply_head *replyhead; + __s32 rc; + int bytes; + + rc = start_request(osdc, req); /* register+send request */ + if (rc) + return rc; + + rc = wait_for_completion_interruptible(&req->r_completion); + if (rc < 0) { + struct ceph_msg *msg; + + dout(0, "tid %llu err %d, revoking %p pages\n", req->r_tid, + rc, req->r_request); + /* + * we were interrupted. + * + * mark req aborted _before_ revoking pages, so that + * if a racing kick_request _does_ dup the page vec + * pointer, it will definitely then see the aborted + * flag and not send the request. + */ + req->r_aborted = 1; + msg = req->r_request; + mutex_lock(&msg->page_mutex); + msg->pages = NULL; + mutex_unlock(&msg->page_mutex); + if (req->r_reply) { + mutex_lock(&req->r_reply->page_mutex); + req->r_reply->pages = NULL; + mutex_unlock(&req->r_reply->page_mutex); + } + return rc; + } + + /* parse reply */ + replyhead = req->r_reply->front.iov_base; + rc = le32_to_cpu(replyhead->result); + bytes = le32_to_cpu(req->r_reply->hdr.data_len); + dout(10, "do_sync_request tid %llu result %d, %d bytes\n", + req->r_tid, rc, bytes); + if (rc < 0) + return rc; + return bytes; +} + + + + +/* + * if one or more requests takes too long, a timeout expires. + * + * FIXME. + */ +static void reschedule_timeout(struct ceph_osd_client *osdc, + unsigned long base_time) +{ + int timeout = osdc->client->mount_args.osd_timeout; + long jifs = 0; + + if (base_time) + jifs = jiffies-base_time; + + jifs = timeout * HZ - jifs; + + if (jifs < 0) { + jifs %= timeout * HZ; + jifs += timeout * HZ; + } + + dout(10, "reschedule timeout (%ld jiffies)\n", jifs); + + schedule_delayed_work(&osdc->timeout_work, + round_jiffies_relative(jifs)); +} + +static void handle_timeout(struct work_struct *work) +{ + u64 next_tid = 0; + struct ceph_osd_client *osdc = + container_of(work, struct ceph_osd_client, timeout_work.work); + struct ceph_osd_request *req; + int got; + int timeout = osdc->client->mount_args.osd_timeout * HZ; + + dout(10, "timeout\n"); + down_read(&osdc->map_sem); + ceph_monc_request_osdmap(&osdc->client->monc, osdc->osdmap->epoch+1); + + /* + * ping any osds with pending requests to ensure the communications + * channel hasn't reset + */ + mutex_lock(&osdc->request_mutex); + got = radix_tree_gang_lookup(&osdc->request_tree, (void **)&req, + osdc->timeout_tid, 1); + + __register_next_request_timeout(osdc, req); + + while (1) { + if (got == 0) + break; + next_tid = req->r_tid + 1; + if (time_after(jiffies, req->r_last_stamp + timeout)) { + struct ceph_entity_name n = { + .type = cpu_to_le32(CEPH_ENTITY_TYPE_OSD), + .num = cpu_to_le32(req->r_last_osd) + }; + ceph_ping(osdc->client->msgr, n, &req->r_last_osd_addr); + } + + got = radix_tree_gang_lookup(&osdc->request_tree, (void **)&req, + next_tid, 1); + } + mutex_unlock(&osdc->request_mutex); + + up_read(&osdc->map_sem); +} + + +/* + * init, shutdown + */ +void ceph_osdc_init(struct ceph_osd_client *osdc, struct ceph_client *client) +{ + dout(5, "init\n"); + osdc->client = client; + osdc->osdmap = NULL; + init_rwsem(&osdc->map_sem); + init_completion(&osdc->map_waiters); + osdc->last_requested_map = 0; + mutex_init(&osdc->request_mutex); + osdc->last_tid = 0; + INIT_RADIX_TREE(&osdc->request_tree, GFP_NOFS); + osdc->num_requests = 0; + INIT_DELAYED_WORK(&osdc->timeout_work, handle_timeout); +} + +void ceph_osdc_stop(struct ceph_osd_client *osdc) +{ + cancel_delayed_work_sync(&osdc->timeout_work); + if (osdc->osdmap) { + osdmap_destroy(osdc->osdmap); + osdc->osdmap = NULL; + } +} + + + +/* + * synchronous read direct to user buffer. + * + * if read spans object boundary, just do two separate reads. + * + * FIXME: for a correct atomic read, we should take read locks on all + * objects. + */ +int ceph_osdc_sync_read(struct ceph_osd_client *osdc, struct ceph_vino vino, + struct ceph_file_layout *layout, + u64 off, u64 len, + char __user *data) +{ + struct ceph_osd_request *req; + int i, po, left, l; + int rc; + int finalrc = 0; + + dout(10, "sync_read on vino %llx.%llx at %llu~%llu\n", vino.ino, + vino.snap, off, len); + +more: + req = ceph_osdc_new_request(osdc, layout, vino, off, &len, + CEPH_OSD_OP_READ, NULL); + if (IS_ERR(req)) + return PTR_ERR(req); + + dout(10, "sync_read %llu~%llu -> %d pages\n", off, len, + req->r_num_pages); + + /* allocate temp pages to hold data */ + for (i = 0; i < req->r_num_pages; i++) { + req->r_pages[i] = alloc_page(GFP_NOFS); + if (req->r_pages[i] == NULL) { + req->r_num_pages = i+1; + ceph_osdc_put_request(req); + return -ENOMEM; + } + } + + rc = do_sync_request(osdc, req); + if (rc > 0) { + /* copy into user buffer */ + po = off & ~PAGE_CACHE_MASK; + left = rc; + i = 0; + while (left > 0) { + int bad; + l = min_t(int, left, PAGE_CACHE_SIZE-po); + bad = copy_to_user(data, + page_address(req->r_pages[i]) + po, + l); + if (bad == l) { + rc = -EFAULT; + goto out; + } + data += l - bad; + left -= l - bad; + if (po) { + po += l - bad; + if (po == PAGE_CACHE_SIZE) + po = 0; + } + i++; + } + } +out: + ceph_osdc_put_request(req); + if (rc > 0) { + finalrc += rc; + off += rc; + len -= rc; + if (len > 0) + goto more; + } else { + finalrc = rc; + } + dout(10, "sync_read result %d\n", finalrc); + return finalrc; +} + +/* + * read a single page. + */ +int ceph_osdc_readpage(struct ceph_osd_client *osdc, struct ceph_vino vino, + struct ceph_file_layout *layout, + u64 off, u64 len, + struct page *page) +{ + struct ceph_osd_request *req; + int rc; + + dout(10, "readpage on ino %llx.%llx at %lld~%lld\n", vino.ino, + vino.snap, off, len); + req = ceph_osdc_new_request(osdc, layout, vino, off, &len, + CEPH_OSD_OP_READ, NULL); + if (IS_ERR(req)) + return PTR_ERR(req); + BUG_ON(len != PAGE_CACHE_SIZE); + + req->r_pages[0] = page; + rc = do_sync_request(osdc, req); + ceph_osdc_put_request(req); + + dout(10, "readpage result %d\n", rc); + if (rc == -ENOENT) + rc = 0; /* object page dne; caller will zero it */ + return rc; +} + +/* + * read some contiguous pages from page_list. + * - we stop if pages aren't contiguous, or when we hit an object boundary + */ +int ceph_osdc_readpages(struct ceph_osd_client *osdc, + struct address_space *mapping, + struct ceph_vino vino, struct ceph_file_layout *layout, + u64 off, u64 len, + struct list_head *page_list, int num_pages) +{ + struct ceph_osd_request *req; + struct ceph_osd_request_head *reqhead; + struct ceph_osd_op *op; + struct page *page; + pgoff_t next_index; + int contig_pages; + int rc = 0; + + /* + * for now, our strategy is simple: start with the + * initial page, and fetch as much of that object as + * we can that falls within the range specified by + * num_pages. + */ + dout(10, "readpages on ino %llx.%llx on %llu~%llu\n", vino.ino, + vino.snap, off, len); + + /* alloc request, w/ optimistically-sized page vector */ + req = ceph_osdc_new_request(osdc, layout, vino, off, &len, + CEPH_OSD_OP_READ, NULL); + if (IS_ERR(req)) + return PTR_ERR(req); + + /* find adjacent pages */ + next_index = list_entry(page_list->prev, struct page, lru)->index; + contig_pages = 0; + list_for_each_entry_reverse(page, page_list, lru) { + if (page->index == next_index) { + req->r_pages[contig_pages] = page; + contig_pages++; + next_index++; + } else { + break; + } + } + dout(10, "readpages found %d/%d contig\n", contig_pages, num_pages); + if (contig_pages == 0) + goto out; + len = min((contig_pages << PAGE_CACHE_SHIFT) - (off & ~PAGE_CACHE_MASK), + len); + req->r_num_pages = contig_pages; + reqhead = req->r_request->front.iov_base; + op = (void *)(reqhead + 1); + op->length = cpu_to_le64(len); + dout(10, "readpages final extent is %llu~%llu -> %d pages\n", + off, len, req->r_num_pages); + rc = do_sync_request(osdc, req); + + if (rc == 0) { + /* on success, return bytes read */ + struct ceph_osd_reply_head *head = req->r_reply->front.iov_base; + struct ceph_osd_op *rop = (void *)(head + 1); + rc = le64_to_cpu(rop->length); + } +out: + ceph_osdc_put_request(req); + dout(10, "readpages result %d\n", rc); + return rc; +} + + +/* + * synchronous write. from userspace. + * + * FIXME: if write spans object boundary, just do two separate write. + * for a correct atomic write, we should take write locks on all + * objects, rollback on failure, etc. + */ +int ceph_osdc_sync_write(struct ceph_osd_client *osdc, struct ceph_vino vino, + struct ceph_file_layout *layout, + struct ceph_snap_context *snapc, + u64 off, u64 len, const char __user *data) +{ + struct ceph_msg *reqm; + struct ceph_osd_request_head *reqhead; + struct ceph_osd_request *req; + int i, po, l, left; + int rc; + int finalrc = 0; + + dout(10, "sync_write on ino %llx.%llx at %llu~%llu\n", vino.ino, + vino.snap, off, len); + +more: + req = ceph_osdc_new_request(osdc, layout, vino, off, &len, + CEPH_OSD_OP_WRITE, snapc); + if (IS_ERR(req)) + return PTR_ERR(req); + reqm = req->r_request; + reqhead = reqm->front.iov_base; + reqhead->flags = + cpu_to_le32(CEPH_OSD_OP_ACK | /* ack for now, FIXME */ + CEPH_OSD_OP_ORDERSNAP | /* EOLDSNAPC if ooo */ + CEPH_OSD_OP_MODIFY); + + dout(10, "sync_write %llu~%llu -> %d pages\n", off, len, + req->r_num_pages); + + /* copy data into a set of pages */ + left = len; + po = off & ~PAGE_MASK; + for (i = 0; i < req->r_num_pages; i++) { + int bad; + req->r_pages[i] = alloc_page(GFP_NOFS); + if (req->r_pages[i] == NULL) { + req->r_num_pages = i+1; + rc = -ENOMEM; + goto out; + } + l = min_t(int, PAGE_SIZE-po, left); + bad = copy_from_user(page_address(req->r_pages[i]) + po, data, + l); + if (bad == l) { + req->r_num_pages = i+1; + rc = -EFAULT; + goto out; + } + data += l - bad; + left -= l - bad; + if (po) { + po += l - bad; + if (po == PAGE_CACHE_SIZE) + po = 0; + } + } + reqm->pages = req->r_pages; + reqm->nr_pages = req->r_num_pages; + reqm->hdr.data_len = cpu_to_le32(len); + reqm->hdr.data_off = cpu_to_le32(off); + + rc = do_sync_request(osdc, req); +out: + for (i = 0; i < req->r_num_pages; i++) + __free_pages(req->r_pages[i], 0); + ceph_osdc_put_request(req); + if (rc == 0) { + finalrc += len; + off += len; + len -= len; + if (len > 0) + goto more; + } else { + finalrc = rc; + } + dout(10, "sync_write result %d\n", finalrc); + return finalrc; +} + +/* + * do a sync write for N pages + */ +int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino, + struct ceph_file_layout *layout, + struct ceph_snap_context *snapc, + u64 off, u64 len, + struct page **pages, int num_pages) +{ + struct ceph_msg *reqm; + struct ceph_osd_request_head *reqhead; + struct ceph_osd_op *op; + struct ceph_osd_request *req; + int rc = 0; + int flags; + + BUG_ON(vino.snap != CEPH_NOSNAP); + + req = ceph_osdc_new_request(osdc, layout, vino, off, &len, + CEPH_OSD_OP_WRITE, snapc); + if (IS_ERR(req)) + return PTR_ERR(req); + reqm = req->r_request; + reqhead = reqm->front.iov_base; + op = (void *)(reqhead + 1); + + flags = CEPH_OSD_OP_MODIFY; + if (osdc->client->mount_args.flags & CEPH_MOUNT_UNSAFE_WRITEBACK) + flags |= CEPH_OSD_OP_ACK; + else + flags |= CEPH_OSD_OP_SAFE; + reqhead->flags = cpu_to_le32(flags); + + len = le64_to_cpu(op->length); + dout(10, "writepages %llu~%llu -> %d pages\n", off, len, + req->r_num_pages); + + /* copy page vector */ + memcpy(req->r_pages, pages, req->r_num_pages * sizeof(struct page *)); + reqm->pages = req->r_pages; + reqm->nr_pages = req->r_num_pages; + reqm->hdr.data_len = cpu_to_le32(len); + reqm->hdr.data_off = cpu_to_le32(off); + + rc = do_sync_request(osdc, req); + ceph_osdc_put_request(req); + if (rc == 0) + rc = len; + dout(10, "writepages result %d\n", rc); + return rc; +} + +/* + * start an async multipage write + */ +int ceph_osdc_writepages_start(struct ceph_osd_client *osdc, + struct ceph_osd_request *req, + u64 len, int num_pages) +{ + struct ceph_msg *reqm = req->r_request; + struct ceph_osd_request_head *reqhead = reqm->front.iov_base; + struct ceph_osd_op *op = (void *)(reqhead + 1); + u64 off = le64_to_cpu(op->offset); + int rc; + int flags; + + dout(10, "writepages_start %llu~%llu, %d pages\n", off, len, num_pages); + + flags = CEPH_OSD_OP_MODIFY; + if (osdc->client->mount_args.flags & CEPH_MOUNT_UNSAFE_WRITEBACK) + flags |= CEPH_OSD_OP_ACK; + else + flags |= CEPH_OSD_OP_SAFE; + reqhead->flags = cpu_to_le32(flags); + op->length = cpu_to_le64(len); + + /* reference pages in message */ + reqm->pages = req->r_pages; + reqm->nr_pages = req->r_num_pages = num_pages; + reqm->hdr.data_len = cpu_to_le32(len); + reqm->hdr.data_off = cpu_to_le32(off); + + rc = start_request(osdc, req); + return rc; +} + diff --git a/fs/ceph/osd_client.h b/fs/ceph/osd_client.h new file mode 100644 index 0000000..a01de8e --- /dev/null +++ b/fs/ceph/osd_client.h @@ -0,0 +1,135 @@ +#ifndef _FS_CEPH_OSD_CLIENT_H +#define _FS_CEPH_OSD_CLIENT_H + +#include <linux/radix-tree.h> +#include <linux/completion.h> + +#include "types.h" +#include "osdmap.h" + +/* + * All data objects are stored within a cluster/cloud of OSDs, or + * "object storage devices." (Note that Ceph OSDs have _nothing_ to + * do with the T10 OSD extensions to SCSI.) Ceph OSDs are simply + * remote daemons serving up and coordinating consistent and safe + * access to storage. + * + * Cluster membership and the mapping of data objects onto storage devices + * are described by the osd map. + * + * We keep track of pending OSD requests (read, write), resubmit + * requests to different OSDs when the cluster topology/data layout + * change, or retry the affected requests when the communications + * channel with an OSD is reset. + */ + +struct ceph_msg; +struct ceph_snap_context; +struct ceph_osd_request; + +/* + * completion callback for async writepages + */ +typedef void (*ceph_osdc_callback_t)(struct ceph_osd_request *); + +/* an in-flight request */ +struct ceph_osd_request { + u64 r_tid; /* unique for this client */ + struct ceph_msg *r_request; + struct ceph_msg *r_reply; + int r_result; + int r_flags; /* any additional flags for the osd */ + int r_aborted; /* set if we cancel this request */ + + atomic_t r_ref; + struct completion r_completion; /* on completion, or... */ + ceph_osdc_callback_t r_callback; /* ...async callback. */ + struct inode *r_inode; /* needed for async write */ + struct writeback_control *r_wbc; + + int r_last_osd; /* last osd we sent request to */ + struct ceph_entity_addr r_last_osd_addr; + unsigned long r_last_stamp; + + union ceph_pg r_pgid; /* placement group */ + struct ceph_snap_context *r_snapc; /* snap context for writes */ + unsigned r_num_pages; /* size of page array (follows) */ + struct page *r_pages[0]; /* pages for data payload */ +}; + +struct ceph_osd_client { + struct ceph_client *client; + + struct ceph_osdmap *osdmap; /* current map */ + struct rw_semaphore map_sem; + struct completion map_waiters; + u64 last_requested_map; + + struct mutex request_mutex; + u64 timeout_tid; /* tid of timeout triggering rq */ + u64 last_tid; /* tid of last request */ + struct radix_tree_root request_tree; /* pending requests, by tid */ + int num_requests; + struct delayed_work timeout_work; +}; + +extern void ceph_osdc_init(struct ceph_osd_client *osdc, + struct ceph_client *client); +extern void ceph_osdc_stop(struct ceph_osd_client *osdc); + +extern void ceph_osdc_handle_reset(struct ceph_osd_client *osdc, + struct ceph_entity_addr *addr); + +extern void ceph_osdc_handle_reply(struct ceph_osd_client *osdc, + struct ceph_msg *msg); +extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc, + struct ceph_msg *msg); + +/* incoming read messages use this to discover which pages to read + * the data payload into. */ +extern int ceph_osdc_prepare_pages(void *p, struct ceph_msg *m, int want); + +extern struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *, + struct ceph_file_layout *layout, + struct ceph_vino vino, + u64 offset, u64 *len, int op, + struct ceph_snap_context *snapc); +extern void ceph_osdc_put_request(struct ceph_osd_request *req); + +extern int ceph_osdc_readpage(struct ceph_osd_client *osdc, + struct ceph_vino vino, + struct ceph_file_layout *layout, + u64 off, u64 len, + struct page *page); +extern int ceph_osdc_readpages(struct ceph_osd_client *osdc, + struct address_space *mapping, + struct ceph_vino vino, + struct ceph_file_layout *layout, + u64 off, u64 len, + struct list_head *page_list, int nr_pages); + +extern int ceph_osdc_writepages(struct ceph_osd_client *osdc, + struct ceph_vino vino, + struct ceph_file_layout *layout, + struct ceph_snap_context *sc, + u64 off, u64 len, + struct page **pagevec, int nr_pages); +extern int ceph_osdc_writepages_start(struct ceph_osd_client *osdc, + struct ceph_osd_request *req, + u64 len, + int nr_pages); + +extern int ceph_osdc_sync_read(struct ceph_osd_client *osdc, + struct ceph_vino vino, + struct ceph_file_layout *layout, + u64 off, u64 len, + char __user *data); +extern int ceph_osdc_sync_write(struct ceph_osd_client *osdc, + struct ceph_vino vino, + struct ceph_file_layout *layout, + struct ceph_snap_context *sc, + u64 off, u64 len, + const char __user *data); + +#endif + diff --git a/fs/ceph/osdmap.c b/fs/ceph/osdmap.c new file mode 100644 index 0000000..e61f4ce --- /dev/null +++ b/fs/ceph/osdmap.c @@ -0,0 +1,664 @@ + +#include <asm/div64.h> + +#include "super.h" +#include "osdmap.h" +#include "crush/hash.h" +#include "decode.h" + +#include "ceph_debug.h" + +int ceph_debug_osdmap = -1; +#define DOUT_MASK DOUT_MASK_OSDMAP +#define DOUT_VAR ceph_debug_osdmap +#define DOUT_PREFIX "osdmap: " + +/* maps */ + +static int calc_bits_of(unsigned t) +{ + int b = 0; + while (t) { + t = t >> 1; + b++; + } + return b; +} + +/* + * the foo_mask is the smallest value 2^n-1 that is >= foo. + */ +static void calc_pg_masks(struct ceph_osdmap *map) +{ + map->pg_num_mask = (1 << calc_bits_of(map->pg_num-1)) - 1; + map->pgp_num_mask = (1 << calc_bits_of(map->pgp_num-1)) - 1; + map->lpg_num_mask = (1 << calc_bits_of(map->lpg_num-1)) - 1; + map->lpgp_num_mask = (1 << calc_bits_of(map->lpgp_num-1)) - 1; +} + +/* + * decode crush map + */ +static int crush_decode_uniform_bucket(void **p, void *end, + struct crush_bucket_uniform *b) +{ + int j; + dout(30, "crush_decode_uniform_bucket %p to %p\n", *p, end); + b->primes = kmalloc(b->h.size * sizeof(u32), GFP_NOFS); + if (b->primes == NULL) + return -ENOMEM; + ceph_decode_need(p, end, (1+b->h.size) * sizeof(u32), bad); + for (j = 0; j < b->h.size; j++) + ceph_decode_32(p, b->primes[j]); + ceph_decode_32(p, b->item_weight); + return 0; +bad: + return -EINVAL; +} + +static int crush_decode_list_bucket(void **p, void *end, + struct crush_bucket_list *b) +{ + int j; + dout(30, "crush_decode_list_bucket %p to %p\n", *p, end); + b->item_weights = kmalloc(b->h.size * sizeof(u32), GFP_NOFS); + if (b->item_weights == NULL) + return -ENOMEM; + b->sum_weights = kmalloc(b->h.size * sizeof(u32), GFP_NOFS); + if (b->sum_weights == NULL) + return -ENOMEM; + ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); + for (j = 0; j < b->h.size; j++) { + ceph_decode_32(p, b->item_weights[j]); + ceph_decode_32(p, b->sum_weights[j]); + } + return 0; +bad: + return -EINVAL; +} + +static int crush_decode_tree_bucket(void **p, void *end, + struct crush_bucket_tree *b) +{ + int j; + dout(30, "crush_decode_tree_bucket %p to %p\n", *p, end); + b->node_weights = kmalloc(b->h.size * sizeof(u32), GFP_NOFS); + if (b->node_weights == NULL) + return -ENOMEM; + ceph_decode_need(p, end, b->h.size * sizeof(u32), bad); + for (j = 0; j < b->h.size; j++) + ceph_decode_32(p, b->node_weights[j]); + return 0; +bad: + return -EINVAL; +} + +static int crush_decode_straw_bucket(void **p, void *end, + struct crush_bucket_straw *b) +{ + int j; + dout(30, "crush_decode_straw_bucket %p to %p\n", *p, end); + b->straws = kmalloc(b->h.size * sizeof(u32), GFP_NOFS); + if (b->straws == NULL) + return -ENOMEM; + ceph_decode_need(p, end, 2 * b->h.size * sizeof(u32), bad); + for (j = 0; j < b->h.size; j++) { + ceph_decode_32(p, b->item_weights[j]); + ceph_decode_32(p, b->straws[j]); + } + return 0; +bad: + return -EINVAL; +} + +static struct crush_map *crush_decode(void *pbyval, void *end) +{ + struct crush_map *c; + int err = -EINVAL; + int i, j; + void **p = &pbyval; + void *start = pbyval; + + dout(30, "crush_decode %p to %p len %d\n", *p, end, (int)(end - *p)); + + c = kzalloc(sizeof(*c), GFP_NOFS); + if (c == NULL) + return ERR_PTR(-ENOMEM); + + ceph_decode_need(p, end, 3*sizeof(u32), bad); + ceph_decode_32(p, c->max_buckets); + ceph_decode_32(p, c->max_rules); + ceph_decode_32(p, c->max_devices); + + c->device_parents = kmalloc(c->max_devices * sizeof(u32), GFP_NOFS); + if (c->device_parents == NULL) + goto badmem; + c->bucket_parents = kmalloc(c->max_buckets * sizeof(u32), GFP_NOFS); + if (c->bucket_parents == NULL) + goto badmem; + + c->buckets = kmalloc(c->max_buckets * sizeof(*c->buckets), GFP_NOFS); + if (c->buckets == NULL) + goto badmem; + c->rules = kmalloc(c->max_rules * sizeof(*c->rules), GFP_NOFS); + if (c->rules == NULL) + goto badmem; + + /* buckets */ + for (i = 0; i < c->max_buckets; i++) { + int size = 0; + u32 type; + struct crush_bucket *b; + + dout(30, "crush_decode bucket %d off %x %p to %p\n", + i, (int)(*p-start), *p, end); + + ceph_decode_32_safe(p, end, type, bad); + if (type == 0) { + c->buckets[i] = NULL; + continue; + } + + switch (type) { + case CRUSH_BUCKET_UNIFORM: + size = sizeof(struct crush_bucket_uniform); + break; + case CRUSH_BUCKET_LIST: + size = sizeof(struct crush_bucket_list); + break; + case CRUSH_BUCKET_TREE: + size = sizeof(struct crush_bucket_tree); + break; + case CRUSH_BUCKET_STRAW: + size = sizeof(struct crush_bucket_straw); + break; + default: + goto bad; + } + BUG_ON(size == 0); + b = c->buckets[i] = kzalloc(size, GFP_NOFS); + if (b == NULL) + goto badmem; + + ceph_decode_need(p, end, 4*sizeof(u32), bad); + ceph_decode_32(p, b->id); + ceph_decode_16(p, b->type); + ceph_decode_16(p, b->alg); + ceph_decode_32(p, b->weight); + ceph_decode_32(p, b->size); + + dout(30, "crush_decode bucket size %d off %x %p to %p\n", + b->size, (int)(*p-start), *p, end); + + b->items = kmalloc(b->size * sizeof(__s32), GFP_NOFS); + if (b->items == NULL) + goto badmem; + + ceph_decode_need(p, end, b->size*sizeof(u32), bad); + for (j = 0; j < b->size; j++) + ceph_decode_32(p, b->items[j]); + + switch (b->type) { + case CRUSH_BUCKET_UNIFORM: + err = crush_decode_uniform_bucket(p, end, + (struct crush_bucket_uniform *)b); + if (err < 0) + goto bad; + break; + case CRUSH_BUCKET_LIST: + err = crush_decode_list_bucket(p, end, + (struct crush_bucket_list *)b); + if (err < 0) + goto bad; + break; + case CRUSH_BUCKET_TREE: + err = crush_decode_tree_bucket(p, end, + (struct crush_bucket_tree *)b); + if (err < 0) + goto bad; + break; + case CRUSH_BUCKET_STRAW: + err = crush_decode_straw_bucket(p, end, + (struct crush_bucket_straw *)b); + if (err < 0) + goto bad; + break; + } + } + + /* rules */ + dout(30, "rule vec is %p\n", c->rules); + for (i = 0; i < c->max_rules; i++) { + u32 yes; + struct crush_rule *r; + + ceph_decode_32_safe(p, end, yes, bad); + if (!yes) { + dout(30, "crush_decode NO rule %d off %x %p to %p\n", + i, (int)(*p-start), *p, end); + c->rules[i] = NULL; + continue; + } + + dout(30, "crush_decode rule %d off %x %p to %p\n", + i, (int)(*p-start), *p, end); + + /* len */ + ceph_decode_32_safe(p, end, yes, bad); + + r = c->rules[i] = kmalloc(sizeof(*r) + + yes*sizeof(struct crush_rule_step), + GFP_NOFS); + if (r == NULL) + goto badmem; + dout(30, " rule %d is at %p\n", i, r); + r->len = yes; + ceph_decode_copy_safe(p, end, &r->mask, 4, bad); /* 4 u8's */ + ceph_decode_need(p, end, r->len*3*sizeof(u32), bad); + for (j = 0; j < r->len; j++) { + ceph_decode_32(p, r->steps[j].op); + ceph_decode_32(p, r->steps[j].arg1); + ceph_decode_32(p, r->steps[j].arg2); + } + } + + /* ignore trailing name maps. */ + + dout(30, "crush_decode success\n"); + return c; + +badmem: + err = -ENOMEM; +bad: + dout(30, "crush_decode fail %d\n", err); + crush_destroy(c); + return ERR_PTR(err); +} + + +/* + * osd map + */ +void osdmap_destroy(struct ceph_osdmap *map) +{ + dout(10, "osdmap_destroy %p\n", map); + if (map->crush) + crush_destroy(map->crush); + kfree(map->osd_state); + kfree(map->osd_weight); + kfree(map->osd_addr); + kfree(map); +} + +/* + * adjust max osd value. reallocate arrays. + */ +static int osdmap_set_max_osd(struct ceph_osdmap *map, int max) +{ + u8 *state; + struct ceph_entity_addr *addr; + u32 *weight; + + state = kzalloc(max * sizeof(*state), GFP_NOFS); + addr = kzalloc(max * sizeof(*addr), GFP_NOFS); + weight = kzalloc(max * sizeof(*weight), GFP_NOFS); + if (state == NULL || addr == NULL || weight == NULL) { + kfree(state); + kfree(addr); + kfree(weight); + return -ENOMEM; + } + + /* copy old? */ + if (map->osd_state) { + memcpy(state, map->osd_state, map->max_osd*sizeof(*state)); + memcpy(addr, map->osd_addr, map->max_osd*sizeof(*addr)); + memcpy(weight, map->osd_weight, map->max_osd*sizeof(*weight)); + kfree(map->osd_state); + kfree(map->osd_addr); + kfree(map->osd_weight); + } + + map->osd_state = state; + map->osd_weight = weight; + map->osd_addr = addr; + map->max_osd = max; + return 0; +} + +/* + * decode a full map. + */ +struct ceph_osdmap *osdmap_decode(void **p, void *end) +{ + struct ceph_osdmap *map; + u32 len, max, i; + int err = -EINVAL; + void *start = *p; + + dout(30, "osdmap_decode %p to %p len %d\n", *p, end, (int)(end - *p)); + + map = kzalloc(sizeof(*map), GFP_NOFS); + if (map == NULL) + return ERR_PTR(-ENOMEM); + + ceph_decode_need(p, end, 2*sizeof(u64)+11*sizeof(u32), bad); + ceph_decode_64_le(p, map->fsid.major); + ceph_decode_64_le(p, map->fsid.minor); + ceph_decode_32(p, map->epoch); + ceph_decode_32_le(p, map->ctime.tv_sec); + ceph_decode_32_le(p, map->ctime.tv_nsec); + ceph_decode_32_le(p, map->mtime.tv_sec); + ceph_decode_32_le(p, map->mtime.tv_nsec); + ceph_decode_32(p, map->pg_num); + ceph_decode_32(p, map->pgp_num); + ceph_decode_32(p, map->lpg_num); + ceph_decode_32(p, map->lpgp_num); + ceph_decode_32(p, map->last_pg_change); + ceph_decode_32(p, map->flags); + + calc_pg_masks(map); + + ceph_decode_32(p, max); + + /* (re)alloc osd arrays */ + err = osdmap_set_max_osd(map, max); + if (err < 0) + goto bad; + dout(30, "osdmap_decode max_osd = %d\n", map->max_osd); + + /* osds */ + err = -EINVAL; + ceph_decode_need(p, end, 3*sizeof(u32) + + map->max_osd*(1 + sizeof(*map->osd_weight) + + sizeof(*map->osd_addr)), bad); + *p += 4; /* skip length field (should match max) */ + ceph_decode_copy(p, map->osd_state, map->max_osd); + + *p += 4; /* skip length field (should match max) */ + for (i = 0; i < map->max_osd; i++) + ceph_decode_32(p, map->osd_weight[i]); + + *p += 4; /* skip length field (should match max) */ + ceph_decode_copy(p, map->osd_addr, map->max_osd*sizeof(*map->osd_addr)); + + *p += sizeof(u32) + map->max_osd * sizeof(u32); /* osd_up_from */ + *p += sizeof(u32) + map->max_osd * sizeof(u32); /* osd_up_thru */ + + /* ignore pg primary swapping */ + ceph_decode_32_safe(p, end, len, bad); + p += len * (sizeof(u64) + sizeof(u32)); + if (len) + derr(0, "WARNING: pg primary swaps in osdmap e%d unsupported\n", + map->epoch); + + /* ignore max_snap, removed_snaps */ + *p += sizeof(u64); + ceph_decode_32_safe(p, end, len, bad); + *p += len * 2 * sizeof(u64); + + /* crush */ + ceph_decode_32_safe(p, end, len, bad); + dout(30, "osdmap_decode crush len %d from off 0x%x\n", len, + (int)(*p - start)); + ceph_decode_need(p, end, len, bad); + map->crush = crush_decode(*p, end); + *p += len; + if (IS_ERR(map->crush)) { + err = PTR_ERR(map->crush); + map->crush = NULL; + goto bad; + } + + dout(30, "osdmap_decode done %p %p\n", *p, end); + if (*p != end) + goto bad; + return map; + +bad: + dout(30, "osdmap_decode fail\n"); + osdmap_destroy(map); + return ERR_PTR(err); +} + +/* + * decode and apply an incremental map update. + */ +struct ceph_osdmap *apply_incremental(void **p, void *end, + struct ceph_osdmap *map, + struct ceph_messenger *msgr) +{ + struct ceph_osdmap *newmap = map; + struct crush_map *newcrush = NULL; + struct ceph_fsid fsid; + u32 epoch = 0; + struct ceph_timespec ctime; + u32 len, x; + __s32 new_flags, max; + void *start = *p; + int err = -EINVAL; + + ceph_decode_need(p, end, sizeof(fsid)+sizeof(ctime)+2*sizeof(u32), + bad); + ceph_decode_64_le(p, fsid.major); + ceph_decode_64_le(p, fsid.minor); + ceph_decode_32(p, epoch); + BUG_ON(epoch != map->epoch+1); + ceph_decode_32_le(p, ctime.tv_sec); + ceph_decode_32_le(p, ctime.tv_nsec); + ceph_decode_32(p, new_flags); + + /* full map? */ + ceph_decode_32_safe(p, end, len, bad); + if (len > 0) { + dout(20, "apply_incremental full map len %d, %p to %p\n", + len, *p, end); + newmap = osdmap_decode(p, min(*p+len, end)); + return newmap; /* error or not */ + } + + /* new crush? */ + ceph_decode_32_safe(p, end, len, bad); + if (len > 0) { + dout(20, "apply_incremental new crush map len %d, %p to %p\n", + len, *p, end); + newcrush = crush_decode(*p, min(*p+len, end)); + if (IS_ERR(newcrush)) + return ERR_PTR(PTR_ERR(newcrush)); + } + + /* new flags? */ + if (new_flags >= 0) + map->flags = new_flags; + + ceph_decode_need(p, end, 5*sizeof(u32), bad); + + /* new max? */ + ceph_decode_32(p, max); + if (max >= 0) { + err = osdmap_set_max_osd(map, max); + if (err < 0) + goto bad; + } + ceph_decode_32(p, x); + if (x) + map->pg_num = x; + ceph_decode_32(p, x); + if (x) + map->pgp_num = x; + ceph_decode_32(p, x); + if (x) + map->lpg_num = x; + ceph_decode_32(p, x); + if (x) + map->lpgp_num = x; + + map->epoch++; + map->ctime = map->ctime; + if (newcrush) { + if (map->crush) + crush_destroy(map->crush); + map->crush = newcrush; + newcrush = NULL; + } + + /* new_up */ + err = -EINVAL; + ceph_decode_32_safe(p, end, len, bad); + while (len--) { + u32 osd; + struct ceph_entity_addr addr; + ceph_decode_32_safe(p, end, osd, bad); + ceph_decode_copy_safe(p, end, &addr, sizeof(addr), bad); + dout(1, "osd%d up\n", osd); + BUG_ON(osd >= map->max_osd); + map->osd_state[osd] |= CEPH_OSD_UP; + map->osd_addr[osd] = addr; + } + + /* new_down */ + ceph_decode_32_safe(p, end, len, bad); + while (len--) { + u32 osd; + ceph_decode_32_safe(p, end, osd, bad); + (*p)++; /* clean flag */ + dout(1, "osd%d down\n", osd); + if (osd < map->max_osd) { + map->osd_state[osd] &= ~CEPH_OSD_UP; + ceph_messenger_mark_down(msgr, &map->osd_addr[osd]); + } + } + + /* new_weight */ + ceph_decode_32_safe(p, end, len, bad); + while (len--) { + u32 osd, off; + ceph_decode_need(p, end, sizeof(u32)*2, bad); + ceph_decode_32(p, osd); + ceph_decode_32(p, off); + dout(1, "osd%d weight 0x%x %s\n", osd, off, + off == CEPH_OSD_IN ? "(in)" : + (off == CEPH_OSD_OUT ? "(out)" : "")); + if (osd < map->max_osd) + map->osd_weight[osd] = off; + } + + /* skip new_up_thru */ + ceph_decode_32_safe(p, end, len, bad); + *p += len * 2 * sizeof(u32); + + /* skip old/new pg_swap stuff */ + ceph_decode_32_safe(p, end, len, bad); + *p += len * (sizeof(u64) + sizeof(u32)); + if (len) + derr(0, "WARNING: pg primary swaps in osdmap e%d unsupported\n", + epoch); + ceph_decode_32_safe(p, end, len, bad); + *p += len * sizeof(u64); + if (len) + derr(0, "WARNING: pg primary swaps in osdmap e%d unsupported\n", + epoch); + + /* skip new_max_snap, removed_snaps */ + *p += sizeof(u64); + ceph_decode_32_safe(p, end, len, bad); + *p += len * 2 * sizeof(u64); + + if (*p != end) { + derr(10, "osdmap incremental has trailing gunk?\n"); + goto bad; + } + return map; + +bad: + derr(10, "corrupt incremental osdmap epoch %d off %d (%p of %p-%p)\n", + epoch, (int)(*p - start), *p, start, end); + if (newcrush) + crush_destroy(newcrush); + return ERR_PTR(err); +} + + + + +/* + * calculate file layout from given offset, length. + * fill in correct oid, logical length, and object extent + * offset, length. + * + * for now, we write only a single su, until we can + * pass a stride back to the caller. + */ +void calc_file_object_mapping(struct ceph_file_layout *layout, + u64 off, u64 *plen, + struct ceph_object *oid, + u64 *oxoff, u64 *oxlen) +{ + u32 osize = le32_to_cpu(layout->fl_object_size); + u32 su = le32_to_cpu(layout->fl_stripe_unit); + u32 sc = le32_to_cpu(layout->fl_stripe_count); + u32 bl, stripeno, stripepos, objsetno; + u32 su_per_object; + u64 t; + + dout(80, "mapping %llu~%llu osize %u fl_su %u\n", off, *plen, + osize, su); + su_per_object = osize / le32_to_cpu(layout->fl_stripe_unit); + dout(80, "osize %u / su %u = su_per_object %u\n", osize, su, + su_per_object); + + BUG_ON((su & ~PAGE_MASK) != 0); + /* bl = *off / su; */ + t = off; + do_div(t, su); + bl = t; + dout(80, "off %llu / su %u = bl %u\n", off, su, bl); + + stripeno = bl / sc; + stripepos = bl % sc; + objsetno = stripeno / su_per_object; + + oid->bno = cpu_to_le32(objsetno * sc + stripepos); + dout(80, "objset %u * sc %u = bno %u\n", objsetno, sc, oid->bno); + /* *oxoff = *off / layout->fl_stripe_unit; */ + t = off; + *oxoff = do_div(t, su); + *oxlen = min_t(u64, *plen, su - *oxoff); + *plen = *oxlen; + + dout(80, " obj extent %llu~%llu\n", *oxoff, *oxlen); +} + +/* + * calculate an object layout (i.e. pgid) from an oid, + * file_layout, and osdmap + */ +void calc_object_layout(struct ceph_object_layout *ol, + struct ceph_object *oid, + struct ceph_file_layout *fl, + struct ceph_osdmap *osdmap) +{ + unsigned num, num_mask; + union ceph_pg pgid; + u64 ino = le64_to_cpu(oid->ino); + unsigned bno = le32_to_cpu(oid->bno); + s32 preferred = (s32)le32_to_cpu(fl->fl_pg_preferred); + + if (preferred >= 0) { + num = osdmap->lpg_num; + num_mask = osdmap->lpg_num_mask; + } else { + num = osdmap->pg_num; + num_mask = osdmap->pg_num_mask; + } + + pgid.pg64 = 0; /* start with it zeroed out */ + pgid.pg.ps = bno + crush_hash32_2(ino, ino>>32); + pgid.pg.preferred = preferred; + pgid.pg.type = fl->fl_pg_type; + pgid.pg.size = fl->fl_pg_size; + pgid.pg.pool = fl->fl_pg_pool; + + ol->ol_pgid = cpu_to_le64(pgid.pg64); + ol->ol_stripe_unit = fl->fl_object_stripe_unit; +} diff --git a/fs/ceph/osdmap.h b/fs/ceph/osdmap.h new file mode 100644 index 0000000..000550b --- /dev/null +++ b/fs/ceph/osdmap.h @@ -0,0 +1,82 @@ +#ifndef _FS_CEPH_OSDMAP_H +#define _FS_CEPH_OSDMAP_H + +#include "types.h" +#include "crush/crush.h" + +/* + * The osd map describes the current membership of the osd cluster and + * specifies the mapping of objects to placement groups and placement + * groups to (sets of) osds. That is, it completely specifies the + * (desired) distribution of all data objects in the system at some + * point in time. + * + * Each map version is identified by an epoch, which increases monotonically. + * + * The map can be updated either via an incremental map (diff) describing + * the change between two successive epochs, or as a fully encoded map. + */ +struct ceph_osdmap { + struct ceph_fsid fsid; + u32 epoch; + u32 mkfs_epoch; + struct ceph_timespec ctime, mtime; + + /* these parameters describe the number of placement groups + * in the system. foo_mask is the smallest value (2**n-1) >= foo. */ + u32 pg_num, pg_num_mask; + u32 pgp_num, pgp_num_mask; + u32 lpg_num, lpg_num_mask; + u32 lpgp_num, lpgp_num_mask; + u32 last_pg_change; /* epoch of last pg count change */ + + u32 flags; /* CEPH_OSDMAP_* */ + + u32 max_osd; /* size of osd_state, _offload, _addr arrays */ + u8 *osd_state; /* CEPH_OSD_* */ + u32 *osd_offload; /* 0 = normal, 0x10000 = 100% offload (failed) */ + u32 *osd_weight; + struct ceph_entity_addr *osd_addr; + + /* the CRUSH map specifies the mapping of placement groups to + * the list of osds that store+replicate them. */ + struct crush_map *crush; +}; + +static inline int ceph_osd_is_up(struct ceph_osdmap *map, int osd) +{ + return (osd < map->max_osd) && (map->osd_state[osd] & CEPH_OSD_UP); +} + +static inline bool ceph_osdmap_flag(struct ceph_osdmap *map, int flag) +{ + return map && (map->flags & flag); +} + +static inline struct ceph_entity_addr *ceph_osd_addr(struct ceph_osdmap *map, + int osd) +{ + if (osd >= map->max_osd) + return 0; + return &map->osd_addr[osd]; +} + +extern struct ceph_osdmap *osdmap_decode(void **p, void *end); +extern struct ceph_osdmap *apply_incremental(void **p, void *end, + struct ceph_osdmap *map, + struct ceph_messenger *msgr); +extern void osdmap_destroy(struct ceph_osdmap *map); + +/* calculate mapping of a file extent to an object */ +extern void calc_file_object_mapping(struct ceph_file_layout *layout, + u64 off, u64 *plen, + struct ceph_object *oid, + u64 *oxoff, u64 *oxlen); + +/* calculate mapping of object to a placement group */ +extern void calc_object_layout(struct ceph_object_layout *ol, + struct ceph_object *oid, + struct ceph_file_layout *fl, + struct ceph_osdmap *osdmap); + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 11/19] ceph: CRUSH mapping algorithm 2008-11-14 0:56 ` [PATCH 10/19] ceph: OSD client Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 12/19] ceph: monitor client Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil CRUSH is a fancy hash function designed to map inputs onto a dynamic hierarchy of devices while minimizing the extent to which inputs are remapped when the devices are added or removed. It includes some features that are specifically useful for storage, most notably the ability to map each input onto a set of N devices that are separated across administrator-defined failure domains. CRUSH is used to distribute data across the cluster of Ceph storage nodes. More information about CRUSH can be found in this paper: http://www.ssrc.ucsc.edu/Papers/weil-sc06.pdf Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/crush/crush.c | 139 +++++++++++++ fs/ceph/crush/crush.h | 176 +++++++++++++++++ fs/ceph/crush/hash.h | 80 ++++++++ fs/ceph/crush/mapper.c | 507 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/crush/mapper.h | 19 ++ 5 files changed, 921 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/crush/crush.c create mode 100644 fs/ceph/crush/crush.h create mode 100644 fs/ceph/crush/hash.h create mode 100644 fs/ceph/crush/mapper.c create mode 100644 fs/ceph/crush/mapper.h diff --git a/fs/ceph/crush/crush.c b/fs/ceph/crush/crush.c new file mode 100644 index 0000000..e039960 --- /dev/null +++ b/fs/ceph/crush/crush.c @@ -0,0 +1,139 @@ + +#ifdef __KERNEL__ +# include <linux/slab.h> +#include "../ceph_tools.h" +#else +# include <stdlib.h> +# include <assert.h> +# define kfree(x) do { if (x) free(x); } while (0) +# define BUG_ON(x) assert(!(x)) +#endif + +#include "crush.h" + +/** + * crush_get_bucket_item_weight - Get weight of an item in given bucket + * @b: bucket pointer + * @p: item index in bucket + */ +int crush_get_bucket_item_weight(struct crush_bucket *b, int p) +{ + if (p >= b->size) + return 0; + + switch (b->alg) { + case CRUSH_BUCKET_UNIFORM: + return ((struct crush_bucket_uniform*)b)->item_weight; + case CRUSH_BUCKET_LIST: + return ((struct crush_bucket_list*)b)->item_weights[p]; + case CRUSH_BUCKET_TREE: + if (p & 1) + return ((struct crush_bucket_tree*)b)->node_weights[p]; + return 0; + case CRUSH_BUCKET_STRAW: + return ((struct crush_bucket_straw*)b)->item_weights[p]; + } + return 0; +} + +/** + * crush_calc_parents - Calculate parent vectors for the given crush map. + * @map: crush_map pointer + */ +void crush_calc_parents(struct crush_map *map) +{ + int i, b, c; + + for (b = 0; b < map->max_buckets; b++) { + if (map->buckets[b] == NULL) + continue; + for (i = 0; i < map->buckets[b]->size; i++) { + c = map->buckets[b]->items[i]; + BUG_ON(c >= map->max_devices || + c < -map->max_buckets); + if (c >= 0) + map->device_parents[c] = map->buckets[b]->id; + else + map->bucket_parents[-1-c] = map->buckets[b]->id; + } + } +} + +void crush_destroy_bucket_uniform(struct crush_bucket_uniform *b) +{ + kfree(b->primes); + kfree(b->h.items); + kfree(b); +} + +void crush_destroy_bucket_list(struct crush_bucket_list *b) +{ + kfree(b->item_weights); + kfree(b->sum_weights); + kfree(b->h.items); + kfree(b); +} + +void crush_destroy_bucket_tree(struct crush_bucket_tree *b) +{ + kfree(b->node_weights); + kfree(b); +} + +void crush_destroy_bucket_straw(struct crush_bucket_straw *b) +{ + kfree(b->straws); + kfree(b->item_weights); + kfree(b->h.items); + kfree(b); +} + +void crush_destroy_bucket(struct crush_bucket *b) +{ + switch (b->alg) { + case CRUSH_BUCKET_UNIFORM: + crush_destroy_bucket_uniform((struct crush_bucket_uniform *)b); + break; + case CRUSH_BUCKET_LIST: + crush_destroy_bucket_list((struct crush_bucket_list *)b); + break; + case CRUSH_BUCKET_TREE: + crush_destroy_bucket_tree((struct crush_bucket_tree *)b); + break; + case CRUSH_BUCKET_STRAW: + crush_destroy_bucket_straw((struct crush_bucket_straw *)b); + break; + } +} + +/** + * crush_destroy - Destroy a crush_map + * @map: crush_map pointer + */ +void crush_destroy(struct crush_map *map) +{ + int b; + + /* buckets */ + if (map->buckets) { + for (b = 0; b < map->max_buckets; b++) { + if (map->buckets[b] == NULL) + continue; + crush_destroy_bucket(map->buckets[b]); + } + kfree(map->buckets); + } + + /* rules */ + if (map->rules) { + for (b = 0; b < map->max_rules; b++) + kfree(map->rules[b]); + kfree(map->rules); + } + + kfree(map->bucket_parents); + kfree(map->device_parents); + kfree(map); +} + + diff --git a/fs/ceph/crush/crush.h b/fs/ceph/crush/crush.h new file mode 100644 index 0000000..f7aab5e --- /dev/null +++ b/fs/ceph/crush/crush.h @@ -0,0 +1,176 @@ +#ifndef _CRUSH_CRUSH_H +#define _CRUSH_CRUSH_H + +#include <linux/types.h> + +/* + * CRUSH is a pseudo-random data distribution algorithm that + * efficiently distributes input values (typically, data objects) + * across a heterogeneous, structured storage cluster. + * + * The algorithm was originally described in detail in this paper + * (although the algorithm has evolved somewhat since then): + * + * http://www.ssrc.ucsc.edu/Papers/weil-sc06.pdf + * + * LGPL2 + */ + + +#define CRUSH_MAX_DEPTH 10 +#define CRUSH_MAX_SET 10 + + +/* + * CRUSH uses user-defined "rules" to describe how inputs should be + * mapped to devices. A rule consists of sequence of steps to perform + * to generate the set of output devices. + */ +struct crush_rule_step { + __u32 op; + __s32 arg1; + __s32 arg2; +}; + +/* step op codes */ +enum { + CRUSH_RULE_NOOP = 0, + CRUSH_RULE_TAKE = 1, /* arg1 = value to start with */ + CRUSH_RULE_CHOOSE_FIRSTN = 2, /* arg1 = num items to pick */ + /* arg2 = type */ + CRUSH_RULE_CHOOSE_INDEP = 3, /* same */ + CRUSH_RULE_EMIT = 4, /* no args */ + CRUSH_RULE_CHOOSE_LEAF_FIRSTN = 6, + CRUSH_RULE_CHOOSE_LEAF_INDEP = 7, +}; + +/* + * for specifying choose num (arg1) relative to the max parameter + * passed to do_rule + */ +#define CRUSH_CHOOSE_N 0 +#define CRUSH_CHOOSE_N_MINUS(x) (-(x)) + +/* + * The rule mask is used to describe what the rule is intended for. + * Given a storage pool and size of output set, we search through the + * rule list for a matching rule_mask. + */ +struct crush_rule_mask { + __u8 pool; + __u8 type; + __u8 min_size; + __u8 max_size; +}; + +struct crush_rule { + __u32 len; + struct crush_rule_mask mask; + struct crush_rule_step steps[0]; +}; + +#define crush_rule_size(len) (sizeof(struct crush_rule) + \ + (len)*sizeof(struct crush_rule_step)) + + + +/* + * A bucket is a named container of other items (either devices or + * other buckets). Items within a bucket are chosen using one of a + * few different algorithms. The table summarizes how the speed of + * each option measures up against mapping stability when items are + * added or removed. + * + * Bucket Alg Speed Additions Removals + * ------------------------------------------------ + * uniform O(1) poor poor + * list O(n) optimal poor + * tree O(log n) good good + * straw O(n) optimal optimal + */ +enum { + CRUSH_BUCKET_UNIFORM = 1, + CRUSH_BUCKET_LIST = 2, + CRUSH_BUCKET_TREE = 3, + CRUSH_BUCKET_STRAW = 4 +}; +static inline const char *crush_bucket_alg_name(int alg) { + switch (alg) { + case CRUSH_BUCKET_UNIFORM: return "uniform"; + case CRUSH_BUCKET_LIST: return "list"; + case CRUSH_BUCKET_TREE: return "tree"; + case CRUSH_BUCKET_STRAW: return "straw"; + default: return "unknown"; + } +} + +struct crush_bucket { + __s32 id; /* this'll be negative */ + __u16 type; /* non-zero; type=0 is reserved for devices */ + __u16 alg; /* one of CRUSH_BUCKET_* */ + __u32 weight; /* 16-bit fixed point */ + __u32 size; /* num items */ + __s32 *items; +}; + +struct crush_bucket_uniform { + struct crush_bucket h; + __u32 *primes; + __u32 item_weight; /* 16-bit fixed point; all items equally weighted */ +}; + +struct crush_bucket_list { + struct crush_bucket h; + __u32 *item_weights; /* 16-bit fixed point */ + __u32 *sum_weights; /* 16-bit fixed point. element i is sum + of weights 0..i, inclusive */ +}; + +struct crush_bucket_tree { + struct crush_bucket h; /* note: h.size is _tree_ size, not number of + actual items */ + __u32 *node_weights; +}; + +struct crush_bucket_straw { + struct crush_bucket h; + __u32 *item_weights; /* 16-bit fixed point */ + __u32 *straws; /* 16-bit fixed point */ +}; + + + +/* + * CRUSH map includes all buckets, rules, etc. + */ +struct crush_map { + struct crush_bucket **buckets; + struct crush_rule **rules; + + /* + * Parent pointers to identify the parent bucket a device or + * bucket in the hierarchy. If an item appears more than + * once, this is the _last_ time it appeared (where buckets + * are processed in bucket id order, from -1 on down to + * -max_buckets. + */ + __u32 *bucket_parents; + __u32 *device_parents; + + __s32 max_buckets; + __u32 max_rules; + __s32 max_devices; +}; + + +/* crush.c */ +extern int crush_get_bucket_item_weight(struct crush_bucket *b, int pos); +extern void crush_calc_parents(struct crush_map *map); +extern void crush_destroy_bucket_uniform(struct crush_bucket_uniform *b); +extern void crush_destroy_bucket_list(struct crush_bucket_list *b); +extern void crush_destroy_bucket_tree(struct crush_bucket_tree *b); +extern void crush_destroy_bucket_straw(struct crush_bucket_straw *b); +extern void crush_destroy_bucket(struct crush_bucket *b); +extern void crush_destroy(struct crush_map *map); + +#endif diff --git a/fs/ceph/crush/hash.h b/fs/ceph/crush/hash.h new file mode 100644 index 0000000..5baf444 --- /dev/null +++ b/fs/ceph/crush/hash.h @@ -0,0 +1,80 @@ +#ifndef _CRUSH_HASH_H +#define _CRUSH_HASH_H + +// Robert Jenkins' function for mixing 32-bit values +// http://burtleburtle.net/bob/hash/evahash.html +// a, b = random bits, c = input and output +#define hashmix(a,b,c) \ + a=a-b; a=a-c; a=a^(c>>13); \ + b=b-c; b=b-a; b=b^(a<<8); \ + c=c-a; c=c-b; c=c^(b>>13); \ + a=a-b; a=a-c; a=a^(c>>12); \ + b=b-c; b=b-a; b=b^(a<<16); \ + c=c-a; c=c-b; c=c^(b>>5); \ + a=a-b; a=a-c; a=a^(c>>3); \ + b=b-c; b=b-a; b=b^(a<<10); \ + c=c-a; c=c-b; c=c^(b>>15); + +#define crush_hash_seed 1315423911 + +static inline unsigned crush_hash32(unsigned a) { + unsigned hash = crush_hash_seed ^ a; + unsigned b = a; + unsigned x = 231232; + unsigned y = 1232; + hashmix(b, x, hash); + hashmix(y, a, hash); + return (hash & 0xFFFFFFFF); +} + +static inline unsigned crush_hash32_2(unsigned a, unsigned b) { + unsigned hash = crush_hash_seed ^ a ^ b; + unsigned x = 231232; + unsigned y = 1232; + hashmix(a, b, hash); + hashmix(x, a, hash); + hashmix(b, y, hash); + return (hash & 0xFFFFFFFF); +} + +static inline unsigned crush_hash32_3(unsigned a, unsigned b, unsigned c) { + unsigned int hash = crush_hash_seed ^ a ^ b ^ c; + unsigned x = 231232; + unsigned y = 1232; + hashmix(a, b, hash); + hashmix(c, x, hash); + hashmix(y, a, hash); + hashmix(b, x, hash); + hashmix(y, c, hash); + return (hash & 0xFFFFFFFF); +} + +static inline unsigned crush_hash32_4(unsigned a, unsigned b, unsigned c, unsigned d) { + unsigned int hash = crush_hash_seed ^a ^ b ^ c ^ d; + unsigned x = 231232; + unsigned y = 1232; + hashmix(a, b, hash); + hashmix(c, d, hash); + hashmix(a, x, hash); + hashmix(y, b, hash); + hashmix(c, x, hash); + hashmix(y, d, hash); + return (hash & 0xFFFFFFFF); +} + +static inline unsigned crush_hash32_5(unsigned a, unsigned b, unsigned c, unsigned d, unsigned e) { + unsigned int hash = crush_hash_seed ^ a ^ b ^ c ^ d ^ e; + unsigned x = 231232; + unsigned y = 1232; + hashmix(a, b, hash); + hashmix(c, d, hash); + hashmix(e, x, hash); + hashmix(y, a, hash); + hashmix(b, x, hash); + hashmix(y, c, hash); + hashmix(d, x, hash); + hashmix(y, e, hash); + return (hash & 0xFFFFFFFF); +} + +#endif diff --git a/fs/ceph/crush/mapper.c b/fs/ceph/crush/mapper.c new file mode 100644 index 0000000..da9c3b6 --- /dev/null +++ b/fs/ceph/crush/mapper.c @@ -0,0 +1,507 @@ + +#ifdef __KERNEL__ +# include <linux/string.h> +# include <linux/slab.h> +# include <asm/bug.h> +# include <linux/kernel.h> +# ifndef dprintk +# define dprintk(args...) +# endif +#else +# include <string.h> +# include <stdio.h> +# include <assert.h> +# define BUG_ON(x) assert(!(x)) +# define dprintk(args...) /* printf(args) */ +#endif + +#include "crush.h" +#include "hash.h" + + +/** + * crush_find_rule - find a crush_rule id for a given pool, type, and size. + * @map: the crush_map + * @pool: the storage pool id (user defined) + * @type: storage pool type (user defined) + * @size: output set size + */ +int crush_find_rule(struct crush_map *map, int pool, int type, int size) +{ + int i; + + for (i = 0; i < map->max_rules; i++) { + if (map->rules[i] && + map->rules[i]->mask.pool == pool && + map->rules[i]->mask.type == type && + map->rules[i]->mask.min_size <= size && + map->rules[i]->mask.max_size >= size) + return i; + } + return -1; +} + + +/* + * bucket choose methods + * + * For each bucket algorithm, we have a "choose" method that, given a + * crush input @x and replica position (usually, position in output set) @r, + * will produce an item in the bucket. + */ + +/* uniform */ +static int bucket_uniform_choose(struct crush_bucket_uniform *bucket, + int x, int r, int shift) +{ + unsigned o = crush_hash32_2(x, bucket->h.id) & 0xffff; + unsigned p = bucket->primes[crush_hash32_2(bucket->h.id, x) % + bucket->h.size]; + unsigned s = (x + o + (r+1)*p) % bucket->h.size; + /*dprintk("%d %d %d %d\n", x, o, r, p);*/ + if (shift) + s = (s + shift) % bucket->h.size; + return bucket->h.items[s]; +} + +/* list */ +static int bucket_list_choose(struct crush_bucket_list *bucket, + int x, int r, int shift) +{ + int i; + + for (i = bucket->h.size-1; i >= 0; i--) { + __u64 w = crush_hash32_4(x, bucket->h.items[i], r, + bucket->h.id); + w &= 0xffff; + /*dprintk("list_choose i=%d x=%d r=%d item %d weight %x sum_weight %x rand %llx", + i, x, r, bucket->h.items[i], bucket->item_weights[i], bucket->sum_weights[i], w);*/ + w *= bucket->sum_weights[i]; + w = w >> 16; + /*dprintk(" scaled %llx\n", w);*/ + if (w < bucket->item_weights[i]) { + if (shift) + i = (i + shift) % bucket->h.size; + return bucket->h.items[i]; + } + } + + BUG_ON(1); + return 0; +} + + +/* tree */ +static int height(int n) { + int h = 0; + while ((n & 1) == 0) { + h++; + n = n >> 1; + } + return h; +} + +static int left(int x) { + int h = height(x); + return x - (1 << (h-1)); +} + +static int right(int x) { + int h = height(x); + return x + (1 << (h-1)); +} + +static int terminal(int x) { + return x & 1; +} + +static int bucket_tree_choose(struct crush_bucket_tree *bucket, + int x, int r, int shift) +{ + int n, l; + __u32 w; + __u64 t; + + /* start at root */ + n = bucket->h.size >> 1; + + while (!terminal(n)) { + /* pick point in [0, w) */ + w = bucket->node_weights[n]; + t = (__u64)crush_hash32_4(x, n, r, bucket->h.id) * (__u64)w; + t = t >> 32; + + /* descend to the left or right? */ + l = left(n); + if (t < bucket->node_weights[l]) + n = l; + else + n = right(n); + } + + while (shift > 0) { + n = (n + 2) % bucket->h.size; + if (bucket->node_weights[n]) + shift--; + } + + return bucket->h.items[n]; +} + + +/* straw */ + +static int bucket_straw_choose(struct crush_bucket_straw *bucket, + int x, int r, int shift) +{ + int i; + int high = 0; + __u64 high_draw = 0; + __u64 draw; + + for (i = 0; i < bucket->h.size; i++) { + draw = crush_hash32_3(x, bucket->h.items[i], r); + draw &= 0xffff; + draw *= bucket->straws[i]; + if (i == 0 || draw > high_draw) { + high = i; + high_draw = draw; + } + } + if (shift) + high = (high + shift) % bucket->h.size; + return bucket->h.items[high]; +} + +static int crush_bucket_choose(struct crush_bucket *in, int x, int r, int shift) +{ + switch (in->alg) { + case CRUSH_BUCKET_UNIFORM: + return bucket_uniform_choose((struct crush_bucket_uniform *)in, + x, r, shift); + case CRUSH_BUCKET_LIST: + return bucket_list_choose((struct crush_bucket_list *)in, + x, r, shift); + case CRUSH_BUCKET_TREE: + return bucket_tree_choose((struct crush_bucket_tree *)in, + x, r, shift); + case CRUSH_BUCKET_STRAW: + return bucket_straw_choose((struct crush_bucket_straw *)in, + x, r, shift); + default: + BUG_ON(1); + return in->items[0]; + } +} + + +/* + * true if device is marked "out" (failed, fully offloaded) + * of the cluster + */ +static int is_out(struct crush_map *map, __u32 *weight, int item, int x) +{ + if (weight[item] >= 0x1000) + return 0; + if (weight[item] == 0) + return 1; + if ((crush_hash32_2(x, item) & 0xffff) < weight[item]) + return 0; + return 1; +} + +/** + * crush_choose - choose numrep distinct items of given type + * @map: the crush_map + * @bucket: the bucket we are choose an item from + * @x: crush input value + * @numrep: the number of items to choose + * @type: the type of item to choose + * @out: pointer to output vector + * @outpos: our position in that vector + * @firstn: true if choosing "first n" items, false if choosing "indep" + * @recurse_to_leaf: true if we want one device under each item of given type + * @out2: second output vector for leaf items (if @recurse_to_leaf) + */ +static int crush_choose(struct crush_map *map, + struct crush_bucket *bucket, + __u32 *weight, + int x, int numrep, int type, + int *out, int outpos, + int firstn, int recurse_to_leaf, + int *out2) +{ + int rep; + int ftotal, flocal, shift; + int retry_descent, retry_bucket, skip_rep; + struct crush_bucket *in = bucket; + int r; + int i; + int item; + int itemtype; + int collide, reject; + dprintk("choose bucket %d x %d outpos %d\n", bucket->id, x, outpos); + + for (rep = outpos; rep < numrep; rep++) { + /* keep trying until we get a non-out, non-colliding item */ + ftotal = 0; + shift = 0; + skip_rep = 0; + do { + retry_descent = 0; + in = bucket; /* initial bucket */ + + /* choose through intervening buckets */ + flocal = 0; + do { + retry_bucket = 0; + r = rep; + if (in->alg == CRUSH_BUCKET_UNIFORM) { + /* be careful */ + if (firstn || numrep >= in->size) + /* r' = r + f_total */ + r += ftotal - shift; + else if (in->size % numrep == 0) + /* r'=r+(n+1)*f_local */ + r += (numrep+1) * (flocal+ftotal- shift); + else + /* r' = r + n*f_local */ + r += numrep * (flocal+ftotal-shift); + } else { + if (firstn) + /* r' = r + f_total */ + r += ftotal - shift; + else + /* r' = r + n*f_local */ + r += numrep * (flocal+ftotal-shift); + } + + /* bucket choose */ + item = crush_bucket_choose(in, x, r, shift); + BUG_ON(item >= map->max_devices); + + /* desired type? */ + if (item < 0) + itemtype = map->buckets[-1-item]->type; + else + itemtype = 0; + dprintk(" item %d type %d\n", item, itemtype); + + /* keep going? */ + if (itemtype != type) { + BUG_ON(item >= 0 || + (-1-item) >= map->max_buckets); + in = map->buckets[-1-item]; + continue; + } + + /* collision? */ + collide = 0; + for (i = 0; i < outpos; i++) { + if (out[i] == item) { + collide = 1; + break; + } + } + + if (recurse_to_leaf && + crush_choose(map, map->buckets[-1-item], weight, + x, outpos+1, 0, + out2, outpos, + firstn, 0, NULL) <= outpos) { + reject = 1; + } else { + /* out? */ + if (itemtype == 0) + reject = is_out(map, weight, item, x); + else + reject = 0; + } + + if (reject || collide) { + ftotal++; + flocal++; + + if (ftotal > 4) + shift++; + + if (collide && flocal < 3) + /* retry locally a few times */ + retry_bucket = 1; + else if (ftotal < 10) { + /* then retry descent */ + retry_descent = 1; + } else + /* else give up */ + skip_rep = 1; + dprintk(" reject %d collide %d ftotal %d flocal %d shift %d\n", reject, collide, ftotal, flocal, shift); + } + } while (retry_bucket); + } while (retry_descent); + + if (skip_rep) { + dprintk("skip rep\n"); + continue; + } + + dprintk("choose got %d\n", item); + out[outpos] = item; + outpos++; + } + + dprintk("choose returns %d\n", outpos); + return outpos; +} + + +/** + * crush_do_rule - calculate a mapping with the given input and rule + * @map: the crush_map + * @ruleno: the rule id + * @x: hash input + * @result: pointer to result vector + * @result_max: maximum result size + * @force: force initial replica choice; -1 for none + */ +int crush_do_rule(struct crush_map *map, + int ruleno, int x, int *result, int result_max, + int force, __u32 *weight) +{ + int result_len; + int force_context[CRUSH_MAX_DEPTH]; + int force_pos = -1; + int a[CRUSH_MAX_SET]; + int b[CRUSH_MAX_SET]; + int c[CRUSH_MAX_SET]; + int recurse_to_leaf; + int *w; + int wsize = 0; + int *o; + int osize; + int *tmp; + struct crush_rule *rule; + int step; + int i,j; + int numrep; + int firstn; + + BUG_ON(ruleno >= map->max_rules); + rule = map->rules[ruleno]; + result_len = 0; + w = a; + o = b; + + /* + * determine hierarchical context of force, if any. note + * that this may or may not correspond to the specific types + * referenced by the crush rule. + */ + if (force >= 0) { + if (force >= map->max_devices || + map->device_parents[force] == 0) { + /*dprintk("CRUSH: forcefed device dne\n");*/ + return -1; /* force fed device dne */ + } + if (!is_out(map, weight, force, x)) { + while (1) { + force_context[++force_pos] = force; + /*dprintk("force_context[%d] = %d\n", force_pos, force);*/ + if (force >= 0) + force = map->device_parents[force]; + else + force = map->bucket_parents[-1-force]; + if (force == 0) + break; + } + } + } + + for (step = 0; step < rule->len; step++) { + firstn = 0; + switch (rule->steps[step].op) { + case CRUSH_RULE_TAKE: + w[0] = rule->steps[step].arg1; + if (force_pos >= 0) { + BUG_ON(force_context[force_pos] != w[0]); + force_pos--; + } + wsize = 1; + break; + + case CRUSH_RULE_CHOOSE_LEAF_FIRSTN: + case CRUSH_RULE_CHOOSE_FIRSTN: + firstn = 1; + case CRUSH_RULE_CHOOSE_LEAF_INDEP: + case CRUSH_RULE_CHOOSE_INDEP: + BUG_ON(wsize == 0); + + /* reset output */ + osize = 0; + + recurse_to_leaf = rule->steps[step].op >= + CRUSH_RULE_CHOOSE_LEAF_FIRSTN; + for (i = 0; i < wsize; i++) { + /* + * see CRUSH_N, CRUSH_N_MINUS macros. + * basically, numrep <= 0 means relative to + * the provided result_max + */ + numrep = rule->steps[step].arg1; + if (numrep <= 0) { + numrep += result_max; + if (numrep <= 0) + continue; + } + j = 0; + if (osize == 0 && force_pos >= 0) { + /* skip any intermediate types */ + while (force_pos && + force_context[force_pos] < 0 && + rule->steps[step].arg2 != + map->buckets[-1-force_context[force_pos]]->type) + force_pos--; + o[osize] = force_context[force_pos]; + if (recurse_to_leaf) + c[osize] = force_context[0]; + j++; + force_pos--; + } + osize += crush_choose(map, + map->buckets[-1-w[i]], + weight, + x, numrep, + rule->steps[step].arg2, + o+osize, j, + firstn, + recurse_to_leaf, c+osize); + } + + if (recurse_to_leaf) + /* copy final _leaf_ values to output set */ + memcpy(o, c, osize*sizeof(*o)); + + /* swap t and w arrays */ + tmp = o; + o = w; + w = tmp; + wsize = osize; + break; + + + case CRUSH_RULE_EMIT: + for (i=0; i<wsize && result_len < result_max; i++) { + result[result_len] = w[i]; + result_len++; + } + wsize = 0; + break; + + default: + BUG_ON(1); + } + } + + return result_len; +} + + diff --git a/fs/ceph/crush/mapper.h b/fs/ceph/crush/mapper.h new file mode 100644 index 0000000..9ca9cd5 --- /dev/null +++ b/fs/ceph/crush/mapper.h @@ -0,0 +1,19 @@ +#ifndef _CRUSH_MAPPER_H +#define _CRUSH_MAPPER_H + +#include "crush.h" + +/* + * CRUSH functions for find rules and then mapping an input to an + * output set. + * + * LGPL2 + */ +extern int crush_find_rule(struct crush_map *map, int pool, int type, int size); +extern int crush_do_rule(struct crush_map *map, + int ruleno, + int x, int *result, int result_max, + int forcefeed, + __u32 *weights); /* -1 for none */ + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 12/19] ceph: monitor client 2008-11-14 0:56 ` [PATCH 11/19] ceph: CRUSH mapping algorithm Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 13/19] ceph: capability management Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil The monitor cluster is responsible for managing cluster membership and state. The monitor client handles what minimal interaction the Ceph client has with it. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/mon_client.c | 385 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/mon_client.h | 100 +++++++++++++ 2 files changed, 485 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/mon_client.c create mode 100644 fs/ceph/mon_client.h diff --git a/fs/ceph/mon_client.c b/fs/ceph/mon_client.c new file mode 100644 index 0000000..ea4a5b2 --- /dev/null +++ b/fs/ceph/mon_client.c @@ -0,0 +1,385 @@ + +#include <linux/types.h> +#include <linux/random.h> +#include <linux/sched.h> +#include "mon_client.h" + +#include "ceph_debug.h" + +int ceph_debug_mon = -1; +#define DOUT_MASK DOUT_MASK_MON +#define DOUT_VAR ceph_debug_mon +#define DOUT_PREFIX "mon: " +#include "super.h" +#include "decode.h" + +/* + * Decode a monmap blob (e.g., during mount). + */ +struct ceph_monmap *ceph_monmap_decode(void *p, void *end) +{ + struct ceph_monmap *m; + int i, err = -EINVAL; + + dout(30, "monmap_decode %p %p len %d\n", p, end, (int)(end-p)); + + /* The encoded and decoded sizes match. */ + m = kmalloc(end-p, GFP_NOFS); + if (m == NULL) + return ERR_PTR(-ENOMEM); + + ceph_decode_need(&p, end, 2*sizeof(u32) + 2*sizeof(u64), bad); + ceph_decode_64_le(&p, m->fsid.major); + ceph_decode_64_le(&p, m->fsid.minor); + ceph_decode_32(&p, m->epoch); + ceph_decode_32(&p, m->num_mon); + ceph_decode_need(&p, end, m->num_mon*sizeof(m->mon_inst[0]), bad); + ceph_decode_copy(&p, m->mon_inst, m->num_mon*sizeof(m->mon_inst[0])); + if (p != end) + goto bad; + + dout(30, "monmap_decode epoch %d, num_mon %d\n", m->epoch, + m->num_mon); + for (i = 0; i < m->num_mon; i++) + dout(30, "monmap_decode mon%d is %u.%u.%u.%u:%u\n", i, + IPQUADPORT(m->mon_inst[i].addr.ipaddr)); + return m; + +bad: + dout(30, "monmap_decode failed with %d\n", err); + kfree(m); + return ERR_PTR(err); +} + +/* + * return true if *addr is included in the monmap. + */ +int ceph_monmap_contains(struct ceph_monmap *m, struct ceph_entity_addr *addr) +{ + int i; + + for (i = 0; i < m->num_mon; i++) + if (ceph_entity_addr_equal(addr, &m->mon_inst[i].addr)) + return 1; + return 0; +} + +/* + * Choose a monitor. If @notmon >= 0, choose a different monitor than + * last time. + */ +static int pick_mon(struct ceph_mon_client *monc, int notmon) +{ + char r; + + if (notmon < 0 && monc->last_mon >= 0) + return monc->last_mon; + get_random_bytes(&r, 1); + monc->last_mon = r % monc->monmap->num_mon; + return monc->last_mon; +} + +/* + * Delay work with exponential backoff. + */ +static void delayed_work(struct delayed_work *dwork, unsigned long *delay) +{ + schedule_delayed_work(dwork, *delay); + if (*delay < MAX_DELAY_INTERVAL) + *delay *= 2; + else + *delay = MAX_DELAY_INTERVAL; +} + + +/* + * mds map + */ +static void do_request_mdsmap(struct work_struct *work) +{ + struct ceph_msg *msg; + struct ceph_mds_getmap *h; + struct ceph_mon_client *monc = + container_of(work, struct ceph_mon_client, + mds_delayed_work.work); + int mon = pick_mon(monc, -1); + + dout(5, "request_mdsmap from mon%d want %u\n", mon, monc->want_mdsmap); + msg = ceph_msg_new(CEPH_MSG_MDS_GETMAP, sizeof(*h), 0, 0, NULL); + if (IS_ERR(msg)) + return; + h = msg->front.iov_base; + h->fsid = monc->monmap->fsid; + h->want = cpu_to_le32(monc->want_mdsmap); + msg->hdr.dst = monc->monmap->mon_inst[mon]; + ceph_msg_send(monc->client->msgr, msg, 0); + + /* keep sending request until we receive mds map */ + if (monc->want_mdsmap) + delayed_work(&monc->mds_delayed_work, &monc->mds_delay); +} + +/* + * Register our desire for an mdsmap >= epoch @want. + */ +void ceph_monc_request_mdsmap(struct ceph_mon_client *monc, u32 want) +{ + dout(5, "request_mdsmap want %u\n", want); + mutex_lock(&monc->req_mutex); + if (want > monc->want_mdsmap) { + monc->mds_delay = BASE_DELAY_INTERVAL; + monc->want_mdsmap = want; + do_request_mdsmap(&monc->mds_delayed_work.work); + } + mutex_unlock(&monc->req_mutex); +} + +/* + * Called when we receive an mds map. + */ +int ceph_monc_got_mdsmap(struct ceph_mon_client *monc, u32 got) +{ + int ret = 0; + + mutex_lock(&monc->req_mutex); + if (got < monc->want_mdsmap) { + dout(5, "got_mdsmap %u < wanted %u\n", got, monc->want_mdsmap); + ret = -EAGAIN; + } else { + dout(5, "got_mdsmap %u >= wanted %u\n", got, monc->want_mdsmap); + monc->want_mdsmap = 0; + cancel_delayed_work_sync(&monc->mds_delayed_work); + monc->mds_delay = BASE_DELAY_INTERVAL; + } + mutex_unlock(&monc->req_mutex); + return ret; +} + + +/* + * osd map + */ +static void do_request_osdmap(struct work_struct *work) +{ + struct ceph_msg *msg; + struct ceph_osd_getmap *h; + struct ceph_mon_client *monc = + container_of(work, struct ceph_mon_client, + osd_delayed_work.work); + int mon = pick_mon(monc, -1); + + dout(5, "request_osdmap from mon%d want %u\n", mon, monc->want_osdmap); + msg = ceph_msg_new(CEPH_MSG_OSD_GETMAP, sizeof(*h), 0, 0, NULL); + if (IS_ERR(msg)) + return; + h = msg->front.iov_base; + h->fsid = monc->monmap->fsid; + h->start = cpu_to_le32(monc->want_osdmap); + msg->hdr.dst = monc->monmap->mon_inst[mon]; + ceph_msg_send(monc->client->msgr, msg, 0); + + /* keep sending request until we receive osd map */ + if (monc->want_osdmap) + delayed_work(&monc->osd_delayed_work, &monc->osd_delay); +} + +void ceph_monc_request_osdmap(struct ceph_mon_client *monc, u32 want) +{ + dout(5, "request_osdmap want %u\n", want); + mutex_lock(&monc->req_mutex); + monc->osd_delay = BASE_DELAY_INTERVAL; + monc->want_osdmap = want; + do_request_osdmap(&monc->osd_delayed_work.work); + mutex_unlock(&monc->req_mutex); +} + +int ceph_monc_got_osdmap(struct ceph_mon_client *monc, u32 got) +{ + int ret = 0; + + mutex_lock(&monc->req_mutex); + if (got < monc->want_osdmap) { + dout(5, "got_osdmap %u < wanted %u\n", got, monc->want_osdmap); + ret = -EAGAIN; + } else { + dout(5, "got_osdmap %u >= wanted %u\n", got, monc->want_osdmap); + monc->want_osdmap = 0; + cancel_delayed_work_sync(&monc->osd_delayed_work); + monc->osd_delay = BASE_DELAY_INTERVAL; + } + mutex_unlock(&monc->req_mutex); + return ret; +} + + +/* + * umount + */ +static void do_request_umount(struct work_struct *work) +{ + struct ceph_msg *msg; + struct ceph_mon_client *monc = + container_of(work, struct ceph_mon_client, + umount_delayed_work.work); + int mon = pick_mon(monc, -1); + + dout(5, "do_request_umount from mon%d\n", mon); + msg = ceph_msg_new(CEPH_MSG_CLIENT_UNMOUNT, 0, 0, 0, NULL); + if (IS_ERR(msg)) + return; + msg->hdr.dst = monc->monmap->mon_inst[mon]; + ceph_msg_send(monc->client->msgr, msg, 0); + + delayed_work(&monc->umount_delayed_work, &monc->umount_delay); +} + +void ceph_monc_request_umount(struct ceph_mon_client *monc) +{ + struct ceph_client *client = monc->client; + + /* don't bother if forced unmount */ + if (client->mount_state == CEPH_MOUNT_SHUTDOWN) + return; + + mutex_lock(&monc->req_mutex); + monc->umount_delay = BASE_DELAY_INTERVAL; + do_request_umount(&monc->umount_delayed_work.work); + mutex_unlock(&monc->req_mutex); +} + +/* + * Handle monitor umount ack. + */ +void ceph_monc_handle_umount(struct ceph_mon_client *monc, + struct ceph_msg *msg) +{ + dout(5, "handle_umount\n"); + mutex_lock(&monc->req_mutex); + cancel_delayed_work_sync(&monc->umount_delayed_work); + monc->client->mount_state = CEPH_MOUNT_UNMOUNTED; + mutex_unlock(&monc->req_mutex); + wake_up(&monc->client->mount_wq); +} + + +/* + * statfs + */ +void ceph_monc_handle_statfs_reply(struct ceph_mon_client *monc, + struct ceph_msg *msg) +{ + struct ceph_mon_statfs_request *req; + struct ceph_mon_statfs_reply *reply = msg->front.iov_base; + u64 tid; + + if (msg->front.iov_len != sizeof(*reply)) + goto bad; + tid = le64_to_cpu(reply->tid); + dout(10, "handle_statfs_reply %p tid %llu\n", msg, tid); + + spin_lock(&monc->statfs_lock); + req = radix_tree_lookup(&monc->statfs_request_tree, tid); + if (req) { + radix_tree_delete(&monc->statfs_request_tree, tid); + req->buf->f_total = reply->st.f_total; + req->buf->f_free = reply->st.f_free; + req->buf->f_avail = reply->st.f_avail; + req->buf->f_objects = reply->st.f_objects; + req->result = 0; + } + spin_unlock(&monc->statfs_lock); + if (req) + complete(&req->completion); + return; + +bad: + derr(10, "corrupt statfs reply, no tid\n"); +} + +/* + * (re)send a statfs request + */ +static int send_statfs(struct ceph_mon_client *monc, u64 tid) +{ + struct ceph_msg *msg; + struct ceph_mon_statfs *h; + int mon = pick_mon(monc, -1); + + dout(10, "send_statfs to mon%d tid %llu\n", mon, tid); + msg = ceph_msg_new(CEPH_MSG_STATFS, sizeof(*h), 0, 0, NULL); + if (IS_ERR(msg)) + return PTR_ERR(msg); + h = msg->front.iov_base; + h->fsid = monc->monmap->fsid; + h->tid = cpu_to_le64(tid); + msg->hdr.dst = monc->monmap->mon_inst[mon]; + ceph_msg_send(monc->client->msgr, msg, 0); + return 0; +} + +/* + * Do a synchronous statfs(). + */ +int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf) +{ + struct ceph_mon_statfs_request req; + int err; + + req.buf = buf; + init_completion(&req.completion); + + /* register request */ + err = radix_tree_preload(GFP_NOFS); + if (err < 0) { + derr(10, "ENOMEM in do_statfs\n"); + return err; + } + spin_lock(&monc->statfs_lock); + req.tid = ++monc->last_tid; + req.last_attempt = jiffies; + radix_tree_insert(&monc->statfs_request_tree, req.tid, &req); + spin_unlock(&monc->statfs_lock); + radix_tree_preload_end(); + + /* send request and wait */ + err = send_statfs(monc, req.tid); + if (err) + return err; + err = wait_for_completion_interruptible(&req.completion); + if (err == -EINTR) + return err; + return req.result; +} + + +int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl) +{ + dout(5, "init\n"); + memset(monc, 0, sizeof(*monc)); + monc->client = cl; + monc->monmap = kzalloc(sizeof(struct ceph_monmap) + + sizeof(struct ceph_entity_addr) * MAX_MON_MOUNT_ADDR, + GFP_KERNEL); + if (monc->monmap == NULL) + return -ENOMEM; + spin_lock_init(&monc->statfs_lock); + INIT_RADIX_TREE(&monc->statfs_request_tree, GFP_ATOMIC); + monc->last_tid = 0; + INIT_DELAYED_WORK(&monc->mds_delayed_work, do_request_mdsmap); + INIT_DELAYED_WORK(&monc->osd_delayed_work, do_request_osdmap); + INIT_DELAYED_WORK(&monc->umount_delayed_work, do_request_umount); + monc->mds_delay = monc->osd_delay = monc->umount_delay = 0; + mutex_init(&monc->req_mutex); + monc->want_mdsmap = 0; + monc->want_osdmap = 0; + return 0; +} + +void ceph_monc_stop(struct ceph_mon_client *monc) +{ + dout(5, "stop\n"); + cancel_delayed_work_sync(&monc->mds_delayed_work); + cancel_delayed_work_sync(&monc->osd_delayed_work); + cancel_delayed_work_sync(&monc->umount_delayed_work); + kfree(monc->monmap); +} diff --git a/fs/ceph/mon_client.h b/fs/ceph/mon_client.h new file mode 100644 index 0000000..920cda8 --- /dev/null +++ b/fs/ceph/mon_client.h @@ -0,0 +1,100 @@ +#ifndef _FS_CEPH_MON_CLIENT_H +#define _FS_CEPH_MON_CLIENT_H + +#include "messenger.h" +#include <linux/completion.h> +#include <linux/radix-tree.h> + +/* + * A small cluster of Ceph "monitors" are responsible for managing critical + * cluster configuration and state information. An odd number (e.g., 3, 5) + * of cmon daemons use a modified version of the Paxos part-time parliament + * algorithm to manage the MDS map (mds cluster membership), OSD map, and + * list of clients who have mounted the file system. + * + * Communication with the monitor cluster is lossy, so requests for + * information may have to be resent if we time out waiting for a response. + * As long as we do not time out, we continue to send all requests to the + * same monitor. If there is a problem, we randomly pick a new monitor form + * the cluster to try. + */ + +struct ceph_client; +struct ceph_mount_args; + +/* + * The monitor map enumerates the set of all monitors. + * + * Make sure this structure size matches the encoded map size, or change + * ceph_monmap_decode(). + */ +struct ceph_monmap { + struct ceph_fsid fsid; + u32 epoch; + u32 num_mon; + struct ceph_entity_inst mon_inst[0]; +}; + +/* + * a pending statfs() request. + */ +struct ceph_mon_statfs_request { + u64 tid; + int result; + struct ceph_statfs *buf; + struct completion completion; + unsigned long last_attempt; /* jiffies */ +}; + +struct ceph_mon_client { + struct ceph_client *client; + int last_mon; /* last monitor i contacted */ + struct ceph_monmap *monmap; + + /* pending statfs requests */ + spinlock_t statfs_lock; + struct radix_tree_root statfs_request_tree; + u64 last_tid; + + /* mds/osd map or umount requests */ + struct delayed_work mds_delayed_work; + struct delayed_work osd_delayed_work; + struct delayed_work umount_delayed_work; + unsigned long mds_delay; + unsigned long osd_delay; + unsigned long umount_delay; + struct mutex req_mutex; + u32 want_mdsmap; + u32 want_osdmap; +}; + +extern struct ceph_monmap *ceph_monmap_decode(void *p, void *end); +extern int ceph_monmap_contains(struct ceph_monmap *m, + struct ceph_entity_addr *addr); + +extern int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl); +extern void ceph_monc_stop(struct ceph_mon_client *monc); + +/* + * The model here is to indicate that we need a new map of at least epoch + * @want, and to indicate which maps receive. Periodically rerequest the map + * from the monitor cluster until we get what we want. + */ +extern void ceph_monc_request_mdsmap(struct ceph_mon_client *monc, u32 want); +extern int ceph_monc_got_mdsmap(struct ceph_mon_client *monc, u32 have); + +extern void ceph_monc_request_osdmap(struct ceph_mon_client *monc, u32 want); +extern int ceph_monc_got_osdmap(struct ceph_mon_client *monc, u32 have); + +extern void ceph_monc_request_umount(struct ceph_mon_client *monc); + +extern int ceph_monc_do_statfs(struct ceph_mon_client *monc, + struct ceph_statfs *buf); +extern void ceph_monc_handle_statfs_reply(struct ceph_mon_client *monc, + struct ceph_msg *msg); + +extern void ceph_monc_request_umount(struct ceph_mon_client *monc); +extern void ceph_monc_handle_umount(struct ceph_mon_client *monc, + struct ceph_msg *msg); + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 13/19] ceph: capability management 2008-11-14 0:56 ` [PATCH 12/19] ceph: monitor client Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 14/19] ceph: snapshot management Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil The Ceph metadata servers control client access to data by issuing capabilities granting clients permission to read and/or write to OSDs (storage nodes). Each capability consists of a set of bits indicating which operations are allowed. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/caps.c | 1464 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 1464 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/caps.c diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c new file mode 100644 index 0000000..bdc761e --- /dev/null +++ b/fs/ceph/caps.c @@ -0,0 +1,1464 @@ +#include <linux/fs.h> +#include <linux/kernel.h> +#include <linux/sched.h> +#include <linux/wait.h> + +#include "ceph_debug.h" + +int ceph_debug_caps = -1; +#define DOUT_MASK DOUT_MASK_CAPS +#define DOUT_VAR ceph_debug_caps +#define DOUT_PREFIX "caps: " +#include "super.h" + +#include "decode.h" +#include "messenger.h" + + +/* + * Find ceph_cap for given mds, if any. + * + * Called with i_lock held. + */ +static struct ceph_cap *__get_cap_for_mds(struct inode *inode, int mds) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_cap *cap; + struct rb_node *n = ci->i_caps.rb_node; + + while (n) { + cap = rb_entry(n, struct ceph_cap, ci_node); + if (mds < cap->mds) + n = n->rb_left; + else if (mds > cap->mds) + n = n->rb_right; + else + return cap; + } + return NULL; +} + +/* + * Return id of any MDS with a cap, preferably WR|WRBUFFER|EXCL, else + * -1. + */ +static int __ceph_get_cap_mds(struct ceph_inode_info *ci, u32 *mseq) +{ + struct ceph_cap *cap; + int mds = -1; + struct rb_node *p; + + /* prefer mds with WR|WRBUFFER|EXCL caps */ + for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { + cap = rb_entry(p, struct ceph_cap, ci_node); + mds = cap->mds; + if (mseq) + *mseq = cap->mseq; + if (cap->issued & (CEPH_CAP_WR|CEPH_CAP_WRBUFFER|CEPH_CAP_EXCL)) + break; + } + return mds; +} + +int ceph_get_cap_mds(struct inode *inode) +{ + int mds; + spin_lock(&inode->i_lock); + mds = __ceph_get_cap_mds(ceph_inode(inode), NULL); + spin_unlock(&inode->i_lock); + return mds; +} + +/* + * Called under i_lock. + */ +static void __insert_cap_node(struct ceph_inode_info *ci, + struct ceph_cap *new) +{ + struct rb_node **p = &ci->i_caps.rb_node; + struct rb_node *parent = NULL; + struct ceph_cap *cap = NULL; + + while (*p) { + parent = *p; + cap = rb_entry(parent, struct ceph_cap, ci_node); + if (new->mds < cap->mds) + p = &(*p)->rb_left; + else if (new->mds > cap->mds) + p = &(*p)->rb_right; + else + BUG(); + } + + rb_link_node(&new->ci_node, parent, p); + rb_insert_color(&new->ci_node, &ci->i_caps); +} + +/* + * Add a capability under the given MDS session, after processing + * the snapblob (to update the snap realm hierarchy). + * + * Bump i_count when adding it's first cap. + * + * Caller should hold session snap_rwsem, s_mutex. + * + * @fmode can be negative, in which case it is ignored. + */ +int ceph_add_cap(struct inode *inode, + struct ceph_mds_session *session, + int fmode, unsigned issued, + unsigned seq, unsigned mseq, + void *snapblob, int snapblob_len, + struct ceph_cap *new_cap) +{ + struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc; + struct ceph_inode_info *ci = ceph_inode(inode); + struct ceph_cap *cap; + struct ceph_snap_realm *realm; + int mds = session->s_mds; + int is_first = 0; + + realm = ceph_update_snap_trace(mdsc, snapblob, snapblob+snapblob_len, + false /* not a deletion */); + + dout(10, "add_cap on %p mds%d cap %d seq %d\n", inode, + session->s_mds, issued, seq); +retry: + spin_lock(&inode->i_lock); + cap = __get_cap_for_mds(inode, mds); + if (!cap) { + if (new_cap) { + cap = new_cap; + new_cap = NULL; + } else { + spin_unlock(&inode->i_lock); + new_cap = kmalloc(sizeof(*cap), GFP_NOFS); + if (new_cap == NULL) { + ceph_put_snap_realm(mdsc, realm); + return -ENOMEM; + } + goto retry; + } + + cap->issued = cap->implemented = 0; + cap->mds = mds; + + is_first = RB_EMPTY_ROOT(&ci->i_caps); /* grab inode later */ + cap->ci = ci; + __insert_cap_node(ci, cap); + + /* add to session cap list */ + cap->session = session; + list_add(&cap->session_caps, &session->s_caps); + session->s_nr_caps++; + + /* clear out old exporting info? (i.e. on cap import) */ + if (ci->i_cap_exporting_mds == mds) { + ci->i_cap_exporting_issued = 0; + ci->i_cap_exporting_mseq = 0; + ci->i_cap_exporting_mds = -1; + } + } + if (!ci->i_snap_realm) { + ci->i_snap_realm = realm; + list_add(&ci->i_snap_realm_item, &realm->inodes_with_caps); + } else { + ceph_put_snap_realm(mdsc, realm); + } + + dout(10, "add_cap inode %p (%llx.%llx) cap %xh now %xh seq %d mds%d\n", + inode, ceph_vinop(inode), issued, issued|cap->issued, seq, mds); + cap->issued |= issued; + cap->implemented |= issued; + cap->seq = seq; + cap->mseq = mseq; + cap->gen = session->s_cap_gen; + if (fmode >= 0) + __ceph_get_fmode(ci, fmode); + spin_unlock(&inode->i_lock); + if (is_first) + igrab(inode); + kfree(new_cap); + return 0; +} + +/* + * Return set of valid cap bits issued to us. Note that caps time + * out, and may be invalidated in bulk if the client session times out + * and session->s_cap_gen is bumped. + */ +int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented) +{ + int have = ci->i_snap_caps; + struct ceph_cap *cap; + u32 gen; + unsigned long ttl; + struct rb_node *p; + + for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { + cap = rb_entry(p, struct ceph_cap, ci_node); + + spin_lock(&cap->session->s_cap_lock); + gen = cap->session->s_cap_gen; + ttl = cap->session->s_cap_ttl; + spin_unlock(&cap->session->s_cap_lock); + + if (cap->gen < gen || time_after_eq(jiffies, ttl)) { + dout(30, "__ceph_caps_issued %p cap %p issued %d " + "but STALE (gen %u vs %u)\n", &ci->vfs_inode, + cap, cap->issued, cap->gen, gen); + continue; + } + dout(30, "__ceph_caps_issued %p cap %p issued %d\n", + &ci->vfs_inode, cap, cap->issued); + have |= cap->issued; + if (implemented) + *implemented |= cap->implemented; + } + return have; +} + +/* + * caller should hold i_lock, snap_rwsem, and session s_mutex. + * returns true if this is the last cap. if so, caller should iput. + */ +static int __ceph_remove_cap(struct ceph_cap *cap) +{ + struct ceph_mds_session *session = cap->session; + struct ceph_inode_info *ci = cap->ci; + struct ceph_mds_client *mdsc = &ceph_client(ci->vfs_inode.i_sb)->mdsc; + + dout(20, "__ceph_remove_cap %p from %p\n", cap, &ci->vfs_inode); + + /* remove from session list */ + list_del_init(&cap->session_caps); + session->s_nr_caps--; + + /* remove from inode list */ + rb_erase(&cap->ci_node, &ci->i_caps); + cap->session = NULL; + + kfree(cap); + + if (RB_EMPTY_ROOT(&ci->i_caps)) { + list_del_init(&ci->i_snap_realm_item); + ceph_put_snap_realm(mdsc, ci->i_snap_realm); + ci->i_snap_realm = NULL; + return 1; + } + return 0; +} + +/* + * caller should hold snap_rwsem and session s_mutex. + */ +void ceph_remove_cap(struct ceph_cap *cap) +{ + struct inode *inode = &cap->ci->vfs_inode; + int was_last; + + spin_lock(&inode->i_lock); + was_last = __ceph_remove_cap(cap); + spin_unlock(&inode->i_lock); + if (was_last) + iput(inode); +} + +/* + * + * (Re)queue cap at the end of the delayed cap release list. + * + * Caller holds i_lock + * -> we take mdsc->cap_delay_lock + */ +static void __cap_delay_requeue(struct ceph_mds_client *mdsc, + struct ceph_inode_info *ci) +{ + ci->i_hold_caps_until = round_jiffies(jiffies + HZ * 5); + dout(10, "__cap_delay_requeue %p at %lu\n", &ci->vfs_inode, + ci->i_hold_caps_until); + spin_lock(&mdsc->cap_delay_lock); + if (!mdsc->stopping) { + if (list_empty(&ci->i_cap_delay_list)) + igrab(&ci->vfs_inode); + else + list_del_init(&ci->i_cap_delay_list); + list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list); + } + spin_unlock(&mdsc->cap_delay_lock); +} + +/* + * Cancel delayed work on cap. + * caller hold s_mutex, snap_rwsem. + */ +static void __cap_delay_cancel(struct ceph_mds_client *mdsc, + struct ceph_inode_info *ci) +{ + dout(10, "__cap_delay_cancel %p\n", &ci->vfs_inode); + if (list_empty(&ci->i_cap_delay_list)) + return; + spin_lock(&mdsc->cap_delay_lock); + list_del_init(&ci->i_cap_delay_list); + spin_unlock(&mdsc->cap_delay_lock); + iput(&ci->vfs_inode); +} + +/* + * Build and send a cap message to the given MDS. + * + * Caller should be holding s_mutex. + */ +static void send_cap_msg(struct ceph_mds_client *mdsc, u64 ino, int op, + int caps, int wanted, u64 seq, u64 mseq, + u64 size, u64 max_size, + struct timespec *mtime, struct timespec *atime, + u64 time_warp_seq, u64 follows, int mds) +{ + struct ceph_mds_caps *fc; + struct ceph_msg *msg; + + dout(10, "send_cap_msg %s %llx caps %d wanted %d seq %llu/%llu" + " follows %lld size %llu\n", ceph_cap_op_name(op), ino, + caps, wanted, seq, mseq, follows, size); + + msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPS, sizeof(*fc), 0, 0, NULL); + if (IS_ERR(msg)) + return; + + fc = msg->front.iov_base; + + memset(fc, 0, sizeof(*fc)); + + fc->op = cpu_to_le32(op); + fc->seq = cpu_to_le32(seq); + fc->migrate_seq = cpu_to_le32(mseq); + fc->caps = cpu_to_le32(caps); + fc->wanted = cpu_to_le32(wanted); + fc->ino = cpu_to_le64(ino); + fc->size = cpu_to_le64(size); + fc->max_size = cpu_to_le64(max_size); + fc->snap_follows = cpu_to_le64(follows); + if (mtime) + ceph_encode_timespec(&fc->mtime, mtime); + if (atime) + ceph_encode_timespec(&fc->atime, atime); + fc->time_warp_seq = cpu_to_le64(time_warp_seq); + + ceph_send_msg_mds(mdsc, msg, mds); +} + +/* + * + * Send a cap msg on the given inode. Make note of max_size + * reported/requested from mds, revoked caps that have now been + * implemented. + * + * Also, try to invalidate page cache if we are dropping RDCACHE. + * Note that this will leave behind any locked pages... FIXME! + * + * called with i_lock, then drops it. + * caller should hold snap_rwsem, s_mutex. + */ +static void __send_cap(struct ceph_mds_client *mdsc, + struct ceph_mds_session *session, + struct ceph_cap *cap, + int used, int wanted) __releases(cap->ci->vfs_inode->i_lock) +{ + struct ceph_inode_info *ci = cap->ci; + struct inode *inode = &ci->vfs_inode; + int revoking = cap->implemented & ~cap->issued; + int dropping = cap->issued & ~wanted; + int keep; + u64 seq, mseq, time_warp_seq, follows; + u64 size, max_size; + struct timespec mtime, atime; + int wake = 0; + int op = CEPH_CAP_OP_ACK; + + if (wanted == 0) + op = CEPH_CAP_OP_RELEASE; + + dout(10, "__send_cap cap %p session %p %d -> %d\n", cap, cap->session, + cap->issued, cap->issued & wanted); + cap->issued &= wanted; /* drop bits we don't want */ + + if (revoking && (revoking && used) == 0) { + cap->implemented = cap->issued; + /* + * Wake up any waiters on wanted -> needed transition. + * This is due to the weird transition from buffered + * to sync IO... we need to flush dirty pages _before_ + * allowing sync writes to avoid reordering. + */ + wake = 1; + } + + keep = cap->issued; + seq = cap->seq; + mseq = cap->mseq; + size = inode->i_size; + ci->i_reported_size = size; + max_size = ci->i_wanted_max_size; + ci->i_requested_max_size = max_size; + mtime = inode->i_mtime; + atime = inode->i_atime; + time_warp_seq = ci->i_time_warp_seq; + follows = ci->i_snap_realm->cached_context->seq; + spin_unlock(&inode->i_lock); + + if (dropping & CEPH_CAP_RDCACHE) { + /* invalidate what we can */ + dout(20, "invalidating pages on %p\n", inode); + invalidate_mapping_pages(&inode->i_data, 0, -1); + } + + send_cap_msg(mdsc, ceph_vino(inode).ino, + op, keep, wanted, seq, mseq, + size, max_size, &mtime, &atime, time_warp_seq, + follows, session->s_mds); + + if (wake) + wake_up(&ci->i_cap_wq); +} + + +/* + * When a snapshot is taken, clients accumulate "dirty" data on inodes + * with capabilities in ceph_cap_snaps to describe the file state at + * the time the snapshot was taken. This must be flushed + * asynchronously back to the MDS once sync writes complete and dirty + * data is written out. + * + * Called under i_lock. Takes s_mutex as needed. + */ +void __ceph_flush_snaps(struct ceph_inode_info *ci, + struct ceph_mds_session **psession) +{ + struct inode *inode = &ci->vfs_inode; + int mds; + struct list_head *p; + struct ceph_cap_snap *capsnap; + u64 follows; + int issued; + u64 size; + struct timespec mtime, atime, ctime; + u64 time_warp_seq; + u32 mseq; + struct ceph_mds_client *mdsc = &ceph_inode_to_client(inode)->mdsc; + struct ceph_mds_session *session = NULL; /* if session != NULL, we hold + session->s_mutex */ + u64 next_follows = 0; /* keep track of how far we've gotten through the + i_cap_snaps list, and skip these entries next time + around to avoid an infinite loop */ + + if (psession) + session = *psession; + + dout(10, "__flush_snaps %p\n", inode); +retry: + list_for_each(p, &ci->i_cap_snaps) { + capsnap = list_entry(p, struct ceph_cap_snap, ci_item); + + /* avoid an infiniute loop after retry */ + if (capsnap->follows < next_follows) + continue; + /* + * we need to wait for sync writes to complete and for dirty + * pages to be written out. + */ + if (capsnap->dirty || capsnap->writing) + continue; + + /* pick mds, take s_mutex */ + mds = __ceph_get_cap_mds(ci, &mseq); + if (session && session->s_mds != mds) { + dout(30, "oops, wrong session %p mutex\n", session); + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + session = NULL; + } + if (!session) { + spin_unlock(&inode->i_lock); + mutex_lock(&mdsc->mutex); + session = __ceph_get_mds_session(mdsc, mds); + mutex_unlock(&mdsc->mutex); + if (session) { + dout(10, "inverting session/ino locks on %p\n", + session); + mutex_lock(&session->s_mutex); + } + /* + * if session == NULL, we raced against a cap + * deletion. retry, and we'll get a better + * @mds value next time. + */ + spin_lock(&inode->i_lock); + goto retry; + } + + follows = capsnap->follows; + size = capsnap->size; + atime = capsnap->atime; + mtime = capsnap->mtime; + ctime = capsnap->ctime; + time_warp_seq = capsnap->time_warp_seq; + issued = capsnap->issued; + spin_unlock(&inode->i_lock); + + dout(10, "flush_snaps %p cap_snap %p follows %lld size %llu\n", + inode, capsnap, next_follows, size); + send_cap_msg(mdsc, ceph_vino(inode).ino, + CEPH_CAP_OP_FLUSHSNAP, issued, 0, 0, mseq, + size, 0, + &mtime, &atime, time_warp_seq, + follows, mds); + + spin_lock(&inode->i_lock); + next_follows = follows + 1; + goto retry; + } + + /* we flushed them all; remove this inode from the queue */ + spin_lock(&mdsc->snap_flush_lock); + list_del_init(&ci->i_snap_flush_item); + spin_unlock(&mdsc->snap_flush_lock); + + if (psession) + *psession = session; + else if (session) { + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + } +} + +void ceph_flush_snaps(struct ceph_inode_info *ci) +{ + struct inode *inode = &ci->vfs_inode; + + spin_lock(&inode->i_lock); + __ceph_flush_snaps(ci, NULL); + spin_unlock(&inode->i_lock); +} + + +/* + * Swiss army knife function to examine currently used, wanted versus + * held caps. Release, flush, ack revoked caps to mds as appropriate. + * + * @is_delayed indicates caller is delayed work and we should not + * delay further. + */ +void ceph_check_caps(struct ceph_inode_info *ci, int is_delayed) +{ + struct ceph_client *client = ceph_inode_to_client(&ci->vfs_inode); + struct ceph_mds_client *mdsc = &client->mdsc; + struct inode *inode = &ci->vfs_inode; + struct ceph_cap *cap; + int file_wanted, used; + struct ceph_mds_session *session = NULL; /* if set, i hold s_mutex */ + int took_snap_rwsem = 0; /* true if mdsc->snap_rwsem held */ + int revoking; + int mds = -1; /* keep track of how far we've gone through i_caps list + to avoid an infinite loop on retry */ + struct rb_node *p; + int tried_invalidate = 0; + + /* if we are unmounting, flush any unused caps immediately. */ + if (mdsc->stopping) + is_delayed = 1; + + spin_lock(&inode->i_lock); + + /* flush snaps first time around only */ + if (!list_empty(&ci->i_cap_snaps)) + __ceph_flush_snaps(ci, &session); + goto retry_locked; +retry: + spin_lock(&inode->i_lock); +retry_locked: + file_wanted = __ceph_caps_file_wanted(ci); + used = __ceph_caps_used(ci); + dout(10, "check_caps %p file_wanted %d used %d issued %d\n", + inode, file_wanted, used, __ceph_caps_issued(ci, NULL)); + + /* + * Reschedule delayed caps release, unless we are called from + * the delayed work handler (i.e. this _is_ the delayed release) + */ + if (!is_delayed) + __cap_delay_requeue(mdsc, ci); + + /* + * If we no longer need to hold onto old our caps, and we may + * have cached pages, but don't want them, then try to invalidate. + * If we fail, it's because pages are locked.... try again later. + */ + if ((!time_before(jiffies, ci->i_hold_caps_until) || mdsc->stopping) && + ci->i_wrbuffer_ref == 0 && /* no dirty pages... */ + ci->i_rdcache_gen && /* may have cached pages */ + file_wanted == 0 && /* no open files */ + !tried_invalidate) { + u32 invalidating_gen = ci->i_rdcache_gen; + int ret; + + dout(10, "check_caps trying to invalidate on %p\n", inode); + spin_unlock(&inode->i_lock); + ret = invalidate_inode_pages2(&inode->i_data); + spin_lock(&inode->i_lock); + if (ret == 0 && invalidating_gen == ci->i_rdcache_gen) { + /* success. */ + ci->i_rdcache_gen = 0; + ci->i_rdcache_revoking = 0; + } else { + dout(10, "check_caps failed to invalidate pages\n"); + /* we failed to invalidate pages. check these + caps again later. */ + if (is_delayed) + __cap_delay_requeue(mdsc, ci); + } + tried_invalidate = 1; + goto retry_locked; + } + + for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { + cap = rb_entry(p, struct ceph_cap, ci_node); + + /* avoid looping forever */ + if (mds >= cap->mds) + continue; + + /* NOTE: no side-effects allowed, until we take s_mutex */ + + revoking = cap->implemented & ~cap->issued; + if (revoking) + dout(10, "mds%d revoking %d\n", cap->mds, revoking); + + /* request larger max_size from MDS? */ + if (ci->i_wanted_max_size > ci->i_max_size && + ci->i_wanted_max_size > ci->i_requested_max_size) + goto ack; + + /* approaching file_max? */ + if ((cap->issued & CEPH_CAP_WR) && + (inode->i_size << 1) >= ci->i_max_size && + (ci->i_reported_size << 1) < ci->i_max_size) { + dout(10, "i_size approaching max_size\n"); + goto ack; + } + + /* completed revocation? going down and there are no caps? */ + if ((revoking && (revoking & used) == 0) || + (mdsc->stopping && (used == 0))) { + dout(10, "completed revocation of %d\n", + cap->implemented & ~cap->issued); + goto ack; + } + + if ((cap->issued & ~(file_wanted | used)) == 0) + continue; /* nothing extra, all good */ + + /* delay cap release for a bit? */ + if (!is_delayed && + time_before(jiffies, ci->i_hold_caps_until)) { + dout(30, "delaying cap release\n"); + continue; + } + +ack: + /* take snap_rwsem before session mutex */ + if (!took_snap_rwsem) { + if (down_read_trylock(&mdsc->snap_rwsem) == 0) { + dout(10, "inverting snap/in locks on %p\n", + inode); + spin_unlock(&inode->i_lock); + down_read(&mdsc->snap_rwsem); + took_snap_rwsem = 1; + goto retry; + } + took_snap_rwsem = 1; + } + if (session && session != cap->session) { + dout(30, "oops, wrong session %p mutex\n", session); + mutex_unlock(&session->s_mutex); + session = NULL; + } + if (!session) { + session = cap->session; + if (mutex_trylock(&session->s_mutex) == 0) { + dout(10, "inverting session/ino locks on %p\n", + session); + spin_unlock(&inode->i_lock); + mutex_lock(&session->s_mutex); + goto retry; + } + } + + mds = cap->mds; /* remember mds, so we don't repeat */ + + /* __send_cap drops i_lock */ + __send_cap(mdsc, session, cap, used, used | file_wanted); + + goto retry; /* retake i_lock and restart our cap scan. */ + } + + /* okay */ + spin_unlock(&inode->i_lock); + + if (session) + mutex_unlock(&session->s_mutex); + if (took_snap_rwsem) + up_read(&mdsc->snap_rwsem); +} + + +/* + * Track references to capabilities we hold, so that we don't release + * them to the MDS prematurely. + * + * Protected by i_lock. + */ +static void __take_cap_refs(struct ceph_inode_info *ci, int got) +{ + if (got & CEPH_CAP_RD) + ci->i_rd_ref++; + if (got & CEPH_CAP_RDCACHE) + ci->i_rdcache_ref++; + if (got & CEPH_CAP_WR) + ci->i_wr_ref++; + if (got & CEPH_CAP_WRBUFFER) { + ci->i_wrbuffer_ref++; + dout(30, "__take_cap_refs %p wrbuffer %d -> %d (?)\n", + &ci->vfs_inode, ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref); + } +} + +/* + * Try to grab cap references. Specify those refs we @want, and the + * minimal set we @need. Also include the larger offset we are writing + * to (when applicable), and check against max_size here as well. + * Note that caller is responsible for ensuring max_size increases are + * requested from the MDS. + */ +int ceph_get_cap_refs(struct ceph_inode_info *ci, int need, int want, int *got, + loff_t endoff) +{ + struct inode *inode = &ci->vfs_inode; + int ret = 0; + int have, implemented; + + dout(30, "get_cap_refs %p need %d want %d\n", inode, need, want); + spin_lock(&inode->i_lock); + if (need & CEPH_CAP_WR) { + if (endoff >= 0 && endoff > (loff_t)ci->i_max_size) { + dout(20, "get_cap_refs %p endoff %llu > maxsize %llu\n", + inode, endoff, ci->i_max_size); + goto sorry; + } + /* + * If a sync write is in progress, we must wait, so that we + * can get a final snapshot value for size+mtime. + */ + if (__ceph_have_pending_cap_snap(ci)) { + dout(20, "get_cap_refs %p cap_snap_pending\n", inode); + goto sorry; + } + } + have = __ceph_caps_issued(ci, &implemented); + /* HACK: force sync writes... + have &= ~CEPH_CAP_WRBUFFER; + implemented &= ~CEPH_CAP_WRBUFFER; + */ + if ((have & need) == need) { + /* + * Look at (implemented & ~have & not) so that we keep waiting + * on transition from wanted -> needed caps. This is needed + * for WRBUFFER|WR -> WR to avoid a new WR sync write from + * going before a prior buffered writeback happens. + */ + int not = want & ~(have & need); + int revoking = implemented & ~have; + dout(30, "get_cap_refs %p have %d but not %d (revoking %d)\n", + inode, have, not, revoking); + if ((revoking & not) == 0) { + *got = need | (have & want); + __take_cap_refs(ci, *got); + ret = 1; + } + } else { + dout(30, "get_cap_refs %p have %d needed %d\n", inode, + have, need); + } +sorry: + spin_unlock(&inode->i_lock); + dout(30, "get_cap_refs %p ret %d got %d\n", inode, + ret, *got); + return ret; +} + +/* + * Release cap refs. + * + * If we released the last ref on any given cap, call ceph_check_caps + * to release (or schedule a release). + * + * If we are releasing a WR cap (from a sync write), finalize any affected + * cap_snap, and wake up any waiters. + */ +void ceph_put_cap_refs(struct ceph_inode_info *ci, int had) +{ + struct inode *inode = &ci->vfs_inode; + int last = 0, flushsnaps = 0, wake = 0; + struct ceph_cap_snap *capsnap; + + spin_lock(&inode->i_lock); + if (had & CEPH_CAP_RD) + if (--ci->i_rd_ref == 0) + last++; + if (had & CEPH_CAP_RDCACHE) + if (--ci->i_rdcache_ref == 0) + last++; + if (had & CEPH_CAP_WRBUFFER) { + if (--ci->i_wrbuffer_ref == 0) + last++; + dout(30, "put_cap_refs %p wrbuffer %d -> %d (?)\n", + inode, ci->i_wrbuffer_ref+1, ci->i_wrbuffer_ref); + } + if (had & CEPH_CAP_WR) + if (--ci->i_wr_ref == 0) { + last++; + if (!list_empty(&ci->i_cap_snaps)) { + capsnap = list_entry(ci->i_cap_snaps.next, + struct ceph_cap_snap, + ci_item); + if (capsnap->writing) { + capsnap->writing = 0; + flushsnaps = + __ceph_finish_cap_snap(ci, + capsnap); + wake = 1; + } + } + } + spin_unlock(&inode->i_lock); + + dout(30, "put_cap_refs %p had %d %s\n", inode, had, last ? "last" : ""); + + if (last && !flushsnaps) + ceph_check_caps(ci, 0); + else if (flushsnaps) + ceph_flush_snaps(ci); + if (wake) + wake_up(&ci->i_cap_wq); +} + +/* + * Release @nr WRBUFFER refs on dirty pages for the given @snapc snap + * context. Adjust per-snap dirty page accounting as appropriate. + * Once all dirty data for a cap_snap is flushed, flush snapped file + * metadata back to the MDS. If we dropped the last ref, call + * ceph_check_caps. + */ +void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr, + struct ceph_snap_context *snapc) +{ + struct inode *inode = &ci->vfs_inode; + int last = 0; + int last_snap = 0; + int found = 0; + struct list_head *p; + struct ceph_cap_snap *capsnap = NULL; + + spin_lock(&inode->i_lock); + ci->i_wrbuffer_ref -= nr; + last = !ci->i_wrbuffer_ref; + + if (ci->i_head_snapc == snapc) { + ci->i_wrbuffer_ref_head -= nr; + if (!ci->i_wrbuffer_ref_head) { + ceph_put_snap_context(ci->i_head_snapc); + ci->i_head_snapc = NULL; + } + dout(30, "put_wrbuffer_cap_refs on %p head %d/%d -> %d/%d %s\n", + inode, + ci->i_wrbuffer_ref+nr, ci->i_wrbuffer_ref_head+nr, + ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head, + last ? " LAST" : ""); + } else { + list_for_each(p, &ci->i_cap_snaps) { + capsnap = list_entry(p, struct ceph_cap_snap, ci_item); + if (capsnap->context == snapc) { + found = 1; + capsnap->dirty -= nr; + last_snap = !capsnap->dirty; + break; + } + } + BUG_ON(!found); + dout(30, "put_wrbuffer_cap_refs on %p cap_snap %p " + " snap %lld %d/%d -> %d/%d %s%s\n", + inode, capsnap, capsnap->context->seq, + ci->i_wrbuffer_ref+nr, capsnap->dirty + nr, + ci->i_wrbuffer_ref, capsnap->dirty, + last ? " (wrbuffer last)" : "", + last_snap ? " (capsnap last)" : ""); + } + + spin_unlock(&inode->i_lock); + + if (last) { + ceph_check_caps(ci, 0); + } else if (last_snap) { + ceph_flush_snaps(ci); + wake_up(&ci->i_cap_wq); + } +} + + + +/* + * Handle a cap GRANT message from the MDS. (Note that a GRANT may + * actually be a revocation if it specifies a smaller cap set.) + * + * caller holds s_mutex. NOT snap_rwsem. + * return value: + * 0 - ok + * 1 - send the msg back to mds + */ +static int handle_cap_grant(struct inode *inode, struct ceph_mds_caps *grant, + struct ceph_mds_session *session) +{ + struct ceph_cap *cap; + struct ceph_inode_info *ci = ceph_inode(inode); + int mds = session->s_mds; + int seq = le32_to_cpu(grant->seq); + int newcaps = le32_to_cpu(grant->caps); + int used; + int issued; /* to me, before */ + int wanted; + int reply = 0; + u64 size = le64_to_cpu(grant->size); + u64 max_size = le64_to_cpu(grant->max_size); + struct timespec mtime, atime, ctime; + int wake = 0; + int writeback = 0; + int revoked_rdcache = 0; + int invalidate_async = 0; + int tried_invalidate = 0; + int ret; + + dout(10, "handle_cap_grant inode %p ci %p mds%d seq %d\n", + inode, ci, mds, seq); + dout(10, " size %llu max_size %llu, i_size %llu\n", size, max_size, + inode->i_size); + spin_lock(&inode->i_lock); +start: + + /* do we have this cap? */ + cap = __get_cap_for_mds(inode, mds); + if (!cap) { + /* + * then ignore. never reply to cap messages out of turn, + * or we'll be mixing up different instances of caps on the + * same inode, and confuse the mds. + */ + dout(10, "no cap on %p ino %llx.%llx from mds%d, ignoring\n", + inode, ci->i_vino.ino, ci->i_vino.snap, mds); + goto out; + } + dout(10, " cap %p\n", cap); + cap->gen = session->s_cap_gen; + + /* + * Each time we receive RDCACHE anew, we increment i_rdcache_gen. + */ + if ((newcaps & CEPH_CAP_RDCACHE) && /* we just got RDCACHE */ + (cap->issued & CEPH_CAP_RDCACHE) == 0 && /* and didn't have it */ + (__ceph_caps_issued(ci, NULL) & CEPH_CAP_RDCACHE) == 0) + ci->i_rdcache_gen++; + + /* + * If RDCACHE is being revoked, and we have no dirty buffers, + * try to invalidate (once). (If there are dirty buffers, we + * will invalidate _after_ writeback.) + */ + if (((cap->issued & ~newcaps) & CEPH_CAP_RDCACHE) && + !ci->i_wrbuffer_ref && !tried_invalidate) { + dout(10, "RDCACHE invalidation\n"); + spin_unlock(&inode->i_lock); + tried_invalidate = 1; + + ret = invalidate_inode_pages2(&inode->i_data); + spin_lock(&inode->i_lock); + if (ret < 0) { + /* there were locked pages.. invalidate later + in a separate thread. */ + if (ci->i_rdcache_revoking != ci->i_rdcache_gen) { + invalidate_async = 1; + ci->i_rdcache_revoking = ci->i_rdcache_gen; + } + } else { + /* we successfully invalidated those pages */ + revoked_rdcache = 1; + ci->i_rdcache_gen = 0; + ci->i_rdcache_revoking = 0; + } + goto start; + } + + + /* size/ctime/mtime/atime? */ + issued = __ceph_caps_issued(ci, NULL); + ceph_decode_timespec(&mtime, &grant->mtime); + ceph_decode_timespec(&atime, &grant->atime); + ceph_decode_timespec(&ctime, &grant->ctime); + ceph_fill_file_bits(inode, issued, + le64_to_cpu(grant->truncate_seq), size, + le64_to_cpu(grant->time_warp_seq), &ctime, &mtime, + &atime); + + /* max size increase? */ + if (max_size != ci->i_max_size) { + dout(10, "max_size %lld -> %llu\n", ci->i_max_size, max_size); + ci->i_max_size = max_size; + if (max_size >= ci->i_wanted_max_size) { + ci->i_wanted_max_size = 0; /* reset */ + ci->i_requested_max_size = 0; + } + wake = 1; + } + + /* check cap bits */ + wanted = __ceph_caps_wanted(ci); + used = __ceph_caps_used(ci); + dout(10, " my wanted = %d, used = %d\n", wanted, used); + if (wanted != le32_to_cpu(grant->wanted)) { + dout(10, "mds wanted %d -> %d\n", le32_to_cpu(grant->wanted), + wanted); + grant->wanted = cpu_to_le32(wanted); + } + + cap->seq = seq; + + /* file layout may have changed */ + ci->i_layout = grant->layout; + + /* revocation? */ + if (cap->issued & ~newcaps) { + dout(10, "revocation: %d -> %d\n", cap->issued, newcaps); + if ((used & ~newcaps) & CEPH_CAP_WRBUFFER) { + writeback = 1; /* will delay ack */ + } else if (((used & ~newcaps) & CEPH_CAP_RDCACHE) == 0 || + revoked_rdcache) { + /* + * we're not using revoked caps.. ack now. + * re-use incoming message. + */ + cap->implemented = newcaps; + + grant->size = cpu_to_le64(inode->i_size); + grant->max_size = 0; /* don't re-request */ + ceph_encode_timespec(&grant->mtime, &inode->i_mtime); + ceph_encode_timespec(&grant->atime, &inode->i_atime); + grant->time_warp_seq = cpu_to_le64(ci->i_time_warp_seq); + grant->snap_follows = + cpu_to_le64(ci->i_snap_realm->cached_context->seq); + reply = 1; + wake = 1; + } + cap->issued = newcaps; + goto out; + } + + /* grant or no-op */ + if (cap->issued == newcaps) { + dout(10, "caps unchanged: %d -> %d\n", cap->issued, newcaps); + } else { + dout(10, "grant: %d -> %d\n", cap->issued, newcaps); + cap->issued = newcaps; + cap->implemented |= newcaps; /* add bits only, to + * avoid stepping on a + * pending revocation */ + wake = 1; + } + +out: + spin_unlock(&inode->i_lock); + if (writeback) { + /* + * queue inode for writeback: we can't actually call + * filemap_write_and_wait, etc. from message handler + * context. + */ + dout(10, "queueing %p for writeback\n", inode); + if (ceph_queue_writeback(inode)) + igrab(inode); + } + if (invalidate_async) { + dout(10, "queueing %p for page invalidation\n", inode); + if (ceph_queue_page_invalidation(inode)) + igrab(inode); + } + if (wake) + wake_up(&ci->i_cap_wq); + return reply; +} + + +/* + * Handle RELEASE from MDS. That means we can throw away our cap + * state as the MDS has fully flushed that metadata to disk. + */ +static void handle_cap_released(struct inode *inode, + struct ceph_mds_caps *m, + struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int seq = le32_to_cpu(m->seq); + int removed_last; + struct ceph_cap *cap; + + dout(10, "handle_cap_released inode %p ci %p mds%d seq %d\n", inode, ci, + session->s_mds, seq); + + spin_lock(&inode->i_lock); + cap = __get_cap_for_mds(inode, session->s_mds); + BUG_ON(!cap); + removed_last = __ceph_remove_cap(cap); + if (removed_last) + __cap_delay_cancel(&ceph_inode_to_client(inode)->mdsc, ci); + spin_unlock(&inode->i_lock); + if (removed_last) + iput(inode); +} + + +/* + * Handle FLUSHEDSNAP. MDS has flushed snap data to disk and we can + * throw away our cap_snap. + * + * Caller hold s_mutex, snap_rwsem. + */ +static void handle_cap_flushedsnap(struct inode *inode, + struct ceph_mds_caps *m, + struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + u64 follows = le64_to_cpu(m->snap_follows); + struct list_head *p; + struct ceph_cap_snap *capsnap; + int drop = 0; + + dout(10, "handle_cap_flushedsnap inode %p ci %p mds%d follows %lld\n", + inode, ci, session->s_mds, follows); + + spin_lock(&inode->i_lock); + list_for_each(p, &ci->i_cap_snaps) { + capsnap = list_entry(p, struct ceph_cap_snap, ci_item); + if (capsnap->follows == follows) { + WARN_ON(capsnap->dirty || capsnap->writing); + dout(10, " removing cap_snap %p follows %lld\n", + capsnap, follows); + ceph_put_snap_context(capsnap->context); + list_del(&capsnap->ci_item); + kfree(capsnap); + drop = 1; + break; + } else { + dout(10, " skipping cap_snap %p follows %lld\n", + capsnap, capsnap->follows); + } + } + spin_unlock(&inode->i_lock); + if (drop) + iput(inode); +} + + +/* + * Handle TRUNC from MDS, indicating file truncation. + * + * caller hold s_mutex, NOT snap_rwsem. + */ +static void handle_cap_trunc(struct inode *inode, + struct ceph_mds_caps *trunc, + struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int mds = session->s_mds; + int seq = le32_to_cpu(trunc->seq); + u64 size = le64_to_cpu(trunc->size); + int queue_trunc = 0; + + dout(10, "handle_cap_trunc inode %p ci %p mds%d seq %d\n", inode, ci, + mds, seq); + + /* + * vmtruncate lazily; we can't block on i_mutex in the message + * handler path, or we deadlock against osd op replies needed + * to complete the writes holding i_lock. vmtruncate will + * also block on page locks held by writes... + * + * if its an expansion, and there is no truncate pending, we + * don't need to truncate. + */ + spin_lock(&inode->i_lock); + if (ci->i_vmtruncate_to < 0 && size > inode->i_size) { + dout(10, "clean fwd truncate, no vmtruncate needed\n"); + } else if (ci->i_vmtruncate_to >= 0 && size >= ci->i_vmtruncate_to) { + dout(10, "trunc to %lld < %lld already queued\n", + ci->i_vmtruncate_to, size); + } else { + /* we need to trunc even smaller */ + dout(10, "queueing trunc %lld -> %lld\n", inode->i_size, size); + ci->i_vmtruncate_to = size; + queue_trunc = 1; + } + i_size_write(inode, size); + ci->i_reported_size = size; + spin_unlock(&inode->i_lock); + + if (queue_trunc) { + if (queue_work(ceph_client(inode->i_sb)->trunc_wq, + &ci->i_vmtruncate_work)) + igrab(inode); + } +} + +/* + * Handle EXPORT from MDS. Cap is being migrated _from_ this mds to a + * different one. If we are the most recent migration we've seen (as + * indicated by mseq), make note of the migrating cap bits for the + * duration (until we see the corresponding IMPORT). + * + * caller holds s_mutex, snap_rwsem + */ +static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex, + struct ceph_mds_session *session) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int mds = session->s_mds; + unsigned mseq = le32_to_cpu(ex->migrate_seq); + struct ceph_cap *cap = NULL, *t; + struct rb_node *p; + int was_last = 0; + int remember = 1; + + dout(10, "handle_cap_export inode %p ci %p mds%d mseq %d\n", + inode, ci, mds, mseq); + + spin_lock(&inode->i_lock); + + /* make sure we haven't seen a higher mseq */ + for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) { + t = rb_entry(p, struct ceph_cap, ci_node); + if (t->mseq > mseq) { + dout(10, " higher mseq on cap from mds%d\n", + t->session->s_mds); + remember = 0; + } + if (t->session->s_mds == mds) + cap = t; + } + + if (cap) { + if (remember) { + /* make note */ + ci->i_cap_exporting_mds = mds; + ci->i_cap_exporting_mseq = mseq; + ci->i_cap_exporting_issued = cap->issued; + } + was_last = __ceph_remove_cap(cap); + } else { + WARN_ON(!cap); + } + + spin_unlock(&inode->i_lock); + if (was_last) + iput(inode); +} + +/* + * Handle cap IMPORT. If there are temp bits from an older EXPORT, + * clean them up. + * + * caller holds s_mutex, snap_rwsem + */ +static void handle_cap_import(struct inode *inode, struct ceph_mds_caps *im, + struct ceph_mds_session *session, + void *snaptrace, int snaptrace_len) +{ + struct ceph_inode_info *ci = ceph_inode(inode); + int mds = session->s_mds; + unsigned issued = le32_to_cpu(im->caps); + unsigned seq = le32_to_cpu(im->seq); + unsigned mseq = le32_to_cpu(im->migrate_seq); + + if (ci->i_cap_exporting_mds >= 0 && + ci->i_cap_exporting_mseq < mseq) { + dout(10, "handle_cap_import inode %p ci %p mds%d mseq %d" + " - cleared exporting from mds%d\n", + inode, ci, mds, mseq, + ci->i_cap_exporting_mds); + ci->i_cap_exporting_issued = 0; + ci->i_cap_exporting_mseq = 0; + ci->i_cap_exporting_mds = -1; + } else { + dout(10, "handle_cap_import inode %p ci %p mds%d mseq %d\n", + inode, ci, mds, mseq); + } + + ceph_add_cap(inode, session, -1, issued, seq, mseq, + snaptrace, snaptrace_len, NULL); +} + + +/* + * Handle a CEPH_CAPS message from the MDS. + * + * Identify the appropriate session, inode, and call the right handler + * based on the cap op. Take read or write lock on snap_rwsem as + * appropriate. + */ +void ceph_handle_caps(struct ceph_mds_client *mdsc, + struct ceph_msg *msg) +{ + struct super_block *sb = mdsc->client->sb; + struct ceph_mds_session *session; + struct inode *inode; + struct ceph_mds_caps *h; + int mds = le32_to_cpu(msg->hdr.src.name.num); + int op; + u32 seq; + struct ceph_vino vino; + u64 size, max_size; + int check_caps = 0; + + dout(10, "handle_caps from mds%d\n", mds); + + /* decode */ + if (msg->front.iov_len < sizeof(*h)) + goto bad; + h = msg->front.iov_base; + op = le32_to_cpu(h->op); + vino.ino = le64_to_cpu(h->ino); + vino.snap = CEPH_NOSNAP; + seq = le32_to_cpu(h->seq); + size = le64_to_cpu(h->size); + max_size = le64_to_cpu(h->max_size); + + /* find session */ + mutex_lock(&mdsc->mutex); + session = __ceph_get_mds_session(mdsc, mds); + if (session) + down_write(&mdsc->snap_rwsem); + mutex_unlock(&mdsc->mutex); + if (!session) { + dout(10, "WTF, got cap but no session for mds%d\n", mds); + return; + } + + mutex_lock(&session->s_mutex); + session->s_seq++; + dout(20, " mds%d seq %lld\n", session->s_mds, session->s_seq); + + /* lookup ino */ + inode = ceph_find_inode(sb, vino); + dout(20, " op %s ino %llx inode %p\n", ceph_cap_op_name(op), vino.ino, + inode); + if (!inode) { + dout(10, " i don't have ino %llx, sending release\n", vino.ino); + send_cap_msg(mdsc, vino.ino, CEPH_CAP_OP_RELEASE, 0, 0, seq, + size, 0, 0, NULL, NULL, 0, 0, mds); + goto no_inode; + } + + switch (op) { + case CEPH_CAP_OP_GRANT: + up_write(&mdsc->snap_rwsem); + if (handle_cap_grant(inode, h, session) == 1) { + dout(10, " sending reply back to mds%d\n", mds); + ceph_msg_get(msg); + ceph_send_msg_mds(mdsc, msg, mds); + } + break; + + case CEPH_CAP_OP_TRUNC: + up_write(&mdsc->snap_rwsem); + handle_cap_trunc(inode, h, session); + break; + + case CEPH_CAP_OP_RELEASED: + handle_cap_released(inode, h, session); + up_write(&mdsc->snap_rwsem); + if (list_empty(&session->s_caps)) + ceph_mdsc_flushed_all_caps(mdsc, session); + break; + + case CEPH_CAP_OP_FLUSHEDSNAP: + handle_cap_flushedsnap(inode, h, session); + up_write(&mdsc->snap_rwsem); + break; + + case CEPH_CAP_OP_EXPORT: + handle_cap_export(inode, h, session); + up_write(&mdsc->snap_rwsem); + if (list_empty(&session->s_caps)) + ceph_mdsc_flushed_all_caps(mdsc, session); + break; + + case CEPH_CAP_OP_IMPORT: + handle_cap_import(inode, h, session, + msg->front.iov_base + sizeof(*h), + le32_to_cpu(h->snap_trace_len)); + up_write(&mdsc->snap_rwsem); + check_caps = 1; /* we may have sent a RELEASE to the old auth */ + break; + + default: + up_write(&mdsc->snap_rwsem); + derr(10, " unknown cap op %d %s\n", op, ceph_cap_op_name(op)); + } + +no_inode: + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + + if (check_caps) + ceph_check_caps(ceph_inode(inode), 1); + if (inode) + iput(inode); + return; + +bad: + derr(10, "corrupt caps message\n"); + return; +} + + +/* + * Delayed work handler to process end of delayed cap release LRU list. + */ +void ceph_check_delayed_caps(struct ceph_mds_client *mdsc) +{ + struct ceph_inode_info *ci; + + dout(10, "check_delayed_caps\n"); + while (1) { + spin_lock(&mdsc->cap_delay_lock); + if (list_empty(&mdsc->cap_delay_list)) + break; + ci = list_first_entry(&mdsc->cap_delay_list, + struct ceph_inode_info, + i_cap_delay_list); + if (time_before(jiffies, ci->i_hold_caps_until)) + break; + list_del_init(&ci->i_cap_delay_list); + spin_unlock(&mdsc->cap_delay_lock); + dout(10, "check_delayed_caps on %p\n", &ci->vfs_inode); + ceph_check_caps(ci, 1); + iput(&ci->vfs_inode); + } + spin_unlock(&mdsc->cap_delay_lock); +} + -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 14/19] ceph: snapshot management 2008-11-14 0:56 ` [PATCH 13/19] ceph: capability management Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 15/19] ceph: messenger library Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Ceph snapshots rely on client cooperation in determining which operations apply to which snapshots, and appropriately flushing snapshotted data and metadata back to the OSD and MDS clusters. Because snapshots apply to subtrees of the file hierarchy and can be created at any time, there is a fair bit of bookkeeping required to make this work. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/snap.c | 753 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 753 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/snap.c diff --git a/fs/ceph/snap.c b/fs/ceph/snap.c new file mode 100644 index 0000000..21fdba2 --- /dev/null +++ b/fs/ceph/snap.c @@ -0,0 +1,753 @@ + +#include <linux/radix-tree.h> +#include <linux/sort.h> + +#include "ceph_debug.h" + +int ceph_debug_snap = -1; +#define DOUT_MASK DOUT_MASK_SNAP +#define DOUT_VAR ceph_debug_snap +#define DOUT_PREFIX "snap: " + +#include "super.h" +#include "decode.h" + +/* + * Snapshots in ceph are driven in large part by cooperation from the + * client. In contrast to local file systems or file servers that + * implement snapshots at a single point in the system, ceph's + * distributed access to storage requires clients to help decide + * whether a write logically occurs before or after a recently created + * snapshot. + * + * This provides a perfect instantanous client-wide snapshot. Between + * clients, however, snapshots may appear to be applied at slightly + * different points in time, depending on delays in delivering the + * snapshot notification. + * + * Snapshots are _not_ file system-wide. Instead, each snapshot + * applies to the subdirectory nested beneath some directory. This + * effectively divides the hierarchy into multiple "realms," where all + * of the files contained by each realm share the same set of + * snapshots. An individual realm's snap set contains snapshots + * explicitly created on that realm, as well as any snaps in its + * parent's snap set _after_ the point at which the parent became it's + * parent (due to, say, a rename). Similarly, snaps from prior parents + * during the time intervals during which they were the parent are included. + * + * The client is spared most of this detail, fortunately... it must only + * maintains a hierarchy of realms reflecting the current parent/child + * realm relationship, and for each realm has an explicit list of snaps + * inherited from prior parents. + * + * A snap_realm struct is maintained for realms containing every inode + * with an open cap in the system. (The needed snap realm information is + * provided by the MDS whenever a cap is issued, i.e., on open.) A 'seq' + * version number is used to ensure that as realm parameters change (new + * snapshot, new parent, etc.) the client's realm hierarchy is updated. + * + * The realm hierarchy drives the generation of a 'snap context' for each + * realm, which simply lists the resulting set of snaps for the realm. This + * is attached to any writes sent to OSDs. + */ + +/* + * Unfortunately error handling is a bit mixed here. If we get a snap + * update, but don't have enough memory to update our realm hierarchy, + * it's not clear what we can do about it (besides complaining to the + * console). + */ + +/* + * find/create the realm rooted at @ino and bump its ref count. + * + * caller must hold snap_rwsem for write. + */ +static +struct ceph_snap_realm *ceph_get_snap_realm(struct ceph_mds_client *mdsc, + u64 ino) +{ + struct ceph_snap_realm *realm; + + realm = radix_tree_lookup(&mdsc->snap_realms, ino); + if (!realm) { + realm = kzalloc(sizeof(*realm), GFP_NOFS); + if (!realm) + return ERR_PTR(-ENOMEM); + radix_tree_insert(&mdsc->snap_realms, ino, realm); + realm->nref = 0; /* tree does not take a ref */ + realm->ino = ino; + INIT_LIST_HEAD(&realm->children); + INIT_LIST_HEAD(&realm->child_item); + INIT_LIST_HEAD(&realm->inodes_with_caps); + dout(20, "get_snap_realm created %llx %p\n", realm->ino, realm); + } + dout(20, "get_snap_realm %llx %p %d -> %d\n", realm->ino, realm, + realm->nref, realm->nref+1); + realm->nref++; + return realm; +} + +/* + * caller must hold snap_rwsem for write + */ +void ceph_put_snap_realm(struct ceph_mds_client *mdsc, + struct ceph_snap_realm *realm) +{ + dout(20, "put_snap_realm %llx %p %d -> %d\n", realm->ino, realm, + realm->nref, realm->nref-1); + realm->nref--; + if (realm->nref == 0) { + if (realm->parent) { + list_del_init(&realm->child_item); + ceph_put_snap_realm(mdsc, realm->parent); + } + radix_tree_delete(&mdsc->snap_realms, realm->ino); + kfree(realm->prior_parent_snaps); + kfree(realm->snaps); + ceph_put_snap_context(realm->cached_context); + kfree(realm); + } +} + +/* + * adjust the parent realm of a given @realm. adjust child list, and parent + * pointers, and ref counts appropriately. + * + * return true if parent was changed, 0 if unchanged, <0 on error. + * + * caller must hold snap_rwsem for write. + */ +static int adjust_snap_realm_parent(struct ceph_mds_client *mdsc, + struct ceph_snap_realm *realm, + u64 parentino) +{ + struct ceph_snap_realm *parent; + + if (realm->parent_ino == parentino) + return 0; + + parent = ceph_get_snap_realm(mdsc, parentino); + if (IS_ERR(parent)) + return PTR_ERR(parent); + dout(20, "adjust_snap_realm_parent %llx %p: %llx %p -> %llx %p\n", + realm->ino, realm, realm->parent_ino, realm->parent, + parentino, parent); + if (realm->parent) { + list_del_init(&realm->child_item); + ceph_put_snap_realm(mdsc, realm->parent); + } + realm->parent_ino = parentino; + realm->parent = parent; + list_add(&realm->child_item, &parent->children); + return 1; +} + + +static int cmpu64_rev(const void *a, const void *b) +{ + if (*(u64 *)a < *(u64 *)b) + return 1; + if (*(u64 *)a > *(u64 *)b) + return -1; + return 0; +} + +/* + * build the snap context for a given realm. + */ +static int build_snap_context(struct ceph_snap_realm *realm) +{ + struct ceph_snap_realm *parent = realm->parent; + struct ceph_snap_context *snapc; + int err = 0; + int i; + int num = realm->num_prior_parent_snaps + realm->num_snaps; + + /* + * build parent context, if it hasn't been built. + * conservatively estimate that all parent snaps might be + * included by us. + */ + if (parent) { + if (!parent->cached_context) { + err = build_snap_context(parent); + if (err) + goto fail; + } + num += parent->cached_context->num_snaps; + } + + /* do i actually need to update? not if my context seq + matches realm seq, and my parents' does to. (this works + because we rebuild_snap_realms() works _downward_ in + hierarchy after each update.) */ + if (realm->cached_context && + realm->cached_context->seq <= realm->seq && + (!parent || + realm->cached_context->seq <= parent->cached_context->seq)) { + dout(10, "build_snap_context %llx %p: %p seq %lld (%d snaps)" + " (unchanged)\n", + realm->ino, realm, realm->cached_context, + realm->cached_context->seq, + realm->cached_context->num_snaps); + return 0; + } + + /* alloc new snap context */ + err = -ENOMEM; + snapc = kzalloc(sizeof(*snapc) + num*sizeof(u64), GFP_NOFS); + if (!snapc) + goto fail; + atomic_set(&snapc->nref, 1); + + /* build (reverse sorted) snap vector */ + num = 0; + snapc->seq = realm->seq; + if (parent) { + /* include any of parent's snaps occuring _after_ my + parent became my parent */ + for (i = 0; i < parent->cached_context->num_snaps; i++) + if (parent->cached_context->snaps[i] >= + realm->parent_since) + snapc->snaps[num++] = + parent->cached_context->snaps[i]; + if (parent->cached_context->seq > snapc->seq) + snapc->seq = parent->cached_context->seq; + } + memcpy(snapc->snaps + num, realm->snaps, + sizeof(u64)*realm->num_snaps); + num += realm->num_snaps; + memcpy(snapc->snaps + num, realm->prior_parent_snaps, + sizeof(u64)*realm->num_prior_parent_snaps); + num += realm->num_prior_parent_snaps; + + sort(snapc->snaps, num, sizeof(u64), cmpu64_rev, NULL); + snapc->num_snaps = num; + dout(10, "build_snap_context %llx %p: %p seq %lld (%d snaps)\n", + realm->ino, realm, snapc, snapc->seq, snapc->num_snaps); + + if (realm->cached_context) + ceph_put_snap_context(realm->cached_context); + realm->cached_context = snapc; + return 0; + +fail: + /* + * if we fail, clear old (incorrect) cached_context... hopefully + * we'll have better luck building it later + */ + if (realm->cached_context) { + ceph_put_snap_context(realm->cached_context); + realm->cached_context = NULL; + } + derr(0, "build_snap_context %llx %p fail %d\n", realm->ino, + realm, err); + return err; +} + +/* + * rebuild snap context for the given realm and all of its children. + */ +static void rebuild_snap_realms(struct ceph_snap_realm *realm) +{ + struct list_head *p; + struct ceph_snap_realm *child; + + dout(10, "rebuild_snap_realms %llx %p\n", realm->ino, realm); + build_snap_context(realm); + + list_for_each(p, &realm->children) { + child = list_entry(p, struct ceph_snap_realm, child_item); + rebuild_snap_realms(child); + } +} + + +/* + * helper to allocate and decode an array of snapids. free prior + * instance, if any. + */ +static int dup_array(u64 **dst, __le64 *src, int num) +{ + int i; + + kfree(*dst); + if (num) { + *dst = kmalloc(sizeof(u64) * num, GFP_NOFS); + if (!*dst) + return -ENOMEM; + for (i = 0; i < num; i++) + (*dst)[i] = le64_to_cpu(src[i]); + } else { + *dst = NULL; + } + return 0; +} + + +/* + * When a snapshot is applied, the size/mtime inode metadata is queued + * in a ceph_cap_snap (one for each snapshot) until writeback + * completes and the metadata can be flushed back to the MDS. + * + * However, if a (sync) write is currently in-progress when we apply + * the snapshot, we have to wait until the write succeeds or fails + * (and a final size/mtime is known). In this case the + * cap_snap->writing = 1, and is said to be "pending." When the write + * finishes, we __ceph_finish_cap_snap(). + * + * Caller must hold snap_rwsem for read (i.e., the realm topology won't + * change). + */ +void ceph_queue_cap_snap(struct ceph_inode_info *ci, + struct ceph_snap_context *snapc) +{ + struct inode *inode = &ci->vfs_inode; + struct ceph_cap_snap *capsnap; + int used; + + capsnap = kzalloc(sizeof(*capsnap), GFP_NOFS); + if (!capsnap) { + derr(10, "ENOMEM allocating ceph_cap_snap on %p\n", inode); + return; + } + + spin_lock(&inode->i_lock); + used = __ceph_caps_used(ci); + if (__ceph_have_pending_cap_snap(ci)) { + /* there is no point in queuing multiple "pending" cap_snaps, + as no new writes are allowed to start when pending, so any + writes in progress now were started before the previous + cap_snap. lucky us. */ + dout(10, "queue_cap_snap %p snapc %p seq %llu used %d" + " already pending\n", inode, snapc, snapc->seq, used); + kfree(capsnap); + } else { + igrab(inode); + capsnap->follows = snapc->seq - 1; + capsnap->context = ceph_get_snap_context(snapc); + capsnap->issued = __ceph_caps_issued(ci, NULL); + /* dirty page count moved from _head to this cap_snap; + all subsequent writes page dirties occur _after_ this + snapshot. */ + capsnap->dirty = ci->i_wrbuffer_ref_head; + ci->i_wrbuffer_ref_head = 0; + ceph_put_snap_context(ci->i_head_snapc); + ci->i_head_snapc = NULL; + list_add_tail(&capsnap->ci_item, &ci->i_cap_snaps); + + if (used & CEPH_CAP_WR) { + dout(10, "queue_cap_snap %p cap_snap %p snapc %p" + " seq %llu used WR, now pending\n", inode, + capsnap, snapc, snapc->seq); + capsnap->writing = 1; + } else { + /* note mtime, size NOW. */ + __ceph_finish_cap_snap(ci, capsnap); + } + } + + spin_unlock(&inode->i_lock); +} + +/* + * Finalize the size, mtime for a cap_snap.. that is, settle on final values + * to be used for the snapshot, to be flushed back to the mds. + * + * If capsnap can now be flushed, add to snap_flush list, and return 1. + * + * Caller must hold i_lock. + */ +int __ceph_finish_cap_snap(struct ceph_inode_info *ci, + struct ceph_cap_snap *capsnap) +{ + struct inode *inode = &ci->vfs_inode; + struct ceph_mds_client *mdsc = &ceph_client(inode->i_sb)->mdsc; + + BUG_ON(capsnap->writing); + capsnap->size = inode->i_size; + capsnap->mtime = inode->i_mtime; + capsnap->atime = inode->i_atime; + capsnap->ctime = inode->i_ctime; + capsnap->time_warp_seq = ci->i_time_warp_seq; + if (capsnap->dirty) { + dout(10, "finish_cap_snap %p cap_snap %p snapc %p %llu s=%llu " + "still has %d dirty pages\n", inode, capsnap, + capsnap->context, capsnap->context->seq, + capsnap->size, capsnap->dirty); + return 0; + } + dout(10, "finish_cap_snap %p cap_snap %p snapc %p %llu s=%llu clean\n", + inode, capsnap, capsnap->context, + capsnap->context->seq, capsnap->size); + + spin_lock(&mdsc->snap_flush_lock); + list_add_tail(&ci->i_snap_flush_item, &mdsc->snap_flush_list); + spin_unlock(&mdsc->snap_flush_lock); + return 1; /* caller may want to ceph_flush_snaps */ +} + + +/* + * Parse and apply a snapblob "snap trace" from the MDS. This specifies + * the snap realm parameters from a given realm and all of its ancestors, + * up to the root. + * + * Caller must hold snap_rwsem for write. + */ +struct ceph_snap_realm *ceph_update_snap_trace(struct ceph_mds_client *mdsc, + void *p, void *e, bool deletion) +{ + struct ceph_mds_snap_realm *ri; /* encoded */ + __le64 *snaps; /* encoded */ + __le64 *prior_parent_snaps; /* encoded */ + struct ceph_snap_realm *realm, *first = NULL; + int invalidate = 0; + int err = -ENOMEM; + + dout(10, "update_snap_trace deletion=%d\n", deletion); +more: + ceph_decode_need(&p, e, sizeof(*ri), bad); + ri = p; + p += sizeof(*ri); + ceph_decode_need(&p, e, sizeof(u64)*(le32_to_cpu(ri->num_snaps) + + le32_to_cpu(ri->num_prior_parent_snaps)), bad); + snaps = p; + p += sizeof(u64) * le32_to_cpu(ri->num_snaps); + prior_parent_snaps = p; + p += sizeof(u64) * le32_to_cpu(ri->num_prior_parent_snaps); + + realm = ceph_get_snap_realm(mdsc, le64_to_cpu(ri->ino)); + if (IS_ERR(realm)) { + err = PTR_ERR(realm); + goto fail; + } + if (!first) { + /* take note if this is the first realm in the trace + * (the most deeply nested)... we will return if (with + * nref bumped) to the caller. */ + first = realm; + realm->nref++; + } + + if (le64_to_cpu(ri->seq) > realm->seq) { + dout(10, "update_snap_trace updating %llx %p %lld -> %lld\n", + realm->ino, realm, realm->seq, le64_to_cpu(ri->seq)); + /* + * if the realm seq has changed, queue a cap_snap for every + * inode with open caps. we do this _before_ we update + * the realm info so that we prepare for writeback under the + * _previous_ snap context. + * + * ...unless it's a snap deletion! + */ + if (!deletion) { + struct list_head *pi; + + list_for_each(pi, &realm->inodes_with_caps) { + struct ceph_inode_info *ci = + list_entry(pi, struct ceph_inode_info, + i_snap_realm_item); + ceph_queue_cap_snap(ci, realm->cached_context); + } + dout(20, "update_snap_trace cap_snaps queued\n"); + } + + } else { + dout(10, "update_snap_trace %llx %p seq %lld unchanged\n", + realm->ino, realm, realm->seq); + } + + /* ensure the parent is correct */ + err = adjust_snap_realm_parent(mdsc, realm, le64_to_cpu(ri->parent)); + if (err < 0) + goto fail; + invalidate += err; + + if (le64_to_cpu(ri->seq) > realm->seq) { + /* update realm parameters, snap lists */ + realm->seq = le64_to_cpu(ri->seq); + realm->created = le64_to_cpu(ri->created); + realm->parent_since = le64_to_cpu(ri->parent_since); + + realm->num_snaps = le32_to_cpu(ri->num_snaps); + err = dup_array(&realm->snaps, snaps, realm->num_snaps); + if (err < 0) + goto fail; + + realm->num_prior_parent_snaps = + le32_to_cpu(ri->num_prior_parent_snaps); + err = dup_array(&realm->prior_parent_snaps, prior_parent_snaps, + realm->num_prior_parent_snaps); + if (err < 0) + goto fail; + + invalidate = 1; + } else if (!realm->cached_context) { + invalidate = 1; + } + + dout(10, "done with %llx %p, invalidated=%d, %p %p\n", realm->ino, + realm, invalidate, p, e); + + /* invalidate when we reach the _end_ (root) of the trace */ + if (p == e && invalidate) + rebuild_snap_realms(realm); + + ceph_put_snap_realm(mdsc, realm); + if (p < e) + goto more; + + return first; + +bad: + err = -EINVAL; +fail: + derr(10, "update_snap_trace error %d\n", err); + return ERR_PTR(err); +} + + +/* + * Send any cap_snaps that are queued for flush. Try to carry + * s_mutex across multiple snap flushes to avoid locking overhead. + * + * Caller holds no locks. + */ +static void flush_snaps(struct ceph_mds_client *mdsc) +{ + struct ceph_inode_info *ci; + struct inode *inode; + struct ceph_mds_session *session = NULL; + + dout(10, "flush_snaps\n"); + spin_lock(&mdsc->snap_flush_lock); + while (!list_empty(&mdsc->snap_flush_list)) { + ci = list_entry(mdsc->snap_flush_list.next, + struct ceph_inode_info, i_snap_flush_item); + inode = &ci->vfs_inode; + igrab(inode); + spin_unlock(&mdsc->snap_flush_lock); + spin_lock(&inode->i_lock); + __ceph_flush_snaps(ci, &session); + spin_unlock(&inode->i_lock); + iput(inode); + spin_lock(&mdsc->snap_flush_lock); + } + spin_unlock(&mdsc->snap_flush_lock); + + if (session) { + mutex_unlock(&session->s_mutex); + ceph_put_mds_session(session); + } + dout(10, "flush_snaps done\n"); +} + + +/* + * Handle a snap notification from the MDS. + * + * This can take two basic forms: the simplest is just a snap creation + * or deletion notification on an existing realm. This should update the + * realm and its children. + * + * The more difficult case is realm creation, due to snap creation at a + * new point in the file hierarchy, or due to a rename that moves a file or + * directory into another realm. + */ +void ceph_handle_snap(struct ceph_mds_client *mdsc, + struct ceph_msg *msg) +{ + struct super_block *sb = mdsc->client->sb; + struct ceph_mds_session *session; + int mds; + u64 split; + int op; + int trace_len; + struct ceph_snap_realm *realm = NULL; + void *p = msg->front.iov_base; + void *e = p + msg->front.iov_len; + struct ceph_mds_snap_head *h; + int num_split_inos, num_split_realms; + __le64 *split_inos = NULL, *split_realms = NULL; + int i; + int locked_rwsem = 0; + + if (le32_to_cpu(msg->hdr.src.name.type) != CEPH_ENTITY_TYPE_MDS) + return; + mds = le32_to_cpu(msg->hdr.src.name.num); + + /* decode */ + if (msg->front.iov_len < sizeof(*h)) + goto bad; + h = p; + op = le32_to_cpu(h->op); + split = le64_to_cpu(h->split); /* non-zero if we are splitting an + * existing realm */ + num_split_inos = le32_to_cpu(h->num_split_inos); + num_split_realms = le32_to_cpu(h->num_split_realms); + trace_len = le32_to_cpu(h->trace_len); + p += sizeof(*h); + + dout(10, "handle_snap from mds%d op %s split %llx tracelen %d\n", mds, + ceph_snap_op_name(op), split, trace_len); + + /* find session */ + mutex_lock(&mdsc->mutex); + session = __ceph_get_mds_session(mdsc, mds); + if (session) + down_write(&mdsc->snap_rwsem); + mutex_unlock(&mdsc->mutex); + if (!session) { + dout(10, "WTF, got snap but no session for mds%d\n", mds); + return; + } + locked_rwsem = 1; + + mutex_lock(&session->s_mutex); + session->s_seq++; + mutex_unlock(&session->s_mutex); + + if (op == CEPH_SNAP_OP_SPLIT) { + struct ceph_mds_snap_realm *ri; + + /* + * A "split" breaks part of an existing realm off into + * a new realm. The MDS provides a list of inodes + * (with caps) and child realms that belong to the new + * child. + */ + split_inos = p; + p += sizeof(u64) * num_split_inos; + split_realms = p; + p += sizeof(u64) * num_split_realms; + ceph_decode_need(&p, e, sizeof(*ri), bad); + /* we will peek at realm info here, but will _not_ + * advance p, as the realm update will occur below in + * ceph_update_snap_trace. */ + ri = p; + + realm = ceph_get_snap_realm(mdsc, split); + if (IS_ERR(realm)) + goto out; + + dout(10, "splitting snap_realm %llx %p\n", realm->ino, realm); + for (i = 0; i < num_split_inos; i++) { + struct ceph_vino vino = { + .ino = le64_to_cpu(split_inos[i]), + .snap = CEPH_NOSNAP, + }; + struct inode *inode = ceph_find_inode(sb, vino); + struct ceph_inode_info *ci; + + if (!inode) + continue; + ci = ceph_inode(inode); + + spin_lock(&inode->i_lock); + if (!ci->i_snap_realm) + goto skip_inode; + /* + * If this inode belongs to a realm that was + * created after our new realm, we experienced + * a race (due to another split notifications + * arriving from a different MDS). So skip + * this inode. + */ + if (ci->i_snap_realm->created > + le64_to_cpu(ri->created)) { + dout(15, " leaving %p in newer realm %llx %p\n", + inode, ci->i_snap_realm->ino, + ci->i_snap_realm); + goto skip_inode; + } + dout(15, " will move %p to split realm %llx %p\n", + inode, realm->ino, realm); + /* + * Remove the inode from the realm's inode + * list, but don't add it to the new realm + * yet. We don't want the cap_snap to be + * queued (again) by ceph_update_snap_trace() + * below. Queue it _now_, under the old context. + */ + list_del_init(&ci->i_snap_realm_item); + spin_unlock(&inode->i_lock); + + ceph_queue_cap_snap(ci, + ci->i_snap_realm->cached_context); + + iput(inode); + continue; + + skip_inode: + spin_unlock(&inode->i_lock); + iput(inode); + } + + /* we may have taken some of the old realm's children. */ + for (i = 0; i < num_split_realms; i++) { + struct ceph_snap_realm *child = + ceph_get_snap_realm(mdsc, + le64_to_cpu(split_realms[i])); + if (IS_ERR(child)) + continue; + adjust_snap_realm_parent(mdsc, child, realm->ino); + ceph_put_snap_realm(mdsc, child); + } + } + + /* + * update using the provided snap trace. if we are deleting a + * snap, we can avoid queueing cap_snaps. + */ + realm = ceph_update_snap_trace(mdsc, p, e, + op == CEPH_SNAP_OP_DESTROY); + if (IS_ERR(realm)) + goto bad; + + if (op == CEPH_SNAP_OP_SPLIT) { + /* + * ok, _now_ add the inodes into the new realm. + */ + for (i = 0; i < num_split_inos; i++) { + struct ceph_vino vino = { + .ino = le64_to_cpu(split_inos[i]), + .snap = CEPH_NOSNAP, + }; + struct inode *inode = ceph_find_inode(sb, vino); + struct ceph_inode_info *ci; + + if (!inode) + continue; + ci = ceph_inode(inode); + spin_lock(&inode->i_lock); + ceph_put_snap_realm(mdsc, ci->i_snap_realm); + list_add(&ci->i_snap_realm_item, + &realm->inodes_with_caps); + ci->i_snap_realm = realm; + realm->nref++; + spin_unlock(&inode->i_lock); + iput(inode); + } + + /* we took a reference when we created the realm, above */ + ceph_put_snap_realm(mdsc, realm); + } + + ceph_put_snap_realm(mdsc, realm); + up_write(&mdsc->snap_rwsem); + + flush_snaps(mdsc); + return; + +bad: + derr(10, "corrupt snap message from mds%d\n", mds); +out: + if (locked_rwsem) + up_write(&mdsc->snap_rwsem); + return; +} + + + -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 15/19] ceph: messenger library 2008-11-14 0:56 ` [PATCH 14/19] ceph: snapshot management Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 16/19] ceph: nfs re-export support Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil A generic message passing library is used to communicate with all other components in the Ceph file system. The messenger library provides ordered, reliable delivery of messages between two nodes in the system, or notifies the higher layer when it is unable to do so. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/decode.h | 151 ++++ fs/ceph/messenger.c | 2304 +++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/messenger.h | 269 ++++++ 3 files changed, 2724 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/decode.h create mode 100644 fs/ceph/messenger.c create mode 100644 fs/ceph/messenger.h diff --git a/fs/ceph/decode.h b/fs/ceph/decode.h new file mode 100644 index 0000000..c34de0a --- /dev/null +++ b/fs/ceph/decode.h @@ -0,0 +1,151 @@ +#ifndef __CEPH_DECODE_H +#define __CEPH_DECODE_H + +/* + * in all cases, + * void **p pointer to position pointer + * void *end pointer to end of buffer (last byte + 1) + */ + +/* + * bounds check input. + */ +#define ceph_decode_need(p, end, n, bad) \ + do { \ + if (unlikely(*(p) + (n) > (end))) \ + goto bad; \ + } while (0) + +#define ceph_decode_64(p, v) \ + do { \ + v = le64_to_cpu(*(__le64 *)*(p)); \ + *(p) += sizeof(u64); \ + } while (0) +#define ceph_decode_32(p, v) \ + do { \ + v = le32_to_cpu(*(__le32 *)*(p)); \ + *(p) += sizeof(u32); \ + } while (0) +#define ceph_decode_16(p, v) \ + do { \ + v = le16_to_cpu(*(__le16 *)*(p)); \ + *(p) += sizeof(u16); \ + } while (0) +#define ceph_decode_8(p, v) \ + do { \ + v = *(u8 *)*(p); \ + (*p)++; \ + } while (0) + +/* decode into an __le## */ +#define ceph_decode_64_le(p, v) \ + do { \ + v = *(__le64 *)*(p); \ + *(p) += sizeof(u64); \ + } while (0) +#define ceph_decode_32_le(p, v) \ + do { \ + v = *(__le32 *)*(p); \ + *(p) += sizeof(u32); \ + } while (0) +#define ceph_decode_16_le(p, v) \ + do { \ + v = *(__le16 *)*(p); \ + *(p) += sizeof(u16); \ + } while (0) + +#define ceph_decode_copy(p, pv, n) \ + do { \ + memcpy(pv, *(p), n); \ + *(p) += n; \ + } while (0) + +/* bounds check too */ +#define ceph_decode_64_safe(p, end, v, bad) \ + do { \ + ceph_decode_need(p, end, sizeof(u64), bad); \ + ceph_decode_64(p, v); \ + } while (0) +#define ceph_decode_32_safe(p, end, v, bad) \ + do { \ + ceph_decode_need(p, end, sizeof(u32), bad); \ + ceph_decode_32(p, v); \ + } while (0) +#define ceph_decode_16_safe(p, end, v, bad) \ + do { \ + ceph_decode_need(p, end, sizeof(u16), bad); \ + ceph_decode_16(p, v); \ + } while (0) + +#define ceph_decode_copy_safe(p, end, pv, n, bad) \ + do { \ + ceph_decode_need(p, end, n, bad); \ + ceph_decode_copy(p, pv, n); \ + } while (0) + +/* + * struct ceph_timespec <-> struct timespec + */ +#define ceph_decode_timespec(ts, tv) \ + do { \ + (ts)->tv_sec = le32_to_cpu((tv)->tv_sec); \ + (ts)->tv_nsec = le32_to_cpu((tv)->tv_nsec); \ + } while (0) +#define ceph_encode_timespec(tv, ts) \ + do { \ + (tv)->tv_sec = cpu_to_le32((ts)->tv_sec); \ + (tv)->tv_nsec = cpu_to_le32((ts)->tv_nsec); \ + } while (0) + + +/* + * encoders + */ +#define ceph_encode_64(p, v) \ + do { \ + *(__le64 *)*(p) = cpu_to_le64((v)); \ + *(p) += sizeof(u64); \ + } while (0) +#define ceph_encode_32(p, v) \ + do { \ + *(__le32 *)*(p) = cpu_to_le32((v)); \ + *(p) += sizeof(u32); \ + } while (0) +#define ceph_encode_16(p, v) \ + do { \ + *(__le16 *)*(p) = cpu_to_le16((v)); \ + *(p) += sizeof(u16); \ + } while (0) +#define ceph_encode_8(p, v) \ + do { \ + *(u8 *)*(p) = v; \ + (*(p))++; \ + } while (0) + +/* + * filepath, string encoders + */ +static inline void ceph_encode_filepath(void **p, void *end, + u64 ino, const char *path) +{ + u32 len = path ? strlen(path) : 0; + BUG_ON(*p + sizeof(ino) + sizeof(len) + len > end); + ceph_encode_64(p, ino); + ceph_encode_32(p, len); + if (len) + memcpy(*p, path, len); + *p += len; +} + +static inline void ceph_encode_string(void **p, void *end, + const char *s, u32 len) +{ + BUG_ON(*p + sizeof(len) + len > end); + ceph_encode_32(p, len); + if (len) + memcpy(*p, s, len); + *p += len; +} + + +#endif diff --git a/fs/ceph/messenger.c b/fs/ceph/messenger.c new file mode 100644 index 0000000..7aec3bc --- /dev/null +++ b/fs/ceph/messenger.c @@ -0,0 +1,2304 @@ +#include <linux/crc32c.h> +#include <linux/kthread.h> +#include <linux/socket.h> +#include <linux/net.h> +#include <linux/string.h> +#include <linux/highmem.h> +#include <net/tcp.h> + +#include "ceph_debug.h" +int ceph_debug_msgr; +#define DOUT_MASK DOUT_MASK_MSGR +#define DOUT_VAR ceph_debug_msgr +#define DOUT_PREFIX "msgr: " + +#include "super.h" +#include "messenger.h" + + + +/* static tag bytes (protocol control messages) */ +static char tag_msg = CEPH_MSGR_TAG_MSG; +static char tag_ack = CEPH_MSGR_TAG_ACK; + + +static void ceph_queue_con(struct ceph_connection *con); +static void con_work(struct work_struct *); +static void ceph_fault(struct ceph_connection *con); + + +/* + * work queue for all reading and writing to/from the socket. + */ +struct workqueue_struct *ceph_msgr_wq; + +int ceph_msgr_init(void) +{ + ceph_msgr_wq = create_workqueue("ceph-msgr"); + if (IS_ERR(ceph_msgr_wq)) { + int ret = PTR_ERR(ceph_msgr_wq); + derr(0, "failed to create workqueue: %d\n", ret); + ceph_msgr_wq = NULL; + return ret; + } + return 0; +} + +void ceph_msgr_exit(void) +{ + destroy_workqueue(ceph_msgr_wq); +} + + +/* + * socket callback functions + */ + +/* listen socket received a connection */ +static void ceph_accept_ready(struct sock *sk, int count_unused) +{ + struct ceph_messenger *msgr = (struct ceph_messenger *)sk->sk_user_data; + + dout(30, "ceph_accept_ready messenger %p sk_state = %u\n", + msgr, sk->sk_state); + if (sk->sk_state == TCP_LISTEN) + queue_work(ceph_msgr_wq, &msgr->awork); +} + +/* data available on socket, or listen socket received a connect */ +static void ceph_data_ready(struct sock *sk, int count_unused) +{ + struct ceph_connection *con = + (struct ceph_connection *)sk->sk_user_data; + if (sk->sk_state != TCP_CLOSE_WAIT) { + dout(30, "ceph_data_ready on %p state = %lu, queueing work\n", + con, con->state); + ceph_queue_con(con); + } +} + +/* socket has buffer space for writing */ +static void ceph_write_space(struct sock *sk) +{ + struct ceph_connection *con = + (struct ceph_connection *)sk->sk_user_data; + + /* only queue to workqueue if there is data we want to write. */ + if (test_bit(WRITE_PENDING, &con->state)) { + dout(30, "ceph_write_space %p queueing write work\n", con); + ceph_queue_con(con); + } else { + dout(30, "ceph_write_space %p nothing to write\n", con); + } + + /* since we have our own write_space, clear the SOCK_NOSPACE flag */ + clear_bit(SOCK_NOSPACE, &sk->sk_socket->flags); +} + +/* socket's state has changed */ +static void ceph_state_change(struct sock *sk) +{ + struct ceph_connection *con = + (struct ceph_connection *)sk->sk_user_data; + + dout(30, "ceph_state_change %p state = %lu sk_state = %u\n", + con, con->state, sk->sk_state); + + if (test_bit(CLOSED, &con->state)) + return; + + switch (sk->sk_state) { + case TCP_CLOSE: + dout(30, "ceph_state_change TCP_CLOSE\n"); + case TCP_CLOSE_WAIT: + dout(30, "ceph_state_change TCP_CLOSE_WAIT\n"); + set_bit(SOCK_CLOSED, &con->state); + if (test_bit(CONNECTING, &con->state)) + con->error_msg = "connection failed"; + else + con->error_msg = "socket closed"; + ceph_queue_con(con); + break; + case TCP_ESTABLISHED: + dout(30, "ceph_state_change TCP_ESTABLISHED\n"); + ceph_queue_con(con); + break; + } +} + +/* + * set up socket callbacks + */ +static void listen_sock_callbacks(struct socket *sock, + struct ceph_messenger *msgr) +{ + struct sock *sk = sock->sk; + sk->sk_user_data = (void *)msgr; + sk->sk_data_ready = ceph_accept_ready; +} + +static void set_sock_callbacks(struct socket *sock, + struct ceph_connection *con) +{ + struct sock *sk = sock->sk; + sk->sk_user_data = (void *)con; + sk->sk_data_ready = ceph_data_ready; + sk->sk_write_space = ceph_write_space; + sk->sk_state_change = ceph_state_change; +} + + +/* + * socket helpers + */ + +/* + * initiate connection to a remote socket. + */ +static struct socket *ceph_tcp_connect(struct ceph_connection *con) +{ + struct sockaddr *paddr = (struct sockaddr *)&con->peer_addr.ipaddr; + struct socket *sock; + int ret; + + BUG_ON(con->sock); + ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); + if (ret) + return ERR_PTR(ret); + con->sock = sock; + sock->sk->sk_allocation = GFP_NOFS; + + set_sock_callbacks(sock, con); + + dout(20, "connect %u.%u.%u.%u:%u\n", + IPQUADPORT(*(struct sockaddr_in *)paddr)); + + ret = sock->ops->connect(sock, paddr, + sizeof(struct sockaddr_in), O_NONBLOCK); + if (ret == -EINPROGRESS) { + dout(20, "connect %u.%u.%u.%u:%u EINPROGRESS sk_state = %u\n", + IPQUADPORT(*(struct sockaddr_in *)paddr), + sock->sk->sk_state); + ret = 0; + } + if (ret < 0) { + derr(1, "connect %u.%u.%u.%u:%u error %d\n", + IPQUADPORT(*(struct sockaddr_in *)paddr), ret); + sock_release(sock); + con->sock = NULL; + con->error_msg = "connect error"; + } + + if (ret < 0) + return ERR_PTR(ret); + return sock; +} + +/* + * set up listening socket + */ +static int ceph_tcp_listen(struct ceph_messenger *msgr) +{ + int ret; + int optval = 1; + struct sockaddr_in *myaddr = &msgr->inst.addr.ipaddr; + int nlen; + struct socket *sock; + + ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); + if (ret) + return ret; + sock->sk->sk_allocation = GFP_NOFS; + ret = kernel_setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, + (char *)&optval, sizeof(optval)); + if (ret < 0) { + derr(0, "failed to set SO_REUSEADDR: %d\n", ret); + goto err; + } + + ret = sock->ops->bind(sock, (struct sockaddr *)myaddr, + sizeof(*myaddr)); + if (ret < 0) { + derr(0, "Failed to bind: %d\n", ret); + goto err; + } + + /* what port did we bind to? */ + nlen = sizeof(*myaddr); + ret = sock->ops->getname(sock, (struct sockaddr *)myaddr, &nlen, + 0); + if (ret < 0) { + derr(0, "failed to getsockname: %d\n", ret); + goto err; + } + dout(0, "listening on %u.%u.%u.%u:%u\n", IPQUADPORT(*myaddr)); + + /* we don't care too much if this works or not */ + sock->ops->listen(sock, CEPH_MSGR_BACKUP); + + /* ok! */ + msgr->listen_sock = sock; + listen_sock_callbacks(sock, msgr); + return 0; + +err: + sock_release(sock); + return ret; +} + +/* + * accept a connection + */ +static int ceph_tcp_accept(struct socket *lsock, struct ceph_connection *con) +{ + struct socket *sock; + int ret; + + ret = sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock); + if (ret) + return ret; + con->sock = sock; + sock->sk->sk_allocation = GFP_NOFS; + + ret = lsock->ops->accept(lsock, sock, O_NONBLOCK); + if (ret < 0) { + derr(0, "accept error: %d\n", ret); + goto err; + } + + sock->ops = lsock->ops; + sock->type = lsock->type; + set_sock_callbacks(sock, con); + return ret; + +err: + sock->ops->shutdown(sock, SHUT_RDWR); + sock_release(sock); + return ret; +} + +static int ceph_tcp_recvmsg(struct socket *sock, void *buf, size_t len) +{ + struct kvec iov = {buf, len}; + struct msghdr msg = { .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL }; + + return kernel_recvmsg(sock, &msg, &iov, 1, len, msg.msg_flags); +} + +/* + * write something. @more is true if caller will be sending more data + * shortly. + */ +static int ceph_tcp_sendmsg(struct socket *sock, struct kvec *iov, + size_t kvlen, size_t len, int more) +{ + struct msghdr msg = { .msg_flags = MSG_DONTWAIT | MSG_NOSIGNAL }; + + if (more) + msg.msg_flags |= MSG_MORE; + else + msg.msg_flags |= MSG_EOR; /* superfluous, but what the hell */ + + return kernel_sendmsg(sock, &msg, iov, kvlen, len); +} + + +/* + * create a new connection. + */ +static struct ceph_connection *new_connection(struct ceph_messenger *msgr) +{ + struct ceph_connection *con; + + con = kzalloc(sizeof(struct ceph_connection), GFP_NOFS); + if (con == NULL) + return NULL; + con->msgr = msgr; + atomic_set(&con->nref, 1); + INIT_LIST_HEAD(&con->list_all); + INIT_LIST_HEAD(&con->list_bucket); + spin_lock_init(&con->out_queue_lock); + INIT_LIST_HEAD(&con->out_queue); + INIT_LIST_HEAD(&con->out_sent); + INIT_DELAYED_WORK(&con->work, con_work); + return con; +} + +/* + * The con_tree radix_tree has an unsigned long key and void * value. + * Since ceph_entity_addr is bigger than that, we use a trivial hash + * key, and point to a list_head in ceph_connection, as you would with + * a hash table. If the trivial hash collides, we just traverse the + * (hopefully short) list until we find what we want. + */ +static unsigned long hash_addr(struct ceph_entity_addr *addr) +{ + unsigned long key; + + key = *(u32 *)&addr->ipaddr.sin_addr.s_addr; + key ^= *(u16 *)&addr->ipaddr.sin_port; + return key; +} + +/* + * Get an existing connection, if any, for given addr. Note that we + * may need to traverse the list_bucket list, which has to "head." + * + * called under con_lock. + */ +static struct ceph_connection *__get_connection(struct ceph_messenger *msgr, + struct ceph_entity_addr *addr) +{ + struct ceph_connection *con = NULL; + struct list_head *head, *p; + unsigned long key = hash_addr(addr); + + head = radix_tree_lookup(&msgr->con_tree, key); + if (head == NULL) + return NULL; + con = list_entry(head, struct ceph_connection, list_bucket); + if (memcmp(&con->peer_addr, addr, sizeof(addr)) == 0) + goto yes; + list_for_each(p, head) { + con = list_entry(p, struct ceph_connection, list_bucket); + if (memcmp(&con->peer_addr, addr, sizeof(addr)) == 0) + goto yes; + } + return NULL; + +yes: + atomic_inc(&con->nref); + dout(20, "get_connection %p nref = %d -> %d\n", con, + atomic_read(&con->nref) - 1, atomic_read(&con->nref)); + return con; +} + + +/* + * Shutdown/close the socket for the given connection. + */ +static int con_close_socket(struct ceph_connection *con) +{ + int rc; + + dout(10, "con_close_socket on %p sock %p\n", con, con->sock); + if (!con->sock) + return 0; + rc = con->sock->ops->shutdown(con->sock, SHUT_RDWR); + sock_release(con->sock); + con->sock = NULL; + return rc; +} + +/* + * drop a reference + */ +static void put_connection(struct ceph_connection *con) +{ + dout(20, "put_connection %p nref = %d -> %d\n", con, + atomic_read(&con->nref), atomic_read(&con->nref) - 1); + BUG_ON(atomic_read(&con->nref) == 0); + if (atomic_dec_and_test(&con->nref)) { + dout(20, "put_connection %p destroying\n", con); + ceph_msg_put_list(&con->out_queue); + ceph_msg_put_list(&con->out_sent); + set_bit(CLOSED, &con->state); + con_close_socket(con); /* silently ignore possible errors */ + kfree(con); + } +} + +/* + * add a connection to the con_tree. + * + * called under con_lock. + */ +static int __register_connection(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + struct list_head *head; + unsigned long key = hash_addr(&con->peer_addr); + int rc = 0; + + dout(20, "register_connection %p %d -> %d\n", con, + atomic_read(&con->nref), atomic_read(&con->nref) + 1); + atomic_inc(&con->nref); + + /* if were just ACCEPTING this connection, it is already on the + * con_all and con_accepting lists. */ + if (test_and_clear_bit(ACCEPTING, &con->state)) { + list_del_init(&con->list_bucket); + put_connection(con); + } else { + list_add(&con->list_all, &msgr->con_all); + } + + head = radix_tree_lookup(&msgr->con_tree, key); + if (head) { + dout(20, "register_connection %p in old bucket %lu head %p\n", + con, key, head); + list_add(&con->list_bucket, head); + } else { + dout(20, "register_connection %p in new bucket %lu head %p\n", + con, key, &con->list_bucket); + INIT_LIST_HEAD(&con->list_bucket); /* empty */ + rc = radix_tree_insert(&msgr->con_tree, key, &con->list_bucket); + if (rc < 0) { + list_del(&con->list_all); + put_connection(con); + return rc; + } + } + set_bit(REGISTERED, &con->state); + return 0; +} + +/* + * called under con_lock. + */ +static void add_connection_accepting(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + dout(20, "add_connection_accepting %p nref = %d -> %d\n", con, + atomic_read(&con->nref), atomic_read(&con->nref) + 1); + atomic_inc(&con->nref); + spin_lock(&msgr->con_lock); + list_add(&con->list_all, &msgr->con_all); + spin_unlock(&msgr->con_lock); +} + +/* + * Remove connection from all list. Also, from con_tree, if it should + * have been there. + * + * called under con_lock. + */ +static void __remove_connection(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + unsigned long key; + void **slot, *val; + + dout(20, "__remove_connection %p\n", con); + if (list_empty(&con->list_all)) { + dout(20, "__remove_connection %p not registered\n", con); + return; + } + list_del_init(&con->list_all); + if (test_bit(REGISTERED, &con->state)) { + key = hash_addr(&con->peer_addr); + if (list_empty(&con->list_bucket)) { + /* last one in this bucket */ + dout(20, "__remove_connection %p and bucket %lu\n", + con, key); + radix_tree_delete(&msgr->con_tree, key); + } else { + /* if we share this bucket, and the radix tree points + * to us, adjust it to point to the next guy. */ + slot = radix_tree_lookup_slot(&msgr->con_tree, key); + val = radix_tree_deref_slot(slot); + dout(20, "__remove_connection %p from bucket %lu " + "head %p\n", con, key, val); + if (val == &con->list_bucket) { + dout(20, "__remove_connection adjusting bucket" + " for %lu to next item, %p\n", key, + con->list_bucket.next); + radix_tree_replace_slot(slot, + con->list_bucket.next); + } + list_del_init(&con->list_bucket); + } + } + if (test_and_clear_bit(ACCEPTING, &con->state)) + list_del_init(&con->list_bucket); + put_connection(con); +} + +static void remove_connection(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + spin_lock(&msgr->con_lock); + __remove_connection(msgr, con); + spin_unlock(&msgr->con_lock); +} + +/* + * replace another connection + * (old and new should be for the _same_ peer, + * and thus in the same bucket in the radix tree) + */ +static void __replace_connection(struct ceph_messenger *msgr, + struct ceph_connection *old, + struct ceph_connection *new) +{ + dout(10, "replace_connection %p with %p\n", old, new); + + /* replace in con_tree */ + if (list_empty(&old->list_bucket)) { + /* oh, just replace old with new in bucket list */ + list_add(&new->list_bucket, &old->list_bucket); + list_del_init(&old->list_bucket); + } else { + unsigned long key = hash_addr(&new->peer_addr); + void **slot; + + slot = radix_tree_lookup_slot(&msgr->con_tree, key); + BUG_ON(radix_tree_deref_slot(slot) != &old->list_bucket); + radix_tree_replace_slot(slot, &new->list_bucket); + } + + /* take old connections message queue */ + spin_lock(&old->out_queue_lock); + if (!list_empty(&old->out_queue)) + list_splice_init(&new->out_queue, &old->out_queue); + spin_unlock(&old->out_queue_lock); + + new->connect_seq = le32_to_cpu(new->in_connect.connect_seq); + new->out_seq = old->out_seq; + + set_bit(CLOSED, &old->state); + put_connection(old); /* dec reference count */ + + clear_bit(ACCEPTING, &new->state); +} + + + + +/* + * We maintain a global counter to order connection attempts. Get + * a unique seq greater than @gt. + */ +static u32 get_global_seq(struct ceph_messenger *msgr, u32 gt) +{ + u32 ret; + + spin_lock(&msgr->global_seq_lock); + if (msgr->global_seq < gt) + msgr->global_seq = gt; + ret = ++msgr->global_seq; + spin_unlock(&msgr->global_seq_lock); + return ret; +} + + + + +/* + * Prepare footer for currently outgoing message, and finish things + * off. Assumes out_kvec* are already valid.. we just add on to the end. + */ +static void prepare_write_message_footer(struct ceph_connection *con, int v) +{ + struct ceph_msg *m = con->out_msg; + + dout(10, "prepare_write_message_footer %p\n", con); + con->out_kvec[v].iov_base = &m->footer; + con->out_kvec[v].iov_len = sizeof(m->footer); + con->out_kvec_bytes += sizeof(m->footer); + con->out_kvec_left++; + con->out_msg = NULL; /* we're done with this one */ + con->out_more = 0; /* end of message */ +} + +/* + * Prepare headers for the next outgoing message. + */ +static void prepare_write_message(struct ceph_connection *con) +{ + struct ceph_msg *m; + int v = 0; + + con->out_kvec_bytes = 0; + + /* Sneak an ack in there first? If we can get it into the same + * TCP packet that's a good thing. */ + if (con->in_seq > con->in_seq_acked) { + con->in_seq_acked = con->in_seq; + con->out_kvec[v].iov_base = &tag_ack; + con->out_kvec[v++].iov_len = 1; + con->out_temp_ack = cpu_to_le32(con->in_seq_acked); + con->out_kvec[v].iov_base = &con->out_temp_ack; + con->out_kvec[v++].iov_len = 4; + con->out_kvec_bytes = 1 + 4; + } + + /* move message to sending/sent list */ + m = list_entry(con->out_queue.next, + struct ceph_msg, list_head); + list_del_init(&m->list_head); + list_add_tail(&m->list_head, &con->out_sent); + con->out_msg = m; /* we don't bother taking a reference here. */ + + dout(20, "prepare_write_message %p seq %lld type %d len %d+%d %d pgs\n", + m, le64_to_cpu(m->hdr.seq), le16_to_cpu(m->hdr.type), + le32_to_cpu(m->hdr.front_len), le32_to_cpu(m->hdr.data_len), + m->nr_pages); + BUG_ON(le32_to_cpu(m->hdr.front_len) != m->front.iov_len); + + /* tag + hdr + front */ + con->out_kvec[v].iov_base = &tag_msg; + con->out_kvec[v++].iov_len = 1; + con->out_kvec[v].iov_base = &m->hdr; + con->out_kvec[v++].iov_len = sizeof(m->hdr); + con->out_kvec[v++] = m->front; + con->out_kvec_left = v; + con->out_kvec_bytes += 1 + sizeof(m->hdr) + m->front.iov_len; + con->out_kvec_cur = con->out_kvec; + + /* fill in crc (except data pages), footer */ + con->out_msg->hdr.crc = + cpu_to_le32(crc32c_le(0, (void *)&m->hdr, + sizeof(m->hdr) - sizeof(m->hdr.crc))); + con->out_msg->footer.flags = 0; + con->out_msg->footer.front_crc = + cpu_to_le32(crc32c_le(0, m->front.iov_base, m->front.iov_len)); + con->out_msg->footer.data_crc = 0; + + /* is there a data payload? */ + if (le32_to_cpu(m->hdr.data_len) > 0) { + /* initialize page iterator */ + con->out_msg_pos.page = 0; + con->out_msg_pos.page_pos = + le32_to_cpu(m->hdr.data_off) & ~PAGE_MASK; + con->out_msg_pos.data_pos = 0; + con->out_msg_pos.did_page_crc = 0; + con->out_more = 1; /* data + footer will follow */ + } else { + /* no, queue up footer too and be done */ + prepare_write_message_footer(con, v); + } + + set_bit(WRITE_PENDING, &con->state); +} + +/* + * Prepare an ack. + */ +static void prepare_write_ack(struct ceph_connection *con) +{ + dout(20, "prepare_write_ack %p %u -> %u\n", con, + con->in_seq_acked, con->in_seq); + con->in_seq_acked = con->in_seq; + + con->out_kvec[0].iov_base = &tag_ack; + con->out_kvec[0].iov_len = 1; + con->out_temp_ack = cpu_to_le32(con->in_seq_acked); + con->out_kvec[1].iov_base = &con->out_temp_ack; + con->out_kvec[1].iov_len = 4; + con->out_kvec_left = 2; + con->out_kvec_bytes = 1 + 4; + con->out_kvec_cur = con->out_kvec; + con->out_more = 1; /* more will follow.. eventually.. */ + set_bit(WRITE_PENDING, &con->state); +} + +/* + * Connection negotiation. + */ + +/* + * We connected to a peer and are saying hello. + */ +static void prepare_write_connect(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + int len = strlen(CEPH_BANNER); + + dout(10, "prepare_write_connect %p\n", con); + con->out_connect.host_type = CEPH_ENTITY_TYPE_CLIENT; + con->out_connect.connect_seq = cpu_to_le32(con->connect_seq); + con->out_connect.global_seq = get_global_seq(con->msgr, 0); + con->out_connect.flags = 0; + if (test_bit(LOSSYTX, &con->state)) + con->out_connect.flags = CEPH_MSG_CONNECT_LOSSY; + + con->out_kvec[0].iov_base = CEPH_BANNER; + con->out_kvec[0].iov_len = len; + con->out_kvec[1].iov_base = &msgr->inst.addr; + con->out_kvec[1].iov_len = sizeof(msgr->inst.addr); + con->out_kvec[2].iov_base = &con->out_connect; + con->out_kvec[2].iov_len = sizeof(con->out_connect); + con->out_kvec_left = 3; + con->out_kvec_bytes = len + sizeof(msgr->inst.addr) + + sizeof(con->out_connect); + con->out_kvec_cur = con->out_kvec; + con->out_more = 0; + set_bit(WRITE_PENDING, &con->state); +} + +static void prepare_write_connect_retry(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + dout(10, "prepare_write_connect_retry %p\n", con); + con->out_connect.connect_seq = cpu_to_le32(con->connect_seq); + con->out_connect.global_seq = get_global_seq(con->msgr, 0); + + con->out_kvec[0].iov_base = &con->out_connect; + con->out_kvec[0].iov_len = sizeof(con->out_connect); + con->out_kvec_left = 1; + con->out_kvec_bytes = sizeof(con->out_connect); + con->out_kvec_cur = con->out_kvec; + con->out_more = 0; + set_bit(WRITE_PENDING, &con->state); +} + +/* + * We accepted a connection and are saying hello. + */ +static void prepare_write_accept_hello(struct ceph_messenger *msgr, + struct ceph_connection *con) +{ + int len = strlen(CEPH_BANNER); + + dout(10, "prepare_write_accept_hello %p\n", con); + con->out_kvec[0].iov_base = CEPH_BANNER; + con->out_kvec[0].iov_len = len; + con->out_kvec[1].iov_base = &msgr->inst.addr; + con->out_kvec[1].iov_len = sizeof(msgr->inst.addr); + con->out_kvec_left = 2; + con->out_kvec_bytes = len + sizeof(msgr->inst.addr); + con->out_kvec_cur = con->out_kvec; + con->out_more = 0; + set_bit(WRITE_PENDING, &con->state); +} + +/* + * Reply to a connect attempt, indicating whether the negotiation has + * succeeded or must continue. + */ +static void prepare_write_accept_reply(struct ceph_connection *con, bool retry) +{ + dout(10, "prepare_write_accept_reply %p\n", con); + con->out_reply.flags = 0; + if (test_bit(LOSSYTX, &con->state)) + con->out_reply.flags = CEPH_MSG_CONNECT_LOSSY; + + con->out_kvec[0].iov_base = &con->out_reply; + con->out_kvec[0].iov_len = sizeof(con->out_reply); + con->out_kvec_left = 1; + con->out_kvec_bytes = sizeof(con->out_reply); + con->out_kvec_cur = con->out_kvec; + con->out_more = 0; + set_bit(WRITE_PENDING, &con->state); + + if (retry) + /* we'll re-read the connect request, sans the hello + addr */ + con->in_base_pos = strlen(CEPH_BANNER) + + sizeof(con->msgr->inst.addr); +} + + + +/* + * write as much of pending kvecs to the socket as we can. + * 1 -> done + * 0 -> socket full, but more to do + * <0 -> error + */ +static int write_partial_kvec(struct ceph_connection *con) +{ + int ret; + + dout(10, "write_partial_kvec %p %d left\n", con, con->out_kvec_bytes); + while (con->out_kvec_bytes > 0) { + ret = ceph_tcp_sendmsg(con->sock, con->out_kvec_cur, + con->out_kvec_left, con->out_kvec_bytes, + con->out_more); + if (ret <= 0) + goto out; + con->out_kvec_bytes -= ret; + if (con->out_kvec_bytes == 0) + break; /* done */ + while (ret > 0) { + if (ret >= con->out_kvec_cur->iov_len) { + ret -= con->out_kvec_cur->iov_len; + con->out_kvec_cur++; + con->out_kvec_left--; + } else { + con->out_kvec_cur->iov_len -= ret; + con->out_kvec_cur->iov_base += ret; + ret = 0; + break; + } + } + } + con->out_kvec_left = 0; + ret = 1; +out: + dout(30, "write_partial_kvec %p %d left in %d kvecs ret = %d\n", con, + con->out_kvec_bytes, con->out_kvec_left, ret); + return ret; /* done! */ +} + +/* + * Write as much message data payload as we can. If we finish, queue + * up the footer. + * 1 -> done, footer is now queued in out_kvec[]. + * 0 -> socket full, but more to do + * <0 -> error + */ +static int write_partial_msg_pages(struct ceph_connection *con) +{ + struct ceph_client *client = con->msgr->parent; + struct ceph_msg *msg = con->out_msg; + unsigned data_len = le32_to_cpu(msg->hdr.data_len); + size_t len; + int crc = !(client->mount_args.flags & CEPH_MOUNT_NOCRC); + int ret; + + dout(30, "write_partial_msg_pages %p msg %p page %d/%d offset %d\n", + con, con->out_msg, con->out_msg_pos.page, con->out_msg->nr_pages, + con->out_msg_pos.page_pos); + + while (con->out_msg_pos.page < con->out_msg->nr_pages) { + struct page *page = NULL; + void *kaddr = NULL; + + /* + * if we are calculating the data crc (the default), we need + * to map the page. if our pages[] has been revoked, use the + * zero page. + */ + mutex_lock(&msg->page_mutex); + if (msg->pages) { + page = msg->pages[con->out_msg_pos.page]; + if (crc) + kaddr = kmap(page); + } else { + page = con->msgr->zero_page; + if (crc) + kaddr = page_address(con->msgr->zero_page); + } + len = min((int)(PAGE_SIZE - con->out_msg_pos.page_pos), + (int)(data_len - con->out_msg_pos.data_pos)); + if (crc && !con->out_msg_pos.did_page_crc) { + void *base = kaddr + con->out_msg_pos.page_pos; + u32 tmpcrc = le32_to_cpu(con->out_msg->footer.data_crc); + + con->out_msg->footer.data_crc = + cpu_to_le32(crc32c_le(tmpcrc, base, len)); + con->out_msg_pos.did_page_crc = 1; + } + + ret = kernel_sendpage(con->sock, page, + con->out_msg_pos.page_pos, len, + MSG_DONTWAIT | MSG_NOSIGNAL | + MSG_MORE); + + if (crc && msg->pages) + kunmap(page); + + mutex_unlock(&msg->page_mutex); + if (ret <= 0) + goto out; + + con->out_msg_pos.data_pos += ret; + con->out_msg_pos.page_pos += ret; + if (ret == len) { + con->out_msg_pos.page_pos = 0; + con->out_msg_pos.page++; + con->out_msg_pos.did_page_crc = 0; + } + } + + dout(30, "write_partial_msg_pages %p msg %p done\n", con, msg); + + /* prepare and queue up footer, too */ + if (!crc) + con->out_msg->footer.flags |= + cpu_to_le32(CEPH_MSG_FOOTER_NOCRC); + con->out_kvec_bytes = 0; + con->out_kvec_left = 0; + con->out_kvec_cur = con->out_kvec; + prepare_write_message_footer(con, 0); + ret = 1; +out: + return ret; +} + + + +/* + * Prepare to read connection handshake, or an ack. + */ +static void prepare_read_connect(struct ceph_connection *con) +{ + dout(10, "prepare_read_connect %p\n", con); + con->in_base_pos = 0; +} + +static void prepare_read_ack(struct ceph_connection *con) +{ + dout(10, "prepare_read_ack %p\n", con); + con->in_base_pos = 0; +} + +static void prepare_read_tag(struct ceph_connection *con) +{ + dout(10, "prepare_read_tag %p\n", con); + con->in_base_pos = 0; + con->in_tag = CEPH_MSGR_TAG_READY; +} + +/* + * Prepare to read a message. + */ +static int prepare_read_message(struct ceph_connection *con) +{ + int err; + + dout(10, "prepare_read_message %p\n", con); + con->in_base_pos = 0; + BUG_ON(con->in_msg != NULL); + con->in_msg = ceph_msg_new(0, 0, 0, 0, NULL); + if (IS_ERR(con->in_msg)) { + err = PTR_ERR(con->in_msg); + con->in_msg = NULL; + con->error_msg = "out of memory for incoming message"; + return err; + } + con->in_front_crc = con->in_data_crc = 0; + return 0; +} + + +static int read_partial(struct ceph_connection *con, + int *to, int size, void *object) +{ + *to += size; + while (con->in_base_pos < *to) { + int left = *to - con->in_base_pos; + int have = size - left; + int ret = ceph_tcp_recvmsg(con->sock, object + have, left); + if (ret <= 0) + return ret; + con->in_base_pos += ret; + } + return 1; +} + + +/* + * Read all or part of the connect-side handshake on a new connection + */ +static int read_partial_connect(struct ceph_connection *con) +{ + int ret, to = 0; + + dout(20, "read_partial_connect %p at %d\n", con, con->in_base_pos); + + /* peer's banner */ + ret = read_partial(con, &to, strlen(CEPH_BANNER), con->in_banner); + if (ret <= 0) + goto out; + ret = read_partial(con, &to, sizeof(con->actual_peer_addr), + &con->actual_peer_addr); + if (ret <= 0) + goto out; + ret = read_partial(con, &to, sizeof(con->in_reply), &con->in_reply); + if (ret <= 0) + goto out; + + dout(20, "read_partial_connect %p connect_seq = %u, global_seq = %u\n", + con, le32_to_cpu(con->in_reply.connect_seq), + le32_to_cpu(con->in_reply.global_seq)); +out: + return ret; +} + +/* + * Verify the hello banner looks okay. + */ +static int verify_hello(struct ceph_connection *con) +{ + if (memcmp(con->in_banner, CEPH_BANNER, strlen(CEPH_BANNER))) { + derr(10, "connection to/from %u.%u.%u.%u:%u has bad banner\n", + IPQUADPORT(con->peer_addr.ipaddr)); + con->error_msg = "protocol error, bad banner"; + return -1; + } + return 0; +} + +/* + * Reset a connection. Discard all incoming and outgoing messages + * and clear *_seq state. + */ +static void reset_connection(struct ceph_connection *con) +{ + derr(1, "%s%d %u.%u.%u.%u:%u connection reset\n", + ENTITY_NAME(con->peer_name), + IPQUADPORT(con->peer_addr.ipaddr)); + + /* reset connection, out_queue, msg_ and connect_seq */ + /* discard existing out_queue and msg_seq */ + spin_lock(&con->out_queue_lock); + ceph_msg_put_list(&con->out_queue); + ceph_msg_put_list(&con->out_sent); + + con->connect_seq = 0; + con->out_seq = 0; + con->out_msg = NULL; + con->in_seq = 0; + con->in_msg = NULL; + spin_unlock(&con->out_queue_lock); +} + + +static int process_connect(struct ceph_connection *con) +{ + dout(20, "process_connect on %p tag %d\n", con, (int)con->in_tag); + + if (verify_hello(con) < 0) + return -1; + + /* + * Make sure the other end is who we wanted. note that the other + * end may not yet know their ip address, so if it's 0.0.0.0, give + * them the benefit of the doubt. + */ + if (!ceph_entity_addr_is_local(&con->peer_addr, + &con->actual_peer_addr) && + con->actual_peer_addr.ipaddr.sin_addr.s_addr != 0) { + derr(1, "process_connect wrong peer, want %u.%u.%u.%u:%u/%d, " + "got %u.%u.%u.%u:%u/%d, wtf\n", + IPQUADPORT(con->peer_addr.ipaddr), + con->peer_addr.nonce, + IPQUADPORT(con->actual_peer_addr.ipaddr), + con->actual_peer_addr.nonce); + con->error_msg = "protocol error, wrong peer"; + return -1; + } + + switch (con->in_reply.tag) { + case CEPH_MSGR_TAG_RESETSESSION: + /* + * If we connected with a large connect_seq but the peer + * has no record of a session with us (no connection, or + * connect_seq == 0), they will send RESETSESION to indicate + * that they must have reset their session, and may have + * dropped messages. + */ + dout(10, "process_connect got RESET peer seq %u\n", + le32_to_cpu(con->in_connect.connect_seq)); + reset_connection(con); + prepare_write_connect_retry(con->msgr, con); + prepare_read_connect(con); + + /* Tell ceph about it. */ + con->msgr->peer_reset(con->msgr->parent, &con->peer_addr, + &con->peer_name); + break; + + case CEPH_MSGR_TAG_RETRY_SESSION: + /* + * If we sent a smaller connect_seq than the peer has, try + * again with a larger value. + */ + dout(10, + "process_connect got RETRY my seq = %u, peer_seq = %u\n", + le32_to_cpu(con->out_connect.connect_seq), + le32_to_cpu(con->in_connect.connect_seq)); + con->connect_seq = le32_to_cpu(con->in_connect.connect_seq); + prepare_write_connect_retry(con->msgr, con); + prepare_read_connect(con); + break; + + case CEPH_MSGR_TAG_RETRY_GLOBAL: + /* + * If we sent a smaller global_seq than the peer has, try + * again with a larger value. + */ + dout(10, + "process_connect got RETRY_GLOBAL my %u, peer_gseq = %u\n", + con->peer_global_seq, + le32_to_cpu(con->in_connect.global_seq)); + get_global_seq(con->msgr, + le32_to_cpu(con->in_connect.global_seq)); + prepare_write_connect_retry(con->msgr, con); + prepare_read_connect(con); + break; + + case CEPH_MSGR_TAG_WAIT: + /* + * If there is a connection race (we are opening connections to + * each other), one of us may just have to WAIT. We will keep + * our queued messages, in expectation of being replaced by an + * incoming connection. + */ + dout(10, "process_connect peer connecting WAIT\n"); + set_bit(WAIT, &con->state); + con_close_socket(con); + break; + + case CEPH_MSGR_TAG_READY: + clear_bit(CONNECTING, &con->state); + if (le32_to_cpu(con->in_reply.flags) & CEPH_MSG_CONNECT_LOSSY) + set_bit(LOSSYRX, &con->state); + con->peer_global_seq = le32_to_cpu(con->in_reply.global_seq); + con->connect_seq++; + dout(10, "process_connect got READY gseq %d cseq %d (%d)\n", + con->peer_global_seq, + le32_to_cpu(con->in_reply.connect_seq), + con->connect_seq); + WARN_ON(con->connect_seq != + le32_to_cpu(con->in_reply.connect_seq)); + + con->delay = 0; /* reset backoff memory */ + prepare_read_tag(con); + break; + + default: + derr(1, "process_connect protocol error, will retry\n"); + con->error_msg = "protocol error, garbage tag during connect"; + return -1; + } + return 0; +} + + +/* + * Read all or part of the accept-side handshake on a newly accepted + * connection. + */ +static int read_partial_accept(struct ceph_connection *con) +{ + int ret; + int to = 0; + + /* banner */ + ret = read_partial(con, &to, strlen(CEPH_BANNER), con->in_banner); + if (ret <= 0) + return ret; + ret = read_partial(con, &to, sizeof(con->peer_addr), &con->peer_addr); + if (ret <= 0) + return ret; + ret = read_partial(con, &to, sizeof(con->in_connect), &con->in_connect); + if (ret <= 0) + return ret; + return 1; +} + +/* + * Call after a new connection's handshake has been read. + */ +static int process_accept(struct ceph_connection *con) +{ + struct ceph_connection *existing; + struct ceph_messenger *msgr = con->msgr; + u32 peer_gseq = le32_to_cpu(con->in_connect.global_seq); + u32 peer_cseq = le32_to_cpu(con->in_connect.connect_seq); + bool retry = true; + bool replace = false; + + dout(10, "process_accept %p got gseq %d cseq %d\n", con, + peer_gseq, peer_cseq); + + if (verify_hello(con) < 0) + return -1; + + /* note flags */ + if (con->in_connect.flags & CEPH_MSG_CONNECT_LOSSY) + set_bit(LOSSYRX, &con->state); + + /* do we have an existing connection for this peer? */ + if (radix_tree_preload(GFP_NOFS) < 0) { + derr(10, "ENOMEM in process_accept\n"); + con->error_msg = "out of memory"; + return -1; + } + + memset(&con->out_reply, 0, sizeof(con->out_reply)); + + spin_lock(&msgr->con_lock); + existing = __get_connection(msgr, &con->peer_addr); + if (existing) { + if (peer_gseq < existing->peer_global_seq) { + /* out of order connection attempt */ + con->out_reply.tag = CEPH_MSGR_TAG_RETRY_GLOBAL; + con->out_reply.global_seq = + cpu_to_le32(con->peer_global_seq); + goto reply; + } + if (test_bit(LOSSYTX, &existing->state)) { + dout(20, "process_accept %p replacing LOSSYTX %p\n", + con, existing); + replace = true; + goto accept; + } + if (peer_cseq < existing->connect_seq) { + if (peer_cseq == 0) { + /* peer reset, then connected to us */ + reset_connection(existing); + con->msgr->peer_reset(con->msgr->parent, + &con->peer_addr, + &con->peer_name); + replace = true; + goto accept; + } + + /* old attempt or peer didn't get the READY */ + con->out_reply.tag = CEPH_MSGR_TAG_RETRY_SESSION; + con->out_reply.connect_seq = + cpu_to_le32(con->connect_seq); + goto reply; + } + + if (peer_cseq == existing->connect_seq) { + /* connection race */ + dout(20, "process_accept connection race state = %lu\n", + con->state); + if (ceph_entity_addr_equal(&msgr->inst.addr, + &con->peer_addr)) { + /* incoming connection wins.. */ + replace = true; + goto accept; + } + + /* our existing outgoing connection wins, tell peer + to wait for our outging connection to go through */ + con->out_reply.tag = CEPH_MSGR_TAG_WAIT; + goto reply; + } + + if (existing->connect_seq == 0 && + peer_cseq > existing->connect_seq) { + /* we reset and already reconnecting */ + con->out_reply.tag = CEPH_MSGR_TAG_RESETSESSION; + goto reply; + } + + WARN_ON(con->in_connect.connect_seq <= existing->connect_seq); + WARN_ON(con->in_connect.global_seq < existing->peer_global_seq); + if (existing->connect_seq == 0) { + /* we reset, sending RESETSESSION */ + con->out_reply.tag = CEPH_MSGR_TAG_RESETSESSION; + goto reply; + } + + /* reconnect, replace connection */ + replace = true; + goto accept; + } + + if (peer_cseq == 0) { + dout(20, "process_accept no existing connection, opening\n"); + goto accept; + } else { + dout(20, "process_accept no existing connection, we reset\n"); + con->out_reply.tag = CEPH_MSGR_TAG_RESETSESSION; + goto reply; + } + + +accept: + /* accept this connection */ + con->connect_seq = peer_cseq + 1; + con->peer_global_seq = peer_gseq; + dout(10, "process_accept %p cseq %d peer_gseq %d %s\n", con, + con->connect_seq, peer_gseq, replace ? "replace" : "new"); + + con->out_reply.tag = CEPH_MSGR_TAG_READY; + con->out_reply.global_seq = get_global_seq(con->msgr, 0); + con->out_reply.connect_seq = peer_cseq + 1; + + retry = false; + prepare_read_tag(con); + + /* do this _after_ con is ready to go */ + if (replace) + __replace_connection(msgr, existing, con); + else + __register_connection(msgr, con); + put_connection(con); + +reply: + if (existing) + put_connection(existing); + prepare_write_accept_reply(con, retry); + + spin_unlock(&msgr->con_lock); + radix_tree_preload_end(); + + ceph_queue_con(con); + return 0; +} + +/* + * read (part of) an ack + */ +static int read_partial_ack(struct ceph_connection *con) +{ + int to = 0; + + return read_partial(con, &to, sizeof(con->in_temp_ack), + &con->in_temp_ack); +} + + +/* + * We can finally discard anything that's been acked. + */ +static void process_ack(struct ceph_connection *con) +{ + struct ceph_msg *m; + u32 ack = le32_to_cpu(con->in_temp_ack); + u64 seq; + + spin_lock(&con->out_queue_lock); + while (!list_empty(&con->out_sent)) { + m = list_entry(con->out_sent.next, struct ceph_msg, list_head); + seq = le64_to_cpu(m->hdr.seq); + if (seq > ack) + break; + dout(5, "got ack for seq %llu type %d at %p\n", seq, + le16_to_cpu(m->hdr.type), m); + list_del_init(&m->list_head); + ceph_msg_put(m); + } + spin_unlock(&con->out_queue_lock); + prepare_read_tag(con); +} + + + + + + +/* + * read (part of) a message. + */ +static int read_partial_message(struct ceph_connection *con) +{ + struct ceph_msg *m = con->in_msg; + void *p; + int ret; + int to, want, left; + unsigned front_len, data_len, data_off; + + dout(20, "read_partial_message con %p msg %p\n", con, m); + + /* header */ + while (con->in_base_pos < sizeof(m->hdr)) { + left = sizeof(m->hdr) - con->in_base_pos; + ret = ceph_tcp_recvmsg(con->sock, + (char *)&m->hdr + con->in_base_pos, + left); + if (ret <= 0) + return ret; + con->in_base_pos += ret; + if (con->in_base_pos == sizeof(m->hdr)) { + u32 crc = crc32c_le(0, (void *)&m->hdr, + sizeof(m->hdr) - sizeof(m->hdr.crc)); + if (crc != le32_to_cpu(m->hdr.crc)) { + derr(0, "read_partial_message %p bad hdr crc" + " %u != expected %u\n", + m, crc, m->hdr.crc); + return -EIO; + } + } + } + + /* front */ + front_len = le32_to_cpu(m->hdr.front_len); + while (m->front.iov_len < front_len) { + if (m->front.iov_base == NULL) { + m->front.iov_base = kmalloc(front_len, GFP_NOFS); + if (m->front.iov_base == NULL) + return -ENOMEM; + } + left = front_len - m->front.iov_len; + ret = ceph_tcp_recvmsg(con->sock, (char *)m->front.iov_base + + m->front.iov_len, left); + if (ret <= 0) + return ret; + m->front.iov_len += ret; + if (m->front.iov_len == front_len) + con->in_front_crc = crc32c_le(0, m->front.iov_base, + m->front.iov_len); + } + + /* (page) data */ + data_len = le32_to_cpu(m->hdr.data_len); + data_off = le32_to_cpu(m->hdr.data_off); + if (data_len == 0) + goto no_data; + if (m->nr_pages == 0) { + con->in_msg_pos.page = 0; + con->in_msg_pos.page_pos = data_off & ~PAGE_MASK; + con->in_msg_pos.data_pos = 0; + /* find pages for data payload */ + want = calc_pages_for(data_off & ~PAGE_MASK, data_len); + ret = 0; + BUG_ON(!con->msgr->prepare_pages); + ret = con->msgr->prepare_pages(con->msgr->parent, m, want); + if (ret < 0) { + dout(10, "prepare_pages failed, skipping payload\n"); + con->in_base_pos = -data_len - sizeof(m->footer); + ceph_msg_put(con->in_msg); + con->in_msg = NULL; + con->in_tag = CEPH_MSGR_TAG_READY; + return 0; + } + BUG_ON(m->nr_pages < want); + } + while (con->in_msg_pos.data_pos < data_len) { + left = min((int)(data_len - con->in_msg_pos.data_pos), + (int)(PAGE_SIZE - con->in_msg_pos.page_pos)); + mutex_lock(&m->page_mutex); + if (!m->pages) { + dout(10, "pages revoked during msg read\n"); + mutex_unlock(&m->page_mutex); + con->in_base_pos = con->in_msg_pos.data_pos - data_len - + sizeof(m->footer); + ceph_msg_put(m); + con->in_msg = NULL; + con->in_tag = CEPH_MSGR_TAG_READY; + return 0; + } + p = kmap(m->pages[con->in_msg_pos.page]); + ret = ceph_tcp_recvmsg(con->sock, p + con->in_msg_pos.page_pos, + left); + if (ret > 0) + con->in_data_crc = + crc32c_le(con->in_data_crc, + p + con->in_msg_pos.page_pos, ret); + kunmap(m->pages[con->in_msg_pos.page]); + mutex_unlock(&m->page_mutex); + if (ret <= 0) + return ret; + con->in_msg_pos.data_pos += ret; + con->in_msg_pos.page_pos += ret; + if (con->in_msg_pos.page_pos == PAGE_SIZE) { + con->in_msg_pos.page_pos = 0; + con->in_msg_pos.page++; + } + } + +no_data: + /* footer */ + to = sizeof(m->hdr) + sizeof(m->footer); + while (con->in_base_pos < to) { + left = to - con->in_base_pos; + ret = ceph_tcp_recvmsg(con->sock, (char *)&m->footer + + (con->in_base_pos - sizeof(m->hdr)), + left); + if (ret <= 0) + return ret; + con->in_base_pos += ret; + } + dout(20, "read_partial_message got msg %p\n", m); + + /* crc ok? */ + if (con->in_front_crc != le32_to_cpu(m->footer.front_crc)) { + derr(0, "read_partial_message %p front crc %u != expected %u\n", + con->in_msg, + con->in_front_crc, m->footer.front_crc); + return -EIO; + } + if (con->in_data_crc != le32_to_cpu(m->footer.data_crc)) { + derr(0, "read_partial_message %p data crc %u != expected %u\n", + con->in_msg, + con->in_data_crc, m->footer.data_crc); + return -EIO; + } + + /* did i learn my ip? */ + if (con->msgr->inst.addr.ipaddr.sin_addr.s_addr == htonl(INADDR_ANY)) { + /* + * in practice, we learn our ip from the first incoming mon + * message, before anyone else knows we exist, so this is + * safe. + */ + con->msgr->inst.addr.ipaddr = con->in_msg->hdr.dst.addr.ipaddr; + dout(10, "read_partial_message learned my addr is " + "%u.%u.%u.%u:%u\n", + IPQUADPORT(con->msgr->inst.addr.ipaddr)); + } + + return 1; /* done! */ +} + +/* + * Process message. This happens in the worker thread. The callback should + * be careful not to do anything that waits on other incoming messages or it + * may deadlock. + */ +static void process_message(struct ceph_connection *con) +{ + /* if first message, set peer_name */ + if (con->peer_name.type == 0) + con->peer_name = con->in_msg->hdr.src.name; + + spin_lock(&con->out_queue_lock); + con->in_seq++; + spin_unlock(&con->out_queue_lock); + + dout(1, "===== %p %llu from %s%d %d=%s len %d+%d (%u %u) =====\n", + con->in_msg, le64_to_cpu(con->in_msg->hdr.seq), + ENTITY_NAME(con->in_msg->hdr.src.name), + le16_to_cpu(con->in_msg->hdr.type), + ceph_msg_type_name(le16_to_cpu(con->in_msg->hdr.type)), + le32_to_cpu(con->in_msg->hdr.front_len), + le32_to_cpu(con->in_msg->hdr.data_len), + con->in_front_crc, con->in_data_crc); + con->msgr->dispatch(con->msgr->parent, con->in_msg); + con->in_msg = NULL; + prepare_read_tag(con); +} + + + + + + + + +/* + * Write something to the socket. Called in a worker thread when the + * socket appears to be writeable and we have something ready to send. + */ +static int try_write(struct ceph_connection *con) +{ + struct ceph_messenger *msgr = con->msgr; + int ret = 1; + + dout(30, "try_write start %p state %lu nref %d\n", con, con->state, + atomic_read(&con->nref)); + +more: + dout(30, "try_write out_kvec_bytes %d\n", con->out_kvec_bytes); + + /* open the socket first? */ + if (con->sock == NULL) { + /* + * if we were STANDBY and are reconnecting _this_ + * connection, bump connect_seq now. Always bump + * global_seq. + */ + if (test_and_clear_bit(STANDBY, &con->state)) + con->connect_seq++; + + prepare_write_connect(msgr, con); + prepare_read_connect(con); + set_bit(CONNECTING, &con->state); + + con->in_tag = CEPH_MSGR_TAG_READY; + dout(5, "try_write initiating connect on %p new state %lu\n", + con, con->state); + con->sock = ceph_tcp_connect(con); + if (IS_ERR(con->sock)) { + con->sock = NULL; + con->error_msg = "connect error"; + ret = -1; + goto out; + } + } + +more_kvec: + /* kvec data queued? */ + if (con->out_kvec_left) { + ret = write_partial_kvec(con); + if (ret <= 0) + goto done; + if (ret < 0) { + dout(30, "try_write write_partial_kvec err %d\n", ret); + goto done; + } + } + + /* msg pages? */ + if (con->out_msg) { + ret = write_partial_msg_pages(con); + if (ret == 1) + goto more_kvec; /* we need to send the footer, too! */ + if (ret == 0) + goto done; + if (ret < 0) { + dout(30, "try_write write_partial_msg_pages err %d\n", + ret); + goto done; + } + } + + if (!test_bit(CONNECTING, &con->state)) { + /* is anything else pending? */ + spin_lock(&con->out_queue_lock); + if (!list_empty(&con->out_queue)) { + prepare_write_message(con); + spin_unlock(&con->out_queue_lock); + goto more; + } + if (con->in_seq > con->in_seq_acked) { + prepare_write_ack(con); + spin_unlock(&con->out_queue_lock); + goto more; + } + spin_unlock(&con->out_queue_lock); + } + + /* Nothing to do! */ + clear_bit(WRITE_PENDING, &con->state); + dout(30, "try_write nothing else to write.\n"); +done: + ret = 0; +out: + dout(30, "try_write done on %p\n", con); + return ret; +} + + + +/* + * Read what we can from the socket. + */ +static int try_read(struct ceph_connection *con) +{ + struct ceph_messenger *msgr; + int ret = -1; + + if (!con->sock) + return 0; + + dout(20, "try_read start on %p\n", con); + msgr = con->msgr; + +more: + dout(20, "try_read tag %d in_base_pos %d\n", (int)con->in_tag, + con->in_base_pos); + if (test_bit(ACCEPTING, &con->state)) { + dout(20, "try_read accepting\n"); + ret = read_partial_accept(con); + if (ret <= 0) + goto done; + if (process_accept(con) < 0) { + ret = -1; + goto out; + } + goto more; + } + if (test_bit(CONNECTING, &con->state)) { + dout(20, "try_read connecting\n"); + ret = read_partial_connect(con); + if (ret <= 0) + goto done; + if (process_connect(con) < 0) { + ret = -1; + goto out; + } + goto more; + } + + if (con->in_base_pos < 0) { + /* + * skipping + discarding content. + * + * FIXME: there must be a better way to do this! + */ + static char buf[1024]; + int skip = min(1024, -con->in_base_pos); + dout(20, "skipping %d / %d bytes\n", skip, -con->in_base_pos); + ret = ceph_tcp_recvmsg(con->sock, buf, skip); + if (ret <= 0) + goto done; + con->in_base_pos += ret; + if (con->in_base_pos) + goto more; + } + if (con->in_tag == CEPH_MSGR_TAG_READY) { + /* + * what's next? + */ + ret = ceph_tcp_recvmsg(con->sock, &con->in_tag, 1); + if (ret <= 0) + goto done; + dout(30, "try_read got tag %d\n", (int)con->in_tag); + switch (con->in_tag) { + case CEPH_MSGR_TAG_MSG: + prepare_read_message(con); + break; + case CEPH_MSGR_TAG_ACK: + prepare_read_ack(con); + break; + case CEPH_MSGR_TAG_CLOSE: + set_bit(CLOSED, &con->state); /* fixme */ + goto done; + default: + goto bad_tag; + } + } + if (con->in_tag == CEPH_MSGR_TAG_MSG) { + ret = read_partial_message(con); + if (ret == -EIO) { + con->error_msg = "bad crc"; + goto out; + } + if (ret <= 0) + goto done; + if (con->in_tag == CEPH_MSGR_TAG_READY) + goto more; + process_message(con); + goto more; + } + if (con->in_tag == CEPH_MSGR_TAG_ACK) { + ret = read_partial_ack(con); + if (ret <= 0) + goto done; + process_ack(con); + goto more; + } + +done: + ret = 0; +out: + dout(20, "try_read done on %p\n", con); + return ret; + +bad_tag: + derr(2, "try_read bad con->in_tag = %d\n", (int)con->in_tag); + con->error_msg = "protocol error, garbage tag"; + ret = -1; + goto out; +} + + +/* + * Atomically queue work on a connection. Bump @con reference to + * avoid races with connection teardown. + * + * There is some trickery going on with QUEUED, BUSY, and BACKOFF because + * we only want a _single_ thread operating on each connection at any point + * in time, but we want to use all available CPUs. + * + * The worker thread only proceeds if it can atomically set BUSY. It + * clears QUEUED and does it's thing. When it thinks it's done, it + * clears BUSY, then rechecks QUEUED.. if it's set again, it loops + * (tries again to set BUSY). + * + * To queue work, we first set QUEUED, _then_ if BUSY isn't set, we + * try to queue work. If that fails (work is already queued, or BUSY) + * we give up (work also already being done or is queued) but leave QUEUED + * set so that the worker thread will loop if necessary. + * + * BACKOFF is set by the fault error path to prevent the worker thread from + * looping or socket events from requeuing work; instead, we schedule delayed + * work explicitly. + */ +static void ceph_queue_con(struct ceph_connection *con) +{ + if (test_bit(WAIT, &con->state) || + test_bit(CLOSED, &con->state) || + test_bit(BACKOFF, &con->state)) { + dout(40, "ceph_queue_con %p ignoring: WAIT|CLOSED|BACKOFF\n", + con); + return; + } + + atomic_inc(&con->nref); + dout(40, "ceph_queue_con %p %d -> %d\n", con, + atomic_read(&con->nref) - 1, atomic_read(&con->nref)); + + set_bit(QUEUED, &con->state); + if (test_bit(BUSY, &con->state) || + !queue_work(ceph_msgr_wq, &con->work.work)) { + dout(40, "ceph_queue_con %p - already BUSY or queued\n", con); + put_connection(con); + } +} + +/* + * Do some work on a connection. Drop a connection ref when we're done. + */ +static void con_work(struct work_struct *work) +{ + struct ceph_connection *con = container_of(work, struct ceph_connection, + work.work); + +more: + if (test_and_set_bit(BUSY, &con->state) != 0) { + dout(10, "con_work %p BUSY already set\n", con); + goto out; + } + dout(10, "con_work %p start, clearing QUEUED\n", con); + clear_bit(QUEUED, &con->state); + + if (test_bit(CLOSED, &con->state)) { /* e.g. if we are replaced */ + dout(5, "con_work CLOSED\n"); + goto done; + } + if (test_bit(WAIT, &con->state)) { /* we are a zombie */ + dout(5, "con_work WAIT\n"); + goto done; + } + if (test_and_clear_bit(BACKOFF, &con->state)) + dout(5, "con_work cleared BACKOFF\n"); + + if (test_and_clear_bit(SOCK_CLOSED, &con->state) || + try_read(con) < 0 || + try_write(con) < 0) + ceph_fault(con); /* error/fault path */ + +done: + clear_bit(BUSY, &con->state); + if (test_bit(QUEUED, &con->state)) { + if (!test_bit(BACKOFF, &con->state)) { + dout(10, "con_work %p QUEUED reset, looping\n", con); + goto more; + } + dout(10, "con_work %p QUEUED reset, but BACKOFF\n", con); + clear_bit(QUEUED, &con->state); + } + dout(10, "con_work %p done\n", con); + +out: + put_connection(con); +} + + +/* + * Generic error/fault handler. A retry mechanism is used with + * exponential backoff + */ +static void ceph_fault(struct ceph_connection *con) +{ + derr(1, "%s%d %u.%u.%u.%u:%u %s\n", ENTITY_NAME(con->peer_name), + IPQUADPORT(con->peer_addr.ipaddr), con->error_msg); + dout(10, "fault %p state %lu to peer %u.%u.%u.%u:%u\n", + con, con->state, IPQUADPORT(con->peer_addr.ipaddr)); + + if (test_bit(LOSSYTX, &con->state)) { + dout(30, "fault on LOSSYTX channel\n"); + remove_connection(con->msgr, con); + return; + } + + con_close_socket(con); + + /* If there are no messages in the queue, place the connection + * in a STANDBY state (i.e., don't try to reconnect just yet). */ + spin_lock(&con->out_queue_lock); + if (list_empty(&con->out_queue)) { + dout(10, "fault setting STANDBY\n"); + set_bit(STANDBY, &con->state); + spin_unlock(&con->out_queue_lock); + return; + } + + /* Requeue anything that hasn't been acked, and retry after a + * delay. */ + list_splice_init(&con->out_sent, &con->out_queue); + spin_unlock(&con->out_queue_lock); + + /* set BACKOFF so that caller does not loop and to prevent + * anything from requeuing work on this connection. */ + dout(10, "fault setting BACKOFF\n"); + set_bit(BACKOFF, &con->state); + clear_bit(BUSY, &con->state); /* to avoid an improbable race */ + + if (con->delay == 0) + con->delay = BASE_DELAY_INTERVAL; + else if (con->delay < MAX_DELAY_INTERVAL) + con->delay *= 2; + + /* explicitly schedule work to try to reconnect again later. */ + dout(40, "fault queueing %p %d -> %d delay %lu\n", con, + atomic_read(&con->nref), atomic_read(&con->nref) + 1, + con->delay); + atomic_inc(&con->nref); + queue_delayed_work(ceph_msgr_wq, &con->work, + round_jiffies_relative(con->delay)); +} + + +/* + * Handle an incoming connection. + */ +static void accept_work(struct work_struct *work) +{ + struct ceph_connection *newcon = NULL; + struct ceph_messenger *msgr = container_of(work, struct ceph_messenger, + awork); + + /* initialize the msgr connection */ + newcon = new_connection(msgr); + if (newcon == NULL) { + derr(1, "kmalloc failure accepting new connection\n"); + return; + } + + set_bit(ACCEPTING, &newcon->state); + newcon->connect_seq = 1; + newcon->in_tag = CEPH_MSGR_TAG_READY; /* eventually, hopefully */ + + if (ceph_tcp_accept(msgr->listen_sock, newcon) < 0) { + derr(1, "error accepting connection\n"); + put_connection(newcon); + return; + } + dout(5, "accepted connection \n"); + + prepare_write_accept_hello(msgr, newcon); + add_connection_accepting(msgr, newcon); + + /* queue work explicitly; we may have missed the socket state + * change before setting the socket callbacks. */ + ceph_queue_con(newcon); +} + + + +/* + * create a new messenger instance, creates listening socket + */ +struct ceph_messenger *ceph_messenger_create(struct ceph_entity_addr *myaddr) +{ + struct ceph_messenger *msgr; + int ret = 0; + + msgr = kzalloc(sizeof(*msgr), GFP_KERNEL); + if (msgr == NULL) + return ERR_PTR(-ENOMEM); + + INIT_WORK(&msgr->awork, accept_work); + spin_lock_init(&msgr->con_lock); + INIT_LIST_HEAD(&msgr->con_all); + INIT_LIST_HEAD(&msgr->con_accepting); + INIT_RADIX_TREE(&msgr->con_tree, GFP_ATOMIC); + spin_lock_init(&msgr->global_seq_lock); + + /* the zero page is needed if a request is "canceled" while the message + * is being written over the socket */ + msgr->zero_page = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!msgr->zero_page) { + kfree(msgr); + return ERR_PTR(-ENOMEM); + } + kmap(msgr->zero_page); + + /* pick listening address */ + if (myaddr) { + msgr->inst.addr = *myaddr; + } else { + dout(10, "create my ip not specified, binding to INADDR_ANY\n"); + msgr->inst.addr.ipaddr.sin_addr.s_addr = htonl(INADDR_ANY); + msgr->inst.addr.ipaddr.sin_port = htons(0); /* any port */ + } + msgr->inst.addr.ipaddr.sin_family = AF_INET; + + /* create listening socket */ + ret = ceph_tcp_listen(msgr); + if (ret < 0) { + kfree(msgr); + return ERR_PTR(ret); + } + if (myaddr) + msgr->inst.addr.ipaddr.sin_addr = myaddr->ipaddr.sin_addr; + + dout(1, "messenger %p listening on %u.%u.%u.%u:%u\n", msgr, + IPQUADPORT(msgr->inst.addr.ipaddr)); + return msgr; +} + +void ceph_messenger_destroy(struct ceph_messenger *msgr) +{ + struct ceph_connection *con; + + dout(2, "destroy %p\n", msgr); + + /* stop listener */ + msgr->listen_sock->ops->shutdown(msgr->listen_sock, SHUT_RDWR); + sock_release(msgr->listen_sock); + cancel_work_sync(&msgr->awork); + + /* kill off connections */ + spin_lock(&msgr->con_lock); + while (!list_empty(&msgr->con_all)) { + con = list_entry(msgr->con_all.next, struct ceph_connection, + list_all); + dout(10, "destroy removing connection %p\n", con); + set_bit(CLOSED, &con->state); + atomic_inc(&con->nref); + dout(40, " get %p %d -> %d\n", con, + atomic_read(&con->nref) - 1, atomic_read(&con->nref)); + __remove_connection(msgr, con); + + /* in case there's queued work. drop a reference if + * we successfully cancel work. */ + spin_unlock(&msgr->con_lock); + if (cancel_delayed_work_sync(&con->work)) + put_connection(con); + put_connection(con); + dout(10, "destroy removed connection %p\n", con); + + spin_lock(&msgr->con_lock); + } + spin_unlock(&msgr->con_lock); + + kunmap(msgr->zero_page); + __free_page(msgr->zero_page); + + kfree(msgr); + dout(10, "destroyed messenger %p\n", msgr); +} + +/* + * mark a peer down. drop any open connections. + */ +void ceph_messenger_mark_down(struct ceph_messenger *msgr, + struct ceph_entity_addr *addr) +{ + struct ceph_connection *con; + + dout(2, "mark_down peer %u.%u.%u.%u:%u\n", + IPQUADPORT(addr->ipaddr)); + + spin_lock(&msgr->con_lock); + con = __get_connection(msgr, addr); + if (con) { + dout(1, "mark_down %s%d %u.%u.%u.%u:%u (%p)\n", + ENTITY_NAME(con->peer_name), + IPQUADPORT(con->peer_addr.ipaddr), con); + set_bit(CLOSED, &con->state); /* in case there's queued work */ + __remove_connection(msgr, con); + } + spin_unlock(&msgr->con_lock); + if (con) + put_connection(con); +} + + +/* + * A single ceph_msg can't be queued for send twice, unless it's + * already been delivered (i.e. we have the only remaining reference), + * because of the list_head indicating which queue it is on. + * + * So, we dup the message if there is more than once reference. If it has + * pages (a data payload), steal the pages away from the old message. + */ +struct ceph_msg *ceph_msg_maybe_dup(struct ceph_msg *old) +{ + struct ceph_msg *dup; + + if (atomic_read(&old->nref) == 1) + return old; /* we have only ref, all is well */ + + dup = ceph_msg_new(le16_to_cpu(old->hdr.type), + le32_to_cpu(old->hdr.front_len), + le32_to_cpu(old->hdr.data_len), + le32_to_cpu(old->hdr.data_off), + old->pages); + if (!dup) + return ERR_PTR(-ENOMEM); + memcpy(dup->front.iov_base, old->front.iov_base, + le32_to_cpu(old->hdr.front_len)); + + /* revoke old message's pages */ + mutex_lock(&old->page_mutex); + old->pages = NULL; + old->footer.flags |= cpu_to_le32(CEPH_MSG_FOOTER_ABORTED); + mutex_unlock(&old->page_mutex); + + ceph_msg_put(old); + return dup; +} + + +/* + * Queue up an outgoing message. + * + * This consumes a msg reference. That is, if the caller wants to + * keep @msg around, it had better call ceph_msg_get first. + */ +int ceph_msg_send(struct ceph_messenger *msgr, struct ceph_msg *msg, + unsigned long timeout) +{ + struct ceph_connection *con, *newcon; + int ret = 0; + + /* set source */ + msg->hdr.src = msgr->inst; + msg->hdr.orig_src = msgr->inst; + + /* do we have the connection? */ + spin_lock(&msgr->con_lock); + con = __get_connection(msgr, &msg->hdr.dst.addr); + if (!con) { + /* drop lock while we allocate a new connection */ + spin_unlock(&msgr->con_lock); + + newcon = new_connection(msgr); + if (IS_ERR(newcon)) + return PTR_ERR(con); + + newcon->out_connect.flags = 0; + if (!timeout) { + dout(10, "ceph_msg_send setting LOSSYTX\n"); + newcon->out_connect.flags |= CEPH_MSG_CONNECT_LOSSY; + set_bit(LOSSYTX, &newcon->state); + } + + ret = radix_tree_preload(GFP_NOFS); + if (ret < 0) { + derr(10, "ENOMEM in ceph_msg_send\n"); + return ret; + } + + spin_lock(&msgr->con_lock); + con = __get_connection(msgr, &msg->hdr.dst.addr); + if (con) { + put_connection(newcon); + dout(10, "ceph_msg_send (lost race and) had connection " + "%p to peer %u.%u.%u.%u:%u\n", con, + IPQUADPORT(msg->hdr.dst.addr.ipaddr)); + } else { + con = newcon; + con->peer_addr = msg->hdr.dst.addr; + con->peer_name = msg->hdr.dst.name; + __register_connection(msgr, con); + dout(5, "ceph_msg_send new connection %p to peer " + "%u.%u.%u.%u:%u\n", con, + IPQUADPORT(msg->hdr.dst.addr.ipaddr)); + } + spin_unlock(&msgr->con_lock); + radix_tree_preload_end(); + } else { + dout(10, "ceph_msg_send had connection %p to peer " + "%u.%u.%u.%u:%u\n", con, + IPQUADPORT(msg->hdr.dst.addr.ipaddr)); + spin_unlock(&msgr->con_lock); + } + + /* queue */ + spin_lock(&con->out_queue_lock); + + /* avoid queuing multiple PING messages in a row. */ + if (unlikely(le16_to_cpu(msg->hdr.type) == CEPH_MSG_PING && + !list_empty(&con->out_queue) && + le16_to_cpu(list_entry(con->out_queue.prev, + struct ceph_msg, + list_head)->hdr.type) == CEPH_MSG_PING)) { + dout(2, "ceph_msg_send dropping dup ping\n"); + ceph_msg_put(msg); + } else { + msg->hdr.seq = cpu_to_le64(++con->out_seq); + dout(1, "----- %p %u to %s%d %d=%s len %d+%d -----\n", msg, + (unsigned)con->out_seq, + ENTITY_NAME(msg->hdr.dst.name), le16_to_cpu(msg->hdr.type), + ceph_msg_type_name(le16_to_cpu(msg->hdr.type)), + le32_to_cpu(msg->hdr.front_len), + le32_to_cpu(msg->hdr.data_len)); + dout(2, "ceph_msg_send %p seq %llu for %s%d on %p pgs %d\n", + msg, le64_to_cpu(msg->hdr.seq), + ENTITY_NAME(msg->hdr.dst.name), con, msg->nr_pages); + list_add_tail(&msg->list_head, &con->out_queue); + } + spin_unlock(&con->out_queue_lock); + + /* if there wasn't anything waiting to send before, queue + * new work */ + if (test_and_set_bit(WRITE_PENDING, &con->state) == 0) + ceph_queue_con(con); + + put_connection(con); + dout(30, "ceph_msg_send done\n"); + return ret; +} + + +/* + * construct a new message with given type, size + * the new msg has a ref count of 1. + */ +struct ceph_msg *ceph_msg_new(int type, int front_len, + int page_len, int page_off, struct page **pages) +{ + struct ceph_msg *m; + + m = kmalloc(sizeof(*m), GFP_NOFS); + if (m == NULL) + goto out; + atomic_set(&m->nref, 1); + mutex_init(&m->page_mutex); + INIT_LIST_HEAD(&m->list_head); + + m->hdr.type = cpu_to_le16(type); + m->hdr.front_len = cpu_to_le32(front_len); + m->hdr.data_len = cpu_to_le32(page_len); + m->hdr.data_off = cpu_to_le32(page_off); + m->footer.front_crc = 0; + m->footer.data_crc = 0; + m->front_is_vmalloc = false; + + /* front */ + if (front_len) { + if (front_len > PAGE_CACHE_SIZE) { + m->front.iov_base = vmalloc(front_len); + m->front_is_vmalloc = true; + } else { + m->front.iov_base = kmalloc(front_len, GFP_NOFS); + } + if (m->front.iov_base == NULL) { + derr(0, "ceph_msg_new can't allocate %d bytes\n", + front_len); + goto out2; + } + } else { + m->front.iov_base = NULL; + } + m->front.iov_len = front_len; + + /* pages */ + m->nr_pages = calc_pages_for(page_off, page_len); + m->pages = pages; + + dout(20, "ceph_msg_new %p page %d~%d -> %d\n", m, page_off, page_len, + m->nr_pages); + return m; + +out2: + ceph_msg_put(m); +out: + derr(0, "msg_new can't create msg type %d len %d\n", type, front_len); + return ERR_PTR(-ENOMEM); +} + +void ceph_msg_put(struct ceph_msg *m) +{ + dout(20, "ceph_msg_put %p %d -> %d\n", m, atomic_read(&m->nref), + atomic_read(&m->nref)-1); + if (atomic_read(&m->nref) <= 0) { + derr(0, "bad ceph_msg_put on %p %llu %s%d->%s%d %d=%s %d+%d\n", + m, le64_to_cpu(m->hdr.seq), + ENTITY_NAME(m->hdr.src.name), + ENTITY_NAME(m->hdr.dst.name), + le16_to_cpu(m->hdr.type), + ceph_msg_type_name(le16_to_cpu(m->hdr.type)), + le32_to_cpu(m->hdr.front_len), + le32_to_cpu(m->hdr.data_len)); + WARN_ON(1); + } + if (atomic_dec_and_test(&m->nref)) { + dout(20, "ceph_msg_put last one on %p\n", m); + WARN_ON(!list_empty(&m->list_head)); + if (m->front_is_vmalloc) + vfree(m->front.iov_base); + else + kfree(m->front.iov_base); + kfree(m); + } +} + +void ceph_ping(struct ceph_messenger *msgr, struct ceph_entity_name name, + struct ceph_entity_addr *addr) +{ + struct ceph_msg *m; + + m = ceph_msg_new(CEPH_MSG_PING, 0, 0, 0, NULL); + if (!m) + return; + memset(m->front.iov_base, 0, m->front.iov_len); + m->hdr.dst.name = name; + m->hdr.dst.addr = *addr; + ceph_msg_send(msgr, m, BASE_DELAY_INTERVAL); +} diff --git a/fs/ceph/messenger.h b/fs/ceph/messenger.h new file mode 100644 index 0000000..99b36bb --- /dev/null +++ b/fs/ceph/messenger.h @@ -0,0 +1,269 @@ +#ifndef __FS_CEPH_MESSENGER_H +#define __FS_CEPH_MESSENGER_H + +#include <linux/kobject.h> +#include <linux/mutex.h> +#include <linux/net.h> +#include <linux/radix-tree.h> +#include <linux/uio.h> +#include <linux/version.h> +#include <linux/workqueue.h> + +#include "types.h" + +/* + * Ceph uses the messenger to exchange ceph_msg messages with + * other hosts in the system. The messenger provides ordered and + * reliable delivery. It tolerates TCP disconnects by reconnecting + * (with exponential backoff) in the case of a fault (disconnection, + * bad crc, protocol error). Acks allow sent messages to be discarded + * by the sender. + * + * The network topology is flat: there is no "client" or "server," and + * any node can initiate a connection (i.e., send messages) to any other + * node. There is a fair bit of complexity to handle the "connection + * race" case where two nodes are simultaneously connecting to each other + * so that the end result is a single session. + * + * The messenger can also send messages in "lossy" mode, where there is + * no error recovery or connect retry... the message is just dropped if + * something goes wrong. + */ + +struct ceph_msg; + +#define IPQUADPORT(n) \ + (unsigned int)((be32_to_cpu((n).sin_addr.s_addr) >> 24)) & 0xFF, \ + (unsigned int)((be32_to_cpu((n).sin_addr.s_addr)) >> 16) & 0xFF, \ + (unsigned int)((be32_to_cpu((n).sin_addr.s_addr))>>8) & 0xFF, \ + (unsigned int)((be32_to_cpu((n).sin_addr.s_addr))) & 0xFF, \ + (unsigned int)(ntohs((n).sin_port)) + + +extern struct workqueue_struct *ceph_msgr_wq; /* receive work queue */ + +/* + * Ceph defines these callbacks for handling events: + */ +/* handle an incoming message. */ +typedef void (*ceph_msgr_dispatch_t) (void *p, struct ceph_msg *m); +/* an incoming message has a data payload; tell me what pages I + * should read the data into. */ +typedef int (*ceph_msgr_prepare_pages_t) (void *p, struct ceph_msg *m, + int want); +/* a remote host as terminated a message exchange session, and messages + * we sent (or they tried to send us) may be lost. */ +typedef void (*ceph_msgr_peer_reset_t) (void *p, struct ceph_entity_addr *addr, + struct ceph_entity_name *pn); + +static inline const char *ceph_name_type_str(int t) +{ + switch (t) { + case CEPH_ENTITY_TYPE_MON: return "mon"; + case CEPH_ENTITY_TYPE_MDS: return "mds"; + case CEPH_ENTITY_TYPE_OSD: return "osd"; + case CEPH_ENTITY_TYPE_CLIENT: return "client"; + case CEPH_ENTITY_TYPE_ADMIN: return "admin"; + default: return "???"; + } +} + +#define CEPH_MSGR_BACKUP 10 /* backlogged incoming connections */ + +/* use format string %s%d */ +#define ENTITY_NAME(n) \ + ceph_name_type_str(le32_to_cpu((n).type)), \ + le32_to_cpu((n).num) + +struct ceph_messenger { + void *parent; /* normally struct ceph_client * */ + ceph_msgr_dispatch_t dispatch; + ceph_msgr_peer_reset_t peer_reset; + ceph_msgr_prepare_pages_t prepare_pages; + + struct ceph_entity_inst inst; /* my name+address */ + + struct socket *listen_sock; /* listening socket */ + struct work_struct awork; /* accept work */ + + spinlock_t con_lock; + struct list_head con_all; /* all open connections */ + struct list_head con_accepting; /* accepting */ + struct radix_tree_root con_tree; /* established */ + + struct page *zero_page; /* used in certain error cases */ + + /* + * the global_seq counts connections i (attempt to) initiate + * in order to disambiguate certain connect race conditions. + */ + u32 global_seq; + spinlock_t global_seq_lock; +}; + +/* + * a single message. it contains a header (src, dest, message type, etc.), + * footer (crc values, mainly), a "front" message body, and possibly a + * data payload (stored in some number of pages). The page_mutex protects + * access to the page vector. + */ +struct ceph_msg { + struct ceph_msg_header hdr; /* header */ + struct ceph_msg_footer footer; /* footer */ + struct kvec front; /* first bit of message */ + struct mutex page_mutex; + struct page **pages; /* data payload. NOT OWNER. */ + unsigned nr_pages; /* size of page array */ + struct list_head list_head; + atomic_t nref; + bool front_is_vmalloc; +}; + +struct ceph_msg_pos { + int page, page_pos; /* which page; offset in page */ + int data_pos; /* offset in data payload */ + int did_page_crc; /* true if we've calculated crc for current page */ +}; + +/* ceph connection fault delay defaults */ +#define BASE_DELAY_INTERVAL (HZ/2) +#define MAX_DELAY_INTERVAL (5 * 60 * HZ) + +/* + * ceph_connection state bit flags + * + * QUEUED, BUSY, and BACKOFF are used together to ensure that only a + * single thread is currently opening, reading or writing data to the + * socket. + */ +#define LOSSYTX 0 /* we can close channel or drop messages on errors */ +#define LOSSYRX 1 /* peer may reset/drop messages */ +#define CONNECTING 2 +#define ACCEPTING 3 +#define WRITE_PENDING 4 /* we have data ready to send */ +#define QUEUED 5 /* there is work queued on this connection */ +#define BUSY 6 /* work is being done */ +#define BACKOFF 7 /* backing off; will retry */ +#define STANDBY 8 /* no outgoing messages, socket closed. we keep + * the ceph_connection around to maintain shared + * state with the peer. */ +#define WAIT 9 /* waiting for peer to connect to us (during a + * connection race) */ +#define CLOSED 10 /* we've closed the connection */ +#define SOCK_CLOSED 11 /* socket state changed to closed */ +#define REGISTERED 12 /* connection appears in con_tree */ + +/* + * A single connection with another host. + * + * We maintain a queue of outgoing messages, and some session state to + * ensure that we can preserve the lossless, ordered delivery of + * messages in the case of a TCP disconnect. + */ +struct ceph_connection { + struct ceph_messenger *msgr; + struct socket *sock; + unsigned long state; /* connection state (see flags above) */ + const char *error_msg; /* error message, if any */ + + atomic_t nref; + + struct list_head list_all; /* msgr->con_all */ + struct list_head list_bucket; /* msgr->con_tree or con_accepting */ + + struct ceph_entity_addr peer_addr; /* peer address */ + struct ceph_entity_name peer_name; /* peer name */ + u32 connect_seq; /* identify the most recent connection + attempt for this connection, client */ + u32 peer_global_seq; /* peer's global seq for this connection */ + + /* out queue */ + spinlock_t out_queue_lock; /* protects out_queue, out_sent, out_seq */ + struct list_head out_queue; + struct list_head out_sent; /* sending/sent but unacked */ + u32 out_seq; /* last message queued for send */ + + u32 in_seq, in_seq_acked; /* last message received, acked */ + + /* connection negotiation temps */ + char in_banner[CEPH_BANNER_MAX_LEN]; + union { + struct { /* outgoing connection */ + struct ceph_msg_connect out_connect; + struct ceph_msg_connect_reply in_reply; + }; + struct { /* incoming */ + struct ceph_msg_connect in_connect; + struct ceph_msg_connect_reply out_reply; + }; + }; + struct ceph_entity_addr actual_peer_addr; + + /* message out temps */ + struct ceph_msg *out_msg; /* sending message (== tail of + out_sent) */ + struct ceph_msg_pos out_msg_pos; + + struct kvec out_kvec[6], /* sending header/footer data */ + *out_kvec_cur; + int out_kvec_left; /* kvec's left in out_kvec */ + int out_kvec_bytes; /* total bytes left */ + int out_more; /* there is more data after the kvecs */ + __le32 out_temp_ack; /* for writing an ack */ + + /* message in temps */ + struct ceph_msg *in_msg; + struct ceph_msg_pos in_msg_pos; + u32 in_front_crc, in_data_crc; /* calculated crc, for comparison + message footer */ + + char in_tag; /* protocol control byte */ + int in_base_pos; /* bytes read */ + __le32 in_temp_ack; /* for reading an ack */ + + struct delayed_work work; /* send|recv work */ + unsigned long delay; /* current delay interval */ +}; + +extern int ceph_msgr_init(void); +extern void ceph_msgr_exit(void); + +extern struct ceph_messenger * +ceph_messenger_create(struct ceph_entity_addr *myaddr); +extern void ceph_messenger_destroy(struct ceph_messenger *); +extern void ceph_messenger_mark_down(struct ceph_messenger *msgr, + struct ceph_entity_addr *addr); + +extern struct ceph_msg *ceph_msg_new(int type, int front_len, + int page_len, int page_off, + struct page **pages); + +static inline struct ceph_msg *ceph_msg_get(struct ceph_msg *msg) +{ + /*printk("ceph_msg_get %p %d -> %d\n", msg, atomic_read(&msg->nref), + atomic_read(&msg->nref)+1);*/ + atomic_inc(&msg->nref); + return msg; +} + +extern void ceph_msg_put(struct ceph_msg *msg); + +static inline void ceph_msg_put_list(struct list_head *head) +{ + while (!list_empty(head)) { + struct ceph_msg *msg = list_first_entry(head, struct ceph_msg, + list_head); + list_del_init(&msg->list_head); + ceph_msg_put(msg); + } +} + +extern struct ceph_msg *ceph_msg_maybe_dup(struct ceph_msg *msg); + +extern int ceph_msg_send(struct ceph_messenger *msgr, struct ceph_msg *msg, + unsigned long timeout); + +extern void ceph_ping(struct ceph_messenger *msgr, struct ceph_entity_name name, + struct ceph_entity_addr *addr); + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 16/19] ceph: nfs re-export support 2008-11-14 0:56 ` [PATCH 15/19] ceph: messenger library Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 17/19] ceph: ioctls Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Basic NFS re-export support is included. This mostly works. However, Ceph's MDS design precludes the ability to generate a (small) filehandle that will be valid forever, so this is of limited utility. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/export.c | 145 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 145 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/export.c diff --git a/fs/ceph/export.c b/fs/ceph/export.c new file mode 100644 index 0000000..78c5699 --- /dev/null +++ b/fs/ceph/export.c @@ -0,0 +1,145 @@ +#include <linux/exportfs.h> + +#include "super.h" +#include "ceph_debug.h" + +int ceph_debug_export = -1; +#define DOUT_MASK DOUT_MASK_EXPORT +#define DOUT_VAR ceph_debug_export +#define DOUT_PREFIX "export: " + +/* + * fh is N tuples of + * <ino, parent's d_name.hash> + * + * This is only a semi-reliable strategy. The fundamental issue is + * that ceph doesn't not have a way to locate an arbitrary inode by + * ino. Keeping a few parents in the handle increases the probability + * that we'll find it in one of the MDS caches, but it is by no means + * a guarantee. + * + * Also, the FINDINODE request is currently directed at a single MDS. + * It should probably try all MDS's before giving up. For a single MDS + * system that isn't a problem. + * + * In the meantime, this works reasonably well for basic usage. + */ + +#define IPSZ (sizeof(struct ceph_inopath_item) / sizeof(u32)) + +static int ceph_encode_fh(struct dentry *dentry, u32 *rawfh, int *max_len, + int connectable) +{ + int type = 1; + struct ceph_inopath_item *fh = + (struct ceph_inopath_item *)rawfh; + int max = *max_len / IPSZ; + int len; + + dout(10, "encode_fh %p max_len %d u32s (%d inopath items)%s\n", dentry, + *max_len, max, connectable ? " connectable" : ""); + + if (max < 1 || (connectable && max < 2)) + return -ENOSPC; + + /* + * pretty sure this is racy. caller holds dentry->d_lock, but + * not parents'. + */ + fh[0].ino = cpu_to_le64(ceph_vino(dentry->d_inode).ino); + fh[0].dname_hash = cpu_to_le32(dentry->d_name.hash); + len = 1; + while (len < max) { + dentry = dentry->d_parent; + if (!dentry) + break; + fh[len].ino = cpu_to_le64(ceph_vino(dentry->d_inode).ino); + fh[len].dname_hash = cpu_to_le32(dentry->d_name.hash); + len++; + type = 2; + if (IS_ROOT(dentry)) + break; + } + + *max_len = len * IPSZ; + return type; +} + +static struct dentry *__fh_to_dentry(struct super_block *sb, + struct ceph_inopath_item *fh, int len) +{ + struct ceph_mds_client *mdsc = &ceph_client(sb)->mdsc; + struct inode *inode; + struct dentry *dentry; + int err; + struct ceph_vino vino = { + .ino = le64_to_cpu(fh[0].ino), + .snap = CEPH_NOSNAP, /* FIXME */ + }; + u32 hash = le32_to_cpu(fh[0].dname_hash); + + inode = ceph_find_inode(sb, vino); + if (!inode) { + struct ceph_mds_request *req; + derr(10, "fh_to_dentry %llx.%x -- no inode\n", vino.ino, hash); + + req = ceph_mdsc_create_request(mdsc, + CEPH_MDS_OP_FINDINODE, + len, (char *)fh, 0, NULL, + NULL, USE_ANY_MDS); + if (IS_ERR(req)) + return ERR_PTR(PTR_ERR(req)); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + + inode = ceph_find_inode(sb, vino); + if (!inode) + 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", + vino.ino, + hash, inode); + iput(inode); + return ERR_PTR(-ENOMEM); + } + dout(10, "fh_to_dentry %llx.%x -- inode %p dentry %p\n", vino.ino, + hash, inode, dentry); + return dentry; + +} + +static struct dentry *ceph_fh_to_dentry(struct super_block *sb, struct fid *fid, + int fh_len, int fh_type) +{ + u32 *fh = fid->raw; + return __fh_to_dentry(sb, (struct ceph_inopath_item *)fh, fh_len/IPSZ); +} + +static struct dentry *ceph_fh_to_parent(struct super_block *sb, struct fid *fid, + int fh_len, int fh_type) +{ + u32 *fh = fid->raw; + u64 ino = *(u64 *)fh; + u32 hash = fh[2]; + + derr(10, "fh_to_parent %llx.%x\n", ino, hash); + + if (fh_len < 6) + return ERR_PTR(-ESTALE); + + return __fh_to_dentry(sb, (struct ceph_inopath_item *)fh + 1, + fh_len/IPSZ - 1); +} + +const struct export_operations ceph_export_ops = { + .encode_fh = ceph_encode_fh, + .fh_to_dentry = ceph_fh_to_dentry, + .fh_to_parent = ceph_fh_to_parent, +}; -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 17/19] ceph: ioctls 2008-11-14 0:56 ` [PATCH 16/19] ceph: nfs re-export support Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 18/19] ceph: debugging Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil A few Ceph ioctls for getting and setting file layout (striping) parameters. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/ioctl.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/ceph/ioctl.h | 12 +++++++++ 2 files changed, 84 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/ioctl.c create mode 100644 fs/ceph/ioctl.h diff --git a/fs/ceph/ioctl.c b/fs/ceph/ioctl.c new file mode 100644 index 0000000..ccbd0d6 --- /dev/null +++ b/fs/ceph/ioctl.c @@ -0,0 +1,72 @@ +#include "ioctl.h" +#include "super.h" +#include "ceph_debug.h" + +int ceph_debug_ioctl = -1; +#define DOUT_MASK DOUT_MASK_IOCTL +#define DOUT_VAR ceph_debug_ioctl +#define DOUT_PREFIX "ioctl: " + + +/* + * ioctls + */ + +static long ceph_ioctl_get_layout(struct file *file, void __user *arg) +{ + struct ceph_inode_info *ci = ceph_inode(file->f_dentry->d_inode); + int err; + + err = ceph_do_getattr(file->f_dentry, CEPH_STAT_MASK_LAYOUT); + if (!err) { + if (copy_to_user(arg, &ci->i_layout, sizeof(ci->i_layout))) + return -EFAULT; + } + + return err; +} + +static long ceph_ioctl_set_layout(struct file *file, void __user *arg) +{ + struct inode *inode = file->f_dentry->d_inode; + struct ceph_mds_client *mdsc = &ceph_sb_to_client(inode->i_sb)->mdsc; + char *path; + int pathlen; + struct ceph_mds_request *req; + struct ceph_mds_request_head *reqh; + u64 pathbase; + struct ceph_file_layout layout; + int err; + + /* copy and validate */ + if (copy_from_user(&layout, arg, sizeof(layout))) + return -EFAULT; + + /* set */ + path = ceph_build_path(file->f_dentry, &pathlen, &pathbase, 0); + if (IS_ERR(path)) + return PTR_ERR(path); + req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LSETLAYOUT, + pathbase, path, 0, NULL, + file->f_dentry, USE_ANY_MDS); + kfree(path); + reqh = req->r_request->front.iov_base; + reqh->args.setlayout.layout = layout; + ceph_mdsc_lease_release(mdsc, inode, NULL, CEPH_LOCK_ICONTENT); + err = ceph_mdsc_do_request(mdsc, req); + ceph_mdsc_put_request(req); + return err; +} + +long ceph_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + dout(10, "ioctl file %p cmd %u arg %lu\n", file, cmd, arg); + switch (cmd) { + case CEPH_IOC_GET_LAYOUT: + return ceph_ioctl_get_layout(file, (void __user *)arg); + + case CEPH_IOC_SET_LAYOUT: + return ceph_ioctl_set_layout(file, (void __user *)arg); + } + return -ENOTTY; +} diff --git a/fs/ceph/ioctl.h b/fs/ceph/ioctl.h new file mode 100644 index 0000000..537c27b --- /dev/null +++ b/fs/ceph/ioctl.h @@ -0,0 +1,12 @@ +#ifndef FS_CEPH_IOCTL_H +#define FS_CEPH_IOCTL_H + +#include <linux/ioctl.h> +#include "types.h" + +#define CEPH_IOCTL_MAGIC 0x97 + +#define CEPH_IOC_GET_LAYOUT _IOR(CEPH_IOCTL_MAGIC, 1, struct ceph_file_layout) +#define CEPH_IOC_SET_LAYOUT _IOW(CEPH_IOCTL_MAGIC, 2, struct ceph_file_layout) + +#endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 18/19] ceph: debugging 2008-11-14 0:56 ` [PATCH 17/19] ceph: ioctls Sage Weil @ 2008-11-14 0:56 ` Sage Weil 2008-11-14 0:56 ` [PATCH 19/19] ceph: Kconfig, Makefile Sage Weil 0 siblings, 1 reply; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Some debugging infrastructure, including the ability to adjust the level of debug output on a per-file basis. A memory leak check tool can also be enabled via .config. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/ceph/ceph_debug.h | 130 +++++++++++++++++++++++++++++++++++ fs/ceph/ceph_tools.c | 125 +++++++++++++++++++++++++++++++++ fs/ceph/ceph_tools.h | 19 +++++ fs/ceph/proc.c | 186 ++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 460 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/ceph_debug.h create mode 100644 fs/ceph/ceph_tools.c create mode 100644 fs/ceph/ceph_tools.h create mode 100644 fs/ceph/proc.c diff --git a/fs/ceph/ceph_debug.h b/fs/ceph/ceph_debug.h new file mode 100644 index 0000000..275fffa --- /dev/null +++ b/fs/ceph/ceph_debug.h @@ -0,0 +1,130 @@ +#ifndef _FS_CEPH_DEBUG_H +#define _FS_CEPH_DEBUG_H + +#include <linux/string.h> + +#include "ceph_tools.h" + +extern int ceph_debug; /* debug level. */ +extern int ceph_debug_console; /* send debug output to console? */ +extern int ceph_debug_mask; + +/* + * different debug levels for different modules. These default to -1. + * If they are >=, then they override the global ceph_debug value. + */ +extern int ceph_debug_addr; +extern int ceph_debug_caps; +extern int ceph_debug_dir; +extern int ceph_debug_export; +extern int ceph_debug_file; +extern int ceph_debug_inode; +extern int ceph_debug_ioctl; +extern int ceph_debug_mdsc; +extern int ceph_debug_mdsmap; +extern int ceph_debug_msgr; +extern int ceph_debug_mon; +extern int ceph_debug_osdc; +extern int ceph_debug_osdmap; +extern int ceph_debug_snap; +extern int ceph_debug_super; +extern int ceph_debug_protocol; +extern int ceph_debug_proc; +extern int ceph_debug_tools; + +#define DOUT_MASK_ADDR 0x00000001 +#define DOUT_MASK_CAPS 0x00000002 +#define DOUT_MASK_DIR 0x00000004 +#define DOUT_MASK_EXPORT 0x00000008 +#define DOUT_MASK_FILE 0x00000010 +#define DOUT_MASK_INODE 0x00000020 +#define DOUT_MASK_IOCTL 0x00000040 +#define DOUT_MASK_MDSC 0x00000080 +#define DOUT_MASK_MDSMAP 0x00000100 +#define DOUT_MASK_MSGR 0x00000200 +#define DOUT_MASK_MON 0x00000400 +#define DOUT_MASK_OSDC 0x00000800 +#define DOUT_MASK_OSDMAP 0x00001000 +#define DOUT_MASK_SNAP 0x00002000 +#define DOUT_MASK_SUPER 0x00004000 +#define DOUT_MASK_PROTOCOL 0x00008000 +#define DOUT_MASK_PROC 0x00010000 +#define DOUT_MASK_TOOLS 0x00020000 + +#define DOUT_UNMASKABLE 0x80000000 + +struct _debug_mask_name { + int mask; + char *name; +}; + +static struct _debug_mask_name _debug_mask_names[] = { + {DOUT_MASK_ADDR, "addr"}, + {DOUT_MASK_CAPS, "caps"}, + {DOUT_MASK_DIR, "dir"}, + {DOUT_MASK_EXPORT, "export"}, + {DOUT_MASK_FILE, "file"}, + {DOUT_MASK_INODE, "inode"}, + {DOUT_MASK_IOCTL, "ioctl"}, + {DOUT_MASK_MDSC, "mdsc"}, + {DOUT_MASK_MDSMAP, "mdsmap"}, + {DOUT_MASK_MSGR, "msgr"}, + {DOUT_MASK_MON, "mon"}, + {DOUT_MASK_OSDC, "osdc"}, + {DOUT_MASK_OSDMAP, "osdmap"}, + {DOUT_MASK_SNAP, "snap"}, + {DOUT_MASK_SUPER, "super"}, + {DOUT_MASK_PROTOCOL, "protocol"}, + {DOUT_MASK_PROC, "proc"}, + {DOUT_MASK_TOOLS, "tools"}, + {0, NULL} +}; + +static inline int ceph_get_debug_mask(char *name) +{ + int i = 0; + + while (_debug_mask_names[i].name) { + if (strcmp(_debug_mask_names[i].name, name) == 0) + return _debug_mask_names[i].mask; + i++; + } + return 0; +} + +#define dout_flag(x, mask, args...) do { \ + if (((ceph_debug_mask | DOUT_UNMASKABLE) & mask) && \ + ((DOUT_VAR >= 0 && x <= DOUT_VAR) || \ + (DOUT_VAR < 0 && x <= ceph_debug))) { \ + if (ceph_debug_console) \ + printk(KERN_ERR "ceph_" DOUT_PREFIX args); \ + else \ + printk(KERN_DEBUG "ceph_" DOUT_PREFIX args); \ + } \ + } while (0) + +#define dout(x, args...) dout_flag(x, DOUT_MASK, args) + +#define derr(x, args...) do { \ + printk(KERN_ERR "ceph_" DOUT_PREFIX args); \ + } while (0) + + +/* dcache d_count debugging */ +#if 0 +# define dput(dentry) \ + do { \ + dout(20, "dput %p %d -> %d\n", dentry, \ + atomic_read(&dentry->d_count), \ + atomic_read(&dentry->d_count)-1); \ + dput(dentry); \ + } while (0) +# define d_drop(dentry) \ + do { \ + dout(20, "d_drop %p\n", dentry); \ + d_drop(dentry); \ + } while (0) +#endif + + +#endif diff --git a/fs/ceph/ceph_tools.c b/fs/ceph/ceph_tools.c new file mode 100644 index 0000000..9994af6 --- /dev/null +++ b/fs/ceph/ceph_tools.c @@ -0,0 +1,125 @@ +#include <linux/spinlock.h> +#include <linux/slab.h> +#include <linux/kallsyms.h> + +#define CEPH_OVERRIDE_BOOKKEEPER /* avoid kmalloc/kfree recursion */ + +#define CEPH_BK_MAGIC 0x140985AC + +#include "ceph_debug.h" + +int ceph_debug_tools = -1; +#define DOUT_VAR ceph_debug_tools +#define DOUT_MASK DOUT_MASK_TOOLS +#define DOUT_PREFIX "tools: " +#include "super.h" + +static struct list_head _bk_allocs; + +static DEFINE_SPINLOCK(_bk_lock); + +static size_t _total_alloc; +static size_t _total_free; + + +struct alloc_data { + u32 prefix_magic; + struct list_head node; + size_t size; + char *fname; + int line; + u32 suffix_magic; +}; + +struct stack_frame { + struct stack_frame *next_frame; + unsigned long return_address; +}; + +void *ceph_kmalloc(char *fname, int line, size_t size, gfp_t flags) +{ + struct alloc_data *p = kmalloc(size+sizeof(struct alloc_data), flags); + + if (!p) + return NULL; + + p->prefix_magic = CEPH_BK_MAGIC; + p->size = size; + p->fname = fname; + p->line = line; + p->suffix_magic = CEPH_BK_MAGIC; + + spin_lock(&_bk_lock); + _total_alloc += size; + + list_add_tail(&p->node, &_bk_allocs); + spin_unlock(&_bk_lock); + + return ((void *)p)+sizeof(struct alloc_data); +} + + +void ceph_kfree(void *ptr) +{ + struct alloc_data *p = (struct alloc_data *)(ptr - + sizeof(struct alloc_data)); + int overrun = 0; + + if (!ptr) + return; + + if (p->prefix_magic != CEPH_BK_MAGIC) { + derr(0, "ERROR: memory overrun (under)!\n"); + overrun = 1; + } + + if (p->suffix_magic != CEPH_BK_MAGIC) { + derr(0, "ERROR: Memory overrun (over)!\n"); + overrun = 1; + } + + if (overrun) { + derr(0, "Memory allocated at %s(%d): p=%p (%zu bytes)\n", p->fname, + p->line, + ((void *)p)+sizeof(struct alloc_data), + p->size); + } + + BUG_ON(overrun); + + spin_lock(&_bk_lock); + _total_free += p->size; + list_del(&p->node); + spin_unlock(&_bk_lock); + + kfree(p); + + return; +} + +void ceph_bookkeeper_init(void) +{ + dout(10, "bookkeeper: start\n"); + INIT_LIST_HEAD(&_bk_allocs); +} + +void ceph_bookkeeper_finalize(void) +{ + struct list_head *p; + struct alloc_data *entry; + + dout(1, "bookkeeper: total bytes alloc: %zu\n", _total_alloc); + dout(1, "bookkeeper: total bytes free: %zu\n", _total_free); + + if (_total_alloc != _total_free) { + list_for_each(p, &_bk_allocs) { + entry = list_entry(p, struct alloc_data, node); + dout(1, "%s(%d): p=%p (%zu bytes)\n", entry->fname, + entry->line, + ((void *)entry)+sizeof(struct alloc_data), + entry->size); + } + } else { + dout(1, "No leaks found! Yay!\n"); + } +} diff --git a/fs/ceph/ceph_tools.h b/fs/ceph/ceph_tools.h new file mode 100644 index 0000000..c8850ee --- /dev/null +++ b/fs/ceph/ceph_tools.h @@ -0,0 +1,19 @@ +#ifndef _FS_CEPH_TOOLS_H +#define _FS_CEPH_TOOLS_H + +#ifdef CONFIG_CEPH_BOOKKEEPER +extern void ceph_bookkeeper_init(void); +extern void ceph_bookkeeper_finalize(void); +extern void *ceph_kmalloc(char *fname, int line, size_t size, gfp_t flags); +extern void ceph_kfree(void *ptr); + +#ifndef CEPH_OVERRIDE_BOOKKEEPER +#define kmalloc(size, flags) ceph_kmalloc(__FILE__, __LINE__, size, flags) +#define kzalloc(size, flags) ceph_kmalloc(__FILE__, __LINE__, size, \ + flags | __GFP_ZERO) +#define kfree ceph_kfree +#endif + +#endif + +#endif diff --git a/fs/ceph/proc.c b/fs/ceph/proc.c new file mode 100644 index 0000000..2ec01ea --- /dev/null +++ b/fs/ceph/proc.c @@ -0,0 +1,186 @@ +#include <linux/module.h> +#include <linux/proc_fs.h> +#include <linux/ctype.h> +#include <linux/uaccess.h> + + +#include "ceph_debug.h" +int ceph_debug_proc = -1; +#define DOUT_MASK DOUT_MASK_PROC +#define DOUT_VAR ceph_debug_proc +#define DOUT_PREFIX "proc: " + +#include "super.h" + + +static int ceph_debug_level_read(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + int len; + int *debug = data; + + len = sprintf(page, "%d\n", *debug); + + if ((len < 0) || (len <= off)) { + *start = page; + *eof = 1; + return 0; + } + + len -= off; + + *start = page + off; + + if (len > count) + len = count; + else + *eof = 1; + + return len; +} + +static int ceph_debug_mask_read(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + int len; + int *debug = data; + + len = sprintf(page, "0x%x\n", *debug); + + if ((len < 0) || (len <= off)) { + *start = page; + *eof = 1; + return 0; + } + + len -= off; + + *start = page + off; + + if (len > count) + len = count; + else + *eof = 1; + + return len; +} + +static int ceph_debug_level_write(struct file *file, const char __user *buffer, + unsigned long count, void *data) +{ +#define PROC_STR_LEN 16 + char level_str[PROC_STR_LEN]; + int new_dl; + int *debug = data; + + if ((count < 1) || (count > sizeof(level_str)-1)) + return -EINVAL; + + level_str[PROC_STR_LEN-1] = 0; + + if (copy_from_user(level_str, buffer, count)) + return -EFAULT; + + level_str[count] = 0; + + new_dl = simple_strtol(level_str, NULL, 0); + + *debug = new_dl; + + return count; +} + +static int ceph_debug_mask_write(struct file *file, const char __user *buffer, + unsigned long count, void *data) +{ + char *mask_str, *tok; + int new_dl; + int *debug = data; + +#define MAX_BUF 512 + if ((count < 1) || (count > MAX_BUF)) + return -EINVAL; + + mask_str = kmalloc(count+1, GFP_KERNEL); + + if (copy_from_user(mask_str, buffer, count)) + return -EFAULT; + + mask_str[count] = 0; + + do { + tok = strsep(&mask_str, " \t\r\n"); + + if (isdigit(*tok)) { + new_dl = simple_strtol(tok, NULL, 0); + *debug = new_dl; + } else { + int remove = 0; + int mask; + + if (*tok == '-') { + remove = 1; + tok++; + } else if (*tok == '+') + tok++; + + mask = ceph_get_debug_mask(tok); + + if (remove) + *debug &= ~mask; + else + *debug |= mask; + + } + } while (mask_str); + + + kfree(mask_str); + + return count; +} + +static struct proc_dir_entry *proc_fs_ceph; + +int ceph_proc_init(void) +{ + struct proc_dir_entry *pde; + + proc_fs_ceph = proc_mkdir("fs/ceph", NULL); + if (!proc_fs_ceph) + return -ENOMEM; + + proc_fs_ceph->owner = THIS_MODULE; + pde = create_proc_read_entry("debug", 0, + proc_fs_ceph, ceph_debug_level_read, + &ceph_debug); + if (pde) + pde->write_proc = ceph_debug_level_write; + pde = create_proc_read_entry("debug_msgr", 0, + proc_fs_ceph, ceph_debug_level_read, + &ceph_debug_msgr); + if (pde) + pde->write_proc = ceph_debug_level_write; + pde = create_proc_read_entry("debug_console", 0, + proc_fs_ceph, ceph_debug_level_read, + &ceph_debug_console); + if (pde) + pde->write_proc = ceph_debug_level_write; + + pde = create_proc_read_entry("debug_mask", 0, + proc_fs_ceph, ceph_debug_mask_read, + &ceph_debug_mask); + if (pde) + pde->write_proc = ceph_debug_mask_write; + + return 0; +} + +void ceph_proc_cleanup(void) +{ + remove_proc_entry("debug", proc_fs_ceph); + remove_proc_entry("debug_msgr", proc_fs_ceph); + remove_proc_entry("debug_console", proc_fs_ceph); + remove_proc_entry("debug_mask", proc_fs_ceph); + remove_proc_entry("fs/ceph", NULL); +} -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH 19/19] ceph: Kconfig, Makefile 2008-11-14 0:56 ` [PATCH 18/19] ceph: debugging Sage Weil @ 2008-11-14 0:56 ` Sage Weil 0 siblings, 0 replies; 20+ messages in thread From: Sage Weil @ 2008-11-14 0:56 UTC (permalink / raw) To: linux-fsdevel; +Cc: linux-kernel, Sage Weil Kconfig options and Makefile. Signed-off-by: Sage Weil <sage@newdream.net> --- fs/Kconfig | 20 ++++++++++++++++++++ fs/Makefile | 1 + fs/ceph/Makefile | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 56 insertions(+), 0 deletions(-) create mode 100644 fs/ceph/Makefile diff --git a/fs/Kconfig b/fs/Kconfig index abccb5d..c5d61b8 100644 --- a/fs/Kconfig +++ b/fs/Kconfig @@ -1803,6 +1803,26 @@ config RPCSEC_GSS_SPKM3 If unsure, say N. +config CEPH_FS + tristate "Ceph distributed file system (EXPERIMENTAL)" + depends on INET && EXPERIMENTAL + select LIBCRC32C + help + Choose Y or M here to include support for mounting the + experimental Ceph distributed file system. Ceph is an extremely + scalable file system designed to provide high performance, + reliable access to petabytes of storage. + + More information at http://ceph.newdream.net/. + + If unsure, say N. + +config CEPH_BOOKKEEPER + bool "Ceph leaks detection tool" + depends on CEPH_FS + help + Leaks detection tool for the Ceph fs. + config SMB_FS tristate "SMB file system support (OBSOLETE, please use CIFS)" depends on INET diff --git a/fs/Makefile b/fs/Makefile index a1482a5..549e129 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -122,3 +122,4 @@ obj-$(CONFIG_HPPFS) += hppfs/ obj-$(CONFIG_DEBUG_FS) += debugfs/ obj-$(CONFIG_OCFS2_FS) += ocfs2/ obj-$(CONFIG_GFS2_FS) += gfs2/ +obj-$(CONFIG_CEPH_FS) += ceph/ diff --git a/fs/ceph/Makefile b/fs/ceph/Makefile new file mode 100644 index 0000000..7926eec --- /dev/null +++ b/fs/ceph/Makefile @@ -0,0 +1,35 @@ +# +# Makefile for CEPH filesystem. +# + +ifneq ($(KERNELRELEASE),) + +obj-$(CONFIG_CEPH_FS) += ceph.o + +ceph-objs := super.o inode.o dir.o file.o addr.o ioctl.o \ + export.o caps.o snap.o \ + messenger.o \ + mds_client.o mdsmap.o \ + mon_client.o \ + osd_client.o osdmap.o crush/crush.o crush/mapper.o \ + proc.o ceph_tools.o + +else +#Otherwise we were called directly from the command +# line; invoke the kernel build system. + +KERNELDIR ?= /lib/modules/$(shell uname -r)/build +PWD := $(shell pwd) + +default: all + +all: + $(MAKE) -C $(KERNELDIR) M=$(PWD) CONFIG_CEPH_FS=m modules + +modules_install: + $(MAKE) -C $(KERNELDIR) M=$(PWD) CONFIG_CEPH_FS=m modules_install + +clean: + $(MAKE) -C $(KERNELDIR) M=$(PWD) clean + +endif -- 1.5.6.5 ^ permalink raw reply related [flat|nested] 20+ messages in thread
end of thread, other threads:[~2008-11-14 1:21 UTC | newest] Thread overview: 20+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2008-11-14 0:55 [PATCH 00/19] ceph: Ceph distributed file system client Sage Weil 2008-11-14 0:56 ` [PATCH 01/19] ceph: documentation Sage Weil 2008-11-14 0:56 ` [PATCH 02/19] ceph: on-wire types Sage Weil 2008-11-14 0:56 ` [PATCH 03/19] ceph: client types Sage Weil 2008-11-14 0:56 ` [PATCH 04/19] ceph: super.c Sage Weil 2008-11-14 0:56 ` [PATCH 05/19] ceph: inode operations Sage Weil 2008-11-14 0:56 ` [PATCH 06/19] ceph: directory operations Sage Weil 2008-11-14 0:56 ` [PATCH 07/19] ceph: file operations Sage Weil 2008-11-14 0:56 ` [PATCH 08/19] ceph: address space operations Sage Weil 2008-11-14 0:56 ` [PATCH 09/19] ceph: MDS client Sage Weil 2008-11-14 0:56 ` [PATCH 10/19] ceph: OSD client Sage Weil 2008-11-14 0:56 ` [PATCH 11/19] ceph: CRUSH mapping algorithm Sage Weil 2008-11-14 0:56 ` [PATCH 12/19] ceph: monitor client Sage Weil 2008-11-14 0:56 ` [PATCH 13/19] ceph: capability management Sage Weil 2008-11-14 0:56 ` [PATCH 14/19] ceph: snapshot management Sage Weil 2008-11-14 0:56 ` [PATCH 15/19] ceph: messenger library Sage Weil 2008-11-14 0:56 ` [PATCH 16/19] ceph: nfs re-export support Sage Weil 2008-11-14 0:56 ` [PATCH 17/19] ceph: ioctls Sage Weil 2008-11-14 0:56 ` [PATCH 18/19] ceph: debugging Sage Weil 2008-11-14 0:56 ` [PATCH 19/19] ceph: Kconfig, Makefile Sage Weil
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).