Whamcloud - gitweb
44eaaa2aa8706492cddc945fb20bc6abf626c0ed
[fs/lustre-release.git] / lustre / llite / file.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
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 <lustre_mdc.h>
47 #include <linux/pagemap.h>
48 #include <linux/file.h>
49 #include "llite_internal.h"
50 #include <lustre/ll_fiemap.h>
51
52 #include "cl_object.h"
53
54 struct ll_file_data *ll_file_data_get(void)
55 {
56         struct ll_file_data *fd;
57
58         OBD_SLAB_ALLOC_PTR_GFP(fd, ll_file_data_slab, CFS_ALLOC_IO);
59         return fd;
60 }
61
62 static void ll_file_data_put(struct ll_file_data *fd)
63 {
64         if (fd != NULL)
65                 OBD_SLAB_FREE_PTR(fd, ll_file_data_slab);
66 }
67
68 void ll_pack_inode2opdata(struct inode *inode, struct md_op_data *op_data,
69                           struct lustre_handle *fh)
70 {
71         op_data->op_fid1 = ll_i2info(inode)->lli_fid;
72         op_data->op_attr.ia_mode = inode->i_mode;
73         op_data->op_attr.ia_atime = inode->i_atime;
74         op_data->op_attr.ia_mtime = inode->i_mtime;
75         op_data->op_attr.ia_ctime = inode->i_ctime;
76         op_data->op_attr.ia_size = i_size_read(inode);
77         op_data->op_attr_blocks = inode->i_blocks;
78         ((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags =
79                                         ll_inode_to_ext_flags(inode->i_flags);
80         op_data->op_ioepoch = ll_i2info(inode)->lli_ioepoch;
81         if (fh)
82                 op_data->op_handle = *fh;
83         op_data->op_capa1 = ll_mdscapa_get(inode);
84 }
85
86 /**
87  * Closes the IO epoch and packs all the attributes into @op_data for
88  * the CLOSE rpc.
89  */
90 static void ll_prepare_close(struct inode *inode, struct md_op_data *op_data,
91                              struct obd_client_handle *och)
92 {
93         ENTRY;
94
95         op_data->op_attr.ia_valid = ATTR_MODE | ATTR_ATIME_SET |
96                                  ATTR_MTIME_SET | ATTR_CTIME_SET;
97
98         if (!(och->och_flags & FMODE_WRITE))
99                 goto out;
100
101         if (!exp_connect_som(ll_i2mdexp(inode)) || !S_ISREG(inode->i_mode))
102                 op_data->op_attr.ia_valid |= ATTR_SIZE | ATTR_BLOCKS;
103         else
104                 ll_ioepoch_close(inode, op_data, &och, 0);
105
106 out:
107         ll_pack_inode2opdata(inode, op_data, &och->och_fh);
108         ll_prep_md_op_data(op_data, inode, NULL, NULL,
109                            0, 0, LUSTRE_OPC_ANY, NULL);
110         EXIT;
111 }
112
113 static int ll_close_inode_openhandle(struct obd_export *md_exp,
114                                      struct inode *inode,
115                                      struct obd_client_handle *och)
116 {
117         struct obd_export *exp = ll_i2mdexp(inode);
118         struct md_op_data *op_data;
119         struct ptlrpc_request *req = NULL;
120         struct obd_device *obd = class_exp2obd(exp);
121         int epoch_close = 1;
122         int rc;
123         ENTRY;
124
125         if (obd == NULL) {
126                 /*
127                  * XXX: in case of LMV, is this correct to access
128                  * ->exp_handle?
129                  */
130                 CERROR("Invalid MDC connection handle "LPX64"\n",
131                        ll_i2mdexp(inode)->exp_handle.h_cookie);
132                 GOTO(out, rc = 0);
133         }
134
135         OBD_ALLOC_PTR(op_data);
136         if (op_data == NULL)
137                 GOTO(out, rc = -ENOMEM); // XXX We leak openhandle and request here.
138
139         ll_prepare_close(inode, op_data, och);
140         epoch_close = (op_data->op_flags & MF_EPOCH_CLOSE);
141         rc = md_close(md_exp, op_data, och->och_mod, &req);
142         if (rc == -EAGAIN) {
143                 /* This close must have the epoch closed. */
144                 LASSERT(epoch_close);
145                 /* MDS has instructed us to obtain Size-on-MDS attribute from
146                  * OSTs and send setattr to back to MDS. */
147                 rc = ll_som_update(inode, op_data);
148                 if (rc) {
149                         CERROR("inode %lu mdc Size-on-MDS update failed: "
150                                "rc = %d\n", inode->i_ino, rc);
151                         rc = 0;
152                 }
153         } else if (rc) {
154                 CERROR("inode %lu mdc close failed: rc = %d\n",
155                        inode->i_ino, rc);
156         }
157         ll_finish_md_op_data(op_data);
158
159         if (rc == 0) {
160                 rc = ll_objects_destroy(req, inode);
161                 if (rc)
162                         CERROR("inode %lu ll_objects destroy: rc = %d\n",
163                                inode->i_ino, rc);
164         }
165
166         EXIT;
167 out:
168
169         if (exp_connect_som(exp) && !epoch_close &&
170             S_ISREG(inode->i_mode) && (och->och_flags & FMODE_WRITE)) {
171                 ll_queue_done_writing(inode, LLIF_DONE_WRITING);
172         } else {
173                 md_clear_open_replay_data(md_exp, och);
174                 /* Free @och if it is not waiting for DONE_WRITING. */
175                 och->och_fh.cookie = DEAD_HANDLE_MAGIC;
176                 OBD_FREE_PTR(och);
177         }
178         if (req) /* This is close request */
179                 ptlrpc_req_finished(req);
180         return rc;
181 }
182
183 int ll_md_real_close(struct inode *inode, int flags)
184 {
185         struct ll_inode_info *lli = ll_i2info(inode);
186         struct obd_client_handle **och_p;
187         struct obd_client_handle *och;
188         __u64 *och_usecount;
189         int rc = 0;
190         ENTRY;
191
192         if (flags & FMODE_WRITE) {
193                 och_p = &lli->lli_mds_write_och;
194                 och_usecount = &lli->lli_open_fd_write_count;
195         } else if (flags & FMODE_EXEC) {
196                 och_p = &lli->lli_mds_exec_och;
197                 och_usecount = &lli->lli_open_fd_exec_count;
198         } else {
199                 LASSERT(flags & FMODE_READ);
200                 och_p = &lli->lli_mds_read_och;
201                 och_usecount = &lli->lli_open_fd_read_count;
202         }
203
204         cfs_down(&lli->lli_och_sem);
205         if (*och_usecount) { /* There are still users of this handle, so
206                                 skip freeing it. */
207                 cfs_up(&lli->lli_och_sem);
208                 RETURN(0);
209         }
210         och=*och_p;
211         *och_p = NULL;
212         cfs_up(&lli->lli_och_sem);
213
214         if (och) { /* There might be a race and somebody have freed this och
215                       already */
216                 rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
217                                                inode, och);
218         }
219
220         RETURN(rc);
221 }
222
223 int ll_md_close(struct obd_export *md_exp, struct inode *inode,
224                 struct file *file)
225 {
226         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
227         struct ll_inode_info *lli = ll_i2info(inode);
228         int rc = 0;
229         ENTRY;
230
231         /* clear group lock, if present */
232         if (unlikely(fd->fd_flags & LL_FILE_GROUP_LOCKED))
233                 ll_put_grouplock(inode, file, fd->fd_grouplock.cg_gid);
234
235         /* Let's see if we have good enough OPEN lock on the file and if
236            we can skip talking to MDS */
237         if (file->f_dentry->d_inode) { /* Can this ever be false? */
238                 int lockmode;
239                 int flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_TEST_LOCK;
240                 struct lustre_handle lockh;
241                 struct inode *inode = file->f_dentry->d_inode;
242                 ldlm_policy_data_t policy = {.l_inodebits={MDS_INODELOCK_OPEN}};
243
244                 cfs_down(&lli->lli_och_sem);
245                 if (fd->fd_omode & FMODE_WRITE) {
246                         lockmode = LCK_CW;
247                         LASSERT(lli->lli_open_fd_write_count);
248                         lli->lli_open_fd_write_count--;
249                 } else if (fd->fd_omode & FMODE_EXEC) {
250                         lockmode = LCK_PR;
251                         LASSERT(lli->lli_open_fd_exec_count);
252                         lli->lli_open_fd_exec_count--;
253                 } else {
254                         lockmode = LCK_CR;
255                         LASSERT(lli->lli_open_fd_read_count);
256                         lli->lli_open_fd_read_count--;
257                 }
258                 cfs_up(&lli->lli_och_sem);
259
260                 if (!md_lock_match(md_exp, flags, ll_inode2fid(inode),
261                                    LDLM_IBITS, &policy, lockmode,
262                                    &lockh)) {
263                         rc = ll_md_real_close(file->f_dentry->d_inode,
264                                               fd->fd_omode);
265                 }
266         } else {
267                 CERROR("Releasing a file %p with negative dentry %p. Name %s",
268                        file, file->f_dentry, file->f_dentry->d_name.name);
269         }
270
271         LUSTRE_FPRIVATE(file) = NULL;
272         ll_file_data_put(fd);
273         ll_capa_close(inode);
274
275         RETURN(rc);
276 }
277
278 int lov_test_and_clear_async_rc(struct lov_stripe_md *lsm);
279
280 /* While this returns an error code, fput() the caller does not, so we need
281  * to make every effort to clean up all of our state here.  Also, applications
282  * rarely check close errors and even if an error is returned they will not
283  * re-try the close call.
284  */
285 int ll_file_release(struct inode *inode, struct file *file)
286 {
287         struct ll_file_data *fd;
288         struct ll_sb_info *sbi = ll_i2sbi(inode);
289         struct ll_inode_info *lli = ll_i2info(inode);
290         struct lov_stripe_md *lsm = lli->lli_smd;
291         int rc;
292         ENTRY;
293
294         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
295                inode->i_generation, inode);
296
297 #ifdef CONFIG_FS_POSIX_ACL
298         if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
299             inode == inode->i_sb->s_root->d_inode) {
300                 struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
301
302                 LASSERT(fd != NULL);
303                 if (unlikely(fd->fd_flags & LL_FILE_RMTACL)) {
304                         fd->fd_flags &= ~LL_FILE_RMTACL;
305                         rct_del(&sbi->ll_rct, cfs_curproc_pid());
306                         et_search_free(&sbi->ll_et, cfs_curproc_pid());
307                 }
308         }
309 #endif
310
311         if (inode->i_sb->s_root != file->f_dentry)
312                 ll_stats_ops_tally(sbi, LPROC_LL_RELEASE, 1);
313         fd = LUSTRE_FPRIVATE(file);
314         LASSERT(fd != NULL);
315
316         /* The last ref on @file, maybe not the the owner pid of statahead.
317          * Different processes can open the same dir, "ll_opendir_key" means:
318          * it is me that should stop the statahead thread. */
319         if (lli->lli_opendir_key == fd && lli->lli_opendir_pid != 0)
320                 ll_stop_statahead(inode, lli->lli_opendir_key);
321
322         if (inode->i_sb->s_root == file->f_dentry) {
323                 LUSTRE_FPRIVATE(file) = NULL;
324                 ll_file_data_put(fd);
325                 RETURN(0);
326         }
327
328         if (lsm)
329                 lov_test_and_clear_async_rc(lsm);
330         lli->lli_async_rc = 0;
331
332         rc = ll_md_close(sbi->ll_md_exp, inode, file);
333
334         if (OBD_FAIL_TIMEOUT_MS(OBD_FAIL_PTLRPC_DUMP_LOG, obd_fail_val))
335                 libcfs_debug_dumplog();
336
337         RETURN(rc);
338 }
339
340 static int ll_intent_file_open(struct file *file, void *lmm,
341                                int lmmsize, struct lookup_intent *itp)
342 {
343         struct ll_sb_info *sbi = ll_i2sbi(file->f_dentry->d_inode);
344         struct dentry *parent = file->f_dentry->d_parent;
345         const char *name = file->f_dentry->d_name.name;
346         const int len = file->f_dentry->d_name.len;
347         struct md_op_data *op_data;
348         struct ptlrpc_request *req;
349         int rc;
350         ENTRY;
351
352         if (!parent)
353                 RETURN(-ENOENT);
354
355         /* Usually we come here only for NFSD, and we want open lock.
356            But we can also get here with pre 2.6.15 patchless kernels, and in
357            that case that lock is also ok */
358         /* We can also get here if there was cached open handle in revalidate_it
359          * but it disappeared while we were getting from there to ll_file_open.
360          * But this means this file was closed and immediatelly opened which
361          * makes a good candidate for using OPEN lock */
362         /* If lmmsize & lmm are not 0, we are just setting stripe info
363          * parameters. No need for the open lock */
364         if (!lmm && !lmmsize)
365                 itp->it_flags |= MDS_OPEN_LOCK;
366
367         op_data  = ll_prep_md_op_data(NULL, parent->d_inode,
368                                       file->f_dentry->d_inode, name, len,
369                                       O_RDWR, LUSTRE_OPC_ANY, NULL);
370         if (IS_ERR(op_data))
371                 RETURN(PTR_ERR(op_data));
372
373         rc = md_intent_lock(sbi->ll_md_exp, op_data, lmm, lmmsize, itp,
374                             0 /*unused */, &req, ll_md_blocking_ast, 0);
375         ll_finish_md_op_data(op_data);
376         if (rc == -ESTALE) {
377                 /* reason for keep own exit path - don`t flood log
378                 * with messages with -ESTALE errors.
379                 */
380                 if (!it_disposition(itp, DISP_OPEN_OPEN) ||
381                      it_open_error(DISP_OPEN_OPEN, itp))
382                         GOTO(out, rc);
383                 ll_release_openhandle(file->f_dentry, itp);
384                 GOTO(out, rc);
385         }
386
387         if (rc != 0 || it_open_error(DISP_OPEN_OPEN, itp)) {
388                 rc = rc ? rc : it_open_error(DISP_OPEN_OPEN, itp);
389                 CDEBUG(D_VFSTRACE, "lock enqueue: err: %d\n", rc);
390                 GOTO(out, rc);
391         }
392
393         rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL);
394         if (!rc && itp->d.lustre.it_lock_mode)
395                 md_set_lock_data(sbi->ll_md_exp,
396                                  &itp->d.lustre.it_lock_handle,
397                                  file->f_dentry->d_inode, NULL);
398
399 out:
400         ptlrpc_req_finished(itp->d.lustre.it_data);
401         it_clear_disposition(itp, DISP_ENQ_COMPLETE);
402         ll_intent_drop_lock(itp);
403
404         RETURN(rc);
405 }
406
407 /**
408  * Assign an obtained @ioepoch to client's inode. No lock is needed, MDS does
409  * not believe attributes if a few ioepoch holders exist. Attributes for
410  * previous ioepoch if new one is opened are also skipped by MDS.
411  */
412 void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch)
413 {
414         if (ioepoch && lli->lli_ioepoch != ioepoch) {
415                 lli->lli_ioepoch = ioepoch;
416                 CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
417                        ioepoch, PFID(&lli->lli_fid));
418         }
419 }
420
421 static int ll_och_fill(struct obd_export *md_exp, struct ll_inode_info *lli,
422                        struct lookup_intent *it, struct obd_client_handle *och)
423 {
424         struct ptlrpc_request *req = it->d.lustre.it_data;
425         struct mdt_body *body;
426
427         LASSERT(och);
428
429         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
430         LASSERT(body != NULL);                      /* reply already checked out */
431
432         memcpy(&och->och_fh, &body->handle, sizeof(body->handle));
433         och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
434         och->och_fid = lli->lli_fid;
435         och->och_flags = it->it_flags;
436         ll_ioepoch_open(lli, body->ioepoch);
437
438         return md_set_open_replay_data(md_exp, och, req);
439 }
440
441 int ll_local_open(struct file *file, struct lookup_intent *it,
442                   struct ll_file_data *fd, struct obd_client_handle *och)
443 {
444         struct inode *inode = file->f_dentry->d_inode;
445         struct ll_inode_info *lli = ll_i2info(inode);
446         ENTRY;
447
448         LASSERT(!LUSTRE_FPRIVATE(file));
449
450         LASSERT(fd != NULL);
451
452         if (och) {
453                 struct ptlrpc_request *req = it->d.lustre.it_data;
454                 struct mdt_body *body;
455                 int rc;
456
457                 rc = ll_och_fill(ll_i2sbi(inode)->ll_md_exp, lli, it, och);
458                 if (rc)
459                         RETURN(rc);
460
461                 body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
462                 if ((it->it_flags & FMODE_WRITE) &&
463                     (body->valid & OBD_MD_FLSIZE))
464                         CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
465                                lli->lli_ioepoch, PFID(&lli->lli_fid));
466         }
467
468         LUSTRE_FPRIVATE(file) = fd;
469         ll_readahead_init(inode, &fd->fd_ras);
470         fd->fd_omode = it->it_flags;
471         RETURN(0);
472 }
473
474 /* Open a file, and (for the very first open) create objects on the OSTs at
475  * this time.  If opened with O_LOV_DELAY_CREATE, then we don't do the object
476  * creation or open until ll_lov_setstripe() ioctl is called.  We grab
477  * lli_open_sem to ensure no other process will create objects, send the
478  * stripe MD to the MDS, or try to destroy the objects if that fails.
479  *
480  * If we already have the stripe MD locally then we don't request it in
481  * md_open(), by passing a lmm_size = 0.
482  *
483  * It is up to the application to ensure no other processes open this file
484  * in the O_LOV_DELAY_CREATE case, or the default striping pattern will be
485  * used.  We might be able to avoid races of that sort by getting lli_open_sem
486  * before returning in the O_LOV_DELAY_CREATE case and dropping it here
487  * or in ll_file_release(), but I'm not sure that is desirable/necessary.
488  */
489 int ll_file_open(struct inode *inode, struct file *file)
490 {
491         struct ll_inode_info *lli = ll_i2info(inode);
492         struct lookup_intent *it, oit = { .it_op = IT_OPEN,
493                                           .it_flags = file->f_flags };
494         struct lov_stripe_md *lsm;
495         struct ptlrpc_request *req = NULL;
496         struct obd_client_handle **och_p;
497         __u64 *och_usecount;
498         struct ll_file_data *fd;
499         int rc = 0, opendir_set = 0;
500         ENTRY;
501
502         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino,
503                inode->i_generation, inode, file->f_flags);
504
505 #ifdef HAVE_VFS_INTENT_PATCHES
506         it = file->f_it;
507 #else
508         it = file->private_data; /* XXX: compat macro */
509         file->private_data = NULL; /* prevent ll_local_open assertion */
510 #endif
511
512         fd = ll_file_data_get();
513         if (fd == NULL)
514                 RETURN(-ENOMEM);
515
516         fd->fd_file = file;
517         if (S_ISDIR(inode->i_mode)) {
518                 cfs_spin_lock(&lli->lli_lock);
519                 if (lli->lli_opendir_key == NULL && lli->lli_opendir_pid == 0) {
520                         LASSERT(lli->lli_sai == NULL);
521                         lli->lli_opendir_key = fd;
522                         lli->lli_opendir_pid = cfs_curproc_pid();
523                         opendir_set = 1;
524                 }
525                 cfs_spin_unlock(&lli->lli_lock);
526         }
527
528         if (inode->i_sb->s_root == file->f_dentry) {
529                 LUSTRE_FPRIVATE(file) = fd;
530                 RETURN(0);
531         }
532
533         if (!it || !it->d.lustre.it_disposition) {
534                 /* Convert f_flags into access mode. We cannot use file->f_mode,
535                  * because everything but O_ACCMODE mask was stripped from
536                  * there */
537                 if ((oit.it_flags + 1) & O_ACCMODE)
538                         oit.it_flags++;
539                 if (file->f_flags & O_TRUNC)
540                         oit.it_flags |= FMODE_WRITE;
541
542                 /* kernel only call f_op->open in dentry_open.  filp_open calls
543                  * dentry_open after call to open_namei that checks permissions.
544                  * Only nfsd_open call dentry_open directly without checking
545                  * permissions and because of that this code below is safe. */
546                 if (oit.it_flags & FMODE_WRITE)
547                         oit.it_flags |= MDS_OPEN_OWNEROVERRIDE;
548
549                 /* We do not want O_EXCL here, presumably we opened the file
550                  * already? XXX - NFS implications? */
551                 oit.it_flags &= ~O_EXCL;
552
553                 /* bug20584, if "it_flags" contains O_CREAT, the file will be
554                  * created if necessary, then "IT_CREAT" should be set to keep
555                  * consistent with it */
556                 if (oit.it_flags & O_CREAT)
557                         oit.it_op |= IT_CREAT;
558
559                 it = &oit;
560         }
561
562 restart:
563         /* Let's see if we have file open on MDS already. */
564         if (it->it_flags & FMODE_WRITE) {
565                 och_p = &lli->lli_mds_write_och;
566                 och_usecount = &lli->lli_open_fd_write_count;
567         } else if (it->it_flags & FMODE_EXEC) {
568                 och_p = &lli->lli_mds_exec_och;
569                 och_usecount = &lli->lli_open_fd_exec_count;
570          } else {
571                 och_p = &lli->lli_mds_read_och;
572                 och_usecount = &lli->lli_open_fd_read_count;
573         }
574
575         cfs_down(&lli->lli_och_sem);
576         if (*och_p) { /* Open handle is present */
577                 if (it_disposition(it, DISP_OPEN_OPEN)) {
578                         /* Well, there's extra open request that we do not need,
579                            let's close it somehow. This will decref request. */
580                         rc = it_open_error(DISP_OPEN_OPEN, it);
581                         if (rc) {
582                                 cfs_up(&lli->lli_och_sem);
583                                 ll_file_data_put(fd);
584                                 GOTO(out_openerr, rc);
585                         }
586                         ll_release_openhandle(file->f_dentry, it);
587                         lprocfs_counter_incr(ll_i2sbi(inode)->ll_stats,
588                                              LPROC_LL_OPEN);
589                 }
590                 (*och_usecount)++;
591
592                 rc = ll_local_open(file, it, fd, NULL);
593                 if (rc) {
594                         (*och_usecount)--;
595                         cfs_up(&lli->lli_och_sem);
596                         ll_file_data_put(fd);
597                         GOTO(out_openerr, rc);
598                 }
599         } else {
600                 LASSERT(*och_usecount == 0);
601                 if (!it->d.lustre.it_disposition) {
602                         /* We cannot just request lock handle now, new ELC code
603                            means that one of other OPEN locks for this file
604                            could be cancelled, and since blocking ast handler
605                            would attempt to grab och_sem as well, that would
606                            result in a deadlock */
607                         cfs_up(&lli->lli_och_sem);
608                         it->it_create_mode |= M_CHECK_STALE;
609                         rc = ll_intent_file_open(file, NULL, 0, it);
610                         it->it_create_mode &= ~M_CHECK_STALE;
611                         if (rc) {
612                                 ll_file_data_put(fd);
613                                 GOTO(out_openerr, rc);
614                         }
615
616                         /* Got some error? Release the request */
617                         if (it->d.lustre.it_status < 0) {
618                                 req = it->d.lustre.it_data;
619                                 ptlrpc_req_finished(req);
620                         }
621                         goto restart;
622                 }
623                 OBD_ALLOC(*och_p, sizeof (struct obd_client_handle));
624                 if (!*och_p) {
625                         ll_file_data_put(fd);
626                         GOTO(out_och_free, rc = -ENOMEM);
627                 }
628                 (*och_usecount)++;
629                 req = it->d.lustre.it_data;
630
631                 /* md_intent_lock() didn't get a request ref if there was an
632                  * open error, so don't do cleanup on the request here
633                  * (bug 3430) */
634                 /* XXX (green): Should not we bail out on any error here, not
635                  * just open error? */
636                 rc = it_open_error(DISP_OPEN_OPEN, it);
637                 if (rc) {
638                         ll_file_data_put(fd);
639                         GOTO(out_och_free, rc);
640                 }
641
642                 ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_OPEN, 1);
643                 rc = ll_local_open(file, it, fd, *och_p);
644                 if (rc) {
645                         ll_file_data_put(fd);
646                         GOTO(out_och_free, rc);
647                 }
648         }
649         cfs_up(&lli->lli_och_sem);
650
651         /* Must do this outside lli_och_sem lock to prevent deadlock where
652            different kind of OPEN lock for this same inode gets cancelled
653            by ldlm_cancel_lru */
654         if (!S_ISREG(inode->i_mode))
655                 GOTO(out, rc);
656
657         ll_capa_open(inode);
658
659         lsm = lli->lli_smd;
660         if (lsm == NULL) {
661                 if (file->f_flags & O_LOV_DELAY_CREATE ||
662                     !(file->f_mode & FMODE_WRITE)) {
663                         CDEBUG(D_INODE, "object creation was delayed\n");
664                         GOTO(out, rc);
665                 }
666         }
667         file->f_flags &= ~O_LOV_DELAY_CREATE;
668         GOTO(out, rc);
669 out:
670         ptlrpc_req_finished(req);
671         if (req)
672                 it_clear_disposition(it, DISP_ENQ_OPEN_REF);
673 out_och_free:
674         if (rc) {
675                 if (*och_p) {
676                         OBD_FREE(*och_p, sizeof (struct obd_client_handle));
677                         *och_p = NULL; /* OBD_FREE writes some magic there */
678                         (*och_usecount)--;
679                 }
680                 cfs_up(&lli->lli_och_sem);
681 out_openerr:
682                 if (opendir_set != 0)
683                         ll_stop_statahead(inode, lli->lli_opendir_key);
684         }
685
686         return rc;
687 }
688
689 /* Fills the obdo with the attributes for the lsm */
690 static int ll_lsm_getattr(struct lov_stripe_md *lsm, struct obd_export *exp,
691                           struct obd_capa *capa, struct obdo *obdo,
692                           __u64 ioepoch, int sync)
693 {
694         struct ptlrpc_request_set *set;
695         struct obd_info            oinfo = { { { 0 } } };
696         int                        rc;
697
698         ENTRY;
699
700         LASSERT(lsm != NULL);
701
702         oinfo.oi_md = lsm;
703         oinfo.oi_oa = obdo;
704         oinfo.oi_oa->o_id = lsm->lsm_object_id;
705         oinfo.oi_oa->o_gr = lsm->lsm_object_gr;
706         oinfo.oi_oa->o_mode = S_IFREG;
707         oinfo.oi_oa->o_ioepoch = ioepoch;
708         oinfo.oi_oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
709                                OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
710                                OBD_MD_FLBLKSZ | OBD_MD_FLATIME |
711                                OBD_MD_FLMTIME | OBD_MD_FLCTIME |
712                                OBD_MD_FLGROUP | OBD_MD_FLEPOCH;
713         oinfo.oi_capa = capa;
714         if (sync) {
715                 oinfo.oi_oa->o_valid |= OBD_MD_FLFLAGS;
716                 oinfo.oi_oa->o_flags |= OBD_FL_SRVLOCK;
717         }
718
719         set = ptlrpc_prep_set();
720         if (set == NULL) {
721                 CERROR("can't allocate ptlrpc set\n");
722                 rc = -ENOMEM;
723         } else {
724                 rc = obd_getattr_async(exp, &oinfo, set);
725                 if (rc == 0)
726                         rc = ptlrpc_set_wait(set);
727                 ptlrpc_set_destroy(set);
728         }
729         if (rc == 0)
730                 oinfo.oi_oa->o_valid &= (OBD_MD_FLBLOCKS | OBD_MD_FLBLKSZ |
731                                          OBD_MD_FLATIME | OBD_MD_FLMTIME |
732                                          OBD_MD_FLCTIME | OBD_MD_FLSIZE);
733         RETURN(rc);
734 }
735
736 /**
737   * Performs the getattr on the inode and updates its fields.
738   * If @sync != 0, perform the getattr under the server-side lock.
739   */
740 int ll_inode_getattr(struct inode *inode, struct obdo *obdo,
741                      __u64 ioepoch, int sync)
742 {
743         struct ll_inode_info *lli  = ll_i2info(inode);
744         struct obd_capa      *capa = ll_mdscapa_get(inode);
745         int rc;
746         ENTRY;
747
748         rc = ll_lsm_getattr(lli->lli_smd, ll_i2dtexp(inode),
749                             capa, obdo, ioepoch, sync);
750         capa_put(capa);
751         if (rc == 0) {
752                 obdo_refresh_inode(inode, obdo, obdo->o_valid);
753                 CDEBUG(D_INODE,
754                        "objid "LPX64" size %Lu, blocks %llu, blksize %lu\n",
755                        lli->lli_smd->lsm_object_id, i_size_read(inode),
756                        (unsigned long long)inode->i_blocks,
757                        (unsigned long)ll_inode_blksize(inode));
758         }
759         RETURN(rc);
760 }
761
762 int ll_merge_lvb(struct inode *inode)
763 {
764         struct ll_inode_info *lli = ll_i2info(inode);
765         struct ll_sb_info *sbi = ll_i2sbi(inode);
766         struct ost_lvb lvb;
767         int rc;
768
769         ENTRY;
770
771         ll_inode_size_lock(inode, 1);
772         inode_init_lvb(inode, &lvb);
773         rc = obd_merge_lvb(sbi->ll_dt_exp, lli->lli_smd, &lvb, 0);
774         cl_isize_write_nolock(inode, lvb.lvb_size);
775         inode->i_blocks = lvb.lvb_blocks;
776
777         LTIME_S(inode->i_mtime) = lvb.lvb_mtime;
778         LTIME_S(inode->i_atime) = lvb.lvb_atime;
779         LTIME_S(inode->i_ctime) = lvb.lvb_ctime;
780         ll_inode_size_unlock(inode, 1);
781
782         RETURN(rc);
783 }
784
785 int ll_glimpse_ioctl(struct ll_sb_info *sbi, struct lov_stripe_md *lsm,
786                      lstat_t *st)
787 {
788         struct obdo obdo = { 0 };
789         int rc;
790
791         rc = ll_lsm_getattr(lsm, sbi->ll_dt_exp, NULL, &obdo, 0, 0);
792         if (rc == 0) {
793                 st->st_size   = obdo.o_size;
794                 st->st_blocks = obdo.o_blocks;
795                 st->st_mtime  = obdo.o_mtime;
796                 st->st_atime  = obdo.o_atime;
797                 st->st_ctime  = obdo.o_ctime;
798         }
799         return rc;
800 }
801
802 void ll_io_init(struct cl_io *io, const struct file *file, int write)
803 {
804         struct inode *inode = file->f_dentry->d_inode;
805
806         memset(io, 0, sizeof *io);
807         io->u.ci_rw.crw_nonblock = file->f_flags & O_NONBLOCK;
808         if (write)
809                 io->u.ci_wr.wr_append = !!(file->f_flags & O_APPEND);
810         io->ci_obj     = ll_i2info(inode)->lli_clob;
811         io->ci_lockreq = CILR_MAYBE;
812         if (ll_file_nolock(file)) {
813                 io->ci_lockreq = CILR_NEVER;
814                 io->ci_no_srvlock = 1;
815         } else if (file->f_flags & O_APPEND) {
816                 io->ci_lockreq = CILR_MANDATORY;
817         }
818 }
819
820 static ssize_t ll_file_io_generic(const struct lu_env *env,
821                 struct vvp_io_args *args, struct file *file,
822                 enum cl_io_type iot, loff_t *ppos, size_t count)
823 {
824         struct cl_io       *io;
825         ssize_t             result;
826         ENTRY;
827
828         io = &ccc_env_info(env)->cti_io;
829         ll_io_init(io, file, iot == CIT_WRITE);
830
831         if (cl_io_rw_init(env, io, iot, *ppos, count) == 0) {
832                 struct vvp_io *vio = vvp_env_io(env);
833                 struct ccc_io *cio = ccc_env_io(env);
834                 struct ll_inode_info *lli = ll_i2info(file->f_dentry->d_inode);
835                 int write_sem_locked = 0;
836
837                 cio->cui_fd  = LUSTRE_FPRIVATE(file);
838                 vio->cui_io_subtype = args->via_io_subtype;
839
840                 switch (vio->cui_io_subtype) {
841                 case IO_NORMAL:
842                         cio->cui_iov = args->u.normal.via_iov;
843                         cio->cui_nrsegs = args->u.normal.via_nrsegs;
844 #ifndef HAVE_FILE_WRITEV
845                         cio->cui_iocb = args->u.normal.via_iocb;
846 #endif
847                         if ((iot == CIT_WRITE) &&
848                             !(cio->cui_fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
849                                 cfs_down(&lli->lli_write_sem);
850                                 write_sem_locked = 1;
851                         }
852                         break;
853                 case IO_SENDFILE:
854                         vio->u.sendfile.cui_actor = args->u.sendfile.via_actor;
855                         vio->u.sendfile.cui_target = args->u.sendfile.via_target;
856                         break;
857                 case IO_SPLICE:
858                         vio->u.splice.cui_pipe = args->u.splice.via_pipe;
859                         vio->u.splice.cui_flags = args->u.splice.via_flags;
860                         break;
861                 default:
862                         CERROR("Unknow IO type - %u\n", vio->cui_io_subtype);
863                         LBUG();
864                 }
865                 result = cl_io_loop(env, io);
866                 if (write_sem_locked)
867                         cfs_up(&lli->lli_write_sem);
868         } else {
869                 /* cl_io_rw_init() handled IO */
870                 result = io->ci_result;
871         }
872
873         if (io->ci_nob > 0) {
874                 result = io->ci_nob;
875                 *ppos = io->u.ci_wr.wr.crw_pos;
876         }
877         cl_io_fini(env, io);
878         RETURN(result);
879 }
880
881
882 /*
883  * XXX: exact copy from kernel code (__generic_file_aio_write_nolock)
884  */
885 static int ll_file_get_iov_count(const struct iovec *iov,
886                                  unsigned long *nr_segs, size_t *count)
887 {
888         size_t cnt = 0;
889         unsigned long seg;
890
891         for (seg = 0; seg < *nr_segs; seg++) {
892                 const struct iovec *iv = &iov[seg];
893
894                 /*
895                  * If any segment has a negative length, or the cumulative
896                  * length ever wraps negative then return -EINVAL.
897                  */
898                 cnt += iv->iov_len;
899                 if (unlikely((ssize_t)(cnt|iv->iov_len) < 0))
900                         return -EINVAL;
901                 if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
902                         continue;
903                 if (seg == 0)
904                         return -EFAULT;
905                 *nr_segs = seg;
906                 cnt -= iv->iov_len;   /* This segment is no good */
907                 break;
908         }
909         *count = cnt;
910         return 0;
911 }
912
913 #ifdef HAVE_FILE_READV
914 static ssize_t ll_file_readv(struct file *file, const struct iovec *iov,
915                               unsigned long nr_segs, loff_t *ppos)
916 {
917         struct lu_env      *env;
918         struct vvp_io_args *args;
919         size_t              count;
920         ssize_t             result;
921         int                 refcheck;
922         ENTRY;
923
924         result = ll_file_get_iov_count(iov, &nr_segs, &count);
925         if (result)
926                 RETURN(result);
927
928         env = cl_env_get(&refcheck);
929         if (IS_ERR(env))
930                 RETURN(PTR_ERR(env));
931
932         args = vvp_env_args(env, IO_NORMAL);
933         args->u.normal.via_iov = (struct iovec *)iov;
934         args->u.normal.via_nrsegs = nr_segs;
935
936         result = ll_file_io_generic(env, args, file, CIT_READ, ppos, count);
937         cl_env_put(env, &refcheck);
938         RETURN(result);
939 }
940
941 static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
942                             loff_t *ppos)
943 {
944         struct lu_env *env;
945         struct iovec  *local_iov;
946         ssize_t        result;
947         int            refcheck;
948         ENTRY;
949
950         env = cl_env_get(&refcheck);
951         if (IS_ERR(env))
952                 RETURN(PTR_ERR(env));
953
954         local_iov = &vvp_env_info(env)->vti_local_iov;
955         local_iov->iov_base = (void __user *)buf;
956         local_iov->iov_len = count;
957         result = ll_file_readv(file, local_iov, 1, ppos);
958         cl_env_put(env, &refcheck);
959         RETURN(result);
960 }
961
962 #else
963 static ssize_t ll_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
964                                 unsigned long nr_segs, loff_t pos)
965 {
966         struct lu_env      *env;
967         struct vvp_io_args *args;
968         size_t              count;
969         ssize_t             result;
970         int                 refcheck;
971         ENTRY;
972
973         result = ll_file_get_iov_count(iov, &nr_segs, &count);
974         if (result)
975                 RETURN(result);
976
977         env = cl_env_get(&refcheck);
978         if (IS_ERR(env))
979                 RETURN(PTR_ERR(env));
980
981         args = vvp_env_args(env, IO_NORMAL);
982         args->u.normal.via_iov = (struct iovec *)iov;
983         args->u.normal.via_nrsegs = nr_segs;
984         args->u.normal.via_iocb = iocb;
985
986         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_READ,
987                                     &iocb->ki_pos, count);
988         cl_env_put(env, &refcheck);
989         RETURN(result);
990 }
991
992 static ssize_t ll_file_read(struct file *file, char *buf, size_t count,
993                             loff_t *ppos)
994 {
995         struct lu_env *env;
996         struct iovec  *local_iov;
997         struct kiocb  *kiocb;
998         ssize_t        result;
999         int            refcheck;
1000         ENTRY;
1001
1002         env = cl_env_get(&refcheck);
1003         if (IS_ERR(env))
1004                 RETURN(PTR_ERR(env));
1005
1006         local_iov = &vvp_env_info(env)->vti_local_iov;
1007         kiocb = &vvp_env_info(env)->vti_kiocb;
1008         local_iov->iov_base = (void __user *)buf;
1009         local_iov->iov_len = count;
1010         init_sync_kiocb(kiocb, file);
1011         kiocb->ki_pos = *ppos;
1012         kiocb->ki_left = count;
1013
1014         result = ll_file_aio_read(kiocb, local_iov, 1, kiocb->ki_pos);
1015         *ppos = kiocb->ki_pos;
1016
1017         cl_env_put(env, &refcheck);
1018         RETURN(result);
1019 }
1020 #endif
1021
1022 /*
1023  * Write to a file (through the page cache).
1024  */
1025 #ifdef HAVE_FILE_WRITEV
1026 static ssize_t ll_file_writev(struct file *file, const struct iovec *iov,
1027                               unsigned long nr_segs, loff_t *ppos)
1028 {
1029         struct lu_env      *env;
1030         struct vvp_io_args *args;
1031         size_t              count;
1032         ssize_t             result;
1033         int                 refcheck;
1034         ENTRY;
1035
1036         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1037         if (result)
1038                 RETURN(result);
1039
1040         env = cl_env_get(&refcheck);
1041         if (IS_ERR(env))
1042                 RETURN(PTR_ERR(env));
1043
1044         args = vvp_env_args(env, IO_NORMAL);
1045         args->u.normal.via_iov = (struct iovec *)iov;
1046         args->u.normal.via_nrsegs = nr_segs;
1047
1048         result = ll_file_io_generic(env, args, file, CIT_WRITE, ppos, count);
1049         cl_env_put(env, &refcheck);
1050         RETURN(result);
1051 }
1052
1053 static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1054                              loff_t *ppos)
1055 {
1056         struct lu_env    *env;
1057         struct iovec     *local_iov;
1058         ssize_t           result;
1059         int               refcheck;
1060         ENTRY;
1061
1062         env = cl_env_get(&refcheck);
1063         if (IS_ERR(env))
1064                 RETURN(PTR_ERR(env));
1065
1066         local_iov = &vvp_env_info(env)->vti_local_iov;
1067         local_iov->iov_base = (void __user *)buf;
1068         local_iov->iov_len = count;
1069
1070         result = ll_file_writev(file, local_iov, 1, ppos);
1071         cl_env_put(env, &refcheck);
1072         RETURN(result);
1073 }
1074
1075 #else /* AIO stuff */
1076 static ssize_t ll_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
1077                                  unsigned long nr_segs, loff_t pos)
1078 {
1079         struct lu_env      *env;
1080         struct vvp_io_args *args;
1081         size_t              count;
1082         ssize_t             result;
1083         int                 refcheck;
1084         ENTRY;
1085
1086         result = ll_file_get_iov_count(iov, &nr_segs, &count);
1087         if (result)
1088                 RETURN(result);
1089
1090         env = cl_env_get(&refcheck);
1091         if (IS_ERR(env))
1092                 RETURN(PTR_ERR(env));
1093
1094         args = vvp_env_args(env, IO_NORMAL);
1095         args->u.normal.via_iov = (struct iovec *)iov;
1096         args->u.normal.via_nrsegs = nr_segs;
1097         args->u.normal.via_iocb = iocb;
1098
1099         result = ll_file_io_generic(env, args, iocb->ki_filp, CIT_WRITE,
1100                                   &iocb->ki_pos, count);
1101         cl_env_put(env, &refcheck);
1102         RETURN(result);
1103 }
1104
1105 static ssize_t ll_file_write(struct file *file, const char *buf, size_t count,
1106                              loff_t *ppos)
1107 {
1108         struct lu_env *env;
1109         struct iovec  *local_iov;
1110         struct kiocb  *kiocb;
1111         ssize_t        result;
1112         int            refcheck;
1113         ENTRY;
1114
1115         env = cl_env_get(&refcheck);
1116         if (IS_ERR(env))
1117                 RETURN(PTR_ERR(env));
1118
1119         local_iov = &vvp_env_info(env)->vti_local_iov;
1120         kiocb = &vvp_env_info(env)->vti_kiocb;
1121         local_iov->iov_base = (void __user *)buf;
1122         local_iov->iov_len = count;
1123         init_sync_kiocb(kiocb, file);
1124         kiocb->ki_pos = *ppos;
1125         kiocb->ki_left = count;
1126
1127         result = ll_file_aio_write(kiocb, local_iov, 1, kiocb->ki_pos);
1128         *ppos = kiocb->ki_pos;
1129
1130         cl_env_put(env, &refcheck);
1131         RETURN(result);
1132 }
1133 #endif
1134
1135
1136 #ifdef HAVE_KERNEL_SENDFILE
1137 /*
1138  * Send file content (through pagecache) somewhere with helper
1139  */
1140 static ssize_t ll_file_sendfile(struct file *in_file, loff_t *ppos,size_t count,
1141                                 read_actor_t actor, void *target)
1142 {
1143         struct lu_env      *env;
1144         struct vvp_io_args *args;
1145         ssize_t             result;
1146         int                 refcheck;
1147         ENTRY;
1148
1149         env = cl_env_get(&refcheck);
1150         if (IS_ERR(env))
1151                 RETURN(PTR_ERR(env));
1152
1153         args = vvp_env_args(env, IO_SENDFILE);
1154         args->u.sendfile.via_target = target;
1155         args->u.sendfile.via_actor = actor;
1156
1157         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1158         cl_env_put(env, &refcheck);
1159         RETURN(result);
1160 }
1161 #endif
1162
1163 #ifdef HAVE_KERNEL_SPLICE_READ
1164 /*
1165  * Send file content (through pagecache) somewhere with helper
1166  */
1167 static ssize_t ll_file_splice_read(struct file *in_file, loff_t *ppos,
1168                                    struct pipe_inode_info *pipe, size_t count,
1169                                    unsigned int flags)
1170 {
1171         struct lu_env      *env;
1172         struct vvp_io_args *args;
1173         ssize_t             result;
1174         int                 refcheck;
1175         ENTRY;
1176
1177         env = cl_env_get(&refcheck);
1178         if (IS_ERR(env))
1179                 RETURN(PTR_ERR(env));
1180
1181         args = vvp_env_args(env, IO_SPLICE);
1182         args->u.splice.via_pipe = pipe;
1183         args->u.splice.via_flags = flags;
1184
1185         result = ll_file_io_generic(env, args, in_file, CIT_READ, ppos, count);
1186         cl_env_put(env, &refcheck);
1187         RETURN(result);
1188 }
1189 #endif
1190
1191 static int ll_lov_recreate_obj(struct inode *inode, struct file *file,
1192                                unsigned long arg)
1193 {
1194         struct obd_export *exp = ll_i2dtexp(inode);
1195         struct ll_recreate_obj ucreatp;
1196         struct obd_trans_info oti = { 0 };
1197         struct obdo *oa = NULL;
1198         int lsm_size;
1199         int rc = 0;
1200         struct lov_stripe_md *lsm, *lsm2;
1201         ENTRY;
1202
1203         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1204                 RETURN(-EPERM);
1205
1206         if (cfs_copy_from_user(&ucreatp, (struct ll_recreate_obj *)arg,
1207                                sizeof(struct ll_recreate_obj)))
1208                 RETURN(-EFAULT);
1209
1210         OBDO_ALLOC(oa);
1211         if (oa == NULL)
1212                 RETURN(-ENOMEM);
1213
1214         ll_inode_size_lock(inode, 0);
1215         lsm = ll_i2info(inode)->lli_smd;
1216         if (lsm == NULL)
1217                 GOTO(out, rc = -ENOENT);
1218         lsm_size = sizeof(*lsm) + (sizeof(struct lov_oinfo) *
1219                    (lsm->lsm_stripe_count));
1220
1221         OBD_ALLOC(lsm2, lsm_size);
1222         if (lsm2 == NULL)
1223                 GOTO(out, rc = -ENOMEM);
1224
1225         oa->o_id = ucreatp.lrc_id;
1226         oa->o_gr = ucreatp.lrc_group;
1227         oa->o_nlink = ucreatp.lrc_ost_idx;
1228         oa->o_flags |= OBD_FL_RECREATE_OBJS;
1229         oa->o_valid = OBD_MD_FLID | OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1230         obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
1231                         OBD_MD_FLMTIME | OBD_MD_FLCTIME);
1232
1233         memcpy(lsm2, lsm, lsm_size);
1234         rc = obd_create(exp, oa, &lsm2, &oti);
1235
1236         OBD_FREE(lsm2, lsm_size);
1237         GOTO(out, rc);
1238 out:
1239         ll_inode_size_unlock(inode, 0);
1240         OBDO_FREE(oa);
1241         return rc;
1242 }
1243
1244 int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
1245                              int flags, struct lov_user_md *lum, int lum_size)
1246 {
1247         struct lov_stripe_md *lsm;
1248         struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
1249         int rc = 0;
1250         ENTRY;
1251
1252         ll_inode_size_lock(inode, 0);
1253         lsm = ll_i2info(inode)->lli_smd;
1254         if (lsm) {
1255                 ll_inode_size_unlock(inode, 0);
1256                 CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
1257                        inode->i_ino);
1258                 RETURN(-EEXIST);
1259         }
1260
1261         rc = ll_intent_file_open(file, lum, lum_size, &oit);
1262         if (rc)
1263                 GOTO(out, rc);
1264         if (it_disposition(&oit, DISP_LOOKUP_NEG))
1265                 GOTO(out_req_free, rc = -ENOENT);
1266         rc = oit.d.lustre.it_status;
1267         if (rc < 0)
1268                 GOTO(out_req_free, rc);
1269
1270         ll_release_openhandle(file->f_dentry, &oit);
1271
1272  out:
1273         ll_inode_size_unlock(inode, 0);
1274         ll_intent_release(&oit);
1275         RETURN(rc);
1276 out_req_free:
1277         ptlrpc_req_finished((struct ptlrpc_request *) oit.d.lustre.it_data);
1278         goto out;
1279 }
1280
1281 int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
1282                              struct lov_mds_md **lmmp, int *lmm_size,
1283                              struct ptlrpc_request **request)
1284 {
1285         struct ll_sb_info *sbi = ll_i2sbi(inode);
1286         struct mdt_body  *body;
1287         struct lov_mds_md *lmm = NULL;
1288         struct ptlrpc_request *req = NULL;
1289         struct obd_capa *oc;
1290         int rc, lmmsize;
1291
1292         rc = ll_get_max_mdsize(sbi, &lmmsize);
1293         if (rc)
1294                 RETURN(rc);
1295
1296         oc = ll_mdscapa_get(inode);
1297         rc = md_getattr_name(sbi->ll_md_exp, ll_inode2fid(inode),
1298                              oc, filename, strlen(filename) + 1,
1299                              OBD_MD_FLEASIZE | OBD_MD_FLDIREA, lmmsize,
1300                              ll_i2suppgid(inode), &req);
1301         capa_put(oc);
1302         if (rc < 0) {
1303                 CDEBUG(D_INFO, "md_getattr_name failed "
1304                        "on %s: rc %d\n", filename, rc);
1305                 GOTO(out, rc);
1306         }
1307
1308         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
1309         LASSERT(body != NULL); /* checked by mdc_getattr_name */
1310
1311         lmmsize = body->eadatasize;
1312
1313         if (!(body->valid & (OBD_MD_FLEASIZE | OBD_MD_FLDIREA)) ||
1314                         lmmsize == 0) {
1315                 GOTO(out, rc = -ENODATA);
1316         }
1317
1318         lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
1319         LASSERT(lmm != NULL);
1320
1321         if ((lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V1)) &&
1322             (lmm->lmm_magic != cpu_to_le32(LOV_MAGIC_V3))) {
1323                 GOTO(out, rc = -EPROTO);
1324         }
1325
1326         /*
1327          * This is coming from the MDS, so is probably in
1328          * little endian.  We convert it to host endian before
1329          * passing it to userspace.
1330          */
1331         if (LOV_MAGIC != cpu_to_le32(LOV_MAGIC)) {
1332                 /* if function called for directory - we should
1333                  * avoid swab not existent lsm objects */
1334                 if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V1)) {
1335                         lustre_swab_lov_user_md_v1((struct lov_user_md_v1 *)lmm);
1336                         if (S_ISREG(body->mode))
1337                                 lustre_swab_lov_user_md_objects(
1338                                  ((struct lov_user_md_v1 *)lmm)->lmm_objects,
1339                                  ((struct lov_user_md_v1 *)lmm)->lmm_stripe_count);
1340                 } else if (lmm->lmm_magic == cpu_to_le32(LOV_MAGIC_V3)) {
1341                         lustre_swab_lov_user_md_v3((struct lov_user_md_v3 *)lmm);
1342                         if (S_ISREG(body->mode))
1343                                 lustre_swab_lov_user_md_objects(
1344                                  ((struct lov_user_md_v3 *)lmm)->lmm_objects,
1345                                  ((struct lov_user_md_v3 *)lmm)->lmm_stripe_count);
1346                 }
1347         }
1348
1349 out:
1350         *lmmp = lmm;
1351         *lmm_size = lmmsize;
1352         *request = req;
1353         return rc;
1354 }
1355
1356 static int ll_lov_setea(struct inode *inode, struct file *file,
1357                             unsigned long arg)
1358 {
1359         int flags = MDS_OPEN_HAS_OBJS | FMODE_WRITE;
1360         struct lov_user_md  *lump;
1361         int lum_size = sizeof(struct lov_user_md) +
1362                        sizeof(struct lov_user_ost_data);
1363         int rc;
1364         ENTRY;
1365
1366         if (!cfs_capable(CFS_CAP_SYS_ADMIN))
1367                 RETURN(-EPERM);
1368
1369         OBD_ALLOC(lump, lum_size);
1370         if (lump == NULL) {
1371                 RETURN(-ENOMEM);
1372         }
1373         if (cfs_copy_from_user(lump, (struct lov_user_md  *)arg, lum_size)) {
1374                 OBD_FREE(lump, lum_size);
1375                 RETURN(-EFAULT);
1376         }
1377
1378         rc = ll_lov_setstripe_ea_info(inode, file, flags, lump, lum_size);
1379
1380         OBD_FREE(lump, lum_size);
1381         RETURN(rc);
1382 }
1383
1384 static int ll_lov_setstripe(struct inode *inode, struct file *file,
1385                             unsigned long arg)
1386 {
1387         struct lov_user_md_v3 lumv3;
1388         struct lov_user_md_v1 *lumv1 = (struct lov_user_md_v1 *)&lumv3;
1389         struct lov_user_md_v1 *lumv1p = (struct lov_user_md_v1 *)arg;
1390         struct lov_user_md_v3 *lumv3p = (struct lov_user_md_v3 *)arg;
1391         int lum_size;
1392         int rc;
1393         int flags = FMODE_WRITE;
1394         ENTRY;
1395
1396         /* first try with v1 which is smaller than v3 */
1397         lum_size = sizeof(struct lov_user_md_v1);
1398         if (cfs_copy_from_user(lumv1, lumv1p, lum_size))
1399                 RETURN(-EFAULT);
1400
1401         if (lumv1->lmm_magic == LOV_USER_MAGIC_V3) {
1402                 lum_size = sizeof(struct lov_user_md_v3);
1403                 if (cfs_copy_from_user(&lumv3, lumv3p, lum_size))
1404                         RETURN(-EFAULT);
1405         }
1406
1407         rc = ll_lov_setstripe_ea_info(inode, file, flags, lumv1, lum_size);
1408         if (rc == 0) {
1409                  put_user(0, &lumv1p->lmm_stripe_count);
1410                  rc = obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode),
1411                                     0, ll_i2info(inode)->lli_smd,
1412                                     (void *)arg);
1413         }
1414         RETURN(rc);
1415 }
1416
1417 static int ll_lov_getstripe(struct inode *inode, unsigned long arg)
1418 {
1419         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
1420
1421         if (!lsm)
1422                 RETURN(-ENODATA);
1423
1424         return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, ll_i2dtexp(inode), 0, lsm,
1425                             (void *)arg);
1426 }
1427
1428 int ll_get_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1429 {
1430         struct ll_inode_info   *lli = ll_i2info(inode);
1431         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1432         struct ccc_grouplock    grouplock;
1433         int                     rc;
1434         ENTRY;
1435
1436         if (ll_file_nolock(file))
1437                 RETURN(-EOPNOTSUPP);
1438
1439         cfs_spin_lock(&lli->lli_lock);
1440         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1441                 CWARN("group lock already existed with gid %lu\n",
1442                        fd->fd_grouplock.cg_gid);
1443                 cfs_spin_unlock(&lli->lli_lock);
1444                 RETURN(-EINVAL);
1445         }
1446         LASSERT(fd->fd_grouplock.cg_lock == NULL);
1447         cfs_spin_unlock(&lli->lli_lock);
1448
1449         rc = cl_get_grouplock(cl_i2info(inode)->lli_clob,
1450                               arg, (file->f_flags & O_NONBLOCK), &grouplock);
1451         if (rc)
1452                 RETURN(rc);
1453
1454         cfs_spin_lock(&lli->lli_lock);
1455         if (fd->fd_flags & LL_FILE_GROUP_LOCKED) {
1456                 cfs_spin_unlock(&lli->lli_lock);
1457                 CERROR("another thread just won the race\n");
1458                 cl_put_grouplock(&grouplock);
1459                 RETURN(-EINVAL);
1460         }
1461
1462         fd->fd_flags |= LL_FILE_GROUP_LOCKED;
1463         fd->fd_grouplock = grouplock;
1464         cfs_spin_unlock(&lli->lli_lock);
1465
1466         CDEBUG(D_INFO, "group lock %lu obtained\n", arg);
1467         RETURN(0);
1468 }
1469
1470 int ll_put_grouplock(struct inode *inode, struct file *file, unsigned long arg)
1471 {
1472         struct ll_inode_info   *lli = ll_i2info(inode);
1473         struct ll_file_data    *fd = LUSTRE_FPRIVATE(file);
1474         struct ccc_grouplock    grouplock;
1475         ENTRY;
1476
1477         cfs_spin_lock(&lli->lli_lock);
1478         if (!(fd->fd_flags & LL_FILE_GROUP_LOCKED)) {
1479                 cfs_spin_unlock(&lli->lli_lock);
1480                 CWARN("no group lock held\n");
1481                 RETURN(-EINVAL);
1482         }
1483         LASSERT(fd->fd_grouplock.cg_lock != NULL);
1484
1485         if (fd->fd_grouplock.cg_gid != arg) {
1486                 CWARN("group lock %lu doesn't match current id %lu\n",
1487                        arg, fd->fd_grouplock.cg_gid);
1488                 cfs_spin_unlock(&lli->lli_lock);
1489                 RETURN(-EINVAL);
1490         }
1491
1492         grouplock = fd->fd_grouplock;
1493         memset(&fd->fd_grouplock, 0, sizeof(fd->fd_grouplock));
1494         fd->fd_flags &= ~LL_FILE_GROUP_LOCKED;
1495         cfs_spin_unlock(&lli->lli_lock);
1496
1497         cl_put_grouplock(&grouplock);
1498         CDEBUG(D_INFO, "group lock %lu released\n", arg);
1499         RETURN(0);
1500 }
1501
1502 /**
1503  * Close inode open handle
1504  *
1505  * \param dentry [in]     dentry which contains the inode
1506  * \param it     [in,out] intent which contains open info and result
1507  *
1508  * \retval 0     success
1509  * \retval <0    failure
1510  */
1511 int ll_release_openhandle(struct dentry *dentry, struct lookup_intent *it)
1512 {
1513         struct inode *inode = dentry->d_inode;
1514         struct obd_client_handle *och;
1515         int rc;
1516         ENTRY;
1517
1518         LASSERT(inode);
1519
1520         /* Root ? Do nothing. */
1521         if (dentry->d_inode->i_sb->s_root == dentry)
1522                 RETURN(0);
1523
1524         /* No open handle to close? Move away */
1525         if (!it_disposition(it, DISP_OPEN_OPEN))
1526                 RETURN(0);
1527
1528         LASSERT(it_open_error(DISP_OPEN_OPEN, it) == 0);
1529
1530         OBD_ALLOC(och, sizeof(*och));
1531         if (!och)
1532                 GOTO(out, rc = -ENOMEM);
1533
1534         ll_och_fill(ll_i2sbi(inode)->ll_md_exp,
1535                     ll_i2info(inode), it, och);
1536
1537         rc = ll_close_inode_openhandle(ll_i2sbi(inode)->ll_md_exp,
1538                                        inode, och);
1539  out:
1540         /* this one is in place of ll_file_open */
1541         if (it_disposition(it, DISP_ENQ_OPEN_REF))
1542                 ptlrpc_req_finished(it->d.lustre.it_data);
1543         it_clear_disposition(it, DISP_ENQ_OPEN_REF);
1544         RETURN(rc);
1545 }
1546
1547 /**
1548  * Get size for inode for which FIEMAP mapping is requested.
1549  * Make the FIEMAP get_info call and returns the result.
1550  */
1551 int ll_do_fiemap(struct inode *inode, struct ll_user_fiemap *fiemap,
1552               int num_bytes)
1553 {
1554         struct obd_export *exp = ll_i2dtexp(inode);
1555         struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
1556         struct ll_fiemap_info_key fm_key = { .name = KEY_FIEMAP, };
1557         int vallen = num_bytes;
1558         int rc;
1559         ENTRY;
1560
1561         /* Checks for fiemap flags */
1562         if (fiemap->fm_flags & ~LUSTRE_FIEMAP_FLAGS_COMPAT) {
1563                 fiemap->fm_flags &= ~LUSTRE_FIEMAP_FLAGS_COMPAT;
1564                 return -EBADR;
1565         }
1566
1567         /* Check for FIEMAP_FLAG_SYNC */
1568         if (fiemap->fm_flags & FIEMAP_FLAG_SYNC) {
1569                 rc = filemap_fdatawrite(inode->i_mapping);
1570                 if (rc)
1571                         return rc;
1572         }
1573
1574         /* If the stripe_count > 1 and the application does not understand
1575          * DEVICE_ORDER flag, then it cannot interpret the extents correctly.
1576          */
1577         if (lsm->lsm_stripe_count > 1 &&
1578             !(fiemap->fm_flags & FIEMAP_FLAG_DEVICE_ORDER))
1579                 return -EOPNOTSUPP;
1580
1581         fm_key.oa.o_id = lsm->lsm_object_id;
1582         fm_key.oa.o_gr = lsm->lsm_object_gr;
1583         fm_key.oa.o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1584
1585         obdo_from_inode(&fm_key.oa, inode, OBD_MD_FLFID | OBD_MD_FLGROUP |
1586                         OBD_MD_FLSIZE);
1587
1588         /* If filesize is 0, then there would be no objects for mapping */
1589         if (fm_key.oa.o_size == 0) {
1590                 fiemap->fm_mapped_extents = 0;
1591                 RETURN(0);
1592         }
1593
1594         memcpy(&fm_key.fiemap, fiemap, sizeof(*fiemap));
1595
1596         rc = obd_get_info(exp, sizeof(fm_key), &fm_key, &vallen, fiemap, lsm);
1597         if (rc)
1598                 CERROR("obd_get_info failed: rc = %d\n", rc);
1599
1600         RETURN(rc);
1601 }
1602
1603 int ll_fid2path(struct obd_export *exp, void *arg)
1604 {
1605         struct getinfo_fid2path *gfout, *gfin;
1606         int outsize, rc;
1607         ENTRY;
1608
1609         /* Need to get the buflen */
1610         OBD_ALLOC_PTR(gfin);
1611         if (gfin == NULL)
1612                 RETURN(-ENOMEM);
1613         if (cfs_copy_from_user(gfin, arg, sizeof(*gfin))) {
1614                 OBD_FREE_PTR(gfin);
1615                 RETURN(-EFAULT);
1616         }
1617
1618         outsize = sizeof(*gfout) + gfin->gf_pathlen;
1619         OBD_ALLOC(gfout, outsize);
1620         if (gfout == NULL) {
1621                 OBD_FREE_PTR(gfin);
1622                 RETURN(-ENOMEM);
1623         }
1624         memcpy(gfout, gfin, sizeof(*gfout));
1625         OBD_FREE_PTR(gfin);
1626
1627         /* Call mdc_iocontrol */
1628         rc = obd_iocontrol(OBD_IOC_FID2PATH, exp, outsize, gfout, NULL);
1629         if (rc)
1630                 GOTO(gf_free, rc);
1631         if (cfs_copy_to_user(arg, gfout, outsize))
1632                 rc = -EFAULT;
1633
1634 gf_free:
1635         OBD_FREE(gfout, outsize);
1636         RETURN(rc);
1637 }
1638
1639 static int ll_ioctl_fiemap(struct inode *inode, unsigned long arg)
1640 {
1641         struct ll_user_fiemap *fiemap_s;
1642         size_t num_bytes, ret_bytes;
1643         unsigned int extent_count;
1644         int rc = 0;
1645
1646         /* Get the extent count so we can calculate the size of
1647          * required fiemap buffer */
1648         if (get_user(extent_count,
1649             &((struct ll_user_fiemap __user *)arg)->fm_extent_count))
1650                 RETURN(-EFAULT);
1651         num_bytes = sizeof(*fiemap_s) + (extent_count *
1652                                          sizeof(struct ll_fiemap_extent));
1653
1654         OBD_VMALLOC(fiemap_s, num_bytes);
1655         if (fiemap_s == NULL)
1656                 RETURN(-ENOMEM);
1657
1658         /* get the fiemap value */
1659         if (copy_from_user(fiemap_s,(struct ll_user_fiemap __user *)arg,
1660                            sizeof(*fiemap_s)))
1661                 GOTO(error, rc = -EFAULT);
1662
1663         /* If fm_extent_count is non-zero, read the first extent since
1664          * it is used to calculate end_offset and device from previous
1665          * fiemap call. */
1666         if (extent_count) {
1667                 if (copy_from_user(&fiemap_s->fm_extents[0],
1668                     (char __user *)arg + sizeof(*fiemap_s),
1669                     sizeof(struct ll_fiemap_extent)))
1670                         GOTO(error, rc = -EFAULT);
1671         }
1672
1673         rc = ll_do_fiemap(inode, fiemap_s, num_bytes);
1674         if (rc)
1675                 GOTO(error, rc);
1676
1677         ret_bytes = sizeof(struct ll_user_fiemap);
1678
1679         if (extent_count != 0)
1680                 ret_bytes += (fiemap_s->fm_mapped_extents *
1681                                  sizeof(struct ll_fiemap_extent));
1682
1683         if (copy_to_user((void *)arg, fiemap_s, ret_bytes))
1684                 rc = -EFAULT;
1685
1686 error:
1687         OBD_VFREE(fiemap_s, num_bytes);
1688         RETURN(rc);
1689 }
1690
1691 int ll_file_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
1692                   unsigned long arg)
1693 {
1694         struct ll_file_data *fd = LUSTRE_FPRIVATE(file);
1695         int flags;
1696         ENTRY;
1697
1698         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
1699                inode->i_generation, inode, cmd);
1700         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
1701
1702         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
1703         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */
1704                 RETURN(-ENOTTY);
1705
1706         switch(cmd) {
1707         case LL_IOC_GETFLAGS:
1708                 /* Get the current value of the file flags */
1709                 return put_user(fd->fd_flags, (int *)arg);
1710         case LL_IOC_SETFLAGS:
1711         case LL_IOC_CLRFLAGS:
1712                 /* Set or clear specific file flags */
1713                 /* XXX This probably needs checks to ensure the flags are
1714                  *     not abused, and to handle any flag side effects.
1715                  */
1716                 if (get_user(flags, (int *) arg))
1717                         RETURN(-EFAULT);
1718
1719                 if (cmd == LL_IOC_SETFLAGS) {
1720                         if ((flags & LL_FILE_IGNORE_LOCK) &&
1721                             !(file->f_flags & O_DIRECT)) {
1722                                 CERROR("%s: unable to disable locking on "
1723                                        "non-O_DIRECT file\n", current->comm);
1724                                 RETURN(-EINVAL);
1725                         }
1726
1727                         fd->fd_flags |= flags;
1728                 } else {
1729                         fd->fd_flags &= ~flags;
1730                 }
1731                 RETURN(0);
1732         case LL_IOC_LOV_SETSTRIPE:
1733                 RETURN(ll_lov_setstripe(inode, file, arg));
1734         case LL_IOC_LOV_SETEA:
1735                 RETURN(ll_lov_setea(inode, file, arg));
1736         case LL_IOC_LOV_GETSTRIPE:
1737                 RETURN(ll_lov_getstripe(inode, arg));
1738         case LL_IOC_RECREATE_OBJ:
1739                 RETURN(ll_lov_recreate_obj(inode, file, arg));
1740         case FSFILT_IOC_FIEMAP:
1741                 RETURN(ll_ioctl_fiemap(inode, arg));
1742         case FSFILT_IOC_GETFLAGS:
1743         case FSFILT_IOC_SETFLAGS:
1744                 RETURN(ll_iocontrol(inode, file, cmd, arg));
1745         case FSFILT_IOC_GETVERSION_OLD:
1746         case FSFILT_IOC_GETVERSION:
1747                 RETURN(put_user(inode->i_generation, (int *)arg));
1748         case LL_IOC_GROUP_LOCK:
1749                 RETURN(ll_get_grouplock(inode, file, arg));
1750         case LL_IOC_GROUP_UNLOCK:
1751                 RETURN(ll_put_grouplock(inode, file, arg));
1752         case IOC_OBD_STATFS:
1753                 RETURN(ll_obd_statfs(inode, (void *)arg));
1754
1755         /* We need to special case any other ioctls we want to handle,
1756          * to send them to the MDS/OST as appropriate and to properly
1757          * network encode the arg field.
1758         case FSFILT_IOC_SETVERSION_OLD:
1759         case FSFILT_IOC_SETVERSION:
1760         */
1761         case LL_IOC_FLUSHCTX:
1762                 RETURN(ll_flush_ctx(inode));
1763         case LL_IOC_PATH2FID: {
1764                 if (cfs_copy_to_user((void *)arg, ll_inode2fid(inode),
1765                                      sizeof(struct lu_fid)))
1766                         RETURN(-EFAULT);
1767
1768                 RETURN(0);
1769         }
1770         case OBD_IOC_FID2PATH:
1771                 RETURN(ll_fid2path(ll_i2mdexp(inode), (void *)arg));
1772
1773         default: {
1774                 int err;
1775
1776                 if (LLIOC_STOP ==
1777                     ll_iocontrol_call(inode, file, cmd, arg, &err))
1778                         RETURN(err);
1779
1780                 RETURN(obd_iocontrol(cmd, ll_i2dtexp(inode), 0, NULL,
1781                                      (void *)arg));
1782         }
1783         }
1784 }
1785
1786 loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
1787 {
1788         struct inode *inode = file->f_dentry->d_inode;
1789         loff_t retval;
1790         ENTRY;
1791         retval = offset + ((origin == 2) ? i_size_read(inode) :
1792                            (origin == 1) ? file->f_pos : 0);
1793         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%Lu=%#Lx(%s)\n",
1794                inode->i_ino, inode->i_generation, inode, retval, retval,
1795                origin == 2 ? "SEEK_END": origin == 1 ? "SEEK_CUR" : "SEEK_SET");
1796         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
1797
1798         if (origin == 2) { /* SEEK_END */
1799                 int nonblock = 0, rc;
1800
1801                 if (file->f_flags & O_NONBLOCK)
1802                         nonblock = LDLM_FL_BLOCK_NOWAIT;
1803
1804                 rc = cl_glimpse_size(inode);
1805                 if (rc != 0)
1806                         RETURN(rc);
1807
1808                 offset += i_size_read(inode);
1809         } else if (origin == 1) { /* SEEK_CUR */
1810                 offset += file->f_pos;
1811         }
1812
1813         retval = -EINVAL;
1814         if (offset >= 0 && offset <= ll_file_maxbytes(inode)) {
1815                 if (offset != file->f_pos) {
1816                         file->f_pos = offset;
1817                 }
1818                 retval = offset;
1819         }
1820
1821         RETURN(retval);
1822 }
1823
1824 int ll_fsync(struct file *file, struct dentry *dentry, int data)
1825 {
1826         struct inode *inode = dentry->d_inode;
1827         struct ll_inode_info *lli = ll_i2info(inode);
1828         struct lov_stripe_md *lsm = lli->lli_smd;
1829         struct ptlrpc_request *req;
1830         struct obd_capa *oc;
1831         int rc, err;
1832         ENTRY;
1833         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
1834                inode->i_generation, inode);
1835         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
1836
1837         /* fsync's caller has already called _fdata{sync,write}, we want
1838          * that IO to finish before calling the osc and mdc sync methods */
1839         rc = filemap_fdatawait(inode->i_mapping);
1840
1841         /* catch async errors that were recorded back when async writeback
1842          * failed for pages in this mapping. */
1843         err = lli->lli_async_rc;
1844         lli->lli_async_rc = 0;
1845         if (rc == 0)
1846                 rc = err;
1847         if (lsm) {
1848                 err = lov_test_and_clear_async_rc(lsm);
1849                 if (rc == 0)
1850                         rc = err;
1851         }
1852
1853         oc = ll_mdscapa_get(inode);
1854         err = md_sync(ll_i2sbi(inode)->ll_md_exp, ll_inode2fid(inode), oc,
1855                       &req);
1856         capa_put(oc);
1857         if (!rc)
1858                 rc = err;
1859         if (!err)
1860                 ptlrpc_req_finished(req);
1861
1862         if (data && lsm) {
1863                 struct obdo *oa;
1864
1865                 OBDO_ALLOC(oa);
1866                 if (!oa)
1867                         RETURN(rc ? rc : -ENOMEM);
1868
1869                 oa->o_id = lsm->lsm_object_id;
1870                 oa->o_gr = lsm->lsm_object_gr;
1871                 oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
1872                 obdo_from_inode(oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
1873                                            OBD_MD_FLMTIME | OBD_MD_FLCTIME |
1874                                            OBD_MD_FLGROUP);
1875
1876                 oc = ll_osscapa_get(inode, CAPA_OPC_OSS_WRITE);
1877                 err = obd_sync(ll_i2sbi(inode)->ll_dt_exp, oa, lsm,
1878                                0, OBD_OBJECT_EOF, oc);
1879                 capa_put(oc);
1880                 if (!rc)
1881                         rc = err;
1882                 OBDO_FREE(oa);
1883         }
1884
1885         RETURN(rc);
1886 }
1887
1888 int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
1889 {
1890         struct inode *inode = file->f_dentry->d_inode;
1891         struct ll_sb_info *sbi = ll_i2sbi(inode);
1892         struct ldlm_enqueue_info einfo = { .ei_type = LDLM_FLOCK,
1893                                            .ei_cb_cp =ldlm_flock_completion_ast,
1894                                            .ei_cbdata = file_lock };
1895         struct md_op_data *op_data;
1896         struct lustre_handle lockh = {0};
1897         ldlm_policy_data_t flock;
1898         int flags = 0;
1899         int rc;
1900         ENTRY;
1901
1902         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
1903                inode->i_ino, file_lock);
1904
1905         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
1906
1907         if (file_lock->fl_flags & FL_FLOCK) {
1908                 LASSERT((cmd == F_SETLKW) || (cmd == F_SETLK));
1909                 /* set missing params for flock() calls */
1910                 file_lock->fl_end = OFFSET_MAX;
1911                 file_lock->fl_pid = current->tgid;
1912         }
1913         flock.l_flock.pid = file_lock->fl_pid;
1914         flock.l_flock.start = file_lock->fl_start;
1915         flock.l_flock.end = file_lock->fl_end;
1916
1917         switch (file_lock->fl_type) {
1918         case F_RDLCK:
1919                 einfo.ei_mode = LCK_PR;
1920                 break;
1921         case F_UNLCK:
1922                 /* An unlock request may or may not have any relation to
1923                  * existing locks so we may not be able to pass a lock handle
1924                  * via a normal ldlm_lock_cancel() request. The request may even
1925                  * unlock a byte range in the middle of an existing lock. In
1926                  * order to process an unlock request we need all of the same
1927                  * information that is given with a normal read or write record
1928                  * lock request. To avoid creating another ldlm unlock (cancel)
1929                  * message we'll treat a LCK_NL flock request as an unlock. */
1930                 einfo.ei_mode = LCK_NL;
1931                 break;
1932         case F_WRLCK:
1933                 einfo.ei_mode = LCK_PW;
1934                 break;
1935         default:
1936                 CERROR("unknown fcntl lock type: %d\n", file_lock->fl_type);
1937                 RETURN (-EINVAL);
1938         }
1939
1940         switch (cmd) {
1941         case F_SETLKW:
1942 #ifdef F_SETLKW64
1943         case F_SETLKW64:
1944 #endif
1945                 flags = 0;
1946                 break;
1947         case F_SETLK:
1948 #ifdef F_SETLK64
1949         case F_SETLK64:
1950 #endif
1951                 flags = LDLM_FL_BLOCK_NOWAIT;
1952                 break;
1953         case F_GETLK:
1954 #ifdef F_GETLK64
1955         case F_GETLK64:
1956 #endif
1957                 flags = LDLM_FL_TEST_LOCK;
1958                 /* Save the old mode so that if the mode in the lock changes we
1959                  * can decrement the appropriate reader or writer refcount. */
1960                 file_lock->fl_type = einfo.ei_mode;
1961                 break;
1962         default:
1963                 CERROR("unknown fcntl lock command: %d\n", cmd);
1964                 RETURN (-EINVAL);
1965         }
1966
1967         op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0,
1968                                      LUSTRE_OPC_ANY, NULL);
1969         if (IS_ERR(op_data))
1970                 RETURN(PTR_ERR(op_data));
1971
1972         CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags=%#x, mode=%u, "
1973                "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
1974                flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
1975
1976         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
1977                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
1978
1979         ll_finish_md_op_data(op_data);
1980
1981         if ((file_lock->fl_flags & FL_FLOCK) &&
1982             (rc == 0 || file_lock->fl_type == F_UNLCK))
1983                 ll_flock_lock_file_wait(file, file_lock, (cmd == F_SETLKW));
1984 #ifdef HAVE_F_OP_FLOCK
1985         if ((file_lock->fl_flags & FL_POSIX) &&
1986             (rc == 0 || file_lock->fl_type == F_UNLCK) &&
1987             !(flags & LDLM_FL_TEST_LOCK))
1988                 posix_lock_file_wait(file, file_lock);
1989 #endif
1990
1991         RETURN(rc);
1992 }
1993
1994 int ll_file_noflock(struct file *file, int cmd, struct file_lock *file_lock)
1995 {
1996         ENTRY;
1997
1998         RETURN(-ENOSYS);
1999 }
2000
2001 int ll_have_md_lock(struct inode *inode, __u64 bits)
2002 {
2003         struct lustre_handle lockh;
2004         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2005         struct lu_fid *fid;
2006         int flags;
2007         ENTRY;
2008
2009         if (!inode)
2010                RETURN(0);
2011
2012         fid = &ll_i2info(inode)->lli_fid;
2013         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2014
2015         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
2016         if (md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2017                           LCK_CR|LCK_CW|LCK_PR|LCK_PW, &lockh)) {
2018                 RETURN(1);
2019         }
2020         RETURN(0);
2021 }
2022
2023 ldlm_mode_t ll_take_md_lock(struct inode *inode, __u64 bits,
2024                             struct lustre_handle *lockh)
2025 {
2026         ldlm_policy_data_t policy = { .l_inodebits = {bits}};
2027         struct lu_fid *fid;
2028         ldlm_mode_t rc;
2029         int flags;
2030         ENTRY;
2031
2032         fid = &ll_i2info(inode)->lli_fid;
2033         CDEBUG(D_INFO, "trying to match res "DFID"\n", PFID(fid));
2034
2035         flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING;
2036         rc = md_lock_match(ll_i2mdexp(inode), flags, fid, LDLM_IBITS, &policy,
2037                            LCK_CR|LCK_CW|LCK_PR|LCK_PW, lockh);
2038         RETURN(rc);
2039 }
2040
2041 static int ll_inode_revalidate_fini(struct inode *inode, int rc) {
2042         if (rc == -ENOENT) { /* Already unlinked. Just update nlink
2043                               * and return success */
2044                 inode->i_nlink = 0;
2045                 /* This path cannot be hit for regular files unless in
2046                  * case of obscure races, so no need to to validate
2047                  * size. */
2048                 if (!S_ISREG(inode->i_mode) &&
2049                     !S_ISDIR(inode->i_mode))
2050                         return 0;
2051         }
2052
2053         if (rc) {
2054                 CERROR("failure %d inode %lu\n", rc, inode->i_ino);
2055                 return -abs(rc);
2056
2057         }
2058
2059         return 0;
2060 }
2061
2062 int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
2063                              __u64 ibits)
2064 {
2065         struct inode *inode = dentry->d_inode;
2066         struct ptlrpc_request *req = NULL;
2067         struct ll_sb_info *sbi;
2068         struct obd_export *exp;
2069         int rc = 0;
2070         ENTRY;
2071
2072         if (!inode) {
2073                 CERROR("REPORT THIS LINE TO PETER\n");
2074                 RETURN(0);
2075         }
2076         sbi = ll_i2sbi(inode);
2077
2078         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
2079                inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
2080
2081         exp = ll_i2mdexp(inode);
2082
2083         if (exp->exp_connect_flags & OBD_CONNECT_ATTRFID) {
2084                 struct lookup_intent oit = { .it_op = IT_GETATTR };
2085                 struct md_op_data *op_data;
2086
2087                 /* Call getattr by fid, so do not provide name at all. */
2088                 op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
2089                                              dentry->d_inode, NULL, 0, 0,
2090                                              LUSTRE_OPC_ANY, NULL);
2091                 if (IS_ERR(op_data))
2092                         RETURN(PTR_ERR(op_data));
2093
2094                 oit.it_create_mode |= M_CHECK_STALE;
2095                 rc = md_intent_lock(exp, op_data, NULL, 0,
2096                                     /* we are not interested in name
2097                                        based lookup */
2098                                     &oit, 0, &req,
2099                                     ll_md_blocking_ast, 0);
2100                 ll_finish_md_op_data(op_data);
2101                 oit.it_create_mode &= ~M_CHECK_STALE;
2102                 if (rc < 0) {
2103                         rc = ll_inode_revalidate_fini(inode, rc);
2104                         GOTO (out, rc);
2105                 }
2106
2107                 rc = ll_revalidate_it_finish(req, &oit, dentry);
2108                 if (rc != 0) {
2109                         ll_intent_release(&oit);
2110                         GOTO(out, rc);
2111                 }
2112
2113                 /* Unlinked? Unhash dentry, so it is not picked up later by
2114                    do_lookup() -> ll_revalidate_it(). We cannot use d_drop
2115                    here to preserve get_cwd functionality on 2.6.
2116                    Bug 10503 */
2117                 if (!dentry->d_inode->i_nlink) {
2118                         cfs_spin_lock(&ll_lookup_lock);
2119                         spin_lock(&dcache_lock);
2120                         ll_drop_dentry(dentry);
2121                         spin_unlock(&dcache_lock);
2122                         cfs_spin_unlock(&ll_lookup_lock);
2123                 }
2124
2125                 ll_lookup_finish_locks(&oit, dentry);
2126         } else if (!ll_have_md_lock(dentry->d_inode, ibits)) {
2127
2128                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
2129                 obd_valid valid = OBD_MD_FLGETATTR;
2130                 struct obd_capa *oc;
2131                 int ealen = 0;
2132
2133                 if (S_ISREG(inode->i_mode)) {
2134                         rc = ll_get_max_mdsize(sbi, &ealen);
2135                         if (rc)
2136                                 RETURN(rc);
2137                         valid |= OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE;
2138                 }
2139                 /* Once OBD_CONNECT_ATTRFID is not supported, we can't find one
2140                  * capa for this inode. Because we only keep capas of dirs
2141                  * fresh. */
2142                 oc = ll_mdscapa_get(inode);
2143                 rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode), oc, valid,
2144                                 ealen, &req);
2145                 capa_put(oc);
2146                 if (rc) {
2147                         rc = ll_inode_revalidate_fini(inode, rc);
2148                         RETURN(rc);
2149                 }
2150
2151                 rc = ll_prep_inode(&inode, req, NULL);
2152         }
2153 out:
2154         ptlrpc_req_finished(req);
2155         return rc;
2156 }
2157
2158 int ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it)
2159 {
2160         int rc;
2161         ENTRY;
2162
2163         rc = __ll_inode_revalidate_it(dentry, it, MDS_INODELOCK_UPDATE |
2164                                                   MDS_INODELOCK_LOOKUP);
2165
2166         /* if object not yet allocated, don't validate size */
2167         if (rc == 0 && ll_i2info(dentry->d_inode)->lli_smd == NULL)
2168                 RETURN(0);
2169
2170         /* cl_glimpse_size will prefer locally cached writes if they extend
2171          * the file */
2172
2173         if (rc == 0)
2174                 rc = cl_glimpse_size(dentry->d_inode);
2175
2176         RETURN(rc);
2177 }
2178
2179 int ll_getattr_it(struct vfsmount *mnt, struct dentry *de,
2180                   struct lookup_intent *it, struct kstat *stat)
2181 {
2182         struct inode *inode = de->d_inode;
2183         int res = 0;
2184
2185         res = ll_inode_revalidate_it(de, it);
2186         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETATTR, 1);
2187
2188         if (res)
2189                 return res;
2190
2191         stat->dev = inode->i_sb->s_dev;
2192         stat->ino = inode->i_ino;
2193         stat->mode = inode->i_mode;
2194         stat->nlink = inode->i_nlink;
2195         stat->uid = inode->i_uid;
2196         stat->gid = inode->i_gid;
2197         stat->rdev = kdev_t_to_nr(inode->i_rdev);
2198         stat->atime = inode->i_atime;
2199         stat->mtime = inode->i_mtime;
2200         stat->ctime = inode->i_ctime;
2201 #ifdef HAVE_INODE_BLKSIZE
2202         stat->blksize = inode->i_blksize;
2203 #else
2204         stat->blksize = 1 << inode->i_blkbits;
2205 #endif
2206
2207         stat->size = i_size_read(inode);
2208         stat->blocks = inode->i_blocks;
2209
2210         return 0;
2211 }
2212 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat)
2213 {
2214         struct lookup_intent it = { .it_op = IT_GETATTR };
2215
2216         return ll_getattr_it(mnt, de, &it, stat);
2217 }
2218
2219 #ifdef HAVE_LINUX_FIEMAP_H
2220 int ll_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
2221                 __u64 start, __u64 len)
2222 {
2223         int rc;
2224         size_t num_bytes;
2225         struct ll_user_fiemap *fiemap;
2226         unsigned int extent_count = fieinfo->fi_extents_max;
2227
2228         num_bytes = sizeof(*fiemap) + (extent_count *
2229                                        sizeof(struct ll_fiemap_extent));
2230         OBD_VMALLOC(fiemap, num_bytes);
2231
2232         if (fiemap == NULL)
2233                 RETURN(-ENOMEM);
2234
2235         fiemap->fm_flags = fieinfo->fi_flags;
2236         fiemap->fm_extent_count = fieinfo->fi_extents_max;
2237         fiemap->fm_start = start;
2238         fiemap->fm_length = len;
2239         memcpy(&fiemap->fm_extents[0], fieinfo->fi_extents_start,
2240                sizeof(struct ll_fiemap_extent));
2241
2242         rc = ll_do_fiemap(inode, fiemap, num_bytes);
2243
2244         fieinfo->fi_flags = fiemap->fm_flags;
2245         fieinfo->fi_extents_mapped = fiemap->fm_mapped_extents;
2246         memcpy(fieinfo->fi_extents_start, &fiemap->fm_extents[0],
2247                fiemap->fm_mapped_extents * sizeof(struct ll_fiemap_extent));
2248
2249         OBD_VFREE(fiemap, num_bytes);
2250         return rc;
2251 }
2252 #endif
2253
2254
2255 static
2256 int lustre_check_acl(struct inode *inode, int mask)
2257 {
2258 #ifdef CONFIG_FS_POSIX_ACL
2259         struct ll_inode_info *lli = ll_i2info(inode);
2260         struct posix_acl *acl;
2261         int rc;
2262         ENTRY;
2263
2264         cfs_spin_lock(&lli->lli_lock);
2265         acl = posix_acl_dup(lli->lli_posix_acl);
2266         cfs_spin_unlock(&lli->lli_lock);
2267
2268         if (!acl)
2269                 RETURN(-EAGAIN);
2270
2271         rc = posix_acl_permission(inode, acl, mask);
2272         posix_acl_release(acl);
2273
2274         RETURN(rc);
2275 #else
2276         return -EAGAIN;
2277 #endif
2278 }
2279
2280 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10))
2281 #ifndef HAVE_INODE_PERMISION_2ARGS
2282 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2283 #else
2284 int ll_inode_permission(struct inode *inode, int mask)
2285 #endif
2286 {
2287         int rc = 0;
2288         ENTRY;
2289
2290        /* as root inode are NOT getting validated in lookup operation,
2291         * need to do it before permission check. */
2292
2293         if (inode == inode->i_sb->s_root->d_inode) {
2294                 struct lookup_intent it = { .it_op = IT_LOOKUP };
2295
2296                 rc = __ll_inode_revalidate_it(inode->i_sb->s_root, &it,
2297                                               MDS_INODELOCK_LOOKUP);
2298                 if (rc)
2299                         RETURN(rc);
2300         }
2301
2302         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
2303                inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
2304
2305         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2306                 return lustre_check_remote_perm(inode, mask);
2307
2308         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2309         rc = generic_permission(inode, mask, lustre_check_acl);
2310
2311         RETURN(rc);
2312 }
2313 #else
2314 int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
2315 {
2316         int mode = inode->i_mode;
2317         int rc;
2318
2319         CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), mask %o\n",
2320                inode->i_ino, inode->i_generation, inode, mask);
2321
2322         if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
2323                 return lustre_check_remote_perm(inode, mask);
2324
2325         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_INODE_PERM, 1);
2326
2327         if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
2328             (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
2329                 return -EROFS;
2330         if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
2331                 return -EACCES;
2332         if (current->fsuid == inode->i_uid) {
2333                 mode >>= 6;
2334         } else if (1) {
2335                 if (((mode >> 3) & mask & S_IRWXO) != mask)
2336                         goto check_groups;
2337                 rc = lustre_check_acl(inode, mask);
2338                 if (rc == -EAGAIN)
2339                         goto check_groups;
2340                 if (rc == -EACCES)
2341                         goto check_capabilities;
2342                 return rc;
2343         } else {
2344 check_groups:
2345                 if (cfs_curproc_is_in_groups(inode->i_gid))
2346                         mode >>= 3;
2347         }
2348         if ((mode & mask & S_IRWXO) == mask)
2349                 return 0;
2350
2351 check_capabilities:
2352         if (!(mask & MAY_EXEC) ||
2353             (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
2354                 if (cfs_capable(CFS_CAP_DAC_OVERRIDE))
2355                         return 0;
2356
2357         if (cfs_capable(CFS_CAP_DAC_READ_SEARCH) && ((mask == MAY_READ) ||
2358             (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE))))
2359                 return 0;
2360
2361         return -EACCES;
2362 }
2363 #endif
2364
2365 #ifdef HAVE_FILE_READV
2366 #define READ_METHOD readv
2367 #define READ_FUNCTION ll_file_readv
2368 #define WRITE_METHOD writev
2369 #define WRITE_FUNCTION ll_file_writev
2370 #else
2371 #define READ_METHOD aio_read
2372 #define READ_FUNCTION ll_file_aio_read
2373 #define WRITE_METHOD aio_write
2374 #define WRITE_FUNCTION ll_file_aio_write
2375 #endif
2376
2377 /* -o localflock - only provides locally consistent flock locks */
2378 struct file_operations ll_file_operations = {
2379         .read           = ll_file_read,
2380         .READ_METHOD    = READ_FUNCTION,
2381         .write          = ll_file_write,
2382         .WRITE_METHOD   = WRITE_FUNCTION,
2383         .ioctl          = ll_file_ioctl,
2384         .open           = ll_file_open,
2385         .release        = ll_file_release,
2386         .mmap           = ll_file_mmap,
2387         .llseek         = ll_file_seek,
2388 #ifdef HAVE_KERNEL_SENDFILE
2389         .sendfile       = ll_file_sendfile,
2390 #endif
2391 #ifdef HAVE_KERNEL_SPLICE_READ
2392         .splice_read    = ll_file_splice_read,
2393 #endif
2394         .fsync          = ll_fsync,
2395 };
2396
2397 struct file_operations ll_file_operations_flock = {
2398         .read           = ll_file_read,
2399         .READ_METHOD    = READ_FUNCTION,
2400         .write          = ll_file_write,
2401         .WRITE_METHOD   = WRITE_FUNCTION,
2402         .ioctl          = ll_file_ioctl,
2403         .open           = ll_file_open,
2404         .release        = ll_file_release,
2405         .mmap           = ll_file_mmap,
2406         .llseek         = ll_file_seek,
2407 #ifdef HAVE_KERNEL_SENDFILE
2408         .sendfile       = ll_file_sendfile,
2409 #endif
2410 #ifdef HAVE_KERNEL_SPLICE_READ
2411         .splice_read    = ll_file_splice_read,
2412 #endif
2413         .fsync          = ll_fsync,
2414 #ifdef HAVE_F_OP_FLOCK
2415         .flock          = ll_file_flock,
2416 #endif
2417         .lock           = ll_file_flock
2418 };
2419
2420 /* These are for -o noflock - to return ENOSYS on flock calls */
2421 struct file_operations ll_file_operations_noflock = {
2422         .read           = ll_file_read,
2423         .READ_METHOD    = READ_FUNCTION,
2424         .write          = ll_file_write,
2425         .WRITE_METHOD   = WRITE_FUNCTION,
2426         .ioctl          = ll_file_ioctl,
2427         .open           = ll_file_open,
2428         .release        = ll_file_release,
2429         .mmap           = ll_file_mmap,
2430         .llseek         = ll_file_seek,
2431 #ifdef HAVE_KERNEL_SENDFILE
2432         .sendfile       = ll_file_sendfile,
2433 #endif
2434 #ifdef HAVE_KERNEL_SPLICE_READ
2435         .splice_read    = ll_file_splice_read,
2436 #endif
2437         .fsync          = ll_fsync,
2438 #ifdef HAVE_F_OP_FLOCK
2439         .flock          = ll_file_noflock,
2440 #endif
2441         .lock           = ll_file_noflock
2442 };
2443
2444 struct inode_operations ll_file_inode_operations = {
2445 #ifdef HAVE_VFS_INTENT_PATCHES
2446         .setattr_raw    = ll_setattr_raw,
2447 #endif
2448         .setattr        = ll_setattr,
2449         .truncate       = ll_truncate,
2450         .getattr        = ll_getattr,
2451         .permission     = ll_inode_permission,
2452         .setxattr       = ll_setxattr,
2453         .getxattr       = ll_getxattr,
2454         .listxattr      = ll_listxattr,
2455         .removexattr    = ll_removexattr,
2456 #ifdef  HAVE_LINUX_FIEMAP_H
2457         .fiemap         = ll_fiemap,
2458 #endif
2459 };
2460
2461 /* dynamic ioctl number support routins */
2462 static struct llioc_ctl_data {
2463         cfs_rw_semaphore_t      ioc_sem;
2464         cfs_list_t              ioc_head;
2465 } llioc = {
2466         __RWSEM_INITIALIZER(llioc.ioc_sem),
2467         CFS_LIST_HEAD_INIT(llioc.ioc_head)
2468 };
2469
2470
2471 struct llioc_data {
2472         cfs_list_t              iocd_list;
2473         unsigned int            iocd_size;
2474         llioc_callback_t        iocd_cb;
2475         unsigned int            iocd_count;
2476         unsigned int            iocd_cmd[0];
2477 };
2478
2479 void *ll_iocontrol_register(llioc_callback_t cb, int count, unsigned int *cmd)
2480 {
2481         unsigned int size;
2482         struct llioc_data *in_data = NULL;
2483         ENTRY;
2484
2485         if (cb == NULL || cmd == NULL ||
2486             count > LLIOC_MAX_CMD || count < 0)
2487                 RETURN(NULL);
2488
2489         size = sizeof(*in_data) + count * sizeof(unsigned int);
2490         OBD_ALLOC(in_data, size);
2491         if (in_data == NULL)
2492                 RETURN(NULL);
2493
2494         memset(in_data, 0, sizeof(*in_data));
2495         in_data->iocd_size = size;
2496         in_data->iocd_cb = cb;
2497         in_data->iocd_count = count;
2498         memcpy(in_data->iocd_cmd, cmd, sizeof(unsigned int) * count);
2499
2500         cfs_down_write(&llioc.ioc_sem);
2501         cfs_list_add_tail(&in_data->iocd_list, &llioc.ioc_head);
2502         cfs_up_write(&llioc.ioc_sem);
2503
2504         RETURN(in_data);
2505 }
2506
2507 void ll_iocontrol_unregister(void *magic)
2508 {
2509         struct llioc_data *tmp;
2510
2511         if (magic == NULL)
2512                 return;
2513
2514         cfs_down_write(&llioc.ioc_sem);
2515         cfs_list_for_each_entry(tmp, &llioc.ioc_head, iocd_list) {
2516                 if (tmp == magic) {
2517                         unsigned int size = tmp->iocd_size;
2518
2519                         cfs_list_del(&tmp->iocd_list);
2520                         cfs_up_write(&llioc.ioc_sem);
2521
2522                         OBD_FREE(tmp, size);
2523                         return;
2524                 }
2525         }
2526         cfs_up_write(&llioc.ioc_sem);
2527
2528         CWARN("didn't find iocontrol register block with magic: %p\n", magic);
2529 }
2530
2531 EXPORT_SYMBOL(ll_iocontrol_register);
2532 EXPORT_SYMBOL(ll_iocontrol_unregister);
2533
2534 enum llioc_iter ll_iocontrol_call(struct inode *inode, struct file *file,
2535                         unsigned int cmd, unsigned long arg, int *rcp)
2536 {
2537         enum llioc_iter ret = LLIOC_CONT;
2538         struct llioc_data *data;
2539         int rc = -EINVAL, i;
2540
2541         cfs_down_read(&llioc.ioc_sem);
2542         cfs_list_for_each_entry(data, &llioc.ioc_head, iocd_list) {
2543                 for (i = 0; i < data->iocd_count; i++) {
2544                         if (cmd != data->iocd_cmd[i])
2545                                 continue;
2546
2547                         ret = data->iocd_cb(inode, file, cmd, arg, data, &rc);
2548                         break;
2549                 }
2550
2551                 if (ret == LLIOC_STOP)
2552                         break;
2553         }
2554         cfs_up_read(&llioc.ioc_sem);
2555
2556         if (rcp)
2557                 *rcp = rc;
2558         return ret;
2559 }