blob: ef4a980a7bf37035c1d20dc9c4fd81d7131be1b4 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002#include <linux/ceph/ceph_debug.h>
Sage Weil355da1e2009-10-06 11:31:08 -07003
4#include <linux/module.h>
5#include <linux/fs.h>
Sage Weil355da1e2009-10-06 11:31:08 -07006#include <linux/slab.h>
7#include <linux/string.h>
8#include <linux/uaccess.h>
9#include <linux/kernel.h>
Sage Weil355da1e2009-10-06 11:31:08 -070010#include <linux/writeback.h>
11#include <linux/vmalloc.h>
Andreas Gruenbacher2cdeb1e2016-04-14 00:30:17 +020012#include <linux/xattr.h>
Linus Torvalds4db658e2014-01-28 18:06:18 -080013#include <linux/posix_acl.h>
Yan, Zheng3e7fbe92014-04-18 16:00:30 +080014#include <linux/random.h>
Yan, Zhenga4078462016-05-03 20:55:50 +080015#include <linux/sort.h>
Jeff Laytona35ead32019-06-06 07:29:23 -040016#include <linux/iversion.h>
Sage Weil355da1e2009-10-06 11:31:08 -070017
18#include "super.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070019#include "mds_client.h"
Milosz Tanski99ccbd22013-08-21 17:29:54 -040020#include "cache.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070021#include <linux/ceph/decode.h>
Sage Weil355da1e2009-10-06 11:31:08 -070022
23/*
24 * Ceph inode operations
25 *
26 * Implement basic inode helpers (get, alloc) and inode ops (getattr,
27 * setattr, etc.), xattr helpers, and helpers for assimilating
28 * metadata returned by the MDS into our cache.
29 *
30 * Also define helpers for doing asynchronous writeback, invalidation,
31 * and truncation for the benefit of those who can't afford to block
32 * (typically because they are in the message handler path).
33 */
34
35static const struct inode_operations ceph_symlink_iops;
36
Yan, Zheng1cf89a82019-05-18 11:18:44 +080037static void ceph_inode_work(struct work_struct *work);
Sage Weil355da1e2009-10-06 11:31:08 -070038
39/*
40 * find or create an inode, given the ceph ino number
41 */
Yehuda Sadehad1fee92011-01-21 16:44:03 -080042static int ceph_set_ino_cb(struct inode *inode, void *data)
43{
Jeff Laytonebce3eb2020-08-18 08:03:48 -040044 struct ceph_inode_info *ci = ceph_inode(inode);
Xiubo Li1dd8d472020-09-03 09:01:40 -040045 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
Jeff Laytonebce3eb2020-08-18 08:03:48 -040046
47 ci->i_vino = *(struct ceph_vino *)data;
48 inode->i_ino = ceph_vino_to_ino_t(ci->i_vino);
Jeff Laytona35ead32019-06-06 07:29:23 -040049 inode_set_iversion_raw(inode, 0);
Xiubo Li1dd8d472020-09-03 09:01:40 -040050 percpu_counter_inc(&mdsc->metric.total_inodes);
51
Yehuda Sadehad1fee92011-01-21 16:44:03 -080052 return 0;
53}
54
Sage Weil355da1e2009-10-06 11:31:08 -070055struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino)
56{
57 struct inode *inode;
Sage Weil355da1e2009-10-06 11:31:08 -070058
Jeff Laytond4f6b312021-04-01 13:55:11 -040059 if (ceph_vino_is_reserved(vino))
60 return ERR_PTR(-EREMOTEIO);
61
Jeff Laytonebce3eb2020-08-18 08:03:48 -040062 inode = iget5_locked(sb, (unsigned long)vino.ino, ceph_ino_compare,
63 ceph_set_ino_cb, &vino);
Markus Elfringd37b1d92017-08-20 20:22:02 +020064 if (!inode)
Sage Weil355da1e2009-10-06 11:31:08 -070065 return ERR_PTR(-ENOMEM);
Sage Weil355da1e2009-10-06 11:31:08 -070066
Jeff Laytonebce3eb2020-08-18 08:03:48 -040067 dout("get_inode on %llu=%llx.%llx got %p new %d\n", ceph_present_inode(inode),
68 ceph_vinop(inode), inode, !!(inode->i_state & I_NEW));
Sage Weil355da1e2009-10-06 11:31:08 -070069 return inode;
70}
71
72/*
73 * get/constuct snapdir inode for a given directory
74 */
75struct inode *ceph_get_snapdir(struct inode *parent)
76{
77 struct ceph_vino vino = {
78 .ino = ceph_ino(parent),
79 .snap = CEPH_SNAPDIR,
80 };
81 struct inode *inode = ceph_get_inode(parent->i_sb, vino);
Sage Weilb377ff12009-11-11 15:22:37 -080082 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weil355da1e2009-10-06 11:31:08 -070083
Sage Weil355da1e2009-10-06 11:31:08 -070084 if (IS_ERR(inode))
Julia Lawall7e34bc52010-05-22 12:01:14 +020085 return inode;
Jeff Layton3e10a152021-02-25 15:04:15 -050086
87 if (!S_ISDIR(parent->i_mode)) {
88 pr_warn_once("bad snapdir parent type (mode=0%o)\n",
89 parent->i_mode);
90 return ERR_PTR(-ENOTDIR);
91 }
92
93 if (!(inode->i_state & I_NEW) && !S_ISDIR(inode->i_mode)) {
94 pr_warn_once("bad snapdir inode type (mode=0%o)\n",
95 inode->i_mode);
96 return ERR_PTR(-ENOTDIR);
97 }
98
Sage Weil355da1e2009-10-06 11:31:08 -070099 inode->i_mode = parent->i_mode;
100 inode->i_uid = parent->i_uid;
101 inode->i_gid = parent->i_gid;
Luis Henriquesef915722020-03-11 11:05:38 +0000102 inode->i_mtime = parent->i_mtime;
103 inode->i_ctime = parent->i_ctime;
104 inode->i_atime = parent->i_atime;
Sage Weilb377ff12009-11-11 15:22:37 -0800105 ci->i_rbytes = 0;
Luis Henriquesef915722020-03-11 11:05:38 +0000106 ci->i_btime = ceph_inode(parent)->i_btime;
Jeff Layton893e4562019-12-11 15:21:24 -0500107
Jeff Laytond3c51ae2021-03-01 07:38:01 -0500108 if (inode->i_state & I_NEW) {
109 inode->i_op = &ceph_snapdir_iops;
110 inode->i_fop = &ceph_snapdir_fops;
111 ci->i_snap_caps = CEPH_CAP_PIN; /* so we can open */
Jeff Layton893e4562019-12-11 15:21:24 -0500112 unlock_new_inode(inode);
Jeff Laytond3c51ae2021-03-01 07:38:01 -0500113 }
Jeff Layton893e4562019-12-11 15:21:24 -0500114
Sage Weil355da1e2009-10-06 11:31:08 -0700115 return inode;
116}
117
118const struct inode_operations ceph_file_iops = {
119 .permission = ceph_permission,
120 .setattr = ceph_setattr,
121 .getattr = ceph_getattr,
Sage Weil355da1e2009-10-06 11:31:08 -0700122 .listxattr = ceph_listxattr,
Guangliang Zhao7221fe42013-11-11 15:18:03 +0800123 .get_acl = ceph_get_acl,
Sage Weil72466d02014-01-29 06:22:25 -0800124 .set_acl = ceph_set_acl,
Sage Weil355da1e2009-10-06 11:31:08 -0700125};
126
127
128/*
129 * We use a 'frag tree' to keep track of the MDS's directory fragments
130 * for a given inode (usually there is just a single fragment). We
131 * need to know when a child frag is delegated to a new MDS, or when
132 * it is flagged as replicated, so we can direct our requests
133 * accordingly.
134 */
135
136/*
137 * find/create a frag in the tree
138 */
139static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci,
140 u32 f)
141{
142 struct rb_node **p;
143 struct rb_node *parent = NULL;
144 struct ceph_inode_frag *frag;
145 int c;
146
147 p = &ci->i_fragtree.rb_node;
148 while (*p) {
149 parent = *p;
150 frag = rb_entry(parent, struct ceph_inode_frag, node);
151 c = ceph_frag_compare(f, frag->frag);
152 if (c < 0)
153 p = &(*p)->rb_left;
154 else if (c > 0)
155 p = &(*p)->rb_right;
156 else
157 return frag;
158 }
159
160 frag = kmalloc(sizeof(*frag), GFP_NOFS);
Markus Elfring51308802017-08-20 20:00:09 +0200161 if (!frag)
Sage Weil355da1e2009-10-06 11:31:08 -0700162 return ERR_PTR(-ENOMEM);
Markus Elfring51308802017-08-20 20:00:09 +0200163
Sage Weil355da1e2009-10-06 11:31:08 -0700164 frag->frag = f;
165 frag->split_by = 0;
166 frag->mds = -1;
167 frag->ndist = 0;
168
169 rb_link_node(&frag->node, parent, p);
170 rb_insert_color(&frag->node, &ci->i_fragtree);
171
172 dout("get_or_create_frag added %llx.%llx frag %x\n",
173 ceph_vinop(&ci->vfs_inode), f);
174 return frag;
175}
176
177/*
178 * find a specific frag @f
179 */
180struct ceph_inode_frag *__ceph_find_frag(struct ceph_inode_info *ci, u32 f)
181{
182 struct rb_node *n = ci->i_fragtree.rb_node;
183
184 while (n) {
185 struct ceph_inode_frag *frag =
186 rb_entry(n, struct ceph_inode_frag, node);
187 int c = ceph_frag_compare(f, frag->frag);
188 if (c < 0)
189 n = n->rb_left;
190 else if (c > 0)
191 n = n->rb_right;
192 else
193 return frag;
194 }
195 return NULL;
196}
197
198/*
199 * Choose frag containing the given value @v. If @pfrag is
200 * specified, copy the frag delegation info to the caller if
201 * it is present.
202 */
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800203static u32 __ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
204 struct ceph_inode_frag *pfrag, int *found)
Sage Weil355da1e2009-10-06 11:31:08 -0700205{
206 u32 t = ceph_frag_make(0, 0);
207 struct ceph_inode_frag *frag;
208 unsigned nway, i;
209 u32 n;
210
211 if (found)
212 *found = 0;
213
Sage Weil355da1e2009-10-06 11:31:08 -0700214 while (1) {
215 WARN_ON(!ceph_frag_contains_value(t, v));
216 frag = __ceph_find_frag(ci, t);
217 if (!frag)
218 break; /* t is a leaf */
219 if (frag->split_by == 0) {
220 if (pfrag)
221 memcpy(pfrag, frag, sizeof(*pfrag));
222 if (found)
223 *found = 1;
224 break;
225 }
226
227 /* choose child */
228 nway = 1 << frag->split_by;
229 dout("choose_frag(%x) %x splits by %d (%d ways)\n", v, t,
230 frag->split_by, nway);
231 for (i = 0; i < nway; i++) {
232 n = ceph_frag_make_child(t, frag->split_by, i);
233 if (ceph_frag_contains_value(n, v)) {
234 t = n;
235 break;
236 }
237 }
238 BUG_ON(i == nway);
239 }
240 dout("choose_frag(%x) = %x\n", v, t);
241
Sage Weil355da1e2009-10-06 11:31:08 -0700242 return t;
243}
244
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800245u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
246 struct ceph_inode_frag *pfrag, int *found)
247{
248 u32 ret;
249 mutex_lock(&ci->i_fragtree_mutex);
250 ret = __ceph_choose_frag(ci, v, pfrag, found);
251 mutex_unlock(&ci->i_fragtree_mutex);
252 return ret;
253}
254
Sage Weil355da1e2009-10-06 11:31:08 -0700255/*
256 * Process dirfrag (delegation) info from the mds. Include leaf
257 * fragment in tree ONLY if ndist > 0. Otherwise, only
258 * branches/splits are included in i_fragtree)
259 */
260static int ceph_fill_dirfrag(struct inode *inode,
261 struct ceph_mds_reply_dirfrag *dirinfo)
262{
263 struct ceph_inode_info *ci = ceph_inode(inode);
264 struct ceph_inode_frag *frag;
265 u32 id = le32_to_cpu(dirinfo->frag);
266 int mds = le32_to_cpu(dirinfo->auth);
267 int ndist = le32_to_cpu(dirinfo->ndist);
Yan, Zheng8d085032014-04-18 22:01:38 +0800268 int diri_auth = -1;
Sage Weil355da1e2009-10-06 11:31:08 -0700269 int i;
270 int err = 0;
271
Yan, Zheng8d085032014-04-18 22:01:38 +0800272 spin_lock(&ci->i_ceph_lock);
273 if (ci->i_auth_cap)
274 diri_auth = ci->i_auth_cap->mds;
275 spin_unlock(&ci->i_ceph_lock);
276
Yan, Zheng42172112016-05-03 22:33:20 +0800277 if (mds == -1) /* CDIR_AUTH_PARENT */
278 mds = diri_auth;
279
Sage Weil355da1e2009-10-06 11:31:08 -0700280 mutex_lock(&ci->i_fragtree_mutex);
Yan, Zheng8d085032014-04-18 22:01:38 +0800281 if (ndist == 0 && mds == diri_auth) {
Sage Weil355da1e2009-10-06 11:31:08 -0700282 /* no delegation info needed. */
283 frag = __ceph_find_frag(ci, id);
284 if (!frag)
285 goto out;
286 if (frag->split_by == 0) {
287 /* tree leaf, remove */
288 dout("fill_dirfrag removed %llx.%llx frag %x"
289 " (no ref)\n", ceph_vinop(inode), id);
290 rb_erase(&frag->node, &ci->i_fragtree);
291 kfree(frag);
292 } else {
293 /* tree branch, keep and clear */
294 dout("fill_dirfrag cleared %llx.%llx frag %x"
295 " referral\n", ceph_vinop(inode), id);
296 frag->mds = -1;
297 frag->ndist = 0;
298 }
299 goto out;
300 }
301
302
303 /* find/add this frag to store mds delegation info */
304 frag = __get_or_create_frag(ci, id);
305 if (IS_ERR(frag)) {
306 /* this is not the end of the world; we can continue
307 with bad/inaccurate delegation info */
308 pr_err("fill_dirfrag ENOMEM on mds ref %llx.%llx fg %x\n",
309 ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
310 err = -ENOMEM;
311 goto out;
312 }
313
314 frag->mds = mds;
315 frag->ndist = min_t(u32, ndist, CEPH_MAX_DIRFRAG_REP);
316 for (i = 0; i < frag->ndist; i++)
317 frag->dist[i] = le32_to_cpu(dirinfo->dist[i]);
318 dout("fill_dirfrag %llx.%llx frag %x ndist=%d\n",
319 ceph_vinop(inode), frag->frag, frag->ndist);
320
321out:
322 mutex_unlock(&ci->i_fragtree_mutex);
323 return err;
324}
325
Yan, Zhenga4078462016-05-03 20:55:50 +0800326static int frag_tree_split_cmp(const void *l, const void *r)
327{
328 struct ceph_frag_tree_split *ls = (struct ceph_frag_tree_split*)l;
329 struct ceph_frag_tree_split *rs = (struct ceph_frag_tree_split*)r;
Jeff Laytonfe2ed422017-01-12 14:42:39 -0500330 return ceph_frag_compare(le32_to_cpu(ls->frag),
331 le32_to_cpu(rs->frag));
Yan, Zhenga4078462016-05-03 20:55:50 +0800332}
333
Yan, Zhenga4b74312016-05-04 11:05:10 +0800334static bool is_frag_child(u32 f, struct ceph_inode_frag *frag)
335{
336 if (!frag)
337 return f == ceph_frag_make(0, 0);
338 if (ceph_frag_bits(f) != ceph_frag_bits(frag->frag) + frag->split_by)
339 return false;
340 return ceph_frag_contains_value(frag->frag, ceph_frag_value(f));
341}
342
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800343static int ceph_fill_fragtree(struct inode *inode,
344 struct ceph_frag_tree_head *fragtree,
345 struct ceph_mds_reply_dirfrag *dirinfo)
346{
347 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhenga4b74312016-05-04 11:05:10 +0800348 struct ceph_inode_frag *frag, *prev_frag = NULL;
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800349 struct rb_node *rb_node;
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800350 unsigned i, split_by, nsplits;
351 u32 id;
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800352 bool update = false;
353
354 mutex_lock(&ci->i_fragtree_mutex);
355 nsplits = le32_to_cpu(fragtree->nsplits);
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800356 if (nsplits != ci->i_fragtree_nsplits) {
357 update = true;
358 } else if (nsplits) {
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800359 i = prandom_u32() % nsplits;
360 id = le32_to_cpu(fragtree->splits[i].frag);
361 if (!__ceph_find_frag(ci, id))
362 update = true;
363 } else if (!RB_EMPTY_ROOT(&ci->i_fragtree)) {
364 rb_node = rb_first(&ci->i_fragtree);
365 frag = rb_entry(rb_node, struct ceph_inode_frag, node);
366 if (frag->frag != ceph_frag_make(0, 0) || rb_next(rb_node))
367 update = true;
368 }
369 if (!update && dirinfo) {
370 id = le32_to_cpu(dirinfo->frag);
371 if (id != __ceph_choose_frag(ci, id, NULL, NULL))
372 update = true;
373 }
374 if (!update)
375 goto out_unlock;
376
Yan, Zhenga4078462016-05-03 20:55:50 +0800377 if (nsplits > 1) {
378 sort(fragtree->splits, nsplits, sizeof(fragtree->splits[0]),
379 frag_tree_split_cmp, NULL);
380 }
381
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800382 dout("fill_fragtree %llx.%llx\n", ceph_vinop(inode));
383 rb_node = rb_first(&ci->i_fragtree);
384 for (i = 0; i < nsplits; i++) {
385 id = le32_to_cpu(fragtree->splits[i].frag);
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800386 split_by = le32_to_cpu(fragtree->splits[i].by);
387 if (split_by == 0 || ceph_frag_bits(id) + split_by > 24) {
388 pr_err("fill_fragtree %llx.%llx invalid split %d/%u, "
389 "frag %x split by %d\n", ceph_vinop(inode),
390 i, nsplits, id, split_by);
391 continue;
392 }
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800393 frag = NULL;
394 while (rb_node) {
395 frag = rb_entry(rb_node, struct ceph_inode_frag, node);
396 if (ceph_frag_compare(frag->frag, id) >= 0) {
397 if (frag->frag != id)
398 frag = NULL;
399 else
400 rb_node = rb_next(rb_node);
401 break;
402 }
403 rb_node = rb_next(rb_node);
Yan, Zhenga4b74312016-05-04 11:05:10 +0800404 /* delete stale split/leaf node */
405 if (frag->split_by > 0 ||
406 !is_frag_child(frag->frag, prev_frag)) {
407 rb_erase(&frag->node, &ci->i_fragtree);
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800408 if (frag->split_by > 0)
409 ci->i_fragtree_nsplits--;
Yan, Zhenga4b74312016-05-04 11:05:10 +0800410 kfree(frag);
411 }
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800412 frag = NULL;
413 }
414 if (!frag) {
415 frag = __get_or_create_frag(ci, id);
416 if (IS_ERR(frag))
417 continue;
418 }
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800419 if (frag->split_by == 0)
420 ci->i_fragtree_nsplits++;
421 frag->split_by = split_by;
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800422 dout(" frag %x split by %d\n", frag->frag, frag->split_by);
Yan, Zhenga4b74312016-05-04 11:05:10 +0800423 prev_frag = frag;
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800424 }
425 while (rb_node) {
426 frag = rb_entry(rb_node, struct ceph_inode_frag, node);
427 rb_node = rb_next(rb_node);
Yan, Zhenga4b74312016-05-04 11:05:10 +0800428 /* delete stale split/leaf node */
429 if (frag->split_by > 0 ||
430 !is_frag_child(frag->frag, prev_frag)) {
431 rb_erase(&frag->node, &ci->i_fragtree);
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800432 if (frag->split_by > 0)
433 ci->i_fragtree_nsplits--;
Yan, Zhenga4b74312016-05-04 11:05:10 +0800434 kfree(frag);
435 }
Yan, Zheng3e7fbe92014-04-18 16:00:30 +0800436 }
437out_unlock:
438 mutex_unlock(&ci->i_fragtree_mutex);
439 return 0;
440}
Sage Weil355da1e2009-10-06 11:31:08 -0700441
442/*
443 * initialize a newly allocated inode.
444 */
445struct inode *ceph_alloc_inode(struct super_block *sb)
446{
447 struct ceph_inode_info *ci;
448 int i;
449
450 ci = kmem_cache_alloc(ceph_inode_cachep, GFP_NOFS);
451 if (!ci)
452 return NULL;
453
454 dout("alloc_inode %p\n", &ci->vfs_inode);
455
Sage Weilbe655592011-11-30 09:47:09 -0800456 spin_lock_init(&ci->i_ceph_lock);
457
Sage Weil355da1e2009-10-06 11:31:08 -0700458 ci->i_version = 0;
Yan, Zheng31c542a2014-11-14 21:41:55 +0800459 ci->i_inline_version = 0;
Sage Weil355da1e2009-10-06 11:31:08 -0700460 ci->i_time_warp_seq = 0;
461 ci->i_ceph_flags = 0;
Yan, Zhengfdd4e152015-06-16 20:48:56 +0800462 atomic64_set(&ci->i_ordered_count, 1);
463 atomic64_set(&ci->i_release_count, 1);
464 atomic64_set(&ci->i_complete_seq[0], 0);
465 atomic64_set(&ci->i_complete_seq[1], 0);
Sage Weil355da1e2009-10-06 11:31:08 -0700466 ci->i_symlink = NULL;
467
Luis Henriquesfb18a572018-01-05 10:47:18 +0000468 ci->i_max_bytes = 0;
469 ci->i_max_files = 0;
470
Sage Weil6c0f3af2010-11-16 11:14:34 -0800471 memset(&ci->i_dir_layout, 0, sizeof(ci->i_dir_layout));
Jeff Layton785892f2020-01-02 07:11:38 -0500472 memset(&ci->i_cached_layout, 0, sizeof(ci->i_cached_layout));
Yan, Zheng30c156d2016-02-14 11:24:31 +0800473 RCU_INIT_POINTER(ci->i_layout.pool_ns, NULL);
Sage Weil6c0f3af2010-11-16 11:14:34 -0800474
Sage Weil355da1e2009-10-06 11:31:08 -0700475 ci->i_fragtree = RB_ROOT;
476 mutex_init(&ci->i_fragtree_mutex);
477
478 ci->i_xattrs.blob = NULL;
479 ci->i_xattrs.prealloc_blob = NULL;
480 ci->i_xattrs.dirty = false;
481 ci->i_xattrs.index = RB_ROOT;
482 ci->i_xattrs.count = 0;
483 ci->i_xattrs.names_size = 0;
484 ci->i_xattrs.vals_size = 0;
485 ci->i_xattrs.version = 0;
486 ci->i_xattrs.index_version = 0;
487
488 ci->i_caps = RB_ROOT;
489 ci->i_auth_cap = NULL;
490 ci->i_dirty_caps = 0;
491 ci->i_flushing_caps = 0;
492 INIT_LIST_HEAD(&ci->i_dirty_item);
493 INIT_LIST_HEAD(&ci->i_flushing_item);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +0800494 ci->i_prealloc_cap_flush = NULL;
Yan, Zhenge4500b52016-07-06 11:12:56 +0800495 INIT_LIST_HEAD(&ci->i_cap_flush_list);
Sage Weil355da1e2009-10-06 11:31:08 -0700496 init_waitqueue_head(&ci->i_cap_wq);
Sage Weil355da1e2009-10-06 11:31:08 -0700497 ci->i_hold_caps_max = 0;
498 INIT_LIST_HEAD(&ci->i_cap_delay_list);
Sage Weil355da1e2009-10-06 11:31:08 -0700499 INIT_LIST_HEAD(&ci->i_cap_snaps);
500 ci->i_head_snapc = NULL;
501 ci->i_snap_caps = 0;
502
Yan, Zheng719a2512020-03-05 20:21:00 +0800503 ci->i_last_rd = ci->i_last_wr = jiffies - 3600 * HZ;
Yan, Zheng774a6a12016-06-06 16:01:39 +0800504 for (i = 0; i < CEPH_FILE_MODE_BITS; i++)
Sage Weil355da1e2009-10-06 11:31:08 -0700505 ci->i_nr_by_mode[i] = 0;
506
Yan, Zhengb0d7c222013-08-12 21:42:15 -0700507 mutex_init(&ci->i_truncate_mutex);
Sage Weil355da1e2009-10-06 11:31:08 -0700508 ci->i_truncate_seq = 0;
509 ci->i_truncate_size = 0;
510 ci->i_truncate_pending = 0;
511
512 ci->i_max_size = 0;
513 ci->i_reported_size = 0;
514 ci->i_wanted_max_size = 0;
515 ci->i_requested_max_size = 0;
516
517 ci->i_pin_ref = 0;
518 ci->i_rd_ref = 0;
519 ci->i_rdcache_ref = 0;
520 ci->i_wr_ref = 0;
Henry C Changd3d07202011-05-11 10:29:54 +0000521 ci->i_wb_ref = 0;
Jeff Laytonf85122a2019-04-02 08:04:30 -0400522 ci->i_fx_ref = 0;
Sage Weil355da1e2009-10-06 11:31:08 -0700523 ci->i_wrbuffer_ref = 0;
524 ci->i_wrbuffer_ref_head = 0;
Yan, Zheng89aa5932017-09-08 15:23:18 +0800525 atomic_set(&ci->i_filelock_ref, 0);
Yan, Zheng1e9c2eb2019-01-28 20:43:55 +0800526 atomic_set(&ci->i_shared_gen, 1);
Sage Weil355da1e2009-10-06 11:31:08 -0700527 ci->i_rdcache_gen = 0;
528 ci->i_rdcache_revoking = 0;
529
Sage Weil355da1e2009-10-06 11:31:08 -0700530 INIT_LIST_HEAD(&ci->i_unsafe_dirops);
Yan, Zheng68cd5b42015-10-27 18:36:06 +0800531 INIT_LIST_HEAD(&ci->i_unsafe_iops);
Sage Weil355da1e2009-10-06 11:31:08 -0700532 spin_lock_init(&ci->i_unsafe_lock);
533
534 ci->i_snap_realm = NULL;
535 INIT_LIST_HEAD(&ci->i_snap_realm_item);
536 INIT_LIST_HEAD(&ci->i_snap_flush_item);
537
Yan, Zheng1cf89a82019-05-18 11:18:44 +0800538 INIT_WORK(&ci->i_work, ceph_inode_work);
539 ci->i_work_mask = 0;
Jeff Layton245ce992019-05-29 11:19:42 -0400540 memset(&ci->i_btime, '\0', sizeof(ci->i_btime));
Sage Weil355da1e2009-10-06 11:31:08 -0700541
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400542 ceph_fscache_inode_init(ci);
543
Sage Weil355da1e2009-10-06 11:31:08 -0700544 return &ci->vfs_inode;
545}
546
Al Virocfa6d412019-04-10 15:18:50 -0400547void ceph_free_inode(struct inode *inode)
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100548{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100549 struct ceph_inode_info *ci = ceph_inode(inode);
550
Al Virodaf5cc22019-03-26 01:38:58 +0000551 kfree(ci->i_symlink);
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100552 kmem_cache_free(ceph_inode_cachep, ci);
553}
554
Yan, Zheng87bc5b82019-06-02 09:45:38 +0800555void ceph_evict_inode(struct inode *inode)
Sage Weil355da1e2009-10-06 11:31:08 -0700556{
557 struct ceph_inode_info *ci = ceph_inode(inode);
Xiubo Li1dd8d472020-09-03 09:01:40 -0400558 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
Sage Weil355da1e2009-10-06 11:31:08 -0700559 struct ceph_inode_frag *frag;
560 struct rb_node *n;
561
Yan, Zheng87bc5b82019-06-02 09:45:38 +0800562 dout("evict_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode));
563
Xiubo Li1dd8d472020-09-03 09:01:40 -0400564 percpu_counter_dec(&mdsc->metric.total_inodes);
565
Yan, Zheng87bc5b82019-06-02 09:45:38 +0800566 truncate_inode_pages_final(&inode->i_data);
Jeff Layton400e1282021-12-07 08:44:50 -0500567 if (inode->i_state & I_PINNING_FSCACHE_WB)
568 ceph_fscache_unuse_cookie(inode, true);
Yan, Zheng87bc5b82019-06-02 09:45:38 +0800569 clear_inode(inode);
Sage Weil355da1e2009-10-06 11:31:08 -0700570
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400571 ceph_fscache_unregister_inode_cookie(ci);
572
Yan, Zhengd6e47812019-05-23 11:01:37 +0800573 __ceph_remove_caps(ci);
Sage Weil355da1e2009-10-06 11:31:08 -0700574
Luis Henriquesd557c482018-01-12 17:19:29 +0000575 if (__ceph_has_any_quota(ci))
576 ceph_adjust_quota_realms_count(inode, false);
577
Sage Weil8b218b82010-03-09 12:59:08 -0800578 /*
579 * we may still have a snap_realm reference if there are stray
Yan, Zhengd9df2782014-04-18 09:57:11 +0800580 * caps in i_snap_caps.
Sage Weil8b218b82010-03-09 12:59:08 -0800581 */
582 if (ci->i_snap_realm) {
Yan, Zheng75c96272017-12-14 15:11:09 +0800583 if (ceph_snap(inode) == CEPH_NOSNAP) {
Yan, Zheng75c96272017-12-14 15:11:09 +0800584 dout(" dropping residual ref to snap realm %p\n",
Jeff Layton0ba92e12021-08-02 11:01:26 -0400585 ci->i_snap_realm);
586 ceph_change_snap_realm(inode, NULL);
Yan, Zheng75c96272017-12-14 15:11:09 +0800587 } else {
588 ceph_put_snapid_map(mdsc, ci->i_snapid_map);
589 ci->i_snap_realm = NULL;
590 }
Sage Weil8b218b82010-03-09 12:59:08 -0800591 }
592
Sage Weil355da1e2009-10-06 11:31:08 -0700593 while ((n = rb_first(&ci->i_fragtree)) != NULL) {
594 frag = rb_entry(n, struct ceph_inode_frag, node);
595 rb_erase(n, &ci->i_fragtree);
596 kfree(frag);
597 }
Yan, Zheng1b1bc162016-05-04 11:40:30 +0800598 ci->i_fragtree_nsplits = 0;
Sage Weil355da1e2009-10-06 11:31:08 -0700599
600 __ceph_destroy_xattrs(ci);
Sage Weilb6c1d5b2009-12-07 12:17:17 -0800601 if (ci->i_xattrs.blob)
602 ceph_buffer_put(ci->i_xattrs.blob);
603 if (ci->i_xattrs.prealloc_blob)
604 ceph_buffer_put(ci->i_xattrs.prealloc_blob);
Sage Weil355da1e2009-10-06 11:31:08 -0700605
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800606 ceph_put_string(rcu_dereference_raw(ci->i_layout.pool_ns));
Jeff Layton785892f2020-01-02 07:11:38 -0500607 ceph_put_string(rcu_dereference_raw(ci->i_cached_layout.pool_ns));
Sage Weil355da1e2009-10-06 11:31:08 -0700608}
609
Yan, Zheng224a75422016-05-05 16:40:17 +0800610static inline blkcnt_t calc_inode_blocks(u64 size)
611{
612 return (size + (1<<9) - 1) >> 9;
613}
614
Sage Weil355da1e2009-10-06 11:31:08 -0700615/*
616 * Helpers to fill in size, ctime, mtime, and atime. We have to be
617 * careful because either the client or MDS may have more up to date
618 * info, depending on which capabilities are held, and whether
619 * time_warp_seq or truncate_seq have increased. (Ordinarily, mtime
620 * and size are monotonically increasing, except when utimes() or
621 * truncate() increments the corresponding _seq values.)
622 */
623int ceph_fill_file_size(struct inode *inode, int issued,
624 u32 truncate_seq, u64 truncate_size, u64 size)
625{
626 struct ceph_inode_info *ci = ceph_inode(inode);
627 int queue_trunc = 0;
Jeff Layton2d6795f2021-04-09 15:58:35 -0400628 loff_t isize = i_size_read(inode);
Sage Weil355da1e2009-10-06 11:31:08 -0700629
630 if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) > 0 ||
Jeff Layton2d6795f2021-04-09 15:58:35 -0400631 (truncate_seq == ci->i_truncate_seq && size > isize)) {
632 dout("size %lld -> %llu\n", isize, size);
Yan, Zhenga3d714c2016-02-26 17:16:32 +0800633 if (size > 0 && S_ISDIR(inode->i_mode)) {
634 pr_err("fill_file_size non-zero size for directory\n");
635 size = 0;
636 }
Yan, Zheng99c88e62015-12-30 11:32:46 +0800637 i_size_write(inode, size);
Yan, Zheng224a75422016-05-05 16:40:17 +0800638 inode->i_blocks = calc_inode_blocks(size);
Jeff Layton400e1282021-12-07 08:44:50 -0500639 /*
640 * If we're expanding, then we should be able to just update
641 * the existing cookie.
642 */
643 if (size > isize)
644 ceph_fscache_update(inode);
Sage Weil355da1e2009-10-06 11:31:08 -0700645 ci->i_reported_size = size;
646 if (truncate_seq != ci->i_truncate_seq) {
647 dout("truncate_seq %u -> %u\n",
648 ci->i_truncate_seq, truncate_seq);
649 ci->i_truncate_seq = truncate_seq;
Yan, Zhengb0d7c222013-08-12 21:42:15 -0700650
651 /* the MDS should have revoked these caps */
652 WARN_ON_ONCE(issued & (CEPH_CAP_FILE_EXCL |
653 CEPH_CAP_FILE_RD |
654 CEPH_CAP_FILE_WR |
655 CEPH_CAP_FILE_LAZYIO));
Yehuda Sadeh3d497d82010-02-09 11:08:40 -0800656 /*
657 * If we hold relevant caps, or in the case where we're
658 * not the only client referencing this file and we
659 * don't hold those caps, then we need to check whether
660 * the file is either opened or mmaped
661 */
Yan, Zhengb0d7c222013-08-12 21:42:15 -0700662 if ((issued & (CEPH_CAP_FILE_CACHE|
663 CEPH_CAP_FILE_BUFFER)) ||
Yehuda Sadeh3d497d82010-02-09 11:08:40 -0800664 mapping_mapped(inode->i_mapping) ||
Yan, Zheng719a2512020-03-05 20:21:00 +0800665 __ceph_is_file_opened(ci)) {
Sage Weil355da1e2009-10-06 11:31:08 -0700666 ci->i_truncate_pending++;
667 queue_trunc = 1;
668 }
669 }
670 }
671 if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) >= 0 &&
672 ci->i_truncate_size != truncate_size) {
673 dout("truncate_size %lld -> %llu\n", ci->i_truncate_size,
674 truncate_size);
675 ci->i_truncate_size = truncate_size;
676 }
677 return queue_trunc;
678}
679
680void ceph_fill_file_time(struct inode *inode, int issued,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200681 u64 time_warp_seq, struct timespec64 *ctime,
682 struct timespec64 *mtime, struct timespec64 *atime)
Sage Weil355da1e2009-10-06 11:31:08 -0700683{
684 struct ceph_inode_info *ci = ceph_inode(inode);
685 int warn = 0;
686
687 if (issued & (CEPH_CAP_FILE_EXCL|
688 CEPH_CAP_FILE_WR|
Sage Weild8672d62010-11-08 09:24:34 -0800689 CEPH_CAP_FILE_BUFFER|
690 CEPH_CAP_AUTH_EXCL|
691 CEPH_CAP_XATTR_EXCL)) {
Yan, Zhengffdeec72018-03-26 16:46:39 +0800692 if (ci->i_version == 0 ||
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200693 timespec64_compare(ctime, &inode->i_ctime) > 0) {
Deepa Dinamani13442b02018-04-23 19:26:50 -0700694 dout("ctime %lld.%09ld -> %lld.%09ld inc w/ cap\n",
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200695 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
696 ctime->tv_sec, ctime->tv_nsec);
697 inode->i_ctime = *ctime;
Sage Weil355da1e2009-10-06 11:31:08 -0700698 }
Yan, Zhengffdeec72018-03-26 16:46:39 +0800699 if (ci->i_version == 0 ||
700 ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) {
Sage Weil355da1e2009-10-06 11:31:08 -0700701 /* the MDS did a utimes() */
Deepa Dinamani13442b02018-04-23 19:26:50 -0700702 dout("mtime %lld.%09ld -> %lld.%09ld "
Sage Weil355da1e2009-10-06 11:31:08 -0700703 "tw %d -> %d\n",
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200704 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
705 mtime->tv_sec, mtime->tv_nsec,
Sage Weil355da1e2009-10-06 11:31:08 -0700706 ci->i_time_warp_seq, (int)time_warp_seq);
707
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200708 inode->i_mtime = *mtime;
709 inode->i_atime = *atime;
Sage Weil355da1e2009-10-06 11:31:08 -0700710 ci->i_time_warp_seq = time_warp_seq;
711 } else if (time_warp_seq == ci->i_time_warp_seq) {
712 /* nobody did utimes(); take the max */
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200713 if (timespec64_compare(mtime, &inode->i_mtime) > 0) {
Deepa Dinamani13442b02018-04-23 19:26:50 -0700714 dout("mtime %lld.%09ld -> %lld.%09ld inc\n",
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200715 inode->i_mtime.tv_sec,
Sage Weil355da1e2009-10-06 11:31:08 -0700716 inode->i_mtime.tv_nsec,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200717 mtime->tv_sec, mtime->tv_nsec);
718 inode->i_mtime = *mtime;
Sage Weil355da1e2009-10-06 11:31:08 -0700719 }
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200720 if (timespec64_compare(atime, &inode->i_atime) > 0) {
Deepa Dinamani13442b02018-04-23 19:26:50 -0700721 dout("atime %lld.%09ld -> %lld.%09ld inc\n",
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200722 inode->i_atime.tv_sec,
Sage Weil355da1e2009-10-06 11:31:08 -0700723 inode->i_atime.tv_nsec,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200724 atime->tv_sec, atime->tv_nsec);
725 inode->i_atime = *atime;
Sage Weil355da1e2009-10-06 11:31:08 -0700726 }
727 } else if (issued & CEPH_CAP_FILE_EXCL) {
728 /* we did a utimes(); ignore mds values */
729 } else {
730 warn = 1;
731 }
732 } else {
Sage Weild8672d62010-11-08 09:24:34 -0800733 /* we have no write|excl caps; whatever the MDS says is true */
Sage Weil355da1e2009-10-06 11:31:08 -0700734 if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200735 inode->i_ctime = *ctime;
736 inode->i_mtime = *mtime;
737 inode->i_atime = *atime;
Sage Weil355da1e2009-10-06 11:31:08 -0700738 ci->i_time_warp_seq = time_warp_seq;
739 } else {
740 warn = 1;
741 }
742 }
743 if (warn) /* time_warp_seq shouldn't go backwards */
744 dout("%p mds time_warp_seq %llu < %u\n",
745 inode, time_warp_seq, ci->i_time_warp_seq);
746}
747
748/*
749 * Populate an inode based on info from mds. May be called on new or
750 * existing inodes.
751 */
Jeff Layton966c7162019-12-05 09:09:25 -0500752int ceph_fill_inode(struct inode *inode, struct page *locked_page,
753 struct ceph_mds_reply_info_in *iinfo,
754 struct ceph_mds_reply_dirfrag *dirinfo,
755 struct ceph_mds_session *session, int cap_fmode,
756 struct ceph_cap_reservation *caps_reservation)
Sage Weil355da1e2009-10-06 11:31:08 -0700757{
Xiubo Li2678da82020-09-03 09:01:39 -0400758 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
Sage Weil355da1e2009-10-06 11:31:08 -0700759 struct ceph_mds_reply_inode *info = iinfo->in;
760 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng2af54a72018-04-27 11:14:39 +0800761 int issued, new_issued, info_caps;
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200762 struct timespec64 mtime, atime, ctime;
Sage Weil355da1e2009-10-06 11:31:08 -0700763 struct ceph_buffer *xattr_blob = NULL;
Luis Henriquesaf8a85a2019-07-19 15:32:22 +0100764 struct ceph_buffer *old_blob = NULL;
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800765 struct ceph_string *pool_ns = NULL;
Yan, Zhengd9df2782014-04-18 09:57:11 +0800766 struct ceph_cap *new_cap = NULL;
Sage Weil355da1e2009-10-06 11:31:08 -0700767 int err = 0;
Yan, Zhengd9df2782014-04-18 09:57:11 +0800768 bool wake = false;
Yan, Zhengf98a1282014-04-17 08:55:50 +0800769 bool queue_trunc = false;
770 bool new_version = false;
Yan, Zheng31c542a2014-11-14 21:41:55 +0800771 bool fill_inline = false;
Jeff Laytoned94f872021-02-25 15:04:16 -0500772 umode_t mode = le32_to_cpu(info->mode);
773 dev_t rdev = le32_to_cpu(info->rdev);
Sage Weil355da1e2009-10-06 11:31:08 -0700774
Jeff Layton27171ae2021-06-01 09:40:25 -0400775 lockdep_assert_held(&mdsc->snap_rwsem);
776
Jeff Layton966c7162019-12-05 09:09:25 -0500777 dout("%s %p ino %llx.%llx v %llu had %llu\n", __func__,
Sage Weil355da1e2009-10-06 11:31:08 -0700778 inode, ceph_vinop(inode), le64_to_cpu(info->version),
779 ci->i_version);
780
Jeff Laytoned94f872021-02-25 15:04:16 -0500781 /* Once I_NEW is cleared, we can't change type or dev numbers */
782 if (inode->i_state & I_NEW) {
783 inode->i_mode = mode;
784 } else {
785 if (inode_wrong_type(inode, mode)) {
786 pr_warn_once("inode type changed! (ino %llx.%llx is 0%o, mds says 0%o)\n",
787 ceph_vinop(inode), inode->i_mode, mode);
788 return -ESTALE;
789 }
790
791 if ((S_ISCHR(mode) || S_ISBLK(mode)) && inode->i_rdev != rdev) {
792 pr_warn_once("dev inode rdev changed! (ino %llx.%llx is %u:%u, mds says %u:%u)\n",
793 ceph_vinop(inode), MAJOR(inode->i_rdev),
794 MINOR(inode->i_rdev), MAJOR(rdev),
795 MINOR(rdev));
796 return -ESTALE;
797 }
798 }
799
Yan, Zheng2af54a72018-04-27 11:14:39 +0800800 info_caps = le32_to_cpu(info->cap.caps);
801
Yan, Zhengd9df2782014-04-18 09:57:11 +0800802 /* prealloc new cap struct */
Jeff Layton9a6bed42019-12-05 08:41:25 -0500803 if (info_caps && ceph_snap(inode) == CEPH_NOSNAP) {
Yan, Zhengd9df2782014-04-18 09:57:11 +0800804 new_cap = ceph_get_cap(mdsc, caps_reservation);
Jeff Layton9a6bed42019-12-05 08:41:25 -0500805 if (!new_cap)
806 return -ENOMEM;
807 }
Yan, Zhengd9df2782014-04-18 09:57:11 +0800808
Sage Weil355da1e2009-10-06 11:31:08 -0700809 /*
810 * prealloc xattr data, if it looks like we'll need it. only
811 * if len > 4 (meaning there are actually xattrs; the first 4
812 * bytes are the xattr count).
813 */
814 if (iinfo->xattr_len > 4) {
Sage Weilb6c1d5b2009-12-07 12:17:17 -0800815 xattr_blob = ceph_buffer_new(iinfo->xattr_len, GFP_NOFS);
Sage Weil355da1e2009-10-06 11:31:08 -0700816 if (!xattr_blob)
Jeff Layton966c7162019-12-05 09:09:25 -0500817 pr_err("%s ENOMEM xattr blob %d bytes\n", __func__,
Sage Weil355da1e2009-10-06 11:31:08 -0700818 iinfo->xattr_len);
819 }
820
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800821 if (iinfo->pool_ns_len > 0)
822 pool_ns = ceph_find_or_create_string(iinfo->pool_ns_data,
823 iinfo->pool_ns_len);
824
Yan, Zheng75c96272017-12-14 15:11:09 +0800825 if (ceph_snap(inode) != CEPH_NOSNAP && !ci->i_snapid_map)
826 ci->i_snapid_map = ceph_get_snapid_map(mdsc, ceph_snap(inode));
827
Sage Weilbe655592011-11-30 09:47:09 -0800828 spin_lock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -0700829
830 /*
831 * provided version will be odd if inode value is projected,
Sage Weil8bd59e02010-11-08 09:23:12 -0800832 * even if stable. skip the update if we have newer stable
833 * info (ours>=theirs, e.g. due to racing mds replies), unless
834 * we are getting projected (unstable) info (in which case the
835 * version is odd, and we want ours>theirs).
836 * us them
837 * 2 2 skip
838 * 3 2 skip
839 * 3 3 update
Sage Weil355da1e2009-10-06 11:31:08 -0700840 */
Yan, Zhengf98a1282014-04-17 08:55:50 +0800841 if (ci->i_version == 0 ||
842 ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
843 le64_to_cpu(info->version) > (ci->i_version & ~1)))
844 new_version = true;
845
Jeff Laytona35ead32019-06-06 07:29:23 -0400846 /* Update change_attribute */
847 inode_set_max_iversion_raw(inode, iinfo->change_attr);
848
Yan, Zheng2af54a72018-04-27 11:14:39 +0800849 __ceph_caps_issued(ci, &issued);
850 issued |= __ceph_caps_dirty(ci);
851 new_issued = ~issued & info_caps;
Sage Weil355da1e2009-10-06 11:31:08 -0700852
Luis Henriques75067032019-07-23 16:50:20 +0100853 /* directories have fl_stripe_unit set to zero */
854 if (le32_to_cpu(info->layout.fl_stripe_unit))
855 inode->i_blkbits =
856 fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
857 else
858 inode->i_blkbits = CEPH_BLOCK_SHIFT;
Sage Weil355da1e2009-10-06 11:31:08 -0700859
Luis Henriquesd557c482018-01-12 17:19:29 +0000860 __ceph_update_quota(ci, iinfo->max_bytes, iinfo->max_files);
Luis Henriquesfb18a572018-01-05 10:47:18 +0000861
Yan, Zhengf98a1282014-04-17 08:55:50 +0800862 if ((new_version || (new_issued & CEPH_CAP_AUTH_SHARED)) &&
863 (issued & CEPH_CAP_AUTH_EXCL) == 0) {
Jeff Laytoned94f872021-02-25 15:04:16 -0500864 inode->i_mode = mode;
Eric W. Biedermanab871b92013-01-31 03:40:12 -0800865 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(info->uid));
866 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(info->gid));
Sage Weil355da1e2009-10-06 11:31:08 -0700867 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
Eric W. Biedermanbd2bae62013-01-31 04:05:39 -0800868 from_kuid(&init_user_ns, inode->i_uid),
869 from_kgid(&init_user_ns, inode->i_gid));
Jeff Layton245ce992019-05-29 11:19:42 -0400870 ceph_decode_timespec64(&ci->i_btime, &iinfo->btime);
David Disseldorp193e7b32019-04-18 14:15:46 +0200871 ceph_decode_timespec64(&ci->i_snap_btime, &iinfo->snap_btime);
Sage Weil355da1e2009-10-06 11:31:08 -0700872 }
873
Yan, Zhengf98a1282014-04-17 08:55:50 +0800874 if ((new_version || (new_issued & CEPH_CAP_LINK_SHARED)) &&
875 (issued & CEPH_CAP_LINK_EXCL) == 0)
Miklos Szeredibfe86842011-10-28 14:13:29 +0200876 set_nlink(inode, le32_to_cpu(info->nlink));
Sage Weil355da1e2009-10-06 11:31:08 -0700877
Yan, Zhengf98a1282014-04-17 08:55:50 +0800878 if (new_version || (new_issued & CEPH_CAP_ANY_RD)) {
879 /* be careful with mtime, atime, size */
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200880 ceph_decode_timespec64(&atime, &info->atime);
881 ceph_decode_timespec64(&mtime, &info->mtime);
882 ceph_decode_timespec64(&ctime, &info->ctime);
Yan, Zhengf98a1282014-04-17 08:55:50 +0800883 ceph_fill_file_time(inode, issued,
884 le32_to_cpu(info->time_warp_seq),
885 &ctime, &mtime, &atime);
886 }
Sage Weil355da1e2009-10-06 11:31:08 -0700887
Yan, Zheng2af54a72018-04-27 11:14:39 +0800888 if (new_version || (info_caps & CEPH_CAP_FILE_SHARED)) {
889 ci->i_files = le64_to_cpu(info->files);
890 ci->i_subdirs = le64_to_cpu(info->subdirs);
891 }
892
Yan, Zhengf98a1282014-04-17 08:55:50 +0800893 if (new_version ||
894 (new_issued & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR))) {
Yan, Zheng76271512016-02-03 21:24:49 +0800895 s64 old_pool = ci->i_layout.pool_id;
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800896 struct ceph_string *old_ns;
897
Yan, Zheng76271512016-02-03 21:24:49 +0800898 ceph_file_layout_from_legacy(&ci->i_layout, &info->layout);
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800899 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
900 lockdep_is_held(&ci->i_ceph_lock));
901 rcu_assign_pointer(ci->i_layout.pool_ns, pool_ns);
902
903 if (ci->i_layout.pool_id != old_pool || pool_ns != old_ns)
Yan, Zheng10183a62015-04-27 15:33:28 +0800904 ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;
Yan, Zheng10183a62015-04-27 15:33:28 +0800905
Yan, Zheng779fe0f2016-03-07 09:35:06 +0800906 pool_ns = old_ns;
Yan, Zhengf98a1282014-04-17 08:55:50 +0800907
908 queue_trunc = ceph_fill_file_size(inode, issued,
909 le32_to_cpu(info->truncate_seq),
910 le64_to_cpu(info->truncate_size),
911 le64_to_cpu(info->size));
912 /* only update max_size on auth cap */
913 if ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
914 ci->i_max_size != le64_to_cpu(info->max_size)) {
915 dout("max_size %lld -> %llu\n", ci->i_max_size,
916 le64_to_cpu(info->max_size));
917 ci->i_max_size = le64_to_cpu(info->max_size);
918 }
919 }
Sage Weil355da1e2009-10-06 11:31:08 -0700920
Yan, Zheng49a9f4f2018-04-25 17:30:23 +0800921 /* layout and rstat are not tracked by capability, update them if
922 * the inode info is from auth mds */
923 if (new_version || (info->cap.flags & CEPH_CAP_FLAG_AUTH)) {
924 if (S_ISDIR(inode->i_mode)) {
925 ci->i_dir_layout = iinfo->dir_layout;
926 ci->i_rbytes = le64_to_cpu(info->rbytes);
927 ci->i_rfiles = le64_to_cpu(info->rfiles);
928 ci->i_rsubdirs = le64_to_cpu(info->rsubdirs);
Yan, Zheng08796872019-01-09 11:07:02 +0800929 ci->i_dir_pin = iinfo->dir_pin;
Yanhu Caoe7f72952020-08-28 09:28:44 +0800930 ci->i_rsnaps = iinfo->rsnaps;
Arnd Bergmann9bbeab42018-07-13 22:18:36 +0200931 ceph_decode_timespec64(&ci->i_rctime, &info->rctime);
Yan, Zheng49a9f4f2018-04-25 17:30:23 +0800932 }
933 }
934
Sage Weil355da1e2009-10-06 11:31:08 -0700935 /* xattrs */
936 /* note that if i_xattrs.len <= 4, i_xattrs.data will still be NULL. */
Yan, Zheng508b32d2014-09-16 21:46:17 +0800937 if ((ci->i_xattrs.version == 0 || !(issued & CEPH_CAP_XATTR_EXCL)) &&
Sage Weil355da1e2009-10-06 11:31:08 -0700938 le64_to_cpu(info->xattr_version) > ci->i_xattrs.version) {
939 if (ci->i_xattrs.blob)
Luis Henriquesaf8a85a2019-07-19 15:32:22 +0100940 old_blob = ci->i_xattrs.blob;
Sage Weil355da1e2009-10-06 11:31:08 -0700941 ci->i_xattrs.blob = xattr_blob;
942 if (xattr_blob)
943 memcpy(ci->i_xattrs.blob->vec.iov_base,
944 iinfo->xattr_data, iinfo->xattr_len);
945 ci->i_xattrs.version = le64_to_cpu(info->xattr_version);
Guangliang Zhao7221fe42013-11-11 15:18:03 +0800946 ceph_forget_all_cached_acls(inode);
Yan, Zhengac6713c2019-05-26 16:27:56 +0800947 ceph_security_invalidate_secctx(inode);
Sage Weila6424e42010-04-29 09:28:11 -0700948 xattr_blob = NULL;
Sage Weil355da1e2009-10-06 11:31:08 -0700949 }
950
Yan, Zhengffdeec72018-03-26 16:46:39 +0800951 /* finally update i_version */
Yan, Zhengaae1a442018-05-26 16:54:39 +0800952 if (le64_to_cpu(info->version) > ci->i_version)
953 ci->i_version = le64_to_cpu(info->version);
Yan, Zhengffdeec72018-03-26 16:46:39 +0800954
Sage Weil355da1e2009-10-06 11:31:08 -0700955 inode->i_mapping->a_ops = &ceph_aops;
Sage Weil355da1e2009-10-06 11:31:08 -0700956
957 switch (inode->i_mode & S_IFMT) {
958 case S_IFIFO:
959 case S_IFBLK:
960 case S_IFCHR:
961 case S_IFSOCK:
Yan, Zheng5ba72e62018-12-18 11:03:38 +0800962 inode->i_blkbits = PAGE_SHIFT;
Jeff Laytoned94f872021-02-25 15:04:16 -0500963 init_special_inode(inode, inode->i_mode, rdev);
Sage Weil355da1e2009-10-06 11:31:08 -0700964 inode->i_op = &ceph_file_iops;
965 break;
966 case S_IFREG:
967 inode->i_op = &ceph_file_iops;
968 inode->i_fop = &ceph_file_fops;
969 break;
970 case S_IFLNK:
971 inode->i_op = &ceph_symlink_iops;
972 if (!ci->i_symlink) {
Xi Wang810339ec2012-02-03 09:55:36 -0500973 u32 symlen = iinfo->symlink_len;
Sage Weil355da1e2009-10-06 11:31:08 -0700974 char *sym;
975
Sage Weilbe655592011-11-30 09:47:09 -0800976 spin_unlock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -0700977
Yan, Zheng224a75422016-05-05 16:40:17 +0800978 if (symlen != i_size_read(inode)) {
Jeff Layton966c7162019-12-05 09:09:25 -0500979 pr_err("%s %llx.%llx BAD symlink "
980 "size %lld\n", __func__,
981 ceph_vinop(inode),
Yan, Zheng224a75422016-05-05 16:40:17 +0800982 i_size_read(inode));
983 i_size_write(inode, symlen);
984 inode->i_blocks = calc_inode_blocks(symlen);
985 }
Xi Wang810339ec2012-02-03 09:55:36 -0500986
Sage Weil355da1e2009-10-06 11:31:08 -0700987 err = -ENOMEM;
Xi Wang810339ec2012-02-03 09:55:36 -0500988 sym = kstrndup(iinfo->symlink, symlen, GFP_NOFS);
Sage Weil355da1e2009-10-06 11:31:08 -0700989 if (!sym)
990 goto out;
Sage Weil355da1e2009-10-06 11:31:08 -0700991
Sage Weilbe655592011-11-30 09:47:09 -0800992 spin_lock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -0700993 if (!ci->i_symlink)
994 ci->i_symlink = sym;
995 else
996 kfree(sym); /* lost a race */
997 }
Al Viroac194dc2015-05-02 10:50:05 -0400998 inode->i_link = ci->i_symlink;
Sage Weil355da1e2009-10-06 11:31:08 -0700999 break;
1000 case S_IFDIR:
1001 inode->i_op = &ceph_dir_iops;
1002 inode->i_fop = &ceph_dir_fops;
Sage Weil355da1e2009-10-06 11:31:08 -07001003 break;
1004 default:
Jeff Layton966c7162019-12-05 09:09:25 -05001005 pr_err("%s %llx.%llx BAD mode 0%o\n", __func__,
Sage Weil355da1e2009-10-06 11:31:08 -07001006 ceph_vinop(inode), inode->i_mode);
1007 }
1008
Sage Weil355da1e2009-10-06 11:31:08 -07001009 /* were we issued a capability? */
Yan, Zheng2af54a72018-04-27 11:14:39 +08001010 if (info_caps) {
Sage Weil355da1e2009-10-06 11:31:08 -07001011 if (ceph_snap(inode) == CEPH_NOSNAP) {
1012 ceph_add_cap(inode, session,
1013 le64_to_cpu(info->cap.cap_id),
Yan, Zheng135e6712020-03-05 20:21:02 +08001014 info_caps,
Sage Weil355da1e2009-10-06 11:31:08 -07001015 le32_to_cpu(info->cap.wanted),
1016 le32_to_cpu(info->cap.seq),
1017 le32_to_cpu(info->cap.mseq),
1018 le64_to_cpu(info->cap.realm),
Yan, Zhengd9df2782014-04-18 09:57:11 +08001019 info->cap.flags, &new_cap);
Yan, Zheng2f92b3d2015-01-19 13:12:24 +08001020
1021 /* set dir completion flag? */
1022 if (S_ISDIR(inode->i_mode) &&
1023 ci->i_files == 0 && ci->i_subdirs == 0 &&
Yan, Zheng2af54a72018-04-27 11:14:39 +08001024 (info_caps & CEPH_CAP_FILE_SHARED) &&
Yan, Zheng2f92b3d2015-01-19 13:12:24 +08001025 (issued & CEPH_CAP_FILE_EXCL) == 0 &&
1026 !__ceph_dir_is_complete(ci)) {
1027 dout(" marking %p complete (empty)\n", inode);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001028 i_size_write(inode, 0);
Yan, Zheng2f92b3d2015-01-19 13:12:24 +08001029 __ceph_dir_set_complete(ci,
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001030 atomic64_read(&ci->i_release_count),
1031 atomic64_read(&ci->i_ordered_count));
Yan, Zheng2f92b3d2015-01-19 13:12:24 +08001032 }
1033
Yan, Zhengd9df2782014-04-18 09:57:11 +08001034 wake = true;
Sage Weil355da1e2009-10-06 11:31:08 -07001035 } else {
Sage Weil355da1e2009-10-06 11:31:08 -07001036 dout(" %p got snap_caps %s\n", inode,
Yan, Zheng2af54a72018-04-27 11:14:39 +08001037 ceph_cap_string(info_caps));
1038 ci->i_snap_caps |= info_caps;
Sage Weil355da1e2009-10-06 11:31:08 -07001039 }
1040 }
Yan, Zheng31c542a2014-11-14 21:41:55 +08001041
1042 if (iinfo->inline_version > 0 &&
1043 iinfo->inline_version >= ci->i_inline_version) {
1044 int cache_caps = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO;
1045 ci->i_inline_version = iinfo->inline_version;
1046 if (ci->i_inline_version != CEPH_INLINE_NONE &&
Yan, Zheng2af54a72018-04-27 11:14:39 +08001047 (locked_page || (info_caps & cache_caps)))
Yan, Zheng31c542a2014-11-14 21:41:55 +08001048 fill_inline = true;
1049 }
1050
Yan, Zheng719a2512020-03-05 20:21:00 +08001051 if (cap_fmode >= 0) {
1052 if (!info_caps)
1053 pr_warn("mds issued no caps on %llx.%llx\n",
1054 ceph_vinop(inode));
1055 __ceph_touch_fmode(ci, mdsc, cap_fmode);
1056 }
1057
Sage Weil355da1e2009-10-06 11:31:08 -07001058 spin_unlock(&ci->i_ceph_lock);
1059
Jeff Layton400e1282021-12-07 08:44:50 -05001060 ceph_fscache_register_inode_cookie(inode);
1061
Yan, Zheng31c542a2014-11-14 21:41:55 +08001062 if (fill_inline)
Yan, Zheng01deead2014-11-14 21:56:29 +08001063 ceph_fill_inline_data(inode, locked_page,
Yan, Zheng31c542a2014-11-14 21:41:55 +08001064 iinfo->inline_data, iinfo->inline_len);
1065
Yan, Zhengd9df2782014-04-18 09:57:11 +08001066 if (wake)
1067 wake_up_all(&ci->i_cap_wq);
1068
Sage Weil355da1e2009-10-06 11:31:08 -07001069 /* queue truncate if we saw i_size decrease */
1070 if (queue_trunc)
1071 ceph_queue_vmtruncate(inode);
1072
1073 /* populate frag tree */
Yan, Zheng3e7fbe92014-04-18 16:00:30 +08001074 if (S_ISDIR(inode->i_mode))
1075 ceph_fill_fragtree(inode, &info->fragtree, dirinfo);
Sage Weil355da1e2009-10-06 11:31:08 -07001076
1077 /* update delegation info? */
1078 if (dirinfo)
1079 ceph_fill_dirfrag(inode, dirinfo);
1080
1081 err = 0;
Sage Weil355da1e2009-10-06 11:31:08 -07001082out:
Yan, Zhengd9df2782014-04-18 09:57:11 +08001083 if (new_cap)
1084 ceph_put_cap(mdsc, new_cap);
Luis Henriquesaf8a85a2019-07-19 15:32:22 +01001085 ceph_buffer_put(old_blob);
1086 ceph_buffer_put(xattr_blob);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08001087 ceph_put_string(pool_ns);
Sage Weil355da1e2009-10-06 11:31:08 -07001088 return err;
1089}
1090
1091/*
Yan, Zheng543212b2019-05-22 21:49:44 +08001092 * caller should hold session s_mutex and dentry->d_lock.
Sage Weil355da1e2009-10-06 11:31:08 -07001093 */
Yan, Zheng543212b2019-05-22 21:49:44 +08001094static void __update_dentry_lease(struct inode *dir, struct dentry *dentry,
1095 struct ceph_mds_reply_lease *lease,
1096 struct ceph_mds_session *session,
1097 unsigned long from_time,
1098 struct ceph_mds_session **old_lease_session)
Sage Weil355da1e2009-10-06 11:31:08 -07001099{
1100 struct ceph_dentry_info *di = ceph_dentry(dentry);
Jeff Laytonf5e17ae2020-02-18 14:12:32 -05001101 unsigned mask = le16_to_cpu(lease->mask);
Sage Weil355da1e2009-10-06 11:31:08 -07001102 long unsigned duration = le32_to_cpu(lease->duration_ms);
1103 long unsigned ttl = from_time + (duration * HZ) / 1000;
1104 long unsigned half_ttl = from_time + (duration * HZ / 2) / 1000;
Sage Weil355da1e2009-10-06 11:31:08 -07001105
Sage Weil2f90b852011-07-26 11:28:25 -07001106 dout("update_dentry_lease %p duration %lu ms ttl %lu\n",
1107 dentry, duration, ttl);
Sage Weil355da1e2009-10-06 11:31:08 -07001108
Al Viro18fc8ab2016-10-28 21:52:50 -04001109 /* only track leases on regular dentries */
1110 if (ceph_snap(dir) != CEPH_NOSNAP)
Yan, Zheng543212b2019-05-22 21:49:44 +08001111 return;
Al Viro18fc8ab2016-10-28 21:52:50 -04001112
Jeff Laytonf5e17ae2020-02-18 14:12:32 -05001113 if (mask & CEPH_LEASE_PRIMARY_LINK)
1114 di->flags |= CEPH_DENTRY_PRIMARY_LINK;
1115 else
1116 di->flags &= ~CEPH_DENTRY_PRIMARY_LINK;
1117
Yan, Zheng97aeb6b2017-11-27 10:47:46 +08001118 di->lease_shared_gen = atomic_read(&ceph_inode(dir)->i_shared_gen);
Jeff Laytonf5e17ae2020-02-18 14:12:32 -05001119 if (!(mask & CEPH_LEASE_VALID)) {
Yan, Zheng37c4efc2019-01-31 16:55:51 +08001120 __ceph_dentry_dir_lease_touch(di);
Yan, Zheng543212b2019-05-22 21:49:44 +08001121 return;
Yan, Zheng37c4efc2019-01-31 16:55:51 +08001122 }
Sage Weil355da1e2009-10-06 11:31:08 -07001123
Jeff Layton52d60f82021-06-04 12:03:09 -04001124 if (di->lease_gen == atomic_read(&session->s_cap_gen) &&
Miklos Szeredi9b16f03c2016-06-22 16:35:04 +02001125 time_before(ttl, di->time))
Yan, Zheng543212b2019-05-22 21:49:44 +08001126 return; /* we already have a newer lease. */
Sage Weil355da1e2009-10-06 11:31:08 -07001127
Yan, Zheng481f0012017-07-03 09:09:10 +08001128 if (di->lease_session && di->lease_session != session) {
Yan, Zheng543212b2019-05-22 21:49:44 +08001129 *old_lease_session = di->lease_session;
Yan, Zheng481f0012017-07-03 09:09:10 +08001130 di->lease_session = NULL;
1131 }
Sage Weil355da1e2009-10-06 11:31:08 -07001132
Sage Weil355da1e2009-10-06 11:31:08 -07001133 if (!di->lease_session)
1134 di->lease_session = ceph_get_mds_session(session);
Jeff Layton52d60f82021-06-04 12:03:09 -04001135 di->lease_gen = atomic_read(&session->s_cap_gen);
Sage Weil355da1e2009-10-06 11:31:08 -07001136 di->lease_seq = le32_to_cpu(lease->seq);
1137 di->lease_renew_after = half_ttl;
1138 di->lease_renew_from = 0;
Miklos Szeredi9b16f03c2016-06-22 16:35:04 +02001139 di->time = ttl;
Yan, Zheng37c4efc2019-01-31 16:55:51 +08001140
1141 __ceph_dentry_lease_touch(di);
Yan, Zheng543212b2019-05-22 21:49:44 +08001142}
1143
1144static inline void update_dentry_lease(struct inode *dir, struct dentry *dentry,
1145 struct ceph_mds_reply_lease *lease,
1146 struct ceph_mds_session *session,
1147 unsigned long from_time)
1148{
1149 struct ceph_mds_session *old_lease_session = NULL;
1150 spin_lock(&dentry->d_lock);
1151 __update_dentry_lease(dir, dentry, lease, session, from_time,
1152 &old_lease_session);
1153 spin_unlock(&dentry->d_lock);
Jeff Layton7e656242021-06-09 14:09:52 -04001154 ceph_put_mds_session(old_lease_session);
Yan, Zheng543212b2019-05-22 21:49:44 +08001155}
1156
1157/*
1158 * update dentry lease without having parent inode locked
1159 */
1160static void update_dentry_lease_careful(struct dentry *dentry,
1161 struct ceph_mds_reply_lease *lease,
1162 struct ceph_mds_session *session,
1163 unsigned long from_time,
1164 char *dname, u32 dname_len,
1165 struct ceph_vino *pdvino,
1166 struct ceph_vino *ptvino)
1167
1168{
1169 struct inode *dir;
1170 struct ceph_mds_session *old_lease_session = NULL;
1171
1172 spin_lock(&dentry->d_lock);
1173 /* make sure dentry's name matches target */
1174 if (dentry->d_name.len != dname_len ||
1175 memcmp(dentry->d_name.name, dname, dname_len))
1176 goto out_unlock;
1177
1178 dir = d_inode(dentry->d_parent);
1179 /* make sure parent matches dvino */
1180 if (!ceph_ino_compare(dir, pdvino))
1181 goto out_unlock;
1182
1183 /* make sure dentry's inode matches target. NULL ptvino means that
1184 * we expect a negative dentry */
1185 if (ptvino) {
1186 if (d_really_is_negative(dentry))
1187 goto out_unlock;
1188 if (!ceph_ino_compare(d_inode(dentry), ptvino))
1189 goto out_unlock;
1190 } else {
1191 if (d_really_is_positive(dentry))
1192 goto out_unlock;
1193 }
1194
1195 __update_dentry_lease(dir, dentry, lease, session,
1196 from_time, &old_lease_session);
Sage Weil355da1e2009-10-06 11:31:08 -07001197out_unlock:
1198 spin_unlock(&dentry->d_lock);
Jeff Layton7e656242021-06-09 14:09:52 -04001199 ceph_put_mds_session(old_lease_session);
Sage Weil355da1e2009-10-06 11:31:08 -07001200}
1201
1202/*
Sage Weil1cd39352010-05-03 22:08:02 -07001203 * splice a dentry to an inode.
1204 * caller must hold directory i_mutex for this to be safe.
Sage Weil1cd39352010-05-03 22:08:02 -07001205 */
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001206static int splice_dentry(struct dentry **pdn, struct inode *in)
Sage Weil1cd39352010-05-03 22:08:02 -07001207{
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001208 struct dentry *dn = *pdn;
Sage Weil1cd39352010-05-03 22:08:02 -07001209 struct dentry *realdn;
1210
David Howells2b0143b2015-03-17 22:25:59 +00001211 BUG_ON(d_inode(dn));
Sage Weil1cd39352010-05-03 22:08:02 -07001212
Yan, Zheng5495c2d2017-11-27 11:23:48 +08001213 if (S_ISDIR(in->i_mode)) {
1214 /* If inode is directory, d_splice_alias() below will remove
1215 * 'realdn' from its origin parent. We need to ensure that
1216 * origin parent's readdir cache will not reference 'realdn'
1217 */
1218 realdn = d_find_any_alias(in);
1219 if (realdn) {
1220 struct ceph_dentry_info *di = ceph_dentry(realdn);
1221 spin_lock(&realdn->d_lock);
1222
1223 realdn->d_op->d_prune(realdn);
1224
1225 di->time = jiffies;
1226 di->lease_shared_gen = 0;
1227 di->offset = 0;
1228
1229 spin_unlock(&realdn->d_lock);
1230 dput(realdn);
1231 }
1232 }
1233
Sage Weil1cd39352010-05-03 22:08:02 -07001234 /* dn must be unhashed */
1235 if (!d_unhashed(dn))
1236 d_drop(dn);
Al Viro41d28bc2014-10-12 22:24:21 -04001237 realdn = d_splice_alias(in, dn);
Sage Weil1cd39352010-05-03 22:08:02 -07001238 if (IS_ERR(realdn)) {
Sage Weild69ed052010-06-21 10:38:14 -07001239 pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
1240 PTR_ERR(realdn), dn, in, ceph_vinop(in));
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001241 return PTR_ERR(realdn);
1242 }
1243
1244 if (realdn) {
Sage Weil1cd39352010-05-03 22:08:02 -07001245 dout("dn %p (%d) spliced with %p (%d) "
1246 "inode %p ino %llx.%llx\n",
Al Viro84d08fa2013-07-05 18:59:33 +04001247 dn, d_count(dn),
1248 realdn, d_count(realdn),
David Howells2b0143b2015-03-17 22:25:59 +00001249 d_inode(realdn), ceph_vinop(d_inode(realdn)));
Sage Weil1cd39352010-05-03 22:08:02 -07001250 dput(dn);
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001251 *pdn = realdn;
Sage Weil1cd39352010-05-03 22:08:02 -07001252 } else {
1253 BUG_ON(!ceph_dentry(dn));
1254 dout("dn %p attached to %p ino %llx.%llx\n",
David Howells2b0143b2015-03-17 22:25:59 +00001255 dn, d_inode(dn), ceph_vinop(d_inode(dn)));
Sage Weil1cd39352010-05-03 22:08:02 -07001256 }
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001257 return 0;
Sage Weil1cd39352010-05-03 22:08:02 -07001258}
1259
1260/*
Sage Weil355da1e2009-10-06 11:31:08 -07001261 * Incorporate results into the local cache. This is either just
1262 * one inode, or a directory, dentry, and possibly linked-to inode (e.g.,
1263 * after a lookup).
1264 *
1265 * A reply may contain
1266 * a directory inode along with a dentry.
1267 * and/or a target inode
1268 *
1269 * Called with snap_rwsem (read).
1270 */
Jeff Laytonf5a03b02017-01-31 11:06:13 -05001271int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req)
Sage Weil355da1e2009-10-06 11:31:08 -07001272{
Jeff Laytonf5a03b02017-01-31 11:06:13 -05001273 struct ceph_mds_session *session = req->r_session;
Sage Weil355da1e2009-10-06 11:31:08 -07001274 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1275 struct inode *in = NULL;
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001276 struct ceph_vino tvino, dvino;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001277 struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
Sage Weil355da1e2009-10-06 11:31:08 -07001278 int err = 0;
1279
1280 dout("fill_trace %p is_dentry %d is_target %d\n", req,
1281 rinfo->head->is_dentry, rinfo->head->is_target);
1282
Sage Weil355da1e2009-10-06 11:31:08 -07001283 if (!rinfo->head->is_target && !rinfo->head->is_dentry) {
1284 dout("fill_trace reply is empty!\n");
Jeff Layton3dd69aa2017-01-31 10:28:26 -05001285 if (rinfo->head->result == 0 && req->r_parent)
Sage Weil167c9e32010-05-14 10:02:57 -07001286 ceph_invalidate_dir_request(req);
Sage Weil355da1e2009-10-06 11:31:08 -07001287 return 0;
1288 }
1289
1290 if (rinfo->head->is_dentry) {
Jeff Layton3dd69aa2017-01-31 10:28:26 -05001291 struct inode *dir = req->r_parent;
Sage Weil5b1daec2010-01-25 11:33:08 -08001292
Sage Weil6c5e50f2012-08-21 15:55:25 -07001293 if (dir) {
Jeff Layton966c7162019-12-05 09:09:25 -05001294 err = ceph_fill_inode(dir, NULL, &rinfo->diri,
1295 rinfo->dirfrag, session, -1,
1296 &req->r_caps_reservation);
Sage Weil6c5e50f2012-08-21 15:55:25 -07001297 if (err < 0)
Yan, Zheng19913b42014-03-06 16:40:32 +08001298 goto done;
Sage Weil6c5e50f2012-08-21 15:55:25 -07001299 } else {
1300 WARN_ON_ONCE(1);
1301 }
Yan, Zheng19913b42014-03-06 16:40:32 +08001302
Yan, Zheng74c9e6b2018-09-28 11:34:42 +08001303 if (dir && req->r_op == CEPH_MDS_OP_LOOKUPNAME &&
1304 test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
1305 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) {
Yan, Zheng19913b42014-03-06 16:40:32 +08001306 struct qstr dname;
1307 struct dentry *dn, *parent;
1308
1309 BUG_ON(!rinfo->head->is_target);
1310 BUG_ON(req->r_dentry);
1311
1312 parent = d_find_any_alias(dir);
1313 BUG_ON(!parent);
1314
1315 dname.name = rinfo->dname;
1316 dname.len = rinfo->dname_len;
Linus Torvalds8387ff22016-06-10 07:51:30 -07001317 dname.hash = full_name_hash(parent, dname.name, dname.len);
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001318 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
1319 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
Yan, Zheng19913b42014-03-06 16:40:32 +08001320retry_lookup:
1321 dn = d_lookup(parent, &dname);
1322 dout("d_lookup on parent=%p name=%.*s got %p\n",
1323 parent, dname.len, dname.name, dn);
1324
1325 if (!dn) {
1326 dn = d_alloc(parent, &dname);
1327 dout("d_alloc %p '%.*s' = %p\n", parent,
1328 dname.len, dname.name, dn);
Markus Elfringd37b1d92017-08-20 20:22:02 +02001329 if (!dn) {
Yan, Zheng19913b42014-03-06 16:40:32 +08001330 dput(parent);
1331 err = -ENOMEM;
1332 goto done;
1333 }
Al Viroad5cb122016-10-28 22:05:13 -04001334 err = 0;
David Howells2b0143b2015-03-17 22:25:59 +00001335 } else if (d_really_is_positive(dn) &&
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001336 (ceph_ino(d_inode(dn)) != tvino.ino ||
1337 ceph_snap(d_inode(dn)) != tvino.snap)) {
Yan, Zheng19913b42014-03-06 16:40:32 +08001338 dout(" dn %p points to wrong inode %p\n",
David Howells2b0143b2015-03-17 22:25:59 +00001339 dn, d_inode(dn));
Yan, Zheng933ad2c92017-10-10 17:06:25 +08001340 ceph_dir_clear_ordered(dir);
Yan, Zheng19913b42014-03-06 16:40:32 +08001341 d_delete(dn);
1342 dput(dn);
1343 goto retry_lookup;
1344 }
1345
1346 req->r_dentry = dn;
1347 dput(parent);
1348 }
Sage Weil5b1daec2010-01-25 11:33:08 -08001349 }
1350
Yan, Zheng86b58d12013-12-05 12:38:59 +08001351 if (rinfo->head->is_target) {
Jeff Laytonbca9fc12020-11-12 10:03:38 -05001352 /* Should be filled in by handle_reply */
1353 BUG_ON(!req->r_target_inode);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001354
Jeff Laytonbca9fc12020-11-12 10:03:38 -05001355 in = req->r_target_inode;
Jeff Layton966c7162019-12-05 09:09:25 -05001356 err = ceph_fill_inode(in, req->r_locked_page, &rinfo->targeti,
1357 NULL, session,
Jeff Laytonbc2de10d2017-02-01 13:49:09 -05001358 (!test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
Jeff Layton3bb48b42019-12-02 13:47:57 -05001359 !test_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags) &&
Jeff Layton57c21992019-12-04 15:28:17 -05001360 rinfo->head->result == 0) ? req->r_fmode : -1,
Yan, Zheng86b58d12013-12-05 12:38:59 +08001361 &req->r_caps_reservation);
1362 if (err < 0) {
Jeff Layton966c7162019-12-05 09:09:25 -05001363 pr_err("ceph_fill_inode badness %p %llx.%llx\n",
Yan, Zheng86b58d12013-12-05 12:38:59 +08001364 in, ceph_vinop(in));
Jeff Laytonbca9fc12020-11-12 10:03:38 -05001365 req->r_target_inode = NULL;
Jeff Layton893e4562019-12-11 15:21:24 -05001366 if (in->i_state & I_NEW)
1367 discard_new_inode(in);
Jeff Layton68cbb802020-11-12 09:37:59 -05001368 else
1369 iput(in);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001370 goto done;
1371 }
Jeff Layton893e4562019-12-11 15:21:24 -05001372 if (in->i_state & I_NEW)
1373 unlock_new_inode(in);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001374 }
1375
Sage Weil9358c6d2010-03-30 13:54:41 -07001376 /*
1377 * ignore null lease/binding on snapdir ENOENT, or else we
1378 * will have trouble splicing in the virtual snapdir later
1379 */
Jeff Layton3dd69aa2017-01-31 10:28:26 -05001380 if (rinfo->head->is_dentry &&
1381 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
1382 test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
Sage Weil9358c6d2010-03-30 13:54:41 -07001383 (rinfo->head->is_target || strncmp(req->r_dentry->d_name.name,
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001384 fsc->mount_options->snapdir_name,
Sage Weil9358c6d2010-03-30 13:54:41 -07001385 req->r_dentry->d_name.len))) {
Sage Weil355da1e2009-10-06 11:31:08 -07001386 /*
1387 * lookup link rename : null -> possibly existing inode
1388 * mknod symlink mkdir : null -> new inode
1389 * unlink : linked -> null
1390 */
Jeff Layton3dd69aa2017-01-31 10:28:26 -05001391 struct inode *dir = req->r_parent;
Sage Weil355da1e2009-10-06 11:31:08 -07001392 struct dentry *dn = req->r_dentry;
1393 bool have_dir_cap, have_lease;
1394
1395 BUG_ON(!dn);
1396 BUG_ON(!dir);
David Howells2b0143b2015-03-17 22:25:59 +00001397 BUG_ON(d_inode(dn->d_parent) != dir);
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001398
1399 dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
1400 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);
1401
1402 BUG_ON(ceph_ino(dir) != dvino.ino);
1403 BUG_ON(ceph_snap(dir) != dvino.snap);
Sage Weil355da1e2009-10-06 11:31:08 -07001404
Sage Weil355da1e2009-10-06 11:31:08 -07001405 /* do we have a lease on the whole dir? */
1406 have_dir_cap =
1407 (le32_to_cpu(rinfo->diri.in->cap.caps) &
1408 CEPH_CAP_FILE_SHARED);
1409
1410 /* do we have a dn lease? */
1411 have_lease = have_dir_cap ||
Sage Weil2f90b852011-07-26 11:28:25 -07001412 le32_to_cpu(rinfo->dlease->duration_ms);
Sage Weil355da1e2009-10-06 11:31:08 -07001413 if (!have_lease)
1414 dout("fill_trace no dentry lease or dir cap\n");
1415
1416 /* rename? */
1417 if (req->r_old_dentry && req->r_op == CEPH_MDS_OP_RENAME) {
Yan, Zheng0a8a70f2014-04-14 13:13:02 +08001418 struct inode *olddir = req->r_old_dentry_dir;
1419 BUG_ON(!olddir);
1420
Al Viroa4555892014-10-21 20:11:25 -04001421 dout(" src %p '%pd' dst %p '%pd'\n",
Sage Weil355da1e2009-10-06 11:31:08 -07001422 req->r_old_dentry,
Al Viroa4555892014-10-21 20:11:25 -04001423 req->r_old_dentry,
1424 dn, dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001425 dout("fill_trace doing d_move %p -> %p\n",
1426 req->r_old_dentry, dn);
Sage Weilc10f5e12010-04-16 12:56:11 -07001427
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001428 /* d_move screws up sibling dentries' offsets */
1429 ceph_dir_clear_ordered(dir);
1430 ceph_dir_clear_ordered(olddir);
1431
Sage Weil355da1e2009-10-06 11:31:08 -07001432 d_move(req->r_old_dentry, dn);
Al Viroa4555892014-10-21 20:11:25 -04001433 dout(" src %p '%pd' dst %p '%pd'\n",
Sage Weil355da1e2009-10-06 11:31:08 -07001434 req->r_old_dentry,
Al Viroa4555892014-10-21 20:11:25 -04001435 req->r_old_dentry,
1436 dn, dn);
Sage Weil81a6cf22010-05-14 09:35:38 -07001437
Sage Weilc4a29f22009-12-21 11:42:18 -08001438 /* ensure target dentry is invalidated, despite
1439 rehashing bug in vfs_rename_dir */
Sage Weil81a6cf22010-05-14 09:35:38 -07001440 ceph_invalidate_dentry_lease(dn);
1441
Milosz Tanski99ccbd22013-08-21 17:29:54 -04001442 dout("dn %p gets new offset %lld\n", req->r_old_dentry,
Sage Weil1cd39352010-05-03 22:08:02 -07001443 ceph_dentry(req->r_old_dentry)->offset);
Sage Weil81a6cf22010-05-14 09:35:38 -07001444
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001445 /* swap r_dentry and r_old_dentry in case that
1446 * splice_dentry() gets called later. This is safe
1447 * because no other place will use them */
1448 req->r_dentry = req->r_old_dentry;
1449 req->r_old_dentry = dn;
1450 dn = req->r_dentry;
Sage Weil355da1e2009-10-06 11:31:08 -07001451 }
1452
1453 /* null dentry? */
1454 if (!rinfo->head->is_target) {
1455 dout("fill_trace null dentry\n");
David Howells2b0143b2015-03-17 22:25:59 +00001456 if (d_really_is_positive(dn)) {
Sage Weil355da1e2009-10-06 11:31:08 -07001457 dout("d_delete %p\n", dn);
Yan, Zheng5495c2d2017-11-27 11:23:48 +08001458 ceph_dir_clear_ordered(dir);
Sage Weil355da1e2009-10-06 11:31:08 -07001459 d_delete(dn);
Jeff Layton80d025f2017-01-26 16:14:18 -05001460 } else if (have_lease) {
1461 if (d_unhashed(dn))
Al Virof8b31712016-03-07 15:11:43 -05001462 d_add(dn, NULL);
Yan, Zheng543212b2019-05-22 21:49:44 +08001463 update_dentry_lease(dir, dn,
1464 rinfo->dlease, session,
1465 req->r_request_started);
Sage Weil355da1e2009-10-06 11:31:08 -07001466 }
1467 goto done;
1468 }
1469
1470 /* attach proper inode */
David Howells2b0143b2015-03-17 22:25:59 +00001471 if (d_really_is_negative(dn)) {
Yan, Zheng70db4f32014-10-21 18:09:56 -07001472 ceph_dir_clear_ordered(dir);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001473 ihold(in);
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001474 err = splice_dentry(&req->r_dentry, in);
1475 if (err < 0)
Sage Weil355da1e2009-10-06 11:31:08 -07001476 goto done;
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001477 dn = req->r_dentry; /* may have spliced */
David Howells2b0143b2015-03-17 22:25:59 +00001478 } else if (d_really_is_positive(dn) && d_inode(dn) != in) {
Sage Weil355da1e2009-10-06 11:31:08 -07001479 dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
David Howells2b0143b2015-03-17 22:25:59 +00001480 dn, d_inode(dn), ceph_vinop(d_inode(dn)),
Yan, Zheng86b58d12013-12-05 12:38:59 +08001481 ceph_vinop(in));
Yan, Zheng200fd272016-03-17 14:41:59 +08001482 d_invalidate(dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001483 have_lease = false;
Sage Weil355da1e2009-10-06 11:31:08 -07001484 }
1485
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001486 if (have_lease) {
Yan, Zheng543212b2019-05-22 21:49:44 +08001487 update_dentry_lease(dir, dn,
1488 rinfo->dlease, session,
1489 req->r_request_started);
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001490 }
Sage Weil355da1e2009-10-06 11:31:08 -07001491 dout(" final dn %p\n", dn);
Jeff Laytonbc2de10d2017-02-01 13:49:09 -05001492 } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
1493 req->r_op == CEPH_MDS_OP_MKSNAP) &&
Al Viro1f085292019-10-29 13:53:29 +00001494 test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
Jeff Laytonbc2de10d2017-02-01 13:49:09 -05001495 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) {
Jeff Layton3dd69aa2017-01-31 10:28:26 -05001496 struct inode *dir = req->r_parent;
Sage Weil355da1e2009-10-06 11:31:08 -07001497
1498 /* fill out a snapdir LOOKUPSNAP dentry */
Yan, Zheng0a8a70f2014-04-14 13:13:02 +08001499 BUG_ON(!dir);
1500 BUG_ON(ceph_snap(dir) != CEPH_SNAPDIR);
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001501 BUG_ON(!req->r_dentry);
1502 dout(" linking snapped dir %p to dn %p\n", in, req->r_dentry);
Yan, Zheng70db4f32014-10-21 18:09:56 -07001503 ceph_dir_clear_ordered(dir);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001504 ihold(in);
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001505 err = splice_dentry(&req->r_dentry, in);
1506 if (err < 0)
Sage Weil355da1e2009-10-06 11:31:08 -07001507 goto done;
Yan, Zheng543212b2019-05-22 21:49:44 +08001508 } else if (rinfo->head->is_dentry && req->r_dentry) {
1509 /* parent inode is not locked, be carefull */
Jeff Laytoncdde7c42017-01-27 13:07:10 -05001510 struct ceph_vino *ptvino = NULL;
Yan, Zheng543212b2019-05-22 21:49:44 +08001511 dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
1512 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);
1513 if (rinfo->head->is_target) {
1514 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
1515 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
1516 ptvino = &tvino;
Jeff Laytoncdde7c42017-01-27 13:07:10 -05001517 }
Yan, Zheng543212b2019-05-22 21:49:44 +08001518 update_dentry_lease_careful(req->r_dentry, rinfo->dlease,
1519 session, req->r_request_started,
1520 rinfo->dname, rinfo->dname_len,
1521 &dvino, ptvino);
Sage Weil355da1e2009-10-06 11:31:08 -07001522 }
Sage Weil355da1e2009-10-06 11:31:08 -07001523done:
1524 dout("fill_trace done err=%d\n", err);
1525 return err;
1526}
1527
1528/*
1529 * Prepopulate our cache with readdir results, leases, etc.
1530 */
Sage Weil79f9f992013-01-29 02:55:31 -05001531static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req,
1532 struct ceph_mds_session *session)
1533{
1534 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1535 int i, err = 0;
1536
1537 for (i = 0; i < rinfo->dir_nr; i++) {
Yan, Zheng2a5beea2016-04-28 09:37:39 +08001538 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
Sage Weil79f9f992013-01-29 02:55:31 -05001539 struct ceph_vino vino;
1540 struct inode *in;
1541 int rc;
1542
Yan, Zheng2a5beea2016-04-28 09:37:39 +08001543 vino.ino = le64_to_cpu(rde->inode.in->ino);
1544 vino.snap = le64_to_cpu(rde->inode.in->snapid);
Sage Weil79f9f992013-01-29 02:55:31 -05001545
1546 in = ceph_get_inode(req->r_dentry->d_sb, vino);
1547 if (IS_ERR(in)) {
1548 err = PTR_ERR(in);
1549 dout("new_inode badness got %d\n", err);
1550 continue;
1551 }
Jeff Layton966c7162019-12-05 09:09:25 -05001552 rc = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
1553 -1, &req->r_caps_reservation);
Sage Weil79f9f992013-01-29 02:55:31 -05001554 if (rc < 0) {
Jeff Layton966c7162019-12-05 09:09:25 -05001555 pr_err("ceph_fill_inode badness on %p got %d\n",
1556 in, rc);
Sage Weil79f9f992013-01-29 02:55:31 -05001557 err = rc;
Jeff Layton893e4562019-12-11 15:21:24 -05001558 if (in->i_state & I_NEW) {
1559 ihold(in);
1560 discard_new_inode(in);
1561 }
1562 } else if (in->i_state & I_NEW) {
1563 unlock_new_inode(in);
Sage Weil79f9f992013-01-29 02:55:31 -05001564 }
Jeff Layton893e4562019-12-11 15:21:24 -05001565
Jeff Layton23c2c762021-06-04 12:03:09 -04001566 iput(in);
Sage Weil79f9f992013-01-29 02:55:31 -05001567 }
1568
1569 return err;
1570}
1571
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001572void ceph_readdir_cache_release(struct ceph_readdir_cache_control *ctl)
1573{
1574 if (ctl->page) {
1575 kunmap(ctl->page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001576 put_page(ctl->page);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001577 ctl->page = NULL;
1578 }
1579}
1580
1581static int fill_readdir_cache(struct inode *dir, struct dentry *dn,
1582 struct ceph_readdir_cache_control *ctl,
1583 struct ceph_mds_request *req)
1584{
1585 struct ceph_inode_info *ci = ceph_inode(dir);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001586 unsigned nsize = PAGE_SIZE / sizeof(struct dentry*);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001587 unsigned idx = ctl->index % nsize;
1588 pgoff_t pgoff = ctl->index / nsize;
1589
1590 if (!ctl->page || pgoff != page_index(ctl->page)) {
1591 ceph_readdir_cache_release(ctl);
Yan, Zhengaf5e5eb2016-02-26 16:27:13 +08001592 if (idx == 0)
1593 ctl->page = grab_cache_page(&dir->i_data, pgoff);
1594 else
1595 ctl->page = find_lock_page(&dir->i_data, pgoff);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001596 if (!ctl->page) {
1597 ctl->index = -1;
Yan, Zhengaf5e5eb2016-02-26 16:27:13 +08001598 return idx == 0 ? -ENOMEM : 0;
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001599 }
1600 /* reading/filling the cache are serialized by
1601 * i_mutex, no need to use page lock */
1602 unlock_page(ctl->page);
1603 ctl->dentries = kmap(ctl->page);
Yan, Zhengaf5e5eb2016-02-26 16:27:13 +08001604 if (idx == 0)
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001605 memset(ctl->dentries, 0, PAGE_SIZE);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001606 }
1607
1608 if (req->r_dir_release_cnt == atomic64_read(&ci->i_release_count) &&
1609 req->r_dir_ordered_cnt == atomic64_read(&ci->i_ordered_count)) {
1610 dout("readdir cache dn %p idx %d\n", dn, ctl->index);
1611 ctl->dentries[idx] = dn;
1612 ctl->index++;
1613 } else {
1614 dout("disable readdir cache\n");
1615 ctl->index = -1;
1616 }
1617 return 0;
1618}
1619
Sage Weil355da1e2009-10-06 11:31:08 -07001620int ceph_readdir_prepopulate(struct ceph_mds_request *req,
1621 struct ceph_mds_session *session)
1622{
1623 struct dentry *parent = req->r_dentry;
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001624 struct ceph_inode_info *ci = ceph_inode(d_inode(parent));
Sage Weil355da1e2009-10-06 11:31:08 -07001625 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1626 struct qstr dname;
1627 struct dentry *dn;
1628 struct inode *in;
Yan, Zheng315f2402016-03-07 10:34:50 +08001629 int err = 0, skipped = 0, ret, i;
Jeff Layton0f51a982020-12-09 10:27:01 -05001630 u32 frag = le32_to_cpu(req->r_args.readdir.frag);
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001631 u32 last_hash = 0;
1632 u32 fpos_offset;
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001633 struct ceph_readdir_cache_control cache_ctl = {};
1634
Jeff Laytonbc2de10d2017-02-01 13:49:09 -05001635 if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags))
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001636 return readdir_prepopulate_inodes_only(req, session);
Yan, Zheng81c6aea2013-09-18 09:44:13 +08001637
Yan, Zheng79162542017-04-05 12:54:05 -04001638 if (rinfo->hash_order) {
1639 if (req->r_path2) {
1640 last_hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash,
1641 req->r_path2,
1642 strlen(req->r_path2));
1643 last_hash = ceph_frag_value(last_hash);
1644 } else if (rinfo->offset_hash) {
1645 /* mds understands offset_hash */
1646 WARN_ON_ONCE(req->r_readdir_offset != 2);
Jeff Layton0f51a982020-12-09 10:27:01 -05001647 last_hash = le32_to_cpu(req->r_args.readdir.offset_hash);
Yan, Zheng79162542017-04-05 12:54:05 -04001648 }
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001649 }
1650
Yan, Zheng81c6aea2013-09-18 09:44:13 +08001651 if (rinfo->dir_dir &&
1652 le32_to_cpu(rinfo->dir_dir->frag) != frag) {
1653 dout("readdir_prepopulate got new frag %x -> %x\n",
1654 frag, le32_to_cpu(rinfo->dir_dir->frag));
1655 frag = le32_to_cpu(rinfo->dir_dir->frag);
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001656 if (!rinfo->hash_order)
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001657 req->r_readdir_offset = 2;
Yan, Zheng81c6aea2013-09-18 09:44:13 +08001658 }
Sage Weil355da1e2009-10-06 11:31:08 -07001659
1660 if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
Sage Weil355da1e2009-10-06 11:31:08 -07001661 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n",
1662 rinfo->dir_nr, parent);
1663 } else {
1664 dout("readdir_prepopulate %d items under dn %p\n",
1665 rinfo->dir_nr, parent);
1666 if (rinfo->dir_dir)
David Howells2b0143b2015-03-17 22:25:59 +00001667 ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
Sage Weil355da1e2009-10-06 11:31:08 -07001668
Yan, Zheng8d45b912017-07-26 12:07:51 +08001669 if (ceph_frag_is_leftmost(frag) &&
1670 req->r_readdir_offset == 2 &&
1671 !(rinfo->hash_order && last_hash)) {
1672 /* note dir version at start of readdir so we can
1673 * tell if any dentries get dropped */
1674 req->r_dir_release_cnt =
1675 atomic64_read(&ci->i_release_count);
1676 req->r_dir_ordered_cnt =
1677 atomic64_read(&ci->i_ordered_count);
1678 req->r_readdir_cache_idx = 0;
1679 }
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001680 }
1681
1682 cache_ctl.index = req->r_readdir_cache_idx;
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001683 fpos_offset = req->r_readdir_offset;
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001684
Yan, Zheng86b58d12013-12-05 12:38:59 +08001685 /* FIXME: release caps/leases if error occurs */
Sage Weil355da1e2009-10-06 11:31:08 -07001686 for (i = 0; i < rinfo->dir_nr; i++) {
Yan, Zheng2a5beea2016-04-28 09:37:39 +08001687 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
Yan, Zheng543212b2019-05-22 21:49:44 +08001688 struct ceph_vino tvino;
Sage Weil355da1e2009-10-06 11:31:08 -07001689
Yan, Zheng2a5beea2016-04-28 09:37:39 +08001690 dname.name = rde->name;
1691 dname.len = rde->name_len;
Linus Torvalds8387ff22016-06-10 07:51:30 -07001692 dname.hash = full_name_hash(parent, dname.name, dname.len);
Sage Weil355da1e2009-10-06 11:31:08 -07001693
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001694 tvino.ino = le64_to_cpu(rde->inode.in->ino);
1695 tvino.snap = le64_to_cpu(rde->inode.in->snapid);
Sage Weil355da1e2009-10-06 11:31:08 -07001696
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001697 if (rinfo->hash_order) {
1698 u32 hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash,
1699 rde->name, rde->name_len);
1700 hash = ceph_frag_value(hash);
1701 if (hash != last_hash)
1702 fpos_offset = 2;
1703 last_hash = hash;
1704 rde->offset = ceph_make_fpos(hash, fpos_offset++, true);
1705 } else {
1706 rde->offset = ceph_make_fpos(frag, fpos_offset++, false);
1707 }
Sage Weil355da1e2009-10-06 11:31:08 -07001708
1709retry_lookup:
1710 dn = d_lookup(parent, &dname);
1711 dout("d_lookup on parent=%p name=%.*s got %p\n",
1712 parent, dname.len, dname.name, dn);
1713
1714 if (!dn) {
1715 dn = d_alloc(parent, &dname);
1716 dout("d_alloc %p '%.*s' = %p\n", parent,
1717 dname.len, dname.name, dn);
Markus Elfringd37b1d92017-08-20 20:22:02 +02001718 if (!dn) {
Sage Weil355da1e2009-10-06 11:31:08 -07001719 dout("d_alloc badness\n");
1720 err = -ENOMEM;
1721 goto out;
1722 }
David Howells2b0143b2015-03-17 22:25:59 +00001723 } else if (d_really_is_positive(dn) &&
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001724 (ceph_ino(d_inode(dn)) != tvino.ino ||
1725 ceph_snap(d_inode(dn)) != tvino.snap)) {
Yan, Zheng5495c2d2017-11-27 11:23:48 +08001726 struct ceph_dentry_info *di = ceph_dentry(dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001727 dout(" dn %p points to wrong inode %p\n",
David Howells2b0143b2015-03-17 22:25:59 +00001728 dn, d_inode(dn));
Yan, Zheng5495c2d2017-11-27 11:23:48 +08001729
1730 spin_lock(&dn->d_lock);
1731 if (di->offset > 0 &&
1732 di->lease_shared_gen ==
1733 atomic_read(&ci->i_shared_gen)) {
1734 __ceph_dir_clear_ordered(ci);
1735 di->offset = 0;
1736 }
1737 spin_unlock(&dn->d_lock);
1738
Sage Weil355da1e2009-10-06 11:31:08 -07001739 d_delete(dn);
1740 dput(dn);
1741 goto retry_lookup;
Sage Weil355da1e2009-10-06 11:31:08 -07001742 }
1743
Sage Weil355da1e2009-10-06 11:31:08 -07001744 /* inode */
David Howells2b0143b2015-03-17 22:25:59 +00001745 if (d_really_is_positive(dn)) {
1746 in = d_inode(dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001747 } else {
Jeff Laytonf5d55f02017-01-27 09:13:57 -05001748 in = ceph_get_inode(parent->d_sb, tvino);
Dan Carpenterac1f12e2010-08-25 09:11:35 +02001749 if (IS_ERR(in)) {
Sage Weil355da1e2009-10-06 11:31:08 -07001750 dout("new_inode badness\n");
Al Viro2744c172012-09-26 21:41:05 -04001751 d_drop(dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001752 dput(dn);
Dan Carpenterac1f12e2010-08-25 09:11:35 +02001753 err = PTR_ERR(in);
Sage Weil355da1e2009-10-06 11:31:08 -07001754 goto out;
1755 }
Sage Weil355da1e2009-10-06 11:31:08 -07001756 }
1757
Jeff Layton966c7162019-12-05 09:09:25 -05001758 ret = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
1759 -1, &req->r_caps_reservation);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001760 if (ret < 0) {
Jeff Layton966c7162019-12-05 09:09:25 -05001761 pr_err("ceph_fill_inode badness on %p\n", in);
Yan, Zheng3e1d0452019-05-18 20:39:55 +08001762 if (d_really_is_negative(dn)) {
Jeff Layton893e4562019-12-11 15:21:24 -05001763 if (in->i_state & I_NEW) {
1764 ihold(in);
1765 discard_new_inode(in);
1766 }
Jeff Layton23c2c762021-06-04 12:03:09 -04001767 iput(in);
Yan, Zheng3e1d0452019-05-18 20:39:55 +08001768 }
Yan, Zheng86b58d12013-12-05 12:38:59 +08001769 d_drop(dn);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001770 err = ret;
Sage Weild69ed052010-06-21 10:38:14 -07001771 goto next_item;
Sage Weil355da1e2009-10-06 11:31:08 -07001772 }
Jeff Layton893e4562019-12-11 15:21:24 -05001773 if (in->i_state & I_NEW)
1774 unlock_new_inode(in);
Yan, Zheng86b58d12013-12-05 12:38:59 +08001775
David Howells2b0143b2015-03-17 22:25:59 +00001776 if (d_really_is_negative(dn)) {
Yan, Zheng315f2402016-03-07 10:34:50 +08001777 if (ceph_security_xattr_deadlock(in)) {
1778 dout(" skip splicing dn %p to inode %p"
1779 " (security xattr deadlock)\n", dn, in);
Jeff Layton23c2c762021-06-04 12:03:09 -04001780 iput(in);
Yan, Zheng315f2402016-03-07 10:34:50 +08001781 skipped++;
1782 goto next_item;
1783 }
1784
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001785 err = splice_dentry(&dn, in);
1786 if (err < 0)
Yan, Zheng86b58d12013-12-05 12:38:59 +08001787 goto next_item;
Yan, Zheng86b58d12013-12-05 12:38:59 +08001788 }
1789
Yan, Zhengf3c4ebe2016-04-29 11:27:30 +08001790 ceph_dentry(dn)->offset = rde->offset;
Yan, Zheng86b58d12013-12-05 12:38:59 +08001791
Yan, Zheng543212b2019-05-22 21:49:44 +08001792 update_dentry_lease(d_inode(parent), dn,
1793 rde->lease, req->r_session,
1794 req->r_request_started);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001795
Yan, Zheng315f2402016-03-07 10:34:50 +08001796 if (err == 0 && skipped == 0 && cache_ctl.index >= 0) {
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001797 ret = fill_readdir_cache(d_inode(parent), dn,
1798 &cache_ctl, req);
1799 if (ret < 0)
1800 err = ret;
1801 }
Sage Weild69ed052010-06-21 10:38:14 -07001802next_item:
Yan, Zheng2bf996a2018-10-25 17:30:30 +08001803 dput(dn);
Sage Weil355da1e2009-10-06 11:31:08 -07001804 }
Sage Weil355da1e2009-10-06 11:31:08 -07001805out:
Yan, Zheng315f2402016-03-07 10:34:50 +08001806 if (err == 0 && skipped == 0) {
Jeff Laytonbc2de10d2017-02-01 13:49:09 -05001807 set_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags);
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001808 req->r_readdir_cache_idx = cache_ctl.index;
1809 }
1810 ceph_readdir_cache_release(&cache_ctl);
Sage Weil355da1e2009-10-06 11:31:08 -07001811 dout("readdir_prepopulate done\n");
1812 return err;
1813}
1814
Yan, Zhengefb0ca72017-05-22 12:03:32 +08001815bool ceph_inode_set_size(struct inode *inode, loff_t size)
Sage Weil355da1e2009-10-06 11:31:08 -07001816{
1817 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhengefb0ca72017-05-22 12:03:32 +08001818 bool ret;
Sage Weil355da1e2009-10-06 11:31:08 -07001819
Sage Weilbe655592011-11-30 09:47:09 -08001820 spin_lock(&ci->i_ceph_lock);
Jeff Layton2d6795f2021-04-09 15:58:35 -04001821 dout("set_size %p %llu -> %llu\n", inode, i_size_read(inode), size);
Yan, Zheng99c88e62015-12-30 11:32:46 +08001822 i_size_write(inode, size);
Jeff Layton400e1282021-12-07 08:44:50 -05001823 ceph_fscache_update(inode);
Yan, Zheng224a75422016-05-05 16:40:17 +08001824 inode->i_blocks = calc_inode_blocks(size);
Sage Weil355da1e2009-10-06 11:31:08 -07001825
Yan, Zhengefb0ca72017-05-22 12:03:32 +08001826 ret = __ceph_should_report_size(ci);
Sage Weil355da1e2009-10-06 11:31:08 -07001827
Sage Weilbe655592011-11-30 09:47:09 -08001828 spin_unlock(&ci->i_ceph_lock);
Jeff Layton400e1282021-12-07 08:44:50 -05001829
Sage Weil355da1e2009-10-06 11:31:08 -07001830 return ret;
1831}
1832
Jeff Layton64f28c62020-10-09 14:24:34 -04001833void ceph_queue_inode_work(struct inode *inode, int work_bit)
Sage Weil3c6f6b72010-02-09 15:24:44 -08001834{
Jeff Layton64f28c62020-10-09 14:24:34 -04001835 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
Yan, Zheng1cf89a82019-05-18 11:18:44 +08001836 struct ceph_inode_info *ci = ceph_inode(inode);
Jeff Layton64f28c62020-10-09 14:24:34 -04001837 set_bit(work_bit, &ci->i_work_mask);
Yan, Zheng1cf89a82019-05-18 11:18:44 +08001838
Sage Weil15a20152011-11-05 22:06:31 -07001839 ihold(inode);
Jeff Layton64f28c62020-10-09 14:24:34 -04001840 if (queue_work(fsc->inode_wq, &ci->i_work)) {
1841 dout("queue_inode_work %p, mask=%lx\n", inode, ci->i_work_mask);
Sage Weil3c6f6b72010-02-09 15:24:44 -08001842 } else {
Jeff Layton64f28c62020-10-09 14:24:34 -04001843 dout("queue_inode_work %p already queued, mask=%lx\n",
Yan, Zheng1cf89a82019-05-18 11:18:44 +08001844 inode, ci->i_work_mask);
1845 iput(inode);
1846 }
1847}
1848
1849static void ceph_do_invalidate_pages(struct inode *inode)
1850{
1851 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weil355da1e2009-10-06 11:31:08 -07001852 u32 orig_gen;
1853 int check = 0;
1854
Jeff Layton400e1282021-12-07 08:44:50 -05001855 ceph_fscache_invalidate(inode, false);
1856
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001857 mutex_lock(&ci->i_truncate_mutex);
Yan, Zheng6c93df52016-04-15 13:56:12 +08001858
Jeff Layton5d6451b2021-08-31 13:39:13 -04001859 if (ceph_inode_is_shutdown(inode)) {
Jeff Layton6407fbb2021-09-02 09:12:35 -04001860 pr_warn_ratelimited("%s: inode %llx.%llx is shut down\n",
1861 __func__, ceph_vinop(inode));
Yan, Zheng6c93df52016-04-15 13:56:12 +08001862 mapping_set_error(inode->i_mapping, -EIO);
1863 truncate_pagecache(inode, 0);
1864 mutex_unlock(&ci->i_truncate_mutex);
1865 goto out;
1866 }
1867
Sage Weilbe655592011-11-30 09:47:09 -08001868 spin_lock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07001869 dout("invalidate_pages %p gen %d revoking %d\n", inode,
1870 ci->i_rdcache_gen, ci->i_rdcache_revoking);
Sage Weilcd045cb2010-11-04 11:05:05 -07001871 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
Yan, Zheng9563f882013-11-22 13:50:45 +08001872 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
1873 check = 1;
Sage Weilbe655592011-11-30 09:47:09 -08001874 spin_unlock(&ci->i_ceph_lock);
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001875 mutex_unlock(&ci->i_truncate_mutex);
Sage Weil355da1e2009-10-06 11:31:08 -07001876 goto out;
1877 }
1878 orig_gen = ci->i_rdcache_gen;
Sage Weilbe655592011-11-30 09:47:09 -08001879 spin_unlock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07001880
Jeff Layton400e1282021-12-07 08:44:50 -05001881 ceph_fscache_invalidate(inode, false);
Yan, Zheng9abd4db2016-05-18 20:58:26 +08001882 if (invalidate_inode_pages2(inode->i_mapping) < 0) {
Jeff Layton6407fbb2021-09-02 09:12:35 -04001883 pr_err("invalidate_inode_pages2 %llx.%llx failed\n",
1884 ceph_vinop(inode));
Yan, Zheng9abd4db2016-05-18 20:58:26 +08001885 }
Sage Weil355da1e2009-10-06 11:31:08 -07001886
Sage Weilbe655592011-11-30 09:47:09 -08001887 spin_lock(&ci->i_ceph_lock);
Sage Weilcd045cb2010-11-04 11:05:05 -07001888 if (orig_gen == ci->i_rdcache_gen &&
1889 orig_gen == ci->i_rdcache_revoking) {
Sage Weil355da1e2009-10-06 11:31:08 -07001890 dout("invalidate_pages %p gen %d successful\n", inode,
1891 ci->i_rdcache_gen);
Sage Weilcd045cb2010-11-04 11:05:05 -07001892 ci->i_rdcache_revoking--;
Sage Weil355da1e2009-10-06 11:31:08 -07001893 check = 1;
1894 } else {
Sage Weilcd045cb2010-11-04 11:05:05 -07001895 dout("invalidate_pages %p gen %d raced, now %d revoking %d\n",
1896 inode, orig_gen, ci->i_rdcache_gen,
1897 ci->i_rdcache_revoking);
Yan, Zheng9563f882013-11-22 13:50:45 +08001898 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
1899 check = 1;
Sage Weil355da1e2009-10-06 11:31:08 -07001900 }
Sage Weilbe655592011-11-30 09:47:09 -08001901 spin_unlock(&ci->i_ceph_lock);
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001902 mutex_unlock(&ci->i_truncate_mutex);
Yan, Zheng9563f882013-11-22 13:50:45 +08001903out:
Sage Weil355da1e2009-10-06 11:31:08 -07001904 if (check)
1905 ceph_check_caps(ci, 0, NULL);
Sage Weil3c6f6b72010-02-09 15:24:44 -08001906}
1907
1908/*
Sage Weil355da1e2009-10-06 11:31:08 -07001909 * Make sure any pending truncation is applied before doing anything
1910 * that may depend on it.
1911 */
Yan, Zhengb415bf42013-07-02 12:40:19 +08001912void __ceph_do_pending_vmtruncate(struct inode *inode)
Sage Weil355da1e2009-10-06 11:31:08 -07001913{
1914 struct ceph_inode_info *ci = ceph_inode(inode);
1915 u64 to;
Yan, Zhenga85f50b2012-11-19 10:49:08 +08001916 int wrbuffer_refs, finish = 0;
Sage Weil355da1e2009-10-06 11:31:08 -07001917
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001918 mutex_lock(&ci->i_truncate_mutex);
Sage Weil355da1e2009-10-06 11:31:08 -07001919retry:
Sage Weilbe655592011-11-30 09:47:09 -08001920 spin_lock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07001921 if (ci->i_truncate_pending == 0) {
1922 dout("__do_pending_vmtruncate %p none pending\n", inode);
Sage Weilbe655592011-11-30 09:47:09 -08001923 spin_unlock(&ci->i_ceph_lock);
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001924 mutex_unlock(&ci->i_truncate_mutex);
Sage Weil355da1e2009-10-06 11:31:08 -07001925 return;
1926 }
1927
1928 /*
1929 * make sure any dirty snapped pages are flushed before we
1930 * possibly truncate them.. so write AND block!
1931 */
1932 if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) {
Yan, Zhengc8fd0d372017-08-28 15:41:28 +08001933 spin_unlock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07001934 dout("__do_pending_vmtruncate %p flushing snaps first\n",
1935 inode);
Sage Weil355da1e2009-10-06 11:31:08 -07001936 filemap_write_and_wait_range(&inode->i_data, 0,
1937 inode->i_sb->s_maxbytes);
1938 goto retry;
1939 }
1940
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001941 /* there should be no reader or writer */
1942 WARN_ON_ONCE(ci->i_rd_ref || ci->i_wr_ref);
1943
Sage Weil355da1e2009-10-06 11:31:08 -07001944 to = ci->i_truncate_size;
1945 wrbuffer_refs = ci->i_wrbuffer_ref;
1946 dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode,
1947 ci->i_truncate_pending, to);
Sage Weilbe655592011-11-30 09:47:09 -08001948 spin_unlock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07001949
Jeff Layton400e1282021-12-07 08:44:50 -05001950 ceph_fscache_resize(inode, to);
Yan, Zheng4e217b52014-06-08 05:08:56 +08001951 truncate_pagecache(inode, to);
Sage Weil355da1e2009-10-06 11:31:08 -07001952
Sage Weilbe655592011-11-30 09:47:09 -08001953 spin_lock(&ci->i_ceph_lock);
Yan, Zhenga85f50b2012-11-19 10:49:08 +08001954 if (to == ci->i_truncate_size) {
1955 ci->i_truncate_pending = 0;
1956 finish = 1;
1957 }
Sage Weilbe655592011-11-30 09:47:09 -08001958 spin_unlock(&ci->i_ceph_lock);
Yan, Zhenga85f50b2012-11-19 10:49:08 +08001959 if (!finish)
1960 goto retry;
Sage Weil355da1e2009-10-06 11:31:08 -07001961
Yan, Zhengb0d7c222013-08-12 21:42:15 -07001962 mutex_unlock(&ci->i_truncate_mutex);
1963
Sage Weil355da1e2009-10-06 11:31:08 -07001964 if (wrbuffer_refs == 0)
Yan, Zhengbf73c622020-03-05 20:21:04 +08001965 ceph_check_caps(ci, 0, NULL);
Yan, Zhenga85f50b2012-11-19 10:49:08 +08001966
1967 wake_up_all(&ci->i_cap_wq);
Sage Weil355da1e2009-10-06 11:31:08 -07001968}
1969
Yan, Zheng1cf89a82019-05-18 11:18:44 +08001970static void ceph_inode_work(struct work_struct *work)
1971{
1972 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info,
1973 i_work);
1974 struct inode *inode = &ci->vfs_inode;
1975
1976 if (test_and_clear_bit(CEPH_I_WORK_WRITEBACK, &ci->i_work_mask)) {
1977 dout("writeback %p\n", inode);
1978 filemap_fdatawrite(&inode->i_data);
1979 }
1980 if (test_and_clear_bit(CEPH_I_WORK_INVALIDATE_PAGES, &ci->i_work_mask))
1981 ceph_do_invalidate_pages(inode);
1982
1983 if (test_and_clear_bit(CEPH_I_WORK_VMTRUNCATE, &ci->i_work_mask))
1984 __ceph_do_pending_vmtruncate(inode);
1985
Jeff Laytona8810cd2020-12-10 14:39:26 -05001986 if (test_and_clear_bit(CEPH_I_WORK_CHECK_CAPS, &ci->i_work_mask))
1987 ceph_check_caps(ci, 0, NULL);
1988
1989 if (test_and_clear_bit(CEPH_I_WORK_FLUSH_SNAPS, &ci->i_work_mask))
1990 ceph_flush_snaps(ci, NULL);
1991
Yan, Zheng1cf89a82019-05-18 11:18:44 +08001992 iput(inode);
1993}
1994
Sage Weil355da1e2009-10-06 11:31:08 -07001995/*
1996 * symlinks
1997 */
Sage Weil355da1e2009-10-06 11:31:08 -07001998static const struct inode_operations ceph_symlink_iops = {
Al Viro6b255392015-11-17 10:20:54 -05001999 .get_link = simple_get_link,
Yan, Zheng0b932672013-04-07 16:28:49 +08002000 .setattr = ceph_setattr,
2001 .getattr = ceph_getattr,
Yan, Zheng0b932672013-04-07 16:28:49 +08002002 .listxattr = ceph_listxattr,
Sage Weil355da1e2009-10-06 11:31:08 -07002003};
2004
Andreas Gruenbachera26fecc2016-04-14 00:30:16 +02002005int __ceph_setattr(struct inode *inode, struct iattr *attr)
Sage Weil355da1e2009-10-06 11:31:08 -07002006{
Sage Weil355da1e2009-10-06 11:31:08 -07002007 struct ceph_inode_info *ci = ceph_inode(inode);
Jeff Laytonc62498d2019-07-25 13:03:32 -04002008 unsigned int ia_valid = attr->ia_valid;
Sage Weil355da1e2009-10-06 11:31:08 -07002009 struct ceph_mds_request *req;
Andreas Gruenbachera26fecc2016-04-14 00:30:16 +02002010 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08002011 struct ceph_cap_flush *prealloc_cf;
Sage Weil355da1e2009-10-06 11:31:08 -07002012 int issued;
2013 int release = 0, dirtied = 0;
2014 int mask = 0;
2015 int err = 0;
Sage Weilfca65b42011-05-04 11:33:47 -07002016 int inode_dirty_flags = 0;
Yan, Zheng604d1b02015-05-01 17:49:16 +08002017 bool lock_snap_rwsem = false;
Sage Weil355da1e2009-10-06 11:31:08 -07002018
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08002019 prealloc_cf = ceph_alloc_cap_flush();
2020 if (!prealloc_cf)
2021 return -ENOMEM;
2022
Sage Weil355da1e2009-10-06 11:31:08 -07002023 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETATTR,
2024 USE_AUTH_MDS);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08002025 if (IS_ERR(req)) {
2026 ceph_free_cap_flush(prealloc_cf);
Sage Weil355da1e2009-10-06 11:31:08 -07002027 return PTR_ERR(req);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08002028 }
Sage Weil355da1e2009-10-06 11:31:08 -07002029
Sage Weilbe655592011-11-30 09:47:09 -08002030 spin_lock(&ci->i_ceph_lock);
Sage Weil355da1e2009-10-06 11:31:08 -07002031 issued = __ceph_caps_issued(ci, NULL);
Yan, Zheng604d1b02015-05-01 17:49:16 +08002032
2033 if (!ci->i_head_snapc &&
2034 (issued & (CEPH_CAP_ANY_EXCL | CEPH_CAP_FILE_WR))) {
2035 lock_snap_rwsem = true;
2036 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2037 spin_unlock(&ci->i_ceph_lock);
2038 down_read(&mdsc->snap_rwsem);
2039 spin_lock(&ci->i_ceph_lock);
2040 issued = __ceph_caps_issued(ci, NULL);
2041 }
2042 }
2043
Sage Weil355da1e2009-10-06 11:31:08 -07002044 dout("setattr %p issued %s\n", inode, ceph_cap_string(issued));
2045
2046 if (ia_valid & ATTR_UID) {
2047 dout("setattr %p uid %d -> %d\n", inode,
Eric W. Biedermanbd2bae62013-01-31 04:05:39 -08002048 from_kuid(&init_user_ns, inode->i_uid),
2049 from_kuid(&init_user_ns, attr->ia_uid));
Sage Weil355da1e2009-10-06 11:31:08 -07002050 if (issued & CEPH_CAP_AUTH_EXCL) {
2051 inode->i_uid = attr->ia_uid;
2052 dirtied |= CEPH_CAP_AUTH_EXCL;
2053 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
Eric W. Biedermanab871b92013-01-31 03:40:12 -08002054 !uid_eq(attr->ia_uid, inode->i_uid)) {
2055 req->r_args.setattr.uid = cpu_to_le32(
2056 from_kuid(&init_user_ns, attr->ia_uid));
Sage Weil355da1e2009-10-06 11:31:08 -07002057 mask |= CEPH_SETATTR_UID;
2058 release |= CEPH_CAP_AUTH_SHARED;
2059 }
2060 }
2061 if (ia_valid & ATTR_GID) {
2062 dout("setattr %p gid %d -> %d\n", inode,
Eric W. Biedermanbd2bae62013-01-31 04:05:39 -08002063 from_kgid(&init_user_ns, inode->i_gid),
2064 from_kgid(&init_user_ns, attr->ia_gid));
Sage Weil355da1e2009-10-06 11:31:08 -07002065 if (issued & CEPH_CAP_AUTH_EXCL) {
2066 inode->i_gid = attr->ia_gid;
2067 dirtied |= CEPH_CAP_AUTH_EXCL;
2068 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
Eric W. Biedermanab871b92013-01-31 03:40:12 -08002069 !gid_eq(attr->ia_gid, inode->i_gid)) {
2070 req->r_args.setattr.gid = cpu_to_le32(
2071 from_kgid(&init_user_ns, attr->ia_gid));
Sage Weil355da1e2009-10-06 11:31:08 -07002072 mask |= CEPH_SETATTR_GID;
2073 release |= CEPH_CAP_AUTH_SHARED;
2074 }
2075 }
2076 if (ia_valid & ATTR_MODE) {
2077 dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode,
2078 attr->ia_mode);
2079 if (issued & CEPH_CAP_AUTH_EXCL) {
2080 inode->i_mode = attr->ia_mode;
2081 dirtied |= CEPH_CAP_AUTH_EXCL;
2082 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
2083 attr->ia_mode != inode->i_mode) {
Guangliang Zhao7221fe42013-11-11 15:18:03 +08002084 inode->i_mode = attr->ia_mode;
Sage Weil355da1e2009-10-06 11:31:08 -07002085 req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode);
2086 mask |= CEPH_SETATTR_MODE;
2087 release |= CEPH_CAP_AUTH_SHARED;
2088 }
2089 }
2090
2091 if (ia_valid & ATTR_ATIME) {
Deepa Dinamani13442b02018-04-23 19:26:50 -07002092 dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02002093 inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
2094 attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
Sage Weil355da1e2009-10-06 11:31:08 -07002095 if (issued & CEPH_CAP_FILE_EXCL) {
2096 ci->i_time_warp_seq++;
2097 inode->i_atime = attr->ia_atime;
2098 dirtied |= CEPH_CAP_FILE_EXCL;
2099 } else if ((issued & CEPH_CAP_FILE_WR) &&
Deepa Dinamani95582b02018-05-08 19:36:02 -07002100 timespec64_compare(&inode->i_atime,
Sage Weil355da1e2009-10-06 11:31:08 -07002101 &attr->ia_atime) < 0) {
2102 inode->i_atime = attr->ia_atime;
2103 dirtied |= CEPH_CAP_FILE_WR;
2104 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
Deepa Dinamani95582b02018-05-08 19:36:02 -07002105 !timespec64_equal(&inode->i_atime, &attr->ia_atime)) {
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02002106 ceph_encode_timespec64(&req->r_args.setattr.atime,
2107 &attr->ia_atime);
Sage Weil355da1e2009-10-06 11:31:08 -07002108 mask |= CEPH_SETATTR_ATIME;
Yan, Zhengbe704892017-11-23 18:22:06 +08002109 release |= CEPH_CAP_FILE_SHARED |
2110 CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
Sage Weil355da1e2009-10-06 11:31:08 -07002111 }
2112 }
Jeff Laytonc62498d2019-07-25 13:03:32 -04002113 if (ia_valid & ATTR_SIZE) {
Jeff Layton2d6795f2021-04-09 15:58:35 -04002114 loff_t isize = i_size_read(inode);
2115
2116 dout("setattr %p size %lld -> %lld\n", inode, isize, attr->ia_size);
Xiubo Lie90334e2021-10-08 16:23:58 +08002117 if ((issued & CEPH_CAP_FILE_EXCL) && attr->ia_size >= isize) {
2118 if (attr->ia_size > isize) {
2119 i_size_write(inode, attr->ia_size);
2120 inode->i_blocks = calc_inode_blocks(attr->ia_size);
2121 ci->i_reported_size = attr->ia_size;
2122 dirtied |= CEPH_CAP_FILE_EXCL;
2123 ia_valid |= ATTR_MTIME;
2124 }
Jeff Laytonc62498d2019-07-25 13:03:32 -04002125 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
Jeff Layton2d6795f2021-04-09 15:58:35 -04002126 attr->ia_size != isize) {
Jeff Laytonc62498d2019-07-25 13:03:32 -04002127 req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
Jeff Layton2d6795f2021-04-09 15:58:35 -04002128 req->r_args.setattr.old_size = cpu_to_le64(isize);
Jeff Laytonc62498d2019-07-25 13:03:32 -04002129 mask |= CEPH_SETATTR_SIZE;
2130 release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
2131 CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
2132 }
2133 }
Sage Weil355da1e2009-10-06 11:31:08 -07002134 if (ia_valid & ATTR_MTIME) {
Deepa Dinamani13442b02018-04-23 19:26:50 -07002135 dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02002136 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
2137 attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
Sage Weil355da1e2009-10-06 11:31:08 -07002138 if (issued & CEPH_CAP_FILE_EXCL) {
2139 ci->i_time_warp_seq++;
2140 inode->i_mtime = attr->ia_mtime;
2141 dirtied |= CEPH_CAP_FILE_EXCL;
2142 } else if ((issued & CEPH_CAP_FILE_WR) &&
Deepa Dinamani95582b02018-05-08 19:36:02 -07002143 timespec64_compare(&inode->i_mtime,
Sage Weil355da1e2009-10-06 11:31:08 -07002144 &attr->ia_mtime) < 0) {
2145 inode->i_mtime = attr->ia_mtime;
2146 dirtied |= CEPH_CAP_FILE_WR;
2147 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
Deepa Dinamani95582b02018-05-08 19:36:02 -07002148 !timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) {
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02002149 ceph_encode_timespec64(&req->r_args.setattr.mtime,
2150 &attr->ia_mtime);
Sage Weil355da1e2009-10-06 11:31:08 -07002151 mask |= CEPH_SETATTR_MTIME;
Yan, Zhengbe704892017-11-23 18:22:06 +08002152 release |= CEPH_CAP_FILE_SHARED |
2153 CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
Sage Weil355da1e2009-10-06 11:31:08 -07002154 }
2155 }
Sage Weil355da1e2009-10-06 11:31:08 -07002156
2157 /* these do nothing */
2158 if (ia_valid & ATTR_CTIME) {
2159 bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|
2160 ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;
Deepa Dinamani13442b02018-04-23 19:26:50 -07002161 dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02002162 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
2163 attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
Sage Weil355da1e2009-10-06 11:31:08 -07002164 only ? "ctime only" : "ignored");
Sage Weil355da1e2009-10-06 11:31:08 -07002165 if (only) {
2166 /*
2167 * if kernel wants to dirty ctime but nothing else,
2168 * we need to choose a cap to dirty under, or do
2169 * a almost-no-op setattr
2170 */
2171 if (issued & CEPH_CAP_AUTH_EXCL)
2172 dirtied |= CEPH_CAP_AUTH_EXCL;
2173 else if (issued & CEPH_CAP_FILE_EXCL)
2174 dirtied |= CEPH_CAP_FILE_EXCL;
2175 else if (issued & CEPH_CAP_XATTR_EXCL)
2176 dirtied |= CEPH_CAP_XATTR_EXCL;
2177 else
2178 mask |= CEPH_SETATTR_CTIME;
2179 }
2180 }
2181 if (ia_valid & ATTR_FILE)
2182 dout("setattr %p ATTR_FILE ... hrm!\n", inode);
2183
2184 if (dirtied) {
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08002185 inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied,
2186 &prealloc_cf);
Yan, Zheng4ca2fea2017-06-01 17:08:00 +08002187 inode->i_ctime = attr->ia_ctime;
Sage Weil355da1e2009-10-06 11:31:08 -07002188 }
2189
2190 release &= issued;
Sage Weilbe655592011-11-30 09:47:09 -08002191 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng604d1b02015-05-01 17:49:16 +08002192 if (lock_snap_rwsem)
2193 up_read(&mdsc->snap_rwsem);
Sage Weil355da1e2009-10-06 11:31:08 -07002194
Sage Weilfca65b42011-05-04 11:33:47 -07002195 if (inode_dirty_flags)
2196 __mark_inode_dirty(inode, inode_dirty_flags);
2197
Sage Weil355da1e2009-10-06 11:31:08 -07002198 if (mask) {
Sage Weil70b666c2011-05-27 09:24:26 -07002199 req->r_inode = inode;
2200 ihold(inode);
Sage Weil355da1e2009-10-06 11:31:08 -07002201 req->r_inode_drop = release;
2202 req->r_args.setattr.mask = cpu_to_le32(mask);
2203 req->r_num_caps = 1;
Arnd Bergmann0ed1e902018-07-13 22:18:38 +02002204 req->r_stamp = attr->ia_ctime;
Sage Weil752c8bd2013-02-05 13:52:29 -08002205 err = ceph_mdsc_do_request(mdsc, NULL, req);
Sage Weil355da1e2009-10-06 11:31:08 -07002206 }
2207 dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,
2208 ceph_cap_string(dirtied), mask);
2209
2210 ceph_mdsc_put_request(req);
Yan, Zheng8179a102017-04-19 10:01:48 +08002211 ceph_free_cap_flush(prealloc_cf);
2212
2213 if (err >= 0 && (mask & CEPH_SETATTR_SIZE))
Yan, Zhengb0d7c222013-08-12 21:42:15 -07002214 __ceph_do_pending_vmtruncate(inode);
Yan, Zheng8179a102017-04-19 10:01:48 +08002215
Sage Weil355da1e2009-10-06 11:31:08 -07002216 return err;
2217}
2218
2219/*
Andreas Gruenbachera26fecc2016-04-14 00:30:16 +02002220 * setattr
2221 */
Christian Brauner549c7292021-01-21 14:19:43 +01002222int ceph_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
2223 struct iattr *attr)
Andreas Gruenbachera26fecc2016-04-14 00:30:16 +02002224{
Jan Karafd5472e2016-05-26 16:10:38 +02002225 struct inode *inode = d_inode(dentry);
Chengguang Xu36a4c72d2018-08-05 19:33:01 +08002226 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
Jan Karafd5472e2016-05-26 16:10:38 +02002227 int err;
2228
2229 if (ceph_snap(inode) != CEPH_NOSNAP)
2230 return -EROFS;
2231
Jeff Layton5d6451b2021-08-31 13:39:13 -04002232 if (ceph_inode_is_shutdown(inode))
2233 return -ESTALE;
2234
Christian Brauner2f221d62021-01-21 14:19:26 +01002235 err = setattr_prepare(&init_user_ns, dentry, attr);
Jan Karafd5472e2016-05-26 16:10:38 +02002236 if (err != 0)
2237 return err;
2238
Luis Henriques2b838452018-01-05 10:47:21 +00002239 if ((attr->ia_valid & ATTR_SIZE) &&
Jeff Layton2d6795f2021-04-09 15:58:35 -04002240 attr->ia_size > max(i_size_read(inode), fsc->max_file_size))
Chengguang Xu36a4c72d2018-08-05 19:33:01 +08002241 return -EFBIG;
2242
2243 if ((attr->ia_valid & ATTR_SIZE) &&
Luis Henriques2b838452018-01-05 10:47:21 +00002244 ceph_quota_is_max_bytes_exceeded(inode, attr->ia_size))
2245 return -EDQUOT;
2246
Yan, Zheng8179a102017-04-19 10:01:48 +08002247 err = __ceph_setattr(inode, attr);
2248
2249 if (err >= 0 && (attr->ia_valid & ATTR_MODE))
Christian Braunere65ce2a2021-01-21 14:19:27 +01002250 err = posix_acl_chmod(&init_user_ns, inode, attr->ia_mode);
Yan, Zheng8179a102017-04-19 10:01:48 +08002251
2252 return err;
Andreas Gruenbachera26fecc2016-04-14 00:30:16 +02002253}
2254
2255/*
Sage Weil355da1e2009-10-06 11:31:08 -07002256 * Verify that we have a lease on the given mask. If not,
2257 * do a getattr against an mds.
2258 */
Yan, Zheng01deead2014-11-14 21:56:29 +08002259int __ceph_do_getattr(struct inode *inode, struct page *locked_page,
2260 int mask, bool force)
Sage Weil355da1e2009-10-06 11:31:08 -07002261{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002262 struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
2263 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weil355da1e2009-10-06 11:31:08 -07002264 struct ceph_mds_request *req;
Yan, Zheng49a9f4f2018-04-25 17:30:23 +08002265 int mode;
Sage Weil355da1e2009-10-06 11:31:08 -07002266 int err;
2267
2268 if (ceph_snap(inode) == CEPH_SNAPDIR) {
2269 dout("do_getattr inode %p SNAPDIR\n", inode);
2270 return 0;
2271 }
2272
Yan, Zheng01deead2014-11-14 21:56:29 +08002273 dout("do_getattr inode %p mask %s mode 0%o\n",
2274 inode, ceph_cap_string(mask), inode->i_mode);
Xiubo Li1af16d52020-03-19 23:45:00 -04002275 if (!force && ceph_caps_issued_mask_metric(ceph_inode(inode), mask, 1))
2276 return 0;
Sage Weil355da1e2009-10-06 11:31:08 -07002277
Yan, Zheng49a9f4f2018-04-25 17:30:23 +08002278 mode = (mask & CEPH_STAT_RSTAT) ? USE_AUTH_MDS : USE_ANY_MDS;
2279 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, mode);
Sage Weil355da1e2009-10-06 11:31:08 -07002280 if (IS_ERR(req))
2281 return PTR_ERR(req);
Sage Weil70b666c2011-05-27 09:24:26 -07002282 req->r_inode = inode;
2283 ihold(inode);
Sage Weil355da1e2009-10-06 11:31:08 -07002284 req->r_num_caps = 1;
2285 req->r_args.getattr.mask = cpu_to_le32(mask);
Yan, Zheng01deead2014-11-14 21:56:29 +08002286 req->r_locked_page = locked_page;
Sage Weil355da1e2009-10-06 11:31:08 -07002287 err = ceph_mdsc_do_request(mdsc, NULL, req);
Yan, Zheng01deead2014-11-14 21:56:29 +08002288 if (locked_page && err == 0) {
2289 u64 inline_version = req->r_reply_info.targeti.inline_version;
2290 if (inline_version == 0) {
2291 /* the reply is supposed to contain inline data */
2292 err = -EINVAL;
2293 } else if (inline_version == CEPH_INLINE_NONE) {
2294 err = -ENODATA;
2295 } else {
2296 err = req->r_reply_info.targeti.inline_len;
2297 }
2298 }
Sage Weil355da1e2009-10-06 11:31:08 -07002299 ceph_mdsc_put_request(req);
2300 dout("do_getattr result=%d\n", err);
2301 return err;
2302}
2303
2304
2305/*
2306 * Check inode permissions. We verify we have a valid value for
2307 * the AUTH cap, then call the generic handler.
2308 */
Christian Brauner549c7292021-01-21 14:19:43 +01002309int ceph_permission(struct user_namespace *mnt_userns, struct inode *inode,
2310 int mask)
Sage Weil355da1e2009-10-06 11:31:08 -07002311{
Nick Pigginb74c79e2011-01-07 17:49:58 +11002312 int err;
2313
Al Viro10556cb22011-06-20 19:28:19 -04002314 if (mask & MAY_NOT_BLOCK)
Nick Pigginb74c79e2011-01-07 17:49:58 +11002315 return -ECHILD;
2316
Yan, Zheng508b32d2014-09-16 21:46:17 +08002317 err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false);
Sage Weil355da1e2009-10-06 11:31:08 -07002318
2319 if (!err)
Christian Brauner47291ba2021-01-21 14:19:24 +01002320 err = generic_permission(&init_user_ns, inode, mask);
Sage Weil355da1e2009-10-06 11:31:08 -07002321 return err;
2322}
2323
Jeff Layton428bb682019-04-11 15:27:03 -04002324/* Craft a mask of needed caps given a set of requested statx attrs. */
Jeff Layton04fabb12020-11-09 13:14:07 -05002325static int statx_to_caps(u32 want, umode_t mode)
Jeff Layton428bb682019-04-11 15:27:03 -04002326{
2327 int mask = 0;
2328
Jeff Layton58981782019-06-05 12:08:32 -04002329 if (want & (STATX_MODE|STATX_UID|STATX_GID|STATX_CTIME|STATX_BTIME))
Jeff Layton428bb682019-04-11 15:27:03 -04002330 mask |= CEPH_CAP_AUTH_SHARED;
2331
Jeff Layton04fabb12020-11-09 13:14:07 -05002332 if (want & (STATX_NLINK|STATX_CTIME)) {
2333 /*
2334 * The link count for directories depends on inode->i_subdirs,
2335 * and that is only updated when Fs caps are held.
2336 */
2337 if (S_ISDIR(mode))
2338 mask |= CEPH_CAP_FILE_SHARED;
2339 else
2340 mask |= CEPH_CAP_LINK_SHARED;
2341 }
Jeff Layton428bb682019-04-11 15:27:03 -04002342
2343 if (want & (STATX_ATIME|STATX_MTIME|STATX_CTIME|STATX_SIZE|
2344 STATX_BLOCKS))
2345 mask |= CEPH_CAP_FILE_SHARED;
2346
2347 if (want & (STATX_CTIME))
2348 mask |= CEPH_CAP_XATTR_SHARED;
2349
2350 return mask;
2351}
2352
Sage Weil355da1e2009-10-06 11:31:08 -07002353/*
Jeff Layton428bb682019-04-11 15:27:03 -04002354 * Get all the attributes. If we have sufficient caps for the requested attrs,
2355 * then we can avoid talking to the MDS at all.
Sage Weil355da1e2009-10-06 11:31:08 -07002356 */
Christian Brauner549c7292021-01-21 14:19:43 +01002357int ceph_getattr(struct user_namespace *mnt_userns, const struct path *path,
2358 struct kstat *stat, u32 request_mask, unsigned int flags)
Sage Weil355da1e2009-10-06 11:31:08 -07002359{
David Howellsa528d352017-01-31 16:46:22 +00002360 struct inode *inode = d_inode(path->dentry);
Sage Weil232d4b02009-10-21 11:21:49 -07002361 struct ceph_inode_info *ci = ceph_inode(inode);
Jeff Layton58981782019-06-05 12:08:32 -04002362 u32 valid_mask = STATX_BASIC_STATS;
Jeff Layton428bb682019-04-11 15:27:03 -04002363 int err = 0;
Sage Weil355da1e2009-10-06 11:31:08 -07002364
Jeff Layton5d6451b2021-08-31 13:39:13 -04002365 if (ceph_inode_is_shutdown(inode))
2366 return -ESTALE;
2367
Jeff Layton428bb682019-04-11 15:27:03 -04002368 /* Skip the getattr altogether if we're asked not to sync */
2369 if (!(flags & AT_STATX_DONT_SYNC)) {
Jeff Layton04fabb12020-11-09 13:14:07 -05002370 err = ceph_do_getattr(inode,
2371 statx_to_caps(request_mask, inode->i_mode),
2372 flags & AT_STATX_FORCE_SYNC);
Jeff Layton428bb682019-04-11 15:27:03 -04002373 if (err)
2374 return err;
Sage Weil355da1e2009-10-06 11:31:08 -07002375 }
Jeff Layton428bb682019-04-11 15:27:03 -04002376
Christian Brauner0d56a452021-01-21 14:19:30 +01002377 generic_fillattr(&init_user_ns, inode, stat);
Jeff Laytonebce3eb2020-08-18 08:03:48 -04002378 stat->ino = ceph_present_inode(inode);
Jeff Layton58981782019-06-05 12:08:32 -04002379
2380 /*
2381 * btime on newly-allocated inodes is 0, so if this is still set to
2382 * that, then assume that it's not valid.
2383 */
2384 if (ci->i_btime.tv_sec || ci->i_btime.tv_nsec) {
2385 stat->btime = ci->i_btime;
2386 valid_mask |= STATX_BTIME;
2387 }
2388
Jeff Layton428bb682019-04-11 15:27:03 -04002389 if (ceph_snap(inode) == CEPH_NOSNAP)
2390 stat->dev = inode->i_sb->s_dev;
2391 else
2392 stat->dev = ci->i_snapid_map ? ci->i_snapid_map->dev : 0;
2393
2394 if (S_ISDIR(inode->i_mode)) {
2395 if (ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb),
2396 RBYTES))
2397 stat->size = ci->i_rbytes;
2398 else
2399 stat->size = ci->i_files + ci->i_subdirs;
2400 stat->blocks = 0;
2401 stat->blksize = 65536;
2402 /*
2403 * Some applications rely on the number of st_nlink
2404 * value on directories to be either 0 (if unlinked)
2405 * or 2 + number of subdirectories.
2406 */
2407 if (stat->nlink == 1)
2408 /* '.' + '..' + subdirs */
2409 stat->nlink = 1 + 1 + ci->i_subdirs;
2410 }
2411
Jeff Layton58981782019-06-05 12:08:32 -04002412 stat->result_mask = request_mask & valid_mask;
Sage Weil355da1e2009-10-06 11:31:08 -07002413 return err;
2414}
Jeff Layton5d6451b2021-08-31 13:39:13 -04002415
2416void ceph_inode_shutdown(struct inode *inode)
2417{
2418 struct ceph_inode_info *ci = ceph_inode(inode);
2419 struct rb_node *p;
2420 int iputs = 0;
2421 bool invalidate = false;
2422
2423 spin_lock(&ci->i_ceph_lock);
2424 ci->i_ceph_flags |= CEPH_I_SHUTDOWN;
2425 p = rb_first(&ci->i_caps);
2426 while (p) {
2427 struct ceph_cap *cap = rb_entry(p, struct ceph_cap, ci_node);
2428
2429 p = rb_next(p);
2430 iputs += ceph_purge_inode_cap(inode, cap, &invalidate);
2431 }
2432 spin_unlock(&ci->i_ceph_lock);
2433
2434 if (invalidate)
2435 ceph_queue_invalidate(inode);
2436 while (iputs--)
2437 iput(inode);
2438}