Whamcloud - gitweb
LU-4712 llite: lock the inode to be migrated
[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.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  * lustre/llite/file.c
37  *
38  * Author: Peter Braam <braam@clusterfs.com>
39  * Author: Phil Schwan <phil@clusterfs.com>
40  * Author: Andreas Dilger <adilger@clusterfs.com>
41  */
42
43 #define DEBUG_SUBSYSTEM S_LLITE
44 #include <lustre_dlm.h>
45 #include <linux/pagemap.h>
46 #include <linux/file.h>
47 #include <linux/sched.h>
48 #include "llite_internal.h"
49 #include <lustre/ll_fiemap.h>
50 #include <lustre_ioctl.h>
51
52 #include "cl_object.h"
53
54 static int
55 ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg);
56
57 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
58                           bool *lease_broken);
59
60 static enum llioc_iter
61 ll_iocontrol_call(struct inode *inode, struct file *file,
62                   unsigned int cmd, unsigned long arg, int *rcp);
63
64 static struct ll_file_data *ll_file_data_get(void)
65 {
66         struct ll_file_data *fd;
67
68         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, GFP_NOFS);
69         if (fd == NULL)
70                 return NULL;
71
72         fd->fd_write_failed = false;
73
74         return fd;
75 }
76
77 static void ll_file_data_put(struct ll_file_data *fd)
78 {
79         if (fd != NULL)
80                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
81 }
82
83 void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
84                           struct lustre_handle *fh)
85 {
86         op_data->op_fid1 = ll_i2info(inode)->lli_fid;
87         op_data->op_attr.ia_mode = inode->i_mode;
88         op_data->op_attr.ia_atime = inode->i_atime;
89         op_data->op_attr.ia_mtime = inode->i_mtime;
90         op_data->op_attr.ia_ctime = inode->i_ctime;
91         op_data->op_attr.ia_size = i_size_read(inode);
92         op_data->op_attr_blocks = inode->i_blocks;
93         op_data->op_attr_flags = ll_inode_to_ext_flags(inode->i_flags);
94         op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch;
95         if (fh)
96                 op_data->op_handle = *fh;
97         op_data->op_capa1 = ll_mdscapa_get(inode);
98
99         if (LLIF_DATA_MODIFIED & ll_i2info(inode)->lli_flags)
100                 op_data->op_bias |= MDS_DATA_MODIFIED;
101 }
102
103 /**
104  * Closes the IO epoch and packs all the attributes into @op_data for
105  * the CLOSE rpc.
106  */
107 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
108                              struct obd_client_handle *och)
109 {
110         ENTRY;
111
112         op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME | ATTR_ATIME_SET |
113                                         ATTR_MTIME | ATTR_MTIME_SET |
114                                         ATTR_CTIME | ATTR_CTIME_SET;
115
116         if (!(och->och_flags & FMODE_WRITE))
117                 goto out;
118
119         if (!exp_connect_som(ll_i2mdexp(inode)) || !S_ISREG(inode->i_mode))
120                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
121         else
122                 ll_ioepoch_close(inode, op_data, &och, 0);
123
124 out:
125         ll_pack_inode2opdata(inode, op_data, &och->och_fh);
126         ll_prep_md_op_data(op_data, inode, NULL, NULL,
127                            0, 0, LUSTRE_OPC_ANY, NULL);
128         EXIT;
129 }
130
131 static int ll_close_inode_openhandle(struct obd_export *md_exp,
132                                      struct inode *inode,
133                                      struct obd_client_handle *och,
134                                      const __u64 *data_version)
135 {
136         struct obd_export *exp = ll_i2mdexp(inode);
137         struct md_op_data *op_data;
138         struct ptlrpc_request *req = NULL;
139         struct obd_device *obd = class_exp2obd(exp);
140         int epoch_close = 1;
141         int rc;
142         ENTRY;
143
144         if (obd == NULL) {
145                 /*
146                  * XXX: in case of LMV, is this correct to access
147                  * ->exp_handle?
148                  */
149                 CERROR("Invalid MDC connection handle "LPX64"\n",
150                        ll_i2mdexp(inode)->exp_handle.h_cookie);
151                 GOTO(out, rc = 0);
152         }
153
154         OBD_ALLOC_PTR(op_data);
155         if (op_data == NULL)
156                 GOTO(out, rc = -ENOMEM); // XXX We leak openhandle and request here.
157
158         ll_prepare_close(inode, op_data, och);
159         if (data_version != NULL) {
160                 /* Pass in data_version implies release. */
161                 op_data->op_bias |= MDS_HSM_RELEASE;
162                 op_data->op_data_version = *data_version;
163                 op_data->op_lease_handle = och->och_lease_handle;
164                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
165         }
166         epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE);
167         rc = md_close(md_exp, op_data, och->och_mod, &req);
168         if (rc == -EAGAIN) {
169                 /* This close must have the epoch closed. */
170                 LASSERT(epoch_close);
171                 /* MDS has instructed us to obtain Size-on-MDS attribute from
172                  * OSTs and send setattr to back to MDS. */
173                 rc = ll_som_update(inode, op_data);
174                 if (rc) {
175                         CERROR("%s: inode "DFID" mdc Size-on-MDS update"
176                                " failed: rc = %d\n",
177                                ll_i2mdexp(inode)->exp_obd->obd_name,
178                                PFID(ll_inode2fid(inode)), rc);
179                         rc = 0;
180                 }
181         } else if (rc) {
182                 CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
183                        ll_i2mdexp(inode)->exp_obd->obd_name,
184                        PFID(ll_inode2fid(inode)), rc);
185         }
186
187         /* DATA_MODIFIED flag was successfully sent on close, cancel data
188          * modification flag. */
189         if (rc == 0 && (op_data->op_bias & MDS_DATA_MODIFIED)) {
190                 struct ll_inode_info *lli = ll_i2info(inode);
191
192                 spin_lock(&lli->lli_lock);
193                 lli->lli_flags &= ~LLIF_DATA_MODIFIED;
194                 spin_unlock(&lli->lli_lock);
195         }
196
197         if (rc == 0 && op_data->op_bias & MDS_HSM_RELEASE) {
198                 struct mdt_body *body;
199                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
200                 if (!(body->mbo_valid & OBD_MD_FLRELEASED))
201                         rc = -EBUSY;
202         }
203
204         ll_finish_md_op_data(op_data);
205         EXIT;
206 out:
207
208         if (exp_connect_som(exp) && !epoch_close &&
209             S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) {
210                 ll_queue_done_writing(inode, LLIF_DONE_WRITING);
211         } else {
212                 md_clear_open_replay_data(md_exp, och);
213                 /* Free @och if it is not waiting for DONE_WRITING. */
214                 och->och_fh.cookie = DEAD_HANDLE_MAGIC;
215                 OBD_FREE_PTR(och);
216         }
217         if (req) /* This is close request */
218                 ptlrpc_req_finished(req);
219         return rc;
220 }
221
222 int ll_md_real_close(struct inode *inode, fmode_t fmode)
223 {
224         struct ll_inode_info *lli = ll_i2info(inode);
225         struct obd_client_handle **och_p;
226         struct obd_client_handle *och;
227         __u64 *och_usecount;
228         int rc = 0;
229         ENTRY;
230
231         if (fmode & FMODE_WRITE) {
232                 och_p = &lli->lli_mds_write_och;
233                 och_usecount = &lli->lli_open_fd_write_count;
234         } else if (fmode & FMODE_EXEC) {
235                 och_p = &lli->lli_mds_exec_och;
236                 och_usecount = &lli->lli_open_fd_exec_count;
237         } else {
238                 LASSERT(fmode & FMODE_READ);
239                 och_p = &lli->lli_mds_read_och;
240                 och_usecount = &lli->lli_open_fd_read_count;
241         }
242
243         mutex_lock(&lli->lli_och_mutex);
244         if (*och_usecount > 0) {
245                 /* There are still users of this handle, so skip
246                  * freeing it. */
247                 mutex_unlock(&lli->lli_och_mutex);
248                 RETURN(0);
249         }
250
251         och = *och_p;
252         *och_p = NULL;
253         mutex_unlock(&lli->lli_och_mutex);
254
255         if (och != NULL) {
256                 /* There might be a race and this handle may already
257                  * be closed. */
258                 rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
259                                                inode, och, NULL);
260         }
261
262         RETURN(rc);
263 }
264
265 static int ll_md_close(struct obd_export *md_exp, struct inode *inode,
266                        struct file *file)
267 {
268         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
269         struct ll_inode_info *lli = ll_i2info(inode);
270         int rc = 0;
271         ENTRY;
272
273         /* clear group lock, if present */
274         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
275                 ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid);
276
277         if (fd->fd_lease_och != NULL) {
278                 bool lease_broken;
279
280                 /* Usually the lease is not released when the
281                  * application crashed, we need to release here. */
282                 rc = ll_lease_close(fd->fd_lease_och, inode, &lease_broken);
283                 CDEBUG(rc ? D_ERROR : D_INODE, "Clean up lease "DFID" %d/%d\n",
284                         PFID(&lli->lli_fid), rc, lease_broken);
285
286                 fd->fd_lease_och = NULL;
287         }
288
289         if (fd->fd_och != NULL) {
290                 rc = ll_close_inode_openhandle(md_exp, inode, fd->fd_och, NULL);
291                 fd->fd_och = NULL;
292                 GOTO(out, rc);
293         }
294
295         /* Let's see if we have good enough OPEN lock on the file and if
296            we can skip talking to MDS */
297         if (file->f_dentry->d_inode) { /* Can this ever be false? */
298                 int lockmode;
299                 __u64 flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
300                 struct lustre_handle lockh;
301                 struct inode *inode = file->f_dentry->d_inode;
302                 ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
303
304                 mutex_lock(&lli->lli_och_mutex);
305                 if (fd->fd_omode & FMODE_WRITE) {
306                         lockmode = LCK_CW;
307                         LASSERT(lli->lli_open_fd_write_count);
308                         lli->lli_open_fd_write_count--;
309                 } else if (fd->fd_omode & FMODE_EXEC) {
310                         lockmode = LCK_PR;
311                         LASSERT(lli->lli_open_fd_exec_count);
312                         lli->lli_open_fd_exec_count--;
313                 } else {
314                         lockmode = LCK_CR;
315                         LASSERT(lli->lli_open_fd_read_count);
316                         lli->lli_open_fd_read_count--;
317                 }
318                 mutex_unlock(&lli->lli_och_mutex);
319
320                 if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
321                                    LDLM_IBITS, &policy, lockmode,
322                                    &lockh)) {
323                         rc = ll_md_real_close(file->f_dentry->d_inode,
324                                               fd->fd_omode);
325                 }
326         } else {
327                 CERROR("released file has negative dentry: file = %p, "
328                        "dentry = %p, name = %s\n",
329                        file, file->f_dentry, file->f_dentry->d_name.name);
330         }
331
332 out:
333         LUSTRE_FPRIVATE(file) = NULL;
334         ll_file_data_put(fd);
335         ll_capa_close(inode);
336
337         RETURN(rc);
338 }
339
340 /* While this returns an error code, fput() the caller does not, so we need
341  * to make every effort to clean up all of our state here.  Also, applications
342  * rarely check close errors and even if an error is returned they will not
343  * re-try the close call.
344  */
345 int ll_file_release(struct inode *inode, struct file *file)
346 {
347         struct ll_file_data *fd;
348         struct ll_sb_info *sbi = ll_i2sbi(inode);
349         struct ll_inode_info *lli = ll_i2info(inode);
350         int rc;
351         ENTRY;
352
353         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
354                PFID(ll_inode2fid(inode)), inode);
355
356 #ifdef CONFIG_FS_POSIX_ACL
357         if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
358             inode == inode->i_sb->s_root->d_inode) {
359                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
360
361                 LASSERT(fd != NULL);
362                 if (unlikely(fd->fd_flags & LL_FILE_RMTACL)) {
363                         fd->fd_flags &= ~LL_FILE_RMTACL;
364                         rct_del(&sbi->ll_rct, current_pid());
365                         et_search_free(&sbi->ll_et, current_pid());
366                 }
367         }
368 #endif
369
370         if (inode->i_sb->s_root != file->f_dentry)
371                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
372         fd = LUSTRE_FPRIVATE(file);
373         LASSERT(fd != NULL);
374
375         /* The last ref on @file, maybe not the the owner pid of statahead,
376          * because parent and child process can share the same file handle. */
377         if (S_ISDIR(inode->i_mode) && lli->lli_opendir_key == fd)
378                 ll_deauthorize_statahead(inode, fd);
379
380         if (inode->i_sb->s_root == file->f_dentry) {
381                 LUSTRE_FPRIVATE(file) = NULL;
382                 ll_file_data_put(fd);
383                 RETURN(0);
384         }
385
386         if (!S_ISDIR(inode->i_mode)) {
387                 if (lli->lli_clob != NULL)
388                         lov_read_and_clear_async_rc(lli->lli_clob);
389                 lli->lli_async_rc = 0;
390         }
391
392         rc = ll_md_close(sbi->ll_md_exp, inode, file);
393
394         if (CFS_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, cfs_fail_val))
395                 libcfs_debug_dumplog();
396
397         RETURN(rc);
398 }
399
400 static int ll_intent_file_open(struct file *file, void *lmm, int lmmsize,
401                                 struct lookup_intent *itp)
402 {
403         struct dentry *de = file->f_dentry;
404         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
405         struct dentry *parent = de->d_parent;
406         const char *name = NULL;
407         int len = 0;
408         struct md_op_data *op_data;
409         struct ptlrpc_request *req = NULL;
410         int rc;
411         ENTRY;
412
413         LASSERT(parent != NULL);
414         LASSERT(itp->it_flags & MDS_OPEN_BY_FID);
415
416         /* if server supports open-by-fid, or file name is invalid, don't pack
417          * name in open request */
418         if (!(exp_connect_flags(sbi->ll_md_exp) & OBD_CONNECT_OPEN_BY_FID) &&
419             lu_name_is_valid_2(de->d_name.name, de->d_name.len)) {
420                 name = de->d_name.name;
421                 len = de->d_name.len;
422         }
423
424         op_data = ll_prep_md_op_data(NULL, parent->d_inode, de->d_inode,
425                                      name, len, 0, LUSTRE_OPC_ANY, NULL);
426         if (IS_ERR(op_data))
427                 RETURN(PTR_ERR(op_data));
428         op_data->op_data = lmm;
429         op_data->op_data_size = lmmsize;
430
431         rc = md_intent_lock(sbi->ll_md_exp, op_data, itp, &req,
432                             &ll_md_blocking_ast, 0);
433         ll_finish_md_op_data(op_data);
434         if (rc == -ESTALE) {
435                 /* reason for keep own exit path - don`t flood log
436                  * with messages with -ESTALE errors.
437                  */
438                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
439                      it_open_error(DISP_OPEN_OPEN, itp))
440                         GOTO(out, rc);
441                 ll_release_openhandle(de, itp);
442                 GOTO(out, rc);
443         }
444
445         if (it_disposition(itp, DISP_LOOKUP_NEG))
446                 GOTO(out, rc = -ENOENT);
447
448         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
449                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
450                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
451                 GOTO(out, rc);
452         }
453
454         rc = ll_prep_inode(&de->d_inode, req, NULL, itp);
455         if (!rc && itp->d.lustre.it_lock_mode)
456                 ll_set_lock_data(sbi->ll_md_exp, de->d_inode, itp, NULL);
457
458 out:
459         ptlrpc_req_finished(req);
460         ll_intent_drop_lock(itp);
461
462         RETURN(rc);
463 }
464
465 /**
466  * Assign an obtained @ioepoch to client's inode. No lock is needed, MDS does
467  * not believe attributes if a few ioepoch holders exist. Attributes for
468  * previous ioepoch if new one is opened are also skipped by MDS.
469  */
470 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch)
471 {
472         if (ioepoch && lli->lli_ioepoch != ioepoch) {
473                 lli->lli_ioepoch = ioepoch;
474                 CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
475                        ioepoch, PFID(&lli->lli_fid));
476         }
477 }
478
479 static int ll_och_fill(struct obd_export *md_exp, struct lookup_intent *it,
480                        struct obd_client_handle *och)
481 {
482         struct ptlrpc_request *req = it->d.lustre.it_data;
483         struct mdt_body *body;
484
485         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
486         och->och_fh = body->mbo_handle;
487         och->och_fid = body->mbo_fid1;
488         och->och_lease_handle.cookie = it->d.lustre.it_lock_handle;
489         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
490         och->och_flags = it->it_flags;
491
492         return md_set_open_replay_data(md_exp, och, it);
493 }
494
495 static int ll_local_open(struct file *file, struct lookup_intent *it,
496                          struct ll_file_data *fd, struct obd_client_handle *och)
497 {
498         struct inode *inode = file->f_dentry->d_inode;
499         struct ll_inode_info *lli = ll_i2info(inode);
500         ENTRY;
501
502         LASSERT(!LUSTRE_FPRIVATE(file));
503
504         LASSERT(fd != NULL);
505
506         if (och) {
507                 struct ptlrpc_request *req = it->d.lustre.it_data;
508                 struct mdt_body *body;
509                 int rc;
510
511                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
512                 if (rc != 0)
513                         RETURN(rc);
514
515                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
516                 ll_ioepoch_open(lli, body->mbo_ioepoch);
517         }
518
519         LUSTRE_FPRIVATE(file) = fd;
520         ll_readahead_init(inode, &fd->fd_ras);
521         fd->fd_omode = it->it_flags & (FMODE_READ | FMODE_WRITE | FMODE_EXEC);
522
523         /* ll_cl_context initialize */
524         rwlock_init(&fd->fd_lock);
525         INIT_LIST_HEAD(&fd->fd_lccs);
526
527         RETURN(0);
528 }
529
530 /* Open a file, and (for the very first open) create objects on the OSTs at
531  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
532  * creation or open until ll_lov_setstripe() ioctl is called.
533  *
534  * If we already have the stripe MD locally then we don't request it in
535  * md_open(), by passing a lmm_size = 0.
536  *
537  * It is up to the application to ensure no other processes open this file
538  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
539  * used.  We might be able to avoid races of that sort by getting lli_open_sem
540  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
541  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
542  */
543 int ll_file_open(struct inode *inode, struct file *file)
544 {
545         struct ll_inode_info *lli = ll_i2info(inode);
546         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
547                                           .it_flags = file->f_flags };
548         struct obd_client_handle **och_p = NULL;
549         __u64 *och_usecount = NULL;
550         struct ll_file_data *fd;
551         int rc = 0;
552         ENTRY;
553
554         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
555                PFID(ll_inode2fid(inode)), inode, file->f_flags);
556
557         it = file->private_data; /* XXX: compat macro */
558         file->private_data = NULL; /* prevent ll_local_open assertion */
559
560         fd = ll_file_data_get();
561         if (fd == NULL)
562                 GOTO(out_openerr, rc = -ENOMEM);
563
564         fd->fd_file = file;
565         if (S_ISDIR(inode->i_mode))
566                 ll_authorize_statahead(inode, fd);
567
568         if (inode->i_sb->s_root == file->f_dentry) {
569                 LUSTRE_FPRIVATE(file) = fd;
570                 RETURN(0);
571         }
572
573         if (!it || !it->d.lustre.it_disposition) {
574                 /* Convert f_flags into access mode. We cannot use file->f_mode,
575                  * because everything but O_ACCMODE mask was stripped from
576                  * there */
577                 if ((oit.it_flags + 1) & O_ACCMODE)
578                         oit.it_flags++;
579                 if (file->f_flags & O_TRUNC)
580                         oit.it_flags |= FMODE_WRITE;
581
582                 /* kernel only call f_op->open in dentry_open.  filp_open calls
583                  * dentry_open after call to open_namei that checks permissions.
584                  * Only nfsd_open call dentry_open directly without checking
585                  * permissions and because of that this code below is safe. */
586                 if (oit.it_flags & (FMODE_WRITE | FMODE_READ))
587                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
588
589                 /* We do not want O_EXCL here, presumably we opened the file
590                  * already? XXX - NFS implications? */
591                 oit.it_flags &= ~O_EXCL;
592
593                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
594                  * created if necessary, then "IT_CREAT" should be set to keep
595                  * consistent with it */
596                 if (oit.it_flags & O_CREAT)
597                         oit.it_op |= IT_CREAT;
598
599                 it = &oit;
600         }
601
602 restart:
603         /* Let's see if we have file open on MDS already. */
604         if (it->it_flags & FMODE_WRITE) {
605                 och_p = &lli->lli_mds_write_och;
606                 och_usecount = &lli->lli_open_fd_write_count;
607         } else if (it->it_flags & FMODE_EXEC) {
608                 och_p = &lli->lli_mds_exec_och;
609                 och_usecount = &lli->lli_open_fd_exec_count;
610          } else {
611                 och_p = &lli->lli_mds_read_och;
612                 och_usecount = &lli->lli_open_fd_read_count;
613         }
614
615         mutex_lock(&lli->lli_och_mutex);
616         if (*och_p) { /* Open handle is present */
617                 if (it_disposition(it, DISP_OPEN_OPEN)) {
618                         /* Well, there's extra open request that we do not need,
619                            let's close it somehow. This will decref request. */
620                         rc = it_open_error(DISP_OPEN_OPEN, it);
621                         if (rc) {
622                                 mutex_unlock(&lli->lli_och_mutex);
623                                 GOTO(out_openerr, rc);
624                         }
625
626                         ll_release_openhandle(file->f_dentry, it);
627                 }
628                 (*och_usecount)++;
629
630                 rc = ll_local_open(file, it, fd, NULL);
631                 if (rc) {
632                         (*och_usecount)--;
633                         mutex_unlock(&lli->lli_och_mutex);
634                         GOTO(out_openerr, rc);
635                 }
636         } else {
637                 LASSERT(*och_usecount == 0);
638                 if (!it->d.lustre.it_disposition) {
639                         /* We cannot just request lock handle now, new ELC code
640                            means that one of other OPEN locks for this file
641                            could be cancelled, and since blocking ast handler
642                            would attempt to grab och_mutex as well, that would
643                            result in a deadlock */
644                         mutex_unlock(&lli->lli_och_mutex);
645                         /*
646                          * Normally called under two situations:
647                          * 1. NFS export.
648                          * 2. A race/condition on MDS resulting in no open
649                          *    handle to be returned from LOOKUP|OPEN request,
650                          *    for example if the target entry was a symlink.
651                          *
652                          * Always fetch MDS_OPEN_LOCK if this is not setstripe.
653                          *
654                          * Always specify MDS_OPEN_BY_FID because we don't want
655                          * to get file with different fid.
656                          */
657                         it->it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID;
658                         rc = ll_intent_file_open(file, NULL, 0, it);
659                         if (rc)
660                                 GOTO(out_openerr, rc);
661
662                         goto restart;
663                 }
664                 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
665                 if (!*och_p)
666                         GOTO(out_och_free, rc = -ENOMEM);
667
668                 (*och_usecount)++;
669
670                 /* md_intent_lock() didn't get a request ref if there was an
671                  * open error, so don't do cleanup on the request here
672                  * (bug 3430) */
673                 /* XXX (green): Should not we bail out on any error here, not
674                  * just open error? */
675                 rc = it_open_error(DISP_OPEN_OPEN, it);
676                 if (rc != 0)
677                         GOTO(out_och_free, rc);
678
679                 LASSERTF(it_disposition(it, DISP_ENQ_OPEN_REF),
680                          "inode %p: disposition %x, status %d\n", inode,
681                          it_disposition(it, ~0), it->d.lustre.it_status);
682
683                 rc = ll_local_open(file, it, fd, *och_p);
684                 if (rc)
685                         GOTO(out_och_free, rc);
686         }
687         mutex_unlock(&lli->lli_och_mutex);
688         fd = NULL;
689
690         /* Must do this outside lli_och_mutex lock to prevent deadlock where
691            different kind of OPEN lock for this same inode gets cancelled
692            by ldlm_cancel_lru */
693         if (!S_ISREG(inode->i_mode))
694                 GOTO(out_och_free, rc);
695
696         ll_capa_open(inode);
697
698         if (!lli->lli_has_smd &&
699             (cl_is_lov_delay_create(file->f_flags) ||
700              (file->f_mode & FMODE_WRITE) == 0)) {
701                 CDEBUG(D_INODE, "object creation was delayed\n");
702                 GOTO(out_och_free, rc);
703         }
704         cl_lov_delay_create_clear(&file->f_flags);
705         GOTO(out_och_free, rc);
706
707 out_och_free:
708         if (rc) {
709                 if (och_p && *och_p) {
710                         OBD_FREE(*och_p, sizeof (struct obd_client_handle));
711                         *och_p = NULL; /* OBD_FREE writes some magic there */
712                         (*och_usecount)--;
713                 }
714                 mutex_unlock(&lli->lli_och_mutex);
715
716 out_openerr:
717                 if (lli->lli_opendir_key == fd)
718                         ll_deauthorize_statahead(inode, fd);
719                 if (fd != NULL)
720                         ll_file_data_put(fd);
721         } else {
722                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
723         }
724
725         if (it && it_disposition(it, DISP_ENQ_OPEN_REF)) {
726                 ptlrpc_req_finished(it->d.lustre.it_data);
727                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
728         }
729
730         return rc;
731 }
732
733 static int ll_md_blocking_lease_ast(struct ldlm_lock *lock,
734                         struct ldlm_lock_desc *desc, void *data, int flag)
735 {
736         int rc;
737         struct lustre_handle lockh;
738         ENTRY;
739
740         switch (flag) {
741         case LDLM_CB_BLOCKING:
742                 ldlm_lock2handle(lock, &lockh);
743                 rc = ldlm_cli_cancel(&lockh, LCF_ASYNC);
744                 if (rc < 0) {
745                         CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
746                         RETURN(rc);
747                 }
748                 break;
749         case LDLM_CB_CANCELING:
750                 /* do nothing */
751                 break;
752         }
753         RETURN(0);
754 }
755
756 /**
757  * Acquire a lease and open the file.
758  */
759 static struct obd_client_handle *
760 ll_lease_open(struct inode *inode, struct file *file, fmode_t fmode,
761               __u64 open_flags)
762 {
763         struct lookup_intent it = { .it_op = IT_OPEN };
764         struct ll_sb_info *sbi = ll_i2sbi(inode);
765         struct md_op_data *op_data;
766         struct ptlrpc_request *req = NULL;
767         struct lustre_handle old_handle = { 0 };
768         struct obd_client_handle *och = NULL;
769         int rc;
770         int rc2;
771         ENTRY;
772
773         if (fmode != FMODE_WRITE && fmode != FMODE_READ)
774                 RETURN(ERR_PTR(-EINVAL));
775
776         if (file != NULL) {
777                 struct ll_inode_info *lli = ll_i2info(inode);
778                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
779                 struct obd_client_handle **och_p;
780                 __u64 *och_usecount;
781
782                 if (!(fmode & file->f_mode) || (file->f_mode & FMODE_EXEC))
783                         RETURN(ERR_PTR(-EPERM));
784
785                 /* Get the openhandle of the file */
786                 rc = -EBUSY;
787                 mutex_lock(&lli->lli_och_mutex);
788                 if (fd->fd_lease_och != NULL) {
789                         mutex_unlock(&lli->lli_och_mutex);
790                         RETURN(ERR_PTR(rc));
791                 }
792
793                 if (fd->fd_och == NULL) {
794                         if (file->f_mode & FMODE_WRITE) {
795                                 LASSERT(lli->lli_mds_write_och != NULL);
796                                 och_p = &lli->lli_mds_write_och;
797                                 och_usecount = &lli->lli_open_fd_write_count;
798                         } else {
799                                 LASSERT(lli->lli_mds_read_och != NULL);
800                                 och_p = &lli->lli_mds_read_och;
801                                 och_usecount = &lli->lli_open_fd_read_count;
802                         }
803                         if (*och_usecount == 1) {
804                                 fd->fd_och = *och_p;
805                                 *och_p = NULL;
806                                 *och_usecount = 0;
807                                 rc = 0;
808                         }
809                 }
810                 mutex_unlock(&lli->lli_och_mutex);
811                 if (rc < 0) /* more than 1 opener */
812                         RETURN(ERR_PTR(rc));
813
814                 LASSERT(fd->fd_och != NULL);
815                 old_handle = fd->fd_och->och_fh;
816         }
817
818         OBD_ALLOC_PTR(och);
819         if (och == NULL)
820                 RETURN(ERR_PTR(-ENOMEM));
821
822         op_data = ll_prep_md_op_data(NULL, inode, inode, NULL, 0, 0,
823                                         LUSTRE_OPC_ANY, NULL);
824         if (IS_ERR(op_data))
825                 GOTO(out, rc = PTR_ERR(op_data));
826
827         /* To tell the MDT this openhandle is from the same owner */
828         op_data->op_handle = old_handle;
829
830         it.it_flags = fmode | open_flags;
831         it.it_flags |= MDS_OPEN_LOCK | MDS_OPEN_BY_FID | MDS_OPEN_LEASE;
832         rc = md_intent_lock(sbi->ll_md_exp, op_data, &it, &req,
833                             &ll_md_blocking_lease_ast,
834         /* LDLM_FL_NO_LRU: To not put the lease lock into LRU list, otherwise
835          * it can be cancelled which may mislead applications that the lease is
836          * broken;
837          * LDLM_FL_EXCL: Set this flag so that it won't be matched by normal
838          * open in ll_md_blocking_ast(). Otherwise as ll_md_blocking_lease_ast
839          * doesn't deal with openhandle, so normal openhandle will be leaked. */
840                             LDLM_FL_NO_LRU | LDLM_FL_EXCL);
841         ll_finish_md_op_data(op_data);
842         ptlrpc_req_finished(req);
843         if (rc < 0)
844                 GOTO(out_release_it, rc);
845
846         if (it_disposition(&it, DISP_LOOKUP_NEG))
847                 GOTO(out_release_it, rc = -ENOENT);
848
849         rc = it_open_error(DISP_OPEN_OPEN, &it);
850         if (rc)
851                 GOTO(out_release_it, rc);
852
853         LASSERT(it_disposition(&it, DISP_ENQ_OPEN_REF));
854         ll_och_fill(sbi->ll_md_exp, &it, och);
855
856         if (!it_disposition(&it, DISP_OPEN_LEASE)) /* old server? */
857                 GOTO(out_close, rc = -EOPNOTSUPP);
858
859         /* already get lease, handle lease lock */
860         ll_set_lock_data(sbi->ll_md_exp, inode, &it, NULL);
861         if (it.d.lustre.it_lock_mode == 0 ||
862             it.d.lustre.it_lock_bits != MDS_INODELOCK_OPEN) {
863                 /* open lock must return for lease */
864                 CERROR(DFID "lease granted but no open lock, %d/"LPU64".\n",
865                         PFID(ll_inode2fid(inode)), it.d.lustre.it_lock_mode,
866                         it.d.lustre.it_lock_bits);
867                 GOTO(out_close, rc = -EPROTO);
868         }
869
870         ll_intent_release(&it);
871         RETURN(och);
872
873 out_close:
874         /* Cancel open lock */
875         if (it.d.lustre.it_lock_mode != 0) {
876                 ldlm_lock_decref_and_cancel(&och->och_lease_handle,
877                                             it.d.lustre.it_lock_mode);
878                 it.d.lustre.it_lock_mode = 0;
879                 och->och_lease_handle.cookie = 0ULL;
880         }
881         rc2 = ll_close_inode_openhandle(sbi->ll_md_exp, inode, och, NULL);
882         if (rc2 < 0)
883                 CERROR("%s: error closing file "DFID": %d\n",
884                        ll_get_fsname(inode->i_sb, NULL, 0),
885                        PFID(&ll_i2info(inode)->lli_fid), rc2);
886         och = NULL; /* och has been freed in ll_close_inode_openhandle() */
887 out_release_it:
888         ll_intent_release(&it);
889 out:
890         if (och != NULL)
891                 OBD_FREE_PTR(och);
892         RETURN(ERR_PTR(rc));
893 }
894
895 /**
896  * Release lease and close the file.
897  * It will check if the lease has ever broken.
898  */
899 static int ll_lease_close(struct obd_client_handle *och, struct inode *inode,
900                           bool *lease_broken)
901 {
902         struct ldlm_lock *lock;
903         bool cancelled = true;
904         int rc;
905         ENTRY;
906
907         lock = ldlm_handle2lock(&och->och_lease_handle);
908         if (lock != NULL) {
909                 lock_res_and_lock(lock);
910                 cancelled = ldlm_is_cancel(lock);
911                 unlock_res_and_lock(lock);
912                 LDLM_LOCK_PUT(lock);
913         }
914
915         CDEBUG(D_INODE, "lease for "DFID" broken? %d\n",
916                 PFID(&ll_i2info(inode)->lli_fid), cancelled);
917
918         if (!cancelled)
919                 ldlm_cli_cancel(&och->och_lease_handle, 0);
920         if (lease_broken != NULL)
921                 *lease_broken = cancelled;
922
923         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
924                                        NULL);
925         RETURN(rc);
926 }
927
928 /* Fills the obdo with the attributes for the lsm */
929 static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp,
930                           struct obd_capa *capa, struct obdo *obdo,
931                           __u64 ioepoch, int dv_flags)
932 {
933         struct ptlrpc_request_set *set;
934         struct obd_info            oinfo = { { { 0 } } };
935         int                        rc;
936
937         ENTRY;
938
939         LASSERT(lsm != NULL);
940
941         oinfo.oi_md = lsm;
942         oinfo.oi_oa = obdo;
943         oinfo.oi_oa->o_oi = lsm->lsm_oi;
944         oinfo.oi_oa->o_mode = S_IFREG;
945         oinfo.oi_oa->o_ioepoch = ioepoch;
946         oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
947                                OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
948                                OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
949                                OBD_MD_FLMTIME | OBD_MD_FLCTIME |
950                                OBD_MD_FLGROUP | OBD_MD_FLEPOCH |
951                                OBD_MD_FLDATAVERSION;
952         oinfo.oi_capa = capa;
953         if (dv_flags & (LL_DV_WR_FLUSH | LL_DV_RD_FLUSH)) {
954                 oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
955                 oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
956                 if (dv_flags & LL_DV_WR_FLUSH)
957                         oinfo.oi_oa->o_flags |= OBD_FL_FLUSH;
958         }
959
960         set = ptlrpc_prep_set();
961         if (set == NULL) {
962                 CERROR("cannot allocate ptlrpc set: rc = %d\n", -ENOMEM);
963                 rc = -ENOMEM;
964         } else {
965                 rc = obd_getattr_async(exp, &oinfo, set);
966                 if (rc == 0)
967                         rc = ptlrpc_set_wait(set);
968                 ptlrpc_set_destroy(set);
969         }
970         if (rc == 0) {
971                 oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
972                                          OBD_MD_FLATIME | OBD_MD_FLMTIME |
973                                          OBD_MD_FLCTIME | OBD_MD_FLSIZE |
974                                          OBD_MD_FLDATAVERSION | OBD_MD_FLFLAGS);
975                 if (dv_flags & LL_DV_WR_FLUSH &&
976                     !(oinfo.oi_oa->o_valid & OBD_MD_FLFLAGS &&
977                       oinfo.oi_oa->o_flags & OBD_FL_FLUSH))
978                         RETURN(-ENOTSUPP);
979         }
980         RETURN(rc);
981 }
982
983 /**
984   * Performs the getattr on the inode and updates its fields.
985   * If @sync != 0, perform the getattr under the server-side lock.
986   */
987 int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
988                      __u64 ioepoch, int sync)
989 {
990         struct obd_capa      *capa = ll_mdscapa_get(inode);
991         struct lov_stripe_md *lsm;
992         int rc;
993         ENTRY;
994
995         lsm = ccc_inode_lsm_get(inode);
996         rc = ll_lsm_getattr(lsm, ll_i2dtexp(inode),
997                                 capa, obdo, ioepoch, sync ? LL_DV_RD_FLUSH : 0);
998         capa_put(capa);
999         if (rc == 0) {
1000                 struct ost_id *oi = lsm ? &lsm->lsm_oi : &obdo->o_oi;
1001
1002                 obdo_refresh_inode(inode, obdo, obdo->o_valid);
1003                 CDEBUG(D_INODE, "objid "DOSTID" size %llu, blocks %llu,"
1004                        " blksize %lu\n", POSTID(oi), i_size_read(inode),
1005                        (unsigned long long)inode->i_blocks,
1006                        1UL << inode->i_blkbits);
1007         }
1008         ccc_inode_lsm_put(inode, lsm);
1009         RETURN(rc);
1010 }
1011
1012 int ll_merge_attr(const struct lu_env *env, struct inode *inode)
1013 {
1014         struct ll_inode_info *lli = ll_i2info(inode);
1015         struct cl_object *obj = lli->lli_clob;
1016         struct cl_attr *attr = ccc_env_thread_attr(env);
1017         s64 atime;
1018         s64 mtime;
1019         s64 ctime;
1020         int rc = 0;
1021
1022         ENTRY;
1023
1024         ll_inode_size_lock(inode);
1025
1026         /* merge timestamps the most recently obtained from mds with
1027            timestamps obtained from osts */
1028         LTIME_S(inode->i_atime) = lli->lli_atime;
1029         LTIME_S(inode->i_mtime) = lli->lli_mtime;
1030         LTIME_S(inode->i_ctime) = lli->lli_ctime;
1031
1032         atime = LTIME_S(inode->i_atime);
1033         mtime = LTIME_S(inode->i_mtime);
1034         ctime = LTIME_S(inode->i_ctime);
1035
1036         cl_object_attr_lock(obj);
1037         rc = cl_object_attr_get(env, obj, attr);
1038         cl_object_attr_unlock(obj);
1039
1040         if (rc != 0)
1041                 GOTO(out_size_unlock, rc);
1042
1043         if (atime < attr->cat_atime)
1044                 atime = attr->cat_atime;
1045
1046         if (ctime < attr->cat_ctime)
1047                 ctime = attr->cat_ctime;
1048
1049         if (mtime < attr->cat_mtime)
1050                 mtime = attr->cat_mtime;
1051
1052         CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
1053                PFID(&lli->lli_fid), attr->cat_size);
1054
1055         i_size_write(inode, attr->cat_size);
1056         inode->i_blocks = attr->cat_blocks;
1057
1058         LTIME_S(inode->i_atime) = atime;
1059         LTIME_S(inode->i_mtime) = mtime;
1060         LTIME_S(inode->i_ctime) = ctime;
1061
1062 out_size_unlock:
1063         ll_inode_size_unlock(inode);
1064
1065         RETURN(rc);
1066 }
1067
1068 int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
1069                      lstat_t *st)
1070 {
1071         struct obdo obdo = { 0 };
1072         int rc;
1073
1074         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0);
1075         if (rc == 0) {
1076                 st->st_size   = obdo.o_size;
1077                 st->st_blocks = obdo.o_blocks;
1078                 st->st_mtime  = obdo.o_mtime;
1079                 st->st_atime  = obdo.o_atime;
1080                 st->st_ctime  = obdo.o_ctime;
1081         }
1082         return rc;
1083 }
1084
1085 static bool file_is_noatime(const struct file *file)
1086 {
1087         const struct vfsmount *mnt = file->f_path.mnt;
1088         const struct inode *inode = file->f_path.dentry->d_inode;
1089
1090         /* Adapted from file_accessed() and touch_atime().*/
1091         if (file->f_flags & O_NOATIME)
1092                 return true;
1093
1094         if (inode->i_flags & S_NOATIME)
1095                 return true;
1096
1097         if (IS_NOATIME(inode))
1098                 return true;
1099
1100         if (mnt->mnt_flags & (MNT_NOATIME | MNT_READONLY))
1101                 return true;
1102
1103         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1104                 return true;
1105
1106         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1107                 return true;
1108
1109         return false;
1110 }
1111
1112 static void ll_io_init(struct cl_io *io, const struct file *file, int write)
1113 {
1114         struct inode *inode = file->f_dentry->d_inode;
1115
1116         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
1117         if (write) {
1118                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
1119                 io->u.ci_wr.wr_sync = file->f_flags & O_SYNC ||
1120                                       file->f_flags & O_DIRECT ||
1121                                       IS_SYNC(inode);
1122         }
1123         io->ci_obj     = ll_i2info(inode)->lli_clob;
1124         io->ci_lockreq = CILR_MAYBE;
1125         if (ll_file_nolock(file)) {
1126                 io->ci_lockreq = CILR_NEVER;
1127                 io->ci_no_srvlock = 1;
1128         } else if (file->f_flags & O_APPEND) {
1129                 io->ci_lockreq = CILR_MANDATORY;
1130         }
1131
1132         io->ci_noatime = file_is_noatime(file);
1133 }
1134
1135 static ssize_t
1136 ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
1137                    struct file *file, enum cl_io_type iot,
1138                    loff_t *ppos, size_t count)
1139 {
1140         struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
1141         struct ll_file_data  *fd  = LUSTRE_FPRIVATE(file);
1142         struct cl_io         *io;
1143         ssize_t               result;
1144         struct range_lock     range;
1145         ENTRY;
1146
1147         CDEBUG(D_VFSTRACE, "file: %s, type: %d ppos: "LPU64", count: %zu\n",
1148                 file->f_dentry->d_name.name, iot, *ppos, count);
1149
1150 restart:
1151         io = ccc_env_thread_io(env);
1152         ll_io_init(io, file, iot == CIT_WRITE);
1153
1154         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
1155                 struct vvp_io *vio = vvp_env_io(env);
1156                 bool range_locked = false;
1157
1158                 if (file->f_flags & O_APPEND)
1159                         range_lock_init(&range, 0, LUSTRE_EOF);
1160                 else
1161                         range_lock_init(&range, *ppos, *ppos + count - 1);
1162
1163                 vio->vui_fd  = LUSTRE_FPRIVATE(file);
1164                 vio->vui_io_subtype = args->via_io_subtype;
1165
1166                 switch (vio->vui_io_subtype) {
1167                 case IO_NORMAL:
1168                         vio->vui_iov = args->u.normal.via_iov;
1169                         vio->vui_nrsegs = args->u.normal.via_nrsegs;
1170                         vio->vui_tot_nrsegs = vio->vui_nrsegs;
1171                         vio->vui_iocb = args->u.normal.via_iocb;
1172                         if ((iot == CIT_WRITE) &&
1173                             !(vio->vui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1174                                 CDEBUG(D_VFSTRACE, "Range lock "RL_FMT"\n",
1175                                        RL_PARA(&range));
1176                                 result = range_lock(&lli->lli_write_tree,
1177                                                     &range);
1178                                 if (result < 0)
1179                                         GOTO(out, result);
1180
1181                                 range_locked = true;
1182                         }
1183                         down_read(&lli->lli_trunc_sem);
1184                         break;
1185                 case IO_SPLICE:
1186                         vio->u.splice.vui_pipe = args->u.splice.via_pipe;
1187                         vio->u.splice.vui_flags = args->u.splice.via_flags;
1188                         break;
1189                 default:
1190                         CERROR("unknown IO subtype %u\n", vio->vui_io_subtype);
1191                         LBUG();
1192                 }
1193
1194                 ll_cl_add(file, env, io);
1195                 result = cl_io_loop(env, io);
1196                 ll_cl_remove(file, env);
1197
1198                 if (args->via_io_subtype == IO_NORMAL)
1199                         up_read(&lli->lli_trunc_sem);
1200                 if (range_locked) {
1201                         CDEBUG(D_VFSTRACE, "Range unlock "RL_FMT"\n",
1202                                RL_PARA(&range));
1203                         range_unlock(&lli->lli_write_tree, &range);
1204                 }
1205         } else {
1206                 /* cl_io_rw_init() handled IO */
1207                 result = io->ci_result;
1208         }
1209
1210         if (io->ci_nob > 0) {
1211                 result = io->ci_nob;
1212                 *ppos = io->u.ci_wr.wr.crw_pos;
1213         }
1214         GOTO(out, result);
1215 out:
1216         cl_io_fini(env, io);
1217         /* If any bit been read/written (result != 0), we just return
1218          * short read/write instead of restart io. */
1219         if ((result == 0 || result == -ENODATA) && io->ci_need_restart) {
1220                 CDEBUG(D_VFSTRACE, "Restart %s on %s from %lld, count:%zu\n",
1221                        iot == CIT_READ ? "read" : "write",
1222                        file->f_dentry->d_name.name, *ppos, count);
1223                 LASSERTF(io->ci_nob == 0, "%zd\n", io->ci_nob);
1224                 goto restart;
1225         }
1226
1227         if (iot == CIT_READ) {
1228                 if (result >= 0)
1229                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1230                                            LPROC_LL_READ_BYTES, result);
1231         } else if (iot == CIT_WRITE) {
1232                 if (result >= 0) {
1233                         ll_stats_ops_tally(ll_i2sbi(file->f_dentry->d_inode),
1234                                            LPROC_LL_WRITE_BYTES, result);
1235                         fd->fd_write_failed = false;
1236                 } else if (result != -ERESTARTSYS) {
1237                         fd->fd_write_failed = true;
1238                 }
1239         }
1240         CDEBUG(D_VFSTRACE, "iot: %d, result: %zd\n", iot, result);
1241
1242         return result;
1243 }
1244
1245
1246 /*
1247  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
1248  */
1249 static int ll_file_get_iov_count(const struct iovec *iov,
1250                                  unsigned long *nr_segs, size_t *count)
1251 {
1252         size_t cnt = 0;
1253         unsigned long seg;
1254
1255         for (seg = 0; seg < *nr_segs; seg++) {
1256                 const struct iovec *iv = &iov[seg];
1257
1258                 /*
1259                  * If any segment has a negative length, or the cumulative
1260                  * length ever wraps negative then return -EINVAL.
1261                  */
1262                 cnt += iv->iov_len;
1263                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
1264                         return -EINVAL;
1265                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
1266                         continue;
1267                 if (seg == 0)
1268                         return -EFAULT;
1269                 *nr_segs = seg;
1270                 cnt -= iv->iov_len;   /* This segment is no good */
1271                 break;
1272         }
1273         *count = cnt;
1274         return 0;
1275 }
1276
1277 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
1278                                 unsigned long nr_segs, loff_t pos)
1279 {
1280         struct lu_env      *env;
1281         struct vvp_io_args *args;
1282         size_t              count;
1283         ssize_t             result;
1284         int                 refcheck;
1285         ENTRY;
1286
1287         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1288         if (result)
1289                 RETURN(result);
1290
1291         env = cl_env_get(&refcheck);
1292         if (IS_ERR(env))
1293                 RETURN(PTR_ERR(env));
1294
1295         args = vvp_env_args(env, IO_NORMAL);
1296         args->u.normal.via_iov = (struct iovec *)iov;
1297         args->u.normal.via_nrsegs = nr_segs;
1298         args->u.normal.via_iocb = iocb;
1299
1300         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
1301                                     &iocb->ki_pos, count);
1302         cl_env_put(env, &refcheck);
1303         RETURN(result);
1304 }
1305
1306 static ssize_t ll_file_read(struct file *file, char __user *buf, size_t count,
1307                             loff_t *ppos)
1308 {
1309         struct lu_env *env;
1310         struct iovec  *local_iov;
1311         struct kiocb  *kiocb;
1312         ssize_t        result;
1313         int            refcheck;
1314         ENTRY;
1315
1316         env = cl_env_get(&refcheck);
1317         if (IS_ERR(env))
1318                 RETURN(PTR_ERR(env));
1319
1320         local_iov = &vvp_env_info(env)->vti_local_iov;
1321         kiocb = &vvp_env_info(env)->vti_kiocb;
1322         local_iov->iov_base = (void __user *)buf;
1323         local_iov->iov_len = count;
1324         init_sync_kiocb(kiocb, file);
1325         kiocb->ki_pos = *ppos;
1326 #ifdef HAVE_KIOCB_KI_LEFT
1327         kiocb->ki_left = count;
1328 #else
1329         kiocb->ki_nbytes = count;
1330 #endif
1331
1332         result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1333         *ppos = kiocb->ki_pos;
1334
1335         cl_env_put(env, &refcheck);
1336         RETURN(result);
1337 }
1338
1339 /*
1340  * Write to a file (through the page cache).
1341  * AIO stuff
1342  */
1343 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1344                                  unsigned long nr_segs, loff_t pos)
1345 {
1346         struct lu_env      *env;
1347         struct vvp_io_args *args;
1348         size_t              count;
1349         ssize_t             result;
1350         int                 refcheck;
1351         ENTRY;
1352
1353         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1354         if (result)
1355                 RETURN(result);
1356
1357         env = cl_env_get(&refcheck);
1358         if (IS_ERR(env))
1359                 RETURN(PTR_ERR(env));
1360
1361         args = vvp_env_args(env, IO_NORMAL);
1362         args->u.normal.via_iov = (struct iovec *)iov;
1363         args->u.normal.via_nrsegs = nr_segs;
1364         args->u.normal.via_iocb = iocb;
1365
1366         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1367                                   &iocb->ki_pos, count);
1368         cl_env_put(env, &refcheck);
1369         RETURN(result);
1370 }
1371
1372 static ssize_t ll_file_write(struct file *file, const char __user *buf,
1373                              size_t count, loff_t *ppos)
1374 {
1375         struct lu_env *env;
1376         struct iovec  *local_iov;
1377         struct kiocb  *kiocb;
1378         ssize_t        result;
1379         int            refcheck;
1380         ENTRY;
1381
1382         env = cl_env_get(&refcheck);
1383         if (IS_ERR(env))
1384                 RETURN(PTR_ERR(env));
1385
1386         local_iov = &vvp_env_info(env)->vti_local_iov;
1387         kiocb = &vvp_env_info(env)->vti_kiocb;
1388         local_iov->iov_base = (void __user *)buf;
1389         local_iov->iov_len = count;
1390         init_sync_kiocb(kiocb, file);
1391         kiocb->ki_pos = *ppos;
1392 #ifdef HAVE_KIOCB_KI_LEFT
1393         kiocb->ki_left = count;
1394 #else
1395         kiocb->ki_nbytes = count;
1396 #endif
1397
1398         result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1399         *ppos = kiocb->ki_pos;
1400
1401         cl_env_put(env, &refcheck);
1402         RETURN(result);
1403 }
1404
1405 /*
1406  * Send file content (through pagecache) somewhere with helper
1407  */
1408 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1409                                    struct pipe_inode_info *pipe, size_t count,
1410                                    unsigned int flags)
1411 {
1412         struct lu_env      *env;
1413         struct vvp_io_args *args;
1414         ssize_t             result;
1415         int                 refcheck;
1416         ENTRY;
1417
1418         env = cl_env_get(&refcheck);
1419         if (IS_ERR(env))
1420                 RETURN(PTR_ERR(env));
1421
1422         args = vvp_env_args(env, IO_SPLICE);
1423         args->u.splice.via_pipe = pipe;
1424         args->u.splice.via_flags = flags;
1425
1426         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1427         cl_env_put(env, &refcheck);
1428         RETURN(result);
1429 }
1430
1431 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1432                              __u64  flags, struct lov_user_md *lum,
1433                              int lum_size)
1434 {
1435         struct lov_stripe_md *lsm = NULL;
1436         struct lookup_intent oit = {
1437                 .it_op = IT_OPEN,
1438                 .it_flags = flags | MDS_OPEN_BY_FID,
1439         };
1440         int rc;
1441         ENTRY;
1442
1443         lsm = ccc_inode_lsm_get(inode);
1444         if (lsm != NULL) {
1445                 ccc_inode_lsm_put(inode, lsm);
1446                 CDEBUG(D_IOCTL, "stripe already exists for inode "DFID"\n",
1447                        PFID(ll_inode2fid(inode)));
1448                 GOTO(out, rc = -EEXIST);
1449         }
1450
1451         ll_inode_size_lock(inode);
1452         rc = ll_intent_file_open(file, lum, lum_size, &oit);
1453         if (rc < 0)
1454                 GOTO(out_unlock, rc);
1455
1456         rc = oit.d.lustre.it_status;
1457         if (rc < 0)
1458                 GOTO(out_unlock, rc);
1459
1460         ll_release_openhandle(file->f_dentry, &oit);
1461
1462 out_unlock:
1463         ll_inode_size_unlock(inode);
1464         ll_intent_release(&oit);
1465         ccc_inode_lsm_put(inode, lsm);
1466 out:
1467         cl_lov_delay_create_clear(&file->f_flags);
1468
1469         RETURN(rc);
1470 }
1471
1472 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1473                              struct lov_mds_md **lmmp, int *lmm_size,
1474                              struct ptlrpc_request **request)
1475 {
1476         struct ll_sb_info *sbi = ll_i2sbi(inode);
1477         struct mdt_body  *body;
1478         struct lov_mds_md *lmm = NULL;
1479         struct ptlrpc_request *req = NULL;
1480         struct md_op_data *op_data;
1481         int rc, lmmsize;
1482
1483         rc = ll_get_default_mdsize(sbi, &lmmsize);
1484         if (rc)
1485                 RETURN(rc);
1486
1487         op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
1488                                      strlen(filename), lmmsize,
1489                                      LUSTRE_OPC_ANY, NULL);
1490         if (IS_ERR(op_data))
1491                 RETURN(PTR_ERR(op_data));
1492
1493         op_data->op_valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA;
1494         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
1495         ll_finish_md_op_data(op_data);
1496         if (rc < 0) {
1497                 CDEBUG(D_INFO, "md_getattr_name failed "
1498                        "on %s: rc %d\n", filename, rc);
1499                 GOTO(out, rc);
1500         }
1501
1502         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1503         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1504
1505         lmmsize = body->mbo_eadatasize;
1506
1507         if (!(body->mbo_valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1508                         lmmsize == 0) {
1509                 GOTO(out, rc = -ENODATA);
1510         }
1511
1512         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1513         LASSERT(lmm != NULL);
1514
1515         if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1516             (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1517                 GOTO(out, rc = -EPROTO);
1518         }
1519
1520         /*
1521          * This is coming from the MDS, so is probably in
1522          * little endian.  We convert it to host endian before
1523          * passing it to userspace.
1524          */
1525         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1526                 int stripe_count;
1527
1528                 stripe_count = le16_to_cpu(lmm->lmm_stripe_count);
1529                 if (le32_to_cpu(lmm->lmm_pattern) & LOV_PATTERN_F_RELEASED)
1530                         stripe_count = 0;
1531
1532                 /* if function called for directory - we should
1533                  * avoid swab not existent lsm objects */
1534                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1535                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1536                         if (S_ISREG(body->mbo_mode))
1537                                 lustre_swab_lov_user_md_objects(
1538                                     ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1539                                     stripe_count);
1540                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1541                         lustre_swab_lov_user_md_v3(
1542                                 (struct lov_user_md_v3 *)lmm);
1543                         if (S_ISREG(body->mbo_mode))
1544                                 lustre_swab_lov_user_md_objects(
1545                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1546                                  stripe_count);
1547                 }
1548         }
1549
1550 out:
1551         *lmmp = lmm;
1552         *lmm_size = lmmsize;
1553         *request = req;
1554         return rc;
1555 }
1556
1557 static int ll_lov_setea(struct inode *inode, struct file *file,
1558                             unsigned long arg)
1559 {
1560         __u64                    flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1561         struct lov_user_md      *lump;
1562         int                      lum_size = sizeof(struct lov_user_md) +
1563                                             sizeof(struct lov_user_ost_data);
1564         int                      rc;
1565         ENTRY;
1566
1567         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1568                 RETURN(-EPERM);
1569
1570         OBD_ALLOC_LARGE(lump, lum_size);
1571         if (lump == NULL)
1572                 RETURN(-ENOMEM);
1573
1574         if (copy_from_user(lump, (struct lov_user_md __user *)arg, lum_size)) {
1575                 OBD_FREE_LARGE(lump, lum_size);
1576                 RETURN(-EFAULT);
1577         }
1578
1579         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1580
1581         OBD_FREE_LARGE(lump, lum_size);
1582         RETURN(rc);
1583 }
1584
1585 static int ll_file_getstripe(struct inode *inode,
1586                              struct lov_user_md __user *lum)
1587 {
1588         struct lu_env   *env;
1589         int             refcheck;
1590         int             rc;
1591         ENTRY;
1592
1593         env = cl_env_get(&refcheck);
1594         if (IS_ERR(env))
1595                 RETURN(PTR_ERR(env));
1596
1597         rc = cl_object_getstripe(env, ll_i2info(inode)->lli_clob, lum);
1598         cl_env_put(env, &refcheck);
1599         RETURN(rc);
1600 }
1601
1602 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1603                             unsigned long arg)
1604 {
1605         struct lov_user_md __user *lum = (struct lov_user_md __user *)arg;
1606         struct lov_user_md        *klum;
1607         int                        lum_size, rc;
1608         __u64                      flags = FMODE_WRITE;
1609         ENTRY;
1610
1611         rc = ll_copy_user_md(lum, &klum);
1612         if (rc < 0)
1613                 RETURN(rc);
1614
1615         lum_size = rc;
1616         rc = ll_lov_setstripe_ea_info(inode, file, flags, klum, lum_size);
1617         if (rc == 0) {
1618                 __u32 gen;
1619
1620                 put_user(0, &lum->lmm_stripe_count);
1621
1622                 ll_layout_refresh(inode, &gen);
1623                 rc = ll_file_getstripe(inode, (struct lov_user_md __user *)arg);
1624         }
1625
1626         OBD_FREE(klum, lum_size);
1627         RETURN(rc);
1628 }
1629
1630 static int
1631 ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1632 {
1633         struct ll_inode_info   *lli = ll_i2info(inode);
1634         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1635         struct ccc_grouplock    grouplock;
1636         int                     rc;
1637         ENTRY;
1638
1639         if (arg == 0) {
1640                 CWARN("group id for group lock must not be 0\n");
1641                 RETURN(-EINVAL);
1642         }
1643
1644         if (ll_file_nolock(file))
1645                 RETURN(-EOPNOTSUPP);
1646
1647         spin_lock(&lli->lli_lock);
1648         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1649                 CWARN("group lock already existed with gid %lu\n",
1650                       fd->fd_grouplock.cg_gid);
1651                 spin_unlock(&lli->lli_lock);
1652                 RETURN(-EINVAL);
1653         }
1654         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1655         spin_unlock(&lli->lli_lock);
1656
1657         rc = cl_get_grouplock(ll_i2info(inode)->lli_clob,
1658                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1659         if (rc)
1660                 RETURN(rc);
1661
1662         spin_lock(&lli->lli_lock);
1663         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1664                 spin_unlock(&lli->lli_lock);
1665                 CERROR("another thread just won the race\n");
1666                 cl_put_grouplock(&grouplock);
1667                 RETURN(-EINVAL);
1668         }
1669
1670         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1671         fd->fd_grouplock = grouplock;
1672         spin_unlock(&lli->lli_lock);
1673
1674         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1675         RETURN(0);
1676 }
1677
1678 static int ll_put_grouplock(struct inode *inode, struct file *file,
1679                             unsigned long arg)
1680 {
1681         struct ll_inode_info   *lli = ll_i2info(inode);
1682         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1683         struct ccc_grouplock    grouplock;
1684         ENTRY;
1685
1686         spin_lock(&lli->lli_lock);
1687         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1688                 spin_unlock(&lli->lli_lock);
1689                 CWARN("no group lock held\n");
1690                 RETURN(-EINVAL);
1691         }
1692         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1693
1694         if (fd->fd_grouplock.cg_gid != arg) {
1695                 CWARN("group lock %lu doesn't match current id %lu\n",
1696                        arg, fd->fd_grouplock.cg_gid);
1697                 spin_unlock(&lli->lli_lock);
1698                 RETURN(-EINVAL);
1699         }
1700
1701         grouplock = fd->fd_grouplock;
1702         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1703         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1704         spin_unlock(&lli->lli_lock);
1705
1706         cl_put_grouplock(&grouplock);
1707         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1708         RETURN(0);
1709 }
1710
1711 /**
1712  * Close inode open handle
1713  *
1714  * \param dentry [in]     dentry which contains the inode
1715  * \param it     [in,out] intent which contains open info and result
1716  *
1717  * \retval 0     success
1718  * \retval <0    failure
1719  */
1720 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1721 {
1722         struct inode *inode = dentry->d_inode;
1723         struct obd_client_handle *och;
1724         int rc;
1725         ENTRY;
1726
1727         LASSERT(inode);
1728
1729         /* Root ? Do nothing. */
1730         if (dentry->d_inode->i_sb->s_root == dentry)
1731                 RETURN(0);
1732
1733         /* No open handle to close? Move away */
1734         if (!it_disposition(it, DISP_OPEN_OPEN))
1735                 RETURN(0);
1736
1737         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1738
1739         OBD_ALLOC(och, sizeof(*och));
1740         if (!och)
1741                 GOTO(out, rc = -ENOMEM);
1742
1743         ll_och_fill(ll_i2sbi(inode)->ll_md_exp, it, och);
1744
1745         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1746                                        inode, och, NULL);
1747 out:
1748         /* this one is in place of ll_file_open */
1749         if (it_disposition(it, DISP_ENQ_OPEN_REF)) {
1750                 ptlrpc_req_finished(it->d.lustre.it_data);
1751                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1752         }
1753         RETURN(rc);
1754 }
1755
1756 /**
1757  * Get size for inode for which FIEMAP mapping is requested.
1758  * Make the FIEMAP get_info call and returns the result.
1759  */
1760 static int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1761                         size_t num_bytes)
1762 {
1763         struct obd_export *exp = ll_i2dtexp(inode);
1764         struct lov_stripe_md *lsm = NULL;
1765         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1766         __u32 vallen = num_bytes;
1767         int rc;
1768         ENTRY;
1769
1770         /* Checks for fiemap flags */
1771         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1772                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1773                 return -EBADR;
1774         }
1775
1776         /* Check for FIEMAP_FLAG_SYNC */
1777         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1778                 rc = filemap_fdatawrite(inode->i_mapping);
1779                 if (rc)
1780                         return rc;
1781         }
1782
1783         lsm = ccc_inode_lsm_get(inode);
1784         if (lsm == NULL)
1785                 return -ENOENT;
1786
1787         /* If the stripe_count > 1 and the application does not understand
1788          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1789          */
1790         if (lsm->lsm_stripe_count > 1 &&
1791             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1792                 GOTO(out, rc = -EOPNOTSUPP);
1793
1794         fm_key.oa.o_oi = lsm->lsm_oi;
1795         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1796
1797         if (i_size_read(inode) == 0) {
1798                 rc = ll_glimpse_size(inode);
1799                 if (rc)
1800                         GOTO(out, rc);
1801         }
1802
1803         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLSIZE);
1804         obdo_set_parent_fid(&fm_key.oa, &ll_i2info(inode)->lli_fid);
1805         /* If filesize is 0, then there would be no objects for mapping */
1806         if (fm_key.oa.o_size == 0) {
1807                 fiemap->fm_mapped_extents = 0;
1808                 GOTO(out, rc = 0);
1809         }
1810
1811         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1812
1813         rc = obd_get_info(NULL, exp, sizeof(fm_key), &fm_key, &vallen,
1814                           fiemap, lsm);
1815         if (rc)
1816                 CERROR("obd_get_info failed: rc = %d\n", rc);
1817
1818 out:
1819         ccc_inode_lsm_put(inode, lsm);
1820         RETURN(rc);
1821 }
1822
1823 int ll_fid2path(struct inode *inode, void __user *arg)
1824 {
1825         struct obd_export       *exp = ll_i2mdexp(inode);
1826         const struct getinfo_fid2path __user *gfin = arg;
1827         __u32                    pathlen;
1828         struct getinfo_fid2path *gfout;
1829         size_t                   outsize;
1830         int                      rc;
1831
1832         ENTRY;
1833
1834         if (!cfs_capable(CFS_CAP_DAC_READ_SEARCH) &&
1835             !(ll_i2sbi(inode)->ll_flags & LL_SBI_USER_FID2PATH))
1836                 RETURN(-EPERM);
1837
1838         /* Only need to get the buflen */
1839         if (get_user(pathlen, &gfin->gf_pathlen))
1840                 RETURN(-EFAULT);
1841
1842         if (pathlen > PATH_MAX)
1843                 RETURN(-EINVAL);
1844
1845         outsize = sizeof(*gfout) + pathlen;
1846         OBD_ALLOC(gfout, outsize);
1847         if (gfout == NULL)
1848                 RETURN(-ENOMEM);
1849
1850         if (copy_from_user(gfout, arg, sizeof(*gfout)))
1851                 GOTO(gf_free, rc = -EFAULT);
1852
1853         /* Call mdc_iocontrol */
1854         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1855         if (rc != 0)
1856                 GOTO(gf_free, rc);
1857
1858         if (copy_to_user(arg, gfout, outsize))
1859                 rc = -EFAULT;
1860
1861 gf_free:
1862         OBD_FREE(gfout, outsize);
1863         RETURN(rc);
1864 }
1865
1866 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1867 {
1868         struct ll_user_fiemap *fiemap_s;
1869         size_t num_bytes, ret_bytes;
1870         unsigned int extent_count;
1871         int rc = 0;
1872
1873         /* Get the extent count so we can calculate the size of
1874          * required fiemap buffer */
1875         if (get_user(extent_count,
1876             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1877                 RETURN(-EFAULT);
1878
1879         if (extent_count >=
1880             (SIZE_MAX - sizeof(*fiemap_s)) / sizeof(struct ll_fiemap_extent))
1881                 RETURN(-EINVAL);
1882         num_bytes = sizeof(*fiemap_s) + (extent_count *
1883                                          sizeof(struct ll_fiemap_extent));
1884
1885         OBD_ALLOC_LARGE(fiemap_s, num_bytes);
1886         if (fiemap_s == NULL)
1887                 RETURN(-ENOMEM);
1888
1889         /* get the fiemap value */
1890         if (copy_from_user(fiemap_s, (struct ll_user_fiemap __user *)arg,
1891                            sizeof(*fiemap_s)))
1892                 GOTO(error, rc = -EFAULT);
1893
1894         /* If fm_extent_count is non-zero, read the first extent since
1895          * it is used to calculate end_offset and device from previous
1896          * fiemap call. */
1897         if (extent_count) {
1898                 if (copy_from_user(&fiemap_s->fm_extents[0],
1899                     (char __user *)arg + sizeof(*fiemap_s),
1900                     sizeof(struct ll_fiemap_extent)))
1901                         GOTO(error, rc = -EFAULT);
1902         }
1903
1904         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1905         if (rc)
1906                 GOTO(error, rc);
1907
1908         ret_bytes = sizeof(struct ll_user_fiemap);
1909
1910         if (extent_count != 0)
1911                 ret_bytes += (fiemap_s->fm_mapped_extents *
1912                                  sizeof(struct ll_fiemap_extent));
1913
1914         if (copy_to_user((void __user *)arg, fiemap_s, ret_bytes))
1915                 rc = -EFAULT;
1916
1917 error:
1918         OBD_FREE_LARGE(fiemap_s, num_bytes);
1919         RETURN(rc);
1920 }
1921
1922 /*
1923  * Read the data_version for inode.
1924  *
1925  * This value is computed using stripe object version on OST.
1926  * Version is computed using server side locking.
1927  *
1928  * @param sync if do sync on the OST side;
1929  *              0: no sync
1930  *              LL_DV_RD_FLUSH: flush dirty pages, LCK_PR on OSTs
1931  *              LL_DV_WR_FLUSH: drop all caching pages, LCK_PW on OSTs
1932  */
1933 int ll_data_version(struct inode *inode, __u64 *data_version, int flags)
1934 {
1935         struct lov_stripe_md    *lsm = NULL;
1936         struct ll_sb_info       *sbi = ll_i2sbi(inode);
1937         struct obdo             *obdo = NULL;
1938         int                      rc;
1939         ENTRY;
1940
1941         /* If no stripe, we consider version is 0. */
1942         lsm = ccc_inode_lsm_get(inode);
1943         if (!lsm_has_objects(lsm)) {
1944                 *data_version = 0;
1945                 CDEBUG(D_INODE, "No object for inode\n");
1946                 GOTO(out, rc = 0);
1947         }
1948
1949         OBD_ALLOC_PTR(obdo);
1950         if (obdo == NULL)
1951                 GOTO(out, rc = -ENOMEM);
1952
1953         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, obdo, 0, flags);
1954         if (rc == 0) {
1955                 if (!(obdo->o_valid & OBD_MD_FLDATAVERSION))
1956                         rc = -EOPNOTSUPP;
1957                 else
1958                         *data_version = obdo->o_data_version;
1959         }
1960
1961         OBD_FREE_PTR(obdo);
1962         EXIT;
1963 out:
1964         ccc_inode_lsm_put(inode, lsm);
1965         RETURN(rc);
1966 }
1967
1968 /*
1969  * Trigger a HSM release request for the provided inode.
1970  */
1971 int ll_hsm_release(struct inode *inode)
1972 {
1973         struct cl_env_nest nest;
1974         struct lu_env *env;
1975         struct obd_client_handle *och = NULL;
1976         __u64 data_version = 0;
1977         int rc;
1978         ENTRY;
1979
1980         CDEBUG(D_INODE, "%s: Releasing file "DFID".\n",
1981                ll_get_fsname(inode->i_sb, NULL, 0),
1982                PFID(&ll_i2info(inode)->lli_fid));
1983
1984         och = ll_lease_open(inode, NULL, FMODE_WRITE, MDS_OPEN_RELEASE);
1985         if (IS_ERR(och))
1986                 GOTO(out, rc = PTR_ERR(och));
1987
1988         /* Grab latest data_version and [am]time values */
1989         rc = ll_data_version(inode, &data_version, LL_DV_WR_FLUSH);
1990         if (rc != 0)
1991                 GOTO(out, rc);
1992
1993         env = cl_env_nested_get(&nest);
1994         if (IS_ERR(env))
1995                 GOTO(out, rc = PTR_ERR(env));
1996
1997         ll_merge_attr(env, inode);
1998         cl_env_nested_put(&nest, env);
1999
2000         /* Release the file.
2001          * NB: lease lock handle is released in mdc_hsm_release_pack() because
2002          * we still need it to pack l_remote_handle to MDT. */
2003         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp, inode, och,
2004                                        &data_version);
2005         och = NULL;
2006
2007         EXIT;
2008 out:
2009         if (och != NULL && !IS_ERR(och)) /* close the file */
2010                 ll_lease_close(och, inode, NULL);
2011
2012         return rc;
2013 }
2014
2015 struct ll_swap_stack {
2016         struct iattr             ia1, ia2;
2017         __u64                    dv1, dv2;
2018         struct inode            *inode1, *inode2;
2019         bool                     check_dv1, check_dv2;
2020 };
2021
2022 static int ll_swap_layouts(struct file *file1, struct file *file2,
2023                            struct lustre_swap_layouts *lsl)
2024 {
2025         struct mdc_swap_layouts  msl;
2026         struct md_op_data       *op_data;
2027         __u32                    gid;
2028         __u64                    dv;
2029         struct ll_swap_stack    *llss = NULL;
2030         int                      rc;
2031
2032         OBD_ALLOC_PTR(llss);
2033         if (llss == NULL)
2034                 RETURN(-ENOMEM);
2035
2036         llss->inode1 = file1->f_dentry->d_inode;
2037         llss->inode2 = file2->f_dentry->d_inode;
2038
2039         if (!S_ISREG(llss->inode2->i_mode))
2040                 GOTO(free, rc = -EINVAL);
2041
2042         if (inode_permission(llss->inode1, MAY_WRITE) ||
2043             inode_permission(llss->inode2, MAY_WRITE))
2044                 GOTO(free, rc = -EPERM);
2045
2046         if (llss->inode2->i_sb != llss->inode1->i_sb)
2047                 GOTO(free, rc = -EXDEV);
2048
2049         /* we use 2 bool because it is easier to swap than 2 bits */
2050         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV1)
2051                 llss->check_dv1 = true;
2052
2053         if (lsl->sl_flags & SWAP_LAYOUTS_CHECK_DV2)
2054                 llss->check_dv2 = true;
2055
2056         /* we cannot use lsl->sl_dvX directly because we may swap them */
2057         llss->dv1 = lsl->sl_dv1;
2058         llss->dv2 = lsl->sl_dv2;
2059
2060         rc = lu_fid_cmp(ll_inode2fid(llss->inode1), ll_inode2fid(llss->inode2));
2061         if (rc == 0) /* same file, done! */
2062                 GOTO(free, rc = 0);
2063
2064         if (rc < 0) { /* sequentialize it */
2065                 swap(llss->inode1, llss->inode2);
2066                 swap(file1, file2);
2067                 swap(llss->dv1, llss->dv2);
2068                 swap(llss->check_dv1, llss->check_dv2);
2069         }
2070
2071         gid = lsl->sl_gid;
2072         if (gid != 0) { /* application asks to flush dirty cache */
2073                 rc = ll_get_grouplock(llss->inode1, file1, gid);
2074                 if (rc < 0)
2075                         GOTO(free, rc);
2076
2077                 rc = ll_get_grouplock(llss->inode2, file2, gid);
2078                 if (rc < 0) {
2079                         ll_put_grouplock(llss->inode1, file1, gid);
2080                         GOTO(free, rc);
2081                 }
2082         }
2083
2084         /* to be able to restore mtime and atime after swap
2085          * we need to first save them */
2086         if (lsl->sl_flags &
2087             (SWAP_LAYOUTS_KEEP_MTIME | SWAP_LAYOUTS_KEEP_ATIME)) {
2088                 llss->ia1.ia_mtime = llss->inode1->i_mtime;
2089                 llss->ia1.ia_atime = llss->inode1->i_atime;
2090                 llss->ia1.ia_valid = ATTR_MTIME | ATTR_ATIME;
2091                 llss->ia2.ia_mtime = llss->inode2->i_mtime;
2092                 llss->ia2.ia_atime = llss->inode2->i_atime;
2093                 llss->ia2.ia_valid = ATTR_MTIME | ATTR_ATIME;
2094         }
2095
2096         /* ultimate check, before swaping the layouts we check if
2097          * dataversion has changed (if requested) */
2098         if (llss->check_dv1) {
2099                 rc = ll_data_version(llss->inode1, &dv, 0);
2100                 if (rc)
2101                         GOTO(putgl, rc);
2102                 if (dv != llss->dv1)
2103                         GOTO(putgl, rc = -EAGAIN);
2104         }
2105
2106         if (llss->check_dv2) {
2107                 rc = ll_data_version(llss->inode2, &dv, 0);
2108                 if (rc)
2109                         GOTO(putgl, rc);
2110                 if (dv != llss->dv2)
2111                         GOTO(putgl, rc = -EAGAIN);
2112         }
2113
2114         /* struct md_op_data is used to send the swap args to the mdt
2115          * only flags is missing, so we use struct mdc_swap_layouts
2116          * through the md_op_data->op_data */
2117         /* flags from user space have to be converted before they are send to
2118          * server, no flag is sent today, they are only used on the client */
2119         msl.msl_flags = 0;
2120         rc = -ENOMEM;
2121         op_data = ll_prep_md_op_data(NULL, llss->inode1, llss->inode2, NULL, 0,
2122                                      0, LUSTRE_OPC_ANY, &msl);
2123         if (IS_ERR(op_data))
2124                 GOTO(free, rc = PTR_ERR(op_data));
2125
2126         rc = obd_iocontrol(LL_IOC_LOV_SWAP_LAYOUTS, ll_i2mdexp(llss->inode1),
2127                            sizeof(*op_data), op_data, NULL);
2128         ll_finish_md_op_data(op_data);
2129
2130 putgl:
2131         if (gid != 0) {
2132                 ll_put_grouplock(llss->inode2, file2, gid);
2133                 ll_put_grouplock(llss->inode1, file1, gid);
2134         }
2135
2136         /* rc can be set from obd_iocontrol() or from a GOTO(putgl, ...) */
2137         if (rc != 0)
2138                 GOTO(free, rc);
2139
2140         /* clear useless flags */
2141         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_MTIME)) {
2142                 llss->ia1.ia_valid &= ~ATTR_MTIME;
2143                 llss->ia2.ia_valid &= ~ATTR_MTIME;
2144         }
2145
2146         if (!(lsl->sl_flags & SWAP_LAYOUTS_KEEP_ATIME)) {
2147                 llss->ia1.ia_valid &= ~ATTR_ATIME;
2148                 llss->ia2.ia_valid &= ~ATTR_ATIME;
2149         }
2150
2151         /* update time if requested */
2152         rc = 0;
2153         if (llss->ia2.ia_valid != 0) {
2154                 mutex_lock(&llss->inode1->i_mutex);
2155                 rc = ll_setattr(file1->f_dentry, &llss->ia2);
2156                 mutex_unlock(&llss->inode1->i_mutex);
2157         }
2158
2159         if (llss->ia1.ia_valid != 0) {
2160                 int rc1;
2161
2162                 mutex_lock(&llss->inode2->i_mutex);
2163                 rc1 = ll_setattr(file2->f_dentry, &llss->ia1);
2164                 mutex_unlock(&llss->inode2->i_mutex);
2165                 if (rc == 0)
2166                         rc = rc1;
2167         }
2168
2169 free:
2170         if (llss != NULL)
2171                 OBD_FREE_PTR(llss);
2172
2173         RETURN(rc);
2174 }
2175
2176 static int ll_hsm_state_set(struct inode *inode, struct hsm_state_set *hss)
2177 {
2178         struct md_op_data       *op_data;
2179         int                      rc;
2180
2181         /* Non-root users are forbidden to set or clear flags which are
2182          * NOT defined in HSM_USER_MASK. */
2183         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
2184             !cfs_capable(CFS_CAP_SYS_ADMIN))
2185                 RETURN(-EPERM);
2186
2187         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2188                                      LUSTRE_OPC_ANY, hss);
2189         if (IS_ERR(op_data))
2190                 RETURN(PTR_ERR(op_data));
2191
2192         rc = obd_iocontrol(LL_IOC_HSM_STATE_SET, ll_i2mdexp(inode),
2193                            sizeof(*op_data), op_data, NULL);
2194
2195         ll_finish_md_op_data(op_data);
2196
2197         RETURN(rc);
2198 }
2199
2200 static int ll_hsm_import(struct inode *inode, struct file *file,
2201                          struct hsm_user_import *hui)
2202 {
2203         struct hsm_state_set    *hss = NULL;
2204         struct iattr            *attr = NULL;
2205         int                      rc;
2206         ENTRY;
2207
2208         if (!S_ISREG(inode->i_mode))
2209                 RETURN(-EINVAL);
2210
2211         /* set HSM flags */
2212         OBD_ALLOC_PTR(hss);
2213         if (hss == NULL)
2214                 GOTO(out, rc = -ENOMEM);
2215
2216         hss->hss_valid = HSS_SETMASK | HSS_ARCHIVE_ID;
2217         hss->hss_archive_id = hui->hui_archive_id;
2218         hss->hss_setmask = HS_ARCHIVED | HS_EXISTS | HS_RELEASED;
2219         rc = ll_hsm_state_set(inode, hss);
2220         if (rc != 0)
2221                 GOTO(out, rc);
2222
2223         OBD_ALLOC_PTR(attr);
2224         if (attr == NULL)
2225                 GOTO(out, rc = -ENOMEM);
2226
2227         attr->ia_mode = hui->hui_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2228         attr->ia_mode |= S_IFREG;
2229         attr->ia_uid = make_kuid(&init_user_ns, hui->hui_uid);
2230         attr->ia_gid = make_kgid(&init_user_ns, hui->hui_gid);
2231         attr->ia_size = hui->hui_size;
2232         attr->ia_mtime.tv_sec = hui->hui_mtime;
2233         attr->ia_mtime.tv_nsec = hui->hui_mtime_ns;
2234         attr->ia_atime.tv_sec = hui->hui_atime;
2235         attr->ia_atime.tv_nsec = hui->hui_atime_ns;
2236
2237         attr->ia_valid = ATTR_SIZE | ATTR_MODE | ATTR_FORCE |
2238                          ATTR_UID | ATTR_GID |
2239                          ATTR_MTIME | ATTR_MTIME_SET |
2240                          ATTR_ATIME | ATTR_ATIME_SET;
2241
2242         mutex_lock(&inode->i_mutex);
2243
2244         rc = ll_setattr_raw(file->f_dentry, attr, true);
2245         if (rc == -ENODATA)
2246                 rc = 0;
2247
2248         mutex_unlock(&inode->i_mutex);
2249
2250 out:
2251         if (hss != NULL)
2252                 OBD_FREE_PTR(hss);
2253
2254         if (attr != NULL)
2255                 OBD_FREE_PTR(attr);
2256
2257         RETURN(rc);
2258 }
2259
2260 static inline long ll_lease_type_from_fmode(fmode_t fmode)
2261 {
2262         return ((fmode & FMODE_READ) ? LL_LEASE_RDLCK : 0) |
2263                ((fmode & FMODE_WRITE) ? LL_LEASE_WRLCK : 0);
2264 }
2265
2266 static long
2267 ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2268 {
2269         struct inode            *inode = file->f_dentry->d_inode;
2270         struct ll_file_data     *fd = LUSTRE_FPRIVATE(file);
2271         int                      flags, rc;
2272         ENTRY;
2273
2274         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
2275                PFID(ll_inode2fid(inode)), inode, cmd);
2276         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
2277
2278         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
2279         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
2280                 RETURN(-ENOTTY);
2281
2282         switch(cmd) {
2283         case LL_IOC_GETFLAGS:
2284                 /* Get the current value of the file flags */
2285                 return put_user(fd->fd_flags, (int __user *)arg);
2286         case LL_IOC_SETFLAGS:
2287         case LL_IOC_CLRFLAGS:
2288                 /* Set or clear specific file flags */
2289                 /* XXX This probably needs checks to ensure the flags are
2290                  *     not abused, and to handle any flag side effects.
2291                  */
2292                 if (get_user(flags, (int __user *) arg))
2293                         RETURN(-EFAULT);
2294
2295                 if (cmd == LL_IOC_SETFLAGS) {
2296                         if ((flags & LL_FILE_IGNORE_LOCK) &&
2297                             !(file->f_flags & O_DIRECT)) {
2298                                 CERROR("%s: unable to disable locking on "
2299                                        "non-O_DIRECT file\n", current->comm);
2300                                 RETURN(-EINVAL);
2301                         }
2302
2303                         fd->fd_flags |= flags;
2304                 } else {
2305                         fd->fd_flags &= ~flags;
2306                 }
2307                 RETURN(0);
2308         case LL_IOC_LOV_SETSTRIPE:
2309                 RETURN(ll_lov_setstripe(inode, file, arg));
2310         case LL_IOC_LOV_SETEA:
2311                 RETURN(ll_lov_setea(inode, file, arg));
2312         case LL_IOC_LOV_SWAP_LAYOUTS: {
2313                 struct file *file2;
2314                 struct lustre_swap_layouts lsl;
2315
2316                 if (copy_from_user(&lsl, (char __user *)arg,
2317                                        sizeof(struct lustre_swap_layouts)))
2318                         RETURN(-EFAULT);
2319
2320                 if ((file->f_flags & O_ACCMODE) == 0) /* O_RDONLY */
2321                         RETURN(-EPERM);
2322
2323                 file2 = fget(lsl.sl_fd);
2324                 if (file2 == NULL)
2325                         RETURN(-EBADF);
2326
2327                 rc = -EPERM;
2328                 if ((file2->f_flags & O_ACCMODE) != 0) /* O_WRONLY or O_RDWR */
2329                         rc = ll_swap_layouts(file, file2, &lsl);
2330                 fput(file2);
2331                 RETURN(rc);
2332         }
2333         case LL_IOC_LOV_GETSTRIPE:
2334                 RETURN(ll_file_getstripe(inode,
2335                                          (struct lov_user_md __user *)arg));
2336         case FSFILT_IOC_FIEMAP:
2337                 RETURN(ll_ioctl_fiemap(inode, arg));
2338         case FSFILT_IOC_GETFLAGS:
2339         case FSFILT_IOC_SETFLAGS:
2340                 RETURN(ll_iocontrol(inode, file, cmd, arg));
2341         case FSFILT_IOC_GETVERSION_OLD:
2342         case FSFILT_IOC_GETVERSION:
2343                 RETURN(put_user(inode->i_generation, (int __user *)arg));
2344         case LL_IOC_GROUP_LOCK:
2345                 RETURN(ll_get_grouplock(inode, file, arg));
2346         case LL_IOC_GROUP_UNLOCK:
2347                 RETURN(ll_put_grouplock(inode, file, arg));
2348         case IOC_OBD_STATFS:
2349                 RETURN(ll_obd_statfs(inode, (void __user *)arg));
2350
2351         /* We need to special case any other ioctls we want to handle,
2352          * to send them to the MDS/OST as appropriate and to properly
2353          * network encode the arg field.
2354         case FSFILT_IOC_SETVERSION_OLD:
2355         case FSFILT_IOC_SETVERSION:
2356         */
2357         case LL_IOC_FLUSHCTX:
2358                 RETURN(ll_flush_ctx(inode));
2359         case LL_IOC_PATH2FID: {
2360                 if (copy_to_user((void __user *)arg, ll_inode2fid(inode),
2361                                  sizeof(struct lu_fid)))
2362                         RETURN(-EFAULT);
2363
2364                 RETURN(0);
2365         }
2366         case LL_IOC_GETPARENT:
2367                 RETURN(ll_getparent(file, (struct getparent __user *)arg));
2368
2369         case OBD_IOC_FID2PATH:
2370                 RETURN(ll_fid2path(inode, (void __user *)arg));
2371         case LL_IOC_DATA_VERSION: {
2372                 struct ioc_data_version idv;
2373                 int rc;
2374
2375                 if (copy_from_user(&idv, (char __user *)arg, sizeof(idv)))
2376                         RETURN(-EFAULT);
2377
2378                 idv.idv_flags &= LL_DV_RD_FLUSH | LL_DV_WR_FLUSH;
2379                 rc = ll_data_version(inode, &idv.idv_version, idv.idv_flags);
2380
2381                 if (rc == 0 &&
2382                     copy_to_user((char __user *)arg, &idv, sizeof(idv)))
2383                         RETURN(-EFAULT);
2384
2385                 RETURN(rc);
2386         }
2387
2388         case LL_IOC_GET_MDTIDX: {
2389                 int mdtidx;
2390
2391                 mdtidx = ll_get_mdt_idx(inode);
2392                 if (mdtidx < 0)
2393                         RETURN(mdtidx);
2394
2395                 if (put_user((int)mdtidx, (int __user *)arg))
2396                         RETURN(-EFAULT);
2397
2398                 RETURN(0);
2399         }
2400         case OBD_IOC_GETDTNAME:
2401         case OBD_IOC_GETMDNAME:
2402                 RETURN(ll_get_obd_name(inode, cmd, arg));
2403         case LL_IOC_HSM_STATE_GET: {
2404                 struct md_op_data       *op_data;
2405                 struct hsm_user_state   *hus;
2406                 int                      rc;
2407
2408                 OBD_ALLOC_PTR(hus);
2409                 if (hus == NULL)
2410                         RETURN(-ENOMEM);
2411
2412                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2413                                              LUSTRE_OPC_ANY, hus);
2414                 if (IS_ERR(op_data)) {
2415                         OBD_FREE_PTR(hus);
2416                         RETURN(PTR_ERR(op_data));
2417                 }
2418
2419                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2420                                    op_data, NULL);
2421
2422                 if (copy_to_user((void __user *)arg, hus, sizeof(*hus)))
2423                         rc = -EFAULT;
2424
2425                 ll_finish_md_op_data(op_data);
2426                 OBD_FREE_PTR(hus);
2427                 RETURN(rc);
2428         }
2429         case LL_IOC_HSM_STATE_SET: {
2430                 struct hsm_state_set    *hss;
2431                 int                      rc;
2432
2433                 OBD_ALLOC_PTR(hss);
2434                 if (hss == NULL)
2435                         RETURN(-ENOMEM);
2436
2437                 if (copy_from_user(hss, (char __user *)arg, sizeof(*hss))) {
2438                         OBD_FREE_PTR(hss);
2439                         RETURN(-EFAULT);
2440                 }
2441
2442                 rc = ll_hsm_state_set(inode, hss);
2443
2444                 OBD_FREE_PTR(hss);
2445                 RETURN(rc);
2446         }
2447         case LL_IOC_HSM_ACTION: {
2448                 struct md_op_data               *op_data;
2449                 struct hsm_current_action       *hca;
2450                 int                              rc;
2451
2452                 OBD_ALLOC_PTR(hca);
2453                 if (hca == NULL)
2454                         RETURN(-ENOMEM);
2455
2456                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2457                                              LUSTRE_OPC_ANY, hca);
2458                 if (IS_ERR(op_data)) {
2459                         OBD_FREE_PTR(hca);
2460                         RETURN(PTR_ERR(op_data));
2461                 }
2462
2463                 rc = obd_iocontrol(cmd, ll_i2mdexp(inode), sizeof(*op_data),
2464                                    op_data, NULL);
2465
2466                 if (copy_to_user((char __user *)arg, hca, sizeof(*hca)))
2467                         rc = -EFAULT;
2468
2469                 ll_finish_md_op_data(op_data);
2470                 OBD_FREE_PTR(hca);
2471                 RETURN(rc);
2472         }
2473         case LL_IOC_SET_LEASE: {
2474                 struct ll_inode_info *lli = ll_i2info(inode);
2475                 struct obd_client_handle *och = NULL;
2476                 bool lease_broken;
2477                 fmode_t fmode;
2478
2479                 switch (arg) {
2480                 case LL_LEASE_WRLCK:
2481                         if (!(file->f_mode & FMODE_WRITE))
2482                                 RETURN(-EPERM);
2483                         fmode = FMODE_WRITE;
2484                         break;
2485                 case LL_LEASE_RDLCK:
2486                         if (!(file->f_mode & FMODE_READ))
2487                                 RETURN(-EPERM);
2488                         fmode = FMODE_READ;
2489                         break;
2490                 case LL_LEASE_UNLCK:
2491                         mutex_lock(&lli->lli_och_mutex);
2492                         if (fd->fd_lease_och != NULL) {
2493                                 och = fd->fd_lease_och;
2494                                 fd->fd_lease_och = NULL;
2495                         }
2496                         mutex_unlock(&lli->lli_och_mutex);
2497
2498                         if (och == NULL)
2499                                 RETURN(-ENOLCK);
2500
2501                         fmode = och->och_flags;
2502                         rc = ll_lease_close(och, inode, &lease_broken);
2503                         if (rc < 0)
2504                                 RETURN(rc);
2505
2506                         if (lease_broken)
2507                                 fmode = 0;
2508
2509                         RETURN(ll_lease_type_from_fmode(fmode));
2510                 default:
2511                         RETURN(-EINVAL);
2512                 }
2513
2514                 CDEBUG(D_INODE, "Set lease with mode %u\n", fmode);
2515
2516                 /* apply for lease */
2517                 och = ll_lease_open(inode, file, fmode, 0);
2518                 if (IS_ERR(och))
2519                         RETURN(PTR_ERR(och));
2520
2521                 rc = 0;
2522                 mutex_lock(&lli->lli_och_mutex);
2523                 if (fd->fd_lease_och == NULL) {
2524                         fd->fd_lease_och = och;
2525                         och = NULL;
2526                 }
2527                 mutex_unlock(&lli->lli_och_mutex);
2528                 if (och != NULL) {
2529                         /* impossible now that only excl is supported for now */
2530                         ll_lease_close(och, inode, &lease_broken);
2531                         rc = -EBUSY;
2532                 }
2533                 RETURN(rc);
2534         }
2535         case LL_IOC_GET_LEASE: {
2536                 struct ll_inode_info *lli = ll_i2info(inode);
2537                 struct ldlm_lock *lock = NULL;
2538                 fmode_t fmode = 0;
2539
2540                 mutex_lock(&lli->lli_och_mutex);
2541                 if (fd->fd_lease_och != NULL) {
2542                         struct obd_client_handle *och = fd->fd_lease_och;
2543
2544                         lock = ldlm_handle2lock(&och->och_lease_handle);
2545                         if (lock != NULL) {
2546                                 lock_res_and_lock(lock);
2547                                 if (!ldlm_is_cancel(lock))
2548                                         fmode = och->och_flags;
2549
2550                                 unlock_res_and_lock(lock);
2551                                 LDLM_LOCK_PUT(lock);
2552                         }
2553                 }
2554                 mutex_unlock(&lli->lli_och_mutex);
2555
2556                 RETURN(ll_lease_type_from_fmode(fmode));
2557         }
2558         case LL_IOC_HSM_IMPORT: {
2559                 struct hsm_user_import *hui;
2560
2561                 OBD_ALLOC_PTR(hui);
2562                 if (hui == NULL)
2563                         RETURN(-ENOMEM);
2564
2565                 if (copy_from_user(hui, (void __user *)arg, sizeof(*hui))) {
2566                         OBD_FREE_PTR(hui);
2567                         RETURN(-EFAULT);
2568                 }
2569
2570                 rc = ll_hsm_import(inode, file, hui);
2571
2572                 OBD_FREE_PTR(hui);
2573                 RETURN(rc);
2574         }
2575
2576         default: {
2577                 int err;
2578
2579                 if (LLIOC_STOP ==
2580                      ll_iocontrol_call(inode, file, cmd, arg, &err))
2581                         RETURN(err);
2582
2583                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
2584                                      (void __user *)arg));
2585         }
2586         }
2587 }
2588
2589 #ifndef HAVE_FILE_LLSEEK_SIZE
2590 static inline loff_t
2591 llseek_execute(struct file *file, loff_t offset, loff_t maxsize)
2592 {
2593         if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET))
2594                 return -EINVAL;
2595         if (offset > maxsize)
2596                 return -EINVAL;
2597
2598         if (offset != file->f_pos) {
2599                 file->f_pos = offset;
2600                 file->f_version = 0;
2601         }
2602         return offset;
2603 }
2604
2605 static loff_t
2606 generic_file_llseek_size(struct file *file, loff_t offset, int origin,
2607                 loff_t maxsize, loff_t eof)
2608 {
2609         struct inode *inode = file->f_dentry->d_inode;
2610
2611         switch (origin) {
2612         case SEEK_END:
2613                 offset += eof;
2614                 break;
2615         case SEEK_CUR:
2616                 /*
2617                  * Here we special-case the lseek(fd, 0, SEEK_CUR)
2618                  * position-querying operation.  Avoid rewriting the "same"
2619                  * f_pos value back to the file because a concurrent read(),
2620                  * write() or lseek() might have altered it
2621                  */
2622                 if (offset == 0)
2623                         return file->f_pos;
2624                 /*
2625                  * f_lock protects against read/modify/write race with other
2626                  * SEEK_CURs. Note that parallel writes and reads behave
2627                  * like SEEK_SET.
2628                  */
2629                 mutex_lock(&inode->i_mutex);
2630                 offset = llseek_execute(file, file->f_pos + offset, maxsize);
2631                 mutex_unlock(&inode->i_mutex);
2632                 return offset;
2633         case SEEK_DATA:
2634                 /*
2635                  * In the generic case the entire file is data, so as long as
2636                  * offset isn't at the end of the file then the offset is data.
2637                  */
2638                 if (offset >= eof)
2639                         return -ENXIO;
2640                 break;
2641         case SEEK_HOLE:
2642                 /*
2643                  * There is a virtual hole at the end of the file, so as long as
2644                  * offset isn't i_size or larger, return i_size.
2645                  */
2646                 if (offset >= eof)
2647                         return -ENXIO;
2648                 offset = eof;
2649                 break;
2650         }
2651
2652         return llseek_execute(file, offset, maxsize);
2653 }
2654 #endif
2655
2656 static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
2657 {
2658         struct inode *inode = file->f_dentry->d_inode;
2659         loff_t retval, eof = 0;
2660
2661         ENTRY;
2662         retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
2663                            (origin == SEEK_CUR) ? file->f_pos : 0);
2664         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
2665                PFID(ll_inode2fid(inode)), inode, retval, retval,
2666                origin);
2667         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
2668
2669         if (origin == SEEK_END || origin == SEEK_HOLE || origin == SEEK_DATA) {
2670                 retval = ll_glimpse_size(inode);
2671                 if (retval != 0)
2672                         RETURN(retval);
2673                 eof = i_size_read(inode);
2674         }
2675
2676         retval = ll_generic_file_llseek_size(file, offset, origin,
2677                                           ll_file_maxbytes(inode), eof);
2678         RETURN(retval);
2679 }
2680
2681 static int ll_flush(struct file *file, fl_owner_t id)
2682 {
2683         struct inode *inode = file->f_dentry->d_inode;
2684         struct ll_inode_info *lli = ll_i2info(inode);
2685         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2686         int rc, err;
2687
2688         LASSERT(!S_ISDIR(inode->i_mode));
2689
2690         /* catch async errors that were recorded back when async writeback
2691          * failed for pages in this mapping. */
2692         rc = lli->lli_async_rc;
2693         lli->lli_async_rc = 0;
2694         if (lli->lli_clob != NULL) {
2695                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2696                 if (rc == 0)
2697                         rc = err;
2698         }
2699
2700         /* The application has been told write failure already.
2701          * Do not report failure again. */
2702         if (fd->fd_write_failed)
2703                 return 0;
2704         return rc ? -EIO : 0;
2705 }
2706
2707 /**
2708  * Called to make sure a portion of file has been written out.
2709  * if @mode is not CL_FSYNC_LOCAL, it will send OST_SYNC RPCs to OST.
2710  *
2711  * Return how many pages have been written.
2712  */
2713 int cl_sync_file_range(struct inode *inode, loff_t start, loff_t end,
2714                        enum cl_fsync_mode mode, int ignore_layout)
2715 {
2716         struct cl_env_nest nest;
2717         struct lu_env *env;
2718         struct cl_io *io;
2719         struct obd_capa *capa = NULL;
2720         struct cl_fsync_io *fio;
2721         int result;
2722         ENTRY;
2723
2724         if (mode != CL_FSYNC_NONE && mode != CL_FSYNC_LOCAL &&
2725             mode != CL_FSYNC_DISCARD && mode != CL_FSYNC_ALL)
2726                 RETURN(-EINVAL);
2727
2728         env = cl_env_nested_get(&nest);
2729         if (IS_ERR(env))
2730                 RETURN(PTR_ERR(env));
2731
2732         capa = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
2733
2734         io = ccc_env_thread_io(env);
2735         io->ci_obj = ll_i2info(inode)->lli_clob;
2736         io->ci_ignore_layout = ignore_layout;
2737
2738         /* initialize parameters for sync */
2739         fio = &io->u.ci_fsync;
2740         fio->fi_capa = capa;
2741         fio->fi_start = start;
2742         fio->fi_end = end;
2743         fio->fi_fid = ll_inode2fid(inode);
2744         fio->fi_mode = mode;
2745         fio->fi_nr_written = 0;
2746
2747         if (cl_io_init(env, io, CIT_FSYNC, io->ci_obj) == 0)
2748                 result = cl_io_loop(env, io);
2749         else
2750                 result = io->ci_result;
2751         if (result == 0)
2752                 result = fio->fi_nr_written;
2753         cl_io_fini(env, io);
2754         cl_env_nested_put(&nest, env);
2755
2756         capa_put(capa);
2757
2758         RETURN(result);
2759 }
2760
2761 /*
2762  * When dentry is provided (the 'else' case), *file->f_dentry may be
2763  * null and dentry must be used directly rather than pulled from
2764  * *file->f_dentry as is done otherwise.
2765  */
2766
2767 #ifdef HAVE_FILE_FSYNC_4ARGS
2768 int ll_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2769 {
2770         struct dentry *dentry = file->f_dentry;
2771 #elif defined(HAVE_FILE_FSYNC_2ARGS)
2772 int ll_fsync(struct file *file, int datasync)
2773 {
2774         struct dentry *dentry = file->f_dentry;
2775         loff_t start = 0;
2776         loff_t end = LLONG_MAX;
2777 #else
2778 int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
2779 {
2780         loff_t start = 0;
2781         loff_t end = LLONG_MAX;
2782 #endif
2783         struct inode *inode = dentry->d_inode;
2784         struct ll_inode_info *lli = ll_i2info(inode);
2785         struct ptlrpc_request *req;
2786         struct obd_capa *oc;
2787         int rc, err;
2788         ENTRY;
2789
2790         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
2791                PFID(ll_inode2fid(inode)), inode);
2792         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
2793
2794 #ifdef HAVE_FILE_FSYNC_4ARGS
2795         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2796         mutex_lock(&inode->i_mutex);
2797 #else
2798         /* fsync's caller has already called _fdata{sync,write}, we want
2799          * that IO to finish before calling the osc and mdc sync methods */
2800         rc = filemap_fdatawait(inode->i_mapping);
2801 #endif
2802
2803         /* catch async errors that were recorded back when async writeback
2804          * failed for pages in this mapping. */
2805         if (!S_ISDIR(inode->i_mode)) {
2806                 err = lli->lli_async_rc;
2807                 lli->lli_async_rc = 0;
2808                 if (rc == 0)
2809                         rc = err;
2810                 err = lov_read_and_clear_async_rc(lli->lli_clob);
2811                 if (rc == 0)
2812                         rc = err;
2813         }
2814
2815         oc = ll_mdscapa_get(inode);
2816         err = md_fsync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
2817                        &req);
2818         capa_put(oc);
2819         if (!rc)
2820                 rc = err;
2821         if (!err)
2822                 ptlrpc_req_finished(req);
2823
2824         if (S_ISREG(inode->i_mode)) {
2825                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
2826
2827                 err = cl_sync_file_range(inode, start, end, CL_FSYNC_ALL, 0);
2828                 if (rc == 0 && err < 0)
2829                         rc = err;
2830                 if (rc < 0)
2831                         fd->fd_write_failed = true;
2832                 else
2833                         fd->fd_write_failed = false;
2834         }
2835
2836 #ifdef HAVE_FILE_FSYNC_4ARGS
2837         mutex_unlock(&inode->i_mutex);
2838 #endif
2839         RETURN(rc);
2840 }
2841
2842 static int
2843 ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
2844 {
2845         struct inode *inode = file->f_dentry->d_inode;
2846         struct ll_sb_info *sbi = ll_i2sbi(inode);
2847         struct ldlm_enqueue_info einfo = {
2848                 .ei_type        = LDLM_FLOCK,
2849                 .ei_cb_cp       = ldlm_flock_completion_ast,
2850                 .ei_cbdata      = file_lock,
2851         };
2852         struct md_op_data *op_data;
2853         struct lustre_handle lockh = {0};
2854         ldlm_policy_data_t flock = {{0}};
2855         int fl_type = file_lock->fl_type;
2856         __u64 flags = 0;
2857         int rc;
2858         int rc2 = 0;
2859         ENTRY;
2860
2861         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
2862                PFID(ll_inode2fid(inode)), file_lock);
2863
2864         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
2865
2866         if (file_lock->fl_flags & FL_FLOCK) {
2867                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
2868                 /* flocks are whole-file locks */
2869                 flock.l_flock.end = OFFSET_MAX;
2870                 /* For flocks owner is determined by the local file desctiptor*/
2871                 flock.l_flock.owner = (unsigned long)file_lock->fl_file;
2872         } else if (file_lock->fl_flags & FL_POSIX) {
2873                 flock.l_flock.owner = (unsigned long)file_lock->fl_owner;
2874                 flock.l_flock.start = file_lock->fl_start;
2875                 flock.l_flock.end = file_lock->fl_end;
2876         } else {
2877                 RETURN(-EINVAL);
2878         }
2879         flock.l_flock.pid = file_lock->fl_pid;
2880
2881         /* Somewhat ugly workaround for svc lockd.
2882          * lockd installs custom fl_lmops->lm_compare_owner that checks
2883          * for the fl_owner to be the same (which it always is on local node
2884          * I guess between lockd processes) and then compares pid.
2885          * As such we assign pid to the owner field to make it all work,
2886          * conflict with normal locks is unlikely since pid space and
2887          * pointer space for current->files are not intersecting */
2888         if (file_lock->fl_lmops && file_lock->fl_lmops->lm_compare_owner)
2889                 flock.l_flock.owner = (unsigned long)file_lock->fl_pid;
2890
2891         switch (fl_type) {
2892         case F_RDLCK:
2893                 einfo.ei_mode = LCK_PR;
2894                 break;
2895         case F_UNLCK:
2896                 /* An unlock request may or may not have any relation to
2897                  * existing locks so we may not be able to pass a lock handle
2898                  * via a normal ldlm_lock_cancel() request. The request may even
2899                  * unlock a byte range in the middle of an existing lock. In
2900                  * order to process an unlock request we need all of the same
2901                  * information that is given with a normal read or write record
2902                  * lock request. To avoid creating another ldlm unlock (cancel)
2903                  * message we'll treat a LCK_NL flock request as an unlock. */
2904                 einfo.ei_mode = LCK_NL;
2905                 break;
2906         case F_WRLCK:
2907                 einfo.ei_mode = LCK_PW;
2908                 break;
2909         default:
2910                 CDEBUG(D_INFO, "Unknown fcntl lock type: %d\n", fl_type);
2911                 RETURN (-ENOTSUPP);
2912         }
2913
2914         switch (cmd) {
2915         case F_SETLKW:
2916 #ifdef F_SETLKW64
2917         case F_SETLKW64:
2918 #endif
2919                 flags = 0;
2920                 break;
2921         case F_SETLK:
2922 #ifdef F_SETLK64
2923         case F_SETLK64:
2924 #endif
2925                 flags = LDLM_FL_BLOCK_NOWAIT;
2926                 break;
2927         case F_GETLK:
2928 #ifdef F_GETLK64
2929         case F_GETLK64:
2930 #endif
2931                 flags = LDLM_FL_TEST_LOCK;
2932                 break;
2933         default:
2934                 CERROR("unknown fcntl lock command: %d\n", cmd);
2935                 RETURN (-EINVAL);
2936         }
2937
2938         /* Save the old mode so that if the mode in the lock changes we
2939          * can decrement the appropriate reader or writer refcount. */
2940         file_lock->fl_type = einfo.ei_mode;
2941
2942         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
2943                                      LUSTRE_OPC_ANY, NULL);
2944         if (IS_ERR(op_data))
2945                 RETURN(PTR_ERR(op_data));
2946
2947         CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags="LPX64", mode=%u, "
2948                "start="LPU64", end="LPU64"\n", PFID(ll_inode2fid(inode)),
2949                flock.l_flock.pid, flags, einfo.ei_mode,
2950                flock.l_flock.start, flock.l_flock.end);
2951
2952         rc = md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data, &lockh,
2953                         flags);
2954
2955         /* Restore the file lock type if not TEST lock. */
2956         if (!(flags & LDLM_FL_TEST_LOCK))
2957                 file_lock->fl_type = fl_type;
2958
2959         if ((file_lock->fl_flags & FL_FLOCK) &&
2960             (rc == 0 || file_lock->fl_type == F_UNLCK))
2961                 rc2  = flock_lock_file_wait(file, file_lock);
2962         if ((file_lock->fl_flags & FL_POSIX) &&
2963             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
2964             !(flags & LDLM_FL_TEST_LOCK))
2965                 rc2  = posix_lock_file_wait(file, file_lock);
2966
2967         if (rc2 && file_lock->fl_type != F_UNLCK) {
2968                 einfo.ei_mode = LCK_NL;
2969                 md_enqueue(sbi->ll_md_exp, &einfo, &flock, NULL, op_data,
2970                            &lockh, flags);
2971                 rc = rc2;
2972         }
2973
2974         ll_finish_md_op_data(op_data);
2975
2976         RETURN(rc);
2977 }
2978
2979 int ll_get_fid_by_name(struct inode *parent, const char *name,
2980                        int namelen, struct lu_fid *fid)
2981 {
2982         struct md_op_data       *op_data = NULL;
2983         struct mdt_body         *body;
2984         struct ptlrpc_request   *req;
2985         int                     rc;
2986         ENTRY;
2987
2988         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen, 0,
2989                                      LUSTRE_OPC_ANY, NULL);
2990         if (IS_ERR(op_data))
2991                 RETURN(PTR_ERR(op_data));
2992
2993         op_data->op_valid = OBD_MD_FLID;
2994         rc = md_getattr_name(ll_i2sbi(parent)->ll_md_exp, op_data, &req);
2995         ll_finish_md_op_data(op_data);
2996         if (rc < 0)
2997                 RETURN(rc);
2998
2999         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
3000         if (body == NULL)
3001                 GOTO(out_req, rc = -EFAULT);
3002         if (fid != NULL)
3003                 *fid = body->mbo_fid1;
3004 out_req:
3005         ptlrpc_req_finished(req);
3006         RETURN(rc);
3007 }
3008
3009 int ll_migrate(struct inode *parent, struct file *file, int mdtidx,
3010                const char *name, int namelen)
3011 {
3012         struct dentry         *dchild = NULL;
3013         struct inode          *child_inode = NULL;
3014         struct md_op_data     *op_data;
3015         struct ptlrpc_request *request = NULL;
3016         struct qstr           qstr;
3017         int                    rc;
3018         ENTRY;
3019
3020         CDEBUG(D_VFSTRACE, "migrate %s under "DFID" to MDT%04x\n",
3021                name, PFID(ll_inode2fid(parent)), mdtidx);
3022
3023         op_data = ll_prep_md_op_data(NULL, parent, NULL, name, namelen,
3024                                      0, LUSTRE_OPC_ANY, NULL);
3025         if (IS_ERR(op_data))
3026                 RETURN(PTR_ERR(op_data));
3027
3028         /* Get child FID first */
3029         qstr.hash = full_name_hash(name, namelen);
3030         qstr.name = name;
3031         qstr.len = namelen;
3032         dchild = d_lookup(file->f_dentry, &qstr);
3033         if (dchild != NULL) {
3034                 if (dchild->d_inode != NULL) {
3035                         child_inode = igrab(dchild->d_inode);
3036                         if (child_inode != NULL) {
3037                                 mutex_lock(&child_inode->i_mutex);
3038                                 op_data->op_fid3 = *ll_inode2fid(child_inode);
3039                                 ll_invalidate_aliases(child_inode);
3040                         }
3041                 }
3042                 dput(dchild);
3043         } else {
3044                 rc = ll_get_fid_by_name(parent, name, namelen,
3045                                         &op_data->op_fid3);
3046                 if (rc != 0)
3047                         GOTO(out_free, rc);
3048         }
3049
3050         if (!fid_is_sane(&op_data->op_fid3)) {
3051                 CERROR("%s: migrate %s , but fid "DFID" is insane\n",
3052                        ll_get_fsname(parent->i_sb, NULL, 0), name,
3053                        PFID(&op_data->op_fid3));
3054                 GOTO(out_free, rc = -EINVAL);
3055         }
3056
3057         rc = ll_get_mdt_idx_by_fid(ll_i2sbi(parent), &op_data->op_fid3);
3058         if (rc < 0)
3059                 GOTO(out_free, rc);
3060
3061         if (rc == mdtidx) {
3062                 CDEBUG(D_INFO, "%s:"DFID" is already on MDT%d.\n", name,
3063                        PFID(&op_data->op_fid3), mdtidx);
3064                 GOTO(out_free, rc = 0);
3065         }
3066
3067         op_data->op_mds = mdtidx;
3068         op_data->op_cli_flags = CLI_MIGRATE;
3069         rc = md_rename(ll_i2sbi(parent)->ll_md_exp, op_data, name,
3070                        namelen, name, namelen, &request);
3071         if (rc == 0)
3072                 ll_update_times(request, parent);
3073
3074         ptlrpc_req_finished(request);
3075         if (rc != 0)
3076                 GOTO(out_free, rc);
3077
3078 out_free:
3079         if (child_inode != NULL) {
3080                 clear_nlink(child_inode);
3081                 mutex_unlock(&child_inode->i_mutex);
3082                 iput(child_inode);
3083         }
3084
3085         ll_finish_md_op_data(op_data);
3086         RETURN(rc);
3087 }
3088
3089 static int
3090 ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
3091 {
3092         ENTRY;
3093
3094         RETURN(-ENOSYS);
3095 }
3096
3097 /**
3098  * test if some locks matching bits and l_req_mode are acquired
3099  * - bits can be in different locks
3100  * - if found clear the common lock bits in *bits
3101  * - the bits not found, are kept in *bits
3102  * \param inode [IN]
3103  * \param bits [IN] searched lock bits [IN]
3104  * \param l_req_mode [IN] searched lock mode
3105  * \retval boolean, true iff all bits are found
3106  */
3107 int ll_have_md_lock(struct inode *inode, __u64 *bits,  ldlm_mode_t l_req_mode)
3108 {
3109         struct lustre_handle lockh;
3110         ldlm_policy_data_t policy;
3111         ldlm_mode_t mode = (l_req_mode == LCK_MINMODE) ?
3112                                 (LCK_CR|LCK_CW|LCK_PR|LCK_PW) : l_req_mode;
3113         struct lu_fid *fid;
3114         __u64 flags;
3115         int i;
3116         ENTRY;
3117
3118         if (!inode)
3119                RETURN(0);
3120
3121         fid = &ll_i2info(inode)->lli_fid;
3122         CDEBUG(D_INFO, "trying to match res "DFID" mode %s\n", PFID(fid),
3123                ldlm_lockname[mode]);
3124
3125         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
3126         for (i = 0; i <= MDS_INODELOCK_MAXSHIFT && *bits != 0; i++) {
3127                 policy.l_inodebits.bits = *bits & (1 << i);
3128                 if (policy.l_inodebits.bits == 0)
3129                         continue;
3130
3131                 if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS,
3132                                   &policy, mode, &lockh)) {
3133                         struct ldlm_lock *lock;
3134
3135                         lock = ldlm_handle2lock(&lockh);
3136                         if (lock) {
3137                                 *bits &=
3138                                       ~(lock->l_policy_data.l_inodebits.bits);
3139                                 LDLM_LOCK_PUT(lock);
3140                         } else {
3141                                 *bits &= ~policy.l_inodebits.bits;
3142                         }
3143                 }
3144         }
3145         RETURN(*bits == 0);
3146 }
3147
3148 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
3149                             struct lustre_handle *lockh, __u64 flags,
3150                             ldlm_mode_t mode)
3151 {
3152         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
3153         struct lu_fid *fid;
3154         ldlm_mode_t rc;
3155         ENTRY;
3156
3157         fid = &ll_i2info(inode)->lli_fid;
3158         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
3159
3160         rc = md_lock_match(ll_i2mdexp(inode), LDLM_FL_BLOCK_GRANTED|flags,
3161                            fid, LDLM_IBITS, &policy, mode, lockh);
3162
3163         RETURN(rc);
3164 }
3165
3166 static int ll_inode_revalidate_fini(struct inode *inode, int rc)
3167 {
3168         /* Already unlinked. Just update nlink and return success */
3169         if (rc == -ENOENT) {
3170                 clear_nlink(inode);
3171                 /* This path cannot be hit for regular files unless in
3172                  * case of obscure races, so no need to to validate
3173                  * size. */
3174                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
3175                         return 0;
3176         } else if (rc != 0) {
3177                 CDEBUG_LIMIT((rc == -EACCES || rc == -EIDRM) ? D_INFO : D_ERROR,
3178                              "%s: revalidate FID "DFID" error: rc = %d\n",
3179                              ll_get_fsname(inode->i_sb, NULL, 0),
3180                              PFID(ll_inode2fid(inode)), rc);
3181         }
3182
3183         return rc;
3184 }
3185
3186 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3187 {
3188         struct inode *inode = dentry->d_inode;
3189         struct ptlrpc_request *req = NULL;
3190         struct obd_export *exp;
3191         int rc = 0;
3192         ENTRY;
3193
3194         LASSERT(inode != NULL);
3195
3196         CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
3197                PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
3198
3199         exp = ll_i2mdexp(inode);
3200
3201         /* XXX: Enable OBD_CONNECT_ATTRFID to reduce unnecessary getattr RPC.
3202          *      But under CMD case, it caused some lock issues, should be fixed
3203          *      with new CMD ibits lock. See bug 12718 */
3204         if (exp_connect_flags(exp) & OBD_CONNECT_ATTRFID) {
3205                 struct lookup_intent oit = { .it_op = IT_GETATTR };
3206                 struct md_op_data *op_data;
3207
3208                 if (ibits == MDS_INODELOCK_LOOKUP)
3209                         oit.it_op = IT_LOOKUP;
3210
3211                 /* Call getattr by fid, so do not provide name at all. */
3212                 op_data = ll_prep_md_op_data(NULL, dentry->d_inode,
3213                                              dentry->d_inode, NULL, 0, 0,
3214                                              LUSTRE_OPC_ANY, NULL);
3215                 if (IS_ERR(op_data))
3216                         RETURN(PTR_ERR(op_data));
3217
3218                 rc = md_intent_lock(exp, op_data, &oit, &req,
3219                                     &ll_md_blocking_ast, 0);
3220                 ll_finish_md_op_data(op_data);
3221                 if (rc < 0) {
3222                         rc = ll_inode_revalidate_fini(inode, rc);
3223                         GOTO (out, rc);
3224                 }
3225
3226                 rc = ll_revalidate_it_finish(req, &oit, dentry);
3227                 if (rc != 0) {
3228                         ll_intent_release(&oit);
3229                         GOTO(out, rc);
3230                 }
3231
3232                 /* Unlinked? Unhash dentry, so it is not picked up later by
3233                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
3234                    here to preserve get_cwd functionality on 2.6.
3235                    Bug 10503 */
3236                 if (!dentry->d_inode->i_nlink)
3237                         d_lustre_invalidate(dentry, 0);
3238
3239                 ll_lookup_finish_locks(&oit, dentry);
3240         } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) {
3241                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
3242                 u64 valid = OBD_MD_FLGETATTR;
3243                 struct md_op_data *op_data;
3244                 int ealen = 0;
3245
3246                 if (S_ISREG(inode->i_mode)) {
3247                         rc = ll_get_default_mdsize(sbi, &ealen);
3248                         if (rc)
3249                                 RETURN(rc);
3250                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
3251                 }
3252
3253                 op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL,
3254                                              0, ealen, LUSTRE_OPC_ANY,
3255                                              NULL);
3256                 if (IS_ERR(op_data))
3257                         RETURN(PTR_ERR(op_data));
3258
3259                 op_data->op_valid = valid;
3260                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
3261                  * capa for this inode. Because we only keep capas of dirs
3262                  * fresh. */
3263                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
3264                 ll_finish_md_op_data(op_data);
3265                 if (rc) {
3266                         rc = ll_inode_revalidate_fini(inode, rc);
3267                         RETURN(rc);
3268                 }
3269
3270                 rc = ll_prep_inode(&inode, req, NULL, NULL);
3271         }
3272 out:
3273         ptlrpc_req_finished(req);
3274         return rc;
3275 }
3276
3277 static int ll_merge_md_attr(struct inode *inode)
3278 {
3279         struct cl_attr attr = { 0 };
3280         int rc;
3281
3282         LASSERT(ll_i2info(inode)->lli_lsm_md != NULL);
3283         rc = md_merge_attr(ll_i2mdexp(inode), ll_i2info(inode)->lli_lsm_md,
3284                            &attr, ll_md_blocking_ast);
3285         if (rc != 0)
3286                 RETURN(rc);
3287
3288         set_nlink(inode, attr.cat_nlink);
3289         inode->i_blocks = attr.cat_blocks;
3290         i_size_write(inode, attr.cat_size);
3291
3292         ll_i2info(inode)->lli_atime = attr.cat_atime;
3293         ll_i2info(inode)->lli_mtime = attr.cat_mtime;
3294         ll_i2info(inode)->lli_ctime = attr.cat_ctime;
3295
3296         RETURN(0);
3297 }
3298
3299 static int
3300 ll_inode_revalidate(struct dentry *dentry, __u64 ibits)
3301 {
3302         struct inode    *inode = dentry->d_inode;
3303         int              rc;
3304         ENTRY;
3305
3306         rc = __ll_inode_revalidate(dentry, ibits);
3307         if (rc != 0)
3308                 RETURN(rc);