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