Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/minix/dir.c | |
3 | * | |
4 | * Copyright (C) 1991, 1992 Linus Torvalds | |
5 | * | |
6 | * minix directory handling functions | |
939b00df AB |
7 | * |
8 | * Updated to filesystem version 3 by Daniel Aragones | |
1da177e4 LT |
9 | */ |
10 | ||
11 | #include "minix.h" | |
4a66af9e | 12 | #include <linux/buffer_head.h> |
1da177e4 | 13 | #include <linux/highmem.h> |
4a66af9e | 14 | #include <linux/swap.h> |
1da177e4 LT |
15 | |
16 | typedef struct minix_dir_entry minix_dirent; | |
939b00df | 17 | typedef struct minix3_dir_entry minix3_dirent; |
1da177e4 LT |
18 | |
19 | static int minix_readdir(struct file *, void *, filldir_t); | |
20 | ||
4b6f5d20 | 21 | const struct file_operations minix_dir_operations = { |
cc46759a | 22 | .llseek = generic_file_llseek, |
1da177e4 LT |
23 | .read = generic_read_dir, |
24 | .readdir = minix_readdir, | |
1b061d92 | 25 | .fsync = generic_file_fsync, |
1da177e4 LT |
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 | ||
4a66af9e | 53 | static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len) |
1da177e4 | 54 | { |
4a66af9e NP |
55 | struct address_space *mapping = page->mapping; |
56 | struct inode *dir = mapping->host; | |
1da177e4 | 57 | int err = 0; |
4a66af9e NP |
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 | } | |
1da177e4 LT |
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; | |
090d2b18 | 74 | struct page *page = read_mapping_page(mapping, n, NULL); |
49837a80 | 75 | if (!IS_ERR(page)) |
1da177e4 | 76 | kmap(page); |
1da177e4 | 77 | return page; |
1da177e4 LT |
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; | |
dcf258ae | 88 | struct inode *inode = filp->f_path.dentry->d_inode; |
1da177e4 LT |
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; | |
939b00df AB |
95 | char *name; |
96 | __u32 inumber; | |
1da177e4 | 97 | |
1da177e4 LT |
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; | |
939b00df AB |
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) { | |
1da177e4 | 122 | int over; |
1da177e4 | 123 | |
939b00df | 124 | unsigned l = strnlen(name, sbi->s_namelen); |
1da177e4 | 125 | offset = p - kaddr; |
939b00df AB |
126 | over = filldir(dirent, name, l, |
127 | (n << PAGE_CACHE_SHIFT) | offset, | |
128 | inumber, DT_UNKNOWN); | |
1da177e4 LT |
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; | |
1da177e4 LT |
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; | |
939b00df | 169 | char *p; |
1da177e4 | 170 | |
939b00df AB |
171 | char *namx; |
172 | __u32 inumber; | |
1da177e4 LT |
173 | *res_page = NULL; |
174 | ||
175 | for (n = 0; n < npages; n++) { | |
939b00df AB |
176 | char *kaddr, *limit; |
177 | ||
1da177e4 LT |
178 | page = dir_get_page(dir, n); |
179 | if (IS_ERR(page)) | |
180 | continue; | |
181 | ||
182 | kaddr = (char*)page_address(page); | |
939b00df AB |
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) | |
1da177e4 | 195 | continue; |
939b00df | 196 | if (namecompare(namelen, sbi->s_namelen, name, namx)) |
1da177e4 LT |
197 | goto found; |
198 | } | |
199 | dir_put_page(page); | |
200 | } | |
201 | return NULL; | |
202 | ||
203 | found: | |
204 | *res_page = page; | |
939b00df | 205 | return (minix_dirent *)p; |
1da177e4 LT |
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; | |
1da177e4 LT |
216 | unsigned long npages = dir_pages(dir); |
217 | unsigned long n; | |
939b00df AB |
218 | char *kaddr, *p; |
219 | minix_dirent *de; | |
220 | minix3_dirent *de3; | |
4a66af9e | 221 | loff_t pos; |
1da177e4 | 222 | int err; |
939b00df AB |
223 | char *namx = NULL; |
224 | __u32 inumber; | |
1da177e4 LT |
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++) { | |
939b00df | 232 | char *limit, *dir_end; |
1da177e4 LT |
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); | |
939b00df AB |
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) { | |
1da177e4 | 253 | /* We hit i_size */ |
939b00df AB |
254 | if (sbi->s_version == MINIX_V3) |
255 | de3->inode = 0; | |
256 | else | |
257 | de->inode = 0; | |
1da177e4 LT |
258 | goto got_it; |
259 | } | |
939b00df | 260 | if (!inumber) |
1da177e4 LT |
261 | goto got_it; |
262 | err = -EEXIST; | |
939b00df | 263 | if (namecompare(namelen, sbi->s_namelen, name, namx)) |
1da177e4 | 264 | goto out_unlock; |
1da177e4 LT |
265 | } |
266 | unlock_page(page); | |
267 | dir_put_page(page); | |
268 | } | |
269 | BUG(); | |
270 | return -EINVAL; | |
271 | ||
272 | got_it: | |
d6b54841 | 273 | pos = page_offset(page) + p - (char *)page_address(page); |
4a66af9e NP |
274 | err = __minix_write_begin(NULL, page->mapping, pos, sbi->s_dirsize, |
275 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); | |
1da177e4 LT |
276 | if (err) |
277 | goto out_unlock; | |
939b00df AB |
278 | memcpy (namx, name, namelen); |
279 | if (sbi->s_version == MINIX_V3) { | |
280 | memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4); | |
281 | de3->inode = inode->i_ino; | |
282 | } else { | |
283 | memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2); | |
284 | de->inode = inode->i_ino; | |
285 | } | |
4a66af9e | 286 | err = dir_commit_chunk(page, pos, sbi->s_dirsize); |
1da177e4 LT |
287 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; |
288 | mark_inode_dirty(dir); | |
289 | out_put: | |
290 | dir_put_page(page); | |
291 | out: | |
292 | return err; | |
293 | out_unlock: | |
294 | unlock_page(page); | |
295 | goto out_put; | |
296 | } | |
297 | ||
298 | int minix_delete_entry(struct minix_dir_entry *de, struct page *page) | |
299 | { | |
300 | struct address_space *mapping = page->mapping; | |
301 | struct inode *inode = (struct inode*)mapping->host; | |
302 | char *kaddr = page_address(page); | |
4a66af9e | 303 | loff_t pos = page_offset(page) + (char*)de - kaddr; |
9f6c1333 DG |
304 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
305 | unsigned len = sbi->s_dirsize; | |
1da177e4 LT |
306 | int err; |
307 | ||
308 | lock_page(page); | |
4a66af9e NP |
309 | err = __minix_write_begin(NULL, mapping, pos, len, |
310 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); | |
1da177e4 | 311 | if (err == 0) { |
9f6c1333 DG |
312 | if (sbi->s_version == MINIX_V3) |
313 | ((minix3_dirent *) de)->inode = 0; | |
314 | else | |
315 | de->inode = 0; | |
4a66af9e | 316 | err = dir_commit_chunk(page, pos, len); |
1da177e4 LT |
317 | } else { |
318 | unlock_page(page); | |
319 | } | |
320 | dir_put_page(page); | |
321 | inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; | |
322 | mark_inode_dirty(inode); | |
323 | return err; | |
324 | } | |
325 | ||
326 | int minix_make_empty(struct inode *inode, struct inode *dir) | |
327 | { | |
328 | struct address_space *mapping = inode->i_mapping; | |
329 | struct page *page = grab_cache_page(mapping, 0); | |
939b00df | 330 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
1da177e4 LT |
331 | char *kaddr; |
332 | int err; | |
333 | ||
334 | if (!page) | |
335 | return -ENOMEM; | |
4a66af9e NP |
336 | err = __minix_write_begin(NULL, mapping, 0, 2 * sbi->s_dirsize, |
337 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); | |
1da177e4 LT |
338 | if (err) { |
339 | unlock_page(page); | |
340 | goto fail; | |
341 | } | |
342 | ||
343 | kaddr = kmap_atomic(page, KM_USER0); | |
344 | memset(kaddr, 0, PAGE_CACHE_SIZE); | |
345 | ||
939b00df AB |
346 | if (sbi->s_version == MINIX_V3) { |
347 | minix3_dirent *de3 = (minix3_dirent *)kaddr; | |
348 | ||
349 | de3->inode = inode->i_ino; | |
350 | strcpy(de3->name, "."); | |
351 | de3 = minix_next_entry(de3, sbi); | |
352 | de3->inode = dir->i_ino; | |
353 | strcpy(de3->name, ".."); | |
354 | } else { | |
355 | minix_dirent *de = (minix_dirent *)kaddr; | |
356 | ||
357 | de->inode = inode->i_ino; | |
358 | strcpy(de->name, "."); | |
359 | de = minix_next_entry(de, sbi); | |
360 | de->inode = dir->i_ino; | |
361 | strcpy(de->name, ".."); | |
362 | } | |
1da177e4 LT |
363 | kunmap_atomic(kaddr, KM_USER0); |
364 | ||
365 | err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize); | |
366 | fail: | |
367 | page_cache_release(page); | |
368 | return err; | |
369 | } | |
370 | ||
371 | /* | |
372 | * routine to check that the specified directory is empty (for rmdir) | |
373 | */ | |
374 | int minix_empty_dir(struct inode * inode) | |
375 | { | |
376 | struct page *page = NULL; | |
377 | unsigned long i, npages = dir_pages(inode); | |
378 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); | |
939b00df AB |
379 | char *name; |
380 | __u32 inumber; | |
1da177e4 LT |
381 | |
382 | for (i = 0; i < npages; i++) { | |
939b00df | 383 | char *p, *kaddr, *limit; |
1da177e4 | 384 | |
939b00df | 385 | page = dir_get_page(inode, i); |
1da177e4 LT |
386 | if (IS_ERR(page)) |
387 | continue; | |
388 | ||
389 | kaddr = (char *)page_address(page); | |
939b00df AB |
390 | limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize; |
391 | for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { | |
392 | if (sbi->s_version == MINIX_V3) { | |
393 | minix3_dirent *de3 = (minix3_dirent *)p; | |
394 | name = de3->name; | |
395 | inumber = de3->inode; | |
396 | } else { | |
397 | minix_dirent *de = (minix_dirent *)p; | |
398 | name = de->name; | |
399 | inumber = de->inode; | |
400 | } | |
1da177e4 | 401 | |
939b00df | 402 | if (inumber != 0) { |
1da177e4 | 403 | /* check for . and .. */ |
939b00df | 404 | if (name[0] != '.') |
1da177e4 | 405 | goto not_empty; |
939b00df AB |
406 | if (!name[1]) { |
407 | if (inumber != inode->i_ino) | |
1da177e4 | 408 | goto not_empty; |
939b00df | 409 | } else if (name[1] != '.') |
1da177e4 | 410 | goto not_empty; |
939b00df | 411 | else if (name[2]) |
1da177e4 LT |
412 | goto not_empty; |
413 | } | |
1da177e4 LT |
414 | } |
415 | dir_put_page(page); | |
416 | } | |
417 | return 1; | |
418 | ||
419 | not_empty: | |
420 | dir_put_page(page); | |
421 | return 0; | |
422 | } | |
423 | ||
424 | /* Releases the page */ | |
425 | void minix_set_link(struct minix_dir_entry *de, struct page *page, | |
426 | struct inode *inode) | |
427 | { | |
4a66af9e NP |
428 | struct address_space *mapping = page->mapping; |
429 | struct inode *dir = mapping->host; | |
1da177e4 | 430 | struct minix_sb_info *sbi = minix_sb(dir->i_sb); |
4a66af9e NP |
431 | loff_t pos = page_offset(page) + |
432 | (char *)de-(char*)page_address(page); | |
1da177e4 LT |
433 | int err; |
434 | ||
435 | lock_page(page); | |
4a66af9e NP |
436 | |
437 | err = __minix_write_begin(NULL, mapping, pos, sbi->s_dirsize, | |
438 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); | |
1da177e4 | 439 | if (err == 0) { |
9f6c1333 DG |
440 | if (sbi->s_version == MINIX_V3) |
441 | ((minix3_dirent *) de)->inode = inode->i_ino; | |
442 | else | |
443 | de->inode = inode->i_ino; | |
4a66af9e | 444 | err = dir_commit_chunk(page, pos, sbi->s_dirsize); |
1da177e4 LT |
445 | } else { |
446 | unlock_page(page); | |
447 | } | |
448 | dir_put_page(page); | |
449 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; | |
450 | mark_inode_dirty(dir); | |
451 | } | |
452 | ||
453 | struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p) | |
454 | { | |
455 | struct page *page = dir_get_page(dir, 0); | |
456 | struct minix_sb_info *sbi = minix_sb(dir->i_sb); | |
457 | struct minix_dir_entry *de = NULL; | |
458 | ||
459 | if (!IS_ERR(page)) { | |
460 | de = minix_next_entry(page_address(page), sbi); | |
461 | *p = page; | |
462 | } | |
463 | return de; | |
464 | } | |
465 | ||
466 | ino_t minix_inode_by_name(struct dentry *dentry) | |
467 | { | |
468 | struct page *page; | |
469 | struct minix_dir_entry *de = minix_find_entry(dentry, &page); | |
470 | ino_t res = 0; | |
471 | ||
472 | if (de) { | |
9f6c1333 DG |
473 | struct address_space *mapping = page->mapping; |
474 | struct inode *inode = mapping->host; | |
475 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); | |
476 | ||
477 | if (sbi->s_version == MINIX_V3) | |
478 | res = ((minix3_dirent *) de)->inode; | |
479 | else | |
480 | res = de->inode; | |
1da177e4 LT |
481 | dir_put_page(page); |
482 | } | |
483 | return res; | |
484 | } |