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