Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[linux-3.10.git] / fs / minix / dir.c
1 /*
2  *  linux/fs/minix/dir.c
3  *
4  *  Copyright (C) 1991, 1992 Linus Torvalds
5  *
6  *  minix directory handling functions
7  *
8  *  Updated to filesystem version 3 by Daniel Aragones
9  */
10
11 #include "minix.h"
12 #include <linux/buffer_head.h>
13 #include <linux/highmem.h>
14 #include <linux/swap.h>
15
16 typedef struct minix_dir_entry minix_dirent;
17 typedef struct minix3_dir_entry minix3_dirent;
18
19 static int minix_readdir(struct file *, void *, filldir_t);
20
21 const struct file_operations minix_dir_operations = {
22         .llseek         = generic_file_llseek,
23         .read           = generic_read_dir,
24         .readdir        = minix_readdir,
25         .fsync          = generic_file_fsync,
26 };
27
28 static inline void dir_put_page(struct page *page)
29 {
30         kunmap(page);
31         page_cache_release(page);
32 }
33
34 /*
35  * Return the offset into page `page_nr' of the last valid
36  * byte in that page, plus one.
37  */
38 static unsigned
39 minix_last_byte(struct inode *inode, unsigned long page_nr)
40 {
41         unsigned last_byte = PAGE_CACHE_SIZE;
42
43         if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT))
44                 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1);
45         return last_byte;
46 }
47
48 static inline unsigned long dir_pages(struct inode *inode)
49 {
50         return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
51 }
52
53 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
54 {
55         struct address_space *mapping = page->mapping;
56         struct inode *dir = mapping->host;
57         int err = 0;
58         block_write_end(NULL, mapping, pos, len, len, page, NULL);
59
60         if (pos+len > dir->i_size) {
61                 i_size_write(dir, pos+len);
62                 mark_inode_dirty(dir);
63         }
64         if (IS_DIRSYNC(dir))
65                 err = write_one_page(page, 1);
66         else
67                 unlock_page(page);
68         return err;
69 }
70
71 static struct page * dir_get_page(struct inode *dir, unsigned long n)
72 {
73         struct address_space *mapping = dir->i_mapping;
74         struct page *page = read_mapping_page(mapping, n, NULL);
75         if (!IS_ERR(page))
76                 kmap(page);
77         return page;
78 }
79
80 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
81 {
82         return (void*)((char*)de + sbi->s_dirsize);
83 }
84
85 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
86 {
87         unsigned long pos = filp->f_pos;
88         struct inode *inode = filp->f_path.dentry->d_inode;
89         struct super_block *sb = inode->i_sb;
90         unsigned offset = pos & ~PAGE_CACHE_MASK;
91         unsigned long n = pos >> PAGE_CACHE_SHIFT;
92         unsigned long npages = dir_pages(inode);
93         struct minix_sb_info *sbi = minix_sb(sb);
94         unsigned chunk_size = sbi->s_dirsize;
95         char *name;
96         __u32 inumber;
97
98         pos = (pos + chunk_size-1) & ~(chunk_size-1);
99         if (pos >= inode->i_size)
100                 goto done;
101
102         for ( ; n < npages; n++, offset = 0) {
103                 char *p, *kaddr, *limit;
104                 struct page *page = dir_get_page(inode, n);
105
106                 if (IS_ERR(page))
107                         continue;
108                 kaddr = (char *)page_address(page);
109                 p = kaddr+offset;
110                 limit = kaddr + minix_last_byte(inode, n) - chunk_size;
111                 for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
112                         if (sbi->s_version == MINIX_V3) {
113                                 minix3_dirent *de3 = (minix3_dirent *)p;
114                                 name = de3->name;
115                                 inumber = de3->inode;
116                         } else {
117                                 minix_dirent *de = (minix_dirent *)p;
118                                 name = de->name;
119                                 inumber = de->inode;
120                         }
121                         if (inumber) {
122                                 int over;
123
124                                 unsigned l = strnlen(name, sbi->s_namelen);
125                                 offset = p - kaddr;
126                                 over = filldir(dirent, name, l,
127                                         (n << PAGE_CACHE_SHIFT) | offset,
128                                         inumber, DT_UNKNOWN);
129                                 if (over) {
130                                         dir_put_page(page);
131                                         goto done;
132                                 }
133                         }
134                 }
135                 dir_put_page(page);
136         }
137
138 done:
139         filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
140         return 0;
141 }
142
143 static inline int namecompare(int len, int maxlen,
144         const char * name, const char * buffer)
145 {
146         if (len < maxlen && buffer[len])
147                 return 0;
148         return !memcmp(name, buffer, len);
149 }
150
151 /*
152  *      minix_find_entry()
153  *
154  * finds an entry in the specified directory with the wanted name. It
155  * returns the cache buffer in which the entry was found, and the entry
156  * itself (as a parameter - res_dir). It does NOT read the inode of the
157  * entry - you'll have to do that yourself if you want to.
158  */
159 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
160 {
161         const char * name = dentry->d_name.name;
162         int namelen = dentry->d_name.len;
163         struct inode * dir = dentry->d_parent->d_inode;
164         struct super_block * sb = dir->i_sb;
165         struct minix_sb_info * sbi = minix_sb(sb);
166         unsigned long n;
167         unsigned long npages = dir_pages(dir);
168         struct page *page = NULL;
169         char *p;
170
171         char *namx;
172         __u32 inumber;
173         *res_page = NULL;
174
175         for (n = 0; n < npages; n++) {
176                 char *kaddr, *limit;
177
178                 page = dir_get_page(dir, n);
179                 if (IS_ERR(page))
180                         continue;
181
182                 kaddr = (char*)page_address(page);
183                 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;
184                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
185                         if (sbi->s_version == MINIX_V3) {
186                                 minix3_dirent *de3 = (minix3_dirent *)p;
187                                 namx = de3->name;
188                                 inumber = de3->inode;
189                         } else {
190                                 minix_dirent *de = (minix_dirent *)p;
191                                 namx = de->name;
192                                 inumber = de->inode;
193                         }
194                         if (!inumber)
195                                 continue;
196                         if (namecompare(namelen, sbi->s_namelen, name, namx))
197                                 goto found;
198                 }
199                 dir_put_page(page);
200         }
201         return NULL;
202
203 found:
204         *res_page = page;
205         return (minix_dirent *)p;
206 }
207
208 int minix_add_link(struct dentry *dentry, struct inode *inode)
209 {
210         struct inode *dir = dentry->d_parent->d_inode;
211         const char * name = dentry->d_name.name;
212         int namelen = dentry->d_name.len;
213         struct super_block * sb = dir->i_sb;
214         struct minix_sb_info * sbi = minix_sb(sb);
215         struct page *page = NULL;
216         unsigned long npages = dir_pages(dir);
217         unsigned long n;
218         char *kaddr, *p;
219         minix_dirent *de;
220         minix3_dirent *de3;
221         loff_t pos;
222         int err;
223         char *namx = NULL;
224         __u32 inumber;
225
226         /*
227          * We take care of directory expansion in the same loop
228          * This code plays outside i_size, so it locks the page
229          * to protect that region.
230          */
231         for (n = 0; n <= npages; n++) {
232                 char *limit, *dir_end;
233
234                 page = dir_get_page(dir, n);
235                 err = PTR_ERR(page);
236                 if (IS_ERR(page))
237                         goto out;
238                 lock_page(page);
239                 kaddr = (char*)page_address(page);
240                 dir_end = kaddr + minix_last_byte(dir, n);
241                 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize;
242                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
243                         de = (minix_dirent *)p;
244                         de3 = (minix3_dirent *)p;
245                         if (sbi->s_version == MINIX_V3) {
246                                 namx = de3->name;
247                                 inumber = de3->inode;
248                         } else {
249                                 namx = de->name;
250                                 inumber = de->inode;
251                         }
252                         if (p == dir_end) {
253                                 /* We hit i_size */
254                                 if (sbi->s_version == MINIX_V3)
255                                         de3->inode = 0;
256                                 else
257                                         de->inode = 0;
258                                 goto got_it;
259                         }
260                         if (!inumber)
261                                 goto got_it;
262                         err = -EEXIST;
263                         if (namecompare(namelen, sbi->s_namelen, name, namx))
264                                 goto out_unlock;
265                 }
266                 unlock_page(page);
267                 dir_put_page(page);
268         }
269         BUG();
270         return -EINVAL;
271
272 got_it:
273         pos = page_offset(page) + p - (char *)page_address(page);
274         err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
275         if (err)
276                 goto out_unlock;
277         memcpy (namx, name, namelen);
278         if (sbi->s_version == MINIX_V3) {
279                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4);
280                 de3->inode = inode->i_ino;
281         } else {
282                 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2);
283                 de->inode = inode->i_ino;
284         }
285         err = dir_commit_chunk(page, pos, sbi->s_dirsize);
286         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
287         mark_inode_dirty(dir);
288 out_put:
289         dir_put_page(page);
290 out:
291         return err;
292 out_unlock:
293         unlock_page(page);
294         goto out_put;
295 }
296
297 int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
298 {
299         struct inode *inode = page->mapping->host;
300         char *kaddr = page_address(page);
301         loff_t pos = page_offset(page) + (char*)de - kaddr;
302         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
303         unsigned len = sbi->s_dirsize;
304         int err;
305
306         lock_page(page);
307         err = minix_prepare_chunk(page, pos, len);
308         if (err == 0) {
309                 if (sbi->s_version == MINIX_V3)
310                         ((minix3_dirent *) de)->inode = 0;
311                 else
312                         de->inode = 0;
313                 err = dir_commit_chunk(page, pos, len);
314         } else {
315                 unlock_page(page);
316         }
317         dir_put_page(page);
318         inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
319         mark_inode_dirty(inode);
320         return err;
321 }
322
323 int minix_make_empty(struct inode *inode, struct inode *dir)
324 {
325         struct page *page = grab_cache_page(inode->i_mapping, 0);
326         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
327         char *kaddr;
328         int err;
329
330         if (!page)
331                 return -ENOMEM;
332         err = minix_prepare_chunk(page, 0, 2 * sbi->s_dirsize);
333         if (err) {
334                 unlock_page(page);
335                 goto fail;
336         }
337
338         kaddr = kmap_atomic(page);
339         memset(kaddr, 0, PAGE_CACHE_SIZE);
340
341         if (sbi->s_version == MINIX_V3) {
342                 minix3_dirent *de3 = (minix3_dirent *)kaddr;
343
344                 de3->inode = inode->i_ino;
345                 strcpy(de3->name, ".");
346                 de3 = minix_next_entry(de3, sbi);
347                 de3->inode = dir->i_ino;
348                 strcpy(de3->name, "..");
349         } else {
350                 minix_dirent *de = (minix_dirent *)kaddr;
351
352                 de->inode = inode->i_ino;
353                 strcpy(de->name, ".");
354                 de = minix_next_entry(de, sbi);
355                 de->inode = dir->i_ino;
356                 strcpy(de->name, "..");
357         }
358         kunmap_atomic(kaddr);
359
360         err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
361 fail:
362         page_cache_release(page);
363         return err;
364 }
365
366 /*
367  * routine to check that the specified directory is empty (for rmdir)
368  */
369 int minix_empty_dir(struct inode * inode)
370 {
371         struct page *page = NULL;
372         unsigned long i, npages = dir_pages(inode);
373         struct minix_sb_info *sbi = minix_sb(inode->i_sb);
374         char *name;
375         __u32 inumber;
376
377         for (i = 0; i < npages; i++) {
378                 char *p, *kaddr, *limit;
379
380                 page = dir_get_page(inode, i);
381                 if (IS_ERR(page))
382                         continue;
383
384                 kaddr = (char *)page_address(page);
385                 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;
386                 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
387                         if (sbi->s_version == MINIX_V3) {
388                                 minix3_dirent *de3 = (minix3_dirent *)p;
389                                 name = de3->name;
390                                 inumber = de3->inode;
391                         } else {
392                                 minix_dirent *de = (minix_dirent *)p;
393                                 name = de->name;
394                                 inumber = de->inode;
395                         }
396
397                         if (inumber != 0) {
398                                 /* check for . and .. */
399                                 if (name[0] != '.')
400                                         goto not_empty;
401                                 if (!name[1]) {
402                                         if (inumber != inode->i_ino)
403                                                 goto not_empty;
404                                 } else if (name[1] != '.')
405                                         goto not_empty;
406                                 else if (name[2])
407                                         goto not_empty;
408                         }
409                 }
410                 dir_put_page(page);
411         }
412         return 1;
413
414 not_empty:
415         dir_put_page(page);
416         return 0;
417 }
418
419 /* Releases the page */
420 void minix_set_link(struct minix_dir_entry *de, struct page *page,
421         struct inode *inode)
422 {
423         struct inode *dir = page->mapping->host;
424         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
425         loff_t pos = page_offset(page) +
426                         (char *)de-(char*)page_address(page);
427         int err;
428
429         lock_page(page);
430
431         err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
432         if (err == 0) {
433                 if (sbi->s_version == MINIX_V3)
434                         ((minix3_dirent *) de)->inode = inode->i_ino;
435                 else
436                         de->inode = inode->i_ino;
437                 err = dir_commit_chunk(page, pos, sbi->s_dirsize);
438         } else {
439                 unlock_page(page);
440         }
441         dir_put_page(page);
442         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
443         mark_inode_dirty(dir);
444 }
445
446 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p)
447 {
448         struct page *page = dir_get_page(dir, 0);
449         struct minix_sb_info *sbi = minix_sb(dir->i_sb);
450         struct minix_dir_entry *de = NULL;
451
452         if (!IS_ERR(page)) {
453                 de = minix_next_entry(page_address(page), sbi);
454                 *p = page;
455         }
456         return de;
457 }
458
459 ino_t minix_inode_by_name(struct dentry *dentry)
460 {
461         struct page *page;
462         struct minix_dir_entry *de = minix_find_entry(dentry, &page);
463         ino_t res = 0;
464
465         if (de) {
466                 struct address_space *mapping = page->mapping;
467                 struct inode *inode = mapping->host;
468                 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
469
470                 if (sbi->s_version == MINIX_V3)
471                         res = ((minix3_dirent *) de)->inode;
472                 else
473                         res = de->inode;
474                 dir_put_page(page);
475         }
476         return res;
477 }