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