4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * minix directory handling functions
8 * Updated to filesystem version 3 by Daniel Aragones
12 #include <linux/buffer_head.h>
13 #include <linux/highmem.h>
14 #include <linux/swap.h>
16 typedef struct minix_dir_entry minix_dirent;
17 typedef struct minix3_dir_entry minix3_dirent;
19 static int minix_readdir(struct file *, void *, filldir_t);
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,
28 static inline void dir_put_page(struct page *page)
31 page_cache_release(page);
35 * Return the offset into page `page_nr' of the last valid
36 * byte in that page, plus one.
39 minix_last_byte(struct inode *inode, unsigned long page_nr)
41 unsigned last_byte = PAGE_CACHE_SIZE;
43 if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT))
44 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1);
48 static inline unsigned long dir_pages(struct inode *inode)
50 return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
53 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len)
55 struct address_space *mapping = page->mapping;
56 struct inode *dir = mapping->host;
58 block_write_end(NULL, mapping, pos, len, len, page, NULL);
60 if (pos+len > dir->i_size) {
61 i_size_write(dir, pos+len);
62 mark_inode_dirty(dir);
65 err = write_one_page(page, 1);
71 static struct page * dir_get_page(struct inode *dir, unsigned long n)
73 struct address_space *mapping = dir->i_mapping;
74 struct page *page = read_mapping_page(mapping, n, NULL);
84 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi)
86 return (void*)((char*)de + sbi->s_dirsize);
89 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir)
91 unsigned long pos = filp->f_pos;
92 struct inode *inode = filp->f_path.dentry->d_inode;
93 struct super_block *sb = inode->i_sb;
94 unsigned offset = pos & ~PAGE_CACHE_MASK;
95 unsigned long n = pos >> PAGE_CACHE_SHIFT;
96 unsigned long npages = dir_pages(inode);
97 struct minix_sb_info *sbi = minix_sb(sb);
98 unsigned chunk_size = sbi->s_dirsize;
102 pos = (pos + chunk_size-1) & ~(chunk_size-1);
103 if (pos >= inode->i_size)
106 for ( ; n < npages; n++, offset = 0) {
107 char *p, *kaddr, *limit;
108 struct page *page = dir_get_page(inode, n);
112 kaddr = (char *)page_address(page);
114 limit = kaddr + minix_last_byte(inode, n) - chunk_size;
115 for ( ; p <= limit; p = minix_next_entry(p, sbi)) {
116 if (sbi->s_version == MINIX_V3) {
117 minix3_dirent *de3 = (minix3_dirent *)p;
119 inumber = de3->inode;
121 minix_dirent *de = (minix_dirent *)p;
128 unsigned l = strnlen(name, sbi->s_namelen);
130 over = filldir(dirent, name, l,
131 (n << PAGE_CACHE_SHIFT) | offset,
132 inumber, DT_UNKNOWN);
143 filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset;
147 static inline int namecompare(int len, int maxlen,
148 const char * name, const char * buffer)
150 if (len < maxlen && buffer[len])
152 return !memcmp(name, buffer, len);
158 * finds an entry in the specified directory with the wanted name. It
159 * returns the cache buffer in which the entry was found, and the entry
160 * itself (as a parameter - res_dir). It does NOT read the inode of the
161 * entry - you'll have to do that yourself if you want to.
163 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page)
165 const char * name = dentry->d_name.name;
166 int namelen = dentry->d_name.len;
167 struct inode * dir = dentry->d_parent->d_inode;
168 struct super_block * sb = dir->i_sb;
169 struct minix_sb_info * sbi = minix_sb(sb);
171 unsigned long npages = dir_pages(dir);
172 struct page *page = NULL;
179 for (n = 0; n < npages; n++) {
182 page = dir_get_page(dir, n);
186 kaddr = (char*)page_address(page);
187 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize;
188 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
189 if (sbi->s_version == MINIX_V3) {
190 minix3_dirent *de3 = (minix3_dirent *)p;
192 inumber = de3->inode;
194 minix_dirent *de = (minix_dirent *)p;
200 if (namecompare(namelen, sbi->s_namelen, name, namx))
209 return (minix_dirent *)p;
212 int minix_add_link(struct dentry *dentry, struct inode *inode)
214 struct inode *dir = dentry->d_parent->d_inode;
215 const char * name = dentry->d_name.name;
216 int namelen = dentry->d_name.len;
217 struct super_block * sb = dir->i_sb;
218 struct minix_sb_info * sbi = minix_sb(sb);
219 struct page *page = NULL;
220 unsigned long npages = dir_pages(dir);
231 * We take care of directory expansion in the same loop
232 * This code plays outside i_size, so it locks the page
233 * to protect that region.
235 for (n = 0; n <= npages; n++) {
236 char *limit, *dir_end;
238 page = dir_get_page(dir, n);
243 kaddr = (char*)page_address(page);
244 dir_end = kaddr + minix_last_byte(dir, n);
245 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize;
246 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
247 de = (minix_dirent *)p;
248 de3 = (minix3_dirent *)p;
249 if (sbi->s_version == MINIX_V3) {
251 inumber = de3->inode;
258 if (sbi->s_version == MINIX_V3)
267 if (namecompare(namelen, sbi->s_namelen, name, namx))
277 pos = page_offset(page) + p - (char *)page_address(page);
278 err = __minix_write_begin(NULL, page->mapping, pos, sbi->s_dirsize,
279 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
282 memcpy (namx, name, namelen);
283 if (sbi->s_version == MINIX_V3) {
284 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4);
285 de3->inode = inode->i_ino;
287 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2);
288 de->inode = inode->i_ino;
290 err = dir_commit_chunk(page, pos, sbi->s_dirsize);
291 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
292 mark_inode_dirty(dir);
302 int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
304 struct address_space *mapping = page->mapping;
305 struct inode *inode = (struct inode*)mapping->host;
306 char *kaddr = page_address(page);
307 loff_t pos = page_offset(page) + (char*)de - kaddr;
308 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
309 unsigned len = sbi->s_dirsize;
313 err = __minix_write_begin(NULL, mapping, pos, len,
314 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
316 if (sbi->s_version == MINIX_V3)
317 ((minix3_dirent *) de)->inode = 0;
320 err = dir_commit_chunk(page, pos, len);
325 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
326 mark_inode_dirty(inode);
330 int minix_make_empty(struct inode *inode, struct inode *dir)
332 struct address_space *mapping = inode->i_mapping;
333 struct page *page = grab_cache_page(mapping, 0);
334 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
340 err = __minix_write_begin(NULL, mapping, 0, 2 * sbi->s_dirsize,
341 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
347 kaddr = kmap_atomic(page, KM_USER0);
348 memset(kaddr, 0, PAGE_CACHE_SIZE);
350 if (sbi->s_version == MINIX_V3) {
351 minix3_dirent *de3 = (minix3_dirent *)kaddr;
353 de3->inode = inode->i_ino;
354 strcpy(de3->name, ".");
355 de3 = minix_next_entry(de3, sbi);
356 de3->inode = dir->i_ino;
357 strcpy(de3->name, "..");
359 minix_dirent *de = (minix_dirent *)kaddr;
361 de->inode = inode->i_ino;
362 strcpy(de->name, ".");
363 de = minix_next_entry(de, sbi);
364 de->inode = dir->i_ino;
365 strcpy(de->name, "..");
367 kunmap_atomic(kaddr, KM_USER0);
369 err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize);
371 page_cache_release(page);
376 * routine to check that the specified directory is empty (for rmdir)
378 int minix_empty_dir(struct inode * inode)
380 struct page *page = NULL;
381 unsigned long i, npages = dir_pages(inode);
382 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
386 for (i = 0; i < npages; i++) {
387 char *p, *kaddr, *limit;
389 page = dir_get_page(inode, i);
393 kaddr = (char *)page_address(page);
394 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize;
395 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) {
396 if (sbi->s_version == MINIX_V3) {
397 minix3_dirent *de3 = (minix3_dirent *)p;
399 inumber = de3->inode;
401 minix_dirent *de = (minix_dirent *)p;
407 /* check for . and .. */
411 if (inumber != inode->i_ino)
413 } else if (name[1] != '.')
428 /* Releases the page */
429 void minix_set_link(struct minix_dir_entry *de, struct page *page,
432 struct address_space *mapping = page->mapping;
433 struct inode *dir = mapping->host;
434 struct minix_sb_info *sbi = minix_sb(dir->i_sb);
435 loff_t pos = page_offset(page) +
436 (char *)de-(char*)page_address(page);
441 err = __minix_write_begin(NULL, mapping, pos, sbi->s_dirsize,
442 AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
444 if (sbi->s_version == MINIX_V3)
445 ((minix3_dirent *) de)->inode = inode->i_ino;
447 de->inode = inode->i_ino;
448 err = dir_commit_chunk(page, pos, sbi->s_dirsize);
453 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
454 mark_inode_dirty(dir);
457 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p)
459 struct page *page = dir_get_page(dir, 0);
460 struct minix_sb_info *sbi = minix_sb(dir->i_sb);
461 struct minix_dir_entry *de = NULL;
464 de = minix_next_entry(page_address(page), sbi);
470 ino_t minix_inode_by_name(struct dentry *dentry)
473 struct minix_dir_entry *de = minix_find_entry(dentry, &page);
477 struct address_space *mapping = page->mapping;
478 struct inode *inode = mapping->host;
479 struct minix_sb_info *sbi = minix_sb(inode->i_sb);
481 if (sbi->s_version == MINIX_V3)
482 res = ((minix3_dirent *) de)->inode;