1 From: <mk@mary.denx.de>
2 Date: Tue, 24 Jan 2006 14:09:21 +0000 (+0100)
3 Subject: Support for new mutex infrastructure
4 X-Git-Url: http://www.denx.de/cgi-bin/gitweb.cgi?p=mini_fo.git;a=commitdiff;h=1dcc028729060ea83ea662155634b33ae8e2c493
6 Support for new mutex infrastructure
7 (7892f2f48d165a34b0b8130c8a195dfd807b8cb6)
13 +2006-01-24 Markus Klotzbuecher <mk@mary.denx.de>
15 + * Add tons of ugly ifdefs to Ed L. Cashin's mutex patch to
16 + retain backwards compatibility.
18 +2006-01-24 Ed L. Cashin <ecashin@coraid.com>
20 + * Support for the new mutex infrastructure
21 + (7892f2f48d165a34b0b8130c8a195dfd807b8cb6)
23 2005-10-15 Markus Klotzbuecher <mk@localhost.localdomain>
25 * Bugfix for a serious memory leak in mini_fo_follow_link.
28 @@ -435,8 +435,11 @@ int build_sto_structure(dentry_t *dir, d
30 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
31 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
32 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
33 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
35 down(&hidden_sto_dir_dentry->d_inode->i_sem);
39 if(dtohd2(dir) != hidden_sto_dir_dentry) {
40 printk(KERN_CRIT "mini_fo: build_sto_structure: invalid parameter or meta data corruption [2].\n");
41 @@ -457,7 +460,11 @@ int build_sto_structure(dentry_t *dir, d
43 printk(KERN_CRIT "mini_fo: build_sto_structure: failed to create storage dir [1].\n");
44 /* was: unlock_dir(dir); */
45 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
46 + mutex_unlock(&dir->d_inode->i_mutex);
48 up(&dir->d_inode->i_sem);
53 @@ -466,7 +473,11 @@ int build_sto_structure(dentry_t *dir, d
54 if(!dtohd2(dentry)->d_inode) {
55 printk(KERN_CRIT "mini_fo: build_sto_structure: failed to create storage dir [2].\n");
56 /* was: unlock_dir(dir); */
57 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
58 + mutex_unlock(&dir->d_inode->i_mutex);
60 up(&dir->d_inode->i_sem);
65 @@ -485,7 +496,11 @@ int build_sto_structure(dentry_t *dir, d
66 hidden_sto_dir_dentry->d_inode);
67 dir->d_inode->i_nlink++;
68 /* was: unlock_dir(hidden_sto_dir_dentry); */
69 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
70 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
72 up(&hidden_sto_dir_dentry->d_inode->i_sem);
74 dput(hidden_sto_dir_dentry);
79 @@ -613,18 +613,34 @@ mini_fo_fsync(file_t *file, dentry_t *de
80 if ((hidden_file = ftohf(file)) != NULL) {
81 hidden_dentry = dtohd(dentry);
82 if (hidden_file->f_op && hidden_file->f_op->fsync) {
83 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
84 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
86 down(&hidden_dentry->d_inode->i_sem);
88 err1 = hidden_file->f_op->fsync(hidden_file, hidden_dentry, datasync);
89 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
90 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
92 up(&hidden_dentry->d_inode->i_sem);
97 if ((hidden_file = ftohf2(file)) != NULL) {
98 hidden_dentry = dtohd2(dentry);
99 if (hidden_file->f_op && hidden_file->f_op->fsync) {
100 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
101 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
103 down(&hidden_dentry->d_inode->i_sem);
105 err2 = hidden_file->f_op->fsync(hidden_file, hidden_dentry, datasync);
106 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
107 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
109 up(&hidden_dentry->d_inode->i_sem);
116 @@ -355,7 +355,11 @@ mini_fo_link(dentry_t *old_dentry, inode
118 /* was: hidden_dir_dentry = lock_parent(hidden_new_dentry); */
119 hidden_dir_dentry = dget(hidden_new_dentry->d_parent);
120 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
121 + mutex_lock(&hidden_dir_dentry->d_inode->i_mutex);
123 down(&hidden_dir_dentry->d_inode->i_sem);
126 err = vfs_link(hidden_old_dentry,
127 hidden_dir_dentry->d_inode,
128 @@ -374,7 +378,11 @@ mini_fo_link(dentry_t *old_dentry, inode
131 /* was: unlock_dir(hidden_dir_dentry); */
132 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
133 + mutex_unlock(&hidden_dir_dentry->d_inode->i_mutex);
135 up(&hidden_dir_dentry->d_inode->i_sem);
137 dput(hidden_dir_dentry);
139 dput(hidden_new_dentry);
140 @@ -452,7 +460,11 @@ mini_fo_symlink(inode_t *dir, dentry_t *
141 dget(hidden_sto_dentry);
142 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
143 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
144 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
145 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
147 down(&hidden_sto_dir_dentry->d_inode->i_sem);
150 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
152 @@ -481,7 +493,11 @@ mini_fo_symlink(inode_t *dir, dentry_t *
155 /* was: unlock_dir(hidden_sto_dir_dentry); */
156 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
157 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
159 up(&hidden_sto_dir_dentry->d_inode->i_sem);
161 dput(hidden_sto_dir_dentry);
163 dput(hidden_sto_dentry);
164 @@ -524,7 +540,11 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
166 /* was:hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
167 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
168 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
169 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
171 down(&hidden_sto_dir_dentry->d_inode->i_sem);
174 /* avoid destroying the hidden inode if the file is in use */
175 dget(hidden_sto_dentry);
176 @@ -572,7 +592,11 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
179 /* was: unlock_dir(hidden_sto_dir_dentry); */
180 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
181 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
183 up(&hidden_sto_dir_dentry->d_inode->i_sem);
185 dput(hidden_sto_dir_dentry);
188 @@ -602,7 +626,12 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
190 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
191 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
193 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
194 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
196 down(&hidden_sto_dir_dentry->d_inode->i_sem);
199 /* avoid destroying the hidden inode if the file is in use */
200 dget(hidden_sto_dentry);
201 @@ -630,7 +659,11 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
202 dtopd(dentry)->state = NON_EXISTANT;
204 /* was: unlock_dir(hidden_sto_dir_dentry); */
205 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
206 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
208 up(&hidden_sto_dir_dentry->d_inode->i_sem);
210 dput(hidden_sto_dir_dentry);
213 @@ -641,7 +674,12 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
215 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
216 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
218 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
219 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
221 down(&hidden_sto_dir_dentry->d_inode->i_sem);
224 /* avoid destroying the hidden inode if the file is in use */
225 dget(hidden_sto_dentry);
226 @@ -668,7 +706,12 @@ mini_fo_rmdir(inode_t *dir, dentry_t *de
227 dentry->d_inode->i_nlink = itohi2(dentry->d_inode)->i_nlink;
228 dtopd(dentry)->state = DELETED;
229 /* was: unlock_dir(hidden_sto_dir_dentry); */
231 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
232 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
234 up(&hidden_sto_dir_dentry->d_inode->i_sem);
236 dput(hidden_sto_dir_dentry);
239 @@ -1294,11 +1337,19 @@ mini_fo_getxattr(struct dentry *dentry,
240 encoded_name = (char *)name;
241 encoded_value = (char *)value;
243 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
244 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
246 down(&hidden_dentry->d_inode->i_sem);
248 /* lock_kernel() already done by caller. */
249 err = hidden_dentry->d_inode->i_op->getxattr(hidden_dentry, encoded_name, encoded_value, size);
250 /* unlock_kernel() will be done by caller. */
251 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
252 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
254 up(&hidden_dentry->d_inode->i_sem);
259 @@ -1340,11 +1391,19 @@ mini_fo_setxattr(struct dentry *dentry,
260 encoded_name = (char *)name;
261 encoded_value = (char *)value;
263 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
264 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
266 down(&hidden_dentry->d_inode->i_sem);
268 /* lock_kernel() already done by caller. */
269 err = hidden_dentry->d_inode->i_op->setxattr(hidden_dentry, encoded_name, encoded_value, size, flags);
270 /* unlock_kernel() will be done by caller. */
271 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
272 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
274 up(&hidden_dentry->d_inode->i_sem);
279 @@ -1372,11 +1431,19 @@ mini_fo_removexattr(struct dentry *dentr
280 if (hidden_dentry->d_inode->i_op->removexattr) {
281 encoded_name = (char *)name;
283 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
284 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
286 down(&hidden_dentry->d_inode->i_sem);
288 /* lock_kernel() already done by caller. */
289 err = hidden_dentry->d_inode->i_op->removexattr(hidden_dentry, encoded_name);
290 /* unlock_kernel() will be done by caller. */
291 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
292 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
294 up(&hidden_dentry->d_inode->i_sem);
299 @@ -1403,11 +1470,20 @@ mini_fo_listxattr(struct dentry *dentry,
301 if (hidden_dentry->d_inode->i_op->listxattr) {
304 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
305 + mutex_lock(&hidden_dentry->d_inode->i_mutex);
307 down(&hidden_dentry->d_inode->i_sem);
309 /* lock_kernel() already done by caller. */
310 err = hidden_dentry->d_inode->i_op->listxattr(hidden_dentry, encoded_list, size);
311 /* unlock_kernel() will be done by caller. */
312 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
313 + mutex_unlock(&hidden_dentry->d_inode->i_mutex);
315 up(&hidden_dentry->d_inode->i_sem);
322 @@ -650,9 +650,20 @@ int meta_sync_d_list(dentry_t *dentry, i
323 struct iattr newattrs;
324 newattrs.ia_size = 0;
325 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
327 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
328 + mutex_lock(&meta_dentry->d_inode->i_mutex);
330 down(&meta_dentry->d_inode->i_sem);
332 err = notify_change(meta_dentry, &newattrs);
334 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
335 + mutex_unlock(&meta_dentry->d_inode->i_mutex);
337 up(&meta_dentry->d_inode->i_sem);
340 if(err || meta_dentry->d_inode->i_size != 0) {
341 printk(KERN_CRIT "mini_fo: meta_sync_d_list: \
342 ERROR truncating meta file.\n");
343 @@ -780,9 +791,19 @@ int meta_sync_r_list(dentry_t *dentry, i
344 struct iattr newattrs;
345 newattrs.ia_size = 0;
346 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
348 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
349 + mutex_lock(&meta_dentry->d_inode->i_mutex);
351 down(&meta_dentry->d_inode->i_sem);
353 err = notify_change(meta_dentry, &newattrs);
355 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
356 + mutex_unlock(&meta_dentry->d_inode->i_mutex);
358 up(&meta_dentry->d_inode->i_sem);
360 if(err || meta_dentry->d_inode->i_size != 0) {
361 printk(KERN_CRIT "mini_fo: meta_sync_r_list: \
362 ERROR truncating meta file.\n");
365 @@ -433,6 +433,33 @@ fist_copy_attr_all(inode_t *dest, const
367 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
368 /* copied from linux/fs.h */
369 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
370 +static inline void double_lock(struct dentry *d1, struct dentry *d2)
372 + struct mutex *m1 = &d1->d_inode->i_mutex;
373 + struct mutex *m2 = &d2->d_inode->i_mutex;
375 + if ((unsigned long) m1 < (unsigned long) m2) {
376 + struct mutex *tmp = m2;
384 +static inline void double_unlock(struct dentry *d1, struct dentry *d2)
386 + struct mutex *m1 = &d1->d_inode->i_mutex;
387 + struct mutex *m2 = &d2->d_inode->i_mutex;
396 static inline void double_down(struct semaphore *s1, struct semaphore *s2)
399 @@ -463,8 +490,8 @@ static inline void double_unlock(struct
405 +#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16) */
406 +#endif /* if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */
407 #endif /* __KERNEL__ */
412 @@ -478,7 +478,11 @@ mini_fo_commit_write(file_t *file, page_
413 if (ftopd(file) != NULL)
414 hidden_file = ftohf(file);
416 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
417 + mutex_lock(&hidden_inode->i_mutex);
419 down(&hidden_inode->i_sem);
421 /* find lower page (returns a locked page) */
422 hidden_page = grab_cache_page(hidden_inode->i_mapping, page->index);
424 @@ -556,7 +560,12 @@ mini_fo_commit_write(file_t *file, page_
425 ClearPageUptodate(page);
427 SetPageUptodate(page);
429 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
430 + mutex_unlock(&hidden_inode->i_mutex);
432 up(&hidden_inode->i_sem);
434 print_exit_status(err);
435 return err; /* assume all is ok */
439 @@ -44,7 +44,12 @@ int create_sto_reg_file(dentry_t *dentry
442 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
444 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
445 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
447 down(&hidden_sto_dir_dentry->d_inode->i_sem);
450 err = PTR_ERR(hidden_sto_dir_dentry);
451 if (IS_ERR(hidden_sto_dir_dentry))
452 @@ -97,7 +102,11 @@ int create_sto_reg_file(dentry_t *dentry
453 hidden_sto_dir_dentry->d_inode);
456 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
457 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
459 up(&hidden_sto_dir_dentry->d_inode->i_sem);
461 dput(hidden_sto_dir_dentry);
464 @@ -130,7 +139,12 @@ n");
466 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
467 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
469 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
470 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
472 down(&hidden_sto_dir_dentry->d_inode->i_sem);
475 err = PTR_ERR(hidden_sto_dir_dentry);
476 if (IS_ERR(hidden_sto_dir_dentry))
477 @@ -184,7 +198,11 @@ n");
480 /* was: unlock_dir(hidden_sto_dir_dentry); */
481 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
482 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
484 up(&hidden_sto_dir_dentry->d_inode->i_sem);
486 dput(hidden_sto_dir_dentry);
489 @@ -217,7 +235,12 @@ int create_sto_nod(dentry_t *dentry, int
492 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
494 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
495 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
497 down(&hidden_sto_dir_dentry->d_inode->i_sem);
500 err = PTR_ERR(hidden_sto_dir_dentry);
501 if (IS_ERR(hidden_sto_dir_dentry))
502 @@ -260,7 +283,11 @@ int create_sto_nod(dentry_t *dentry, int
503 fist_copy_attr_timesizes(dir, hidden_sto_dir_dentry->d_inode);
506 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
507 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
509 up(&hidden_sto_dir_dentry->d_inode->i_sem);
511 dput(hidden_sto_dir_dentry);
514 @@ -314,7 +341,12 @@ int nondir_unmod_to_mod(dentry_t *dentry
517 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
519 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
520 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
522 down(&hidden_sto_dir_dentry->d_inode->i_sem);
525 err = PTR_ERR(hidden_sto_dir_dentry);
526 if (IS_ERR(hidden_sto_dir_dentry))
527 @@ -365,7 +397,12 @@ int nondir_unmod_to_mod(dentry_t *dentry
528 if((cp_flag == 1) && S_ISREG(dentry->d_inode->i_mode)) {
531 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
532 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
534 up(&hidden_sto_dir_dentry->d_inode->i_sem);
537 dput(hidden_sto_dir_dentry);
539 tgt_dentry = dtohd2(dentry);
540 @@ -383,7 +420,11 @@ int nondir_unmod_to_mod(dentry_t *dentry
544 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
545 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
547 up(&hidden_sto_dir_dentry->d_inode->i_sem);
549 dput(hidden_sto_dir_dentry);
552 @@ -420,7 +461,12 @@ int nondir_creat_to_del(dentry_t *dentry
554 /* was: hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry);*/
555 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
557 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
558 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
560 down(&hidden_sto_dir_dentry->d_inode->i_sem);
563 /* avoid destroying the hidden inode if the file is in use */
564 dget(hidden_sto_dentry);
565 @@ -435,7 +481,11 @@ int nondir_creat_to_del(dentry_t *dentry
566 dtost(dentry) = NON_EXISTANT;
568 /* was: unlock_dir(hidden_sto_dir_dentry); */
569 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
570 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
572 up(&hidden_sto_dir_dentry->d_inode->i_sem);
574 dput(hidden_sto_dir_dentry);
577 @@ -464,7 +514,12 @@ int nondir_mod_to_del(dentry_t *dentry)
579 /* was hidden_sto_dir_dentry = lock_parent(hidden_sto_dentry); */
580 hidden_sto_dir_dentry = dget(hidden_sto_dentry->d_parent);
582 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
583 + mutex_lock(&hidden_sto_dir_dentry->d_inode->i_mutex);
585 down(&hidden_sto_dir_dentry->d_inode->i_sem);
588 /* avoid destroying the hidden inode if the file is in use */
589 dget(hidden_sto_dentry);
590 @@ -488,7 +543,11 @@ int nondir_mod_to_del(dentry_t *dentry)
593 /* was: unlock_dir(hidden_sto_dir_dentry); */
594 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
595 + mutex_unlock(&hidden_sto_dir_dentry->d_inode->i_mutex);
597 up(&hidden_sto_dir_dentry->d_inode->i_sem);
599 dput(hidden_sto_dir_dentry);