blob: a40ceda47a3218ee53c2167d8844899c5de3e9cf [file] [log] [blame]
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001#include <linux/ceph/ceph_debug.h>
Sage Weil2817b002009-10-06 11:31:08 -07002
3#include <linux/spinlock.h>
4#include <linux/fs_struct.h>
5#include <linux/namei.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09006#include <linux/slab.h>
Sage Weil2817b002009-10-06 11:31:08 -07007#include <linux/sched.h>
8
9#include "super.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070010#include "mds_client.h"
Sage Weil2817b002009-10-06 11:31:08 -070011
12/*
13 * Directory operations: readdir, lookup, create, link, unlink,
14 * rename, etc.
15 */
16
17/*
18 * Ceph MDS operations are specified in terms of a base ino and
19 * relative path. Thus, the client can specify an operation on a
20 * specific inode (e.g., a getattr due to fstat(2)), or as a path
21 * relative to, say, the root directory.
22 *
23 * Normally, we limit ourselves to strict inode ops (no path component)
24 * or dentry operations (a single path component relative to an ino). The
25 * exception to this is open_root_dentry(), which will open the mount
26 * point by name.
27 */
28
29const struct inode_operations ceph_dir_iops;
30const struct file_operations ceph_dir_fops;
Sage Weil52dfb8a2010-08-03 10:25:30 -070031const struct dentry_operations ceph_dentry_ops;
Sage Weil2817b002009-10-06 11:31:08 -070032
33/*
34 * Initialize ceph dentry state.
35 */
36int ceph_init_dentry(struct dentry *dentry)
37{
38 struct ceph_dentry_info *di;
39
40 if (dentry->d_fsdata)
41 return 0;
42
Sage Weil36e21682010-08-24 16:23:48 -070043 di = kmem_cache_alloc(ceph_dentry_cachep, GFP_NOFS | __GFP_ZERO);
Sage Weil2817b002009-10-06 11:31:08 -070044 if (!di)
45 return -ENOMEM; /* oh well */
46
47 spin_lock(&dentry->d_lock);
Sage Weil8c6efb52010-04-23 11:36:54 -070048 if (dentry->d_fsdata) {
49 /* lost a race */
50 kmem_cache_free(ceph_dentry_cachep, di);
Sage Weil2817b002009-10-06 11:31:08 -070051 goto out_unlock;
Sage Weil8c6efb52010-04-23 11:36:54 -070052 }
Sage Weil48d0cbd2011-07-26 11:30:15 -070053
Sage Weil8842b3b2012-06-07 13:43:35 -070054 if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP)
Sage Weil48d0cbd2011-07-26 11:30:15 -070055 d_set_d_op(dentry, &ceph_dentry_ops);
56 else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR)
57 d_set_d_op(dentry, &ceph_snapdir_dentry_ops);
58 else
59 d_set_d_op(dentry, &ceph_snap_dentry_ops);
60
Sage Weil2817b002009-10-06 11:31:08 -070061 di->dentry = dentry;
62 di->lease_session = NULL;
Sage Weil2817b002009-10-06 11:31:08 -070063 dentry->d_time = jiffies;
Sage Weil48d0cbd2011-07-26 11:30:15 -070064 /* avoid reordering d_fsdata setup so that the check above is safe */
65 smp_mb();
66 dentry->d_fsdata = di;
Sage Weil2817b002009-10-06 11:31:08 -070067 ceph_dentry_lru_add(dentry);
68out_unlock:
69 spin_unlock(&dentry->d_lock);
70 return 0;
71}
72
Sage Weil5f21c962011-07-26 11:30:29 -070073struct inode *ceph_get_dentry_parent_inode(struct dentry *dentry)
74{
75 struct inode *inode = NULL;
76
77 if (!dentry)
78 return NULL;
79
80 spin_lock(&dentry->d_lock);
Sage Weil8842b3b2012-06-07 13:43:35 -070081 if (!IS_ROOT(dentry)) {
Sage Weil5f21c962011-07-26 11:30:29 -070082 inode = dentry->d_parent->d_inode;
83 ihold(inode);
84 }
85 spin_unlock(&dentry->d_lock);
86 return inode;
87}
Sage Weil2817b002009-10-06 11:31:08 -070088
89
90/*
91 * for readdir, we encode the directory frag and offset within that
92 * frag into f_pos.
93 */
94static unsigned fpos_frag(loff_t p)
95{
96 return p >> 32;
97}
98static unsigned fpos_off(loff_t p)
99{
100 return p & 0xffffffff;
101}
102
103/*
104 * When possible, we try to satisfy a readdir by peeking at the
105 * dcache. We make this work by carefully ordering dentries on
106 * d_u.d_child when we initially get results back from the MDS, and
107 * falling back to a "normal" sync readdir if any dentries in the dir
108 * are dropped.
109 *
Yan, Zheng2f276c52013-03-13 19:44:32 +0800110 * Complete dir indicates that we have all dentries in the dir. It is
Sage Weil2817b002009-10-06 11:31:08 -0700111 * defined IFF we hold CEPH_CAP_FILE_SHARED (which will be revoked by
112 * the MDS if/when the directory is modified).
113 */
Al Viro77acfa22013-05-17 16:52:26 -0400114static int __dcache_readdir(struct file *file, struct dir_context *ctx)
Sage Weil2817b002009-10-06 11:31:08 -0700115{
Al Viro77acfa22013-05-17 16:52:26 -0400116 struct ceph_file_info *fi = file->private_data;
117 struct dentry *parent = file->f_dentry;
Sage Weil2817b002009-10-06 11:31:08 -0700118 struct inode *dir = parent->d_inode;
119 struct list_head *p;
120 struct dentry *dentry, *last;
121 struct ceph_dentry_info *di;
122 int err = 0;
123
124 /* claim ref on last dentry we returned */
125 last = fi->dentry;
126 fi->dentry = NULL;
127
Al Viro77acfa22013-05-17 16:52:26 -0400128 dout("__dcache_readdir %p at %llu (last %p)\n", dir, ctx->pos,
Sage Weil2817b002009-10-06 11:31:08 -0700129 last);
130
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100131 spin_lock(&parent->d_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700132
133 /* start at beginning? */
Al Viro77acfa22013-05-17 16:52:26 -0400134 if (ctx->pos == 2 || last == NULL ||
135 ctx->pos < ceph_dentry(last)->offset) {
Sage Weil2817b002009-10-06 11:31:08 -0700136 if (list_empty(&parent->d_subdirs))
137 goto out_unlock;
138 p = parent->d_subdirs.prev;
139 dout(" initial p %p/%p\n", p->prev, p->next);
140 } else {
141 p = last->d_u.d_child.prev;
142 }
143
144more:
145 dentry = list_entry(p, struct dentry, d_u.d_child);
146 di = ceph_dentry(dentry);
147 while (1) {
Sage Weil1cd39352010-05-03 22:08:02 -0700148 dout(" p %p/%p %s d_subdirs %p/%p\n", p->prev, p->next,
149 d_unhashed(dentry) ? "!hashed" : "hashed",
Sage Weil2817b002009-10-06 11:31:08 -0700150 parent->d_subdirs.prev, parent->d_subdirs.next);
151 if (p == &parent->d_subdirs) {
Sage Weil9cfa1092011-07-26 11:26:18 -0700152 fi->flags |= CEPH_F_ATEND;
Sage Weil2817b002009-10-06 11:31:08 -0700153 goto out_unlock;
154 }
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100155 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
Sage Weil2817b002009-10-06 11:31:08 -0700156 if (!d_unhashed(dentry) && dentry->d_inode &&
Sage Weil09b8a7d2009-11-11 15:21:27 -0800157 ceph_snap(dentry->d_inode) != CEPH_SNAPDIR &&
Sage Weil1d1de9162009-12-02 11:54:25 -0800158 ceph_ino(dentry->d_inode) != CEPH_INO_CEPH &&
Al Viro77acfa22013-05-17 16:52:26 -0400159 ctx->pos <= di->offset)
Sage Weil2817b002009-10-06 11:31:08 -0700160 break;
161 dout(" skipping %p %.*s at %llu (%llu)%s%s\n", dentry,
162 dentry->d_name.len, dentry->d_name.name, di->offset,
Al Viro77acfa22013-05-17 16:52:26 -0400163 ctx->pos, d_unhashed(dentry) ? " unhashed" : "",
Sage Weil2817b002009-10-06 11:31:08 -0700164 !dentry->d_inode ? " null" : "");
Nick Pigginda502952011-01-07 17:49:33 +1100165 spin_unlock(&dentry->d_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700166 p = p->prev;
167 dentry = list_entry(p, struct dentry, d_u.d_child);
168 di = ceph_dentry(dentry);
169 }
170
Nick Pigginda502952011-01-07 17:49:33 +1100171 dget_dlock(dentry);
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100172 spin_unlock(&dentry->d_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100173 spin_unlock(&parent->d_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700174
Al Viro77acfa22013-05-17 16:52:26 -0400175 dout(" %llu (%llu) dentry %p %.*s %p\n", di->offset, ctx->pos,
Sage Weil2817b002009-10-06 11:31:08 -0700176 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
Al Viro77acfa22013-05-17 16:52:26 -0400177 ctx->pos = di->offset;
178 if (!dir_emit(ctx, dentry->d_name.name,
179 dentry->d_name.len,
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800180 ceph_translate_ino(dentry->d_sb, dentry->d_inode->i_ino),
Al Viro77acfa22013-05-17 16:52:26 -0400181 dentry->d_inode->i_mode >> 12)) {
182 if (last) {
Sage Weil2817b002009-10-06 11:31:08 -0700183 /* remember our position */
184 fi->dentry = last;
185 fi->next_offset = di->offset;
Sage Weil2817b002009-10-06 11:31:08 -0700186 }
Al Viro77acfa22013-05-17 16:52:26 -0400187 dput(dentry);
188 return 0;
Sage Weil2817b002009-10-06 11:31:08 -0700189 }
Al Viro77acfa22013-05-17 16:52:26 -0400190
191 if (last)
192 dput(last);
Sage Weilf5b06622010-04-12 14:24:28 -0700193 last = dentry;
194
Al Viro77acfa22013-05-17 16:52:26 -0400195 ctx->pos++;
Sage Weil2817b002009-10-06 11:31:08 -0700196
Nick Pigginb5c84bf2011-01-07 17:49:38 +1100197 /* make sure a dentry wasn't dropped while we didn't have parent lock */
Yan, Zheng2f276c52013-03-13 19:44:32 +0800198 if (!ceph_dir_is_complete(dir)) {
199 dout(" lost dir complete on %p; falling back to mds\n", dir);
Sage Weilefa4c122010-10-18 14:04:31 -0700200 err = -EAGAIN;
201 goto out;
202 }
203
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100204 spin_lock(&parent->d_lock);
Sage Weilefa4c122010-10-18 14:04:31 -0700205 p = p->prev; /* advance to next dentry */
206 goto more;
Sage Weil2817b002009-10-06 11:31:08 -0700207
208out_unlock:
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100209 spin_unlock(&parent->d_lock);
Sage Weilefa4c122010-10-18 14:04:31 -0700210out:
211 if (last)
Sage Weil2817b002009-10-06 11:31:08 -0700212 dput(last);
Sage Weil2817b002009-10-06 11:31:08 -0700213 return err;
214}
215
216/*
217 * make note of the last dentry we read, so we can
218 * continue at the same lexicographical point,
219 * regardless of what dir changes take place on the
220 * server.
221 */
222static int note_last_dentry(struct ceph_file_info *fi, const char *name,
223 int len)
224{
225 kfree(fi->last_name);
226 fi->last_name = kmalloc(len+1, GFP_NOFS);
227 if (!fi->last_name)
228 return -ENOMEM;
229 memcpy(fi->last_name, name, len);
230 fi->last_name[len] = 0;
231 dout("note_last_dentry '%s'\n", fi->last_name);
232 return 0;
233}
234
Al Viro77acfa22013-05-17 16:52:26 -0400235static int ceph_readdir(struct file *file, struct dir_context *ctx)
Sage Weil2817b002009-10-06 11:31:08 -0700236{
Al Viro77acfa22013-05-17 16:52:26 -0400237 struct ceph_file_info *fi = file->private_data;
238 struct inode *inode = file_inode(file);
Sage Weil2817b002009-10-06 11:31:08 -0700239 struct ceph_inode_info *ci = ceph_inode(inode);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700240 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
241 struct ceph_mds_client *mdsc = fsc->mdsc;
Al Viro77acfa22013-05-17 16:52:26 -0400242 unsigned frag = fpos_frag(ctx->pos);
243 int off = fpos_off(ctx->pos);
Sage Weil2817b002009-10-06 11:31:08 -0700244 int err;
245 u32 ftype;
246 struct ceph_mds_reply_info_parsed *rinfo;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700247 const int max_entries = fsc->mount_options->max_readdir;
248 const int max_bytes = fsc->mount_options->max_readdir_bytes;
Sage Weil2817b002009-10-06 11:31:08 -0700249
Al Viro77acfa22013-05-17 16:52:26 -0400250 dout("readdir %p file %p frag %u off %u\n", inode, file, frag, off);
Sage Weil9cfa1092011-07-26 11:26:18 -0700251 if (fi->flags & CEPH_F_ATEND)
Sage Weil2817b002009-10-06 11:31:08 -0700252 return 0;
253
254 /* always start with . and .. */
Al Viro77acfa22013-05-17 16:52:26 -0400255 if (ctx->pos == 0) {
Sage Weil2817b002009-10-06 11:31:08 -0700256 /* note dir version at start of readdir so we can tell
257 * if any dentries get dropped */
Yan, Zheng2f276c52013-03-13 19:44:32 +0800258 fi->dir_release_count = atomic_read(&ci->i_release_count);
Sage Weil2817b002009-10-06 11:31:08 -0700259
260 dout("readdir off 0 -> '.'\n");
Al Viro77acfa22013-05-17 16:52:26 -0400261 if (!dir_emit(ctx, ".", 1,
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800262 ceph_translate_ino(inode->i_sb, inode->i_ino),
Al Viro77acfa22013-05-17 16:52:26 -0400263 inode->i_mode >> 12))
Sage Weil2817b002009-10-06 11:31:08 -0700264 return 0;
Al Viro77acfa22013-05-17 16:52:26 -0400265 ctx->pos = 1;
Sage Weil2817b002009-10-06 11:31:08 -0700266 off = 1;
267 }
Al Viro77acfa22013-05-17 16:52:26 -0400268 if (ctx->pos == 1) {
269 ino_t ino = parent_ino(file->f_dentry);
Sage Weil2817b002009-10-06 11:31:08 -0700270 dout("readdir off 1 -> '..'\n");
Al Viro77acfa22013-05-17 16:52:26 -0400271 if (!dir_emit(ctx, "..", 2,
Yehuda Sadehad1fee92011-01-21 16:44:03 -0800272 ceph_translate_ino(inode->i_sb, ino),
Al Viro77acfa22013-05-17 16:52:26 -0400273 inode->i_mode >> 12))
Sage Weil2817b002009-10-06 11:31:08 -0700274 return 0;
Al Viro77acfa22013-05-17 16:52:26 -0400275 ctx->pos = 2;
Sage Weil2817b002009-10-06 11:31:08 -0700276 off = 2;
277 }
278
279 /* can we use the dcache? */
Sage Weilbe655592011-11-30 09:47:09 -0800280 spin_lock(&ci->i_ceph_lock);
Al Viro77acfa22013-05-17 16:52:26 -0400281 if ((ctx->pos == 2 || fi->dentry) &&
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700282 !ceph_test_mount_opt(fsc, NOASYNCREADDIR) &&
Sage Weila0dff782010-07-22 13:47:21 -0700283 ceph_snap(inode) != CEPH_SNAPDIR &&
Yan, Zheng2f276c52013-03-13 19:44:32 +0800284 __ceph_dir_is_complete(ci) &&
Sage Weil2817b002009-10-06 11:31:08 -0700285 __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1)) {
Sage Weilbe655592011-11-30 09:47:09 -0800286 spin_unlock(&ci->i_ceph_lock);
Al Viro77acfa22013-05-17 16:52:26 -0400287 err = __dcache_readdir(file, ctx);
Sage Weilefa4c122010-10-18 14:04:31 -0700288 if (err != -EAGAIN)
Sage Weil2817b002009-10-06 11:31:08 -0700289 return err;
Sage Weilefa4c122010-10-18 14:04:31 -0700290 } else {
Sage Weilbe655592011-11-30 09:47:09 -0800291 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700292 }
Sage Weil2817b002009-10-06 11:31:08 -0700293 if (fi->dentry) {
294 err = note_last_dentry(fi, fi->dentry->d_name.name,
295 fi->dentry->d_name.len);
296 if (err)
297 return err;
298 dput(fi->dentry);
299 fi->dentry = NULL;
300 }
301
302 /* proceed with a normal readdir */
303
304more:
305 /* do we have the correct frag content buffered? */
306 if (fi->frag != frag || fi->last_readdir == NULL) {
307 struct ceph_mds_request *req;
308 int op = ceph_snap(inode) == CEPH_SNAPDIR ?
309 CEPH_MDS_OP_LSSNAP : CEPH_MDS_OP_READDIR;
310
311 /* discard old result, if any */
Sage Weil393f6622010-03-10 12:03:32 -0800312 if (fi->last_readdir) {
Sage Weil2817b002009-10-06 11:31:08 -0700313 ceph_mdsc_put_request(fi->last_readdir);
Sage Weil393f6622010-03-10 12:03:32 -0800314 fi->last_readdir = NULL;
315 }
Sage Weil2817b002009-10-06 11:31:08 -0700316
317 /* requery frag tree, as the frag topology may have changed */
318 frag = ceph_choose_frag(ceph_inode(inode), frag, NULL, NULL);
319
320 dout("readdir fetching %llx.%llx frag %x offset '%s'\n",
321 ceph_vinop(inode), frag, fi->last_name);
322 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
323 if (IS_ERR(req))
324 return PTR_ERR(req);
Sage Weil70b666c2011-05-27 09:24:26 -0700325 req->r_inode = inode;
326 ihold(inode);
Al Viro77acfa22013-05-17 16:52:26 -0400327 req->r_dentry = dget(file->f_dentry);
Sage Weil2817b002009-10-06 11:31:08 -0700328 /* hints to request -> mds selection code */
329 req->r_direct_mode = USE_AUTH_MDS;
330 req->r_direct_hash = ceph_frag_value(frag);
331 req->r_direct_is_hash = true;
332 req->r_path2 = kstrdup(fi->last_name, GFP_NOFS);
333 req->r_readdir_offset = fi->next_offset;
334 req->r_args.readdir.frag = cpu_to_le32(frag);
335 req->r_args.readdir.max_entries = cpu_to_le32(max_entries);
Sage Weil23804d92010-05-14 13:06:30 -0700336 req->r_args.readdir.max_bytes = cpu_to_le32(max_bytes);
Yehuda Sadehe1e4dd02010-04-13 11:45:56 -0700337 req->r_num_caps = max_entries + 1;
Sage Weil2817b002009-10-06 11:31:08 -0700338 err = ceph_mdsc_do_request(mdsc, NULL, req);
339 if (err < 0) {
340 ceph_mdsc_put_request(req);
341 return err;
342 }
343 dout("readdir got and parsed readdir result=%d"
344 " on frag %x, end=%d, complete=%d\n", err, frag,
345 (int)req->r_reply_info.dir_end,
346 (int)req->r_reply_info.dir_complete);
347
348 if (!req->r_did_prepopulate) {
349 dout("readdir !did_prepopulate");
Yan, Zheng2f276c52013-03-13 19:44:32 +0800350 /* preclude from marking dir complete */
351 fi->dir_release_count--;
Sage Weil2817b002009-10-06 11:31:08 -0700352 }
353
354 /* note next offset and last dentry name */
355 fi->offset = fi->next_offset;
356 fi->last_readdir = req;
357
358 if (req->r_reply_info.dir_end) {
359 kfree(fi->last_name);
360 fi->last_name = NULL;
Sage Weil7b88dad2010-11-11 16:48:59 -0800361 if (ceph_frag_is_rightmost(frag))
362 fi->next_offset = 2;
363 else
364 fi->next_offset = 0;
Sage Weil2817b002009-10-06 11:31:08 -0700365 } else {
366 rinfo = &req->r_reply_info;
367 err = note_last_dentry(fi,
368 rinfo->dir_dname[rinfo->dir_nr-1],
369 rinfo->dir_dname_len[rinfo->dir_nr-1]);
370 if (err)
371 return err;
372 fi->next_offset += rinfo->dir_nr;
373 }
374 }
375
376 rinfo = &fi->last_readdir->r_reply_info;
377 dout("readdir frag %x num %d off %d chunkoff %d\n", frag,
378 rinfo->dir_nr, off, fi->offset);
Al Viro77acfa22013-05-17 16:52:26 -0400379
380 ctx->pos = ceph_make_fpos(frag, off);
Sage Weilda398222011-05-12 15:28:11 -0700381 while (off >= fi->offset && off - fi->offset < rinfo->dir_nr) {
Sage Weil2817b002009-10-06 11:31:08 -0700382 struct ceph_mds_reply_inode *in =
383 rinfo->dir_in[off - fi->offset].in;
Sage Weil3105c192010-11-18 09:15:07 -0800384 struct ceph_vino vino;
385 ino_t ino;
386
Sage Weil2817b002009-10-06 11:31:08 -0700387 dout("readdir off %d (%d/%d) -> %lld '%.*s' %p\n",
Al Viro77acfa22013-05-17 16:52:26 -0400388 off, off - fi->offset, rinfo->dir_nr, ctx->pos,
Sage Weil2817b002009-10-06 11:31:08 -0700389 rinfo->dir_dname_len[off - fi->offset],
390 rinfo->dir_dname[off - fi->offset], in);
391 BUG_ON(!in);
392 ftype = le32_to_cpu(in->mode) >> 12;
Sage Weil3105c192010-11-18 09:15:07 -0800393 vino.ino = le64_to_cpu(in->ino);
394 vino.snap = le64_to_cpu(in->snapid);
395 ino = ceph_vino_to_ino(vino);
Al Viro77acfa22013-05-17 16:52:26 -0400396 if (!dir_emit(ctx,
Sage Weil2817b002009-10-06 11:31:08 -0700397 rinfo->dir_dname[off - fi->offset],
398 rinfo->dir_dname_len[off - fi->offset],
Al Viro77acfa22013-05-17 16:52:26 -0400399 ceph_translate_ino(inode->i_sb, ino), ftype)) {
Sage Weil2817b002009-10-06 11:31:08 -0700400 dout("filldir stopping us...\n");
401 return 0;
402 }
403 off++;
Al Viro77acfa22013-05-17 16:52:26 -0400404 ctx->pos++;
Sage Weil2817b002009-10-06 11:31:08 -0700405 }
406
407 if (fi->last_name) {
408 ceph_mdsc_put_request(fi->last_readdir);
409 fi->last_readdir = NULL;
410 goto more;
411 }
412
413 /* more frags? */
414 if (!ceph_frag_is_rightmost(frag)) {
415 frag = ceph_frag_next(frag);
416 off = 0;
Al Viro77acfa22013-05-17 16:52:26 -0400417 ctx->pos = ceph_make_fpos(frag, off);
Sage Weil2817b002009-10-06 11:31:08 -0700418 dout("readdir next frag is %x\n", frag);
419 goto more;
420 }
Sage Weil9cfa1092011-07-26 11:26:18 -0700421 fi->flags |= CEPH_F_ATEND;
Sage Weil2817b002009-10-06 11:31:08 -0700422
423 /*
424 * if dir_release_count still matches the dir, no dentries
425 * were released during the whole readdir, and we should have
426 * the complete dir contents in our cache.
427 */
Sage Weilbe655592011-11-30 09:47:09 -0800428 spin_lock(&ci->i_ceph_lock);
Yan, Zheng2f276c52013-03-13 19:44:32 +0800429 if (atomic_read(&ci->i_release_count) == fi->dir_release_count) {
Yan, Zhenga8673d62013-02-18 16:38:14 +0800430 dout(" marking %p complete\n", inode);
Yan, Zheng2f276c52013-03-13 19:44:32 +0800431 __ceph_dir_set_complete(ci, fi->dir_release_count);
Al Viro77acfa22013-05-17 16:52:26 -0400432 ci->i_max_offset = ctx->pos;
Sage Weil2817b002009-10-06 11:31:08 -0700433 }
Sage Weilbe655592011-11-30 09:47:09 -0800434 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700435
Al Viro77acfa22013-05-17 16:52:26 -0400436 dout("readdir %p file %p done.\n", inode, file);
Sage Weil2817b002009-10-06 11:31:08 -0700437 return 0;
438}
439
440static void reset_readdir(struct ceph_file_info *fi)
441{
442 if (fi->last_readdir) {
443 ceph_mdsc_put_request(fi->last_readdir);
444 fi->last_readdir = NULL;
445 }
446 kfree(fi->last_name);
Sage Weila1629c32010-11-11 15:24:06 -0800447 fi->last_name = NULL;
Sage Weil2817b002009-10-06 11:31:08 -0700448 fi->next_offset = 2; /* compensate for . and .. */
449 if (fi->dentry) {
450 dput(fi->dentry);
451 fi->dentry = NULL;
452 }
Sage Weil9cfa1092011-07-26 11:26:18 -0700453 fi->flags &= ~CEPH_F_ATEND;
Sage Weil2817b002009-10-06 11:31:08 -0700454}
455
Andrew Morton965c8e52012-12-17 15:59:39 -0800456static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence)
Sage Weil2817b002009-10-06 11:31:08 -0700457{
458 struct ceph_file_info *fi = file->private_data;
459 struct inode *inode = file->f_mapping->host;
460 loff_t old_offset = offset;
461 loff_t retval;
462
463 mutex_lock(&inode->i_mutex);
Josef Bacik06222e42011-07-18 13:21:38 -0400464 retval = -EINVAL;
Andrew Morton965c8e52012-12-17 15:59:39 -0800465 switch (whence) {
Sage Weil2817b002009-10-06 11:31:08 -0700466 case SEEK_END:
467 offset += inode->i_size + 2; /* FIXME */
468 break;
469 case SEEK_CUR:
470 offset += file->f_pos;
Josef Bacik06222e42011-07-18 13:21:38 -0400471 case SEEK_SET:
472 break;
473 default:
474 goto out;
Sage Weil2817b002009-10-06 11:31:08 -0700475 }
Josef Bacik06222e42011-07-18 13:21:38 -0400476
Sage Weil2817b002009-10-06 11:31:08 -0700477 if (offset >= 0 && offset <= inode->i_sb->s_maxbytes) {
478 if (offset != file->f_pos) {
479 file->f_pos = offset;
480 file->f_version = 0;
Sage Weil9cfa1092011-07-26 11:26:18 -0700481 fi->flags &= ~CEPH_F_ATEND;
Sage Weil2817b002009-10-06 11:31:08 -0700482 }
483 retval = offset;
484
485 /*
486 * discard buffered readdir content on seekdir(0), or
487 * seek to new frag, or seek prior to current chunk.
488 */
489 if (offset == 0 ||
490 fpos_frag(offset) != fpos_frag(old_offset) ||
491 fpos_off(offset) < fi->offset) {
492 dout("dir_llseek dropping %p content\n", file);
493 reset_readdir(fi);
494 }
495
496 /* bump dir_release_count if we did a forward seek */
497 if (offset > old_offset)
498 fi->dir_release_count--;
499 }
Josef Bacik06222e42011-07-18 13:21:38 -0400500out:
Sage Weil2817b002009-10-06 11:31:08 -0700501 mutex_unlock(&inode->i_mutex);
502 return retval;
503}
504
505/*
Sage Weil468640e2011-07-26 11:28:11 -0700506 * Handle lookups for the hidden .snap directory.
Sage Weil2817b002009-10-06 11:31:08 -0700507 */
Sage Weil468640e2011-07-26 11:28:11 -0700508int ceph_handle_snapdir(struct ceph_mds_request *req,
509 struct dentry *dentry, int err)
Sage Weil2817b002009-10-06 11:31:08 -0700510{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700511 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb);
Sage Weild79698d2011-07-26 11:31:26 -0700512 struct inode *parent = dentry->d_parent->d_inode; /* we hold i_mutex */
Sage Weil2817b002009-10-06 11:31:08 -0700513
514 /* .snap dir? */
515 if (err == -ENOENT &&
Sage Weil455cec02011-03-03 13:44:35 -0800516 ceph_snap(parent) == CEPH_NOSNAP &&
Sage Weil6b805182009-10-27 11:50:50 -0700517 strcmp(dentry->d_name.name,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700518 fsc->mount_options->snapdir_name) == 0) {
Sage Weil2817b002009-10-06 11:31:08 -0700519 struct inode *inode = ceph_get_snapdir(parent);
520 dout("ENOENT on snapdir %p '%.*s', linking to snapdir %p\n",
521 dentry, dentry->d_name.len, dentry->d_name.name, inode);
Sage Weil9358c6d2010-03-30 13:54:41 -0700522 BUG_ON(!d_unhashed(dentry));
Sage Weil2817b002009-10-06 11:31:08 -0700523 d_add(dentry, inode);
524 err = 0;
525 }
Sage Weil468640e2011-07-26 11:28:11 -0700526 return err;
527}
Sage Weil2817b002009-10-06 11:31:08 -0700528
Sage Weil468640e2011-07-26 11:28:11 -0700529/*
530 * Figure out final result of a lookup/open request.
531 *
532 * Mainly, make sure we return the final req->r_dentry (if it already
533 * existed) in place of the original VFS-provided dentry when they
534 * differ.
535 *
536 * Gracefully handle the case where the MDS replies with -ENOENT and
537 * no trace (which it may do, at its discretion, e.g., if it doesn't
538 * care to issue a lease on the negative dentry).
539 */
540struct dentry *ceph_finish_lookup(struct ceph_mds_request *req,
541 struct dentry *dentry, int err)
542{
Sage Weil2817b002009-10-06 11:31:08 -0700543 if (err == -ENOENT) {
544 /* no trace? */
545 err = 0;
546 if (!req->r_reply_info.head->is_dentry) {
547 dout("ENOENT and no trace, dentry %p inode %p\n",
548 dentry, dentry->d_inode);
549 if (dentry->d_inode) {
550 d_drop(dentry);
551 err = -ENOENT;
552 } else {
553 d_add(dentry, NULL);
554 }
555 }
556 }
557 if (err)
558 dentry = ERR_PTR(err);
559 else if (dentry != req->r_dentry)
560 dentry = dget(req->r_dentry); /* we got spliced */
561 else
562 dentry = NULL;
563 return dentry;
564}
565
Sage Weil1d1de9162009-12-02 11:54:25 -0800566static int is_root_ceph_dentry(struct inode *inode, struct dentry *dentry)
567{
568 return ceph_ino(inode) == CEPH_INO_ROOT &&
569 strncmp(dentry->d_name.name, ".ceph", 5) == 0;
570}
571
Sage Weil2817b002009-10-06 11:31:08 -0700572/*
573 * Look up a single dir entry. If there is a lookup intent, inform
574 * the MDS so that it gets our 'caps wanted' value in a single op.
575 */
576static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry,
Al Viro00cd8dd2012-06-10 17:13:09 -0400577 unsigned int flags)
Sage Weil2817b002009-10-06 11:31:08 -0700578{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700579 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
580 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700581 struct ceph_mds_request *req;
582 int op;
583 int err;
584
585 dout("lookup %p dentry %p '%.*s'\n",
586 dir, dentry, dentry->d_name.len, dentry->d_name.name);
587
588 if (dentry->d_name.len > NAME_MAX)
589 return ERR_PTR(-ENAMETOOLONG);
590
591 err = ceph_init_dentry(dentry);
592 if (err < 0)
593 return ERR_PTR(err);
594
Sage Weil2817b002009-10-06 11:31:08 -0700595 /* can we conclude ENOENT locally? */
596 if (dentry->d_inode == NULL) {
597 struct ceph_inode_info *ci = ceph_inode(dir);
598 struct ceph_dentry_info *di = ceph_dentry(dentry);
599
Sage Weilbe655592011-11-30 09:47:09 -0800600 spin_lock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700601 dout(" dir %p flags are %d\n", dir, ci->i_ceph_flags);
602 if (strncmp(dentry->d_name.name,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700603 fsc->mount_options->snapdir_name,
Sage Weil2817b002009-10-06 11:31:08 -0700604 dentry->d_name.len) &&
Sage Weil1d1de9162009-12-02 11:54:25 -0800605 !is_root_ceph_dentry(dir, dentry) &&
Yan, Zheng2f276c52013-03-13 19:44:32 +0800606 __ceph_dir_is_complete(ci) &&
Sage Weil2817b002009-10-06 11:31:08 -0700607 (__ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1))) {
Sage Weilbe655592011-11-30 09:47:09 -0800608 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700609 dout(" dir %p complete, -ENOENT\n", dir);
610 d_add(dentry, NULL);
611 di->lease_shared_gen = ci->i_shared_gen;
612 return NULL;
613 }
Sage Weilbe655592011-11-30 09:47:09 -0800614 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700615 }
616
617 op = ceph_snap(dir) == CEPH_SNAPDIR ?
618 CEPH_MDS_OP_LOOKUPSNAP : CEPH_MDS_OP_LOOKUP;
619 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS);
620 if (IS_ERR(req))
Julia Lawall7e34bc52010-05-22 12:01:14 +0200621 return ERR_CAST(req);
Sage Weil2817b002009-10-06 11:31:08 -0700622 req->r_dentry = dget(dentry);
623 req->r_num_caps = 2;
624 /* we only need inode linkage */
625 req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INODE);
626 req->r_locked_dir = dir;
627 err = ceph_mdsc_do_request(mdsc, NULL, req);
Sage Weil468640e2011-07-26 11:28:11 -0700628 err = ceph_handle_snapdir(req, dentry, err);
Sage Weil2817b002009-10-06 11:31:08 -0700629 dentry = ceph_finish_lookup(req, dentry, err);
630 ceph_mdsc_put_request(req); /* will dput(dentry) */
631 dout("lookup result=%p\n", dentry);
632 return dentry;
633}
634
635/*
636 * If we do a create but get no trace back from the MDS, follow up with
637 * a lookup (the VFS expects us to link up the provided dentry).
638 */
639int ceph_handle_notrace_create(struct inode *dir, struct dentry *dentry)
640{
Al Viro00cd8dd2012-06-10 17:13:09 -0400641 struct dentry *result = ceph_lookup(dir, dentry, 0);
Sage Weil2817b002009-10-06 11:31:08 -0700642
643 if (result && !IS_ERR(result)) {
644 /*
645 * We created the item, then did a lookup, and found
646 * it was already linked to another inode we already
647 * had in our cache (and thus got spliced). Link our
648 * dentry to that inode, but don't hash it, just in
649 * case the VFS wants to dereference it.
650 */
651 BUG_ON(!result->d_inode);
652 d_instantiate(dentry, result->d_inode);
653 return 0;
654 }
655 return PTR_ERR(result);
656}
657
658static int ceph_mknod(struct inode *dir, struct dentry *dentry,
Al Viro1a67aaf2011-07-26 01:52:52 -0400659 umode_t mode, dev_t rdev)
Sage Weil2817b002009-10-06 11:31:08 -0700660{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700661 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
662 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700663 struct ceph_mds_request *req;
664 int err;
665
666 if (ceph_snap(dir) != CEPH_NOSNAP)
667 return -EROFS;
668
Al Viro1a67aaf2011-07-26 01:52:52 -0400669 dout("mknod in dir %p dentry %p mode 0%ho rdev %d\n",
Sage Weil2817b002009-10-06 11:31:08 -0700670 dir, dentry, mode, rdev);
671 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, USE_AUTH_MDS);
672 if (IS_ERR(req)) {
673 d_drop(dentry);
674 return PTR_ERR(req);
675 }
676 req->r_dentry = dget(dentry);
677 req->r_num_caps = 2;
678 req->r_locked_dir = dir;
679 req->r_args.mknod.mode = cpu_to_le32(mode);
680 req->r_args.mknod.rdev = cpu_to_le32(rdev);
681 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
682 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
683 err = ceph_mdsc_do_request(mdsc, dir, req);
684 if (!err && !req->r_reply_info.head->is_dentry)
685 err = ceph_handle_notrace_create(dir, dentry);
686 ceph_mdsc_put_request(req);
687 if (err)
688 d_drop(dentry);
689 return err;
690}
691
Al Viro4acdaf22011-07-26 01:42:34 -0400692static int ceph_create(struct inode *dir, struct dentry *dentry, umode_t mode,
Al Viroebfc3b42012-06-10 18:05:36 -0400693 bool excl)
Sage Weil2817b002009-10-06 11:31:08 -0700694{
Miklos Szeredi2d83bde2012-06-05 15:10:25 +0200695 return ceph_mknod(dir, dentry, mode, 0);
Sage Weil2817b002009-10-06 11:31:08 -0700696}
697
698static int ceph_symlink(struct inode *dir, struct dentry *dentry,
699 const char *dest)
700{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700701 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
702 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700703 struct ceph_mds_request *req;
704 int err;
705
706 if (ceph_snap(dir) != CEPH_NOSNAP)
707 return -EROFS;
708
709 dout("symlink in dir %p dentry %p to '%s'\n", dir, dentry, dest);
710 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, USE_AUTH_MDS);
711 if (IS_ERR(req)) {
712 d_drop(dentry);
713 return PTR_ERR(req);
714 }
715 req->r_dentry = dget(dentry);
716 req->r_num_caps = 2;
717 req->r_path2 = kstrdup(dest, GFP_NOFS);
718 req->r_locked_dir = dir;
719 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
720 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
721 err = ceph_mdsc_do_request(mdsc, dir, req);
722 if (!err && !req->r_reply_info.head->is_dentry)
723 err = ceph_handle_notrace_create(dir, dentry);
724 ceph_mdsc_put_request(req);
725 if (err)
726 d_drop(dentry);
727 return err;
728}
729
Al Viro18bb1db2011-07-26 01:41:39 -0400730static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Sage Weil2817b002009-10-06 11:31:08 -0700731{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700732 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
733 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700734 struct ceph_mds_request *req;
735 int err = -EROFS;
736 int op;
737
738 if (ceph_snap(dir) == CEPH_SNAPDIR) {
739 /* mkdir .snap/foo is a MKSNAP */
740 op = CEPH_MDS_OP_MKSNAP;
741 dout("mksnap dir %p snap '%.*s' dn %p\n", dir,
742 dentry->d_name.len, dentry->d_name.name, dentry);
743 } else if (ceph_snap(dir) == CEPH_NOSNAP) {
Al Viro18bb1db2011-07-26 01:41:39 -0400744 dout("mkdir dir %p dn %p mode 0%ho\n", dir, dentry, mode);
Sage Weil2817b002009-10-06 11:31:08 -0700745 op = CEPH_MDS_OP_MKDIR;
746 } else {
747 goto out;
748 }
749 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
750 if (IS_ERR(req)) {
751 err = PTR_ERR(req);
752 goto out;
753 }
754
755 req->r_dentry = dget(dentry);
756 req->r_num_caps = 2;
757 req->r_locked_dir = dir;
758 req->r_args.mkdir.mode = cpu_to_le32(mode);
759 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
760 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
761 err = ceph_mdsc_do_request(mdsc, dir, req);
762 if (!err && !req->r_reply_info.head->is_dentry)
763 err = ceph_handle_notrace_create(dir, dentry);
764 ceph_mdsc_put_request(req);
765out:
766 if (err < 0)
767 d_drop(dentry);
768 return err;
769}
770
771static int ceph_link(struct dentry *old_dentry, struct inode *dir,
772 struct dentry *dentry)
773{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700774 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
775 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700776 struct ceph_mds_request *req;
777 int err;
778
779 if (ceph_snap(dir) != CEPH_NOSNAP)
780 return -EROFS;
781
782 dout("link in dir %p old_dentry %p dentry %p\n", dir,
783 old_dentry, dentry);
784 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LINK, USE_AUTH_MDS);
785 if (IS_ERR(req)) {
786 d_drop(dentry);
787 return PTR_ERR(req);
788 }
789 req->r_dentry = dget(dentry);
790 req->r_num_caps = 2;
791 req->r_old_dentry = dget(old_dentry); /* or inode? hrm. */
Sage Weil41b02e12011-07-26 11:31:14 -0700792 req->r_old_dentry_dir = ceph_get_dentry_parent_inode(old_dentry);
Sage Weil2817b002009-10-06 11:31:08 -0700793 req->r_locked_dir = dir;
794 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
795 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
796 err = ceph_mdsc_do_request(mdsc, dir, req);
Sage Weil70b666c2011-05-27 09:24:26 -0700797 if (err) {
Sage Weil2817b002009-10-06 11:31:08 -0700798 d_drop(dentry);
Sage Weil70b666c2011-05-27 09:24:26 -0700799 } else if (!req->r_reply_info.head->is_dentry) {
800 ihold(old_dentry->d_inode);
801 d_instantiate(dentry, old_dentry->d_inode);
802 }
Sage Weil2817b002009-10-06 11:31:08 -0700803 ceph_mdsc_put_request(req);
804 return err;
805}
806
807/*
808 * For a soon-to-be unlinked file, drop the AUTH_RDCACHE caps. If it
809 * looks like the link count will hit 0, drop any other caps (other
810 * than PIN) we don't specifically want (due to the file still being
811 * open).
812 */
813static int drop_caps_for_unlink(struct inode *inode)
814{
815 struct ceph_inode_info *ci = ceph_inode(inode);
816 int drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL;
817
Sage Weilbe655592011-11-30 09:47:09 -0800818 spin_lock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700819 if (inode->i_nlink == 1) {
820 drop |= ~(__ceph_caps_wanted(ci) | CEPH_CAP_PIN);
821 ci->i_ceph_flags |= CEPH_I_NODELAY;
822 }
Sage Weilbe655592011-11-30 09:47:09 -0800823 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700824 return drop;
825}
826
827/*
828 * rmdir and unlink are differ only by the metadata op code
829 */
830static int ceph_unlink(struct inode *dir, struct dentry *dentry)
831{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700832 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb);
833 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700834 struct inode *inode = dentry->d_inode;
835 struct ceph_mds_request *req;
836 int err = -EROFS;
837 int op;
838
839 if (ceph_snap(dir) == CEPH_SNAPDIR) {
840 /* rmdir .snap/foo is RMSNAP */
841 dout("rmsnap dir %p '%.*s' dn %p\n", dir, dentry->d_name.len,
842 dentry->d_name.name, dentry);
843 op = CEPH_MDS_OP_RMSNAP;
844 } else if (ceph_snap(dir) == CEPH_NOSNAP) {
845 dout("unlink/rmdir dir %p dn %p inode %p\n",
846 dir, dentry, inode);
Al Virodba19c62011-07-25 20:49:29 -0400847 op = S_ISDIR(dentry->d_inode->i_mode) ?
Sage Weil2817b002009-10-06 11:31:08 -0700848 CEPH_MDS_OP_RMDIR : CEPH_MDS_OP_UNLINK;
849 } else
850 goto out;
851 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
852 if (IS_ERR(req)) {
853 err = PTR_ERR(req);
854 goto out;
855 }
856 req->r_dentry = dget(dentry);
857 req->r_num_caps = 2;
858 req->r_locked_dir = dir;
859 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
860 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
861 req->r_inode_drop = drop_caps_for_unlink(inode);
862 err = ceph_mdsc_do_request(mdsc, dir, req);
863 if (!err && !req->r_reply_info.head->is_dentry)
864 d_delete(dentry);
865 ceph_mdsc_put_request(req);
866out:
867 return err;
868}
869
870static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
871 struct inode *new_dir, struct dentry *new_dentry)
872{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700873 struct ceph_fs_client *fsc = ceph_sb_to_client(old_dir->i_sb);
874 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil2817b002009-10-06 11:31:08 -0700875 struct ceph_mds_request *req;
876 int err;
877
878 if (ceph_snap(old_dir) != ceph_snap(new_dir))
879 return -EXDEV;
880 if (ceph_snap(old_dir) != CEPH_NOSNAP ||
881 ceph_snap(new_dir) != CEPH_NOSNAP)
882 return -EROFS;
883 dout("rename dir %p dentry %p to dir %p dentry %p\n",
884 old_dir, old_dentry, new_dir, new_dentry);
885 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_RENAME, USE_AUTH_MDS);
886 if (IS_ERR(req))
887 return PTR_ERR(req);
888 req->r_dentry = dget(new_dentry);
889 req->r_num_caps = 2;
890 req->r_old_dentry = dget(old_dentry);
Sage Weil41b02e12011-07-26 11:31:14 -0700891 req->r_old_dentry_dir = ceph_get_dentry_parent_inode(old_dentry);
Sage Weil2817b002009-10-06 11:31:08 -0700892 req->r_locked_dir = new_dir;
893 req->r_old_dentry_drop = CEPH_CAP_FILE_SHARED;
894 req->r_old_dentry_unless = CEPH_CAP_FILE_EXCL;
895 req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
896 req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
897 /* release LINK_RDCACHE on source inode (mds will lock it) */
898 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED;
899 if (new_dentry->d_inode)
900 req->r_inode_drop = drop_caps_for_unlink(new_dentry->d_inode);
901 err = ceph_mdsc_do_request(mdsc, old_dir, req);
902 if (!err && !req->r_reply_info.head->is_dentry) {
903 /*
904 * Normally d_move() is done by fill_trace (called by
905 * do_request, above). If there is no trace, we need
906 * to do it here.
907 */
Sage Weilea1409f2010-04-28 16:12:06 -0700908
909 /* d_move screws up d_subdirs order */
Yan, Zheng2f276c52013-03-13 19:44:32 +0800910 ceph_dir_clear_complete(new_dir);
Sage Weilea1409f2010-04-28 16:12:06 -0700911
Sage Weil2817b002009-10-06 11:31:08 -0700912 d_move(old_dentry, new_dentry);
Sage Weilea1409f2010-04-28 16:12:06 -0700913
914 /* ensure target dentry is invalidated, despite
915 rehashing bug in vfs_rename_dir */
Sage Weil81a6cf22010-05-14 09:35:38 -0700916 ceph_invalidate_dentry_lease(new_dentry);
Sage Weil2817b002009-10-06 11:31:08 -0700917 }
918 ceph_mdsc_put_request(req);
919 return err;
920}
921
Sage Weil81a6cf22010-05-14 09:35:38 -0700922/*
923 * Ensure a dentry lease will no longer revalidate.
924 */
925void ceph_invalidate_dentry_lease(struct dentry *dentry)
926{
927 spin_lock(&dentry->d_lock);
928 dentry->d_time = jiffies;
929 ceph_dentry(dentry)->lease_shared_gen = 0;
930 spin_unlock(&dentry->d_lock);
931}
Sage Weil2817b002009-10-06 11:31:08 -0700932
933/*
934 * Check if dentry lease is valid. If not, delete the lease. Try to
935 * renew if the least is more than half up.
936 */
937static int dentry_lease_is_valid(struct dentry *dentry)
938{
939 struct ceph_dentry_info *di;
940 struct ceph_mds_session *s;
941 int valid = 0;
942 u32 gen;
943 unsigned long ttl;
944 struct ceph_mds_session *session = NULL;
945 struct inode *dir = NULL;
946 u32 seq = 0;
947
948 spin_lock(&dentry->d_lock);
949 di = ceph_dentry(dentry);
Sage Weil3d8eb7a2011-11-11 09:48:53 -0800950 if (di->lease_session) {
Sage Weil2817b002009-10-06 11:31:08 -0700951 s = di->lease_session;
Alex Elderd8fb02a2012-01-12 17:48:10 -0800952 spin_lock(&s->s_gen_ttl_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700953 gen = s->s_cap_gen;
954 ttl = s->s_cap_ttl;
Alex Elderd8fb02a2012-01-12 17:48:10 -0800955 spin_unlock(&s->s_gen_ttl_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700956
957 if (di->lease_gen == gen &&
958 time_before(jiffies, dentry->d_time) &&
959 time_before(jiffies, ttl)) {
960 valid = 1;
961 if (di->lease_renew_after &&
962 time_after(jiffies, di->lease_renew_after)) {
963 /* we should renew */
964 dir = dentry->d_parent->d_inode;
965 session = ceph_get_mds_session(s);
966 seq = di->lease_seq;
967 di->lease_renew_after = 0;
968 di->lease_renew_from = jiffies;
969 }
Sage Weil2817b002009-10-06 11:31:08 -0700970 }
971 }
972 spin_unlock(&dentry->d_lock);
973
974 if (session) {
975 ceph_mdsc_lease_send_msg(session, dir, dentry,
976 CEPH_MDS_LEASE_RENEW, seq);
977 ceph_put_mds_session(session);
978 }
979 dout("dentry_lease_is_valid - dentry %p = %d\n", dentry, valid);
980 return valid;
981}
982
983/*
984 * Check if directory-wide content lease/cap is valid.
985 */
986static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry)
987{
988 struct ceph_inode_info *ci = ceph_inode(dir);
989 struct ceph_dentry_info *di = ceph_dentry(dentry);
990 int valid = 0;
991
Sage Weilbe655592011-11-30 09:47:09 -0800992 spin_lock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700993 if (ci->i_shared_gen == di->lease_shared_gen)
994 valid = __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1);
Sage Weilbe655592011-11-30 09:47:09 -0800995 spin_unlock(&ci->i_ceph_lock);
Sage Weil2817b002009-10-06 11:31:08 -0700996 dout("dir_lease_is_valid dir %p v%u dentry %p v%u = %d\n",
997 dir, (unsigned)ci->i_shared_gen, dentry,
998 (unsigned)di->lease_shared_gen, valid);
999 return valid;
1000}
1001
1002/*
1003 * Check if cached dentry can be trusted.
1004 */
Al Viro0b728e12012-06-10 16:03:43 -04001005static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags)
Sage Weil2817b002009-10-06 11:31:08 -07001006{
Sage Weilbf1c6ac2011-07-26 11:30:43 -07001007 int valid = 0;
Nick Piggin34286d62011-01-07 17:49:57 +11001008 struct inode *dir;
1009
Al Viro0b728e12012-06-10 16:03:43 -04001010 if (flags & LOOKUP_RCU)
Nick Piggin34286d62011-01-07 17:49:57 +11001011 return -ECHILD;
1012
Sage Weil1cd39352010-05-03 22:08:02 -07001013 dout("d_revalidate %p '%.*s' inode %p offset %lld\n", dentry,
1014 dentry->d_name.len, dentry->d_name.name, dentry->d_inode,
1015 ceph_dentry(dentry)->offset);
Sage Weil2817b002009-10-06 11:31:08 -07001016
Sage Weilbf1c6ac2011-07-26 11:30:43 -07001017 dir = ceph_get_dentry_parent_inode(dentry);
1018
Sage Weil2817b002009-10-06 11:31:08 -07001019 /* always trust cached snapped dentries, snapdir dentry */
1020 if (ceph_snap(dir) != CEPH_NOSNAP) {
1021 dout("d_revalidate %p '%.*s' inode %p is SNAPPED\n", dentry,
1022 dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
Sage Weilbf1c6ac2011-07-26 11:30:43 -07001023 valid = 1;
1024 } else if (dentry->d_inode &&
1025 ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) {
1026 valid = 1;
1027 } else if (dentry_lease_is_valid(dentry) ||
1028 dir_lease_is_valid(dir, dentry)) {
1029 valid = 1;
Sage Weil2817b002009-10-06 11:31:08 -07001030 }
Sage Weil2817b002009-10-06 11:31:08 -07001031
Sage Weilbf1c6ac2011-07-26 11:30:43 -07001032 dout("d_revalidate %p %s\n", dentry, valid ? "valid" : "invalid");
1033 if (valid)
1034 ceph_dentry_lru_touch(dentry);
1035 else
1036 d_drop(dentry);
1037 iput(dir);
1038 return valid;
Sage Weil2817b002009-10-06 11:31:08 -07001039}
1040
1041/*
Sage Weil147851d2011-03-15 14:57:41 -07001042 * Release our ceph_dentry_info.
Sage Weil2817b002009-10-06 11:31:08 -07001043 */
Sage Weil147851d2011-03-15 14:57:41 -07001044static void ceph_d_release(struct dentry *dentry)
Sage Weil2817b002009-10-06 11:31:08 -07001045{
1046 struct ceph_dentry_info *di = ceph_dentry(dentry);
Sage Weil2817b002009-10-06 11:31:08 -07001047
Sage Weil147851d2011-03-15 14:57:41 -07001048 dout("d_release %p\n", dentry);
Sage Weil3d8eb7a2011-11-11 09:48:53 -08001049 ceph_dentry_lru_del(dentry);
1050 if (di->lease_session)
1051 ceph_put_mds_session(di->lease_session);
1052 kmem_cache_free(ceph_dentry_cachep, di);
1053 dentry->d_fsdata = NULL;
Sage Weil2817b002009-10-06 11:31:08 -07001054}
1055
1056static int ceph_snapdir_d_revalidate(struct dentry *dentry,
Al Viro0b728e12012-06-10 16:03:43 -04001057 unsigned int flags)
Sage Weil2817b002009-10-06 11:31:08 -07001058{
1059 /*
1060 * Eventually, we'll want to revalidate snapped metadata
1061 * too... probably...
1062 */
1063 return 1;
1064}
1065
Sage Weilb58dc412011-03-15 15:53:40 -07001066/*
1067 * When the VFS prunes a dentry from the cache, we need to clear the
1068 * complete flag on the parent directory.
1069 *
1070 * Called under dentry->d_lock.
1071 */
1072static void ceph_d_prune(struct dentry *dentry)
1073{
Sage Weil774ac212011-11-11 09:48:08 -08001074 dout("ceph_d_prune %p\n", dentry);
Sage Weilb58dc412011-03-15 15:53:40 -07001075
1076 /* do we have a valid parent? */
Sage Weil8842b3b2012-06-07 13:43:35 -07001077 if (IS_ROOT(dentry))
Sage Weilb58dc412011-03-15 15:53:40 -07001078 return;
1079
Yan, Zheng2f276c52013-03-13 19:44:32 +08001080 /* if we are not hashed, we don't affect dir's completeness */
Sage Weilb58dc412011-03-15 15:53:40 -07001081 if (d_unhashed(dentry))
1082 return;
1083
1084 /*
1085 * we hold d_lock, so d_parent is stable, and d_fsdata is never
1086 * cleared until d_release
1087 */
Yan, Zheng2f276c52013-03-13 19:44:32 +08001088 ceph_dir_clear_complete(dentry->d_parent->d_inode);
Sage Weilb58dc412011-03-15 15:53:40 -07001089}
Sage Weil2817b002009-10-06 11:31:08 -07001090
1091/*
1092 * read() on a dir. This weird interface hack only works if mounted
1093 * with '-o dirstat'.
1094 */
1095static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size,
1096 loff_t *ppos)
1097{
1098 struct ceph_file_info *cf = file->private_data;
Al Viro496ad9a2013-01-23 17:07:38 -05001099 struct inode *inode = file_inode(file);
Sage Weil2817b002009-10-06 11:31:08 -07001100 struct ceph_inode_info *ci = ceph_inode(inode);
1101 int left;
Sage Weilae598082011-05-12 14:28:05 -07001102 const int bufsize = 1024;
Sage Weil2817b002009-10-06 11:31:08 -07001103
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001104 if (!ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), DIRSTAT))
Sage Weil2817b002009-10-06 11:31:08 -07001105 return -EISDIR;
1106
1107 if (!cf->dir_info) {
Sage Weilae598082011-05-12 14:28:05 -07001108 cf->dir_info = kmalloc(bufsize, GFP_NOFS);
Sage Weil2817b002009-10-06 11:31:08 -07001109 if (!cf->dir_info)
1110 return -ENOMEM;
1111 cf->dir_info_len =
Sage Weilae598082011-05-12 14:28:05 -07001112 snprintf(cf->dir_info, bufsize,
Sage Weil2817b002009-10-06 11:31:08 -07001113 "entries: %20lld\n"
1114 " files: %20lld\n"
1115 " subdirs: %20lld\n"
1116 "rentries: %20lld\n"
1117 " rfiles: %20lld\n"
1118 " rsubdirs: %20lld\n"
1119 "rbytes: %20lld\n"
1120 "rctime: %10ld.%09ld\n",
1121 ci->i_files + ci->i_subdirs,
1122 ci->i_files,
1123 ci->i_subdirs,
1124 ci->i_rfiles + ci->i_rsubdirs,
1125 ci->i_rfiles,
1126 ci->i_rsubdirs,
1127 ci->i_rbytes,
1128 (long)ci->i_rctime.tv_sec,
1129 (long)ci->i_rctime.tv_nsec);
1130 }
1131
1132 if (*ppos >= cf->dir_info_len)
1133 return 0;
1134 size = min_t(unsigned, size, cf->dir_info_len-*ppos);
1135 left = copy_to_user(buf, cf->dir_info + *ppos, size);
1136 if (left == size)
1137 return -EFAULT;
1138 *ppos += (size - left);
1139 return size - left;
1140}
1141
1142/*
1143 * an fsync() on a dir will wait for any uncommitted directory
1144 * operations to commit.
1145 */
Josef Bacik02c24a82011-07-16 20:44:56 -04001146static int ceph_dir_fsync(struct file *file, loff_t start, loff_t end,
1147 int datasync)
Sage Weil2817b002009-10-06 11:31:08 -07001148{
Al Viro496ad9a2013-01-23 17:07:38 -05001149 struct inode *inode = file_inode(file);
Sage Weil2817b002009-10-06 11:31:08 -07001150 struct ceph_inode_info *ci = ceph_inode(inode);
1151 struct list_head *head = &ci->i_unsafe_dirops;
1152 struct ceph_mds_request *req;
1153 u64 last_tid;
1154 int ret = 0;
1155
1156 dout("dir_fsync %p\n", inode);
Josef Bacik02c24a82011-07-16 20:44:56 -04001157 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
1158 if (ret)
1159 return ret;
1160 mutex_lock(&inode->i_mutex);
1161
Sage Weil2817b002009-10-06 11:31:08 -07001162 spin_lock(&ci->i_unsafe_lock);
1163 if (list_empty(head))
1164 goto out;
1165
1166 req = list_entry(head->prev,
1167 struct ceph_mds_request, r_unsafe_dir_item);
1168 last_tid = req->r_tid;
1169
1170 do {
1171 ceph_mdsc_get_request(req);
1172 spin_unlock(&ci->i_unsafe_lock);
Sage Weil2ff179e2012-01-03 10:09:07 -08001173
Sage Weil2817b002009-10-06 11:31:08 -07001174 dout("dir_fsync %p wait on tid %llu (until %llu)\n",
1175 inode, req->r_tid, last_tid);
1176 if (req->r_timeout) {
1177 ret = wait_for_completion_timeout(
1178 &req->r_safe_completion, req->r_timeout);
1179 if (ret > 0)
1180 ret = 0;
1181 else if (ret == 0)
1182 ret = -EIO; /* timed out */
1183 } else {
1184 wait_for_completion(&req->r_safe_completion);
1185 }
Sage Weil2817b002009-10-06 11:31:08 -07001186 ceph_mdsc_put_request(req);
1187
Sage Weil2ff179e2012-01-03 10:09:07 -08001188 spin_lock(&ci->i_unsafe_lock);
Sage Weil2817b002009-10-06 11:31:08 -07001189 if (ret || list_empty(head))
1190 break;
1191 req = list_entry(head->next,
1192 struct ceph_mds_request, r_unsafe_dir_item);
1193 } while (req->r_tid < last_tid);
1194out:
1195 spin_unlock(&ci->i_unsafe_lock);
Josef Bacik02c24a82011-07-16 20:44:56 -04001196 mutex_unlock(&inode->i_mutex);
1197
Sage Weil2817b002009-10-06 11:31:08 -07001198 return ret;
1199}
1200
1201/*
1202 * We maintain a private dentry LRU.
1203 *
1204 * FIXME: this needs to be changed to a per-mds lru to be useful.
1205 */
1206void ceph_dentry_lru_add(struct dentry *dn)
1207{
1208 struct ceph_dentry_info *di = ceph_dentry(dn);
1209 struct ceph_mds_client *mdsc;
Sage Weil2817b002009-10-06 11:31:08 -07001210
Sage Weil04a419f2009-12-23 09:30:21 -08001211 dout("dentry_lru_add %p %p '%.*s'\n", di, dn,
1212 dn->d_name.len, dn->d_name.name);
Sage Weil3d8eb7a2011-11-11 09:48:53 -08001213 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
1214 spin_lock(&mdsc->dentry_lru_lock);
1215 list_add_tail(&di->lru, &mdsc->dentry_lru);
1216 mdsc->num_dentry++;
1217 spin_unlock(&mdsc->dentry_lru_lock);
Sage Weil2817b002009-10-06 11:31:08 -07001218}
1219
1220void ceph_dentry_lru_touch(struct dentry *dn)
1221{
1222 struct ceph_dentry_info *di = ceph_dentry(dn);
1223 struct ceph_mds_client *mdsc;
Sage Weil2817b002009-10-06 11:31:08 -07001224
Sage Weil1cd39352010-05-03 22:08:02 -07001225 dout("dentry_lru_touch %p %p '%.*s' (offset %lld)\n", di, dn,
1226 dn->d_name.len, dn->d_name.name, di->offset);
Sage Weil3d8eb7a2011-11-11 09:48:53 -08001227 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
1228 spin_lock(&mdsc->dentry_lru_lock);
1229 list_move_tail(&di->lru, &mdsc->dentry_lru);
1230 spin_unlock(&mdsc->dentry_lru_lock);
Sage Weil2817b002009-10-06 11:31:08 -07001231}
1232
1233void ceph_dentry_lru_del(struct dentry *dn)
1234{
1235 struct ceph_dentry_info *di = ceph_dentry(dn);
1236 struct ceph_mds_client *mdsc;
1237
Sage Weil04a419f2009-12-23 09:30:21 -08001238 dout("dentry_lru_del %p %p '%.*s'\n", di, dn,
1239 dn->d_name.len, dn->d_name.name);
Sage Weil3d8eb7a2011-11-11 09:48:53 -08001240 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc;
1241 spin_lock(&mdsc->dentry_lru_lock);
1242 list_del_init(&di->lru);
1243 mdsc->num_dentry--;
1244 spin_unlock(&mdsc->dentry_lru_lock);
Sage Weil2817b002009-10-06 11:31:08 -07001245}
1246
Sage Weil6c0f3af2010-11-16 11:14:34 -08001247/*
1248 * Return name hash for a given dentry. This is dependent on
1249 * the parent directory's hash function.
1250 */
Sage Weile5f86dc2011-07-26 11:30:55 -07001251unsigned ceph_dentry_hash(struct inode *dir, struct dentry *dn)
Sage Weil6c0f3af2010-11-16 11:14:34 -08001252{
Sage Weil6c0f3af2010-11-16 11:14:34 -08001253 struct ceph_inode_info *dci = ceph_inode(dir);
1254
1255 switch (dci->i_dir_layout.dl_dir_hash) {
1256 case 0: /* for backward compat */
1257 case CEPH_STR_HASH_LINUX:
1258 return dn->d_name.hash;
1259
1260 default:
1261 return ceph_str_hash(dci->i_dir_layout.dl_dir_hash,
1262 dn->d_name.name, dn->d_name.len);
1263 }
1264}
1265
Sage Weil2817b002009-10-06 11:31:08 -07001266const struct file_operations ceph_dir_fops = {
1267 .read = ceph_read_dir,
Al Viro77acfa22013-05-17 16:52:26 -04001268 .iterate = ceph_readdir,
Sage Weil2817b002009-10-06 11:31:08 -07001269 .llseek = ceph_dir_llseek,
1270 .open = ceph_open,
1271 .release = ceph_release,
1272 .unlocked_ioctl = ceph_ioctl,
1273 .fsync = ceph_dir_fsync,
1274};
1275
1276const struct inode_operations ceph_dir_iops = {
1277 .lookup = ceph_lookup,
1278 .permission = ceph_permission,
1279 .getattr = ceph_getattr,
1280 .setattr = ceph_setattr,
1281 .setxattr = ceph_setxattr,
1282 .getxattr = ceph_getxattr,
1283 .listxattr = ceph_listxattr,
1284 .removexattr = ceph_removexattr,
1285 .mknod = ceph_mknod,
1286 .symlink = ceph_symlink,
1287 .mkdir = ceph_mkdir,
1288 .link = ceph_link,
1289 .unlink = ceph_unlink,
1290 .rmdir = ceph_unlink,
1291 .rename = ceph_rename,
1292 .create = ceph_create,
Miklos Szeredi2d83bde2012-06-05 15:10:25 +02001293 .atomic_open = ceph_atomic_open,
Sage Weil2817b002009-10-06 11:31:08 -07001294};
1295
Sage Weil52dfb8a2010-08-03 10:25:30 -07001296const struct dentry_operations ceph_dentry_ops = {
Sage Weil2817b002009-10-06 11:31:08 -07001297 .d_revalidate = ceph_d_revalidate,
Sage Weil147851d2011-03-15 14:57:41 -07001298 .d_release = ceph_d_release,
Sage Weilb58dc412011-03-15 15:53:40 -07001299 .d_prune = ceph_d_prune,
Sage Weil2817b002009-10-06 11:31:08 -07001300};
1301
Sage Weil52dfb8a2010-08-03 10:25:30 -07001302const struct dentry_operations ceph_snapdir_dentry_ops = {
Sage Weil2817b002009-10-06 11:31:08 -07001303 .d_revalidate = ceph_snapdir_d_revalidate,
Sage Weil147851d2011-03-15 14:57:41 -07001304 .d_release = ceph_d_release,
Sage Weil2817b002009-10-06 11:31:08 -07001305};
1306
Sage Weil52dfb8a2010-08-03 10:25:30 -07001307const struct dentry_operations ceph_snap_dentry_ops = {
Sage Weil147851d2011-03-15 14:57:41 -07001308 .d_release = ceph_d_release,
Sage Weilb58dc412011-03-15 15:53:40 -07001309 .d_prune = ceph_d_prune,
Sage Weil2817b002009-10-06 11:31:08 -07001310};