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