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