nfs4recover.c 9.3 KB

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