Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/fs/sysv/dir.c | |
4 | * | |
5 | * minix/dir.c | |
6 | * Copyright (C) 1991, 1992 Linus Torvalds | |
7 | * | |
8 | * coh/dir.c | |
9 | * Copyright (C) 1993 Pascal Haible, Bruno Haible | |
10 | * | |
11 | * sysv/dir.c | |
12 | * Copyright (C) 1993 Bruno Haible | |
13 | * | |
14 | * SystemV/Coherent directory handling functions | |
15 | */ | |
16 | ||
17 | #include <linux/pagemap.h> | |
18 | #include <linux/highmem.h> | |
26a6441a | 19 | #include <linux/swap.h> |
1da177e4 LT |
20 | #include "sysv.h" |
21 | ||
80886298 | 22 | static int sysv_readdir(struct file *, struct dir_context *); |
1da177e4 | 23 | |
4b6f5d20 | 24 | const struct file_operations sysv_dir_operations = { |
5ac3455a | 25 | .llseek = generic_file_llseek, |
1da177e4 | 26 | .read = generic_read_dir, |
3b0a3c1a | 27 | .iterate_shared = sysv_readdir, |
1b061d92 | 28 | .fsync = generic_file_fsync, |
1da177e4 LT |
29 | }; |
30 | ||
31 | static inline void dir_put_page(struct page *page) | |
32 | { | |
33 | kunmap(page); | |
09cbfeaf | 34 | put_page(page); |
1da177e4 LT |
35 | } |
36 | ||
4309093e | 37 | static void dir_commit_chunk(struct page *page, loff_t pos, unsigned len) |
1da177e4 | 38 | { |
26a6441a NP |
39 | struct address_space *mapping = page->mapping; |
40 | struct inode *dir = mapping->host; | |
1da177e4 | 41 | |
26a6441a NP |
42 | block_write_end(NULL, mapping, pos, len, len, page, NULL); |
43 | if (pos+len > dir->i_size) { | |
44 | i_size_write(dir, pos+len); | |
45 | mark_inode_dirty(dir); | |
46 | } | |
4309093e CH |
47 | unlock_page(page); |
48 | } | |
49 | ||
50 | static int sysv_handle_dirsync(struct inode *dir) | |
51 | { | |
52 | int err; | |
53 | ||
54 | err = filemap_write_and_wait(dir->i_mapping); | |
55 | if (!err) | |
56 | err = sync_inode_metadata(dir, 1); | |
1da177e4 LT |
57 | return err; |
58 | } | |
59 | ||
60 | static struct page * dir_get_page(struct inode *dir, unsigned long n) | |
61 | { | |
62 | struct address_space *mapping = dir->i_mapping; | |
090d2b18 | 63 | struct page *page = read_mapping_page(mapping, n, NULL); |
6fe6900e | 64 | if (!IS_ERR(page)) |
1da177e4 | 65 | kmap(page); |
1da177e4 | 66 | return page; |
1da177e4 LT |
67 | } |
68 | ||
80886298 | 69 | static int sysv_readdir(struct file *file, struct dir_context *ctx) |
1da177e4 | 70 | { |
80886298 AV |
71 | unsigned long pos = ctx->pos; |
72 | struct inode *inode = file_inode(file); | |
1da177e4 | 73 | struct super_block *sb = inode->i_sb; |
1da177e4 | 74 | unsigned long npages = dir_pages(inode); |
80886298 AV |
75 | unsigned offset; |
76 | unsigned long n; | |
1da177e4 | 77 | |
80886298 | 78 | ctx->pos = pos = (pos + SYSV_DIRSIZE-1) & ~(SYSV_DIRSIZE-1); |
1da177e4 | 79 | if (pos >= inode->i_size) |
80886298 AV |
80 | return 0; |
81 | ||
09cbfeaf KS |
82 | offset = pos & ~PAGE_MASK; |
83 | n = pos >> PAGE_SHIFT; | |
1da177e4 LT |
84 | |
85 | for ( ; n < npages; n++, offset = 0) { | |
86 | char *kaddr, *limit; | |
87 | struct sysv_dir_entry *de; | |
88 | struct page *page = dir_get_page(inode, n); | |
89 | ||
90 | if (IS_ERR(page)) | |
91 | continue; | |
92 | kaddr = (char *)page_address(page); | |
93 | de = (struct sysv_dir_entry *)(kaddr+offset); | |
09cbfeaf | 94 | limit = kaddr + PAGE_SIZE - SYSV_DIRSIZE; |
80886298 | 95 | for ( ;(char*)de <= limit; de++, ctx->pos += sizeof(*de)) { |
1da177e4 | 96 | char *name = de->name; |
1da177e4 LT |
97 | |
98 | if (!de->inode) | |
99 | continue; | |
100 | ||
80886298 | 101 | if (!dir_emit(ctx, name, strnlen(name,SYSV_NAMELEN), |
1da177e4 | 102 | fs16_to_cpu(SYSV_SB(sb), de->inode), |
80886298 | 103 | DT_UNKNOWN)) { |
1da177e4 | 104 | dir_put_page(page); |
80886298 | 105 | return 0; |
1da177e4 LT |
106 | } |
107 | } | |
108 | dir_put_page(page); | |
109 | } | |
1da177e4 LT |
110 | return 0; |
111 | } | |
112 | ||
113 | /* compare strings: name[0..len-1] (not zero-terminated) and | |
114 | * buffer[0..] (filled with zeroes up to buffer[0..maxlen-1]) | |
115 | */ | |
116 | static inline int namecompare(int len, int maxlen, | |
117 | const char * name, const char * buffer) | |
118 | { | |
119 | if (len < maxlen && buffer[len]) | |
120 | return 0; | |
121 | return !memcmp(name, buffer, len); | |
122 | } | |
123 | ||
124 | /* | |
125 | * sysv_find_entry() | |
126 | * | |
127 | * finds an entry in the specified directory with the wanted name. It | |
128 | * returns the cache buffer in which the entry was found, and the entry | |
129 | * itself (as a parameter - res_dir). It does NOT read the inode of the | |
130 | * entry - you'll have to do that yourself if you want to. | |
131 | */ | |
132 | struct sysv_dir_entry *sysv_find_entry(struct dentry *dentry, struct page **res_page) | |
133 | { | |
134 | const char * name = dentry->d_name.name; | |
135 | int namelen = dentry->d_name.len; | |
2b0143b5 | 136 | struct inode * dir = d_inode(dentry->d_parent); |
1da177e4 LT |
137 | unsigned long start, n; |
138 | unsigned long npages = dir_pages(dir); | |
139 | struct page *page = NULL; | |
140 | struct sysv_dir_entry *de; | |
141 | ||
142 | *res_page = NULL; | |
143 | ||
144 | start = SYSV_I(dir)->i_dir_start_lookup; | |
145 | if (start >= npages) | |
146 | start = 0; | |
147 | n = start; | |
148 | ||
149 | do { | |
150 | char *kaddr; | |
151 | page = dir_get_page(dir, n); | |
152 | if (!IS_ERR(page)) { | |
153 | kaddr = (char*)page_address(page); | |
154 | de = (struct sysv_dir_entry *) kaddr; | |
09cbfeaf | 155 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
156 | for ( ; (char *) de <= kaddr ; de++) { |
157 | if (!de->inode) | |
158 | continue; | |
159 | if (namecompare(namelen, SYSV_NAMELEN, | |
160 | name, de->name)) | |
161 | goto found; | |
162 | } | |
404e7812 | 163 | dir_put_page(page); |
1da177e4 | 164 | } |
1da177e4 LT |
165 | |
166 | if (++n >= npages) | |
167 | n = 0; | |
168 | } while (n != start); | |
169 | ||
170 | return NULL; | |
171 | ||
172 | found: | |
173 | SYSV_I(dir)->i_dir_start_lookup = n; | |
174 | *res_page = page; | |
175 | return de; | |
176 | } | |
177 | ||
178 | int sysv_add_link(struct dentry *dentry, struct inode *inode) | |
179 | { | |
2b0143b5 | 180 | struct inode *dir = d_inode(dentry->d_parent); |
1da177e4 LT |
181 | const char * name = dentry->d_name.name; |
182 | int namelen = dentry->d_name.len; | |
183 | struct page *page = NULL; | |
184 | struct sysv_dir_entry * de; | |
185 | unsigned long npages = dir_pages(dir); | |
186 | unsigned long n; | |
187 | char *kaddr; | |
26a6441a | 188 | loff_t pos; |
1da177e4 LT |
189 | int err; |
190 | ||
191 | /* We take care of directory expansion in the same loop */ | |
192 | for (n = 0; n <= npages; n++) { | |
193 | page = dir_get_page(dir, n); | |
194 | err = PTR_ERR(page); | |
195 | if (IS_ERR(page)) | |
196 | goto out; | |
197 | kaddr = (char*)page_address(page); | |
198 | de = (struct sysv_dir_entry *)kaddr; | |
09cbfeaf | 199 | kaddr += PAGE_SIZE - SYSV_DIRSIZE; |
1da177e4 LT |
200 | while ((char *)de <= kaddr) { |
201 | if (!de->inode) | |
202 | goto got_it; | |
203 | err = -EEXIST; | |
204 | if (namecompare(namelen, SYSV_NAMELEN, name, de->name)) | |
205 | goto out_page; | |
206 | de++; | |
207 | } | |
208 | dir_put_page(page); | |
209 | } | |
210 | BUG(); | |
211 | return -EINVAL; | |
212 | ||
213 | got_it: | |
4bb1a137 | 214 | pos = page_offset(page) + offset_in_page(de); |
1da177e4 | 215 | lock_page(page); |
f4e420dc | 216 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 LT |
217 | if (err) |
218 | goto out_unlock; | |
219 | memcpy (de->name, name, namelen); | |
220 | memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2); | |
221 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
4309093e | 222 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
02027d42 | 223 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 224 | mark_inode_dirty(dir); |
4309093e | 225 | err = sysv_handle_dirsync(dir); |
1da177e4 LT |
226 | out_page: |
227 | dir_put_page(page); | |
228 | out: | |
229 | return err; | |
230 | out_unlock: | |
231 | unlock_page(page); | |
232 | goto out_page; | |
233 | } | |
234 | ||
235 | int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page) | |
236 | { | |
f4e420dc | 237 | struct inode *inode = page->mapping->host; |
4bb1a137 | 238 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
239 | int err; |
240 | ||
241 | lock_page(page); | |
f4e420dc | 242 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
d6735bfc | 243 | BUG_ON(err); |
1da177e4 | 244 | de->inode = 0; |
4309093e | 245 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 | 246 | dir_put_page(page); |
02027d42 | 247 | inode->i_ctime = inode->i_mtime = current_time(inode); |
1da177e4 | 248 | mark_inode_dirty(inode); |
4309093e | 249 | return sysv_handle_dirsync(inode); |
1da177e4 LT |
250 | } |
251 | ||
252 | int sysv_make_empty(struct inode *inode, struct inode *dir) | |
253 | { | |
f4e420dc | 254 | struct page *page = grab_cache_page(inode->i_mapping, 0); |
1da177e4 LT |
255 | struct sysv_dir_entry * de; |
256 | char *base; | |
257 | int err; | |
258 | ||
259 | if (!page) | |
260 | return -ENOMEM; | |
f4e420dc | 261 | err = sysv_prepare_chunk(page, 0, 2 * SYSV_DIRSIZE); |
1da177e4 LT |
262 | if (err) { |
263 | unlock_page(page); | |
264 | goto fail; | |
265 | } | |
26a6441a | 266 | kmap(page); |
1da177e4 LT |
267 | |
268 | base = (char*)page_address(page); | |
09cbfeaf | 269 | memset(base, 0, PAGE_SIZE); |
1da177e4 LT |
270 | |
271 | de = (struct sysv_dir_entry *) base; | |
272 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); | |
273 | strcpy(de->name,"."); | |
274 | de++; | |
275 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino); | |
276 | strcpy(de->name,".."); | |
277 | ||
26a6441a | 278 | kunmap(page); |
4309093e CH |
279 | dir_commit_chunk(page, 0, 2 * SYSV_DIRSIZE); |
280 | err = sysv_handle_dirsync(inode); | |
1da177e4 | 281 | fail: |
09cbfeaf | 282 | put_page(page); |
1da177e4 LT |
283 | return err; |
284 | } | |
285 | ||
286 | /* | |
287 | * routine to check that the specified directory is empty (for rmdir) | |
288 | */ | |
289 | int sysv_empty_dir(struct inode * inode) | |
290 | { | |
291 | struct super_block *sb = inode->i_sb; | |
292 | struct page *page = NULL; | |
293 | unsigned long i, npages = dir_pages(inode); | |
294 | ||
295 | for (i = 0; i < npages; i++) { | |
296 | char *kaddr; | |
297 | struct sysv_dir_entry * de; | |
298 | page = dir_get_page(inode, i); | |
299 | ||
300 | if (IS_ERR(page)) | |
301 | continue; | |
302 | ||
303 | kaddr = (char *)page_address(page); | |
304 | de = (struct sysv_dir_entry *)kaddr; | |
09cbfeaf | 305 | kaddr += PAGE_SIZE-SYSV_DIRSIZE; |
1da177e4 LT |
306 | |
307 | for ( ;(char *)de <= kaddr; de++) { | |
308 | if (!de->inode) | |
309 | continue; | |
310 | /* check for . and .. */ | |
311 | if (de->name[0] != '.') | |
312 | goto not_empty; | |
313 | if (!de->name[1]) { | |
314 | if (de->inode == cpu_to_fs16(SYSV_SB(sb), | |
315 | inode->i_ino)) | |
316 | continue; | |
317 | goto not_empty; | |
318 | } | |
319 | if (de->name[1] != '.' || de->name[2]) | |
320 | goto not_empty; | |
321 | } | |
322 | dir_put_page(page); | |
323 | } | |
324 | return 1; | |
325 | ||
326 | not_empty: | |
327 | dir_put_page(page); | |
328 | return 0; | |
329 | } | |
330 | ||
331 | /* Releases the page */ | |
332 | void sysv_set_link(struct sysv_dir_entry *de, struct page *page, | |
333 | struct inode *inode) | |
334 | { | |
f4e420dc | 335 | struct inode *dir = page->mapping->host; |
4bb1a137 | 336 | loff_t pos = page_offset(page) + offset_in_page(de); |
1da177e4 LT |
337 | int err; |
338 | ||
339 | lock_page(page); | |
f4e420dc | 340 | err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE); |
d6735bfc | 341 | BUG_ON(err); |
1da177e4 | 342 | de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); |
4309093e | 343 | dir_commit_chunk(page, pos, SYSV_DIRSIZE); |
1da177e4 | 344 | dir_put_page(page); |
02027d42 | 345 | dir->i_mtime = dir->i_ctime = current_time(dir); |
1da177e4 | 346 | mark_inode_dirty(dir); |
4309093e | 347 | sysv_handle_dirsync(inode); |
1da177e4 LT |
348 | } |
349 | ||
350 | struct sysv_dir_entry * sysv_dotdot (struct inode *dir, struct page **p) | |
351 | { | |
352 | struct page *page = dir_get_page(dir, 0); | |
353 | struct sysv_dir_entry *de = NULL; | |
354 | ||
355 | if (!IS_ERR(page)) { | |
356 | de = (struct sysv_dir_entry*) page_address(page) + 1; | |
357 | *p = page; | |
358 | } | |
359 | return de; | |
360 | } | |
361 | ||
362 | ino_t sysv_inode_by_name(struct dentry *dentry) | |
363 | { | |
364 | struct page *page; | |
365 | struct sysv_dir_entry *de = sysv_find_entry (dentry, &page); | |
366 | ino_t res = 0; | |
367 | ||
368 | if (de) { | |
369 | res = fs16_to_cpu(SYSV_SB(dentry->d_sb), de->inode); | |
370 | dir_put_page(page); | |
371 | } | |
372 | return res; | |
373 | } |