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