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