include upstream ip1000a driver version 2.09f
[linux-2.4.git] / fs / ncpfs / mmap.c
1 /*
2  *  mmap.c
3  *
4  *  Copyright (C) 1995, 1996 by Volker Lendecke
5  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
6  *
7  */
8
9 #include <linux/stat.h>
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/mm.h>
13 #include <linux/shm.h>
14 #include <linux/errno.h>
15 #include <linux/mman.h>
16 #include <linux/string.h>
17 #include <linux/slab.h>
18 #include <linux/fcntl.h>
19 #include <linux/ncp_fs.h>
20
21 #include "ncplib_kernel.h"
22 #include <asm/uaccess.h>
23 #include <asm/system.h>
24
25 /*
26  * Fill in the supplied page for mmap
27  */
28 static struct page* ncp_file_mmap_nopage(struct vm_area_struct *area,
29                                      unsigned long address, int write_access)
30 {
31         struct file *file = area->vm_file;
32         struct dentry *dentry = file->f_dentry;
33         struct inode *inode = dentry->d_inode;
34         struct page* page;
35         char *pg_addr;
36         unsigned int already_read;
37         unsigned int count;
38         int bufsize;
39         int pos;
40
41         page = alloc_page(GFP_HIGHUSER); /* ncpfs has nothing against high pages
42                    as long as recvmsg and memset works on it */
43         if (!page)
44                 return page;
45         pg_addr = kmap(page);
46         address &= PAGE_MASK;
47         pos = address - area->vm_start + (area->vm_pgoff << PAGE_SHIFT);
48
49         count = PAGE_SIZE;
50         if (address + PAGE_SIZE > area->vm_end) {
51                 count = area->vm_end - address;
52         }
53         /* what we can read in one go */
54         bufsize = NCP_SERVER(inode)->buffer_size;
55
56         already_read = 0;
57         if (ncp_make_open(inode, O_RDONLY) >= 0) {
58                 while (already_read < count) {
59                         int read_this_time;
60                         int to_read;
61
62                         to_read = bufsize - (pos % bufsize);
63
64                         to_read = min_t(unsigned int, to_read, count - already_read);
65
66                         if (ncp_read_kernel(NCP_SERVER(inode),
67                                      NCP_FINFO(inode)->file_handle,
68                                      pos, to_read,
69                                      pg_addr + already_read,
70                                      &read_this_time) != 0) {
71                                 read_this_time = 0;
72                         }
73                         pos += read_this_time;
74                         already_read += read_this_time;
75
76                         if (read_this_time < to_read) {
77                                 break;
78                         }
79                 }
80                 ncp_inode_close(inode);
81
82         }
83
84         if (already_read < PAGE_SIZE)
85                 memset(pg_addr + already_read, 0, PAGE_SIZE - already_read);
86         flush_dcache_page(page);
87         kunmap(page);
88         return page;
89 }
90
91 static struct vm_operations_struct ncp_file_mmap =
92 {
93         nopage: ncp_file_mmap_nopage,
94 };
95
96
97 /* This is used for a general mmap of a ncp file */
98 int ncp_mmap(struct file *file, struct vm_area_struct *vma)
99 {
100         struct inode *inode = file->f_dentry->d_inode;
101         
102         DPRINTK("ncp_mmap: called\n");
103
104         if (!ncp_conn_valid(NCP_SERVER(inode))) {
105                 return -EIO;
106         }
107         /* only PAGE_COW or read-only supported now */
108         if (vma->vm_flags & VM_SHARED)
109                 return -EINVAL;
110         if (!inode->i_sb || !S_ISREG(inode->i_mode))
111                 return -EACCES;
112         /* we do not support files bigger than 4GB... We eventually 
113            supports just 4GB... */
114         if (((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff 
115            > (1U << (32 - PAGE_SHIFT)))
116                 return -EFBIG;
117         if (!IS_RDONLY(inode)) {
118                 inode->i_atime = CURRENT_TIME;
119         }
120
121         vma->vm_ops = &ncp_file_mmap;
122         return 0;
123 }