Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/fs/minix/dir.c |
| 3 | * |
| 4 | * Copyright (C) 1991, 1992 Linus Torvalds |
| 5 | * |
| 6 | * minix directory handling functions |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 7 | * |
| 8 | * Updated to filesystem version 3 by Daniel Aragones |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include "minix.h" |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 12 | #include <linux/buffer_head.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/highmem.h> |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 14 | #include <linux/swap.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | typedef struct minix_dir_entry minix_dirent; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 17 | typedef struct minix3_dir_entry minix3_dirent; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
| 19 | static int minix_readdir(struct file *, void *, filldir_t); |
| 20 | |
Arjan van de Ven | 4b6f5d2 | 2006-03-28 01:56:42 -0800 | [diff] [blame] | 21 | const struct file_operations minix_dir_operations = { |
Al Viro | cc46759 | 2009-06-16 23:47:45 -0400 | [diff] [blame] | 22 | .llseek = generic_file_llseek, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | .read = generic_read_dir, |
| 24 | .readdir = minix_readdir, |
Christoph Hellwig | 1b061d9 | 2010-05-26 17:53:41 +0200 | [diff] [blame] | 25 | .fsync = generic_file_fsync, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 53 | static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | { |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 55 | struct address_space *mapping = page->mapping; |
| 56 | struct inode *dir = mapping->host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | int err = 0; |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 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 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Pekka Enberg | 090d2b1 | 2006-06-23 02:05:08 -0700 | [diff] [blame] | 74 | struct page *page = read_mapping_page(mapping, n, NULL); |
Al Viro | 49837a8 | 2010-05-28 11:34:50 -0400 | [diff] [blame^] | 75 | if (!IS_ERR(page)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | kmap(page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | return page; |
| 78 | |
| 79 | fail: |
| 80 | dir_put_page(page); |
| 81 | return ERR_PTR(-EIO); |
| 82 | } |
| 83 | |
| 84 | static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi) |
| 85 | { |
| 86 | return (void*)((char*)de + sbi->s_dirsize); |
| 87 | } |
| 88 | |
| 89 | static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir) |
| 90 | { |
| 91 | unsigned long pos = filp->f_pos; |
Josef Sipek | dcf258a | 2006-12-08 02:37:19 -0800 | [diff] [blame] | 92 | struct inode *inode = filp->f_path.dentry->d_inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 99 | char *name; |
| 100 | __u32 inumber; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | pos = (pos + chunk_size-1) & ~(chunk_size-1); |
| 103 | if (pos >= inode->i_size) |
| 104 | goto done; |
| 105 | |
| 106 | for ( ; n < npages; n++, offset = 0) { |
| 107 | char *p, *kaddr, *limit; |
| 108 | struct page *page = dir_get_page(inode, n); |
| 109 | |
| 110 | if (IS_ERR(page)) |
| 111 | continue; |
| 112 | kaddr = (char *)page_address(page); |
| 113 | p = kaddr+offset; |
| 114 | limit = kaddr + minix_last_byte(inode, n) - chunk_size; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 115 | for ( ; p <= limit; p = minix_next_entry(p, sbi)) { |
| 116 | if (sbi->s_version == MINIX_V3) { |
| 117 | minix3_dirent *de3 = (minix3_dirent *)p; |
| 118 | name = de3->name; |
| 119 | inumber = de3->inode; |
| 120 | } else { |
| 121 | minix_dirent *de = (minix_dirent *)p; |
| 122 | name = de->name; |
| 123 | inumber = de->inode; |
| 124 | } |
| 125 | if (inumber) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | int over; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 128 | unsigned l = strnlen(name, sbi->s_namelen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | offset = p - kaddr; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 130 | over = filldir(dirent, name, l, |
| 131 | (n << PAGE_CACHE_SHIFT) | offset, |
| 132 | inumber, DT_UNKNOWN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | if (over) { |
| 134 | dir_put_page(page); |
| 135 | goto done; |
| 136 | } |
| 137 | } |
| 138 | } |
| 139 | dir_put_page(page); |
| 140 | } |
| 141 | |
| 142 | done: |
| 143 | filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | return 0; |
| 145 | } |
| 146 | |
| 147 | static inline int namecompare(int len, int maxlen, |
| 148 | const char * name, const char * buffer) |
| 149 | { |
| 150 | if (len < maxlen && buffer[len]) |
| 151 | return 0; |
| 152 | return !memcmp(name, buffer, len); |
| 153 | } |
| 154 | |
| 155 | /* |
| 156 | * minix_find_entry() |
| 157 | * |
| 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. |
| 162 | */ |
| 163 | minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page) |
| 164 | { |
| 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); |
| 170 | unsigned long n; |
| 171 | unsigned long npages = dir_pages(dir); |
| 172 | struct page *page = NULL; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 173 | char *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 175 | char *namx; |
| 176 | __u32 inumber; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | *res_page = NULL; |
| 178 | |
| 179 | for (n = 0; n < npages; n++) { |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 180 | char *kaddr, *limit; |
| 181 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | page = dir_get_page(dir, n); |
| 183 | if (IS_ERR(page)) |
| 184 | continue; |
| 185 | |
| 186 | kaddr = (char*)page_address(page); |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 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; |
| 191 | namx = de3->name; |
| 192 | inumber = de3->inode; |
| 193 | } else { |
| 194 | minix_dirent *de = (minix_dirent *)p; |
| 195 | namx = de->name; |
| 196 | inumber = de->inode; |
| 197 | } |
| 198 | if (!inumber) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | continue; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 200 | if (namecompare(namelen, sbi->s_namelen, name, namx)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | goto found; |
| 202 | } |
| 203 | dir_put_page(page); |
| 204 | } |
| 205 | return NULL; |
| 206 | |
| 207 | found: |
| 208 | *res_page = page; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 209 | return (minix_dirent *)p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | int minix_add_link(struct dentry *dentry, struct inode *inode) |
| 213 | { |
| 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | unsigned long npages = dir_pages(dir); |
| 221 | unsigned long n; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 222 | char *kaddr, *p; |
| 223 | minix_dirent *de; |
| 224 | minix3_dirent *de3; |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 225 | loff_t pos; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | int err; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 227 | char *namx = NULL; |
| 228 | __u32 inumber; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | |
| 230 | /* |
| 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. |
| 234 | */ |
| 235 | for (n = 0; n <= npages; n++) { |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 236 | char *limit, *dir_end; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
| 238 | page = dir_get_page(dir, n); |
| 239 | err = PTR_ERR(page); |
| 240 | if (IS_ERR(page)) |
| 241 | goto out; |
| 242 | lock_page(page); |
| 243 | kaddr = (char*)page_address(page); |
| 244 | dir_end = kaddr + minix_last_byte(dir, n); |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 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) { |
| 250 | namx = de3->name; |
| 251 | inumber = de3->inode; |
| 252 | } else { |
| 253 | namx = de->name; |
| 254 | inumber = de->inode; |
| 255 | } |
| 256 | if (p == dir_end) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | /* We hit i_size */ |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 258 | if (sbi->s_version == MINIX_V3) |
| 259 | de3->inode = 0; |
| 260 | else |
| 261 | de->inode = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | goto got_it; |
| 263 | } |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 264 | if (!inumber) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | goto got_it; |
| 266 | err = -EEXIST; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 267 | if (namecompare(namelen, sbi->s_namelen, name, namx)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | goto out_unlock; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | } |
| 270 | unlock_page(page); |
| 271 | dir_put_page(page); |
| 272 | } |
| 273 | BUG(); |
| 274 | return -EINVAL; |
| 275 | |
| 276 | got_it: |
Evgeniy Dushistov | d6b5484 | 2009-01-06 14:42:38 -0800 | [diff] [blame] | 277 | pos = page_offset(page) + p - (char *)page_address(page); |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 278 | err = __minix_write_begin(NULL, page->mapping, pos, sbi->s_dirsize, |
| 279 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | if (err) |
| 281 | goto out_unlock; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 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; |
| 286 | } else { |
| 287 | memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2); |
| 288 | de->inode = inode->i_ino; |
| 289 | } |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 290 | err = dir_commit_chunk(page, pos, sbi->s_dirsize); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; |
| 292 | mark_inode_dirty(dir); |
| 293 | out_put: |
| 294 | dir_put_page(page); |
| 295 | out: |
| 296 | return err; |
| 297 | out_unlock: |
| 298 | unlock_page(page); |
| 299 | goto out_put; |
| 300 | } |
| 301 | |
| 302 | int minix_delete_entry(struct minix_dir_entry *de, struct page *page) |
| 303 | { |
| 304 | struct address_space *mapping = page->mapping; |
| 305 | struct inode *inode = (struct inode*)mapping->host; |
| 306 | char *kaddr = page_address(page); |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 307 | loff_t pos = page_offset(page) + (char*)de - kaddr; |
Doug Graham | 9f6c133 | 2009-09-22 16:48:00 -0700 | [diff] [blame] | 308 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
| 309 | unsigned len = sbi->s_dirsize; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | int err; |
| 311 | |
| 312 | lock_page(page); |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 313 | err = __minix_write_begin(NULL, mapping, pos, len, |
| 314 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | if (err == 0) { |
Doug Graham | 9f6c133 | 2009-09-22 16:48:00 -0700 | [diff] [blame] | 316 | if (sbi->s_version == MINIX_V3) |
| 317 | ((minix3_dirent *) de)->inode = 0; |
| 318 | else |
| 319 | de->inode = 0; |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 320 | err = dir_commit_chunk(page, pos, len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | } else { |
| 322 | unlock_page(page); |
| 323 | } |
| 324 | dir_put_page(page); |
| 325 | inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; |
| 326 | mark_inode_dirty(inode); |
| 327 | return err; |
| 328 | } |
| 329 | |
| 330 | int minix_make_empty(struct inode *inode, struct inode *dir) |
| 331 | { |
| 332 | struct address_space *mapping = inode->i_mapping; |
| 333 | struct page *page = grab_cache_page(mapping, 0); |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 334 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | char *kaddr; |
| 336 | int err; |
| 337 | |
| 338 | if (!page) |
| 339 | return -ENOMEM; |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 340 | err = __minix_write_begin(NULL, mapping, 0, 2 * sbi->s_dirsize, |
| 341 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | if (err) { |
| 343 | unlock_page(page); |
| 344 | goto fail; |
| 345 | } |
| 346 | |
| 347 | kaddr = kmap_atomic(page, KM_USER0); |
| 348 | memset(kaddr, 0, PAGE_CACHE_SIZE); |
| 349 | |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 350 | if (sbi->s_version == MINIX_V3) { |
| 351 | minix3_dirent *de3 = (minix3_dirent *)kaddr; |
| 352 | |
| 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, ".."); |
| 358 | } else { |
| 359 | minix_dirent *de = (minix_dirent *)kaddr; |
| 360 | |
| 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, ".."); |
| 366 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 367 | kunmap_atomic(kaddr, KM_USER0); |
| 368 | |
| 369 | err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize); |
| 370 | fail: |
| 371 | page_cache_release(page); |
| 372 | return err; |
| 373 | } |
| 374 | |
| 375 | /* |
| 376 | * routine to check that the specified directory is empty (for rmdir) |
| 377 | */ |
| 378 | int minix_empty_dir(struct inode * inode) |
| 379 | { |
| 380 | struct page *page = NULL; |
| 381 | unsigned long i, npages = dir_pages(inode); |
| 382 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 383 | char *name; |
| 384 | __u32 inumber; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | |
| 386 | for (i = 0; i < npages; i++) { |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 387 | char *p, *kaddr, *limit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 389 | page = dir_get_page(inode, i); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | if (IS_ERR(page)) |
| 391 | continue; |
| 392 | |
| 393 | kaddr = (char *)page_address(page); |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 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; |
| 398 | name = de3->name; |
| 399 | inumber = de3->inode; |
| 400 | } else { |
| 401 | minix_dirent *de = (minix_dirent *)p; |
| 402 | name = de->name; |
| 403 | inumber = de->inode; |
| 404 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 405 | |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 406 | if (inumber != 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | /* check for . and .. */ |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 408 | if (name[0] != '.') |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | goto not_empty; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 410 | if (!name[1]) { |
| 411 | if (inumber != inode->i_ino) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | goto not_empty; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 413 | } else if (name[1] != '.') |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | goto not_empty; |
Andries Brouwer | 939b00d | 2007-02-12 00:52:49 -0800 | [diff] [blame] | 415 | else if (name[2]) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | goto not_empty; |
| 417 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | } |
| 419 | dir_put_page(page); |
| 420 | } |
| 421 | return 1; |
| 422 | |
| 423 | not_empty: |
| 424 | dir_put_page(page); |
| 425 | return 0; |
| 426 | } |
| 427 | |
| 428 | /* Releases the page */ |
| 429 | void minix_set_link(struct minix_dir_entry *de, struct page *page, |
| 430 | struct inode *inode) |
| 431 | { |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 432 | struct address_space *mapping = page->mapping; |
| 433 | struct inode *dir = mapping->host; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | struct minix_sb_info *sbi = minix_sb(dir->i_sb); |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 435 | loff_t pos = page_offset(page) + |
| 436 | (char *)de-(char*)page_address(page); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | int err; |
| 438 | |
| 439 | lock_page(page); |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 440 | |
| 441 | err = __minix_write_begin(NULL, mapping, pos, sbi->s_dirsize, |
| 442 | AOP_FLAG_UNINTERRUPTIBLE, &page, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | if (err == 0) { |
Doug Graham | 9f6c133 | 2009-09-22 16:48:00 -0700 | [diff] [blame] | 444 | if (sbi->s_version == MINIX_V3) |
| 445 | ((minix3_dirent *) de)->inode = inode->i_ino; |
| 446 | else |
| 447 | de->inode = inode->i_ino; |
Nick Piggin | 4a66af9 | 2007-10-16 01:25:21 -0700 | [diff] [blame] | 448 | err = dir_commit_chunk(page, pos, sbi->s_dirsize); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | } else { |
| 450 | unlock_page(page); |
| 451 | } |
| 452 | dir_put_page(page); |
| 453 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; |
| 454 | mark_inode_dirty(dir); |
| 455 | } |
| 456 | |
| 457 | struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p) |
| 458 | { |
| 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; |
| 462 | |
| 463 | if (!IS_ERR(page)) { |
| 464 | de = minix_next_entry(page_address(page), sbi); |
| 465 | *p = page; |
| 466 | } |
| 467 | return de; |
| 468 | } |
| 469 | |
| 470 | ino_t minix_inode_by_name(struct dentry *dentry) |
| 471 | { |
| 472 | struct page *page; |
| 473 | struct minix_dir_entry *de = minix_find_entry(dentry, &page); |
| 474 | ino_t res = 0; |
| 475 | |
| 476 | if (de) { |
Doug Graham | 9f6c133 | 2009-09-22 16:48:00 -0700 | [diff] [blame] | 477 | struct address_space *mapping = page->mapping; |
| 478 | struct inode *inode = mapping->host; |
| 479 | struct minix_sb_info *sbi = minix_sb(inode->i_sb); |
| 480 | |
| 481 | if (sbi->s_version == MINIX_V3) |
| 482 | res = ((minix3_dirent *) de)->inode; |
| 483 | else |
| 484 | res = de->inode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | dir_put_page(page); |
| 486 | } |
| 487 | return res; |
| 488 | } |