xref: /openbmc/linux/fs/minix/dir.c (revision e5bd61e8)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/minix/dir.c
4  *
5  *  Copyright (C) 1991, 1992 Linus Torvalds
6  *
7  *  minix directory handling functions
8  *
9  *  Updated to filesystem version 3 by Daniel Aragones
10  */
11 
12 #include "minix.h"
13 #include <linux/buffer_head.h>
14 #include <linux/highmem.h>
15 #include <linux/swap.h>
16 
17 typedef struct minix_dir_entry minix_dirent;
18 typedef struct minix3_dir_entry minix3_dirent;
19 
20 static int minix_readdir(struct file *, struct dir_context *);
21 
22 const struct file_operations minix_dir_operations = {
23 	.llseek		= generic_file_llseek,
24 	.read		= generic_read_dir,
25 	.iterate_shared	= minix_readdir,
26 	.fsync		= generic_file_fsync,
27 };
28 
29 static inline void dir_put_page(struct page *page)
30 {
31 	kunmap(page);
32 	put_page(page);
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 {
42 	unsigned last_byte = PAGE_SIZE;
43 
44 	if (page_nr == (inode->i_size >> PAGE_SHIFT))
45 		last_byte = inode->i_size & (PAGE_SIZE - 1);
46 	return last_byte;
47 }
48 
49 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
50 {
51 	struct address_space *mapping = page->mapping;
52 	struct inode *dir = mapping->host;
53 	int err = 0;
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 	}
60 	if (IS_DIRSYNC(dir))
61 		err = write_one_page(page);
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;
70 	struct page *page = read_mapping_page(mapping, n, NULL);
71 	if (!IS_ERR(page))
72 		kmap(page);
73 	return page;
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 
81 static int minix_readdir(struct file *file, struct dir_context *ctx)
82 {
83 	struct inode *inode = file_inode(file);
84 	struct super_block *sb = inode->i_sb;
85 	struct minix_sb_info *sbi = minix_sb(sb);
86 	unsigned chunk_size = sbi->s_dirsize;
87 	unsigned long npages = dir_pages(inode);
88 	unsigned long pos = ctx->pos;
89 	unsigned offset;
90 	unsigned long n;
91 
92 	ctx->pos = pos = ALIGN(pos, chunk_size);
93 	if (pos >= inode->i_size)
94 		return 0;
95 
96 	offset = pos & ~PAGE_MASK;
97 	n = pos >> PAGE_SHIFT;
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;
108 		for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
109 			const char *name;
110 			__u32 inumber;
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) {
121 				unsigned l = strnlen(name, sbi->s_namelen);
122 				if (!dir_emit(ctx, name, l,
123 					      inumber, DT_UNKNOWN)) {
124 					dir_put_page(page);
125 					return 0;
126 				}
127 			}
128 			ctx->pos += chunk_size;
129 		}
130 		dir_put_page(page);
131 	}
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;
155 	struct inode * dir = d_inode(dentry->d_parent);
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;
161 	char *p;
162 
163 	char *namx;
164 	__u32 inumber;
165 	*res_page = NULL;
166 
167 	for (n = 0; n < npages; n++) {
168 		char *kaddr, *limit;
169 
170 		page = dir_get_page(dir, n);
171 		if (IS_ERR(page))
172 			continue;
173 
174 		kaddr = (char*)page_address(page);
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)
187 				continue;
188 			if (namecompare(namelen, sbi->s_namelen, name, namx))
189 				goto found;
190 		}
191 		dir_put_page(page);
192 	}
193 	return NULL;
194 
195 found:
196 	*res_page = page;
197 	return (minix_dirent *)p;
198 }
199 
200 int minix_add_link(struct dentry *dentry, struct inode *inode)
201 {
202 	struct inode *dir = d_inode(dentry->d_parent);
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;
208 	unsigned long npages = dir_pages(dir);
209 	unsigned long n;
210 	char *kaddr, *p;
211 	minix_dirent *de;
212 	minix3_dirent *de3;
213 	loff_t pos;
214 	int err;
215 	char *namx = NULL;
216 	__u32 inumber;
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++) {
224 		char *limit, *dir_end;
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);
233 		limit = kaddr + PAGE_SIZE - sbi->s_dirsize;
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) {
245 				/* We hit i_size */
246 				if (sbi->s_version == MINIX_V3)
247 					de3->inode = 0;
248 		 		else
249 					de->inode = 0;
250 				goto got_it;
251 			}
252 			if (!inumber)
253 				goto got_it;
254 			err = -EEXIST;
255 			if (namecompare(namelen, sbi->s_namelen, name, namx))
256 				goto out_unlock;
257 		}
258 		unlock_page(page);
259 		dir_put_page(page);
260 	}
261 	BUG();
262 	return -EINVAL;
263 
264 got_it:
265 	pos = page_offset(page) + p - (char *)page_address(page);
266 	err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
267 	if (err)
268 		goto out_unlock;
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 	}
277 	err = dir_commit_chunk(page, pos, sbi->s_dirsize);
278 	dir->i_mtime = dir->i_ctime = current_time(dir);
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 {
291 	struct inode *inode = page->mapping->host;
292 	char *kaddr = page_address(page);
293 	loff_t pos = page_offset(page) + (char*)de - kaddr;
294 	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
295 	unsigned len = sbi->s_dirsize;
296 	int err;
297 
298 	lock_page(page);
299 	err = minix_prepare_chunk(page, pos, len);
300 	if (err == 0) {
301 		if (sbi->s_version == MINIX_V3)
302 			((minix3_dirent *) de)->inode = 0;
303 		else
304 			de->inode = 0;
305 		err = dir_commit_chunk(page, pos, len);
306 	} else {
307 		unlock_page(page);
308 	}
309 	dir_put_page(page);
310 	inode->i_ctime = inode->i_mtime = current_time(inode);
311 	mark_inode_dirty(inode);
312 	return err;
313 }
314 
315 int minix_make_empty(struct inode *inode, struct inode *dir)
316 {
317 	struct page *page = grab_cache_page(inode->i_mapping, 0);
318 	struct minix_sb_info *sbi = minix_sb(inode->i_sb);
319 	char *kaddr;
320 	int err;
321 
322 	if (!page)
323 		return -ENOMEM;
324 	err = minix_prepare_chunk(page, 0, 2 * sbi->s_dirsize);
325 	if (err) {
326 		unlock_page(page);
327 		goto fail;
328 	}
329 
330 	kaddr = kmap_atomic(page);
331 	memset(kaddr, 0, PAGE_SIZE);
332 
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 	}
350 	kunmap_atomic(kaddr);
351 
352 	err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
353 fail:
354 	put_page(page);
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);
366 	char *name;
367 	__u32 inumber;
368 
369 	for (i = 0; i < npages; i++) {
370 		char *p, *kaddr, *limit;
371 
372 		page = dir_get_page(inode, i);
373 		if (IS_ERR(page))
374 			continue;
375 
376 		kaddr = (char *)page_address(page);
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 			}
388 
389 			if (inumber != 0) {
390 				/* check for . and .. */
391 				if (name[0] != '.')
392 					goto not_empty;
393 				if (!name[1]) {
394 					if (inumber != inode->i_ino)
395 						goto not_empty;
396 				} else if (name[1] != '.')
397 					goto not_empty;
398 				else if (name[2])
399 					goto not_empty;
400 			}
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 {
415 	struct inode *dir = page->mapping->host;
416 	struct minix_sb_info *sbi = minix_sb(dir->i_sb);
417 	loff_t pos = page_offset(page) +
418 			(char *)de-(char*)page_address(page);
419 	int err;
420 
421 	lock_page(page);
422 
423 	err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
424 	if (err == 0) {
425 		if (sbi->s_version == MINIX_V3)
426 			((minix3_dirent *) de)->inode = inode->i_ino;
427 		else
428 			de->inode = inode->i_ino;
429 		err = dir_commit_chunk(page, pos, sbi->s_dirsize);
430 	} else {
431 		unlock_page(page);
432 	}
433 	dir_put_page(page);
434 	dir->i_mtime = dir->i_ctime = current_time(dir);
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) {
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;
466 		dir_put_page(page);
467 	}
468 	return res;
469 }
470