Whamcloud - gitweb
LU-12275 sec: encryption support for DoM files
[fs/lustre-release.git] / lustre / llite / file.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/llite/file.c
33  *
34  * Author: Peter Braam <braam@clusterfs.com>
35  * Author: Phil Schwan <phil@clusterfs.com>
36  * Author: Andreas Dilger <adilger@clusterfs.com>
37  */
38
39 #define DEBUG_SUBSYSTEM S_LLITE
40 #include <lustre_dlm.h>
41 #include <linux/pagemap.h>
42 #include <linux/file.h>
43 #include <linux/sched.h>
44 #include <linux/user_namespace.h>
45 #include <linux/uidgid.h>
46 #include <linux/falloc.h>
47
48 #include <uapi/linux/lustre/lustre_ioctl.h>
49 #include <uapi/linux/llcrypt.h>
50 #include <lustre_swab.h>
51
52 #include "cl_object.h"
53 #include "llite_internal.h"
54 #include "vvp_internal.h"
55
56 struct split_param {
57         struct inode    *sp_inode;
58         __u16           sp_mirror_id;
59 };
60
61 struct pcc_param {
62         __u64   pa_data_version;
63         __u32   pa_archive_id;
64         __u32   pa_layout_gen;
65 };
66
67 static int
68 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
69
70 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
71                           bool *lease_broken);
72
73 static struct ll_file_data *ll_file_data_get(void)
74 {
75         struct ll_file_data *fd;
76
77         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
78         if (fd == NULL)
79                 return NULL;
80
81         fd->fd_write_failed = false;
82         pcc_file_init(&fd->fd_pcc_file);
83
84         return fd;
85 }
86
87 static void ll_file_data_put(struct ll_file_data *fd)
88 {
89         if (fd != NULL)
90                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
91 }
92
93 /**
94  * Packs all the attributes into @op_data for the CLOSE rpc.
95  */
96 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
97                              struct obd_client_handle *och)
98 {
99         ENTRY;
100
101         ll_prep_md_op_data(op_data, inode, NULL, NULL,
102                            0, 0, LUSTRE_OPC_ANY, NULL);
103
104         op_data->op_attr.ia_mode = inode->i_mode;
105         op_data->op_attr.ia_atime = inode->i_atime;
106         op_data->op_attr.ia_mtime = inode->i_mtime;
107         op_data->op_attr.ia_ctime = inode->i_ctime;
108         op_data->op_attr.ia_size = i_size_read(inode);
109         op_data->op_attr.ia_valid |= (ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
110                                       ATTR_MTIME | ATTR_MTIME_SET |
111                                       ATTR_CTIME);
112         op_data->op_xvalid |= OP_XVALID_CTIME_SET;
113         op_data->op_attr_blocks = inode->i_blocks;
114         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
115         if (ll_file_test_flag(ll_i2info(inode), LLIF_PROJECT_INHERIT))
116                 op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
117         op_data->op_open_handle = och->och_open_handle;
118
119         if (och->och_flags & FMODE_WRITE &&
120             ll_file_test_and_clear_flag(ll_i2info(inode), LLIF_DATA_MODIFIED))
121                 /* For HSM: if inode data has been modified, pack it so that
122                  * MDT can set data dirty flag in the archive. */
123                 op_data->op_bias |= MDS_DATA_MODIFIED;
124
125         EXIT;
126 }
127
128 /**
129  * Perform a close, possibly with a bias.
130  * The meaning of "data" depends on the value of "bias".
131  *
132  * If \a bias is MDS_HSM_RELEASE then \a data is a pointer to the data version.
133  * If \a bias is MDS_CLOSE_LAYOUT_SWAP then \a data is a pointer to the inode to
134  * swap layouts with.
135  */
136 static int ll_close_inode_openhandle(struct inode *inode,
137                                      struct obd_client_handle *och,
138                                      enum mds_op_bias bias, void *data)
139 {
140         struct obd_export *md_exp = ll_i2mdexp(inode);
141         const struct ll_inode_info *lli = ll_i2info(inode);
142         struct md_op_data *op_data;
143         struct ptlrpc_request *req = NULL;
144         int rc;
145         ENTRY;
146
147         if (class_exp2obd(md_exp) == NULL) {
148                 CERROR("%s: invalid MDC connection handle closing "DFID"\n",
149                        ll_i2sbi(inode)->ll_fsname, PFID(&lli->lli_fid));
150                 GOTO(out, rc = 0);
151         }
152
153         OBD_ALLOC_PTR(op_data);
154         /* We leak openhandle and request here on error, but not much to be
155          * done in OOM case since app won't retry close on error either. */
156         if (op_data == NULL)
157                 GOTO(out, rc = -ENOMEM);
158
159         ll_prepare_close(inode, op_data, och);
160         switch (bias) {
161         case MDS_CLOSE_LAYOUT_MERGE:
162                 /* merge blocks from the victim inode */
163                 op_data->op_attr_blocks += ((struct inode *)data)->i_blocks;
164                 op_data->op_attr.ia_valid |= ATTR_SIZE;
165                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
166                 /* fallthrough */
167         case MDS_CLOSE_LAYOUT_SPLIT:
168         case MDS_CLOSE_LAYOUT_SWAP: {
169                 struct split_param *sp = data;
170
171                 LASSERT(data != NULL);
172                 op_data->op_bias |= bias;
173                 op_data->op_data_version = 0;
174                 op_data->op_lease_handle = och->och_lease_handle;
175                 if (bias == MDS_CLOSE_LAYOUT_SPLIT) {
176                         op_data->op_fid2 = *ll_inode2fid(sp->sp_inode);
177                         op_data->op_mirror_id = sp->sp_mirror_id;
178                 } else {
179                         op_data->op_fid2 = *ll_inode2fid(data);
180                 }
181                 break;
182         }
183
184         case MDS_CLOSE_RESYNC_DONE: {
185                 struct ll_ioc_lease *ioc = data;
186
187                 LASSERT(data != NULL);
188                 op_data->op_attr_blocks +=
189                         ioc->lil_count * op_data->op_attr_blocks;
190                 op_data->op_attr.ia_valid |= ATTR_SIZE;
191                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
192                 op_data->op_bias |= MDS_CLOSE_RESYNC_DONE;
193
194                 op_data->op_lease_handle = och->och_lease_handle;
195                 op_data->op_data = &ioc->lil_ids[0];
196                 op_data->op_data_size =
197                         ioc->lil_count * sizeof(ioc->lil_ids[0]);
198                 break;
199         }
200
201         case MDS_PCC_ATTACH: {
202                 struct pcc_param *param = data;
203
204                 LASSERT(data != NULL);
205                 op_data->op_bias |= MDS_HSM_RELEASE | MDS_PCC_ATTACH;
206                 op_data->op_archive_id = param->pa_archive_id;
207                 op_data->op_data_version = param->pa_data_version;
208                 op_data->op_lease_handle = och->och_lease_handle;
209                 break;
210         }
211
212         case MDS_HSM_RELEASE:
213                 LASSERT(data != NULL);
214                 op_data->op_bias |= MDS_HSM_RELEASE;
215                 op_data->op_data_version = *(__u64 *)data;
216                 op_data->op_lease_handle = och->och_lease_handle;
217                 op_data->op_attr.ia_valid |= ATTR_SIZE;
218                 op_data->op_xvalid |= OP_XVALID_BLOCKS;
219                 break;
220
221         default:
222                 LASSERT(data == NULL);
223                 break;
224         }
225
226         if (!(op_data->op_attr.ia_valid & ATTR_SIZE))
227                 op_data->op_xvalid |= OP_XVALID_LAZYSIZE;
228         if (!(op_data->op_xvalid & OP_XVALID_BLOCKS))
229                 op_data->op_xvalid |= OP_XVALID_LAZYBLOCKS;
230
231         rc = md_close(md_exp, op_data, och->och_mod, &req);
232         if (rc != 0 && rc != -EINTR)
233                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
234                        md_exp->exp_obd->obd_name, PFID(&lli->lli_fid), rc);
235
236         if (rc == 0 && op_data->op_bias & bias) {
237                 struct mdt_body *body;
238
239                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
240                 if (!(body->mbo_valid & OBD_MD_CLOSE_INTENT_EXECED))
241                         rc = -EBUSY;
242
243                 if (bias & MDS_PCC_ATTACH) {
244                         struct pcc_param *param = data;
245
246                         param->pa_layout_gen = body->mbo_layout_gen;
247                 }
248         }
249
250         ll_finish_md_op_data(op_data);
251         EXIT;
252 out:
253
254         md_clear_open_replay_data(md_exp, och);
255         och->och_open_handle.cookie = DEAD_HANDLE_MAGIC;
256         OBD_FREE_PTR(och);
257
258         ptlrpc_req_finished(req);       /* This is close request */
259         return rc;
260 }
261
262 int ll_md_real_close(struct inode *inode, fmode_t fmode)
263 {
264         struct ll_inode_info *lli = ll_i2info(inode);
265         struct obd_client_handle **och_p;
266         struct obd_client_handle *och;
267         __u64 *och_usecount;
268         int rc = 0;
269         ENTRY;
270
271         if (fmode & FMODE_WRITE) {
272                 och_p = &lli->lli_mds_write_och;
273                 och_usecount = &lli->lli_open_fd_write_count;
274         } else if (fmode & FMODE_EXEC) {
275                 och_p = &lli->lli_mds_exec_och;
276                 och_usecount = &lli->lli_open_fd_exec_count;
277         } else {
278                 LASSERT(fmode & FMODE_READ);
279                 och_p = &lli->lli_mds_read_och;
280                 och_usecount = &lli->lli_open_fd_read_count;
281         }
282
283         mutex_lock(&lli->lli_och_mutex);
284         if (*och_usecount > 0) {
285                 /* There are still users of this handle, so skip
286                  * freeing it. */
287                 mutex_unlock(&lli->lli_och_mutex);
288                 RETURN(0);
289         }
290
291         och = *och_p;
292         *och_p = NULL;
293         mutex_unlock(&lli->lli_och_mutex);
294
295         if (och != NULL) {
296                 /* There might be a race and this handle may already
297                  * be closed. */
298                 rc = ll_close_inode_openhandle(inode, och, 0, NULL);
299         }
300
301         RETURN(rc);
302 }
303
304 static int ll_md_close(struct inode *inode, struct file *file)
305 {
306         union ldlm_policy_data policy = {
307                 .l_inodebits    = { MDS_INODELOCK_OPEN },
308         };
309         __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
310         struct ll_file_data *fd = file->private_data;
311         struct ll_inode_info *lli = ll_i2info(inode);
312         struct lustre_handle lockh;
313         enum ldlm_mode lockmode;
314         int rc = 0;
315         ENTRY;
316
317         /* clear group lock, if present */
318         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
319                 ll_put_grouplock(inode, file, fd->fd_grouplock.lg_gid);
320
321         if (fd->fd_lease_och != NULL) {
322                 bool lease_broken;
323
324                 /* Usually the lease is not released when the
325                  * application crashed, we need to release here. */
326                 rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken);
327                 CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n",
328                         PFID(&lli->lli_fid), rc, lease_broken);
329
330                 fd->fd_lease_och = NULL;
331         }
332
333         if (fd->fd_och != NULL) {
334                 rc = ll_close_inode_openhandle(inode, fd->fd_och, 0, NULL);
335                 fd->fd_och = NULL;
336                 GOTO(out, rc);
337         }
338
339         /* Let's see if we have good enough OPEN lock on the file and if
340            we can skip talking to MDS */
341         mutex_lock(&lli->lli_och_mutex);
342         if (fd->fd_omode & FMODE_WRITE) {
343                 lockmode = LCK_CW;
344                 LASSERT(lli->lli_open_fd_write_count);
345                 lli->lli_open_fd_write_count--;
346         } else if (fd->fd_omode & FMODE_EXEC) {
347                 lockmode = LCK_PR;
348                 LASSERT(lli->lli_open_fd_exec_count);
349                 lli->lli_open_fd_exec_count--;
350         } else {
351                 lockmode = LCK_CR;
352                 LASSERT(lli->lli_open_fd_read_count);
353                 lli->lli_open_fd_read_count--;
354         }
355         mutex_unlock(&lli->lli_och_mutex);
356
357         /* LU-4398: do not cache write open lock if the file has exec bit */
358         if ((lockmode == LCK_CW && inode->i_mode & S_IXUGO) ||
359             !md_lock_match(ll_i2mdexp(inode), flags, ll_inode2fid(inode),
360                            LDLM_IBITS, &policy, lockmode, &lockh))
361                 rc = ll_md_real_close(inode, fd->fd_omode);
362
363 out:
364         file->private_data = NULL;
365         ll_file_data_put(fd);
366
367         RETURN(rc);
368 }
369
370 /* While this returns an error code, fput() the caller does not, so we need
371  * to make every effort to clean up all of our state here.  Also, applications
372  * rarely check close errors and even if an error is returned they will not
373  * re-try the close call.
374  */
375 int ll_file_release(struct inode *inode, struct file *file)
376 {
377         struct ll_file_data *fd;
378         struct ll_sb_info *sbi = ll_i2sbi(inode);
379         struct ll_inode_info *lli = ll_i2info(inode);
380         ktime_t kstart = ktime_get();
381         int rc;
382
383         ENTRY;
384
385         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
386                PFID(ll_inode2fid(inode)), inode);
387
388         fd = file->private_data;
389         LASSERT(fd != NULL);
390
391         /* The last ref on @file, maybe not the the owner pid of statahead,
392          * because parent and child process can share the same file handle. */
393         if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd)
394                 ll_deauthorize_statahead(inode, fd);
395
396         if (inode->i_sb->s_root == file_dentry(file)) {
397                 file->private_data = NULL;
398                 ll_file_data_put(fd);
399                 GOTO(out, rc = 0);
400         }
401
402         pcc_file_release(inode, file);
403
404         if (!S_ISDIR(inode->i_mode)) {
405                 if (lli->lli_clob != NULL)
406                         lov_read_and_clear_async_rc(lli->lli_clob);
407                 lli->lli_async_rc = 0;
408         }
409
410         rc = ll_md_close(inode, file);
411
412         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
413                 libcfs_debug_dumplog();
414
415 out:
416         if (!rc && inode->i_sb->s_root != file_dentry(file))
417                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE,
418                                    ktime_us_delta(ktime_get(), kstart));
419         RETURN(rc);
420 }
421
422 static inline int ll_dom_readpage(void *data, struct page *page)
423 {
424         struct niobuf_local *lnb = data;
425         void *kaddr;
426         int rc = 0;
427
428         struct inode *inode = page2inode(page);
429
430         kaddr = kmap_atomic(page);
431         memcpy(kaddr, lnb->lnb_data, lnb->lnb_len);
432         if (lnb->lnb_len < PAGE_SIZE)
433                 memset(kaddr + lnb->lnb_len, 0,
434                        PAGE_SIZE - lnb->lnb_len);
435         flush_dcache_page(page);
436         SetPageUptodate(page);
437         kunmap_atomic(kaddr);
438
439         if (inode && IS_ENCRYPTED(inode) && S_ISREG(inode->i_mode)) {
440                 if (!llcrypt_has_encryption_key(inode))
441                         CDEBUG(D_SEC, "no enc key for "DFID"\n",
442                                PFID(ll_inode2fid(inode)));
443                 /* decrypt only if page is not empty */
444                 else if (memcmp(page_address(page),
445                                 page_address(ZERO_PAGE(0)),
446                                 PAGE_SIZE) != 0)
447                         rc = llcrypt_decrypt_pagecache_blocks(page,
448                                                               PAGE_SIZE,
449                                                               0);
450         }
451         unlock_page(page);
452
453         return rc;
454 }
455
456 void ll_dom_finish_open(struct inode *inode, struct ptlrpc_request *req,
457                         struct lookup_intent *it)
458 {
459         struct ll_inode_info *lli = ll_i2info(inode);
460         struct cl_object *obj = lli->lli_clob;
461         struct address_space *mapping = inode->i_mapping;
462         struct page *vmpage;
463         struct niobuf_remote *rnb;
464         struct mdt_body *body;
465         char *data;
466         unsigned long index, start;
467         struct niobuf_local lnb;
468
469         ENTRY;
470
471         if (obj == NULL)
472                 RETURN_EXIT;
473
474         if (!req_capsule_field_present(&req->rq_pill, &RMF_NIOBUF_INLINE,
475                                        RCL_SERVER))
476                 RETURN_EXIT;
477
478         rnb = req_capsule_server_get(&req->rq_pill, &RMF_NIOBUF_INLINE);
479         if (rnb == NULL || rnb->rnb_len == 0)
480                 RETURN_EXIT;
481
482         /* LU-11595: Server may return whole file and that is OK always or
483          * it may return just file tail and its offset must be aligned with
484          * client PAGE_SIZE to be used on that client, if server's PAGE_SIZE is
485          * smaller then offset may be not aligned and that data is just ignored.
486          */
487         if (rnb->rnb_offset & ~PAGE_MASK)
488                 RETURN_EXIT;
489
490         /* Server returns whole file or just file tail if it fills in reply
491          * buffer, in both cases total size should be equal to the file size.
492          */
493         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
494         if (rnb->rnb_offset + rnb->rnb_len != body->mbo_dom_size &&
495             !(inode && IS_ENCRYPTED(inode))) {
496                 CERROR("%s: server returns off/len %llu/%u but size %llu\n",
497                        ll_i2sbi(inode)->ll_fsname, rnb->rnb_offset,
498                        rnb->rnb_len, body->mbo_dom_size);
499                 RETURN_EXIT;
500         }
501
502         CDEBUG(D_INFO, "Get data along with open at %llu len %i, size %llu\n",
503                rnb->rnb_offset, rnb->rnb_len, body->mbo_dom_size);
504
505         data = (char *)rnb + sizeof(*rnb);
506
507         lnb.lnb_file_offset = rnb->rnb_offset;
508         start = lnb.lnb_file_offset >> PAGE_SHIFT;
509         index = 0;
510         LASSERT((lnb.lnb_file_offset & ~PAGE_MASK) == 0);
511         lnb.lnb_page_offset = 0;
512         do {
513                 lnb.lnb_data = data + (index << PAGE_SHIFT);
514                 lnb.lnb_len = rnb->rnb_len - (index << PAGE_SHIFT);
515                 if (lnb.lnb_len > PAGE_SIZE)
516                         lnb.lnb_len = PAGE_SIZE;
517
518                 vmpage = read_cache_page(mapping, index + start,
519                                          ll_dom_readpage, &lnb);
520                 if (IS_ERR(vmpage)) {
521                         CWARN("%s: cannot fill page %lu for "DFID
522                               " with data: rc = %li\n",
523                               ll_i2sbi(inode)->ll_fsname, index + start,
524                               PFID(lu_object_fid(&obj->co_lu)),
525                               PTR_ERR(vmpage));
526                         break;
527                 }
528                 put_page(vmpage);
529                 index++;
530         } while (rnb->rnb_len > (index << PAGE_SHIFT));
531         EXIT;
532 }
533
534 static int ll_intent_file_open(struct dentry *de, void *lmm, int lmmsize,
535                                 struct lookup_intent *itp)
536 {
537         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
538         struct dentry *parent = de->d_parent;
539         char *name = NULL;
540         int len = 0;
541         struct md_op_data *op_data;
542         struct ptlrpc_request *req = NULL;
543         int rc;
544         ENTRY;
545
546         LASSERT(parent != NULL);
547         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
548
549         /* if server supports open-by-fid, or file name is invalid, don't pack
550          * name in open request */
551         if (OBD_FAIL_CHECK(OBD_FAIL_LLITE_OPEN_BY_NAME) ||
552             !(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID)) {
553 retry:
554                 len = de->d_name.len;
555                 name = kmalloc(len + 1, GFP_NOFS);
556                 if (!name)
557                         RETURN(-ENOMEM);
558
559                 /* race here */
560                 spin_lock(&de->d_lock);
561                 if (len != de->d_name.len) {
562                         spin_unlock(&de->d_lock);
563                         kfree(name);
564                         goto retry;
565                 }
566                 memcpy(name, de->d_name.name, len);
567                 name[len] = '\0';
568                 spin_unlock(&de->d_lock);
569
570                 if (!lu_name_is_valid_2(name, len)) {
571                         kfree(name);
572                         RETURN(-ESTALE);
573                 }
574         }
575
576         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
577                                      name, len, 0, LUSTRE_OPC_ANY, NULL);
578         if (IS_ERR(op_data)) {
579                 kfree(name);
580                 RETURN(PTR_ERR(op_data));
581         }
582         op_data->op_data = lmm;
583         op_data->op_data_size = lmmsize;
584
585         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
586                             &ll_md_blocking_ast, 0);
587         kfree(name);
588         ll_finish_md_op_data(op_data);
589         if (rc == -ESTALE) {
590                 /* reason for keep own exit path - don`t flood log
591                  * with messages with -ESTALE errors.
592                  */
593                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
594                      it_open_error(DISP_OPEN_OPEN, itp))
595                         GOTO(out, rc);
596                 ll_release_openhandle(de, itp);
597                 GOTO(out, rc);
598         }
599
600         if (it_disposition(itp, DISP_LOOKUP_NEG))
601                 GOTO(out, rc = -ENOENT);
602
603         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
604                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
605                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
606                 GOTO(out, rc);
607         }
608
609         rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
610
611         if (!rc && itp->it_lock_mode) {
612                 struct lustre_handle handle = {.cookie = itp->it_lock_handle};
613                 struct ldlm_lock *lock;
614                 bool has_dom_bit = false;
615
616                 /* If we got a lock back and it has a LOOKUP bit set,
617                  * make sure the dentry is marked as valid so we can find it.
618                  * We don't need to care about actual hashing since other bits
619                  * of kernel will deal with that later.
620                  */
621                 lock = ldlm_handle2lock(&handle);
622                 if (lock) {
623                         has_dom_bit = ldlm_has_dom(lock);
624                         if (lock->l_policy_data.l_inodebits.bits &
625                             MDS_INODELOCK_LOOKUP)
626                                 d_lustre_revalidate(de);
627
628                         LDLM_LOCK_PUT(lock);
629                 }
630                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, NULL);
631                 if (has_dom_bit)
632                         ll_dom_finish_open(de->d_inode, req, itp);
633         }
634
635 out:
636         ptlrpc_req_finished(req);
637         ll_intent_drop_lock(itp);
638
639         /* We did open by fid, but by the time we got to the server,
640          * the object disappeared. If this is a create, we cannot really
641          * tell the userspace that the file it was trying to create
642          * does not exist. Instead let's return -ESTALE, and the VFS will
643          * retry the create with LOOKUP_REVAL that we are going to catch
644          * in ll_revalidate_dentry() and use lookup then.
645          */
646         if (rc == -ENOENT && itp->it_op & IT_CREAT)
647                 rc = -ESTALE;
648
649         RETURN(rc);
650 }
651
652 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
653                        struct obd_client_handle *och)
654 {
655         struct mdt_body *body;
656
657         body = req_capsule_server_get(&it->it_request->rq_pill, &RMF_MDT_BODY);
658         och->och_open_handle = body->mbo_open_handle;
659         och->och_fid = body->mbo_fid1;
660         och->och_lease_handle.cookie = it->it_lock_handle;
661         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
662         och->och_flags = it->it_flags;
663
664         return md_set_open_replay_data(md_exp, och, it);
665 }
666
667 static int ll_local_open(struct file *file, struct lookup_intent *it,
668                          struct ll_file_data *fd, struct obd_client_handle *och)
669 {
670         struct inode *inode = file_inode(file);
671         ENTRY;
672
673         LASSERT(!file->private_data);
674
675         LASSERT(fd != NULL);
676
677         if (och) {
678                 int rc;
679
680                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
681                 if (rc != 0)
682                         RETURN(rc);
683         }
684
685         file->private_data = fd;
686         ll_readahead_init(inode, &fd->fd_ras);
687         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
688
689         /* ll_cl_context initialize */
690         rwlock_init(&fd->fd_lock);
691         INIT_LIST_HEAD(&fd->fd_lccs);
692
693         RETURN(0);
694 }
695
696 /* Open a file, and (for the very first open) create objects on the OSTs at
697  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
698  * creation or open until ll_lov_setstripe() ioctl is called.
699  *
700  * If we already have the stripe MD locally then we don't request it in
701  * md_open(), by passing a lmm_size = 0.
702  *
703  * It is up to the application to ensure no other processes open this file
704  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
705  * used.  We might be able to avoid races of that sort by getting lli_open_sem
706  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
707  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
708  */
709 int ll_file_open(struct inode *inode, struct file *file)
710 {
711         struct ll_inode_info *lli = ll_i2info(inode);
712         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
713                                           .it_flags = file->f_flags };
714         struct obd_client_handle **och_p = NULL;
715         __u64 *och_usecount = NULL;
716         struct ll_file_data *fd;
717         ktime_t kstart = ktime_get();
718         int rc = 0;
719         ENTRY;
720
721         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
722                PFID(ll_inode2fid(inode)), inode, file->f_flags);
723
724         it = file->private_data; /* XXX: compat macro */
725         file->private_data = NULL; /* prevent ll_local_open assertion */
726
727         if (S_ISREG(inode->i_mode)) {
728                 rc = llcrypt_file_open(inode, file);
729                 if (rc)
730                         GOTO(out_nofiledata, rc);
731         }
732
733         fd = ll_file_data_get();
734         if (fd == NULL)
735                 GOTO(out_nofiledata, rc = -ENOMEM);
736
737         fd->fd_file = file;
738         if (S_ISDIR(inode->i_mode))
739                 ll_authorize_statahead(inode, fd);
740
741         if (inode->i_sb->s_root == file_dentry(file)) {
742                 file->private_data = fd;
743                 RETURN(0);
744         }
745
746         if (!it || !it->it_disposition) {
747                 /* Convert f_flags into access mode. We cannot use file->f_mode,
748                  * because everything but O_ACCMODE mask was stripped from
749                  * there */
750                 if ((oit.it_flags + 1) & O_ACCMODE)
751                         oit.it_flags++;
752                 if (file->f_flags & O_TRUNC)
753                         oit.it_flags |= FMODE_WRITE;
754
755                 /* kernel only call f_op->open in dentry_open.  filp_open calls
756                  * dentry_open after call to open_namei that checks permissions.
757                  * Only nfsd_open call dentry_open directly without checking
758                  * permissions and because of that this code below is safe.
759                  */
760                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
761                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
762
763                 /* We do not want O_EXCL here, presumably we opened the file
764                  * already? XXX - NFS implications? */
765                 oit.it_flags &= ~O_EXCL;
766
767                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
768                  * created if necessary, then "IT_CREAT" should be set to keep
769                  * consistent with it */
770                 if (oit.it_flags & O_CREAT)
771                         oit.it_op |= IT_CREAT;
772
773                 it = &oit;
774         }
775
776 restart:
777         /* Let's see if we have file open on MDS already. */
778         if (it->it_flags & FMODE_WRITE) {
779                 och_p = &lli->lli_mds_write_och;
780                 och_usecount = &lli->lli_open_fd_write_count;
781         } else if (it->it_flags & FMODE_EXEC) {
782                 och_p = &lli->lli_mds_exec_och;
783                 och_usecount = &lli->lli_open_fd_exec_count;
784         } else {
785                 och_p = &lli->lli_mds_read_och;
786                 och_usecount = &lli->lli_open_fd_read_count;
787         }
788
789         mutex_lock(&lli->lli_och_mutex);
790         if (*och_p) { /* Open handle is present */
791                 if (it_disposition(it, DISP_OPEN_OPEN)) {
792                         /* Well, there's extra open request that we do not need,
793                          * let's close it somehow. This will decref request. */
794                         rc = it_open_error(DISP_OPEN_OPEN, it);
795                         if (rc) {
796                                 mutex_unlock(&lli->lli_och_mutex);
797                                 GOTO(out_openerr, rc);
798                         }
799
800                         ll_release_openhandle(file_dentry(file), it);
801                 }
802                 (*och_usecount)++;
803
804                 rc = ll_local_open(file, it, fd, NULL);
805                 if (rc) {
806                         (*och_usecount)--;
807                         mutex_unlock(&lli->lli_och_mutex);
808                         GOTO(out_openerr, rc);
809                 }
810         } else {
811                 LASSERT(*och_usecount == 0);
812                 if (!it->it_disposition) {
813                         struct dentry *dentry = file_dentry(file);
814                         struct ll_dentry_data *ldd;
815
816                         /* We cannot just request lock handle now, new ELC code
817                          * means that one of other OPEN locks for this file
818                          * could be cancelled, and since blocking ast handler
819                          * would attempt to grab och_mutex as well, that would
820                          * result in a deadlock
821                          */
822                         mutex_unlock(&lli->lli_och_mutex);
823                         /*
824                          * Normally called under two situations:
825                          * 1. NFS export.
826                          * 2. A race/condition on MDS resulting in no open
827                          *    handle to be returned from LOOKUP|OPEN request,
828                          *    for example if the target entry was a symlink.
829                          *
830                          *  Only fetch MDS_OPEN_LOCK if this is in NFS path,
831                          *  marked by a bit set in ll_iget_for_nfs. Clear the
832                          *  bit so that it's not confusing later callers.
833                          *
834                          *  NB; when ldd is NULL, it must have come via normal
835                          *  lookup path only, since ll_iget_for_nfs always calls
836                          *  ll_d_init().
837                          */
838                         ldd = ll_d2d(dentry);
839                         if (ldd && ldd->lld_nfs_dentry) {
840                                 ldd->lld_nfs_dentry = 0;
841                                 if (!filename_is_volatile(dentry->d_name.name,
842                                                           dentry->d_name.len,
843                                                           NULL))
844                                         it->it_flags |= MDS_OPEN_LOCK;
845                         }
846
847                         /*
848                          * Always specify MDS_OPEN_BY_FID because we don't want
849                          * to get file with different fid.
850                          */
851                         it->it_flags |= MDS_OPEN_BY_FID;
852                         rc = ll_intent_file_open(dentry, NULL, 0, it);
853                         if (rc)
854                                 GOTO(out_openerr, rc);
855
856                         goto restart;
857                 }
858                 OBD_ALLOC(*och_p, sizeof(struct obd_client_handle));
859                 if (!*och_p)
860                         GOTO(out_och_free, rc = -ENOMEM);
861
862                 (*och_usecount)++;
863
864                 /* md_intent_lock() didn't get a request ref if there was an
865                  * open error, so don't do cleanup on the request here
866                  * (bug 3430) */
867                 /* XXX (green): Should not we bail out on any error here, not
868                  * just open error? */
869                 rc = it_open_error(DISP_OPEN_OPEN, it);
870                 if (rc != 0)
871                         GOTO(out_och_free, rc);
872
873                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
874                          "inode %p: disposition %x, status %d\n", inode,
875                          it_disposition(it, ~0), it->it_status);
876
877                 rc = ll_local_open(file, it, fd, *och_p);
878                 if (rc)
879                         GOTO(out_och_free, rc);
880         }
881
882         rc = pcc_file_open(inode, file);
883         if (rc)
884                 GOTO(out_och_free, rc);
885
886         mutex_unlock(&lli->lli_och_mutex);
887
888         /* lockless for direct IO so that it can do IO in parallel */
889         if (file->f_flags & O_DIRECT)
890                 fd->fd_flags |= LL_FILE_LOCKLESS_IO;
891         fd = NULL;
892
893         /* Must do this outside lli_och_mutex lock to prevent deadlock where
894            different kind of OPEN lock for this same inode gets cancelled
895            by ldlm_cancel_lru */
896         if (!S_ISREG(inode->i_mode))
897                 GOTO(out_och_free, rc);
898         cl_lov_delay_create_clear(&file->f_flags);
899         GOTO(out_och_free, rc);
900
901 out_och_free:
902         if (rc) {
903                 if (och_p && *och_p) {
904                         OBD_FREE(*och_p, sizeof(struct obd_client_handle));
905                         *och_p = NULL; /* OBD_FREE writes some magic there */
906                         (*och_usecount)--;
907                 }
908                 mutex_unlock(&lli->lli_och_mutex);
909
910 out_openerr:
911                 if (lli->lli_opendir_key == fd)
912                         ll_deauthorize_statahead(inode, fd);
913
914                 if (fd != NULL)
915                         ll_file_data_put(fd);
916         } else {
917                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN,
918                                    ktime_us_delta(ktime_get(), kstart));
919         }
920
921 out_nofiledata:
922         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
923                 ptlrpc_req_finished(it->it_request);
924                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
925         }
926
927         return rc;
928 }
929
930 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
931                         struct ldlm_lock_desc *desc, void *data, int flag)
932 {
933         int rc;
934         struct lustre_handle lockh;
935         ENTRY;
936
937         switch (flag) {
938         case LDLM_CB_BLOCKING:
939                 ldlm_lock2handle(lock, &lockh);
940                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
941                 if (rc < 0) {
942                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
943                         RETURN(rc);
944                 }
945                 break;
946         case LDLM_CB_CANCELING:
947                 /* do nothing */
948                 break;
949         }
950         RETURN(0);
951 }
952
953 /**
954  * When setting a lease on a file, we take ownership of the lli_mds_*_och
955  * and save it as fd->fd_och so as to force client to reopen the file even
956  * if it has an open lock in cache already.
957  */
958 static int ll_lease_och_acquire(struct inode *inode, struct file *file,
959                                 struct lustre_handle *old_open_handle)
960 {
961         struct ll_inode_info *lli = ll_i2info(inode);
962         struct ll_file_data *fd = file->private_data;
963         struct obd_client_handle **och_p;
964         __u64 *och_usecount;
965         int rc = 0;
966         ENTRY;
967
968         /* Get the openhandle of the file */
969         mutex_lock(&lli->lli_och_mutex);
970         if (fd->fd_lease_och != NULL)
971                 GOTO(out_unlock, rc = -EBUSY);
972
973         if (fd->fd_och == NULL) {
974                 if (file->f_mode & FMODE_WRITE) {
975                         LASSERT(lli->lli_mds_write_och != NULL);
976                         och_p = &lli->lli_mds_write_och;
977                         och_usecount = &lli->lli_open_fd_write_count;
978                 } else {
979                         LASSERT(lli->lli_mds_read_och != NULL);
980                         och_p = &lli->lli_mds_read_och;
981                         och_usecount = &lli->lli_open_fd_read_count;
982                 }
983
984                 if (*och_usecount > 1)
985                         GOTO(out_unlock, rc = -EBUSY);
986
987                 fd->fd_och = *och_p;
988                 *och_usecount = 0;
989                 *och_p = NULL;
990         }
991
992         *old_open_handle = fd->fd_och->och_open_handle;
993
994         EXIT;
995 out_unlock:
996         mutex_unlock(&lli->lli_och_mutex);
997         return rc;
998 }
999
1000 /**
1001  * Release ownership on lli_mds_*_och when putting back a file lease.
1002  */
1003 static int ll_lease_och_release(struct inode *inode, struct file *file)
1004 {
1005         struct ll_inode_info *lli = ll_i2info(inode);
1006         struct ll_file_data *fd = file->private_data;
1007         struct obd_client_handle **och_p;
1008         struct obd_client_handle *old_och = NULL;
1009         __u64 *och_usecount;
1010         int rc = 0;
1011         ENTRY;
1012
1013         mutex_lock(&lli->lli_och_mutex);
1014         if (file->f_mode & FMODE_WRITE) {
1015                 och_p = &lli->lli_mds_write_och;
1016                 och_usecount = &lli->lli_open_fd_write_count;
1017         } else {
1018                 och_p = &lli->lli_mds_read_och;
1019                 och_usecount = &lli->lli_open_fd_read_count;
1020         }
1021
1022         /* The file may have been open by another process (broken lease) so
1023          * *och_p is not NULL. In this case we should simply increase usecount
1024          * and close fd_och.
1025          */
1026         if (*och_p != NULL) {
1027                 old_och = fd->fd_och;
1028                 (*och_usecount)++;
1029         } else {
1030                 *och_p = fd->fd_och;
1031                 *och_usecount = 1;
1032         }
1033         fd->fd_och = NULL;
1034         mutex_unlock(&lli->lli_och_mutex);
1035
1036         if (old_och != NULL)
1037                 rc = ll_close_inode_openhandle(inode, old_och, 0, NULL);
1038
1039         RETURN(rc);
1040 }
1041
1042 /**
1043  * Acquire a lease and open the file.
1044  */
1045 static struct obd_client_handle *
1046 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
1047               __u64 open_flags)
1048 {
1049         struct lookup_intent it = { .it_op = IT_OPEN };
1050         struct ll_sb_info *sbi = ll_i2sbi(inode);
1051         struct md_op_data *op_data;
1052         struct ptlrpc_request *req = NULL;
1053         struct lustre_handle old_open_handle = { 0 };
1054         struct obd_client_handle *och = NULL;
1055         int rc;
1056         int rc2;
1057         ENTRY;
1058
1059         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
1060                 RETURN(ERR_PTR(-EINVAL));
1061
1062         if (file != NULL) {
1063                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
1064                         RETURN(ERR_PTR(-EPERM));
1065
1066                 rc = ll_lease_och_acquire(inode, file, &old_open_handle);
1067                 if (rc)
1068                         RETURN(ERR_PTR(rc));
1069         }
1070
1071         OBD_ALLOC_PTR(och);
1072         if (och == NULL)
1073                 RETURN(ERR_PTR(-ENOMEM));
1074
1075         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
1076                                         LUSTRE_OPC_ANY, NULL);
1077         if (IS_ERR(op_data))
1078                 GOTO(out, rc = PTR_ERR(op_data));
1079
1080         /* To tell the MDT this openhandle is from the same owner */
1081         op_data->op_open_handle = old_open_handle;
1082
1083         it.it_flags = fmode | open_flags;
1084         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
1085         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
1086                             &ll_md_blocking_lease_ast,
1087         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
1088          * it can be cancelled which may mislead applications that the lease is
1089          * broken;
1090          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
1091          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
1092          * doesn't deal with openhandle, so normal openhandle will be leaked. */
1093                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
1094         ll_finish_md_op_data(op_data);
1095         ptlrpc_req_finished(req);
1096         if (rc < 0)
1097                 GOTO(out_release_it, rc);
1098
1099         if (it_disposition(&it, DISP_LOOKUP_NEG))
1100                 GOTO(out_release_it, rc = -ENOENT);
1101
1102         rc = it_open_error(DISP_OPEN_OPEN, &it);
1103         if (rc)
1104                 GOTO(out_release_it, rc);
1105
1106         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
1107         rc = ll_och_fill(sbi->ll_md_exp, &it, och);
1108         if (rc)
1109                 GOTO(out_release_it, rc);
1110
1111         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
1112                 GOTO(out_close, rc = -EOPNOTSUPP);
1113
1114         /* already get lease, handle lease lock */
1115         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
1116         if (it.it_lock_mode == 0 ||
1117             it.it_lock_bits != MDS_INODELOCK_OPEN) {
1118                 /* open lock must return for lease */
1119                 CERROR(DFID "lease granted but no open lock, %d/%llu.\n",
1120                         PFID(ll_inode2fid(inode)), it.it_lock_mode,
1121                         it.it_lock_bits);
1122                 GOTO(out_close, rc = -EPROTO);
1123         }
1124
1125         ll_intent_release(&it);
1126         RETURN(och);
1127
1128 out_close:
1129         /* Cancel open lock */
1130         if (it.it_lock_mode != 0) {
1131                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
1132                                             it.it_lock_mode);
1133                 it.it_lock_mode = 0;
1134                 och->och_lease_handle.cookie = 0ULL;
1135         }
1136         rc2 = ll_close_inode_openhandle(inode, och, 0, NULL);
1137         if (rc2 < 0)
1138                 CERROR("%s: error closing file "DFID": %d\n",
1139                        sbi->ll_fsname, PFID(&ll_i2info(inode)->lli_fid), rc2);
1140         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
1141 out_release_it:
1142         ll_intent_release(&it);
1143 out:
1144         if (och != NULL)
1145                 OBD_FREE_PTR(och);
1146         RETURN(ERR_PTR(rc));
1147 }
1148
1149 /**
1150  * Check whether a layout swap can be done between two inodes.
1151  *
1152  * \param[in] inode1  First inode to check
1153  * \param[in] inode2  Second inode to check
1154  *
1155  * \retval 0 on success, layout swap can be performed between both inodes
1156  * \retval negative error code if requirements are not met
1157  */
1158 static int ll_check_swap_layouts_validity(struct inode *inode1,
1159                                           struct inode *inode2)
1160 {
1161         if (!S_ISREG(inode1->i_mode) || !S_ISREG(inode2->i_mode))
1162                 return -EINVAL;
1163
1164         if (inode_permission(inode1, MAY_WRITE) ||
1165             inode_permission(inode2, MAY_WRITE))
1166                 return -EPERM;
1167
1168         if (inode1->i_sb != inode2->i_sb)
1169                 return -EXDEV;
1170
1171         return 0;
1172 }
1173
1174 static int ll_swap_layouts_close(struct obd_client_handle *och,
1175                                  struct inode *inode, struct inode *inode2)
1176 {
1177         const struct lu_fid     *fid1 = ll_inode2fid(inode);
1178         const struct lu_fid     *fid2;
1179         int                      rc;
1180         ENTRY;
1181
1182         CDEBUG(D_INODE, "%s: biased close of file "DFID"\n",
1183                ll_i2sbi(inode)->ll_fsname, PFID(fid1));
1184
1185         rc = ll_check_swap_layouts_validity(inode, inode2);
1186         if (rc < 0)
1187                 GOTO(out_free_och, rc);
1188
1189         /* We now know that inode2 is a lustre inode */
1190         fid2 = ll_inode2fid(inode2);
1191
1192         rc = lu_fid_cmp(fid1, fid2);
1193         if (rc == 0)
1194                 GOTO(out_free_och, rc = -EINVAL);
1195
1196         /* Close the file and {swap,merge} layouts between inode & inode2.
1197          * NB: lease lock handle is released in mdc_close_layout_swap_pack()
1198          * because we still need it to pack l_remote_handle to MDT. */
1199         rc = ll_close_inode_openhandle(inode, och, MDS_CLOSE_LAYOUT_SWAP,
1200                                        inode2);
1201
1202         och = NULL; /* freed in ll_close_inode_openhandle() */
1203
1204 out_free_och:
1205         if (och != NULL)
1206                 OBD_FREE_PTR(och);
1207
1208         RETURN(rc);
1209 }
1210
1211 /**
1212  * Release lease and close the file.
1213  * It will check if the lease has ever broken.
1214  */
1215 static int ll_lease_close_intent(struct obd_client_handle *och,
1216                                  struct inode *inode,
1217                                  bool *lease_broken, enum mds_op_bias bias,
1218                                  void *data)
1219 {
1220         struct ldlm_lock *lock;
1221         bool cancelled = true;
1222         int rc;
1223         ENTRY;
1224
1225         lock = ldlm_handle2lock(&och->och_lease_handle);
1226         if (lock != NULL) {
1227                 lock_res_and_lock(lock);
1228                 cancelled = ldlm_is_cancel(lock);
1229                 unlock_res_and_lock(lock);
1230                 LDLM_LOCK_PUT(lock);
1231         }
1232
1233         CDEBUG(D_INODE, "lease for "DFID" broken? %d, bias: %x\n",
1234                PFID(&ll_i2info(inode)->lli_fid), cancelled, bias);
1235
1236         if (lease_broken != NULL)
1237                 *lease_broken = cancelled;
1238
1239         if (!cancelled && !bias)
1240                 ldlm_cli_cancel(&och->och_lease_handle, 0);
1241
1242         if (cancelled) { /* no need to excute intent */
1243                 bias = 0;
1244                 data = NULL;
1245         }
1246
1247         rc = ll_close_inode_openhandle(inode, och, bias, data);
1248         RETURN(rc);
1249 }
1250
1251 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
1252                           bool *lease_broken)
1253 {
1254         return ll_lease_close_intent(och, inode, lease_broken, 0, NULL);
1255 }
1256
1257 /**
1258  * After lease is taken, send the RPC MDS_REINT_RESYNC to the MDT
1259  */
1260 static int ll_lease_file_resync(struct obd_client_handle *och,
1261                                 struct inode *inode, unsigned long arg)
1262 {
1263         struct ll_sb_info *sbi = ll_i2sbi(inode);
1264         struct md_op_data *op_data;
1265         struct ll_ioc_lease_id ioc;
1266         __u64 data_version_unused;
1267         int rc;
1268         ENTRY;
1269
1270         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
1271                                      LUSTRE_OPC_ANY, NULL);
1272         if (IS_ERR(op_data))
1273                 RETURN(PTR_ERR(op_data));
1274
1275         if (copy_from_user(&ioc, (struct ll_ioc_lease_id __user *)arg,
1276                            sizeof(ioc)))
1277                 RETURN(-EFAULT);
1278
1279         /* before starting file resync, it's necessary to clean up page cache
1280          * in client memory, otherwise once the layout version is increased,
1281          * writing back cached data will be denied the OSTs. */
1282         rc = ll_data_version(inode, &data_version_unused, LL_DV_WR_FLUSH);
1283         if (rc)
1284                 GOTO(out, rc);
1285
1286         op_data->op_lease_handle = och->och_lease_handle;
1287         op_data->op_mirror_id = ioc.lil_mirror_id;
1288         rc = md_file_resync(sbi->ll_md_exp, op_data);
1289         if (rc)
1290                 GOTO(out, rc);
1291
1292         EXIT;
1293 out:
1294         ll_finish_md_op_data(op_data);
1295         return rc;
1296 }
1297
1298 int ll_merge_attr(const struct lu_env *env, struct inode *inode)
1299 {
1300         struct ll_inode_info *lli = ll_i2info(inode);
1301         struct cl_object *obj = lli->lli_clob;
1302         struct cl_attr *attr = vvp_env_thread_attr(env);
1303         s64 atime;
1304         s64 mtime;
1305         s64 ctime;
1306         int rc = 0;
1307
1308         ENTRY;
1309
1310         ll_inode_size_lock(inode);
1311
1312         /* Merge timestamps the most recently obtained from MDS with
1313          * timestamps obtained from OSTs.
1314          *
1315          * Do not overwrite atime of inode because it may be refreshed
1316          * by file_accessed() function. If the read was served by cache
1317          * data, there is no RPC to be sent so that atime may not be
1318          * transferred to OSTs at all. MDT only updates atime at close time
1319          * if it's at least 'mdd.*.atime_diff' older.
1320          * All in all, the atime in Lustre does not strictly comply with
1321          * POSIX. Solving this problem needs to send an RPC to MDT for each
1322          * read, this will hurt performance.
1323          */
1324         if (ll_file_test_and_clear_flag(lli, LLIF_UPDATE_ATIME) ||
1325             inode->i_atime.tv_sec < lli->lli_atime)
1326                 inode->i_atime.tv_sec = lli->lli_atime;
1327
1328         inode->i_mtime.tv_sec = lli->lli_mtime;
1329         inode->i_ctime.tv_sec = lli->lli_ctime;
1330
1331         mtime = inode->i_mtime.tv_sec;
1332         atime = inode->i_atime.tv_sec;
1333         ctime = inode->i_ctime.tv_sec;
1334
1335         cl_object_attr_lock(obj);
1336         if (OBD_FAIL_CHECK(OBD_FAIL_MDC_MERGE))
1337                 rc = -EINVAL;
1338         else
1339                 rc = cl_object_attr_get(env, obj, attr);
1340         cl_object_attr_unlock(obj);
1341
1342         if (rc != 0)
1343                 GOTO(out_size_unlock, rc = (rc == -ENODATA ? 0 : rc));
1344
1345         if (atime < attr->cat_atime)
1346                 atime = attr->cat_atime;
1347
1348         if (ctime < attr->cat_ctime)
1349                 ctime = attr->cat_ctime;
1350
1351         if (mtime < attr->cat_mtime)
1352                 mtime = attr->cat_mtime;
1353
1354         CDEBUG(D_VFSTRACE, DFID" updating i_size %llu\n",
1355                PFID(&lli->lli_fid), attr->cat_size);
1356
1357         i_size_write(inode, attr->cat_size);
1358         inode->i_blocks = attr->cat_blocks;
1359
1360         inode->i_mtime.tv_sec = mtime;
1361         inode->i_atime.tv_sec = atime;
1362         inode->i_ctime.tv_sec = ctime;
1363
1364 out_size_unlock:
1365         ll_inode_size_unlock(inode);
1366
1367         RETURN(rc);
1368 }
1369
1370 /**
1371  * Set designated mirror for I/O.
1372  *
1373  * So far only read, write, and truncated can support to issue I/O to
1374  * designated mirror.
1375  */
1376 void ll_io_set_mirror(struct cl_io *io, const struct file *file)
1377 {
1378         struct ll_file_data *fd = file->private_data;
1379
1380         /* clear layout version for generic(non-resync) I/O in case it carries
1381          * stale layout version due to I/O restart */
1382         io->ci_layout_version = 0;
1383
1384         /* FLR: disable non-delay for designated mirror I/O because obviously
1385          * only one mirror is available */
1386         if (fd->fd_designated_mirror > 0) {
1387                 io->ci_ndelay = 0;
1388                 io->ci_designated_mirror = fd->fd_designated_mirror;
1389                 io->ci_layout_version = fd->fd_layout_version;
1390         }
1391
1392         CDEBUG(D_VFSTRACE, "%s: desiginated mirror: %d\n",
1393                file->f_path.dentry->d_name.name, io->ci_designated_mirror);
1394 }
1395
1396 static bool file_is_noatime(const struct file *file)
1397 {
1398         const struct vfsmount *mnt = file->f_path.mnt;
1399         const struct inode *inode = file_inode((struct file *)file);
1400
1401         /* Adapted from file_accessed() and touch_atime().*/
1402         if (file->f_flags & O_NOATIME)
1403                 return true;
1404
1405         if (inode->i_flags & S_NOATIME)
1406                 return true;
1407
1408         if (IS_NOATIME(inode))
1409                 return true;
1410
1411         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1412                 return true;
1413
1414         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1415                 return true;
1416
1417         if ((inode->i_sb->s_flags & SB_NODIRATIME) && S_ISDIR(inode->i_mode))
1418                 return true;
1419
1420         return false;
1421 }
1422
1423 void ll_io_init(struct cl_io *io, struct file *file, enum cl_io_type iot,
1424                 struct vvp_io_args *args)
1425 {
1426         struct inode *inode = file_inode(file);
1427         struct ll_file_data *fd  = file->private_data;
1428
1429         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
1430         io->ci_lock_no_expand = fd->ll_lock_no_expand;
1431
1432         if (iot == CIT_WRITE) {
1433                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
1434                 io->u.ci_wr.wr_sync   = !!(file->f_flags & O_SYNC ||
1435                                            file->f_flags & O_DIRECT ||
1436                                            IS_SYNC(inode));
1437 #ifdef HAVE_GENERIC_WRITE_SYNC_2ARGS
1438                 io->u.ci_wr.wr_sync  |= !!(args &&
1439                                            args->via_io_subtype == IO_NORMAL &&
1440                                            args->u.normal.via_iocb->ki_flags & IOCB_DSYNC);
1441 #endif
1442         }
1443
1444         io->ci_obj = ll_i2info(inode)->lli_clob;
1445         io->ci_lockreq = CILR_MAYBE;
1446         if (ll_file_nolock(file)) {
1447                 io->ci_lockreq = CILR_NEVER;
1448                 io->ci_no_srvlock = 1;
1449         } else if (file->f_flags & O_APPEND) {
1450                 io->ci_lockreq = CILR_MANDATORY;
1451         }
1452         io->ci_noatime = file_is_noatime(file);
1453         io->ci_async_readahead = false;
1454
1455         /* FLR: only use non-delay I/O for read as there is only one
1456          * avaliable mirror for write. */
1457         io->ci_ndelay = !(iot == CIT_WRITE);
1458
1459         ll_io_set_mirror(io, file);
1460 }
1461
1462 static void ll_heat_add(struct inode *inode, enum cl_io_type iot,
1463                         __u64 count)
1464 {
1465         struct ll_inode_info *lli = ll_i2info(inode);
1466         struct ll_sb_info *sbi = ll_i2sbi(inode);
1467         enum obd_heat_type sample_type;
1468         enum obd_heat_type iobyte_type;
1469         __u64 now = ktime_get_real_seconds();
1470
1471         if (!ll_sbi_has_file_heat(sbi) ||
1472             lli->lli_heat_flags & LU_HEAT_FLAG_OFF)
1473                 return;
1474
1475         if (iot == CIT_READ) {
1476                 sample_type = OBD_HEAT_READSAMPLE;
1477                 iobyte_type = OBD_HEAT_READBYTE;
1478         } else if (iot == CIT_WRITE) {
1479                 sample_type = OBD_HEAT_WRITESAMPLE;
1480                 iobyte_type = OBD_HEAT_WRITEBYTE;
1481         } else {
1482                 return;
1483         }
1484
1485         spin_lock(&lli->lli_heat_lock);
1486         obd_heat_add(&lli->lli_heat_instances[sample_type], now, 1,
1487                      sbi->ll_heat_decay_weight, sbi->ll_heat_period_second);
1488         obd_heat_add(&lli->lli_heat_instances[iobyte_type], now, count,
1489                      sbi->ll_heat_decay_weight, sbi->ll_heat_period_second);
1490         spin_unlock(&lli->lli_heat_lock);
1491 }
1492
1493 static ssize_t
1494 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1495                    struct file *file, enum cl_io_type iot,
1496                    loff_t *ppos, size_t count)
1497 {
1498         struct vvp_io *vio = vvp_env_io(env);
1499         struct inode *inode = file_inode(file);
1500         struct ll_inode_info *lli = ll_i2info(inode);
1501         struct ll_file_data *fd  = file->private_data;
1502         struct range_lock range;
1503         struct cl_io *io;
1504         ssize_t result = 0;
1505         int rc = 0;
1506         unsigned int retried = 0, ignore_lockless = 0;
1507         bool is_aio = false;
1508
1509         ENTRY;
1510
1511         CDEBUG(D_VFSTRACE, "%s: %s ppos: %llu, count: %zu\n",
1512                 file_dentry(file)->d_name.name,
1513                 iot == CIT_READ ? "read" : "write", *ppos, count);
1514
1515 restart:
1516         io = vvp_env_thread_io(env);
1517         ll_io_init(io, file, iot, args);
1518         io->ci_ignore_lockless = ignore_lockless;
1519         io->ci_ndelay_tried = retried;
1520
1521         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
1522                 bool range_locked = false;
1523
1524                 if (file->f_flags & O_APPEND)
1525                         range_lock_init(&range, 0, LUSTRE_EOF);
1526                 else
1527                         range_lock_init(&range, *ppos, *ppos + count - 1);
1528
1529                 vio->vui_fd  = file->private_data;
1530                 vio->vui_io_subtype = args->via_io_subtype;
1531
1532                 switch (vio->vui_io_subtype) {
1533                 case IO_NORMAL:
1534                         vio->vui_iter = args->u.normal.via_iter;
1535                         vio->vui_iocb = args->u.normal.via_iocb;
1536                         if (file->f_flags & O_DIRECT) {
1537                                 if (!is_sync_kiocb(vio->vui_iocb))
1538                                         is_aio = true;
1539                                 io->ci_aio = cl_aio_alloc(vio->vui_iocb);
1540                                 if (!io->ci_aio)
1541                                         GOTO(out, rc = -ENOMEM);
1542                         }
1543                         /* Direct IO reads must also take range lock,
1544                          * or multiple reads will try to work on the same pages
1545                          * See LU-6227 for details. */
1546                         if (((iot == CIT_WRITE) ||
1547                             (iot == CIT_READ && (file->f_flags & O_DIRECT))) &&
1548                             !(vio->vui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1549                                 CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1550                                        RL_PARA(&range));
1551                                 rc = range_lock(&lli->lli_write_tree, &range);
1552                                 if (rc < 0)
1553                                         GOTO(out, rc);
1554
1555                                 range_locked = true;
1556                         }
1557                         break;
1558                 case IO_SPLICE:
1559                         vio->u.splice.vui_pipe = args->u.splice.via_pipe;
1560                         vio->u.splice.vui_flags = args->u.splice.via_flags;
1561                         break;
1562                 default:
1563                         CERROR("unknown IO subtype %u\n", vio->vui_io_subtype);
1564                         LBUG();
1565                 }
1566
1567                 ll_cl_add(file, env, io, LCC_RW);
1568                 rc = cl_io_loop(env, io);
1569                 ll_cl_remove(file, env);
1570
1571                 if (range_locked) {
1572                         CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1573                                RL_PARA(&range));
1574                         range_unlock(&lli->lli_write_tree, &range);
1575                 }
1576         } else {
1577                 /* cl_io_rw_init() handled IO */
1578                 rc = io->ci_result;
1579         }
1580
1581         /*
1582          * In order to move forward AIO, ci_nob was increased,
1583          * but that doesn't mean io have been finished, it just
1584          * means io have been submited, we will always return
1585          * EIOCBQUEUED to the caller, So we could only return
1586          * number of bytes in non-AIO case.
1587          */
1588         if (io->ci_nob > 0 && !is_aio) {
1589                 result += io->ci_nob;
1590                 count  -= io->ci_nob;
1591                 *ppos = io->u.ci_wr.wr.crw_pos; /* for splice */
1592
1593                 /* prepare IO restart */
1594                 if (count > 0 && args->via_io_subtype == IO_NORMAL)
1595                         args->u.normal.via_iter = vio->vui_iter;
1596         }
1597 out:
1598         if (io->ci_aio) {
1599                 /**
1600                  * Drop one extra reference so that end_io() could be
1601                  * called for this IO context, we could call it after
1602                  * we make sure all AIO requests have been proceed.
1603                  */
1604                 cl_sync_io_note(env, &io->ci_aio->cda_sync,
1605                                 rc == -EIOCBQUEUED ? 0 : rc);
1606                 if (!is_aio) {
1607                         cl_aio_free(io->ci_aio);
1608                         io->ci_aio = NULL;
1609                 }
1610         }
1611         cl_io_fini(env, io);
1612
1613         CDEBUG(D_VFSTRACE,
1614                "%s: %d io complete with rc: %d, result: %zd, restart: %d\n",
1615                file->f_path.dentry->d_name.name,
1616                iot, rc, result, io->ci_need_restart);
1617
1618         if ((rc == 0 || rc == -ENODATA || rc == -ENOLCK) &&
1619             count > 0 && io->ci_need_restart) {
1620                 CDEBUG(D_VFSTRACE,
1621                        "%s: restart %s from %lld, count: %zu, ret: %zd, rc: %d\n",
1622                        file_dentry(file)->d_name.name,
1623                        iot == CIT_READ ? "read" : "write",
1624                        *ppos, count, result, rc);
1625                 /* preserve the tried count for FLR */
1626                 retried = io->ci_ndelay_tried;
1627                 ignore_lockless = io->ci_ignore_lockless;
1628                 goto restart;
1629         }
1630
1631         if (iot == CIT_READ) {
1632                 if (result > 0)
1633                         ll_stats_ops_tally(ll_i2sbi(inode),
1634                                            LPROC_LL_READ_BYTES, result);
1635         } else if (iot == CIT_WRITE) {
1636                 if (result > 0) {
1637                         ll_stats_ops_tally(ll_i2sbi(inode),
1638                                            LPROC_LL_WRITE_BYTES, result);
1639                         fd->fd_write_failed = false;
1640                 } else if (result == 0 && rc == 0) {
1641                         rc = io->ci_result;
1642                         if (rc < 0)
1643                                 fd->fd_write_failed = true;
1644                         else
1645                                 fd->fd_write_failed = false;
1646                 } else if (rc != -ERESTARTSYS) {
1647                         fd->fd_write_failed = true;
1648                 }
1649         }
1650
1651         CDEBUG(D_VFSTRACE, "iot: %d, result: %zd\n", iot, result);
1652         if (result > 0)
1653                 ll_heat_add(inode, iot, result);
1654
1655         RETURN(result > 0 ? result : rc);
1656 }
1657
1658 /**
1659  * The purpose of fast read is to overcome per I/O overhead and improve IOPS
1660  * especially for small I/O.
1661  *
1662  * To serve a read request, CLIO has to create and initialize a cl_io and
1663  * then request DLM lock. This has turned out to have siginificant overhead
1664  * and affects the performance of small I/O dramatically.
1665  *
1666  * It's not necessary to create a cl_io for each I/O. Under the help of read
1667  * ahead, most of the pages being read are already in memory cache and we can
1668  * read those pages directly because if the pages exist, the corresponding DLM
1669  * lock must exist so that page content must be valid.
1670  *
1671  * In fast read implementation, the llite speculatively finds and reads pages
1672  * in memory cache. There are three scenarios for fast read:
1673  *   - If the page exists and is uptodate, kernel VM will provide the data and
1674  *     CLIO won't be intervened;
1675  *   - If the page was brought into memory by read ahead, it will be exported
1676  *     and read ahead parameters will be updated;
1677  *   - Otherwise the page is not in memory, we can't do fast read. Therefore,
1678  *     it will go back and invoke normal read, i.e., a cl_io will be created
1679  *     and DLM lock will be requested.
1680  *
1681  * POSIX compliance: posix standard states that read is intended to be atomic.
1682  * Lustre read implementation is in line with Linux kernel read implementation
1683  * and neither of them complies with POSIX standard in this matter. Fast read
1684  * doesn't make the situation worse on single node but it may interleave write
1685  * results from multiple nodes due to short read handling in ll_file_aio_read().
1686  *
1687  * \param env - lu_env
1688  * \param iocb - kiocb from kernel
1689  * \param iter - user space buffers where the data will be copied
1690  *
1691  * \retval - number of bytes have been read, or error code if error occurred.
1692  */
1693 static ssize_t
1694 ll_do_fast_read(struct kiocb *iocb, struct iov_iter *iter)
1695 {
1696         ssize_t result;
1697
1698         if (!ll_sbi_has_fast_read(ll_i2sbi(file_inode(iocb->ki_filp))))
1699                 return 0;
1700
1701         /* NB: we can't do direct IO for fast read because it will need a lock
1702          * to make IO engine happy. */
1703         if (iocb->ki_filp->f_flags & O_DIRECT)
1704                 return 0;
1705
1706         result = generic_file_read_iter(iocb, iter);
1707
1708         /* If the first page is not in cache, generic_file_aio_read() will be
1709          * returned with -ENODATA.
1710          * See corresponding code in ll_readpage(). */
1711         if (result == -ENODATA)
1712                 result = 0;
1713
1714         if (result > 0) {
1715                 ll_heat_add(file_inode(iocb->ki_filp), CIT_READ, result);
1716                 ll_stats_ops_tally(ll_i2sbi(file_inode(iocb->ki_filp)),
1717                                    LPROC_LL_READ_BYTES, result);
1718         }
1719
1720         return result;
1721 }
1722
1723 /*
1724  * Read from a file (through the page cache).
1725  */
1726 static ssize_t ll_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
1727 {
1728         struct lu_env *env;
1729         struct vvp_io_args *args;
1730         struct file *file = iocb->ki_filp;
1731         ssize_t result;
1732         ssize_t rc2;
1733         __u16 refcheck;
1734         ktime_t kstart = ktime_get();
1735         bool cached;
1736
1737         if (!iov_iter_count(to))
1738                 return 0;
1739
1740         /**
1741          * Currently when PCC read failed, we do not fall back to the
1742          * normal read path, just return the error.
1743          * The resaon is that: for RW-PCC, the file data may be modified
1744          * in the PCC and inconsistent with the data on OSTs (or file
1745          * data has been removed from the Lustre file system), at this
1746          * time, fallback to the normal read path may read the wrong
1747          * data.
1748          * TODO: for RO-PCC (readonly PCC), fall back to normal read
1749          * path: read data from data copy on OSTs.
1750          */
1751         result = pcc_file_read_iter(iocb, to, &cached);
1752         if (cached)
1753                 GOTO(out, result);
1754
1755         ll_ras_enter(file, iocb->ki_pos, iov_iter_count(to));
1756
1757         result = ll_do_fast_read(iocb, to);
1758         if (result < 0 || iov_iter_count(to) == 0)
1759                 GOTO(out, result);
1760
1761         env = cl_env_get(&refcheck);
1762         if (IS_ERR(env))
1763                 return PTR_ERR(env);
1764
1765         args = ll_env_args(env, IO_NORMAL);
1766         args->u.normal.via_iter = to;
1767         args->u.normal.via_iocb = iocb;
1768
1769         rc2 = ll_file_io_generic(env, args, file, CIT_READ,
1770                                  &iocb->ki_pos, iov_iter_count(to));
1771         if (rc2 > 0)
1772                 result += rc2;
1773         else if (result == 0)
1774                 result = rc2;
1775
1776         cl_env_put(env, &refcheck);
1777 out:
1778         if (result > 0) {
1779                 ll_rw_stats_tally(ll_i2sbi(file_inode(file)), current->pid,
1780                                   file->private_data, iocb->ki_pos, result,
1781                                   READ);
1782                 ll_stats_ops_tally(ll_i2sbi(file_inode(file)), LPROC_LL_READ,
1783                                    ktime_us_delta(ktime_get(), kstart));
1784         }
1785
1786         return result;
1787 }
1788
1789 /**
1790  * Similar trick to ll_do_fast_read, this improves write speed for tiny writes.
1791  * If a page is already in the page cache and dirty (and some other things -
1792  * See ll_tiny_write_begin for the instantiation of these rules), then we can
1793  * write to it without doing a full I/O, because Lustre already knows about it
1794  * and will write it out.  This saves a lot of processing time.
1795  *
1796  * All writes here are within one page, so exclusion is handled by the page
1797  * lock on the vm page.  We do not do tiny writes for writes which touch
1798  * multiple pages because it's very unlikely multiple sequential pages are
1799  * are already dirty.
1800  *
1801  * We limit these to < PAGE_SIZE because PAGE_SIZE writes are relatively common
1802  * and are unlikely to be to already dirty pages.
1803  *
1804  * Attribute updates are important here, we do them in ll_tiny_write_end.
1805  */
1806 static ssize_t ll_do_tiny_write(struct kiocb *iocb, struct iov_iter *iter)
1807 {
1808         ssize_t count = iov_iter_count(iter);
1809         struct  file *file = iocb->ki_filp;
1810         struct  inode *inode = file_inode(file);
1811         bool    lock_inode = !IS_NOSEC(inode);
1812         ssize_t result = 0;
1813
1814         ENTRY;
1815
1816         /* Restrict writes to single page and < PAGE_SIZE.  See comment at top
1817          * of function for why.
1818          */
1819         if (count >= PAGE_SIZE ||
1820             (iocb->ki_pos & (PAGE_SIZE-1)) + count > PAGE_SIZE)
1821                 RETURN(0);
1822
1823         if (unlikely(lock_inode))
1824                 inode_lock(inode);
1825         result = __generic_file_write_iter(iocb, iter);
1826
1827         if (unlikely(lock_inode))
1828                 inode_unlock(inode);
1829
1830         /* If the page is not already dirty, ll_tiny_write_begin returns
1831          * -ENODATA.  We continue on to normal write.
1832          */
1833         if (result == -ENODATA)
1834                 result = 0;
1835
1836         if (result > 0) {
1837                 ll_heat_add(inode, CIT_WRITE, result);
1838                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_WRITE_BYTES,
1839                                    result);
1840                 ll_file_set_flag(ll_i2info(inode), LLIF_DATA_MODIFIED);
1841         }
1842
1843         CDEBUG(D_VFSTRACE, "result: %zu, original count %zu\n", result, count);
1844
1845         RETURN(result);
1846 }
1847
1848 /*
1849  * Write to a file (through the page cache).
1850  */
1851 static ssize_t ll_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
1852 {
1853         struct vvp_io_args *args;
1854         struct lu_env *env;
1855         ssize_t rc_tiny = 0, rc_normal;
1856         struct file *file = iocb->ki_filp;
1857         __u16 refcheck;
1858         bool cached;
1859         ktime_t kstart = ktime_get();
1860         int result;
1861
1862         ENTRY;
1863
1864         if (!iov_iter_count(from))
1865                 GOTO(out, rc_normal = 0);
1866
1867         /**
1868          * When PCC write failed, we usually do not fall back to the normal
1869          * write path, just return the error. But there is a special case when
1870          * returned error code is -ENOSPC due to running out of space on PCC HSM
1871          * bakcend. At this time, it will fall back to normal I/O path and
1872          * retry the I/O. As the file is in HSM released state, it will restore
1873          * the file data to OSTs first and redo the write again. And the
1874          * restore process will revoke the layout lock and detach the file
1875          * from PCC cache automatically.
1876          */
1877         result = pcc_file_write_iter(iocb, from, &cached);
1878         if (cached && result != -ENOSPC && result != -EDQUOT)
1879                 GOTO(out, rc_normal = result);
1880
1881         /* NB: we can't do direct IO for tiny writes because they use the page
1882          * cache, we can't do sync writes because tiny writes can't flush
1883          * pages, and we can't do append writes because we can't guarantee the
1884          * required DLM locks are held to protect file size.
1885          */
1886         if (ll_sbi_has_tiny_write(ll_i2sbi(file_inode(file))) &&
1887             !(file->f_flags & (O_DIRECT | O_SYNC | O_APPEND)))
1888                 rc_tiny = ll_do_tiny_write(iocb, from);
1889
1890         /* In case of error, go on and try normal write - Only stop if tiny
1891          * write completed I/O.
1892          */
1893         if (iov_iter_count(from) == 0)
1894                 GOTO(out, rc_normal = rc_tiny);
1895
1896         env = cl_env_get(&refcheck);
1897         if (IS_ERR(env))
1898                 return PTR_ERR(env);
1899
1900         args = ll_env_args(env, IO_NORMAL);
1901         args->u.normal.via_iter = from;
1902         args->u.normal.via_iocb = iocb;
1903
1904         rc_normal = ll_file_io_generic(env, args, file, CIT_WRITE,
1905                                        &iocb->ki_pos, iov_iter_count(from));
1906
1907         /* On success, combine bytes written. */
1908         if (rc_tiny >= 0 && rc_normal > 0)
1909                 rc_normal += rc_tiny;
1910         /* On error, only return error from normal write if tiny write did not
1911          * write any bytes.  Otherwise return bytes written by tiny write.
1912          */
1913         else if (rc_tiny > 0)
1914                 rc_normal = rc_tiny;
1915
1916         cl_env_put(env, &refcheck);
1917 out:
1918         if (rc_normal > 0) {
1919                 ll_rw_stats_tally(ll_i2sbi(file_inode(file)), current->pid,
1920                                   file->private_data, iocb->ki_pos,
1921                                   rc_normal, WRITE);
1922                 ll_stats_ops_tally(ll_i2sbi(file_inode(file)), LPROC_LL_WRITE,
1923                                    ktime_us_delta(ktime_get(), kstart));
1924         }
1925
1926         RETURN(rc_normal);
1927 }
1928
1929 #ifndef HAVE_FILE_OPERATIONS_READ_WRITE_ITER
1930 /*
1931  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1932  */
1933 static int ll_file_get_iov_count(const struct iovec *iov,
1934                                  unsigned long *nr_segs, size_t *count,
1935                                  int access_flags)
1936 {
1937         size_t cnt = 0;
1938         unsigned long seg;
1939
1940         for (seg = 0; seg < *nr_segs; seg++) {
1941                 const struct iovec *iv = &iov[seg];
1942
1943                 /*
1944                  * If any segment has a negative length, or the cumulative
1945                  * length ever wraps negative then return -EINVAL.
1946                  */
1947                 cnt += iv->iov_len;
1948                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1949                         return -EINVAL;
1950                 if (access_ok(access_flags, iv->iov_base, iv->iov_len))
1951                         continue;
1952                 if (seg == 0)
1953                         return -EFAULT;
1954                 *nr_segs = seg;
1955                 cnt -= iv->iov_len;     /* This segment is no good */
1956                 break;
1957         }
1958         *count = cnt;
1959         return 0;
1960 }
1961
1962 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1963                                 unsigned long nr_segs, loff_t pos)
1964 {
1965         struct iov_iter to;
1966         size_t iov_count;
1967         ssize_t result;
1968         ENTRY;
1969
1970         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count, VERIFY_READ);
1971         if (result)
1972                 RETURN(result);
1973
1974         if (!iov_count)
1975                 RETURN(0);
1976
1977 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
1978         iov_iter_init(&to, READ, iov, nr_segs, iov_count);
1979 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
1980         iov_iter_init(&to, iov, nr_segs, iov_count, 0);
1981 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
1982
1983         result = ll_file_read_iter(iocb, &to);
1984
1985         RETURN(result);
1986 }
1987
1988 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
1989                             loff_t *ppos)
1990 {
1991         struct iovec   iov = { .iov_base = buf, .iov_len = count };
1992         struct kiocb   kiocb;
1993         ssize_t        result;
1994
1995         ENTRY;
1996
1997         if (!count)
1998                 RETURN(0);
1999
2000         init_sync_kiocb(&kiocb, file);
2001         kiocb.ki_pos = *ppos;
2002 #ifdef HAVE_KIOCB_KI_LEFT
2003         kiocb.ki_left = count;
2004 #elif defined(HAVE_KI_NBYTES)
2005         kiocb.i_nbytes = count;
2006 #endif
2007
2008         result = ll_file_aio_read(&kiocb, &iov, 1, kiocb.ki_pos);
2009         *ppos = kiocb.ki_pos;
2010
2011         RETURN(result);
2012 }
2013
2014 /*
2015  * Write to a file (through the page cache).
2016  * AIO stuff
2017  */
2018 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
2019                                  unsigned long nr_segs, loff_t pos)
2020 {
2021         struct iov_iter from;
2022         size_t iov_count;
2023         ssize_t result;
2024         ENTRY;
2025
2026         result = ll_file_get_iov_count(iov, &nr_segs, &iov_count, VERIFY_WRITE);
2027         if (result)
2028                 RETURN(result);
2029
2030         if (!iov_count)
2031                 RETURN(0);
2032
2033 # ifdef HAVE_IOV_ITER_INIT_DIRECTION
2034         iov_iter_init(&from, WRITE, iov, nr_segs, iov_count);
2035 # else /* !HAVE_IOV_ITER_INIT_DIRECTION */
2036         iov_iter_init(&from, iov, nr_segs, iov_count, 0);
2037 # endif /* HAVE_IOV_ITER_INIT_DIRECTION */
2038
2039         result = ll_file_write_iter(iocb, &from);
2040
2041         RETURN(result);
2042 }
2043
2044 static ssize_t ll_file_write(struct file *file, const char __user *buf,
2045                              size_t count, loff_t *ppos)
2046 {
2047         struct iovec   iov = { .iov_base = (void __user *)buf,
2048                                .iov_len = count };
2049         struct kiocb   kiocb;
2050         ssize_t        result;
2051
2052         ENTRY;
2053
2054         if (!count)
2055                 RETURN(0);
2056
2057         init_sync_kiocb(&kiocb, file);
2058         kiocb.ki_pos = *ppos;
2059 #ifdef HAVE_KIOCB_KI_LEFT
2060         kiocb.ki_left = count;
2061 #elif defined(HAVE_KI_NBYTES)
2062         kiocb.ki_nbytes = count;
2063 #endif
2064
2065         result = ll_file_aio_write(&kiocb, &iov, 1, kiocb.ki_pos);
2066         *ppos = kiocb.ki_pos;
2067
2068         RETURN(result);
2069 }
2070 #endif /* !HAVE_FILE_OPERATIONS_READ_WRITE_ITER */
2071
2072 /*
2073  * Send file content (through pagecache) somewhere with helper
2074  */
2075 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
2076                                    struct pipe_inode_info *pipe, size_t count,
2077                                    unsigned int flags)
2078 {
2079         struct lu_env *env;
2080         struct vvp_io_args *args;
2081         ssize_t result;
2082         __u16 refcheck;
2083         bool cached;
2084
2085         ENTRY;
2086
2087         result = pcc_file_splice_read(in_file, ppos, pipe,
2088                                       count, flags, &cached);
2089         if (cached)
2090                 RETURN(result);
2091
2092         ll_ras_enter(in_file, *ppos, count);
2093
2094         env = cl_env_get(&refcheck);
2095         if (IS_ERR(env))
2096                 RETURN(PTR_ERR(env));
2097
2098         args = ll_env_args(env, IO_SPLICE);
2099         args->u.splice.via_pipe = pipe;
2100         args->u.splice.via_flags = flags;
2101
2102         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
2103         cl_env_put(env, &refcheck);
2104
2105         if (result > 0)
2106                 ll_rw_stats_tally(ll_i2sbi(file_inode(in_file)), current->pid,
2107                                   in_file->private_data, *ppos, result,
2108                                   READ);
2109         RETURN(result);
2110 }
2111
2112 int ll_lov_setstripe_ea_info(struct inode *inode, struct dentry *dentry,
2113                              __u64 flags, struct lov_user_md *lum, int lum_size)
2114 {
2115         struct lookup_intent oit = {
2116                 .it_op = IT_OPEN,
2117                 .it_flags = flags | MDS_OPEN_BY_FID,
2118         };
2119         int rc;
2120         ENTRY;
2121
2122         if ((__swab32(lum->lmm_magic) & le32_to_cpu(LOV_MAGIC_MASK)) ==
2123             le32_to_cpu(LOV_MAGIC_MAGIC)) {
2124                 /* this code will only exist for big-endian systems */
2125                 lustre_swab_lov_user_md(lum, 0);
2126         }
2127
2128         ll_inode_size_lock(inode);
2129         rc = ll_intent_file_open(dentry, lum, lum_size, &oit);
2130         if (rc < 0)
2131                 GOTO(out_unlock, rc);
2132
2133         ll_release_openhandle(dentry, &oit);
2134
2135 out_unlock:
2136         ll_inode_size_unlock(inode);
2137         ll_intent_release(&oit);
2138
2139         RETURN(rc);
2140 }
2141
2142 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
2143                              struct lov_mds_md **lmmp, int *lmm_size,
2144                              struct ptlrpc_request **request)
2145 {
2146         struct ll_sb_info *sbi = ll_i2sbi(inode);
2147         struct mdt_body  *body;
2148         struct lov_mds_md *lmm = NULL;
2149         struct ptlrpc_request *req = NULL;
2150         struct md_op_data *op_data;
2151         int rc, lmmsize;
2152
2153         rc = ll_get_default_mdsize(sbi, &lmmsize);
2154         if (rc)
2155                 RETURN(rc);
2156
2157         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
2158                                      strlen(filename), lmmsize,
2159                                      LUSTRE_OPC_ANY, NULL);
2160         if (IS_ERR(op_data))
2161                 RETURN(PTR_ERR(op_data));
2162
2163         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
2164         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
2165         ll_finish_md_op_data(op_data);
2166         if (rc < 0) {
2167                 CDEBUG(D_INFO, "md_getattr_name failed "
2168                        "on %s: rc %d\n", filename, rc);
2169                 GOTO(out, rc);
2170         }
2171
2172         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
2173         LASSERT(body != NULL); /* checked by mdc_getattr_name */
2174
2175         lmmsize = body->mbo_eadatasize;
2176
2177         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
2178                         lmmsize == 0) {
2179                 GOTO(out, rc = -ENODATA);
2180         }
2181
2182         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
2183         LASSERT(lmm != NULL);
2184
2185         if (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1) &&
2186             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3) &&
2187             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_COMP_V1) &&
2188             lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_FOREIGN))
2189                 GOTO(out, rc = -EPROTO);
2190
2191         /*
2192          * This is coming from the MDS, so is probably in
2193          * little endian.  We convert it to host endian before
2194          * passing it to userspace.
2195          */
2196         if ((lmm->lmm_magic & __swab32(LOV_MAGIC_MAGIC)) ==
2197             __swab32(LOV_MAGIC_MAGIC)) {
2198                 int stripe_count = 0;
2199
2200                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1) ||
2201                     lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
2202                         stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
2203                         if (le32_to_cpu(lmm->lmm_pattern) &
2204                             LOV_PATTERN_F_RELEASED)
2205                                 stripe_count = 0;
2206                 }
2207
2208                 lustre_swab_lov_user_md((struct lov_user_md *)lmm, 0);
2209
2210                 /* if function called for directory - we should
2211                  * avoid swab not existent lsm objects */
2212                 if (lmm->lmm_magic == LOV_MAGIC_V1 && S_ISREG(body->mbo_mode))
2213                         lustre_swab_lov_user_md_objects(
2214                                 ((struct lov_user_md_v1 *)lmm)->lmm_objects,
2215                                 stripe_count);
2216                 else if (lmm->lmm_magic == LOV_MAGIC_V3 &&
2217                          S_ISREG(body->mbo_mode))
2218                         lustre_swab_lov_user_md_objects(
2219                                 ((struct lov_user_md_v3 *)lmm)->lmm_objects,
2220                                 stripe_count);
2221         }
2222
2223 out:
2224         *lmmp = lmm;
2225         *lmm_size = lmmsize;
2226         *request = req;
2227         return rc;
2228 }
2229
2230 static int ll_lov_setea(struct inode *inode, struct file *file,
2231                         void __user *arg)
2232 {
2233         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
2234         struct lov_user_md      *lump;
2235         int                      lum_size = sizeof(struct lov_user_md) +
2236                                             sizeof(struct lov_user_ost_data);
2237         int                      rc;
2238         ENTRY;
2239
2240         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
2241                 RETURN(-EPERM);
2242
2243         OBD_ALLOC_LARGE(lump, lum_size);
2244         if (lump == NULL)
2245                 RETURN(-ENOMEM);
2246
2247         if (copy_from_user(lump, arg, lum_size))
2248                 GOTO(out_lump, rc = -EFAULT);
2249
2250         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, lump,
2251                                       lum_size);
2252         cl_lov_delay_create_clear(&file->f_flags);
2253
2254 out_lump:
2255         OBD_FREE_LARGE(lump, lum_size);
2256         RETURN(rc);
2257 }
2258
2259 static int ll_file_getstripe(struct inode *inode, void __user *lum, size_t size)
2260 {
2261         struct lu_env   *env;
2262         __u16           refcheck;
2263         int             rc;
2264         ENTRY;
2265
2266         env = cl_env_get(&refcheck);
2267         if (IS_ERR(env))
2268                 RETURN(PTR_ERR(env));
2269
2270         rc = cl_object_getstripe(env, ll_i2info(inode)->lli_clob, lum, size);
2271         cl_env_put(env, &refcheck);
2272         RETURN(rc);
2273 }
2274
2275 static int ll_lov_setstripe(struct inode *inode, struct file *file,
2276                             void __user *arg)
2277 {
2278         struct lov_user_md __user *lum = (struct lov_user_md __user *)arg;
2279         struct lov_user_md        *klum;
2280         int                        lum_size, rc;
2281         __u64                      flags = FMODE_WRITE;
2282         ENTRY;
2283
2284         rc = ll_copy_user_md(lum, &klum);
2285         if (rc < 0)
2286                 RETURN(rc);
2287
2288         lum_size = rc;
2289         rc = ll_lov_setstripe_ea_info(inode, file_dentry(file), flags, klum,
2290                                       lum_size);
2291         if (!rc) {
2292                 __u32 gen;
2293
2294                 rc = put_user(0, &lum->lmm_stripe_count);
2295                 if (rc)
2296                         GOTO(out, rc);
2297
2298                 rc = ll_layout_refresh(inode, &gen);
2299                 if (rc)
2300                         GOTO(out, rc);
2301
2302                 rc = ll_file_getstripe(inode, arg, lum_size);
2303                 if (S_ISREG(inode->i_mode) && IS_ENCRYPTED(inode) &&
2304                     ll_i2info(inode)->lli_clob) {
2305                         struct iattr attr = { 0 };
2306
2307                         rc = cl_setattr_ost(ll_i2info(inode)->lli_clob, &attr,
2308                                             OP_XVALID_FLAGS, LUSTRE_ENCRYPT_FL);
2309                 }
2310         }
2311         cl_lov_delay_create_clear(&file->f_flags);
2312
2313 out:
2314         OBD_FREE_LARGE(klum, lum_size);
2315         RETURN(rc);
2316 }
2317
2318
2319 static int
2320 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
2321 {
2322         struct ll_inode_info *lli = ll_i2info(inode);
2323         struct cl_object *obj = lli->lli_clob;
2324         struct ll_file_data *fd = file->private_data;
2325         struct ll_grouplock grouplock;
2326         int rc;
2327         ENTRY;
2328
2329         if (arg == 0) {
2330                 CWARN("group id for group lock must not be 0\n");
2331                 RETURN(-EINVAL);
2332         }
2333
2334         if (ll_file_nolock(file))
2335                 RETURN(-EOPNOTSUPP);
2336 retry:
2337         if (file->f_flags & O_NONBLOCK) {
2338                 if (!mutex_trylock(&lli->lli_group_mutex))
2339                         RETURN(-EAGAIN);
2340         } else
2341                 mutex_lock(&lli->lli_group_mutex);
2342
2343         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
2344                 CWARN("group lock already existed with gid %lu\n",
2345                       fd->fd_grouplock.lg_gid);
2346                 GOTO(out, rc = -EINVAL);
2347         }
2348         if (arg != lli->lli_group_gid && lli->lli_group_users != 0) {
2349                 if (file->f_flags & O_NONBLOCK)
2350                         GOTO(out, rc = -EAGAIN);
2351                 mutex_unlock(&lli->lli_group_mutex);
2352                 wait_var_event(&lli->lli_group_users, !lli->lli_group_users);
2353                 GOTO(retry, rc = 0);
2354         }
2355         LASSERT(fd->fd_grouplock.lg_lock == NULL);
2356
2357         /**
2358          * XXX: group lock needs to protect all OST objects while PFL
2359          * can add new OST objects during the IO, so we'd instantiate
2360          * all OST objects before getting its group lock.
2361          */
2362         if (obj) {
2363                 struct lu_env *env;
2364                 __u16 refcheck;
2365                 struct cl_layout cl = {
2366                         .cl_is_composite = false,
2367                 };
2368                 struct lu_extent ext = {
2369                         .e_start = 0,
2370                         .e_end = OBD_OBJECT_EOF,
2371                 };
2372
2373                 env = cl_env_get(&refcheck);
2374                 if (IS_ERR(env))
2375                         GOTO(out, rc = PTR_ERR(env));
2376
2377                 rc = cl_object_layout_get(env, obj, &cl);
2378                 if (!rc && cl.cl_is_composite)
2379                         rc = ll_layout_write_intent(inode, LAYOUT_INTENT_WRITE,
2380                                                     &ext);
2381
2382                 cl_env_put(env, &refcheck);
2383                 if (rc)
2384                         GOTO(out, rc);
2385         }
2386
2387         rc = cl_get_grouplock(ll_i2info(inode)->lli_clob,
2388                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
2389
2390         if (rc)
2391                 GOTO(out, rc);
2392
2393         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
2394         fd->fd_grouplock = grouplock;
2395         if (lli->lli_group_users == 0)
2396                 lli->lli_group_gid = grouplock.lg_gid;
2397         lli->lli_group_users++;
2398
2399         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
2400 out:
2401         mutex_unlock(&lli->lli_group_mutex);
2402
2403         RETURN(rc);
2404 }
2405
2406 static int ll_put_grouplock(struct inode *inode, struct file *file,
2407                             unsigned long arg)
2408 {
2409         struct ll_inode_info   *lli = ll_i2info(inode);
2410         struct ll_file_data    *fd = file->private_data;
2411         struct ll_grouplock     grouplock;
2412         int                     rc;
2413         ENTRY;
2414
2415         mutex_lock(&lli->lli_group_mutex);
2416         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
2417                 CWARN("no group lock held\n");
2418                 GOTO(out, rc = -EINVAL);
2419         }
2420
2421         LASSERT(fd->fd_grouplock.lg_lock != NULL);
2422
2423         if (fd->fd_grouplock.lg_gid != arg) {
2424                 CWARN("group lock %lu doesn't match current id %lu\n",
2425                       arg, fd->fd_grouplock.lg_gid);
2426                 GOTO(out, rc = -EINVAL);
2427         }
2428
2429         grouplock = fd->fd_grouplock;
2430         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
2431         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
2432
2433         cl_put_grouplock(&grouplock);
2434
2435         lli->lli_group_users--;
2436         if (lli->lli_group_users == 0) {
2437                 lli->lli_group_gid = 0;
2438                 wake_up_var(&lli->lli_group_users);
2439         }
2440         CDEBUG(D_INFO, "group lock %lu released\n", arg);
2441         GOTO(out, rc = 0);
2442 out:
2443         mutex_unlock(&lli->lli_group_mutex);
2444
2445         RETURN(rc);
2446 }
2447
2448 /**
2449  * Close inode open handle
2450  *
2451  * \param dentry [in]     dentry which contains the inode
2452  * \param it     [in,out] intent which contains open info and result
2453  *
2454  * \retval 0     success
2455  * \retval <0    failure
2456  */
2457 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
2458 {
2459         struct inode *inode = dentry->d_inode;
2460         struct obd_client_handle *och;
2461         int rc;
2462         ENTRY;
2463
2464         LASSERT(inode);
2465
2466         /* Root ? Do nothing. */
2467         if (dentry->d_inode->i_sb->s_root == dentry)
2468                 RETURN(0);
2469
2470         /* No open handle to close? Move away */
2471         if (!it_disposition(it, DISP_OPEN_OPEN))
2472                 RETURN(0);
2473
2474         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
2475
2476         OBD_ALLOC(och, sizeof(*och));
2477         if (!och)
2478                 GOTO(out, rc = -ENOMEM);
2479
2480         rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
2481         if (rc)
2482                 GOTO(out, rc);
2483
2484         rc = ll_close_inode_openhandle(inode, och, 0, NULL);
2485 out:
2486         /* this one is in place of ll_file_open */
2487         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
2488                 ptlrpc_req_finished(it->it_request);
2489                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
2490         }
2491         RETURN(rc);
2492 }
2493
2494 /**
2495  * Get size for inode for which FIEMAP mapping is requested.
2496  * Make the FIEMAP get_info call and returns the result.
2497  * \param fiemap        kernel buffer to hold extens
2498  * \param num_bytes     kernel buffer size
2499  */
2500 static int ll_do_fiemap(struct inode *inode, struct fiemap *fiemap,
2501                         size_t num_bytes)
2502 {
2503         struct lu_env                   *env;
2504         __u16                           refcheck;
2505         int                             rc = 0;
2506         struct ll_fiemap_info_key       fmkey = { .lfik_name = KEY_FIEMAP, };
2507         ENTRY;
2508
2509         /* Checks for fiemap flags */
2510         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
2511                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
2512                 return -EBADR;
2513         }
2514
2515         /* Check for FIEMAP_FLAG_SYNC */
2516         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
2517                 rc = filemap_fdatawrite(inode->i_mapping);
2518                 if (rc)
2519                         return rc;
2520         }
2521
2522         env = cl_env_get(&refcheck);
2523         if (IS_ERR(env))
2524                 RETURN(PTR_ERR(env));
2525
2526         if (i_size_read(inode) == 0) {
2527                 rc = ll_glimpse_size(inode);
2528                 if (rc)
2529                         GOTO(out, rc);
2530         }
2531
2532         fmkey.lfik_oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
2533         obdo_from_inode(&fmkey.lfik_oa, inode, OBD_MD_FLSIZE);
2534         obdo_set_parent_fid(&fmkey.lfik_oa, &ll_i2info(inode)->lli_fid);
2535
2536         /* If filesize is 0, then there would be no objects for mapping */
2537         if (fmkey.lfik_oa.o_size == 0) {
2538                 fiemap->fm_mapped_extents = 0;
2539                 GOTO(out, rc = 0);
2540         }
2541
2542         fmkey.lfik_fiemap = *fiemap;
2543
2544         rc = cl_object_fiemap(env, ll_i2info(inode)->lli_clob,
2545                               &fmkey, fiemap, &num_bytes);
2546 out:
2547         cl_env_put(env, &refcheck);
2548         RETURN(rc);
2549 }
2550
2551 int ll_fid2path(struct inode *inode, void __user *arg)
2552 {
2553         struct obd_export       *exp = ll_i2mdexp(inode);
2554         const struct getinfo_fid2path __user *gfin = arg;
2555         __u32                    pathlen;
2556         struct getinfo_fid2path *gfout;
2557         size_t                   outsize;
2558         int                      rc;
2559
2560         ENTRY;
2561
2562         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
2563             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
2564                 RETURN(-EPERM);
2565
2566         /* Only need to get the buflen */
2567         if (get_user(pathlen, &gfin->gf_pathlen))
2568                 RETURN(-EFAULT);
2569
2570         if (pathlen > PATH_MAX)
2571                 RETURN(-EINVAL);
2572
2573         outsize = sizeof(*gfout) + pathlen;
2574         OBD_ALLOC(gfout, outsize);
2575         if (gfout == NULL)
2576                 RETURN(-ENOMEM);
2577
2578         if (copy_from_user(gfout, arg, sizeof(*gfout)))
2579                 GOTO(gf_free, rc = -EFAULT);
2580         /* append root FID after gfout to let MDT know the root FID so that it
2581          * can lookup the correct path, this is mainly for fileset.
2582          * old server without fileset mount support will ignore this. */
2583         *gfout->gf_u.gf_root_fid = *ll_inode2fid(inode);
2584
2585         /* Call mdc_iocontrol */
2586         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
2587         if (rc != 0)
2588                 GOTO(gf_free, rc);
2589
2590         if (copy_to_user(arg, gfout, outsize))
2591                 rc = -EFAULT;
2592
2593 gf_free:
2594         OBD_FREE(gfout, outsize);
2595         RETURN(rc);
2596 }
2597
2598 static int
2599 ll_ioc_data_version(struct inode *inode, struct ioc_data_version *ioc)
2600 {
2601         struct cl_object *obj = ll_i2info(inode)->lli_clob;
2602         struct lu_env *env;
2603         struct cl_io *io;
2604         __u16  refcheck;
2605         int result;
2606
2607         ENTRY;
2608
2609         ioc->idv_version = 0;
2610         ioc->idv_layout_version = UINT_MAX;
2611
2612         /* If no file object initialized, we consider its version is 0. */
2613         if (obj == NULL)
2614                 RETURN(0);
2615
2616         env = cl_env_get(&refcheck);
2617         if (IS_ERR(env))
2618                 RETURN(PTR_ERR(env));
2619
2620         io = vvp_env_thread_io(env);
2621         io->ci_obj = obj;
2622         io->u.ci_data_version.dv_data_version = 0;
2623         io->u.ci_data_version.dv_layout_version = UINT_MAX;
2624         io->u.ci_data_version.dv_flags = ioc->idv_flags;
2625
2626 restart:
2627         if (cl_io_init(env, io, CIT_DATA_VERSION, io->ci_obj) == 0)
2628                 result = cl_io_loop(env, io);
2629         else
2630                 result = io->ci_result;
2631
2632         ioc->idv_version = io->u.ci_data_version.dv_data_version;
2633         ioc->idv_layout_version = io->u.ci_data_version.dv_layout_version;
2634
2635         cl_io_fini(env, io);
2636
2637         if (unlikely(io->ci_need_restart))
2638                 goto restart;
2639
2640         cl_env_put(env, &refcheck);
2641
2642         RETURN(result);
2643 }
2644
2645 /*
2646  * Read the data_version for inode.
2647  *
2648  * This value is computed using stripe object version on OST.
2649  * Version is computed using server side locking.
2650  *
2651  * @param flags if do sync on the OST side;
2652  *              0: no sync
2653  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
2654  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
2655  */
2656 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
2657 {
2658         struct ioc_data_version ioc = { .idv_flags = flags };
2659         int rc;
2660
2661         rc = ll_ioc_data_version(inode, &ioc);
2662         if (!rc)
2663                 *data_version = ioc.idv_version;
2664
2665         return rc;
2666 }
2667
2668 /*
2669  * Trigger a HSM release request for the provided inode.
2670  */
2671 int ll_hsm_release(struct inode *inode)
2672 {
2673         struct lu_env *env;
2674         struct obd_client_handle *och = NULL;
2675         __u64 data_version = 0;
2676         int rc;
2677         __u16 refcheck;
2678         ENTRY;
2679
2680         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
2681                ll_i2sbi(inode)->ll_fsname,
2682                PFID(&ll_i2info(inode)->lli_fid));
2683
2684         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
2685         if (IS_ERR(och))
2686                 GOTO(out, rc = PTR_ERR(och));
2687
2688         /* Grab latest data_version and [am]time values */
2689         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
2690         if (rc != 0)
2691                 GOTO(out, rc);
2692
2693         env = cl_env_get(&refcheck);
2694         if (IS_ERR(env))
2695                 GOTO(out, rc = PTR_ERR(env));
2696
2697         rc = ll_merge_attr(env, inode);
2698         cl_env_put(env, &refcheck);
2699
2700         /* If error happen, we have the wrong size for a file.
2701          * Don't release it.
2702          */
2703         if (rc != 0)
2704                 GOTO(out, rc);
2705
2706         /* Release the file.
2707          * NB: lease lock handle is released in mdc_hsm_release_pack() because
2708          * we still need it to pack l_remote_handle to MDT. */
2709         rc = ll_close_inode_openhandle(inode, och, MDS_HSM_RELEASE,
2710                                        &data_version);
2711         och = NULL;
2712
2713         EXIT;
2714 out:
2715         if (och != NULL && !IS_ERR(och)) /* close the file */
2716                 ll_lease_close(och, inode, NULL);
2717
2718         return rc;
2719 }
2720
2721 struct ll_swap_stack {
2722         __u64                    dv1;
2723         __u64                    dv2;
2724         struct inode            *inode1;
2725         struct inode            *inode2;
2726         bool                     check_dv1;
2727         bool                     check_dv2;
2728 };
2729
2730 static int ll_swap_layouts(struct file *file1, struct file *file2,
2731                            struct lustre_swap_layouts *lsl)
2732 {
2733         struct mdc_swap_layouts  msl;
2734         struct md_op_data       *op_data;
2735         __u32                    gid;
2736         __u64                    dv;
2737         struct ll_swap_stack    *llss = NULL;
2738         int                      rc;
2739
2740         OBD_ALLOC_PTR(llss);
2741         if (llss == NULL)
2742                 RETURN(-ENOMEM);
2743
2744         llss->inode1 = file_inode(file1);
2745         llss->inode2 = file_inode(file2);
2746
2747         rc = ll_check_swap_layouts_validity(llss->inode1, llss->inode2);
2748         if (rc < 0)
2749                 GOTO(free, rc);
2750
2751         /* we use 2 bool because it is easier to swap than 2 bits */
2752         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2753                 llss->check_dv1 = true;
2754
2755         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2756                 llss->check_dv2 = true;
2757
2758         /* we cannot use lsl->sl_dvX directly because we may swap them */
2759         llss->dv1 = lsl->sl_dv1;
2760         llss->dv2 = lsl->sl_dv2;
2761
2762         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2763         if (rc == 0) /* same file, done! */
2764                 GOTO(free, rc);
2765
2766         if (rc < 0) { /* sequentialize it */
2767                 swap(llss->inode1, llss->inode2);
2768                 swap(file1, file2);
2769                 swap(llss->dv1, llss->dv2);
2770                 swap(llss->check_dv1, llss->check_dv2);
2771         }
2772
2773         gid = lsl->sl_gid;
2774         if (gid != 0) { /* application asks to flush dirty cache */
2775                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2776                 if (rc < 0)
2777                         GOTO(free, rc);
2778
2779                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2780                 if (rc < 0) {
2781                         ll_put_grouplock(llss->inode1, file1, gid);
2782                         GOTO(free, rc);
2783                 }
2784         }
2785
2786         /* ultimate check, before swaping the layouts we check if
2787          * dataversion has changed (if requested) */
2788         if (llss->check_dv1) {
2789                 rc = ll_data_version(llss->inode1, &dv, 0);
2790                 if (rc)
2791                         GOTO(putgl, rc);
2792                 if (dv != llss->dv1)
2793                         GOTO(putgl, rc = -EAGAIN);
2794         }
2795
2796         if (llss->check_dv2) {
2797                 rc = ll_data_version(llss->inode2, &dv, 0);
2798                 if (rc)
2799                         GOTO(putgl, rc);
2800                 if (dv != llss->dv2)
2801                         GOTO(putgl, rc = -EAGAIN);
2802         }
2803
2804         /* struct md_op_data is used to send the swap args to the mdt
2805          * only flags is missing, so we use struct mdc_swap_layouts
2806          * through the md_op_data->op_data */
2807         /* flags from user space have to be converted before they are send to
2808          * server, no flag is sent today, they are only used on the client */
2809         msl.msl_flags = 0;
2810         rc = -ENOMEM;
2811         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2812                                      0, LUSTRE_OPC_ANY, &msl);
2813         if (IS_ERR(op_data))
2814                 GOTO(free, rc = PTR_ERR(op_data));
2815
2816         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2817                            sizeof(*op_data), op_data, NULL);
2818         ll_finish_md_op_data(op_data);
2819
2820         if (rc < 0)
2821                 GOTO(putgl, rc);
2822
2823 putgl:
2824         if (gid != 0) {
2825                 ll_put_grouplock(llss->inode2, file2, gid);
2826                 ll_put_grouplock(llss->inode1, file1, gid);
2827         }
2828
2829 free:
2830         if (llss != NULL)
2831                 OBD_FREE_PTR(llss);
2832
2833         RETURN(rc);
2834 }
2835
2836 int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2837 {
2838         struct obd_export *exp = ll_i2mdexp(inode);
2839         struct md_op_data *op_data;
2840         int rc;
2841         ENTRY;
2842
2843         /* Detect out-of range masks */
2844         if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK)
2845                 RETURN(-EINVAL);
2846
2847         /* Non-root users are forbidden to set or clear flags which are
2848          * NOT defined in HSM_USER_MASK. */
2849         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2850             !cfs_capable(CFS_CAP_SYS_ADMIN))
2851                 RETURN(-EPERM);
2852
2853         if (!exp_connect_archive_id_array(exp)) {
2854                 /* Detect out-of range archive id */
2855                 if ((hss->hss_valid & HSS_ARCHIVE_ID) &&
2856                     (hss->hss_archive_id > LL_HSM_ORIGIN_MAX_ARCHIVE))
2857                         RETURN(-EINVAL);
2858         }
2859
2860         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2861                                      LUSTRE_OPC_ANY, hss);
2862         if (IS_ERR(op_data))
2863                 RETURN(PTR_ERR(op_data));
2864
2865         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, exp, sizeof(*op_data),
2866                            op_data, NULL);
2867
2868         ll_finish_md_op_data(op_data);
2869
2870         RETURN(rc);
2871 }
2872
2873 static int ll_hsm_import(struct inode *inode, struct file *file,
2874                          struct hsm_user_import *hui)
2875 {
2876         struct hsm_state_set    *hss = NULL;
2877         struct iattr            *attr = NULL;
2878         int                      rc;
2879         ENTRY;
2880
2881         if (!S_ISREG(inode->i_mode))
2882                 RETURN(-EINVAL);
2883
2884         /* set HSM flags */
2885         OBD_ALLOC_PTR(hss);
2886         if (hss == NULL)
2887                 GOTO(out, rc = -ENOMEM);
2888
2889         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2890         hss->hss_archive_id = hui->hui_archive_id;
2891         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2892         rc = ll_hsm_state_set(inode, hss);
2893         if (rc != 0)
2894                 GOTO(out, rc);
2895
2896         OBD_ALLOC_PTR(attr);
2897         if (attr == NULL)
2898                 GOTO(out, rc = -ENOMEM);
2899
2900         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2901         attr->ia_mode |= S_IFREG;
2902         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2903         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2904         attr->ia_size = hui->hui_size;
2905         attr->ia_mtime.tv_sec = hui->hui_mtime;
2906         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2907         attr->ia_atime.tv_sec = hui->hui_atime;
2908         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2909
2910         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2911                          ATTR_UID | ATTR_GID |
2912                          ATTR_MTIME | ATTR_MTIME_SET |
2913                          ATTR_ATIME | ATTR_ATIME_SET;
2914
2915         inode_lock(inode);
2916
2917         rc = ll_setattr_raw(file_dentry(file), attr, 0, true);
2918         if (rc == -ENODATA)
2919                 rc = 0;
2920
2921         inode_unlock(inode);
2922
2923 out:
2924         if (hss != NULL)
2925                 OBD_FREE_PTR(hss);
2926
2927         if (attr != NULL)
2928                 OBD_FREE_PTR(attr);
2929
2930         RETURN(rc);
2931 }
2932
2933 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2934 {
2935         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2936                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2937 }
2938
2939 static int ll_file_futimes_3(struct file *file, const struct ll_futimes_3 *lfu)
2940 {
2941         struct inode *inode = file_inode(file);
2942         struct iattr ia = {
2943                 .ia_valid = ATTR_ATIME | ATTR_ATIME_SET |
2944                             ATTR_MTIME | ATTR_MTIME_SET |
2945                             ATTR_CTIME,
2946                 .ia_atime = {
2947                         .tv_sec = lfu->lfu_atime_sec,
2948                         .tv_nsec = lfu->lfu_atime_nsec,
2949                 },
2950                 .ia_mtime = {
2951                         .tv_sec = lfu->lfu_mtime_sec,
2952                         .tv_nsec = lfu->lfu_mtime_nsec,
2953                 },
2954                 .ia_ctime = {
2955                         .tv_sec = lfu->lfu_ctime_sec,
2956                         .tv_nsec = lfu->lfu_ctime_nsec,
2957                 },
2958         };
2959         int rc;
2960         ENTRY;
2961
2962         if (!capable(CAP_SYS_ADMIN))
2963                 RETURN(-EPERM);
2964
2965         if (!S_ISREG(inode->i_mode))
2966                 RETURN(-EINVAL);
2967
2968         inode_lock(inode);
2969         rc = ll_setattr_raw(file_dentry(file), &ia, OP_XVALID_CTIME_SET,
2970                             false);
2971         inode_unlock(inode);
2972
2973         RETURN(rc);
2974 }
2975
2976 static enum cl_lock_mode cl_mode_user_to_kernel(enum lock_mode_user mode)
2977 {
2978         switch (mode) {
2979         case MODE_READ_USER:
2980                 return CLM_READ;
2981         case MODE_WRITE_USER:
2982                 return CLM_WRITE;
2983         default:
2984                 return -EINVAL;
2985         }
2986 }
2987
2988 static const char *const user_lockname[] = LOCK_MODE_NAMES;
2989
2990 /* Used to allow the upper layers of the client to request an LDLM lock
2991  * without doing an actual read or write.
2992  *
2993  * Used for ladvise lockahead to manually request specific locks.
2994  *
2995  * \param[in] file      file this ladvise lock request is on
2996  * \param[in] ladvise   ladvise struct describing this lock request
2997  *
2998  * \retval 0            success, no detailed result available (sync requests
2999  *                      and requests sent to the server [not handled locally]
3000  *                      cannot return detailed results)
3001  * \retval LLA_RESULT_{SAME,DIFFERENT} - detailed result of the lock request,
3002  *                                       see definitions for details.
3003  * \retval negative     negative errno on error
3004  */
3005 int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise)
3006 {
3007         struct lu_env *env = NULL;
3008         struct cl_io *io  = NULL;
3009         struct cl_lock *lock = NULL;
3010         struct cl_lock_descr *descr = NULL;
3011         struct dentry *dentry = file->f_path.dentry;
3012         struct inode *inode = dentry->d_inode;
3013         enum cl_lock_mode cl_mode;
3014         off_t start = ladvise->lla_start;
3015         off_t end = ladvise->lla_end;
3016         int result;
3017         __u16 refcheck;
3018
3019         ENTRY;
3020
3021         CDEBUG(D_VFSTRACE,
3022                "Lock request: file=%pd, inode=%p, mode=%s start=%llu, end=%llu\n",
3023                dentry, dentry->d_inode,
3024                user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
3025                (__u64) end);
3026
3027         cl_mode = cl_mode_user_to_kernel(ladvise->lla_lockahead_mode);
3028         if (cl_mode < 0)
3029                 GOTO(out, result = cl_mode);
3030
3031         /* Get IO environment */
3032         result = cl_io_get(inode, &env, &io, &refcheck);
3033         if (result <= 0)
3034                 GOTO(out, result);
3035
3036         result = cl_io_init(env, io, CIT_MISC, io->ci_obj);
3037         if (result > 0) {
3038                 /*
3039                  * nothing to do for this io. This currently happens when
3040                  * stripe sub-object's are not yet created.
3041                  */
3042                 result = io->ci_result;
3043         } else if (result == 0) {
3044                 lock = vvp_env_lock(env);
3045                 descr = &lock->cll_descr;
3046
3047                 descr->cld_obj   = io->ci_obj;
3048                 /* Convert byte offsets to pages */
3049                 descr->cld_start = cl_index(io->ci_obj, start);
3050                 descr->cld_end   = cl_index(io->ci_obj, end);
3051                 descr->cld_mode  = cl_mode;
3052                 /* CEF_MUST is used because we do not want to convert a
3053                  * lockahead request to a lockless lock */
3054                 descr->cld_enq_flags = CEF_MUST | CEF_LOCK_NO_EXPAND |
3055                                        CEF_NONBLOCK;
3056
3057                 if (ladvise->lla_peradvice_flags & LF_ASYNC)
3058                         descr->cld_enq_flags |= CEF_SPECULATIVE;
3059
3060                 result = cl_lock_request(env, io, lock);
3061
3062                 /* On success, we need to release the lock */
3063                 if (result >= 0)
3064                         cl_lock_release(env, lock);
3065         }
3066         cl_io_fini(env, io);
3067         cl_env_put(env, &refcheck);
3068
3069         /* -ECANCELED indicates a matching lock with a different extent
3070          * was already present, and -EEXIST indicates a matching lock
3071          * on exactly the same extent was already present.
3072          * We convert them to positive values for userspace to make
3073          * recognizing true errors easier.
3074          * Note we can only return these detailed results on async requests,
3075          * as sync requests look the same as i/o requests for locking. */
3076         if (result == -ECANCELED)
3077                 result = LLA_RESULT_DIFFERENT;
3078         else if (result == -EEXIST)
3079                 result = LLA_RESULT_SAME;
3080
3081 out:
3082         RETURN(result);
3083 }
3084 static const char *const ladvise_names[] = LU_LADVISE_NAMES;
3085
3086 static int ll_ladvise_sanity(struct inode *inode,
3087                              struct llapi_lu_ladvise *ladvise)
3088 {
3089         struct ll_sb_info *sbi = ll_i2sbi(inode);
3090         enum lu_ladvise_type advice = ladvise->lla_advice;
3091         /* Note the peradvice flags is a 32 bit field, so per advice flags must
3092          * be in the first 32 bits of enum ladvise_flags */
3093         __u32 flags = ladvise->lla_peradvice_flags;
3094         /* 3 lines at 80 characters per line, should be plenty */
3095         int rc = 0;
3096
3097         if (advice > LU_LADVISE_MAX || advice == LU_LADVISE_INVALID) {
3098                 rc = -EINVAL;
3099                 CDEBUG(D_VFSTRACE,
3100                        "%s: advice with value '%d' not recognized, last supported advice is %s (value '%d'): rc = %d\n",
3101                        sbi->ll_fsname, advice,
3102                        ladvise_names[LU_LADVISE_MAX-1], LU_LADVISE_MAX-1, rc);
3103                 GOTO(out, rc);
3104         }
3105
3106         /* Per-advice checks */
3107         switch (advice) {
3108         case LU_LADVISE_LOCKNOEXPAND:
3109                 if (flags & ~LF_LOCKNOEXPAND_MASK) {
3110                         rc = -EINVAL;
3111                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
3112                                "rc = %d\n", sbi->ll_fsname, flags,
3113                                ladvise_names[advice], rc);
3114                         GOTO(out, rc);
3115                 }
3116                 break;
3117         case LU_LADVISE_LOCKAHEAD:
3118                 /* Currently only READ and WRITE modes can be requested */
3119                 if (ladvise->lla_lockahead_mode >= MODE_MAX_USER ||
3120                     ladvise->lla_lockahead_mode == 0) {
3121                         rc = -EINVAL;
3122                         CDEBUG(D_VFSTRACE, "%s: Invalid mode (%d) for %s: "
3123                                "rc = %d\n", sbi->ll_fsname,
3124                                ladvise->lla_lockahead_mode,
3125                                ladvise_names[advice], rc);
3126                         GOTO(out, rc);
3127                 }
3128                 /* fallthrough */
3129         case LU_LADVISE_WILLREAD:
3130         case LU_LADVISE_DONTNEED:
3131         default:
3132                 /* Note fall through above - These checks apply to all advices
3133                  * except LOCKNOEXPAND */
3134                 if (flags & ~LF_DEFAULT_MASK) {
3135                         rc = -EINVAL;
3136                         CDEBUG(D_VFSTRACE, "%s: Invalid flags (%x) for %s: "
3137                                "rc = %d\n", sbi->ll_fsname, flags,
3138                                ladvise_names[advice], rc);
3139                         GOTO(out, rc);
3140                 }
3141                 if (ladvise->lla_start >= ladvise->lla_end) {
3142                         rc = -EINVAL;
3143                         CDEBUG(D_VFSTRACE, "%s: Invalid range (%llu to %llu) "
3144                                "for %s: rc = %d\n", sbi->ll_fsname,
3145                                ladvise->lla_start, ladvise->lla_end,
3146                                ladvise_names[advice], rc);
3147                         GOTO(out, rc);
3148                 }
3149                 break;
3150         }
3151
3152 out:
3153         return rc;
3154 }
3155 #undef ERRSIZE
3156
3157 /*
3158  * Give file access advices
3159  *
3160  * The ladvise interface is similar to Linux fadvise() system call, except it
3161  * forwards the advices directly from Lustre client to server. The server side
3162  * codes will apply appropriate read-ahead and caching techniques for the
3163  * corresponding files.
3164  *
3165  * A typical workload for ladvise is e.g. a bunch of different clients are
3166  * doing small random reads of a file, so prefetching pages into OSS cache
3167  * with big linear reads before the random IO is a net benefit. Fetching
3168  * all that data into each client cache with fadvise() may not be, due to
3169  * much more data being sent to the client.
3170  */
3171 static int ll_ladvise(struct inode *inode, struct file *file, __u64 flags,
3172                       struct llapi_lu_ladvise *ladvise)
3173 {
3174         struct lu_env *env;
3175         struct cl_io *io;
3176         struct cl_ladvise_io *lio;
3177         int rc;
3178         __u16 refcheck;
3179         ENTRY;
3180
3181         env = cl_env_get(&refcheck);
3182         if (IS_ERR(env))
3183                 RETURN(PTR_ERR(env));
3184
3185         io = vvp_env_thread_io(env);
3186         io->ci_obj = ll_i2info(inode)->lli_clob;
3187
3188         /* initialize parameters for ladvise */
3189         lio = &io->u.ci_ladvise;
3190         lio->li_start = ladvise->lla_start;
3191         lio->li_end = ladvise->lla_end;
3192         lio->li_fid = ll_inode2fid(inode);
3193         lio->li_advice = ladvise->lla_advice;
3194         lio->li_flags = flags;
3195
3196         if (cl_io_init(env, io, CIT_LADVISE, io->ci_obj) == 0)
3197                 rc = cl_io_loop(env, io);
3198         else
3199                 rc = io->ci_result;
3200
3201         cl_io_fini(env, io);
3202         cl_env_put(env, &refcheck);
3203         RETURN(rc);
3204 }
3205
3206 static int ll_lock_noexpand(struct file *file, int flags)
3207 {
3208         struct ll_file_data *fd = file->private_data;
3209
3210         fd->ll_lock_no_expand = !(flags & LF_UNSET);
3211
3212         return 0;
3213 }
3214
3215 int ll_ioctl_fsgetxattr(struct inode *inode, unsigned int cmd,
3216                         unsigned long arg)
3217 {
3218         struct fsxattr fsxattr;
3219
3220         if (copy_from_user(&fsxattr,
3221                            (const struct fsxattr __user *)arg,
3222                            sizeof(fsxattr)))
3223                 RETURN(-EFAULT);
3224
3225         fsxattr.fsx_xflags = ll_inode_flags_to_xflags(inode->i_flags);
3226         if (ll_file_test_flag(ll_i2info(inode), LLIF_PROJECT_INHERIT))
3227                 fsxattr.fsx_xflags |= FS_XFLAG_PROJINHERIT;
3228         fsxattr.fsx_projid = ll_i2info(inode)->lli_projid;
3229         if (copy_to_user((struct fsxattr __user *)arg,
3230                          &fsxattr, sizeof(fsxattr)))
3231                 RETURN(-EFAULT);
3232
3233         RETURN(0);
3234 }
3235
3236 int ll_ioctl_check_project(struct inode *inode, struct fsxattr *fa)
3237 {
3238         /*
3239          * Project Quota ID state is only allowed to change from within the init
3240          * namespace. Enforce that restriction only if we are trying to change
3241          * the quota ID state. Everything else is allowed in user namespaces.
3242          */
3243         if (current_user_ns() == &init_user_ns)
3244                 return 0;
3245
3246         if (ll_i2info(inode)->lli_projid != fa->fsx_projid)
3247                 return -EINVAL;
3248
3249         if (ll_file_test_flag(ll_i2info(inode), LLIF_PROJECT_INHERIT)) {
3250                 if (!(fa->fsx_xflags & FS_XFLAG_PROJINHERIT))
3251                         return -EINVAL;
3252         } else {
3253                 if (fa->fsx_xflags & FS_XFLAG_PROJINHERIT)
3254                         return -EINVAL;
3255         }
3256
3257         return 0;
3258 }
3259
3260 int ll_ioctl_fssetxattr(struct inode *inode, unsigned int cmd,
3261                         unsigned long arg)
3262 {
3263
3264         struct md_op_data *op_data;
3265         struct ptlrpc_request *req = NULL;
3266         int rc = 0;
3267         struct fsxattr fsxattr;
3268         struct cl_object *obj;
3269         struct iattr *attr;
3270         int flags;
3271
3272         if (copy_from_user(&fsxattr,
3273                            (const struct fsxattr __user *)arg,
3274                            sizeof(fsxattr)))
3275                 RETURN(-EFAULT);
3276
3277         rc = ll_ioctl_check_project(inode, &fsxattr);
3278         if (rc)
3279                 RETURN(rc);
3280
3281         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
3282                                      LUSTRE_OPC_ANY, NULL);
3283         if (IS_ERR(op_data))
3284                 RETURN(PTR_ERR(op_data));
3285
3286         flags = ll_xflags_to_inode_flags(fsxattr.fsx_xflags);
3287         op_data->op_attr_flags = ll_inode_to_ext_flags(flags);
3288         if (fsxattr.fsx_xflags & FS_XFLAG_PROJINHERIT)
3289                 op_data->op_attr_flags |= LUSTRE_PROJINHERIT_FL;
3290         op_data->op_projid = fsxattr.fsx_projid;
3291         op_data->op_xvalid |= OP_XVALID_PROJID | OP_XVALID_FLAGS;
3292         rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data, NULL,
3293                         0, &req);
3294         ptlrpc_req_finished(req);
3295         if (rc)
3296                 GOTO(out_fsxattr, rc);
3297         ll_update_inode_flags(inode, op_data->op_attr_flags);
3298         obj = ll_i2info(inode)->lli_clob;
3299         if (obj == NULL)
3300                 GOTO(out_fsxattr, rc);
3301
3302         /* Avoiding OST RPC if this is only project ioctl */
3303         if (fsxattr.fsx_xflags == 0 ||
3304             fsxattr.fsx_xflags == FS_XFLAG_PROJINHERIT)
3305                 GOTO(out_fsxattr, rc);
3306
3307         OBD_ALLOC_PTR(attr);
3308         if (attr == NULL)
3309                 GOTO(out_fsxattr, rc = -ENOMEM);
3310
3311         rc = cl_setattr_ost(obj, attr, OP_XVALID_FLAGS,
3312                             fsxattr.fsx_xflags);
3313         OBD_FREE_PTR(attr);
3314 out_fsxattr:
3315         ll_finish_md_op_data(op_data);
3316         RETURN(rc);
3317 }
3318
3319 static long ll_file_unlock_lease(struct file *file, struct ll_ioc_lease *ioc,
3320                                  unsigned long arg)
3321 {
3322         struct inode            *inode = file_inode(file);
3323         struct ll_file_data     *fd = file->private_data;
3324         struct ll_inode_info    *lli = ll_i2info(inode);
3325         struct obd_client_handle *och = NULL;
3326         struct split_param sp;
3327         struct pcc_param param;
3328         bool lease_broken = false;
3329         fmode_t fmode = 0;
3330         enum mds_op_bias bias = 0;
3331         struct file *layout_file = NULL;
3332         void *data = NULL;
3333         size_t data_size = 0;
3334         bool attached = false;
3335         long rc, rc2 = 0;
3336
3337         ENTRY;
3338
3339         mutex_lock(&lli->lli_och_mutex);
3340         if (fd->fd_lease_och != NULL) {
3341                 och = fd->fd_lease_och;
3342                 fd->fd_lease_och = NULL;
3343         }
3344         mutex_unlock(&lli->lli_och_mutex);
3345
3346         if (och == NULL)