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