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