nfs4recover.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  1. /*
  2. * linux/fs/nfsd/nfs4recover.c
  3. *
  4. * Copyright (c) 2004 The Regents of the University of Michigan.
  5. * All rights reserved.
  6. *
  7. * Andy Adamson <andros@citi.umich.edu>
  8. *
  9. * Redistribution and use in source and binary forms, with or without
  10. * modification, are permitted provided that the following conditions
  11. * are met:
  12. *
  13. * 1. Redistributions of source code must retain the above copyright
  14. * notice, this list of conditions and the following disclaimer.
  15. * 2. Redistributions in binary form must reproduce the above copyright
  16. * notice, this list of conditions and the following disclaimer in the
  17. * documentation and/or other materials provided with the distribution.
  18. * 3. Neither the name of the University nor the names of its
  19. * contributors may be used to endorse or promote products derived
  20. * from this software without specific prior written permission.
  21. *
  22. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  23. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  29. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33. *
  34. */
  35. #include <linux/err.h>
  36. #include <linux/sunrpc/svc.h>
  37. #include <linux/nfsd/nfsd.h>
  38. #include <linux/nfs4.h>
  39. #include <linux/nfsd/state.h>
  40. #include <linux/nfsd/xdr4.h>
  41. #include <linux/param.h>
  42. #include <linux/file.h>
  43. #include <linux/namei.h>
  44. #include <asm/uaccess.h>
  45. #include <asm/scatterlist.h>
  46. #include <linux/crypto.h>
  47. #define NFSDDBG_FACILITY NFSDDBG_PROC
  48. /* Globals */
  49. static struct nameidata rec_dir;
  50. static int rec_dir_init = 0;
  51. static void
  52. nfs4_save_user(uid_t *saveuid, gid_t *savegid)
  53. {
  54. *saveuid = current->fsuid;
  55. *savegid = current->fsgid;
  56. current->fsuid = 0;
  57. current->fsgid = 0;
  58. }
  59. static void
  60. nfs4_reset_user(uid_t saveuid, gid_t savegid)
  61. {
  62. current->fsuid = saveuid;
  63. current->fsgid = savegid;
  64. }
  65. static void
  66. md5_to_hex(char *out, char *md5)
  67. {
  68. int i;
  69. for (i=0; i<16; i++) {
  70. unsigned char c = md5[i];
  71. *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
  72. *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
  73. }
  74. *out = '\0';
  75. }
  76. __be32
  77. nfs4_make_rec_clidname(char *dname, struct xdr_netobj *clname)
  78. {
  79. struct xdr_netobj cksum;
  80. struct hash_desc desc;
  81. struct scatterlist sg[1];
  82. __be32 status = nfserr_resource;
  83. dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
  84. clname->len, clname->data);
  85. desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
  86. desc.tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
  87. if (IS_ERR(desc.tfm))
  88. goto out_no_tfm;
  89. cksum.len = crypto_hash_digestsize(desc.tfm);
  90. cksum.data = kmalloc(cksum.len, GFP_KERNEL);
  91. if (cksum.data == NULL)
  92. goto out;
  93. sg[0].page = virt_to_page(clname->data);
  94. sg[0].offset = offset_in_page(clname->data);
  95. sg[0].length = clname->len;
  96. if (crypto_hash_digest(&desc, sg, sg->length, cksum.data))
  97. goto out;
  98. md5_to_hex(dname, cksum.data);
  99. kfree(cksum.data);
  100. status = nfs_ok;
  101. out:
  102. crypto_free_hash(desc.tfm);
  103. out_no_tfm:
  104. return status;
  105. }
  106. static void
  107. nfsd4_sync_rec_dir(void)
  108. {
  109. mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
  110. nfsd_sync_dir(rec_dir.dentry);
  111. mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
  112. }
  113. int
  114. nfsd4_create_clid_dir(struct nfs4_client *clp)
  115. {
  116. char *dname = clp->cl_recdir;
  117. struct dentry *dentry;
  118. uid_t uid;
  119. gid_t gid;
  120. int status;
  121. dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname);
  122. if (!rec_dir_init || clp->cl_firststate)
  123. return 0;
  124. nfs4_save_user(&uid, &gid);
  125. /* lock the parent */
  126. mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
  127. dentry = lookup_one_len(dname, rec_dir.dentry, HEXDIR_LEN-1);
  128. if (IS_ERR(dentry)) {
  129. status = PTR_ERR(dentry);
  130. goto out_unlock;
  131. }
  132. status = -EEXIST;
  133. if (dentry->d_inode) {
  134. dprintk("NFSD: nfsd4_create_clid_dir: DIRECTORY EXISTS\n");
  135. goto out_put;
  136. }
  137. status = vfs_mkdir(rec_dir.dentry->d_inode, dentry, S_IRWXU);
  138. out_put:
  139. dput(dentry);
  140. out_unlock:
  141. mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
  142. if (status == 0) {
  143. clp->cl_firststate = 1;
  144. nfsd4_sync_rec_dir();
  145. }
  146. nfs4_reset_user(uid, gid);
  147. dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status);
  148. return status;
  149. }
  150. typedef int (recdir_func)(struct dentry *, struct dentry *);
  151. struct dentry_list {
  152. struct dentry *dentry;
  153. struct list_head list;
  154. };
  155. struct dentry_list_arg {
  156. struct list_head dentries;
  157. struct dentry *parent;
  158. };
  159. static int
  160. nfsd4_build_dentrylist(void *arg, const char *name, int namlen,
  161. loff_t offset, u64 ino, unsigned int d_type)
  162. {
  163. struct dentry_list_arg *dla = arg;
  164. struct list_head *dentries = &dla->dentries;
  165. struct dentry *parent = dla->parent;
  166. struct dentry *dentry;
  167. struct dentry_list *child;
  168. if (name && isdotent(name, namlen))
  169. return 0;
  170. dentry = lookup_one_len(name, parent, namlen);
  171. if (IS_ERR(dentry))
  172. return PTR_ERR(dentry);
  173. child = kmalloc(sizeof(*child), GFP_KERNEL);
  174. if (child == NULL)
  175. return -ENOMEM;
  176. child->dentry = dentry;
  177. list_add(&child->list, dentries);
  178. return 0;
  179. }
  180. static int
  181. nfsd4_list_rec_dir(struct dentry *dir, recdir_func *f)
  182. {
  183. struct file *filp;
  184. struct dentry_list_arg dla = {
  185. .parent = dir,
  186. };
  187. struct list_head *dentries = &dla.dentries;
  188. struct dentry_list *child;
  189. uid_t uid;
  190. gid_t gid;
  191. int status;
  192. if (!rec_dir_init)
  193. return 0;
  194. nfs4_save_user(&uid, &gid);
  195. filp = dentry_open(dget(dir), mntget(rec_dir.mnt), O_RDONLY);
  196. status = PTR_ERR(filp);
  197. if (IS_ERR(filp))
  198. goto out;
  199. INIT_LIST_HEAD(dentries);
  200. status = vfs_readdir(filp, nfsd4_build_dentrylist, &dla);
  201. fput(filp);
  202. while (!list_empty(dentries)) {
  203. child = list_entry(dentries->next, struct dentry_list, list);
  204. status = f(dir, child->dentry);
  205. if (status)
  206. goto out;
  207. list_del(&child->list);
  208. dput(child->dentry);
  209. kfree(child);
  210. }
  211. out:
  212. while (!list_empty(dentries)) {
  213. child = list_entry(dentries->next, struct dentry_list, list);
  214. list_del(&child->list);
  215. dput(child->dentry);
  216. kfree(child);
  217. }
  218. nfs4_reset_user(uid, gid);
  219. return status;
  220. }
  221. static int
  222. nfsd4_remove_clid_file(struct dentry *dir, struct dentry *dentry)
  223. {
  224. int status;
  225. if (!S_ISREG(dir->d_inode->i_mode)) {
  226. printk("nfsd4: non-file found in client recovery directory\n");
  227. return -EINVAL;
  228. }
  229. mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
  230. status = vfs_unlink(dir->d_inode, dentry);
  231. mutex_unlock(&dir->d_inode->i_mutex);
  232. return status;
  233. }
  234. static int
  235. nfsd4_clear_clid_dir(struct dentry *dir, struct dentry *dentry)
  236. {
  237. int status;
  238. /* For now this directory should already be empty, but we empty it of
  239. * any regular files anyway, just in case the directory was created by
  240. * a kernel from the future.... */
  241. nfsd4_list_rec_dir(dentry, nfsd4_remove_clid_file);
  242. mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
  243. status = vfs_rmdir(dir->d_inode, dentry);
  244. mutex_unlock(&dir->d_inode->i_mutex);
  245. return status;
  246. }
  247. static int
  248. nfsd4_unlink_clid_dir(char *name, int namlen)
  249. {
  250. struct dentry *dentry;
  251. int status;
  252. dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
  253. mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
  254. dentry = lookup_one_len(name, rec_dir.dentry, namlen);
  255. mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
  256. if (IS_ERR(dentry)) {
  257. status = PTR_ERR(dentry);
  258. return status;
  259. }
  260. status = -ENOENT;
  261. if (!dentry->d_inode)
  262. goto out;
  263. status = nfsd4_clear_clid_dir(rec_dir.dentry, dentry);
  264. out:
  265. dput(dentry);
  266. return status;
  267. }
  268. void
  269. nfsd4_remove_clid_dir(struct nfs4_client *clp)
  270. {
  271. uid_t uid;
  272. gid_t gid;
  273. int status;
  274. if (!rec_dir_init || !clp->cl_firststate)
  275. return;
  276. clp->cl_firststate = 0;
  277. nfs4_save_user(&uid, &gid);
  278. status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
  279. nfs4_reset_user(uid, gid);
  280. if (status == 0)
  281. nfsd4_sync_rec_dir();
  282. if (status)
  283. printk("NFSD: Failed to remove expired client state directory"
  284. " %.*s\n", HEXDIR_LEN, clp->cl_recdir);
  285. return;
  286. }
  287. static int
  288. purge_old(struct dentry *parent, struct dentry *child)
  289. {
  290. int status;
  291. if (nfs4_has_reclaimed_state(child->d_name.name))
  292. return 0;
  293. status = nfsd4_clear_clid_dir(parent, child);
  294. if (status)
  295. printk("failed to remove client recovery directory %s\n",
  296. child->d_name.name);
  297. /* Keep trying, success or failure: */
  298. return 0;
  299. }
  300. void
  301. nfsd4_recdir_purge_old(void) {
  302. int status;
  303. if (!rec_dir_init)
  304. return;
  305. status = nfsd4_list_rec_dir(rec_dir.dentry, purge_old);
  306. if (status == 0)
  307. nfsd4_sync_rec_dir();
  308. if (status)
  309. printk("nfsd4: failed to purge old clients from recovery"
  310. " directory %s\n", rec_dir.dentry->d_name.name);
  311. return;
  312. }
  313. static int
  314. load_recdir(struct dentry *parent, struct dentry *child)
  315. {
  316. if (child->d_name.len != HEXDIR_LEN - 1) {
  317. printk("nfsd4: illegal name %s in recovery directory\n",
  318. child->d_name.name);
  319. /* Keep trying; maybe the others are OK: */
  320. return 0;
  321. }
  322. nfs4_client_to_reclaim(child->d_name.name);
  323. return 0;
  324. }
  325. int
  326. nfsd4_recdir_load(void) {
  327. int status;
  328. status = nfsd4_list_rec_dir(rec_dir.dentry, load_recdir);
  329. if (status)
  330. printk("nfsd4: failed loading clients from recovery"
  331. " directory %s\n", rec_dir.dentry->d_name.name);
  332. return status;
  333. }
  334. /*
  335. * Hold reference to the recovery directory.
  336. */
  337. void
  338. nfsd4_init_recdir(char *rec_dirname)
  339. {
  340. uid_t uid = 0;
  341. gid_t gid = 0;
  342. int status;
  343. printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
  344. rec_dirname);
  345. BUG_ON(rec_dir_init);
  346. nfs4_save_user(&uid, &gid);
  347. status = path_lookup(rec_dirname, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
  348. &rec_dir);
  349. if (status)
  350. printk("NFSD: unable to find recovery directory %s\n",
  351. rec_dirname);
  352. if (!status)
  353. rec_dir_init = 1;
  354. nfs4_reset_user(uid, gid);
  355. }
  356. void
  357. nfsd4_shutdown_recdir(void)
  358. {
  359. if (!rec_dir_init)
  360. return;
  361. rec_dir_init = 0;
  362. path_release(&rec_dir);
  363. }