Merge branch 'i915fb' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/intelf...
[linux-2.6] / fs / xfs / linux-2.6 / xfs_file.c
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_bit.h"
20 #include "xfs_log.h"
21 #include "xfs_inum.h"
22 #include "xfs_sb.h"
23 #include "xfs_ag.h"
24 #include "xfs_dir.h"
25 #include "xfs_dir2.h"
26 #include "xfs_trans.h"
27 #include "xfs_dmapi.h"
28 #include "xfs_mount.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_alloc_btree.h"
31 #include "xfs_ialloc_btree.h"
32 #include "xfs_alloc.h"
33 #include "xfs_btree.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dir_sf.h"
36 #include "xfs_dir2_sf.h"
37 #include "xfs_dinode.h"
38 #include "xfs_inode.h"
39 #include "xfs_error.h"
40 #include "xfs_rw.h"
41 #include "xfs_ioctl32.h"
42
43 #include <linux/dcache.h>
44 #include <linux/smp_lock.h>
45
46 static struct vm_operations_struct xfs_file_vm_ops;
47 #ifdef CONFIG_XFS_DMAPI
48 static struct vm_operations_struct xfs_dmapi_file_vm_ops;
49 #endif
50
51 STATIC inline ssize_t
52 __xfs_file_read(
53         struct kiocb            *iocb,
54         char                    __user *buf,
55         int                     ioflags,
56         size_t                  count,
57         loff_t                  pos)
58 {
59         struct iovec            iov = {buf, count};
60         struct file             *file = iocb->ki_filp;
61         vnode_t                 *vp = vn_from_inode(file->f_dentry->d_inode);
62         ssize_t                 rval;
63
64         BUG_ON(iocb->ki_pos != pos);
65
66         if (unlikely(file->f_flags & O_DIRECT))
67                 ioflags |= IO_ISDIRECT;
68         VOP_READ(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
69         return rval;
70 }
71
72 STATIC ssize_t
73 xfs_file_aio_read(
74         struct kiocb            *iocb,
75         char                    __user *buf,
76         size_t                  count,
77         loff_t                  pos)
78 {
79         return __xfs_file_read(iocb, buf, IO_ISAIO, count, pos);
80 }
81
82 STATIC ssize_t
83 xfs_file_aio_read_invis(
84         struct kiocb            *iocb,
85         char                    __user *buf,
86         size_t                  count,
87         loff_t                  pos)
88 {
89         return __xfs_file_read(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
90 }
91
92 STATIC inline ssize_t
93 __xfs_file_write(
94         struct kiocb    *iocb,
95         const char      __user *buf,
96         int             ioflags,
97         size_t          count,
98         loff_t          pos)
99 {
100         struct iovec    iov = {(void __user *)buf, count};
101         struct file     *file = iocb->ki_filp;
102         struct inode    *inode = file->f_mapping->host;
103         vnode_t         *vp = vn_from_inode(inode);
104         ssize_t         rval;
105
106         BUG_ON(iocb->ki_pos != pos);
107         if (unlikely(file->f_flags & O_DIRECT))
108                 ioflags |= IO_ISDIRECT;
109
110         VOP_WRITE(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
111         return rval;
112 }
113
114 STATIC ssize_t
115 xfs_file_aio_write(
116         struct kiocb            *iocb,
117         const char              __user *buf,
118         size_t                  count,
119         loff_t                  pos)
120 {
121         return __xfs_file_write(iocb, buf, IO_ISAIO, count, pos);
122 }
123
124 STATIC ssize_t
125 xfs_file_aio_write_invis(
126         struct kiocb            *iocb,
127         const char              __user *buf,
128         size_t                  count,
129         loff_t                  pos)
130 {
131         return __xfs_file_write(iocb, buf, IO_ISAIO|IO_INVIS, count, pos);
132 }
133
134 STATIC inline ssize_t
135 __xfs_file_readv(
136         struct file             *file,
137         const struct iovec      *iov,
138         int                     ioflags,
139         unsigned long           nr_segs,
140         loff_t                  *ppos)
141 {
142         struct inode    *inode = file->f_mapping->host;
143         vnode_t         *vp = vn_from_inode(inode);
144         struct kiocb    kiocb;
145         ssize_t         rval;
146
147         init_sync_kiocb(&kiocb, file);
148         kiocb.ki_pos = *ppos;
149
150         if (unlikely(file->f_flags & O_DIRECT))
151                 ioflags |= IO_ISDIRECT;
152         VOP_READ(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
153
154         *ppos = kiocb.ki_pos;
155         return rval;
156 }
157
158 STATIC ssize_t
159 xfs_file_readv(
160         struct file             *file,
161         const struct iovec      *iov,
162         unsigned long           nr_segs,
163         loff_t                  *ppos)
164 {
165         return __xfs_file_readv(file, iov, 0, nr_segs, ppos);
166 }
167
168 STATIC ssize_t
169 xfs_file_readv_invis(
170         struct file             *file,
171         const struct iovec      *iov,
172         unsigned long           nr_segs,
173         loff_t                  *ppos)
174 {
175         return __xfs_file_readv(file, iov, IO_INVIS, nr_segs, ppos);
176 }
177
178 STATIC inline ssize_t
179 __xfs_file_writev(
180         struct file             *file,
181         const struct iovec      *iov,
182         int                     ioflags,
183         unsigned long           nr_segs,
184         loff_t                  *ppos)
185 {
186         struct inode    *inode = file->f_mapping->host;
187         vnode_t         *vp = vn_from_inode(inode);
188         struct kiocb    kiocb;
189         ssize_t         rval;
190
191         init_sync_kiocb(&kiocb, file);
192         kiocb.ki_pos = *ppos;
193         if (unlikely(file->f_flags & O_DIRECT))
194                 ioflags |= IO_ISDIRECT;
195
196         VOP_WRITE(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
197
198         *ppos = kiocb.ki_pos;
199         return rval;
200 }
201
202 STATIC ssize_t
203 xfs_file_writev(
204         struct file             *file,
205         const struct iovec      *iov,
206         unsigned long           nr_segs,
207         loff_t                  *ppos)
208 {
209         return __xfs_file_writev(file, iov, 0, nr_segs, ppos);
210 }
211
212 STATIC ssize_t
213 xfs_file_writev_invis(
214         struct file             *file,
215         const struct iovec      *iov,
216         unsigned long           nr_segs,
217         loff_t                  *ppos)
218 {
219         return __xfs_file_writev(file, iov, IO_INVIS, nr_segs, ppos);
220 }
221
222 STATIC ssize_t
223 xfs_file_sendfile(
224         struct file             *filp,
225         loff_t                  *pos,
226         size_t                  count,
227         read_actor_t            actor,
228         void                    *target)
229 {
230         vnode_t                 *vp = vn_from_inode(filp->f_dentry->d_inode);
231         ssize_t                 rval;
232
233         VOP_SENDFILE(vp, filp, pos, 0, count, actor, target, NULL, rval);
234         return rval;
235 }
236
237 STATIC ssize_t
238 xfs_file_sendfile_invis(
239         struct file             *filp,
240         loff_t                  *pos,
241         size_t                  count,
242         read_actor_t            actor,
243         void                    *target)
244 {
245         vnode_t                 *vp = vn_from_inode(filp->f_dentry->d_inode);
246         ssize_t                 rval;
247
248         VOP_SENDFILE(vp, filp, pos, IO_INVIS, count, actor, target, NULL, rval);
249         return rval;
250 }
251
252 STATIC ssize_t
253 xfs_file_splice_read(
254         struct file             *infilp,
255         loff_t                  *ppos,
256         struct pipe_inode_info  *pipe,
257         size_t                  len,
258         unsigned int            flags)
259 {
260         vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
261         ssize_t                 rval;
262
263         VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, 0, NULL, rval);
264         return rval;
265 }
266
267 STATIC ssize_t
268 xfs_file_splice_read_invis(
269         struct file             *infilp,
270         loff_t                  *ppos,
271         struct pipe_inode_info  *pipe,
272         size_t                  len,
273         unsigned int            flags)
274 {
275         vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
276         ssize_t                 rval;
277
278         VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, IO_INVIS, NULL, rval);
279         return rval;
280 }
281
282 STATIC ssize_t
283 xfs_file_splice_write(
284         struct pipe_inode_info  *pipe,
285         struct file             *outfilp,
286         loff_t                  *ppos,
287         size_t                  len,
288         unsigned int            flags)
289 {
290         vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
291         ssize_t                 rval;
292
293         VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, 0, NULL, rval);
294         return rval;
295 }
296
297 STATIC ssize_t
298 xfs_file_splice_write_invis(
299         struct pipe_inode_info  *pipe,
300         struct file             *outfilp,
301         loff_t                  *ppos,
302         size_t                  len,
303         unsigned int            flags)
304 {
305         vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
306         ssize_t                 rval;
307
308         VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, IO_INVIS, NULL, rval);
309         return rval;
310 }
311
312 STATIC int
313 xfs_file_open(
314         struct inode    *inode,
315         struct file     *filp)
316 {
317         vnode_t         *vp = vn_from_inode(inode);
318         int             error;
319
320         if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
321                 return -EFBIG;
322         VOP_OPEN(vp, NULL, error);
323         return -error;
324 }
325
326 STATIC int
327 xfs_file_release(
328         struct inode    *inode,
329         struct file     *filp)
330 {
331         vnode_t         *vp = vn_from_inode(inode);
332         int             error = 0;
333
334         if (vp)
335                 VOP_RELEASE(vp, error);
336         return -error;
337 }
338
339 STATIC int
340 xfs_file_fsync(
341         struct file     *filp,
342         struct dentry   *dentry,
343         int             datasync)
344 {
345         struct inode    *inode = dentry->d_inode;
346         vnode_t         *vp = vn_from_inode(inode);
347         int             error;
348         int             flags = FSYNC_WAIT;
349
350         if (datasync)
351                 flags |= FSYNC_DATA;
352         VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
353         return -error;
354 }
355
356 #ifdef CONFIG_XFS_DMAPI
357 STATIC struct page *
358 xfs_vm_nopage(
359         struct vm_area_struct   *area,
360         unsigned long           address,
361         int                     *type)
362 {
363         struct inode    *inode = area->vm_file->f_dentry->d_inode;
364         vnode_t         *vp = vn_from_inode(inode);
365         xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
366         int             error;
367
368         ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
369
370         error = XFS_SEND_MMAP(mp, area, 0);
371         if (error)
372                 return NULL;
373
374         return filemap_nopage(area, address, type);
375 }
376 #endif /* CONFIG_XFS_DMAPI */
377
378 STATIC int
379 xfs_file_readdir(
380         struct file     *filp,
381         void            *dirent,
382         filldir_t       filldir)
383 {
384         int             error = 0;
385         vnode_t         *vp = vn_from_inode(filp->f_dentry->d_inode);
386         uio_t           uio;
387         iovec_t         iov;
388         int             eof = 0;
389         caddr_t         read_buf;
390         int             namelen, size = 0;
391         size_t          rlen = PAGE_CACHE_SIZE;
392         xfs_off_t       start_offset, curr_offset;
393         xfs_dirent_t    *dbp = NULL;
394
395         /* Try fairly hard to get memory */
396         do {
397                 if ((read_buf = (caddr_t)kmalloc(rlen, GFP_KERNEL)))
398                         break;
399                 rlen >>= 1;
400         } while (rlen >= 1024);
401
402         if (read_buf == NULL)
403                 return -ENOMEM;
404
405         uio.uio_iov = &iov;
406         uio.uio_segflg = UIO_SYSSPACE;
407         curr_offset = filp->f_pos;
408         if (filp->f_pos != 0x7fffffff)
409                 uio.uio_offset = filp->f_pos;
410         else
411                 uio.uio_offset = 0xffffffff;
412
413         while (!eof) {
414                 uio.uio_resid = iov.iov_len = rlen;
415                 iov.iov_base = read_buf;
416                 uio.uio_iovcnt = 1;
417
418                 start_offset = uio.uio_offset;
419
420                 VOP_READDIR(vp, &uio, NULL, &eof, error);
421                 if ((uio.uio_offset == start_offset) || error) {
422                         size = 0;
423                         break;
424                 }
425
426                 size = rlen - uio.uio_resid;
427                 dbp = (xfs_dirent_t *)read_buf;
428                 while (size > 0) {
429                         namelen = strlen(dbp->d_name);
430
431                         if (filldir(dirent, dbp->d_name, namelen,
432                                         (loff_t) curr_offset & 0x7fffffff,
433                                         (ino_t) dbp->d_ino,
434                                         DT_UNKNOWN)) {
435                                 goto done;
436                         }
437                         size -= dbp->d_reclen;
438                         curr_offset = (loff_t)dbp->d_off /* & 0x7fffffff */;
439                         dbp = (xfs_dirent_t *)((char *)dbp + dbp->d_reclen);
440                 }
441         }
442 done:
443         if (!error) {
444                 if (size == 0)
445                         filp->f_pos = uio.uio_offset & 0x7fffffff;
446                 else if (dbp)
447                         filp->f_pos = curr_offset;
448         }
449
450         kfree(read_buf);
451         return -error;
452 }
453
454 STATIC int
455 xfs_file_mmap(
456         struct file     *filp,
457         struct vm_area_struct *vma)
458 {
459         struct inode    *ip = filp->f_dentry->d_inode;
460         vnode_t         *vp = vn_from_inode(ip);
461         vattr_t         vattr;
462         int             error;
463
464         vma->vm_ops = &xfs_file_vm_ops;
465
466 #ifdef CONFIG_XFS_DMAPI
467         if (vp->v_vfsp->vfs_flag & VFS_DMI) {
468                 vma->vm_ops = &xfs_dmapi_file_vm_ops;
469         }
470 #endif /* CONFIG_XFS_DMAPI */
471
472         vattr.va_mask = XFS_AT_UPDATIME;
473         VOP_SETATTR(vp, &vattr, XFS_AT_UPDATIME, NULL, error);
474         if (likely(!error))
475                 __vn_revalidate(vp, &vattr);    /* update flags */
476         return 0;
477 }
478
479
480 STATIC long
481 xfs_file_ioctl(
482         struct file     *filp,
483         unsigned int    cmd,
484         unsigned long   arg)
485 {
486         int             error;
487         struct inode    *inode = filp->f_dentry->d_inode;
488         vnode_t         *vp = vn_from_inode(inode);
489
490         VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
491         VMODIFY(vp);
492
493         /* NOTE:  some of the ioctl's return positive #'s as a
494          *        byte count indicating success, such as
495          *        readlink_by_handle.  So we don't "sign flip"
496          *        like most other routines.  This means true
497          *        errors need to be returned as a negative value.
498          */
499         return error;
500 }
501
502 STATIC long
503 xfs_file_ioctl_invis(
504         struct file     *filp,
505         unsigned int    cmd,
506         unsigned long   arg)
507 {
508         struct inode    *inode = filp->f_dentry->d_inode;
509         vnode_t         *vp = vn_from_inode(inode);
510         int             error;
511
512         VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
513         VMODIFY(vp);
514
515         /* NOTE:  some of the ioctl's return positive #'s as a
516          *        byte count indicating success, such as
517          *        readlink_by_handle.  So we don't "sign flip"
518          *        like most other routines.  This means true
519          *        errors need to be returned as a negative value.
520          */
521         return error;
522 }
523
524 #ifdef CONFIG_XFS_DMAPI
525 #ifdef HAVE_VMOP_MPROTECT
526 STATIC int
527 xfs_vm_mprotect(
528         struct vm_area_struct *vma,
529         unsigned int    newflags)
530 {
531         vnode_t         *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
532         int             error = 0;
533
534         if (vp->v_vfsp->vfs_flag & VFS_DMI) {
535                 if ((vma->vm_flags & VM_MAYSHARE) &&
536                     (newflags & VM_WRITE) && !(vma->vm_flags & VM_WRITE)) {
537                         xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
538
539                         error = XFS_SEND_MMAP(mp, vma, VM_WRITE);
540                     }
541         }
542         return error;
543 }
544 #endif /* HAVE_VMOP_MPROTECT */
545 #endif /* CONFIG_XFS_DMAPI */
546
547 #ifdef HAVE_FOP_OPEN_EXEC
548 /* If the user is attempting to execute a file that is offline then
549  * we have to trigger a DMAPI READ event before the file is marked as busy
550  * otherwise the invisible I/O will not be able to write to the file to bring
551  * it back online.
552  */
553 STATIC int
554 xfs_file_open_exec(
555         struct inode    *inode)
556 {
557         vnode_t         *vp = vn_from_inode(inode);
558         xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
559         int             error = 0;
560         xfs_inode_t     *ip;
561
562         if (vp->v_vfsp->vfs_flag & VFS_DMI) {
563                 ip = xfs_vtoi(vp);
564                 if (!ip) {
565                         error = -EINVAL;
566                         goto open_exec_out;
567                 }
568                 if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ)) {
569                         error = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
570                                                0, 0, 0, NULL);
571                 }
572         }
573 open_exec_out:
574         return error;
575 }
576 #endif /* HAVE_FOP_OPEN_EXEC */
577
578 const struct file_operations xfs_file_operations = {
579         .llseek         = generic_file_llseek,
580         .read           = do_sync_read,
581         .write          = do_sync_write,
582         .readv          = xfs_file_readv,
583         .writev         = xfs_file_writev,
584         .aio_read       = xfs_file_aio_read,
585         .aio_write      = xfs_file_aio_write,
586         .sendfile       = xfs_file_sendfile,
587         .splice_read    = xfs_file_splice_read,
588         .splice_write   = xfs_file_splice_write,
589         .unlocked_ioctl = xfs_file_ioctl,
590 #ifdef CONFIG_COMPAT
591         .compat_ioctl   = xfs_file_compat_ioctl,
592 #endif
593         .mmap           = xfs_file_mmap,
594         .open           = xfs_file_open,
595         .release        = xfs_file_release,
596         .fsync          = xfs_file_fsync,
597 #ifdef HAVE_FOP_OPEN_EXEC
598         .open_exec      = xfs_file_open_exec,
599 #endif
600 };
601
602 const struct file_operations xfs_invis_file_operations = {
603         .llseek         = generic_file_llseek,
604         .read           = do_sync_read,
605         .write          = do_sync_write,
606         .readv          = xfs_file_readv_invis,
607         .writev         = xfs_file_writev_invis,
608         .aio_read       = xfs_file_aio_read_invis,
609         .aio_write      = xfs_file_aio_write_invis,
610         .sendfile       = xfs_file_sendfile_invis,
611         .splice_read    = xfs_file_splice_read_invis,
612         .splice_write   = xfs_file_splice_write_invis,
613         .unlocked_ioctl = xfs_file_ioctl_invis,
614 #ifdef CONFIG_COMPAT
615         .compat_ioctl   = xfs_file_compat_invis_ioctl,
616 #endif
617         .mmap           = xfs_file_mmap,
618         .open           = xfs_file_open,
619         .release        = xfs_file_release,
620         .fsync          = xfs_file_fsync,
621 };
622
623
624 const struct file_operations xfs_dir_file_operations = {
625         .read           = generic_read_dir,
626         .readdir        = xfs_file_readdir,
627         .unlocked_ioctl = xfs_file_ioctl,
628 #ifdef CONFIG_COMPAT
629         .compat_ioctl   = xfs_file_compat_ioctl,
630 #endif
631         .fsync          = xfs_file_fsync,
632 };
633
634 static struct vm_operations_struct xfs_file_vm_ops = {
635         .nopage         = filemap_nopage,
636         .populate       = filemap_populate,
637 };
638
639 #ifdef CONFIG_XFS_DMAPI
640 static struct vm_operations_struct xfs_dmapi_file_vm_ops = {
641         .nopage         = xfs_vm_nopage,
642         .populate       = filemap_populate,
643 #ifdef HAVE_VMOP_MPROTECT
644         .mprotect       = xfs_vm_mprotect,
645 #endif
646 };
647 #endif /* CONFIG_XFS_DMAPI */